diff --git a/flow/compositor_context.cc b/flow/compositor_context.cc index aecd3a24cddf7..e5a725ef6478c 100644 --- a/flow/compositor_context.cc +++ b/flow/compositor_context.cc @@ -63,7 +63,7 @@ CompositorContext::ScopedFrame::~ScopedFrame() { bool CompositorContext::ScopedFrame::Raster(flow::LayerTree& layer_tree, bool ignore_raster_cache) { layer_tree.Preroll(*this, ignore_raster_cache); - layer_tree.Paint(*this); + layer_tree.Paint(*this, ignore_raster_cache); return true; } diff --git a/flow/debug_print.cc b/flow/debug_print.cc index e2d7fc3f4c882..a811e4abea875 100644 --- a/flow/debug_print.cc +++ b/flow/debug_print.cc @@ -25,9 +25,8 @@ std::ostream& operator<<(std::ostream& os, const flow::MatrixDecomposition& m) { std::ostream& operator<<(std::ostream& os, const SkMatrix& m) { SkString string; - string.printf( - "[%8.4f %8.4f %8.4f][%8.4f %8.4f %8.4f][%8.4f %8.4f %8.4f]", - m[0], m[1], m[2], m[3], m[4], m[5], m[6], m[7], m[8]); + string.printf("[%8.4f %8.4f %8.4f][%8.4f %8.4f %8.4f][%8.4f %8.4f %8.4f]", + m[0], m[1], m[2], m[3], m[4], m[5], m[6], m[7], m[8]); os << string.c_str(); return os; } @@ -72,8 +71,9 @@ std::ostream& operator<<(std::ostream& os, const SkPoint& r) { return os; } -std::ostream& operator<<(std::ostream& os, const flow::RasterCacheKey& k) { - os << "Picture: " << k.picture_id() << " matrix: " << k.matrix(); +std::ostream& operator<<(std::ostream& os, + const flow::PictureRasterCacheKey& k) { + os << "Picture: " << k.id() << " matrix: " << k.matrix(); return os; } diff --git a/flow/debug_print.h b/flow/debug_print.h index d58dcbed28bed..4db0748bc31cb 100644 --- a/flow/debug_print.h +++ b/flow/debug_print.h @@ -16,7 +16,7 @@ #define DEF_PRINTER(x) std::ostream& operator<<(std::ostream&, const x&); DEF_PRINTER(flow::MatrixDecomposition); -DEF_PRINTER(flow::RasterCacheKey); +DEF_PRINTER(flow::PictureRasterCacheKey); DEF_PRINTER(SkISize); DEF_PRINTER(SkMatrix); DEF_PRINTER(SkMatrix44); diff --git a/flow/layers/layer.h b/flow/layers/layer.h index a52f6e04aa86c..50fd3b63b277d 100644 --- a/flow/layers/layer.h +++ b/flow/layers/layer.h @@ -40,6 +40,19 @@ enum Clip { none, hardEdge, antiAlias, antiAliasWithSaveLayer }; class ContainerLayer; +struct PrerollContext { + RasterCache* raster_cache; + GrContext* gr_context; + SkColorSpace* dst_color_space; + SkRect child_paint_bounds; + + // The following allows us to paint in the end of subtree preroll + const Stopwatch& frame_time; + const Stopwatch& engine_time; + TextureRegistry& texture_registry; + const bool checkerboard_offscreen_layers; +}; + // Represents a single composited layer. Created on the UI thread but then // subquently used on the Rasterizer thread. class Layer { @@ -47,13 +60,6 @@ class Layer { Layer(); virtual ~Layer(); - struct PrerollContext { - RasterCache* raster_cache; - GrContext* gr_context; - SkColorSpace* dst_color_space; - SkRect child_paint_bounds; - }; - virtual void Preroll(PrerollContext* context, const SkMatrix& matrix); struct PaintContext { @@ -61,6 +67,7 @@ class Layer { const Stopwatch& frame_time; const Stopwatch& engine_time; TextureRegistry& texture_registry; + const RasterCache* raster_cache; const bool checkerboard_offscreen_layers; }; diff --git a/flow/layers/layer_tree.cc b/flow/layers/layer_tree.cc index 29f9c93b52c19..de28918193576 100644 --- a/flow/layers/layer_tree.cc +++ b/flow/layers/layer_tree.cc @@ -25,12 +25,15 @@ void LayerTree::Preroll(CompositorContext::ScopedFrame& frame, frame.canvas() ? frame.canvas()->imageInfo().colorSpace() : nullptr; frame.context().raster_cache().SetCheckboardCacheImages( checkerboard_raster_cache_images_); - Layer::PrerollContext context = { + PrerollContext context = { ignore_raster_cache ? nullptr : &frame.context().raster_cache(), frame.gr_context(), color_space, SkRect::MakeEmpty(), - }; + frame.context().frame_time(), + frame.context().engine_time(), + frame.context().texture_registry(), + checkerboard_offscreen_layers_}; root_layer_->Preroll(&context, frame.root_surface_transformation()); } @@ -60,15 +63,16 @@ void LayerTree::UpdateScene(SceneUpdateContext& context, } #endif -void LayerTree::Paint(CompositorContext::ScopedFrame& frame) const { +void LayerTree::Paint(CompositorContext::ScopedFrame& frame, + bool ignore_raster_cache) const { TRACE_EVENT0("flutter", "LayerTree::Paint"); Layer::PaintContext context = { - *frame.canvas(), // - frame.context().frame_time(), // - frame.context().engine_time(), // - frame.context().texture_registry(), // - checkerboard_offscreen_layers_ // - }; + *frame.canvas(), + frame.context().frame_time(), + frame.context().engine_time(), + frame.context().texture_registry(), + ignore_raster_cache ? nullptr : &frame.context().raster_cache(), + checkerboard_offscreen_layers_}; if (root_layer_->needs_painting()) root_layer_->Paint(context); @@ -84,24 +88,29 @@ sk_sp LayerTree::Flatten(const SkRect& bounds) { return nullptr; } - Layer::PrerollContext preroll_context{ - nullptr, // raster_cache (don't consult the cache) - nullptr, // gr_context (used for the raster cache) - nullptr, // SkColorSpace* dst_color_space - SkRect::MakeEmpty(), // SkRect child_paint_bounds - }; - const Stopwatch unused_stopwatch; TextureRegistry unused_texture_registry; SkMatrix root_surface_transformation; // No root surface transformation. So assume identity. root_surface_transformation.reset(); + PrerollContext preroll_context{ + nullptr, // raster_cache (don't consult the cache) + nullptr, // gr_context (used for the raster cache) + nullptr, // SkColorSpace* dst_color_space + SkRect::MakeEmpty(), // SkRect child_paint_bounds + unused_stopwatch, // frame time (dont care) + unused_stopwatch, // engine time (dont care) + unused_texture_registry, // texture registry (not supported) + false, // checkerboard_offscreen_layers + }; + Layer::PaintContext paint_context = { *canvas, // canvas unused_stopwatch, // frame time (dont care) unused_stopwatch, // engine time (dont care) unused_texture_registry, // texture registry (not supported) + nullptr, // raster cache false // checkerboard offscreen layers }; diff --git a/flow/layers/layer_tree.h b/flow/layers/layer_tree.h index 93d4e27cde2d5..e8591b49661c7 100644 --- a/flow/layers/layer_tree.h +++ b/flow/layers/layer_tree.h @@ -32,7 +32,8 @@ class LayerTree { scenic::ContainerNode& container); #endif - void Paint(CompositorContext::ScopedFrame& frame) const; + void Paint(CompositorContext::ScopedFrame& frame, + bool ignore_raster_cache = false) const; sk_sp Flatten(const SkRect& bounds); diff --git a/flow/layers/opacity_layer.cc b/flow/layers/opacity_layer.cc index 2272e79093864..351d3107f0d50 100644 --- a/flow/layers/opacity_layer.cc +++ b/flow/layers/opacity_layer.cc @@ -10,6 +10,18 @@ OpacityLayer::OpacityLayer() = default; OpacityLayer::~OpacityLayer() = default; +void OpacityLayer::Preroll(PrerollContext* context, const SkMatrix& matrix) { + ContainerLayer::Preroll(context, matrix); + if (context->raster_cache && layers().size() == 1) { + std::shared_ptr child = layers()[0]; + SkMatrix ctm = matrix; +#ifndef SUPPORT_FRACTIONAL_TRANSLATION + ctm = RasterCache::GetIntegralTransCTM(ctm); +#endif + context->raster_cache->Prepare(context, child, ctm); + } +} + void OpacityLayer::Paint(PaintContext& context) const { TRACE_EVENT0("flutter", "OpacityLayer::Paint"); FML_DCHECK(needs_painting()); @@ -17,7 +29,23 @@ void OpacityLayer::Paint(PaintContext& context) const { SkPaint paint; paint.setAlpha(alpha_); - Layer::AutoSaveLayer save = + SkAutoCanvasRestore save(&context.canvas, true); + +#ifndef SUPPORT_FRACTIONAL_TRANSLATION + context.canvas.setMatrix( + RasterCache::GetIntegralTransCTM(context.canvas.getTotalMatrix())); +#endif + + if (layers().size() == 1 && context.raster_cache) { + const SkMatrix& ctm = context.canvas.getTotalMatrix(); + RasterCacheResult child_cache = context.raster_cache->Get(layers()[0], ctm); + if (child_cache.is_valid()) { + child_cache.draw(context.canvas, &paint); + return; + } + } + + Layer::AutoSaveLayer save_layer = Layer::AutoSaveLayer::Create(context, paint_bounds(), &paint); PaintChildren(context); } diff --git a/flow/layers/opacity_layer.h b/flow/layers/opacity_layer.h index b27829385046b..4733d13645233 100644 --- a/flow/layers/opacity_layer.h +++ b/flow/layers/opacity_layer.h @@ -16,6 +16,8 @@ class OpacityLayer : public ContainerLayer { void set_alpha(int alpha) { alpha_ = alpha; } + void Preroll(PrerollContext* context, const SkMatrix& matrix) override; + void Paint(PaintContext& context) const override; // TODO(chinmaygarde): Once MZ-139 is addressed, introduce a new node in the diff --git a/flow/layers/picture_layer.cc b/flow/layers/picture_layer.cc index 3cbf15a609ad1..9dcef880b7313 100644 --- a/flow/layers/picture_layer.cc +++ b/flow/layers/picture_layer.cc @@ -21,11 +21,8 @@ void PictureLayer::Preroll(PrerollContext* context, const SkMatrix& matrix) { #ifndef SUPPORT_FRACTIONAL_TRANSLATION ctm = RasterCache::GetIntegralTransCTM(ctm); #endif - raster_cache_result_ = cache->GetPrerolledImage( - context->gr_context, sk_picture, ctm, context->dst_color_space, - is_complex_, will_change_); - } else { - raster_cache_result_ = RasterCacheResult(); + cache->Prepare(context->gr_context, sk_picture, ctm, + context->dst_color_space, is_complex_, will_change_); } SkRect bounds = sk_picture->cullRect().makeOffset(offset_.x(), offset_.y()); @@ -44,11 +41,15 @@ void PictureLayer::Paint(PaintContext& context) const { RasterCache::GetIntegralTransCTM(context.canvas.getTotalMatrix())); #endif - if (raster_cache_result_.is_valid()) { - raster_cache_result_.draw(context.canvas); - } else { - context.canvas.drawPicture(picture()); + if (context.raster_cache) { + const SkMatrix& ctm = context.canvas.getTotalMatrix(); + RasterCacheResult result = context.raster_cache->Get(*picture(), ctm); + if (result.is_valid()) { + result.draw(context.canvas); + return; + } } + context.canvas.drawPicture(picture()); } } // namespace flow diff --git a/flow/layers/picture_layer.h b/flow/layers/picture_layer.h index 12e2807c33d23..8b6f74c313839 100644 --- a/flow/layers/picture_layer.h +++ b/flow/layers/picture_layer.h @@ -39,7 +39,6 @@ class PictureLayer : public Layer { SkiaGPUObject picture_; bool is_complex_ = false; bool will_change_ = false; - RasterCacheResult raster_cache_result_; FML_DISALLOW_COPY_AND_ASSIGN(PictureLayer); }; diff --git a/flow/raster_cache.cc b/flow/raster_cache.cc index a3aef6e3d1410..8100453457ca1 100644 --- a/flow/raster_cache.cc +++ b/flow/raster_cache.cc @@ -6,6 +6,7 @@ #include +#include "flutter/flow/layers/layer.h" #include "flutter/flow/paint_utils.h" #include "flutter/fml/logging.h" #include "flutter/fml/trace_event.h" @@ -17,13 +18,13 @@ namespace flow { -void RasterCacheResult::draw(SkCanvas& canvas) const { +void RasterCacheResult::draw(SkCanvas& canvas, const SkPaint* paint) const { SkAutoCanvasRestore auto_restore(&canvas, true); SkIRect bounds = RasterCache::GetDeviceBounds(logical_rect_, canvas.getTotalMatrix()); FML_DCHECK(bounds.size() == image_->dimensions()); canvas.resetMatrix(); - canvas.drawImage(image_, bounds.fLeft, bounds.fTop); + canvas.drawImage(image_, bounds.fLeft, bounds.fTop, paint); } RasterCache::RasterCache(size_t threshold) @@ -77,14 +78,13 @@ static bool IsPictureWorthRasterizing(SkPicture* picture, return picture->approximateOpCount() > 10; } -RasterCacheResult RasterizePicture(SkPicture* picture, - GrContext* context, - const SkMatrix& ctm, - SkColorSpace* dst_color_space, - bool checkerboard) { - TRACE_EVENT0("flutter", "RasterCachePopulate"); - - const SkRect logical_rect = picture->cullRect(); +static RasterCacheResult Rasterize( + GrContext* context, + const SkMatrix& ctm, + SkColorSpace* dst_color_space, + bool checkerboard, + const SkRect& logical_rect, + std::function draw_function) { SkIRect cache_rect = RasterCache::GetDeviceBounds(logical_rect, ctm); const SkImageInfo image_info = @@ -112,7 +112,7 @@ RasterCacheResult RasterizePicture(SkPicture* picture, canvas->clear(SK_ColorTRANSPARENT); canvas->translate(-cache_rect.left(), -cache_rect.top()); canvas->concat(ctm); - canvas->drawPicture(picture); + draw_function(canvas); if (checkerboard) { DrawCheckerboard(canvas, logical_rect); @@ -121,6 +121,18 @@ RasterCacheResult RasterizePicture(SkPicture* picture, return {surface->makeImageSnapshot(), logical_rect}; } +RasterCacheResult RasterizePicture(SkPicture* picture, + GrContext* context, + const SkMatrix& ctm, + SkColorSpace* dst_color_space, + bool checkerboard) { + TRACE_EVENT0("flutter", "RasterCachePopulate"); + + return Rasterize(context, ctm, dst_color_space, checkerboard, + picture->cullRect(), + [=](SkCanvas* canvas) { canvas->drawPicture(picture); }); +} + static inline size_t ClampSize(size_t value, size_t min, size_t max) { if (value > max) { return max; @@ -133,16 +145,38 @@ static inline size_t ClampSize(size_t value, size_t min, size_t max) { return value; } -RasterCacheResult RasterCache::GetPrerolledImage( - GrContext* context, - SkPicture* picture, - const SkMatrix& transformation_matrix, - SkColorSpace* dst_color_space, - bool is_complex, - bool will_change) { +void RasterCache::Prepare(PrerollContext* context, + std::shared_ptr layer, + const SkMatrix& ctm) { + LayerRasterCacheKey cache_key(layer, ctm); + Entry& entry = layer_cache_[cache_key]; + entry.access_count = ClampSize(entry.access_count + 1, 0, threshold_); + entry.used_this_frame = true; + if (!entry.image.is_valid()) { + entry.image = Rasterize(context->gr_context, ctm, context->dst_color_space, + checkerboard_images_, layer->paint_bounds(), + [layer, context](SkCanvas* canvas) { + Layer::PaintContext paintContext = { + *canvas, + context->frame_time, + context->engine_time, + context->texture_registry, + context->raster_cache, + context->checkerboard_offscreen_layers}; + layer->Paint(paintContext); + }); + } +} + +bool RasterCache::Prepare(GrContext* context, + SkPicture* picture, + const SkMatrix& transformation_matrix, + SkColorSpace* dst_color_space, + bool is_complex, + bool will_change) { if (!IsPictureWorthRasterizing(picture, will_change, is_complex)) { // We only deal with pictures that are worthy of rasterization. - return {}; + return false; } // Decompose the matrix (once) for all subsequent operations. We want to make @@ -151,46 +185,50 @@ RasterCacheResult RasterCache::GetPrerolledImage( if (!matrix.IsValid()) { // The matrix was singular. No point in going further. - return {}; + return false; } - RasterCacheKey cache_key(*picture, transformation_matrix); + PictureRasterCacheKey cache_key(picture->uniqueID(), transformation_matrix); - Entry& entry = cache_[cache_key]; + Entry& entry = picture_cache_[cache_key]; entry.access_count = ClampSize(entry.access_count + 1, 0, threshold_); entry.used_this_frame = true; if (entry.access_count < threshold_ || threshold_ == 0) { // Frame threshold has not yet been reached. - return {}; + return false; } if (!entry.image.is_valid()) { entry.image = RasterizePicture(picture, context, transformation_matrix, dst_color_space, checkerboard_images_); } - - return entry.image; + return true; } -void RasterCache::SweepAfterFrame() { - std::vector::iterator> dead; +RasterCacheResult RasterCache::Get(const SkPicture& picture, + const SkMatrix& ctm) const { + PictureRasterCacheKey cache_key(picture.uniqueID(), ctm); + auto it = picture_cache_.find(cache_key); + return it == picture_cache_.end() ? RasterCacheResult() : it->second.image; +} - for (auto it = cache_.begin(); it != cache_.end(); ++it) { - Entry& entry = it->second; - if (!entry.used_this_frame) { - dead.push_back(it); - } - entry.used_this_frame = false; - } +RasterCacheResult RasterCache::Get(std::shared_ptr layer, + const SkMatrix& ctm) const { + LayerRasterCacheKey cache_key(layer, ctm); + auto it = layer_cache_.find(cache_key); + return it == layer_cache_.end() ? RasterCacheResult() : it->second.image; +} - for (auto it : dead) { - cache_.erase(it); - } +void RasterCache::SweepAfterFrame() { + using PictureCache = PictureRasterCacheKey::Map; + using LayerCache = LayerRasterCacheKey::Map; + SweepOneCacheAfterFrame(picture_cache_); + SweepOneCacheAfterFrame(layer_cache_); } void RasterCache::Clear() { - cache_.clear(); + picture_cache_.clear(); } void RasterCache::SetCheckboardCacheImages(bool checkerboard) { diff --git a/flow/raster_cache.h b/flow/raster_cache.h index 348ab8000da39..f15028e1d019d 100644 --- a/flow/raster_cache.h +++ b/flow/raster_cache.h @@ -28,13 +28,15 @@ class RasterCacheResult { bool is_valid() const { return static_cast(image_); }; - void draw(SkCanvas& canvas) const; + void draw(SkCanvas& canvas, const SkPaint* paint = nullptr) const; private: sk_sp image_; SkRect logical_rect_; }; +struct PrerollContext; + class RasterCache { public: explicit RasterCache(size_t threshold = 3); @@ -56,12 +58,26 @@ class RasterCache { return result; } - RasterCacheResult GetPrerolledImage(GrContext* context, - SkPicture* picture, - const SkMatrix& transformation_matrix, - SkColorSpace* dst_color_space, - bool is_complex, - bool will_change); + // Return true if the cache is generated. + // + // We may return false and not generate the cache if + // 1. The picture is not worth rasterizing + // 2. The matrix is singular + // 3. The picture is accessed too few times + bool Prepare(GrContext* context, + SkPicture* picture, + const SkMatrix& transformation_matrix, + SkColorSpace* dst_color_space, + bool is_complex, + bool will_change); + + void Prepare(PrerollContext* context, + std::shared_ptr layer, + const SkMatrix& ctm); + + RasterCacheResult Get(const SkPicture& picture, const SkMatrix& ctm) const; + RasterCacheResult Get(std::shared_ptr layer, + const SkMatrix& ctm) const; void SweepAfterFrame(); @@ -76,8 +92,26 @@ class RasterCache { RasterCacheResult image; }; + template + static void SweepOneCacheAfterFrame(Cache& cache) { + std::vector dead; + + for (auto it = cache.begin(); it != cache.end(); ++it) { + Entry& entry = it->second; + if (!entry.used_this_frame) { + dead.push_back(it); + } + entry.used_this_frame = false; + } + + for (auto it : dead) { + cache.erase(it); + } + } + const size_t threshold_; - RasterCacheKey::Map cache_; + PictureRasterCacheKey::Map picture_cache_; + LayerRasterCacheKey::Map layer_cache_; bool checkerboard_images_; fml::WeakPtrFactory weak_factory_; diff --git a/flow/raster_cache_key.h b/flow/raster_cache_key.h index 3f20072df8e3b..d681bff4b3a36 100644 --- a/flow/raster_cache_key.h +++ b/flow/raster_cache_key.h @@ -14,10 +14,10 @@ namespace flow { +template class RasterCacheKey { public: - RasterCacheKey(const SkPicture& picture, const SkMatrix& ctm) - : picture_id_(picture.uniqueID()), matrix_(ctm) { + RasterCacheKey(ID id, const SkMatrix& ctm) : id_(id), matrix_(ctm) { matrix_[SkMatrix::kMTransX] = SkScalarFraction(ctm.getTranslateX()); matrix_[SkMatrix::kMTransY] = SkScalarFraction(ctm.getTranslateY()); #ifndef SUPPORT_FRACTIONAL_TRANSLATION @@ -25,19 +25,19 @@ class RasterCacheKey { #endif } - uint32_t picture_id() const { return picture_id_; } + ID id() const { return id_; } const SkMatrix& matrix() const { return matrix_; } struct Hash { - std::size_t operator()(RasterCacheKey const& key) const { - return key.picture_id_; + uint32_t operator()(RasterCacheKey const& key) const { + return std::hash()(key.id_); } }; struct Equal { constexpr bool operator()(const RasterCacheKey& lhs, const RasterCacheKey& rhs) const { - return lhs.picture_id_ == rhs.picture_id_ && lhs.matrix_ == rhs.matrix_; + return lhs.id_ == rhs.id_ && lhs.matrix_ == rhs.matrix_; } }; @@ -45,7 +45,7 @@ class RasterCacheKey { using Map = std::unordered_map; private: - uint32_t picture_id_; + ID id_; // ctm where only fractional (0-1) translations are preserved: // matrix_ = ctm; @@ -54,6 +54,13 @@ class RasterCacheKey { SkMatrix matrix_; }; +// The ID is the uint32_t picture uniqueID +using PictureRasterCacheKey = RasterCacheKey; + +class Layer; + +using LayerRasterCacheKey = RasterCacheKey>; + } // namespace flow #endif // FLUTTER_FLOW_RASTER_CACHE_KEY_H_ diff --git a/flow/raster_cache_unittests.cc b/flow/raster_cache_unittests.cc index 0033d475b4bcb..5d6c89b48e23d 100644 --- a/flow/raster_cache_unittests.cc +++ b/flow/raster_cache_unittests.cc @@ -33,14 +33,14 @@ TEST(RasterCache, ThresholdIsRespected) { sk_sp image; sk_sp srgb = SkColorSpace::MakeSRGB(); - ASSERT_FALSE(cache.GetPrerolledImage(NULL, picture.get(), matrix, srgb.get(), - true, false)); // 1 + ASSERT_FALSE(cache.Prepare(NULL, picture.get(), matrix, srgb.get(), true, + false)); // 1 cache.SweepAfterFrame(); - ASSERT_FALSE(cache.GetPrerolledImage(NULL, picture.get(), matrix, srgb.get(), - true, false)); // 2 + ASSERT_FALSE(cache.Prepare(NULL, picture.get(), matrix, srgb.get(), true, + false)); // 2 cache.SweepAfterFrame(); - ASSERT_TRUE(cache.GetPrerolledImage(NULL, picture.get(), matrix, srgb.get(), - true, false)); // 3 + ASSERT_TRUE(cache.Prepare(NULL, picture.get(), matrix, srgb.get(), true, + false)); // 3 cache.SweepAfterFrame(); } @@ -55,14 +55,14 @@ TEST(RasterCache, ThresholdIsRespectedWhenZero) { sk_sp image; sk_sp srgb = SkColorSpace::MakeSRGB(); - ASSERT_FALSE(cache.GetPrerolledImage(NULL, picture.get(), matrix, srgb.get(), - true, false)); // 1 + ASSERT_FALSE(cache.Prepare(NULL, picture.get(), matrix, srgb.get(), true, + false)); // 1 cache.SweepAfterFrame(); - ASSERT_FALSE(cache.GetPrerolledImage(NULL, picture.get(), matrix, srgb.get(), - true, false)); // 2 + ASSERT_FALSE(cache.Prepare(NULL, picture.get(), matrix, srgb.get(), true, + false)); // 2 cache.SweepAfterFrame(); - ASSERT_FALSE(cache.GetPrerolledImage(NULL, picture.get(), matrix, srgb.get(), - true, false)); // 3 + ASSERT_FALSE(cache.Prepare(NULL, picture.get(), matrix, srgb.get(), true, + false)); // 3 cache.SweepAfterFrame(); } @@ -77,19 +77,19 @@ TEST(RasterCache, SweepsRemoveUnusedFrames) { sk_sp image; sk_sp srgb = SkColorSpace::MakeSRGB(); - ASSERT_FALSE(cache.GetPrerolledImage(NULL, picture.get(), matrix, srgb.get(), - true, false)); // 1 + ASSERT_FALSE(cache.Prepare(NULL, picture.get(), matrix, srgb.get(), true, + false)); // 1 cache.SweepAfterFrame(); - ASSERT_FALSE(cache.GetPrerolledImage(NULL, picture.get(), matrix, srgb.get(), - true, false)); // 2 + ASSERT_FALSE(cache.Prepare(NULL, picture.get(), matrix, srgb.get(), true, + false)); // 2 cache.SweepAfterFrame(); - ASSERT_TRUE(cache.GetPrerolledImage(NULL, picture.get(), matrix, srgb.get(), - true, false)); // 3 + ASSERT_TRUE(cache.Prepare(NULL, picture.get(), matrix, srgb.get(), true, + false)); // 3 cache.SweepAfterFrame(); - ASSERT_TRUE(cache.GetPrerolledImage(NULL, picture.get(), matrix, srgb.get(), - true, false)); // 4 + ASSERT_TRUE(cache.Prepare(NULL, picture.get(), matrix, srgb.get(), true, + false)); // 4 cache.SweepAfterFrame(); cache.SweepAfterFrame(); // Extra frame without a preroll image access. - ASSERT_FALSE(cache.GetPrerolledImage(NULL, picture.get(), matrix, srgb.get(), - true, false)); // 5 + ASSERT_FALSE(cache.Prepare(NULL, picture.get(), matrix, srgb.get(), true, + false)); // 5 } diff --git a/flow/scene_update_context.cc b/flow/scene_update_context.cc index 576bde7fa1aff..a89df0ff7ae9a 100644 --- a/flow/scene_update_context.cc +++ b/flow/scene_update_context.cc @@ -187,9 +187,12 @@ SceneUpdateContext::ExecutePaintTasks(CompositorContext::ScopedFrame& frame) { for (auto& task : paint_tasks_) { FML_DCHECK(task.surface); SkCanvas* canvas = task.surface->GetSkiaSurface()->getCanvas(); - Layer::PaintContext context = {*canvas, frame.context().frame_time(), + Layer::PaintContext context = {*canvas, + frame.context().frame_time(), frame.context().engine_time(), - frame.context().texture_registry(), false}; + frame.context().texture_registry(), + &frame.context().raster_cache(), + false}; canvas->restoreToCount(1); canvas->save(); canvas->clear(task.background_color);