Move serialize/deserialize logic onto Entry.

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"
 #include "mojo/common/url_type_converters.h"
-#include "mojo/services/catalog/builder.h"
 #include "mojo/services/catalog/entry.h"
 #include "mojo/services/catalog/store.h"
 #include "mojo/shell/public/cpp/names.h"
 #include "mojo/util/filename_util.h"
 #include "url/url_util.h"
 
 namespace catalog {
 namespace {
 
 scoped_ptr<base::Value> ReadManifest(const base::FilePath& manifest_path) {
@@ skipping 90 matching lines @@
 
 void Catalog::GetEntries(mojo::Array<mojo::String> names,
                          const GetEntriesCallback& callback) {
   mojo::Map<mojo::String, mojom::CatalogEntryPtr> entries;
   std::vector<mojo::String> names_vec = names.PassStorage();
   for (const std::string& name : names_vec) {
     if (catalog_.find(name) == catalog_.end())
       continue;
     const Entry& entry = catalog_[name];
     mojom::CatalogEntryPtr entry_ptr(mojom::CatalogEntry::New());
-    entry_ptr->display_name = entry.display_name;
-    entries[entry.name] = std::move(entry_ptr);
+    entry_ptr->display_name = entry.display_name();
+    entries[entry.name()] = std::move(entry_ptr);
   }
   callback.Run(std::move(entries));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Catalog, private:
 
 void Catalog::CompleteResolveMojoName(
     const std::string& resolved_name,
     const std::string& qualifier,
@@ skipping 11 matching lines @@
 #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::CapabilitySpecPtr capabilities_ptr =
-      mojo::shell::mojom::CapabilitySpec::From(entry_iter->second.capabilities);
+      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,
@@ skipping 19 matching lines @@
 void Catalog::DeserializeCatalog() {
   if (!store_)
     return;
   const base::ListValue* catalog = store_->GetStore();
   CHECK(catalog);
   // TODO(sky): make this handle aliases.
   for (auto it = catalog->begin(); it != catalog->end(); ++it) {
     const base::DictionaryValue* dictionary = nullptr;
     const base::Value* v = *it;
     CHECK(v->GetAsDictionary(&dictionary));
-    const Entry entry = BuildEntry(*dictionary);
-    catalog_[entry.name] = entry;
+    Entry entry;
+    if (Entry::DeserializeResult::SUCCESS ==
+        Entry::Deserialize(*dictionary, &entry)) {
+      catalog_[entry.name()] = entry;
+    }
   }
 }
 
 void Catalog::SerializeCatalog() {
   scoped_ptr<base::ListValue> catalog(new base::ListValue);
   for (const auto& entry : catalog_)
-    catalog->Append(SerializeEntry(entry.second));
+    catalog->Append(entry.second.Serialize());
   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;
+Entry::DeserializeResult Catalog::DeserializeApplication(
+    const base::DictionaryValue* dictionary,
+    Entry* out_entry) {
+  Entry entry;
+  Entry::DeserializeResult result =
+      Entry::Deserialize(*dictionary, &entry);
+  if (result != Entry::DeserializeResult::SUCCESS)
+    return result;
+
+  // TODO(beng): move raw dictionary analysis into Deserialize().
+  if (catalog_.find(entry.name()) == catalog_.end()) {
+    catalog_[entry.name()] = entry;
 
     if (dictionary->HasKey("applications")) {
       const base::ListValue* applications = nullptr;
       dictionary->GetList("applications", &applications);
       for (size_t i = 0; i < applications->GetSize(); ++i) {
         const base::DictionaryValue* child_value = nullptr;
         applications->GetDictionary(i, &child_value);
-        const Entry& child = DeserializeApplication(child_value);
-        mojo_name_aliases_[child.name] =
-            std::make_pair(entry.name, child.qualifier);
+        Entry child;
+        if (Entry::DeserializeResult::SUCCESS ==
+            DeserializeApplication(child_value, &child)) {
+          mojo_name_aliases_[child.name()] =
+              std::make_pair(entry.name(), child.qualifier());
+        }
       }
     }
-    qualifiers_[entry.name] = entry.qualifier;
+    qualifiers_[entry.name()] = entry.qualifier();
   }
-  return catalog_[entry.name];
+  if (out_entry)
+    *out_entry = catalog_[entry.name()];
+  return result;
 }
 
 GURL Catalog::GetManifestURL(const std::string& name) {
   // TODO(beng): think more about how this should be done for exe targets.
   std::string type = mojo::GetNameType(name);
   std::string path = mojo::GetNamePath(name);
   if (type == "mojo")
     return system_package_dir_.Resolve(path + "/manifest.json");
   else if (type == "exe")
     return system_package_dir_.Resolve(path + "_manifest.json");
@@ skipping 13 matching lines @@
   }
   catalog->OnReadManifestImpl(name, callback, std::move(manifest));
 }
 
 void Catalog::OnReadManifestImpl(const std::string& name,
                                  const ResolveMojoNameCallback& callback,
                                  scoped_ptr<base::Value> manifest) {
   if (manifest) {
     base::DictionaryValue* dictionary = nullptr;
     CHECK(manifest->GetAsDictionary(&dictionary));
-    DeserializeApplication(dictionary);
+    DeserializeApplication(dictionary, nullptr);
   } else {
     Entry entry;
-    entry.name = name;
-    entry.display_name = name;
-    catalog_[entry.name] = entry;
-    qualifiers_[entry.name] = mojo::GetNamePath(name);
+    entry.set_name(name);
+    entry.set_display_name(name);
+    catalog_[entry.name()] = entry;
+    qualifiers_[entry.name()] = mojo::GetNamePath(name);
   }
   SerializeCatalog();
 
   auto qualifier_iter = qualifiers_.find(name);
   DCHECK(qualifier_iter != qualifiers_.end());
   std::string qualifier = qualifier_iter->second;
   CompleteResolveMojoName(name, qualifier, callback);
 }
 
 }  // namespace catalog