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..89ad3a4ac409fe81d9fa2e50ef17a1506582989e
--- /dev/null
+++ b/Source/core/dom/ScriptedIdleTaskController.cpp
@@ -0,0 +1,103 @@
+// 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/Document.h"
+#include "core/dom/IdleRequestCallback.h"
+#include "core/loader/DocumentLoader.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(Document* document)

[esprehn, 2015/06/10 07:11:41]

reference

[rmcilroy, 2015/06/10 18:32:41]

Moved to ActiveDOMObject so this isn't needed any more, but still takes
ExecutionContext as pointer since that's what ActiveDOMObject's constructor
needs.

+    : m_document(document)
+    , m_callbacks()

[esprehn, 2015/06/10 07:11:41]

no need to list things with default constructors

[rmcilroy, 2015/06/10 18:32:40]

Done.

+    , m_nextCallbackId(0)
+{
+}
+
+DEFINE_EMPTY_DESTRUCTOR_WILL_BE_REMOVED(ScriptedIdleTaskController);
+
+DEFINE_TRACE(ScriptedIdleTaskController)
+{
+#if ENABLE(OILPAN)
+    visitor->trace(m_document);
+    visitor->trace(m_callbacks);
+#endif
+}
+
+ScriptedIdleTaskController::CallbackId ScriptedIdleTaskController::registerCallback(IdleRequestCallback* callback)
+{
+    CallbackId id = ++m_nextCallbackId;
+    callback->m_id = id;
+    callback->m_controller = this;
+    m_callbacks.set(id, callback);
+
+    RefPtr<IdleRequestCallbackWrapper> callbackWrapper = IdleRequestCallbackWrapper::create(callback);
+    Platform::current()->currentThread()->scheduler()->postIdleTask(

[esprehn, 2015/06/10 07:11:41]

Can any of these ever be null? We should either make them start returning
references or add some null checks I guess.

[rmcilroy, 2015/06/10 18:32:41]

They shouldn't return null whenever Blink is initialized. There are quite a few
other places in the code where we do the same sequence of
"Platform::current()->currentThread()->scheduler()", so it should be safe.

It is probably difficult to make them return references though since the
Platform, WebThread and WebScheduler are all abstract classes in Blink, which
are implemented by the embedder, and thus have default noop implementations
which return nullptr until they are overriden by the embedder.

+        FROM_HERE, WTF::bind<double>(&ScriptedIdleTaskController::IdleRequestCallbackWrapper::runCallback, callbackWrapper));

[esprehn, 2015/06/10 07:11:42]

This has scary lifetime management, wouldn't you want runCallback to take an id
instead?

[rmcilroy, 2015/06/10 18:32:40]

It needs some reference to the ScriptedIdleTaskController though (otherwise it
couldn't do anything with the id), and since ScriptedIdleTaskController will be
GCed in the Oilpan world, it can't be passed as a raw pointer out of Blink (as
is required for post[Idle]Task) so needs to be wrapped up in an off-oilpan-heap
object which contains a Persistent with a reference to the
ScriptedIdleTaskController.

I've changed the IdleRequestCallbackWrapper to hold an id and a reference to the
ScriptedIdleTaskController directly (instead of holding an IdleRequestCallback
with a reference to IdleRequestCallbackWrapper which I originally did because I
wanted to avoid a pending idle task stuck on the message loop holding onto the
ScriptedIdleTaskController and preventing it from being GCed, however I don't
think this is really much of a concern now that ScriptedIdleTaskController's
m_callbacks hashmap get cleared when the document goes inactive). Is this
better?

If there is a better way to do this I'd be very open to it.

+    // TODO(rmcilroy) TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "RequestIdleFrame", TRACE_EVENT_SCOPE_THREAD, "data", InspectorIdleFrameEvent::data(m_document, id));
+    // TODO(rmcilroy) InspectorInstrumentation::didRequestIdleFrame(m_docuement, id);
+    return id;
+}
+
+void ScriptedIdleTaskController::runCallback(IdleRequestCallback* callback, double deadlineSeconds)
+{
+    m_callbacks.remove(callback->m_id);
+
+    // TODO(rmcilroy) TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "FireIdleFrame", "data", InspectorIdleFrameEvent::data(m_document, callback->m_id));
+    // TODO(rmcilroy) InspectorInstrumentationCookie cookie = InspectorInstrumentation::willFireIdleFrame(m_document, callback->m_id);
+
+    double highResNowMs = 1000.0 * m_document->loader()->timing().monotonicTimeToZeroBasedDocumentTime(monotonicallyIncreasingTime());
+    double highResDeadlineMs = 1000.0 * m_document->loader()->timing().monotonicTimeToZeroBasedDocumentTime(deadlineSeconds);

[esprehn, 2015/06/10 07:11:41]

How does the callback use the highResNow? Seems like they want deadline but not
now?

[rmcilroy, 2015/06/10 18:32:41]

I've already removed |now| in the latest patch-set (it was originally in the
draft spec to avoid the web-dev having to call the perf.now() during the
callback but we decided against this).

+    callback->handleEvent(highResNowMs, highResDeadlineMs);
+
+    // TODO(rmcilroy) InspectorInstrumentation::didFireIdleFrame(cookie);
+    // TODO(rmcilroy) TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "UpdateCounters", TRACE_EVENT_SCOPE_THREAD, "data", InspectorUpdateCountersEvent::data());
+
+}
+
+void ScriptedIdleTaskController::cancelCallback(CallbackId id)
+{
+    IdleRequestCallback* callback = m_callbacks.get(id);
+    if (!callback)
+        return;
+
+    // TODO(rmcilroy) TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "CancelIdleFrame", TRACE_EVENT_SCOPE_THREAD, "data", InspectorIdleFrameEvent::data(m_document, id));
+    // TODO(rmcilroy) InspectorInstrumentation::didCancelAnimationFrame(m_document, id);
+
+    // Cancel callback by clearing its reference to the controller.
+    callback->m_controller.clear();

[esprehn, 2015/06/10 07:11:41]

If we just post ids you don't need this.

[rmcilroy, 2015/06/10 18:32:41]

Done.

+    m_callbacks.remove(id);
+}
+
+ScriptedIdleTaskController::IdleRequestCallbackWrapper::IdleRequestCallbackWrapper(IdleRequestCallback* callback)
+    : m_callback(callback)
+{
+}
+
+ScriptedIdleTaskController::IdleRequestCallbackWrapper::~IdleRequestCallbackWrapper()
+{
+}
+
+// static
+void ScriptedIdleTaskController::IdleRequestCallbackWrapper::runCallback(PassRefPtr<IdleRequestCallbackWrapper> callbackWrapper, double deadlineSeconds)
+{
+    IdleRequestCallback* callback = callbackWrapper->m_callback;
+    RefPtrWillBeRawPtr<ScriptedIdleTaskController> controller = callback->m_controller;
+    if (!controller)
+        return;
+
+    controller->runCallback(callback, deadlineSeconds);
+}
+
+} // namespace blink