Adjust callers and networking delegates in net/ to modified APIs

net/proxy/proxy_script_fetcher_impl.cc

 // Copyright (c) 2012 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 "net/proxy/proxy_script_fetcher_impl.h"
 
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
@@ skipping 86 matching lines @@
   max_duration_ = timeout;
   return prev;
 }
 
 size_t ProxyScriptFetcherImpl::SetSizeConstraint(size_t size_bytes) {
   size_t prev = max_response_bytes_;
   max_response_bytes_ = size_bytes;
   return prev;
 }
 
-void ProxyScriptFetcherImpl::OnResponseCompleted(URLRequest* request) {
+void ProxyScriptFetcherImpl::OnResponseCompleted(URLRequest* request,
+                                                 int net_error) {
   DCHECK_EQ(request, cur_request_.get());
 
   // Use |result_code_| as the request's error if we have already set it to
   // something specific.
-  if (result_code_ == OK && !request->status().is_success())
-    result_code_ = request->status().error();
+  if (result_code_ == OK && net_error != OK)
+    result_code_ = net_error;
 
   FetchCompleted();
 }
 
 int ProxyScriptFetcherImpl::Fetch(
     const GURL& url, base::string16* text, const CompletionCallback& callback) {
   // It is invalid to call Fetch() while a request is already in progress.
   DCHECK(!cur_request_.get());
   DCHECK(!callback.is_null());
   DCHECK(text);
@@ skipping 75 matching lines @@
   if (IsCertStatusMinorError(ssl_info.cert_status)) {
     request->ContinueDespiteLastError();
     return;
   }
   LOG(WARNING) << "SSL certificate error when fetching PAC script, aborting.";
   // Certificate errors are in same space as net errors.
   result_code_ = MapCertStatusToNetError(ssl_info.cert_status);
   request->Cancel();
 }
 
-void ProxyScriptFetcherImpl::OnResponseStarted(URLRequest* request) {
+void ProxyScriptFetcherImpl::OnResponseStarted(URLRequest* request,
+                                               int net_error) {
   DCHECK_EQ(request, cur_request_.get());
+  DCHECK_NE(ERR_IO_PENDING, net_error);
 
-  if (!request->status().is_success()) {
-    OnResponseCompleted(request);
+  if (net_error != OK) {
+    OnResponseCompleted(request, net_error);
     return;
   }
 
   // Require HTTP responses to have a success status code.
   if (request->url().SchemeIsHTTPOrHTTPS()) {
     // NOTE about status codes: We are like Firefox 3 in this respect.
     // {IE 7, Safari 3, Opera 9.5} do not care about the status code.
     if (request->GetResponseCode() != 200) {
       VLOG(1) << "Fetched PAC script had (bad) status line: "
               << request->response_headers()->GetStatusLine();
@@ skipping 11 matching lines @@
       VLOG(1) << "Fetched PAC script does not have a proper mime type: "
               << mime_type;
     }
   }
 
   ReadBody(request);
 }
 
 void ProxyScriptFetcherImpl::OnReadCompleted(URLRequest* request,
                                              int num_bytes) {
+  DCHECK_NE(ERR_IO_PENDING, num_bytes);
+
   DCHECK_EQ(request, cur_request_.get());
   if (ConsumeBytesRead(request, num_bytes)) {
     // Keep reading.
     ReadBody(request);
   }
 }
 
 void ProxyScriptFetcherImpl::ReadBody(URLRequest* request) {
   // Read as many bytes as are available synchronously.
   while (true) {
-    int num_bytes;
-    if (!request->Read(buf_.get(), kBufSize, &num_bytes)) {
+    int num_bytes = request->Read(buf_.get(), kBufSize);
+    if (num_bytes < 0) {
       // Check whether the read failed synchronously.
-      if (!request->status().is_io_pending())
-        OnResponseCompleted(request);
+      if (num_bytes != ERR_IO_PENDING)
+        OnResponseCompleted(request, num_bytes);
       return;
     }

[mmenke, 2016/08/30 22:13:22]

Think this is clearer as:

if (num_bytes == ERR_IO_PENDING)
  return;

if (num_bytes < 0) {
  ...
  return;
}

if (!ConsumeBytesRead(...))
 return;


A tad more code, but keeping each case separate makes it easier to follow,
rather than grouping the ERR_IO_PENDING and error cases in the first if.

[maksims (do not use this acc), 2016/09/01 12:22:30]

Done.

     if (!ConsumeBytesRead(request, num_bytes))
       return;
   }
 }
 
 bool ProxyScriptFetcherImpl::ConsumeBytesRead(URLRequest* request,
                                               int num_bytes) {
   if (num_bytes <= 0) {
     // Error while reading, or EOF.
-    OnResponseCompleted(request);
+    OnResponseCompleted(request, num_bytes);
     return false;
   }
 
   // Enforce maximum size bound.
   if (num_bytes + bytes_read_so_far_.size() >
       static_cast<size_t>(max_response_bytes_)) {
     result_code_ = ERR_FILE_TOO_BIG;
     request->Cancel();
     return false;
   }
@@ skipping 49 matching lines @@
   // is still applicable.
   if (cur_request_id_ != id)
     return;
 
   DCHECK(cur_request_.get());
   result_code_ = ERR_TIMED_OUT;
   cur_request_->Cancel();
 }
 
 }  // namespace net