Use modified URLRequest::Read() and delegate methods in components/

components/cronet/android/url_request_adapter.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 "components/cronet/android/url_request_adapter.h"
 
 #include <stddef.h>
 #include <string.h>
 #include <utility>
 
@@ skipping 192 matching lines @@
 
 // static
 void URLRequestAdapter::OnDestroyRequest(URLRequestAdapter* self) {
   DCHECK(self->OnNetworkThread());
   VLOG(1) << "Destroying chromium request: "
           << self->url_.possibly_invalid_spec();
   delete self;
 }
 
 // static
-void URLRequestAdapter::OnResponseStarted(net::URLRequest* request) {
+void URLRequestAdapter::OnResponseStarted(net::URLRequest* request,
+                                          int net_error) {
+  DCHECK_NE(net::ERR_IO_PENDING, net_error);
   DCHECK(OnNetworkThread());
-  if (request->status().status() != net::URLRequestStatus::SUCCESS) {
-    OnRequestFailed();
+
+  if (net_error != net::OK) {
+    OnRequestFailed(net_error);
     return;
   }
 
   http_status_code_ = request->GetResponseCode();
   VLOG(1) << "Response started with status: " << http_status_code_;
 
   net::HttpResponseHeaders* headers = request->response_headers();
   if (headers)
     http_status_text_ = headers->GetStatusText();
 
   request->GetResponseHeaderByName("Content-Type", &content_type_);
   expected_size_ = request->GetExpectedContentSize();
   delegate_->OnResponseStarted(this);
 
   Read();
 }
 
 // Reads all available data or starts an asynchronous read.
 void URLRequestAdapter::Read() {
   DCHECK(OnNetworkThread());
   if (!read_buffer_.get())
     read_buffer_ = new net::IOBufferWithSize(kReadBufferSize);
 
   while(true) {
-    int bytes_read = 0;
-    url_request_->Read(read_buffer_.get(), kReadBufferSize, &bytes_read);
+    int result = url_request_->Read(read_buffer_.get(), kReadBufferSize);
     // If IO is pending, wait for the URLRequest to call OnReadCompleted.
-    if (url_request_->status().is_io_pending())
+    if (result == net::ERR_IO_PENDING)
       return;
     // Stop when request has failed or succeeded.
-    if (!HandleReadResult(bytes_read))
+    if (!HandleReadResult(result))
       return;
   }
 }
 
-bool URLRequestAdapter::HandleReadResult(int bytes_read) {
+bool URLRequestAdapter::HandleReadResult(int result) {
   DCHECK(OnNetworkThread());
-  if (!url_request_->status().is_success()) {
-    OnRequestFailed();
+  if (result < 0) {
+    OnRequestFailed(result);
     return false;
-  } else if (bytes_read == 0) {
+  }
+
+  if (result == 0) {
     OnRequestSucceeded();
     return false;
   }
 
-  total_bytes_read_ += bytes_read;
-  delegate_->OnBytesRead(this, bytes_read);
+  total_bytes_read_ += result;
+  delegate_->OnBytesRead(this, result);
 
   return true;
 }
 
 void URLRequestAdapter::OnReadCompleted(net::URLRequest* request,
                                         int bytes_read) {
+  DCHECK_NE(net::ERR_IO_PENDING, bytes_read);
   if (!HandleReadResult(bytes_read))
     return;
 
   Read();
 }
 
 void URLRequestAdapter::OnReceivedRedirect(net::URLRequest* request,
                                            const net::RedirectInfo& info,
                                            bool* defer_redirect) {
   DCHECK(OnNetworkThread());
@@ skipping 12 matching lines @@
   if (canceled_) {
     return;
   }
 
   VLOG(1) << "Request completed with HTTP status: " << http_status_code_
           << ". Total bytes read: " << total_bytes_read_;
 
   OnRequestCompleted();
 }
 
-void URLRequestAdapter::OnRequestFailed() {
+void URLRequestAdapter::OnRequestFailed(int net_error) {
+  DCHECK_LE(net_error, 0);
+  DCHECK_NE(net::ERR_IO_PENDING, net_error);
   DCHECK(OnNetworkThread());
   if (canceled_) {
     return;
   }
 
-  error_code_ = url_request_->status().error();
-  VLOG(1) << "Request failed with status: " << url_request_->status().status()
-          << " and error: " << net::ErrorToString(error_code_);
+  error_code_ = net_error;
+  VLOG(1) << "Request failed with error: " << net::ErrorToString(error_code_);
   OnRequestCompleted();
 }
 
 void URLRequestAdapter::OnRequestCompleted() {
   DCHECK(OnNetworkThread());
   VLOG(1) << "Completed: " << url_.possibly_invalid_spec();
 
   DCHECK(url_request_ != nullptr);
 
   delegate_->OnRequestFinished(this);
   url_request_.reset();
 }
 
 unsigned char* URLRequestAdapter::Data() const {
   DCHECK(OnNetworkThread());
   return reinterpret_cast<unsigned char*>(read_buffer_->data());
 }
 
 bool URLRequestAdapter::OnNetworkThread() const {
   return context_->GetNetworkTaskRunner()->BelongsToCurrentThread();
 }
 
 }  // namespace cronet