Only create PaintChunks at drawing and foreignLayer boundaries

third_party/WebKit/Source/platform/graphics/paint/PaintChunker.h

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef PaintChunker_h
 #define PaintChunker_h
 
 #include "platform/PlatformExport.h"
 #include "platform/graphics/paint/DisplayItem.h"
 #include "platform/graphics/paint/PaintChunk.h"
 #include "platform/graphics/paint/PaintChunkProperties.h"
 #include "wtf/Allocator.h"
 #include "wtf/Noncopyable.h"
 #include "wtf/Vector.h"
 
 namespace blink {
 
-// Accepts information about changes to |PaintChunkProperties| as drawings are
-// accumulated, and produces a series of paint chunks: contiguous ranges of the
-// display list with identical |PaintChunkProperties|.
+// Accepts information about changes to |PaintChunkProperties| as drawings and
+// foreign layers [1] are accumulated, and produces a series of paint chunks:
+// contiguous ranges of the display list with identical |PaintChunkProperties|.
+//
+// [1] Only drawings and foreign layers are used for compositing (i.e., other
+// display item types are ignored by PaintArtifactCompositor), so other types
+// do not create paint chunks as an optimization (see: canBeginOrEndChunk).
 class PLATFORM_EXPORT PaintChunker final {
   DISALLOW_NEW();
   WTF_MAKE_NONCOPYABLE(PaintChunker);
 
  public:
   PaintChunker();
   ~PaintChunker();
 
   bool isInInitialState() const {
-    return m_chunks.isEmpty() && m_currentProperties == PaintChunkProperties();
+    return m_chunks.isEmpty() &&
+           m_currentProperties == PaintChunkProperties() &&
+           m_skippedItemsSinceLastChunk == 0;
   }
 
   const PaintChunkProperties& currentPaintChunkProperties() const {
     return m_currentProperties;
   }
   void updateCurrentPaintChunkProperties(const PaintChunk::Id*,
                                          const PaintChunkProperties&);
 
   // Returns true if a new chunk is created.
   bool incrementDisplayItemIndex(const DisplayItem&);
   // Returns true if the last chunk is removed.
   bool decrementDisplayItemIndex();
 
+  // Paint chunks are only created/ended at drawing and foreign layer boundaries
+  // with all other types being skipped (see: m_skippedItemsSinceLastChunk).
+  static bool canBeginOrEndChunk(const DisplayItem& item) {
+    return DisplayItem::isDrawingType(item.getType()) ||
+           DisplayItem::isForeignLayerType(item.getType());
+  }
+
   PaintChunk& paintChunkAt(size_t i) { return m_chunks[i]; }
   size_t lastChunkIndex() const {
     return m_chunks.isEmpty() ? kNotFound : m_chunks.size() - 1;
   }
   PaintChunk& lastChunk() { return m_chunks.back(); }
 
   PaintChunk& findChunkByDisplayItemIndex(size_t index) {
     auto chunk = findChunkInVectorByDisplayItemIndex(m_chunks, index);
     DCHECK(chunk != m_chunks.end());
     return *chunk;
@@ skipping 11 matching lines @@
     DefaultBehavior = 0,
 
     // Item requires its own paint chunk.
     RequiresSeparateChunk,
   };
 
   Vector<PaintChunk> m_chunks;
   Vector<ItemBehavior> m_chunkBehavior;
   Optional<PaintChunk::Id> m_currentChunkId;
   PaintChunkProperties m_currentProperties;
+  size_t m_skippedItemsSinceLastChunk;
 };
 
 }  // namespace blink
 
 #endif  // PaintChunker_h