Use intersection observer to control frame throttling

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 15 matching lines @@
 
 #include "core/frame/FrameView.h"
 
 #include "core/HTMLNames.h"
 #include "core/MediaTypeNames.h"
 #include "core/css/FontFaceSet.h"
 #include "core/css/resolver/StyleResolver.h"
 #include "core/dom/AXObjectCache.h"
 #include "core/dom/DOMNodeIds.h"
 #include "core/dom/Fullscreen.h"
+#include "core/dom/IntersectionObserverCallback.h"
 #include "core/dom/IntersectionObserverController.h"
+#include "core/dom/IntersectionObserverInit.h"
 #include "core/editing/EditingUtilities.h"
 #include "core/editing/FrameSelection.h"
 #include "core/editing/RenderedPosition.h"
 #include "core/editing/markers/DocumentMarkerController.h"
 #include "core/events/ErrorEvent.h"
 #include "core/fetch/ResourceFetcher.h"
 #include "core/frame/EventHandlerRegistry.h"
 #include "core/frame/FrameHost.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Location.h"
@@ skipping 97 matching lines @@
 static bool s_initialTrackAllPaintInvalidations = false;
 
 FrameView::FrameView(LocalFrame* frame)
     : m_frame(frame)
     , m_displayMode(WebDisplayModeBrowser)
     , m_canHaveScrollbars(true)
     , m_hasPendingLayout(false)
     , m_inSynchronousPostLayout(false)
     , m_postLayoutTasksTimer(this, &FrameView::postLayoutTimerFired)
     , m_updateWidgetsTimer(this, &FrameView::updateWidgetsTimerFired)
-    , m_renderThrottlingObserverNotificationFactory(CancellableTaskFactory::create(this, &FrameView::notifyRenderThrottlingObservers))
     , m_isTransparent(false)
     , m_baseBackgroundColor(Color::white)
     , m_mediaType(MediaTypeNames::screen)
     , m_safeToPropagateScrollToParent(true)
     , m_scrollCorner(nullptr)
     , m_stickyPositionObjectCount(0)
     , m_inputEventsScaleFactorForEmulation(1)
     , m_layoutSizeFixedToFrameSize(true)
     , m_didScrollTimer(this, &FrameView::didScrollTimerFired)
     , m_topControlsViewportAdjustment(0)
     , m_needsUpdateWidgetGeometries(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)
     , m_subtreeThrottled(false)
     , m_currentUpdateLifecyclePhasesTargetState(DocumentLifecycle::Uninitialized)
     , m_needsScrollbarsUpdate(false)
     , m_suppressAdjustViewSize(false)
     , m_allowsLayoutInvalidationAfterLayoutClean(true)
 {
     ASSERT(m_frame);
     init();
 }
 
@@ skipping 24 matching lines @@
     visitor->trace(m_frame);
     visitor->trace(m_fragmentAnchor);
     visitor->trace(m_scrollableAreas);
     visitor->trace(m_animatingScrollableAreas);
     visitor->trace(m_autoSizeInfo);
     visitor->trace(m_horizontalScrollbar);
     visitor->trace(m_verticalScrollbar);
     visitor->trace(m_children);
     visitor->trace(m_viewportScrollableArea);
     visitor->trace(m_scrollAnchor);
+    visitor->trace(m_intersectionObserver);
     Widget::trace(visitor);
     ScrollableArea::trace(visitor);
 }
 
 void FrameView::reset()
 {
     m_hasPendingLayout = false;
     m_layoutSchedulingEnabled = true;
     m_inSynchronousPostLayout = false;
     m_layoutCount = 0;
@@ skipping 37 matching lines @@
 {
     reset();
 
     m_size = LayoutSize();
 
     // Propagate the marginwidth/height and scrolling modes to the view.
     if (m_frame->owner() && m_frame->owner()->scrollingMode() == ScrollbarAlwaysOff)
         setCanHaveScrollbars(false);
 }
 
+void FrameView::setupRenderThrottling()
+{
+    if (m_intersectionObserver || !frame().document() || !frame().document()->frame() || !frame().document()->documentElement())
+        return;
+
+    ExecutionContext* context = frame().document();
+    IntersectionObserverInit observerInit;
+    // Intersection observer does not currently support remote frames. As a
+    // workaround we monitor visibility up to the local root (crbug.com/615156).
+    Frame* mainFrame = frame().tree().top();
+    if (!mainFrame || !mainFrame->isLocalFrame()) {
+        observerInit.setRoot(frame().localFrameRoot()->document()->documentElement());
+        context = &observerInit.root()->document();
+    }

[szager1, 2016/08/31 20:54:27]

Shouldn't this be:

} else {
  context = mainFrame->document();
}

?

[Sami, 2016/09/01 11:11:35]

Ah, well spotted, thanks.

+
+    IntersectionObserverCallback* callback = new IntersectionObserverCallback(this, context);
+    m_intersectionObserver = IntersectionObserver::create(observerInit, *callback, ASSERT_NO_EXCEPTION);
+    m_intersectionObserver->setLowLatency(true);
+    m_intersectionObserver->observe(frame().document()->documentElement());
+
+    // Initially the intersection observer assumes the target is hidden. If it
+    // actually is, no notification about this will be delivered. To work around
+    // this, we set the observer into an undefined state so the first
+    // notification will always get delivered.
+    for (auto& observation : m_intersectionObserver->observations())
+        observation->setLastThresholdIndex(std::numeric_limits<unsigned>::max());
+}
+
 void FrameView::dispose()
 {
     RELEASE_ASSERT(!isInPerformLayout());
 
     if (ScrollAnimatorBase* scrollAnimator = existingScrollAnimator())
         scrollAnimator->cancelAnimation();
     cancelProgrammaticScrollAnimation();
 
     detachScrollbars();
 
@@ skipping 10 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_renderThrottlingObserverNotificationFactory->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 2859 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();
+
+    setupRenderThrottling();
 }
 
 void FrameView::removeChild(Widget* child)
 {
     ASSERT(child->parent() == this);
 
     if (child->isFrameView())
         removeScrollableArea(toFrameView(child));
 
     child->setParent(0);
@@ skipping 958 matching lines @@
     if (layoutObject.isText())
         return;
 
     layoutObject.addAnnotatedRegions(regions);
     for (LayoutObject* curr = layoutObject.slowFirstChild(); curr; curr = curr->nextSibling())
         collectAnnotatedRegions(*curr, regions);
 }
 
 void FrameView::setNeedsUpdateViewportIntersection()
 {
-    m_needsUpdateViewportIntersection = true;
     for (FrameView* parent = parentFrameView(); parent; parent = parent->parentFrameView())
         parent->m_needsUpdateViewportIntersectionInSubtree = true;
 }
 
-void FrameView::updateViewportIntersectionIfNeeded()
-{
-    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(DocumentLifecycle::LifecycleState targetState)
 {
-    bool hadValidIntersection = m_viewportIntersectionValid;
-    bool hadEmptyIntersection = m_viewportIntersection.isEmpty();
-    updateViewportIntersectionIfNeeded();
-
     // Notify javascript IntersectionObservers
     if (targetState == DocumentLifecycle::PaintClean && frame().document()->intersectionObserverController())
         frame().document()->intersectionObserverController()->computeTrackedIntersectionObservations();
 
-    // Adjust render throttling for iframes based on visibility
-    bool shouldNotify = !hadValidIntersection || hadEmptyIntersection != m_viewportIntersection.isEmpty();
-    if (shouldNotify && !m_renderThrottlingObserverNotificationFactory->isPending())
-        m_frame->frameScheduler()->unthrottledTaskRunner()->postTask(BLINK_FROM_HERE, m_renderThrottlingObserverNotificationFactory->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(targetState);
     }
 }
 
-void FrameView::updateThrottlingStatus()
+void FrameView::updateRenderThrottlingStatusForTesting()
 {
-    // Only offscreen frames can be throttled.
-    DCHECK(m_viewportIntersectionValid);
-    m_hiddenForThrottling = 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;
-    // If any of our parents are throttled, we must be too.
-    m_subtreeThrottled = false;
-    const SecurityOrigin* origin = frame().securityContext()->getSecurityOrigin();
-    for (Frame* parentFrame = m_frame->tree().parent(); parentFrame; parentFrame = parentFrame->tree().parent()) {
-        const SecurityOrigin* parentOrigin = parentFrame->securityContext()->getSecurityOrigin();
-        if (!origin->canAccess(parentOrigin))
-            m_crossOriginForThrottling = true;
-        if (parentFrame->isLocalFrame() && toLocalFrame(parentFrame)->view() && toLocalFrame(parentFrame)->view()->canThrottleRendering())
-            m_subtreeThrottled = true;
-    }
-    m_frame->frameScheduler()->setFrameVisible(!m_hiddenForThrottling);
-    m_frame->frameScheduler()->setCrossOrigin(m_crossOriginForThrottling);
+    m_intersectionObserver->deliver();
 }
 
-void FrameView::notifyRenderThrottlingObserversForTesting()
-{
-    DCHECK(m_renderThrottlingObserverNotificationFactory->isPending());
-    notifyRenderThrottlingObservers();
-}
-
-void FrameView::notifyRenderThrottlingObservers()
+void FrameView::updateRenderThrottlingStatus(bool hidden, bool subtreeThrottled)
 {
     TRACE_EVENT0("blink", "FrameView::notifyRenderThrottlingObservers");
     DCHECK(!isInPerformLayout());
     DCHECK(!m_frame->document() || !m_frame->document()->inStyleRecalc());
     bool wasThrottled = canThrottleRendering();
 
-    updateThrottlingStatus();
+    m_hiddenForThrottling = hidden;
+    m_subtreeThrottled = subtreeThrottled;
 
-    bool becameThrottled = !wasThrottled && canThrottleRendering();
-    bool becameUnthrottled = wasThrottled && !canThrottleRendering();
+    bool isThrottled = canThrottleRendering();
+    bool becameUnthrottled = wasThrottled && !isThrottled;
+
+    // If this FrameView became unthrottled or throttled, we must make sure all
+    // its children are notified synchronously. Otherwise we 1) might attempt to
+    // paint one of the children with an out-of-date layout before
+    // |updateRenderThrottlingStatus| has made it throttled or 2) fail to
+    // unthrottle a child whose parent is unthrottled by a later notification.
+    if (wasThrottled != isThrottled) {
+        for (const Member<Widget>& child : *children()) {
+            if (child->isFrameView()) {
+                FrameView* childView = toFrameView(child);
+                childView->updateRenderThrottlingStatus(childView->m_hiddenForThrottling, isThrottled);
+            }
+        }
+    }
+
     ScrollingCoordinator* scrollingCoordinator = this->scrollingCoordinator();
-    if (becameThrottled) {
-        // If this FrameView became throttled, we must make sure all of its
-        // children become throttled at the same time. Otherwise we might
-        // attempt to paint one of the children with an out-of-date layout
-        // before |notifyRenderThrottlingObservers| has made it throttled.
-        forAllNonThrottledFrameViews([](FrameView& frameView) {
-            frameView.m_subtreeThrottled = true;
-            DCHECK(frameView.canThrottleRendering());
-        });
-    }
     if (becameUnthrottled) {
         // ScrollingCoordinator needs to update according to the new throttling status.
         if (scrollingCoordinator)
             scrollingCoordinator->notifyGeometryChanged();
         // Start ticking animation frames again if necessary.
         if (page())
             page()->animator().scheduleVisualUpdate(m_frame.get());
         // Force a full repaint of this frame to ensure we are not left with a
         // partially painted version of this frame's contents if we skipped
         // painting them while the frame was throttled.
@@ skipping 18 matching lines @@
 
 bool FrameView::shouldThrottleRendering() const
 {
     return canThrottleRendering() && lifecycle().throttlingAllowed();
 }
 
 bool FrameView::canThrottleRendering() const
 {
     if (!RuntimeEnabledFeatures::renderingPipelineThrottlingEnabled())
         return false;
-    return m_subtreeThrottled || (m_hiddenForThrottling && m_crossOriginForThrottling);
+    // 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.
+    return m_subtreeThrottled || (m_hiddenForThrottling && m_frame->isCrossOriginSubframe());
+}
+
+FrameView::IntersectionObserverCallback::IntersectionObserverCallback(FrameView* frameView, ExecutionContext* context)
+    : m_frameView(frameView)
+    , m_context(context)
+{
+}
+
+void FrameView::IntersectionObserverCallback::handleEvent(const HeapVector<Member<IntersectionObserverEntry>>& entries, IntersectionObserver&)
+{
+    if (!m_frameView)
+        return;
+    bool wasHidden = m_frameView->m_hiddenForThrottling;
+    bool isHidden = wasHidden;
+    if (!entries.isEmpty())
+        isHidden = !entries.last()->intersectionRatio();
+    if (wasHidden != isHidden)
+        m_frameView->updateRenderThrottlingStatus(isHidden, m_frameView->m_subtreeThrottled);
+}
+
+ExecutionContext* FrameView::IntersectionObserverCallback::getExecutionContext() const
+{
+    return m_context.get();
+}
+
+DEFINE_TRACE(FrameView::IntersectionObserverCallback)
+{
+    blink::IntersectionObserverCallback::trace(visitor);
+    visitor->trace(m_frameView);
+    visitor->trace(m_context);
 }
 
 } // namespace blink