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

Commit dc2ee4a

Browse files
zandersozanderso
authored
Revert "Lazily allocate RasterCacheItems only when caching is enabled… (#45747)
…" (#45734) Reverts #45211 b/298583505
1 parent ef6d5e3 commit dc2ee4a

22 files changed

+200
-567
lines changed

‎flow/layers/cacheable_layer.cc

Lines changed: 16 additions & 24 deletions
Original file line numberDiff line numberDiff line change
@@ -6,39 +6,31 @@
66

77
namespace flutter {
88

9-
AutoCache::AutoCache(CacheableLayer& cacheable_layer,
9+
AutoCache::AutoCache(RasterCacheItem* raster_cache_item,
1010
PrerollContext* context,
11-
bool caching_enabled) {
12-
if (context->raster_cache && caching_enabled) {
13-
raster_cache_item_ = cacheable_layer.realize_raster_cache_item();
14-
if (raster_cache_item_) {
15-
context_ = context;
16-
matrix_ = context->state_stack.transform_3x3();
17-
raster_cache_item_->PrerollSetup(context_, matrix_);
18-
}
19-
} else {
20-
cacheable_layer.disable_raster_cache_item();
11+
const SkMatrix& matrix)
12+
: raster_cache_item_(raster_cache_item),
13+
context_(context),
14+
matrix_(matrix) {
15+
if (IsCacheEnabled()) {
16+
raster_cache_item->PrerollSetup(context, matrix);
2117
}
2218
}
2319

24-
AutoCache::~AutoCache() {
25-
if (raster_cache_item_) {
26-
raster_cache_item_->PrerollFinalize(context_, matrix_);
27-
}
20+
bool AutoCache::IsCacheEnabled() {
21+
return raster_cache_item_ && context_ && context_->raster_cache;
2822
}
2923

30-
RasterCacheItem* CacheableContainerLayer::realize_raster_cache_item() {
31-
if (!layer_raster_cache_item_) {
32-
layer_raster_cache_item_ = LayerRasterCacheItem::Make(
33-
this, layer_cache_threshold_, can_cache_children_);
24+
AutoCache::~AutoCache() {
25+
if (IsCacheEnabled()) {
26+
raster_cache_item_->PrerollFinalize(context_, matrix_);
3427
}
35-
return layer_raster_cache_item_.get();
3628
}
3729

38-
void CacheableContainerLayer::disable_raster_cache_item() {
39-
if (layer_raster_cache_item_) {
40-
layer_raster_cache_item_->reset_cache_state();
41-
}
30+
CacheableContainerLayer::CacheableContainerLayer(int layer_cached_threshold,
31+
bool can_cache_children) {
32+
layer_raster_cache_item_ = LayerRasterCacheItem::Make(
33+
this, layer_cached_threshold, can_cache_children);
4234
}
4335

4436
} // namespace flutter

‎flow/layers/cacheable_layer.h

Lines changed: 6 additions & 29 deletions
Original file line numberDiff line numberDiff line change
@@ -9,62 +9,39 @@
99

1010
#include "flutter/flow/layers/container_layer.h"
1111
#include "flutter/flow/layers/layer_raster_cache_item.h"
12-
#include "flutter/flow/raster_cache_util.h"
1312

1413
namespace flutter {
1514

16-
class CacheableLayer {
17-
protected:
18-
virtual RasterCacheItem* realize_raster_cache_item() = 0;
19-
virtual void disable_raster_cache_item() = 0;
20-
21-
friend class AutoCache;
22-
};
23-
2415
class AutoCache {
2516
public:
26-
AutoCache(CacheableLayer& item_provider,
17+
AutoCache(RasterCacheItem* raster_cache_item,
2718
PrerollContext* context,
28-
bool caching_enabled = true);
19+
const SkMatrix& matrix);
2920

3021
void ShouldNotBeCached() { raster_cache_item_ = nullptr; }
3122

3223
~AutoCache();
3324

3425
private:
26+
inline bool IsCacheEnabled();
3527
RasterCacheItem* raster_cache_item_ = nullptr;
3628
PrerollContext* context_ = nullptr;
37-
SkMatrix matrix_;
38-
39-
FML_DISALLOW_COPY_ASSIGN_AND_MOVE(AutoCache);
29+
const SkMatrix matrix_;
4030
};
4131

42-
class CacheableContainerLayer : public ContainerLayer, public CacheableLayer {
32+
class CacheableContainerLayer : public ContainerLayer {
4333
public:
4434
explicit CacheableContainerLayer(
4535
int layer_cached_threshold =
4636
RasterCacheUtil::kMinimumRendersBeforeCachingFilterLayer,
47-
bool can_cache_children = false)
48-
: layer_cache_threshold_(layer_cached_threshold),
49-
can_cache_children_(can_cache_children) {}
37+
bool can_cache_children = false);
5038

5139
const LayerRasterCacheItem* raster_cache_item() const {
5240
return layer_raster_cache_item_.get();
5341
}
5442

55-
void MarkCanCacheChildren(bool can_cache_children) {
56-
if (layer_raster_cache_item_) {
57-
layer_raster_cache_item_->MarkCanCacheChildren(can_cache_children);
58-
}
59-
}
60-
6143
protected:
62-
RasterCacheItem* realize_raster_cache_item() override;
63-
virtual void disable_raster_cache_item() override;
6444
std::unique_ptr<LayerRasterCacheItem> layer_raster_cache_item_;
65-
66-
int layer_cache_threshold_;
67-
bool can_cache_children_;
6845
};
6946

7047
} // namespace flutter

‎flow/layers/clip_path_layer_unittests.cc

Lines changed: 6 additions & 49 deletions
Original file line numberDiff line numberDiff line change
@@ -519,74 +519,31 @@ TEST_F(ClipPathLayerTest, LayerCached) {
519519
use_mock_raster_cache();
520520
preroll_context()->state_stack.set_preroll_delegate(initial_transform);
521521

522+
const auto* clip_cache_item = layer->raster_cache_item();
523+
522524
EXPECT_EQ(raster_cache()->GetLayerCachedEntriesCount(), (size_t)0);
523-
EXPECT_EQ(layer->raster_cache_item(), nullptr);
524525

525526
layer->Preroll(preroll_context());
526-
EXPECT_NE(layer->raster_cache_item(), nullptr);
527527
LayerTree::TryToRasterCache(cacheable_items(), &paint_context());
528528

529529
EXPECT_EQ(raster_cache()->GetLayerCachedEntriesCount(), (size_t)0);
530-
EXPECT_EQ(layer->raster_cache_item()->cache_state(),
531-
RasterCacheItem::CacheState::kNone);
530+
EXPECT_EQ(clip_cache_item->cache_state(), RasterCacheItem::CacheState::kNone);
532531

533532
layer->Preroll(preroll_context());
534533
LayerTree::TryToRasterCache(cacheable_items(), &paint_context());
535534
EXPECT_EQ(raster_cache()->GetLayerCachedEntriesCount(), (size_t)0);
536-
EXPECT_EQ(layer->raster_cache_item()->cache_state(),
537-
RasterCacheItem::CacheState::kNone);
535+
EXPECT_EQ(clip_cache_item->cache_state(), RasterCacheItem::CacheState::kNone);
538536

539537
layer->Preroll(preroll_context());
540538
LayerTree::TryToRasterCache(cacheable_items(), &paint_context());
541539
EXPECT_EQ(raster_cache()->GetLayerCachedEntriesCount(), (size_t)1);
542-
EXPECT_EQ(layer->raster_cache_item()->cache_state(),
540+
EXPECT_EQ(clip_cache_item->cache_state(),
543541
RasterCacheItem::CacheState::kCurrent);
544542
DlPaint paint;
545-
EXPECT_TRUE(raster_cache()->Draw(layer->raster_cache_item()->GetId().value(),
543+
EXPECT_TRUE(raster_cache()->Draw(clip_cache_item->GetId().value(),
546544
cache_canvas, &paint));
547545
}
548546

549-
TEST_F(ClipPathLayerTest, NullRasterCacheResetsRasterCacheItem) {
550-
auto path1 = SkPath().addRect({10, 10, 30, 30});
551-
auto mock1 = MockLayer::MakeOpacityCompatible(path1);
552-
auto layer_clip = SkPath()
553-
.addRect(SkRect::MakeLTRB(5, 5, 25, 25))
554-
.addOval(SkRect::MakeLTRB(20, 20, 40, 50));
555-
auto layer =
556-
std::make_shared<ClipPathLayer>(layer_clip, Clip::antiAliasWithSaveLayer);
557-
layer->Add(mock1);
558-
559-
ASSERT_EQ(layer->raster_cache_item(), nullptr);
560-
561-
layer->Preroll(preroll_context());
562-
ASSERT_EQ(layer->raster_cache_item(), nullptr);
563-
564-
use_mock_raster_cache();
565-
566-
int limit = RasterCacheUtil::kMinimumRendersBeforeCachingFilterLayer;
567-
for (int i = 1; i < limit; i++) {
568-
layer->Preroll(preroll_context());
569-
ASSERT_NE(layer->raster_cache_item(), nullptr);
570-
ASSERT_EQ(layer->raster_cache_item()->cache_state(),
571-
RasterCacheItem::kNone);
572-
ASSERT_FALSE(
573-
layer->raster_cache_item()->TryToPrepareRasterCache(paint_context()));
574-
}
575-
576-
layer->Preroll(preroll_context());
577-
ASSERT_NE(layer->raster_cache_item(), nullptr);
578-
ASSERT_EQ(layer->raster_cache_item()->cache_state(),
579-
RasterCacheItem::kCurrent);
580-
ASSERT_TRUE(
581-
layer->raster_cache_item()->TryToPrepareRasterCache(paint_context()));
582-
583-
use_null_raster_cache();
584-
585-
layer->Preroll(preroll_context());
586-
ASSERT_NE(layer->raster_cache_item(), nullptr);
587-
ASSERT_EQ(layer->raster_cache_item()->cache_state(), RasterCacheItem::kNone);
588-
}
589-
590547
TEST_F(ClipPathLayerTest, EmptyClipDoesNotCullPlatformView) {
591548
const SkPoint view_offset = SkPoint::Make(0.0f, 0.0f);
592549
const SkSize view_size = SkSize::Make(8.0f, 8.0f);

‎flow/layers/clip_rect_layer_unittests.cc

Lines changed: 6 additions & 47 deletions
Original file line numberDiff line numberDiff line change
@@ -499,71 +499,30 @@ TEST_F(ClipRectLayerTest, LayerCached) {
499499

500500
use_mock_raster_cache();
501501
preroll_context()->state_stack.set_preroll_delegate(initial_transform);
502-
EXPECT_EQ(layer->raster_cache_item(), nullptr);
502+
503+
const auto* clip_cache_item = layer->raster_cache_item();
503504

504505
layer->Preroll(preroll_context());
505-
EXPECT_NE(layer->raster_cache_item(), nullptr);
506506
LayerTree::TryToRasterCache(cacheable_items(), &paint_context());
507507

508508
EXPECT_EQ(raster_cache()->GetLayerCachedEntriesCount(), (size_t)0);
509-
EXPECT_EQ(layer->raster_cache_item()->cache_state(),
510-
RasterCacheItem::CacheState::kNone);
509+
EXPECT_EQ(clip_cache_item->cache_state(), RasterCacheItem::CacheState::kNone);
511510

512511
layer->Preroll(preroll_context());
513512
LayerTree::TryToRasterCache(cacheable_items(), &paint_context());
514513
EXPECT_EQ(raster_cache()->GetLayerCachedEntriesCount(), (size_t)0);
515-
EXPECT_EQ(layer->raster_cache_item()->cache_state(),
516-
RasterCacheItem::CacheState::kNone);
514+
EXPECT_EQ(clip_cache_item->cache_state(), RasterCacheItem::CacheState::kNone);
517515

518516
layer->Preroll(preroll_context());
519517
LayerTree::TryToRasterCache(cacheable_items(), &paint_context());
520518
EXPECT_EQ(raster_cache()->GetLayerCachedEntriesCount(), (size_t)1);
521-
EXPECT_EQ(layer->raster_cache_item()->cache_state(),
519+
EXPECT_EQ(clip_cache_item->cache_state(),
522520
RasterCacheItem::CacheState::kCurrent);
523521
DlPaint paint;
524-
EXPECT_TRUE(raster_cache()->Draw(layer->raster_cache_item()->GetId().value(),
522+
EXPECT_TRUE(raster_cache()->Draw(clip_cache_item->GetId().value(),
525523
cache_canvas, &paint));
526524
}
527525

528-
TEST_F(ClipRectLayerTest, NullRasterCacheResetsRasterCacheItem) {
529-
auto path1 = SkPath().addRect({10, 10, 30, 30});
530-
auto mock1 = MockLayer::MakeOpacityCompatible(path1);
531-
SkRect clip_rect = SkRect::MakeWH(500, 500);
532-
auto layer =
533-
std::make_shared<ClipRectLayer>(clip_rect, Clip::antiAliasWithSaveLayer);
534-
layer->Add(mock1);
535-
536-
ASSERT_EQ(layer->raster_cache_item(), nullptr);
537-
538-
layer->Preroll(preroll_context());
539-
ASSERT_EQ(layer->raster_cache_item(), nullptr);
540-
541-
use_mock_raster_cache();
542-
543-
int limit = RasterCacheUtil::kMinimumRendersBeforeCachingFilterLayer;
544-
for (int i = 1; i < limit; i++) {
545-
layer->Preroll(preroll_context());
546-
ASSERT_NE(layer->raster_cache_item(), nullptr);
547-
ASSERT_EQ(layer->raster_cache_item()->cache_state(),
548-
RasterCacheItem::kNone);
549-
ASSERT_FALSE(
550-
layer->raster_cache_item()->TryToPrepareRasterCache(paint_context()));
551-
}
552-
553-
layer->Preroll(preroll_context());
554-
ASSERT_NE(layer->raster_cache_item(), nullptr);
555-
ASSERT_EQ(layer->raster_cache_item()->cache_state(),
556-
RasterCacheItem::kCurrent);
557-
ASSERT_TRUE(
558-
layer->raster_cache_item()->TryToPrepareRasterCache(paint_context()));
559-
560-
use_null_raster_cache();
561-
562-
layer->Preroll(preroll_context());
563-
ASSERT_NE(layer->raster_cache_item(), nullptr);
564-
ASSERT_EQ(layer->raster_cache_item()->cache_state(), RasterCacheItem::kNone);
565-
}
566-
567526
TEST_F(ClipRectLayerTest, EmptyClipDoesNotCullPlatformView) {
568527
const SkPoint view_offset = SkPoint::Make(0.0f, 0.0f);
569528
const SkSize view_size = SkSize::Make(8.0f, 8.0f);

‎flow/layers/clip_rrect_layer_unittests.cc

Lines changed: 11 additions & 53 deletions
Original file line numberDiff line numberDiff line change
@@ -512,72 +512,29 @@ TEST_F(ClipRRectLayerTest, LayerCached) {
512512

513513
use_mock_raster_cache();
514514
preroll_context()->state_stack.set_preroll_delegate(initial_transform);
515-
EXPECT_EQ(layer->raster_cache_item(), nullptr);
515+
516+
const auto* clip_cache_item = layer->raster_cache_item();
516517

517518
layer->Preroll(preroll_context());
518-
EXPECT_NE(layer->raster_cache_item(), nullptr);
519519
LayerTree::TryToRasterCache(cacheable_items(), &paint_context());
520520

521521
EXPECT_EQ(raster_cache()->GetLayerCachedEntriesCount(), (size_t)0);
522-
EXPECT_EQ(layer->raster_cache_item()->cache_state(),
523-
RasterCacheItem::CacheState::kNone);
522+
EXPECT_EQ(clip_cache_item->cache_state(), RasterCacheItem::CacheState::kNone);
524523

525524
layer->Preroll(preroll_context());
526525
LayerTree::TryToRasterCache(cacheable_items(), &paint_context());
527526
EXPECT_EQ(raster_cache()->GetLayerCachedEntriesCount(), (size_t)0);
528-
EXPECT_EQ(layer->raster_cache_item()->cache_state(),
529-
RasterCacheItem::CacheState::kNone);
527+
EXPECT_EQ(clip_cache_item->cache_state(), RasterCacheItem::CacheState::kNone);
530528

531529
layer->Preroll(preroll_context());
532530
LayerTree::TryToRasterCache(cacheable_items(), &paint_context());
533531
EXPECT_EQ(raster_cache()->GetLayerCachedEntriesCount(), (size_t)1);
534-
EXPECT_EQ(layer->raster_cache_item()->cache_state(),
532+
EXPECT_EQ(clip_cache_item->cache_state(),
535533
RasterCacheItem::CacheState::kCurrent);
536-
EXPECT_TRUE(raster_cache()->Draw(layer->raster_cache_item()->GetId().value(),
534+
EXPECT_TRUE(raster_cache()->Draw(clip_cache_item->GetId().value(),
537535
cache_canvas, &paint));
538536
}
539537

540-
TEST_F(ClipRRectLayerTest, NullRasterCacheResetsRasterCacheItem) {
541-
auto path1 = SkPath().addRect({10, 10, 30, 30});
542-
DlPaint paint = DlPaint();
543-
auto mock1 = MockLayer::MakeOpacityCompatible(path1);
544-
SkRect clip_rect = SkRect::MakeWH(500, 500);
545-
SkRRect clip_rrect = SkRRect::MakeRectXY(clip_rect, 20, 20);
546-
auto layer = std::make_shared<ClipRRectLayer>(clip_rrect,
547-
Clip::antiAliasWithSaveLayer);
548-
layer->Add(mock1);
549-
550-
ASSERT_EQ(layer->raster_cache_item(), nullptr);
551-
552-
layer->Preroll(preroll_context());
553-
ASSERT_EQ(layer->raster_cache_item(), nullptr);
554-
555-
use_mock_raster_cache();
556-
557-
int limit = RasterCacheUtil::kMinimumRendersBeforeCachingFilterLayer;
558-
for (int i = 1; i < limit; i++) {
559-
layer->Preroll(preroll_context());
560-
ASSERT_NE(layer->raster_cache_item(), nullptr);
561-
ASSERT_EQ(layer->raster_cache_item()->cache_state(),
562-
RasterCacheItem::kNone);
563-
ASSERT_FALSE(
564-
layer->raster_cache_item()->TryToPrepareRasterCache(paint_context()));
565-
}
566-
567-
layer->Preroll(preroll_context());
568-
ASSERT_NE(layer->raster_cache_item(), nullptr);
569-
ASSERT_EQ(layer->raster_cache_item()->cache_state(),
570-
RasterCacheItem::kCurrent);
571-
ASSERT_TRUE(
572-
layer->raster_cache_item()->TryToPrepareRasterCache(paint_context()));
573-
574-
use_null_raster_cache();
575-
576-
layer->Preroll(preroll_context());
577-
ASSERT_NE(layer->raster_cache_item(), nullptr);
578-
ASSERT_EQ(layer->raster_cache_item()->cache_state(), RasterCacheItem::kNone);
579-
}
580-
581538
TEST_F(ClipRRectLayerTest, NoSaveLayerShouldNotCache) {
582539
auto path1 = SkPath().addRect({10, 10, 30, 30});
583540

@@ -594,23 +551,24 @@ TEST_F(ClipRRectLayerTest, NoSaveLayerShouldNotCache) {
594551

595552
use_mock_raster_cache();
596553
preroll_context()->state_stack.set_preroll_delegate(initial_transform);
597-
EXPECT_EQ(layer->raster_cache_item(), nullptr);
554+
555+
const auto* clip_cache_item = layer->raster_cache_item();
598556

599557
layer->Preroll(preroll_context());
600558
LayerTree::TryToRasterCache(cacheable_items(), &paint_context());
601559

602560
EXPECT_EQ(raster_cache()->GetLayerCachedEntriesCount(), (size_t)0);
603-
EXPECT_EQ(layer->raster_cache_item(), nullptr);
561+
EXPECT_EQ(clip_cache_item->cache_state(), RasterCacheItem::CacheState::kNone);
604562

605563
layer->Preroll(preroll_context());
606564
LayerTree::TryToRasterCache(cacheable_items(), &paint_context());
607565
EXPECT_EQ(raster_cache()->GetLayerCachedEntriesCount(), (size_t)0);
608-
EXPECT_EQ(layer->raster_cache_item(), nullptr);
566+
EXPECT_EQ(clip_cache_item->cache_state(), RasterCacheItem::CacheState::kNone);
609567

610568
layer->Preroll(preroll_context());
611569
LayerTree::TryToRasterCache(cacheable_items(), &paint_context());
612570
EXPECT_EQ(raster_cache()->GetLayerCachedEntriesCount(), (size_t)0);
613-
EXPECT_EQ(layer->raster_cache_item(), nullptr);
571+
EXPECT_EQ(clip_cache_item->cache_state(), RasterCacheItem::CacheState::kNone);
614572
}
615573

616574
TEST_F(ClipRRectLayerTest, EmptyClipDoesNotCullPlatformView) {

0 commit comments

Comments
 (0)