Rename shell namespace to 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 11 matching lines @@
 #include "mojo/public/cpp/bindings/binding.h"
 #include "mojo/public/cpp/bindings/binding_set.h"
 #include "services/service_manager/connect_util.h"
 #include "services/service_manager/public/cpp/connector.h"
 #include "services/service_manager/public/cpp/names.h"
 #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 shell {
+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";
@@ skipping 65 matching lines @@
 
 // Encapsulates a connection to an instance of a service, tracked by the
 // Service Manager.
 class ServiceManager::Instance
     : public mojom::Connector,
       public mojom::PIDReceiver,
       public Service,
       public InterfaceFactory<mojom::ServiceManager>,
       public mojom::ServiceManager {
  public:
-  Instance(shell::ServiceManager* service_manager,
+  Instance(service_manager::ServiceManager* service_manager,
            const Identity& identity,
            const CapabilitySpec& capability_spec)
       : service_manager_(service_manager),
         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() == kServiceManagerName ||
@@ skipping 123 matching lines @@
     DCHECK(source);
     if (HasClass(source->capability_spec_, kCapabilityClass_ServiceManager)) {
       registry->AddInterface<mojom::ServiceManager>(this);
       return true;
     }
     return false;
   }
 
  private:
   // mojom::Connector implementation:
-  void Connect(const shell::Identity& in_target,
+  void Connect(const service_manager::Identity& in_target,
                mojom::InterfaceProviderRequest remote_interfaces,
                mojom::ClientProcessConnectionPtr client_process_connection,
                const ConnectCallback& callback) override {
     Identity target = in_target;
     if (target.user_id() == mojom::kInheritUserID)
       target.set_user_id(identity_.user_id());
 
     if (!ValidateIdentity(target, callback))
       return;
     if (!ValidateClientProcessConnection(&client_process_connection, target,
@@ skipping 136 matching lines @@
 
   void PIDAvailable(base::ProcessId pid) {
     if (pid == base::kNullProcessId) {
       service_manager_->OnInstanceError(this);
       return;
     }
     pid_ = pid;
     service_manager_->NotifyPIDAvailable(identity_, pid_);
   }
 
-  void OnServiceLost(base::WeakPtr<shell::ServiceManager> service_manager) {
+  void OnServiceLost(
+      base::WeakPtr<service_manager::ServiceManager> service_manager) {
     service_.reset();
     OnConnectionLost(service_manager);
   }
 
-  void OnConnectionLost(base::WeakPtr<shell::ServiceManager> service_manager) {
+  void OnConnectionLost(
+      base::WeakPtr<service_manager::ServiceManager> service_manager) {
     // 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 (service_manager && !service_) {
       if (connectors_.empty())
         service_manager->OnInstanceError(this);
       else
         service_manager->OnInstanceUnreachable(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),
                      service_manager_->GetWeakPtr()));
     }
   }
 
   // Callback when NativeRunner completes.
   void OnRunnerCompleted() {
     if (!runner_.get())
       return;  // We're in the destructor.
 
     service_manager_->OnInstanceError(this);
   }
 
-  shell::ServiceManager* const service_manager_;
+  service_manager::ServiceManager* const service_manager_;
 
   // 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::ServicePtr service_;
@@ skipping 28 matching lines @@
 ServiceManager::ServiceManager(
     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(
-      "shell::mojom::ServiceManager");
+      "service_manager::mojom::ServiceManager");
   spec.required["*"].insert("shell:service_factory");
   spec.required["service:catalog"].insert("shell: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)
@@ skipping 63 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("shell::mojom::Resolver");
+  spec.provided["shell: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 58 matching lines @@
 
   // The catalog needs to see the source identity as that of the originating
   // app so it loads the correct store. Since the catalog is itself run as root
   // when this re-enters Connect() it'll be handled by
   // ConnectToExistingInstance().
   mojom::Resolver* resolver =
       GetResolver(Identity(kServiceManagerName, params->target().user_id()));
 
   std::string name = params->target().name();
   resolver->ResolveMojoName(
-      name, base::Bind(&shell::ServiceManager::OnGotResolvedName,
-                       weak_ptr_factory_.GetWeakPtr(), base::Passed(&params),
-                       base::Passed(&service), !!source_instance,
-                       source_instance));
+      name,
+      base::Bind(&service_manager::ServiceManager::OnGotResolvedName,
+                 weak_ptr_factory_.GetWeakPtr(), base::Passed(&params),
+                 base::Passed(&service), !!source_instance, source_instance));
 }
 
 ServiceManager::Instance* ServiceManager::GetExistingInstance(
     const Identity& identity) const {
   const auto& it = identity_to_instance_.find(identity);
   Instance* instance = it != identity_to_instance_.end() ? it->second : nullptr;
   if (instance)
     return instance;
 
   if (singletons_.find(identity.name()) != singletons_.end()) {
@@ skipping 73 matching lines @@
     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(kServiceManagerName, mojom::kInheritUserID);
   mojom::ServiceFactoryPtr factory;
   ConnectToInterface(this, source_identity, service_factory_identity,
                      &factory);
   mojom::ServiceFactory* factory_interface = factory.get();
-  factory.set_connection_error_handler(base::Bind(
-      &shell::ServiceManager::OnServiceFactoryLost,
-      weak_ptr_factory_.GetWeakPtr(), service_factory_identity));
+  factory.set_connection_error_handler(
+      base::Bind(&service_manager::ServiceManager::OnServiceFactoryLost,
+                 weak_ptr_factory_.GetWeakPtr(), service_factory_identity));
   service_factories_[service_factory_identity] = std::move(factory);
   return factory_interface;
 }
 
 void ServiceManager::OnServiceFactoryLost(const Identity& which) {
   // Remove the mapping.
   auto it = service_factories_.find(which);
   DCHECK(it != service_factories_.end());
   service_factories_.erase(it);
 }
@@ skipping 99 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 shell
+}  // namespace service_manager