Slimming Paint phase 2 compositing algorithm plumbing & skeleton display list API.

Source/platform/graphics/paint/DisplayItemList.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 DisplayItemList_h
 #define DisplayItemList_h
 
 #include "platform/PlatformExport.h"
 #include "platform/graphics/ListContainer.h"
 #include "platform/graphics/paint/DisplayItem.h"
 #include "platform/graphics/paint/Transform3DDisplayItem.h"
+#include "public/platform/WebDisplayList.h"
 #include "wtf/HashMap.h"
 #include "wtf/PassOwnPtr.h"
 #include "wtf/Utility.h"
 #include "wtf/Vector.h"
 
 namespace blink {
 
 class GraphicsContext;
 
 using DisplayItems = ListContainer<DisplayItem>;
 
 static const size_t kInitialDisplayItemsCapacity = 64;
 static const size_t kMaximumDisplayItemSize = sizeof(BeginTransform3DDisplayItem);
 
-class PLATFORM_EXPORT DisplayItemList {
+class PLATFORM_EXPORT DisplayItemList : public WebDisplayList {
     WTF_MAKE_NONCOPYABLE(DisplayItemList);
     WTF_MAKE_FAST_ALLOCATED(DisplayItemList);
 public:
     static PassOwnPtr<DisplayItemList> create()
     {
         return adoptPtr(new DisplayItemList());
     }
 
     // These methods are called during paint invalidation.
     void invalidate(DisplayItemClient);
     void invalidateAll();
 
     // These methods are called during painting.
     template <typename DisplayItemClass, typename... Args>
     DisplayItemClass& createAndAppend(Args&&... args)
     {
         static_assert(WTF::IsSubclass<DisplayItemClass, DisplayItem>::value,
             "Can only createAndAppend subclasses of DisplayItem.");
         static_assert(sizeof(DisplayItemClass) <= kMaximumDisplayItemSize,
             "DisplayItem subclass is larger than kMaximumDisplayItemSize.");
 
         DisplayItemClass* displayItem = m_newDisplayItems.allocateAndConstruct<DisplayItemClass>(WTF::forward<Args>(args)...);
         processNewItem(displayItem);
         return *displayItem;
     }
     void beginScope(DisplayItemClient);
     void endScope(DisplayItemClient);
 
+    void addPixelRef(const skia::PixelRefUtils::PositionPixelRef&);
+
     // True if the last display item is a begin that doesn't draw content.
     bool lastDisplayItemIsNoopBegin() const;
     void removeLastDisplayItem();
 
     void beginSkippingCache() { ++m_skippingCacheCount; }
     void endSkippingCache() { ASSERT(m_skippingCacheCount > 0); --m_skippingCacheCount; }
     bool skippingCache() const { return m_skippingCacheCount; }
 
-    // Must be called when a painting is finished.
-    void commitNewDisplayItems();
+    // Must be called when a painting is finished. If passed, the diff is initialized
+    // to the difference of the new display list from the last time commitNewDisplayItems() was called.
+    void commitNewDisplayItems(WebDisplayListDiff* = 0);
 
     // Returns the approximate memory usage, excluding memory likely to be
     // shared with the embedder after copying to WebDisplayItemList.
     // Should only be called right after commitNewDisplayItems.
     size_t approximateUnsharedMemoryUsage() const;
 
     // Get the paint list generated after the last painting.
     const DisplayItems& displayItems() const;
+    const WebVector<WebDisplayItem>& webDisplayItems() const override;
+    // Get the pixel refs generated after the last painting.
+    const skia::DiscardablePixelRefList& pixelRefs() const override;
 
     bool clientCacheIsValid(DisplayItemClient) const;
 
     // Commits the new display items and plays back the updated display items into the given context.
     void commitNewDisplayItemsAndReplay(GraphicsContext& context)
     {
         commitNewDisplayItems();
         replay(context);
     }
 
@@ skipping 75 matching lines @@
     // display items.
     struct Scope {
         Scope(DisplayItemClient c, int i) : client(c), id(i) { }
         DisplayItemClient client;
         int id;
     };
     typedef HashMap<DisplayItemClient, int> ClientScopeIdMap;
     ClientScopeIdMap m_clientScopeIdMap;
     Vector<Scope> m_scopeStack;
 
+    skia::DiscardablePixelRefList m_currentPixelRefs;
+    skia::DiscardablePixelRefList m_newPixelRefs;
+
 #if ENABLE(ASSERT)
     // This is used to check duplicated ids during add(). We could also check during
     // updatePaintList(), but checking during add() helps developer easily find where
     // the duplicated ids are from.
     DisplayItemIndicesByClientMap m_newDisplayItemIndicesByClient;
 #endif
+
+    // This is a placeholder, not a real data structure.
+    WebVector<WebDisplayItem> m_webDisplayItems;
 };
 
 } // namespace blink
 
 #endif // DisplayItemList_h