Move navigations with POST or referrer to the 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;
+    mojo::URLRequestPtr request(mojo::URLRequest::New());
+    request->url = mojo::String::From(content_handler_url.spec());
     manager->ConnectToApplicationInternal(
-        content_handler_url, qualifier, requestor_url, GetProxy(&services),
+        request.Pass(), qualifier, requestor_url, GetProxy(&services),
         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(); }
 
@@ skipping 38 matching lines @@
   TerminateShellConnections();
   STLDeleteValues(&url_to_loader_);
   STLDeleteValues(&scheme_to_loader_);
 }
 
 void ApplicationManager::TerminateShellConnections() {
   STLDeleteValues(&identity_to_shell_impl_);
 }
 
 void ApplicationManager::ConnectToApplication(
-    const GURL& requested_url,
+    mojo::URLRequestPtr requested_url,
     const GURL& requestor_url,
     InterfaceRequest<ServiceProvider> services,
     ServiceProviderPtr exposed_services,
     const base::Closure& on_application_end) {
   ConnectToApplicationInternal(
-      requested_url, std::string(), requestor_url, services.Pass(),
+      requested_url.Pass(), std::string(), requestor_url, services.Pass(),
       exposed_services.Pass(), on_application_end);
 }
 
 void ApplicationManager::ConnectToApplicationInternal(
-    const GURL& requested_url,
+    mojo::URLRequestPtr requested_url,
     const std::string& qualifier,
     const GURL& requestor_url,
     InterfaceRequest<ServiceProvider> services,
     ServiceProviderPtr exposed_services,
     const base::Closure& on_application_end) {
+  GURL requested_gurl(requested_url->url.To<std::string>());
   TRACE_EVENT_INSTANT1(
       "mojo_shell", "ApplicationManager::ConnectToApplication",
-      TRACE_EVENT_SCOPE_THREAD, "requested_url", requested_url.spec());
-  DCHECK(requested_url.is_valid());
+      TRACE_EVENT_SCOPE_THREAD, "requested_url", requested_gurl.spec());
+  DCHECK(requested_gurl.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);
+  GURL mapped_url = delegate_->ResolveMappings(requested_gurl);
   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,
+          requested_gurl, qualifier, mapped_url, requestor_url, &services,
           &exposed_services, on_application_end, GetLoaderForURL(mapped_url))) {
     return;
   }
 
   if (ConnectToApplicationWithLoader(
-          requested_url, qualifier, resolved_url, requestor_url, &services,
+          requested_gurl, qualifier, resolved_url, requestor_url, &services,
           &exposed_services, on_application_end,
           GetLoaderForURL(resolved_url))) {
     return;
   }
 
   if (ConnectToApplicationWithLoader(
-          requested_url, qualifier, resolved_url, requestor_url, &services,
+          requested_gurl, qualifier, resolved_url, requestor_url, &services,
           &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()),
+      requested_gurl, qualifier, requestor_url, base::Passed(services.Pass()),
       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),
         base::Bind(callback, NativeApplicationCleanup::DONT_DELETE));
     return;
   }
 
   if (!network_service_)
     ConnectToService(GURL("mojo:network_service"), &network_service_);
 
   const NativeApplicationCleanup cleanup =
       base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDontDeleteOnDownload)
           ? NativeApplicationCleanup::DONT_DELETE
           : NativeApplicationCleanup::DELETE;
 
-  new NetworkFetcher(disable_cache_, resolved_url, network_service_.get(),
-                     base::Bind(callback, cleanup));
+  new NetworkFetcher(disable_cache_, requested_url.Pass(),
+                     network_service_.get(), base::Bind(callback, cleanup));
 }
 
 bool ApplicationManager::ConnectToRunningApplication(
     const GURL& resolved_url,
     const std::string& qualifier,
     const GURL& requestor_url,
     InterfaceRequest<ServiceProvider>* services,
     ServiceProviderPtr* exposed_services) {
   GURL application_url = GetBaseURLAndQuery(resolved_url, nullptr);
   ShellImpl* shell_impl = GetShellImpl(application_url, qualifier);
@@ skipping 76 matching lines @@
     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|.
-    ConnectToApplicationInternal(redirect_url, qualifier, requestor_url,
+    mojo::URLRequestPtr request(mojo::URLRequest::New());
+    request->url = mojo::String::From(redirect_url.spec());
+    HttpHeaderPtr header = HttpHeader::New();
+    header->name = "Referer";
+    header->value = fetcher->GetRedirectReferer().spec();
+    request->headers.push_back(header.Pass());
+    ConnectToApplicationInternal(request.Pass(), 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
@@ skipping 204 matching lines @@
                      content_handler->content_handler_qualifier()));
   DCHECK(it != url_to_content_handler_.end());
   delete it->second;
   url_to_content_handler_.erase(it);
 }
 
 ScopedMessagePipeHandle ApplicationManager::ConnectToServiceByName(
     const GURL& application_url,
     const std::string& interface_name) {
   ServiceProviderPtr services;
-  ConnectToApplication(application_url, GURL(), GetProxy(&services), nullptr,
+  mojo::URLRequestPtr request(mojo::URLRequest::New());
+  request->url = mojo::String::From(application_url.spec());
+  ConnectToApplication(request.Pass(), GURL(), GetProxy(&services), nullptr,
                        base::Closure());
   MessagePipe pipe;
   services->ConnectToService(interface_name, pipe.handle1.Pass());
   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