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..100bf5b4837f03335dc1520044bbc1afdb15af1f
--- /dev/null
+++ b/Source/core/dom/ScriptedIdleTaskController.h
@@ -0,0 +1,94 @@
+// 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 IdleRequestTimeoutTimer : public Timer<IdleRequestTimeoutTimer> {

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

Woah doubly nested class is a little crazy, does this really need to be nested
inside IdleRequestCallbackWrapper?

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

Removed.

+        public:
+            IdleRequestTimeoutTimer(PassRefPtr<IdleRequestCallbackWrapper>);

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

explicit

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

Removed.

+            virtual ~IdleRequestTimeoutTimer();
+
+            void timeoutFired(Timer<IdleRequestTimeoutTimer>*);
+
+        private:
+            RefPtr<IdleRequestCallbackWrapper> m_callbackWrapper;
+        };
+
+        explicit IdleRequestCallbackWrapper(CallbackId, PassRefPtrWillBeRawPtr<ScriptedIdleTaskController>);
+
+        CallbackId m_id;
+        OwnPtr<IdleRequestTimeoutTimer> 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;
+    WebScheduler* m_scheduler; // Not owned.
+    PersistentHeapHashMapWillBeHeapHashMap<CallbackId, Member<IdleRequestCallback>> m_callbacks;

[esprehn, 2015/08/20 21:52:40]

I think you just want WillBeHeapHashMap, your object is on the heap, it doesn't
need to use Persistents.

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

I get an Oilpan error if I do that:
 [blink-gc] Member field 'm_callbacks' in unmanaged class declared here:

I think it's because the ScriptedIdleTaskController isn't yet garbage collected
(it's RefCountedWillBeGarbageCollected).

+    std::queue<CallbackId> m_pendingTimeouts;

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

I think this can just be a Vector, why do you need to use a queue?

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

Done.

+    CallbackId m_nextCallbackId;
+    bool m_suspended;
+};
+
+} // namespace blink
+
+#endif // ScriptedIdleTaskController_h