Move navigations with POST or referrer to the shell.

mojo/shell/network_fetcher.cc

 // Copyright 2015 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/network_fetcher.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file.h"
 #include "base/files/file_path.h"
@@ skipping 12 matching lines @@
 #include "mojo/common/data_pipe_utils.h"
 #include "mojo/common/url_type_converters.h"
 #include "mojo/services/network/public/interfaces/network_service.mojom.h"
 #include "mojo/shell/data_pipe_peek.h"
 #include "mojo/shell/switches.h"
 
 namespace mojo {
 namespace shell {
 
 NetworkFetcher::NetworkFetcher(bool disable_cache,
-                               const GURL& url,
+                               mojo::URLRequestPtr request,
                                NetworkService* network_service,
                                const FetchCallback& loader_callback)
     : Fetcher(loader_callback),
       disable_cache_(false),
-      url_(url),
+      url_(request->url.To<GURL>()),
       weak_ptr_factory_(this) {
-  StartNetworkRequest(url, network_service);
+  StartNetworkRequest(request.Pass(), network_service);
 }
 
 NetworkFetcher::~NetworkFetcher() {
 }
 
 const GURL& NetworkFetcher::GetURL() const {
   return url_;
 }
 
 GURL NetworkFetcher::GetRedirectURL() const {
   if (!response_)
     return GURL::EmptyGURL();
 
   if (response_->redirect_url.is_null())
     return GURL::EmptyGURL();
 
   return GURL(response_->redirect_url);
 }
 
+GURL NetworkFetcher::GetRedirectReferer() const {
+  if (!response_)
+    return GURL::EmptyGURL();
+
+  if (response_->redirect_referrer.is_null())
+    return GURL::EmptyGURL();
+
+  return GURL(response_->redirect_referrer);
+}
 URLResponsePtr NetworkFetcher::AsURLResponse(base::TaskRunner* task_runner,
                                              uint32_t skip) {
   if (skip != 0) {
     MojoResult result = ReadDataRaw(
         response_->body.get(), nullptr, &skip,
         MOJO_READ_DATA_FLAG_ALL_OR_NONE | MOJO_READ_DATA_FLAG_DISCARD);
     DCHECK_EQ(result, MOJO_RESULT_OK);
   }
   return response_.Pass();
 }
@@ skipping 132 matching lines @@
   return BlockingPeekNBytes(response_->body.get(), &magic, strlen(kMojoMagic),
                             kPeekTimeout) &&
          magic == kMojoMagic;
 }
 
 bool NetworkFetcher::PeekFirstLine(std::string* line) {
   return BlockingPeekLine(response_->body.get(), line, kMaxShebangLength,
                           kPeekTimeout);
 }
 
-void NetworkFetcher::StartNetworkRequest(const GURL& url,
+void NetworkFetcher::StartNetworkRequest(mojo::URLRequestPtr request,
                                          NetworkService* network_service) {
   TRACE_EVENT_ASYNC_BEGIN1("mojo_shell", "NetworkFetcher::NetworkRequest", this,
-                           "url", url.spec());
-  URLRequestPtr request(URLRequest::New());
-  request->url = String::From(url);
+                           "url", request->url.To<std::string>());
   request->auto_follow_redirects = false;
   request->bypass_cache = disable_cache_;
 
   network_service->CreateURLLoader(GetProxy(&url_loader_));
   url_loader_->Start(request.Pass(),
                      base::Bind(&NetworkFetcher::OnLoadComplete,
                                 weak_ptr_factory_.GetWeakPtr()));
 }
 
 void NetworkFetcher::OnLoadComplete(URLResponsePtr response) {
@@ skipping 14 matching lines @@
     loader_callback_.Run(nullptr);
     return;
   }
 
   response_ = response.Pass();
   loader_callback_.Run(owner.Pass());
 }
 
 }  // namespace shell
 }  // namespace mojo