Use a static catalog manifest for the standalone Mash runner

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 "services/catalog/catalog.h"
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/macros.h"
@@ skipping 68 matching lines @@
     registry->AddInterface<service_manager::mojom::Resolver>(catalog_);
     return true;
   }
 
  private:
   Catalog* const catalog_;
 
   DISALLOW_COPY_AND_ASSIGN(ServiceImpl);
 };
 
+Catalog::Catalog(std::unique_ptr<base::Value> static_manifest) : Catalog() {
+  system_reader_.reset(new Reader(std::move(static_manifest), &system_cache_));
+  loaded_ = true;
+}
+
 Catalog::Catalog(base::SequencedWorkerPool* worker_pool,
-                 std::unique_ptr<Store> store,
-                 ManifestProvider* manifest_provider)
-    : Catalog(std::move(store)) {
+                 ManifestProvider* manifest_provider) : Catalog() {
   system_reader_.reset(new Reader(worker_pool, manifest_provider));
   ScanSystemPackageDir();
 }
 
 Catalog::Catalog(base::SingleThreadTaskRunner* task_runner,
-                 std::unique_ptr<Store> store,
-                 ManifestProvider* manifest_provider)
-    : Catalog(std::move(store)) {
+                 ManifestProvider* manifest_provider) : Catalog() {
   system_reader_.reset(new Reader(task_runner, manifest_provider));
   ScanSystemPackageDir();
 }
 
 Catalog::~Catalog() {}
 
 void Catalog::OverridePackageName(const std::string& service_name,
                                   const std::string& package_name) {
   system_reader_->OverridePackageName(service_name, package_name);
 }
 
 service_manager::mojom::ServicePtr Catalog::TakeService() {
   return std::move(service_);
 }
 
-Catalog::Catalog(std::unique_ptr<Store> store)
-    : store_(std::move(store)), weak_factory_(this) {
-  service_manager::mojom::ServiceRequest request(&service_);
+Catalog::Catalog() : weak_factory_(this) {
   service_context_.reset(new service_manager::ServiceContext(
-      base::MakeUnique<ServiceImpl>(this), std::move(request)));
+      base::MakeUnique<ServiceImpl>(this),
+      service_manager::mojom::ServiceRequest(&service_)));
 }
 
 void Catalog::ScanSystemPackageDir() {
   base::FilePath system_package_dir;
   PathService::Get(base::DIR_MODULE, &system_package_dir);
   system_package_dir = system_package_dir.AppendASCII(kPackagesDirName);
   system_reader_->Read(system_package_dir, &system_cache_,
                        base::Bind(&Catalog::SystemPackageDirScanned,
                                   weak_factory_.GetWeakPtr()));
 }
@@ skipping 34 matching lines @@
     const OverrideManifestPathCallback& callback) {
   system_reader_->OverrideManifestPath(service_name, path);
   callback.Run();
 }
 
 Instance* Catalog::GetInstanceForUserId(const std::string& user_id) {
   auto it = instances_.find(user_id);
   if (it != instances_.end())
     return it->second.get();
 
-  // TODO(beng): There needs to be a way to load the store from different users.
-  Instance* instance = new Instance(std::move(store_), system_reader_.get());
+  Instance* instance = new Instance(system_reader_.get());
   instances_[user_id] = base::WrapUnique(instance);
   if (loaded_)
     instance->CacheReady(&system_cache_);
 
   return instance;
 }
 
 void Catalog::SystemPackageDirScanned() {
   loaded_ = true;
   for (auto& instance : instances_)
     instance.second->CacheReady(&system_cache_);
 }
 
 }  // namespace catalog