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/animation/DocumentAnimations.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/ElementVisibilityObserver.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 98 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_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_scrollAnchor(this),
       m_scrollbarManager(*this),
       m_needsScrollbarsUpdate(false),
       m_suppressAdjustViewSize(false),
       m_allowsLayoutInvalidationAfterLayoutClean(true) {
   ASSERT(m_frame);
   init();
@@ skipping 19 matching lines @@
 }
 
 DEFINE_TRACE(FrameView) {
   visitor->trace(m_frame);
   visitor->trace(m_fragmentAnchor);
   visitor->trace(m_scrollableAreas);
   visitor->trace(m_animatingScrollableAreas);
   visitor->trace(m_autoSizeInfo);
   visitor->trace(m_children);
   visitor->trace(m_viewportScrollableArea);
+  visitor->trace(m_visibilityObserver);
   visitor->trace(m_scrollAnchor);
   visitor->trace(m_scrollbarManager);
   Widget::trace(visitor);
   ScrollableArea::trace(visitor);
 }
 
 void FrameView::reset() {
   m_hasPendingLayout = false;
   m_layoutSchedulingEnabled = true;
   m_inSynchronousPostLayout = false;
@@ skipping 41 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_visibilityObserver)
+    return;
+
+  // We observe the frame owner element instead of the document element, because
+  // if the document has no content we can falsely think the frame is invisible.
+  // Note that this means we cannot throttle top-level frames or (currently)
+  // frames whose owner element is remote.
+  Element* targetElement = frame().deprecatedLocalOwner();
+  if (!targetElement)
+    return;
+
+  m_visibilityObserver = new ElementVisibilityObserver(
+      targetElement, WTF::bind(
+                         [](FrameView* frameView, bool isVisible) {
+                           frameView->updateRenderThrottlingStatus(
+                               !isVisible, frameView->m_subtreeThrottled);
+                         },
+                         wrapWeakPersistent(this)));
+  m_visibilityObserver->start();
+}
+
 void FrameView::dispose() {
   RELEASE_ASSERT(!isInPerformLayout());
 
   if (ScrollAnimatorBase* scrollAnimator = existingScrollAnimator())
     scrollAnimator->cancelAnimation();
   cancelProgrammaticScrollAnimation();
 
   detachScrollbars();
 
   if (ScrollingCoordinator* scrollingCoordinator = this->scrollingCoordinator())
     scrollingCoordinator->willDestroyScrollableArea(this);
 
   // We need to clear the RootFrameViewport's animator since it gets called
   // from non-GC'd objects and RootFrameViewport will still have a pointer to
   // this class.
   if (m_viewportScrollableArea)
     m_viewportScrollableArea->clearScrollAnimators();
 
   clearScrollAnimators();
 
   // Destroy |m_autoSizeInfo| as early as possible, to avoid dereferencing
   // partially destroyed |this| via |m_autoSizeInfo->m_frameView|.
   m_autoSizeInfo.clear();
 
   m_postLayoutTasksTimer.stop();
   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;
 #endif
@@ skipping 3069 matching lines @@
 }
 
 void FrameView::setParent(Widget* parentView) {
   if (parentView == parent())
     return;
 
   Widget::setParent(parentView);
 
   updateScrollableAreaSet();
   setNeedsUpdateViewportIntersection();
+  setupRenderThrottling();
+
+  if (parentFrameView())
+    m_subtreeThrottled = parentFrameView()->canThrottleRendering();
 }
 
 void FrameView::removeChild(Widget* child) {
   ASSERT(child->parent() == this);
 
   if (child->isFrameView())
     removeScrollableArea(toFrameView(child));
 
   child->setParent(0);
   m_children.remove(child);
@@ skipping 897 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) {
-    HTMLFrameOwnerElement* element = frame().deprecatedLocalOwner();
-    if (!element)
-      frame().document()->maybeRecordLoadReason(WouldLoadOutOfProcess);
-    // Having no layout object means the frame is not drawn.
-    else if (!element->layoutObject())
-      frame().document()->maybeRecordLoadReason(WouldLoadDisplayNone);
-    m_viewportIntersection = frameRect();
-    return;
-  }
-  ASSERT(!parent->m_needsUpdateViewportIntersection);
-
-  bool parentLoaded = parent->frame().document()->wouldLoadReason() > Created;
-  // If the parent wasn't loaded, the children won't be either.
-  if (parentLoaded) {
-    if (frameRect().isEmpty())
-      frame().document()->maybeRecordLoadReason(WouldLoadZeroByZero);
-    else if (frameRect().maxY() < 0)
-      frame().document()->maybeRecordLoadReason(WouldLoadAbove);
-    else if (frameRect().maxX() < 0)
-      frame().document()->maybeRecordLoadReason(WouldLoadLeft);
-  }
-
-  // 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);
-
-  if (parentLoaded && !m_viewportIntersection.isEmpty())
-    frame().document()->maybeRecordLoadReason(WouldLoadVisible);
-}
-
 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() {
-  // Only offscreen frames can be throttled. Note that we disallow throttling
-  // of 0x0 frames because some sites use them to drive UI logic.
-  DCHECK(m_viewportIntersectionValid);
-  m_hiddenForThrottling =
-      m_viewportIntersection.isEmpty() && !frameRect().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);
+void FrameView::updateRenderThrottlingStatusForTesting() {
+  m_visibilityObserver->deliverObservationsForTesting();
 }
 
-void FrameView::notifyRenderThrottlingObserversForTesting() {
-  DCHECK(m_renderThrottlingObserverNotificationFactory->isPending());
-  notifyRenderThrottlingObservers();
-}
-
-void FrameView::notifyRenderThrottlingObservers() {
-  TRACE_EVENT0("blink", "FrameView::notifyRenderThrottlingObservers");
+void FrameView::updateRenderThrottlingStatus(bool hidden,
+                                             bool subtreeThrottled) {
+  TRACE_EVENT0("blink", "FrameView::updateRenderThrottlingStatus");
   DCHECK(!isInPerformLayout());
-  DCHECK(frame().document());
-  DCHECK(!frame().document()->inStyleRecalc());
+  DCHECK(!m_frame->document() || !m_frame->document()->inStyleRecalc());
   bool wasThrottled = canThrottleRendering();
 
-  updateThrottlingStatus();
+  // Note that we disallow throttling of 0x0 frames because some sites use
+  // them to drive UI logic.
+  m_hiddenForThrottling = hidden && !frameRect().isEmpty();
+  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.
     LayoutViewItem layoutViewItem = this->layoutViewItem();
     if (!layoutViewItem.isNull())
       layoutViewItem.invalidatePaintForViewAndCompositedLayers();
   }
 
   bool hasHandlers = m_frame->host() &&
                      m_frame->host()->eventHandlerRegistry().hasEventHandlers(
                          EventHandlerRegistry::TouchStartOrMoveEventBlocking);
   if (wasThrottled != canThrottleRendering() && scrollingCoordinator &&
       hasHandlers)
     scrollingCoordinator->touchEventTargetRectsDidChange();
 
+  FrameView* parent = parentFrameView();
+  if (frame().document()->frame()) {
+    if (!parent) {
+      HTMLFrameOwnerElement* element = frame().deprecatedLocalOwner();
+      if (!element)
+        frame().document()->maybeRecordLoadReason(WouldLoadOutOfProcess);
+      // Having no layout object means the frame is not drawn.
+      else if (!element->layoutObject())
+        frame().document()->maybeRecordLoadReason(WouldLoadDisplayNone);
+    } else {
+      // Assume the main frame has always loaded since we don't track its
+      // visibility.
+      bool parentLoaded =
+          !parent->parentFrameView() ||
+          parent->frame().document()->wouldLoadReason() > Created;
+      // If the parent wasn't loaded, the children won't be either.
+      if (parentLoaded) {
+        if (frameRect().isEmpty())
+          frame().document()->maybeRecordLoadReason(WouldLoadZeroByZero);
+        else if (frameRect().maxY() < 0)
+          frame().document()->maybeRecordLoadReason(WouldLoadAbove);
+        else if (frameRect().maxX() < 0)
+          frame().document()->maybeRecordLoadReason(WouldLoadLeft);
+        else if (!m_hiddenForThrottling)
+          frame().document()->maybeRecordLoadReason(WouldLoadVisible);
+      }
+    }
+  }
+
 #if DCHECK_IS_ON()
   // Make sure we never have an unthrottled frame inside a throttled one.
-  FrameView* parent = parentFrameView();
   while (parent) {
     DCHECK(canThrottleRendering() || !parent->canThrottleRendering());
     parent = parent->parentFrameView();
   }
 #endif
 }
 
 bool FrameView::shouldThrottleRendering() const {
   return canThrottleRendering() && lifecycle().throttlingAllowed();
 }
 
 bool FrameView::canThrottleRendering() const {
   if (!RuntimeEnabledFeatures::renderingPipelineThrottlingEnabled())
     return false;
+  // 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_crossOriginForThrottling);
+         (m_hiddenForThrottling && m_frame->isCrossOriginSubframe());
 }
 
 void FrameView::setInitialViewportSize(const IntSize& viewportSize) {
   if (viewportSize == m_initialViewportSize)
     return;
 
   m_initialViewportSize = viewportSize;
   if (Document* document = m_frame->document())
     document->styleEngine().initialViewportChanged();
 }
 
 int FrameView::initialViewportWidth() const {
   DCHECK(m_frame->isMainFrame());
   return m_initialViewportSize.width();
 }
 
 int FrameView::initialViewportHeight() const {
   DCHECK(m_frame->isMainFrame());
   return m_initialViewportSize.height();
 }
 
 }  // namespace blink