Revert of 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,
-                                     pre_redirect_parameters,
-                                     GetLoaderForURL(mapped_url))) {
+                                     parameters, GetLoaderForURL(mapped_url))) {
+    return;
+  }
+
+  if (ConnectToApplicationWithLoader(
+          resolved_url, requestor_url, &services, &exposed_services,
+          on_application_end, parameters, GetLoaderForURL(resolved_url))) {
     return;
   }
 
   if (ConnectToApplicationWithLoader(resolved_url, requestor_url, &services,
                                      &exposed_services, on_application_end,
-                                     pre_redirect_parameters,
-                                     GetLoaderForURL(resolved_url))) {
+                                     parameters, default_loader_.get())) {
     return;
   }
 
-  if (ConnectToApplicationWithLoader(
-          resolved_url, requestor_url, &services, &exposed_services,
-          on_application_end, pre_redirect_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, pre_redirect_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,
+      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