Rename shell namespace to service_manager

services/catalog/catalog.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 "services/catalog/catalog.h"
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/ptr_util.h"
@@ skipping 32 matching lines @@
       base::StartsWith(path, "service:", base::CompareCase::INSENSITIVE_ASCII);
   const bool is_exe =
       !is_service &&
       base::StartsWith(path, "exe:", base::CompareCase::INSENSITIVE_ASCII);
   if (!is_service && !is_exe)
     return base::FilePath();
   if (path.find('.') != std::string::npos)
     return base::FilePath();
   if (is_service) {
     path.erase(path.begin(),
-      path.begin() + strlen(shell::kNameType_Service) + 1);
+               path.begin() + strlen(service_manager::kNameType_Service) + 1);
   } else {
-    path.erase(path.begin(), path.begin() + strlen(shell::kNameType_Exe) + 1);
+    path.erase(path.begin(),
+               path.begin() + strlen(service_manager::kNameType_Exe) + 1);
   }
   base::TrimString(path, "/", &path);
   size_t end_of_name = path.find('/');
   if (end_of_name != std::string::npos)
     path.erase(path.begin() + end_of_name, path.end());
 
   if (!IsPathNameValid(path))
     return base::FilePath();
 
   base::FilePath base_path;
@@ skipping 21 matching lines @@
   ScanSystemPackageDir();
 }
 
 Catalog::~Catalog() {}
 
 void Catalog::OverridePackageName(const std::string& service_name,
                                   const std::string& package_name) {
   system_reader_->OverridePackageName(service_name, package_name);
 }
 
-shell::mojom::ServicePtr Catalog::TakeService() {
+service_manager::mojom::ServicePtr Catalog::TakeService() {
   return std::move(service_);
 }
 
 Catalog::Catalog(std::unique_ptr<Store> store)
     : store_(std::move(store)), weak_factory_(this) {
-  shell::mojom::ServiceRequest request = GetProxy(&service_);
-  shell_connection_.reset(new shell::ServiceContext(this, std::move(request)));
+  service_manager::mojom::ServiceRequest request = GetProxy(&service_);
+  service_manager_connection_.reset(
+      new service_manager::ServiceContext(this, std::move(request)));
 }
 
 void Catalog::ScanSystemPackageDir() {
   base::FilePath system_package_dir;
   PathService::Get(base::DIR_MODULE, &system_package_dir);
   system_package_dir = system_package_dir.AppendASCII(kPackagesDirName);
   system_reader_->Read(system_package_dir, &system_cache_,
                        base::Bind(&Catalog::SystemPackageDirScanned,
                                   weak_factory_.GetWeakPtr()));
 }
 
-bool Catalog::OnConnect(const shell::Identity& remote_identity,
-                        shell::InterfaceRegistry* registry) {
+bool Catalog::OnConnect(const service_manager::Identity& remote_identity,
+                        service_manager::InterfaceRegistry* registry) {
   registry->AddInterface<mojom::Catalog>(this);
   registry->AddInterface<mojom::CatalogControl>(this);
   registry->AddInterface<filesystem::mojom::Directory>(this);
-  registry->AddInterface<shell::mojom::Resolver>(this);
+  registry->AddInterface<service_manager::mojom::Resolver>(this);
   return true;
 }
 
-void Catalog::Create(const shell::Identity& remote_identity,
-                     shell::mojom::ResolverRequest request) {
+void Catalog::Create(const service_manager::Identity& remote_identity,
+                     service_manager::mojom::ResolverRequest request) {
   Instance* instance = GetInstanceForUserId(remote_identity.user_id());
   instance->BindResolver(std::move(request));
 }
 
-void Catalog::Create(const shell::Identity& remote_identity,
+void Catalog::Create(const service_manager::Identity& remote_identity,
                      mojom::CatalogRequest request) {
   Instance* instance = GetInstanceForUserId(remote_identity.user_id());
   instance->BindCatalog(std::move(request));
 }
 
-void Catalog::Create(const shell::Identity& remote_identity,
+void Catalog::Create(const service_manager::Identity& remote_identity,
                      filesystem::mojom::DirectoryRequest request) {
   if (!lock_table_)
     lock_table_ = new filesystem::LockTable;
   base::FilePath resources_path =
       GetPathForApplicationName(remote_identity.name());
   mojo::MakeStrongBinding(
       base::MakeUnique<filesystem::DirectoryImpl>(
           resources_path, scoped_refptr<filesystem::SharedTempDir>(),
           lock_table_),
       std::move(request));
 }
 
-void Catalog::Create(const shell::Identity& remote_identity,
+void Catalog::Create(const service_manager::Identity& remote_identity,
                      mojom::CatalogControlRequest request) {
   control_bindings_.AddBinding(this, std::move(request));
 }
 
 void Catalog::OverrideManifestPath(
     const std::string& service_name,
     const base::FilePath& path,
     const OverrideManifestPathCallback& callback) {
   system_reader_->OverrideManifestPath(service_name, path);
   callback.Run();
@@ skipping 13 matching lines @@
   return instance;
 }
 
 void Catalog::SystemPackageDirScanned() {
   loaded_ = true;
   for (auto& instance : instances_)
     instance.second->CacheReady(&system_cache_);
 }
 
 }  // namespace catalog