First step of PaintInvalidator implementation

third_party/WebKit/Source/core/layout/PaintInvalidationState.cpp

 // 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.
 
 #include "core/layout/PaintInvalidationState.h"
 
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/layout/LayoutInline.h"
 #include "core/layout/LayoutPart.h"
 #include "core/layout/LayoutView.h"
 #include "core/layout/svg/LayoutSVGRoot.h"
 #include "core/layout/svg/SVGLayoutSupport.h"
+#include "core/paint/PaintInvalidator.h"
 #include "core/paint/PaintLayer.h"
+#include "core/paint/PaintPropertyTreeBuilder.h"
 
 namespace blink {
 
 static bool supportsCachedOffsets(const LayoutObject& object)
 {
     return !object.hasTransformRelatedProperty()
         && !object.hasReflection()
         && !object.hasFilterInducingProperty()
         && !object.isLayoutFlowThread()
         && !object.isLayoutMultiColumnSpannerPlaceholder()
@@ skipping 84 matching lines @@
         // The current object is stacked, so we should use m_paintInvalidationContainerForStackedContents as its
         // paint invalidation container on which the current object is painted.
         m_paintInvalidationContainer = m_paintInvalidationContainerForStackedContents;
         // We are changing paintInvalidationContainer to m_paintInvalidationContainerForStackedContents. Must disable
         // cached offsets because we didn't track paint offset from m_paintInvalidationContainerForStackedContents.
         // TODO(wangxianzhu): There are optimization opportunities:
         // - Like what we do for fixed-position, calculate the paint offset in slow path and enable fast path for
         //   descendants if possible; or
         // - Track offset between the two paintInvalidationContainers.
         m_cachedOffsetsEnabled = false;
-        if (m_forcedSubtreeInvalidationFlags & FullInvalidationForStackedContents)
-            m_forcedSubtreeInvalidationFlags |= FullInvalidation;
+        if (m_forcedSubtreeInvalidationFlags & PaintInvalidatorContext::ForcedSubtreeFullInvalidationForStackedContents)
+            m_forcedSubtreeInvalidationFlags |= PaintInvalidatorContext::ForcedSubtreeFullInvalidation;
     }
 
     if (!currentObject.isBoxModelObject() && !currentObject.isSVG())
         return;
 
     if (m_cachedOffsetsEnabled || currentObject == m_paintInvalidationContainer)
         m_cachedOffsetsEnabled = supportsCachedOffsets(currentObject);
 
     if (currentObject.isSVG()) {
         if (currentObject.isSVGRoot()) {
             m_svgTransform = toLayoutSVGRoot(currentObject).localToBorderBoxTransform();
             // Don't early return here, because the SVGRoot object needs to execute the later code
             // as a normal LayoutBox.
         } else {
             ASSERT(currentObject != m_paintInvalidationContainer);
             m_svgTransform *= currentObject.localToSVGParentTransform();
             return;
         }
     }
 
     if (currentObject == m_paintInvalidationContainer) {
         // When we hit a new paint invalidation container, we don't need to
         // continue forcing a check for paint invalidation, since we're
         // descending into a different invalidation container. (For instance if
         // our parents were moved, the entire container will just move.)
         if (currentObject != m_paintInvalidationContainerForStackedContents) {
             // However, we need to keep the FullInvalidationForStackedContents flag
             // if the current object isn't the paint invalidation container of
             // stacked contents.
-            m_forcedSubtreeInvalidationFlags &= FullInvalidationForStackedContents;
+            m_forcedSubtreeInvalidationFlags &= PaintInvalidatorContext::ForcedSubtreeFullInvalidationForStackedContents;
         } else {
             m_forcedSubtreeInvalidationFlags = 0;
             if (currentObject != m_containerForAbsolutePosition
                 && m_cachedOffsetsForAbsolutePositionEnabled
                 && m_cachedOffsetsEnabled) {
                 // The current object is the new paintInvalidationContainer for absolute-position descendants but is not their container.
                 // Call updateForCurrentObject() before resetting m_paintOffset to get paint offset of the current object
                 // from the original paintInvalidationContainerForStackingContents, then use this paint offset to adjust
                 // m_paintOffsetForAbsolutePosition.
                 updateForCurrentObject(parentState);
@@ skipping 83 matching lines @@
 #if ENABLE(ASSERT)
     ASSERT(!m_didUpdateForChildren);
     m_didUpdateForChildren = true;
 #endif
 
     switch (reason) {
     case PaintInvalidationDelayedFull:
         m_pendingDelayedPaintInvalidations.append(&m_currentObject);
         break;
     case PaintInvalidationSubtree:
-        m_forcedSubtreeInvalidationFlags |= (FullInvalidation | FullInvalidationForStackedContents);
+        m_forcedSubtreeInvalidationFlags |= (PaintInvalidatorContext::ForcedSubtreeFullInvalidation | PaintInvalidatorContext::ForcedSubtreeFullInvalidationForStackedContents);
         break;
     case PaintInvalidationSVGResourceChange:
         setForceSubtreeInvalidationCheckingWithinContainer();
         break;
     default:
         break;
     }
 
     updateForNormalChildren();
 
@@ skipping 239 matching lines @@
 
     WTFLogAlways("Fast path paint invalidation rect differs from slow path: fast: %s vs slow: %s",
         fastPathRect.toString().ascii().data(), slowPathRect.toString().ascii().data());
     showLayoutTree(&m_currentObject);
 
     ASSERT_NOT_REACHED();
 }
 
 #endif // CHECK_FAST_PATH_SLOW_PATH_EQUALITY
 
+static const PaintPropertyTreeBuilderContext& dummyTreeBuilderContext()
+{
+    DEFINE_STATIC_LOCAL(PaintPropertyTreeBuilderContext, dummyContext, ());
+    return dummyContext;
+}
+
+PaintInvalidatorContextAdapter::PaintInvalidatorContextAdapter(const PaintInvalidationState& paintInvalidationState)
+    : PaintInvalidatorContext(dummyTreeBuilderContext())
+    , m_paintInvalidationState(paintInvalidationState)
+{
+    forcedSubtreeInvalidationFlags = paintInvalidationState.m_forcedSubtreeInvalidationFlags;
+    paintInvalidationContainer = &paintInvalidationState.paintInvalidationContainer();
+    paintingLayer = &paintInvalidationState.paintingLayer();
+}
+
+
+void PaintInvalidatorContextAdapter::mapLocalRectToPaintInvalidationBacking(const LayoutObject& object, LayoutRect& rect) const
+{
+    DCHECK(&object == &m_paintInvalidationState.currentObject());
+    m_paintInvalidationState.mapLocalRectToPaintInvalidationBacking(rect);
+}
+
 } // namespace blink