Files required by a service now listed in manifest.

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/files/file_path.h"
 #include "base/memory/ptr_util.h"
 #include "base/path_service.h"
 #include "base/values.h"
+#include "services/catalog/public/cpp/manifest_parsing_util.h"
 #include "services/catalog/store.h"
 
 namespace catalog {
 namespace {
 
 #if defined(OS_WIN)
 const char kServiceExecutableExtension[] = ".service.exe";
 #else
 const char kServiceExecutableExtension[] = ".service";
 #endif
@@ skipping 81 matching lines @@
 }
 
 }  // namespace
 
 Entry::Entry() {}
 Entry::Entry(const std::string& name)
     : name_(name),
       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_);
-
-  auto specs = 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 : 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));
-  }
-  value->Set(Store::kInterfaceProviderSpecsKey, std::move(specs));
-  return value;
-}
-
 // static
 std::unique_ptr<Entry> Entry::Deserialize(const base::Value& manifest_root) {
   const base::DictionaryValue* dictionary_value = nullptr;
   if (!manifest_root.GetAsDictionary(&dictionary_value))
     return nullptr;
   const base::DictionaryValue& value = *dictionary_value;
 
   auto entry = base::MakeUnique<Entry>();
 
   // Name.
@@ skipping 45 matching lines @@
 
     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);
   }
 
+  // Required files.
+  base::Optional<RequiredFileMap> required_files =
+      catalog::RetrieveRequiredFiles(value);
+  DCHECK(required_files);
+  for (const auto& iter : *required_files) {
+    entry->AddRequiredFilePath(iter.first, iter.second);
+  }
+
   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_parent(entry.get());
         entry->children().emplace_back(std::move(child));
@@ skipping 20 matching lines @@
          other.display_name_ == display_name_ &&
          other.interface_provider_specs_ == interface_provider_specs_;
 }
 
 void Entry::AddInterfaceProviderSpec(
     const std::string& name,
     const service_manager::InterfaceProviderSpec& spec) {
   interface_provider_specs_[name] = spec;
 }
 
+void Entry::AddRequiredFilePath(const std::string& name,
+                                const base::FilePath& path) {
+  required_file_paths_[name] = path;
+}
+
 }  // catalog
 
 namespace mojo {
 
 // static
 service_manager::mojom::ResolveResultPtr
 TypeConverter<service_manager::mojom::ResolveResultPtr, const catalog::Entry*>
     ::Convert(const catalog::Entry* input) {
   service_manager::mojom::ResolveResultPtr result;
   if (input) {
     result = service_manager::mojom::ResolveResult::New();
     result->name = input->name();
     result->interface_provider_specs = input->interface_provider_specs();
     result->package_path = input->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