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).
+    // |visualContentRect| can be nullptr if we know it's unchanged and PaintController has cached the previous value.
+    // Otherwise we must pass a correct value (bounds of the display item client in coordinates of the

[chrishtr, 2015/10/23 19:57:49]

"bounds" needs to be defined here. I suggest just saying this is a rect in the
space of the GraphicsLayer into which the DisplayItem paints which contains all
pixels within the GraphicsLayer which might be painted into by the DisplayItem.

Also, danakj explained to me that this should be visualLayerRect, not
visualContentRect. "content" in cc means the space that takes into account pinch
zoom and such; "layer" is in the space of the cc::Layer (GraphicsLayer).

[Xianzhu, 2015/10/23 20:56:53]

Done.
I think visualLayerRect looks confusing to blink people and needs more
explanation and reference to cc to be understood. How about avoiding 'content',
just 'visualRect', or 'visualBoundingRect'?

[chrishtr, 2015/10/23 20:59:45]

visualRect is ok then, with comment.

[Xianzhu, 2015/10/23 21:28:22]

Done.

+    // PaintController's GraphicsLayer (spv1) or TODO(pdr): definition of it for spv2.
+    void invalidate(const DisplayItemClientWrapper&, PaintInvalidationReason, const IntRect* visibleContentRect);
     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