ShellClient -> Service

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 19 matching lines @@
 #include "mojo/edk/embedder/embedder.h"
 #include "mojo/public/cpp/bindings/interface_request.h"
 #include "mojo/public/cpp/bindings/string.h"
 #include "services/catalog/catalog.h"
 #include "services/catalog/manifest_provider.h"
 #include "services/catalog/store.h"
 #include "services/shell/connect_params.h"
 #include "services/shell/native_runner.h"
 #include "services/shell/public/cpp/connector.h"
 #include "services/shell/public/cpp/identity.h"
-#include "services/shell/public/cpp/shell_client.h"
+#include "services/shell/public/cpp/service.h"
 #include "services/shell/public/interfaces/connector.mojom.h"
-#include "services/shell/public/interfaces/shell_client.mojom.h"
-#include "services/shell/public/interfaces/shell_client_factory.mojom.h"
+#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>;
 
@@ skipping 25 matching lines @@
 }
 
 void OnApplicationLoaded(const std::string& name, bool success) {
   if (!success)
     LOG(ERROR) << "Failed to launch Mojo application for " << name;
 }
 
 void LaunchAppInUtilityProcess(const std::string& app_name,
                                const base::string16& process_name,
                                bool use_sandbox,
-                               shell::mojom::ShellClientRequest request) {
+                               shell::mojom::ServiceRequest request) {
   mojom::ProcessControlPtr process_control;
   mojom::ProcessControlRequest process_request =
       mojo::GetProxy(&process_control);
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
                           base::Bind(&StartUtilityProcessOnIOThread,
                                      base::Passed(&process_request),
                                      process_name, use_sandbox));
   process_control->LoadApplication(app_name, std::move(request),
                                    base::Bind(&OnApplicationLoaded, app_name));
 }
@@ skipping 14 matching lines @@
 
   // TODO(xhwang): It's possible that |process_host| is non-null, but the actual
   // process is dead. In that case, |request| will be dropped and application
   // load requests through mojom::ProcessControl will also fail. Make sure we
   // handle
   // these cases correctly.
   process_host->GetRemoteInterfaces()->GetInterface(std::move(request));
 }
 
 void LaunchAppInGpuProcess(const std::string& app_name,
-                           shell::mojom::ShellClientRequest request) {
+                           shell::mojom::ServiceRequest request) {
   mojom::ProcessControlPtr process_control;
   mojom::ProcessControlRequest process_request =
       mojo::GetProxy(&process_control);
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&RequestGpuProcessControl, base::Passed(&process_request)));
   process_control->LoadApplication(app_name, std::move(request),
                                    base::Bind(&OnApplicationLoaded, app_name));
 }
 
@@ skipping 120 matching lines @@
   manifest_provider_->AddManifestResource(kUtilityMojoApplicationName,
                                           IDR_MOJO_CONTENT_UTILITY_MANIFEST);
   manifest_provider_->AddManifestResource("mojo:catalog",
                                           IDR_MOJO_CATALOG_MANIFEST);
   manifest_provider_->AddManifestResource(user_service::kUserServiceName,
                                           IDR_MOJO_PROFILE_MANIFEST);
 
   catalog_.reset(new catalog::Catalog(file_task_runner.get(), nullptr,
                                       manifest_provider_.get()));
 
-  shell::mojom::ShellClientRequest request;
+  shell::mojom::ServiceRequest request;
   if (shell::ShellIsRemote()) {
     mojo::edk::SetParentPipeHandleFromCommandLine();
-    request = shell::GetShellClientRequestFromCommandLine();
+    request = shell::GetServiceRequestFromCommandLine();
   } else {
     shell_.reset(new shell::Shell(std::move(native_runner_factory),
-                                  catalog_->TakeShellClient()));
+                                  catalog_->TakeService()));
     request = shell_->InitInstanceForEmbedder(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)));
 
   ContentBrowserClient::StaticMojoApplicationMap apps;
   GetContentClient()->browser()->RegisterInProcessMojoApplications(&apps);
   for (const auto& entry : apps) {
     MojoShellConnection::GetForProcess()->AddEmbeddedService(entry.first,
                                                              entry.second);
   }
 
   ContentBrowserClient::OutOfProcessMojoApplicationMap sandboxed_apps;
   GetContentClient()
       ->browser()
       ->RegisterOutOfProcessMojoApplications(&sandboxed_apps);
   for (const auto& app : sandboxed_apps) {
-    MojoShellConnection::GetForProcess()->AddShellClientRequestHandler(
+    MojoShellConnection::GetForProcess()->AddServiceRequestHandler(
         app.first,
         base::Bind(&LaunchAppInUtilityProcess, app.first, app.second,
                    true /* use_sandbox */));
   }
 
   ContentBrowserClient::OutOfProcessMojoApplicationMap unsandboxed_apps;
   GetContentClient()
       ->browser()
       ->RegisterUnsandboxedOutOfProcessMojoApplications(&unsandboxed_apps);
   for (const auto& app : unsandboxed_apps) {
-    MojoShellConnection::GetForProcess()->AddShellClientRequestHandler(
+    MojoShellConnection::GetForProcess()->AddServiceRequestHandler(
         app.first,
         base::Bind(&LaunchAppInUtilityProcess, app.first, app.second,
                    false /* use_sandbox */));
   }
 
 #if (ENABLE_MOJO_MEDIA_IN_GPU_PROCESS)
-  MojoShellConnection::GetForProcess()->AddShellClientRequestHandler(
+  MojoShellConnection::GetForProcess()->AddServiceRequestHandler(
       "mojo:media", base::Bind(&LaunchAppInGpuProcess, "mojo:media"));
 #endif
 }
 
 MojoShellContext::~MojoShellContext() {
   if (MojoShellConnection::GetForProcess())
     MojoShellConnection::DestroyForProcess();
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
                           base::Bind(&DestroyConnectorOnIOThread));
   catalog_.reset();
@@ skipping 29 matching lines @@
   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);
   shell_->Connect(std::move(params));
 }
 
 }  // namespace content