firka/flutter
3
0
Fork 1
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Revert "Allow raster caching any layer subtree (#6442)" (flutter/engine#6506)

Browse Source 
Reverts flutter/engine#6442

container_layer.h file is not synced which broke the bots
This commit is contained in:
liyuqian
2018-10-11 14:18:22 -07:00
committed by GitHub
parent 397c02b215
commit 0ec9ea75fe
15 changed files with 119 additions and 248 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
engine/src/flutter/flow/compositor_context.cc
View File

@@ -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;
}

10
engine/src/flutter/flow/debug_print.cc
View File

@@ -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;
}

2
engine/src/flutter/flow/debug_print.h
View File

@@ -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);

21
engine/src/flutter/flow/layers/layer.h
View File

@@ -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;
};

41
engine/src/flutter/flow/layers/layer_tree.cc
View File

@@ -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<SkPicture> 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
};

3
engine/src/flutter/flow/layers/layer_tree.h
View File

@@ -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<SkPicture> Flatten(const SkRect& bounds);

30
engine/src/flutter/flow/layers/opacity_layer.cc
View File

@@ -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<Layer> 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);
}

2
engine/src/flutter/flow/layers/opacity_layer.h
View File

@@ -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

19
engine/src/flutter/flow/layers/picture_layer.cc
View File

@@ -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

1
engine/src/flutter/flow/layers/picture_layer.h
View File

@@ -39,6 +39,7 @@ class PictureLayer : public Layer {
SkiaGPUObject<SkPicture> picture_;
bool is_complex_ = false;
bool will_change_ = false;
RasterCacheResult raster_cache_result_;
FML_DISALLOW_COPY_AND_ASSIGN(PictureLayer);
};

114
engine/src/flutter/flow/raster_cache.cc
View File

@@ -6,7 +6,6 @@
#include <vector>
#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<void(SkCanvas*)> 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> 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> 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<Entry>;
using LayerCache = LayerRasterCacheKey::Map<Entry>;
SweepOneCacheAfterFrame<PictureCache, PictureCache::iterator>(picture_cache_);
SweepOneCacheAfterFrame<LayerCache, LayerCache::iterator>(layer_cache_);
std::vector<RasterCacheKey::Map<Entry>::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) {

50
engine/src/flutter/flow/raster_cache.h
View File

@@ -28,15 +28,13 @@ class RasterCacheResult {
bool is_valid() const { return static_cast<bool>(image_); };
void draw(SkCanvas& canvas, const SkPaint* paint = nullptr) const;
void draw(SkCanvas& canvas) const;
private:
sk_sp<SkImage> 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> layer,
const SkMatrix& ctm);
RasterCacheResult Get(const SkPicture& picture, const SkMatrix& ctm) const;
RasterCacheResult Get(std::shared_ptr<Layer> 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 <class Cache, class Iterator>
static void SweepOneCacheAfterFrame(Cache& 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);
}
}
const size_t threshold_;
PictureRasterCacheKey::Map<Entry> picture_cache_;
LayerRasterCacheKey::Map<Entry> layer_cache_;
RasterCacheKey::Map<Entry> cache_;
bool checkerboard_images_;
fml::WeakPtrFactory<RasterCache> weak_factory_;

21
engine/src/flutter/flow/raster_cache_key.h
View File

@@ -14,10 +14,10 @@
namespace flow {
template <typename ID>
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<ID>()(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<RasterCacheKey, Value, Hash, Equal>;
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<uint32_t>;
class Layer;
using LayerRasterCacheKey = RasterCacheKey<std::shared_ptr<Layer>>;
} // namespace flow
#endif // FLUTTER_FLOW_RASTER_CACHE_KEY_H_

44
engine/src/flutter/flow/raster_cache_unittests.cc
View File

@@ -33,14 +33,14 @@ TEST(RasterCache, ThresholdIsRespected) {
sk_sp<SkImage> image;
sk_sp<SkColorSpace> 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<SkImage> image;
sk_sp<SkColorSpace> 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<SkImage> image;
sk_sp<SkColorSpace> 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
}

7
engine/src/flutter/flow/scene_update_context.cc
View File

@@ -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);