predictors: Don't cancel the request when IO is pending.

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 "base/stl_util.h"
@@ skipping 159 matching lines @@
 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) {
       status = ShouldContinueReadingRequest(request, bytes_read);
-    } else if (request->status().error()) {
+    } else if (!request->status().is_success()) {

[pasko, 2016/07/29 09:35:29]

I could be missing something .. but will this not turn into a busy loop at
IO_PENDING?

The async read that we started on line 176 will only change the
request->status() before the OnReadCompleted() is called, but we are occupying
the thread here for it to happen.

Seems like we should break out of the loop and continue in OnReadCompleted().

[pasko, 2016/07/29 09:40:42]

oh, my reading was wrong, the status is actually false and we will break out of
the loop.

       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())
@@ skipping 24 matching lines @@
   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().error()) {
+  if (!request->status().is_success()) {
     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().error()) {
+  if (!request->status().is_success()) {
     FinishRequest(request, Request::PREFETCH_STATUS_FAILED);
     return;
   }
 
   if (ShouldContinueReadingRequest(request, bytes_read))
     ReadFullResponse(request);
 }
 
 }  // namespace predictors