Rename shell namespace to service_manager

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 "services/catalog/store.h"
 #include "services/service_manager/public/cpp/names.h"
 
@@ skipping 18 matching lines @@
                             std::set<std::string>* string_set) {
   const base::ListValue* list_value = nullptr;
   if (!value.GetAsList(&list_value)) {
     LOG(ERROR) << "Entry::Deserialize: Value must be a list.";
     return false;
   }
   return ReadStringSet(*list_value, string_set);
 }
 
 bool BuildCapabilities(const base::DictionaryValue& value,
-                       shell::CapabilitySpec* capabilities) {
+                       service_manager::CapabilitySpec* capabilities) {
   DCHECK(capabilities);
   const base::DictionaryValue* provided_value = nullptr;
   if (value.HasKey(Store::kCapabilities_ProvidedKey) &&
       !value.GetDictionary(Store::kCapabilities_ProvidedKey,
                            &provided_value)) {
     LOG(ERROR) << "Entry::Deserialize: " << Store::kCapabilities_ProvidedKey
                << " must be a dictionary.";
     return false;
   }
   if (provided_value) {
     base::DictionaryValue::Iterator it(*provided_value);
     for(; !it.IsAtEnd(); it.Advance()) {
-      shell::Interfaces interfaces;
+      service_manager::Interfaces interfaces;
       if (!ReadStringSetFromValue(it.value(), &interfaces)) {
         LOG(ERROR) << "Entry::Deserialize: Invalid interface list in provided "
                    << " classes dictionary";
         return false;
       }
       capabilities->provided[it.key()] = interfaces;
     }
   }
 
   const base::DictionaryValue* required_value = nullptr;
   if (value.HasKey(Store::kCapabilities_RequiredKey) &&
       !value.GetDictionary(Store::kCapabilities_RequiredKey,
                            &required_value)) {
     LOG(ERROR) << "Entry::Deserialize: " << Store::kCapabilities_RequiredKey
                << " must be a dictionary.";
     return false;
   }
   if (required_value) {
     base::DictionaryValue::Iterator it(*required_value);
     for (; !it.IsAtEnd(); it.Advance()) {
-      shell::Classes classes;
+      service_manager::Classes classes;
       const base::ListValue* entry_value = nullptr;
       if (!it.value().GetAsList(&entry_value)) {
         LOG(ERROR) << "Entry::Deserialize: " << Store::kCapabilities_RequiredKey
                    << " entry must be a list.";
         return false;
       }
       if (!ReadStringSet(*entry_value, &classes)) {
         LOG(ERROR) << "Entry::Deserialize: Invalid classes list in required "
                    << "capabilities dictionary.";
         return false;
       }
 
       capabilities->required[it.key()] = classes;
     }
   }
   return true;
 }
 
 }  // namespace
 
 Entry::Entry() {}
 Entry::Entry(const std::string& name)
-    : name_(name), qualifier_(shell::GetNamePath(name)), display_name_(name) {}
+    : name_(name),
+      qualifier_(service_manager::GetNamePath(name)),
+      display_name_(name) {}
 Entry::~Entry() {}
 
 std::unique_ptr<base::DictionaryValue> Entry::Serialize() const {
   std::unique_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_);
   std::unique_ptr<base::DictionaryValue> spec(new base::DictionaryValue);
 
@@ skipping 36 matching lines @@
     return nullptr;
   }
 
   // Name.
   std::string name_string;
   if (!value.GetString(Store::kNameKey, &name_string)) {
     LOG(ERROR) << "Entry::Deserialize: dictionary has no "
                << Store::kNameKey << " key";
     return nullptr;
   }
-  if (!shell::IsValidName(name_string)) {
+  if (!service_manager::IsValidName(name_string)) {
     LOG(ERROR) << "Entry::Deserialize: " << name_string << " is not a valid "
                << "Mojo name";
     return nullptr;
   }
   entry->set_name(name_string);
 
   // Process group.
   if (value.HasKey(Store::kQualifierKey)) {
     std::string qualifier;
     if (!value.GetString(Store::kQualifierKey, &qualifier)) {
       LOG(ERROR) << "Entry::Deserialize: " << Store::kQualifierKey << " must "
                  << "be a string.";
       return nullptr;
     }
     entry->set_qualifier(qualifier);
   } else {
-    entry->set_qualifier(shell::GetNamePath(name_string));
+    entry->set_qualifier(service_manager::GetNamePath(name_string));
   }
 
   // Human-readable name.
   std::string display_name;
   if (!value.GetString(Store::kDisplayNameKey, &display_name)) {
     LOG(ERROR) << "Entry::Deserialize: dictionary has no "
                << Store::kDisplayNameKey << " key";
     return nullptr;
   }
   entry->set_display_name(display_name);
 
   // Capability spec.
   const base::DictionaryValue* capabilities = nullptr;
   if (!value.GetDictionary(Store::kCapabilitiesKey, &capabilities)) {
     LOG(ERROR) << "Entry::Deserialize: dictionary has no "
                << Store::kCapabilitiesKey << " key";
     return nullptr;
   }
 
-  shell::CapabilitySpec spec;
+  service_manager::CapabilitySpec spec;
   if (!BuildCapabilities(*capabilities, &spec)) {
     LOG(ERROR) << "Entry::Deserialize: failed to build capability spec for "
                << entry->name();
     return nullptr;
   }
   entry->set_capabilities(spec);
 
   if (value.HasKey(Store::kServicesKey)) {
     const base::ListValue* services = nullptr;
     value.GetList(Store::kServicesKey, &services);
@@ skipping 26 matching lines @@
   return std::tie(name_, qualifier_, display_name_, capabilities_) <
          std::tie(other.name_, other.qualifier_, other.display_name_,
                   other.capabilities_);
 }
 
 }  // catalog
 
 namespace mojo {
 
 // static
-shell::mojom::ResolveResultPtr
-    TypeConverter<shell::mojom::ResolveResultPtr, catalog::Entry>::Convert(
-        const catalog::Entry& input) {
-  shell::mojom::ResolveResultPtr result(shell::mojom::ResolveResult::New());
+service_manager::mojom::ResolveResultPtr
+TypeConverter<service_manager::mojom::ResolveResultPtr,
+              catalog::Entry>::Convert(const catalog::Entry& input) {
+  service_manager::mojom::ResolveResultPtr result(
+      service_manager::mojom::ResolveResult::New());
   result->name = input.name();
   const catalog::Entry& package = input.package() ? *input.package() : input;
   result->resolved_name = package.name();
   result->qualifier = input.qualifier();
   result->capabilities = input.capabilities();
   result->package_path = package.path();
   return result;
 }
 
 // static
 catalog::mojom::EntryPtr
     TypeConverter<catalog::mojom::EntryPtr, catalog::Entry>::Convert(
         const catalog::Entry& input) {
   catalog::mojom::EntryPtr result(catalog::mojom::Entry::New());
   result->name = input.name();
   result->display_name = input.display_name();
   return result;
 }
 
 }  // namespace mojo