Mojo: cleanup redirect handling for network service.

mojo/services/network/url_loader_impl.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/services/network/url_loader_impl.h"
 
+#include "mojo/common/common_type_converters.h"
 #include "mojo/services/network/network_context.h"
 #include "net/base/io_buffer.h"
 #include "net/base/load_flags.h"
 #include "net/http/http_response_headers.h"
 
 namespace mojo {
 namespace {
 
 const uint32_t kMaxReadSize = 64 * 1024;
 
@@ skipping 69 matching lines @@
       : net::WrappedIOBuffer(pending_write->buffer()),
         pending_write_(pending_write) {
   }
  private:
   virtual ~DependentIOBuffer() {}
   scoped_refptr<PendingWriteToDataPipe> pending_write_;
 };
 
 URLLoaderImpl::URLLoaderImpl(NetworkContext* context)
     : context_(context),
+      auto_follow_redirects_(true),
       weak_ptr_factory_(this) {
 }
 
 URLLoaderImpl::~URLLoaderImpl() {
 }
 
 void URLLoaderImpl::OnConnectionError() {
   delete this;
 }
 
@@ skipping 13 matching lines @@
   }
 
   response_body_stream_ = response_body_stream.Pass();
 
   GURL url(request->url);
   url_request_.reset(
       new net::URLRequest(url,
                           net::DEFAULT_PRIORITY,
                           this,
                           context_->url_request_context()));
+  url_request_->set_method(request->method);
+  if (request->headers) {
+    net::HttpRequestHeaders headers;
+    for (size_t i = 0; i < request->headers.size(); ++i)
+      headers.AddHeaderFromString(request->headers[i].To<base::StringPiece>());
+    url_request_->SetExtraRequestHeaders(headers);
+  }
   if (request->bypass_cache)
     url_request_->SetLoadFlags(net::LOAD_BYPASS_CACHE);
+  // TODO(darin): Handle request body.
+
+  auto_follow_redirects_ = request->auto_follow_redirects;
+
   url_request_->Start();
 }
 
 void URLLoaderImpl::FollowRedirect() {
-  NOTIMPLEMENTED();
+  if (auto_follow_redirects_) {
+    DLOG(ERROR) << "Spurious call to FollowRedirect";
+  } else {
+    if (url_request_)
+      url_request_->FollowDeferredRedirect();
+  }
 }
 
 void URLLoaderImpl::OnReceivedRedirect(net::URLRequest* url_request,
                                        const GURL& new_url,
                                        bool* defer_redirect) {
   DCHECK(url_request == url_request_.get());
   DCHECK(url_request->status().is_success());
 
   URLResponsePtr response = MakeURLResponse(url_request);
   std::string redirect_method =
       net::URLRequest::ComputeMethodForRedirect(url_request->method(),
                                                 response->status_code);
   client()->OnReceivedRedirect(
       response.Pass(), new_url.spec(), redirect_method);
 
-  *defer_redirect = false;
+  *defer_redirect = !auto_follow_redirects_;
 }
 
 void URLLoaderImpl::OnResponseStarted(net::URLRequest* url_request) {
   DCHECK(url_request == url_request_.get());
 
   if (!url_request->status().is_success()) {
     SendError(url_request->status().error());
     return;
   }
 
@@ skipping 64 matching lines @@
   if (completed_synchronously) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&URLLoaderImpl::ReadMore, weak_ptr_factory_.GetWeakPtr()));
   } else {
     ReadMore();
   }
 }
 
 }  // namespace mojo