Implement requestIdleCallback API

Source/core/dom/ScriptedIdleTaskController.h

Index: Source/core/dom/ScriptedIdleTaskController.h
diff --git a/Source/core/dom/ScriptedIdleTaskController.h b/Source/core/dom/ScriptedIdleTaskController.h
new file mode 100644
index 0000000000000000000000000000000000000000..44a81104d2aec145314b4318e9be73efa6e9afa3
--- /dev/null
+++ b/Source/core/dom/ScriptedIdleTaskController.h
@@ -0,0 +1,93 @@
+// 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 "core/dom/IdleCallbackDeadline.h"
+#include "platform/Timer.h"
+#include "platform/heap/Handle.h"
+#include "wtf/RefCounted.h"
+#include "wtf/RefPtr.h"
+
+#include <queue>
+
+namespace blink {
+
+class ExecutionContext;
+class IdleRequestCallback;
+class DocumentLoadTiming;
+
+class ScriptedIdleTaskController : public RefCountedWillBeGarbageCollected<ScriptedIdleTaskController>, public ActiveDOMObject {
+    DECLARE_EMPTY_DESTRUCTOR_WILL_BE_REMOVED(ScriptedIdleTaskController);
+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 timeoutMillis);
+    void cancelCallback(CallbackId);
+
+    // ActiveDOMObject interface.
+    void stop() override;
+    void suspend() override;
+    void resume() override;
+    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));
+        }
+        virtual ~IdleRequestCallbackWrapper();
+
+        void setTimeout(double timeoutMillis);
+        void cancelTimeout();
+
+        static void idleTaskFired(PassRefPtr<IdleRequestCallbackWrapper>, double deadlineSeconds);
+
+        CallbackId id() { return m_id; }
+        PassRefPtrWillBeRawPtr<ScriptedIdleTaskController> controller() { return m_controller; }
+
+    private:
+        class IdleRequestTimoutTimer : public Timer<IdleRequestTimoutTimer> {

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

typo: Timeout

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

Done.

+        public:
+            IdleRequestTimoutTimer(PassRefPtr<IdleRequestCallbackWrapper>);
+            virtual ~IdleRequestTimoutTimer();
+
+            void timeoutFired(Timer<IdleRequestTimoutTimer>*);
+
+        private:
+            RefPtr<IdleRequestCallbackWrapper> m_callbackWrapper;
+        };
+
+        explicit IdleRequestCallbackWrapper(CallbackId, PassRefPtrWillBeRawPtr<ScriptedIdleTaskController>);
+
+        CallbackId m_id;
+        OwnPtr<IdleRequestTimoutTimer> m_timeoutTimer;
+        RefPtrWillBePersistent<ScriptedIdleTaskController> m_controller;
+    };
+
+    ScriptedIdleTaskController(ExecutionContext*, const DocumentLoadTiming&);
+
+    void callbackFired(IdleRequestCallbackWrapper*, double deadlineSeconds, IdleCallbackDeadline::CallbackType);
+    void runCallback(CallbackId, double deadlineMillis, IdleCallbackDeadline::CallbackType);
+
+    const DocumentLoadTiming& m_timing;
+    PersistentHeapHashMapWillBeHeapHashMap<CallbackId, Member<IdleRequestCallback>> m_callbacks;
+    std::queue<CallbackId> m_pendingTimeouts;
+    CallbackId m_nextCallbackId;
+    bool m_suspended;
+};
+
+} // namespace blink
+
+#endif // ScriptedIdleTaskController_h