Begin to wean child processes off reliance on a persistent service_manager::Connection to the brows…

content/child/child_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/child/child_thread_impl.h"
 
 #include <signal.h>
 #include <string>
 #include <utility>
 
@@ skipping 436 matching lines @@
     mojo::ScopedMessagePipeHandle handle =
         mojo::edk::CreateChildMessagePipe(service_request_token);
     DCHECK(handle.is_valid());
     service_manager_connection_ = ServiceManagerConnection::Create(
         mojo::MakeRequest<service_manager::mojom::Service>(std::move(handle)),
         GetIOTaskRunner());
 
     // When connect_to_browser is true, we obtain interfaces from the browser
     // process by connecting to it, rather than from the incoming interface
     // provider. Exposed interfaces are subject to manifest capability spec.
-    service_manager::InterfaceProvider* remote_interfaces = nullptr;
     if (options.connect_to_browser) {
       browser_connection_ =
           service_manager_connection_->GetConnector()->Connect(
               mojom::kBrowserServiceName);
-    } else {
-      remote_interfaces = GetRemoteInterfaces();
     }
 
     // TODO(rockot): Remove this once all child-to-browser interface connections
     // are made via a Connector rather than directly through an
     // InterfaceProvider, and all exposed interfaces are exposed via a
     // ConnectionFilter.
     service_manager_connection_->SetupInterfaceRequestProxies(
-        GetInterfaceRegistry(), remote_interfaces);
+        GetInterfaceRegistry(), nullptr);
   }
 
   sync_message_filter_ = channel_->CreateSyncMessageFilter();
   thread_safe_sender_ = new ThreadSafeSender(
       message_loop_->task_runner(), sync_message_filter_.get());
 
   resource_dispatcher_.reset(new ResourceDispatcher(
       this, message_loop()->task_runner()));
   file_system_dispatcher_.reset(new FileSystemDispatcher());
 
@@ skipping 18 matching lines @@
   channel_->AddFilter(service_worker_message_filter_->GetFilter());
 
   if (!IsInBrowserProcess()) {
     // In single process mode, browser-side tracing and memory will cover the
     // whole process including renderers.
     channel_->AddFilter(new tracing::ChildTraceMessageFilter(
         ChildProcess::current()->io_task_runner()));
     channel_->AddFilter(new ChildMemoryMessageFilter());
 
     memory_instrumentation::MemoryDumpManagerDelegateImpl::Config config(
-        GetRemoteInterfaces());
+        GetConnector(), mojom::kBrowserServiceName);
     auto delegate =
         base::MakeUnique<memory_instrumentation::MemoryDumpManagerDelegateImpl>(
             config);
     base::trace_event::MemoryDumpManager::GetInstance()->Initialize(
         std::move(delegate));
   }
 
   // In single process mode we may already have a power monitor,
   // also for some edge cases where there is no ServiceManagerConnection, we do
   // not create the power monitor.
@@ skipping 124 matching lines @@
 }
 
 service_manager::InterfaceRegistry* ChildThreadImpl::GetInterfaceRegistry() {
   if (!interface_registry_.get()) {
     interface_registry_ = base::MakeUnique<service_manager::InterfaceRegistry>(
         service_manager::mojom::kServiceManager_ConnectorSpec);
   }
   return interface_registry_.get();
 }
 
-service_manager::InterfaceProvider* ChildThreadImpl::GetRemoteInterfaces() {
-  if (browser_connection_)
-    return browser_connection_->GetRemoteInterfaces();
-
-  if (!remote_interfaces_.get())
-    remote_interfaces_.reset(new service_manager::InterfaceProvider);
-  return remote_interfaces_.get();
+service_manager::Connector* ChildThreadImpl::GetConnector() {
+  return service_manager_connection_->GetConnector();
 }
 
 const service_manager::ServiceInfo&
     ChildThreadImpl::GetChildServiceInfo() const {
   DCHECK(IsConnectedToBrowser());
   return child_info_;
 }
 
 const service_manager::ServiceInfo&
     ChildThreadImpl::GetBrowserServiceInfo() const {
@@ skipping 210 matching lines @@
   connected_to_browser_ = true;
   child_info_ = local_info;
   browser_info_ = remote_info;
 }
 
 bool ChildThreadImpl::IsInBrowserProcess() const {
   return static_cast<bool>(browser_process_io_runner_);
 }
 
 }  // namespace content