First step of PaintInvalidator implementation

third_party/WebKit/Source/core/layout/PaintInvalidationState.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 PaintInvalidationState_h
 #define PaintInvalidationState_h
 
 #include "core/CoreExport.h"
+#include "core/paint/PaintInvalidator.h"
 #include "platform/geometry/LayoutRect.h"
 #include "platform/graphics/PaintInvalidationReason.h"
 #include "platform/transforms/AffineTransform.h"
 #include "wtf/Allocator.h"
 #include "wtf/Noncopyable.h"
 
 namespace blink {
 
 class LayoutBoxModelObject;
 class LayoutObject;
@@ skipping 30 matching lines @@
     PaintInvalidationState(const LayoutView&, Vector<const LayoutObject*>& pendingDelayedPaintInvalidations);
 
     // When a PaintInvalidationState is constructed, it can be used to map points/rects in the object's
     // local space (border box space for LayoutBoxes). After invalidation of the current object,
     // before invalidation of the subtrees, this method must be called to apply clip and scroll offset
     // etc. for creating child PaintInvalidationStates.
     void updateForChildren(PaintInvalidationReason);
 
     bool hasForcedSubtreeInvalidationFlags() const { return m_forcedSubtreeInvalidationFlags; }
 
-    bool forcedSubtreeInvalidationCheckingWithinContainer() const { return m_forcedSubtreeInvalidationFlags & InvalidationChecking; }
-    void setForceSubtreeInvalidationCheckingWithinContainer() { m_forcedSubtreeInvalidationFlags |= InvalidationChecking; }
+    bool forcedSubtreeInvalidationCheckingWithinContainer() const { return m_forcedSubtreeInvalidationFlags & PaintInvalidatorContext::ForcedSubtreeInvalidationChecking; }
+    void setForceSubtreeInvalidationCheckingWithinContainer() { m_forcedSubtreeInvalidationFlags |= PaintInvalidatorContext::ForcedSubtreeInvalidationChecking; }
 
-    bool forcedSubtreeFullInvalidationWithinContainer() const { return m_forcedSubtreeInvalidationFlags & FullInvalidation; }
+    bool forcedSubtreeFullInvalidationWithinContainer() const { return m_forcedSubtreeInvalidationFlags & PaintInvalidatorContext::ForcedSubtreeFullInvalidation; }
 
-    bool forcedSubtreeInvalidationRectUpdateWithinContainerOnly() const { return m_forcedSubtreeInvalidationFlags == InvalidationRectUpdate; }
-    void setForceSubtreeInvalidationRectUpdateWithinContainer() { m_forcedSubtreeInvalidationFlags |= InvalidationRectUpdate; }
+    bool forcedSubtreeInvalidationRectUpdateWithinContainerOnly() const { return m_forcedSubtreeInvalidationFlags == PaintInvalidatorContext::ForcedSubtreeInvalidationRectUpdate; }
+    void setForceSubtreeInvalidationRectUpdateWithinContainer() { m_forcedSubtreeInvalidationFlags |= PaintInvalidatorContext::ForcedSubtreeInvalidationRectUpdate; }
 
     const LayoutBoxModelObject& paintInvalidationContainer() const { return *m_paintInvalidationContainer; }
 
     // Computes the position of the current object ((0,0) in the space of the object)
     // in the space of paint invalidation backing.
     LayoutPoint computePositionFromPaintInvalidationBacking() const;
 
     // Returns the rect bounds needed to invalidate paint of this object,
     // in the space of paint invalidation backing.
     LayoutRect computePaintInvalidationRectInBacking() const;
 
     void mapLocalRectToPaintInvalidationBacking(LayoutRect&) const;
 
     PaintLayer& paintingLayer() const;
 
 #if ENABLE(ASSERT)
     const LayoutObject& currentObject() const { return m_currentObject; }
 #endif
 
 private:
     friend class VisualRectMappingTest;
+    friend class PaintInvalidatorContextAdapter;
 
     void mapLocalRectToPaintInvalidationContainer(LayoutRect&) const;
 
     void updateForCurrentObject(const PaintInvalidationState& parentState);
     void updateForNormalChildren();
 
     LayoutRect computePaintInvalidationRectInBackingForSVG() const;
 
     void addClipRectRelativeToPaintOffset(const LayoutRect& localClipRect);
 
     const LayoutObject& m_currentObject;
 
-    enum ForcedSubtreeInvalidationFlag {
-        InvalidationChecking = 1 << 0,
-        InvalidationRectUpdate = 1 << 1,
-        FullInvalidation = 1 << 2,
-        FullInvalidationForStackedContents = 1 << 3,
-    };
     unsigned m_forcedSubtreeInvalidationFlags;
 
     bool m_clipped;
     bool m_clippedForAbsolutePosition;
 
     // Clip rect from paintInvalidationContainer if m_cachedOffsetsEnabled is true.
     LayoutRect m_clipRect;
     LayoutRect m_clipRectForAbsolutePosition;
 
     // x/y offset from the paintInvalidationContainer if m_cachedOffsetsEnabled is true.
@@ skipping 38 matching lines @@
 #if ENABLE(ASSERT) && !defined(NDEBUG)
 // #define CHECK_FAST_PATH_SLOW_PATH_EQUALITY
 #endif
 
 #ifdef CHECK_FAST_PATH_SLOW_PATH_EQUALITY
     void assertFastPathAndSlowPathRectsEqual(const LayoutRect& fastPathRect, const LayoutRect& slowPathRect) const;
     bool m_canCheckFastPathSlowPathEquality;
 #endif
 };
 
+// This is temporary to adapt legacy PaintInvalidationState to PaintInvalidatorContext
+class PaintInvalidatorContextAdapter : public PaintInvalidatorContext {
+public:
+    PaintInvalidatorContextAdapter(const PaintInvalidationState&);
+    void mapLocalRectToPaintInvalidationBacking(const LayoutObject& object, LayoutRect& rect) const override

[chrishtr, 2016/08/09 23:47:31]

Doesn't need to be inline.

[Xianzhu, 2016/08/10 16:25:01]

Done.

+    {
+        DCHECK(&object == &m_paintInvalidationState.currentObject());
+        m_paintInvalidationState.mapLocalRectToPaintInvalidationBacking(rect);
+    }
+private:
+    const PaintInvalidationState& m_paintInvalidationState;
+};
+
 } // namespace blink
 
 #endif // PaintInvalidationState_h