Fixing possible read on URLRequest when there is no more data.

chrome/browser/predictors/resource_prefetcher.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 <iterator>
 
 #include "chrome/browser/predictors/resource_prefetcher.h"
 
 #include "base/stl_util.h"
 #include "content/public/browser/browser_thread.h"
@@ skipping 152 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, kResourceBufferSizeBytes, &bytes_read);
 
     if (status) {
-      if (request->status().error()) {
-        FinishRequest(request, Request::PREFETCH_STATUS_FAILED);
-        return;
-      } else if (bytes_read == 0) {
-        if (request->was_cached())
-          FinishRequest(request, Request::PREFETCH_STATUS_FROM_CACHE);
-        else
-          FinishRequest(request, Request::PREFETCH_STATUS_FROM_NETWORK);
-        return;
-      }
+      status = ShouldContinueReadingRequest(request, bytes_read);
+    } else if (request->status().error()) {
+      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
+      FinishRequest(request, Request::PREFETCH_STATUS_FROM_NETWORK);
+    return false;
+  }
+
+  return true;
+}
+
 void ResourcePrefetcher::OnReceivedRedirect(net::URLRequest* request,
                                             const GURL& new_url,
                                             bool* defer_redirect) {
   FinishRequest(request, Request::PREFETCH_STATUS_REDIRECTED);
 }
 
 void ResourcePrefetcher::OnAuthRequired(net::URLRequest* request,
                                         net::AuthChallengeInfo* auth_info) {
   FinishRequest(request, Request::PREFETCH_STATUS_AUTH_REQUIRED);
 }
 
 void ResourcePrefetcher::OnCertificateRequested(
     net::URLRequest* request,
     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().error()) {
     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()) {
     FinishRequest(request, Request::PREFETCH_STATUS_FAILED);
     return;
   }
 
-  ReadFullResponse(request);
+  if (ShouldContinueReadingRequest(request, bytes_read))
+    ReadFullResponse(request);
 }
 
 }  // namespace predictors