Support reading multiple InterfaceProviderSpecs from manifests

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/memory/ptr_util.h"
 #include "base/values.h"
 #include "services/catalog/store.h"
 #include "services/service_manager/public/cpp/names.h"
@@ skipping 92 matching lines @@
       display_name_(name) {}
 Entry::~Entry() {}
 
 std::unique_ptr<base::DictionaryValue> Entry::Serialize() const {
   auto value = base::MakeUnique<base::DictionaryValue>();
   value->SetString(Store::kNameKey, name_);
   value->SetString(Store::kDisplayNameKey, display_name_);
   value->SetString(Store::kQualifierKey, qualifier_);
 
   auto specs = base::MakeUnique<base::DictionaryValue>();
-  auto connection_spec = base::MakeUnique<base::DictionaryValue>();
+  for (const auto& it : interface_provider_specs_) {
+    auto spec = base::MakeUnique<base::DictionaryValue>();
 
-  auto provides = base::MakeUnique<base::DictionaryValue>();
-  for (const auto& i : connection_spec_.provides) {
-    auto interfaces = base::MakeUnique<base::ListValue>();
-    for (const auto& interface_name : i.second)
-      interfaces->AppendString(interface_name);
-    provides->Set(i.first, std::move(interfaces));
+    auto provides = base::MakeUnique<base::DictionaryValue>();
+    for (const auto& i : it.second.provides) {
+      auto interfaces = base::MakeUnique<base::ListValue>();
+      for (const auto& interface_name : i.second)
+        interfaces->AppendString(interface_name);
+      provides->Set(i.first, std::move(interfaces));
+    }
+    spec->Set(Store::kInterfaceProviderSpecs_ProvidesKey, std::move(provides));
+
+    auto requires = base::MakeUnique<base::DictionaryValue>();
+    for (const auto& i : it.second.requires) {
+      auto capabilities = base::MakeUnique<base::ListValue>();
+      for (const auto& capability : i.second)
+        capabilities->AppendString(capability);
+      requires->Set(i.first, std::move(capabilities));
+    }
+    spec->Set(Store::kInterfaceProviderSpecs_RequiresKey, std::move(requires));
+    specs->Set(it.first, std::move(spec));
   }
-  connection_spec->Set(Store::kInterfaceProviderSpecs_ProvidesKey,
-                       std::move(provides));
-
-  auto requires = base::MakeUnique<base::DictionaryValue>();
-  for (const auto& i : connection_spec_.requires) {
-    auto capabilities = base::MakeUnique<base::ListValue>();
-    for (const auto& class_name : i.second)
-      capabilities->AppendString(class_name);
-    requires->Set(i.first, std::move(capabilities));
-  }
-  connection_spec->Set(Store::kInterfaceProviderSpecs_RequiresKey,
-                       std::move(requires));
-
-  specs->Set(Store::kInterfaceProvider_ConnectionSpecKey,
-             std::move(connection_spec));
   value->Set(Store::kInterfaceProviderSpecsKey, std::move(specs));
   return value;
 }
 
 // static
 std::unique_ptr<Entry> Entry::Deserialize(const base::DictionaryValue& value) {
   auto entry = base::MakeUnique<Entry>();
 
   // Name.
   std::string name_string;
@@ skipping 33 matching lines @@
 
   // InterfaceProvider specs.
   const base::DictionaryValue* interface_provider_specs = nullptr;
   if (!value.GetDictionary(Store::kInterfaceProviderSpecsKey,
                            &interface_provider_specs)) {
     LOG(ERROR) << "Entry::Deserialize: dictionary has no "
                << Store::kInterfaceProviderSpecsKey << " key";
     return nullptr;
   }
 
-  const base::DictionaryValue* connection_spec = nullptr;
-  if (interface_provider_specs->GetDictionary(
-      Store::kInterfaceProvider_ConnectionSpecKey, &connection_spec)) {
-    service_manager::InterfaceProviderSpec spec;
-    if (!BuildInterfaceProviderSpec(*connection_spec, &spec)) {
-      LOG(ERROR) << "Entry::Deserialize: failed to build InterfaceProvider "
-        << "spec for " << entry->name();
+  base::DictionaryValue::Iterator it(*interface_provider_specs);
+  for (; !it.IsAtEnd(); it.Advance()) {
+    const base::DictionaryValue* spec_value = nullptr;
+    if (!interface_provider_specs->GetDictionary(it.key(), &spec_value)) {
+      LOG(ERROR) << "Entry::Deserialize: value of InterfaceProvider map for "
+                 << "key: " << it.key() << " not a dictionary.";
       return nullptr;
     }
-    entry->set_connection_spec(spec);
+
+    service_manager::InterfaceProviderSpec spec;
+    if (!BuildInterfaceProviderSpec(*spec_value, &spec)) {
+      LOG(ERROR) << "Entry::Deserialize: failed to build InterfaceProvider "
+                 << "spec for key: " << it.key();
+      return nullptr;
+    }
+    entry->AddInterfaceProviderSpec(it.key(), spec);
   }
 
   if (value.HasKey(Store::kServicesKey)) {
     const base::ListValue* services = nullptr;
     value.GetList(Store::kServicesKey, &services);
     for (size_t i = 0; i < services->GetSize(); ++i) {
       const base::DictionaryValue* service = nullptr;
       services->GetDictionary(i, &service);
       std::unique_ptr<Entry> child = Entry::Deserialize(*service);
       if (child) {
         child->set_package(entry.get());
         // Caller must assume ownership of these items.
         entry->children_.emplace_back(std::move(child));
       }
     }
   }
 
   return entry;
 }
 
-bool Entry::ProvidesClass(const std::string& clazz) const {
-  return connection_spec_.provides.find(clazz) !=
-      connection_spec_.provides.end();
+bool Entry::ProvidesCapability(const std::string& capability) const {
+  auto it = interface_provider_specs_.find(
+      service_manager::mojom::kServiceManager_ConnectorSpec);
+  if (it == interface_provider_specs_.end())
+    return false;
+
+  auto connection_spec = it->second;
+  return connection_spec.provides.find(capability) !=
+      connection_spec.provides.end();
 }
 
 bool Entry::operator==(const Entry& other) const {
   return other.name_ == name_ && other.qualifier_ == qualifier_ &&
          other.display_name_ == display_name_ &&
-         other.connection_spec_ == connection_spec_;
+         other.interface_provider_specs_ == interface_provider_specs_;
 }
 
-bool Entry::operator<(const Entry& other) const {
-  return std::tie(name_, qualifier_, display_name_, connection_spec_) <
-         std::tie(other.name_, other.qualifier_, other.display_name_,
-                  other.connection_spec_);
+void Entry::AddInterfaceProviderSpec(
+    const std::string& name,
+    const service_manager::InterfaceProviderSpec& spec) {
+  interface_provider_specs_[name] = spec;
 }
 
 }  // catalog
 
 namespace mojo {
 
 // static
 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->connection_spec = input.connection_spec();
+  result->interface_provider_specs = input.interface_provider_specs();
   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