PaintChunk::id

third_party/WebKit/Source/platform/graphics/paint/PaintChunk.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 PaintChunk_h
 #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 {
 
 // A contiguous sequence of drawings with common paint properties.
 //
 // This is expected to be owned by the paint artifact which also owns the
 // related drawings.
 //
 // This is a Slimming Paint v2 class.
 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
     {
         ASSERT(endIndex >= beginIndex);
         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;
 
     // Index of the first drawing not in this chunk, so that there are
     // |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;
 
     // The total bounds of this paint chunk's contents.
     FloatRect bounds;
 
     // True if the bounds are filled entirely with opaque contents.
     bool knownToBeOpaque;
 };
 
 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;
 }
 
 inline bool operator!=(const PaintChunk& a, const PaintChunk& b)
 {
     return !(a == b);
 }
 
 // Redeclared here to avoid ODR issues.
 // See platform/testing/PaintPrinters.h.
 void PrintTo(const PaintChunk&, std::ostream*);
 
 } // namespace blink
 
 #endif // PaintChunk_h