ShellClient -> Service

services/shell/shell.cc

 // Copyright 2014 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 "services/shell/shell.h"
 
 #include <stdint.h>
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/guid.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/process/process.h"
 #include "base/process/process_handle.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/trace_event/trace_event.h"
 #include "mojo/public/cpp/bindings/binding.h"
 #include "mojo/public/cpp/bindings/binding_set.h"
 #include "services/shell/connect_util.h"
 #include "services/shell/public/cpp/connector.h"
 #include "services/shell/public/cpp/names.h"
 #include "services/shell/public/cpp/shell_connection.h"
 #include "services/shell/public/interfaces/connector.mojom.h"
+#include "services/shell/public/interfaces/service.mojom.h"
 #include "services/shell/public/interfaces/shell.mojom.h"
-#include "services/shell/public/interfaces/shell_client.mojom.h"
 
 namespace shell {
 
 namespace {
 
 const char kCatalogName[] = "mojo:catalog";
 const char kShellName[] = "mojo:shell";
 const char kCapabilityClass_UserID[] = "shell:user_id";
 const char kCapabilityClass_ClientProcess[] = "shell:client_process";
 const char kCapabilityClass_InstanceName[] = "shell:instance_name";
@@ skipping 63 matching lines @@
   auto it = spec.required.find(kShellName);
   if (it == spec.required.end())
     return false;
   return it->second.classes.find(class_name) != it->second.classes.end();
 }
 
 // Encapsulates a connection to an instance of an application, tracked by the
 // shell's Shell.
 class Shell::Instance : public mojom::Connector,
                         public mojom::PIDReceiver,
-                        public ShellClient,
+                        public Service,
                         public InterfaceFactory<mojom::Shell>,
                         public mojom::Shell {
  public:
   Instance(shell::Shell* shell,
            const Identity& identity,
            const CapabilitySpec& capability_spec)
       : shell_(shell),
         id_(GenerateUniqueID()),
         identity_(identity),
         capability_spec_(capability_spec),
         allow_any_application_(capability_spec.required.count("*") == 1),
         pid_receiver_binding_(this),
         weak_factory_(this) {
     if (identity_.name() == kShellName || identity_.name() == kCatalogName)
       pid_ = base::Process::Current().Pid();
     DCHECK_NE(mojom::kInvalidInstanceID, id_);
   }
 
   ~Instance() override {
     if (parent_)
       parent_->RemoveChild(this);
     // |children_| will be modified during destruction.
     std::set<Instance*> children = children_;
     for (auto child : children)
       shell_->OnInstanceError(child);
 
     // Shutdown all bindings before we close the runner. This way the process
     // should see the pipes closed and exit, as well as waking up any potential
     // sync/WaitForIncomingResponse().
-    shell_client_.reset();
+    service_.reset();
     if (pid_receiver_binding_.is_bound())
       pid_receiver_binding_.Close();
     connectors_.CloseAllBindings();
     shell_bindings_.CloseAllBindings();
     // Release |runner_| so that if we are called back to OnRunnerCompleted()
     // we know we're in the destructor.
     std::unique_ptr<NativeRunner> runner = std::move(runner_);
     runner.reset();
   }
 
   Instance* parent() { return parent_; }
 
   void AddChild(Instance* child) {
     children_.insert(child);
     child->parent_ = this;
   }
 
   void RemoveChild(Instance* child) {
     auto it = children_.find(child);
     DCHECK(it != children_.end());
     children_.erase(it);
     child->parent_ = nullptr;
   }
 
   bool ConnectToClient(std::unique_ptr<ConnectParams>* connect_params) {
-    if (!shell_client_.is_bound())
+    if (!service_.is_bound())
       return false;
 
     std::unique_ptr<ConnectParams> params(std::move(*connect_params));
     if (!params->connect_callback().is_null()) {
         params->connect_callback().Run(mojom::ConnectResult::SUCCEEDED,
                                        identity_.user_id(), id_);
     }
     uint32_t source_id = mojom::kInvalidInstanceID;
     CapabilityRequest request;
     request.interfaces.insert("*");
     Instance* source = shell_->GetExistingInstance(params->source());
     if (source) {
       request = GenerateCapabilityRequestForConnection(
           source->capability_spec_, identity_, capability_spec_);
       source_id = source->id();
     }
 
     // The target has specified that sources must request one of its provided
     // classes instead of specifying a wild-card for interfaces.
     if (HasClass(capability_spec_, kCapabilityClass_ExplicitClass) &&
         (request.interfaces.count("*") != 0)) {
       request.interfaces.erase("*");
     }
 
-    shell_client_->AcceptConnection(
+    service_->OnConnect(
         mojom::Identity::From(params->source()), source_id,
         params->TakeRemoteInterfaces(), params->TakeLocalInterfaces(),
         mojom::CapabilityRequest::From(request), params->target().name());
 
     return true;
   }
 
-  void StartWithClient(mojom::ShellClientPtr client) {
-    CHECK(!shell_client_);
-    shell_client_ = std::move(client);
-    shell_client_.set_connection_error_handler(
-        base::Bind(&Instance::OnShellClientLost, base::Unretained(this),
+  void StartWithClient(mojom::ServicePtr client) {
+    CHECK(!service_);
+    service_ = std::move(client);
+    service_.set_connection_error_handler(
+        base::Bind(&Instance::OnServiceLost, base::Unretained(this),
                    shell_->GetWeakPtr()));
-    shell_client_->Initialize(mojom::Identity::From(identity_), id_,
-                              base::Bind(&Instance::OnInitializeResponse,
-                                         base::Unretained(this)));
+    service_->OnStart(mojom::Identity::From(identity_), id_,
+                      base::Bind(&Instance::OnInitializeResponse,
+                                 base::Unretained(this)));
   }
 
   void StartWithClientProcessConnection(
       mojom::ClientProcessConnectionPtr client_process_connection) {
-    mojom::ShellClientPtr client;
-    client.Bind(mojom::ShellClientPtrInfo(
-        std::move(client_process_connection->shell_client), 0));
+    mojom::ServicePtr client;
+    client.Bind(mojom::ServicePtrInfo(
+        std::move(client_process_connection->service), 0));
     pid_receiver_binding_.Bind(
         std::move(client_process_connection->pid_receiver_request));
     StartWithClient(std::move(client));
   }
 
   void StartWithFilePath(const base::FilePath& path) {
-    CHECK(!shell_client_);
+    CHECK(!service_);
     runner_ = shell_->native_runner_factory_->Create(path);
     bool start_sandboxed = false;
-    mojom::ShellClientPtr client = runner_->Start(
+    mojom::ServicePtr client = runner_->Start(
         path, identity_, start_sandboxed,
         base::Bind(&Instance::PIDAvailable, weak_factory_.GetWeakPtr()),
         base::Bind(&Instance::OnRunnerCompleted, weak_factory_.GetWeakPtr()));
     StartWithClient(std::move(client));
   }
 
   mojom::InstanceInfoPtr CreateInstanceInfo() const {
     mojom::InstanceInfoPtr info(mojom::InstanceInfo::New());
     info->id = id_;
     info->identity = mojom::Identity::From(identity_);
     info->pid = pid_;
     return info;
   }
 
   const CapabilitySpec& capability_spec() const {
     return capability_spec_;
   }
   const Identity& identity() const { return identity_; }
   uint32_t id() const { return id_; }
 
-  // ShellClient:
-  bool AcceptConnection(Connection* connection) override {
+  // Service:
+  bool OnConnect(Connection* connection) override {
     connection->AddInterface<mojom::Shell>(this);
     return true;
   }
 
  private:
   // mojom::Connector implementation:
   void Connect(mojom::IdentityPtr target_ptr,
                mojom::InterfaceProviderRequest remote_interfaces,
                mojom::InterfaceProviderPtr local_interfaces,
                mojom::ClientProcessConnectionPtr client_process_connection,
@@ skipping 68 matching lines @@
       if (!HasClass(capability_spec_, kCapabilityClass_ClientProcess)) {
         LOG(ERROR) << "Instance: " << identity_.name() << " attempting "
                    << "to register an instance for a process it created for "
                    << "target: " << target.name() << " without the "
                    << "mojo:shell{client_process} capability class.";
         callback.Run(mojom::ConnectResult::ACCESS_DENIED,
                      mojom::kInheritUserID, mojom::kInvalidInstanceID);
         return false;
       }
 
-      if (!(*client_process_connection)->shell_client.is_valid() ||
+      if (!(*client_process_connection)->service.is_valid() ||
           !(*client_process_connection)->pid_receiver_request.is_valid()) {
-        LOG(ERROR) << "Must supply both shell_client AND "
+        LOG(ERROR) << "Must supply both service AND "
                    << "pid_receiver_request when sending "
                    << "client_process_connection.";
         callback.Run(mojom::ConnectResult::INVALID_ARGUMENT,
                      mojom::kInheritUserID, mojom::kInvalidInstanceID);
         return false;
       }
       if (shell_->GetExistingInstance(target)) {
         LOG(ERROR) << "Cannot client process matching existing identity:"
                    << "Name: " << target.name() << " User: "
                    << target.user_id() << " Instance: " << target.instance();
@@ skipping 55 matching lines @@
 
   void PIDAvailable(base::ProcessId pid) {
     if (pid == base::kNullProcessId) {
       shell_->OnInstanceError(this);
       return;
     }
     pid_ = pid;
     shell_->NotifyPIDAvailable(id_, pid_);
   }
 
-  void OnShellClientLost(base::WeakPtr<shell::Shell> shell) {
-    shell_client_.reset();
+  void OnServiceLost(base::WeakPtr<shell::Shell> shell) {
+    service_.reset();
     OnConnectionLost(shell);
   }
 
   void OnConnectionLost(base::WeakPtr<shell::Shell> shell) {
-    // Any time a Connector is lost or we lose the ShellClient connection, it
+    // Any time a Connector is lost or we lose the Service connection, it
     // may have been the last pipe using this Instance. If so, clean up.
-    if (shell && connectors_.empty() && !shell_client_) {
+    if (shell && connectors_.empty() && !service_) {
       // Deletes |this|.
       shell->OnInstanceError(this);
     }
   }
 
   void OnInitializeResponse(mojom::ConnectorRequest connector_request) {
     if (connector_request.is_pending()) {
       connectors_.AddBinding(this, std::move(connector_request));
       connectors_.set_connection_error_handler(
           base::Bind(&Instance::OnConnectionLost, base::Unretained(this),
@@ skipping 12 matching lines @@
   shell::Shell* const shell_;
 
   // An id that identifies this instance. Distinct from pid, as a single process
   // may vend multiple application instances, and this object may exist before a
   // process is launched.
   const uint32_t id_;
   const Identity identity_;
   const CapabilitySpec capability_spec_;
   const bool allow_any_application_;
   std::unique_ptr<NativeRunner> runner_;
-  mojom::ShellClientPtr shell_client_;
+  mojom::ServicePtr service_;
   mojo::Binding<mojom::PIDReceiver> pid_receiver_binding_;
   mojo::BindingSet<mojom::Connector> connectors_;
   mojo::BindingSet<mojom::Shell> shell_bindings_;
   base::ProcessId pid_ = base::kNullProcessId;
   Instance* parent_ = nullptr;
   std::set<Instance*> children_;
   base::WeakPtrFactory<Instance> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(Instance);
 };
 
 // static
 Shell::TestAPI::TestAPI(Shell* shell) : shell_(shell) {}
 Shell::TestAPI::~TestAPI() {}
 
 bool Shell::TestAPI::HasRunningInstanceForName(const std::string& name) const {
   for (const auto& entry : shell_->identity_to_instance_) {
     if (entry.first.name() == name)
       return true;
   }
   return false;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Shell, public:
 
 Shell::Shell(std::unique_ptr<NativeRunnerFactory> native_runner_factory,
-             mojom::ShellClientPtr catalog)
+             mojom::ServicePtr catalog)
     : native_runner_factory_(std::move(native_runner_factory)),
       weak_ptr_factory_(this) {
-  mojom::ShellClientPtr client;
-  mojom::ShellClientRequest request = mojo::GetProxy(&client);
+  mojom::ServicePtr client;
+  mojom::ServiceRequest request = mojo::GetProxy(&client);
   Instance* instance = CreateInstance(Identity(), CreateShellIdentity(),
                                       GetPermissiveCapabilities());
   instance->StartWithClient(std::move(client));
   singletons_.insert(kShellName);
   shell_connection_.reset(new ShellConnection(this, std::move(request)));
 
   if (catalog)
     InitCatalog(std::move(catalog));
 }
 
 Shell::~Shell() {
   TerminateShellConnections();
   // Terminate any remaining instances.
   while (!identity_to_instance_.empty())
     OnInstanceError(identity_to_instance_.begin()->second);
   identity_to_resolver_.clear();
 }
 
 void Shell::SetInstanceQuitCallback(
     base::Callback<void(const Identity&)> callback) {
   instance_quit_callback_ = callback;
 }
 
 void Shell::Connect(std::unique_ptr<ConnectParams> params) {
   Connect(std::move(params), nullptr);
 }
 
-mojom::ShellClientRequest Shell::InitInstanceForEmbedder(
+mojom::ServiceRequest Shell::InitInstanceForEmbedder(
     const std::string& name) {
   std::unique_ptr<ConnectParams> params(new ConnectParams);
 
   Identity embedder_identity(name, mojom::kRootUserID);
   params->set_source(embedder_identity);
   params->set_target(embedder_identity);
 
-  mojom::ShellClientPtr client;
-  mojom::ShellClientRequest request = mojo::GetProxy(&client);
+  mojom::ServicePtr client;
+  mojom::ServiceRequest request = mojo::GetProxy(&client);
   Connect(std::move(params), std::move(client));
 
   return request;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// Shell, ShellClient implementation:
+// Shell, Service implementation:
 
-bool Shell::AcceptConnection(Connection* connection) {
+bool Shell::OnConnect(Connection* connection) {
   // The only interface we expose is mojom::Shell, and access to this interface
   // is brokered by a policy specific to each caller, managed by the caller's
   // instance. Here we look to see who's calling, and forward to the caller's
   // instance to continue.
   Instance* instance = nullptr;
   for (const auto& entry : identity_to_instance_) {
     if (entry.second->id() == connection->GetRemoteInstanceID()) {
       instance = entry.second;
       break;
     }
   }
   DCHECK(instance);
-  return instance->AcceptConnection(connection);
+  return instance->OnConnect(connection);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Shell, private:
 
-void Shell::InitCatalog(mojom::ShellClientPtr catalog) {
+void Shell::InitCatalog(mojom::ServicePtr catalog) {
   // TODO(beng): It'd be great to build this from the manifest, however there's
   //             a bit of a chicken-and-egg problem.
   CapabilitySpec spec;
   Interfaces interfaces;
   interfaces.insert("filesystem::mojom::Directory");
   spec.provided["app"] = interfaces;
   Instance* instance = CreateInstance(CreateShellIdentity(),
                                       CreateCatalogIdentity(),
                                       spec);
   singletons_.insert(kCatalogName);
@@ skipping 27 matching lines @@
   identity_to_instance_.erase(it);
   instance_listeners_.ForAllPtrs([this, id](mojom::InstanceListener* listener) {
                                    listener->InstanceDestroyed(id);
                                  });
   delete instance;
   if (!instance_quit_callback_.is_null())
     instance_quit_callback_.Run(identity);
 }
 
 void Shell::Connect(std::unique_ptr<ConnectParams> params,
-                    mojom::ShellClientPtr client) {
+                    mojom::ServicePtr client) {
   TRACE_EVENT_INSTANT1("mojo_shell", "Shell::Connect",
                        TRACE_EVENT_SCOPE_THREAD, "original_name",
                        params->target().name());
   DCHECK(IsValidName(params->target().name()));
   DCHECK(base::IsValidGUID(params->target().user_id()));
   DCHECK_NE(mojom::kInheritUserID, params->target().user_id());
   DCHECK(!client.is_bound() || !identity_to_instance_.count(params->target()));
 
   // Connect to an existing matching instance, if possible.
   if (!client.is_bound() && ConnectToExistingInstance(&params))
@@ skipping 62 matching lines @@
 void Shell::AddInstanceListener(mojom::InstanceListenerPtr listener) {
   // TODO(beng): filter instances provided by those visible to this client.
   mojo::Array<mojom::InstanceInfoPtr> instances;
   for (auto& instance : identity_to_instance_)
     instances.push_back(instance.second->CreateInstanceInfo());
   listener->SetExistingInstances(std::move(instances));
 
   instance_listeners_.AddPtr(std::move(listener));
 }
 
-void Shell::CreateShellClientWithFactory(const Identity& shell_client_factory,
-                                         const std::string& name,
-                                         mojom::ShellClientRequest request) {
-  mojom::ShellClientFactory* factory =
-      GetShellClientFactory(shell_client_factory);
-  factory->CreateShellClient(std::move(request), name);
+void Shell::CreateServiceWithFactory(const Identity& service_factory,
+                                     const std::string& name,
+                                     mojom::ServiceRequest request) {
+  mojom::ServiceFactory* factory = GetServiceFactory(service_factory);
+  factory->CreateService(std::move(request), name);
 }
 
-mojom::ShellClientFactory* Shell::GetShellClientFactory(
-    const Identity& shell_client_factory_identity) {
-  auto it = shell_client_factories_.find(shell_client_factory_identity);
-  if (it != shell_client_factories_.end())
+mojom::ServiceFactory* Shell::GetServiceFactory(
+    const Identity& service_factory_identity) {
+  auto it = service_factories_.find(service_factory_identity);
+  if (it != service_factories_.end())
     return it->second.get();
 
   Identity source_identity(kShellName, mojom::kInheritUserID);
-  mojom::ShellClientFactoryPtr factory;
-  ConnectToInterface(this, source_identity, shell_client_factory_identity,
+  mojom::ServiceFactoryPtr factory;
+  ConnectToInterface(this, source_identity, service_factory_identity,
                      &factory);
-  mojom::ShellClientFactory* factory_interface = factory.get();
+  mojom::ServiceFactory* factory_interface = factory.get();
   factory.set_connection_error_handler(base::Bind(
-      &shell::Shell::OnShellClientFactoryLost, weak_ptr_factory_.GetWeakPtr(),
-      shell_client_factory_identity));
-  shell_client_factories_[shell_client_factory_identity] = std::move(factory);
+      &shell::Shell::OnServiceFactoryLost, weak_ptr_factory_.GetWeakPtr(),
+      service_factory_identity));
+  service_factories_[service_factory_identity] = std::move(factory);
   return factory_interface;
 }
 
-void Shell::OnShellClientFactoryLost(const Identity& which) {
+void Shell::OnServiceFactoryLost(const Identity& which) {
   // Remove the mapping.
-  auto it = shell_client_factories_.find(which);
-  DCHECK(it != shell_client_factories_.end());
-  shell_client_factories_.erase(it);
+  auto it = service_factories_.find(which);
+  DCHECK(it != service_factories_.end());
+  service_factories_.erase(it);
 }
 
 void Shell::OnGotResolvedName(std::unique_ptr<ConnectParams> params,
-                              mojom::ShellClientPtr client,
+                              mojom::ServicePtr client,
                               mojom::ResolveResultPtr result) {
   std::string instance_name = params->target().instance();
   if (instance_name == GetNamePath(params->target().name()) &&
       result->qualifier != GetNamePath(result->resolved_name)) {
     instance_name = result->qualifier;
   }
   Identity target(params->target().name(), params->target().user_id(),
                   instance_name);
   params->set_target(target);
 
@@ skipping 23 matching lines @@
   } else {
     source_identity_for_creation = params->source();
   }
 
   mojom::ClientProcessConnectionPtr client_process_connection =
       params->TakeClientProcessConnection();
   Instance* instance = CreateInstance(source_identity_for_creation,
                                       target, capabilities);
 
   // Below are various paths through which a new Instance can be bound to a
-  // ShellClient proxy.
+  // Service proxy.
   if (client.is_bound()) {
-    // If a ShellClientPtr was provided, there's no more work to do: someone
-    // is already holding a corresponding ShellClientRequest.
+    // If a ServicePtr was provided, there's no more work to do: someone
+    // is already holding a corresponding ServiceRequest.
     instance->StartWithClient(std::move(client));
   } else if (!client_process_connection.is_null()) {
     // Likewise if a ClientProcessConnection was given via Connect(), it
-    // provides the ShellClient proxy to use.
+    // provides the Service proxy to use.
     instance->StartWithClientProcessConnection(
         std::move(client_process_connection));
   } else {
-    // Otherwise we create a new ShellClient pipe.
-    mojom::ShellClientRequest request = GetProxy(&client);
+    // Otherwise we create a new Service pipe.
+    mojom::ServiceRequest request = GetProxy(&client);
     CHECK(!result->package_path.empty() && !result->capabilities.is_null());
 
     if (target.name() != result->resolved_name) {
       instance->StartWithClient(std::move(client));
       Identity factory(result->resolved_name, target.user_id(),
                        instance_name);
-      CreateShellClientWithFactory(factory, target.name(),
+      CreateServiceWithFactory(factory, target.name(),
                                    std::move(request));
     } else {
       instance->StartWithFilePath(result->package_path);
     }
   }
 
-  // Now that the instance has a ShellClient, we can connect to it.
+  // Now that the instance has a Service, we can connect to it.
   bool connected = instance->ConnectToClient(&params);
   DCHECK(connected);
 }
 
 base::WeakPtr<Shell> Shell::GetWeakPtr() {
   return weak_ptr_factory_.GetWeakPtr();
 }
 
 }  // namespace shell