Create PaintChunk and begin writing code to build paint chunks.

third_party/WebKit/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/RuntimeEnabledFeatures.h"
 #include "platform/geometry/LayoutPoint.h"
 #include "platform/graphics/ContiguousContainer.h"
 #include "platform/graphics/paint/DisplayItem.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/PassOwnPtr.h"
 #include "wtf/Utility.h"
 #include "wtf/Vector.h"
 
 namespace blink {
 
+class CachedDisplayItem;
+class DrawingDisplayItem;
 class GraphicsContext;
 
 // kDisplayItemAlignment must be a multiple of alignof(derived display item) for
 // each derived display item; the ideal value is the least common multiple.
 // Currently the limiting factor is TransformtionMatrix (in
 // BeginTransform3DDisplayItem), which requests 16-byte alignment.
 static const size_t kDisplayItemAlignment = WTF_ALIGN_OF(BeginTransform3DDisplayItem);
 static const size_t kInitialDisplayItemsCapacity = 64;
 static const size_t kMaximumDisplayItemSize = sizeof(BeginTransform3DDisplayItem);
 
@@ skipping 37 matching lines @@
     void invalidateUntracked(DisplayItemClient);
     void invalidateAll();
 
     // Record when paint offsets change during paint.
     void invalidatePaintOffset(const DisplayItemClientWrapper&);
 #if ENABLE(ASSERT)
     bool paintOffsetWasInvalidated(DisplayItemClient) const;
 #endif
 
     // These methods are called during painting.
+
+    // Provide a new set of paint properties to apply to recorded display items,
+    // for Slimming Paint v2.
+    void updateCurrentPaintProperties(const PaintProperties&);
+
     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);
@@ skipping 19 matching lines @@
     void commitNewDisplayItems(DisplayListDiff* = 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;
 
+    // Get the paint chunks generated after the last painting.
+    const Vector<PaintChunk>& paintChunks() const;
+
     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);
     }
 
     void appendToWebDisplayItemList(WebDisplayItemList*);
@@ skipping 64 matching lines @@
     void checkUnderInvalidation(DisplayItems::iterator& newIt, DisplayItems::iterator& currentIt);
     void checkCachedDisplayItemIsUnchanged(const char* messagePrefix, const DisplayItem& newItem, const DisplayItem& oldItem);
     void checkNoRemainingCachedDisplayItems();
 #endif
 
     void replay(GraphicsContext&);
 
     DisplayItems m_currentDisplayItems;
     DisplayItems m_newDisplayItems;
 
+    // In Slimming Paint v2, paint properties (e.g. transform) useful for
+    // compositing are stored in corresponding paint chunks instead of in the
+    // display items.
+    Vector<PaintChunk> m_currentPaintChunks;
+    PaintChunker m_newPaintChunks;
+
     // Contains all clients having valid cached paintings if updated.
     // It's lazily updated in updateValidlyCachedClientsIfNeeded().
     // FIXME: 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 bool m_validlyCachedClientsDirty;
 
 #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.
@@ skipping 17 matching lines @@
     // the duplicated ids are from.
     DisplayItemIndicesByClientMap m_newDisplayItemIndicesByClient;
 #endif
 
     OwnPtr<Vector<String>> m_trackedPaintInvalidationObjects;
 };
 
 } // namespace blink
 
 #endif // DisplayItemList_h