Rename shell namespace to service_manager

services/catalog/reader.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/reader.h"
 
 #include "base/bind.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_util.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/json/json_reader.h"
 #include "base/memory/ptr_util.h"
 #include "base/path_service.h"
 #include "base/task_runner_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "services/catalog/constants.h"
 #include "services/catalog/entry.h"
 #include "services/catalog/manifest_provider.h"
 #include "services/service_manager/public/cpp/names.h"
 
 namespace catalog {
 namespace {
 
 base::FilePath GetManifestPath(const base::FilePath& package_dir,
                                const std::string& name,
                                const std::string& package_name_override) {
   // TODO(beng): think more about how this should be done for exe targets.
-  std::string type = shell::GetNameType(name);
-  std::string path = shell::GetNamePath(name);
-  if (type == shell::kNameType_Service) {
+  std::string type = service_manager::GetNameType(name);
+  std::string path = service_manager::GetNamePath(name);
+  if (type == service_manager::kNameType_Service) {
     std::string package_name;
     if (package_name_override.empty())
       package_name = path;
     else
       package_name = package_name_override;
     return package_dir.AppendASCII(kPackagesDirName).AppendASCII(
         package_name + "/manifest.json");
   }
-  if (type == shell::kNameType_Exe)
+  if (type == service_manager::kNameType_Exe)
     return package_dir.AppendASCII(path + "_manifest.json");
   return base::FilePath();
 }
 
 base::FilePath GetExecutablePath(const base::FilePath& package_dir,
                                  const std::string& name) {
-  std::string type = shell::GetNameType(name);
-  if (type == shell::kNameType_Service) {
+  std::string type = service_manager::GetNameType(name);
+  if (type == service_manager::kNameType_Service) {
     // It's still a mojo: URL, use the default mapping scheme.
-    const std::string host = shell::GetNamePath(name);
+    const std::string host = service_manager::GetNamePath(name);
     return package_dir.AppendASCII(host + "/" + host + ".library");
   }
-  if (type == shell::kNameType_Exe) {
+  if (type == service_manager::kNameType_Exe) {
 #if defined OS_WIN
     std::string extension = ".exe";
 #else
     std::string extension;
 #endif
-    return package_dir.AppendASCII(shell::GetNamePath(name) + extension);
+    return package_dir.AppendASCII(service_manager::GetNamePath(name) +
+                                   extension);
   }
   return base::FilePath();
 }
 
 std::unique_ptr<Entry> ProcessManifest(
     std::unique_ptr<base::Value> manifest_root,
     const base::FilePath& package_dir) {
   // Manifest was malformed or did not exist.
   if (!manifest_root)
     return nullptr;
@@ skipping 80 matching lines @@
   return entry;
 }
 
 void AddEntryToCache(EntryCache* cache, std::unique_ptr<Entry> entry) {
   std::vector<std::unique_ptr<Entry>> children = entry->TakeChildren();
   for (auto& child : children)
     AddEntryToCache(cache, std::move(child));
   (*cache)[entry->name()] = std::move(entry);
 }
 
-void DoNothing(shell::mojom::ResolveResultPtr) {}
+void DoNothing(service_manager::mojom::ResolveResultPtr) {}
 
 }  // namespace
 
 // A sequenced task runner is used to guarantee requests are serviced in the
 // order requested. To do otherwise means we may run callbacks in an
 // unpredictable order, leading to flake.
 Reader::Reader(base::SequencedWorkerPool* worker_pool,
                ManifestProvider* manifest_provider)
     : Reader(manifest_provider) {
   file_task_runner_ = worker_pool->GetSequencedTaskRunnerWithShutdownBehavior(
@@ skipping 74 matching lines @@
     : manifest_provider_(manifest_provider), weak_factory_(this) {
   PathService::Get(base::DIR_MODULE, &system_package_dir_);
 }
 
 void Reader::OnReadManifest(
     EntryCache* cache,
     const CreateEntryForNameCallback& entry_created_callback,
     std::unique_ptr<Entry> entry) {
   if (!entry)
     return;
-  shell::mojom::ResolveResultPtr result =
-      shell::mojom::ResolveResult::From(*entry);
+  service_manager::mojom::ResolveResultPtr result =
+      service_manager::mojom::ResolveResult::From(*entry);
   AddEntryToCache(cache, std::move(entry));
   entry_created_callback.Run(std::move(result));
 }
 
 }  // namespace catalog