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 122 matching lines @@
 #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_lifecycleThrottlingMode(LifecycleThrottlingMode::Disallow)
+    , m_viewportVisibility(ViewportVisibility::Unknown)
+    , m_viewportVisibilityForThrottling(ViewportVisibility::Unknown)
+    , m_isCrossOriginForThrottling(false)
 {
     ASSERT(m_frame);
     init();
 }
 
 PassRefPtrWillBeRawPtr<FrameView> FrameView::create(LocalFrame* frame)
 {
     RefPtrWillBeRawPtr<FrameView> view = adoptRefWillBeNoop(new FrameView(frame));
     view->show();
     return view.release();
@@ skipping 929 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());
 
     // In slimming paint mode we do per-object invalidation.
     if (m_doFullPaintInvalidation && !RuntimeEnabledFeatures::slimmingPaintEnabled())
@@ skipping 193 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::setLifecycleThrottlingModeRecursive(LifecycleThrottlingMode lifecycleThrottlingMode)

[esprehn, 2015/09/02 21:10:37]

This actually doesn't need to be recursive, you can just do
.traverseNext(*frame())

[Sami, 2015/09/03 17:23:20]

Neat, thanks!

+{
+    m_lifecycleThrottlingMode = lifecycleThrottlingMode;
+
+    for (Frame* child = m_frame->tree().firstChild(); child; child = child->tree().nextSibling()) {
+        if (!child->isLocalFrame())
+            continue;
+        if (FrameView* view = toLocalFrame(child)->view())
+            view->setLifecycleThrottlingModeRecursive(lifecycleThrottlingMode);
+    }
+}
+
 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 1094 matching lines @@
 void FrameView::updateWidgetPositionsIfNeeded()
 {
     if (!m_needsUpdateWidgetPositions)
         return;
 
     m_needsUpdateWidgetPositions = false;
 
     updateWidgetPositions();
 }
 
-void FrameView::updateAllLifecyclePhases()
+void FrameView::updateAllLifecyclePhases(LifecycleThrottlingMode lifecycleThrottlingMode)
 {
-    frame().localFrameRoot()->view()->updateLifecyclePhasesInternal(AllPhases);
+    frame().localFrameRoot()->view()->updateLifecyclePhasesInternal(AllPhases, lifecycleThrottlingMode);
 }
 
 // TODO(chrishtr): add a scrolling update lifecycle phase.
-void FrameView::updateLifecycleToCompositingCleanPlusScrolling()
+void FrameView::updateLifecycleToCompositingCleanPlusScrolling(LifecycleThrottlingMode lifecycleThrottlingMode)
 {
-    frame().localFrameRoot()->view()->updateLifecyclePhasesInternal(OnlyUpToCompositingCleanPlusScrolling);
+    frame().localFrameRoot()->view()->updateLifecyclePhasesInternal(OnlyUpToCompositingCleanPlusScrolling, lifecycleThrottlingMode);
 }
 
-void FrameView::updateLifecyclePhasesInternal(LifeCycleUpdateOption phases)
+void FrameView::updateLifecyclePhasesInternal(LifeCycleUpdateOption phases, LifecycleThrottlingMode lifecycleThrottlingMode)
 {
     // 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);
 
+    setLifecycleThrottlingModeRecursive(lifecycleThrottlingMode);
     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 84 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 306 matching lines @@
 
     if (m_scrollbarsAvoidingResizer && parent())
         toFrameView(parent())->adjustScrollbarsAvoidingResizerCount(-m_scrollbarsAvoidingResizer);
 
     Widget::setParent(parentView);
 
     if (m_scrollbarsAvoidingResizer && parent())
         toFrameView(parent())->adjustScrollbarsAvoidingResizerCount(m_scrollbarsAvoidingResizer);
 
     updateScrollableAreaSet();
+    computeViewportVisibility();
 }
 
 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());
 
+    computeViewportVisibility();
     for (const auto& child : m_children)
         child->frameRectsChanged();
 }
 
 void FrameView::setLayoutSizeInternal(const IntSize& size)
 {
     if (m_layoutSize == size)
         return;
 
     m_layoutSize = size;
@@ skipping 770 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)
 {
+    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::computeViewportVisibility()
+{
+    // TODO(skyostil): Replace this with a position observer.

[esprehn, 2015/09/02 21:10:37]

This needs lifecycle asserts, what phases is this allowed in? What times?

[Sami, 2015/09/03 17:23:20]

Yeah, agreed. Since frameRectsChanged() is called from various places, the
lifecycle states we get here are pretty over the map. I'm thinking it'd be
better to just make a note here that the visibility info is dirty and actually
compute it at the end of the lifecycle. That way we only do it once per cycle
too.

+
+    // Our frame's bounds in our parent's content coordinates.
+    m_clippedBounds = frameRect();
+    m_viewportVisibility = ViewportVisibility::Visible;
+
+    FrameView* parent = parentFrameView();
+    if (!parent)
+        return;
+
+    // If our parent has indeterminate visibility, then so do we.
+    if (parent->m_viewportVisibility == ViewportVisibility::Unknown) {
+        m_viewportVisibility = ViewportVisibility::Unknown;
+        return;
+    }
+
+    // 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(false);

[esprehn, 2015/09/02 21:10:37]

This boolean is not clear.

[Sami, 2015/09/03 17:23:20]

Replaced with an enum.

+}
+
+void FrameView::updateThrottlingRecursive(bool hasCrossedSecurityOrigin)
+{
+    ASSERT(!isInPerformLayout());
+    bool wasThrottled = shouldThrottleRenderingPipeline();
+
+    // Visibility should never go back to an unknown state.
+    ASSERT(m_viewportVisibility != ViewportVisibility::Unknown
+        || m_viewportVisibilityForThrottling == ViewportVisibility::Unknown);

[esprehn, 2015/09/02 21:10:37]

Lets remove the Unknown state, you're either visible or not.

[Sami, 2015/09/03 17:23:20]

Ok, let's default to visible.

+    m_viewportVisibilityForThrottling = m_viewportVisibility;
+
+    // Check if we can access our parent's security origin. As an optimization only do this if we are invisible.
+    if (!hasCrossedSecurityOrigin && parentFrameView() && m_viewportVisibilityForThrottling == ViewportVisibility::Hidden) {

[esprehn, 2015/09/02 21:10:37]

What's the reason for this?

[Sami, 2015/09/03 17:23:20]

Added a big comment, but the tl;dr is that we want to avoid cases where frame A
depends on frame B and breaks if B is throttled. This could happen for instance
if the rAF in B drives something in A. The theory is that we can reduce the
chances this happening if we only throttle cross origin frames, because they
already need to communicate via postMessage and hence have an expectation of
some asynchronity.

+        const SecurityOrigin* origin = frame().securityContext()->securityOrigin();
+        const SecurityOrigin* parentOrigin = parentFrameView()->frame().securityContext()->securityOrigin();
+        hasCrossedSecurityOrigin = !origin->canAccess(parentOrigin);

[Mike West, 2015/09/02 11:30:08]

This looks pretty reasonable.

That said:

1. Do we need to care about the public suffix list? That is, are
"hangouts.google.com" and "myaccounts.google.com" cross-origin for purposes of
throttling? If not, you'll want to look into `OriginAccessEntry` (used in
`Document::firstPartyForCookies`, for example).

2. How will this work once the OOPIF work is done? I suppose `RemoteFrame`s
would always be cross-origin?

[Sami, 2015/09/03 14:07:56]

Great, thanks for checking.
 
Good question. The main thing I'm looking for here is whether frame A can
execute JS in frame B. If yes, then we shouldn't throttle B because A might
directly see the effects of throttling and the page could break. To use your
example, can hangouts.google.com poke into myaccounts.google.com (or vice versa)
and what determines that?
Thanks for mentioning this, I hadn't really considered all the interactions with
OOPIF. My understanding is that the local <=> remote boundary will always be
cross-origin, so this logic should work. I'm more unsure about what the frame
tree looks like in the remote processes and whether they can even do any
meaningful visibility determination. I'll do some experiments to find out.

+    }
+    // FIXME: Always throttle for testing.
+    hasCrossedSecurityOrigin = true;
+    m_isCrossOriginForThrottling = hasCrossedSecurityOrigin;
+
+    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(hasCrossedSecurityOrigin);
+    }
+}
+
+bool FrameView::shouldThrottleStyleLayoutAndCompositingUpdates() const
+{
+    return m_lifecycleThrottlingMode == LifecycleThrottlingMode::Allow

[esprehn, 2015/09/02 21:10:37]

This bit seems like it should be in the DocumentLifecyle, not here.

[Sami, 2015/09/03 17:23:20]

Good idea, done.

+        && shouldThrottleRenderingPipeline();
+}
+
+bool FrameView::shouldThrottleRenderingPipeline() const
+{
+    // FIXME: Ignore for layout testing
+    //if (!RuntimeEnabledFeatures::renderingPipelineThrottlingEnabled())
+        //return false;
+    return parent()

[esprehn, 2015/09/02 21:10:37]

This parent check shouldn't be needed.

[Sami, 2015/09/03 17:23:20]

Done.

+        && m_viewportVisibilityForThrottling == ViewportVisibility::Hidden
+        && m_isCrossOriginForThrottling;
+}
+
 } // namespace blink