Let PaintController build PaintArtifact

This prepares for unified PaintController for pre-CompositeAfterPaint
and CompositeAfterPaint. Unified PaintController needs to create
PaintChunkSubset for the painting of a pre-composited layer
(GraphicsLayer) which needs to hold a reference to the PaintArtifact.

Bug: 1132717
Change-Id: I9ec46fdda2eb6ad1d755f2d9f20a0d081db26973
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2447121
Commit-Queue: Xianzhu Wang <wangxianzhu@chromium.org>
Reviewed-by: Philip Rogers <pdr@chromium.org>
Cr-Commit-Position: refs/heads/master@{#814501}

third_party/blink/renderer/platform/graphics/compositing/paint_chunks_to_cc_layer_test.cc

@@ -179,10 +179,13 @@ class TestChunks {
       const EffectPaintPropertyNodeOrAlias& e,
       const IntRect& bounds = IntRect(0, 0, 100, 100),
       const base::Optional<IntRect>& drawable_bounds = base::nullopt) {
+    auto& items = paint_artifact_->GetDisplayItemList();
     auto i = items.size();
     items.AllocateAndConstruct<DrawingDisplayItem>(
         DefaultId().client, DefaultId().type,
         drawable_bounds ? *drawable_bounds : bounds, std::move(record));
+
+    auto& chunks = paint_artifact_->PaintChunks();
     chunks.emplace_back(i, i + 1, DefaultId(),
                         PropertyTreeStateOrAlias(t, c, e));
     chunks.back().bounds = bounds;
@@ -193,19 +196,19 @@ class TestChunks {
                      const ClipPaintPropertyNode& c,
                      const EffectPaintPropertyNode& e,
                      const IntRect& bounds = IntRect(0, 0, 100, 100)) {
-    auto i = items.size();
+    auto& chunks = paint_artifact_->PaintChunks();
+    auto i = paint_artifact_->GetDisplayItemList().size();
     chunks.emplace_back(i, i, DefaultId(), PropertyTreeState(t, c, e));
     chunks.back().bounds = bounds;
   }
 
   PaintChunkSubset Build() {
-    return PaintChunkSubset(base::MakeRefCounted<PaintArtifact>(
-        std::move(items), std::move(chunks)));
+    return PaintChunkSubset(std::move(paint_artifact_));
   }
 
  private:
-  Vector<PaintChunk> chunks;
-  DisplayItemList items;
+  scoped_refptr<PaintArtifact> paint_artifact_ =
+      base::MakeRefCounted<PaintArtifact>();
 };
 
 TEST_P(PaintChunksToCcLayerTest, EffectGroupingSimple) {

third_party/blink/renderer/platform/graphics/paint/drawing_recorder.cc

@@ -12,12 +12,6 @@
 
 namespace blink {
 
-#if DCHECK_IS_ON()
-static bool g_list_modification_check_disabled = false;
-DisableListModificationCheck::DisableListModificationCheck()
-    : disabler_(&g_list_modification_check_disabled, true) {}
-#endif
-
 DrawingRecorder::DrawingRecorder(GraphicsContext& context,
                                  const DisplayItemClient& display_item_client,
                                  DisplayItem::Type display_item_type,
@@ -44,11 +38,6 @@ DrawingRecorder::DrawingRecorder(GraphicsContext& context,
       context.SetDOMNodeId(dom_node_id);
     }
   }
-
-#if DCHECK_IS_ON()
-  initial_display_item_list_size_ =
-      context_.GetPaintController().NewDisplayItemList().size();
-#endif
 }
 
 DrawingRecorder::~DrawingRecorder() {
@@ -57,13 +46,6 @@ DrawingRecorder::~DrawingRecorder() {
 
   context_.SetInDrawingRecorder(false);
 
-#if DCHECK_IS_ON()
-  if (!g_list_modification_check_disabled) {
-    DCHECK(initial_display_item_list_size_ ==
-           context_.GetPaintController().NewDisplayItemList().size());
-  }
-#endif
-
   context_.GetPaintController().CreateAndAppend<DrawingDisplayItem>(
       client_, type_, visual_rect_, context_.EndRecording());
 }

third_party/blink/renderer/platform/graphics/paint/drawing_recorder.h

@@ -84,11 +84,6 @@ class PLATFORM_EXPORT DrawingRecorder {
   IntRect visual_rect_;
   base::Optional<DOMNodeId> dom_node_id_to_restore_;
 
-#if DCHECK_IS_ON()
-  // Ensures the list size does not change during the recorder's scope.
-  wtf_size_t initial_display_item_list_size_;
-#endif
-
   DISALLOW_COPY_AND_ASSIGN(DrawingRecorder);
 };
 

third_party/blink/renderer/platform/graphics/paint/paint_artifact.cc

@@ -14,13 +14,6 @@
 
 namespace blink {
 
-PaintArtifact::PaintArtifact(DisplayItemList display_items,
-                             Vector<PaintChunk> chunks)
-    : display_item_list_(std::move(display_items)), chunks_(std::move(chunks)) {
-}
-
-PaintArtifact::~PaintArtifact() = default;
-
 size_t PaintArtifact::ApproximateUnsharedMemoryUsage() const {
   size_t total_size = sizeof(*this) + display_item_list_.MemoryUsageInBytes() +
                       chunks_.capacity() * sizeof(chunks_[0]);

third_party/blink/renderer/platform/graphics/paint/paint_artifact.h

@@ -34,9 +34,9 @@ class PLATFORM_EXPORT PaintArtifact final : public RefCounted<PaintArtifact> {
   USING_FAST_MALLOC(PaintArtifact);
 
  public:
-  PaintArtifact() = default;
-  PaintArtifact(DisplayItemList, Vector<PaintChunk>);
-  ~PaintArtifact();
+  explicit PaintArtifact(
+      wtf_size_t initial_display_item_list_capacity_in_bytes = 0)
+      : display_item_list_(initial_display_item_list_capacity_in_bytes) {}
 
   PaintArtifact(const PaintArtifact& other) = delete;
   PaintArtifact& operator=(const PaintArtifact& other) = delete;

third_party/blink/renderer/platform/graphics/paint/paint_chunker.cc

@@ -8,11 +8,18 @@
 
 namespace blink {
 
-PaintChunker::PaintChunker()
-    : current_properties_(PropertyTreeState::Uninitialized()),
-      force_new_chunk_(true) {}
-
-PaintChunker::~PaintChunker() = default;
+void PaintChunker::ResetChunks(Vector<PaintChunk>* chunks) {
+  if (chunks_) {
+    FinalizeLastChunkProperties();
+    SetWillForceNewChunk(true);
+    current_properties_ = PropertyTreeState::Uninitialized();
+  }
+  chunks_ = chunks;
+#if DCHECK_IS_ON()
+  DCHECK(!chunks || chunks->IsEmpty());
+  DCHECK(IsInInitialState());
+#endif
+}
 
 #if DCHECK_IS_ON()
 bool PaintChunker::IsInInitialState() const {
@@ -20,7 +27,8 @@ bool PaintChunker::IsInInitialState() const {
     return false;
   DCHECK_EQ(candidate_background_color_.Rgb(), Color::kTransparent);
   DCHECK_EQ(candidate_background_area_, 0u);
-  DCHECK(chunks_.IsEmpty());
+  DCHECK(will_force_new_chunk_);
+  DCHECK(!chunks_ || chunks_->IsEmpty());
   return true;
 }
 #endif
@@ -41,14 +49,16 @@ void PaintChunker::UpdateCurrentPaintChunkProperties(
 }
 
 void PaintChunker::AppendByMoving(PaintChunk&& chunk) {
+  DCHECK(chunks_);
   FinalizeLastChunkProperties();
   wtf_size_t next_chunk_begin_index =
-      chunks_.IsEmpty() ? 0 : LastChunk().end_index;
-  chunks_.emplace_back(next_chunk_begin_index, std::move(chunk));
+      chunks_->IsEmpty() ? 0 : chunks_->back().end_index;
+  chunks_->emplace_back(next_chunk_begin_index, std::move(chunk));
 }
 
-PaintChunk& PaintChunker::EnsureCurrentChunk(const PaintChunk::Id& id) {
+bool PaintChunker::EnsureCurrentChunk(const PaintChunk::Id& id) {
 #if DCHECK_IS_ON()
+  DCHECK(chunks_);
   // If this DCHECKs are hit we are missing a call to update the properties.
   // See: ScopedPaintChunkProperties.
   DCHECK(!IsInInitialState());
@@ -56,28 +66,31 @@ PaintChunk& PaintChunker::EnsureCurrentChunk(const PaintChunk::Id& id) {
   DCHECK(current_properties_.IsInitialized());
 #endif
 
-  if (WillForceNewChunk() || current_properties_ != LastChunk().properties) {
+  if (WillForceNewChunk() ||
+      current_properties_ != chunks_->back().properties) {
     if (!next_chunk_id_)
       next_chunk_id_.emplace(id);
     FinalizeLastChunkProperties();
-    wtf_size_t begin = chunks_.IsEmpty() ? 0 : LastChunk().end_index;
-    chunks_.emplace_back(begin, begin, *next_chunk_id_, current_properties_);
+    wtf_size_t begin = chunks_->IsEmpty() ? 0 : chunks_->back().end_index;
+    chunks_->emplace_back(begin, begin, *next_chunk_id_, current_properties_);
     next_chunk_id_ = base::nullopt;
-    force_new_chunk_ = false;
+    will_force_new_chunk_ = false;
+    return true;
   }
-  return LastChunk();
+  return false;
 }
 
 bool PaintChunker::IncrementDisplayItemIndex(const DisplayItem& item) {
+  DCHECK(chunks_);
+
   bool item_forces_new_chunk = item.IsForeignLayer() ||
                                item.IsGraphicsLayerWrapper() ||
                                item.IsScrollbar();
   if (item_forces_new_chunk)
-    SetForceNewChunk(true);
+    SetWillForceNewChunk(true);
 
-  auto previous_size = size();
-  auto& chunk = EnsureCurrentChunk(item.GetId());
-  bool created_new_chunk = size() > previous_size;
+  bool created_new_chunk = EnsureCurrentChunk(item.GetId());
+  auto& chunk = chunks_->back();
 
   chunk.bounds.Unite(item.VisualRect());
   if (item.DrawsContent())
@@ -105,16 +118,16 @@ bool PaintChunker::IncrementDisplayItemIndex(const DisplayItem& item) {
 
   // When forcing a new chunk, we still need to force new chunk for the next
   // display item. Otherwise reset force_new_chunk_ to false.
-  DCHECK(!force_new_chunk_);
+  DCHECK(!will_force_new_chunk_);
   if (item_forces_new_chunk) {
     DCHECK(created_new_chunk);
-    SetForceNewChunk(true);
+    SetWillForceNewChunk(true);
   }
 
   return created_new_chunk;
 }
 
-void PaintChunker::AddHitTestDataToCurrentChunk(const PaintChunk::Id& id,
+bool PaintChunker::AddHitTestDataToCurrentChunk(const PaintChunk::Id& id,
                                                 const IntRect& rect,
                                                 TouchAction touch_action) {
   // In CompositeAfterPaint, we ensure a paint chunk for correct composited
@@ -124,14 +137,16 @@ void PaintChunker::AddHitTestDataToCurrentChunk(const PaintChunk::Id& id,
   if (!RuntimeEnabledFeatures::CompositeAfterPaintEnabled() &&
       touch_action == TouchAction::kAuto &&
       &current_properties_.Effect() == &EffectPaintPropertyNode::Root())
-    return;
+    return false;
 
-  auto& chunk = EnsureCurrentChunk(id);
+  bool created_new_chunk = EnsureCurrentChunk(id);
+  auto& chunk = chunks_->back();
   chunk.bounds.Unite(rect);
   if (touch_action != TouchAction::kAuto) {
     chunk.EnsureHitTestData().touch_action_rects.push_back(
         TouchActionRect{rect, touch_action});
   }
+  return created_new_chunk;
 }
 
 void PaintChunker::CreateScrollHitTestChunk(
@@ -154,50 +169,47 @@ void PaintChunker::CreateScrollHitTestChunk(
   }
 #endif
 
-  SetForceNewChunk(true);
-  auto& chunk = EnsureCurrentChunk(id);
+  SetWillForceNewChunk(true);
+  bool created_new_chunk = EnsureCurrentChunk(id);
+  DCHECK(created_new_chunk);
+
+  auto& chunk = chunks_->back();
   chunk.bounds.Unite(rect);
   auto& hit_test_data = chunk.EnsureHitTestData();
   hit_test_data.scroll_translation = scroll_translation;
   hit_test_data.scroll_hit_test_rect = rect;
-  SetForceNewChunk(true);
+  SetWillForceNewChunk(true);
 }
 
-void PaintChunker::ProcessBackgroundColorCandidate(const PaintChunk::Id& id,
+bool PaintChunker::ProcessBackgroundColorCandidate(const PaintChunk::Id& id,
                                                    Color color,
                                                    uint64_t area) {
-  EnsureCurrentChunk(id);
+  bool created_new_chunk = EnsureCurrentChunk(id);
   if (color != Color::kTransparent &&
       (candidate_background_color_ == Color::kTransparent ||
        (area >= candidate_background_area_))) {
     candidate_background_color_ = color;
     candidate_background_area_ = area;
   }
+  return created_new_chunk;
 }
 
 void PaintChunker::FinalizeLastChunkProperties() {
-  if (chunks_.IsEmpty() || LastChunk().is_moved_from_cached_subsequence)
+  DCHECK(chunks_);
+  if (chunks_->IsEmpty() || chunks_->back().is_moved_from_cached_subsequence)
     return;
 
-  LastChunk().known_to_be_opaque =
-      last_chunk_known_to_be_opaque_region_.Contains(LastChunk().bounds);
+  auto& chunk = chunks_->back();
+  chunk.known_to_be_opaque =
+      last_chunk_known_to_be_opaque_region_.Contains(chunk.bounds);
   last_chunk_known_to_be_opaque_region_ = Region();
 
   if (candidate_background_color_ != Color::kTransparent) {
-    LastChunk().background_color = candidate_background_color_;
-    LastChunk().background_color_area = candidate_background_area_;
+    chunk.background_color = candidate_background_color_;
+    chunk.background_color_area = candidate_background_area_;
   }
   candidate_background_color_ = Color::kTransparent;
   candidate_background_area_ = 0u;
 }
 
-Vector<PaintChunk> PaintChunker::ReleasePaintChunks() {
-  FinalizeLastChunkProperties();
-  next_chunk_id_ = base::nullopt;
-  current_properties_ = PropertyTreeState::Uninitialized();
-  chunks_.ShrinkToFit();
-  force_new_chunk_ = true;
-  return std::move(chunks_);
-}
-
 }  // namespace blink

third_party/blink/renderer/platform/graphics/paint/paint_chunker.h

@@ -25,8 +25,11 @@ class PLATFORM_EXPORT PaintChunker final {
   DISALLOW_NEW();
 
  public:
-  PaintChunker();
-  ~PaintChunker();
+  explicit PaintChunker(Vector<PaintChunk>& chunks) { ResetChunks(&chunks); }
+
+  // Finishes current chunks if any, and makes it ready to create chunks into
+  // the given vector if not null.
+  void ResetChunks(Vector<PaintChunk>*);
 
 #if DCHECK_IS_ON()
   bool IsInInitialState() const;
@@ -43,28 +46,20 @@ class PLATFORM_EXPORT PaintChunker final {
   // display item and then automatically resets the status. Some special display
   // item (e.g. ForeignLayerDisplayItem) also automatically sets the status on
   // before and after the item to force a dedicated paint chunk.
-  void SetForceNewChunk(bool force) {
-    force_new_chunk_ = force;
+  void SetWillForceNewChunk(bool force) {
+    will_force_new_chunk_ = force;
     next_chunk_id_ = base::nullopt;
   }
-  bool WillForceNewChunk() const {
-    return force_new_chunk_ || chunks_.IsEmpty();
-  }
+  bool WillForceNewChunk() const { return will_force_new_chunk_; }
 
   void AppendByMoving(PaintChunk&&);
 
   // Returns true if a new chunk is created.
   bool IncrementDisplayItemIndex(const DisplayItem&);
 
-  const Vector<PaintChunk>& PaintChunks() const { return chunks_; }
-  wtf_size_t size() const { return chunks_.size(); }
-
-  PaintChunk& LastChunk() { return chunks_.back(); }
-  const PaintChunk& LastChunk() const { return chunks_.back(); }
-
   // The id will be used when we need to create a new current chunk.
-  // Otherwise it's ignored.
-  void AddHitTestDataToCurrentChunk(const PaintChunk::Id&,
+  // Otherwise it's ignored. Returns true if a new chunk is added.
+  bool AddHitTestDataToCurrentChunk(const PaintChunk::Id&,
                                     const IntRect&,
                                     TouchAction);
   void CreateScrollHitTestChunk(
@@ -72,20 +67,21 @@ class PLATFORM_EXPORT PaintChunker final {
       const TransformPaintPropertyNode* scroll_translation,
       const IntRect&);
 
-  void ProcessBackgroundColorCandidate(const PaintChunk::Id& id,
+  // Returns true if a new chunk is created.
+  bool ProcessBackgroundColorCandidate(const PaintChunk::Id& id,
                                        Color color,
                                        uint64_t area);
-  void EnsureChunk() { EnsureCurrentChunk(*next_chunk_id_); }
 
-  // Releases the generated paint chunk list and raster invalidations and
-  // resets the state of this object.
-  Vector<PaintChunk> ReleasePaintChunks();
+  // Returns true if a new chunk is created.
+  bool EnsureChunk() { return EnsureCurrentChunk(*next_chunk_id_); }
 
  private:
-  PaintChunk& EnsureCurrentChunk(const PaintChunk::Id&);
+  // Returns true if a new chunk is created.
+  bool EnsureCurrentChunk(const PaintChunk::Id&);
+
   void FinalizeLastChunkProperties();
 
-  Vector<PaintChunk> chunks_;
+  Vector<PaintChunk>* chunks_ = nullptr;
 
   // The id specified by UpdateCurrentPaintChunkProperties(). If it is not
   // nullopt, we will use it as the id of the next new chunk. Otherwise we will
@@ -95,14 +91,15 @@ class PLATFORM_EXPORT PaintChunker final {
   // forced to create a new chunk).
   base::Optional<PaintChunk::Id> next_chunk_id_;
 
-  PropertyTreeStateOrAlias current_properties_;
+  PropertyTreeStateOrAlias current_properties_ =
+      PropertyTreeState::Uninitialized();
 
   Region last_chunk_known_to_be_opaque_region_;
 
   // True when an item forces a new chunk (e.g., foreign display items), and for
   // the item following a forced chunk. PaintController also forces new chunks
   // before and after subsequences by calling ForceNewChunk().
-  bool force_new_chunk_;
+  bool will_force_new_chunk_ = true;
 
   Color candidate_background_color_ = Color::kTransparent;
   uint64_t candidate_background_area_ = 0;

third_party/blink/renderer/platform/graphics/paint/paint_chunker_test.cc

@@ -62,32 +62,35 @@ class TestDisplayItemRequiringSeparateChunk : public ForeignLayerDisplayItem {
 };
 
 TEST_F(PaintChunkerTest, Empty) {
-  PaintChunker chunker;
-  EXPECT_TRUE(chunker.PaintChunks().IsEmpty());
+  Vector<PaintChunk> chunks;
+  PaintChunker chunker(chunks);
+  EXPECT_TRUE(chunks.IsEmpty());
 
-  auto chunks = chunker.ReleasePaintChunks();
+  chunker.ResetChunks(&chunks);
   EXPECT_TRUE(chunks.IsEmpty());
 }
 
 TEST_F(PaintChunkerTest, SingleNonEmptyRange) {
-  PaintChunker chunker;
+  Vector<PaintChunk> chunks;
+  PaintChunker chunker(chunks);
   PaintChunk::Id id(client_, DisplayItemType(1));
   chunker.UpdateCurrentPaintChunkProperties(&id, DefaultPaintChunkProperties());
   chunker.IncrementDisplayItemIndex(TestChunkerDisplayItem(client_));
   chunker.IncrementDisplayItemIndex(TestChunkerDisplayItem(client_));
 
-  const auto& chunks = chunker.PaintChunks();
   EXPECT_THAT(chunks, ElementsAre(IsPaintChunk(0, 2, id,
                                                DefaultPaintChunkProperties())));
 
-  auto chunks1 = chunker.ReleasePaintChunks();
-  EXPECT_TRUE(chunker.PaintChunks().IsEmpty());
-  EXPECT_THAT(chunks1, ElementsAre(IsPaintChunk(
-                           0, 2, id, DefaultPaintChunkProperties())));
+  Vector<PaintChunk> chunks1;
+  chunker.ResetChunks(&chunks1);
+  EXPECT_THAT(chunks, ElementsAre(IsPaintChunk(0, 2, id,
+                                               DefaultPaintChunkProperties())));
+  EXPECT_TRUE(chunks1.IsEmpty());
 }
 
 TEST_F(PaintChunkerTest, SamePropertiesTwiceCombineIntoOneChunk) {
-  PaintChunker chunker;
+  Vector<PaintChunk> chunks;
+  PaintChunker chunker(chunks);
   PaintChunk::Id id(client_, DisplayItemType(1));
   chunker.UpdateCurrentPaintChunkProperties(&id, DefaultPaintChunkProperties());
   chunker.IncrementDisplayItemIndex(TestChunkerDisplayItem(client_));
@@ -95,18 +98,19 @@ TEST_F(PaintChunkerTest, SamePropertiesTwiceCombineIntoOneChunk) {
   chunker.UpdateCurrentPaintChunkProperties(&id, DefaultPaintChunkProperties());
   chunker.IncrementDisplayItemIndex(TestChunkerDisplayItem(client_));
 
-  const auto& chunks = chunker.PaintChunks();
   EXPECT_THAT(chunks, ElementsAre(IsPaintChunk(0, 3, id,
                                                DefaultPaintChunkProperties())));
 
-  auto chunks1 = chunker.ReleasePaintChunks();
-  EXPECT_TRUE(chunker.PaintChunks().IsEmpty());
-  EXPECT_THAT(chunks1, ElementsAre(IsPaintChunk(
-                           0, 3, id, DefaultPaintChunkProperties())));
+  Vector<PaintChunk> chunks1;
+  chunker.ResetChunks(&chunks1);
+  EXPECT_THAT(chunks, ElementsAre(IsPaintChunk(0, 3, id,
+                                               DefaultPaintChunkProperties())));
+  EXPECT_TRUE(chunks1.IsEmpty());
 }
 
 TEST_F(PaintChunkerTest, BuildMultipleChunksWithSinglePropertyChanging) {
-  PaintChunker chunker;
+  Vector<PaintChunk> chunks;
+  PaintChunker chunker(chunks);
   PaintChunk::Id id1(client_, DisplayItemType(1));
   chunker.UpdateCurrentPaintChunkProperties(&id1,
                                             DefaultPaintChunkProperties());
@@ -130,15 +134,15 @@ TEST_F(PaintChunkerTest, BuildMultipleChunksWithSinglePropertyChanging) {
   chunker.UpdateCurrentPaintChunkProperties(&id3, another_transform);
   chunker.IncrementDisplayItemIndex(TestChunkerDisplayItem(client_));
 
-  EXPECT_THAT(
-      chunker.PaintChunks(),
-      ElementsAre(IsPaintChunk(0, 2, id1, DefaultPaintChunkProperties()),
-                  IsPaintChunk(2, 3, id2, simple_transform),
-                  IsPaintChunk(3, 4, id3, another_transform)));
+  EXPECT_THAT(chunks, ElementsAre(IsPaintChunk(0, 2, id1,
+                                               DefaultPaintChunkProperties()),
+                                  IsPaintChunk(2, 3, id2, simple_transform),
+                                  IsPaintChunk(3, 4, id3, another_transform)));
 }
 
 TEST_F(PaintChunkerTest, BuildMultipleChunksWithDifferentPropertyChanges) {
-  PaintChunker chunker;
+  Vector<PaintChunk> chunks;
+  PaintChunker chunker(chunks);
   PaintChunk::Id id1(client_, DisplayItemType(1));
   chunker.UpdateCurrentPaintChunkProperties(&id1,
                                             DefaultPaintChunkProperties());
@@ -186,7 +190,7 @@ TEST_F(PaintChunkerTest, BuildMultipleChunksWithDifferentPropertyChanges) {
   chunker.IncrementDisplayItemIndex(TestChunkerDisplayItem(client_));
 
   EXPECT_THAT(
-      chunker.PaintChunks(),
+      chunks,
       ElementsAre(
           IsPaintChunk(0, 1, id1, DefaultPaintChunkProperties()),
           IsPaintChunk(1, 3, id2, simple_transform),
@@ -207,7 +211,8 @@ TEST_F(PaintChunkerTest, BuildChunksFromNestedTransforms) {
   //   </a xform>
   //   <paint>
   // </root xform>
-  PaintChunker chunker;
+  Vector<PaintChunk> chunks;
+  PaintChunker chunker(chunks);
   PaintChunk::Id id1(client_, DisplayItemType(1));
   chunker.UpdateCurrentPaintChunkProperties(&id1,
                                             DefaultPaintChunkProperties());
@@ -227,17 +232,17 @@ TEST_F(PaintChunkerTest, BuildChunksFromNestedTransforms) {
   TestChunkerDisplayItem item_after_restore(client_, DisplayItemType(10));
   chunker.IncrementDisplayItemIndex(item_after_restore);
 
-  EXPECT_THAT(
-      chunker.PaintChunks(),
-      ElementsAre(IsPaintChunk(0, 1, id1, DefaultPaintChunkProperties()),
-                  IsPaintChunk(1, 3, id2, simple_transform),
-                  IsPaintChunk(3, 4, item_after_restore.GetId(),
-                               DefaultPaintChunkProperties())));
+  EXPECT_THAT(chunks, ElementsAre(IsPaintChunk(0, 1, id1,
+                                               DefaultPaintChunkProperties()),
+                                  IsPaintChunk(1, 3, id2, simple_transform),
+                                  IsPaintChunk(3, 4, item_after_restore.GetId(),
+                                               DefaultPaintChunkProperties())));
 }
 
 TEST_F(PaintChunkerTest, ChangingPropertiesWithoutItems) {
   // Test that properties can change without display items being generated.
-  PaintChunker chunker;
+  Vector<PaintChunk> chunks;
+  PaintChunker chunker(chunks);
   PaintChunk::Id id1(client_, DisplayItemType(1));
   chunker.UpdateCurrentPaintChunkProperties(&id1,
                                             DefaultPaintChunkProperties());
@@ -258,16 +263,16 @@ TEST_F(PaintChunkerTest, ChangingPropertiesWithoutItems) {
   chunker.UpdateCurrentPaintChunkProperties(&id3, second_transform);
 
   chunker.IncrementDisplayItemIndex(TestChunkerDisplayItem(client_));
-  EXPECT_THAT(
-      chunker.PaintChunks(),
-      ElementsAre(IsPaintChunk(0, 1, id1, DefaultPaintChunkProperties()),
-                  IsPaintChunk(1, 2, id3, second_transform)));
+  EXPECT_THAT(chunks, ElementsAre(IsPaintChunk(0, 1, id1,
+                                               DefaultPaintChunkProperties()),
+                                  IsPaintChunk(1, 2, id3, second_transform)));
 }
 
 TEST_F(PaintChunkerTest, CreatesSeparateChunksWhenRequested) {
   // Tests that the chunker creates a separate chunks for display items which
   // require it.
-  PaintChunker chunker;
+  Vector<PaintChunk> chunks;
+  PaintChunker chunker(chunks);
   FakeDisplayItemClient client1;
   TestDisplayItemRequiringSeparateChunk i1(client1);
   FakeDisplayItemClient client2;
@@ -289,7 +294,7 @@ TEST_F(PaintChunkerTest, CreatesSeparateChunksWhenRequested) {
   chunker.IncrementDisplayItemIndex(i3);
 
   EXPECT_THAT(
-      chunker.PaintChunks(),
+      chunks,
       ElementsAre(
           IsPaintChunk(0, 1, id0, DefaultPaintChunkProperties()),
           IsPaintChunk(1, 2, i1.GetId(), DefaultPaintChunkProperties()),
@@ -299,118 +304,121 @@ TEST_F(PaintChunkerTest, CreatesSeparateChunksWhenRequested) {
 }
 
 TEST_F(PaintChunkerTest, ForceNewChunkWithNewId) {
-  PaintChunker chunker;
+  Vector<PaintChunk> chunks;
+  PaintChunker chunker(chunks);
   PaintChunk::Id id0(client_, DisplayItemType(0));
   chunker.UpdateCurrentPaintChunkProperties(&id0,
                                             DefaultPaintChunkProperties());
   EXPECT_TRUE(chunker.WillForceNewChunk());
-  EXPECT_EQ(0u, chunker.size());
+  EXPECT_EQ(0u, chunks.size());
   chunker.IncrementDisplayItemIndex(TestChunkerDisplayItem(client_));
   EXPECT_FALSE(chunker.WillForceNewChunk());
   chunker.IncrementDisplayItemIndex(TestChunkerDisplayItem(client_));
-  EXPECT_EQ(1u, chunker.size());
+  EXPECT_EQ(1u, chunks.size());
 
-  chunker.SetForceNewChunk(true);
+  chunker.SetWillForceNewChunk(true);
   EXPECT_TRUE(chunker.WillForceNewChunk());
-  EXPECT_EQ(1u, chunker.size());
+  EXPECT_EQ(1u, chunks.size());
   PaintChunk::Id id1(client_, DisplayItemType(1));
   chunker.UpdateCurrentPaintChunkProperties(&id1,
                                             DefaultPaintChunkProperties());
   chunker.IncrementDisplayItemIndex(TestChunkerDisplayItem(client_));
-  EXPECT_EQ(2u, chunker.size());
+  EXPECT_EQ(2u, chunks.size());
   EXPECT_FALSE(chunker.WillForceNewChunk());
   chunker.IncrementDisplayItemIndex(TestChunkerDisplayItem(client_));
-  EXPECT_EQ(2u, chunker.size());
+  EXPECT_EQ(2u, chunks.size());
 
-  chunker.SetForceNewChunk(true);
+  chunker.SetWillForceNewChunk(true);
   PaintChunk::Id id2(client_, DisplayItemType(2));
   EXPECT_TRUE(chunker.WillForceNewChunk());
   chunker.UpdateCurrentPaintChunkProperties(&id2,
                                             DefaultPaintChunkProperties());
-  EXPECT_EQ(2u, chunker.size());
+  EXPECT_EQ(2u, chunks.size());
   chunker.IncrementDisplayItemIndex(TestChunkerDisplayItem(client_));
-  EXPECT_EQ(3u, chunker.size());
+  EXPECT_EQ(3u, chunks.size());
   EXPECT_FALSE(chunker.WillForceNewChunk());
   chunker.IncrementDisplayItemIndex(TestChunkerDisplayItem(client_));
 
   EXPECT_THAT(
-      chunker.PaintChunks(),
+      chunks,
       ElementsAre(IsPaintChunk(0, 2, id0, DefaultPaintChunkProperties()),
                   IsPaintChunk(2, 4, id1, DefaultPaintChunkProperties()),
                   IsPaintChunk(4, 6, id2, DefaultPaintChunkProperties())));
 }
 
 TEST_F(PaintChunkerTest, ForceNewChunkWithoutNewId) {
-  PaintChunker chunker;
+  Vector<PaintChunk> chunks;
+  PaintChunker chunker(chunks);
   PaintChunk::Id id0(client_, DisplayItemType(0));
   chunker.UpdateCurrentPaintChunkProperties(nullptr,
                                             DefaultPaintChunkProperties());
   EXPECT_TRUE(chunker.WillForceNewChunk());
-  EXPECT_EQ(0u, chunker.size());
+  EXPECT_EQ(0u, chunks.size());
   chunker.IncrementDisplayItemIndex(
       TestChunkerDisplayItem(id0.client, id0.type));
   EXPECT_FALSE(chunker.WillForceNewChunk());
-  EXPECT_EQ(1u, chunker.size());
+  EXPECT_EQ(1u, chunks.size());
   chunker.IncrementDisplayItemIndex(TestChunkerDisplayItem(client_));
 
-  chunker.SetForceNewChunk(true);
+  chunker.SetWillForceNewChunk(true);
   EXPECT_TRUE(chunker.WillForceNewChunk());
-  EXPECT_EQ(1u, chunker.size());
+  EXPECT_EQ(1u, chunks.size());
   PaintChunk::Id id1(client_, DisplayItemType(1));
   chunker.IncrementDisplayItemIndex(
       TestChunkerDisplayItem(id1.client, id1.type));
   EXPECT_FALSE(chunker.WillForceNewChunk());
-  EXPECT_EQ(2u, chunker.size());
+  EXPECT_EQ(2u, chunks.size());
   chunker.IncrementDisplayItemIndex(
       TestChunkerDisplayItem(client_, DisplayItemType(2)));
 
-  chunker.SetForceNewChunk(true);
+  chunker.SetWillForceNewChunk(true);
   EXPECT_TRUE(chunker.WillForceNewChunk());
-  EXPECT_EQ(2u, chunker.size());
+  EXPECT_EQ(2u, chunks.size());
   PaintChunk::Id id2(client_, DisplayItemType(3));
   chunker.IncrementDisplayItemIndex(
       TestChunkerDisplayItem(id2.client, id2.type));
   EXPECT_FALSE(chunker.WillForceNewChunk());
-  EXPECT_EQ(3u, chunker.size());
+  EXPECT_EQ(3u, chunks.size());
   chunker.IncrementDisplayItemIndex(
       TestChunkerDisplayItem(client_, DisplayItemType(4)));
 
   EXPECT_THAT(
-      chunker.PaintChunks(),
+      chunks,
       ElementsAre(IsPaintChunk(0, 2, id0, DefaultPaintChunkProperties()),
                   IsPaintChunk(2, 4, id1, DefaultPaintChunkProperties()),
                   IsPaintChunk(4, 6, id2, DefaultPaintChunkProperties())));
 }
 
-TEST_F(PaintChunkerTest, SetAndImmediatelyUnsetForceNewChunk) {
-  PaintChunker chunker;
+TEST_F(PaintChunkerTest, SetAndImmediatelyUnSetWillForceNewChunk) {
+  Vector<PaintChunk> chunks;
+  PaintChunker chunker(chunks);
   PaintChunk::Id id0(client_, DisplayItemType(0));
   chunker.UpdateCurrentPaintChunkProperties(nullptr,
                                             DefaultPaintChunkProperties());
   EXPECT_TRUE(chunker.WillForceNewChunk());
-  EXPECT_EQ(0u, chunker.size());
+  EXPECT_EQ(0u, chunks.size());
   chunker.IncrementDisplayItemIndex(
       TestChunkerDisplayItem(id0.client, id0.type));
   EXPECT_FALSE(chunker.WillForceNewChunk());
-  EXPECT_EQ(1u, chunker.size());
+  EXPECT_EQ(1u, chunks.size());
   chunker.IncrementDisplayItemIndex(TestChunkerDisplayItem(client_));
 
   // This should not force a new chunk. Simulates a ScopedPaintChunkHint
   // without any painting in the scope.
-  chunker.SetForceNewChunk(true);
-  chunker.SetForceNewChunk(false);
+  chunker.SetWillForceNewChunk(true);
+  chunker.SetWillForceNewChunk(false);
   EXPECT_FALSE(chunker.WillForceNewChunk());
   chunker.IncrementDisplayItemIndex(
       TestChunkerDisplayItem(client_, DisplayItemType(1)));
-  EXPECT_EQ(1u, chunker.size());
+  EXPECT_EQ(1u, chunks.size());
 
-  EXPECT_THAT(
-      chunker.PaintChunks(),
-      ElementsAre(IsPaintChunk(0, 3, id0, DefaultPaintChunkProperties())));
+  EXPECT_THAT(chunks, ElementsAre(IsPaintChunk(0, 3, id0,
+                                               DefaultPaintChunkProperties())));
 }
 
 TEST_F(PaintChunkerTest, NoNewChunkForSamePropertyDifferentIds) {
-  PaintChunker chunker;
+  Vector<PaintChunk> chunks;
+  PaintChunker chunker(chunks);
   PaintChunk::Id id0(client_, DisplayItemType(0));
   chunker.UpdateCurrentPaintChunkProperties(&id0,
                                             DefaultPaintChunkProperties());
@@ -428,15 +436,15 @@ TEST_F(PaintChunkerTest, NoNewChunkForSamePropertyDifferentIds) {
   chunker.IncrementDisplayItemIndex(TestChunkerDisplayItem(client_));
   chunker.IncrementDisplayItemIndex(TestChunkerDisplayItem(client_));
 
-  EXPECT_THAT(
-      chunker.PaintChunks(),
-      ElementsAre(IsPaintChunk(0, 6, id0, DefaultPaintChunkProperties())));
+  EXPECT_THAT(chunks, ElementsAre(IsPaintChunk(0, 6, id0,
+                                               DefaultPaintChunkProperties())));
 }
 
 // Ensure that items following a forced chunk begin using the next display
 // item's id.
 TEST_F(PaintChunkerTest, ChunksFollowingForcedChunk) {
-  PaintChunker chunker;
+  Vector<PaintChunk> chunks;
+  PaintChunker chunker(chunks);
   FakeDisplayItemClient client;
   TestChunkerDisplayItem before_forced1(client, DisplayItemType(1));
   TestChunkerDisplayItem before_forced2(client, DisplayItemType(2));
@@ -457,7 +465,7 @@ TEST_F(PaintChunkerTest, ChunksFollowingForcedChunk) {
   chunker.IncrementDisplayItemIndex(after_forced2);
 
   EXPECT_THAT(
-      chunker.PaintChunks(),
+      chunks,
       ElementsAre(
           IsPaintChunk(0, 2, id0, DefaultPaintChunkProperties()),
           IsPaintChunk(2, 3, forced.GetId(), DefaultPaintChunkProperties()),
@@ -466,7 +474,8 @@ TEST_F(PaintChunkerTest, ChunksFollowingForcedChunk) {
 }
 
 TEST_F(PaintChunkerTest, ChunkIdsSkippingCache) {
-  PaintChunker chunker;
+  Vector<PaintChunk> chunks;
+  PaintChunker chunker(chunks);
 
   PaintChunk::Id id1(client_, DisplayItemType(1));
   chunker.UpdateCurrentPaintChunkProperties(&id1,
@@ -500,7 +509,6 @@ TEST_F(PaintChunkerTest, ChunkIdsSkippingCache) {
   TestChunkerDisplayItem after_restore(client_, DisplayItemType(4));
   chunker.IncrementDisplayItemIndex(after_restore);
 
-  const auto& chunks = chunker.PaintChunks();
   EXPECT_THAT(
       chunks,
       ElementsAre(
@@ -519,7 +527,8 @@ TEST_F(PaintChunkerTest, ChunkIdsSkippingCache) {
 }
 
 TEST_F(PaintChunkerTest, AddHitTestDataToCurrentChunk) {
-  PaintChunker chunker;
+  Vector<PaintChunk> chunks;
+  PaintChunker chunker(chunks);
 
   PaintChunk::Id id1(client_, DisplayItemType(1));
 
@@ -539,7 +548,7 @@ TEST_F(PaintChunkerTest, AddHitTestDataToCurrentChunk) {
   chunker.AddHitTestDataToCurrentChunk(hit_test_id, IntRect(20, 30, 40, 50),
                                        TouchAction::kPan);
 
-  chunker.SetForceNewChunk(true);
+  chunker.SetWillForceNewChunk(true);
   PaintChunk::Id id3(client_, DisplayItemType(4));
   chunker.AddHitTestDataToCurrentChunk(id3, IntRect(40, 50, 60, 70),
                                        TouchAction::kAuto);
@@ -551,7 +560,7 @@ TEST_F(PaintChunkerTest, AddHitTestDataToCurrentChunk) {
       {IntRect(20, 30, 40, 50), TouchAction::kPan}};
   if (RuntimeEnabledFeatures::CompositeAfterPaintEnabled()) {
     EXPECT_THAT(
-        chunker.PaintChunks(),
+        chunks,
         ElementsAre(IsPaintChunk(0, 1, id1, DefaultPaintChunkProperties(),
                                  nullptr, IntRect(0, 0, 10, 10)),
                     IsPaintChunk(1, 1, id2, properties, &hit_test_data,
@@ -560,7 +569,7 @@ TEST_F(PaintChunkerTest, AddHitTestDataToCurrentChunk) {
                                  IntRect(0, 0, 100, 120))));
   } else {
     EXPECT_THAT(
-        chunker.PaintChunks(),
+        chunks,
         ElementsAre(
             IsPaintChunk(0, 1, id1, DefaultPaintChunkProperties(), nullptr,
                          IntRect(0, 0, 10, 10)),
@@ -573,7 +582,8 @@ TEST_F(PaintChunkerTest, AddHitTestDataToCurrentChunk) {
 
 TEST_F(PaintChunkerTest, ChunkBoundsAndKnownToBeOpaqueAllOpaqueItems) {
   ScopedCompositeAfterPaintForTest cap(true);
-  PaintChunker chunker;
+  Vector<PaintChunk> chunks;
+  PaintChunker chunker(chunks);
   FakeDisplayItemClient client1("client1");
   FakeDisplayItemClient client2("client2");
   FakeDisplayItemClient client3("client3");
@@ -583,20 +593,19 @@ TEST_F(PaintChunkerTest, ChunkBoundsAndKnownToBeOpaqueAllOpaqueItems) {
   // Single opaque item.
   chunker.IncrementDisplayItemIndex(TestChunkerOpaqueDisplayItem(
       client1, DisplayItemType(0), IntRect(0, 0, 100, 100)));
-  chunker.SetForceNewChunk(true);
+  chunker.SetWillForceNewChunk(true);
   // Two opaque items. No empty area in the united bounds.
   chunker.IncrementDisplayItemIndex(TestChunkerOpaqueDisplayItem(
       client1, DisplayItemType(1), IntRect(0, 0, 100, 100)));
   chunker.IncrementDisplayItemIndex(TestChunkerOpaqueDisplayItem(
       client2, DisplayItemType(2), IntRect(0, 100, 100, 50)));
-  chunker.SetForceNewChunk(true);
+  chunker.SetWillForceNewChunk(true);
   // Two opaque items. Has empty area in the united bounds.
   chunker.IncrementDisplayItemIndex(TestChunkerOpaqueDisplayItem(
       client1, DisplayItemType(3), IntRect(0, 0, 100, 100)));
   chunker.IncrementDisplayItemIndex(TestChunkerOpaqueDisplayItem(
       client3, DisplayItemType(4), IntRect(50, 50, 100, 100)));
 
-  Vector<PaintChunk> chunks = chunker.ReleasePaintChunks();
   EXPECT_THAT(
       chunks,
       ElementsAre(
@@ -614,7 +623,8 @@ TEST_F(PaintChunkerTest, ChunkBoundsAndKnownToBeOpaqueAllOpaqueItems) {
 
 TEST_F(PaintChunkerTest, ChunkBoundsAndKnownToBeOpaqueWithHitTest) {
   ScopedCompositeAfterPaintForTest cap(true);
-  PaintChunker chunker;
+  Vector<PaintChunk> chunks;
+  PaintChunker chunker(chunks);
   FakeDisplayItemClient client1("client1");
   FakeDisplayItemClient client2("client2");
   FakeDisplayItemClient client3("client3");
@@ -625,21 +635,21 @@ TEST_F(PaintChunkerTest, ChunkBoundsAndKnownToBeOpaqueWithHitTest) {
   chunker.AddHitTestDataToCurrentChunk(
       PaintChunk::Id(client1, DisplayItemType(0)), IntRect(10, 20, 30, 40),
       TouchAction::kAuto);
-  chunker.SetForceNewChunk(true);
+  chunker.SetWillForceNewChunk(true);
   // Hit test rect is smaller than the opaque item.
   chunker.IncrementDisplayItemIndex(TestChunkerOpaqueDisplayItem(
       client1, DisplayItemType(1), IntRect(0, 0, 100, 100)));
   chunker.AddHitTestDataToCurrentChunk(
       PaintChunk::Id(client1, DisplayItemType(2)), IntRect(0, 0, 50, 100),
       TouchAction::kAuto);
-  chunker.SetForceNewChunk(true);
+  chunker.SetWillForceNewChunk(true);
   // Hit test rect is the same as the opaque item.
   chunker.IncrementDisplayItemIndex(TestChunkerOpaqueDisplayItem(
       client1, DisplayItemType(3), IntRect(0, 0, 100, 100)));
   chunker.AddHitTestDataToCurrentChunk(
       PaintChunk::Id(client1, DisplayItemType(4)), IntRect(0, 0, 100, 100),
       TouchAction::kAuto);
-  chunker.SetForceNewChunk(true);
+  chunker.SetWillForceNewChunk(true);
   // Hit test rect is bigger than the opaque item.
   chunker.IncrementDisplayItemIndex(TestChunkerOpaqueDisplayItem(
       client1, DisplayItemType(5), IntRect(0, 0, 100, 100)));
@@ -647,7 +657,6 @@ TEST_F(PaintChunkerTest, ChunkBoundsAndKnownToBeOpaqueWithHitTest) {
       PaintChunk::Id(client1, DisplayItemType(6)), IntRect(0, 100, 200, 100),
       TouchAction::kAuto);
 
-  Vector<PaintChunk> chunks = chunker.ReleasePaintChunks();
   EXPECT_THAT(
       chunks,
       ElementsAre(
@@ -668,7 +677,8 @@ TEST_F(PaintChunkerTest, ChunkBoundsAndKnownToBeOpaqueWithHitTest) {
 
 TEST_F(PaintChunkerTest, ChunkBoundsAndKnownToBeOpaqueMixedOpaquenessItems) {
   ScopedCompositeAfterPaintForTest cap(true);
-  PaintChunker chunker;
+  Vector<PaintChunk> chunks;
+  PaintChunker chunker(chunks);
   FakeDisplayItemClient client1("client1");
   FakeDisplayItemClient client2("client2");
   IntRect visual_rect1(0, 0, 100, 100);
@@ -679,20 +689,20 @@ TEST_F(PaintChunkerTest, ChunkBoundsAndKnownToBeOpaqueMixedOpaquenessItems) {
   // Single translucent item .
   chunker.IncrementDisplayItemIndex(
       TestChunkerDisplayItem(client1, DisplayItemType(1), visual_rect1));
-  chunker.SetForceNewChunk(true);
+  chunker.SetWillForceNewChunk(true);
   // Two items, one translucent, one opaque. The opaque item doesn't contain
   // the translucent item.
   chunker.IncrementDisplayItemIndex(
       TestChunkerDisplayItem(client1, DisplayItemType(2), visual_rect1));
   chunker.IncrementDisplayItemIndex(
       TestChunkerOpaqueDisplayItem(client2, DisplayItemType(3), visual_rect2));
-  chunker.SetForceNewChunk(true);
+  chunker.SetWillForceNewChunk(true);
   // Two items, one translucent, one opaque, with the same visual rect.
   chunker.IncrementDisplayItemIndex(
       TestChunkerDisplayItem(client1, DisplayItemType(4), visual_rect1));
   chunker.IncrementDisplayItemIndex(
       TestChunkerOpaqueDisplayItem(client1, DisplayItemType(5), visual_rect1));
-  chunker.SetForceNewChunk(true);
+  chunker.SetWillForceNewChunk(true);
   // Two items, one opaque, one translucent. The opaque item contains the
   // translucent item.
   chunker.IncrementDisplayItemIndex(
@@ -700,7 +710,8 @@ TEST_F(PaintChunkerTest, ChunkBoundsAndKnownToBeOpaqueMixedOpaquenessItems) {
   chunker.IncrementDisplayItemIndex(
       TestChunkerDisplayItem(client2, DisplayItemType(7), visual_rect2));
 
-  Vector<PaintChunk> chunks = chunker.ReleasePaintChunks();
+  chunker.ResetChunks(nullptr);
+
   EXPECT_THAT(
       chunks,
       ElementsAre(

third_party/blink/renderer/platform/graphics/paint/paint_controller.cc

@@ -15,16 +15,13 @@
 
 namespace blink {
 
-// This is just for initializing current_paint_artifact_ to avoid allocation of
-// a PaintArtifacts that might not be used.
-static scoped_refptr<PaintArtifact> EmptyPaintArtifact() {
-  DEFINE_STATIC_REF(PaintArtifact, empty, base::AdoptRef(new PaintArtifact()));
-  DCHECK(empty->IsEmpty());
-  return empty;
-}
-
 PaintController::PaintController(Usage usage)
-    : usage_(usage), current_paint_artifact_(EmptyPaintArtifact()) {
+    : usage_(usage),
+      current_paint_artifact_(usage == kMultiplePaints
+                                  ? base::MakeRefCounted<PaintArtifact>()
+                                  : nullptr),
+      new_paint_artifact_(base::MakeRefCounted<PaintArtifact>()),
+      paint_chunker_(new_paint_artifact_->PaintChunks()) {
   // frame_first_paints_ should have one null frame since the beginning, so
   // that PaintController is robust even if it paints outside of BeginFrame
   // and EndFrame cycles. It will also enable us to combine the first paint
@@ -34,12 +31,61 @@ PaintController::PaintController(Usage usage)
 }
 
 PaintController::~PaintController() {
+#if DCHECK_IS_ON()
   if (usage_ == kMultiplePaints) {
     // New display items should have been committed.
-    DCHECK(new_display_item_list_.IsEmpty());
+    DCHECK(new_paint_artifact_->IsEmpty());
     // And the committed_ flag should have been cleared by FinishCycle().
     DCHECK(!committed_);
   }
+#endif
+}
+
+void PaintController::EnsureChunk() {
+  if (paint_chunker_.EnsureChunk())
+    DidAppendChunk();
+}
+
+void PaintController::RecordHitTestData(const DisplayItemClient& client,
+                                        const IntRect& rect,
+                                        TouchAction touch_action) {
+  if (rect.IsEmpty())
+    return;
+  // In CompositeAfterPaint, we ensure a paint chunk for correct composited
+  // hit testing. In pre-CompositeAfterPaint, this is unnecessary, except that
+  // there is special touch action, and that we have a non-root effect so that
+  // PaintChunksToCcLayer will emit paint operations for filters.
+  if (!RuntimeEnabledFeatures::CompositeAfterPaintEnabled() &&
+      touch_action == TouchAction::kAuto &&
+      CurrentPaintChunkProperties().Effect().IsRoot())
+    return;
+
+  PaintChunk::Id id(client, DisplayItem::kHitTest, current_fragment_);
+  CheckDuplicatePaintChunkId(id);
+  if (paint_chunker_.AddHitTestDataToCurrentChunk(id, rect, touch_action))
+    DidAppendChunk();
+}
+
+void PaintController::RecordScrollHitTestData(
+    const DisplayItemClient& client,
+    DisplayItem::Type type,
+    const TransformPaintPropertyNode* scroll_translation,
+    const IntRect& rect) {
+  PaintChunk::Id id(client, type, current_fragment_);
+  CheckDuplicatePaintChunkId(id);
+  paint_chunker_.CreateScrollHitTestChunk(id, scroll_translation, rect);
+  DidAppendChunk();
+}
+
+void PaintController::SetPossibleBackgroundColor(
+    const DisplayItemClient& client,
+    Color color,
+    uint64_t area) {
+  PaintChunk::Id id(client, DisplayItem::kBoxDecorationBackground,
+                    current_fragment_);
+  CheckDuplicatePaintChunkId(id);
+  if (paint_chunker_.ProcessBackgroundColorCandidate(id, color, area))
+    DidAppendChunk();
 }
 
 bool PaintController::UseCachedItemIfPossible(const DisplayItemClient& client,
@@ -173,13 +219,13 @@ PaintController::SubsequenceMarkers* PaintController::GetSubsequenceMarkers(
 
 wtf_size_t PaintController::BeginSubsequence() {
   // Force new paint chunk which is required for subsequence caching.
-  SetForceNewChunk(true);
-  return new_paint_chunks_.size();
+  SetWillForceNewChunk(true);
+  return NumNewChunks();
 }
 
 void PaintController::EndSubsequence(const DisplayItemClient& client,
                                      wtf_size_t start_chunk_index) {
-  auto end_chunk_index = new_paint_chunks_.size();
+  auto end_chunk_index = NumNewChunks();
 
   if (RuntimeEnabledFeatures::PaintUnderInvalidationCheckingEnabled() &&
       IsCheckingUnderInvalidation()) {
@@ -204,7 +250,7 @@ void PaintController::EndSubsequence(const DisplayItemClient& client,
         const auto& old_chunk =
             current_paint_artifact_->PaintChunks()[old_chunk_index];
         const auto& new_chunk =
-            new_paint_chunks_.PaintChunks()[new_chunk_index];
+            new_paint_artifact_->PaintChunks()[new_chunk_index];
         if (!old_chunk.EqualsForUnderInvalidationChecking(new_chunk)) {
           ShowSequenceUnderInvalidationError(
               "under-invalidation: chunk changed", client);
@@ -223,7 +269,7 @@ void PaintController::EndSubsequence(const DisplayItemClient& client,
   }
 
   // Force new paint chunk which is required for subsequence caching.
-  SetForceNewChunk(true);
+  SetWillForceNewChunk(true);
 
   DCHECK(!new_cached_subsequences_.Contains(&client))
       << "Multiple subsequences for client: " << client.DebugName();
@@ -238,17 +284,18 @@ void PaintController::DidAppendItem(DisplayItem& display_item) {
 
 #if DCHECK_IS_ON()
   if (display_item.IsCacheable()) {
+    auto& new_display_item_list = new_paint_artifact_->GetDisplayItemList();
     auto index = FindItemFromIdIndexMap(display_item.GetId(),
                                         new_display_item_id_index_map_,
-                                        new_display_item_list_);
+                                        new_display_item_list);
     if (index != kNotFound) {
       ShowDebugData();
       NOTREACHED() << "DisplayItem " << display_item.AsDebugString().Utf8()
                    << " has duplicated id with previous "
-                   << new_display_item_list_[index].AsDebugString().Utf8()
+                   << new_display_item_list[index].AsDebugString().Utf8()
                    << " (index=" << index << ")";
     }
-    AddToIdIndexMap(display_item.GetId(), new_display_item_list_.size() - 1,
+    AddToIdIndexMap(display_item.GetId(), new_display_item_list.size() - 1,
                     new_display_item_id_index_map_);
   }
 #endif
@@ -263,7 +310,7 @@ void PaintController::ProcessNewItem(DisplayItem& display_item) {
     display_item.SetUncacheable();
   }
 
-  if (new_paint_chunks_.IncrementDisplayItemIndex(display_item))
+  if (paint_chunker_.IncrementDisplayItemIndex(display_item))
     DidAppendChunk();
 
   if (!frame_first_paints_.back().first_painted && display_item.IsDrawing() &&
@@ -281,15 +328,15 @@ void PaintController::ProcessNewItem(DisplayItem& display_item) {
 
 DisplayItem& PaintController::MoveItemFromCurrentListToNewList(
     wtf_size_t index) {
-  return new_display_item_list_.AppendByMoving(
+  return new_paint_artifact_->GetDisplayItemList().AppendByMoving(
       current_paint_artifact_->GetDisplayItemList()[index]);
 }
 
 void PaintController::DidAppendChunk() {
 #if DCHECK_IS_ON()
-  if (new_paint_chunks_.LastChunk().is_cacheable) {
-    AddToIdIndexMap(new_paint_chunks_.LastChunk().id,
-                    new_paint_chunks_.size() - 1,
+  auto& chunks = new_paint_artifact_->PaintChunks();
+  if (chunks.back().is_cacheable) {
+    AddToIdIndexMap(chunks.back().id, chunks.size() - 1,
                     new_paint_chunk_id_index_map_);
   }
 #endif
@@ -303,8 +350,8 @@ void PaintController::InvalidateAll() {
 void PaintController::InvalidateAllInternal() {
   // TODO(wangxianzhu): Rename this to InvalidateAllForTesting() for CAP.
   // Can only be called during layout/paintInvalidation, not during painting.
-  DCHECK(new_display_item_list_.IsEmpty());
-  current_paint_artifact_ = EmptyPaintArtifact();
+  CheckNoNewPaint();
+  current_paint_artifact_ = base::MakeRefCounted<PaintArtifact>();
   current_cached_subsequences_.clear();
   cache_is_all_invalid_ = true;
 }
@@ -320,17 +367,17 @@ void PaintController::UpdateCurrentPaintChunkProperties(
     const PropertyTreeStateOrAlias& properties) {
   if (id) {
     PaintChunk::Id id_with_fragment(*id, current_fragment_);
-    new_paint_chunks_.UpdateCurrentPaintChunkProperties(&id_with_fragment,
-                                                        properties);
+    paint_chunker_.UpdateCurrentPaintChunkProperties(&id_with_fragment,
+                                                     properties);
     CheckDuplicatePaintChunkId(id_with_fragment);
   } else {
-    new_paint_chunks_.UpdateCurrentPaintChunkProperties(nullptr, properties);
+    paint_chunker_.UpdateCurrentPaintChunkProperties(nullptr, properties);
   }
 }
 
 void PaintController::AppendChunkByMoving(PaintChunk&& chunk) {
   CheckDuplicatePaintChunkId(chunk.id);
-  new_paint_chunks_.AppendByMoving(std::move(chunk));
+  paint_chunker_.AppendByMoving(std::move(chunk));
   DidAppendChunk();
 }
 
@@ -448,8 +495,7 @@ void PaintController::CopyCachedSubsequence(wtf_size_t start_chunk_index,
                                             wtf_size_t end_chunk_index) {
 #if DCHECK_IS_ON()
   DCHECK(!RuntimeEnabledFeatures::PaintUnderInvalidationCheckingEnabled());
-  auto properties_before_subsequence =
-      new_paint_chunks_.CurrentPaintChunkProperties();
+  auto properties_before_subsequence = CurrentPaintChunkProperties();
 #endif
 
   for (auto chunk_index = start_chunk_index; chunk_index < end_chunk_index;
@@ -471,7 +517,7 @@ void PaintController::CopyCachedSubsequence(wtf_size_t start_chunk_index,
     AppendChunkByMoving(std::move(cached_chunk));
   }
 
-  SetForceNewChunk(true);
+  SetWillForceNewChunk(true);
 
 #if DCHECK_IS_ON()
   DCHECK_EQ(properties_before_subsequence, CurrentPaintChunkProperties());
@@ -487,11 +533,14 @@ void PaintController::ResetCurrentListIndices() {
 
 DISABLE_CFI_PERF
 void PaintController::CommitNewDisplayItems() {
-  TRACE_EVENT2("blink,benchmark", "PaintController::commitNewDisplayItems",
-               "current_display_list_size",
-               (int)current_paint_artifact_->GetDisplayItemList().size(),
-               "num_non_cached_new_items",
-               (int)new_display_item_list_.size() - num_cached_new_items_);
+  TRACE_EVENT2(
+      "blink,benchmark", "PaintController::commitNewDisplayItems",
+      "current_display_list_size",
+      current_paint_artifact_
+          ? current_paint_artifact_->GetDisplayItemList().size()
+          : 0,
+      "num_non_cached_new_items",
+      new_paint_artifact_->GetDisplayItemList().size() - num_cached_new_items_);
 
   if (usage_ == kMultiplePaints)
     UpdateUMACounts();
@@ -509,17 +558,19 @@ void PaintController::CommitNewDisplayItems() {
   new_cached_subsequences_.swap(current_cached_subsequences_);
   new_cached_subsequences_.clear();
 
-  current_paint_artifact_ = base::MakeRefCounted<PaintArtifact>(
-      std::move(new_display_item_list_),
-      new_paint_chunks_.ReleasePaintChunks());
+  current_paint_artifact_ = std::move(new_paint_artifact_);
+  if (usage_ == kMultiplePaints) {
+    new_paint_artifact_ = base::MakeRefCounted<PaintArtifact>(
+        current_paint_artifact_->GetDisplayItemList().UsedCapacityInBytes());
+    paint_chunker_.ResetChunks(&new_paint_artifact_->PaintChunks());
+  } else {
+    new_paint_artifact_ = nullptr;
+    paint_chunker_.ResetChunks(nullptr);
+  }
 
   ResetCurrentListIndices();
   out_of_order_item_id_index_map_.clear();
 
-  // We'll allocate the initial buffer when we start the next paint.
-  new_display_item_list_ =
-      DisplayItemList(GetDisplayItemList().UsedCapacityInBytes());
-
 #if DCHECK_IS_ON()
   num_indexed_items_ = 0;
   num_sequential_matches_ = 0;
@@ -531,11 +582,7 @@ void PaintController::FinishCycle() {
   if (usage_ == kTransient || !committed_)
     return;
 
-#if DCHECK_IS_ON()
-  DCHECK(new_display_item_list_.IsEmpty());
-  DCHECK(new_paint_chunks_.IsInInitialState());
-#endif
-
+  CheckNoNewPaint();
   committed_ = false;
 
   // Validate display item clients that have validly cached subsequence or
@@ -597,17 +644,14 @@ void PaintController::ClearPropertyTreeChangedStateTo(
 size_t PaintController::ApproximateUnsharedMemoryUsage() const {
   size_t memory_usage = sizeof(*this);
 
-  // Memory outside this class due to current_paint_artifact_.
+  // Memory outside this class due to paint artifacts.
   memory_usage += current_paint_artifact_->ApproximateUnsharedMemoryUsage();
+  memory_usage += new_paint_artifact_->ApproximateUnsharedMemoryUsage();
 
   // External objects, shared with the embedder, such as PaintRecord, should be
   // excluded to avoid double counting. It is the embedder's responsibility to
   // count such objects.
 
-  // Memory outside this class due to new_display_item_list_.
-  DCHECK(new_display_item_list_.IsEmpty());
-  memory_usage += new_display_item_list_.MemoryUsageInBytes();
-
   // Memory outside this class due to current_cached_subsequences_ and
   // new_cached_subsequences_.
   memory_usage += current_cached_subsequences_.Capacity() *
@@ -683,7 +727,7 @@ void PaintController::CheckUnderInvalidation() {
     return;
   }
 
-  DisplayItem& new_item = new_display_item_list_.Last();
+  DisplayItem& new_item = new_paint_artifact_->GetDisplayItemList().Last();
   auto old_item_index = under_invalidation_checking_begin_;
   DisplayItem* old_item =
       old_item_index < current_paint_artifact_->GetDisplayItemList().size()
@@ -693,11 +737,8 @@ void PaintController::CheckUnderInvalidation() {
   if (!old_item || !new_item.Equals(*old_item)) {
     // If we ever skipped reporting any under-invalidations, report the earliest
     // one.
-    ShowUnderInvalidationError(
-        "under-invalidation: display item changed",
-        new_display_item_list_.Last(),
-        &current_paint_artifact_
-             ->GetDisplayItemList()[under_invalidation_checking_begin_]);
+    ShowUnderInvalidationError("under-invalidation: display item changed",
+                               new_item, old_item);
     CHECK(false);
   }
 
@@ -706,7 +747,7 @@ void PaintController::CheckUnderInvalidation() {
   // non-under-invalidation-checking path to empty the original cached slot,
   // leaving only disappeared or invalidated display items in the old list after
   // painting.
-  new_display_item_list_.RemoveLast();
+  new_paint_artifact_->GetDisplayItemList().RemoveLast();
   MoveItemFromCurrentListToNewList(old_item_index);
 
   ++under_invalidation_checking_begin_;
@@ -753,7 +794,7 @@ void PaintController::CheckDuplicatePaintChunkId(const PaintChunk::Id& id) {
     ShowDebugData();
     NOTREACHED() << "New paint chunk id " << id
                  << " has duplicated id with previous chuck "
-                 << new_paint_chunks_.PaintChunks()[it->value];
+                 << new_paint_artifact_->PaintChunks()[it->value];
   }
 #endif
 }
@@ -765,7 +806,7 @@ size_t PaintController::sum_num_cached_subsequences_ = 0;
 
 void PaintController::UpdateUMACounts() {
   DCHECK_EQ(usage_, kMultiplePaints);
-  sum_num_items_ += new_display_item_list_.size();
+  sum_num_items_ += new_paint_artifact_->GetDisplayItemList().size();
   sum_num_cached_items_ += num_cached_new_items_;
   sum_num_subsequences_ += new_cached_subsequences_.size();
   sum_num_cached_subsequences_ += num_cached_new_subsequences_;

third_party/blink/renderer/platform/graphics/paint/paint_controller.h

@@ -93,46 +93,31 @@ class PLATFORM_EXPORT PaintController {
   void UpdateCurrentPaintChunkProperties(const PaintChunk::Id*,
                                          const PropertyTreeStateOrAlias&);
   const PropertyTreeStateOrAlias& CurrentPaintChunkProperties() const {
-    return new_paint_chunks_.CurrentPaintChunkProperties();
+    return paint_chunker_.CurrentPaintChunkProperties();
   }
   // See PaintChunker for documentation of the following methods.
-  wtf_size_t NumNewChunks() const { return new_paint_chunks_.size(); }
-  void SetForceNewChunk(bool force) {
-    new_paint_chunks_.SetForceNewChunk(force);
-  }
-  bool WillForceNewChunk() const {
-    return new_paint_chunks_.WillForceNewChunk();
-  }
-  const IntRect& LastChunkBounds() const {
-    return new_paint_chunks_.LastChunk().bounds;
+  void SetWillForceNewChunk(bool force) {
+    paint_chunker_.SetWillForceNewChunk(force);
   }
+  bool WillForceNewChunk() const { return paint_chunker_.WillForceNewChunk(); }
 
-  void EnsureChunk() { new_paint_chunks_.EnsureChunk(); }
-  void RecordHitTestData(const DisplayItemClient& client,
-                         const IntRect& rect,
-                         TouchAction touch_action) {
-    if (rect.IsEmpty())
-      return;
-    PaintChunk::Id id(client, DisplayItem::kHitTest, current_fragment_);
-    CheckDuplicatePaintChunkId(id);
-    new_paint_chunks_.AddHitTestDataToCurrentChunk(id, rect, touch_action);
-  }
+  void EnsureChunk();
+
+  void RecordHitTestData(const DisplayItemClient&, const IntRect&, TouchAction);
   void RecordScrollHitTestData(
-      const DisplayItemClient& client,
-      DisplayItem::Type type,
+      const DisplayItemClient&,
+      DisplayItem::Type,
       const TransformPaintPropertyNode* scroll_translation,
-      const IntRect& rect) {
-    PaintChunk::Id id(client, type, current_fragment_);
-    CheckDuplicatePaintChunkId(id);
-    new_paint_chunks_.CreateScrollHitTestChunk(id, scroll_translation, rect);
-  }
+      const IntRect&);
+  void SetPossibleBackgroundColor(const DisplayItemClient&,
+                                  Color,
+                                  uint64_t area);
 
-  void SetPossibleBackgroundColor(const DisplayItemClient& client,
-                                  Color color,
-                                  uint64_t area) {
-    PaintChunk::Id id = {client, DisplayItem::kBoxDecorationBackground,
-                         current_fragment_};
-    new_paint_chunks_.ProcessBackgroundColorCandidate(id, color, area);
+  wtf_size_t NumNewChunks() const {
+    return new_paint_artifact_->PaintChunks().size();
+  }
+  const IntRect& LastChunkBounds() const {
+    return new_paint_artifact_->PaintChunks().back().bounds;
   }
 
   template <typename DisplayItemClass, typename... Args>
@@ -147,8 +132,9 @@ class PLATFORM_EXPORT PaintController {
                   "kDisplayItemAlignment.");
 
     DisplayItemClass& display_item =
-        new_display_item_list_.AllocateAndConstruct<DisplayItemClass>(
-            std::forward<Args>(args)...);
+        new_paint_artifact_->GetDisplayItemList()
+            .AllocateAndConstruct<DisplayItemClass>(
+                std::forward<Args>(args)...);
     display_item.SetFragment(current_fragment_);
     ProcessNewItem(display_item);
   }
@@ -210,15 +196,12 @@ class PLATFORM_EXPORT PaintController {
 
   // Get the artifact generated after the last commit.
   const PaintArtifact& GetPaintArtifact() const {
-#if DCHECK_IS_ON()
-    DCHECK(new_display_item_list_.IsEmpty());
-    DCHECK(new_paint_chunks_.IsInInitialState());
-    DCHECK(current_paint_artifact_);
-#endif
+    CheckNoNewPaint();
     return *current_paint_artifact_;
   }
   scoped_refptr<const PaintArtifact> GetPaintArtifactShared() const {
-    return base::WrapRefCounted(&GetPaintArtifact());
+    CheckNoNewPaint();
+    return current_paint_artifact_;
   }
   const DisplayItemList& GetDisplayItemList() const {
     return GetPaintArtifact().GetDisplayItemList();
@@ -227,6 +210,11 @@ class PLATFORM_EXPORT PaintController {
     return GetPaintArtifact().PaintChunks();
   }
 
+  scoped_refptr<const PaintArtifact> GetNewPaintArtifactShared() const {
+    DCHECK(new_paint_artifact_);
+    return new_paint_artifact_;
+  }
+
   class ScopedBenchmarkMode {
     STACK_ALLOCATED();
 
@@ -255,10 +243,6 @@ class PLATFORM_EXPORT PaintController {
   void SetTextPainted();
   void SetImagePainted();
 
-  // Returns DisplayItemList added using CreateAndAppend() since beginning or
-  // the last CommitNewDisplayItems(). Use with care.
-  DisplayItemList& NewDisplayItemList() { return new_display_item_list_; }
-
 #if DCHECK_IS_ON()
   void ShowCompactDebugData() const;
   void ShowDebugData() const;
@@ -403,6 +387,14 @@ class PLATFORM_EXPORT PaintController {
   bool ShouldInvalidateDisplayItemForBenchmark();
   bool ShouldInvalidateSubsequenceForBenchmark();
 
+  void CheckNoNewPaint() const {
+#if DCHECK_IS_ON()
+    DCHECK(!new_paint_artifact_ || new_paint_artifact_->IsEmpty());
+    DCHECK(paint_chunker_.IsInInitialState());
+    DCHECK(current_paint_artifact_);
+#endif
+  }
+
   Usage usage_;
 
   // The last paint artifact after CommitNewDisplayItems().
@@ -410,8 +402,8 @@ class PLATFORM_EXPORT PaintController {
   scoped_refptr<PaintArtifact> current_paint_artifact_;
 
   // Data being used to build the next paint artifact.
-  DisplayItemList new_display_item_list_;
-  PaintChunker new_paint_chunks_;
+  scoped_refptr<PaintArtifact> new_paint_artifact_;
+  PaintChunker paint_chunker_;
 
   bool cache_is_all_invalid_ = true;
   bool committed_ = false;
@@ -486,7 +478,7 @@ class PLATFORM_EXPORT PaintController {
   static size_t sum_num_subsequences_;
   static size_t sum_num_cached_subsequences_;
 
-  class DisplayItemListAsJSON;
+  class PaintArtifactAsJSON;
 
   DISALLOW_COPY_AND_ASSIGN(PaintController);
 };

third_party/blink/renderer/platform/graphics/paint/paint_controller_debug_data.cc

@@ -10,17 +10,17 @@
 
 namespace blink {
 
-class PaintController::DisplayItemListAsJSON {
+class PaintController::PaintArtifactAsJSON {
   STACK_ALLOCATED();
 
  public:
-  DisplayItemListAsJSON(const DisplayItemList&,
-                        const CachedSubsequenceMap&,
-                        const Vector<PaintChunk>&,
-                        DisplayItemList::JsonFlags);
+  PaintArtifactAsJSON(const PaintArtifact&,
+                      const CachedSubsequenceMap&,
+                      DisplayItemList::JsonFlags);
 
   String ToString() {
-    return ChunksAsJSONArrayRecursive(0, chunks_.size())->ToPrettyJSONString();
+    return ChunksAsJSONArrayRecursive(0, artifact_.PaintChunks().size())
+        ->ToPrettyJSONString();
   }
 
  private:
@@ -35,21 +35,17 @@ class PaintController::DisplayItemListAsJSON {
     wtf_size_t end_chunk_index;
   };
 
-  const DisplayItemList& list_;
+  const PaintArtifact& artifact_;
   Vector<SubsequenceInfo> subsequences_;
-  Vector<SubsequenceInfo>::const_iterator current_subsequence_;
-  const Vector<PaintChunk>& chunks_;
+  Vector<SubsequenceInfo>::const_iterator next_subsequence_;
   DisplayItemList::JsonFlags flags_;
 };
 
-PaintController::DisplayItemListAsJSON::DisplayItemListAsJSON(
-    const DisplayItemList& list,
+PaintController::PaintArtifactAsJSON::PaintArtifactAsJSON(
+    const PaintArtifact& artifact,
     const CachedSubsequenceMap& subsequence_map,
-    const Vector<PaintChunk>& chunks,
     DisplayItemList::JsonFlags flags)
-    : list_(list),
-      chunks_(chunks),
-      flags_(flags) {
+    : artifact_(artifact), flags_(flags) {
   for (const auto& item : subsequence_map) {
     subsequences_.push_back(SubsequenceInfo{
         item.key, item.value.start_chunk_index, item.value.end_chunk_index});
@@ -61,13 +57,13 @@ PaintController::DisplayItemListAsJSON::DisplayItemListAsJSON(
                          : a.start_chunk_index < b.start_chunk_index;
             });
 
-  current_subsequence_ = subsequences_.begin();
+  next_subsequence_ = subsequences_.begin();
 }
 
 std::unique_ptr<JSONObject>
-PaintController::DisplayItemListAsJSON::SubsequenceAsJSONObjectRecursive() {
-  const auto& subsequence = *current_subsequence_;
-  ++current_subsequence_;
+PaintController::PaintArtifactAsJSON::SubsequenceAsJSONObjectRecursive() {
+  const auto& subsequence = *next_subsequence_;
+  ++next_subsequence_;
 
   auto json_object = std::make_unique<JSONObject>();
 
@@ -82,15 +78,15 @@ PaintController::DisplayItemListAsJSON::SubsequenceAsJSONObjectRecursive() {
 }
 
 std::unique_ptr<JSONArray>
-PaintController::DisplayItemListAsJSON::ChunksAsJSONArrayRecursive(
+PaintController::PaintArtifactAsJSON::ChunksAsJSONArrayRecursive(
     wtf_size_t start_chunk_index,
     wtf_size_t end_chunk_index) {
   auto array = std::make_unique<JSONArray>();
   auto chunk_index = start_chunk_index;
 
-  while (current_subsequence_ != subsequences_.end() &&
-         current_subsequence_->start_chunk_index < end_chunk_index) {
-    const auto& subsequence = *current_subsequence_;
+  while (next_subsequence_ != subsequences_.end() &&
+         next_subsequence_->start_chunk_index < end_chunk_index) {
+    const auto& subsequence = *next_subsequence_;
     DCHECK_GE(subsequence.start_chunk_index, chunk_index);
     DCHECK_LE(subsequence.end_chunk_index, end_chunk_index);
 
@@ -106,13 +102,13 @@ PaintController::DisplayItemListAsJSON::ChunksAsJSONArrayRecursive(
   return array;
 }
 
-void PaintController::DisplayItemListAsJSON::AppendChunksAsJSON(
+void PaintController::PaintArtifactAsJSON::AppendChunksAsJSON(
     wtf_size_t start_chunk_index,
     wtf_size_t end_chunk_index,
     JSONArray& json_array) {
   DCHECK_GT(end_chunk_index, start_chunk_index);
   for (auto i = start_chunk_index; i < end_chunk_index; ++i) {
-    const auto& chunk = chunks_[i];
+    const auto& chunk = artifact_.PaintChunks()[i];
     auto json_object = std::make_unique<JSONObject>();
 
     json_object->SetString(
@@ -122,16 +118,15 @@ void PaintController::DisplayItemListAsJSON::AppendChunksAsJSON(
     if (flags_ & DisplayItemList::kShowPaintRecords)
       json_object->SetString("chunkData", chunk.ToString());
 
-    json_object->SetArray(
-        "displayItems",
-        DisplayItemList::DisplayItemsAsJSON(
-            list_.ItemsInRange(chunk.begin_index, chunk.end_index), flags_));
+    json_object->SetArray("displayItems",
+                          DisplayItemList::DisplayItemsAsJSON(
+                              artifact_.DisplayItemsInChunk(i), flags_));
 
     json_array.PushObject(std::move(json_object));
   }
 }
 
-String PaintController::DisplayItemListAsJSON::ClientName(
+String PaintController::PaintArtifactAsJSON::ClientName(
     const DisplayItemClient& client) const {
   return client.SafeDebugName(flags_ & DisplayItemList::kClientKnownToBeAlive);
 }
@@ -142,22 +137,25 @@ void PaintController::ShowDebugDataInternal(
   // The clients in the current list are known to be alive before FinishCycle().
   if (committed_)
     current_list_flags |= DisplayItemList::kClientKnownToBeAlive;
-  LOG(INFO) << "current display item list: "
-            << DisplayItemListAsJSON(
-                   current_paint_artifact_->GetDisplayItemList(),
-                   current_cached_subsequences_,
-                   current_paint_artifact_->PaintChunks(), current_list_flags)
-                   .ToString()
-                   .Utf8();
-
-  LOG(INFO) << "new display item list: "
-            << DisplayItemListAsJSON(
-                   new_display_item_list_, new_cached_subsequences_,
-                   new_paint_chunks_.PaintChunks(),
-                   // The clients in new_display_item_list_ are all alive.
-                   flags | DisplayItemList::kClientKnownToBeAlive)
-                   .ToString()
-                   .Utf8();
+  LOG(INFO) << "current paint artifact: "
+            << (current_paint_artifact_
+                    ? PaintArtifactAsJSON(*current_paint_artifact_,
+                                          current_cached_subsequences_,
+                                          current_list_flags)
+                          .ToString()
+                          .Utf8()
+                    : "null");
+
+  LOG(INFO)
+      << "new paint artifact: "
+      << (new_paint_artifact_
+              ? PaintArtifactAsJSON(
+                    *new_paint_artifact_, new_cached_subsequences_,
+                    // The clients in new_display_item_list_ are all alive.
+                    flags | DisplayItemList::kClientKnownToBeAlive)
+                    .ToString()
+                    .Utf8()
+              : "null");
 }
 
 void PaintController::ShowCompactDebugData() const {

third_party/blink/renderer/platform/graphics/paint/paint_controller_test.cc

@@ -844,6 +844,85 @@ TEST_P(PaintControllerTest, CachedSubsequenceAndDisplayItemsSwapOrder) {
                        DefaultPaintChunkProperties())));
 }
 
+TEST_P(PaintControllerTest, DisplayItemSwapOrderBeforeCachedSubsequence) {
+  FakeDisplayItemClient content1a("content1a");
+  FakeDisplayItemClient content1b("content1b");
+  FakeDisplayItemClient container2("container2");
+  FakeDisplayItemClient content3("content3");
+  GraphicsContext context(GetPaintController());
+
+  PaintChunk::Id content1a_id(content1a, kBackgroundType);
+  PaintChunk::Id content1b_id(content1b, kBackgroundType);
+  PaintChunk::Id container2_id(container2, kBackgroundType);
+  PaintChunk::Id content3_id(content3, kBackgroundType);
+  IntRect rect(100, 100, 50, 200);
+
+  InitRootChunk();
+
+  DrawRect(context, content1a, kBackgroundType, rect);
+  DrawRect(context, content1b, kBackgroundType, rect);
+  {
+    SubsequenceRecorder r(context, container2);
+    DrawRect(context, container2, kBackgroundType, rect);
+  }
+  DrawRect(context, content3, kBackgroundType, rect);
+  CommitAndFinishCycle();
+
+  EXPECT_THAT(GetPaintController().GetDisplayItemList(),
+              ElementsAre(IsSameId(&content1a, kBackgroundType),
+                          IsSameId(&content1b, kBackgroundType),
+                          IsSameId(&container2, kBackgroundType),
+                          IsSameId(&content3, kBackgroundType)));
+
+  // New paint order:
+  // Subsequence(container1): container1, content1b(cached), content1a(cached).
+  // Subsequence(container2): cached
+  // Subsequence(contaienr3): container3, content3
+  InitRootChunk();
+  if (RuntimeEnabledFeatures::PaintUnderInvalidationCheckingEnabled()) {
+    EXPECT_FALSE(DrawingRecorder::UseCachedDrawingIfPossible(context, content1b,
+                                                             kBackgroundType));
+    DrawRect(context, content1b, kBackgroundType, rect);
+    EXPECT_FALSE(DrawingRecorder::UseCachedDrawingIfPossible(context, content1a,
+                                                             kBackgroundType));
+    DrawRect(context, content1a, kBackgroundType, rect);
+    {
+      EXPECT_FALSE(SubsequenceRecorder::UseCachedSubsequenceIfPossible(
+          context, container2));
+      SubsequenceRecorder r(context, container2);
+      DrawRect(context, container2, kBackgroundType, rect);
+    }
+    EXPECT_FALSE(DrawingRecorder::UseCachedDrawingIfPossible(context, content3,
+                                                             kBackgroundType));
+    DrawRect(context, content3, kBackgroundType, rect);
+  } else {
+    EXPECT_TRUE(DrawingRecorder::UseCachedDrawingIfPossible(context, content1b,
+                                                            kBackgroundType));
+    EXPECT_TRUE(DrawingRecorder::UseCachedDrawingIfPossible(context, content1a,
+                                                            kBackgroundType));
+    EXPECT_TRUE(SubsequenceRecorder::UseCachedSubsequenceIfPossible(
+        context, container2));
+    EXPECT_TRUE(DrawingRecorder::UseCachedDrawingIfPossible(context, content3,
+                                                            kBackgroundType));
+  }
+
+  EXPECT_EQ(4u, NumCachedNewItems());
+  EXPECT_EQ(1u, NumCachedNewSubsequences());
+#if DCHECK_IS_ON()
+  EXPECT_EQ(1u, NumIndexedItems());
+  EXPECT_EQ(2u, NumSequentialMatches());
+  EXPECT_EQ(1u, NumOutOfOrderMatches());
+#endif
+
+  CommitAndFinishCycle();
+
+  EXPECT_THAT(GetPaintController().GetDisplayItemList(),
+              ElementsAre(IsSameId(&content1b, kBackgroundType),
+                          IsSameId(&content1a, kBackgroundType),
+                          IsSameId(&container2, kBackgroundType),
+                          IsSameId(&content3, kBackgroundType)));
+}
+
 TEST_P(PaintControllerTest, CachedSubsequenceContainingFragments) {
   GraphicsContext context(GetPaintController());
   FakeDisplayItemClient root("root");
@@ -1246,17 +1325,19 @@ TEST_P(PaintControllerTest, SkipCache) {
   GetPaintController().EndSkippingCache();
 
   // We should repaint everything on invalidation of the scope container.
-  EXPECT_THAT(GetPaintController().NewDisplayItemList(),
+  const auto& display_item_list =
+      GetPaintController().GetNewPaintArtifactShared()->GetDisplayItemList();
+  EXPECT_THAT(display_item_list,
               ElementsAre(IsSameId(&multicol, kBackgroundType),
                           IsSameId(&content, kForegroundType),
                           IsSameId(&content, kForegroundType),
                           IsSameId(&content, kForegroundType)));
-  EXPECT_NE(record1, static_cast<const DrawingDisplayItem&>(
-                         GetPaintController().NewDisplayItemList()[1])
-                         .GetPaintRecord());
-  EXPECT_NE(record2, static_cast<const DrawingDisplayItem&>(
-                         GetPaintController().NewDisplayItemList()[2])
-                         .GetPaintRecord());
+  EXPECT_NE(record1,
+            static_cast<const DrawingDisplayItem&>(display_item_list[1])
+                .GetPaintRecord());
+  EXPECT_NE(record2,
+            static_cast<const DrawingDisplayItem&>(display_item_list[2])
+                .GetPaintRecord());
 
   CommitAndFinishCycle();
   EXPECT_DEFAULT_ROOT_CHUNK(4);

third_party/blink/renderer/platform/graphics/paint/scoped_paint_chunk_hint.h

@@ -46,7 +46,7 @@ class ScopedPaintChunkHint {
         previous_force_new_chunk_(paint_controller_.WillForceNewChunk()) {
     if (!previous_force_new_chunk_ && previous_num_chunks_ &&
         !paint_controller_.LastChunkBounds().Contains(visual_rect))
-      paint_controller_.SetForceNewChunk(true);
+      paint_controller_.SetWillForceNewChunk(true);
     // This is after SetForceNewChunk(true) so that the possible new chunk will
     // use the specified id.
     paint_chunk_properties_.emplace(paint_controller, properties, client, type);
@@ -55,7 +55,7 @@ class ScopedPaintChunkHint {
   ~ScopedPaintChunkHint() {
     paint_chunk_properties_ = base::nullopt;
     if (!HasCreatedPaintChunk())
-      paint_controller_.SetForceNewChunk(previous_force_new_chunk_);
+      paint_controller_.SetWillForceNewChunk(previous_force_new_chunk_);
   }
 
   bool HasCreatedPaintChunk() const {

third_party/blink/renderer/platform/testing/test_paint_artifact.cc

@@ -38,17 +38,18 @@ TestPaintArtifact& TestPaintArtifact::Chunk(int id) {
 
 TestPaintArtifact& TestPaintArtifact::Chunk(DisplayItemClient& client,
                                             DisplayItem::Type type) {
-  paint_chunks_.push_back(
-      PaintChunk(display_item_list_.size(), display_item_list_.size(),
-                 PaintChunk::Id(client, type), PropertyTreeState::Root()));
+  auto& display_item_list = paint_artifact_->GetDisplayItemList();
+  paint_artifact_->PaintChunks().emplace_back(
+      display_item_list.size(), display_item_list.size(),
+      PaintChunk::Id(client, type), PropertyTreeState::Root());
   // Assume PaintController has processed this chunk.
-  paint_chunks_.back().client_is_just_created = false;
+  paint_artifact_->PaintChunks().back().client_is_just_created = false;
   return *this;
 }
 
 TestPaintArtifact& TestPaintArtifact::Properties(
     const PropertyTreeStateOrAlias& properties) {
-  paint_chunks_.back().properties = properties;
+  paint_artifact_->PaintChunks().back().properties = properties;
   return *this;
 }
 
@@ -66,8 +67,9 @@ TestPaintArtifact& TestPaintArtifact::ForeignLayer(
     scoped_refptr<cc::Layer> layer,
     const IntPoint& offset) {
   DEFINE_STATIC_LOCAL(LiteralDebugNameClient, client, ("ForeignLayer"));
-  display_item_list_.AllocateAndConstruct<ForeignLayerDisplayItem>(
-      client, DisplayItem::kForeignLayerFirst, std::move(layer), offset);
+  paint_artifact_->GetDisplayItemList()
+      .AllocateAndConstruct<ForeignLayerDisplayItem>(
+          client, DisplayItem::kForeignLayerFirst, std::move(layer), offset);
   DidAddDisplayItem();
   return *this;
 }
@@ -82,9 +84,10 @@ TestPaintArtifact& TestPaintArtifact::RectDrawing(DisplayItemClient& client,
     flags.setColor(color.Rgb());
     canvas->drawRect(bounds, flags);
   }
-  display_item_list_.AllocateAndConstruct<DrawingDisplayItem>(
-      client, DisplayItem::kDrawingFirst, bounds,
-      recorder.finishRecordingAsPicture());
+  paint_artifact_->GetDisplayItemList()
+      .AllocateAndConstruct<DrawingDisplayItem>(
+          client, DisplayItem::kDrawingFirst, bounds,
+          recorder.finishRecordingAsPicture());
   DidAddDisplayItem();
   return *this;
 }
@@ -92,43 +95,44 @@ TestPaintArtifact& TestPaintArtifact::RectDrawing(DisplayItemClient& client,
 TestPaintArtifact& TestPaintArtifact::ScrollHitTest(
     DisplayItemClient& client,
     const TransformPaintPropertyNode* scroll_translation) {
-  paint_chunks_.back().EnsureHitTestData().scroll_translation =
+  paint_artifact_->PaintChunks().back().EnsureHitTestData().scroll_translation =
       scroll_translation;
   return *this;
 }
 
 TestPaintArtifact& TestPaintArtifact::SetRasterEffectOutset(
     RasterEffectOutset outset) {
-  paint_chunks_.back().raster_effect_outset = outset;
+  paint_artifact_->PaintChunks().back().raster_effect_outset = outset;
   return *this;
 }
 
 TestPaintArtifact& TestPaintArtifact::KnownToBeOpaque() {
-  paint_chunks_.back().known_to_be_opaque = true;
+  paint_artifact_->PaintChunks().back().known_to_be_opaque = true;
   return *this;
 }
 
 TestPaintArtifact& TestPaintArtifact::Bounds(const IntRect& bounds) {
-  paint_chunks_.back().bounds = bounds;
-  paint_chunks_.back().drawable_bounds = bounds;
+  auto& chunk = paint_artifact_->PaintChunks().back();
+  chunk.bounds = bounds;
+  chunk.drawable_bounds = bounds;
   return *this;
 }
 
 TestPaintArtifact& TestPaintArtifact::DrawableBounds(
     const IntRect& drawable_bounds) {
-  paint_chunks_.back().drawable_bounds = drawable_bounds;
-  DCHECK(paint_chunks_.back().bounds.Contains(drawable_bounds));
+  auto& chunk = paint_artifact_->PaintChunks().back();
+  chunk.drawable_bounds = drawable_bounds;
+  DCHECK(chunk.bounds.Contains(drawable_bounds));
   return *this;
 }
 
 TestPaintArtifact& TestPaintArtifact::Uncacheable() {
-  paint_chunks_.back().is_cacheable = false;
+  paint_artifact_->PaintChunks().back().is_cacheable = false;
   return *this;
 }
 
 scoped_refptr<PaintArtifact> TestPaintArtifact::Build() {
-  return base::MakeRefCounted<PaintArtifact>(std::move(display_item_list_),
-                                             std::move(paint_chunks_));
+  return std::move(paint_artifact_);
 }
 
 FakeDisplayItemClient& TestPaintArtifact::NewClient() {
@@ -141,9 +145,9 @@ FakeDisplayItemClient& TestPaintArtifact::Client(wtf_size_t i) const {
 }
 
 void TestPaintArtifact::DidAddDisplayItem() {
-  auto& chunk = paint_chunks_.back();
-  DCHECK_EQ(chunk.end_index, display_item_list_.size() - 1);
-  const auto& item = display_item_list_.Last();
+  auto& chunk = paint_artifact_->PaintChunks().back();
+  DCHECK_EQ(chunk.end_index, paint_artifact_->GetDisplayItemList().size() - 1);
+  const auto& item = paint_artifact_->GetDisplayItemList().Last();
   chunk.bounds.Unite(item.VisualRect());
   if (item.DrawsContent())
     chunk.drawable_bounds.Unite(item.VisualRect());

third_party/blink/renderer/platform/testing/test_paint_artifact.h

@@ -132,9 +132,8 @@ class TestPaintArtifact {
   void DidAddDisplayItem();
 
   Vector<std::unique_ptr<FakeDisplayItemClient>> clients_;
-
-  DisplayItemList display_item_list_;
-  Vector<PaintChunk> paint_chunks_;
+  scoped_refptr<PaintArtifact> paint_artifact_ =
+      base::MakeRefCounted<PaintArtifact>();
 };
 
 }  // namespace blink