Rename a bunch of Mojo Application stuff to reference Services.

content/common/service_manager/service_manager_connection_impl.cc

 // Copyright 2016 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/common/mojo/mojo_shell_connection_impl.h"
+#include "content/common/service_manager/service_manager_connection_impl.h"
 
 #include <queue>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/lazy_instance.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/threading/thread_checker.h"
-#include "content/common/mojo/embedded_application_runner.h"
+#include "content/common/service_manager/embedded_service_runner.h"
 #include "content/public/common/connection_filter.h"
 #include "mojo/public/cpp/bindings/binding_set.h"
 #include "mojo/public/cpp/system/message_pipe.h"
 #include "services/shell/public/cpp/service.h"
 #include "services/shell/public/cpp/service_context.h"
 #include "services/shell/public/interfaces/service_factory.mojom.h"
 #include "services/shell/runner/common/client_util.h"
 
 namespace content {
 namespace {
 
-base::LazyInstance<std::unique_ptr<MojoShellConnection>>::Leaky
+base::LazyInstance<std::unique_ptr<ServiceManagerConnection>>::Leaky
     g_connection_for_process = LAZY_INSTANCE_INITIALIZER;
 
-MojoShellConnection::Factory* mojo_shell_connection_factory = nullptr;
+ServiceManagerConnection::Factory* service_manager_connection_factory = nullptr;
 
 }  // namespace
 
 // A ref-counted object which owns the IO thread state of a
-// MojoShellConnectionImpl. This includes Service and ServiceFactory
+// ServiceManagerConnectionImpl. This includes Service and ServiceFactory
 // bindings.
-class MojoShellConnectionImpl::IOThreadContext
+class ServiceManagerConnectionImpl::IOThreadContext
     : public base::RefCountedThreadSafe<IOThreadContext>,
       public shell::Service,
       public shell::InterfaceFactory<shell::mojom::ServiceFactory>,
       public shell::mojom::ServiceFactory {
  public:
   using InitializeCallback = base::Callback<void(const shell::Identity&)>;
   using ServiceFactoryCallback =
       base::Callback<void(shell::mojom::ServiceRequest, const std::string&)>;
 
   IOThreadContext(shell::mojom::ServiceRequest service_request,
@@ skipping 168 matching lines @@
     DCHECK(!initialize_handler_.is_null());
     id_ = identity;
 
     InitializeCallback handler = base::ResetAndReturn(&initialize_handler_);
     callback_task_runner_->PostTask(FROM_HERE, base::Bind(handler, identity));
   }
 
   bool OnConnect(const shell::Identity& remote_identity,
                  shell::InterfaceRegistry* registry) override {
     DCHECK(io_thread_checker_.CalledOnValidThread());
-    std::string remote_app = remote_identity.name();
-    if (remote_app == "service:shell") {
+    std::string remote_service = remote_identity.name();
+    if (remote_service == "service:shell") {
       // Only expose the SCF interface to the shell.
       registry->AddInterface<shell::mojom::ServiceFactory>(this);
       return true;
     }
 
     bool accept = false;
     {
       base::AutoLock lock(lock_);
       for (auto& entry : connection_filters_) {
         accept |= entry.second->OnConnect(remote_identity, registry,
@@ skipping 95 matching lines @@
   // Guards |connection_filters_|.
   base::Lock lock_;
   std::map<int, std::unique_ptr<ConnectionFilter>> connection_filters_;
 
   base::WeakPtrFactory<IOThreadContext> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(IOThreadContext);
 };
 
 ////////////////////////////////////////////////////////////////////////////////
-// MojoShellConnection, public:
+// ServiceManagerConnection, public:
 
 // static
-void MojoShellConnection::SetForProcess(
-    std::unique_ptr<MojoShellConnection> connection) {
+void ServiceManagerConnection::SetForProcess(
+    std::unique_ptr<ServiceManagerConnection> connection) {
   DCHECK(!g_connection_for_process.Get());
   g_connection_for_process.Get() = std::move(connection);
 }
 
 // static
-MojoShellConnection* MojoShellConnection::GetForProcess() {
+ServiceManagerConnection* ServiceManagerConnection::GetForProcess() {
   return g_connection_for_process.Get().get();
 }
 
 // static
-void MojoShellConnection::DestroyForProcess() {
-  // This joins the shell controller thread.
+void ServiceManagerConnection::DestroyForProcess() {
+  // This joins the service manager controller thread.
   g_connection_for_process.Get().reset();
 }
 
 // static
-void MojoShellConnection::SetFactoryForTest(Factory* factory) {
+void ServiceManagerConnection::SetFactoryForTest(Factory* factory) {
   DCHECK(!g_connection_for_process.Get());
-  mojo_shell_connection_factory = factory;
+  service_manager_connection_factory = factory;
 }
 
 // static
-std::unique_ptr<MojoShellConnection> MojoShellConnection::Create(
+std::unique_ptr<ServiceManagerConnection> ServiceManagerConnection::Create(
     shell::mojom::ServiceRequest request,
     scoped_refptr<base::SequencedTaskRunner> io_task_runner) {
-  if (mojo_shell_connection_factory)
-    return mojo_shell_connection_factory->Run();
-  return base::MakeUnique<MojoShellConnectionImpl>(
+  if (service_manager_connection_factory)
+    return service_manager_connection_factory->Run();
+  return base::MakeUnique<ServiceManagerConnectionImpl>(
       std::move(request), io_task_runner);
 }
 
-MojoShellConnection::~MojoShellConnection() {}
+ServiceManagerConnection::~ServiceManagerConnection() {}
 
 ////////////////////////////////////////////////////////////////////////////////
-// MojoShellConnectionImpl, public:
+// ServiceManagerConnectionImpl, public:
 
-MojoShellConnectionImpl::MojoShellConnectionImpl(
+ServiceManagerConnectionImpl::ServiceManagerConnectionImpl(
     shell::mojom::ServiceRequest request,
     scoped_refptr<base::SequencedTaskRunner> io_task_runner)
     : weak_factory_(this) {
   shell::mojom::ConnectorRequest connector_request;
   connector_ = shell::Connector::Create(&connector_request);
 
   std::unique_ptr<shell::Connector> io_thread_connector = connector_->Clone();
   context_ = new IOThreadContext(
       std::move(request), io_task_runner, std::move(io_thread_connector),
       std::move(connector_request));
 }
 
-MojoShellConnectionImpl::~MojoShellConnectionImpl() {
+ServiceManagerConnectionImpl::~ServiceManagerConnectionImpl() {
   context_->ShutDown();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// MojoShellConnectionImpl, MojoShellConnection implementation:
+// ServiceManagerConnectionImpl, ServiceManagerConnection implementation:
 
-void MojoShellConnectionImpl::Start() {
+void ServiceManagerConnectionImpl::Start() {
   context_->Start(
-      base::Bind(&MojoShellConnectionImpl::OnContextInitialized,
+      base::Bind(&ServiceManagerConnectionImpl::OnContextInitialized,
                  weak_factory_.GetWeakPtr()),
-      base::Bind(&MojoShellConnectionImpl::CreateService,
+      base::Bind(&ServiceManagerConnectionImpl::CreateService,
                  weak_factory_.GetWeakPtr()),
-      base::Bind(&MojoShellConnectionImpl::OnConnectionLost,
+      base::Bind(&ServiceManagerConnectionImpl::OnConnectionLost,
                  weak_factory_.GetWeakPtr()));
 }
 
-void MojoShellConnectionImpl::SetInitializeHandler(
+void ServiceManagerConnectionImpl::SetInitializeHandler(
     const base::Closure& handler) {
   DCHECK(initialize_handler_.is_null());
   initialize_handler_ = handler;
 }
 
-shell::Connector* MojoShellConnectionImpl::GetConnector() {
+shell::Connector* ServiceManagerConnectionImpl::GetConnector() {
   return connector_.get();
 }
 
-const shell::Identity& MojoShellConnectionImpl::GetIdentity() const {
+const shell::Identity& ServiceManagerConnectionImpl::GetIdentity() const {
   return identity_;
 }
 
-void MojoShellConnectionImpl::SetConnectionLostClosure(
+void ServiceManagerConnectionImpl::SetConnectionLostClosure(
     const base::Closure& closure) {
   connection_lost_handler_ = closure;
 }
 
-void MojoShellConnectionImpl::SetupInterfaceRequestProxies(
+void ServiceManagerConnectionImpl::SetupInterfaceRequestProxies(
     shell::InterfaceRegistry* registry,
     shell::InterfaceProvider* provider) {
   // It's safe to bind |registry| as a raw pointer because the caller must
   // guarantee that it outlives |this|, and |this| is bound as a weak ptr here.
   context_->SetDefaultBinderForBrowserConnection(
-      base::Bind(&MojoShellConnectionImpl::GetInterface,
+      base::Bind(&ServiceManagerConnectionImpl::GetInterface,
                  weak_factory_.GetWeakPtr(), registry));
 
   // TODO(beng): remove provider parameter.
 }
 
-int MojoShellConnectionImpl::AddConnectionFilter(
+int ServiceManagerConnectionImpl::AddConnectionFilter(
     std::unique_ptr<ConnectionFilter> filter) {
   return context_->AddConnectionFilter(std::move(filter));
 }
 
-void MojoShellConnectionImpl::RemoveConnectionFilter(int filter_id) {
+void ServiceManagerConnectionImpl::RemoveConnectionFilter(int filter_id) {
   context_->RemoveConnectionFilter(filter_id);
 }
 
-void MojoShellConnectionImpl::AddEmbeddedService(
-    const std::string& name,
-    const MojoApplicationInfo& info) {
-  std::unique_ptr<EmbeddedApplicationRunner> app(
-      new EmbeddedApplicationRunner(name, info));
+void ServiceManagerConnectionImpl::AddEmbeddedService(const std::string& name,
+                                                      const ServiceInfo& info) {
+  std::unique_ptr<EmbeddedServiceRunner> service(
+      new EmbeddedServiceRunner(name, info));
   AddServiceRequestHandler(
-      name, base::Bind(&EmbeddedApplicationRunner::BindServiceRequest,
-                       base::Unretained(app.get())));
-  auto result = embedded_apps_.insert(std::make_pair(name, std::move(app)));
+      name, base::Bind(&EmbeddedServiceRunner::BindServiceRequest,
+                       base::Unretained(service.get())));
+  auto result =
+      embedded_services_.insert(std::make_pair(name, std::move(service)));
   DCHECK(result.second);
 }
 
-void MojoShellConnectionImpl::AddServiceRequestHandler(
+void ServiceManagerConnectionImpl::AddServiceRequestHandler(
     const std::string& name,
     const ServiceRequestHandler& handler) {
   auto result = request_handlers_.insert(std::make_pair(name, handler));
   DCHECK(result.second);
 }
 
-void MojoShellConnectionImpl::CreateService(
+void ServiceManagerConnectionImpl::CreateService(
     shell::mojom::ServiceRequest request,
     const std::string& name) {
   auto it = request_handlers_.find(name);
   if (it != request_handlers_.end())
     it->second.Run(std::move(request));
 }
 
-void MojoShellConnectionImpl::OnContextInitialized(
+void ServiceManagerConnectionImpl::OnContextInitialized(
     const shell::Identity& identity) {
   identity_ = identity;
   if (!initialize_handler_.is_null())
     base::ResetAndReturn(&initialize_handler_).Run();
 }
 
-void MojoShellConnectionImpl::OnConnectionLost() {
+void ServiceManagerConnectionImpl::OnConnectionLost() {
   if (!connection_lost_handler_.is_null())
     connection_lost_handler_.Run();
 }
 
-void MojoShellConnectionImpl::GetInterface(
+void ServiceManagerConnectionImpl::GetInterface(
     shell::mojom::InterfaceProvider* provider,
     const std::string& interface_name,
     mojo::ScopedMessagePipeHandle request_handle) {
   provider->GetInterface(interface_name, std::move(request_handle));
 }
 
 }  // namespace content