Move shell service to toplevel shell namespace

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 55 matching lines @@
 }
 
 void OnApplicationLoaded(const std::string& name, bool success) {
   if (!success)
     LOG(ERROR) << "Failed to launch Mojo application for " << name;
 }
 
 // This launches a utility process and forwards the Load request the
 // mojom::ProcessControl service there. The utility process is sandboxed iff
 // |use_sandbox| is true.
-class UtilityProcessLoader : public mojo::shell::Loader {
+class UtilityProcessLoader : public shell::Loader {
  public:
   UtilityProcessLoader(const base::string16& process_name, bool use_sandbox)
       : process_name_(process_name), use_sandbox_(use_sandbox) {}
   ~UtilityProcessLoader() override {}
 
  private:
-  // mojo::shell::Loader:
+  // shell::Loader:
   void Load(const std::string& name,
-            mojo::shell::mojom::ShellClientRequest request) override {
+            shell::mojom::ShellClientRequest request) override {
     mojom::ProcessControlPtr process_control;
     auto 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(name, std::move(request),
                                      base::Bind(&OnApplicationLoaded, name));
   }
 
@@ skipping 18 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->GetServiceRegistry()->ConnectToRemoteService(
       std::move(request));
 }
 
 // Forwards the load request to the GPU process.
-class GpuProcessLoader : public mojo::shell::Loader {
+class GpuProcessLoader : public shell::Loader {
  public:
   GpuProcessLoader() {}
   ~GpuProcessLoader() override {}
 
  private:
-  // mojo::shell::Loader:
+  // shell::Loader:
   void Load(const std::string& name,
-            mojo::shell::mojom::ShellClientRequest request) override {
+            shell::mojom::ShellClientRequest request) override {
     mojom::ProcessControlPtr process_control;
     auto process_request = mojo::GetProxy(&process_control);
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&RequestGpuProcessControl, base::Passed(&process_request)));
     process_control->LoadApplication(name, std::move(request),
                                      base::Bind(&OnApplicationLoaded, name));
   }
 
   DISALLOW_COPY_AND_ASSIGN(GpuProcessLoader);
@@ skipping 38 matching lines @@
   Proxy(MojoShellContext* shell_context)
       : shell_context_(shell_context),
         task_runner_(base::ThreadTaskRunnerHandle::Get()) {}
 
   ~Proxy() {}
 
   void ConnectToApplication(
       const std::string& user_id,
       const std::string& name,
       const std::string& requestor_name,
-      mojo::shell::mojom::InterfaceProviderRequest request,
-      mojo::shell::mojom::InterfaceProviderPtr exposed_services,
-      const mojo::shell::mojom::Connector::ConnectCallback& callback) {
+      shell::mojom::InterfaceProviderRequest request,
+      shell::mojom::InterfaceProviderPtr exposed_services,
+      const shell::mojom::Connector::ConnectCallback& callback) {
     if (task_runner_ == base::ThreadTaskRunnerHandle::Get()) {
       if (shell_context_) {
         shell_context_->ConnectToApplicationOnOwnThread(
             user_id, name, requestor_name, std::move(request),
             std::move(exposed_services), callback);
       }
     } else {
       // |shell_context_| outlives the main MessageLoop, so it's safe for it to
       // be unretained here.
       task_runner_->PostTask(
@@ skipping 19 matching lines @@
 void MojoShellContext::SetApplicationsForTest(
     const StaticApplicationMap* apps) {
   g_applications_for_test = apps;
 }
 
 MojoShellContext::MojoShellContext() {
   proxy_.Get().reset(new Proxy(this));
 
   scoped_refptr<base::SingleThreadTaskRunner> file_task_runner =
       BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE);
-  std::unique_ptr<mojo::shell::NativeRunnerFactory> native_runner_factory(
-      new mojo::shell::InProcessNativeRunnerFactory(
+  std::unique_ptr<shell::NativeRunnerFactory> native_runner_factory(
+      new shell::InProcessNativeRunnerFactory(
           BrowserThread::GetBlockingPool()));
 
   manifest_provider_.reset(new BuiltinManifestProvider);
   manifest_provider_->AddManifestResource(kBrowserMojoApplicationName,
                                           IDR_MOJO_CONTENT_BROWSER_MANIFEST);
   manifest_provider_->AddManifestResource(kRendererMojoApplicationName,
                                           IDR_MOJO_CONTENT_RENDERER_MANIFEST);
   manifest_provider_->AddManifestResource("mojo:catalog",
                                           IDR_MOJO_CATALOG_MANIFEST);
   manifest_provider_->AddManifestResource(user_service::kUserServiceName,
                                           IDR_MOJO_PROFILE_MANIFEST);
 
   catalog_.reset(new catalog::Factory(file_task_runner.get(), nullptr,
                                       manifest_provider_.get()));
-  shell_.reset(new mojo::shell::Shell(std::move(native_runner_factory),
-                                      catalog_->TakeShellClient()));
+  shell_.reset(new shell::Shell(std::move(native_runner_factory),
+                                catalog_->TakeShellClient()));
 
   StaticApplicationMap apps;
   GetContentClient()->browser()->RegisterInProcessMojoApplications(&apps);
   if (g_applications_for_test) {
     // Add testing apps to the map, potentially overwriting whatever the
     // browser client registered.
     for (const auto& entry : *g_applications_for_test)
       apps[entry.first] = entry.second;
   }
   for (const auto& entry : apps) {
@@ skipping 36 matching lines @@
 MojoShellContext::~MojoShellContext() {
   if (!IsRunningInMojoShell())
     MojoShellConnectionImpl::Destroy();
 }
 
 // static
 void MojoShellContext::ConnectToApplication(
     const std::string& user_id,
     const std::string& name,
     const std::string& requestor_name,
-    mojo::shell::mojom::InterfaceProviderRequest request,
-    mojo::shell::mojom::InterfaceProviderPtr exposed_services,
-    const mojo::shell::mojom::Connector::ConnectCallback& callback) {
+    shell::mojom::InterfaceProviderRequest request,
+    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);
 }
 
 void MojoShellContext::ConnectToApplicationOnOwnThread(
     const std::string& user_id,
     const std::string& name,
     const std::string& requestor_name,
-    mojo::shell::mojom::InterfaceProviderRequest request,
-    mojo::shell::mojom::InterfaceProviderPtr exposed_services,
-    const mojo::shell::mojom::Connector::ConnectCallback& callback) {
-  std::unique_ptr<mojo::shell::ConnectParams> params(
-      new mojo::shell::ConnectParams);
-  mojo::Identity source_id(requestor_name, user_id);
+    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(mojo::Identity(name, user_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