Implement requestIdleCallback API

Source/core/dom/ScriptedIdleTaskController.cpp

+// 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/IdleCallbackDeadline.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)
+{
+}
+
+DEFINE_EMPTY_DESTRUCTOR_WILL_BE_REMOVED(ScriptedIdleTaskController);
+
+DEFINE_TRACE(ScriptedIdleTaskController)
+{
+    ActiveDOMObject::trace(visitor);
+    visitor->trace(m_callbacks);
+}
+
+ScriptedIdleTaskController::CallbackId ScriptedIdleTaskController::registerCallback(IdleRequestCallback* callback, double timeout)
+{
+    CallbackId id = ++m_nextCallbackId;
+    callback->m_id = id;
+    m_callbacks.set(id, callback);
+
+    RefPtr<IdleRequestCallbackWrapper> callbackWrapper = IdleRequestCallbackWrapper::create(id, this);
+    if (timeout > 0) {
+        callbackWrapper->setTimeout(timeout);
+    }
+    Platform::current()->currentThread()->scheduler()->postIdleTask(
+        FROM_HERE, WTF::bind<double>(&ScriptedIdleTaskController::IdleRequestCallbackWrapper::runCallback, callbackWrapper));
+    // TODO(rmcilroy): Add devtools tracing.
+    return id;
+}
+
+void ScriptedIdleTaskController::runCallback(CallbackId id, double deadlineSeconds, bool didTimeout)
+{
+    auto callback = m_callbacks.take(id);
+    if (!callback)
+        return;
+
+    // TODO(rmcilroy): Add devtools tracing.
+    double deadlineMs;
+    if (didTimeout) {
+        deadlineMs = -1;
+    } else {
+        deadlineMs = 1000.0 * m_timing.monotonicTimeToZeroBasedDocumentTime(deadlineSeconds);
+    }
+    callback->handleEvent(IdleCallbackDeadline::create(deadlineMs, didTimeout, m_timing));
+}
+
+void ScriptedIdleTaskController::cancelCallback(CallbackId id)
+{
+    // TODO(rmcilroy): Add devtools tracing.
+    m_callbacks.remove(id);
+}
+
+void ScriptedIdleTaskController::stop()
+{
+    m_callbacks.clear();
+}
+
+bool ScriptedIdleTaskController::hasPendingActivity() const
+{
+    return !m_callbacks.isEmpty();
+}
+
+ScriptedIdleTaskController::IdleRequestCallbackWrapper::IdleRequestCallbackWrapper(CallbackId id, PassRefPtrWillBeRawPtr<ScriptedIdleTaskController> controller)
+    : m_id(id)
+    , m_timeoutTimer(this, &IdleRequestCallbackWrapper::timeoutFired)
+    , m_controller(controller)
+{
+}
+
+ScriptedIdleTaskController::IdleRequestCallbackWrapper::~IdleRequestCallbackWrapper()
+{
+}
+
+void ScriptedIdleTaskController::IdleRequestCallbackWrapper::setTimeout(double timeout)
+{
+    m_timeoutTimer.startOneShot(0.001 * timeout, FROM_HERE);
+}
+
+void ScriptedIdleTaskController::IdleRequestCallbackWrapper::timeoutFired(Timer<IdleRequestCallbackWrapper>* timer)
+{
+    m_controller->runCallback(m_id, 0, true);
+}
+
+// static
+void ScriptedIdleTaskController::IdleRequestCallbackWrapper::runCallback(PassRefPtr<IdleRequestCallbackWrapper> callbackWrapper, double deadlineSeconds)
+{
+    callbackWrapper->m_timeoutTimer.stop();
+    callbackWrapper->m_controller->runCallback(callbackWrapper->m_id, deadlineSeconds, false);
+}
+
+} // namespace blink