Make idle tasks optional in the default platform.

src/libplatform/default-platform.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/libplatform/default-platform.h"
 
 #include <algorithm>
 #include <queue>
 
 #include "include/libplatform/libplatform.h"
 #include "src/base/logging.h"
 #include "src/base/platform/platform.h"
 #include "src/base/platform/time.h"
 #include "src/base/sys-info.h"
 #include "src/libplatform/worker-thread.h"
 
 namespace v8 {
 namespace platform {
 
-
-v8::Platform* CreateDefaultPlatform(int thread_pool_size) {
-  DefaultPlatform* platform = new DefaultPlatform();
+v8::Platform* CreateDefaultPlatform(int thread_pool_size,
+                                    IdleTaskSupport idle_task_support) {
+  DefaultPlatform* platform = new DefaultPlatform(idle_task_support);
   platform->SetThreadPoolSize(thread_pool_size);
   platform->EnsureInitialized();
   return platform;
 }
 
 
 bool PumpMessageLoop(v8::Platform* platform, v8::Isolate* isolate) {
   return reinterpret_cast<DefaultPlatform*>(platform)->PumpMessageLoop(isolate);
 }
 
 void RunIdleTasks(v8::Platform* platform, v8::Isolate* isolate,
                   double idle_time_in_seconds) {
   reinterpret_cast<DefaultPlatform*>(platform)->RunIdleTasks(
       isolate, idle_time_in_seconds);
 }
 
 void SetTracingController(
     v8::Platform* platform,
     v8::platform::tracing::TracingController* tracing_controller) {
   return reinterpret_cast<DefaultPlatform*>(platform)->SetTracingController(
       tracing_controller);
 }
 
 const int DefaultPlatform::kMaxThreadPoolSize = 8;
 
-DefaultPlatform::DefaultPlatform()
-    : initialized_(false), thread_pool_size_(0) {}
+DefaultPlatform::DefaultPlatform(IdleTaskSupport idle_task_support)
+    : initialized_(false),
+      thread_pool_size_(0),
+      idle_task_support_(idle_task_support) {}
 
 DefaultPlatform::~DefaultPlatform() {
   if (tracing_controller_) {
     tracing_controller_->StopTracing();
     tracing_controller_.reset();
   }
 
   base::LockGuard<base::Mutex> guard(&lock_);
   queue_.Terminate();
   if (initialized_) {
@@ skipping 98 matching lines @@
       return false;
     }
   }
   task->Run();
   delete task;
   return true;
 }
 
 void DefaultPlatform::RunIdleTasks(v8::Isolate* isolate,
                                    double idle_time_in_seconds) {
+  DCHECK(IdleTaskSupport::kEnabled == idle_task_support_);
   double deadline_in_seconds =
       MonotonicallyIncreasingTime() + idle_time_in_seconds;
   while (deadline_in_seconds > MonotonicallyIncreasingTime()) {
     {
       IdleTask* task;
       {
         base::LockGuard<base::Mutex> guard(&lock_);
         task = PopTaskInMainThreadIdleQueue(isolate);
       }
       if (task == nullptr) return;
@@ skipping 23 matching lines @@
   double deadline = MonotonicallyIncreasingTime() + delay_in_seconds;
   main_thread_delayed_queue_[isolate].push(std::make_pair(deadline, task));
 }
 
 void DefaultPlatform::CallIdleOnForegroundThread(Isolate* isolate,
                                                  IdleTask* task) {
   base::LockGuard<base::Mutex> guard(&lock_);
   main_thread_idle_queue_[isolate].push(task);
 }
 
-bool DefaultPlatform::IdleTasksEnabled(Isolate* isolate) { return true; }
+bool DefaultPlatform::IdleTasksEnabled(Isolate* isolate) {
+  return idle_task_support_ == IdleTaskSupport::kEnabled;
+}
 
 double DefaultPlatform::MonotonicallyIncreasingTime() {
   return base::TimeTicks::HighResolutionNow().ToInternalValue() /
          static_cast<double>(base::Time::kMicrosecondsPerSecond);
 }
 
 uint64_t DefaultPlatform::AddTraceEvent(
     char phase, const uint8_t* category_enabled_flag, const char* name,
     const char* scope, uint64_t id, uint64_t bind_id, int num_args,
     const char** arg_names, const uint8_t* arg_types,
@@ skipping 46 matching lines @@
   tracing_controller_->AddTraceStateObserver(observer);
 }
 
 void DefaultPlatform::RemoveTraceStateObserver(TraceStateObserver* observer) {
   if (!tracing_controller_) return;
   tracing_controller_->RemoveTraceStateObserver(observer);
 }
 
 }  // namespace platform
 }  // namespace v8