Remove application-specific args from Mandoline's shell.

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 "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/macros.h"
@@ skipping 23 matching lines @@
 class ApplicationManager::ContentHandlerConnection : public ErrorHandler {
  public:
   ContentHandlerConnection(ApplicationManager* manager,
                            const GURL& content_handler_url,
                            const GURL& requestor_url,
                            const std::string& qualifier)
       : manager_(manager),
         content_handler_url_(content_handler_url),
         content_handler_qualifier_(qualifier) {
     ServiceProviderPtr services;
-    manager->ConnectToApplicationWithParameters(
+    manager->ConnectToApplicationInternal(
         content_handler_url, qualifier, requestor_url, GetProxy(&services),
-        nullptr, base::Closure(), std::vector<std::string>());
+        nullptr, base::Closure());
     MessagePipe pipe;
     content_handler_.Bind(
         InterfacePtrInfo<ContentHandler>(pipe.handle0.Pass(), 0u));
     services->ConnectToService(ContentHandler::Name_, pipe.handle1.Pass());
     content_handler_.set_error_handler(this);
   }
 
   ContentHandler* content_handler() { return content_handler_.get(); }
 
   GURL content_handler_url() { return content_handler_url_; }
@@ skipping 42 matching lines @@
 void ApplicationManager::TerminateShellConnections() {
   STLDeleteValues(&identity_to_shell_impl_);
 }
 
 void ApplicationManager::ConnectToApplication(
     const GURL& requested_url,
     const GURL& requestor_url,
     InterfaceRequest<ServiceProvider> services,
     ServiceProviderPtr exposed_services,
     const base::Closure& on_application_end) {
-  ConnectToApplicationWithParameters(
+  ConnectToApplicationInternal(
       requested_url, std::string(), requestor_url, services.Pass(),
-      exposed_services.Pass(), on_application_end, std::vector<std::string>());
+      exposed_services.Pass(), on_application_end);
 }
 
-void ApplicationManager::ConnectToApplicationWithParameters(
+void ApplicationManager::ConnectToApplicationInternal(
     const GURL& requested_url,
     const std::string& qualifier,
     const GURL& requestor_url,
     InterfaceRequest<ServiceProvider> services,
     ServiceProviderPtr exposed_services,
-    const base::Closure& on_application_end,
-    const std::vector<std::string>& pre_redirect_parameters) {
+    const base::Closure& on_application_end) {
   TRACE_EVENT_INSTANT1(
-      "mojo_shell", "ApplicationManager::ConnectToApplicationWithParameters",
+      "mojo_shell", "ApplicationManager::ConnectToApplication",
       TRACE_EVENT_SCOPE_THREAD, "requested_url", requested_url.spec());
   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, qualifier, requestor_url,
                                   &services, &exposed_services)) {
     return;
   }
 
   GURL resolved_url = delegate_->ResolveMojoURL(mapped_url);
   if (ConnectToRunningApplication(resolved_url, qualifier, requestor_url,
                                   &services, &exposed_services)) {
     return;
   }
 
   // The application is not running, let's compute the parameters.
   if (ConnectToApplicationWithLoader(
           requested_url, qualifier, mapped_url, requestor_url, &services,
-          &exposed_services, on_application_end, pre_redirect_parameters,
-          GetLoaderForURL(mapped_url))) {
+          &exposed_services, on_application_end, GetLoaderForURL(mapped_url))) {
     return;
   }
 
   if (ConnectToApplicationWithLoader(
           requested_url, qualifier, resolved_url, requestor_url, &services,
-          &exposed_services, on_application_end, pre_redirect_parameters,
+          &exposed_services, on_application_end,
           GetLoaderForURL(resolved_url))) {
     return;
   }
 
   if (ConnectToApplicationWithLoader(
           requested_url, qualifier, resolved_url, requestor_url, &services,
-          &exposed_services, on_application_end, pre_redirect_parameters,
-          default_loader_.get())) {
+          &exposed_services, on_application_end, default_loader_.get())) {
     return;
   }
 
   auto callback = base::Bind(
       &ApplicationManager::HandleFetchCallback, weak_ptr_factory_.GetWeakPtr(),
       requested_url, qualifier, requestor_url, base::Passed(services.Pass()),
-      base::Passed(exposed_services.Pass()), on_application_end,
-      pre_redirect_parameters);
+      base::Passed(exposed_services.Pass()), on_application_end);
 
   if (delegate_->CreateFetcher(
           resolved_url,
           base::Bind(callback, NativeApplicationCleanup::DONT_DELETE))) {
     return;
   }
 
   if (resolved_url.SchemeIsFile()) {
     new LocalFetcher(
         resolved_url, GetBaseURLAndQuery(resolved_url, nullptr),
@@ skipping 31 matching lines @@
 }
 
 bool ApplicationManager::ConnectToApplicationWithLoader(
     const GURL& requested_url,
     const std::string& qualifier,
     const GURL& resolved_url,
     const GURL& requestor_url,
     InterfaceRequest<ServiceProvider>* services,
     ServiceProviderPtr* exposed_services,
     const base::Closure& on_application_end,
-    const std::vector<std::string>& parameters,
     ApplicationLoader* loader) {
   if (!loader)
     return false;
 
   const GURL app_url =
       requested_url.scheme() == "mojo" ? requested_url : resolved_url;
 
   loader->Load(
       resolved_url,
       RegisterShell(app_url, qualifier, requestor_url, services->Pass(),
-                    exposed_services->Pass(), on_application_end, parameters));
+                    exposed_services->Pass(), on_application_end));
   return true;
 }
 
 InterfaceRequest<Application> ApplicationManager::RegisterShell(
     const GURL& app_url,
     const std::string& qualifier,
     const GURL& requestor_url,
     InterfaceRequest<ServiceProvider> services,
     ServiceProviderPtr exposed_services,
-    const base::Closure& on_application_end,
-    const std::vector<std::string>& parameters) {
+    const base::Closure& on_application_end) {
   Identity app_identity(app_url, qualifier);
 
   ApplicationPtr application;
   InterfaceRequest<Application> application_request = GetProxy(&application);
   ShellImpl* shell =
       new ShellImpl(application.Pass(), this, app_identity, on_application_end);
   identity_to_shell_impl_[app_identity] = shell;
-  shell->InitializeApplication(Array<String>::From(parameters));
+  shell->InitializeApplication();
   ConnectToClient(shell, app_url, requestor_url, services.Pass(),
                   exposed_services.Pass());
   return application_request.Pass();
 }
 
 ShellImpl* ApplicationManager::GetShellImpl(const GURL& url,
                                             const std::string& qualifier) {
   const auto& shell_it = identity_to_shell_impl_.find(Identity(url, qualifier));
   if (shell_it != identity_to_shell_impl_.end())
     return shell_it->second;
@@ skipping 10 matching lines @@
                               exposed_services.Pass());
 }
 
 void ApplicationManager::HandleFetchCallback(
     const GURL& requested_url,
     const std::string& qualifier,
     const GURL& requestor_url,
     InterfaceRequest<ServiceProvider> services,
     ServiceProviderPtr exposed_services,
     const base::Closure& on_application_end,
-    const std::vector<std::string>& parameters,
     NativeApplicationCleanup cleanup,
     scoped_ptr<Fetcher> fetcher) {
   if (!fetcher) {
     // Network error. Drop |application_request| to tell requestor.
     return;
   }
 
   GURL redirect_url = fetcher->GetRedirectURL();
   if (!redirect_url.is_empty()) {
     // And around we go again... Whee!
     // TODO(sky): this loses |requested_url|.
-    ConnectToApplicationWithParameters(redirect_url, qualifier, requestor_url,
-                                       services.Pass(), exposed_services.Pass(),
-                                       on_application_end, parameters);
+    ConnectToApplicationInternal(redirect_url, qualifier, requestor_url,
+                                 services.Pass(), exposed_services.Pass(),
+                                 on_application_end);
     return;
   }
 
   // We already checked if the application was running before we fetched it, but
   // it might have started while the fetch was outstanding. We don't want to
   // have two copies of the app running, so check again.
   //
   // Also, it's possible the original URL was redirected to an app that is
   // already running.
   if (ConnectToRunningApplication(requested_url, qualifier, requestor_url,
                                   &services, &exposed_services)) {
     return;
   }
 
   const GURL app_url =
       requested_url.scheme() == "mojo" ? requested_url : fetcher->GetURL();
 
   InterfaceRequest<Application> request(
       RegisterShell(app_url, qualifier, requestor_url, services.Pass(),
-                    exposed_services.Pass(), on_application_end, parameters));
+                    exposed_services.Pass(), on_application_end));
 
   // If the response begins with a #!mojo <content-handler-url>, use it.
   GURL content_handler_url;
   std::string shebang;
   if (fetcher->PeekContentHandler(&shebang, &content_handler_url)) {
     LoadWithContentHandler(
         content_handler_url, requestor_url, qualifier, request.Pass(),
         fetcher->AsURLResponse(blocking_pool_,
                                static_cast<int>(shebang.size())));
     return;
@@ skipping 196 matching lines @@
   return pipe.handle0.Pass();
 }
 
 void ApplicationManager::CleanupRunner(NativeRunner* runner) {
   native_runners_.erase(
       std::find(native_runners_.begin(), native_runners_.end(), runner));
 }
 
 }  // namespace shell
 }  // namespace mojo