New paint invalidation using paint property tree walk

third_party/WebKit/Source/core/frame/FrameView.cpp

 /*
  * Copyright (C) 1998, 1999 Torben Weis <weis@kde.org>
  *                     1999 Lars Knoll <knoll@kde.org>
  *                     1999 Antti Koivisto <koivisto@kde.org>
  *                     2000 Dirk Mueller <mueller@kde.org>
  * Copyright (C) 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
  *           (C) 2006 Graham Dennis (graham.dennis@gmail.com)
  *           (C) 2006 Alexey Proskuryakov (ap@nypop.com)
  * Copyright (C) 2009 Google Inc. All rights reserved.
  *
@@ skipping 63 matching lines @@
 #include "core/loader/FrameLoader.h"
 #include "core/loader/FrameLoaderClient.h"
 #include "core/page/AutoscrollController.h"
 #include "core/page/ChromeClient.h"
 #include "core/page/FocusController.h"
 #include "core/page/FrameTree.h"
 #include "core/page/Page.h"
 #include "core/page/scrolling/ScrollingCoordinator.h"
 #include "core/paint/FramePainter.h"
 #include "core/paint/PaintLayer.h"
-#include "core/paint/PaintPropertyTreeBuilder.h"
+#include "core/paint/PrePaintTreeWalk.h"
 #include "core/plugins/PluginView.h"
 #include "core/style/ComputedStyle.h"
 #include "core/svg/SVGDocumentExtensions.h"
 #include "core/svg/SVGSVGElement.h"
 #include "platform/HostWindow.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/ScriptForbiddenScope.h"
 #include "platform/TraceEvent.h"
 #include "platform/TracedValue.h"
 #include "platform/fonts/FontCache.h"
@@ skipping 978 matching lines @@
 #if ENABLE(ASSERT)
     // Post-layout assert that nobody was re-marked as needing layout during layout.
     layoutView()->assertSubtreeIsLaidOut();
 #endif
 
     frame().document()->layoutUpdated();
 }
 
 void FrameView::invalidateTreeIfNeeded(PaintInvalidationState& paintInvalidationState)
 {
+    ASSERT(!RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled());
+
     if (shouldThrottleRendering())
         return;
 
     lifecycle().advanceTo(DocumentLifecycle::InPaintInvalidation);
 
     RELEASE_ASSERT(layoutView());
     LayoutView& rootForPaintInvalidation = *layoutView();
     ASSERT(!rootForPaintInvalidation.needsLayout());
 
     TRACE_EVENT1("blink", "FrameView::invalidateTree", "root", rootForPaintInvalidation.debugName().ascii());
@@ skipping 1296 matching lines @@
 }
 
 void FrameView::updateLifecycleToLayoutClean()
 {
     frame().localFrameRoot()->view()->updateLifecyclePhasesInternal(OnlyUpToLayoutClean);
 }
 
 void FrameView::scheduleVisualUpdateForPaintInvalidationIfNeeded()
 {
     LocalFrame* localFrameRoot = frame().localFrameRoot();
-    if (!localFrameRoot->view()->m_isUpdatingAllLifecyclePhases || lifecycle().state() >= DocumentLifecycle::PaintInvalidationClean) {
+    if (!localFrameRoot->view()->m_isUpdatingAllLifecyclePhases
+        || (!RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled() && lifecycle().state() >= DocumentLifecycle::PaintInvalidationClean)
+        || lifecycle().state() >= DocumentLifecycle::PrePaintTreeWalkClean) {
         // Schedule visual update to process the paint invalidation in the next cycle.
         localFrameRoot->scheduleVisualUpdateUnlessThrottled();
     }
     // Otherwise the paint invalidation will be handled in paint invalidation phase of this cycle.
 }
 
 // TODO(leviw): We don't assert lifecycle information from documents in child PluginViews.
 void FrameView::updateLifecyclePhasesInternal(LifeCycleUpdateOption phases)
 {
     Optional<TemporaryChange<bool>> isUpdatingAllLifecyclePhasesScope;
@@ skipping 25 matching lines @@
             TRACE_EVENT1("devtools.timeline", "UpdateLayerTree", "data", InspectorUpdateLayerTreeEvent::data(m_frame.get()));
 
             // This was required for slimming paint v1 but is only temporarily
             // needed for slimming paint v2.
             view->compositor()->updateIfNeededRecursive();
             scrollContentsIfNeededRecursive();
 
             ASSERT(lifecycle().state() >= DocumentLifecycle::CompositingClean);
 
             if (phases == AllPhases) {
-                invalidateTreeIfNeededRecursive();
+                if (!RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled())
+                    invalidateTreeIfNeededRecursive();
 
                 if (view->compositor()->inCompositingMode())
                     scrollingCoordinator()->updateAfterCompositingChangeIfNeeded();
 
                 updateCompositedSelectionIfNeeded();
             }
         }
 
         if (phases == AllPhases) {
-            if (RuntimeEnabledFeatures::slimmingPaintV2Enabled())
+            if (RuntimeEnabledFeatures::slimmingPaintV2Enabled() || RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled())
                 updatePaintProperties();
 
             if (!m_frame->document()->printing())
                 synchronizedPaint();
 
             if (RuntimeEnabledFeatures::frameTimingSupportEnabled())
                 updateFrameTimingRequestsIfNeeded();
 
             if (RuntimeEnabledFeatures::slimmingPaintV2Enabled())
                 pushPaintArtifactToCompositor();
 
             ASSERT(!view->hasPendingSelection());
             ASSERT((m_frame->document()->printing() && lifecycle().state() == DocumentLifecycle::PaintInvalidationClean)
                 || lifecycle().state() == DocumentLifecycle::PaintClean);
         }
     }
 
     updateViewportIntersectionsForSubtree(phases);
 }
 
 void FrameView::updatePaintProperties()
 {
     TRACE_EVENT0("blink", "FrameView::updatePaintProperties");
 
-    ASSERT(RuntimeEnabledFeatures::slimmingPaintV2Enabled());
+    ASSERT(RuntimeEnabledFeatures::slimmingPaintV2Enabled() || RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled());
 
-    forAllNonThrottledFrameViews([](FrameView& frameView) { frameView.lifecycle().advanceTo(DocumentLifecycle::InUpdatePaintProperties); });
-    PaintPropertyTreeBuilder().buildPropertyTrees(*this);
-    forAllNonThrottledFrameViews([](FrameView& frameView) { frameView.lifecycle().advanceTo(DocumentLifecycle::UpdatePaintPropertiesClean); });
+    forAllNonThrottledFrameViews([](FrameView& frameView) { frameView.lifecycle().advanceTo(DocumentLifecycle::InPrePaintTreeWalk); });
+    PrePaintTreeWalk builder;
+    builder.buildPropertyTreesAndInvalidatePaint(*this);
+    forAllNonThrottledFrameViews([](FrameView& frameView) { frameView.lifecycle().advanceTo(DocumentLifecycle::PrePaintTreeWalkClean); });
+
+    // Process objects needing paint invalidation on the next frame. See the definition of PaintInvalidationDelayedFull for more details.
+    for (auto& target : builder.pendingDelayedPaintInvalidations())
+        target->setShouldDoFullPaintInvalidation(PaintInvalidationDelayedFull);
 }
 
 void FrameView::synchronizedPaint()
 {
     TRACE_EVENT0("blink", "FrameView::synchronizedPaint");
 
     ASSERT(frame() == page()->mainFrame() || (!frame().tree().parent()->isLocalFrame()));
 
     LayoutView* view = layoutView();
     ASSERT(view);
@@ skipping 148 matching lines @@
         lifecycle().advanceTo(DocumentLifecycle::LayoutClean);
 
     // Ensure that we become visually non-empty eventually.
     // TODO(esprehn): This should check isRenderingReady() instead.
     if (frame().document()->hasFinishedParsing() && frame().loader().stateMachine()->committedFirstRealDocumentLoad())
         m_isVisuallyNonEmpty = true;
 }
 
 void FrameView::invalidateTreeIfNeededRecursive()
 {
+    ASSERT(!RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled());
     RELEASE_ASSERT(layoutView());
 
     // We need to stop recursing here since a child frame view might not be throttled
     // even though we are (e.g., it didn't compute its visibility yet).
     if (shouldThrottleRendering())
         return;
     TRACE_EVENT1("blink", "FrameView::invalidateTreeIfNeededRecursive", "root", layoutView()->debugName().ascii());
 
     Vector<LayoutObject*> pendingDelayedPaintInvalidations;
     PaintInvalidationState rootPaintInvalidationState(*layoutView(), pendingDelayedPaintInvalidations);
@@ skipping 1447 matching lines @@
     return m_hiddenForThrottling && m_crossOriginForThrottling;
 }
 
 LayoutBox& FrameView::boxForScrollControlPaintInvalidation() const
 {
     ASSERT(layoutView());
     return *layoutView();
 }
 
 } // namespace blink