Use timer task runner for V8PerIsolate tasks

Per the effort of getting rid of default task queue in scheduler, post per-isolate
tasks to renderer-wide timer task queue.

BUG=676805

Review-Url: https://codereview.chromium.org/2589363003
Cr-Commit-Position: refs/heads/master@{#441114}

extensions/renderer/api_binding_test.cc

@@ -5,6 +5,7 @@
 #include "extensions/renderer/api_binding_test.h"
 
 #include "base/memory/ptr_util.h"
+#include "base/threading/thread_task_runner_handle.h"
 #include "gin/array_buffer.h"
 #include "gin/public/context_holder.h"
 #include "gin/public/isolate_holder.h"
@@ -31,7 +32,8 @@ void APIBindingTest::SetUp() {
                                  gin::IsolateHolder::kStableV8Extras,
                                  gin::ArrayBufferAllocator::SharedInstance());
 
-  isolate_holder_ = base::MakeUnique<gin::IsolateHolder>();
+  isolate_holder_ =
+      base::MakeUnique<gin::IsolateHolder>(base::ThreadTaskRunnerHandle::Get());
   isolate()->Enter();
 
   v8::HandleScope handle_scope(isolate());

gin/isolate_holder.cc

@@ -27,10 +27,13 @@ namespace {
 v8::ArrayBuffer::Allocator* g_array_buffer_allocator = nullptr;
 }  // namespace
 
-IsolateHolder::IsolateHolder() : IsolateHolder(AccessMode::kSingleThread) {
-}
+IsolateHolder::IsolateHolder(
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner)
+    : IsolateHolder(std::move(task_runner), AccessMode::kSingleThread) {}
 
-IsolateHolder::IsolateHolder(AccessMode access_mode)
+IsolateHolder::IsolateHolder(
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner,
+    AccessMode access_mode)
     : access_mode_(access_mode) {
   v8::ArrayBuffer::Allocator* allocator = g_array_buffer_allocator;
   CHECK(allocator) << "You need to invoke gin::IsolateHolder::Initialize first";
@@ -41,7 +44,8 @@ IsolateHolder::IsolateHolder(AccessMode access_mode)
                                        base::SysInfo::AmountOfVirtualMemory());
   params.array_buffer_allocator = allocator;
   isolate_ = v8::Isolate::New(params);
-  isolate_data_.reset(new PerIsolateData(isolate_, allocator, access_mode));
+  isolate_data_.reset(
+      new PerIsolateData(isolate_, allocator, access_mode, task_runner));
   isolate_memory_dump_provider_.reset(new V8IsolateMemoryDumpProvider(this));
 #if defined(OS_WIN)
   {

gin/per_isolate_data.cc

@@ -21,13 +21,15 @@ using v8::ObjectTemplate;
 
 namespace gin {
 
-PerIsolateData::PerIsolateData(Isolate* isolate,
-                               ArrayBuffer::Allocator* allocator,
-                               IsolateHolder::AccessMode access_mode)
+PerIsolateData::PerIsolateData(
+    Isolate* isolate,
+    ArrayBuffer::Allocator* allocator,
+    IsolateHolder::AccessMode access_mode,
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner)
     : isolate_(isolate),
       allocator_(allocator),
       access_mode_(access_mode),
-      task_runner_(base::ThreadTaskRunnerHandle::Get()) {
+      task_runner_(task_runner) {
   isolate_->SetData(kEmbedderNativeGin, this);
 }
 

gin/per_isolate_data.h

@@ -32,7 +32,8 @@ class GIN_EXPORT PerIsolateData {
  public:
   PerIsolateData(v8::Isolate* isolate,
                  v8::ArrayBuffer::Allocator* allocator,
-                 IsolateHolder::AccessMode access_mode);
+                 IsolateHolder::AccessMode access_mode,
+                 scoped_refptr<base::SingleThreadTaskRunner> task_runner);
   ~PerIsolateData();
 
   static PerIsolateData* From(v8::Isolate* isolate);

gin/public/isolate_holder.h

@@ -8,10 +8,15 @@
 #include <memory>
 
 #include "base/macros.h"
+#include "base/memory/ref_counted.h"
 #include "gin/gin_export.h"
 #include "gin/public/v8_idle_task_runner.h"
 #include "v8/include/v8.h"
 
+namespace base {
+class SingleThreadTaskRunner;
+}
+
 namespace gin {
 
 class PerIsolateData;
@@ -42,8 +47,10 @@ class GIN_EXPORT IsolateHolder {
     kStableAndExperimentalV8Extras,
   };
 
-  IsolateHolder();
-  explicit IsolateHolder(AccessMode access_mode);
+  explicit IsolateHolder(
+      scoped_refptr<base::SingleThreadTaskRunner> task_runner);
+  IsolateHolder(scoped_refptr<base::SingleThreadTaskRunner> task_runner,
+                AccessMode access_mode);
   ~IsolateHolder();
 
   // Should be invoked once before creating IsolateHolder instances to

gin/shell/gin_main.cc

@@ -80,8 +80,7 @@ int main(int argc, char** argv) {
   gin::IsolateHolder::Initialize(gin::IsolateHolder::kStrictMode,
                                  gin::IsolateHolder::kStableV8Extras,
                                  gin::ArrayBufferAllocator::SharedInstance());
-  gin::IsolateHolder instance;
-
+  gin::IsolateHolder instance(base::ThreadTaskRunnerHandle::Get());
 
   gin::GinShellRunnerDelegate delegate;
   gin::ShellRunner runner(&delegate, instance.isolate());

gin/shell_runner_unittest.cc

@@ -6,6 +6,7 @@
 
 #include "base/compiler_specific.h"
 #include "base/message_loop/message_loop.h"
+#include "base/threading/thread_task_runner_handle.h"
 #include "gin/array_buffer.h"
 #include "gin/converter.h"
 #include "gin/public/isolate_holder.h"
@@ -35,7 +36,7 @@ TEST(RunnerTest, Run) {
   gin::IsolateHolder::Initialize(gin::IsolateHolder::kStrictMode,
                                  gin::IsolateHolder::kStableV8Extras,
                                  gin::ArrayBufferAllocator::SharedInstance());
-  gin::IsolateHolder instance;
+  gin::IsolateHolder instance(base::ThreadTaskRunnerHandle::Get());
 
   ShellRunnerDelegate delegate;
   Isolate* isolate = instance.isolate();

gin/test/file_runner.cc

@@ -8,6 +8,7 @@
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/run_loop.h"
+#include "base/threading/thread_task_runner_handle.h"
 #include "gin/array_buffer.h"
 #include "gin/converter.h"
 #include "gin/modules/console.h"
@@ -69,7 +70,7 @@ void RunTestFromFile(const base::FilePath& path, FileRunnerDelegate* delegate,
                                  gin::IsolateHolder::kStableV8Extras,
                                  gin::ArrayBufferAllocator::SharedInstance());
 
-  gin::IsolateHolder instance;
+  gin::IsolateHolder instance(base::ThreadTaskRunnerHandle::Get());
   gin::ShellRunner runner(delegate, instance.isolate());
   {
     gin::Runner::Scope scope(&runner);

gin/test/v8_test.cc

@@ -4,6 +4,7 @@
 
 #include "gin/test/v8_test.h"
 
+#include "base/threading/thread_task_runner_handle.h"
 #include "gin/array_buffer.h"
 #include "gin/public/isolate_holder.h"
 #include "gin/v8_initializer.h"
@@ -29,7 +30,7 @@ void V8Test::SetUp() {
                                  gin::IsolateHolder::kStableV8Extras,
                                  gin::ArrayBufferAllocator::SharedInstance());
 
-  instance_.reset(new gin::IsolateHolder);
+  instance_.reset(new gin::IsolateHolder(base::ThreadTaskRunnerHandle::Get()));
   instance_->isolate()->Enter();
   HandleScope handle_scope(instance_->isolate());
   context_.Reset(instance_->isolate(), Context::New(instance_->isolate()));

mojo/edk/js/tests/js_to_cpp_tests.cc

@@ -15,6 +15,7 @@
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/threading/thread_task_runner_handle.h"
 #include "gin/array_buffer.h"
 #include "gin/public/isolate_holder.h"
 #include "gin/v8_initializer.h"
@@ -404,7 +405,7 @@ class JsToCppTest : public testing::Test {
     gin::IsolateHolder::Initialize(gin::IsolateHolder::kStrictMode,
                                    gin::IsolateHolder::kStableV8Extras,
                                    gin::ArrayBufferAllocator::SharedInstance());
-    gin::IsolateHolder instance;
+    gin::IsolateHolder instance(base::ThreadTaskRunnerHandle::Get());
     MojoRunnerDelegate delegate;
     gin::ShellRunner runner(&delegate, instance.isolate());
     delegate.Start(&runner, js_side_proxy.PassMessagePipe().release().value(),

net/proxy/proxy_resolver_v8.cc

@@ -18,6 +18,7 @@
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/lock.h"
+#include "base/threading/thread_task_runner_handle.h"
 #include "gin/array_buffer.h"
 #include "gin/public/isolate_holder.h"
 #include "gin/v8_initializer.h"
@@ -391,7 +392,8 @@ class SharedIsolateFactory {
         has_initialized_v8_ = true;
       }
 
-      holder_.reset(new gin::IsolateHolder(gin::IsolateHolder::kUseLocker));
+      holder_.reset(new gin::IsolateHolder(base::ThreadTaskRunnerHandle::Get(),
+                                           gin::IsolateHolder::kUseLocker));
     }
 
     return holder_->isolate();

pdf/pdfium/pdfium_engine.cc

@@ -25,6 +25,7 @@
 #include "base/strings/string_piece.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/threading/thread_task_runner_handle.h"
 #include "gin/array_buffer.h"
 #include "gin/public/gin_embedders.h"
 #include "gin/public/isolate_holder.h"
@@ -607,8 +608,8 @@ void SetUpV8() {
   gin::IsolateHolder::Initialize(gin::IsolateHolder::kNonStrictMode,
                                  gin::IsolateHolder::kStableV8Extras,
                                  gin::ArrayBufferAllocator::SharedInstance());
-  g_isolate_holder =
-      new gin::IsolateHolder(gin::IsolateHolder::kSingleThread);
+  g_isolate_holder = new gin::IsolateHolder(base::ThreadTaskRunnerHandle::Get(),
+                                            gin::IsolateHolder::kSingleThread);
   g_isolate_holder->isolate()->Enter();
 }
 

third_party/WebKit/Source/bindings/core/v8/V8Initializer.cpp

@@ -392,7 +392,9 @@ void V8Initializer::initializeMainThread() {
   gin::IsolateHolder::Initialize(gin::IsolateHolder::kNonStrictMode,
                                  v8ExtrasMode, &arrayBufferAllocator);
 
-  v8::Isolate* isolate = V8PerIsolateData::initialize();
+  WebScheduler* scheduler = Platform::current()->currentThread()->scheduler();
+  v8::Isolate* isolate =
+      V8PerIsolateData::initialize(scheduler->timerTaskRunner());
 
   initializeV8Common(isolate);
 
@@ -409,7 +411,6 @@ void V8Initializer::initializeMainThread() {
       codeGenerationCheckCallbackInMainThread);
 
   if (RuntimeEnabledFeatures::v8IdleTasksEnabled()) {
-    WebScheduler* scheduler = Platform::current()->currentThread()->scheduler();
     V8PerIsolateData::enableIdleTasks(
         isolate, WTF::makeUnique<V8IdleTaskRunner>(scheduler));
   }

third_party/WebKit/Source/bindings/core/v8/V8PerIsolateData.cpp

@@ -53,8 +53,9 @@ static void microtasksCompletedCallback(v8::Isolate* isolate) {
   V8PerIsolateData::from(isolate)->runEndOfScopeTasks();
 }
 
-V8PerIsolateData::V8PerIsolateData()
-    : m_isolateHolder(WTF::makeUnique<gin::IsolateHolder>()),
+V8PerIsolateData::V8PerIsolateData(WebTaskRunner* taskRunner)
+    : m_isolateHolder(WTF::makeUnique<gin::IsolateHolder>(
+          taskRunner->toSingleThreadTaskRunner())),
       m_stringCache(WTF::wrapUnique(new StringCache(isolate()))),
       m_hiddenValue(V8HiddenValue::create()),
       m_privateProperty(V8PrivateProperty::create()),
@@ -78,8 +79,8 @@ v8::Isolate* V8PerIsolateData::mainThreadIsolate() {
   return mainThreadPerIsolateData->isolate();
 }
 
-v8::Isolate* V8PerIsolateData::initialize() {
-  V8PerIsolateData* data = new V8PerIsolateData();
+v8::Isolate* V8PerIsolateData::initialize(WebTaskRunner* taskRunner) {
+  V8PerIsolateData* data = new V8PerIsolateData(taskRunner);
   v8::Isolate* isolate = data->isolate();
   isolate->SetData(gin::kEmbedderBlink, data);
   return isolate;

third_party/WebKit/Source/bindings/core/v8/V8PerIsolateData.h

@@ -48,6 +48,7 @@ class DOMDataStore;
 class StringCache;
 class ThreadDebugger;
 class V8PrivateProperty;
+class WebTaskRunner;
 struct WrapperTypeInfo;
 
 typedef WTF::Vector<DOMDataStore*> DOMDataStoreList;
@@ -89,7 +90,7 @@ class CORE_EXPORT V8PerIsolateData {
     const bool m_originalUseCounterDisabled;
   };
 
-  static v8::Isolate* initialize();
+  static v8::Isolate* initialize(WebTaskRunner*);
 
   static V8PerIsolateData* from(v8::Isolate* isolate) {
     ASSERT(isolate);
@@ -175,7 +176,7 @@ class CORE_EXPORT V8PerIsolateData {
   }
 
  private:
-  V8PerIsolateData();
+  explicit V8PerIsolateData(WebTaskRunner*);
   ~V8PerIsolateData();
 
   static void useCounterCallback(v8::Isolate*, v8::Isolate::UseCounterFeature);

third_party/WebKit/Source/core/workers/WorkerBackingThread.cpp

@@ -64,7 +64,8 @@ WorkerBackingThread::~WorkerBackingThread() {}
 void WorkerBackingThread::initialize() {
   DCHECK(!m_isolate);
   m_backingThread->initialize();
-  m_isolate = V8PerIsolateData::initialize();
+  m_isolate = V8PerIsolateData::initialize(
+      m_backingThread->platformThread().getWebTaskRunner());
   addWorkerIsolate(m_isolate);
   V8Initializer::initializeWorker(m_isolate);
 

third_party/WebKit/Source/modules/fetch/DataConsumerHandleTestUtil.cpp

@@ -5,6 +5,7 @@
 #include "modules/fetch/DataConsumerHandleTestUtil.h"
 
 #include "bindings/core/v8/DOMWrapperWorld.h"
+#include "public/platform/WebScheduler.h"
 #include "wtf/PtrUtil.h"
 #include <memory>
 
@@ -58,7 +59,12 @@ DataConsumerHandleTestUtil::Thread::~Thread() {
 
 void DataConsumerHandleTestUtil::Thread::initialize() {
   if (m_initializationPolicy >= ScriptExecution) {
-    m_isolateHolder = WTF::makeUnique<gin::IsolateHolder>();
+    m_isolateHolder =
+        WTF::makeUnique<gin::IsolateHolder>(Platform::current()
+                                                ->currentThread()
+                                                ->scheduler()
+                                                ->loadingTaskRunner()
+                                                ->toSingleThreadTaskRunner());
     isolate()->Enter();
   }
   m_thread->initialize();