Implement requestIdleCallback API

Source/core/dom/ScriptedIdleTaskController.h

+// 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.
+
+#ifndef ScriptedIdleTaskController_h
+#define ScriptedIdleTaskController_h
+
+#include "core/dom/ActiveDOMObject.h"
+#include "platform/Timer.h"
+#include "platform/heap/Handle.h"
+#include "wtf/RefCounted.h"
+#include "wtf/RefPtr.h"
+
+namespace blink {
+
+class ExecutionContext;
+class IdleRequestCallback;
+class DocumentLoadTiming;
+
+class ScriptedIdleTaskController : public RefCountedWillBeGarbageCollected<ScriptedIdleTaskController>, public ActiveDOMObject {
+    DECLARE_EMPTY_DESTRUCTOR_WILL_BE_REMOVED(ScriptedIdleTaskController);
+

[jochen (gone - plz use gerrit), 2015/07/31 09:19:19]

nit. remove empty line

[rmcilroy, 2015/08/11 16:30:51]

Done - git cl format does this though :(.

+public:
+    static PassRefPtrWillBeRawPtr<ScriptedIdleTaskController> create(ExecutionContext* context, const DocumentLoadTiming& timing)
+    {
+        return adoptRefWillBeNoop(new ScriptedIdleTaskController(context, timing));
+    }
+    DECLARE_TRACE();
+
+    using CallbackId = int;
+
+    int registerCallback(IdleRequestCallback*, double timeout);
+    void cancelCallback(CallbackId);
+
+    // ActiveDOMObject interface.
+    void stop() override;

[Sami, 2015/08/10 09:47:47]

Do we need to support suspend/resume like with rAF? IIRC this could fire at
unfortunate times otherwise -- while we're suspended on a breakpoint for
instance.

[rmcilroy, 2015/08/11 16:30:52]

Good catch! This should now be addressed, thanks.

+    bool hasPendingActivity() const override;
+
+private:
+    class IdleRequestCallbackWrapper : public RefCounted<IdleRequestCallbackWrapper> {
+    public:
+        static PassRefPtr<IdleRequestCallbackWrapper> create(CallbackId id, PassRefPtrWillBeRawPtr<ScriptedIdleTaskController> controller)
+        {
+            return adoptRef(new IdleRequestCallbackWrapper(id, controller));
+        }
+        ~IdleRequestCallbackWrapper();
+
+        void setTimeout(double delay);
+
+        void timeoutFired(Timer<IdleRequestCallbackWrapper>*);
+        static void runCallback(PassRefPtr<IdleRequestCallbackWrapper>, double deadlineSeconds);
+
+    private:
+        explicit IdleRequestCallbackWrapper(CallbackId, PassRefPtrWillBeRawPtr<ScriptedIdleTaskController>);
+
+        CallbackId m_id;
+        Timer<IdleRequestCallbackWrapper> m_timeoutTimer;
+        RefPtrWillBePersistent<ScriptedIdleTaskController> m_controller;
+    };
+
+    ScriptedIdleTaskController(ExecutionContext*, const DocumentLoadTiming&);
+
+    void runCallback(CallbackId, double deadlineSeconds, bool didTimeout);
+
+    const DocumentLoadTiming& m_timing;
+    PersistentHeapHashMapWillBeHeapHashMap<CallbackId, Member<IdleRequestCallback>> m_callbacks;
+    CallbackId m_nextCallbackId;
+};
+
+} // namespace blink
+
+#endif // ScriptedIdleTaskController_h