Rename shell namespace to service_manager

content/browser/service_manager/service_manager_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/service_manager/service_manager_context.h"
 
 #include <memory>
 #include <string>
 #include <utility>
 
@@ skipping 25 matching lines @@
 #include "services/service_manager/public/cpp/service.h"
 #include "services/service_manager/public/interfaces/service.mojom.h"
 #include "services/service_manager/runner/common/client_util.h"
 #include "services/service_manager/runner/host/in_process_native_runner.h"
 #include "services/service_manager/service_manager.h"
 
 namespace content {
 
 namespace {
 
-base::LazyInstance<std::unique_ptr<shell::Connector>>::Leaky
+base::LazyInstance<std::unique_ptr<service_manager::Connector>>::Leaky
     g_io_thread_connector = LAZY_INSTANCE_INITIALIZER;
 
 void DestroyConnectorOnIOThread() { g_io_thread_connector.Get().reset(); }
 
-void StartUtilityProcessOnIOThread(shell::mojom::ServiceFactoryRequest request,
-                                   const base::string16& process_name,
-                                   bool use_sandbox) {
+void StartUtilityProcessOnIOThread(
+    service_manager::mojom::ServiceFactoryRequest 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();
   process_host->Start();
   process_host->GetRemoteInterfaces()->GetInterface(std::move(request));
 }
 
-void StartServiceInUtilityProcess(const std::string& service_name,
-                                  const base::string16& process_name,
-                                  bool use_sandbox,
-                                  shell::mojom::ServiceRequest request) {
-  shell::mojom::ServiceFactoryPtr service_factory;
+void StartServiceInUtilityProcess(
+    const std::string& service_name,
+    const base::string16& process_name,
+    bool use_sandbox,
+    service_manager::mojom::ServiceRequest request) {
+  service_manager::mojom::ServiceFactoryPtr service_factory;
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
                           base::Bind(&StartUtilityProcessOnIOThread,
                                      base::Passed(GetProxy(&service_factory)),
                                      process_name, use_sandbox));
   service_factory->CreateService(std::move(request), service_name);
 }
 
 #if (ENABLE_MOJO_MEDIA_IN_GPU_PROCESS)
 
-// Request shell::mojom::ServiceFactory from GPU process host. Must be called on
+// Request service_manager::mojom::ServiceFactory from GPU process host. Must be
+// called on
 // IO thread.
-void RequestGpuServiceFactory(shell::mojom::ServiceFactoryRequest request) {
+void RequestGpuServiceFactory(
+    service_manager::mojom::ServiceFactoryRequest request) {
   GpuProcessHost* process_host =
       GpuProcessHost::Get(GpuProcessHost::GPU_PROCESS_KIND_SANDBOXED);
   if (!process_host) {
     DLOG(ERROR) << "GPU process host not available.";
     return;
   }
 
   // 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 ServiceFactory will also fail. Make sure we handle
   // these cases correctly.
   process_host->GetRemoteInterfaces()->GetInterface(std::move(request));
 }
 
 void StartServiceInGpuProcess(const std::string& service_name,
-                              shell::mojom::ServiceRequest request) {
-  shell::mojom::ServiceFactoryPtr service_factory;
+                              service_manager::mojom::ServiceRequest request) {
+  service_manager::mojom::ServiceFactoryPtr service_factory;
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&RequestGpuServiceFactory,
                  base::Passed(GetProxy(&service_factory))));
   service_factory->CreateService(std::move(request), service_name);
 }
 
 #endif  // ENABLE_MOJO_MEDIA_IN_GPU_PROCESS
 
 // A ManifestProvider which resolves application names to builtin manifest
@@ skipping 23 matching lines @@
 };
 
 }  // namespace
 
 // State which lives on the IO thread and drives the ServiceManager.
 class ServiceManagerContext::InProcessServiceManagerContext
     : public base::RefCountedThreadSafe<InProcessServiceManagerContext> {
  public:
   InProcessServiceManagerContext() {}
 
-  shell::mojom::ServiceRequest Start(
+  service_manager::mojom::ServiceRequest Start(
       std::unique_ptr<BuiltinManifestProvider> manifest_provider) {
-    shell::mojom::ServicePtr embedder_service_proxy;
-    shell::mojom::ServiceRequest embedder_service_request =
+    service_manager::mojom::ServicePtr embedder_service_proxy;
+    service_manager::mojom::ServiceRequest embedder_service_request =
         mojo::GetProxy(&embedder_service_proxy);
-    shell::mojom::ServicePtrInfo embedder_service_proxy_info =
+    service_manager::mojom::ServicePtrInfo embedder_service_proxy_info =
         embedder_service_proxy.PassInterface();
     BrowserThread::GetTaskRunnerForThread(BrowserThread::IO)->PostTask(
         FROM_HERE,
         base::Bind(&InProcessServiceManagerContext::StartOnIOThread, this,
                    base::Passed(&manifest_provider),
                    base::Passed(&embedder_service_proxy_info)));
     return embedder_service_request;
   }
 
   void ShutDown() {
     BrowserThread::GetTaskRunnerForThread(BrowserThread::IO)->PostTask(
         FROM_HERE,
         base::Bind(&InProcessServiceManagerContext::ShutDownOnIOThread, this));
   }
 
  private:
   friend class base::RefCountedThreadSafe<InProcessServiceManagerContext>;
 
   ~InProcessServiceManagerContext() {}
 
   void StartOnIOThread(
       std::unique_ptr<BuiltinManifestProvider> manifest_provider,
-      shell::mojom::ServicePtrInfo embedder_service_proxy_info) {
+      service_manager::mojom::ServicePtrInfo embedder_service_proxy_info) {
     manifest_provider_ = std::move(manifest_provider);
 
     base::SequencedWorkerPool* blocking_pool = BrowserThread::GetBlockingPool();
-    std::unique_ptr<shell::NativeRunnerFactory> native_runner_factory(
-        new shell::InProcessNativeRunnerFactory(blocking_pool));
+    std::unique_ptr<service_manager::NativeRunnerFactory> native_runner_factory(
+        new service_manager::InProcessNativeRunnerFactory(blocking_pool));
     catalog_.reset(
         new catalog::Catalog(blocking_pool, nullptr, manifest_provider_.get()));
-    service_manager_.reset(new shell::ServiceManager(
+    service_manager_.reset(new service_manager::ServiceManager(
         std::move(native_runner_factory), catalog_->TakeService()));
 
-    shell::mojom::ServiceRequest request =
+    service_manager::mojom::ServiceRequest request =
         service_manager_->StartEmbedderService(kBrowserServiceName);
     mojo::FuseInterface(
         std::move(request), std::move(embedder_service_proxy_info));
   }
 
   void ShutDownOnIOThread() {
     service_manager_.reset();
     catalog_.reset();
     manifest_provider_.reset();
   }
 
   std::unique_ptr<BuiltinManifestProvider> manifest_provider_;
   std::unique_ptr<catalog::Catalog> catalog_;
-  std::unique_ptr<shell::ServiceManager> service_manager_;
+  std::unique_ptr<service_manager::ServiceManager> service_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(InProcessServiceManagerContext);
 };
 
 ServiceManagerContext::ServiceManagerContext() {
-  shell::mojom::ServiceRequest request;
-  if (shell::ShellIsRemote()) {
+  service_manager::mojom::ServiceRequest request;
+  if (service_manager::ServiceManagerIsRemote()) {
     mojo::edk::SetParentPipeHandleFromCommandLine();
-    request = shell::GetServiceRequestFromCommandLine();
+    request = service_manager::GetServiceRequestFromCommandLine();
   } else {
     std::unique_ptr<BuiltinManifestProvider> manifest_provider =
         base::MakeUnique<BuiltinManifestProvider>();
 
     static const struct ManifestInfo {
       const char* name;
       int resource_id;
     } kManifests[] = {
       { kBrowserServiceName, IDR_MOJO_CONTENT_BROWSER_MANIFEST },
       { kGpuServiceName, IDR_MOJO_CONTENT_GPU_MANIFEST },
@@ skipping 81 matching lines @@
   // which it may attempt to service by launching a new instance of the browser.
   if (in_process_context_)
     in_process_context_->ShutDown();
   if (ServiceManagerConnection::GetForProcess())
     ServiceManagerConnection::DestroyForProcess();
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
                           base::Bind(&DestroyConnectorOnIOThread));
 }
 
 // static
-shell::Connector* ServiceManagerContext::GetConnectorForIOThread() {
+service_manager::Connector* ServiceManagerContext::GetConnectorForIOThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   return g_io_thread_connector.Get().get();
 }
 
 }  // namespace content