Implement requestIdleCallback API

Source/core/dom/ScriptedIdleTaskController.cpp

Index: Source/core/dom/ScriptedIdleTaskController.cpp
diff --git a/Source/core/dom/ScriptedIdleTaskController.cpp b/Source/core/dom/ScriptedIdleTaskController.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..aa69b412ab9d05d7663f80f2a9c567199418bfd3
--- /dev/null
+++ b/Source/core/dom/ScriptedIdleTaskController.cpp
@@ -0,0 +1,178 @@
+// Copyright 2015 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 "config.h"
+#include "core/dom/ScriptedIdleTaskController.h"
+
+#include "core/dom/ExecutionContext.h"
+#include "core/dom/IdleRequestCallback.h"
+#include "core/loader/DocumentLoadTiming.h"
+#include "platform/Logging.h"
+#include "platform/TraceEvent.h"
+#include "public/platform/Platform.h"
+#include "public/platform/WebScheduler.h"
+#include "public/platform/WebTraceLocation.h"
+#include "wtf/CurrentTime.h"
+#include "wtf/Functional.h"
+
+namespace blink {
+
+ScriptedIdleTaskController::ScriptedIdleTaskController(ExecutionContext* context, const DocumentLoadTiming& timing)
+    : ActiveDOMObject(context)
+    , m_timing(timing)
+    , m_nextCallbackId(0)
+    , m_suspended(false)
+{
+    suspendIfNeeded();
+}
+
+DEFINE_EMPTY_DESTRUCTOR_WILL_BE_REMOVED(ScriptedIdleTaskController);
+
+DEFINE_TRACE(ScriptedIdleTaskController)
+{
+    ActiveDOMObject::trace(visitor);
+    visitor->trace(m_callbacks);
+}
+
+ScriptedIdleTaskController::CallbackId ScriptedIdleTaskController::registerCallback(IdleRequestCallback* callback, double timeoutMillis)
+{
+    CallbackId id = ++m_nextCallbackId;
+    m_callbacks.set(id, callback);
+
+    RefPtr<IdleRequestCallbackWrapper> callbackWrapper = IdleRequestCallbackWrapper::create(id, this);
+    if (timeoutMillis > 0)
+        callbackWrapper->setTimeout(timeoutMillis);
+
+    Platform::current()->currentThread()->scheduler()->postIdleTask(

[Sami, 2015/08/11 18:03:00]

nit: Maybe it's worth saving a pointer to the scheduler to cut down on the
pointer chasing a bit? Current way works too.

[rmcilroy, 2015/08/12 14:17:30]

Done.

+        FROM_HERE, WTF::bind<double>(&ScriptedIdleTaskController::IdleRequestCallbackWrapper::idleTaskFired, callbackWrapper));
+    // TODO(rmcilroy): Add devtools tracing.
+    return id;
+}
+
+void ScriptedIdleTaskController::cancelCallback(CallbackId id)
+{
+    // TODO(rmcilroy): Add devtools tracing.
+    m_callbacks.remove(id);
+}
+
+void ScriptedIdleTaskController::callbackFired(IdleRequestCallbackWrapper* callbackWrapper, double deadlineSeconds, IdleCallbackDeadline::CallbackType callbackType)
+{
+    CallbackId id = callbackWrapper->id();
+    if (!m_callbacks.contains(id))
+        return;
+
+    if (m_suspended) {
+        if (callbackType == IdleCallbackDeadline::CalledByTimeout) {
+            callbackWrapper->cancelTimeout();
+            // Queue for execution when we are resumed.
+            m_pendingTimeouts.push(id);
+        }
+        // Just drop callbacks called while idle, these will be reposted on the idle task queue when we are resumed.

[Sami, 2015/08/11 18:03:00]

s/idle/suspended/?

[rmcilroy, 2015/08/12 14:17:30]

Done.

+        return;
+    }
+
+    double deadlineMillis;
+    if (callbackType == IdleCallbackDeadline::CalledByTimeout)
+        deadlineMillis = -1;
+    else
+        deadlineMillis = 1000.0 * m_timing.monotonicTimeToZeroBasedDocumentTime(deadlineSeconds);
+
+    callbackWrapper->cancelTimeout();
+    runCallback(id, deadlineMillis, callbackType);
+}
+
+void ScriptedIdleTaskController::runCallback(CallbackId id, double deadlineMillis, IdleCallbackDeadline::CallbackType callbackType)
+{
+    ASSERT(!m_suspended);
+    auto callback = m_callbacks.take(id);
+    if (!callback)
+        return;
+
+    // TODO(rmcilroy): Add devtools tracing.
+    callback->handleEvent(IdleCallbackDeadline::create(deadlineMillis, callbackType, m_timing));
+}
+
+void ScriptedIdleTaskController::stop()
+{
+    m_callbacks.clear();
+}
+
+void ScriptedIdleTaskController::suspend()
+{
+    m_suspended = true;
+}
+
+void ScriptedIdleTaskController::resume()
+{
+    ASSERT(m_suspended);
+    m_suspended = false;
+
+    // Run any pending timeouts.
+    while (!m_pendingTimeouts.empty()) {
+        runCallback(m_pendingTimeouts.front(), -1, IdleCallbackDeadline::CalledByTimeout);
+        m_pendingTimeouts.pop();
+    }
+
+    // Repost idle tasks for any remaining callbacks.
+    for (auto callback = m_callbacks.begin(); callback != m_callbacks.end();
+        ++callback) {
+        RefPtr<IdleRequestCallbackWrapper> callbackWrapper = IdleRequestCallbackWrapper::create(callback->key, this);
+        Platform::current()->currentThread()->scheduler()->postIdleTask(
+            FROM_HERE, WTF::bind<double>(&ScriptedIdleTaskController::IdleRequestCallbackWrapper::idleTaskFired, callbackWrapper));
+    }
+}
+
+bool ScriptedIdleTaskController::hasPendingActivity() const
+{
+    return !m_callbacks.isEmpty();
+}
+
+ScriptedIdleTaskController::IdleRequestCallbackWrapper::IdleRequestCallbackWrapper(CallbackId id, PassRefPtrWillBeRawPtr<ScriptedIdleTaskController> controller)
+    : m_id(id)
+    , m_timeoutTimer(nullptr)
+    , m_controller(controller)
+{
+}
+
+ScriptedIdleTaskController::IdleRequestCallbackWrapper::~IdleRequestCallbackWrapper()
+{
+}
+
+// static
+void ScriptedIdleTaskController::IdleRequestCallbackWrapper::idleTaskFired(PassRefPtr<IdleRequestCallbackWrapper> callbackWrapper, double deadlineSeconds)
+{
+    callbackWrapper->m_controller->callbackFired(callbackWrapper.get(), deadlineSeconds, IdleCallbackDeadline::CalledWhenIdle);
+}
+
+ScriptedIdleTaskController::IdleRequestCallbackWrapper::IdleRequestTimoutTimer::IdleRequestTimoutTimer(PassRefPtr<IdleRequestCallbackWrapper> callbackWrapper)
+    : Timer(this, &IdleRequestTimoutTimer::timeoutFired)
+    , m_callbackWrapper(callbackWrapper)
+{
+}
+
+void ScriptedIdleTaskController::IdleRequestCallbackWrapper::cancelTimeout()
+{
+    if (m_timeoutTimer.get()) {
+        m_timeoutTimer->stop();
+        m_timeoutTimer.clear();
+    }
+}
+
+ScriptedIdleTaskController::IdleRequestCallbackWrapper::IdleRequestTimoutTimer::~IdleRequestTimoutTimer()
+{
+}
+
+void ScriptedIdleTaskController::IdleRequestCallbackWrapper::IdleRequestTimoutTimer::timeoutFired(Timer<IdleRequestTimoutTimer>* timer)
+{
+    m_callbackWrapper->controller()->callbackFired(m_callbackWrapper.get(), -1, IdleCallbackDeadline::CalledByTimeout);
+}
+
+void ScriptedIdleTaskController::IdleRequestCallbackWrapper::setTimeout(double timeoutMillis)
+{
+    ASSERT(!m_timeoutTimer.get());
+    m_timeoutTimer = adoptPtr(new IdleRequestTimoutTimer(this));
+    m_timeoutTimer->startOneShot(0.001 * timeoutMillis, FROM_HERE);
+}
+
+} // namespace blink