Simplify resolve.

mojo/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 "mojo/services/catalog/entry.h"
 
 #include "base/values.h"
 #include "mojo/services/catalog/store.h"
 #include "mojo/shell/public/cpp/names.h"
+#include "mojo/util/filename_util.h"
+#include "url/gurl.h"
 
 namespace catalog {
 namespace {
 
 mojo::CapabilitySpec BuildCapabilitiesV0(
     const base::DictionaryValue& value) {
   mojo::CapabilitySpec capabilities;
   base::DictionaryValue::Iterator it(value);
   for (; !it.IsAtEnd(); it.Advance()) {
     const base::ListValue* values = nullptr;
@@ skipping 74 matching lines @@
           *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) {}
 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 66 matching lines @@
   else
     entry->set_capabilities(BuildCapabilitiesV1(*capabilities));
 
   if (value.HasKey(Store::kApplicationsKey)) {
     const base::ListValue* applications = nullptr;
     value.GetList(Store::kApplicationsKey, &applications);
     for (size_t i = 0; i < applications->GetSize(); ++i) {
       const base::DictionaryValue* application = nullptr;
       applications->GetDictionary(i, &application);
       scoped_ptr<Entry> child = Entry::Deserialize(*application);
-      if (child)
-        entry->applications_.insert(*child);
+      if (child) {
+        child->set_package(entry.get());
+        // Caller must assume ownership of these items.
+        entry->applications_.insert(child.release());
+      }
     }
   }
 
   return entry;
 }
 
 bool Entry::operator==(const Entry& other) const {
   return other.name_ == name_ && other.qualifier_ == qualifier_ &&
          other.display_name_ == display_name_ &&
          other.capabilities_ == capabilities_;
 }
 
 bool Entry::operator<(const Entry& other) const {
   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());
+  result->name = input.name();
+  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