Allow ChildThreadImpl subclasses to manually start MojoShellConnection

content/renderer/render_thread_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_thread_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <map>
 #include <utility>
@@ skipping 593 matching lines @@
   return lazy_tls.Pointer()->Get();
 }
 
 RenderThreadImpl::RenderThreadImpl(
     const InProcessChildThreadParams& params,
     std::unique_ptr<scheduler::RendererScheduler> scheduler,
     scoped_refptr<base::SingleThreadTaskRunner>& resource_task_queue)
     : ChildThreadImpl(Options::Builder()
                           .InBrowserProcess(params)
                           .UseMojoChannel(true)
+                          .AutoStartMojoShellConnection(false)
                           .Build()),
       renderer_scheduler_(std::move(scheduler)),
       categorized_worker_pool_(new CategorizedWorkerPool()) {
   Init(resource_task_queue);
 }
 
 // When we run plugins in process, we actually run them on the render thread,
 // which means that we need to make the render thread pump UI events.
 RenderThreadImpl::RenderThreadImpl(
     std::unique_ptr<base::MessageLoop> main_message_loop,
     std::unique_ptr<scheduler::RendererScheduler> scheduler)
-    : ChildThreadImpl(Options::Builder().UseMojoChannel(true).Build()),
+    : ChildThreadImpl(Options::Builder()
+                          .UseMojoChannel(true)
+                          .AutoStartMojoShellConnection(false)
+                          .Build()),
       renderer_scheduler_(std::move(scheduler)),
       main_message_loop_(std::move(main_message_loop)),
       categorized_worker_pool_(new CategorizedWorkerPool()) {
   scoped_refptr<base::SingleThreadTaskRunner> test_task_counter;
   Init(test_task_counter);
 }
 
 void RenderThreadImpl::Init(
     scoped_refptr<base::SingleThreadTaskRunner>& resource_task_queue) {
   TRACE_EVENT0("startup", "RenderThreadImpl::Init");
@@ skipping 83 matching lines @@
 
   midi_message_filter_ = new MidiMessageFilter(GetIOTaskRunner());
   AddFilter(midi_message_filter_.get());
 
   AddFilter((new IndexedDBMessageFilter(thread_safe_sender()))->GetFilter());
 
   AddFilter((new CacheStorageMessageFilter(thread_safe_sender()))->GetFilter());
 
   AddFilter((new ServiceWorkerContextMessageFilter())->GetFilter());
 
+#if defined(MOJO_SHELL_CLIENT) && defined(USE_AURA)
+  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kUseMusInRenderer)) {
+    CreateRenderWidgetWindowTreeClientFactory(GetMojoShellConnection());
+  }
+#endif
+
+  // Must be called before RenderThreadStarted() below.
+  StartMojoShellConnection();
+
   GetContentClient()->renderer()->RenderThreadStarted();
 
   InitSkiaEventTracer();
   base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider(
       skia::SkiaMemoryDumpProvider::GetInstance(), "Skia", nullptr);
 
   const base::CommandLine& command_line =
       *base::CommandLine::ForCurrentProcess();
 
 #if defined(ENABLE_IPC_FUZZER)
@@ skipping 241 matching lines @@
   ChildThreadImpl::ShutdownDiscardableSharedMemoryManager();
 
   // The message loop must be cleared after shutting down
   // the DiscardableSharedMemoryManager, which needs to send messages
   // to the browser process.
   main_message_loop_.reset();
 
   lazy_tls.Pointer()->Set(nullptr);
 }
 
-void RenderThreadImpl::AddConnectionFilters(MojoShellConnection* connection) {
-#if defined(MOJO_SHELL_CLIENT) && defined(USE_AURA)
-  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kUseMusInRenderer)) {
-    CreateRenderWidgetWindowTreeClientFactory(connection);
-  }
-#endif
-}
-
 bool RenderThreadImpl::Send(IPC::Message* msg) {
   // There are cases where we want to pump asynchronous messages while waiting
   // synchronously for the replies to the message to be sent here. However, this
   // may create an opportunity for re-entrancy into WebKit and other subsystems,
   // so we need to take care to disable callbacks, timers, and pending network
   // loads that could trigger such callbacks.
   bool pumping_events = false;
   if (msg->is_sync()) {
     if (msg->is_caller_pumping_messages()) {
       pumping_events = true;
@@ skipping 1232 matching lines @@
       v8_memory_pressure_level == v8::MemoryPressureLevel::kCritical)
     v8_memory_pressure_level = v8::MemoryPressureLevel::kModerate;
 
   blink::mainThreadIsolate()->MemoryPressureNotification(
       v8_memory_pressure_level);
   blink::MemoryPressureNotificationToWorkerThreadIsolates(
       v8_memory_pressure_level);
 }
 
 }  // namespace content