Move use of DisplayItemList's vector behind an explicit DisplayItems interface.

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"
@@ skipping 158 matching lines @@
         BeginSubtreeLast = BeginSubtreePaintPhaseLast,
 
         EndSubtreeFirst,
         EndSubtreePaintPhaseFirst = EndSubtreeFirst,
         EndSubtreePaintPhaseLast = EndSubtreePaintPhaseFirst + PaintPhaseMax,
         EndSubtreeLast = EndSubtreePaintPhaseLast,
 
         TypeLast = EndSubtreeLast
     };
 
+    struct Id {
+        Id(DisplayItemClient c, Type t) : client(c), type(t), scopeId(0), scopeContainer(nullptr)
+        {
+            ASSERT(c);
+        }
+
+        bool operator==(const Id& other) const
+        {
+            return client == other.client
+                && type == other.type
+                && scopeId == other.scopeId
+                && scopeContainer == other.scopeContainer;
+        }
+
+        bool equalToExceptForType(const Id& other, DisplayItem::Type overrideType) const
+        {
+            return client == other.client
+                && type == overrideType
+                && scopeId == other.scopeId
+                && scopeContainer == other.scopeContainer;
+        }
+
+        const DisplayItemClient client;
+        const Type type;
+        int scopeId;
+        DisplayItemClient scopeContainer;
+    };
+
     virtual ~DisplayItem() { }
 
     virtual void replay(GraphicsContext&) { }
 
     DisplayItemClient client() const { return m_client; }
     Type type() const { return m_type; }
+    Id id() const
+    {
+        Id result(m_client, m_type);
+        result.scopeId = m_scopeId;
+        result.scopeContainer = m_scopeContainer;
+        return result;
+    }
     bool idsEqual(const DisplayItem& other, Type overrideType) const
     {
-        return m_client == other.m_client
-            && m_type == overrideType
-            && m_scopeId == other.m_scopeId
-            && m_scopeContainer == other.m_scopeContainer;
+        return id().equalToExceptForType(other.id(), overrideType);
     }
 
     void setScope(int scopeId, DisplayItemClient scopeContainer)
     {
         m_scopeId = scopeId;
         m_scopeContainer = scopeContainer;
     }
 
     // For DisplayItemList only. Painters should use DisplayItemCacheSkipper instead.
     void setSkippedCache() { m_skippedCache = true; }
@@ skipping 58 matching lines @@
     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)
 
     virtual bool isBegin() const { return false; }
     virtual bool isEnd() const { return false; }
 
 #if ENABLE(ASSERT)
-    virtual bool isEndAndPairedWith(const DisplayItem& other) const { return false; }
+    virtual bool isEndAndPairedWith(DisplayItem::Type otherType) const { return false; }
 #endif
 
     virtual bool drawsContent() const { return false; }
 
 #ifndef NDEBUG
     static WTF::String typeAsDebugString(DisplayItem::Type);
     const WTF::String& clientDebugString() const { return m_clientDebugString; }
     WTF::String asDebugString() const;
     virtual void dumpPropertiesAsDebugString(WTF::StringBuilder&) const;
 #endif
@@ skipping 29 matching lines @@
 
 private:
     virtual bool isBegin() const override final { return true; }
 };
 
 class PLATFORM_EXPORT PairedEndDisplayItem : public DisplayItem {
 protected:
     PairedEndDisplayItem(const DisplayItemClientWrapper& client, Type type) : DisplayItem(client, type) { }
 
 #if ENABLE(ASSERT)
-    virtual bool isEndAndPairedWith(const DisplayItem& other) const override = 0;
+    virtual bool isEndAndPairedWith(DisplayItem::Type otherType) const override = 0;
 #endif
 
 private:
     virtual bool isEnd() const override final { return true; }
 };
 
 } // namespace blink
 
 #endif // DisplayItem_h