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 843 matching lines @@
   base::TaskScheduler::CreateAndSetDefaultTaskScheduler(
       params_vector, index_to_traits_callback);
 
   GetContentClient()->browser()->PerformExperimentalTaskSchedulerRedirections();
 
   base::Thread::Options io_message_loop_options;
   io_message_loop_options.message_loop_type = base::MessageLoop::TYPE_IO;
   base::Thread::Options ui_message_loop_options;
   ui_message_loop_options.message_loop_type = base::MessageLoop::TYPE_UI;
 
-  const bool redirect_nonUInonIO_browser_threads =
+  const bool client_redirect_nonUInonIO_browser_threads =
       GetContentClient()
           ->browser()
           ->RedirectNonUINonIOBrowserThreadsToTaskScheduler();
 
   // 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) {
     // 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_nonUInonIO_browser_threads =

[gab, 2017/03/29 18:14:04]

bool redirect_thread = redirect_nonUInonIO_browser_threads;

(i.e. this individual bool only applies to this thread and should be named as
such -- also removes need to rename top-level bool)

[boliu, 2017/03/29 18:30:07]

Done, but now needs to rename all the usage of the old var in the switch block
:p

+        client_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:
@@ skipping 44 matching lines @@
           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 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 is not a problem in practice.

[gab, 2017/03/29 18:14:04]

s/is/are/

[boliu, 2017/03/29 18:30:07]

Done.

+        redirect_nonUInonIO_browser_threads = false;
+        message_loop = android::LauncherThread::GetMessageLoop();
+#endif
         if (redirect_nonUInonIO_browser_threads) {

[gab, 2017/03/29 18:38:06]

Actually can't we just change this to

if (redirect_nonUInonIO_browser_threads && !message_loop) {
  ...

instead of having a duplicate of the bool merely to skip this block?

[boliu, 2017/03/29 18:42:20]

Hmm, then in theory, that should be changed in all the case blocks, which is no
better than the current thing imo

[gab, 2017/03/29 18:46:53]

Hmmm ok sure.

           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",
@@ skipping 33 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