Adjust callers and networking delegates in chrome/ to modified APIs

chrome/browser/predictors/resource_prefetcher.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 "chrome/browser/predictors/resource_prefetcher.h"
 
 #include <iterator>
 #include <utility>
 
 #include "content/public/browser/browser_thread.h"
@@ skipping 148 matching lines @@
 
   TryToLaunchPrefetchRequests();
 }
 
 void ResourcePrefetcher::ReadFullResponse(net::URLRequest* request) {
   bool status = true;
   while (status) {
     int bytes_read = 0;
     scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(
         kResourceBufferSizeBytes));
-    status = request->Read(buffer.get(), kResourceBufferSizeBytes, &bytes_read);
+    bytes_read = request->Read(buffer.get(), kResourceBufferSizeBytes);
 
-    if (status) {
+    if (bytes_read >= 0) {
       status = ShouldContinueReadingRequest(request, bytes_read);
-    } else if (!request->status().is_success()) {
-      FinishRequest(request, Request::PREFETCH_STATUS_FAILED);
-      return;
+    } else if (bytes_read < 0) {

[pasko, 2016/09/21 18:14:02]

why checking the condition again?

this equivalent code would look more readable:
if (bytes_read >= 0) {
  ...
else if (bytes_read != net::ERR_IO_PENDING) {
  ...
}

[pasko, 2016/09/29 13:51:40]

please respond to this comment

[maksims (do not use this acc), 2016/09/30 06:06:07]

Sorry. Right, done!

+      if (bytes_read != net::ERR_IO_PENDING) {
+        FinishRequest(request, Request::PREFETCH_STATUS_FAILED);
+        return;
+      }
     }
   }
 }
 
 bool ResourcePrefetcher::ShouldContinueReadingRequest(net::URLRequest* request,
                                                       int bytes_read) {
   if (bytes_read == 0) {  // When bytes_read == 0, no more data.
     if (request->was_cached())
       FinishRequest(request, Request::PREFETCH_STATUS_FROM_CACHE);
     else
@@ skipping 21 matching lines @@
     net::SSLCertRequestInfo* cert_request_info) {
   FinishRequest(request, Request::PREFETCH_STATUS_CERT_REQUIRED);
 }
 
 void ResourcePrefetcher::OnSSLCertificateError(net::URLRequest* request,
                                                const net::SSLInfo& ssl_info,
                                                bool fatal) {
   FinishRequest(request, Request::PREFETCH_STATUS_CERT_ERROR);
 }
 
-void ResourcePrefetcher::OnResponseStarted(net::URLRequest* request) {
-  if (!request->status().is_success()) {
+void ResourcePrefetcher::OnResponseStarted(net::URLRequest* request,
+                                           int net_error) {
+  DCHECK_NE(net::ERR_IO_PENDING, net_error);

[pasko, 2016/09/21 18:14:02]

In what circumstances is net::ERR_IO_PENDING provided with OnResponseStarted()?
Never? If so, why DCHECK in every client while it could be checked on the API
level?

[maksims (do not use this acc), 2016/09/22 04:17:48]

Because it was done like this in some clients. What is more, it helps to avoid
misusing of these delegate methods.

+
+  if (net_error != net::OK) {
     FinishRequest(request, Request::PREFETCH_STATUS_FAILED);
     return;
   }
 
   // TODO(shishir): Do not read cached entries, or ones that are not cacheable.
   ReadFullResponse(request);
 }
 
 void ResourcePrefetcher::OnReadCompleted(net::URLRequest* request,
                                          int bytes_read) {
-  if (!request->status().is_success()) {
+  DCHECK_NE(net::ERR_IO_PENDING, bytes_read);
+
+  if (bytes_read < 0) {
     FinishRequest(request, Request::PREFETCH_STATUS_FAILED);
     return;
   }
 
   if (ShouldContinueReadingRequest(request, bytes_read))
     ReadFullResponse(request);
 }
 
 }  // namespace predictors