[SPv2] Defer decision of raster invalidation after paint for changes z-index, transform, etc.

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

 // Copyright 2014 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 DisplayItem_h
 #define DisplayItem_h
 
 #include "platform/PlatformExport.h"
 #include "platform/graphics/ContiguousContainer.h"
 #include "platform/graphics/paint/DisplayItemClient.h"
@@ skipping 164 matching lines @@
         kBeginCompositing,
         kEndCompositing,
         kBeginTransform,
         kEndTransform,
         kBeginClipPath,
         kEndClipPath,
 
         kSubsequence,
         kEndSubsequence,
 
+        kHasBeenMoved,
         kUninitializedType,
         kTypeLast = kUninitializedType
     };
 
     static_assert(kTableCollapsedBorderBase >= kTableCollapsedBorderUnalignedBase, "TableCollapsedBorder types overlap with other types");
     static_assert((kTableCollapsedBorderBase & 0xf) == 0, "The lowest 4 bits of TableCollapsedBorderBase should be zero");
     // Bits or'ed onto TableCollapsedBorderBase to generate a real table collapsed border type.
     enum TableCollapsedBorderSides {
         TableCollapsedBorderTop = 1 << 0,
         TableCollapsedBorderRight = 1 << 1,
@@ skipping 22 matching lines @@
     struct Id {
         DISALLOW_NEW_EXCEPT_PLACEMENT_NEW();
         Id(const DisplayItemClient& client, const Type type)
             : client(client)
             , type(type) { }
 
         const DisplayItemClient& client;
         const Type type;
     };
 
-    Id getId() const { return Id(*m_client, m_type); }
+    Id getId() const { return Id(client(), getType()); }
 
     virtual void replay(GraphicsContext&) const { }
 
-    const DisplayItemClient& client() const { ASSERT(m_client); return *m_client; }
+    const DisplayItemClient& client() const
+    {
+        DCHECK(!hasBeenMoved());
+        DCHECK(m_client);
+        return *m_client;
+    }
+
     Type getType() const { return m_type; }
 
     // Size of this object in memory, used to move it with memcpy.
     // This is not sizeof(*this), because it needs to account for the size of
     // the derived class (i.e. runtime type). Derived classes are expected to
     // supply this to the DisplayItem constructor.
     size_t derivedSize() const { return m_derivedSize; }
 
     // For PaintController only. Painters should use DisplayItemCacheSkipper instead.
     void setSkippedCache() { m_skippedCache = true; }
@@ skipping 63 matching lines @@
     virtual bool isEndAndPairedWith(DisplayItem::Type otherType) const { return false; }
     virtual bool equals(const DisplayItem& other) const
     {
         return m_client == other.m_client
             && m_type == other.m_type
             && m_derivedSize == other.m_derivedSize
             && m_skippedCache == other.m_skippedCache;
     }
 #endif
 
-    // True if the client is non-null. Because m_client is const, this should
-    // never be false except when we explicitly create a tombstone/"dead display
-    // item" as part of moving an item from one list to another (see:
-    // DisplayItemList::appendByMoving).
-    bool hasValidClient() const { return m_client; }
+    // True if the item is a placeholder at the place of the original item that
+    // has been moved by DisplayItemList::appendByMoving().
+    bool hasBeenMoved() const { return m_type == kHasBeenMoved; }
+    size_t movedToIndex() const { DCHECK(hasBeenMoved()); return m_movedToIndex; }
 
     virtual bool drawsContent() const { return false; }
 
     // Override to implement specific analysis strategies.
     virtual void analyzeForGpuRasterization(SkPictureGpuAnalyzer&) const { }
 
 #ifndef NDEBUG
     static WTF::String typeAsDebugString(DisplayItem::Type);
     const WTF::String clientDebugString() const { return m_clientDebugString; }
     void setClientDebugString(const WTF::String& s) { m_clientDebugString = s; }
     WTF::String asDebugString() const;
     virtual void dumpPropertiesAsDebugString(WTF::StringBuilder&) const;
 #endif
 
 private:
-    // The default DisplayItem constructor is only used by
-    // ContiguousContainer::appendByMoving where an invalid DisplaItem is
+    // The DisplayItem(size_t) constructor is only used by
+    // ContiguousContainer::appendByMoving() where a placeholder DisplayItem is
     // constructed at the source location.
     template <typename T, unsigned alignment> friend class ContiguousContainer;
-
-    DisplayItem()
-        : m_client(nullptr)
-        , m_type(kUninitializedType)
+    DisplayItem(size_t movedToIndex)
+        : m_movedToIndex(movedToIndex)
+        , m_type(kHasBeenMoved)
         , m_derivedSize(sizeof(*this))
         , m_skippedCache(false)
     { }
 
-    const DisplayItemClient* m_client;
+    union {

[pdr., 2016/09/08 01:36:23]

This approach of using a union is very efficient but also very brittle. I can
imagine a person reading this for the first time would have a difficult time
understanding why a subclass like DrawingDisplayItem has two flavors in base
class. The way we move DisplayItems out of the contiguous container and replace
them with an invalid DisplayItem was already a lot of mental overhead.

What do you think of a simpler approach where we use an auxiliary array and
optimize later if needed? For example, before painting we could allocate a flat
array of size_t's that stores the index where the item has moved to.

[Xianzhu, 2016/09/08 03:01:42]

Done.

+        const DisplayItemClient* m_client; // For m_type != HasBeenMoved.
+        size_t m_movedToIndex; // For m_type == HasBeenMoved.
+    };
     static_assert(kTypeLast < (1 << 16), "DisplayItem::Type should fit in 16 bits");
     const Type m_type : 16;
     const unsigned m_derivedSize : 8; // size of the actual derived class
     unsigned m_skippedCache : 1;
 
 #ifndef NDEBUG
     WTF::String m_clientDebugString;
 #endif
 };
 
@@ skipping 23 matching lines @@
     bool isEndAndPairedWith(DisplayItem::Type otherType) const override = 0;
 #endif
 
 private:
     bool isEnd() const final { return true; }
 };
 
 } // namespace blink
 
 #endif // DisplayItem_h