Allow Catalogs to be constructed per-user

mojo/shell/shell.cc

 // Copyright 2014 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/shell/shell.h"
 
 #include <stdint.h>
 
 #include <utility>
 
@@ skipping 33 matching lines @@
                            const String& resolved_instance,
                            mojom::CapabilitySpecPtr capabilities,
                            const String& file_url) {}
 
 }
 
 Identity CreateShellIdentity() {
   return Identity(kShellName, mojom::kRootUserID);
 }
 
+Identity CreateCatalogIdentity() {
+  return Identity(kCatalogName, mojom::kRootUserID);
+}
+
 CapabilitySpec GetPermissiveCapabilities() {
   CapabilitySpec capabilities;
   CapabilityRequest spec;
   spec.interfaces.insert("*");
   capabilities.required["*"] = spec;
   return capabilities;
 }
 
 CapabilityRequest GetCapabilityRequest(const CapabilitySpec& source_spec,
                                        const Identity& target) {
@@ skipping 417 matching lines @@
     }
   }
   DCHECK(instance);
   return instance->AcceptConnection(connection);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Shell, private:
 
 void Shell::InitCatalog(mojom::ShellClientPtr catalog) {
-  Identity identity(kCatalogName, mojom::kRootUserID);
-  CreateInstance(identity, CapabilitySpec(), std::move(catalog));
-  shell_connection_->connector()->ConnectToInterface(
-      kCatalogName, &shell_resolver_);
+  CreateInstance(CreateCatalogIdentity(), CapabilitySpec(), std::move(catalog));
 
+  // TODO(beng): this doesn't work anymore.
   // Seed the catalog with manifest info for the shell & catalog.
-  shell_resolver_->ResolveMojoName(
-      kCatalogName, base::Bind(&EmptyResolverCallback));
-  shell_resolver_->ResolveMojoName(
-      kShellName, base::Bind(&EmptyResolverCallback));
+  mojo::shell::mojom::ShellResolverPtr resolver;
+  shell_connection_->connector()->ConnectToInterface(kCatalogName, &resolver);
+  resolver->ResolveMojoName(kCatalogName, base::Bind(&EmptyResolverCallback));
+  resolver->ResolveMojoName(kShellName, base::Bind(&EmptyResolverCallback));
 }
 
 void Shell::TerminateShellConnections() {
   STLDeleteValues(&identity_to_instance_);
 }
 
 void Shell::OnInstanceError(Instance* instance) {
   const Identity identity = instance->identity();
   // Remove the shell.
   auto it = identity_to_instance_.find(identity);
@@ skipping 15 matching lines @@
                        params->target().name());
   DCHECK(IsValidName(params->target().name()));
   DCHECK(base::IsValidGUID(params->target().user_id()));
   DCHECK_NE(mojom::kInheritUserID, params->target().user_id());
   DCHECK(!client.is_bound() || !identity_to_instance_.count(params->target()));
 
   // Connect to an existing matching instance, if possible.
   if (!client.is_bound() && ConnectToExistingInstance(&params))
     return;
 
+  // The catalog needs to see the source identity as that of the originating
+  // app so it loads the correct store. Since the catalog is itself run as root
+  // when this re-enters Connect() it'll be handled by
+  // ConnectToExistingInstance().
+  mojom::ShellResolverPtr resolver;
+  ConnectToInterface(this, Identity(kShellName, params->target().user_id()),
+                     CreateCatalogIdentity(), &resolver);
+
   std::string name = params->target().name();
-  shell_resolver_->ResolveMojoName(
+  mojom::ShellResolver* resolver_raw = resolver.get();
+  resolver_raw->ResolveMojoName(
       name,
-      base::Bind(&Shell::OnGotResolvedName,
-                 weak_ptr_factory_.GetWeakPtr(), base::Passed(&params),
+      base::Bind(&Shell::OnGotResolvedName, weak_ptr_factory_.GetWeakPtr(),
+                 base::Passed(std::move(resolver)), base::Passed(&params),
                  base::Passed(&client)));
 }
 
 Shell::Instance* Shell::GetExistingInstance(const Identity& identity) const {
   const auto& it = identity_to_instance_.find(identity);
   return it != identity_to_instance_.end() ? it->second : nullptr;
 }
 
 Shell::Instance* Shell::GetExistingOrRootInstance(
     const Identity& identity) const {
@@ skipping 74 matching lines @@
   return factory_interface;
 }
 
 void Shell::OnShellClientFactoryLost(const Identity& which) {
   // Remove the mapping.
   auto it = shell_client_factories_.find(which);
   DCHECK(it != shell_client_factories_.end());
   shell_client_factories_.erase(it);
 }
 
-void Shell::OnGotResolvedName(scoped_ptr<ConnectParams> params,
+void Shell::OnGotResolvedName(mojom::ShellResolverPtr resolver,
+                              scoped_ptr<ConnectParams> params,
                               mojom::ShellClientPtr client,
                               const String& resolved_name,
                               const String& resolved_instance,
                               mojom::CapabilitySpecPtr capabilities_ptr,
                               const String& file_url) {
   std::string instance_name = params->target().instance();
   if (instance_name == GetNamePath(params->target().name()) &&
       resolved_instance != GetNamePath(resolved_name)) {
     instance_name = resolved_instance;
   }
@@ skipping 74 matching lines @@
   for (auto it = native_runners_.begin(); it != native_runners_.end(); ++it) {
     if (it->get() == runner) {
       native_runners_.erase(it);
       return;
     }
   }
 }
 
 }  // namespace shell
 }  // namespace mojo