Use the scheduling mechanism provided by the platform

Source/bindings/core/v8/V8Initializer.cpp

Index: Source/bindings/core/v8/V8Initializer.cpp
diff --git a/Source/bindings/core/v8/V8Initializer.cpp b/Source/bindings/core/v8/V8Initializer.cpp
index e038279daa2b5c4da13b0e062ef12ca82cbe0a07..94622a732e04029a1058652733f4d0945f8a6f77 100644
--- a/Source/bindings/core/v8/V8Initializer.cpp
+++ b/Source/bindings/core/v8/V8Initializer.cpp
@@ -52,8 +52,9 @@
 #include "platform/EventDispatchForbiddenScope.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/TraceEvent.h"
-#include "platform/scheduler/Scheduler.h"
 #include "public/platform/Platform.h"
+#include "public/platform/WebScheduler.h"
+#include "public/platform/WebTraceLocation.h"
 #include "wtf/RefPtr.h"
 #include "wtf/text/WTFString.h"
 #include <v8-debug.h>
@@ -294,29 +295,31 @@ static bool codeGenerationCheckCallbackInMainThread(v8::Local<v8::Context> conte
     return false;
 }
 
-static void idleGCTaskInMainThread(double deadlineSeconds);
+static void postIdleGCTaskMainThread();
 
-static void postIdleGCTaskMainThread()
-{
-    if (RuntimeEnabledFeatures::v8IdleTasksEnabled()) {
-        Scheduler* scheduler = Scheduler::shared();
-        if (scheduler)
-            scheduler->postIdleTask(FROM_HERE, WTF::bind<double>(idleGCTaskInMainThread));
+class IdleGCTaskInMainThread : public WebScheduler::IdleTask {
+public:
+    virtual void run(double deadlineSeconds) override
+    {
+        ASSERT(isMainThread());
+        ASSERT(RuntimeEnabledFeatures::v8IdleTasksEnabled());
+        v8::Isolate* isolate = v8::Isolate::GetCurrent();
+        // FIXME: Change V8's API to take a deadline - http://crbug.com/417668
+        double idleTimeInSeconds = deadlineSeconds - Platform::current()->monotonicallyIncreasingTime();
+        int idleTimeInMillis = static_cast<int>(idleTimeInSeconds * 1000);
+        if (idleTimeInMillis > 0)
+            isolate->IdleNotification(idleTimeInMillis);
+        // FIXME: only repost if there is more work to do.
+        postIdleGCTaskMainThread();

[eseidel, 2014/10/21 16:11:02]

So we'll always have a GC task in the run loop?  Won't that just churn battery
waking up the machine on an idle page?

I see that was already the case, but it seems bad.

[Sami, 2014/10/21 18:49:34]

The idle queue is disabled while the compositor isn't actively drawing anything,
so this won't actually cause any extra wake-ups or spinning. The FIXME here is
about making this smarter about only posting a task when necessary, but right
now it won't make a measurable difference either way.

     }
-}
+};
 
-static void idleGCTaskInMainThread(double deadlineSeconds)
+static void postIdleGCTaskMainThread()
 {
-    ASSERT(isMainThread());
-    ASSERT(RuntimeEnabledFeatures::v8IdleTasksEnabled());
-    v8::Isolate* isolate = v8::Isolate::GetCurrent();
-    // FIXME: Change V8's API to take a deadline - http://crbug.com/417668
-    double idleTimeInSeconds = deadlineSeconds - Platform::current()->monotonicallyIncreasingTime();
-    int idleTimeInMillis = static_cast<int>(idleTimeInSeconds * 1000);
-    if (idleTimeInMillis > 0)
-        isolate->IdleNotification(idleTimeInMillis);
-    // FIXME: only repost if there is more work to do.
-    postIdleGCTaskMainThread();
+    if (!RuntimeEnabledFeatures::v8IdleTasksEnabled())

[eseidel, 2014/10/21 16:11:02]

Previously this was an assert?

[Sami, 2014/10/21 18:49:34]

Sorry, the diff is a little confusing since I moved from code below this
function to above it. I just changed this particular check to an early-out.

+        return;
+    if (WebScheduler* scheduler = Platform::current()->scheduler())

[eseidel, 2014/10/21 16:11:02]

When do we ever have a platform but not have a scheduler?

[Sami, 2014/10/21 18:49:34]

Initially I thought we would need this for the bootstrap phase, but now that
I've kept the helper in platform/scheduler/Scheduler.h we'll always have a
fallback.

+        scheduler->postIdleTask(FROM_HERE.toWebTraceLocation(), new IdleGCTaskInMainThread());

[eseidel, 2014/10/21 16:11:02]

We don't just have a shared task which we reuse?  Does the scheduler delete our
tasks for us?

[Sami, 2014/10/21 18:49:34]

Yes, that's the best we can do with the current model since we can't share
closures across the repo boundary :( The ownership needs to be on the scheduler
side because here we don't know when anything is actually run. That means we
need to allocate a new object every time.

Note that we already need to do this for everything that goes through
WebThread::postTask().

An alternative would be having a version that takes just a function pointer and
an argument, but since you can't easily wrap that into a closure on the Blink
side, we prefer to pass an actual object through this interface instead.

 }
 
 static void timerTraceProfilerInMainThread(const char* name, int status)