Rename a bunch of Mojo Application stuff to reference Services.

content/browser/renderer_host/render_process_host_impl.cc

 // Copyright 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.
 
 // Represents the browser side of the browser <--> renderer communication
 // channel. There will be one RenderProcessHost per renderer process.
 
 #include "content/browser/renderer_host/render_process_host_impl.h"
 
 #include <algorithm>
@@ skipping 111 matching lines @@
 #include "content/browser/streams/stream_context.h"
 #include "content/browser/tracing/trace_message_filter.h"
 #include "content/browser/websockets/websocket_manager.h"
 #include "content/browser/webui/web_ui_controller_factory_registry.h"
 #include "content/common/child_process_host_impl.h"
 #include "content/common/child_process_messages.h"
 #include "content/common/content_switches_internal.h"
 #include "content/common/frame_messages.h"
 #include "content/common/gpu_host_messages.h"
 #include "content/common/in_process_child_thread_params.h"
-#include "content/common/mojo/mojo_child_connection.h"
-#include "content/common/mojo/mojo_shell_connection_impl.h"
 #include "content/common/render_process_messages.h"
 #include "content/common/resource_messages.h"
+#include "content/common/service_manager/child_connection.h"
+#include "content/common/service_manager/service_manager_connection_impl.h"
 #include "content/common/site_isolation_policy.h"
 #include "content/common/view_messages.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_process_host_factory.h"
 #include "content/public/browser/render_process_host_observer.h"
 #include "content/public/browser/render_widget_host.h"
@@ skipping 360 matching lines @@
 
   void Detach() {
     base::AutoLock lock(lock_);
     filter_ = nullptr;
   }
 
   base::Lock lock_;
   ConnectionFilterImpl* filter_;
 };
 
-// Held by the RPH's BrowserContext's MojoShellConnection, ownership transferred
-// back to RPH upon RPH destruction.
+// Held by the RPH's BrowserContext's ServiceManagerConnection, ownership
+// transferred back to RPH upon RPH destruction.
 class RenderProcessHostImpl::ConnectionFilterImpl : public ConnectionFilter {
  public:
   ConnectionFilterImpl(
       const shell::Identity& child_identity,
       std::unique_ptr<shell::InterfaceRegistry> registry)
       : child_identity_(child_identity),
         registry_(std::move(registry)),
         controller_(new ConnectionFilterController(this)),
         weak_factory_(this) {
     // Registration of this filter may race with browser shutdown, in which case
@@ skipping 221 matching lines @@
   IPC::AttachmentBrokerPrivileged::CreateBrokerIfNeeded(
       MachBroker::GetInstance());
 #else
   IPC::AttachmentBrokerPrivileged::CreateBrokerIfNeeded();
 #endif  // defined(OS_MACOSX)
 #endif  // USE_ATTACHMENT_BROKER
 
   scoped_refptr<base::SequencedTaskRunner> io_task_runner =
       BrowserThread::GetTaskRunnerForThread(BrowserThread::IO);
   shell::Connector* connector =
-      BrowserContext::GetShellConnectorFor(browser_context_);
+      BrowserContext::GetConnectorFor(browser_context_);
   // Some embedders may not initialize Mojo or the shell connector for a browser
   // context (e.g. Android WebView)... so just fall back to the per-process
   // connector.
   if (!connector) {
     // Additionally, some test code may not initialize the process-wide
-    // MojoShellConnection prior to this point. This class of test code doesn't
-    // care about render processes so we can initialize a dummy one.
-    if (!MojoShellConnection::GetForProcess()) {
+    // ServiceManagerConnection prior to this point. This class of test code
+    // doesn't care about render processes so we can initialize a dummy one.
+    if (!ServiceManagerConnection::GetForProcess()) {
       shell::mojom::ServiceRequest request = mojo::GetProxy(&test_service_);
-      MojoShellConnection::SetForProcess(MojoShellConnection::Create(
+      ServiceManagerConnection::SetForProcess(ServiceManagerConnection::Create(
           std::move(request), io_task_runner));
     }
-    connector = MojoShellConnection::GetForProcess()->GetConnector();
+    connector = ServiceManagerConnection::GetForProcess()->GetConnector();
   }
-  mojo_child_connection_.reset(new MojoChildConnection(
-      kRendererMojoApplicationName,
+  child_connection_.reset(new ChildConnection(
+      kRendererServiceName,
       base::StringPrintf("%d_%d", id_, instance_id_++), child_token_, connector,
       io_task_runner));
 }
 
 // static
 void RenderProcessHostImpl::ShutDownInProcessRenderer() {
   DCHECK(g_run_renderer_in_process_);
 
   switch (g_all_hosts.Pointer()->size()) {
     case 0:
@@ skipping 138 matching lines @@
     DCHECK(g_renderer_main_thread_factory);
     // Crank up a thread and run the initialization there.  With the way that
     // messages flow between the browser and renderer, this thread is required
     // to prevent a deadlock in single-process mode.  Since the primordial
     // thread in the renderer process runs the WebKit code and can sometimes
     // make blocking calls to the UI thread (i.e. this thread), they need to run
     // on separate threads.
     in_process_renderer_.reset(
         g_renderer_main_thread_factory(InProcessChildThreadParams(
             BrowserThread::GetTaskRunnerForThread(BrowserThread::IO),
-            mojo_child_connection_->service_token())));
+            child_connection_->service_token())));
 
     base::Thread::Options options;
 #if defined(OS_WIN) && !defined(OS_MACOSX)
     // In-process plugins require this to be a UI message loop.
     options.message_loop_type = base::MessageLoop::TYPE_UI;
 #else
     // We can't have multiple UI loops on Linux and Android, so we don't support
     // in-process plugins.
     options.message_loop_type = base::MessageLoop::TYPE_DEFAULT;
 #endif
@@ skipping 340 matching lines @@
 
   // This is to support usage of WebSockets in cases in which there is no
   // associated RenderFrame (e.g., Shared Workers).
   AddUIThreadInterface(
       registry.get(), base::Bind(&WebSocketManager::CreateWebSocket, GetID(),
                                  MSG_ROUTING_NONE));
 
   GetContentClient()->browser()->ExposeInterfacesToRenderer(registry.get(),
                                                             this);
 
-  MojoShellConnection* mojo_shell_connection =
-      BrowserContext::GetMojoShellConnectionFor(browser_context_);
+  ServiceManagerConnection* service_manager_connection =
+      BrowserContext::GetServiceManagerConnectionFor(browser_context_);
   std::unique_ptr<ConnectionFilterImpl> connection_filter(
-      new ConnectionFilterImpl(mojo_child_connection_->child_identity(),
+      new ConnectionFilterImpl(child_connection_->child_identity(),
                                std::move(registry)));
   connection_filter_controller_ = connection_filter->controller();
-  connection_filter_id_ =
-      mojo_shell_connection->AddConnectionFilter(std::move(connection_filter));
+  connection_filter_id_ = service_manager_connection->AddConnectionFilter(
+      std::move(connection_filter));
 }
 
 void RenderProcessHostImpl::GetRoute(
     int32_t routing_id,
     mojom::AssociatedInterfaceProviderAssociatedRequest request) {
   DCHECK(request.is_pending());
   associated_interface_provider_bindings_.AddBinding(
       this, std::move(request),
       reinterpret_cast<void*>(static_cast<uintptr_t>(routing_id)));
 }
@@ skipping 20 matching lines @@
 int RenderProcessHostImpl::GetNextRoutingID() {
   return widget_helper_->GetNextRoutingID();
 }
 
 void RenderProcessHostImpl::ResumeDeferredNavigation(
     const GlobalRequestID& request_id) {
   widget_helper_->ResumeDeferredNavigation(request_id);
 }
 
 shell::InterfaceProvider* RenderProcessHostImpl::GetRemoteInterfaces() {
-  return mojo_child_connection_->GetRemoteInterfaces();
+  return child_connection_->GetRemoteInterfaces();
 }
 
 std::unique_ptr<base::SharedPersistentMemoryAllocator>
 RenderProcessHostImpl::TakeMetricsAllocator() {
   return std::move(metrics_allocator_);
 }
 
 const base::TimeTicks& RenderProcessHostImpl::GetInitTimeForNavigationMetrics()
     const {
   return init_time_;
@@ skipping 251 matching lines @@
     command_line->AppendSwitch(switches::kEnablePinch);
 
 #if defined(OS_WIN)
   command_line->AppendSwitchASCII(
       switches::kDeviceScaleFactor,
       base::DoubleToString(display::win::GetDPIScale()));
 #endif
 
   AppendCompositorCommandLineFlags(command_line);
 
-  command_line->AppendSwitchASCII(switches::kMojoApplicationChannelToken,
-                                  mojo_child_connection_->service_token());
+  command_line->AppendSwitchASCII(switches::kServiceRequestChannelToken,
+                                  child_connection_->service_token());
 }
 
 void RenderProcessHostImpl::PropagateBrowserCommandLineToRenderer(
     const base::CommandLine& browser_cmd,
     base::CommandLine* renderer_cmd) const {
   // Propagate the following switches to the renderer command line (along
   // with any associated values) if present in the browser command line.
   static const char* const kSwitchNames[] = {
     switches::kAgcStartupMinVolume,
     switches::kAecRefinedAdaptiveFilter,
@@ skipping 236 matching lines @@
   // Add kWaitForDebugger to let renderer process wait for a debugger.
   if (browser_cmd.HasSwitch(switches::kWaitForDebuggerChildren)) {
     // Look to pass-on the kWaitForDebugger flag.
     std::string value =
         browser_cmd.GetSwitchValueASCII(switches::kWaitForDebuggerChildren);
     if (value.empty() || value == switches::kRendererProcess) {
       renderer_cmd->AppendSwitch(switches::kWaitForDebugger);
     }
   }
 
-  DCHECK(mojo_child_connection_);
+  DCHECK(child_connection_);
   renderer_cmd->AppendSwitchASCII(switches::kPrimordialPipeToken,
-                                  mojo_child_connection_->service_token());
+                                  child_connection_->service_token());
 
 #if defined(OS_WIN) && !defined(OFFICIAL_BUILD)
   // Needed because we can't show the dialog from the sandbox. Don't pass
   // --no-sandbox in official builds because that would bypass the bad_flgs
   // prompt.
   if (renderer_cmd->HasSwitch(switches::kRendererStartupDialog) &&
       !renderer_cmd->HasSwitch(switches::kNoSandbox)) {
     renderer_cmd->AppendSwitch(switches::kNoSandbox);
   }
 #endif
@@ skipping 271 matching lines @@
         RenderProcessExited(this, base::TERMINATION_STATUS_NORMAL_TERMINATION,
                             0));
   }
   FOR_EACH_OBSERVER(RenderProcessHostObserver, observers_,
                     RenderProcessHostDestroyed(this));
   NotificationService::current()->Notify(
       NOTIFICATION_RENDERER_PROCESS_TERMINATED,
       Source<RenderProcessHost>(this), NotificationService::NoDetails());
 
   if (connection_filter_id_ !=
-        MojoShellConnection::kInvalidConnectionFilterId) {
-    MojoShellConnection* mojo_shell_connection =
-        BrowserContext::GetMojoShellConnectionFor(browser_context_);
+        ServiceManagerConnection::kInvalidConnectionFilterId) {
+    ServiceManagerConnection* service_manager_connection =
+        BrowserContext::GetServiceManagerConnectionFor(browser_context_);
     connection_filter_controller_->DisableFilter();
-    mojo_shell_connection->RemoveConnectionFilter(connection_filter_id_);
-    connection_filter_id_ = MojoShellConnection::kInvalidConnectionFilterId;
+    service_manager_connection->RemoveConnectionFilter(connection_filter_id_);
+    connection_filter_id_ =
+        ServiceManagerConnection::kInvalidConnectionFilterId;
   }
 
 #ifndef NDEBUG
   is_self_deleted_ = true;
 #endif
   base::ThreadTaskRunnerHandle::Get()->DeleteSoon(FROM_HERE, this);
   deleting_soon_ = true;
 
 #if USE_ATTACHMENT_BROKER
   IPC::AttachmentBroker::GetGlobal()->DeregisterCommunicationChannel(
@@ skipping 510 matching lines @@
   RemoveUserData(kRendererInterfaceKeyName);
 
   UpdateProcessPriority();
   DCHECK(!is_process_backgrounded_);
 
   // RenderProcessExited observers and RenderProcessGone handlers might
   // navigate or perform other actions that require a connection. Ensure that
   // there is one before calling them.
   child_token_ = mojo::edk::GenerateRandomToken();
   shell::Connector* connector =
-      BrowserContext::GetShellConnectorFor(browser_context_);
+      BrowserContext::GetConnectorFor(browser_context_);
   if (!connector)
-    connector = MojoShellConnection::GetForProcess()->GetConnector();
-  mojo_child_connection_.reset(new MojoChildConnection(
-      kRendererMojoApplicationName,
+    connector = ServiceManagerConnection::GetForProcess()->GetConnector();
+  child_connection_.reset(new ChildConnection(
+      kRendererServiceName,
       base::StringPrintf("%d_%d", id_, instance_id_++), child_token_, connector,
       BrowserThread::GetTaskRunnerForThread(BrowserThread::IO)));
 
   within_process_died_observer_ = true;
   NotificationService::current()->Notify(
       NOTIFICATION_RENDERER_PROCESS_CLOSED, Source<RenderProcessHost>(this),
       Details<RendererClosedDetails>(&details));
   FOR_EACH_OBSERVER(RenderProcessHostObserver, observers_,
                     RenderProcessExited(this, status, exit_code));
   within_process_died_observer_ = false;
@@ skipping 123 matching lines @@
   if (child_process_launcher_) {
     DCHECK(child_process_launcher_->GetProcess().IsValid());
     DCHECK(!is_process_backgrounded_);
 
     // Unpause the channel now that the process is launched. We don't flush it
     // yet to ensure that any initialization messages sent here (e.g., things
     // done in response to NOTIFICATION_RENDER_PROCESS_CREATED; see below)
     // preempt already queued messages.
     channel_->Unpause(false /* flush */);
 
-    if (mojo_child_connection_) {
-      mojo_child_connection_->SetProcessHandle(
+    if (child_connection_) {
+      child_connection_->SetProcessHandle(
           child_process_launcher_->GetProcess().Handle());
     }
 
     // Not all platforms launch processes in the same backgrounded state. Make
     // sure |is_process_backgrounded_| reflects this platform's initial process
     // state.
     is_process_backgrounded_ =
         child_process_launcher_->GetProcess().IsProcessBackgrounded();
 
     // Disable updating process priority on startup for now as it incorrectly
@@ skipping 168 matching lines @@
   LOG(ERROR) << "Terminating render process for bad Mojo message: " << error;
 
   // The ReceivedBadMessage call below will trigger a DumpWithoutCrashing. Alias
   // enough information here so that we can determine what the bad message was.
   base::debug::Alias(&error);
   bad_message::ReceivedBadMessage(render_process_id,
                                   bad_message::RPH_MOJO_PROCESS_ERROR);
 }
 
 }  // namespace content