Make DisplayItemClient an interface

third_party/WebKit/Source/platform/graphics/paint/PaintController.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 PaintController_h
 #define PaintController_h
 
 #include "platform/PlatformExport.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/geometry/IntRect.h"
 #include "platform/geometry/LayoutPoint.h"
 #include "platform/graphics/ContiguousContainer.h"
 #include "platform/graphics/PaintInvalidationReason.h"
 #include "platform/graphics/paint/DisplayItem.h"
 #include "platform/graphics/paint/DisplayItemList.h"
 #include "platform/graphics/paint/PaintArtifact.h"
 #include "platform/graphics/paint/PaintChunk.h"
 #include "platform/graphics/paint/PaintChunker.h"
 #include "platform/graphics/paint/Transform3DDisplayItem.h"
 #include "wtf/Alignment.h"
 #include "wtf/HashMap.h"
+#include "wtf/HashSet.h"
 #include "wtf/PassOwnPtr.h"
 #include "wtf/Utility.h"
 #include "wtf/Vector.h"
 
 namespace blink {
 
 class GraphicsContext;
 
 static const size_t kInitialDisplayItemListCapacityBytes = 512;
 
 // Responsible for processing display items as they are produced, and producing
 // a final paint artifact when complete. This class includes logic for caching,
 // cache invalidation, and merging.
 class PLATFORM_EXPORT PaintController {
     WTF_MAKE_NONCOPYABLE(PaintController);
     USING_FAST_MALLOC(PaintController);
 public:
     static PassOwnPtr<PaintController> create()
     {
         return adoptPtr(new PaintController());
     }
 
     // These methods are called during paint invalidation (or paint if SlimmingPaintV2 is on).
 
     // If |visualRect| is not nullptr, for slimming paint v1, it contains all pixels within the GraphicsLayer
     // which might be painted into by the display item client, in coordinate space of the GraphicsLayer.
     // TODO(pdr): define it for spv2.
     // |visualRect| can be nullptr if we know it's unchanged and PaintController has cached the previous value.
-    void invalidate(const DisplayItemClientWrapper&, PaintInvalidationReason, const IntRect* visualRect);
-    void invalidateUntracked(DisplayItemClient);
+    void invalidate(const DisplayItemClient&, PaintInvalidationReason, const IntRect* visualRect);
+    void invalidateUntracked(const DisplayItemClient&);
     void invalidateAll();
 
     // Record when paint offsets change during paint.
-    void invalidatePaintOffset(const DisplayItemClientWrapper&);
+    void invalidatePaintOffset(const DisplayItemClient&);
 #if ENABLE(ASSERT)
-    bool paintOffsetWasInvalidated(DisplayItemClient) const;
+    bool paintOffsetWasInvalidated(const DisplayItemClient&) const;
 #endif
 
     // These methods are called during painting.
 
     // Provide a new set of paint chunk properties to apply to recorded display
     // items, for Slimming Paint v2.
     void updateCurrentPaintChunkProperties(const PaintChunkProperties&);
 
     // Retrieve the current paint properties.
     const PaintChunkProperties& currentPaintChunkProperties() const;
@@ skipping 48 matching lines @@
     // Returns the approximate memory usage, excluding memory likely to be
     // shared with the embedder after copying to WebPaintController.
     // Should only be called right after commitNewDisplayItems.
     size_t approximateUnsharedMemoryUsage() const;
 
     // Get the artifact generated after the last commit.
     const PaintArtifact& paintArtifact() const;
     const DisplayItemList& displayItemList() const { return paintArtifact().displayItemList(); }
     const Vector<PaintChunk>& paintChunks() const { return paintArtifact().paintChunks(); }
 
-    bool clientCacheIsValid(DisplayItemClient) const;
+    bool clientCacheIsValid(const DisplayItemClient&) const;
     bool cacheIsEmpty() const { return m_currentPaintArtifact.isEmpty(); }
 
     bool displayItemConstructionIsDisabled() const { return m_constructionDisabled; }
     void setDisplayItemConstructionIsDisabled(const bool disable) { m_constructionDisabled = disable; }
 
     bool textPainted() const { return m_textPainted; }
     void setTextPainted() { m_textPainted = true; }
     bool imagePainted() const { return m_imagePainted; }
     void setImagePainted() { m_imagePainted = true; }
 
@@ skipping 14 matching lines @@
     {
         ASSERT(RuntimeEnabledFeatures::slimmingPaintV2Enabled());
         m_trackedPaintInvalidationObjects = nullptr;
     }
     Vector<String> trackedPaintInvalidationObjects()
     {
         ASSERT(RuntimeEnabledFeatures::slimmingPaintV2Enabled());
         return m_trackedPaintInvalidationObjects ? *m_trackedPaintInvalidationObjects : Vector<String>();
     }
 
-    bool clientHasCheckedPaintInvalidation(DisplayItemClient client) const
+    bool clientHasCheckedPaintInvalidation(const DisplayItemClient& client) const
     {
         ASSERT(RuntimeEnabledFeatures::slimmingPaintSynchronizedPaintingEnabled());
-        return m_clientsCheckedPaintInvalidation.contains(client);
+        return m_clientsCheckedPaintInvalidation.contains(&client);
     }
-    void setClientHasCheckedPaintInvalidation(DisplayItemClient client)
+    void setClientHasCheckedPaintInvalidation(const DisplayItemClient& client)
     {
         ASSERT(RuntimeEnabledFeatures::slimmingPaintSynchronizedPaintingEnabled());
-        m_clientsCheckedPaintInvalidation.add(client);
+        m_clientsCheckedPaintInvalidation.add(&client);
     }
 
 protected:
     PaintController()
         : m_newDisplayItemList(kInitialDisplayItemListCapacityBytes)
         , m_validlyCachedClientsDirty(false)
         , m_constructionDisabled(false)
         , m_textPainted(false)
         , m_imagePainted(false)
         , m_skippingCacheCount(0)
         , m_numCachedItems(0)
         , m_nextScope(1) { }
 
 private:
     // Set new item state (scopes, cache skipping, etc) for a new item.
     void processNewItem(DisplayItem&);
 
     void updateValidlyCachedClientsIfNeeded() const;
 
-    void invalidateClient(const DisplayItemClientWrapper&);
+    void invalidateClient(const DisplayItemClient&);
 
 #ifndef NDEBUG
     WTF::String displayItemListAsDebugString(const DisplayItemList&) const;
 #endif
 
     // Indices into PaintList of all DrawingDisplayItems and BeginSubsequenceDisplayItems of each client.
     // Temporarily used during merge to find out-of-order display items.
-    using DisplayItemIndicesByClientMap = HashMap<DisplayItemClient, Vector<size_t>>;
+    using DisplayItemIndicesByClientMap = HashMap<const DisplayItemClient*, Vector<size_t>>;
 
     static size_t findMatchingItemFromIndex(const DisplayItem::Id&, const DisplayItemIndicesByClientMap&, const DisplayItemList&);
     static void addItemToIndexIfNeeded(const DisplayItem&, size_t index, DisplayItemIndicesByClientMap&);
 
     struct OutOfOrderIndexContext;
     DisplayItemList::iterator findOutOfOrderCachedItem(const DisplayItem::Id&, OutOfOrderIndexContext&);
     DisplayItemList::iterator findOutOfOrderCachedItemForward(const DisplayItem::Id&, OutOfOrderIndexContext&);
     void copyCachedSubsequence(DisplayItemList::iterator& currentIt, DisplayItemList& updatedList);
 
 #if ENABLE(ASSERT)
     // The following two methods are for checking under-invalidations
     // (when RuntimeEnabledFeatures::slimmingPaintUnderInvalidationCheckingEnabled).
     void checkUnderInvalidation(DisplayItemList::iterator& newIt, DisplayItemList::iterator& currentIt);
     void checkCachedDisplayItemIsUnchanged(const char* messagePrefix, const DisplayItem& newItem, const DisplayItem& oldItem);
     void checkNoRemainingCachedDisplayItems();
 #endif
 
     // The last complete paint artifact.
     // In SPv2, this includes paint chunks as well as display items.
     PaintArtifact m_currentPaintArtifact;
 
     // Data being used to build the next paint artifact.
     DisplayItemList m_newDisplayItemList;
     PaintChunker m_newPaintChunks;
 
     // Contains all clients having valid cached paintings if updated.
     // It's lazily updated in updateValidlyCachedClientsIfNeeded().
     // TODO(wangxianzhu): In the future we can replace this with client-side repaint flags
     // to avoid the cost of building and querying the hash table.
-    mutable HashSet<DisplayItemClient> m_validlyCachedClients;
+    mutable HashSet<const DisplayItemClient*> m_validlyCachedClients;
     mutable bool m_validlyCachedClientsDirty;
 
     // Used during painting. Contains clients that have checked paint invalidation and
     // are known to be valid.
     // TODO(wangxianzhu): Use client side flag to avoid const of hash table.
-    HashSet<DisplayItemClient> m_clientsCheckedPaintInvalidation;
+    HashSet<const DisplayItemClient*> m_clientsCheckedPaintInvalidation;
 
 #if ENABLE(ASSERT)
     // Set of clients which had paint offset changes since the last commit. This is used for
     // ensuring paint offsets are only updated once and are the same in all phases.
-    HashSet<DisplayItemClient> m_clientsWithPaintOffsetInvalidations;
+    HashSet<const DisplayItemClient*> m_clientsWithPaintOffsetInvalidations;
 #endif
 
     // Allow display item construction to be disabled to isolate the costs of construction
     // in performance metrics.
     bool m_constructionDisabled;
 
     // Indicates this PaintController has ever had text. It is never reset to false.
     bool m_textPainted;
     bool m_imagePainted;
 
@@ skipping 13 matching lines @@
     // easily find where the duplicated ids are from.
     DisplayItemIndicesByClientMap m_newDisplayItemIndicesByClient;
 #endif
 
     OwnPtr<Vector<String>> m_trackedPaintInvalidationObjects;
 };
 
 } // namespace blink
 
 #endif // PaintController_h