Enable V8 idle tasks.

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 29 matching lines @@
 #include "bindings/core/v8/V8PerContextData.h"
 #include "bindings/core/v8/V8Window.h"
 #include "core/dom/Document.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/frame/ConsoleTypes.h"
 #include "core/frame/LocalDOMWindow.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/csp/ContentSecurityPolicy.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 "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 110 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()
+{
+    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();
+    // TODO: Change V8's API to take a deadline - http://crbug.com/417668

[jochen (gone - plz use gerrit), 2014/10/13 08:06:20]

blink has FIXME: instead of TODO

[rmcilroy, 2014/10/13 11:22:07]

Done.

+    double idleTimeInSeconds = deadlineSeconds - Platform::current()->monotonicallyIncreasingTime();
+    int idleTimeInMillis = static_cast<int>(idleTimeInSeconds * 1000);
+    if (idleTimeInMillis > 0) {

[jochen (gone - plz use gerrit), 2014/10/13 08:06:20]

no { } required

[jochen (gone - plz use gerrit), 2014/10/13 08:06:20]

no { } required

[rmcilroy, 2014/10/13 11:22:08]

Done.

+        isolate->IdleNotification(idleTimeInMillis);
+    }
+    // TODO: only repost if there is more work to do.
+    postIdleGCTaskMainThread();

[jochen (gone - plz use gerrit), 2014/10/13 08:06:20]

how will you make sure that you don't end up squeezing multiple gc tasks into a
single idle pause.

how will you restart idle notifications once nothing more was to be done?

[rmcilroy, 2014/10/13 11:22:07]

CL https://codereview.chromium.org/640053003/ deals with this - it ensures that
only tasks posted before the current idle period will execute during the current
idle period.
This is what we will need to work out.  Is there any bottleneck on starting JS
execution which we could use for this?

+}
+
 static void timerTraceProfilerInMainThread(const char* name, int status)
 {
     if (!status) {
         TRACE_EVENT_BEGIN0("v8", name);
     } else {
         TRACE_EVENT_END0("v8", name);
     }
 }
 
 static void initializeV8Common(v8::Isolate* isolate)
@@ skipping 75 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