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)
+    , m_lowLatencyCallbackFiredWhileSuspended(false)

[szager1, 2016/08/30 23:57:11]

I don't think you need m_lowLatencyCallbacksFiredWhileSuspended.  Instead,
resume() should call deliverLowLatencyNotifications() unconditionally, or post a
task to do so.

[Sami, 2016/08/31 11:08:55]

Done.

 {
 }
 
 IntersectionObserverController::~IntersectionObserverController() { }
 
 void IntersectionObserverController::scheduleIntersectionObserverForDelivery(IntersectionObserver& observer)
 {
+    if (observer.lowLatency()) {

[szager1, 2016/08/30 23:57:11]

I think this would read better if you refactor it to call into one of two new
methods:

void
IntersectionObserverController::scheduleIntersectionObserverForDelivery(IntersectionObserver&
observer)
{
  if (observer.lowLatency())
    scheduleLowLatencyNotification(observer);
  else
    scheduleIdleNotification(observer);
}

[Sami, 2016/08/31 11:08:55]

Good idea, done.

+        m_pendingLowLatencyIntersectionObservers.add(&observer);
+        if (!m_lowLatencyNotificationTask->isPending())
+            TaskRunnerHelper::get(TaskType::Unthrottled, getExecutionContext())->postTask(BLINK_FROM_HERE, m_lowLatencyNotificationTask->cancelAndCreate());
+        return;
+    }
     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::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).
+    if (m_lowLatencyCallbackFiredWhileSuspended) {
+        m_lowLatencyCallbackFiredWhileSuspended = false;
+        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()) {
+        m_lowLatencyCallbackFiredWhileSuspended = true;
+        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