From 7451daced562ec71703f3e4ccc39097e5af22734 Mon Sep 17 00:00:00 2001 From: liyuqian Date: Thu, 11 Oct 2018 14:17:33 -0700 Subject: [PATCH] Revert "Allow raster caching any layer subtree (#6442)" This reverts commit 6447418f760847786940ae82f53ce966bbba1e94. --- flow/compositor_context.cc | 2 +- flow/debug_print.cc | 10 +-- flow/debug_print.h | 2 +- flow/layers/layer.h | 21 ++---- flow/layers/layer_tree.cc | 41 +++++------- flow/layers/layer_tree.h | 3 +- flow/layers/opacity_layer.cc | 30 +-------- flow/layers/opacity_layer.h | 2 - flow/layers/picture_layer.cc | 19 +++--- flow/layers/picture_layer.h | 1 + flow/raster_cache.cc | 114 +++++++++++---------------------- flow/raster_cache.h | 50 +++------------ flow/raster_cache_key.h | 21 ++---- flow/raster_cache_unittests.cc | 44 ++++++------- flow/scene_update_context.cc | 7 +- 15 files changed, 119 insertions(+), 248 deletions(-) diff --git a/flow/compositor_context.cc b/flow/compositor_context.cc index e5a725ef6478c..aecd3a24cddf7 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, ignore_raster_cache); + layer_tree.Paint(*this); return true; } diff --git a/flow/debug_print.cc b/flow/debug_print.cc index a811e4abea875..e2d7fc3f4c882 100644 --- a/flow/debug_print.cc +++ b/flow/debug_print.cc @@ -25,8 +25,9 @@ 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; } @@ -71,9 +72,8 @@ std::ostream& operator<<(std::ostream& os, const SkPoint& r) { return os; } -std::ostream& operator<<(std::ostream& os, - const flow::PictureRasterCacheKey& k) { - os << "Picture: " << k.id() << " matrix: " << k.matrix(); +std::ostream& operator<<(std::ostream& os, const flow::RasterCacheKey& k) { + os << "Picture: " << k.picture_id() << " matrix: " << k.matrix(); return os; } diff --git a/flow/debug_print.h b/flow/debug_print.h index 4db0748bc31cb..d58dcbed28bed 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::PictureRasterCacheKey); +DEF_PRINTER(flow::RasterCacheKey); DEF_PRINTER(SkISize); DEF_PRINTER(SkMatrix); DEF_PRINTER(SkMatrix44); diff --git a/flow/layers/layer.h b/flow/layers/layer.h index 50fd3b63b277d..a52f6e04aa86c 100644 --- a/flow/layers/layer.h +++ b/flow/layers/layer.h @@ -40,19 +40,6 @@ 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 { @@ -60,6 +47,13 @@ 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 { @@ -67,7 +61,6 @@ 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 de28918193576..29f9c93b52c19 100644 --- a/flow/layers/layer_tree.cc +++ b/flow/layers/layer_tree.cc @@ -25,15 +25,12 @@ void LayerTree::Preroll(CompositorContext::ScopedFrame& frame, frame.canvas() ? frame.canvas()->imageInfo().colorSpace() : nullptr; frame.context().raster_cache().SetCheckboardCacheImages( checkerboard_raster_cache_images_); - PrerollContext context = { + Layer::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()); } @@ -63,16 +60,15 @@ void LayerTree::UpdateScene(SceneUpdateContext& context, } #endif -void LayerTree::Paint(CompositorContext::ScopedFrame& frame, - bool ignore_raster_cache) const { +void LayerTree::Paint(CompositorContext::ScopedFrame& frame) const { TRACE_EVENT0("flutter", "LayerTree::Paint"); Layer::PaintContext context = { - *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_}; + *frame.canvas(), // + frame.context().frame_time(), // + frame.context().engine_time(), // + frame.context().texture_registry(), // + checkerboard_offscreen_layers_ // + }; if (root_layer_->needs_painting()) root_layer_->Paint(context); @@ -88,29 +84,24 @@ 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 a146a3520f609..bae883ca207be 100644 --- a/flow/layers/layer_tree.h +++ b/flow/layers/layer_tree.h @@ -32,8 +32,7 @@ class LayerTree { scenic::ContainerNode& container); #endif - void Paint(CompositorContext::ScopedFrame& frame, - bool ignore_raster_cache = false) const; + void Paint(CompositorContext::ScopedFrame& frame) const; sk_sp Flatten(const SkRect& bounds); diff --git a/flow/layers/opacity_layer.cc b/flow/layers/opacity_layer.cc index 351d3107f0d50..2272e79093864 100644 --- a/flow/layers/opacity_layer.cc +++ b/flow/layers/opacity_layer.cc @@ -10,18 +10,6 @@ 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()); @@ -29,23 +17,7 @@ void OpacityLayer::Paint(PaintContext& context) const { SkPaint paint; paint.setAlpha(alpha_); - 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 save = Layer::AutoSaveLayer::Create(context, paint_bounds(), &paint); PaintChildren(context); } diff --git a/flow/layers/opacity_layer.h b/flow/layers/opacity_layer.h index 4733d13645233..b27829385046b 100644 --- a/flow/layers/opacity_layer.h +++ b/flow/layers/opacity_layer.h @@ -16,8 +16,6 @@ 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 9dcef880b7313..3cbf15a609ad1 100644 --- a/flow/layers/picture_layer.cc +++ b/flow/layers/picture_layer.cc @@ -21,8 +21,11 @@ void PictureLayer::Preroll(PrerollContext* context, const SkMatrix& matrix) { #ifndef SUPPORT_FRACTIONAL_TRANSLATION ctm = RasterCache::GetIntegralTransCTM(ctm); #endif - cache->Prepare(context->gr_context, sk_picture, ctm, - context->dst_color_space, is_complex_, will_change_); + raster_cache_result_ = cache->GetPrerolledImage( + context->gr_context, sk_picture, ctm, context->dst_color_space, + is_complex_, will_change_); + } else { + raster_cache_result_ = RasterCacheResult(); } SkRect bounds = sk_picture->cullRect().makeOffset(offset_.x(), offset_.y()); @@ -41,15 +44,11 @@ void PictureLayer::Paint(PaintContext& context) const { RasterCache::GetIntegralTransCTM(context.canvas.getTotalMatrix())); #endif - 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; - } + if (raster_cache_result_.is_valid()) { + raster_cache_result_.draw(context.canvas); + } else { + context.canvas.drawPicture(picture()); } - context.canvas.drawPicture(picture()); } } // namespace flow diff --git a/flow/layers/picture_layer.h b/flow/layers/picture_layer.h index 8b6f74c313839..12e2807c33d23 100644 --- a/flow/layers/picture_layer.h +++ b/flow/layers/picture_layer.h @@ -39,6 +39,7 @@ 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 8100453457ca1..a3aef6e3d1410 100644 --- a/flow/raster_cache.cc +++ b/flow/raster_cache.cc @@ -6,7 +6,6 @@ #include -#include "flutter/flow/layers/layer.h" #include "flutter/flow/paint_utils.h" #include "flutter/fml/logging.h" #include "flutter/fml/trace_event.h" @@ -18,13 +17,13 @@ namespace flow { -void RasterCacheResult::draw(SkCanvas& canvas, const SkPaint* paint) const { +void RasterCacheResult::draw(SkCanvas& canvas) 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, paint); + canvas.drawImage(image_, bounds.fLeft, bounds.fTop); } RasterCache::RasterCache(size_t threshold) @@ -78,13 +77,14 @@ static bool IsPictureWorthRasterizing(SkPicture* picture, return picture->approximateOpCount() > 10; } -static RasterCacheResult Rasterize( - GrContext* context, - const SkMatrix& ctm, - SkColorSpace* dst_color_space, - bool checkerboard, - const SkRect& logical_rect, - std::function draw_function) { +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(); SkIRect cache_rect = RasterCache::GetDeviceBounds(logical_rect, ctm); const SkImageInfo image_info = @@ -112,7 +112,7 @@ static RasterCacheResult Rasterize( canvas->clear(SK_ColorTRANSPARENT); canvas->translate(-cache_rect.left(), -cache_rect.top()); canvas->concat(ctm); - draw_function(canvas); + canvas->drawPicture(picture); if (checkerboard) { DrawCheckerboard(canvas, logical_rect); @@ -121,18 +121,6 @@ static RasterCacheResult Rasterize( 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; @@ -145,38 +133,16 @@ static inline size_t ClampSize(size_t value, size_t min, size_t max) { return value; } -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) { +RasterCacheResult RasterCache::GetPrerolledImage( + 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 false; + return {}; } // Decompose the matrix (once) for all subsequent operations. We want to make @@ -185,50 +151,46 @@ bool RasterCache::Prepare(GrContext* context, if (!matrix.IsValid()) { // The matrix was singular. No point in going further. - return false; + return {}; } - PictureRasterCacheKey cache_key(picture->uniqueID(), transformation_matrix); + RasterCacheKey cache_key(*picture, transformation_matrix); - Entry& entry = picture_cache_[cache_key]; + Entry& entry = 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 false; + return {}; } if (!entry.image.is_valid()) { entry.image = RasterizePicture(picture, context, transformation_matrix, dst_color_space, checkerboard_images_); } - return true; -} - -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; -} -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; + return entry.image; } void RasterCache::SweepAfterFrame() { - using PictureCache = PictureRasterCacheKey::Map; - using LayerCache = LayerRasterCacheKey::Map; - SweepOneCacheAfterFrame(picture_cache_); - SweepOneCacheAfterFrame(layer_cache_); + std::vector::iterator> 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); + } } void RasterCache::Clear() { - picture_cache_.clear(); + cache_.clear(); } void RasterCache::SetCheckboardCacheImages(bool checkerboard) { diff --git a/flow/raster_cache.h b/flow/raster_cache.h index f15028e1d019d..348ab8000da39 100644 --- a/flow/raster_cache.h +++ b/flow/raster_cache.h @@ -28,15 +28,13 @@ class RasterCacheResult { bool is_valid() const { return static_cast(image_); }; - void draw(SkCanvas& canvas, const SkPaint* paint = nullptr) const; + void draw(SkCanvas& canvas) const; private: sk_sp image_; SkRect logical_rect_; }; -struct PrerollContext; - class RasterCache { public: explicit RasterCache(size_t threshold = 3); @@ -58,26 +56,12 @@ class RasterCache { return result; } - // 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; + RasterCacheResult GetPrerolledImage(GrContext* context, + SkPicture* picture, + const SkMatrix& transformation_matrix, + SkColorSpace* dst_color_space, + bool is_complex, + bool will_change); void SweepAfterFrame(); @@ -92,26 +76,8 @@ 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_; - PictureRasterCacheKey::Map picture_cache_; - LayerRasterCacheKey::Map layer_cache_; + RasterCacheKey::Map cache_; bool checkerboard_images_; fml::WeakPtrFactory weak_factory_; diff --git a/flow/raster_cache_key.h b/flow/raster_cache_key.h index d681bff4b3a36..3f20072df8e3b 100644 --- a/flow/raster_cache_key.h +++ b/flow/raster_cache_key.h @@ -14,10 +14,10 @@ namespace flow { -template class RasterCacheKey { public: - RasterCacheKey(ID id, const SkMatrix& ctm) : id_(id), matrix_(ctm) { + RasterCacheKey(const SkPicture& picture, const SkMatrix& ctm) + : picture_id_(picture.uniqueID()), 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 } - ID id() const { return id_; } + uint32_t picture_id() const { return picture_id_; } const SkMatrix& matrix() const { return matrix_; } struct Hash { - uint32_t operator()(RasterCacheKey const& key) const { - return std::hash()(key.id_); + std::size_t operator()(RasterCacheKey const& key) const { + return key.picture_id_; } }; struct Equal { constexpr bool operator()(const RasterCacheKey& lhs, const RasterCacheKey& rhs) const { - return lhs.id_ == rhs.id_ && lhs.matrix_ == rhs.matrix_; + return lhs.picture_id_ == rhs.picture_id_ && lhs.matrix_ == rhs.matrix_; } }; @@ -45,7 +45,7 @@ class RasterCacheKey { using Map = std::unordered_map; private: - ID id_; + uint32_t picture_id_; // ctm where only fractional (0-1) translations are preserved: // matrix_ = ctm; @@ -54,13 +54,6 @@ 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 5d6c89b48e23d..0033d475b4bcb 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.Prepare(NULL, picture.get(), matrix, srgb.get(), true, - false)); // 1 + ASSERT_FALSE(cache.GetPrerolledImage(NULL, picture.get(), matrix, srgb.get(), + true, false)); // 1 cache.SweepAfterFrame(); - ASSERT_FALSE(cache.Prepare(NULL, picture.get(), matrix, srgb.get(), true, - false)); // 2 + ASSERT_FALSE(cache.GetPrerolledImage(NULL, picture.get(), matrix, srgb.get(), + true, false)); // 2 cache.SweepAfterFrame(); - ASSERT_TRUE(cache.Prepare(NULL, picture.get(), matrix, srgb.get(), true, - false)); // 3 + ASSERT_TRUE(cache.GetPrerolledImage(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.Prepare(NULL, picture.get(), matrix, srgb.get(), true, - false)); // 1 + ASSERT_FALSE(cache.GetPrerolledImage(NULL, picture.get(), matrix, srgb.get(), + true, false)); // 1 cache.SweepAfterFrame(); - ASSERT_FALSE(cache.Prepare(NULL, picture.get(), matrix, srgb.get(), true, - false)); // 2 + ASSERT_FALSE(cache.GetPrerolledImage(NULL, picture.get(), matrix, srgb.get(), + true, false)); // 2 cache.SweepAfterFrame(); - ASSERT_FALSE(cache.Prepare(NULL, picture.get(), matrix, srgb.get(), true, - false)); // 3 + ASSERT_FALSE(cache.GetPrerolledImage(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.Prepare(NULL, picture.get(), matrix, srgb.get(), true, - false)); // 1 + ASSERT_FALSE(cache.GetPrerolledImage(NULL, picture.get(), matrix, srgb.get(), + true, false)); // 1 cache.SweepAfterFrame(); - ASSERT_FALSE(cache.Prepare(NULL, picture.get(), matrix, srgb.get(), true, - false)); // 2 + ASSERT_FALSE(cache.GetPrerolledImage(NULL, picture.get(), matrix, srgb.get(), + true, false)); // 2 cache.SweepAfterFrame(); - ASSERT_TRUE(cache.Prepare(NULL, picture.get(), matrix, srgb.get(), true, - false)); // 3 + ASSERT_TRUE(cache.GetPrerolledImage(NULL, picture.get(), matrix, srgb.get(), + true, false)); // 3 cache.SweepAfterFrame(); - ASSERT_TRUE(cache.Prepare(NULL, picture.get(), matrix, srgb.get(), true, - false)); // 4 + ASSERT_TRUE(cache.GetPrerolledImage(NULL, picture.get(), matrix, srgb.get(), + true, false)); // 4 cache.SweepAfterFrame(); cache.SweepAfterFrame(); // Extra frame without a preroll image access. - ASSERT_FALSE(cache.Prepare(NULL, picture.get(), matrix, srgb.get(), true, - false)); // 5 + ASSERT_FALSE(cache.GetPrerolledImage(NULL, picture.get(), matrix, srgb.get(), + true, false)); // 5 } diff --git a/flow/scene_update_context.cc b/flow/scene_update_context.cc index a89df0ff7ae9a..576bde7fa1aff 100644 --- a/flow/scene_update_context.cc +++ b/flow/scene_update_context.cc @@ -187,12 +187,9 @@ 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(), - &frame.context().raster_cache(), - false}; + frame.context().texture_registry(), false}; canvas->restoreToCount(1); canvas->save(); canvas->clear(task.background_color);