First version of new merge algorithm (not enabled yet)

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/paint/DisplayItemClient.h"
 #include "wtf/Assertions.h"
+#include "wtf/HashTraits.h"
 #include "wtf/PassOwnPtr.h"
 
 #ifndef NDEBUG
 #include "wtf/text/StringBuilder.h"
 #include "wtf/text/WTFString.h"
 #endif
 
 
 namespace blink {
 
@@ skipping 90 matching lines @@
         EndScrollLast = EndScrollFirst + ScrollLast - ScrollFirst,
 
         BeginFilter,
         EndFilter,
         BeginCompositing,
         EndCompositing,
         BeginTransform,
         EndTransform,
         BeginClipPath,
         EndClipPath,
+
+        SubtreeCachedFirst,
+        SubtreeCachedPaintPhaseFirst = SubtreeCachedFirst,
+        SubtreeCachedPaintPhaseLast = SubtreeCachedPaintPhaseFirst + PaintPhaseMax,
+        SubtreeCachedLast = SubtreeCachedPaintPhaseLast,
+
+        BeginSubtreeFirst,
+        BeginSubtreePaintPhaseFirst = BeginSubtreeFirst,
+        BeginSubtreePaintPhaseLast = BeginSubtreePaintPhaseFirst + PaintPhaseMax,
+        BeginSubtreeLast = BeginSubtreePaintPhaseLast,
+
+        EndSubtreeFirst,
+        EndSubtreePaintPhaseFirst = EndSubtreeFirst,
+        EndSubtreePaintPhaseLast = EndSubtreePaintPhaseFirst + PaintPhaseMax,
+        EndSubtreeLast = EndSubtreePaintPhaseLast,
+    };
+
+    struct Id {
+        Id(DisplayItemClient c, Type t) : client(c), type(t) { }
+
+        bool operator==(const Id& other) const { return client == other.client && type == other.type; }
+        bool operator!=(const Id& other) const { return !(*this == other); }
+
+        DisplayItemClient client;
+        Type type;
     };
 
     // Create a dummy display item which just holds the id but has no display operation.
     // It helps a CachedDisplayItem to match the corresponding original empty display item.
     static PassOwnPtr<DisplayItem> create(DisplayItemClient client, Type type) { return adoptPtr(new DisplayItem(client, type)); }
 
     virtual ~DisplayItem() { }
 
     virtual void replay(GraphicsContext*) { }
 
     DisplayItemClient client() const { return m_id.client; }
     Type type() const { return m_id.type; }
-    bool idsEqual(const DisplayItem& other) const { return m_id.client == other.m_id.client && m_id.type == other.m_id.type; }
+    const Id& id() const { return m_id; }
+    bool idsEqual(const DisplayItem& other) const { return m_id == other.m_id; }
 
     virtual void appendToWebDisplayItemList(WebDisplayItemList*) const { }
 
     // See comments of enum Type for usage of the following macros.
 #define DEFINE_CATEGORY_METHODS(Category) \
     static bool is##Category##Type(Type type) { return type >= Category##First && type <= Category##Last; } \
     bool is##Category() const { return is##Category##Type(type()); }
 
 #define DEFINE_CONVERSION_METHODS(Category1, category1, Category2, category2) \
     static Type category1##TypeTo##Category2##Type(Type type) \
@@ skipping 31 matching lines @@
     DEFINE_PAINT_PHASE_CONVERSION_METHOD(ClipLayerFragment)
     DEFINE_PAINT_PHASE_CONVERSION_METHOD(ClipBox)
     DEFINE_PAINT_PHASE_CONVERSION_METHOD(ClipColumnBounds)
 
     DEFINE_PAIRED_CATEGORY_METHODS(FloatClip, floatClip)
     DEFINE_PAINT_PHASE_CONVERSION_METHOD(FloatClip)
 
     DEFINE_PAIRED_CATEGORY_METHODS(Scroll, scroll)
     DEFINE_PAINT_PHASE_CONVERSION_METHOD(Scroll)
 
+    DEFINE_CATEGORY_METHODS(SubtreeCached)
+    DEFINE_PAINT_PHASE_CONVERSION_METHOD(SubtreeCached)
+    DEFINE_CATEGORY_METHODS(BeginSubtree)
+    DEFINE_PAINT_PHASE_CONVERSION_METHOD(BeginSubtree)
+    DEFINE_CATEGORY_METHODS(EndSubtree)
+    DEFINE_PAINT_PHASE_CONVERSION_METHOD(EndSubtree)
+    DEFINE_CONVERSION_METHODS(SubtreeCached, subtreeCached, BeginSubtree, beginSubtree)
+    DEFINE_CONVERSION_METHODS(SubtreeCached, subtreeCached, EndSubtree, endSubtree)
+    DEFINE_CONVERSION_METHODS(BeginSubtree, beginSubtree, EndSubtree, endSubtree)
+
+    bool isBegin() const { return isClip() || isFloatClip() || isScroll() || isBeginSubtree() || type() == BeginFilter || type() == BeginCompositing || type() == BeginTransform || type() == BeginClipPath; }

[pdr., 2015/02/04 05:19:58]

Can we introduce a subclass of paired display item types to make this cleaner?
Keeping this up to date is error-prone.

[Xianzhu, 2015/02/04 20:46:32]

Done and separated into https://codereview.chromium.org/900653003/.

Tried to avoid virtual functions, but it seems not worth it to sacrifice code
maintainability.

+    bool isEnd() const { return isEndClip() || isEndFloatClip() || isEndScroll() || isEndSubtree() || type() == EndFilter || type() == EndCompositing || type() == EndTransform || type() == EndClipPath; }
+
+#if ENABLE(ASSERT)
+    bool isEndAndPairedWith(DisplayItem& other) const
+    {
+        return client() == other.client()
+            && ((isEndClip() && other.isClip() && type() == clipTypeToEndClipType(other.type()))
+                || (isEndFloatClip() && other.isFloatClip() && type() == floatClipTypeToEndFloatClipType(other.type()))
+                || (isEndScroll() && other.isScroll() && type() == scrollTypeToEndScrollType(other.type()))
+                || (isEndSubtree() && other.isBeginSubtree() && type() == beginSubtreeTypeToEndSubtreeType(other.type()))
+                || (type() == EndFilter && other.type() == BeginFilter)
+                || (type() == EndCompositing && other.type() == BeginCompositing)
+                || (type() == EndTransform && other.type() == BeginTransform)
+                || (type() == EndClipPath && other.type() == BeginClipPath));
+    }
+#endif
+
 #ifndef NDEBUG
     static WTF::String typeAsDebugString(DisplayItem::Type);
 
     void setClientDebugString(const WTF::String& clientDebugString) { m_clientDebugString = clientDebugString; }
     const WTF::String& clientDebugString() const { return m_clientDebugString; }
 
     WTF::String asDebugString() const;
     virtual void dumpPropertiesAsDebugString(WTF::StringBuilder&) const;
 #endif
 
 protected:
     DisplayItem(DisplayItemClient client, Type type)
         : m_id(client, type)
     {
         ASSERT(client);
     }
 
 private:
-    struct Id {
-        Id(DisplayItemClient c, Type t)
-            : client(c)
-            , type(t)
-        {
-            ASSERT(client);
-        }
-
-        const DisplayItemClient client;
-        const Type type;
-    } m_id;
+    const Id m_id;
 #ifndef NDEBUG
     WTF::String m_clientDebugString;
 #endif
 };
 
-}
+} // namespace blink
+
+// Allow DisplayItem::Id to be hash key.
+namespace WTF {
+
+template<> struct DefaultHash<blink::DisplayItem::Id> {
+    struct Hash {
+        static unsigned hash(const blink::DisplayItem::Id& id) { return pairIntHash(PtrHash<blink::DisplayItemClient>::hash(id.client), static_cast<unsigned>(id.type)); }
+        static bool equal(const blink::DisplayItem::Id& a, const blink::DisplayItem::Id& b) { return a == b; }
+        static const bool safeToCompareToEmptyOrDeleted = true;
+    };
+};
+template<> struct HashTraits<blink::DisplayItem::Id> : GenericHashTraits<blink::DisplayItem::Id> {
+    static const bool emptyValueIsZero = true;
+    static const bool needsDestruction = false;
+    static blink::DisplayItem::Id emptyValue() { return blink::DisplayItem::Id(nullptr, static_cast<blink::DisplayItem::Type>(0)); }
+    static void constructDeletedValue(blink::DisplayItem::Id& slot, bool) { new (NotNull, &slot) blink::DisplayItem::Id(nullptr, static_cast<blink::DisplayItem::Type>(-1)); }
+    static bool isDeletedValue(const blink::DisplayItem::Id& id) { return id.type == static_cast<blink::DisplayItem::Type>(-1); }
+};
+
+} // namespace WTF
 
 #endif // DisplayItem_h