Preparation for enabling slimming paint synchronized painting

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 207 matching lines @@
     m_isPainting = false;
     m_visuallyNonEmptyCharacterCount = 0;
     m_visuallyNonEmptyPixelCount = 0;
     m_isVisuallyNonEmpty = false;
     clearScrollAnchor();
     m_viewportConstrainedObjects.clear();
     m_layoutSubtreeRootList.clear();
 }
 
 template <typename Function>
-void FrameView::forAllFrameViews(Function function)
+void FrameView::forAllNonThrottledFrameViews(Function function)
 {
-    for (Frame* frame = m_frame.get(); frame; frame = frame->tree().traverseNext(m_frame.get())) {
-        if (!frame->isLocalFrame())
+    if (shouldThrottleRendering())
+        return;
+
+    function(*this);
+
+    for (Frame* child = m_frame->tree().firstChild(); child; child = child->tree().nextSibling()) {
+        if (!child->isLocalFrame())
             continue;
-        if (FrameView* view = toLocalFrame(frame)->view())
-            function(*view);
+        if (FrameView* childView = toLocalFrame(child)->view())
+            childView->forAllNonThrottledFrameViews(function);
     }
 }
 
 void FrameView::removeFromAXObjectCache()
 {
     if (AXObjectCache* cache = axObjectCache()) {
         cache->remove(this);
         cache->childrenChanged(m_frame->pagePopupOwner());
     }
 }
@@ skipping 1040 matching lines @@
 }
 
 bool FrameView::shouldSetCursor() const
 {
     Page* page = frame().page();
     return page && page->visibilityState() != PageVisibilityStateHidden && page->focusController().isActive() && page->settings().deviceSupportsMouse();
 }
 
 void FrameView::scrollContentsIfNeededRecursive()
 {
-    forAllFrameViews([](FrameView& frameView) {
-        if (frameView.shouldThrottleRendering())
-            return;
+    forAllNonThrottledFrameViews([](FrameView& frameView) {
         frameView.scrollContentsIfNeeded();
     });
 }
 
 void FrameView::invalidateBackgroundAttachmentFixedObjects()
 {
     for (const auto& layoutObject : m_backgroundAttachmentFixedObjects)
         layoutObject->setShouldDoFullPaintInvalidation();
 }
 
@@ skipping 509 matching lines @@
         CompositedLayerMapping* compositedLayerMapping = layoutView()->layer()->compositedLayerMapping();
         compositedLayerMapping->updateContentsOpaque();
         if (compositedLayerMapping->mainGraphicsLayer())
             compositedLayerMapping->mainGraphicsLayer()->setNeedsDisplay();
     }
     recalculateScrollbarOverlayStyle();
 }
 
 void FrameView::updateBackgroundRecursively(const Color& backgroundColor, bool transparent)
 {
-    forAllFrameViews([backgroundColor, transparent](FrameView& frameView) {
+    forAllNonThrottledFrameViews([backgroundColor, transparent](FrameView& frameView) {
         frameView.setTransparent(transparent);
         frameView.setBaseBackgroundColor(backgroundColor);
     });
 }
 
 void FrameView::scrollToAnchor()
 {
     RefPtrWillBeRawPtr<Node> anchorNode = m_scrollAnchor;
     if (!anchorNode)
         return;
@@ skipping 612 matching lines @@
             invalidateTreeIfNeededRecursive();
 
             if (view->compositor()->inCompositingMode())
                 scrollingCoordinator()->updateAfterCompositingChangeIfNeeded();
 
             updateCompositedSelectionIfNeeded();
 
             if (RuntimeEnabledFeatures::slimmingPaintV2Enabled())
                 updatePaintProperties();
 
-            if (RuntimeEnabledFeatures::slimmingPaintSynchronizedPaintingEnabled()) {
+            if (RuntimeEnabledFeatures::slimmingPaintSynchronizedPaintingEnabled() && !m_frame->document()->printing()) {
                 synchronizedPaint();
                 if (RuntimeEnabledFeatures::slimmingPaintV2Enabled())
                     compositeForSlimmingPaintV2();
             }
 
             if (RuntimeEnabledFeatures::frameTimingSupportEnabled())
                 updateFrameTimingRequestsIfNeeded();
 
             ASSERT(!view->hasPendingSelection());
             ASSERT(lifecycle().state() == DocumentLifecycle::PaintInvalidationClean
                 || (RuntimeEnabledFeatures::slimmingPaintV2Enabled() && lifecycle().state() == DocumentLifecycle::CompositingForSlimmingPaintV2Clean)
                 || (RuntimeEnabledFeatures::slimmingPaintSynchronizedPaintingEnabled() && lifecycle().state() == DocumentLifecycle::PaintClean));
         }
     }
 
     updateViewportIntersectionsForSubtree();
 }
 
 void FrameView::updatePaintProperties()
 {
     ASSERT(RuntimeEnabledFeatures::slimmingPaintV2Enabled());
 
-    forAllFrameViews([](FrameView& frameView) { frameView.lifecycle().advanceTo(DocumentLifecycle::InUpdatePaintProperties); });
+    forAllNonThrottledFrameViews([](FrameView& frameView) { frameView.lifecycle().advanceTo(DocumentLifecycle::InUpdatePaintProperties); });
     PaintPropertyTreeBuilder().buildPropertyTrees(*this);
-    forAllFrameViews([](FrameView& frameView) { frameView.lifecycle().advanceTo(DocumentLifecycle::UpdatePaintPropertiesClean); });
+    forAllNonThrottledFrameViews([](FrameView& frameView) { frameView.lifecycle().advanceTo(DocumentLifecycle::UpdatePaintPropertiesClean); });
 }
 
 void FrameView::synchronizedPaint()
 {
     ASSERT(RuntimeEnabledFeatures::slimmingPaintSynchronizedPaintingEnabled());
     ASSERT(frame() == page()->mainFrame() || (!frame().tree().parent()->isLocalFrame()));
 
     LayoutView* view = layoutView();
     ASSERT(view);
-    // TODO(chrishtr): figure out if there can be any GraphicsLayer above this one that draws content.
-    GraphicsLayer* rootGraphicsLayer = view->layer()->graphicsLayerBacking();
-    forAllFrameViews([](FrameView& frameView) { frameView.lifecycle().advanceTo(DocumentLifecycle::InPaint); });
+    forAllNonThrottledFrameViews([](FrameView& frameView) { frameView.lifecycle().advanceTo(DocumentLifecycle::InPaint); });
 
     // A null graphics layer can occur for painting of SVG images that are not parented into the main frame tree.
-    if (rootGraphicsLayer) {
-        synchronizedPaintRecursively(rootGraphicsLayer);
+    if (GraphicsLayer* rootGraphicsLayer = view->layer()->graphicsLayerBacking()) {
+        if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
+            // TODO(wangxianzhu,chrishtr): What about the extra graphics layers for overflow control, virtual viewport, etc?
+            GraphicsContext context(*rootGraphicsLayer->paintController());
+            rootGraphicsLayer->paint(context, nullptr);
+        } else {
+            while (GraphicsLayer* parent = rootGraphicsLayer->parent())

[chrishtr, 2015/10/30 21:12:57]

Ok can you add a comment here explaining?

[Xianzhu, 2015/10/30 21:46:26]

Done.

+                rootGraphicsLayer = parent;
+            synchronizedPaintRecursively(rootGraphicsLayer);
+        }
     }
 
-    forAllFrameViews([](FrameView& frameView) {
+    forAllNonThrottledFrameViews([](FrameView& frameView) {
         frameView.lifecycle().advanceTo(DocumentLifecycle::PaintClean);
         frameView.layoutView()->layer()->clearNeedsRepaintRecursively();
     });
 }
 
 void FrameView::synchronizedPaintRecursively(GraphicsLayer* graphicsLayer)
 {
+    ASSERT(!RuntimeEnabledFeatures::slimmingPaintV2Enabled());
     ASSERT(graphicsLayer->paintController());
     GraphicsContext context(*graphicsLayer->paintController());
 
+    if (GraphicsLayer* maskLayer = graphicsLayer->maskLayer())
+        synchronizedPaintRecursively(maskLayer);
+    if (GraphicsLayer* contentsClippingMaskLayer = graphicsLayer->contentsClippingMaskLayer())
+        synchronizedPaintRecursively(contentsClippingMaskLayer);
+    if (GraphicsLayer* replicaLayer = graphicsLayer->replicaLayer())
+        synchronizedPaintRecursively(replicaLayer);
+
+    // TODO(chrishtr): fix unit tests to not inject one-off interest rects.
     graphicsLayer->paint(context, nullptr);
-
-    if (!RuntimeEnabledFeatures::slimmingPaintV2Enabled())
-        graphicsLayer->paintController()->commitNewDisplayItems();
+    graphicsLayer->paintController()->commitNewDisplayItems();
 
     for (auto& child : graphicsLayer->children())
         synchronizedPaintRecursively(child);
 }
 
 void FrameView::compositeForSlimmingPaintV2()
 {
     ASSERT(RuntimeEnabledFeatures::slimmingPaintV2Enabled());
     ASSERT(frame() == page()->mainFrame() || (!frame().tree().parent()->isLocalFrame()));
 
-    forAllFrameViews([](FrameView& frameView) { frameView.lifecycle().advanceTo(DocumentLifecycle::InCompositingForSlimmingPaintV2); });
+    forAllNonThrottledFrameViews([](FrameView& frameView) { frameView.lifecycle().advanceTo(DocumentLifecycle::InCompositingForSlimmingPaintV2); });
 
-    // Detached frames can have no root graphics layer.
     if (GraphicsLayer* rootGraphicsLayer = layoutView()->layer()->graphicsLayerBacking())
         rootGraphicsLayer->paintController()->commitNewDisplayItems();
 
-    forAllFrameViews([](FrameView& frameView) { frameView.lifecycle().advanceTo(DocumentLifecycle::CompositingForSlimmingPaintV2Clean); });
+    forAllNonThrottledFrameViews([](FrameView& frameView) { frameView.lifecycle().advanceTo(DocumentLifecycle::CompositingForSlimmingPaintV2Clean); });
 }
 
 void FrameView::updateFrameTimingRequestsIfNeeded()
 {
     GraphicsLayerFrameTimingRequests graphicsLayerTimingRequests;
     // TODO(mpb) use a 'dirty' bit to not call this every time.
     collectFrameTimingRequestsRecursive(graphicsLayerTimingRequests);
 
     for (const auto& iter : graphicsLayerTimingRequests) {
         const GraphicsLayer* graphicsLayer = iter.key;
@@ skipping 63 matching lines @@
 
     // 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);
 
-    invalidateTreeIfNeeded(rootPaintInvalidationState);
+    if (lifecycle().state() < DocumentLifecycle::PaintInvalidationClean)
+        invalidateTreeIfNeeded(rootPaintInvalidationState);
 
     // Some frames may be not reached during the above invalidateTreeIfNeeded because
     // - the frame is a detached frame; or
     // - it didn't need paint invalidation.
     // We need to call invalidateTreeIfNeededRecursive() for such frames to finish required
     // paint invalidation and advance their life cycle state.
     for (Frame* child = m_frame->tree().firstChild(); child; child = child->tree().nextSibling()) {
-        if (!child->isLocalFrame())
-            continue;
-        FrameView* childFrameView = toLocalFrame(child)->view();
-        if (childFrameView->lifecycle().state() < DocumentLifecycle::PaintInvalidationClean)
-            childFrameView->invalidateTreeIfNeededRecursive();
+        if (child->isLocalFrame())
+            toLocalFrame(child)->view()->invalidateTreeIfNeededRecursive();
     }
 
     // Process objects needing paint invalidation on the next frame. See the definition of PaintInvalidationDelayedFull for more details.
     for (auto& target : pendingDelayedPaintInvalidations)
         target->setShouldDoFullPaintInvalidation(PaintInvalidationDelayedFull);
 }
 
 void FrameView::enableAutoSizeMode(const IntSize& minSize, const IntSize& maxSize)
 {
     if (!m_autoSizeInfo)
@@ skipping 1436 matching lines @@
 }
 
 bool FrameView::canThrottleRendering() const
 {
     if (!RuntimeEnabledFeatures::renderingPipelineThrottlingEnabled())
         return false;
     return m_hiddenForThrottling && m_crossOriginForThrottling;
 }
 
 } // namespace blink