Use a static catalog manifest for the standalone Mash runner

services/catalog/reader.cc

Index: services/catalog/reader.cc
diff --git a/services/catalog/reader.cc b/services/catalog/reader.cc
index 67b15d37a6a935e245d2ff30b5a7540400685d6d..e435d171a26e528f7190ec32c760bdd2d401dc36 100644
--- a/services/catalog/reader.cc
+++ b/services/catalog/reader.cc
@@ -4,6 +4,7 @@
 
 #include "services/catalog/reader.h"
 
+#include "base/base_paths.h"
 #include "base/bind.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_util.h"
@@ -11,8 +12,11 @@
 #include "base/json/json_reader.h"
 #include "base/memory/ptr_util.h"
 #include "base/path_service.h"
+#include "base/strings/string_util.h"
+#include "base/strings/utf_string_conversions.h"
 #include "base/task_runner_util.h"
 #include "base/threading/thread_task_runner_handle.h"
+#include "base/values.h"
 #include "services/catalog/constants.h"
 #include "services/catalog/entry.h"
 #include "services/catalog/manifest_provider.h"
@@ -28,6 +32,11 @@ const char kServiceExecutableExtension[] = ".service.exe";
 const char kServiceExecutableExtension[] = ".service";
 #endif
 
+const char kCatalogServicesKey[] = "services";
+const char kCatalogServiceEmbeddedKey[] = "embedded";
+const char kCatalogServiceExecutableKey[] = "executable";
+const char kCatalogServiceManifestKey[] = "manifest";
+
 base::FilePath GetManifestPath(const base::FilePath& package_dir,
                                const std::string& name,
                                const std::string& package_name_override) {
@@ -44,9 +53,10 @@ base::FilePath GetExecutablePath(const base::FilePath& package_dir,
       name + "/" + name + kServiceExecutableExtension);
 }
 
-std::unique_ptr<Entry> ProcessManifest(
-    std::unique_ptr<base::Value> manifest_root,
-    const base::FilePath& package_dir) {
+std::unique_ptr<Entry> ProcessManifest(const base::Value* manifest_root,
+                                       const base::FilePath& package_dir,
+                                       const base::FilePath& executable_path) {
+
   // Manifest was malformed or did not exist.
   if (!manifest_root)
     return nullptr;
@@ -58,10 +68,19 @@ std::unique_ptr<Entry> ProcessManifest(
   std::unique_ptr<Entry> entry = Entry::Deserialize(*dictionary);
   if (!entry)
     return nullptr;
-  entry->set_path(GetExecutablePath(package_dir, entry->name()));
+  if (!executable_path.empty())
+    entry->set_path(executable_path);
+  else
+    entry->set_path(GetExecutablePath(package_dir, entry->name()));
   return entry;
 }
 
+std::unique_ptr<Entry> ProcessUniqueManifest(
+    std::unique_ptr<base::Value> manifest_root,
+    const base::FilePath& package_dir) {
+  return ProcessManifest(manifest_root.get(), package_dir, base::FilePath());
+}
+
 std::unique_ptr<Entry> CreateEntryForManifestAt(
     const base::FilePath& manifest_path,
     const base::FilePath& package_dir) {
@@ -71,8 +90,8 @@ std::unique_ptr<Entry> CreateEntryForManifestAt(
 
   // TODO(beng): probably want to do more detailed error checking. This should
   //             be done when figuring out if to unblock connection completion.
-  return ProcessManifest(deserializer.Deserialize(&error, &message),
-                         package_dir);
+  return ProcessUniqueManifest(deserializer.Deserialize(&error, &message),
+                               package_dir);
 }
 
 void ScanDir(
@@ -142,8 +161,87 @@ void AddEntryToCache(EntryCache* cache, std::unique_ptr<Entry> entry) {
 
 void DoNothing(service_manager::mojom::ResolveResultPtr) {}
 
+void LoadCatalogManifestIntoCache(const base::Value* root,
+                                  const base::FilePath& package_dir,
+                                  EntryCache* cache) {
+  DCHECK(root);
+  const base::DictionaryValue* catalog = nullptr;
+  if (!root->GetAsDictionary(&catalog)) {
+    LOG(ERROR) << "Catalog manifest is not a dictionary value.";
+    return;
+  }
+  DCHECK(catalog);
+
+  const base::DictionaryValue* services = nullptr;
+  if (!catalog->GetDictionary(kCatalogServicesKey, &services)) {
+    LOG(ERROR) << "Catalog manifest \"services\" is not a dictionary value.";
+    return;
+  }
+
+  for (base::DictionaryValue::Iterator it(*services); !it.IsAtEnd();
+       it.Advance()) {
+    const base::DictionaryValue* service_entry = nullptr;
+    if (!it.value().GetAsDictionary(&service_entry)) {
+      LOG(ERROR) << "Catalog service entry for \"" << it.key()
+                 << "\" is not a dictionary value.";
+      continue;
+    }
+
+    bool is_embedded = false;
+    service_entry->GetBoolean(kCatalogServiceEmbeddedKey, &is_embedded);
+
+    base::FilePath executable_path;
+    std::string executable_path_string;
+    if (service_entry->GetString(kCatalogServiceExecutableKey,
+                                 &executable_path_string)) {
+      base::FilePath exe_dir;
+      CHECK(base::PathService::Get(base::DIR_EXE, &exe_dir));
+#if defined(OS_WIN)
+      executable_path_string += ".exe";
+      base::ReplaceFirstSubstringAfterOffset(
+          &executable_path_string, 0, "@EXE_DIR",
+          base::UTF16ToUTF8(exe_dir.value()));
+      executable_path =
+          base::FilePath(base::UTF8ToUTF16(executable_path_string));
+#else
+      base::ReplaceFirstSubstringAfterOffset(
+          &executable_path_string, 0, "@EXE_DIR", exe_dir.value());
+      executable_path = base::FilePath(executable_path_string);
+#endif
+    }
+
+    const base::DictionaryValue* manifest = nullptr;
+    if (!service_entry->GetDictionary(kCatalogServiceManifestKey, &manifest)) {
+      LOG(ERROR) << "Catalog entry for \"" << it.key() << "\" has an invalid "
+                 << "\"manifest\" value.";
+      continue;
+    }
+
+    DCHECK(!(is_embedded && !executable_path.empty()));
+
+    auto entry = ProcessManifest(
+        manifest, is_embedded ? base::FilePath() : package_dir,
+        executable_path);
+    if (entry)
+      AddEntryToCache(cache, std::move(entry));
+    else
+      LOG(ERROR) << "Failed to read manifest entry for \"" << it.key() << "\".";
+  }
+}
+
 }  // namespace
 
+Reader::Reader(std::unique_ptr<base::Value> static_manifest,
+               EntryCache* cache)
+    : using_static_catalog_(true),
+      manifest_provider_(nullptr),
+      weak_factory_(this) {
+  PathService::Get(base::DIR_MODULE, &system_package_dir_);
+  LoadCatalogManifestIntoCache(
+      static_manifest.get(), system_package_dir_.AppendASCII(kPackagesDirName),
+      cache);
+}
+
 // A sequenced task runner is used to guarantee requests are serviced in the
 // order requested. To do otherwise means we may run callbacks in an
 // unpredictable order, leading to flake.
@@ -185,12 +283,17 @@ void Reader::CreateEntryForName(
     if (manifest_root) {
       base::PostTaskAndReplyWithResult(
           file_task_runner_.get(), FROM_HERE,
-          base::Bind(&ProcessManifest, base::Passed(&manifest_root),
+          base::Bind(&ProcessUniqueManifest, base::Passed(&manifest_root),
                      system_package_dir_),
           base::Bind(&Reader::OnReadManifest, weak_factory_.GetWeakPtr(), cache,
                      entry_created_callback));
       return;
     }
+  } else if (using_static_catalog_) {
+    // A Reader using a static catalog manifest does not support dynamic
+    // discovery or introduction of new catalog entries.
+    entry_created_callback.Run(service_manager::mojom::ResolveResultPtr());
+    return;
   }
 
   base::FilePath manifest_path_override;
@@ -225,7 +328,9 @@ void Reader::OverrideManifestPath(const std::string& service_name,
 }
 
 Reader::Reader(ManifestProvider* manifest_provider)
-    : manifest_provider_(manifest_provider), weak_factory_(this) {
+    : using_static_catalog_(false),
+      manifest_provider_(manifest_provider),
+      weak_factory_(this) {
   PathService::Get(base::DIR_MODULE, &system_package_dir_);
 }