Initialize TaskScheduler in renderers.

content/renderer/render_process_impl.cc

 // Copyright (c) 2012 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.
 
 #include "content/renderer/render_process_impl.h"
 
 #include "build/build_config.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #include <objidl.h>
 #include <mlang.h>
 #endif
 
+#include <stddef.h>
+
+#include <vector>
+
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/feature_list.h"
 #include "base/sys_info.h"
+#include "base/task_scheduler/scheduler_worker_pool_params.h"
+#include "base/task_scheduler/task_scheduler.h"
+#include "base/task_scheduler/task_traits.h"
+#include "base/threading/sequenced_worker_pool.h"
 #include "content/child/site_isolation_stats_gatherer.h"
 #include "content/public/common/content_features.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/renderer/content_renderer_client.h"
 #include "third_party/WebKit/public/web/WebFrame.h"
 #include "v8/include/v8.h"
 
 namespace {
 
 const base::Feature kV8_ES2015_TailCalls_Feature {
@@ skipping 14 matching lines @@
     v8::V8::SetFlagsFromString(v8_flag, strlen(v8_flag));
   }
 }
 
 void SetV8FlagIfHasSwitch(const char* switch_name, const char* v8_flag) {
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(switch_name)) {
     v8::V8::SetFlagsFromString(v8_flag, strlen(v8_flag));
   }
 }
 
+bool IsSingleProcess() {
+  return base::CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kSingleProcess);
+}
+
+enum WorkerPoolType : size_t {
+  BACKGROUND_WORKER_POOL = 0,
+  FOREGROUND_WORKER_POOL,
+  WORKER_POOL_COUNT  // Always last.
+};
+
+size_t GetTaskSchedulerWorkerPoolIndexForTraits(
+    const base::TaskTraits& traits) {
+  return traits.priority() == base::TaskPriority::BACKGROUND

[gab, 2016/11/15 20:25:05]

DCHECK(!traits.with_file_io());

[fdoray, 2016/11/16 16:40:52]

Done.

+             ? BACKGROUND_WORKER_POOL
+             : FOREGROUND_WORKER_POOL;
+}
+
+void InitializeTaskScheduler() {
+  if (IsSingleProcess()) {
+    // If this renderer runs in the browser process, there should already be a
+    // TaskScheduler and redirection settings shouldn't be changed.
+    DCHECK(base::TaskScheduler::GetInstance());
+    return;
+  }
+  DCHECK(!base::TaskScheduler::GetInstance());
+
+  int max_background_threads = 0;
+  base::TimeDelta background_reclaim_time;
+  int max_foreground_threads = 0;
+  base::TimeDelta foreground_reclaim_time;
+  bool redirect_sequenced_worker_pool = false;
+
+  content::GetContentClient()
+      ->renderer()
+      ->GetTaskSchedulerInitializationArguments(
+          &max_background_threads, &background_reclaim_time,
+          &max_foreground_threads, &foreground_reclaim_time,
+          &redirect_sequenced_worker_pool);
+
+  DCHECK_GT(max_background_threads, 0);

[robliao, 2016/11/15 20:31:51]

Hitting this DCHECK and the one below seems like it would be pretty bad as no
workers would be allocated to create tasks.  Maybe we should CHECK instead?

[robliao, 2016/11/15 20:32:36]

create tasks -> run tasks

[gab, 2016/11/15 20:42:47]

No need to CHECK IMO, DCHECK documents runtime invariants. CHECK is meant to
verify bad input that could cause security issues.

https://chromium.googlesource.com/chromium/src/+/master/styleguide/c++/c++.md...

[robliao, 2016/11/15 20:49:08]

This would be pretty fatal to the process. We already CHECK that
SchedulerWorkerPoolImpl::Initialize provides at least one worker thread because
we won't make progress otherwise. Bringing that CHECK here would cover the input
case (and we wouldn't have to disambiguate between the OOM case and bad inputs).

[gab, 2016/11/15 22:04:30]

But the CHECK in SchedulerWorkerPoolImpl::Initialize is different IMO (i.e. it's
CHECKing versus the result of invoking OS APIs to create threads which we can't
do without)

A CHECK here is merely verifying input we own (albeit sometimes from server but
don't think we should bother with that).

[fdoray, 2016/11/16 16:40:52]

These DCHECKs will only fail if GetTaskSchedulerInitializationArguments() isn't
properly implemented. Such a problem is easy to catch on developer machines and
there is little value to having CHECKs for it in production code.

The CHECKs in TaskSchedulerImpl::Initialize() may fail even if there is no error
in our code (e.g. CreateThread fails). For our users, a process that is
terminated is better than having a process that can't run tasks.

Since the style guide says that we may only use CHECK to prevent security
vulnerabilities or to temporarily to catch errors in the wild, we might have to
find an alternative way to exit the process when there are errors in
TaskSchedulerImpl::Initialize().

[gab, 2016/11/16 16:58:06]

Agreed.
Meh, I'm fine with the current use of CHECK for hard exit on system failure to
create threads.

+  DCHECK(!background_reclaim_time.is_zero());
+  DCHECK_GT(max_foreground_threads, 0);
+  DCHECK(!foreground_reclaim_time.is_zero());
+
+  std::vector<base::SchedulerWorkerPoolParams> worker_pool_params_vector;
+  DCHECK_EQ(BACKGROUND_WORKER_POOL, worker_pool_params_vector.size());
+  worker_pool_params_vector.emplace_back(
+      "RendererBackground", base::ThreadPriority::BACKGROUND,
+      base::SchedulerWorkerPoolParams::IORestriction::DISALLOWED,
+      max_background_threads, background_reclaim_time);
+  DCHECK_EQ(FOREGROUND_WORKER_POOL, worker_pool_params_vector.size());
+  worker_pool_params_vector.emplace_back(
+      "RendererForeground", base::ThreadPriority::NORMAL,
+      base::SchedulerWorkerPoolParams::IORestriction::DISALLOWED,
+      max_foreground_threads, foreground_reclaim_time);
+  DCHECK_EQ(WORKER_POOL_COUNT, worker_pool_params_vector.size());
+
+  base::TaskScheduler::CreateAndSetDefaultTaskScheduler(
+      worker_pool_params_vector,
+      base::Bind(&GetTaskSchedulerWorkerPoolIndexForTraits));
+
+  if (redirect_sequenced_worker_pool)
+    base::SequencedWorkerPool::RedirectToTaskSchedulerForProcess();
+}
+
 }  // namespace
 
 namespace content {
 
 RenderProcessImpl::RenderProcessImpl()
     : enabled_bindings_(0) {
 #if defined(OS_WIN)
   // HACK:  See http://b/issue?id=1024307 for rationale.
   if (GetModuleHandle(L"LPK.DLL") == NULL) {
     // Makes sure lpk.dll is loaded by gdi32 to make sure ExtTextOut() works
@@ skipping 33 matching lines @@
       *base::CommandLine::ForCurrentProcess();
 
   if (command_line.HasSwitch(switches::kJavaScriptFlags)) {
     std::string flags(
         command_line.GetSwitchValueASCII(switches::kJavaScriptFlags));
     v8::V8::SetFlagsFromString(flags.c_str(), static_cast<int>(flags.size()));
   }
 
   SiteIsolationStatsGatherer::SetEnabled(
       GetContentClient()->renderer()->ShouldGatherSiteIsolationStats());
+
+  InitializeTaskScheduler();
 }
 
 RenderProcessImpl::~RenderProcessImpl() {
 #ifndef NDEBUG
   int count = blink::WebFrame::instanceCount();
   if (count)
     DLOG(ERROR) << "WebFrame LEAKED " << count << " TIMES";
 #endif
 
+  if (!IsSingleProcess()) {
+    DCHECK(base::TaskScheduler::GetInstance());
+    base::TaskScheduler::GetInstance()->Shutdown();
+  }
+
   GetShutDownEvent()->Signal();
 }
 
 void RenderProcessImpl::AddBindings(int bindings) {
   enabled_bindings_ |= bindings;
 }
 
 int RenderProcessImpl::GetEnabledBindings() const {
   return enabled_bindings_;
 }
 
 }  // namespace content