IntersectionObserver: second cut.

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 14 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/Fullscreen.h"
+#include "core/dom/IntersectionObserverController.h"
 #include "core/editing/EditingUtilities.h"
 #include "core/editing/FrameSelection.h"
 #include "core/editing/RenderedPosition.h"
 #include "core/editing/markers/DocumentMarkerController.h"
 #include "core/fetch/ResourceFetcher.h"
 #include "core/frame/FrameHost.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/html/HTMLFrameElement.h"
 #include "core/html/HTMLPlugInElement.h"
@@ skipping 68 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_intersectionObserverNotificationFactory(CancellableTaskFactory::create(this, &FrameView::notifyIntersectionObservers))
+    , m_renderThrottlingObserverNotificationFactory(CancellableTaskFactory::create(this, &FrameView::notifyRenderThrottlingObservers))
     , 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)
@@ skipping 144 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();
+    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 2070 matching lines @@
         isUpdatingAllLifecyclePhasesScope.emplace(m_isUpdatingAllLifecyclePhases, true);
 
     // 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);
 
     if (shouldThrottleRendering()) {
-        updateViewportIntersectionsForSubtree();
+        updateViewportIntersectionsForSubtree(std::min(phases, OnlyUpToCompositingCleanPlusScrolling));
         return;
     }
 
     updateStyleAndLayoutIfNeededRecursive();
     ASSERT(lifecycle().state() >= DocumentLifecycle::LayoutClean);
 
     if (phases == OnlyUpToLayoutClean) {
-        updateViewportIntersectionsForSubtree();
+        updateViewportIntersectionsForSubtree(phases);
         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();
@@ skipping 23 matching lines @@
 
             if (RuntimeEnabledFeatures::slimmingPaintV2Enabled())
                 pushPaintArtifactToCompositor();
 
             ASSERT(!view->hasPendingSelection());
             ASSERT((m_frame->document()->printing() && lifecycle().state() == DocumentLifecycle::PaintInvalidationClean)
                 || lifecycle().state() == DocumentLifecycle::PaintClean);
         }
     }
 
-    updateViewportIntersectionsForSubtree();
+    updateViewportIntersectionsForSubtree(phases);
 }
 
 void FrameView::updatePaintProperties()
 {
     TRACE_EVENT0("blink", "FrameView::updatePaintProperties");
 
     ASSERT(RuntimeEnabledFeatures::slimmingPaintV2Enabled());
 
     forAllNonThrottledFrameViews([](FrameView& frameView) { frameView.lifecycle().advanceTo(DocumentLifecycle::InUpdatePaintProperties); });
     PaintPropertyTreeBuilder().buildPropertyTrees(*this);
@@ skipping 1482 matching lines @@
 
 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()
+void FrameView::updateViewportIntersectionsForSubtree(LifeCycleUpdateOption phases)
 {
     bool hadValidIntersection = m_viewportIntersectionValid;
     bool hadEmptyIntersection = m_viewportIntersection.isEmpty();
     updateViewportIntersectionIfNeeded();
+
+    // Notify javascript IntersectionObservers
+    if (phases == AllPhases)
+        frame().document()->ensureIntersectionObserverController().computeTrackedIntersectionObservations();
+
+    // Adjust render throttling for iframes based on visibility
     bool shouldNotify = !hadValidIntersection || hadEmptyIntersection != m_viewportIntersection.isEmpty();
-    if (shouldNotify && !m_intersectionObserverNotificationFactory->isPending())
-        m_frame->frameScheduler()->timerTaskRunner()->postTask(BLINK_FROM_HERE, m_intersectionObserverNotificationFactory->cancelAndCreate());
+    if (shouldNotify && !m_renderThrottlingObserverNotificationFactory->isPending())
+        m_frame->frameScheduler()->timerTaskRunner()->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();
+            view->updateViewportIntersectionsForSubtree(phases);
     }
 }
 
-void FrameView::notifyIntersectionObservers()
+void FrameView::notifyRenderThrottlingObservers()
 {
-    TRACE_EVENT0("blink", "FrameView::notifyIntersectionObservers");
+    TRACE_EVENT0("blink", "FrameView::notifyRenderThrottlingObservers");
     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.
@@ skipping 29 matching lines @@
     return m_hiddenForThrottling && m_crossOriginForThrottling;
 }
 
 LayoutBox& FrameView::boxForScrollControlPaintInvalidation() const
 {
     ASSERT(layoutView());
     return *layoutView();
 }
 
 } // namespace blink