Add a instance groups to Connect(), and introduce an Identity struct.

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 19 matching lines @@
 #include "mojo/shell/public/interfaces/shell.mojom.h"
 #include "mojo/shell/public/interfaces/shell_client.mojom.h"
 #include "mojo/util/filename_util.h"
 
 namespace mojo {
 namespace shell {
 namespace {
 const char kPackageManagerName[] = "mojo:package_manager";
 
 void EmptyResolverCallback(const String& resolved_name,
-                           const String& resolved_qualifier,
+                           const String& resolved_instance,
                            mojom::CapabilityFilterPtr base_filter,
                            const String& file_url) {}
 
 }
 
+Identity CreateShellIdentity() {
+  return Identity("mojo:shell", mojom::kRootUserID);
+}
+
+CapabilityFilter GetPermissiveCapabilityFilter() {
+  CapabilityFilter filter;
+  AllowedInterfaces interfaces;
+  interfaces.insert("*");
+  filter["*"] = interfaces;
+  return filter;
+}
+
+AllowedInterfaces GetAllowedInterfaces(const CapabilityFilter& filter,
+                                       const Identity& identity) {
+  // Start by looking for interfaces specific to the supplied identity.
+  auto it = filter.find(identity.name());
+  if (it != filter.end())
+    return it->second;
+
+  // Fall back to looking for a wildcard rule.
+  it = filter.find("*");
+  if (filter.size() == 1 && it != filter.end())
+    return it->second;
+
+  // Finally, nothing is allowed.
+  return AllowedInterfaces();
+}
+
 // Encapsulates a connection to an instance of an application, tracked by the
 // shell's Shell.
 class Shell::Instance : public mojom::Connector,
                         public mojom::PIDReceiver,
                         public ShellClient,
                         public InterfaceFactory<mojom::Shell>,
                         public mojom::Shell {
  public:
   Instance(mojom::ShellClientPtr shell_client,
            mojo::shell::Shell* shell,
-           const Identity& identity)
+           const Identity& identity,
+           const CapabilityFilter& filter)
     : shell_(shell),
       id_(GenerateUniqueID()),
       identity_(identity),
-      allow_any_application_(identity.filter().size() == 1 &&
-      identity.filter().count("*") == 1),
+      filter_(filter),
+      allow_any_application_(filter.size() == 1 && filter.count("*") == 1),
       shell_client_(std::move(shell_client)),
       pid_receiver_binding_(this),
       weak_factory_(this) {
     if (identity_.name() == "mojo:shell" ||
         shell_->GetLoaderForName(identity_.name())) {
       pid_ = base::Process::Current().Pid();
     }
     DCHECK_NE(mojom::kInvalidInstanceID, id_);
   }
 
   ~Instance() override {}
 
   void InitializeClient() {
     shell_client_->Initialize(connectors_.CreateInterfacePtrAndBind(this),
-                              identity_.name(), identity_.user_id(), id_);
+                              mojom::Identity::From(identity_), id_);
     connectors_.set_connection_error_handler(
         base::Bind(&mojo::shell::Shell::OnInstanceError,
                    base::Unretained(shell_), base::Unretained(this)));
   }
 
   void ConnectToClient(scoped_ptr<ConnectParams> params) {
     params->connect_callback().Run(mojom::ConnectResult::SUCCEEDED,
                                    identity_.user_id(), id_);
+    uint32_t source_id = mojom::kInvalidInstanceID;
     AllowedInterfaces interfaces;
     interfaces.insert("*");
-    if (!params->source().is_null())
-      interfaces = GetAllowedInterfaces(params->source().filter(), identity_);
-
     Instance* source = shell_->GetExistingInstance(params->source());
-    uint32_t source_id = source ? source->id() : mojom::kInvalidInstanceID;
+    if (source) {
+      interfaces = GetAllowedInterfaces(source->filter_, identity_);
+      source_id = source->id();
+    }
     shell_client_->AcceptConnection(
-        params->source().name(), params->source().user_id(), source_id,
+        mojom::Identity::From(params->source()), source_id,
         params->TakeRemoteInterfaces(), params->TakeLocalInterfaces(),
         Array<String>::From(interfaces), params->target().name());
   }
 
   scoped_ptr<NativeRunner> StartWithFileURL(const GURL& file_url,
                                             mojom::ShellClientRequest request,
                                             bool start_sandboxed,
                                             NativeRunnerFactory* factory) {
     base::FilePath path = util::UrlToFilePath(file_url);
     scoped_ptr<NativeRunner> runner = factory->Create(path);
     runner_ = runner.get();
     runner_->Start(path, identity_, start_sandboxed, std::move(request),
                    base::Bind(&Instance::PIDAvailable,
                               weak_factory_.GetWeakPtr()),
                    base::Bind(&mojo::shell::Shell::CleanupRunner,
                               shell_->weak_ptr_factory_.GetWeakPtr(),
                               runner_));
     return runner;
   }
 
   mojom::InstanceInfoPtr CreateInstanceInfo() const {
     mojom::InstanceInfoPtr info(mojom::InstanceInfo::New());
     info->id = id_;
-    info->name = identity_.name();
-    info->qualifier = identity_.qualifier();
+    info->identity = mojom::Identity::From(identity_);
     info->pid = pid_;
     return info;
   }
 
   const Identity& identity() const { return identity_; }
   uint32_t id() const { return id_; }
 
   // ShellClient:
   bool AcceptConnection(Connection* connection) override {
     connection->AddInterface<mojom::Shell>(this);
     return true;
   }
 
  private:
   // mojom::Connector implementation:
-  void Connect(const String& app_name,
-               const String& user_id,
-               shell::mojom::InterfaceProviderRequest remote_interfaces,
-               shell::mojom::InterfaceProviderPtr local_interfaces,
+  void Connect(mojom::IdentityPtr target,
+               mojom::InterfaceProviderRequest remote_interfaces,
+               mojom::InterfaceProviderPtr local_interfaces,
                const ConnectCallback& callback) override {
-    if (!IsValidName(app_name)) {
-      LOG(ERROR) << "Error: invalid Name: " << app_name;
+    if (!IsValidName(target->name)) {
+      LOG(ERROR) << "Error: invalid Name: " << target->name;
       callback.Run(mojom::ConnectResult::INVALID_ARGUMENT,
                    mojom::kInheritUserID, mojom::kInvalidInstanceID);
       return;
     }
-    if (!base::IsValidGUID(user_id)) {
-      LOG(ERROR) << "Error: invalid user_id: " << user_id;
+    if (!base::IsValidGUID(target->user_id)) {
+      LOG(ERROR) << "Error: invalid user_id: " << target->user_id;
       callback.Run(mojom::ConnectResult::INVALID_ARGUMENT,
                    mojom::kInheritUserID, mojom::kInvalidInstanceID);
       return;
     }
     // TODO(beng): perform checking on policy of whether this instance is
     // allowed to pass different user_ids.
-    if (allow_any_application_ ||
-        identity_.filter().find(app_name) != identity_.filter().end()) {
+    // TODO(beng): perform checking on policy of whether this instance is
+    // allowed to pass non-empty instance identifiers.
+    if (allow_any_application_ || filter_.find(target->name) != filter_.end()) {
       scoped_ptr<ConnectParams> params(new ConnectParams);
       params->set_source(identity_);
-      params->set_target(Identity(app_name, std::string(), user_id));
+      params->set_target(target.To<Identity>());
       params->set_remote_interfaces(std::move(remote_interfaces));
       params->set_local_interfaces(std::move(local_interfaces));
       params->set_connect_callback(callback);
       shell_->Connect(std::move(params));
     } else {
       LOG(WARNING) << "CapabilityFilter prevented connection from: " <<
-          identity_.name() << " to: " << app_name;
+          identity_.name() << " to: " << target->name;
       callback.Run(mojom::ConnectResult::ACCESS_DENIED,
                    mojom::kInheritUserID, mojom::kInvalidInstanceID);
     }
   }
   void Clone(mojom::ConnectorRequest request) override {
     connectors_.AddBinding(this, std::move(request));
   }
 
   // mojom::PIDReceiver:
   void SetPID(uint32_t pid) override {
     PIDAvailable(pid);
   }
 
   // InterfaceFactory<mojom::Shell>:
   void Create(Connection* connection,
               mojom::ShellRequest request) override {
     shell_bindings_.AddBinding(this, std::move(request));
   }
 
   // mojom::Shell implementation:
   void CreateInstance(mojom::ShellClientFactoryPtr factory,
-                      const String& name,
-                      const String& user_id,
+                      mojom::IdentityPtr target,
                       mojom::CapabilityFilterPtr filter,
                       mojom::PIDReceiverRequest pid_receiver,
                       const CreateInstanceCallback& callback) override {
-    if (!base::IsValidGUID(user_id))
+    if (!base::IsValidGUID(target->user_id))
       callback.Run(mojom::ConnectResult::INVALID_ARGUMENT);
+
+    Identity target_id = target.To<Identity>();
+
     // TODO(beng): perform checking on policy of whether this instance is
     // allowed to pass different user_ids.
-    std::string user_id_string = user_id;
-    if (user_id_string == mojom::kInheritUserID)
-      user_id_string = identity_.user_id();
+    if (target_id.user_id() == mojom::kInheritUserID)
+      target_id.set_user_id(identity_.user_id());
 
+    mojom::ShellClientRequest request;
+    Instance* instance = shell_->CreateInstance(
+        target_id, filter->filter.To<CapabilityFilter>(), &request);
+    instance->pid_receiver_binding_.Bind(std::move(pid_receiver));
+    instance->factory_ = std::move(factory);
+    instance->factory_->CreateShellClient(std::move(request), target->name);
+    callback.Run(mojom::ConnectResult::SUCCEEDED);
     // We don't call ConnectToClient() here since the instance was created
     // manually by other code, not in response to a Connect() request. The newly
     // created instance is identified by |name| and may be subsequently reached
     // by client code using this identity.
-    Identity target_id(name, std::string(), user_id_string);
-    target_id.set_filter(filter->filter.To<CapabilityFilter>());
-    mojom::ShellClientRequest request;
-    Instance* instance = shell_->CreateInstance(target_id, &request);
-    instance->pid_receiver_binding_.Bind(std::move(pid_receiver));
-    instance->factory_ = std::move(factory);
-    instance->factory_->CreateShellClient(std::move(request), name);
-    callback.Run(mojom::ConnectResult::SUCCEEDED);
   }
   void AddInstanceListener(mojom::InstanceListenerPtr listener) override {
     // TODO(beng): this should only track the instances matching this user, and
     // root.
     shell_->AddInstanceListener(std::move(listener));
   }
 
   uint32_t GenerateUniqueID() const {
     static uint32_t id = mojom::kInvalidInstanceID;
     ++id;
     CHECK_NE(mojom::kInvalidInstanceID, id);
     return id;
   }
 
   void PIDAvailable(base::ProcessId pid) {
     pid_ = pid;
     shell_->NotifyPIDAvailable(id_, pid_);
   }
 
   mojo::shell::Shell* const shell_;
   // An id that identifies this instance. Distinct from pid, as a single process
   // may vend multiple application instances, and this object may exist before a
   // process is launched.
   const uint32_t id_;
   const Identity identity_;
+  const CapabilityFilter filter_;
   const bool allow_any_application_;
   mojom::ShellClientPtr shell_client_;
   Binding<mojom::PIDReceiver> pid_receiver_binding_;
   BindingSet<mojom::Connector> connectors_;
   BindingSet<mojom::Shell> shell_bindings_;
   mojom::ShellClientFactoryPtr factory_;
   NativeRunner* runner_ = nullptr;
   base::ProcessId pid_ = base::kNullProcessId;
   base::WeakPtrFactory<Instance> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(Instance);
 };
 
 // static
 Shell::TestAPI::TestAPI(Shell* shell) : shell_(shell) {}
 Shell::TestAPI::~TestAPI() {}
 
 bool Shell::TestAPI::HasRunningInstanceForName(const std::string& name) const {
-  return shell_->identity_to_instance_.find(Identity(name)) !=
-         shell_->identity_to_instance_.end();
+  for (const auto& entry : shell_->identity_to_instance_) {
+    if (entry.first.name() == name)
+      return true;
+  }
+  return false;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Shell, public:
 
 Shell::Shell(scoped_ptr<NativeRunnerFactory> native_runner_factory,
              base::TaskRunner* file_task_runner,
              scoped_ptr<package_manager::ApplicationCatalogStore> app_catalog)
     : file_task_runner_(file_task_runner),
       native_runner_factory_(std::move(native_runner_factory)),
       weak_ptr_factory_(this) {
   mojom::ShellClientRequest request;
-  CreateInstance(CreateShellIdentity(), &request);
+  CreateInstance(CreateShellIdentity(), GetPermissiveCapabilityFilter(),
+                 &request);
   shell_connection_.reset(new ShellConnection(this, std::move(request)));
 
   InitPackageManager(std::move(app_catalog));
 }
 
 Shell::~Shell() {
   TerminateShellConnections();
   STLDeleteValues(&name_to_loader_);
   for (auto& runner : native_runners_)
     runner.reset();
@@ skipping 12 matching lines @@
 
   if (params->target().user_id() == mojom::kInheritUserID) {
     Instance* source = GetExistingInstance(params->source());
     Identity target = params->target();
     // TODO(beng): we should CHECK source.
     target.set_user_id(source ? source->identity().user_id()
                               : mojom::kRootUserID);
     params->set_target(target);
   }
 
+  CHECK(params->target().user_id() != mojom::kInheritUserID);
+
   // Connect to an existing matching instance, if possible.
   if (ConnectToExistingInstance(&params))
     return;
 
   std::string name = params->target().name();
   shell_resolver_->ResolveMojoName(
       name,
       base::Bind(&Shell::OnGotResolvedName,
                  weak_ptr_factory_.GetWeakPtr(), base::Passed(&params)));
 }
 
 mojom::ShellClientRequest Shell::InitInstanceForEmbedder(
     const std::string& name) {
   DCHECK(!embedder_instance_);
 
-  mojo::shell::Identity target(name, std::string(), mojom::kRootUserID);
-  target.set_filter(GetPermissiveCapabilityFilter());
+  Identity target(name, mojom::kRootUserID);
   DCHECK(!GetExistingInstance(target));
 
   mojom::ShellClientRequest request;
-  embedder_instance_ = CreateInstance(target, &request);
+  embedder_instance_ = CreateInstance(
+      target, GetPermissiveCapabilityFilter(), &request);
   DCHECK(embedder_instance_);
 
   return request;
 }
 
 void Shell::SetLoaderForName(scoped_ptr<Loader> loader,
                              const std::string& name) {
   NameToLoaderMap::iterator it = name_to_loader_.find(name);
   if (it != name_to_loader_.end())
     delete it->second;
@@ skipping 24 matching lines @@
 
 void Shell::InitPackageManager(
     scoped_ptr<package_manager::ApplicationCatalogStore> app_catalog) {
   scoped_ptr<Loader> loader(
       new package_manager::Loader(file_task_runner_, std::move(app_catalog)));
   Loader* loader_raw = loader.get();
   std::string name = kPackageManagerName;
   SetLoaderForName(std::move(loader), name);
 
   mojom::ShellClientRequest request;
-  CreateInstance(Identity(name), &request);
+  // TODO(beng): Does the package manager actually have to be run with a
+  //             permissive filter?
+  Identity identity(name, mojom::kRootUserID);
+  CreateInstance(identity, GetPermissiveCapabilityFilter(), &request);
   loader_raw->Load(name, std::move(request));
 
   ConnectToInterface(this, CreateShellIdentity(), name, &shell_resolver_);
 
   // Seed the catalog with manifest info for the shell & package manager.
   if (file_task_runner_) {
     shell_resolver_->ResolveMojoName(name, base::Bind(&EmptyResolverCallback));
     shell_resolver_->ResolveMojoName("mojo:shell",
                                      base::Bind(&EmptyResolverCallback));
   }
@@ skipping 35 matching lines @@
     Identity root_identity = (*params)->target();
     root_identity.set_user_id(mojom::kRootUserID);
     instance = GetExistingInstance(root_identity);
     if (!instance) return false;
   }
   instance->ConnectToClient(std::move(*params));
   return true;
 }
 
 Shell::Instance* Shell::CreateInstance(const Identity& target_id,
+                                       const CapabilityFilter& filter,
                                        mojom::ShellClientRequest* request) {
+  CHECK(target_id.user_id() != mojom::kInheritUserID);
   mojom::ShellClientPtr shell_client;
   *request = GetProxy(&shell_client);
-  Instance* instance = new Instance(std::move(shell_client), this, target_id);
+  Instance* instance =
+      new Instance(std::move(shell_client), this, target_id, filter);
   DCHECK(identity_to_instance_.find(target_id) ==
          identity_to_instance_.end());
   identity_to_instance_[target_id] = instance;
   mojom::InstanceInfoPtr info = instance->CreateInstanceInfo();
   instance_listeners_.ForAllPtrs(
       [this, &info](mojom::InstanceListener* listener) {
         listener->InstanceCreated(info.Clone());
       });
   instance->InitializeClient();
   return instance;
@@ skipping 40 matching lines @@
 
 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,
                               const String& resolved_name,
-                              const String& resolved_qualifier,
+                              const String& resolved_instance,
                               mojom::CapabilityFilterPtr base_filter,
                               const String& file_url) {
-  std::string qualifier = params->target().qualifier();
-  if (qualifier == GetNamePath(params->target().name()))
-    qualifier = resolved_qualifier;
-  Identity target(params->target().name(), qualifier,
-                  params->target().user_id());
+  std::string instance_name = params->target().instance();
+  if (instance_name == GetNamePath(params->target().name()))
+    instance_name = resolved_instance;
+  Identity target(params->target().name(), params->target().user_id(),
+                  instance_name);
   params->set_target(target);
 
   // It's possible that when this manifest request was issued, another one was
   // already in-progress and completed by the time this one did, and so the
   // requested application may already be running.
   if (ConnectToExistingInstance(&params))
     return;
 
   Identity source = params->source();
   // |base_filter| can be null when there is no manifest, e.g. for URL types
   // not resolvable by the resolver.
   CapabilityFilter filter = GetPermissiveCapabilityFilter();
   if (!base_filter.is_null())
     filter = base_filter->filter.To<CapabilityFilter>();
-  target.set_filter(filter);
 
   mojom::ShellClientRequest request;
-  Instance* instance = CreateInstance(target, &request);
+  Instance* instance = CreateInstance(target, filter, &request);
   instance->ConnectToClient(std::move(params));
 
   if (LoadWithLoader(target, &request))
     return;
 
   CHECK(!file_url.is_null() && !base_filter.is_null());
 
   if (target.name() != resolved_name) {
-    // In cases where a package alias is resolved, we have to use the qualifier
+    // In cases where a package alias is resolved, we have to use the instance
     // from the original request rather than for the package itself, which will
     // always be the same.
     CreateShellClient(
-        source, Identity(resolved_name, resolved_qualifier, target.user_id()),
+        source, Identity(resolved_name, target.user_id(), resolved_instance),
         target.name(), std::move(request));
   } else {
     bool start_sandboxed = false;
     native_runners_.push_back(
         instance->StartWithFileURL(file_url.To<GURL>(), std::move(request),
                                    start_sandboxed,
                                    native_runner_factory_.get()));
   }
 }
 
@@ skipping 17 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