Throttle rendering pipeline for invisible frames

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 75 matching lines @@
 #include "platform/TraceEvent.h"
 #include "platform/TracedValue.h"
 #include "platform/fonts/FontCache.h"
 #include "platform/geometry/DoubleRect.h"
 #include "platform/geometry/FloatRect.h"
 #include "platform/geometry/LayoutRect.h"
 #include "platform/graphics/GraphicsContext.h"
 #include "platform/graphics/GraphicsLayer.h"
 #include "platform/graphics/GraphicsLayerDebugInfo.h"
 #include "platform/graphics/paint/PaintController.h"
+#include "platform/scheduler/CancellableTaskFactory.h"
 #include "platform/scroll/ScrollAnimator.h"
 #include "platform/text/TextStream.h"
 #include "public/platform/WebDisplayItemList.h"
+#include "public/platform/WebFrameScheduler.h"
 #include "wtf/CurrentTime.h"
 #include "wtf/StdLibExtras.h"
 #include "wtf/TemporaryChange.h"
 
 namespace blink {
 
 using namespace HTMLNames;
 
 // The maximum number of updateWidgets iterations that should be done before returning.
 static const unsigned maxUpdateWidgetsIterations = 2;
 static const double resourcePriorityUpdateDelayAfterScroll = 0.250;
 
 static bool s_initialTrackAllPaintInvalidations = false;
 
 FrameView::FrameView(LocalFrame* frame)
     : m_frame(frame)
     , m_displayMode(WebDisplayModeBrowser)
     , m_canHaveScrollbars(true)
     , m_slowRepaintObjectCount(0)
     , m_hasPendingLayout(false)
     , m_inSynchronousPostLayout(false)
     , m_postLayoutTasksTimer(this, &FrameView::postLayoutTimerFired)
     , m_updateWidgetsTimer(this, &FrameView::updateWidgetsTimerFired)
+    , m_intersectionObserverNotificationFactory(CancellableTaskFactory::create(this, &FrameView::notifyIntersectionObservers))
     , m_isTransparent(false)
     , 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_needsUpdateViewportIntersection(true)
+    , m_needsUpdateViewportIntersectionInSubtree(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_frameTimingRequestsDirty(true)
-
+    , m_viewportIntersectionValid(false)
+    , m_hiddenForThrottling(false)
+    , m_crossOriginForThrottling(false)
 {
     ASSERT(m_frame);
     init();
 }
 
 PassRefPtrWillBeRawPtr<FrameView> FrameView::create(LocalFrame* frame)
 {
     RefPtrWillBeRawPtr<FrameView> view = adoptRefWillBeNoop(new FrameView(frame));
     view->show();
     return view.release();
@@ skipping 105 matching lines @@
 
     // Destroy |m_autoSizeInfo| as early as possible, to avoid dereferencing
     // partially destroyed |this| via |m_autoSizeInfo->m_frameView|.
     m_autoSizeInfo.clear();
 
     if (m_postLayoutTasksTimer.isActive())
         m_postLayoutTasksTimer.stop();
 
     if (m_didScrollTimer.isActive())
         m_didScrollTimer.stop();
+    m_intersectionObserverNotificationFactory->cancel();
 
     // FIXME: Do we need to do something here for OOPI?
     HTMLFrameOwnerElement* ownerElement = m_frame->deprecatedLocalOwner();
     // TODO(dcheng): It seems buggy that we can have an owner element that
     // points to another Widget.
     if (ownerElement && ownerElement->ownedWidget() == this)
         ownerElement->setWidget(nullptr);
 
 #if ENABLE(ASSERT)
     m_hasBeenDisposed = true;
@@ skipping 590 matching lines @@
 
 void FrameView::layout()
 {
     // We should never layout a Document which is not in a LocalFrame.
     ASSERT(m_frame);
     ASSERT(m_frame->view() == this);
     ASSERT(m_frame->page());
 
     ScriptForbiddenScope forbidScript;
 
-    if (isInPerformLayout() || !m_frame->document()->isActive())
+    if (isInPerformLayout() || !m_frame->document()->isActive() || shouldThrottleRendering())
         return;
 
     TRACE_EVENT0("blink,benchmark", "FrameView::layout");
     TRACE_EVENT_SCOPED_SAMPLING_STATE("blink", "Layout");
 
     // Protect the view from being deleted during layout (in recalcStyle)
     RefPtrWillBeRawPtr<FrameView> protector(this);
 
     if (m_autoSizeInfo)
         m_autoSizeInfo->autoSizeIfNeeded();
@@ skipping 163 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 (shouldThrottleRendering())
+        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 (shouldThrottleRendering())
+        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();
     }
 }
 
@@ skipping 400 matching lines @@
     if (!m_frame->document()->shouldScheduleLayout())
         return;
     TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "InvalidateLayout", TRACE_EVENT_SCOPE_THREAD, "data", InspectorInvalidateLayoutEvent::data(m_frame.get()));
 
     clearLayoutSubtreeRootsAndMarkContainingBlocks();
 
     if (m_hasPendingLayout)
         return;
     m_hasPendingLayout = true;
 
-    page()->animator().scheduleVisualUpdate(m_frame.get());
+    if (!shouldThrottleRendering())
+        page()->animator().scheduleVisualUpdate(m_frame.get());
     lifecycle().ensureStateAtMost(DocumentLifecycle::StyleClean);
 }
 
 void FrameView::scheduleRelayoutOfSubtree(LayoutObject* relayoutRoot)
 {
     ASSERT(m_frame->view() == this);
 
     // FIXME: Should this call shouldScheduleLayout instead?
     if (!m_frame->document()->isActive())
         return;
@@ skipping 697 matching lines @@
     // 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);
 
     updateStyleAndLayoutIfNeededRecursive();
     ASSERT(lifecycle().state() >= DocumentLifecycle::LayoutClean);
 
-    if (phases == OnlyUpToLayoutClean)
+    if (phases == OnlyUpToLayoutClean) {
+        updateViewportIntersectionsForSubtree();
         return;
+    }
 
     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();
 
         ASSERT(lifecycle().state() >= DocumentLifecycle::CompositingClean);
@@ skipping 17 matching lines @@
 
             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());
 
     lifecycle().advanceTo(DocumentLifecycle::InUpdatePaintProperties);
     // TODO(pdr): Calculate the paint properties by walking the layout tree.
     lifecycle().advanceTo(DocumentLifecycle::UpdatePaintPropertiesClean);
 }
@@ skipping 70 matching lines @@
     collectFrameTimingRequestsRecursive(graphicsLayerTimingRequests);
 
     for (const auto& iter : graphicsLayerTimingRequests) {
         const GraphicsLayer* graphicsLayer = iter.key;
         graphicsLayer->platformLayer()->setFrameTimingRequests(iter.value);
     }
 }
 
 void FrameView::updateStyleAndLayoutIfNeededRecursive()
 {
+    if (shouldThrottleRendering())
+        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 34 matching lines @@
 
     updateWidgetPositionsIfNeeded();
 
     if (lifecycle().state() < DocumentLifecycle::LayoutClean)
         lifecycle().advanceTo(DocumentLifecycle::LayoutClean);
 }
 
 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 (shouldThrottleRendering())
+        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();
+    setNeedsUpdateViewportIntersection();
 }
 
 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());
 
+    setNeedsUpdateViewportIntersection();
     for (const auto& child : m_children)
         child->frameRectsChanged();
 }
 
 void FrameView::setLayoutSizeInternal(const IntSize& size)
 {
     if (m_layoutSize == size)
         return;
 
     m_layoutSize = size;
@@ skipping 756 matching lines @@
     return ScrollBehaviorInstant;
 }
 
 void FrameView::paint(GraphicsContext* context, const IntRect& rect) const
 {
     paint(context, GlobalPaintNormalPhase, rect);
 }
 
 void FrameView::paint(GraphicsContext* context, const GlobalPaintFlags globalPaintFlags, const IntRect& rect) const
 {
+    // TODO(skyostil): Remove this early-out in favor of painting cached scrollbars.
+    if (shouldThrottleRendering())
+        return;
     FramePainter(*this).paint(context, globalPaintFlags, rect);
 }
 
 void FrameView::paintContents(GraphicsContext* context, const GlobalPaintFlags globalPaintFlags, const IntRect& damageRect) const
 {
+    if (shouldThrottleRendering())
+        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;
 
     PaintLayer::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::setNeedsUpdateViewportIntersection()
+{
+    m_needsUpdateViewportIntersection = true;
+    for (FrameView* parent = parentFrameView(); parent; parent = parent->parentFrameView())
+        parent->m_needsUpdateViewportIntersectionInSubtree = true;
+}
+
+void FrameView::updateViewportIntersectionIfNeeded()
+{
+    // TODO(skyostil): Replace this with a real intersection observer.
+    if (!m_needsUpdateViewportIntersection)
+        return;
+    m_needsUpdateViewportIntersection = false;
+    m_viewportIntersectionValid = true;
+
+    FrameView* parent = parentFrameView();
+    if (!parent) {
+        m_viewportIntersection = frameRect();
+        return;
+    }
+    ASSERT(!parent->m_needsUpdateViewportIntersection);
+
+    // If our parent is hidden, then we are too.
+    if (parent->m_viewportIntersection.isEmpty()) {
+        m_viewportIntersection = parent->m_viewportIntersection;
+        return;
+    }
+
+    // Transform our bounds into the root frame's content coordinate space,
+    // making sure we have valid layout data in our parent document. If our
+    // parent is throttled, we'll use possible stale layout information and
+    // rely on the fact that another lifecycle update will be scheduled once
+    // our parent becomes unthrottled.
+    ASSERT(parent->lifecycle().state() >= DocumentLifecycle::LayoutClean || parent->shouldThrottleRendering());
+    m_viewportIntersection = parent->contentsToRootFrame(frameRect());
+
+    // TODO(skyostil): Expand the viewport to make it less likely to see stale content while scrolling.
+    IntRect viewport = parent->m_viewportIntersection;
+    m_viewportIntersection.intersect(viewport);
+}
+
+void FrameView::updateViewportIntersectionsForSubtree()
+{
+    bool hadValidIntersection = m_viewportIntersectionValid;
+    bool hadEmptyIntersection = m_viewportIntersection.isEmpty();
+    updateViewportIntersectionIfNeeded();
+    bool shouldNotify = !hadValidIntersection || hadEmptyIntersection != m_viewportIntersection.isEmpty();
+    if (shouldNotify && !m_intersectionObserverNotificationFactory->isPending())
+        m_frame->frameScheduler()->timerTaskRunner()->postTask(FROM_HERE, m_intersectionObserverNotificationFactory->cancelAndCreate());
+
+    if (!m_needsUpdateViewportIntersectionInSubtree)
+        return;
+    m_needsUpdateViewportIntersectionInSubtree = false;
+
+    for (Frame* child = m_frame->tree().firstChild(); child; child = child->tree().nextSibling()) {
+        if (!child->isLocalFrame())
+            continue;
+        if (FrameView* view = toLocalFrame(child)->view())
+            view->updateViewportIntersectionsForSubtree();
+    }
+}
+
+void FrameView::notifyIntersectionObservers()
+{
+    TRACE_EVENT0("blink", "FrameView::notifyIntersectionObservers");
+    ASSERT(!isInPerformLayout());
+    ASSERT(!m_frame->document()->inStyleRecalc());
+    bool wasThrottled = canThrottleRendering();
+
+    // Only offscreen frames can be throttled.
+    m_hiddenForThrottling = m_viewportIntersectionValid && m_viewportIntersection.isEmpty();
+
+    // 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.
+    m_crossOriginForThrottling = false;
+    const SecurityOrigin* origin = frame().securityContext()->securityOrigin();
+    for (Frame* parentFrame = m_frame->tree().parent(); parentFrame; parentFrame = parentFrame->tree().parent()) {
+        const SecurityOrigin* parentOrigin = parentFrame->securityContext()->securityOrigin();
+        if (!origin->canAccess(parentOrigin)) {
+            m_crossOriginForThrottling = true;
+            break;
+        }
+    }
+
+    bool becameUnthrottled = wasThrottled && !canThrottleRendering();
+    if (becameUnthrottled)
+        page()->animator().scheduleVisualUpdate(m_frame.get());
+}
+
+bool FrameView::shouldThrottleRendering() const
+{
+    return canThrottleRendering() && lifecycle().throttlingAllowed();
+}
+
+bool FrameView::canThrottleRendering() const
+{
+    if (!RuntimeEnabledFeatures::renderingPipelineThrottlingEnabled())
+        return false;
+    return m_hiddenForThrottling && m_crossOriginForThrottling;
+}
+
 } // namespace blink