Rename shell namespace to service_manager

services/catalog/instance.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/instance.h"
 
 #include "base/bind.h"
 #include "services/catalog/entry.h"
 #include "services/catalog/manifest_provider.h"
 #include "services/catalog/reader.h"
@@ skipping 14 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 // Instance, public:
 
 Instance::Instance(std::unique_ptr<Store> store, Reader* system_reader)
     : store_(std::move(store)),
       system_reader_(system_reader),
       weak_factory_(this) {}
 Instance::~Instance() {}
 
-void Instance::BindResolver(shell::mojom::ResolverRequest request) {
+void Instance::BindResolver(service_manager::mojom::ResolverRequest request) {
   if (system_cache_)
     resolver_bindings_.AddBinding(this, std::move(request));
   else
     pending_resolver_requests_.push_back(std::move(request));
 }
 
 void Instance::BindCatalog(mojom::CatalogRequest request) {
   if (system_cache_)
     catalog_bindings_.AddBinding(this, std::move(request));
   else
     pending_catalog_requests_.push_back(std::move(request));
 }
 
 void Instance::CacheReady(EntryCache* cache) {
   system_cache_ = cache;
   DeserializeCatalog();
   for (auto& request : pending_resolver_requests_)
     BindResolver(std::move(request));
   for (auto& request : pending_catalog_requests_)
     BindCatalog(std::move(request));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// Instance, shell::mojom::Resolver:
+// Instance, service_manager::mojom::Resolver:
 
 void Instance::ResolveMojoName(const std::string& mojo_name,
                                const ResolveMojoNameCallback& callback) {
   DCHECK(system_cache_);
 
-  std::string type = shell::GetNameType(mojo_name);
-  if (type != shell::kNameType_Service && type != shell::kNameType_Exe) {
+  std::string type = service_manager::GetNameType(mojo_name);
+  if (type != service_manager::kNameType_Service &&
+      type != service_manager::kNameType_Exe) {
     std::unique_ptr<Entry> entry(new Entry(mojo_name));
-    shell::mojom::ResolveResultPtr result =
-        shell::mojom::ResolveResult::From(*entry);
+    service_manager::mojom::ResolveResultPtr result =
+        service_manager::mojom::ResolveResult::From(*entry);
     result->capabilities = base::nullopt;
     callback.Run(std::move(result));
     return;
   }
 
   // TODO(beng): per-user catalogs.
   auto entry = system_cache_->find(mojo_name);
   if (entry != system_cache_->end()) {
-    callback.Run(shell::mojom::ResolveResult::From(*entry->second));
+    callback.Run(service_manager::mojom::ResolveResult::From(*entry->second));
     return;
   }
 
   // Manifests for mojo: names should always be in the catalog by this point.
-  //DCHECK(type == shell::kNameType_Exe);
+  // DCHECK(type == service_manager::kNameType_Exe);
   system_reader_->CreateEntryForName(
       mojo_name, system_cache_,
       base::Bind(&Instance::OnReadManifest, weak_factory_.GetWeakPtr(),
                  mojo_name, callback));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Instance, mojom::Catalog:
 
 void Instance::GetEntries(const base::Optional<std::vector<std::string>>& names,
@@ skipping 69 matching lines @@
   for (const auto& entry : *system_cache_)
     catalog->Append(entry.second->Serialize());
   if (store_)
     store_->UpdateStore(std::move(catalog));
 }
 
 // static
 void Instance::OnReadManifest(base::WeakPtr<Instance> instance,
                               const std::string& mojo_name,
                               const ResolveMojoNameCallback& callback,
-                              shell::mojom::ResolveResultPtr result) {
+                              service_manager::mojom::ResolveResultPtr result) {
   callback.Run(std::move(result));
   if (instance)
     instance->SerializeCatalog();
 }
 
 }  // namespace catalog