Mash: Replaces "exe:chrome" with "service:content_browser"

services/catalog/reader.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/reader.h"
 
 #include "base/bind.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_util.h"
 #include "base/json/json_file_value_serializer.h"
@@ skipping 103 matching lines @@
     }
 
     original_thread_task_runner->PostTask(
         FROM_HERE,
         base::Bind(read_manifest_callback, base::Passed(&entry)));
   }
 
   original_thread_task_runner->PostTask(FROM_HERE, read_complete_closure);
 }
 
-std::unique_ptr<Entry> ReadManifest(const base::FilePath& package_dir,
-                                    const std::string& mojo_name) {
-  std::unique_ptr<Entry> entry = CreateEntryForManifestAt(
-      GetManifestPath(package_dir, mojo_name), package_dir);
+std::unique_ptr<Entry> ReadManifest(
+    const base::FilePath& package_dir,
+    const std::string& mojo_name,
+    const base::FilePath& manifest_path_override) {
+  base::FilePath manifest_path;
+  if (manifest_path_override.empty())
+    manifest_path = GetManifestPath(package_dir, mojo_name);
+  else
+    manifest_path = manifest_path_override;
+
+  std::unique_ptr<Entry> entry = CreateEntryForManifestAt(manifest_path,
+                                                          package_dir);
   if (!entry) {
     entry.reset(new Entry(mojo_name));
     entry->set_path(GetExecutablePath(
         package_dir.AppendASCII(kPackagesDirName), mojo_name));
   }
   return entry;
 }
 
 void AddEntryToCache(EntryCache* cache, std::unique_ptr<Entry> entry) {
   std::vector<std::unique_ptr<Entry>> children = entry->TakeChildren();
@@ skipping 47 matching lines @@
     if (manifest_root) {
       base::PostTaskAndReplyWithResult(
           file_task_runner_.get(), FROM_HERE,
           base::Bind(&ProcessManifest, base::Passed(&manifest_root),
                      system_package_dir_),
           base::Bind(&Reader::OnReadManifest, weak_factory_.GetWeakPtr(), cache,
                      entry_created_callback));
       return;
     }
   }
+
+  base::FilePath manifest_path_override;
+  auto override_iter = manifest_path_overrides_.find(mojo_name);
+  if (override_iter != manifest_path_overrides_.end())
+    manifest_path_override = override_iter->second;
+
   base::PostTaskAndReplyWithResult(
       file_task_runner_.get(), FROM_HERE,
-      base::Bind(&ReadManifest, system_package_dir_, mojo_name),
+      base::Bind(&ReadManifest, system_package_dir_, mojo_name,
+                 manifest_path_override),
       base::Bind(&Reader::OnReadManifest, weak_factory_.GetWeakPtr(), cache,
                   entry_created_callback));
 }
 
+void Reader::OverrideManifestPath(const std::string& service_name,
+                                  const base::FilePath& path) {
+  manifest_path_overrides_.insert(std::make_pair(service_name, path));
+}
+
 Reader::Reader(ManifestProvider* manifest_provider)
     : manifest_provider_(manifest_provider), weak_factory_(this) {
   PathService::Get(base::DIR_MODULE, &system_package_dir_);
 }
 
 void Reader::OnReadManifest(
     EntryCache* cache,
     const CreateEntryForNameCallback& entry_created_callback,
     std::unique_ptr<Entry> entry) {
   if (!entry)
     return;
   shell::mojom::ResolveResultPtr result =
       shell::mojom::ResolveResult::From(*entry);
   AddEntryToCache(cache, std::move(entry));
   entry_created_callback.Run(std::move(result));
 }
 
 }  // namespace catalog