Fix parameters aggregation.

shell/application_manager/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 "shell/application_manager/application_manager.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/macros.h"
@@ skipping 114 matching lines @@
   ConnectToApplicationWithParameters(requested_url, requestor_url,
                                      services.Pass(), exposed_services.Pass(),
                                      std::vector<std::string>());
 }
 
 void ApplicationManager::ConnectToApplicationWithParameters(
     const GURL& requested_url,
     const GURL& requestor_url,
     InterfaceRequest<ServiceProvider> services,
     ServiceProviderPtr exposed_services,
-    const std::vector<std::string>& parameters) {
+    const std::vector<std::string>& pre_redirect_parameters) {
   DCHECK(requested_url.is_valid());
 
   // We check both the mapped and resolved urls for existing shell_impls because
   // external applications can be registered for the unresolved mojo:foo urls.
 
   GURL mapped_url = delegate_->ResolveMappings(requested_url);
   if (ConnectToRunningApplication(mapped_url, requestor_url, &services,
                                   &exposed_services)) {
     return;
   }
 
   GURL resolved_url = delegate_->ResolveURL(mapped_url);
   if (ConnectToRunningApplication(resolved_url, requestor_url, &services,
                                   &exposed_services)) {
     return;
   }
 
+  // The application is not running, let's compute the parameters.
+  std::vector<std::string> parameters =
+      Concatenate(pre_redirect_parameters, GetArgsForURL(resolved_url));
+
   if (ConnectToApplicationWithLoader(requested_url, mapped_url, requestor_url,
                                      &services, &exposed_services, parameters,
                                      GetLoaderForURL(mapped_url))) {
     return;
   }
 
   if (ConnectToApplicationWithLoader(requested_url, resolved_url, requestor_url,
                                      &services, &exposed_services, parameters,
                                      GetLoaderForURL(resolved_url))) {
     return;
   }
 
   if (ConnectToApplicationWithLoader(requested_url, resolved_url, requestor_url,
                                      &services, &exposed_services, parameters,
                                      default_loader_.get())) {
     return;
   }
 
-  auto callback = base::Bind(
-      &ApplicationManager::HandleFetchCallback, weak_ptr_factory_.GetWeakPtr(),
-      requested_url, requestor_url, base::Passed(services.Pass()),
-      base::Passed(exposed_services.Pass()),
-      Concatenate(parameters, GetArgsForURL(resolved_url)));
+  auto callback = base::Bind(&ApplicationManager::HandleFetchCallback,
+                             weak_ptr_factory_.GetWeakPtr(), requested_url,
+                             requestor_url, base::Passed(services.Pass()),
+                             base::Passed(exposed_services.Pass()), parameters);
 
   if (resolved_url.SchemeIsFile()) {
     new LocalFetcher(resolved_url, GetBaseURLAndQuery(resolved_url, nullptr),
                      base::Bind(callback, NativeRunner::DontDeleteAppPath));
     return;
   }
 
   if (!network_service_)
     ConnectToService(GURL("mojo:network_service"), &network_service_);
 
@@ skipping 47 matching lines @@
     InterfaceRequest<ServiceProvider> services,
     ServiceProviderPtr exposed_services,
     const std::vector<std::string>& parameters) {
   Identity app_identity(resolved_url);
 
   ApplicationPtr application;
   InterfaceRequest<Application> application_request = GetProxy(&application);
   ShellImpl* shell =
       new ShellImpl(application.Pass(), this, original_url, app_identity);
   identity_to_shell_impl_[app_identity] = shell;
-  shell->InitializeApplication(Array<String>::From(
-      Concatenate(parameters, GetArgsForURL(app_identity.url))));
+  shell->InitializeApplication(Array<String>::From(parameters));
   ConnectToClient(shell, resolved_url, requestor_url, services.Pass(),
                   exposed_services.Pass());
   return application_request.Pass();
 }
 
 ShellImpl* ApplicationManager::GetShellImpl(const GURL& url) {
   const auto& shell_it = identity_to_shell_impl_.find(Identity(url));
   if (shell_it != identity_to_shell_impl_.end())
     return shell_it->second;
   return nullptr;
@@ skipping 248 matching lines @@
   return std::vector<std::string>();
 }
 
 void ApplicationManager::CleanupRunner(NativeRunner* runner) {
   native_runners_.erase(
       std::find(native_runners_.begin(), native_runners_.end(), runner));
 }
 
 }  // namespace shell
 }  // namespace mojo