Move content's shell connections to the IO thread

content/browser/mojo/mojo_shell_context.cc

 // Copyright 2015 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/mojo/mojo_shell_context.h"
 
 #include <unordered_map>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 31 matching lines @@
 #include "services/shell/public/interfaces/service.mojom.h"
 #include "services/shell/public/interfaces/service_factory.mojom.h"
 #include "services/shell/runner/common/client_util.h"
 #include "services/shell/runner/host/in_process_native_runner.h"
 #include "services/user/public/cpp/constants.h"
 
 namespace content {
 
 namespace {
 
-using ConnectorPtr = base::ThreadLocalPointer<shell::Connector>;
+base::LazyInstance<std::unique_ptr<shell::Connector>>::Leaky
+    g_io_thread_connector = LAZY_INSTANCE_INITIALIZER;
 
-base::LazyInstance<ConnectorPtr>::Leaky io_connector_tls_ptr =
-    LAZY_INSTANCE_INITIALIZER;
-
-void SetConnectorOnIOThread(std::unique_ptr<shell::Connector> connector) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  io_connector_tls_ptr.Pointer()->Set(connector.release());
-}
-
-void DestroyConnectorOnIOThread() {
-  delete MojoShellContext::GetConnectorForIOThread();
-  io_connector_tls_ptr.Pointer()->Set(nullptr);
-}
+void DestroyConnectorOnIOThread() { g_io_thread_connector.Get().reset(); }
 
 void StartUtilityProcessOnIOThread(
     mojo::InterfaceRequest<mojom::ProcessControl> request,
     const base::string16& process_name,
     bool use_sandbox) {
   UtilityProcessHost* process_host =
       UtilityProcessHost::Create(nullptr, nullptr);
   process_host->SetName(process_name);
   if (!use_sandbox)
     process_host->DisableSandbox();
@@ skipping 189 matching lines @@
   shell::mojom::ServiceRequest request;
   if (shell::ShellIsRemote()) {
     mojo::edk::SetParentPipeHandleFromCommandLine();
     request = shell::GetServiceRequestFromCommandLine();
   } else {
     service_manager_.reset(new shell::ServiceManager(
         std::move(native_runner_factory), catalog_->TakeService()));
     request =
         service_manager_->StartEmbedderService(kBrowserMojoApplicationName);
   }
-  MojoShellConnection::SetForProcess(
-      MojoShellConnection::Create(std::move(request)));
-
-  std::unique_ptr<shell::Connector> io_connector =
-      MojoShellConnection::GetForProcess()->GetConnector()->Clone();
-  BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE,
-      base::Bind(&SetConnectorOnIOThread, base::Passed(&io_connector)));
+  MojoShellConnection::SetForProcess(MojoShellConnection::Create(
+      std::move(request),
+      BrowserThread::GetTaskRunnerForThread(BrowserThread::IO)));
 
   ContentBrowserClient::StaticMojoApplicationMap apps;
   GetContentClient()->browser()->RegisterInProcessMojoApplications(&apps);
   for (const auto& entry : apps) {
     MojoShellConnection::GetForProcess()->AddEmbeddedService(entry.first,
                                                              entry.second);
   }
 
+  // This is safe to assign directly from any thread, because MojoShellContext
+  // must be constructed before anyone can call GetConnectorForIOThread().
+  g_io_thread_connector.Get() =
+      MojoShellConnection::GetForProcess()->GetConnector()->Clone();
+
+  MojoShellConnection::GetForProcess()->Start();
+
   ContentBrowserClient::OutOfProcessMojoApplicationMap sandboxed_apps;
   GetContentClient()
       ->browser()
       ->RegisterOutOfProcessMojoApplications(&sandboxed_apps);
   for (const auto& app : sandboxed_apps) {
     MojoShellConnection::GetForProcess()->AddServiceRequestHandler(
         app.first,
         base::Bind(&LaunchAppInUtilityProcess, app.first, app.second,
                    true /* use_sandbox */));
   }
@@ skipping 32 matching lines @@
     shell::mojom::InterfaceProviderPtr exposed_services,
     const shell::mojom::Connector::ConnectCallback& callback) {
   proxy_.Get()->ConnectToApplication(user_id, name, requestor_name,
                                      std::move(request),
                                      std::move(exposed_services), callback);
 }
 
 // static
 shell::Connector* MojoShellContext::GetConnectorForIOThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  return io_connector_tls_ptr.Pointer()->Get();
+  return g_io_thread_connector.Get().get();
 }
 
 void MojoShellContext::ConnectToApplicationOnOwnThread(
     const std::string& user_id,
     const std::string& name,
     const std::string& requestor_name,
     shell::mojom::InterfaceProviderRequest request,
     shell::mojom::InterfaceProviderPtr exposed_services,
     const shell::mojom::Connector::ConnectCallback& callback) {
   std::unique_ptr<shell::ConnectParams> params(new shell::ConnectParams);
   shell::Identity source_id(requestor_name, user_id);
   params->set_source(source_id);
   params->set_target(shell::Identity(name, user_id));
   params->set_remote_interfaces(std::move(request));
   params->set_local_interfaces(std::move(exposed_services));
   params->set_connect_callback(callback);
   service_manager_->Connect(std::move(params));
 }
 
 }  // namespace content