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 =
+  bool 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.

[gab, 2017/03/29 17:19:53]

Document |message_loop| here.

[boliu, 2017/03/29 18:02:39]

Done.

     std::unique_ptr<BrowserProcessSubThread>* thread_to_start = nullptr;
     base::Thread::Options options;
+    base::MessageLoop* message_loop = nullptr;
 
     // 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)
+        redirect_nonUInonIO_browser_threads = false;

[gab, 2017/03/29 17:19:53]

That's a large hammer since this bool is set outside the loop and as such this
alters behaviour of all other threads in this loop, let's tweak logic to only
ignore redirection for PROCESS_LAUNCHER thread?

[boliu, 2017/03/29 18:02:39]

Oh good catch! Added a bool in the loop instead

+        message_loop = android::LauncherThread::GetMessageLoop();
+#endif
         if (redirect_nonUInonIO_browser_threads) {
           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:
@@ skipping 34 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));

[gab, 2017/03/29 17:19:53]

This will alter shutdown behavior of PROCESS_LAUNCHER thread on Android. When
BrowserThreadImpl is passed an external message loop, it no longer joins
remaining tasks on shutdown [1] as Thread::Stop() no-ops (2). This might not be
a problem but something you should be aware of and document in this CL's
description. FWIW, I don't think joining process launch tasks is necessary, but
if the process launching code happens to be using anything registered on
AtExitManager (e.g. non-leaky Singleton/LazyInstances), it's possible you get
use-after-frees if your custom background thread uses those after Chrome's main
thread has unwound (so once again, document that in CL description so it's easy
to come back to this if crashes start popping up -- do we even have a crash
dashboard for Android?)

[1]
https://cs.chromium.org/chromium/src/content/browser/browser_thread_impl.cc?t...

[2]
https://cs.chromium.org/chromium/src/base/threading/thread.cc?type=cs&q=using...

[boliu, 2017/03/29 18:02:39]

Noted. Thankfully, android never does clean shutdown, so don't need to think
about this too much. Added comments though

       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