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)

[pdr., 2016/07/13 23:31:34]

Since this is just for foreign layers, foreignLayerId?

Since it's just used as an id, could we just store a raw pointer to a
ForeignLayerDisplayItem*?

[Xianzhu, 2016/07/14 04:53:09]

The ids are not just for foreign layers, but for all chunks. They need to be
unique, while also need to be stable even if the contents of the chunk changes
between frames.

A new chunk matches an old chunk means that we need to treat the old and new
chunk as the same thing even if it changed. If the old chunk has a layer, we
need to associate the new chunk to the original layer of the old chunk, instead
of creating a new layer. This is important otherwise we'll recreate the whole
layer tree in each frame and loose all benefits of compositing layers.

In this CL I use the client creating the chunk (plus optional type to
distinguish multiple chunks created by the same client) as the chunk id, so that
the old chunk create in the previous frame and the new chunk created in the
current frame created by the same object are treated as the same chunk. We'll
compare the old and new chunks to determine which part of the layer needs
rasterization invalidation. We'll also avoid creating new layer for the new
chunk.

+        : 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 created in the latest paint matches an old PaintChunk
+    // created in the previous paint.
+    bool idMatches(const PaintChunk& other) const

[pdr., 2016/07/13 23:31:34]

Is this used/tested? The need for isJustCreated is confusing to me.

[Xianzhu, 2016/07/14 04:53:09]

Added PaintChunkTest.* for this method.

The isJustCreated logic is now tested by PaintChunkTest.IdNotMatchesJustCreated.
Updated the comments to be clearer.

This will be the key method for matching cached and new paint chunks for
rasterization invalidation. 

+    {
+        // A PaintChunk without an id doesn't match any other PaintChunks.
+        if (!id || !other.id)
+            return false;
+        if (*id != *other.id)
+            return false;
+        // If the client is just created, it's actually a new client. The client
+        // of this or the other PaintChunk was allocated at the same address and has
+        // been deleted.
+        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;
+
     // 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