Replace remaining shell references with service manager

services/service_manager/service_manager.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/service_manager/service_manager.h"
 
 #include <stdint.h>
 
 #include <utility>
 
@@ skipping 16 matching lines @@
 #include "services/service_manager/public/cpp/service_context.h"
 #include "services/service_manager/public/interfaces/connector.mojom.h"
 #include "services/service_manager/public/interfaces/service.mojom.h"
 #include "services/service_manager/public/interfaces/service_manager.mojom.h"
 
 namespace service_manager {
 
 namespace {
 
 const char kCatalogName[] = "service:catalog";
-const char kServiceManagerName[] = "service:shell";
-const char kCapabilityClass_UserID[] = "shell:user_id";
-const char kCapabilityClass_ClientProcess[] = "shell:client_process";
-const char kCapabilityClass_InstanceName[] = "shell:instance_name";
-const char kCapabilityClass_AllUsers[] = "shell:all_users";
-const char kCapabilityClass_ExplicitClass[] = "shell:explicit_class";
-const char kCapabilityClass_ServiceManager[] = "shell:service_manager";
+const char kServiceManagerName[] = "service:service_manager";
+const char kCapabilityClass_UserID[] = "service_manager:user_id";
+const char kCapabilityClass_ClientProcess[] = "service_manager:client_process";
+const char kCapabilityClass_InstanceName[] = "service_manager:instance_name";
+const char kCapabilityClass_AllUsers[] = "service_manager:all_users";
+const char kCapabilityClass_ExplicitClass[] = "service_manager:explicit_class";
+const char kCapabilityClass_ServiceManager[] =
+    "service_manager:service_manager";
 
 }  // namespace
 
 Identity CreateServiceManagerIdentity() {
   return Identity(kServiceManagerName, mojom::kRootUserID);
 }
 
 Identity CreateCatalogIdentity() {
   return Identity(kCatalogName, mojom::kRootUserID);
 }
@@ skipping 273 matching lines @@
 
   bool ValidateClientProcessConnection(
       mojom::ClientProcessConnectionPtr* client_process_connection,
       const Identity& target,
       const ConnectCallback& callback) {
     if (!client_process_connection->is_null()) {
       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 "
-                   << "service:shell{client_process} capability class.";
+                   << "service:service_manager{client_process} capability "
+                   << "class.";
         callback.Run(mojom::ConnectResult::ACCESS_DENIED,
                      mojom::kInheritUserID);
         return false;
       }
 
       if (!(*client_process_connection)->service.is_valid() ||
           !(*client_process_connection)->pid_receiver_request.is_valid()) {
         LOG(ERROR) << "Must supply both service AND "
                    << "pid_receiver_request when sending "
                    << "client_process_connection.";
@@ skipping 14 matching lines @@
   }
 
   bool ValidateCapabilities(const Identity& target,
                             const ConnectCallback& callback) {
     // TODO(beng): Need to do the following additional policy validation of
     // whether this instance is allowed to connect using:
     // - a non-null client_process_connection.
     if (target.user_id() != identity_.user_id() &&
         target.user_id() != mojom::kRootUserID &&
         !HasClass(capability_spec_, kCapabilityClass_UserID)) {
-      LOG(ERROR) << "Instance: " << identity_.name() << " running as: "
-                  << identity_.user_id() << " attempting to connect to: "
-                  << target.name() << " as: " << target.user_id() << " without "
-                  << " the service:shell{user_id} capability class.";
+      LOG(ERROR) << "Instance: " << identity_.name()
+                 << " running as: " << identity_.user_id()
+                 << " attempting to connect to: " << target.name()
+                 << " as: " << target.user_id() << " without "
+                 << " the service:service_manager{user_id} capability class.";
       callback.Run(mojom::ConnectResult::ACCESS_DENIED,
                    mojom::kInheritUserID);
       return false;
     }
     if (!target.instance().empty() &&
         target.instance() != GetNamePath(target.name()) &&
         !HasClass(capability_spec_, kCapabilityClass_InstanceName)) {
       LOG(ERROR) << "Instance: " << identity_.name() << " attempting to "
-                  << "connect to " << target.name() << " using Instance name: "
-                  << target.instance() << " without the "
-                  << "service:shell{instance_name} capability class.";
+                 << "connect to " << target.name()
+                 << " using Instance name: " << target.instance()
+                 << " without the "
+                 << "service:service_manager{instance_name} capability class.";
       callback.Run(mojom::ConnectResult::ACCESS_DENIED, mojom::kInheritUserID);
       return false;
 
     }
 
     if (allow_any_application_ ||
         capability_spec_.required.find(target.name()) !=
             capability_spec_.required.end()) {
       return true;
     }
@@ skipping 97 matching lines @@
     std::unique_ptr<NativeRunnerFactory> native_runner_factory,
     mojom::ServicePtr catalog)
     : native_runner_factory_(std::move(native_runner_factory)),
       weak_ptr_factory_(this) {
   mojom::ServicePtr service;
   mojom::ServiceRequest request = mojo::GetProxy(&service);
 
   CapabilitySpec spec;
   spec.provided[kCapabilityClass_ServiceManager].insert(
       "service_manager::mojom::ServiceManager");
-  spec.required["*"].insert("shell:service_factory");
-  spec.required["service:catalog"].insert("shell:resolver");
+  spec.required["*"].insert("service_manager:service_factory");
+  spec.required["service:catalog"].insert("service_manager:resolver");
 
   service_manager_instance_ =
       CreateInstance(Identity(), CreateServiceManagerIdentity(), spec);
   service_manager_instance_->StartWithService(std::move(service));
   singletons_.insert(kServiceManagerName);
   service_context_.reset(new ServiceContext(this, std::move(request)));
 
   if (catalog)
     InitCatalog(std::move(catalog));
 }
@@ skipping 61 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 // ServiceManager, private:
 
 void ServiceManager::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;
   spec.provided["app"].insert("filesystem::mojom::Directory");
   spec.provided["catalog:catalog"].insert("catalog::mojom::Catalog");
-  spec.provided["shell:resolver"].insert("service_manager::mojom::Resolver");
+  spec.provided["service_manager:resolver"].insert(
+      "service_manager::mojom::Resolver");
   spec.provided["control"].insert("catalog::mojom::CatalogControl");
   Instance* instance = CreateInstance(
       CreateServiceManagerIdentity(), CreateCatalogIdentity(), spec);
   singletons_.insert(kCatalogName);
   instance->StartWithService(std::move(catalog));
 }
 
 mojom::Resolver* ServiceManager::GetResolver(const Identity& identity) {
   auto iter = identity_to_resolver_.find(identity);
   if (iter != identity_to_resolver_.end())
@@ skipping 37 matching lines @@
   listeners_.ForAllPtrs([identity](mojom::ServiceManagerListener* listener) {
     listener->OnServiceStopped(identity);
   });
   if (!instance_quit_callback_.is_null())
     instance_quit_callback_.Run(identity);
 }
 
 void ServiceManager::Connect(std::unique_ptr<ConnectParams> params,
                              mojom::ServicePtr service,
                              base::WeakPtr<Instance> source_instance) {
-  TRACE_EVENT_INSTANT1("mojo_shell", "ServiceManager::Connect",
+  TRACE_EVENT_INSTANT1("service_manager", "ServiceManager::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(!service.is_bound() || !identity_to_instance_.count(params->target()));
 
   // Connect to an existing matching instance, if possible.
   if (!service.is_bound() && ConnectToExistingInstance(&params))
     return;
@@ skipping 220 matching lines @@
   // Now that the instance has a Service, we can connect to it.
   bool connected = instance->ConnectToService(&params);
   DCHECK(connected);
 }
 
 base::WeakPtr<ServiceManager> ServiceManager::GetWeakPtr() {
   return weak_ptr_factory_.GetWeakPtr();
 }
 
 }  // namespace service_manager