Throttle rendering pipeline for invisible iframes

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 112 matching lines @@
     , m_baseBackgroundColor(Color::white)
     , m_mediaType(MediaTypeNames::screen)
     , m_safeToPropagateScrollToParent(true)
     , m_isTrackingPaintInvalidations(false)
     , m_scrollCorner(nullptr)
     , m_inputEventsScaleFactorForEmulation(1)
     , m_layoutSizeFixedToFrameSize(true)
     , m_didScrollTimer(this, &FrameView::didScrollTimerFired)
     , m_topControlsViewportAdjustment(0)
     , m_needsUpdateWidgetPositions(false)
+    , m_needsUpdateViewportVisibility(true)
 #if ENABLE(ASSERT)
     , m_hasBeenDisposed(false)
 #endif
     , m_horizontalScrollbarMode(ScrollbarAuto)
     , m_verticalScrollbarMode(ScrollbarAuto)
     , m_horizontalScrollbarLock(false)
     , m_verticalScrollbarLock(false)
     , m_scrollbarsAvoidingResizer(0)
     , m_scrollbarsSuppressed(false)
     , m_inUpdateScrollbars(false)
     , m_clipsRepaints(true)
     , m_frameTimingRequestsDirty(true)
-
+    , m_viewportVisibility(ViewportVisibility::Visible)
+    , m_securityOriginStatusForThrottling(SecurityOriginStatus::IsSameOrigin)
 {
     ASSERT(m_frame);
     init();
 }
 
 PassRefPtrWillBeRawPtr<FrameView> FrameView::create(LocalFrame* frame)
 {
     RefPtrWillBeRawPtr<FrameView> view = adoptRefWillBeNoop(new FrameView(frame));
     view->show();
     return view.release();
@@ skipping 921 matching lines @@
 
     frame().document()->layoutUpdated();
 }
 
 // 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(PaintInvalidationState& paintInvalidationState)
 {
+    if (shouldThrottleRenderingPipeline())
+        return;
+
     lifecycle().advanceTo(DocumentLifecycle::InPaintInvalidation);
 
     ASSERT(layoutView());
     LayoutView& rootForPaintInvalidation = *layoutView();
     ASSERT(!rootForPaintInvalidation.needsLayout());
 
     TRACE_EVENT1("blink", "FrameView::invalidateTree", "root", rootForPaintInvalidation.debugName().ascii());
 
     rootForPaintInvalidation.invalidateTreeIfNeeded(paintInvalidationState);
 
@@ skipping 189 matching lines @@
 }
 
 bool FrameView::shouldSetCursor() const
 {
     Page* page = frame().page();
     return page && page->visibilityState() != PageVisibilityStateHidden && page->focusController().isActive() && page->settings().deviceSupportsMouse();
 }
 
 void FrameView::scrollContentsIfNeededRecursive()
 {
+    if (shouldThrottleStyleLayoutAndCompositingUpdates())
+        return;
     scrollContentsIfNeeded();
 
     for (Frame* child = m_frame->tree().firstChild(); child; child = child->tree().nextSibling()) {
         if (!child->isLocalFrame())
             continue;
         if (FrameView* view = toLocalFrame(child)->view())
             view->scrollContentsIfNeededRecursive();
     }
 }
 
+void FrameView::setLifecycleThrottlingModeForSubtree(DocumentLifecycle::ThrottlingMode throttlingMode)
+{
+    ASSERT(m_frame->isLocalRoot());
+    for (Frame* frame = m_frame.get(); frame; frame = frame->tree().traverseNext(m_frame.get())) {
+        if (!frame->isLocalFrame())
+            continue;
+        if (FrameView* view = toLocalFrame(frame)->view())
+            view->lifecycle().setThrottlingMode(throttlingMode);
+    }
+}
+
 bool FrameView::invalidateViewportConstrainedObjects()
 {
     for (const auto& viewportConstrainedObject : *m_viewportConstrainedObjects) {
         LayoutObject* layoutObject = viewportConstrainedObject;
         ASSERT(layoutObject->style()->hasViewportConstrainedPosition());
         ASSERT(layoutObject->hasLayer());
         DeprecatedPaintLayer* layer = toLayoutBoxModelObject(layoutObject)->layer();
 
         if (layer->isPaintInvalidationContainer())
             continue;
@@ skipping 1095 matching lines @@
 void FrameView::updateWidgetPositionsIfNeeded()
 {
     if (!m_needsUpdateWidgetPositions)
         return;
 
     m_needsUpdateWidgetPositions = false;
 
     updateWidgetPositions();
 }
 
-void FrameView::updateAllLifecyclePhases(const LayoutRect& interestRect)
+void FrameView::updateAllLifecyclePhases(DocumentLifecycle::ThrottlingMode throttlingMode, const LayoutRect& interestRect)
 {
-    frame().localFrameRoot()->view()->updateLifecyclePhasesInternal(AllPhases, interestRect);
+    frame().localFrameRoot()->view()->updateLifecyclePhasesInternal(AllPhases, throttlingMode, interestRect);
 }
 
 // TODO(chrishtr): add a scrolling update lifecycle phase.
-void FrameView::updateLifecycleToCompositingCleanPlusScrolling()
+void FrameView::updateLifecycleToCompositingCleanPlusScrolling(DocumentLifecycle::ThrottlingMode throttlingMode)
 {
-    frame().localFrameRoot()->view()->updateLifecyclePhasesInternal(OnlyUpToCompositingCleanPlusScrolling);
+    frame().localFrameRoot()->view()->updateLifecyclePhasesInternal(OnlyUpToCompositingCleanPlusScrolling, throttlingMode, LayoutRect::infiniteRect());
 }
 
-void FrameView::updateLifecyclePhasesInternal(LifeCycleUpdateOption phases, const LayoutRect& interestRect)
+void FrameView::updateLifecyclePhasesInternal(LifeCycleUpdateOption phases, DocumentLifecycle::ThrottlingMode throttlingMode, const LayoutRect& interestRect)
 {
     // This must be called from the root frame, since it recurses down, not up.
     // Otherwise the lifecycles of the frames might be out of sync.
     ASSERT(m_frame->isLocalRoot());
 
     // Updating layout can run script, which can tear down the FrameView.
     RefPtrWillBeRawPtr<FrameView> protector(this);
 
+    setLifecycleThrottlingModeForSubtree(throttlingMode);
     updateStyleAndLayoutIfNeededRecursive();
 
     if (LayoutView* view = layoutView()) {
         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();
 
@@ skipping 74 matching lines @@
     collectFrameTimingRequestsRecursive(graphicsLayerTimingRequests);
 
     for (const auto& iter : graphicsLayerTimingRequests) {
         const GraphicsLayer* graphicsLayer = iter.key;
         graphicsLayer->platformLayer()->setFrameTimingRequests(iter.value);
     }
 }
 
 void FrameView::updateStyleAndLayoutIfNeededRecursive()
 {
+    if (shouldThrottleStyleLayoutAndCompositingUpdates())
+        return;
+
     // We have to crawl our entire subtree looking for any FrameViews that need
     // layout and make sure they are up to date.
     // Mac actually tests for intersection with the dirty region and tries not to
     // update layout for frames that are outside the dirty region.  Not only does this seem
     // pointless (since those frames will have set a zero timer to layout anyway), but
     // it is also incorrect, since if two frames overlap, the first could be excluded from the dirty
     // region but then become included later by the second frame adding rects to the dirty region
     // when it lays out.
 
     m_frame->document()->updateLayoutTreeIfNeeded();
@@ skipping 31 matching lines @@
 #if ENABLE(ASSERT)
     m_frame->document()->layoutView()->assertLaidOut();
 #endif
 
     updateWidgetPositionsIfNeeded();
 }
 
 void FrameView::invalidateTreeIfNeededRecursive()
 {
     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 (shouldThrottleRenderingPipeline())
+        return;
     TRACE_EVENT1("blink", "FrameView::invalidateTreeIfNeededRecursive", "root", layoutView()->debugName().ascii());
 
     Vector<LayoutObject*> pendingDelayedPaintInvalidations;
     PaintInvalidationState rootPaintInvalidationState(*layoutView(), pendingDelayedPaintInvalidations);
 
     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.
@@ skipping 298 matching lines @@
 
     if (m_scrollbarsAvoidingResizer && parent())
         toFrameView(parent())->adjustScrollbarsAvoidingResizerCount(-m_scrollbarsAvoidingResizer);
 
     Widget::setParent(parentView);
 
     if (m_scrollbarsAvoidingResizer && parent())
         toFrameView(parent())->adjustScrollbarsAvoidingResizerCount(m_scrollbarsAvoidingResizer);
 
     updateScrollableAreaSet();
+    m_needsUpdateViewportVisibility = true;
 }
 
 void FrameView::removeChild(Widget* child)
 {
     ASSERT(child->parent() == this);
 
     if (child->isFrameView())
         removeScrollableArea(toFrameView(child));
 
     child->setParent(0);
@@ skipping 37 matching lines @@
         return;
     page->chromeClient().setCursor(cursor);
 }
 
 void FrameView::frameRectsChanged()
 {
     TRACE_EVENT0("blink", "FrameView::frameRectsChanged");
     if (layoutSizeFixedToFrameSize())
         setLayoutSizeInternal(frameRect().size());
 
+    m_needsUpdateViewportVisibility = true;
     for (const auto& child : m_children)
         child->frameRectsChanged();
 }
 
 void FrameView::setLayoutSizeInternal(const IntSize& size)
 {
     if (m_layoutSize == size)
         return;
 
     m_layoutSize = size;
@@ skipping 761 matching lines @@
     return ScrollBehaviorInstant;
 }
 
 void FrameView::paint(GraphicsContext* context, const IntRect& rect)
 {
     paint(context, GlobalPaintNormalPhase, rect);
 }
 
 void FrameView::paint(GraphicsContext* context, const GlobalPaintFlags globalPaintFlags, const IntRect& rect)
 {
+    // TODO(skyostil): Remove this early-out in favor of painting cached scrollbars.
+    if (shouldThrottleRenderingPipeline())
+        return;
     FramePainter(*this).paint(context, globalPaintFlags, rect);
 }
 
 void FrameView::paintContents(GraphicsContext* context, const GlobalPaintFlags globalPaintFlags, const IntRect& damageRect)
 {
+    if (shouldThrottleRenderingPipeline())
+        return;
     FramePainter(*this).paintContents(context, globalPaintFlags, damageRect);
 }
 
 bool FrameView::isPointInScrollbarCorner(const IntPoint& windowPoint)
 {
     if (!scrollbarCornerPresent())
         return false;
 
     IntPoint framePoint = convertFromContainingWindow(windowPoint);
 
@@ skipping 167 matching lines @@
 }
 
 void FrameView::collectFrameTimingRequests(GraphicsLayerFrameTimingRequests& graphicsLayerTimingRequests)
 {
     if (!m_frame->isLocalFrame())
         return;
     Frame* frame = m_frame.get();
     LocalFrame* localFrame = toLocalFrame(frame);
     LayoutRect viewRect = localFrame->contentLayoutObject()->viewRect();
     const LayoutBoxModelObject* paintInvalidationContainer = localFrame->contentLayoutObject()->containerForPaintInvalidation();
+    // If the frame is being throttled, its compositing state may not be up to date.
+    if (!paintInvalidationContainer->enclosingLayer()->isAllowedToQueryCompositingState())
+        return;
     const GraphicsLayer* graphicsLayer = paintInvalidationContainer->enclosingLayer()->graphicsLayerBacking();
 
     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)));
 }
 
+void FrameView::updateViewportVisibilityIfNeeded()
+{
+    // TODO(skyostil): Replace this with an intersection observer.
+
+    // Without slimming paint v2 we can sometimes end up back in LayoutClean
+    // during painting (e.g., because of block selection gaps).

[esprehn, 2015/09/21 21:27:20]

huh?

[Sami, 2015/09/23 18:31:07]

Yeah :( I found out that block selections can invalidate compositing inputs
during painting, see
https://code.google.com/p/chromium/codesearch#chromium/src/third_party/WebKit....

Added a pointer to that function here.

+    if (RuntimeEnabledFeatures::slimmingPaintV2Enabled())
+        ASSERT(shouldThrottleRenderingPipeline() || lifecycle().state() >= DocumentLifecycle::PaintInvalidationClean);
+    else
+        ASSERT(shouldThrottleRenderingPipeline() || lifecycle().state() >= DocumentLifecycle::LayoutClean);
+    if (!m_needsUpdateViewportVisibility)
+        return;
+
+    // Our frame's bounds in our parent's content coordinates.
+    m_clippedBounds = frameRect();
+    m_viewportVisibility = ViewportVisibility::Visible;
+    m_needsUpdateViewportVisibility = false;
+
+    FrameView* parent = parentFrameView();
+    if (!parent)
+        return;
+    ASSERT(!parent->m_needsUpdateViewportVisibility);
+
+    // If our parent is hidden, then we are too.
+    if (parent->m_viewportVisibility == ViewportVisibility::Hidden) {
+        m_viewportVisibility = ViewportVisibility::Hidden;
+        return;
+    }
+
+    // Transform our bounds into the root frame's content coordinate space.
+    m_clippedBounds = parent->contentsToRootFrame(m_clippedBounds);
+
+    // TODO(skyostil): Expand the viewport to make it less likely to see stale content while scrolling.
+    IntRect viewport = parent->m_clippedBounds;
+    m_clippedBounds.intersect(viewport);
+
+    // If our bounds got clipped away, we are invisible.
+    if (m_clippedBounds.isEmpty())
+        m_viewportVisibility = ViewportVisibility::Hidden;
+}
+
+void FrameView::updateThrottling()
+{
+    ASSERT(m_frame->isLocalRoot());
+    updateThrottlingRecursive(SecurityOriginStatus::IsSameOrigin);
+}
+
+void FrameView::updateThrottlingRecursive(SecurityOriginStatus securityOriginStatus)
+{
+    ASSERT(!isInPerformLayout());
+    // Without slimming paint v2 we can sometimes end up back in LayoutClean
+    // during painting (e.g., because of block selection gaps).
+    if (RuntimeEnabledFeatures::slimmingPaintV2Enabled())
+        ASSERT(shouldThrottleRenderingPipeline() || lifecycle().state() >= DocumentLifecycle::PaintInvalidationClean);
+    else
+        ASSERT(shouldThrottleRenderingPipeline() || lifecycle().state() >= DocumentLifecycle::LayoutClean);
+    bool wasThrottled = shouldThrottleRenderingPipeline();
+
+    updateViewportVisibilityIfNeeded();
+
+    // We only throttle the rendering pipeline in cross-origin frames. This is
+    // to avoid a situation where an ancestor frame directly depends on the
+    // pipeline timing of a descendant and breaks as a result of throttling.
+    // The rationale is that cross-origin frames must already communicate with
+    // asynchronous messages, so they should be able to tolerate some delay in
+    // receiving replies from a throttled peer.
+    //
+    // Check if we can access our parent's security origin. As an optimization
+    // only do this if we are invisible.
+    if (securityOriginStatus == SecurityOriginStatus::IsSameOrigin
+        && parentFrameView() && m_viewportVisibility == ViewportVisibility::Hidden) {
+        const SecurityOrigin* origin = frame().securityContext()->securityOrigin();
+        const SecurityOrigin* parentOrigin = parentFrameView()->frame().securityContext()->securityOrigin();
+        if (!origin->canAccess(parentOrigin))
+            securityOriginStatus = SecurityOriginStatus::IsCrossOrigin;
+    }
+    m_securityOriginStatusForThrottling = securityOriginStatus;
+
+    bool becameUnthrottled = wasThrottled && !shouldThrottleRenderingPipeline();
+    if (becameUnthrottled)
+        page()->animator().scheduleVisualUpdate(m_frame.get());
+
+    for (Frame* child = m_frame->tree().firstChild(); child; child = child->tree().nextSibling()) {
+        if (!child->isLocalFrame())
+            continue;
+        if (FrameView* view = toLocalFrame(child)->view())
+            view->updateThrottlingRecursive(securityOriginStatus);
+    }
+}
+
+bool FrameView::shouldThrottleStyleLayoutAndCompositingUpdates() const
+{
+    return lifecycle().throttlingMode() == DocumentLifecycle::ThrottlingMode::Allow
+        && shouldThrottleRenderingPipeline();
+}
+
+bool FrameView::shouldThrottleRenderingPipeline() const
+{
+    if (!RuntimeEnabledFeatures::renderingPipelineThrottlingEnabled())
+        return false;
+    return m_viewportVisibility == ViewportVisibility::Hidden
+        && m_securityOriginStatusForThrottling == SecurityOriginStatus::IsCrossOrigin;
+}
+
 } // namespace blink