Move shell service to toplevel shell namespace

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/json/json_file_value_serializer.h"
 #include "base/json/json_reader.h"
 #include "base/strings/string_split.h"
 #include "base/task_runner_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "mojo/common/url_type_converters.h"
 #include "services/catalog/entry.h"
 #include "services/catalog/manifest_provider.h"
 #include "services/catalog/store.h"
 #include "services/shell/public/cpp/names.h"
 #include "url/gurl.h"
 #include "url/url_util.h"
 
 namespace catalog {
 namespace {
 
 base::FilePath GetManifestPath(const base::FilePath& package_dir,
                                const std::string& name) {
   // TODO(beng): think more about how this should be done for exe targets.
-  std::string type = mojo::GetNameType(name);
-  std::string path = mojo::GetNamePath(name);
-  if (type == mojo::kNameType_Mojo) {
+  std::string type = shell::GetNameType(name);
+  std::string path = shell::GetNamePath(name);
+  if (type == shell::kNameType_Mojo) {
     return package_dir.AppendASCII("Mojo Applications").AppendASCII(
         path + "/manifest.json");
   }
-  if (type == mojo::kNameType_Exe)
+  if (type == shell::kNameType_Exe)
     return package_dir.AppendASCII(path + "_manifest.json");
   return base::FilePath();
 }
 
 base::FilePath GetPackagePath(const base::FilePath& package_dir,
                               const std::string& name) {
-  std::string type = mojo::GetNameType(name);
-  if (type == mojo::kNameType_Mojo) {
+  std::string type = shell::GetNameType(name);
+  if (type == shell::kNameType_Mojo) {
     // It's still a mojo: URL, use the default mapping scheme.
-    const std::string host = mojo::GetNamePath(name);
+    const std::string host = shell::GetNamePath(name);
     return package_dir.AppendASCII("Mojo Applications").AppendASCII(
         host + "/" + host + ".mojo");
   }
-  if (type == mojo::kNameType_Exe) {
+  if (type == shell::kNameType_Exe) {
 #if defined OS_WIN
     std::string extension = ".exe";
 #else
     std::string extension;
 #endif
-    return package_dir.AppendASCII(mojo::GetNamePath(name) + extension);
+    return package_dir.AppendASCII(shell::GetNamePath(name) + extension);
   }
   return base::FilePath();
 }
 
 scoped_ptr<ReadManifestResult> ProcessManifest(
     const base::FilePath& user_package_dir,
     const base::FilePath& system_package_dir,
     const std::string& name,
     scoped_ptr<base::Value> manifest_root) {
   scoped_ptr<Entry> entry(new Entry(name));
   if (manifest_root) {
     const base::DictionaryValue* dictionary = nullptr;
     CHECK(manifest_root->GetAsDictionary(&dictionary));
     entry = Entry::Deserialize(*dictionary);
   }
   entry->set_path(GetPackagePath(system_package_dir, name));
 
   scoped_ptr<ReadManifestResult> result(new ReadManifestResult);
   // NOTE: This TypeConverter must run on a thread which allows IO.
-  result->resolve_result = mojo::shell::mojom::ResolveResult::From(*entry);
+  result->resolve_result = shell::mojom::ResolveResult::From(*entry);
   result->catalog_entry = std::move(entry);
   result->package_dir = system_package_dir;
   return result;
 }
 
 scoped_ptr<ReadManifestResult> ReadManifest(
     const base::FilePath& user_package_dir,
     const base::FilePath& system_package_dir,
     const std::string& name) {
   base::FilePath manifest_path = GetManifestPath(system_package_dir, name);
@@ skipping 34 matching lines @@
   PathService::Get(base::DIR_MODULE, &system_package_dir_);
   DeserializeCatalog();
 }
 
 Catalog::~Catalog() {}
 
 void Catalog::BindResolver(mojom::ResolverRequest request) {
   resolver_bindings_.AddBinding(this, std::move(request));
 }
 
-void Catalog::BindShellResolver(
-    mojo::shell::mojom::ShellResolverRequest request) {
+void Catalog::BindShellResolver(shell::mojom::ShellResolverRequest request) {
   shell_resolver_bindings_.AddBinding(this, std::move(request));
 }
 
 void Catalog::BindCatalog(mojom::CatalogRequest request) {
   catalog_bindings_.AddBinding(this, std::move(request));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Catalog, mojom::Resolver:
 
 void Catalog::ResolveInterfaces(mojo::Array<mojo::String> interfaces,
                                 const ResolveInterfacesCallback& callback) {
   // TODO(beng): implement.
 }
 
 void Catalog::ResolveMIMEType(const mojo::String& mime_type,
                               const ResolveMIMETypeCallback& callback) {
   // TODO(beng): implement.
 }
 
 void Catalog::ResolveProtocolScheme(
     const mojo::String& scheme,
     const ResolveProtocolSchemeCallback& callback) {
   // TODO(beng): implement.
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// Catalog, mojo::shell::mojom::ShellResolver:
+// Catalog, shell::mojom::ShellResolver:
 
 void Catalog::ResolveMojoName(const mojo::String& mojo_name,
                               const ResolveMojoNameCallback& callback) {
-  std::string type = mojo::GetNameType(mojo_name);
+  std::string type = shell::GetNameType(mojo_name);
   if (type != "mojo" && type != "exe") {
     scoped_ptr<Entry> entry(new Entry(mojo_name));
-    callback.Run(mojo::shell::mojom::ResolveResult::From(*entry));
+    callback.Run(shell::mojom::ResolveResult::From(*entry));
     return;
   }
 
   auto entry = user_catalog_.find(mojo_name);
   if (entry != user_catalog_.end()) {
-    callback.Run(mojo::shell::mojom::ResolveResult::From(*entry->second));
+    callback.Run(shell::mojom::ResolveResult::From(*entry->second));
     return;
   }
   entry = system_catalog_->find(mojo_name);
   if (entry != system_catalog_->end()) {
-    callback.Run(mojo::shell::mojom::ResolveResult::From(*entry->second));
+    callback.Run(shell::mojom::ResolveResult::From(*entry->second));
     return;
   }
 
   std::string manifest_contents;
   if (manifest_provider_ &&
       manifest_provider_->GetApplicationManifest(mojo_name.To<std::string>(),
                                                  &manifest_contents)) {
     scoped_ptr<base::Value> manifest_root =
         base::JSONReader::Read(manifest_contents);
     base::PostTaskAndReplyWithResult(
@@ skipping 87 matching lines @@
   EntryCache* catalog = is_system_catalog ? system_catalog_ : &user_catalog_;
   if (catalog->end() != catalog->find(entry->name()))
     return;
   for (auto child : entry->applications())
     AddEntryToCatalog(make_scoped_ptr(child), is_system_catalog);
   (*catalog)[entry->name()] = std::move(entry);
   SerializeCatalog();
 }
 
 }  // namespace catalog