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..8e740d0aa4e22b1035a4cc28f3716121669040ac
--- /dev/null
+++ b/Source/core/dom/ScriptedIdleTaskController.cpp
@@ -0,0 +1,172 @@
+// 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_scheduler(Platform::current()->currentThread()->scheduler())
+    , 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);
+
+    m_scheduler->postIdleTask(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::CallbackType::CalledByTimeout) {
+            callbackWrapper->cancelTimeout();
+            // Queue for execution when we are resumed.
+            m_pendingTimeouts.push(id);
+        }
+        // Just drop callbacks called while suspended, these will be reposted on the idle task queue when we are resumed.
+        return;
+    }
+    callbackWrapper->cancelTimeout();
+
+    double deadlineMillis = 1000.0 * m_timing.monotonicTimeToZeroBasedDocumentTime(deadlineSeconds);
+    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()) {

[esprehn, 2015/08/20 20:45:55]

Vector<...> pendingTimeouts;
m_pendingTimeouts.swap(pendingTimeouts);
for (auto& id : pendingTimeouts)
  runCallback(id, -1, IdleCallbackDeadline::CallbackType::CalledByTimeout);

[rmcilroy, 2015/08/21 00:03:45]

Done.

+        runCallback(m_pendingTimeouts.front(), -1, IdleCallbackDeadline::CallbackType::CalledByTimeout);

[esprehn, 2015/08/20 20:45:55]

Why is the deadline -1?

[rmcilroy, 2015/08/21 00:03:45]

Good catch, this was a leftover from the spec before the timeRemaining() change
- fixed.

+        m_pendingTimeouts.pop();
+    }
+
+    // Repost idle tasks for any remaining callbacks.
+    for (auto callback = m_callbacks.begin(); callback != m_callbacks.end();

[esprehn, 2015/08/20 20:45:55]

for(auto& callback : m_callbacks)

[rmcilroy, 2015/08/21 00:03:45]

Done.

+        ++callback) {
+        RefPtr<IdleRequestCallbackWrapper> callbackWrapper = IdleRequestCallbackWrapper::create(callback->key, this);
+        m_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()

[esprehn, 2015/08/20 20:45:55]

Can we un nested the classes and put them in separate files?

[rmcilroy, 2015/08/21 00:03:45]

I've removed the IdleRequestTimeoutTimer class entirely, and un-nested
IdleRequestCallbackWrapper (and removed it from the header), but I've kept it as
a private internal class in this cc file because it's an implementation detail
which shouldn't be used by anything else. Is this better?

+{
+}
+
+// static
+void ScriptedIdleTaskController::IdleRequestCallbackWrapper::idleTaskFired(PassRefPtr<IdleRequestCallbackWrapper> callbackWrapper, double deadlineSeconds)
+{
+    callbackWrapper->m_controller->callbackFired(callbackWrapper.get(), deadlineSeconds, IdleCallbackDeadline::CallbackType::CalledWhenIdle);
+}
+
+ScriptedIdleTaskController::IdleRequestCallbackWrapper::IdleRequestTimeoutTimer::IdleRequestTimeoutTimer(PassRefPtr<IdleRequestCallbackWrapper> callbackWrapper)
+    : Timer(this, &IdleRequestTimeoutTimer::timeoutFired)
+    , m_callbackWrapper(callbackWrapper)
+{
+}
+
+void ScriptedIdleTaskController::IdleRequestCallbackWrapper::cancelTimeout()
+{
+    if (m_timeoutTimer.get()) {

[esprehn, 2015/08/20 20:45:55]

Why is this heap allocated?

The destructor should run stop(), and this should just do .clear()

[rmcilroy, 2015/08/21 00:03:45]

Removed entirely.

+        m_timeoutTimer->stop();
+        m_timeoutTimer.clear();
+    }
+}
+
+ScriptedIdleTaskController::IdleRequestCallbackWrapper::IdleRequestTimeoutTimer::~IdleRequestTimeoutTimer()
+{
+}
+
+void ScriptedIdleTaskController::IdleRequestCallbackWrapper::IdleRequestTimeoutTimer::timeoutFired(Timer<IdleRequestTimeoutTimer>* timer)
+{
+    m_callbackWrapper->controller()->callbackFired(m_callbackWrapper.get(), monotonicallyIncreasingTime(), IdleCallbackDeadline::CallbackType::CalledByTimeout);

[esprehn, 2015/08/20 20:45:55]

Can we just do this with methods on the controller instead? WHy do we need the
IdleRequestCallbackWrapper?

Normally we just use a Timer<> and .startOneShot()

[rmcilroy, 2015/08/21 00:03:44]

As discussed offline, changed this to be a bind() then post directly to the
scheduler's postTimerTask().

+}
+
+void ScriptedIdleTaskController::IdleRequestCallbackWrapper::setTimeout(double timeoutMillis)
+{
+    ASSERT(!m_timeoutTimer.get());
+    m_timeoutTimer = adoptPtr(new IdleRequestTimeoutTimer(this));
+    m_timeoutTimer->startOneShot(0.001 * timeoutMillis, FROM_HERE);
+}
+
+} // namespace blink