Morph CapabilityFilter into caps::Capabilities, which supports capability classes (yet unimplemente…

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 20 matching lines @@
 #include "mojo/shell/public/interfaces/shell_client.mojom.h"
 #include "mojo/util/filename_util.h"
 
 namespace mojo {
 namespace shell {
 namespace {
 const char kCatalogName[] = "mojo:catalog";
 
 void EmptyResolverCallback(const String& resolved_name,
                            const String& resolved_instance,
-                           mojom::CapabilityFilterPtr base_filter,
+                           mojom::CapabilitySpecPtr capabilities,
                            const String& file_url) {}
 
 }
 
 Identity CreateShellIdentity() {
   return Identity("mojo:shell", mojom::kRootUserID);
 }
 
-CapabilityFilter GetPermissiveCapabilityFilter() {
-  CapabilityFilter filter;
-  AllowedInterfaces interfaces;
-  interfaces.insert("*");
-  filter["*"] = interfaces;
-  return filter;
+CapabilitySpec GetPermissiveCapabilities() {
+  CapabilitySpec capabilities;
+  CapabilityRequest spec;
+  spec.interfaces.insert("*");
+  capabilities.required["*"] = spec;
+  return capabilities;
 }
 
-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())
+CapabilityRequest GetCapabilityRequest(const CapabilitySpec& spec,
+                                             const Identity& identity) {
+  // Start by looking for specs specific to the supplied identity.
+  auto it = spec.required.find(identity.name());
+  if (it != spec.required.end())
     return it->second;
 
   // Fall back to looking for a wildcard rule.
-  it = filter.find("*");
-  if (filter.size() == 1 && it != filter.end())
+  it = spec.required.find("*");
+  if (spec.required.size() == 1 && it != spec.required.end())
     return it->second;
 
   // Finally, nothing is allowed.
-  return AllowedInterfaces();
+  return CapabilityRequest();
 }
 
 // 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 CapabilityFilter& filter)
+           const CapabilitySpec& capabilities)
     : shell_(shell),
       id_(GenerateUniqueID()),
       identity_(identity),
-      filter_(filter),
-      allow_any_application_(filter.size() == 1 && filter.count("*") == 1),
+      capabilities_(capabilities),
+      allow_any_application_(capabilities.required.size() == 1 &&
+                             capabilities.required.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),
                               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("*");
+    CapabilityRequest spec;
+    spec.interfaces.insert("*");
     Instance* source = shell_->GetExistingInstance(params->source());
     if (source) {
-      interfaces = GetAllowedInterfaces(source->filter_, identity_);
+      spec = GetCapabilityRequest(source->capabilities_, identity_);
       source_id = source->id();
     }
     shell_client_->AcceptConnection(
         mojom::Identity::From(params->source()), source_id,
         params->TakeRemoteInterfaces(), params->TakeLocalInterfaces(),
-        Array<String>::From(interfaces), params->target().name());
+        mojom::CapabilityRequest::From(spec), params->target().name());
   }
 
   void StartWithClientProcessConnection(
       mojom::ShellClientRequest request,
       mojom::ClientProcessConnectionPtr client_process_connection) {
     factory_.Bind(mojom::ShellClientFactoryPtrInfo(
         std::move(client_process_connection->shell_client_factory), 0u));
     pid_receiver_binding_.Bind(
         std::move(client_process_connection->pid_receiver_request));
     factory_->CreateShellClient(std::move(request), identity_.name());
@@ skipping 42 matching lines @@
       return;
     if (!ValidateClientProcessConnection(&client_process_connection, target,
                                          callback)) {
       return;
     }
     // TODO(beng): Need to do the following additional policy validation of
     // whether this instance is allowed to connect using:
     // - a user id other than its own, kInheritUserID or kRootUserID.
     // - a non-empty instance name.
     // - a non-null client_process_connection.
-    if (!ValidateCapabilityFilter(target, callback))
+    if (!ValidateCapabilities(target, callback))
       return;
 
     scoped_ptr<ConnectParams> params(new ConnectParams);
     params->set_source(identity_);
     params->set_target(target);
     params->set_remote_interfaces(std::move(remote_interfaces));
     params->set_local_interfaces(std::move(local_interfaces));
     params->set_client_process_connection(std::move(client_process_connection));
     params->set_connect_callback(callback);
     shell_->Connect(std::move(params));
@@ skipping 57 matching lines @@
                    << identity.user_id() << " Instance: "
                    << identity.instance();
         callback.Run(mojom::ConnectResult::INVALID_ARGUMENT,
                      mojom::kInheritUserID, mojom::kInvalidInstanceID);
         return false;
       }
     }
     return true;
   }
 
-  bool ValidateCapabilityFilter(const Identity& target,
-                                const ConnectCallback& callback) {
+  bool ValidateCapabilities(const Identity& target,
+                            const ConnectCallback& callback) {
     if (allow_any_application_ ||
-        filter_.find(target.name()) != filter_.end()) {
+        capabilities_.required.find(target.name()) !=
+            capabilities_.required.end()) {
       return true;
     }
-    LOG(ERROR) << "CapabilityFilter prevented connection from: " <<
+    LOG(ERROR) << "Capabilities prevented connection from: " <<
                   identity_.name() << " to: " << target.name();
     callback.Run(mojom::ConnectResult::ACCESS_DENIED,
                  mojom::kInheritUserID, mojom::kInvalidInstanceID);
     return false;
   }
 
   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 CapabilitySpec capabilities_;
   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_;
 
@@ skipping 15 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 // Shell, public:
 
 Shell::Shell(scoped_ptr<NativeRunnerFactory> native_runner_factory,
              base::TaskRunner* file_task_runner,
              scoped_ptr<catalog::Store> catalog_store)
     : file_task_runner_(file_task_runner),
       native_runner_factory_(std::move(native_runner_factory)),
       weak_ptr_factory_(this) {
   mojom::ShellClientRequest request;
-  CreateInstance(CreateShellIdentity(), GetPermissiveCapabilityFilter(),
-                 &request);
+  CreateInstance(CreateShellIdentity(), GetPermissiveCapabilities(), &request);
   shell_connection_.reset(new ShellConnection(this, std::move(request)));
 
   InitCatalog(std::move(catalog_store));
 }
 
 Shell::~Shell() {
   TerminateShellConnections();
   STLDeleteValues(&name_to_loader_);
   for (auto& runner : native_runners_)
     runner.reset();
@@ skipping 33 matching lines @@
 }
 
 mojom::ShellClientRequest Shell::InitInstanceForEmbedder(
     const std::string& name) {
   DCHECK(!embedder_instance_);
 
   Identity target(name, mojom::kRootUserID);
   DCHECK(!GetExistingInstance(target));
 
   mojom::ShellClientRequest request;
-  embedder_instance_ = CreateInstance(
-      target, GetPermissiveCapabilityFilter(), &request);
+  embedder_instance_ =
+      CreateInstance(target, GetPermissiveCapabilities(), &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 26 matching lines @@
   scoped_ptr<Loader> loader(
       new catalog::Loader(file_task_runner_, std::move(store)));
   Loader* loader_raw = loader.get();
   std::string name = kCatalogName;
   SetLoaderForName(std::move(loader), name);
 
   mojom::ShellClientRequest request;
   // TODO(beng): Does the catalog actually have to be run with a permissive
   //             filter?
   Identity identity(name, mojom::kRootUserID);
-  CreateInstance(identity, GetPermissiveCapabilityFilter(), &request);
+  CreateInstance(identity, GetPermissiveCapabilities(), &request);
   loader_raw->Load(name, std::move(request));
 
   ConnectToInterface(this, CreateShellIdentity(), name, &shell_resolver_);
 
   // Seed the catalog with manifest info for the shell & catalog.
   if (file_task_runner_) {
     shell_resolver_->ResolveMojoName(name, base::Bind(&EmptyResolverCallback));
     shell_resolver_->ResolveMojoName("mojo:shell",
                                      base::Bind(&EmptyResolverCallback));
   }
@@ skipping 41 matching lines @@
 }
 
 bool Shell::ConnectToExistingInstance(scoped_ptr<ConnectParams>* params) {
   Instance* instance = GetExistingOrRootInstance((*params)->target());
   if (instance)
     instance->ConnectToClient(std::move(*params));
   return !!instance;
 }
 
 Shell::Instance* Shell::CreateInstance(const Identity& target_id,
-                                       const CapabilityFilter& filter,
+                                       const CapabilitySpec& capabilities,
                                        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, filter);
+      new Instance(std::move(shell_client), this, target_id, capabilities);
   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 41 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_instance,
-                              mojom::CapabilityFilterPtr base_filter,
+                              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;
   }
   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>();
+  // |capabilities_ptr| can be null when there is no manifest, e.g. for URL
+  // types not resolvable by the resolver.
+  CapabilitySpec capabilities = GetPermissiveCapabilities();
+  if (!capabilities_ptr.is_null())
+    capabilities = capabilities_ptr.To<CapabilitySpec>();
 
   mojom::ClientProcessConnectionPtr client_process_connection =
       params->TakeClientProcessConnection();
   mojom::ShellClientRequest request;
-  Instance* instance = CreateInstance(target, filter, &request);
+  Instance* instance = CreateInstance(target, capabilities, &request);
   instance->ConnectToClient(std::move(params));
 
   if (LoadWithLoader(target, &request))
     return;
 
-  CHECK(!file_url.is_null() && !base_filter.is_null());
+  CHECK(!file_url.is_null() && !capabilities_ptr.is_null());
 
   if (target.name() != resolved_name) {
     // 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, target.user_id(), instance_name),
         target.name(), std::move(request));
   } else {
     if (!client_process_connection.is_null()) {
@@ skipping 28 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