Move shell service to toplevel shell namespace

services/catalog/entry.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/entry.h"
 
 #include "base/values.h"
 #include "mojo/util/filename_util.h"
 #include "services/catalog/store.h"
 #include "services/shell/public/cpp/names.h"
 #include "url/gurl.h"
 
 namespace catalog {
 namespace {
 
-mojo::CapabilitySpec BuildCapabilitiesV0(
-    const base::DictionaryValue& value) {
-  mojo::CapabilitySpec capabilities;
+shell::CapabilitySpec BuildCapabilitiesV0(const base::DictionaryValue& value) {
+  shell::CapabilitySpec capabilities;
   base::DictionaryValue::Iterator it(value);
   for (; !it.IsAtEnd(); it.Advance()) {
     const base::ListValue* values = nullptr;
     CHECK(it.value().GetAsList(&values));
-    mojo::CapabilityRequest spec;
+    shell::CapabilityRequest spec;
     for (auto i = values->begin(); i != values->end(); ++i) {
-      mojo::Interface interface_name;
+      shell::Interface interface_name;
       const base::Value* v = *i;
       CHECK(v->GetAsString(&interface_name));
       spec.interfaces.insert(interface_name);
     }
     capabilities.required[it.key()] = spec;
   }
   return capabilities;
 }
 
 void ReadStringSet(const base::ListValue& list_value,
@@ skipping 17 matching lines @@
 void ReadStringSetFromDictionary(const base::DictionaryValue& dictionary,
                                  const std::string& key,
                                  std::set<std::string>* string_set) {
   const base::ListValue* list_value = nullptr;
   if (dictionary.HasKey(key))
     CHECK(dictionary.GetList(key, &list_value));
   if (list_value)
     ReadStringSet(*list_value, string_set);
 }
 
-mojo::CapabilitySpec BuildCapabilitiesV1(
-    const base::DictionaryValue& value) {
-  mojo::CapabilitySpec capabilities;
+shell::CapabilitySpec BuildCapabilitiesV1(const base::DictionaryValue& value) {
+  shell::CapabilitySpec capabilities;
 
   const base::DictionaryValue* provided_value = nullptr;
   if (value.HasKey(Store::kCapabilities_ProvidedKey)) {
     CHECK(value.GetDictionary(Store::kCapabilities_ProvidedKey,
                               &provided_value));
   }
   if (provided_value) {
-    mojo::CapabilityRequest provided;
+    shell::CapabilityRequest provided;
     base::DictionaryValue::Iterator it(*provided_value);
     for(; !it.IsAtEnd(); it.Advance()) {
-      mojo::Interfaces interfaces;
+      shell::Interfaces interfaces;
       ReadStringSetFromValue(it.value(), &interfaces);
       capabilities.provided[it.key()] = interfaces;
     }
   }
 
   const base::DictionaryValue* required_value = nullptr;
   if (value.HasKey(Store::kCapabilities_RequiredKey)) {
     CHECK(value.GetDictionary(Store::kCapabilities_RequiredKey,
                               &required_value));
   }
   if (required_value) {
     base::DictionaryValue::Iterator it(*required_value);
     for (; !it.IsAtEnd(); it.Advance()) {
-      mojo::CapabilityRequest spec;
+      shell::CapabilityRequest spec;
       const base::DictionaryValue* entry_value = nullptr;
       CHECK(it.value().GetAsDictionary(&entry_value));
       ReadStringSetFromDictionary(
           *entry_value, Store::kCapabilities_ClassesKey, &spec.classes);
       ReadStringSetFromDictionary(
           *entry_value, Store::kCapabilities_InterfacesKey, &spec.interfaces);
       capabilities.required[it.key()] = spec;
     }
   }
   return capabilities;
 }
 
 }  // namespace
 
 Entry::Entry() {}
 Entry::Entry(const std::string& name)
-    : name_(name),
-      qualifier_(mojo::GetNamePath(name)),
-      display_name_(name) {}
+    : name_(name), qualifier_(shell::GetNamePath(name)), display_name_(name) {}
 Entry::Entry(const Entry& other) = default;
 Entry::~Entry() {}
 
 scoped_ptr<base::DictionaryValue> Entry::Serialize() const {
   scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue);
   value->SetInteger(Store::kManifestVersionKey, 1);
   value->SetString(Store::kNameKey, name_);
   value->SetString(Store::kDisplayNameKey, display_name_);
   value->SetString(Store::kQualifierKey, qualifier_);
   scoped_ptr<base::DictionaryValue> spec(new base::DictionaryValue);
@@ skipping 30 matching lines @@
 scoped_ptr<Entry> Entry::Deserialize(const base::DictionaryValue& value) {
   scoped_ptr<Entry> entry(new Entry);
   int manifest_version = 0;
   if (value.HasKey(Store::kManifestVersionKey))
     CHECK(value.GetInteger(Store::kManifestVersionKey, &manifest_version));
   std::string name_string;
   if (!value.GetString(Store::kNameKey, &name_string)) {
     LOG(ERROR) << "Entry::Deserialize: dictionary has no name key";
     return nullptr;
   }
-  if (!mojo::IsValidName(name_string)) {
+  if (!shell::IsValidName(name_string)) {
     LOG(WARNING) << "Entry::Deserialize: " << name_string << " is not a valid "
                  << "Mojo name";
     return nullptr;
   }
   entry->set_name(name_string);
   if (value.HasKey(Store::kQualifierKey)) {
     std::string qualifier;
     CHECK(value.GetString(Store::kQualifierKey, &qualifier));
     entry->set_qualifier(qualifier);
   } else {
-    entry->set_qualifier(mojo::GetNamePath(name_string));
+    entry->set_qualifier(shell::GetNamePath(name_string));
   }
   std::string display_name;
   if (!value.GetString(Store::kDisplayNameKey, &display_name)) {
     LOG(WARNING) << "Entry::Deserialize: dictionary has no display_name key";
     return nullptr;
   }
   entry->set_display_name(display_name);
   const base::DictionaryValue* capabilities = nullptr;
   if (!value.GetDictionary(Store::kCapabilitiesKey, &capabilities)) {
     LOG(WARNING) << "Entry::Description: dictionary has no capabilities key";
@@ skipping 47 matching lines @@
   const catalog::Entry& package = input.package() ? *input.package() : input;
   result->resolved_name = package.name();
   result->qualifier = input.qualifier();
   result->capabilities =
       shell::mojom::CapabilitySpec::From(input.capabilities());
   result->package_url = mojo::util::FilePathToFileURL(package.path()).spec();
   return result;
 }
 
 }  // namespace mojo