1. Various functionalities offered by this tool are now organized into commands (e.g. `felt test`, `felt check-licenses`).
2. The felt tool can now be invoked from anywhere, not necessarily from the web_ui directory.
3. This new structure helps us scale better as we add more commands (e.g. soon a `build/watch` command is coming).
* enabling spellcheck for text editing
* Fixing errors in the input box, which arrises when the fontweight is null.
* Rollback the spellcheck change. Still not tested in safari mobile.
* Carrying the assignment of fontweight from index to EditingStyle constructor. This reduce # of null checks to one.
- Add a custom `PlatformPlugin` that spins up a server waiting for test to request a screenshot.
- When a screenshot is requested the plugin talks to Chrome via the debug port, captures a screenshot, and compares it with a golden file
- This PR also adds proper CLI for `dev/test.dart` with an `ArgParser` for future extension into a proper developer tool for the team.
- As a first couple of features, it adds `--debug` option to launch Chrome in debug mode, a `--target` option to choose a single test to run rather than all tests, and `--shard` option to choose a subset of tests to run.
Limitations:
- While screenshot test will run on Cirrus, they are configured to not fail on Cirrus. Need to solve Chrome version skew.
- Stack maps do not work yet (you get stacks, but they are nonsensical)
- When requesting a single test, build_runner builds all tests anyway
- Nothing but desktop Chrome is supported
- Nothing but Linux is supported
- There's no Chrome version pinning; currently assumed stable Chrome channel
- Tested this compatibility in topaz repo. The build rules can now be
used to build kernel_platform_files in topaz tree, after this change we
can migrate the platform*dill and vm*snapshot files in topaz to use the
engine built artifacts.
- Also removes some namespace conflicts for dart configuration.
* WIP on web plugin registry
* WIP on web plugins
* More WIP on registering web plugins
* remove flutter_web_plugins
* add license header
* Update year of license header to 2013
* Update the license goldens file
This was required by the C++ spec pre-C++11 and still gets picked up in
the Fuchsia tree due to -Wnewline-eof. It fixes:
../../third_party/flutter/lib/ui/text/line_metrics.h:75:47: error: no newline at end of file [-Werror,-Wnewline-eof]
#endif // FLUTTER_LIB_UI_TEXT_LINE_METRICS_H_
Without this, developers have to override `onReportTimings` to listen for `FrameTiming`.
That can potentially break previous `onReportTimings` listeners if they forget to call
the old listener in their new callback.
This PR replaces the similar RP in the framework: https://github.com/flutter/flutter/pull/38574
Once this PR landed, we'll have to create another framework PR to use the stream to replace
`onReportTimings` usages.
Once that's done, we can then propose the breaking change of removing the deprecated
`onReportTimings`.
This patch allows embedders to split the Flutter layer tree into multiple
chunks. These chunks are meant to be composed one on top of another. This gives
embedders a chance to interleave their own contents between these chunks.
The Flutter embedder API already provides hooks for the specification of
textures for the Flutter engine to compose within its own hierarchy (for camera
feeds, video, etc..). However, not all embedders can render the contents of such
sources into textures the Flutter engine can accept. Moreover, this composition
model may have overheads that are non-trivial for certain use cases. In such
cases, the embedder may choose to specify multiple render target for Flutter to
render into instead of just one.
The use of this API allows embedders to perform composition very similar to the
iOS embedder. This composition model is used on that platform for the embedding
of UIKit view such and web view and map views within the Flutter hierarchy.
However, do note that iOS also has threading configurations that are currently
not available to custom embedders.
The embedder API updates in this patch are ABI stable and existing embedders
will continue to work are normal. For embedders that want to enable this
composition mode, the API is designed to make it easy to opt into the same in an
incremental manner.
Rendering of contents into the “root” rendering surface remains unchanged.
However, now the application can push “platform views” via a scene builder.
These platform views need to handled by a FlutterCompositor specified in a new
field at the end of the FlutterProjectArgs struct.
When a new platform view in introduced within the layer tree, the compositor
will ask the embedder to create a new render target for that platform view.
Render targets can currently be OpenGL framebuffers, OpenGL textures or software
buffers. The type of the render target returned by the embedder must be
compatible with the root render surface. That is, if the root render surface is
an OpenGL framebuffer, the render target for each platform view must either be a
texture or a framebuffer in the same OpenGL context. New render target types as
well as root renderers for newer APIs like Metal & Vulkan can and will be added
in the future. The addition of these APIs will be done in an ABI & API stable
manner.
As Flutter renders frames, it gives the embedder a callback with information
about the position of the various platform views in the effective hierarchy.
The embedder is then meant to put the contents of the render targets that it
setup and had previously given to the engine onto the screen (of course
interleaving the contents of the platform views).
Unit-tests have been added that test not only the structure and properties of
layer hierarchy given to the compositor, but also the contents of the texels
rendered by a test compositor using both the OpenGL and software rendering
backends.
Fixes b/132812775
Fixesflutter/flutter#35410
SingleFrameCodec had been holding a persistent handle to the peer Dart object
while waiting for the decoder callback. However, Dart code could call
Codec.dispose during that interval, which would cause the Dart peer to drop
its reference to the SingleFrameCodec and potentially delete the
SingleFrameCodec.
Fixes https://github.com/flutter/flutter/issues/36631
Previously ParagraphBuilder was concatenating the child's fonts to the
parent's font list, causing the parent's fonts to take precedence.
Fixes https://github.com/flutter/flutter/issues/35992
After the frame is decoded SingleFrameCodec will invoke pending callbacks
from calls to getNextFrame. The callbacks could result in more calls to
getNextFrame. Those calls should receive the frame instead of being added
to the pending list.
