Simplify mojo_shell since it's now only used for Mandoline.

mojo/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 "mojo/shell/application_manager/application_manager.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/macros.h"
@@ skipping 11 matching lines @@
 #include "third_party/mojo_services/src/content_handler/public/interfaces/content_handler.mojom.h"
 
 namespace mojo {
 namespace shell {
 
 namespace {
 
 // Used by TestAPI.
 bool has_created_instance = false;
 
-std::vector<std::string> Concatenate(const std::vector<std::string>& v1,
-                                     const std::vector<std::string>& v2) {
-  if (!v1.size())
-    return v2;
-  if (!v2.size())
-    return v1;
-  std::vector<std::string> result(v1);
-  result.insert(result.end(), v1.begin(), v1.end());
-  return result;
-}
-
 }  // namespace
 
 ApplicationManager::Delegate::~Delegate() {
 }
 
 GURL ApplicationManager::Delegate::ResolveURL(const GURL& url) {
   return url;
 }
 
 GURL ApplicationManager::Delegate::ResolveMappings(const GURL& url) {
@@ skipping 94 matching lines @@
     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(mapped_url, requestor_url, &services,
                                      &exposed_services, on_application_end,
-                                     parameters, GetLoaderForURL(mapped_url))) {
+                                     pre_redirect_parameters,
+                                     GetLoaderForURL(mapped_url))) {
+    return;
+  }
+
+  if (ConnectToApplicationWithLoader(resolved_url, requestor_url, &services,
+                                     &exposed_services, on_application_end,
+                                     pre_redirect_parameters,
+                                     GetLoaderForURL(resolved_url))) {
     return;
   }
 
   if (ConnectToApplicationWithLoader(
           resolved_url, requestor_url, &services, &exposed_services,
-          on_application_end, parameters, GetLoaderForURL(resolved_url))) {
+          on_application_end, pre_redirect_parameters, default_loader_.get())) {
     return;
   }
 
-  if (ConnectToApplicationWithLoader(resolved_url, requestor_url, &services,
-                                     &exposed_services, on_application_end,
-                                     parameters, default_loader_.get())) {
-    return;
-  }
-
-  auto callback = base::Bind(
-      &ApplicationManager::HandleFetchCallback, weak_ptr_factory_.GetWeakPtr(),
-      requestor_url, base::Passed(services.Pass()),
-      base::Passed(exposed_services.Pass()), on_application_end,
-      parameters);
+  auto callback = base::Bind(&ApplicationManager::HandleFetchCallback,
+                             weak_ptr_factory_.GetWeakPtr(), requestor_url,
+                             base::Passed(services.Pass()),
+                             base::Passed(exposed_services.Pass()),
+                             on_application_end, pre_redirect_parameters);
 
   if (resolved_url.SchemeIsFile()) {
     new LocalFetcher(
         resolved_url, GetBaseURLAndQuery(resolved_url, nullptr),
         base::Bind(callback, NativeApplicationCleanup::DONT_DELETE));
     return;
   }
 
   if (!network_service_)
     ConnectToService(GURL("mojo:network_service"), &network_service_);
@@ skipping 175 matching lines @@
 
   TRACE_EVENT1("mojo_shell", "ApplicationManager::RunNativeApplication", "path",
                path.AsUTF8Unsafe());
   NativeRunner* runner = native_runner_factory_->Create(options).release();
   native_runners_.push_back(runner);
   runner->Start(path, cleanup, application_request.Pass(),
                 base::Bind(&ApplicationManager::CleanupRunner,
                            weak_ptr_factory_.GetWeakPtr(), runner));
 }
 
-void ApplicationManager::RegisterExternalApplication(
-    const GURL& url,
-    const std::vector<std::string>& args,
-    ApplicationPtr application) {
-  const auto& args_it = url_to_args_.find(url);
-  if (args_it != url_to_args_.end()) {
-    LOG(WARNING) << "--args-for provided for external application " << url
-                 << " <ignored>";
-  }
-  Identity identity(url);
-  ShellImpl* shell_impl =
-      new ShellImpl(application.Pass(), this, identity, base::Closure());
-  identity_to_shell_impl_[identity] = shell_impl;
-  shell_impl->InitializeApplication(Array<String>::From(args));
-}
-
 void ApplicationManager::RegisterContentHandler(
     const std::string& mime_type,
     const GURL& content_handler_url) {
   DCHECK(content_handler_url.is_valid())
       << "Content handler URL is invalid for mime type " << mime_type;
   mime_type_to_url_[mime_type] = content_handler_url;
 }
 
 void ApplicationManager::LoadWithContentHandler(
     const GURL& content_handler_url,
@@ skipping 23 matching lines @@
 
 void ApplicationManager::SetLoaderForScheme(
     scoped_ptr<ApplicationLoader> loader,
     const std::string& scheme) {
   SchemeToLoaderMap::iterator it = scheme_to_loader_.find(scheme);
   if (it != scheme_to_loader_.end())
     delete it->second;
   scheme_to_loader_[scheme] = loader.release();
 }
 
-void ApplicationManager::SetArgsForURL(const std::vector<std::string>& args,
-                                       const GURL& url) {
-  url_to_args_[url].insert(url_to_args_[url].end(), args.begin(), args.end());
-  GURL mapped_url = delegate_->ResolveMappings(url);
-  if (mapped_url != url) {
-    url_to_args_[mapped_url].insert(url_to_args_[mapped_url].end(),
-                                    args.begin(), args.end());
-  }
-  GURL resolved_url = delegate_->ResolveURL(mapped_url);
-  if (resolved_url != mapped_url) {
-    url_to_args_[resolved_url].insert(url_to_args_[resolved_url].end(),
-                                      args.begin(), args.end());
-  }
-}
-
 void ApplicationManager::SetNativeOptionsForURL(
     const NativeRunnerFactory::Options& options,
     const GURL& url) {
   DCHECK(!url.has_query());  // Precondition.
   // Apply mappings and resolution to get the resolved URL.
   GURL resolved_url = delegate_->ResolveURL(delegate_->ResolveMappings(url));
   DCHECK(!resolved_url.has_query());  // Still shouldn't have query.
   // TODO(vtl): We should probably also remove/disregard the query string (and
   // maybe canonicalize in other ways).
   DVLOG(2) << "Storing native options for resolved URL " << resolved_url
@@ skipping 38 matching lines @@
     const GURL& application_url,
     const std::string& interface_name) {
   ServiceProviderPtr services;
   ConnectToApplication(application_url, GURL(), GetProxy(&services), nullptr,
                        base::Closure());
   MessagePipe pipe;
   services->ConnectToService(interface_name, pipe.handle1.Pass());
   return pipe.handle0.Pass();
 }
 
-std::vector<std::string> ApplicationManager::GetArgsForURL(const GURL& url) {
-  const auto& args_it = url_to_args_.find(url);
-  if (args_it != url_to_args_.end())
-    return args_it->second;
-  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