8 files changed, 64 insertions, 1 deletions

diff --git a/gin/BUILD.gn b/gin/BUILD.gn
index d926cb9..52611dc 100644
--- a/gin/BUILD.gn
+++ b/gin/BUILD.gn
@@ -46,6 +46,7 @@ component("gin") {
     "public/debug.h",
     "public/gin_embedders.h",
     "public/isolate_holder.h",
+    "public/v8_idle_task_runner.h",
     "public/v8_platform.h",
     "public/wrapper_info.h",
     "run_microtasks_observer.cc",
diff --git a/gin/isolate_holder.cc b/gin/isolate_holder.cc
index 656ce09..3defd7c 100644
--- a/gin/isolate_holder.cc
+++ b/gin/isolate_holder.cc
@@ -92,4 +92,10 @@ void IsolateHolder::RemoveRunMicrotasksObserver() {
   task_observer_.reset();
 }
 
+void IsolateHolder::EnableIdleTasks(
+    scoped_ptr<V8IdleTaskRunner> idle_task_runner) {
+  DCHECK(isolate_data_.get());
+  isolate_data_->EnableIdleTasks(idle_task_runner.Pass());
+}
+
 }  // namespace gin
diff --git a/gin/per_isolate_data.cc b/gin/per_isolate_data.cc
index 8f72d76..cec0821 100644
--- a/gin/per_isolate_data.cc
+++ b/gin/per_isolate_data.cc
@@ -2,10 +2,11 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include "gin/per_isolate_data.h"
+
 #include "base/logging.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
-#include "gin/per_isolate_data.h"
 #include "gin/public/gin_embedders.h"
 
 using v8::ArrayBuffer;
@@ -110,4 +111,9 @@ NamedPropertyInterceptor* PerIsolateData::GetNamedPropertyInterceptor(
     return NULL;
 }
 
+void PerIsolateData::EnableIdleTasks(
+    scoped_ptr<V8IdleTaskRunner> idle_task_runner) {
+  idle_task_runner_ = idle_task_runner.Pass();
+}
+
 }  // namespace gin
diff --git a/gin/per_isolate_data.h b/gin/per_isolate_data.h
index 175161c..ef44f31 100644
--- a/gin/per_isolate_data.h
+++ b/gin/per_isolate_data.h
@@ -9,7 +9,9 @@
 
 #include "base/basictypes.h"
 #include "base/memory/ref_counted.h"
+#include "base/memory/scoped_ptr.h"
 #include "gin/gin_export.h"
+#include "gin/public/v8_idle_task_runner.h"
 #include "gin/public/wrapper_info.h"
 #include "v8/include/v8.h"
 
@@ -63,9 +65,14 @@ class GIN_EXPORT PerIsolateData {
       WrappableBase* base);
   NamedPropertyInterceptor* GetNamedPropertyInterceptor(WrappableBase* base);
 
+  void EnableIdleTasks(scoped_ptr<V8IdleTaskRunner> idle_task_runner);
+
   v8::Isolate* isolate() { return isolate_; }
   v8::ArrayBuffer::Allocator* allocator() { return allocator_; }
   base::SingleThreadTaskRunner* task_runner() { return task_runner_.get(); }
+  V8IdleTaskRunner* idle_task_runner() {
+    return idle_task_runner_.get();
+  }
 
  private:
   typedef std::map<
@@ -86,6 +93,7 @@ class GIN_EXPORT PerIsolateData {
   IndexedPropertyInterceptorMap indexed_interceptors_;
   NamedPropertyInterceptorMap named_interceptors_;
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
+  scoped_ptr<V8IdleTaskRunner> idle_task_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(PerIsolateData);
 };
diff --git a/gin/public/isolate_holder.h b/gin/public/isolate_holder.h
index 1647293..f7e01e8 100644
--- a/gin/public/isolate_holder.h
+++ b/gin/public/isolate_holder.h
@@ -8,6 +8,7 @@
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "gin/gin_export.h"
+#include "gin/public/v8_idle_task_runner.h"
 #include "v8/include/v8.h"
 
 namespace gin {
@@ -66,6 +67,8 @@ class GIN_EXPORT IsolateHolder {
   // This method returns if v8::Locker is needed to access isolate.
   AccessMode access_mode() const { return access_mode_; }
 
+  void EnableIdleTasks(scoped_ptr<V8IdleTaskRunner> idle_task_runner);
+
   // This method returns V8IsolateMemoryDumpProvider of this isolate, used for
   // testing.
   V8IsolateMemoryDumpProvider* isolate_memory_dump_provider_for_testing()
diff --git a/gin/public/v8_idle_task_runner.h b/gin/public/v8_idle_task_runner.h
new file mode 100644
index 0000000..f0662d1
--- /dev/null
+++ b/gin/public/v8_idle_task_runner.h
@@ -0,0 +1,26 @@
+// Copyright 2013 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 GIN_PUBLIC_V8_IDLE_TASK_RUNNER_H_
+#define GIN_PUBLIC_V8_IDLE_TASK_RUNNER_H_
+
+#include "base/basictypes.h"
+#include "v8/include/v8-platform.h"
+
+namespace gin {
+
+// A V8IdleTaskRunner is a task runner for running idle tasks.
+// Idle tasks have an unbound argument which is bound to a deadline in
+// (v8::Platform::MonotonicallyIncreasingTime) when they are run.
+// The idle task is expected to complete by this deadline.
+class GIN_EXPORT V8IdleTaskRunner {
+ public:
+  virtual void PostIdleTask(v8::IdleTask* task) = 0;
+
+  virtual ~V8IdleTaskRunner() {}
+};
+
+}  // namespace gin
+
+#endif  // GIN_PUBLIC_V8_IDLE_TASK_RUNNER_H_
diff --git a/gin/public/v8_platform.h b/gin/public/v8_platform.h
index df18943..d66c1fb 100644
--- a/gin/public/v8_platform.h
+++ b/gin/public/v8_platform.h
@@ -26,6 +26,9 @@ class GIN_EXPORT V8Platform : public NON_EXPORTED_BASE(v8::Platform) {
   void CallDelayedOnForegroundThread(v8::Isolate* isolate,
                                      v8::Task* task,
                                      double delay_in_seconds) override;
+  void CallIdleOnForegroundThread(v8::Isolate* isolate,
+                                  v8::IdleTask* task) override;
+  bool IdleTasksEnabled(v8::Isolate* isolate) override;
   double MonotonicallyIncreasingTime() override;
 
  private:
diff --git a/gin/v8_platform.cc b/gin/v8_platform.cc
index 6214d3d..bd32977 100644
--- a/gin/v8_platform.cc
+++ b/gin/v8_platform.cc
@@ -46,6 +46,16 @@ void V8Platform::CallDelayedOnForegroundThread(v8::Isolate* isolate,
       base::TimeDelta::FromSecondsD(delay_in_seconds));
 }
 
+void V8Platform::CallIdleOnForegroundThread(v8::Isolate* isolate,
+                                            v8::IdleTask* task) {
+  DCHECK(PerIsolateData::From(isolate)->idle_task_runner());
+  PerIsolateData::From(isolate)->idle_task_runner()->PostIdleTask(task);
+}
+
+bool V8Platform::IdleTasksEnabled(v8::Isolate* isolate) {
+  return PerIsolateData::From(isolate)->idle_task_runner() != nullptr;
+}
+
 double V8Platform::MonotonicallyIncreasingTime() {
   return base::TimeTicks::Now().ToInternalValue() /
       static_cast<double>(base::Time::kMicrosecondsPerSecond);