Eliminate CapabilityFilter parameter from CreateInstance, instead reading it from the associated ma…

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 195 matching lines @@
 
   // 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,
                       mojom::IdentityPtr target,
-                      mojom::CapabilityFilterPtr filter,
                       mojom::PIDReceiverRequest pid_receiver,
                       const CreateInstanceCallback& callback) override {
+    // We need to bounce through the package manager to load the
+    // CapabilityFilter.
+    std::string name = target->name;
+    shell_->shell_resolver_->ResolveMojoName(name, base::Bind(
+        &mojo::shell::Shell::Instance::OnResolvedNameForCreateInstance,
+        weak_factory_.GetWeakPtr(), base::Passed(std::move(factory)),
+        base::Passed(std::move(target)), base::Passed(std::move(pid_receiver)),
+        callback));
+  }
+  void AddInstanceListener(mojom::InstanceListenerPtr listener) override {
+    // TODO(beng): this should only track the instances matching this user, and
+    // root.
+    shell_->AddInstanceListener(std::move(listener));
+  }
+
+  void OnResolvedNameForCreateInstance(mojom::ShellClientFactoryPtr factory,
+                                       mojom::IdentityPtr target,
+                                       mojom::PIDReceiverRequest pid_receiver,
+                                       const CreateInstanceCallback& callback,
+                                       const String& resolved_name,
+                                       const String& resolved_instance,
+                                       mojom::CapabilityFilterPtr filter,
+                                       const String& file_url) {
     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.
     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);
+      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.
   }
-  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;
@@ skipping 339 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