Let synchronized painting generate correct paint invalidation rects

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/PassOwnPtr.h"
 #include "wtf/Utility.h"
 #include "wtf/Vector.h"
 
 namespace blink {
 
-class GraphicsLayer;
 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);
     WTF_MAKE_FAST_ALLOCATED(PaintController);
 public:
     static PassOwnPtr<PaintController> create()
     {
         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);
+    // 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 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.
@@ skipping 39 matching lines @@
     void endScope();
 
     // 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. If passed, invalidations are recorded on the given
-    // GraphicsLayer.
-    void commitNewDisplayItems(GraphicsLayer* = nullptr);
+    // Must be called when a painting is finished.
+    void commitNewDisplayItems();
 
     // 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(); }
@@ skipping 116 matching lines @@
     // 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;
-    };
+#if ENABLE(ASSERT)
+    // Record the debug names of invalidated clients for assertion and debugging.
+    Vector<String> m_invalidations;
 
-    Vector<Invalidation> m_invalidations;
-
-#if ENABLE(ASSERT)
     // This is used to check duplicated ids during add(). We could also check
     // during commitNewDisplayItems(), 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 // PaintController_h