components/cronet/android/cronet_url_request_adapter.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "cronet_url_request_adapter.h"
   6
   7 #include "base/bind.h"
   8 #include "base/location.h"
   9 #include "base/logging.h"
  10 #include "components/cronet/android/cronet_url_request_context_adapter.h"
  11 #include "components/cronet/android/wrapped_channel_upload_element_reader.h"
  12 #include "net/base/io_buffer.h"
  13 #include "net/base/load_flags.h"
  14 #include "net/http/http_status_code.h"
  15 #include "net/url_request/redirect_info.h"
  16 #include "net/url_request/url_request_context.h"
  17
  18 namespace cronet {
  19
  20 static const int kReadBufferSize = 32768;
  21
  22 CronetURLRequestAdapter::CronetURLRequestAdapter(
  23     CronetURLRequestContextAdapter* context,
  24     scoped_ptr<CronetURLRequestAdapterDelegate> delegate,
  25     const GURL& url,
  26     net::RequestPriority priority)
  27     : context_(context),
  28       delegate_(delegate.Pass()),
  29       initial_url_(url),
  30       initial_priority_(priority),
  31       initial_method_("GET"),
  32       load_flags_(context->default_load_flags()) {
  33 }
  34
  35 CronetURLRequestAdapter::~CronetURLRequestAdapter() {
  36   DCHECK(IsOnNetworkThread());
  37 }
  38
  39 void CronetURLRequestAdapter::AddRequestHeader(const std::string& name,
  40                                                const std::string& value) {
  41   DCHECK(!IsOnNetworkThread());
  42   initial_request_headers_.SetHeader(name, value);
  43 }
  44
  45 void CronetURLRequestAdapter::DisableCache() {
  46   DCHECK(!IsOnNetworkThread());
  47   load_flags_ |= net::LOAD_DISABLE_CACHE;
  48 }
  49
  50 void CronetURLRequestAdapter::PostTaskToNetworkThread(
  51     const tracked_objects::Location& from_here,
  52     const base::Closure& task) {
  53   DCHECK(!IsOnNetworkThread());
  54   context_->PostTaskToNetworkThread(from_here, task);
  55 }
  56
  57 bool CronetURLRequestAdapter::IsOnNetworkThread() const {
  58   return context_->IsOnNetworkThread();
  59 }
  60
  61 void CronetURLRequestAdapter::SetUpload(
  62     scoped_ptr<net::UploadDataStream> upload) {
  63   DCHECK(!IsOnNetworkThread());
  64   DCHECK(!upload_);
  65   upload_ = upload.Pass();
  66 }
  67
  68 void CronetURLRequestAdapter::Start() {
  69   DCHECK(IsOnNetworkThread());
  70   VLOG(1) << "Starting chromium request: "
  71           << initial_url_.possibly_invalid_spec().c_str()
  72           << " priority: " << RequestPriorityToString(initial_priority_);
  73   url_request_ = context_->GetURLRequestContext()->CreateRequest(
  74       initial_url_, net::DEFAULT_PRIORITY, this, NULL);
  75   url_request_->SetLoadFlags(load_flags_);
  76   url_request_->set_method(initial_method_);
  77   url_request_->SetExtraRequestHeaders(initial_request_headers_);
  78   url_request_->SetPriority(initial_priority_);
  79   if (upload_)
  80     url_request_->set_upload(upload_.Pass());
  81   url_request_->Start();
  82 }
  83
  84 void CronetURLRequestAdapter::FollowDeferredRedirect() {
  85   DCHECK(IsOnNetworkThread());
  86
  87   url_request_->FollowDeferredRedirect();
  88 }
  89
  90 void CronetURLRequestAdapter::ReadData() {
  91   DCHECK(IsOnNetworkThread());
  92   if (!read_buffer_.get())
  93     read_buffer_ = new net::IOBufferWithSize(kReadBufferSize);
  94
  95   int bytes_read = 0;
  96   url_request_->Read(read_buffer_.get(), read_buffer_->size(), &bytes_read);
  97   // If IO is pending, wait for the URLRequest to call OnReadCompleted.
  98   if (url_request_->status().is_io_pending())
  99     return;
 100
 101   OnReadCompleted(url_request_.get(), bytes_read);
 102 }
 103
 104 void CronetURLRequestAdapter::Destroy() {
 105   DCHECK(IsOnNetworkThread());
 106   delete this;
 107 }
 108
 109 const net::HttpResponseHeaders*
 110 CronetURLRequestAdapter::GetResponseHeaders() const {
 111   DCHECK(IsOnNetworkThread());
 112   return url_request_->response_headers();
 113 }
 114
 115 const std::string& CronetURLRequestAdapter::GetNegotiatedProtocol() const {
 116   DCHECK(IsOnNetworkThread());
 117   return url_request_->response_info().npn_negotiated_protocol;
 118 }
 119
 120 bool CronetURLRequestAdapter::GetWasCached() const {
 121   DCHECK(IsOnNetworkThread());
 122   return url_request_->response_info().was_cached;
 123 }
 124
 125 int64 CronetURLRequestAdapter::GetTotalReceivedBytes() const {
 126   DCHECK(IsOnNetworkThread());
 127   return url_request_->GetTotalReceivedBytes();
 128 }
 129
 130 // net::URLRequest::Delegate overrides (called on network thread).
 131
 132 void CronetURLRequestAdapter::OnReceivedRedirect(
 133     net::URLRequest* request,
 134     const net::RedirectInfo& redirect_info,
 135     bool* defer_redirect) {
 136   DCHECK(IsOnNetworkThread());
 137   DCHECK(request->status().is_success());
 138   delegate_->OnRedirect(redirect_info.new_url, redirect_info.status_code);
 139   *defer_redirect = true;
 140 }
 141
 142 void CronetURLRequestAdapter::OnResponseStarted(net::URLRequest* request) {
 143   DCHECK(IsOnNetworkThread());
 144   if (MaybeReportError(request))
 145     return;
 146   delegate_->OnResponseStarted(request->GetResponseCode());
 147 }
 148
 149 void CronetURLRequestAdapter::OnReadCompleted(net::URLRequest* request,
 150                                               int bytes_read) {
 151   DCHECK(IsOnNetworkThread());
 152   if (MaybeReportError(request))
 153     return;
 154   if (bytes_read != 0) {
 155     delegate_->OnBytesRead(
 156         reinterpret_cast<unsigned char*>(read_buffer_->data()), bytes_read);
 157   } else {
 158     delegate_->OnRequestFinished();
 159   }
 160 }
 161
 162 bool CronetURLRequestAdapter::MaybeReportError(net::URLRequest* request) const {
 163   DCHECK_NE(net::URLRequestStatus::IO_PENDING, url_request_->status().status());
 164   DCHECK_EQ(request, url_request_);
 165   if (url_request_->status().is_success())
 166     return false;
 167   VLOG(1) << "Error " << url_request_->status().error()
 168           << " on chromium request: " << initial_url_.possibly_invalid_spec();
 169   delegate_->OnError(url_request_->status().error());
 170   return true;
 171 }
 172
 173 }  // namespace cronet