Use the scheduling mechanism provided by the platform

Source/bindings/core/v8/V8Initializer.cpp

 /*
  * Copyright (C) 2009 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 34 matching lines @@
 #include "core/frame/ConsoleTypes.h"
 #include "core/frame/LocalDOMWindow.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/csp/ContentSecurityPolicy.h"
 #include "core/inspector/ConsoleMessage.h"
 #include "core/inspector/ScriptArguments.h"
 #include "core/inspector/ScriptCallStack.h"
 #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>
 
 namespace blink {
 
 static LocalFrame* findFrame(v8::Local<v8::Object> host, v8::Local<v8::Value> data, v8::Isolate* isolate)
 {
     const WrapperTypeInfo* type = WrapperTypeInfo::unwrap(data);
 
@@ skipping 220 matching lines @@
 
 static bool codeGenerationCheckCallbackInMainThread(v8::Local<v8::Context> context)
 {
     if (ExecutionContext* executionContext = toExecutionContext(context)) {
         if (ContentSecurityPolicy* policy = toDocument(executionContext)->contentSecurityPolicy())
             return policy->allowEval(ScriptState::from(context));
     }
     return false;
 }
 
-static void idleGCTaskInMainThread(double deadlineSeconds);
+static void postIdleGCTaskMainThread();
+
+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 postIdleGCTaskMainThread()
 {
-    if (RuntimeEnabledFeatures::v8IdleTasksEnabled()) {
-        Scheduler* scheduler = Scheduler::shared();
-        if (scheduler)
-            scheduler->postIdleTask(FROM_HERE, WTF::bind<double>(idleGCTaskInMainThread));
-    }
-}
-
-static void idleGCTaskInMainThread(double deadlineSeconds)
-{
-    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)
 {
     if (!status) {
         TRACE_EVENT_BEGIN0("v8", name);
     } else {
         TRACE_EVENT_END0("v8", name);
     }
 }
@@ skipping 80 matching lines @@
     initializeV8Common(isolate);
 
     v8::V8::AddMessageListener(messageHandlerInWorker);
     v8::V8::SetFatalErrorHandler(reportFatalErrorInWorker);
 
     uint32_t here;
     isolate->SetStackLimit(reinterpret_cast<uintptr_t>(&here - kWorkerMaxStackSize / sizeof(uint32_t*)));
 }
 
 } // namespace blink