Use intersection observer to control frame throttling

third_party/WebKit/Source/core/dom/IntersectionObserverController.cpp

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/dom/IntersectionObserverController.h"
 
 #include "core/dom/Document.h"
 #include "core/dom/IdleRequestOptions.h"
+#include "core/dom/TaskRunnerHelper.h"
 #include "platform/TraceEvent.h"
+#include "platform/scheduler/CancellableTaskFactory.h"
 
 namespace blink {
 
 IntersectionObserverController* IntersectionObserverController::create(Document* document)
 {
     IntersectionObserverController* result = new IntersectionObserverController(document);
     result->suspendIfNeeded();
     return result;
 }
 
 IntersectionObserverController::IntersectionObserverController(Document* document)
     : ActiveDOMObject(document)
+    , m_lowLatencyNotificationTask(CancellableTaskFactory::create(this, &IntersectionObserverController::deliverLowLatencyNotifications))
     , m_callbackID(0)
     , m_callbackFiredWhileSuspended(false)
 {
 }
 
 IntersectionObserverController::~IntersectionObserverController() { }
 
 void IntersectionObserverController::scheduleIntersectionObserverForDelivery(IntersectionObserver& observer)
 {
+    if (observer.lowLatency()) {
+        scheduleLowLatencyNotification(observer);
+    } else {
+        scheduleIdleNotification(observer);
+    }
+}
+
+void IntersectionObserverController::scheduleIdleNotification(IntersectionObserver& observer)
+{
     m_pendingIntersectionObservers.add(&observer);
     if (m_callbackID)
         return;
     Document* document = toDocument(getExecutionContext());
     if (!document)
         return;
     IdleRequestOptions options;
     // The IntersectionObserver spec mandates that notifications be sent within 100ms.
     options.setTimeout(100);
     m_callbackID = document->requestIdleCallback(this, options);
 }
 
+void IntersectionObserverController::scheduleLowLatencyNotification(IntersectionObserver& observer)
+{
+    m_pendingLowLatencyIntersectionObservers.add(&observer);
+    if (!m_lowLatencyNotificationTask->isPending())
+        TaskRunnerHelper::get(TaskType::Unthrottled, getExecutionContext())->postTask(BLINK_FROM_HERE, m_lowLatencyNotificationTask->cancelAndCreate());

[ojan, 2016/09/10 02:18:27]

In retrospect, I wonder if unthrottled task runner is really necessary. Maybe it
was a mistake to use postTask at all for throttling frames. We could just use
takeRecords on the IntersectionObserver at the end of updateAllLifeCyclePhases.
It's doing something that web content can't do with current API, which is a bit
of a bummer, but so is the unthrottled task running. I think it's reasonably to
say that the code that actually does the platform-level throttling of frames can
be a bit special. But also, we have some API proposals that would actually let
web content hook in at this point in the pipeline as well. Lastly, we still
share all the code for computing intersection rects and everything.

Let me know what you think about this. If we were to change that, then we could
change https://codereview.chromium.org/2322143002 to just use a Timer instead of
needing it's own weakPtrFactory and whatnot and I think we could get rid of the
concept of unthrottled tasks?

[haraken, 2016/09/12 00:46:32]

Just help me understand: IIUC, frame throttling is enabled on cross-origin
frames. It means that IntersectionObservers may be throttled only on
cross-origin frames. I was thinking that it's totally okay, but is your
intention for this CL that you don't want to throttle IntersectionObservers even
on cross-origin frames?

+}
+
 void IntersectionObserverController::resume()
 {
     // If the callback fired while DOM objects were suspended, notifications might be late, so deliver
     // them right away (rather than waiting to fire again).
+    deliverLowLatencyNotifications();
     if (m_callbackFiredWhileSuspended) {
         m_callbackFiredWhileSuspended = false;
         deliverIntersectionObservations();
     }
 }
 
 void IntersectionObserverController::handleEvent(IdleDeadline*)
 {
     DCHECK(m_callbackID);
     m_callbackID = 0;
@@ skipping 10 matching lines @@
     if (context->activeDOMObjectsAreSuspended()) {
         m_callbackFiredWhileSuspended = true;
         return;
     }
     HeapHashSet<Member<IntersectionObserver>> observers;
     m_pendingIntersectionObservers.swap(observers);
     for (auto& observer : observers)
         observer->deliver();
 }
 
+void IntersectionObserverController::deliverLowLatencyNotifications()
+{
+    ExecutionContext* context = getExecutionContext();
+    if (!context) {
+        m_pendingLowLatencyIntersectionObservers.clear();
+        return;
+    }
+    if (context->activeDOMObjectsAreSuspended()) {
+        // resume() will deliver low latency notifications directly.
+        return;
+    }
+    HeapHashSet<Member<IntersectionObserver>> observers;
+    m_pendingLowLatencyIntersectionObservers.swap(observers);
+    for (auto& observer : observers)
+        observer->deliver();
+}
+
 void IntersectionObserverController::computeTrackedIntersectionObservations()
 {
     TRACE_EVENT0("blink", "IntersectionObserverController::computeTrackedIntersectionObservations");
     for (auto& observer : m_trackedIntersectionObservers) {
         observer->computeIntersectionObservations();
         if (observer->hasEntries())
             scheduleIntersectionObserverForDelivery(*observer);
     }
 }
 
 void IntersectionObserverController::addTrackedObserver(IntersectionObserver& observer)
 {
     m_trackedIntersectionObservers.add(&observer);
 }
 
 void IntersectionObserverController::removeTrackedObserversForRoot(const Node& root)
 {
     HeapVector<Member<IntersectionObserver>> toRemove;
     for (auto& observer : m_trackedIntersectionObservers) {
         if (observer->rootNode() == &root)
             toRemove.append(observer);
     }
     m_trackedIntersectionObservers.removeAll(toRemove);
 }
 
 DEFINE_TRACE(IntersectionObserverController)
 {
     visitor->trace(m_trackedIntersectionObservers);
     visitor->trace(m_pendingIntersectionObservers);
+    visitor->trace(m_pendingLowLatencyIntersectionObservers);
     ActiveDOMObject::trace(visitor);
     IdleRequestCallback::trace(visitor);
 }
 
 } // namespace blink