Remove CapabilityFilter from Connect()

mojo/shell/application_manager.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/application_manager.h"
 
 #include <stdint.h>
 
 #include <utility>
 
@@ skipping 160 matching lines @@
 
 void ApplicationManager::CreateInstanceForHandle(
     ScopedHandle channel,
     const String& url,
     mojom::CapabilityFilterPtr filter,
     mojom::PIDReceiverRequest pid_receiver) {
   // 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 |url| and may be subsequently reached by
   // client code using this identity.
-  CapabilityFilter local_filter = filter->filter.To<CapabilityFilter>();
   // TODO(beng): obtain userid from the inbound connection.
   Identity target_id(url.To<GURL>(), std::string(),
-                     mojom::Connector::kUserInherit, local_filter);
+                     mojom::Connector::kUserInherit);
+  target_id.SetFilter(filter->filter.To<CapabilityFilter>());
   mojom::ShellClientRequest request;
   ApplicationInstance* instance = CreateInstance(target_id, &request);
   instance->BindPIDReceiver(std::move(pid_receiver));
   scoped_ptr<NativeRunner> runner =
       native_runner_factory_->Create(base::FilePath());
   runner->InitHost(std::move(channel), std::move(request));
   instance->SetNativeRunner(runner.get());
   native_runners_.push_back(std::move(runner));
 }
 
@@ skipping 102 matching lines @@
     const String& resolved_qualifier,
     mojom::CapabilityFilterPtr base_filter,
     const String& file_url) {
   // 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();
-  CapabilityFilter filter = params->target().filter();
-  // TODO(beng): this clobbers the filter passed via Connect().
+  // |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>();
-  Identity target(params->target().url(), params->target().qualifier(),
-                  params->target().user_id(), filter);
+  Identity target = params->target();
+  target.SetFilter(filter);
 
   mojom::ShellClientRequest request;
   ApplicationInstance* instance = CreateInstance(target, &request);
   instance->ConnectToClient(std::move(params));
 
   if (LoadWithLoader(target, &request))
     return;
 
   CHECK(!file_url.is_null() && !base_filter.is_null());
 
   GURL resolved_gurl = resolved_url.To<GURL>();
   if (target.url().spec() != resolved_url) {
     // In cases where a package alias is resolved, we have to use the qualifier
     // from the original request rather than for the package itself, which will
     // always be the same.
-    CreateShellClient(source,
-                      Identity(resolved_gurl, target.qualifier(),
-                               target.user_id(), filter),
-                      target.url(), std::move(request));
+    CreateShellClient(
+        source, Identity(resolved_gurl, target.qualifier(), target.user_id()),
+        target.url(), std::move(request));
   } else {
     bool start_sandboxed = false;
     base::FilePath path = util::UrlToFilePath(file_url.To<GURL>());
     scoped_ptr<NativeRunner> runner = native_runner_factory_->Create(path);
     runner->Start(path, target, start_sandboxed, std::move(request),
                   base::Bind(&ApplicationManager::ApplicationPIDAvailable,
                              weak_ptr_factory_.GetWeakPtr(), instance->id()),
                   base::Bind(&ApplicationManager::CleanupRunner,
                              weak_ptr_factory_.GetWeakPtr(), runner.get()));
     instance->SetNativeRunner(runner.get());
@@ skipping 34 matching lines @@
   info->qualifier = instance->identity().qualifier();
   if (instance->identity().url().spec() == "mojo://shell/")
     info->pid = base::Process::Current().Pid();
   else
     info->pid = instance->pid();
   return info;
 }
 
 }  // namespace shell
 }  // namespace mojo