Experiment with redirecting all BrowserThreads (but UI/IO) to TaskScheduler

content/browser/browser_main_loop.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/browser/browser_main_loop.h"
 
 #include <stddef.h>
 
 #include <string>
 #include <utility>
@@ skipping 12 matching lines @@
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/user_metrics.h"
 #include "base/pending_task.h"
 #include "base/power_monitor/power_monitor.h"
 #include "base/power_monitor/power_monitor_device_source.h"
 #include "base/process/process_metrics.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
+#include "base/synchronization/waitable_event.h"
 #include "base/system_monitor/system_monitor.h"
+#include "base/task_scheduler/post_task.h"
+#include "base/task_scheduler/task_traits.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/timer/hi_res_timer_manager.h"
 #include "base/trace_event/memory_dump_manager.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "components/discardable_memory/service/discardable_shared_memory_manager.h"
 #include "components/tracing/browser/trace_config_file.h"
 #include "components/tracing/common/process_metrics_memory_dump_provider.h"
 #include "components/tracing/common/trace_to_console.h"
@@ skipping 247 matching lines @@
 void OnStoppedStartupTracing(const base::FilePath& trace_file) {
   VLOG(0) << "Completed startup tracing to " << trace_file.value();
 }
 
 // Disable optimizations for this block of functions so the compiler doesn't
 // merge them all together. This makes it possible to tell what thread was
 // unresponsive by inspecting the callstack.
 MSVC_DISABLE_OPTIMIZE()
 MSVC_PUSH_DISABLE_WARNING(4748)
 
-NOINLINE void ResetThread_DB(std::unique_ptr<BrowserProcessSubThread> thread) {
+// Takes ownership of |task_runner| and blocks until it's empty.
+void FlushThreadTaskRunner(
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
+  base::WaitableEvent thread_terminated(
+      base::WaitableEvent::ResetPolicy::MANUAL,
+      base::WaitableEvent::InitialState::NOT_SIGNALED);
+  task_runner->PostTask(FROM_HERE,
+                        base::Bind(&base::WaitableEvent::Signal,
+                                   base::Unretained(&thread_terminated)));
+  thread_terminated.Wait();
+}
+
+NOINLINE void ResetThread_DB(
+    std::unique_ptr<BrowserProcessSubThread> thread,
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
+  DCHECK(!thread || !task_runner);

[Avi (use Gerrit), 2016/11/08 16:16:15]

This checks that we don't have both.

Do we want to check that we have exactly one? (and below too)

[gab, 2016/11/08 20:40:44]

Right, made this
DCHECK((thread && !task_runner) || (!thread && task_runner));
instead. Otherwise, to verify inline below would require making the else {} and
else if and having a NOTREACHED() else {} IMO which is uglier I think.

   volatile int inhibit_comdat = __LINE__;
   ALLOW_UNUSED_LOCAL(inhibit_comdat);
-  thread.reset();
+  if (thread) {
+    thread.reset();
+  } else {
+    BrowserThreadImpl::RedirectThreadIDToTaskRunner(BrowserThread::DB, nullptr);
+    FlushThreadTaskRunner(std::move(task_runner));
+  }
 }
 
 NOINLINE void ResetThread_FILE(
-    std::unique_ptr<BrowserProcessSubThread> thread) {
+    std::unique_ptr<BrowserProcessSubThread> thread,
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
+  DCHECK(!thread || !task_runner);
   volatile int inhibit_comdat = __LINE__;
   ALLOW_UNUSED_LOCAL(inhibit_comdat);
-  thread.reset();
+  if (thread) {
+    thread.reset();
+  } else {
+    BrowserThreadImpl::RedirectThreadIDToTaskRunner(BrowserThread::FILE,
+                                                    nullptr);
+    FlushThreadTaskRunner(std::move(task_runner));
+  }
 }
 
 NOINLINE void ResetThread_FILE_USER_BLOCKING(
-    std::unique_ptr<BrowserProcessSubThread> thread) {
+    std::unique_ptr<BrowserProcessSubThread> thread,
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
+  DCHECK(!thread || !task_runner);
   volatile int inhibit_comdat = __LINE__;
   ALLOW_UNUSED_LOCAL(inhibit_comdat);
-  thread.reset();
+  if (thread) {
+    thread.reset();
+  } else {
+    BrowserThreadImpl::RedirectThreadIDToTaskRunner(
+        BrowserThread::FILE_USER_BLOCKING, nullptr);
+    FlushThreadTaskRunner(std::move(task_runner));
+  }
 }
 
 NOINLINE void ResetThread_PROCESS_LAUNCHER(
-    std::unique_ptr<BrowserProcessSubThread> thread) {
+    std::unique_ptr<BrowserProcessSubThread> thread,
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
+  DCHECK(!thread || !task_runner);
   volatile int inhibit_comdat = __LINE__;
   ALLOW_UNUSED_LOCAL(inhibit_comdat);
-  thread.reset();
+  if (thread) {
+    thread.reset();
+  } else {
+    BrowserThreadImpl::RedirectThreadIDToTaskRunner(
+        BrowserThread::PROCESS_LAUNCHER, nullptr);
+    FlushThreadTaskRunner(std::move(task_runner));
+  }
 }
 
 NOINLINE void ResetThread_CACHE(
-    std::unique_ptr<BrowserProcessSubThread> thread) {
+    std::unique_ptr<BrowserProcessSubThread> thread,
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
+  DCHECK(!thread || !task_runner);
   volatile int inhibit_comdat = __LINE__;
   ALLOW_UNUSED_LOCAL(inhibit_comdat);
-  thread.reset();
+  if (thread) {
+    thread.reset();
+  } else {
+    BrowserThreadImpl::RedirectThreadIDToTaskRunner(BrowserThread::CACHE,
+                                                    nullptr);
+    FlushThreadTaskRunner(std::move(task_runner));
+  }
 }
 
 NOINLINE void ResetThread_IO(std::unique_ptr<BrowserProcessSubThread> thread) {
   volatile int inhibit_comdat = __LINE__;
   ALLOW_UNUSED_LOCAL(inhibit_comdat);
   thread.reset();
 }
 
 NOINLINE void ResetThread_IndexedDb(std::unique_ptr<base::Thread> thread) {
   volatile int inhibit_comdat = __LINE__;
@@ skipping 517 matching lines @@
   ui_message_loop_options.message_loop_type = base::MessageLoop::TYPE_UI;
 
   // Start threads in the order they occur in the BrowserThread::ID
   // enumeration, except for BrowserThread::UI which is the main
   // thread.
   //
   // Must be size_t so we can increment it.
   for (size_t thread_id = BrowserThread::UI + 1;
        thread_id < BrowserThread::ID_COUNT;
        ++thread_id) {
-    std::unique_ptr<BrowserProcessSubThread>* thread_to_start = NULL;
+    // If this thread ID is backed by a real thread, |thread_to_start| will be
+    // set to the appropriate |BrowserProcessSubThread*|. And |options| can be
+    // updated away from its default.
+    std::unique_ptr<BrowserProcessSubThread>* thread_to_start = nullptr;
     base::Thread::Options options;
 
+    // Otherwise this thread ID will be backed by a SingleThreadTaskRunner in
+    // which case |task_runner_to_create| will be set to the appropriate
+    // |SingleThreadTaskRunner*| and |task_runner_traits| can be updated away
+    // from its default. |execution_mode| defaults to |SINGLE_THREADED| as-is
+    // appropriate to map most old browser threads but can also be updated in
+    // the switch statement below if a thread has specific requirements.
+    scoped_refptr<base::SingleThreadTaskRunner>* task_runner_to_create =
+        nullptr;
+    base::TaskTraits task_runner_traits;
+
+    const bool redirect_nonUInonIO_browser_threads =
+        GetContentClient()
+            ->browser()
+            ->RedirectNonUINonIOBrowserThreadsToTaskScheduler();
+
     switch (thread_id) {
       case BrowserThread::DB:
         TRACE_EVENT_BEGIN1("startup",
             "BrowserMainLoop::CreateThreads:start",
             "Thread", "BrowserThread::DB");
-        thread_to_start = &db_thread_;
-        options.timer_slack = base::TIMER_SLACK_MAXIMUM;
+        if (redirect_nonUInonIO_browser_threads) {
+          task_runner_to_create = &db_task_runner_;
+          task_runner_traits.WithFileIO()
+              .WithPriority(base::TaskPriority::USER_VISIBLE)
+              .WithShutdownBehavior(base::TaskShutdownBehavior::BLOCK_SHUTDOWN);
+        } else {
+          thread_to_start = &db_thread_;
+          options.timer_slack = base::TIMER_SLACK_MAXIMUM;
+        }
         break;
       case BrowserThread::FILE_USER_BLOCKING:
         TRACE_EVENT_BEGIN1("startup",
             "BrowserMainLoop::CreateThreads:start",
             "Thread", "BrowserThread::FILE_USER_BLOCKING");
-        thread_to_start = &file_user_blocking_thread_;
+        if (redirect_nonUInonIO_browser_threads) {
+          task_runner_to_create = &file_user_blocking_task_runner_;
+          task_runner_traits.WithFileIO()
+              .WithPriority(base::TaskPriority::USER_BLOCKING)
+              .WithShutdownBehavior(base::TaskShutdownBehavior::BLOCK_SHUTDOWN);
+        } else {
+          thread_to_start = &file_user_blocking_thread_;
+        }
         break;
       case BrowserThread::FILE:
         TRACE_EVENT_BEGIN1("startup",
             "BrowserMainLoop::CreateThreads:start",
             "Thread", "BrowserThread::FILE");
+
+#if defined(OS_WIN)
+        // On Windows, the FILE thread needs to be have a UI message loop which
+        // pumps messages in such a way that Google Update can communicate back
+        // to us.
+        // TODO(robliao): Need to support COM in TaskScheduler before
+        // redirecting the FILE thread on Windows. http://crbug.com/662122
+        // TODO(gab): Also need to support clipboard (see below).
         thread_to_start = &file_thread_;
-#if defined(OS_WIN)
-        // On Windows, the FILE thread needs to be have a UI message loop
-        // which pumps messages in such a way that Google Update can
-        // communicate back to us.
         options = ui_message_loop_options;
 #else
-        options = io_message_loop_options;
+        if (redirect_nonUInonIO_browser_threads) {
+          task_runner_to_create = &file_task_runner_;
+          task_runner_traits.WithFileIO()
+              .WithPriority(base::TaskPriority::BACKGROUND)
+              .WithShutdownBehavior(base::TaskShutdownBehavior::BLOCK_SHUTDOWN);
+        } else {
+          thread_to_start = &file_thread_;
+          options = io_message_loop_options;
+          options.timer_slack = base::TIMER_SLACK_MAXIMUM;
+        }
 #endif
-        options.timer_slack = base::TIMER_SLACK_MAXIMUM;
         break;
       case BrowserThread::PROCESS_LAUNCHER:
         TRACE_EVENT_BEGIN1("startup",
             "BrowserMainLoop::CreateThreads:start",
             "Thread", "BrowserThread::PROCESS_LAUNCHER");
-        thread_to_start = &process_launcher_thread_;
-        options.timer_slack = base::TIMER_SLACK_MAXIMUM;
+        if (redirect_nonUInonIO_browser_threads) {
+          task_runner_to_create = &process_launcher_task_runner_;
+          task_runner_traits.WithFileIO()
+              .WithPriority(base::TaskPriority::USER_BLOCKING)
+              .WithShutdownBehavior(base::TaskShutdownBehavior::BLOCK_SHUTDOWN);
+        } else {
+          thread_to_start = &process_launcher_thread_;
+          options.timer_slack = base::TIMER_SLACK_MAXIMUM;
+        }
         break;
       case BrowserThread::CACHE:
         TRACE_EVENT_BEGIN1("startup",
             "BrowserMainLoop::CreateThreads:start",
             "Thread", "BrowserThread::CACHE");
+#if defined(OS_WIN)
+        // TaskScheduler doesn't support async I/O on Windows as CACHE thread is
+        // the only user and this use case is going away in
+        // https://codereview.chromium.org/2216583003/. TODO(gavinp): Remove
+        // this ifdef (and thus enable redirection of the CACHE thread on
+        // Windows) once that CL lands.
         thread_to_start = &cache_thread_;
-#if defined(OS_WIN)
         options = io_message_loop_options;
-#endif  // defined(OS_WIN)
         options.timer_slack = base::TIMER_SLACK_MAXIMUM;
+#else  // OS_WIN
+        if (redirect_nonUInonIO_browser_threads) {
+          task_runner_to_create = &cache_task_runner_;
+          task_runner_traits.WithFileIO()
+              .WithPriority(base::TaskPriority::USER_BLOCKING)
+              .WithShutdownBehavior(base::TaskShutdownBehavior::BLOCK_SHUTDOWN);
+        } else {
+          thread_to_start = &cache_thread_;
+          options.timer_slack = base::TIMER_SLACK_MAXIMUM;
+        }
+#endif  // OS_WIN
         break;
       case BrowserThread::IO:
         TRACE_EVENT_BEGIN1("startup",
             "BrowserMainLoop::CreateThreads:start",
             "Thread", "BrowserThread::IO");
         thread_to_start = &io_thread_;
         options = io_message_loop_options;
 #if defined(OS_ANDROID) || defined(OS_CHROMEOS)
         // Up the priority of the |io_thread_| as some of its IPCs relate to
         // display tasks.
         options.priority = base::ThreadPriority::DISPLAY;
 #endif
         break;
-      case BrowserThread::UI:
-      case BrowserThread::ID_COUNT:
-      default:
+      case BrowserThread::UI:        // Falls through.
+      case BrowserThread::ID_COUNT:  // Falls through.
         NOTREACHED();
         break;
     }
 
     BrowserThread::ID id = static_cast<BrowserThread::ID>(thread_id);
 
     if (thread_to_start) {
+      DCHECK(!task_runner_to_create);
       (*thread_to_start).reset(new BrowserProcessSubThread(id));
       if (!(*thread_to_start)->StartWithOptions(options)) {
         LOG(FATAL) << "Failed to start the browser thread: id == " << id;
       }
+    } else if (task_runner_to_create) {
+      *task_runner_to_create =
+          base::CreateSingleThreadTaskRunnerWithTraits(task_runner_traits);
+      DCHECK(*task_runner_to_create);
+      BrowserThreadImpl::RedirectThreadIDToTaskRunner(
+          id, task_runner_to_create->get());
     } else {
       NOTREACHED();
     }
 
     TRACE_EVENT_END0("startup", "BrowserMainLoop::CreateThreads:start");
   }
   created_threads_ = true;
   return result_code_;
 }
 
@@ skipping 127 matching lines @@
     // - The IO thread is the only user of the CACHE thread.
     //
     // - The PROCESS_LAUNCHER thread must be stopped after IO in case
     //   the IO thread posted a task to terminate a process on the
     //   process launcher thread.
     //
     // - (Not sure why DB stops last.)
     switch (thread_id) {
       case BrowserThread::DB: {
         TRACE_EVENT0("shutdown", "BrowserMainLoop::Subsystem:DBThread");
-        ResetThread_DB(std::move(db_thread_));
+        ResetThread_DB(std::move(db_thread_), std::move(db_task_runner_));
         break;
       }
       case BrowserThread::FILE: {
         TRACE_EVENT0("shutdown", "BrowserMainLoop::Subsystem:FileThread");
-        // Clean up state that lives on or uses the file_thread_ before
-        // it goes away.
+        // Clean up state that lives on or uses the file_thread_ before it goes
+        // away.
         save_file_manager_->Shutdown();
-        ResetThread_FILE(std::move(file_thread_));
+        ResetThread_FILE(std::move(file_thread_), std::move(file_task_runner_));
         break;
       }
       case BrowserThread::FILE_USER_BLOCKING: {
         TRACE_EVENT0("shutdown",
                       "BrowserMainLoop::Subsystem:FileUserBlockingThread");
-        ResetThread_FILE_USER_BLOCKING(std::move(file_user_blocking_thread_));
+        ResetThread_FILE_USER_BLOCKING(
+            std::move(file_user_blocking_thread_),
+            std::move(file_user_blocking_task_runner_));
         break;
       }
       case BrowserThread::PROCESS_LAUNCHER: {
         TRACE_EVENT0("shutdown", "BrowserMainLoop::Subsystem:LauncherThread");
-        ResetThread_PROCESS_LAUNCHER(std::move(process_launcher_thread_));
+        ResetThread_PROCESS_LAUNCHER(std::move(process_launcher_thread_),
+                                     std::move(process_launcher_task_runner_));
         break;
       }
       case BrowserThread::CACHE: {
         TRACE_EVENT0("shutdown", "BrowserMainLoop::Subsystem:CacheThread");
-        ResetThread_CACHE(std::move(cache_thread_));
+        ResetThread_CACHE(std::move(cache_thread_),
+                          std::move(cache_task_runner_));
         break;
       }
       case BrowserThread::IO: {
         TRACE_EVENT0("shutdown", "BrowserMainLoop::Subsystem:IOThread");
         ResetThread_IO(std::move(io_thread_));
         break;
       }
       case BrowserThread::UI:
       case BrowserThread::ID_COUNT:
-      default:
         NOTREACHED();
         break;
     }
   }
   {
     TRACE_EVENT0("shutdown", "BrowserMainLoop::Subsystem:IndexedDBThread");
     ResetThread_IndexedDb(std::move(indexed_db_thread_));
   }
 
   // Close the blocking I/O pool after the other threads. Other threads such
@@ skipping 217 matching lines @@
     save_file_manager_ = new SaveFileManager();
   }
 
   // Alert the clipboard class to which threads are allowed to access the
   // clipboard:
   std::vector<base::PlatformThreadId> allowed_clipboard_threads;
   // The current thread is the UI thread.
   allowed_clipboard_threads.push_back(base::PlatformThread::CurrentId());
 #if defined(OS_WIN)
   // On Windows, clipboards are also used on the FILE or IO threads.
+  // TODO(gab): Figure out how to selectively allow clipboard via TaskTraits for
+  // TaskScheduler. http://crbug.com/662055
   allowed_clipboard_threads.push_back(file_thread_->GetThreadId());
   allowed_clipboard_threads.push_back(io_thread_->GetThreadId());
 #endif
   ui::Clipboard::SetAllowedThreads(allowed_clipboard_threads);
 
   // When running the GPU thread in-process, avoid optimistically starting it
   // since creating the GPU thread races against creation of the one-and-only
   // ChildProcess instance which is created by the renderer thread.
   if (GpuDataManagerImpl::GetInstance()->GpuAccessAllowed(NULL) &&
       !established_gpu_channel && always_uses_gpu && !UsingInProcessGpu() &&
@@ skipping 225 matching lines @@
     scoped_refptr<base::SingleThreadTaskRunner> worker_task_runner =
         audio_thread_->task_runner();
     audio_manager_ = media::AudioManager::Create(std::move(audio_task_runner),
                                                  std::move(worker_task_runner),
                                                  MediaInternals::GetInstance());
   }
   CHECK(audio_manager_);
 }
 
 }  // namespace content