Allow Catalogs to be constructed per-user

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"
@@ skipping 12 matching lines @@
   JSONFileValueDeserializer deserializer(manifest_path);
   int error = 0;
   std::string message;
   // TODO(beng): probably want to do more detailed error checking. This should
   //             be done when figuring out if to unblock connection completion.
   return deserializer.Deserialize(&error, &message);
 }
 
 }  // namespace
 
-Catalog::Catalog(base::TaskRunner* blocking_pool,
-                 scoped_ptr<Store> catalog)
+////////////////////////////////////////////////////////////////////////////////
+// Catalog, public:
+
+Catalog::Catalog(base::TaskRunner* blocking_pool, scoped_ptr<Store> store)
     : blocking_pool_(blocking_pool),
-      store_(std::move(catalog)),
+      store_(std::move(store)),
       weak_factory_(this) {
   base::FilePath shell_dir;
   PathService::Get(base::DIR_MODULE, &shell_dir);
 
   system_package_dir_ =
       mojo::util::FilePathToFileURL(shell_dir).Resolve(std::string());
   system_package_dir_ =
       mojo::util::AddTrailingSlashIfNeeded(system_package_dir_);
 
   DeserializeCatalog();
 }
+
 Catalog::~Catalog() {}
 
-bool Catalog::AcceptConnection(mojo::Connection* connection) {
-  connection->AddInterface<mojom::Catalog>(this);
-  connection->AddInterface<mojom::Resolver>(this);
-  if (connection->GetRemoteIdentity().name() == "mojo:shell")
-    connection->AddInterface<mojo::shell::mojom::ShellResolver>(this);
-  return true;
-}
-
-void Catalog::Create(mojo::Connection* connection,
-                     mojom::ResolverRequest request) {
+void Catalog::BindResolver(mojom::ResolverRequest request) {
   resolver_bindings_.AddBinding(this, std::move(request));
 }
 
-void Catalog::Create(mojo::Connection* connection,
-                     mojo::shell::mojom::ShellResolverRequest request) {
+void Catalog::BindShellResolver(
+    mojo::shell::mojom::ShellResolverRequest request) {
   shell_resolver_bindings_.AddBinding(this, std::move(request));
 }
 
-void Catalog::Create(mojo::Connection* connection,
-                     mojom::CatalogRequest request) {
+void Catalog::BindCatalog(mojom::CatalogRequest request) {
   catalog_bindings_.AddBinding(this, std::move(request));
 }
 
+////////////////////////////////////////////////////////////////////////////////
+// Catalog, mojom::Resolver:
+
 void Catalog::ResolveResponse(mojo::URLResponsePtr response,
                               const ResolveResponseCallback& callback) {
   // TODO(beng): implement.
 }
 
 void Catalog::ResolveInterfaces(mojo::Array<mojo::String> interfaces,
                                 const ResolveInterfacesCallback& callback) {
   // TODO(beng): implement.
 }
 
 void Catalog::ResolveMIMEType(const mojo::String& mime_type,
                               const ResolveMIMETypeCallback& callback) {
   // TODO(beng): implement.
 }
 
 void Catalog::ResolveProtocolScheme(
     const mojo::String& scheme,
     const ResolveProtocolSchemeCallback& callback) {
   // TODO(beng): implement.
 }
 
+////////////////////////////////////////////////////////////////////////////////
+// Catalog, mojo::shell::mojom::ShellResolver:
+
 void Catalog::ResolveMojoName(const mojo::String& mojo_name,
                               const ResolveMojoNameCallback& callback) {
   std::string resolved_name = mojo_name;
   auto alias_iter = mojo_name_aliases_.find(resolved_name);
   if (alias_iter != mojo_name_aliases_.end())
     resolved_name = alias_iter->second.first;
 
   std::string qualifier = mojo::GetNamePath(resolved_name);
   auto qualifier_iter = qualifiers_.find(resolved_name);
   if (qualifier_iter != qualifiers_.end())
     qualifier = qualifier_iter->second;
 
   if (IsNameInCatalog(resolved_name))
     CompleteResolveMojoName(resolved_name, qualifier, callback);
   else
     AddNameToCatalog(resolved_name, callback);
 }
 
+////////////////////////////////////////////////////////////////////////////////
+// Catalog, mojom::Catalog:
+
 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);
   }
   callback.Run(std::move(entries));
 }
 
+////////////////////////////////////////////////////////////////////////////////
+// Catalog, private:
+
 void Catalog::CompleteResolveMojoName(
     const std::string& resolved_name,
     const std::string& qualifier,
     const ResolveMojoNameCallback& callback) {
   auto entry_iter = catalog_.find(resolved_name);
   CHECK(entry_iter != catalog_.end());
 
   GURL file_url;
   std::string type = mojo::GetNameType(resolved_name);
   if (type == "mojo") {
@@ skipping 127 matching lines @@
   }
   SerializeCatalog();
 
   auto qualifier_iter = qualifiers_.find(name);
   DCHECK(qualifier_iter != qualifiers_.end());
   std::string qualifier = qualifier_iter->second;
   CompleteResolveMojoName(name, qualifier, callback);
 }
 
 }  // namespace catalog