Morph CapabilityFilter into caps::Capabilities, which supports capability classes (yet unimplemente…

mojo/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 "mojo/services/catalog/catalog.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"
@@ skipping 130 matching lines @@
   } else if (type == "exe") {
 #if defined OS_WIN
     std::string extension = ".exe";
 #else
     std::string extension;
 #endif
     file_url = system_package_dir_.Resolve(
         mojo::GetNamePath(resolved_name) + extension);
   }
 
-  mojo::shell::mojom::CapabilityFilterPtr filter(
-      mojo::shell::mojom::CapabilityFilter::New());
-  filter->filter = mojo::Map<mojo::String, mojo::Array<mojo::String>>();
-  for (const auto& entry : entry_iter->second.capabilities) {
-    mojo::Array<mojo::String> interfaces;
-    for (auto interface_name : entry.second)
-      interfaces.push_back(interface_name);
-    filter->filter.insert(entry.first, std::move(interfaces));
-  }
-  callback.Run(resolved_name, qualifier, std::move(filter),
+  mojo::shell::mojom::CapabilitySpecPtr capabilities_ptr =
+      mojo::shell::mojom::CapabilitySpec::From(entry_iter->second.capabilities);
+
+  callback.Run(resolved_name, qualifier, std::move(capabilities_ptr),
                file_url.spec());
 }
 
 bool Catalog::IsNameInCatalog(const std::string& name) const {
   return catalog_.find(name) != catalog_.end();
 }
 
 void Catalog::AddNameToCatalog(const std::string& name,
                                const ResolveMojoNameCallback& callback) {
   GURL manifest_url = GetManifestURL(name);
@@ skipping 25 matching lines @@
     const base::DictionaryValue* dictionary = nullptr;
     const base::Value* v = *it;
     CHECK(v->GetAsDictionary(&dictionary));
     const Entry entry = BuildEntry(*dictionary);
     catalog_[entry.name] = entry;
   }
 }
 
 void Catalog::SerializeCatalog() {
   scoped_ptr<base::ListValue> catalog(new base::ListValue);
-  for (const auto& entry : catalog_) {
-    base::DictionaryValue* dictionary = nullptr;
-    SerializeEntry(entry.second, &dictionary);
-    catalog->Append(make_scoped_ptr(dictionary));
-  }
+  for (const auto& entry : catalog_)
+    catalog->Append(SerializeEntry(entry.second));
   if (store_)
     store_->UpdateStore(std::move(catalog));
 }
 
 const Entry& Catalog::DeserializeApplication(
     const base::DictionaryValue* dictionary) {
   Entry entry = BuildEntry(*dictionary);
   if (catalog_.find(entry.name) == catalog_.end()) {
     catalog_[entry.name] = entry;
 
@@ skipping 54 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 catalog