Rename DisplayItemList to PaintController

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 DisplayItemList_h
-#define DisplayItemList_h
+#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/DisplayItems.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/PassOwnPtr.h"
 #include "wtf/Utility.h"
 #include "wtf/Vector.h"
 
 namespace blink {
 
 class GraphicsLayer;
 class GraphicsContext;
 
 static const size_t kInitialDisplayItemsCapacity = 64;
 
 // 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 DisplayItemList {
-    WTF_MAKE_NONCOPYABLE(DisplayItemList);
-    WTF_MAKE_FAST_ALLOCATED(DisplayItemList);
+class PLATFORM_EXPORT PaintController {
+    WTF_MAKE_NONCOPYABLE(PaintController);
+    WTF_MAKE_FAST_ALLOCATED(PaintController);
 public:
-    static PassOwnPtr<DisplayItemList> create()
+    static PassOwnPtr<PaintController> create()
     {
-        return adoptPtr(new DisplayItemList());
+        return adoptPtr(new PaintController());
     }
 
     // These methods are called during paint invalidation (or paint if SlimmingPaintSynchronizedPainting is on).
     void invalidate(const DisplayItemClientWrapper&, PaintInvalidationReason, const IntRect& previousPaintInvalidationRect, const IntRect& newPaintInvalidationRect);
     void invalidateUntracked(DisplayItemClient);
     void invalidateAll();
 
     // Record when paint offsets change during paint.
     void invalidatePaintOffset(const DisplayItemClientWrapper&);
 #if ENABLE(ASSERT)
@@ skipping 49 matching lines @@
 
     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. If passed, invalidations are recorded on the given
     // GraphicsLayer.
     void commitNewDisplayItems(GraphicsLayer* = 0);
 
     // Returns the approximate memory usage, excluding memory likely to be
-    // shared with the embedder after copying to WebDisplayItemList.
+    // 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 DisplayItems& displayItems() const { return paintArtifact().displayItems(); }
     const Vector<PaintChunk>& paintChunks() const { return paintArtifact().paintChunks(); }
 
     bool clientCacheIsValid(DisplayItemClient) const;
 
@@ skipping 32 matching lines @@
         ASSERT(RuntimeEnabledFeatures::slimmingPaintSynchronizedPaintingEnabled());
         return m_clientsCheckedPaintInvalidation.contains(client);
     }
     void setClientHasCheckedPaintInvalidation(DisplayItemClient client)
     {
         ASSERT(RuntimeEnabledFeatures::slimmingPaintSynchronizedPaintingEnabled());
         m_clientsCheckedPaintInvalidation.add(client);
     }
 
 protected:
-    DisplayItemList()
+    PaintController()
         : m_newDisplayItems(kInitialDisplayItemsCapacity * kMaximumDisplayItemSize)
         , m_validlyCachedClientsDirty(false)
         , m_constructionDisabled(false)
         , m_textPainted(false)
         , m_skippingCacheCount(0)
         , m_numCachedItems(0)
         , m_nextScope(1) { }
 
 private:
     // Set new item state (scopes, cache skipping, etc) for a new item.
@@ skipping 50 matching lines @@
 #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;
 #endif
 
     // Allow display item construction to be disabled to isolate the costs of construction
     // in performance metrics.
     bool m_constructionDisabled;
 
-    // Indicates this DisplayItemList has ever had text. It is never reset to false.
+    // Indicates this PaintController has ever had text. It is never reset to false.
     bool m_textPainted;
 
     int m_skippingCacheCount;
 
     int m_numCachedItems;
 
     unsigned m_nextScope;
     Vector<unsigned> m_scopeStack;
 
     struct Invalidation {
         IntRect rect;
         PaintInvalidationReason invalidationReason;
     };
 
     Vector<Invalidation> m_invalidations;
 
 #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
 
     OwnPtr<Vector<String>> m_trackedPaintInvalidationObjects;
 };
 
 } // namespace blink
 
-#endif // DisplayItemList_h
+#endif // PaintController_h