Traverse into child LayoutViews during invalidateTreeIfNeeded

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 1084 matching lines @@
     if (frame().page())
         frame().page()->chromeClient().layoutUpdated(m_frame.get());
 
     frame().document()->markers().updateRenderedRectsForMarkers();
 }
 
 // The plan is to move to compositor-queried paint invalidation, in which case this
 // method would setNeedsRedraw on the GraphicsLayers with invalidations and
 // let the compositor pick which to actually draw.
 // See http://crbug.com/306706
-void FrameView::invalidateTreeIfNeeded(Vector<LayoutObject*>& pendingDelayedPaintInvalidations)
+void FrameView::invalidateTreeIfNeeded(PaintInvalidationState& paintInvalidationState)
 {
+    lifecycle().advanceTo(DocumentLifecycle::InPaintInvalidation);
+
     ASSERT(layoutView());
     LayoutView& rootForPaintInvalidation = *layoutView();
     ASSERT(!rootForPaintInvalidation.needsLayout());
 
     TRACE_EVENT1("blink", "FrameView::invalidateTree", "root", rootForPaintInvalidation.debugName().ascii());
 
-    PaintInvalidationState rootPaintInvalidationState(rootForPaintInvalidation, pendingDelayedPaintInvalidations);
-
     // In slimming paint mode we do per-object invalidation.
     if (m_doFullPaintInvalidation && !RuntimeEnabledFeatures::slimmingPaintEnabled())
         layoutView()->compositor()->fullyInvalidatePaint();
 
-    rootForPaintInvalidation.invalidateTreeIfNeeded(rootPaintInvalidationState);
+    rootForPaintInvalidation.invalidateTreeIfNeeded(paintInvalidationState);
 
     // Invalidate the paint of the frameviews scrollbars if needed
     if (hasVerticalBarDamage())
         invalidateRect(verticalBarDamage());
     if (hasHorizontalBarDamage())
         invalidateRect(horizontalBarDamage());
     resetScrollbarDamage();
 
 #if ENABLE(ASSERT)
     layoutView()->assertSubtreeClearedPaintInvalidationState();
 #endif
 
     if (m_frame->selection().isCaretBoundsDirty())
         m_frame->selection().invalidateCaretRect();
+
+    m_doFullPaintInvalidation = false;
+    lifecycle().advanceTo(DocumentLifecycle::PaintInvalidationClean);
 }
 
 DocumentLifecycle& FrameView::lifecycle() const
 {
     return m_frame->document()->lifecycle();
 }
 
 LayoutBox* FrameView::embeddedContentBox() const
 {
     LayoutView* layoutView = this->layoutView();
@@ skipping 1438 matching lines @@
     ASSERT(!m_frame->document()->hasSVGFilterElementsRequiringLayerUpdate());
 #if ENABLE(ASSERT)
     m_frame->document()->layoutView()->assertLaidOut();
 #endif
 
     updateWidgetPositionsIfNeeded();
 }
 
 void FrameView::invalidateTreeIfNeededRecursive()
 {
-    // FIXME: We should be more aggressive at cutting tree traversals.
-    lifecycle().advanceTo(DocumentLifecycle::InPaintInvalidation);
+    ASSERT(layoutView());
+    TRACE_EVENT1("blink", "FrameView::invalidateTreeIfNeededRecursive", "root", layoutView()->debugName().ascii());
 
     Vector<LayoutObject*> pendingDelayedPaintInvalidations;
+    PaintInvalidationState rootPaintInvalidationState(*layoutView(), pendingDelayedPaintInvalidations);
 
-    invalidateTreeIfNeeded(pendingDelayedPaintInvalidations);
+    invalidateTreeIfNeeded(rootPaintInvalidationState);
 
     for (Frame* child = m_frame->tree().firstChild(); child; child = child->tree().nextSibling()) {
         if (!child->isLocalFrame())
             continue;
 
-        toLocalFrame(child)->view()->invalidateTreeIfNeededRecursive();
+        FrameView* childFrameView = toLocalFrame(child)->view();
+        if (childFrameView->layoutView()->shouldCheckForPaintInvalidationRegardlessOfPaintInvalidationState()) {
+            // This is a detached frame which is not reached during the above invalidateTreeIfNeeded().
+            PaintInvalidationState childPaintInvalidationState(*childFrameView->layoutView(), pendingDelayedPaintInvalidations);
+            childFrameView->invalidateTreeIfNeeded(childPaintInvalidationState);

[Xianzhu, 2015/06/30 00:02:13]

This is a new complication. Covered by unit tests.

+        } else {
+            DocumentLifecycle& childLifecycle = childFrameView->lifecycle();
+            if (childLifecycle.state() < DocumentLifecycle::PaintInvalidationClean) {
+                // The frame didn't need paint invalidation. We still need to advance the lifecycle of it.
+                childLifecycle.advanceTo(DocumentLifecycle::InPaintInvalidation);
+                childLifecycle.advanceTo(DocumentLifecycle::PaintInvalidationClean);
+            }
+        }
     }
 
-    m_doFullPaintInvalidation = false;
-    lifecycle().advanceTo(DocumentLifecycle::PaintInvalidationClean);
-
     // 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)
         m_autoSizeInfo = FrameViewAutoSizeInfo::create(this);
 
@@ skipping 1353 matching lines @@
 
     if (!graphicsLayer)
         return;
 
     DeprecatedPaintLayer::mapRectToPaintInvalidationBacking(localFrame->contentLayoutObject(), paintInvalidationContainer, viewRect);
 
     graphicsLayerTimingRequests.add(graphicsLayer, Vector<std::pair<int64_t, WebRect>>()).storedValue->value.append(std::make_pair(m_frame->frameID(), enclosingIntRect(viewRect)));
 }
 
 } // namespace blink