CapabilitySpec

mojo/services/package_manager/package_manager.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 "mojo/services/package_manager/package_manager.h"
 
 #include "base/bind.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/strings/string_split.h"
 #include "base/task_runner_util.h"
 #include "mojo/common/url_type_converters.h"
 #include "mojo/shell/public/cpp/names.h"
 #include "mojo/util/filename_util.h"
 #include "net/base/filename_util.h"
 #include "url/url_util.h"
 
 namespace package_manager {
 namespace {
 
-CapabilityFilter BuildCapabilityFilterFromDictionary(
+Capabilities BuildCapabilitiesFromDictionary(
     const base::DictionaryValue& value) {
-  CapabilityFilter filter;
+  Capabilities capabilities;
+
+  const base::DictionaryValue* provided_value = nullptr;
+  if (value.HasKey(ApplicationCatalogStore::kCapabilities_ProvidedKey)) {
+    value.GetDictionary(ApplicationCatalogStore::kCapabilities_ProvidedKey,
+                        &provided_value);
+  }
+  if (provided_value) {
+    base::DictionaryValue::Iterator it(provided_value);
+    for (; !it.IsAtEnd(); it.Advance()) {
+      const base::ListValue* values = nullptr;
+      CHECK(it.value().GetAsList(&values));
+      mojo::caps::Interfaces interfaces;
+      for (auto i = values->begin(); i != values->end(); ++i) {
+        mojo::caps::Interface interface_name;
+        const base::Value* v = *i;
+        CHECK(v->GetAsString(&interface_name));
+        interfaces.insert(interface_name);
+      }
+      capabilities.provided[it.key] = interfaces;
+    }
+  }
+
+  const base::DictionaryValue* required_value = nullptr;
+  if (value.HasKey(ApplicationCatalogStore::kCapabilities_RequiredKey)) {
+    value.GetDictionary(ApplicationCatalogStore::kCapabilities_RequiredKey,
+                        &required_value);
+  }
+  if (required_value) {
+    base::DictionaryValue::Iterator it(required_value);
+    for (; !it.IsAtEnd(); it.Advance()) {
+      const base::DictionaryValue* 
+    }
+
+  }
+
+
+
+  /*
   base::DictionaryValue::Iterator it(value);
   for (; !it.IsAtEnd(); it.Advance()) {
     const base::ListValue* values = nullptr;
     CHECK(it.value().GetAsList(&values));
     AllowedInterfaces interfaces;
     for (auto i = values->begin(); i != values->end(); ++i) {
       std::string iface_name;
       const base::Value* v = *i;
       CHECK(v->GetAsString(&iface_name));
       interfaces.insert(iface_name);
     }
     filter[it.key()] = interfaces;
   }
-  return filter;
+  */
+  return capabilities;
 }
 
 ApplicationInfo BuildApplicationInfoFromDictionary(
     const base::DictionaryValue& value) {
   ApplicationInfo info;
   std::string name_string;
   CHECK(value.GetString(ApplicationCatalogStore::kNameKey, &name_string));
   CHECK(mojo::IsValidName(name_string)) << "Invalid Name: " << name_string;
   info.name = name_string;
   if (value.HasKey(ApplicationCatalogStore::kQualifierKey)) {
     CHECK(value.GetString(ApplicationCatalogStore::kQualifierKey,
                           &info.qualifier));
   } else {
     info.qualifier = mojo::GetNamePath(name_string);
   }
   CHECK(value.GetString(ApplicationCatalogStore::kDisplayNameKey,
                         &info.display_name));
   const base::DictionaryValue* capabilities = nullptr;
   CHECK(value.GetDictionary(ApplicationCatalogStore::kCapabilitiesKey,
                             &capabilities));
-  info.base_filter = BuildCapabilityFilterFromDictionary(*capabilities);
+  info.base_filter = BuildCapabilitiesFromDictionary(*capabilities);
   return info;
 }
 
 void SerializeEntry(const ApplicationInfo& entry,
                     base::DictionaryValue** value) {
   *value = new base::DictionaryValue;
   (*value)->SetString(ApplicationCatalogStore::kNameKey, entry.name);
   (*value)->SetString(ApplicationCatalogStore::kDisplayNameKey,
                       entry.display_name);
   base::DictionaryValue* capabilities = new base::DictionaryValue;
@@ skipping 19 matching lines @@
 }  // namespace
 
 // static
 const char ApplicationCatalogStore::kNameKey[] = "name";
 // static
 const char ApplicationCatalogStore::kQualifierKey[] = "process-group";
 // static
 const char ApplicationCatalogStore::kDisplayNameKey[] = "display_name";
 // static
 const char ApplicationCatalogStore::kCapabilitiesKey[] = "capabilities";
+// static
+const char ApplicationCatalogStore::kCapabilities_ProvidedKey[] = "provided";
+// static
+const char ApplicationCatalogStore::kCapabilities_RequiredKey[] = "required";
+// static
+const char ApplicationCatalogStore::kCapabilities_InterfacesKey[] =
+    "interfaces";
+// static
+const char ApplicationCatalogStore::kCapabilities_ClassesKey[] = "classes";
 
 ApplicationInfo::ApplicationInfo() {}
 ApplicationInfo::ApplicationInfo(const ApplicationInfo& other) = default;
 ApplicationInfo::~ApplicationInfo() {}
 
 PackageManager::PackageManager(base::TaskRunner* blocking_pool,
                                scoped_ptr<ApplicationCatalogStore> catalog)
     : blocking_pool_(blocking_pool),
       catalog_store_(std::move(catalog)),
       weak_factory_(this) {
@@ skipping 240 matching lines @@
   }
   SerializeCatalog();
 
   auto qualifier_iter = qualifiers_.find(name);
   DCHECK(qualifier_iter != qualifiers_.end());
   std::string qualifier = qualifier_iter->second;
   CompleteResolveMojoName(name, qualifier, callback);
 }
 
 }  // namespace package_manager