New paint invalidation using paint property tree walk

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

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
  *           (C) 2004 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2009 Google Inc. All rights reserved.
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 238 matching lines @@
     , m_node(node)
     , m_parent(nullptr)
     , m_previous(nullptr)
     , m_next(nullptr)
 #if ENABLE(ASSERT)
     , m_hasAXObject(false)
     , m_setNeedsLayoutForbidden(false)
 #endif
     , m_bitfields(node)
 {
-    // TODO(wangxianzhu): Move this into initialization list when we enable the feature by default.
-    if (RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled())
-        m_previousPositionFromPaintInvalidationBacking = uninitializedPaintOffset();
-
 #ifndef NDEBUG
     layoutObjectCounter().increment();
 #endif
     InstanceCounters::incrementCounter(InstanceCounters::LayoutObjectCounter);
 }
 
 LayoutObject::~LayoutObject()
 {
     ASSERT(!m_hasAXObject);
 #ifndef NDEBUG
@@ skipping 937 matching lines @@
     paintRect.intersect(frameView->visibleContentRect());
     if (paintRect.isEmpty())
         return;
 
     if (HostWindow* window = frameView->getHostWindow())
         window->invalidateRect(frameView->contentsToRootFrame(paintRect));
 }
 
 void LayoutObject::invalidatePaintUsingContainer(const LayoutBoxModelObject& paintInvalidationContainer, const LayoutRect& dirtyRect, PaintInvalidationReason invalidationReason) const
 {
-    // TODO(wangxianzhu): Enable the following assert after paint invalidation for spv2 is ready.
-    // ASSERT(!RuntimeEnabledFeatures::slimmingPaintV2Enabled());
-
     if (paintInvalidationContainer.frameView()->shouldThrottleRendering())
         return;
 
-    ASSERT(gDisablePaintInvalidationStateAsserts || document().lifecycle().state() == DocumentLifecycle::InPaintInvalidation);
+    ASSERT(gDisablePaintInvalidationStateAsserts
+        || document().lifecycle().state() == DocumentLifecycle::InPaintInvalidation
+        || (RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled() && document().lifecycle().state() == DocumentLifecycle::InPrePaintTreeWalk));
 
     if (dirtyRect.isEmpty())
         return;
 
     RELEASE_ASSERT(isRooted());
 
     // FIXME: Unify "devtools.timeline.invalidationTracking" and "blink.invalidation". crbug.com/413527.
     TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline.invalidationTracking"),
         "PaintInvalidationTracking",
         TRACE_EVENT_SCOPE_THREAD,
@@ skipping 88 matching lines @@
         invalidateDisplayItemClients(*paintInvalidationContainer, PaintInvalidationRectangle);
 }
 
 void LayoutObject::invalidatePaintRectangleNotInvalidatingDisplayItemClients(const LayoutRect& r) const
 {
     invalidatePaintRectangleInternal(r);
 }
 
 void LayoutObject::invalidateTreeIfNeeded(PaintInvalidationState& paintInvalidationState)
 {
+    ASSERT(!RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled());
     ASSERT(!needsLayout());
 
     // If we didn't need paint invalidation then our children don't need as well.
     // Skip walking down the tree as everything should be fine below us.
     if (!shouldCheckForPaintInvalidation(paintInvalidationState))
         return;
 
     PaintInvalidationReason reason = invalidatePaintIfNeeded(paintInvalidationState, paintInvalidationState.paintInvalidationContainer());
     clearPaintInvalidationState(paintInvalidationState);
 
     if (reason == PaintInvalidationDelayedFull)
         paintInvalidationState.pushDelayedPaintInvalidationTarget(*this);
 
     invalidatePaintOfSubtreesIfNeeded(paintInvalidationState);
 }
 
 void LayoutObject::invalidatePaintOfSubtreesIfNeeded(PaintInvalidationState& childPaintInvalidationState)
 {
+    ASSERT(!RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled());
+
     for (LayoutObject* child = slowFirstChild(); child; child = child->nextSibling()) {
         if (!child->isOutOfFlowPositioned())
             child->invalidateTreeIfNeeded(childPaintInvalidationState);
     }
 }
 
 static PassOwnPtr<TracedValue> jsonObjectForOldAndNewRects(const LayoutRect& oldRect, const LayoutPoint& oldLocation, const LayoutRect& newRect, const LayoutPoint& newLocation)
 {
     OwnPtr<TracedValue> value = TracedValue::create();
     addJsonObjectForRect(value.get(), "oldRect", oldRect);
@@ skipping 23 matching lines @@
             return;
         selectionPaintInvalidationMap = new SelectionPaintInvalidationMap();
     }
 
     if (selectionRect.isEmpty())
         selectionPaintInvalidationMap->remove(this);
     else
         selectionPaintInvalidationMap->set(this, selectionRect);
 }
 
-// TODO(wangxianzhu): Remove this for slimming paint v2 because we won't care about paint invalidation rects.
 inline void LayoutObject::invalidateSelectionIfNeeded(const LayoutBoxModelObject& paintInvalidationContainer, const PaintInvalidationState& paintInvalidationState, PaintInvalidationReason invalidationReason)
 {
     // Update selection rect when we are doing full invalidation (in case that the object is moved, composite status changed, etc.)
     // or shouldInvalidationSelection is set (in case that the selection itself changed).
     bool fullInvalidation = view()->doingFullPaintInvalidation() || isFullPaintInvalidationReason(invalidationReason);
     if (!fullInvalidation && !shouldInvalidateSelection())
         return;
 
     LayoutRect oldSelectionRect = previousSelectionRectForPaintInvalidation();
     LayoutRect newSelectionRect = selectionRectForPaintInvalidation(&paintInvalidationContainer);
@@ skipping 22 matching lines @@
         PaintLayer& layer = paintInvalidationState.enclosingSelfPaintingLayer(*this);
         if (layer.layoutObject() != this)
             layer.setNeedsPaintPhaseDescendantOutlines();
     }
 
     LayoutView* v = view();
     if (v->document().printing())
         return PaintInvalidationNone; // Don't invalidate paints if we're printing.
 
     const LayoutRect oldBounds = previousPaintInvalidationRect();
-    const LayoutPoint oldLocation = RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled() ? LayoutPoint() : previousPositionFromPaintInvalidationBacking();
+    const LayoutPoint oldLocation = previousPositionFromPaintInvalidationBacking();
     LayoutRect newBounds = boundsRectForPaintInvalidation(paintInvalidationContainer, &paintInvalidationState);
-    LayoutPoint newLocation = RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled() ? LayoutPoint() : PaintLayer::positionFromPaintInvalidationBacking(this, &paintInvalidationContainer, &paintInvalidationState);
+    LayoutPoint newLocation = PaintLayer::positionFromPaintInvalidationBacking(this, &paintInvalidationContainer, &paintInvalidationState);
 
     // Composited scrolling should not be included in the bounds and position tracking, because the graphics layer backing the scroller
     // does not move on scroll.
     if (paintInvalidationContainer.usesCompositedScrolling() && &paintInvalidationContainer != this) {
         LayoutSize inverseOffset(toLayoutBox(&paintInvalidationContainer)->scrolledContentOffset());
         newLocation.move(inverseOffset);
         newBounds.move(inverseOffset);
     }
 
     setPreviousPaintInvalidationRect(newBounds);
-    if (!RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled())
-        setPreviousPositionFromPaintInvalidationBacking(newLocation);
+    setPreviousPositionFromPaintInvalidationBacking(newLocation);
 
     if (!shouldCheckForPaintInvalidationRegardlessOfPaintInvalidationState() && !paintInvalidationState.forcedSubtreeInvalidationWithinContainer()) {
         ASSERT(paintInvalidationState.forcedSubtreeInvalidationRectUpdateWithinContainer());
         return PaintInvalidationNone;
     }
 
     PaintInvalidationReason invalidationReason = getPaintInvalidationReason(paintInvalidationContainer, oldBounds, oldLocation, newBounds, newLocation);
 
     // We need to invalidate the selection before checking for whether we are doing a full invalidation.
     // This is because we need to update the old rect regardless.
@@ skipping 1159 matching lines @@
     }
 
     return o;
 }
 
 LayoutObject* LayoutObject::containerCrossingFrameBoundaries() const
 {
     return isLayoutView() ? frame()->ownerLayoutObject() : container();
 }
 
+LayoutObject* LayoutObject::parentCrossingFrameBoundaries() const
+{
+    return isLayoutView() ? frame()->ownerLayoutObject() : parent();
+}
+
 bool LayoutObject::isSelectionBorder() const
 {
     SelectionState st = getSelectionState();
     return st == SelectionStart || st == SelectionEnd || st == SelectionBoth;
 }
 
 inline void LayoutObject::clearLayoutRootIfNeeded() const
 {
     if (FrameView* view = frameView()) {
         if (!documentBeingDestroyed())
@@ skipping 795 matching lines @@
         return PaintInvalidationForcedByLayout;
     case DocumentLifecycle::InCompositingUpdate:
         return PaintInvalidationCompositingUpdate;
     default:
         return PaintInvalidationFull;
     }
 }
 
 inline void LayoutObject::markContainerChainForPaintInvalidation()
 {
+    if (RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled()) {
+        // We use PaintPropertyTreeBuilder, which walks layout tree in DOM order, for paint invalidation,
+        // so we need to mark paint invalidation flags also in DOM order (instead of containing block order).
+        for (LayoutObject* ancestor = this->parentCrossingFrameBoundaries(); ancestor && !ancestor->shouldCheckForPaintInvalidationRegardlessOfPaintInvalidationState(); ancestor = ancestor->parentCrossingFrameBoundaries())
+            ancestor->m_bitfields.setChildShouldCheckForPaintInvalidation(true);
+        return;
+    }
+
     for (LayoutObject* container = this->containerCrossingFrameBoundaries(); container && !container->shouldCheckForPaintInvalidationRegardlessOfPaintInvalidationState(); container = container->containerCrossingFrameBoundaries())
         container->m_bitfields.setChildShouldCheckForPaintInvalidation(true);
 }
 
 void LayoutObject::setShouldInvalidateSelection()
 {
     if (!canUpdateSelectionOnRootLineBoxes())
         return;
     m_bitfields.setShouldInvalidateSelection(true);
     markContainerChainForPaintInvalidation();
@@ skipping 270 matching lines @@
         const blink::LayoutObject* root = object1;
         while (root->parent())
             root = root->parent();
         root->showLayoutTreeAndMark(object1, "*", object2, "-", 0);
     } else {
         fprintf(stderr, "Cannot showLayoutTree. Root is (nil)\n");
     }
 }
 
 #endif