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()) {
+            GraphicsContext context(*rootGraphicsLayer->paintController());
+            rootGraphicsLayer->paint(context, nullptr);
+        } else {
+            while (GraphicsLayer* parent = rootGraphicsLayer->parent())

[chrishtr, 2015/10/30 19:01:13]

Why this while loop?

[Xianzhu, 2015/10/30 19:28:56]

There may be other paintable layers (e.g. frame scrollbar layers, virtual
viewport layers) not in the layer subtree of the LayoutView and we also need to
paint them.

I'm not sure what these layers will be for spv2. Added a TODO in the 'if (spv2)'
block.

+                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 1433 matching lines @@
 }
 
 bool FrameView::canThrottleRendering() const
 {
     if (!RuntimeEnabledFeatures::renderingPipelineThrottlingEnabled())
         return false;
     return m_hiddenForThrottling && m_crossOriginForThrottling;
 }
 
 } // namespace blink