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"
 #include "net/base/io_buffer.h"
 #include "net/base/load_flags.h"
 #include "net/base/request_priority.h"
 #include "net/url_request/url_request_context.h"
 #include "url/origin.h"
 
 namespace {
 
 // The size of the buffer used to read the resource.
 static const size_t kResourceBufferSizeBytes = 50000;
 
 }  // namespace
 
 namespace predictors {
+
 ResourcePrefetcher::ResourcePrefetcher(
     Delegate* delegate,
     const ResourcePrefetchPredictorConfig& config,
     const GURL& main_frame_url,
     const std::vector<GURL>& urls)
     : state_(INITIALIZED),
       delegate_(delegate),
       config_(config),
       main_frame_url_(main_frame_url) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
@@ skipping 100 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);
-
-    if (status) {
+    bytes_read = request->Read(buffer.get(), kResourceBufferSizeBytes);
+    if (bytes_read >= 0) {
       status = ShouldContinueReadingRequest(request, bytes_read);
-    } else if (!request->status().is_success()) {
+    } else if (bytes_read != net::ERR_IO_PENDING) {

[pasko, 2016/10/04 11:18:42]

So if we get net::ERR_IO_PENDING, this will turn into a busy loop never updating
the |status|. Not good.

[maksims (do not use this acc), 2016/10/04 11:51:35]

Basically, previous implementation has this error as well.
is_success() returned true if the error code was net::OK or net::ERR_IO_PENDING;

[pasko, 2016/10/04 12:14:16]

I noticed you fixed it. Thank you!

Feel free to revert back to the previous version (and notifying me) in case it
does not pass tests for some reason. The previous version was looking good as a
refactoring.

       FinishRequest(request);
       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())
@@ skipping 23 matching lines @@
     net::SSLCertRequestInfo* cert_request_info) {
   FinishRequest(request);
 }
 
 void ResourcePrefetcher::OnSSLCertificateError(net::URLRequest* request,
                                                const net::SSLInfo& ssl_info,
                                                bool fatal) {
   FinishRequest(request);
 }
 
-void ResourcePrefetcher::OnResponseStarted(net::URLRequest* request) {
+void ResourcePrefetcher::OnResponseStarted(net::URLRequest* request,
+                                           int net_error) {
+  DCHECK_NE(net::ERR_IO_PENDING, net_error);
+
+  if (net_error != net::OK) {
+    FinishRequest(request);
+    return;
+  }
+
   // TODO(shishir): Do not read cached entries, or ones that are not cacheable.
-  if (request->status().is_success())
-    ReadFullResponse(request);
-  else
-    FinishRequest(request);
+  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);
     return;
   }
 
   if (ShouldContinueReadingRequest(request, bytes_read))
     ReadFullResponse(request);
 }
 
 }  // namespace predictors