Rename MojoShellContext -> ServiceManagerContext.

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/mojo/mojo_shell_context.h"
+#include "content/browser/service_manager/service_manager_context.h"
 
 #include <memory>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/json/json_reader.h"
 #include "base/lazy_instance.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
 #include "content/browser/gpu/gpu_process_host.h"
-#include "content/browser/mojo/merge_dictionary.h"
+#include "content/browser/service_manager/merge_dictionary.h"
 #include "content/common/mojo/mojo_shell_connection_impl.h"
 #include "content/grit/content_resources.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/utility_process_host.h"
 #include "content/public/browser/utility_process_host_client.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/mojo_shell_connection.h"
 #include "content/public/common/service_names.h"
 #include "mojo/edk/embedder/embedder.h"
@@ skipping 96 matching lines @@
   }
 
   std::map<std::string, std::unique_ptr<base::Value>> manifests_;
 
   DISALLOW_COPY_AND_ASSIGN(BuiltinManifestProvider);
 };
 
 }  // namespace
 
 // State which lives on the IO thread and drives the ServiceManager.
-class MojoShellContext::InProcessServiceManagerContext
+class ServiceManagerContext::InProcessServiceManagerContext
     : public base::RefCountedThreadSafe<InProcessServiceManagerContext> {
  public:
   InProcessServiceManagerContext() {}
 
   shell::mojom::ServiceRequest Start(
       std::unique_ptr<BuiltinManifestProvider> manifest_provider) {
     shell::mojom::ServicePtr embedder_service_proxy;
     shell::mojom::ServiceRequest embedder_service_request =
         mojo::GetProxy(&embedder_service_proxy);
     shell::mojom::ServicePtrInfo embedder_service_proxy_info =
@@ skipping 42 matching lines @@
     manifest_provider_.reset();
   }
 
   std::unique_ptr<BuiltinManifestProvider> manifest_provider_;
   std::unique_ptr<catalog::Catalog> catalog_;
   std::unique_ptr<shell::ServiceManager> service_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(InProcessServiceManagerContext);
 };
 
-MojoShellContext::MojoShellContext() {
+ServiceManagerContext::ServiceManagerContext() {
   shell::mojom::ServiceRequest request;
   if (shell::ShellIsRemote()) {
     mojo::edk::SetParentPipeHandleFromCommandLine();
     request = shell::GetServiceRequestFromCommandLine();
   } else {
     std::unique_ptr<BuiltinManifestProvider> manifest_provider =
         base::MakeUnique<BuiltinManifestProvider>();
 
     static const struct ManifestInfo {
       const char* name;
@@ skipping 35 matching lines @@
       std::move(request),
       BrowserThread::GetTaskRunnerForThread(BrowserThread::IO)));
 
   ContentBrowserClient::StaticMojoApplicationMap apps;
   GetContentClient()->browser()->RegisterInProcessMojoApplications(&apps);
   for (const auto& entry : apps) {
     MojoShellConnection::GetForProcess()->AddEmbeddedService(entry.first,
                                                              entry.second);
   }
 
-  // This is safe to assign directly from any thread, because MojoShellContext
-  // must be constructed before anyone can call GetConnectorForIOThread().
+  // This is safe to assign directly from any thread, because
+  // ServiceManagerContext must be constructed before anyone can call
+  // GetConnectorForIOThread().
   g_io_thread_connector.Get() =
       MojoShellConnection::GetForProcess()->GetConnector()->Clone();
 
   MojoShellConnection::GetForProcess()->Start();
 
   ContentBrowserClient::OutOfProcessMojoApplicationMap sandboxed_apps;
   GetContentClient()
       ->browser()
       ->RegisterOutOfProcessMojoApplications(&sandboxed_apps);
   for (const auto& app : sandboxed_apps) {
@@ skipping 13 matching lines @@
         base::Bind(&StartServiceInUtilityProcess, app.first, app.second,
                    false /* use_sandbox */));
   }
 
 #if (ENABLE_MOJO_MEDIA_IN_GPU_PROCESS)
   MojoShellConnection::GetForProcess()->AddServiceRequestHandler(
       "service:media", base::Bind(&StartServiceInGpuProcess, "service:media"));
 #endif
 }
 
-MojoShellContext::~MojoShellContext() {
+ServiceManagerContext::~ServiceManagerContext() {
   // NOTE: The in-process ServiceManager MUST be destroyed before the browser
   // process-wide MojoShellConnection. Otherwise it's possible for the
   // ServiceManager to receive connection requests for service:content_browser
   // which it may attempt to service by launching a new instance of the browser.
   if (in_process_context_)
     in_process_context_->ShutDown();
   if (MojoShellConnection::GetForProcess())
     MojoShellConnection::DestroyForProcess();
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
                           base::Bind(&DestroyConnectorOnIOThread));
 }
 
 // static
-shell::Connector* MojoShellContext::GetConnectorForIOThread() {
+shell::Connector* ServiceManagerContext::GetConnectorForIOThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   return g_io_thread_connector.Get().get();
 }
 
 }  // namespace content