android: Java-based launcher thread

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 105 matching lines @@
 
 #if defined(USE_AURA)
 #include "content/public/browser/context_factory.h"
 #include "ui/aura/env.h"
 #endif
 
 #if defined(OS_ANDROID)
 #include "base/android/jni_android.h"
 #include "components/tracing/common/graphics_memory_dump_provider_android.h"
 #include "content/browser/android/browser_startup_controller.h"
+#include "content/browser/android/launcher_thread.h"
 #include "content/browser/android/scoped_surface_request_manager.h"
 #include "content/browser/android/tracing_controller_android.h"
 #include "content/browser/media/android/browser_media_player_manager.h"
 #include "content/browser/screen_orientation/screen_orientation_delegate_android.h"
 #include "media/base/android/media_drm_bridge_client.h"
 #include "ui/android/screen_android.h"
 #include "ui/display/screen.h"
 #include "ui/gl/gl_surface.h"
 #endif
 
@@ skipping 860 matching lines @@
   //
   // Must be size_t so we can increment it.
   for (size_t thread_id = BrowserThread::UI + 1;
        thread_id < BrowserThread::ID_COUNT;
        ++thread_id) {
     // 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;
+    // If |message_loop| is not nullptr, then this BrowserThread will use this
+    // message loop instead of creating a new thread. Note that means this
+    // thread will not be joined on shutdown, and may cause use-after-free if
+    // anything tries to access objects deleted by AtExitManager, such as
+    // non-leaky LazyInstance.
+    base::MessageLoop* message_loop = nullptr;
+    bool redirect_thread = redirect_nonUInonIO_browser_threads;
 
     // Otherwise this thread ID will be backed by a SingleThreadTaskRunner using
     // |non_ui_non_io_task_runner_traits| (which can be augmented below).
     // TODO(gab): Existing non-UI/non-IO BrowserThreads allow sync primitives so
     // the initial redirection will as well but they probably don't need to.
     base::TaskTraits non_ui_non_io_task_runner_traits =
         base::TaskTraits().MayBlock().WithBaseSyncPrimitives();
 
     switch (thread_id) {
       case BrowserThread::DB:
         TRACE_EVENT_BEGIN1("startup",
             "BrowserMainLoop::CreateThreads:start",
             "Thread", "BrowserThread::DB");
-        if (redirect_nonUInonIO_browser_threads) {
+        if (redirect_thread) {
           non_ui_non_io_task_runner_traits
               .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");
-        if (redirect_nonUInonIO_browser_threads) {
+        if (redirect_thread) {
           non_ui_non_io_task_runner_traits
               .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 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
         thread_to_start = &file_thread_;
         options = ui_message_loop_options;
         options.timer_slack = base::TIMER_SLACK_MAXIMUM;
 #else
-        if (redirect_nonUInonIO_browser_threads) {
+        if (redirect_thread) {
           non_ui_non_io_task_runner_traits
               .WithPriority(base::TaskPriority::USER_VISIBLE)
               .WithShutdownBehavior(base::TaskShutdownBehavior::BLOCK_SHUTDOWN);
         } else {
           thread_to_start = &file_thread_;
           options = io_message_loop_options;
           options.timer_slack = base::TIMER_SLACK_MAXIMUM;
         }
 #endif
         break;
       case BrowserThread::PROCESS_LAUNCHER:
         TRACE_EVENT_BEGIN1("startup",
             "BrowserMainLoop::CreateThreads:start",
             "Thread", "BrowserThread::PROCESS_LAUNCHER");
-        if (redirect_nonUInonIO_browser_threads) {
+#if defined(OS_ANDROID)
+        // Android specializes Launcher thread so it is accessible in java.
+        // Note Android never does clean shutdown, so shutdown use-after-free
+        // concerns are not a problem in practice.
+        redirect_thread = false;
+        message_loop = android::LauncherThread::GetMessageLoop();
+#endif
+        if (redirect_thread) {
           non_ui_non_io_task_runner_traits
               .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_;
         options = io_message_loop_options;
         options.timer_slack = base::TIMER_SLACK_MAXIMUM;
 #else  // OS_WIN
-        if (redirect_nonUInonIO_browser_threads) {
+        if (redirect_thread) {
           non_ui_non_io_task_runner_traits
               .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:
@@ skipping 10 matching lines @@
         break;
       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) {
-      (*thread_to_start).reset(new BrowserProcessSubThread(id));
+      (*thread_to_start)
+          .reset(message_loop ? new BrowserProcessSubThread(id, message_loop)
+                              : new BrowserProcessSubThread(id));
       if (!(*thread_to_start)->StartWithOptions(options))
         LOG(FATAL) << "Failed to start the browser thread: id == " << id;
     } else {
       scoped_refptr<base::SingleThreadTaskRunner> redirection_task_runner =
           base::CreateSingleThreadTaskRunnerWithTraits(
               non_ui_non_io_task_runner_traits);
       DCHECK(redirection_task_runner);
       BrowserThreadImpl::RedirectThreadIDToTaskRunner(
           id, std::move(redirection_task_runner));
     }
@@ skipping 620 matching lines @@
         BrowserThread::GetTaskRunnerForThread(BrowserThread::FILE),
         MediaInternals::GetInstance());
   }
   CHECK(audio_manager_);
 
   audio_system_ = media::AudioSystemImpl::Create(audio_manager_.get());
   CHECK(audio_system_);
 }
 
 }  // namespace content