Skip to content
This repository was archived by the owner on Feb 25, 2025. It is now read-only.

Defer decisions about RasterCache actions until after Preroll is complete #31892

Merged
fluttergithubbot merged 37 commits into from
Jun 30, 2022
Merged

Defer decisions about RasterCache actions until after Preroll is complete #31892

Show file tree
Hide file tree
Changes from 1 commit
Commits
Show all changes
37 commits
Select commit Hold shift + click to select a range
9f44aad
Collection Need RasterCache Layer in Preroll
JsouLiang Mar 9, 2022
bb6a4cc
Collection Need RasterCache DisplayListLayer In Preroll
JsouLiang Mar 9, 2022
51ae333
Collection Need RasterCache DisplayListLayer In Preroll
JsouLiang Mar 31, 2022
bb86e3a
Differentiate RasterCacheableEntry Layer DisplayList SkPicture
JsouLiang Mar 31, 2022
98b4ad6
Collection Raster Cacheable OpacityLayer in Preroll
JsouLiang Apr 2, 2022
2a0fbc3
Add PictureLayer RasterCache
JsouLiang Apr 8, 2022
9a71e09
Use Cacheable Object to entry the layer
JsouLiang Apr 16, 2022
0f60777
Fix some failed cases; Add new test case for collect RasterCacheable …
JsouLiang Apr 16, 2022
d53733e
Fix RasterCacheDisabledWithPlatformViews test error
JsouLiang Apr 16, 2022
4600cd6
ImageFilterLayer NeedCache check filter is nullptr
JsouLiang Apr 16, 2022
7626d11
Fix the PrerollContext size is different in windows platform
JsouLiang Apr 17, 2022
d88aff2
Change the logic of raster cache entry
JsouLiang Apr 19, 2022
45b28cf
Change the Cacheable interface capacity
JsouLiang Apr 20, 2022
57a8d16
Update the LayerTree::TryToRasterCache logic; Change some comments
JsouLiang Apr 22, 2022
e4eb2a0
fix conflict
JsouLiang Apr 23, 2022
7e5af26
Add RasterCache test in Container_layer_unittest file
JsouLiang Apr 24, 2022
879ee10
If parent cached success, we will try to remove the children cache
JsouLiang Apr 26, 2022
2c038e9
Move Prepare, Touch, Draw from RasterCache to CacheableItem
JsouLiang Apr 30, 2022
829e9f4
fix shell unittest test failed
JsouLiang Apr 30, 2022
91cf4e9
Optimize structure
JsouLiang May 3, 2022
ba5694e
Change RasterCacheItem struct and fix some test cases
JsouLiang May 4, 2022
45448d4
Fix test cases
JsouLiang May 5, 2022
dc089ad
Remove the RasterCacheResult survival count
JsouLiang May 7, 2022
2f1eb2f
fix naming issues
JsouLiang May 10, 2022
473288b
Change the RasterCache of ClipLayer
JsouLiang May 17, 2022
a80a037
Fix some comments
JsouLiang May 20, 2022
fd82489
Change the licenses
JsouLiang May 20, 2022
d3883c6
fix some comments
JsouLiang Jun 13, 2022
3e1ed6c
Rebase master
JsouLiang Jun 14, 2022
a25e920
Remove redundant logic
JsouLiang Jun 15, 2022
fd3bc8e
resolve conflicting files
JsouLiang Jun 23, 2022
cdc123d
Fix comments
JsouLiang Jun 23, 2022
d8d373a
Update licenses
JsouLiang Jun 23, 2022
9e0e52b
fix the display_list_raster_item set cache entry logic
JsouLiang Jun 24, 2022
9b68847
ImageFilterLayer Reset cache_children; Fix some comments
JsouLiang Jun 27, 2022
7c7fc4c
LayerRCI use GetPaintBoundsFromLayer to paint cache
JsouLiang Jun 29, 2022
91f7278
Change lambda capture variable; fix nits
JsouLiang Jun 30, 2022
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
Prev Previous commit
Next Next commit
Move Prepare, Touch, Draw from RasterCache to CacheableItem
  • Loading branch information
@JsouLiang
JsouLiang committed Jun 23, 2022
commit 2c038e9c0993279f53ca41610f6a985c93e3d2bf
87 changes: 63 additions & 24 deletions flow/layers/cacheable_layer.cc
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -3,55 +3,94 @@
// found in the LICENSE file.

#include "flutter/flow/layers/cacheable_layer.h"
#include <memory>
#include "flutter/flow/layers/display_list_layer.h"
#include "flutter/flow/layers/layer.h"
#include "flutter/flow/layers/picture_layer.h"
#include "flutter/flow/raster_cacheable_entry.h"
#include "include/core/SkMatrix.h"

namespace flutter {

void Cacheable::InitialCacheableLayerItem(Layer* layer) {
cacheable_item_ = std::make_unique<LayerCacheableItem>(layer);
}

void Cacheable::InitialCacheableDisplayListItem(DisplayList* display_list,
SkRect bounds,
bool is_complex,
bool will_change) {
cacheable_item_ = std::make_unique<DisplayListCacheableItem>(
display_list, bounds, SkMatrix::I(), is_complex, will_change);
}

void Cacheable::InitialCacheableSkPictureItem(SkPicture* sk_picture,
SkRect bounds,
bool is_complex,
bool will_change) {
cacheable_item_ = std::make_unique<SkPictureCacheableItem>(
sk_picture, bounds, SkMatrix::I(), is_complex, will_change);
}

Cacheable::AutoCache::~AutoCache() {
if (skip_) {
return;
}
cacheable_->cacheable_item_->set_child_entries(
context_->raster_cached_entries->size() - current_index_);
cacheable_->TryToCache(context_, matrix_);
if (auto* cacheable_layer = cacheable_->GetCacheableLayer()) {
cacheable_layer->SetHasPlatformView(context_->has_platform_view);
cacheable_layer->SetHasTextureLayer(context_->has_texture_layer);
}
}

Cacheable::AutoCache Cacheable::AutoCache::Create(Cacheable* cacheable,
PrerollContext* context,
const SkMatrix& matrix) {
auto cache_entry =
RasterCacheableEntry::MakeLayerCacheable(cacheable, *context, matrix);
if (cache_entry) {
auto* entry_ptr =
context->raster_cached_entries.emplace_back(std::move(cache_entry))
.get();
return AutoCache(cacheable, entry_ptr, context, matrix);
bool skip = true;
if (context->raster_cache) {
cacheable->cacheable_item_->Reset();
cacheable->cacheable_item_->set_matrix(matrix);
cacheable->cacheable_item_->set_cull_rect(context->cull_rect);
context->raster_cached_entries->emplace_back(
cacheable->cacheable_item_.get());
skip = false;
}
return AutoCache(cacheable, nullptr, context, matrix);
return AutoCache(cacheable, context, matrix, skip);
}

Cacheable::AutoCache Cacheable::AutoCache::Create(
DisplayListLayer* display_list_layer,
PrerollContext* context,
const SkMatrix& matrix,
SkRect bounds) {
auto cache_entry = RasterCacheableEntry::MakeDisplayListCacheable(
display_list_layer->display_list(), *context, matrix, bounds);
if (cache_entry) {
auto* entry_ptr =
context->raster_cached_entries.emplace_back(std::move(cache_entry))
.get();
return AutoCache(display_list_layer, entry_ptr, context, matrix);
bool skip = true;
if (context->raster_cache && display_list_layer->display_list()) {
display_list_layer->cacheable_item_->Reset();
display_list_layer->cacheable_item_->set_matrix(matrix);
display_list_layer->cacheable_item_->set_cull_rect(context->cull_rect);
context->raster_cached_entries->emplace_back(
display_list_layer->cacheable_item_.get());
skip = false;
}
return AutoCache(display_list_layer, nullptr, context, matrix);
return AutoCache(display_list_layer, context, matrix, skip);
}

Cacheable::AutoCache Cacheable::AutoCache::Create(PictureLayer* picture_layer,
PrerollContext* context,
const SkMatrix& matrix,
SkRect bounds) {
auto cache_entry = RasterCacheableEntry::MakeSkPictureCacheable(
picture_layer->picture(), *context, matrix, bounds);
if (cache_entry) {
auto* entry_ptr =
context->raster_cached_entries.emplace_back(std::move(cache_entry))
.get();
return AutoCache(picture_layer, entry_ptr, context, matrix);
bool skip = true;
if (context->raster_cache && picture_layer->picture()) {
picture_layer->cacheable_item_->Reset();
picture_layer->cacheable_item_->set_matrix(matrix);
picture_layer->cacheable_item_->set_cull_rect(context->cull_rect);
context->raster_cached_entries->emplace_back(
picture_layer->cacheable_item_.get());
skip = false;
}
return AutoCache(picture_layer, nullptr, context, matrix);
return AutoCache(picture_layer, context, matrix, skip);
}

} // namespace flutter
75 changes: 56 additions & 19 deletions flow/layers/cacheable_layer.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -12,13 +12,26 @@
#include "include/core/SkColor.h"
#include "include/core/SkMatrix.h"
#include "include/core/SkPoint.h"
#include "include/core/SkRect.h"

namespace flutter {

class Cacheable {
Copy link
Contributor

@flar flar May 4, 2022 •
edited
Loading

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

The way this class is mixed in here, it just becomes a dispatcher for 3 other classes that encapsulate the concepts for each of the 3 types of cacheable.

Just instantiate the type of CacheableItem in the constructor of the layers and declare a type-specific field in those classes and this entire class goes away.

AutoCache can be a simple class that takes the base CacheableItem type and calls methods on it and doesn't need 3 different type of Create methods.

public:
Cacheable() = default;

void InitialCacheableLayerItem(Layer*);

void InitialCacheableDisplayListItem(DisplayList*,
SkRect bounds,
bool is_complex,
bool will_change);

void InitialCacheableSkPictureItem(SkPicture*,
SkRect bounds,
bool is_complex,
bool will_change);

class AutoCache {
public:
static AutoCache Create(Cacheable* cacheable,
Expand All @@ -35,41 +48,65 @@ class Cacheable {
const SkMatrix& matrix,
SkRect bounds);

~AutoCache() {
if (!cacheable_entry_) {
return;
}
cacheable_entry_->num_child_entries =
context_->raster_cached_entries.size() - current_index_;
cacheable_->TryToCache(context_, cacheable_entry_, matrix_);
cacheable_entry_->has_platform_view = context_->has_platform_view;
cacheable_entry_->has_texture_layer = context_->has_texture_layer;
}
~AutoCache();

private:
AutoCache(Cacheable* cacheable,
RasterCacheableEntry* cacheable_entry,
PrerollContext* context,
const SkMatrix& matrix)
: cacheable_(cacheable), context_(context), matrix_(matrix) {
cacheable_entry_ = cacheable_entry;
current_index_ = context_->raster_cached_entries.size();
const SkMatrix& matrix,
bool skip = false)
: cacheable_(cacheable),
context_(context),
matrix_(matrix),
skip_(skip) {
if (context_ && context_->raster_cache) {
current_index_ = context_->raster_cached_entries->size();
}
}

int current_index_;
RasterCacheableEntry* cacheable_entry_ = nullptr;
Cacheable* cacheable_ = nullptr;
PrerollContext* context_ = nullptr;
const SkMatrix& matrix_;
bool skip_ = false;
};

virtual Layer* asLayer() = 0;

virtual void TryToCache(PrerollContext* context,
RasterCacheableEntry* entry,
const SkMatrix& ctm) = 0;
virtual void TryToCache(PrerollContext* context, const SkMatrix& ctm) = 0;

virtual ~Cacheable() = default;

LayerCacheableItem* GetCacheableLayer() {
Copy link
Contributor

@flar flar May 4, 2022

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

This is not a good use of asFoo() and asBar() types of methods. The various layers called a specific method to instantiate a specific sub-type of the CacheableItem and then this class hides that type-specific knowledge and makes them ask permission to access the type of object that they specifically called into being.

Cacheable has gone from an unnecessary dispatch class to actively thwarting the layers from directly using their own style of cache item.

Cacheable needs to be deleted. Just have the layers have a "FooCacheableItem" field and instantiate it directly in their constructors, and then they'll never have to call these methods which use a de-obfuscation facility to perform the work we know should happen.

return cacheable_item_.get()->asLayerCacheableItem();
}

const LayerCacheableItem* GetCacheableLayer() const {
return cacheable_item_.get()->asLayerCacheableItem();
}

DisplayListCacheableItem* GetCacheableDisplayListItem() {
return cacheable_item_.get()->asDisplayCacheableItem();
}

const DisplayListCacheableItem* GetCacheableDisplayListItem() const {
return cacheable_item_.get()->asDisplayCacheableItem();
}

SkPictureCacheableItem* GetCacheableSkPictureItem() {
return cacheable_item_.get()->asSkPictureCacheableItem();
}

const SkPictureCacheableItem* GetCacheableSkPictureItem() const {
return cacheable_item_.get()->asSkPictureCacheableItem();
}

protected:
const CacheableItem* GetCacheableItem() const {
return cacheable_item_.get();
}

std::unique_ptr<CacheableItem> cacheable_item_;
};

} // namespace flutter
Expand Down
23 changes: 12 additions & 11 deletions flow/layers/color_filter_layer.cc
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -8,7 +8,9 @@
namespace flutter {

ColorFilterLayer::ColorFilterLayer(sk_sp<SkColorFilter> filter)
: filter_(std::move(filter)), render_count_(1) {}
: filter_(std::move(filter)), render_count_(1) {
InitialCacheableLayerItem(this);
}

void ColorFilterLayer::Diff(DiffContext* context, const Layer* old_layer) {
DiffContext::AutoSubtreeRestore subtree(context);
Expand Down Expand Up @@ -44,16 +46,16 @@ void ColorFilterLayer::Preroll(PrerollContext* context,
}

void ColorFilterLayer::TryToCache(PrerollContext* context,
RasterCacheableEntry* entry,
const SkMatrix& ctm) {
// We should try to cache the layer or layer's children.
// First we should to check if we need to touch the cache.
if (render_count_ >= kMinimumRendersBeforeCachingFilterLayer) {
// entry default cache current layer
GetCacheableLayer()->set_cache_layer();
return;
}
render_count_++;
entry->MarkLayerChildrenNeedCached();
GetCacheableLayer()->set_cache_children_layer();
}

void ColorFilterLayer::Paint(PaintContext& context) const {
Expand All @@ -63,15 +65,14 @@ void ColorFilterLayer::Paint(PaintContext& context) const {
AutoCachePaint cache_paint(context);

if (context.raster_cache) {
if (context.raster_cache->Draw(this, *context.leaf_nodes_canvas,
RasterCacheLayerStrategy::kLayer,
cache_paint.paint())) {
return;
const auto* layer_cacheable_item = GetCacheableLayer();
layer_cacheable_item->set_cache_layer();
if (layer_cacheable_item->GetStrategy() ==
RasterCacheLayerStrategy::kLayerChildren) {
cache_paint.setColorFilter(filter_);
}

cache_paint.setColorFilter(filter_);
if (context.raster_cache->Draw(this, *context.leaf_nodes_canvas,
RasterCacheLayerStrategy::kLayerChildren,
if (layer_cacheable_item->Draw(context.raster_cache,
*context.leaf_nodes_canvas,
cache_paint.paint())) {
return;
}
Expand Down
4 changes: 1 addition & 3 deletions flow/layers/color_filter_layer.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -21,9 +21,7 @@ class ColorFilterLayer : public ContainerLayer, public Cacheable {

void Paint(PaintContext& context) const override;

void TryToCache(PrerollContext* context,
RasterCacheableEntry* entry,
const SkMatrix& ctm) override;
void TryToCache(PrerollContext* context, const SkMatrix& ctm) override;

Layer* asLayer() override { return this; }

Expand Down
68 changes: 22 additions & 46 deletions flow/layers/color_filter_layer_unittests.cc
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -241,33 +241,22 @@ TEST_F(ColorFilterLayerTest, CacheChild) {
other_canvas.setMatrix(other_transform);

use_mock_raster_cache();
const auto* cachebale_color_filter_item = layer->GetCacheableLayer();

EXPECT_EQ(raster_cache()->GetLayerCachedEntriesCount(), (size_t)0);
EXPECT_FALSE(raster_cache()->Draw(mock_layer.get(), other_canvas));
EXPECT_FALSE(raster_cache()->Draw(mock_layer.get(), cache_canvas));
EXPECT_FALSE(raster_cache()->Draw(layer.get(), other_canvas,
RasterCacheLayerStrategy::kLayer));
EXPECT_FALSE(raster_cache()->Draw(layer.get(), cache_canvas,
RasterCacheLayerStrategy::kLayer));
EXPECT_FALSE(raster_cache()->Draw(layer.get(), other_canvas,
RasterCacheLayerStrategy::kLayerChildren));
EXPECT_FALSE(raster_cache()->Draw(layer.get(), cache_canvas,
RasterCacheLayerStrategy::kLayerChildren));
EXPECT_EQ(cachebale_color_filter_item->GetStrategy(),
RasterCacheLayerStrategy::kLayer);
EXPECT_FALSE(cachebale_color_filter_item->Draw(raster_cache(), other_canvas));
EXPECT_FALSE(cachebale_color_filter_item->Draw(raster_cache(), cache_canvas));

layer->Preroll(preroll_context(), initial_transform);
LayerTree::TryToRasterCache(preroll_context());
LayerTree::TryToRasterCache(cacheable_items(), &paint_context());

EXPECT_EQ(raster_cache()->GetLayerCachedEntriesCount(), (size_t)1);
EXPECT_FALSE(raster_cache()->Draw(mock_layer.get(), other_canvas));
EXPECT_FALSE(raster_cache()->Draw(mock_layer.get(), cache_canvas));
EXPECT_FALSE(raster_cache()->Draw(layer.get(), other_canvas,
RasterCacheLayerStrategy::kLayer));
EXPECT_FALSE(raster_cache()->Draw(layer.get(), cache_canvas,
RasterCacheLayerStrategy::kLayer));
EXPECT_FALSE(raster_cache()->Draw(layer.get(), other_canvas,
RasterCacheLayerStrategy::kLayerChildren));
EXPECT_TRUE(raster_cache()->Draw(layer.get(), cache_canvas,
RasterCacheLayerStrategy::kLayerChildren));
EXPECT_EQ(cachebale_color_filter_item->GetStrategy(),
RasterCacheLayerStrategy::kLayerChildren);
EXPECT_TRUE(cachebale_color_filter_item->Draw(raster_cache(), cache_canvas));
EXPECT_FALSE(cachebale_color_filter_item->Draw(raster_cache(), other_canvas));
}

TEST_F(ColorFilterLayerTest, CacheChildren) {
Expand All @@ -292,35 +281,22 @@ TEST_F(ColorFilterLayerTest, CacheChildren) {
use_mock_raster_cache();

EXPECT_EQ(raster_cache()->GetLayerCachedEntriesCount(), (size_t)0);
EXPECT_FALSE(raster_cache()->Draw(mock_layer1.get(), other_canvas));
EXPECT_FALSE(raster_cache()->Draw(mock_layer1.get(), cache_canvas));
EXPECT_FALSE(raster_cache()->Draw(mock_layer2.get(), other_canvas));
EXPECT_FALSE(raster_cache()->Draw(mock_layer2.get(), cache_canvas));
EXPECT_FALSE(raster_cache()->Draw(layer.get(), other_canvas,
RasterCacheLayerStrategy::kLayer));
EXPECT_FALSE(raster_cache()->Draw(layer.get(), cache_canvas,
RasterCacheLayerStrategy::kLayer));
EXPECT_FALSE(raster_cache()->Draw(layer.get(), other_canvas,
RasterCacheLayerStrategy::kLayerChildren));
EXPECT_FALSE(raster_cache()->Draw(layer.get(), cache_canvas,
RasterCacheLayerStrategy::kLayerChildren));
const auto* cachebale_color_filter_item = layer->GetCacheableLayer();

EXPECT_EQ(raster_cache()->GetLayerCachedEntriesCount(), (size_t)0);
EXPECT_EQ(cachebale_color_filter_item->GetStrategy(),
RasterCacheLayerStrategy::kLayer);
EXPECT_FALSE(cachebale_color_filter_item->Draw(raster_cache(), other_canvas));
EXPECT_FALSE(cachebale_color_filter_item->Draw(raster_cache(), cache_canvas));

layer->Preroll(preroll_context(), initial_transform);
LayerTree::TryToRasterCache(preroll_context());
LayerTree::TryToRasterCache(cacheable_items(), &paint_context());

EXPECT_EQ(raster_cache()->GetLayerCachedEntriesCount(), (size_t)1);
EXPECT_FALSE(raster_cache()->Draw(mock_layer1.get(), other_canvas));
EXPECT_FALSE(raster_cache()->Draw(mock_layer1.get(), cache_canvas));
EXPECT_FALSE(raster_cache()->Draw(mock_layer2.get(), other_canvas));
EXPECT_FALSE(raster_cache()->Draw(mock_layer2.get(), cache_canvas));
EXPECT_FALSE(raster_cache()->Draw(layer.get(), other_canvas,
RasterCacheLayerStrategy::kLayer));
EXPECT_FALSE(raster_cache()->Draw(layer.get(), cache_canvas,
RasterCacheLayerStrategy::kLayer));
EXPECT_FALSE(raster_cache()->Draw(layer.get(), other_canvas,
RasterCacheLayerStrategy::kLayerChildren));
EXPECT_TRUE(raster_cache()->Draw(layer.get(), cache_canvas,
RasterCacheLayerStrategy::kLayerChildren));
EXPECT_EQ(cachebale_color_filter_item->GetStrategy(),
RasterCacheLayerStrategy::kLayerChildren);
EXPECT_TRUE(cachebale_color_filter_item->Draw(raster_cache(), cache_canvas));
EXPECT_FALSE(cachebale_color_filter_item->Draw(raster_cache(), other_canvas));
}

TEST_F(ColorFilterLayerTest, OpacityInheritance) {
Expand Down
Loading