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

components/cronet/android/cronet_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/cronet_url_request_adapter.h"
 
 #include <limits>
 #include <utility>
 #include <vector>
 
@@ skipping 178 matching lines @@
   context_->PostTaskToNetworkThread(
       FROM_HERE, base::Bind(&CronetURLRequestAdapter::DestroyOnNetworkThread,
                             base::Unretained(this), jsend_on_canceled));
 }
 
 void CronetURLRequestAdapter::OnReceivedRedirect(
     net::URLRequest* request,
     const net::RedirectInfo& redirect_info,
     bool* defer_redirect) {
   DCHECK(context_->IsOnNetworkThread());
-  DCHECK(request->status().is_success());
   JNIEnv* env = base::android::AttachCurrentThread();
   cronet::Java_CronetUrlRequest_onRedirectReceived(
       env, owner_.obj(),
       ConvertUTF8ToJavaString(env, redirect_info.new_url.spec()).obj(),
       redirect_info.status_code,
       ConvertUTF8ToJavaString(env, request->response_headers()->GetStatusText())
           .obj(),
       GetResponseHeaders(env).obj(),
       request->response_info().was_cached ? JNI_TRUE : JNI_FALSE,
       ConvertUTF8ToJavaString(env,
@@ skipping 22 matching lines @@
   request->Cancel();
   int net_error = net::MapCertStatusToNetError(ssl_info.cert_status);
   JNIEnv* env = base::android::AttachCurrentThread();
   cronet::Java_CronetUrlRequest_onError(
       env, owner_.obj(), NetErrorToUrlRequestError(net_error), net_error,
       net::QUIC_NO_ERROR,
       ConvertUTF8ToJavaString(env, net::ErrorToString(net_error)).obj(),
       request->GetTotalReceivedBytes());
 }
 
-void CronetURLRequestAdapter::OnResponseStarted(net::URLRequest* request) {
+void CronetURLRequestAdapter::OnResponseStarted(net::URLRequest* request,
+                                                int net_error) {
+  DCHECK_NE(net::ERR_IO_PENDING, net_error);
   DCHECK(context_->IsOnNetworkThread());
-  if (MaybeReportError(request))
+
+  if (net_error != net::OK) {
+    ReportError(request, net_error);
     return;
+  }
   JNIEnv* env = base::android::AttachCurrentThread();
   cronet::Java_CronetUrlRequest_onResponseStarted(
       env, owner_.obj(), request->GetResponseCode(),
       ConvertUTF8ToJavaString(env, request->response_headers()->GetStatusText())
           .obj(),
       GetResponseHeaders(env).obj(),
       request->response_info().was_cached ? JNI_TRUE : JNI_FALSE,
       ConvertUTF8ToJavaString(env,
                               request->response_info().npn_negotiated_protocol)
           .obj(),
       ConvertUTF8ToJavaString(env,
                               request->response_info().proxy_server.ToString())
           .obj());
 }
 
 void CronetURLRequestAdapter::OnReadCompleted(net::URLRequest* request,
                                               int bytes_read) {
   DCHECK(context_->IsOnNetworkThread());
-  if (MaybeReportError(request))
+
+  if (bytes_read < 0) {
+    ReportError(request, bytes_read);
     return;
-  if (bytes_read != 0) {
+  }
+
+  if (bytes_read == 0) {
+    JNIEnv* env = base::android::AttachCurrentThread();
+    cronet::Java_CronetUrlRequest_onSucceeded(
+        env, owner_.obj(), url_request_->GetTotalReceivedBytes());
+  } else {
     JNIEnv* env = base::android::AttachCurrentThread();
     cronet::Java_CronetUrlRequest_onReadCompleted(
         env, owner_.obj(), read_buffer_->byte_buffer(), bytes_read,
         read_buffer_->initial_position(), read_buffer_->initial_limit(),
         request->GetTotalReceivedBytes());
     // Free the read buffer. This lets the Java ByteBuffer be freed, if the
     // embedder releases it, too.
     read_buffer_ = nullptr;
-  } else {
-    JNIEnv* env = base::android::AttachCurrentThread();
-    cronet::Java_CronetUrlRequest_onSucceeded(
-        env, owner_.obj(), url_request_->GetTotalReceivedBytes());
   }
 }
 
 void CronetURLRequestAdapter::StartOnNetworkThread() {
   DCHECK(context_->IsOnNetworkThread());
   VLOG(1) << "Starting chromium request: "
           << initial_url_.possibly_invalid_spec().c_str()
           << " priority: " << RequestPriorityToString(initial_priority_);
   url_request_ = context_->GetURLRequestContext()->CreateRequest(
       initial_url_, net::DEFAULT_PRIORITY, this);
@@ skipping 48 matching lines @@
 
 void CronetURLRequestAdapter::ReadDataOnNetworkThread(
     scoped_refptr<IOBufferWithByteBuffer> read_buffer,
     int buffer_size) {
   DCHECK(context_->IsOnNetworkThread());
   DCHECK(read_buffer);
   DCHECK(!read_buffer_);
 
   read_buffer_ = read_buffer;
 
-  int bytes_read = 0;
-  url_request_->Read(read_buffer_.get(), buffer_size, &bytes_read);
+  int result = url_request_->Read(read_buffer_.get(), buffer_size);
   // 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;
 
-  OnReadCompleted(url_request_.get(), bytes_read);
+  OnReadCompleted(url_request_.get(), result);
 }
 
 void CronetURLRequestAdapter::DestroyOnNetworkThread(bool send_on_canceled) {
   DCHECK(context_->IsOnNetworkThread());
   if (send_on_canceled) {
     JNIEnv* env = base::android::AttachCurrentThread();
     cronet::Java_CronetUrlRequest_onCanceled(env, owner_.obj());
   }
   delete this;
 }
 
-bool CronetURLRequestAdapter::MaybeReportError(net::URLRequest* request) const {
-  DCHECK_NE(net::URLRequestStatus::IO_PENDING, url_request_->status().status());
+void CronetURLRequestAdapter::ReportError(net::URLRequest* request,
+                                          int net_error) const {
+  DCHECK_NE(net::ERR_IO_PENDING, net_error);
+  DCHECK_LT(net_error, 0);
   DCHECK_EQ(request, url_request_.get());
-  if (url_request_->status().is_success())
-    return false;
-  int net_error = url_request_->status().error();
+
   net::NetErrorDetails net_error_details;
   url_request_->PopulateNetErrorDetails(&net_error_details);
   VLOG(1) << "Error " << net::ErrorToString(net_error)
           << " on chromium request: " << initial_url_.possibly_invalid_spec();
   JNIEnv* env = base::android::AttachCurrentThread();
   cronet::Java_CronetUrlRequest_onError(
       env, owner_.obj(), NetErrorToUrlRequestError(net_error), net_error,
       net_error_details.quic_connection_error,
       ConvertUTF8ToJavaString(env, net::ErrorToString(net_error)).obj(),
       request->GetTotalReceivedBytes());
-  return true;
 }
 
 net::URLRequest* CronetURLRequestAdapter::GetURLRequestForTesting() {
   return url_request_.get();
 }
 
 }  // namespace cronet