Revert "Revert "Reland "Run Flutter on iOS and Android with color correct Skia (#3826)" (#3878)" (#3895)

This reverts commit 1db18a40.

This reverts commit 2d9155e1.

Fixes a regression with semitransparent images (flutter/flutter#11169)

* Revert "Revert "Reland "Run Flutter on iOS and Android with color correct Skia" (#3818)" (#3823)"

This reverts commit db8d8a99.

* Fix test code to match internal API change

This reverts commit 2650f529.

* Revert "Revert "Run Flutter on iOS and Android with color correct Skia (#3743)" (#3775)"

This reverts commit cfe70e07.

* Enable sRGB on IO thread, too

* Add 4444 as a fallback rendering mode

* Use bare ptr to SkColorSpace (not sk_sp) in PrerollContext

This reverts commit ffe8181f.

* Run Flutter on iOS and Android with color correct Skia (#3716)

***Turns on color correct rendering for Android and iOS
***Communicates dst color space to raster cache
***Turns on color space aware image decoding

Test:
***color_testing_demo on Pixel XL
***flutter_gallery on iPad Mini and iPad Pro (haven't figured out how to run manual_tests on iOS)

TODO:
I needed to split up this CL somewhere. These are follow-up tasks.
***Make desktop backends color correct
***Make debugging tools (ex: encoding frames to png) preserve color space
***Investigate using UIKit API to allow iOS to fine tune color space of rendered content

* Fix pixel rounding error in the picture layer by first ensuring that
  the texture for the image is at least as big as the next integer size
  along each dimension and using kStrict_SrcRectConstraint while
  drawing the same image. We already select the source subset by
  looking at the cull rect of the picture.
* Decompose the transformation matrix into a series of operations that
  generated the same to calculate the scale at which to rasterize the
  picture. This make the rasterization scale resilient to
  transformations that introduce a perspective component to the
  resultant matrix.
* The scale in the decomposed matrix is now part of the key in the
  cache.
* Raster cache images that could never be rasterized were still taking
  part in the cache. Now, those entries are rejected early on. This
  leads to the sweep after the frame iterating over fewer items.
* Added a unit test target.

***Turns on color correct rendering for Android and iOS
***Communicates dst color space to raster cache
***Turns on color space aware image decoding

Test:
***color_testing_demo on Pixel XL
***flutter_gallery on iPad Mini and iPad Pro (haven't figured out how to run manual_tests on iOS)

TODO:
I needed to split up this CL somewhere. These are follow-up tasks.
***Make desktop backends color correct
***Make debugging tools (ex: encoding frames to png) preserve color space
***Investigate using UIKit API to allow iOS to fine tune color space of rendered content

Fixes https://github.com/flutter/flutter/issues/7182

We push a bit up the tree during preroll to learn whether there system
composited layers below each layer. During update scene, we squash down
to paint tasks, which we execute after publishing the new scene.

The picture may hold references to images backed by GPU textures that must
be deleted on the IO thread.

When rasterizing to a recorder backed canvas for SKP tracing, don’t attempt to update the raster cache. (#2983)

We could get into a situation where the second time we rasterize a picture for an SKP, the raster cache detects that the same picture is being repeated in subsequent onscreen frames and then proceeds to rasterize the contents to an offscreen texture. This not only causes an unnecessary cache entry, but also shows the cached image in the final SKP trace (which is not what was originally displayed on screen).

This patch removes almost all //base dependency of //flow. The only dependency
left is on tracing.

The code that draws the picture knows more about the picture (and the future)
than we do. This patch gives them a way to hint us about what's going to
happen with the picture in the future.

* Added instrumentation for timings.

* A few more traces for better granularity.

Instead, make Layer::Paint take a new PaintContext that has just exactly
the state that it needs, mirroring PrerollContext. Also, rename
PaintContext to CompositorContext because it holds the context for the
whole compositor.

This patch makes these files better match Google C++ style.

Also, add the engine lap time when running on Mojo.

Now that the compositor doesn't have any tricky deps, we can make it a
top-level project, which saves a bunch of typing.

The matrix parameter to drawPicture doesn't quite work the way we expected.
This patch moves us back to using the translate function on SkCanvas.

Fixes https://github.com/flutter/flutter/issues/1205

The shader is supposed to be drawn on top of the children as a mask. The
previous drawing code was incorrect.

This patch uses some fancier Skia APIs to simplify how PictureLayer
paints.

Rather than relying upon the rects passed in from Dart, the compositor
should compute the paint bounds of layers from the cull rects of the
underlying SkPictures. This approach is better because it will handle
effects like shadows that paint outside the incorrect paint bounds we
use today (as well as shrinking around empty space).

Using the picture's cull rect to select the size of the texture is more
accurate than using the paint bounds. The cull rect captures shadows and
other "out of bounds" drawing as well as shrinks down around empty space
in the recording.

Prerolling the rasterization tasks reduces the number of render target
switches because we don't interrupt the main render target.

This patch adds back (and tweaks) some code that we previously removed
for caching rasterized layers. Now that our layerization code in the
framework is more sophisticated, we should be able to get more value out
of this mechanism.

The gr_context and canvas are stored at the frame level instead of the storing the same temporarily in the context

Make the paint context own the rasterizer and options. Also give it the ability to vend frames to render into.