Find cached display items directly during painting

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 98 matching lines @@
         TableSectionBoxShadowInset,
         TableSectionBoxShadowNormal,
         TableRowBoxShadowInset,
         TableRowBoxShadowNormal,
         VideoBitmap,
         WebPlugin,
         WebFont,
         ReflectionMask,
         DrawingLast = ReflectionMask,
 
-        CachedDrawingFirst,
-        CachedDrawingLast = CachedDrawingFirst + DrawingLast - DrawingFirst,
-
         ForeignLayerFirst,
         ForeignLayerCanvas = ForeignLayerFirst,
         ForeignLayerPlugin,
         ForeignLayerVideo,
         ForeignLayerLast = ForeignLayerVideo,
 
         ClipFirst,
         ClipBoxPaintPhaseFirst = ClipFirst,
         ClipBoxPaintPhaseLast = ClipBoxPaintPhaseFirst + PaintPhaseMax,
         ClipColumnBoundsPaintPhaseFirst,
@@ skipping 45 matching lines @@
         EndFilter,
         BeginCompositing,
         EndCompositing,
         BeginTransform,
         EndTransform,
         BeginClipPath,
         EndClipPath,
 
         Subsequence,
         EndSubsequence,
-        CachedSubsequence,
 
         UninitializedType,
         TypeLast = UninitializedType
     };
 
     static_assert(TableCollapsedBorderBase >= TableCollapsedBorderUnalignedBase, "TableCollapsedBorder types overlap with other types");
     static_assert((TableCollapsedBorderBase & 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,
@@ skipping 19 matching lines @@
 
     virtual ~DisplayItem() { }
 
     // Ids are for matching new DisplayItems with existing DisplayItems.
     struct Id {
         STACK_ALLOCATED();
         Id(const DisplayItemClient& client, const Type type)
             : client(client)
             , type(type) { }
 
-        bool matches(const DisplayItem& item) const
-        {
-            // We should always convert to non-cached types before matching.
-            ASSERT(!isCachedType(item.m_type));
-            ASSERT(!isCachedType(type));
-            return &client == item.m_client && type == item.m_type;
-        }
-
         const DisplayItemClient& client;
         const Type type;
     };
 
-    // Convert cached type to non-cached type (e.g., Type::CachedSVGImage -> Type::SVGImage).
-    static Type nonCachedType(Type type)
-    {
-        if (isCachedDrawingType(type))
-            return cachedDrawingTypeToDrawingType(type);
-        if (type == CachedSubsequence)
-            return Subsequence;
-        return type;
-    }
-
-    // Return the Id with cached type converted to non-cached type.
-    Id nonCachedId() const
-    {
-        return Id(*m_client, nonCachedType(m_type));
-    }
+    Id getId() const { return Id(*m_client, m_type); }
 
     virtual void replay(GraphicsContext&) const { }
 
     const DisplayItemClient& client() const { ASSERT(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.
@@ skipping 32 matching lines @@
 #define DEFINE_PAINT_PHASE_CONVERSION_METHOD(Category) \
     static Type paintPhaseTo##Category##Type(int paintPhase) \
     { \
         static_assert(Category##PaintPhaseLast - Category##PaintPhaseFirst == PaintPhaseMax, \
             "Invalid paint-phase-based category " #Category ". See comments of DisplayItem::Type"); \
         return static_cast<Type>(paintPhase + Category##PaintPhaseFirst); \
     }
 
     DEFINE_CATEGORY_METHODS(Drawing)
     DEFINE_PAINT_PHASE_CONVERSION_METHOD(Drawing)
-    DEFINE_CATEGORY_METHODS(CachedDrawing)
-    DEFINE_CONVERSION_METHODS(Drawing, drawing, CachedDrawing, cachedDrawing)
 
     DEFINE_CATEGORY_METHODS(ForeignLayer)
 
     DEFINE_PAIRED_CATEGORY_METHODS(Clip, clip)
     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_PAIRED_CATEGORY_METHODS(Transform3D, transform3D)
 
-    static bool isCachedType(Type type) { return isCachedDrawingType(type) || type == CachedSubsequence; }
-    bool isCached() const { return isCachedType(m_type); }
     static bool isCacheableType(Type type) { return isDrawingType(type) || type == Subsequence; }
     bool isCacheable() const { return !skippedCache() && isCacheableType(m_type); }
 
     virtual bool isBegin() const { return false; }
     virtual bool isEnd() const { return false; }
 
 #if DCHECK_IS_ON()
     virtual bool isEndAndPairedWith(DisplayItem::Type otherType) const { return false; }
     virtual bool equals(const DisplayItem& other) const
     {
@@ skipping 40 matching lines @@
     static_assert(TypeLast < (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
 };
 
+inline bool operator==(const DisplayItem::Id& a, const DisplayItem::Id& b)
+{
+    return a.client == b.client && a.type == b.type;
+}
+
+inline bool operator!=(const DisplayItem::Id& a, const DisplayItem::Id& b)
+{
+    return !(a == b);
+}
+
 class PLATFORM_EXPORT PairedBeginDisplayItem : public DisplayItem {
 protected:
     PairedBeginDisplayItem(const DisplayItemClient& client, Type type, size_t derivedSize) : DisplayItem(client, type, derivedSize) { }
 
 private:
     bool isBegin() const final { return true; }
 };
 
 class PLATFORM_EXPORT PairedEndDisplayItem : public DisplayItem {
 protected:
     PairedEndDisplayItem(const DisplayItemClient& client, Type type, size_t derivedSize) : DisplayItem(client, type, derivedSize) { }
 
 #if ENABLE(ASSERT)
     bool isEndAndPairedWith(DisplayItem::Type otherType) const override = 0;
 #endif
 
 private:
     bool isEnd() const final { return true; }
 };
 
 } // namespace blink
 
 #endif // DisplayItem_h