PaintChunk::id

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

Index: third_party/WebKit/Source/platform/graphics/paint/PaintChunk.h
diff --git a/third_party/WebKit/Source/platform/graphics/paint/PaintChunk.h b/third_party/WebKit/Source/platform/graphics/paint/PaintChunk.h
index bafb8298ecdc2ba775afed614f996c1d485bfab7..40ff009b0beca9e901de4b84cab3cd5555f51e8d 100644
--- a/third_party/WebKit/Source/platform/graphics/paint/PaintChunk.h
+++ b/third_party/WebKit/Source/platform/graphics/paint/PaintChunk.h
@@ -6,8 +6,10 @@
 #define PaintChunk_h
 
 #include "platform/geometry/FloatRect.h"
+#include "platform/graphics/paint/DisplayItem.h"
 #include "platform/graphics/paint/PaintChunkProperties.h"
 #include "wtf/Allocator.h"
+#include "wtf/Optional.h"
 #include <iosfwd>
 
 namespace blink {
@@ -21,8 +23,12 @@ namespace blink {
 struct PaintChunk {
     DISALLOW_NEW_EXCEPT_PLACEMENT_NEW();
     PaintChunk() : beginIndex(0), endIndex(0), knownToBeOpaque(false) { }
-    PaintChunk(unsigned begin, unsigned end, const PaintChunkProperties& props)
-        : beginIndex(begin), endIndex(end), properties(props), knownToBeOpaque(false) { }
+    PaintChunk(unsigned begin, unsigned end, const DisplayItem::Id* chunkId, const PaintChunkProperties& props)
+        : beginIndex(begin), endIndex(end), properties(props), knownToBeOpaque(false)
+    {
+        if (chunkId)
+            id.emplace(*chunkId);
+    }
 
     unsigned size() const
     {
@@ -30,6 +36,24 @@ struct PaintChunk {
         return endIndex - beginIndex;
     }
 
+    // Check if a new PaintChunk (this) created in the latest paint matches an old
+    // PaintChunk created in the previous paint.
+    bool idMatches(const PaintChunk& old) const
+    {
+        // A PaintChunk without an id doesn't match any other PaintChunks.
+        if (!id || !old.id)
+            return false;
+        if (*id != *old.id)
+            return false;
+#if CHECK_DISPLAY_ITEM_CLIENT_ALIVENESS
+        CHECK(id->client.isAlive());
+#endif
+        // A chunk whose client is just created should not match any cached chunk,

[pdr., 2016/07/14 22:22:06]

I see what you mean about why this is needed, but I'm not sure this is the right
place. In the final design, who will be calling idMatches? Will the caller have
access to the display items and chunks? If so, can the caller just look up
whether the first display item corresponds to the current cache generation?

[Xianzhu, 2016/07/14 23:03:24]

Chunk ids should be stable even if the contents changes (so that we can track
changes of each chunk), so we can't use cache generation (a new chunk can match
a new chunk even if its contents are invalidated), and can't use the id of the
first display item as the id of the chunk (except that the chunk is created for
a foreign layer).

For example,

<div id="container" style="transform...">
  <div id="child1">Child1</div>
  <div id="child2">Child2</div>
</div>

there will be a chunk including the painting of "Child1" and "Child2" in
foreground phase. The id of the chunk is (container, PaintPhaseForeground).

Then we remove child1 from container and start another document cycle. In the
new painting, there is still a chunk with id (container, PaintPhaseForeground),
and this id matches the old chunk, so we can compare the old chunk and new chunk
to see what changed, and issue necessary paint invalidations on the chunk.

The matching can be also used in incremental layerization. In the above case, we
should not re-create the layer for the chunk, because the new chunk can match a
old chunk.

In the next steps, we will match new chunks to old chunks during painting for
rasterization invalidation and layerization. The algorithm will be similar to
matching of cached display items, including sequential matching and indexed
matching.

+        // even if it's id equals the old chunk's id (which may happen if this chunk's
+        // client is just created at the same address of the old chunk's deleted client).
+        return !id->client.isJustCreated();
+    }
+
     // Index of the first drawing in this chunk.
     unsigned beginIndex;
 
@@ -37,6 +61,9 @@ struct PaintChunk {
     // |endIndex - beginIndex| drawings in the chunk.
     unsigned endIndex;
 
+    // Identifier of this chunk. If it has a value, it should be unique.
+    Optional<DisplayItem::Id> id;

[pdr., 2016/07/14 22:22:06]

Can you add a comment here about what a null value means? Maybe that it causes
the paint chunk to be uncacheable?

Also, can you add something like "The first display item's id forms the
PaintChunk's id"?

[Xianzhu, 2016/07/14 23:03:24]

Done.
See the previous comment.

+
     // The paint properties which apply to this chunk.
     PaintChunkProperties properties;
 
@@ -51,6 +78,7 @@ inline bool operator==(const PaintChunk& a, const PaintChunk& b)
 {
     return a.beginIndex == b.beginIndex
         && a.endIndex == b.endIndex
+        && a.id == b.id
         && a.properties == b.properties
         && a.bounds == b.bounds
         && a.knownToBeOpaque == b.knownToBeOpaque;