Adjust callers and networking delegates in chrome/ to modified APIs

Use modified Read and delegate methods from the following CL-
https://codereview.chromium.org/2262653003/

This CL dependents on the following CL as well -
https://codereview.chromium.org/2264973002/

BUG=423484

Review-Url: https://codereview.chromium.org/2264903003
Cr-Commit-Position: refs/heads/master@{#423805}

chrome/browser/android/offline_pages/offline_page_request_job_unittest.cc

@@ -99,8 +99,9 @@ class TestURLRequestDelegate : public net::URLRequest::Delegate {
       : read_completed_callback_(callback),
         buffer_(new net::IOBuffer(kBufSize)) {}
 
-  void OnResponseStarted(net::URLRequest* request) override {
-    if (!request->status().is_success()) {
+  void OnResponseStarted(net::URLRequest* request, int net_error) override {
+    DCHECK_NE(net::ERR_IO_PENDING, net_error);
+    if (net_error != net::OK) {
       read_completed_callback_.Run(0);
       return;
     }

chrome/browser/extensions/api/web_request/web_request_api_unittest.cc

@@ -29,6 +29,7 @@
 #include "base/time/time.h"
 #include "chrome/browser/content_settings/cookie_settings_factory.h"
 #include "chrome/browser/extensions/event_router_forwarder.h"
+#include "chrome/browser/net/chrome_extensions_network_delegate.h"
 #include "chrome/browser/net/chrome_network_delegate.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "chrome/test/base/testing_profile.h"
@@ -299,8 +300,7 @@ TEST_F(ExtensionWebRequestTest, BlockingEventPrecedenceRedirect) {
     base::RunLoop().Run();
 
     EXPECT_TRUE(!request->is_pending());
-    EXPECT_EQ(net::URLRequestStatus::SUCCESS, request->status().status());
-    EXPECT_EQ(0, request->status().error());
+    EXPECT_EQ(net::OK, delegate_.request_status());
     EXPECT_EQ(redirect_url, request->url());
     EXPECT_EQ(2U, request->url_chain().size());
     EXPECT_EQ(0U, ipc_sender_.GetNumTasks());
@@ -350,8 +350,7 @@ TEST_F(ExtensionWebRequestTest, BlockingEventPrecedenceRedirect) {
     base::RunLoop().Run();
 
     EXPECT_TRUE(!request2->is_pending());
-    EXPECT_EQ(net::URLRequestStatus::SUCCESS, request2->status().status());
-    EXPECT_EQ(0, request2->status().error());
+    EXPECT_EQ(net::OK, delegate_.request_status());
     EXPECT_EQ(redirect_url, request2->url());
     EXPECT_EQ(2U, request2->url_chain().size());
     EXPECT_EQ(0U, ipc_sender_.GetNumTasks());
@@ -419,8 +418,7 @@ TEST_F(ExtensionWebRequestTest, BlockingEventPrecedenceCancel) {
   base::RunLoop().Run();
 
   EXPECT_TRUE(!request->is_pending());
-  EXPECT_EQ(net::URLRequestStatus::FAILED, request->status().status());
-  EXPECT_EQ(net::ERR_BLOCKED_BY_CLIENT, request->status().error());
+  EXPECT_EQ(net::ERR_BLOCKED_BY_CLIENT, delegate_.request_status());
   EXPECT_EQ(request_url, request->url());
   EXPECT_EQ(1U, request->url_chain().size());
   EXPECT_EQ(0U, ipc_sender_.GetNumTasks());
@@ -483,12 +481,11 @@ TEST_F(ExtensionWebRequestTest, SimulateChancelWhileBlocked) {
 
   request->Start();
   // request->Start() will have submitted OnBeforeRequest by the time we cancel.
-  request->Cancel();
+  int net_error = request->Cancel();
   run_loop.Run();
 
+  EXPECT_EQ(net::ERR_ABORTED, net_error);
   EXPECT_TRUE(!request->is_pending());
-  EXPECT_EQ(net::URLRequestStatus::CANCELED, request->status().status());
-  EXPECT_EQ(net::ERR_ABORTED, request->status().error());
   EXPECT_EQ(request_url, request->url());
   EXPECT_EQ(1U, request->url_chain().size());
   EXPECT_EQ(0U, ipc_sender_.GetNumTasks());
@@ -1121,7 +1118,7 @@ TEST_P(ExtensionWebRequestHeaderModificationTest, TestModifications) {
 
   EXPECT_TRUE(!request->is_pending());
   // This cannot succeed as we send the request to a server that does not exist.
-  EXPECT_EQ(net::URLRequestStatus::FAILED, request->status().status());
+  EXPECT_EQ(net::ERR_NAME_NOT_RESOLVED, delegate_.request_status());
   EXPECT_EQ(request_url, request->url());
   EXPECT_EQ(1U, request->url_chain().size());
   EXPECT_EQ(0U, ipc_sender_.GetNumTasks());

chrome/browser/extensions/extension_protocols_unittest.cc

@@ -153,8 +153,7 @@ class ExtensionProtocolTest : public testing::Test {
   // Helper method to create a URLRequest, call StartRequest on it, and return
   // the result. If |extension| hasn't already been added to
   // |extension_info_map_|, this will add it.
-  net::URLRequestStatus::Status DoRequest(const Extension& extension,
-                                          const std::string& relative_path) {
+  int DoRequest(const Extension& extension, const std::string& relative_path) {
     if (!extension_info_map_->extensions().Contains(extension.id())) {
       extension_info_map_->AddExtension(&extension,
                                         base::Time::Now(),
@@ -166,7 +165,7 @@ class ExtensionProtocolTest : public testing::Test {
             extension.GetResourceURL(relative_path), net::DEFAULT_PRIORITY,
             &test_delegate_));
     StartRequest(request.get(), content::RESOURCE_TYPE_MAIN_FRAME);
-    return request->status().status();
+    return test_delegate_.request_status();
   }
 
  protected:
@@ -219,13 +218,12 @@ TEST_F(ExtensionProtocolTest, IncognitoRequest) {
               extension->GetResourceURL("404.html"), net::DEFAULT_PRIORITY,
               &test_delegate_));
       StartRequest(request.get(), content::RESOURCE_TYPE_MAIN_FRAME);
-      EXPECT_EQ(net::URLRequestStatus::FAILED, request->status().status());
 
       if (cases[i].should_allow_main_frame_load) {
-        EXPECT_EQ(net::ERR_FILE_NOT_FOUND, request->status().error()) <<
-            cases[i].name;
+        EXPECT_EQ(net::ERR_FILE_NOT_FOUND, test_delegate_.request_status())
+            << cases[i].name;
       } else {
-        EXPECT_EQ(net::ERR_BLOCKED_BY_CLIENT, request->status().error())
+        EXPECT_EQ(net::ERR_BLOCKED_BY_CLIENT, test_delegate_.request_status())
             << cases[i].name;
       }
     }
@@ -237,13 +235,12 @@ TEST_F(ExtensionProtocolTest, IncognitoRequest) {
               extension->GetResourceURL("404.html"), net::DEFAULT_PRIORITY,
               &test_delegate_));
       StartRequest(request.get(), content::RESOURCE_TYPE_SUB_FRAME);
-      EXPECT_EQ(net::URLRequestStatus::FAILED, request->status().status());
 
       if (cases[i].should_allow_sub_frame_load) {
-        EXPECT_EQ(net::ERR_FILE_NOT_FOUND, request->status().error()) <<
-            cases[i].name;
+        EXPECT_EQ(net::ERR_FILE_NOT_FOUND, test_delegate_.request_status())
+            << cases[i].name;
       } else {
-        EXPECT_EQ(net::ERR_BLOCKED_BY_CLIENT, request->status().error())
+        EXPECT_EQ(net::ERR_BLOCKED_BY_CLIENT, test_delegate_.request_status())
             << cases[i].name;
       }
     }
@@ -279,7 +276,7 @@ TEST_F(ExtensionProtocolTest, ComponentResourceRequest) {
             extension->GetResourceURL("webstore_icon_16.png"),
             net::DEFAULT_PRIORITY, &test_delegate_));
     StartRequest(request.get(), content::RESOURCE_TYPE_MEDIA);
-    EXPECT_EQ(net::URLRequestStatus::SUCCESS, request->status().status());
+    EXPECT_EQ(net::OK, test_delegate_.request_status());
     CheckForContentLengthHeader(request.get());
   }
 
@@ -292,7 +289,7 @@ TEST_F(ExtensionProtocolTest, ComponentResourceRequest) {
             extension->GetResourceURL("webstore_icon_16.png"),
             net::DEFAULT_PRIORITY, &test_delegate_));
     StartRequest(request.get(), content::RESOURCE_TYPE_MEDIA);
-    EXPECT_EQ(net::URLRequestStatus::SUCCESS, request->status().status());
+    EXPECT_EQ(net::OK, test_delegate_.request_status());
     CheckForContentLengthHeader(request.get());
   }
 }
@@ -315,7 +312,7 @@ TEST_F(ExtensionProtocolTest, ResourceRequestResponseHeaders) {
             extension->GetResourceURL("test.dat"), net::DEFAULT_PRIORITY,
             &test_delegate_));
     StartRequest(request.get(), content::RESOURCE_TYPE_MEDIA);
-    EXPECT_EQ(net::URLRequestStatus::SUCCESS, request->status().status());
+    EXPECT_EQ(net::OK, test_delegate_.request_status());
 
     // Check that cache-related headers are set.
     std::string etag;
@@ -356,7 +353,7 @@ TEST_F(ExtensionProtocolTest, AllowFrameRequests) {
             extension->GetResourceURL("test.dat"), net::DEFAULT_PRIORITY,
             &test_delegate_));
     StartRequest(request.get(), content::RESOURCE_TYPE_MAIN_FRAME);
-    EXPECT_EQ(net::URLRequestStatus::SUCCESS, request->status().status());
+    EXPECT_EQ(net::OK, test_delegate_.request_status());
   }
   {
     std::unique_ptr<net::URLRequest> request(
@@ -364,7 +361,7 @@ TEST_F(ExtensionProtocolTest, AllowFrameRequests) {
             extension->GetResourceURL("test.dat"), net::DEFAULT_PRIORITY,
             &test_delegate_));
     StartRequest(request.get(), content::RESOURCE_TYPE_SUB_FRAME);
-    EXPECT_EQ(net::URLRequestStatus::FAILED, request->status().status());
+    EXPECT_EQ(net::ERR_BLOCKED_BY_CLIENT, test_delegate_.request_status());
   }
 
   // And subresource types, such as media, should fail.
@@ -374,7 +371,7 @@ TEST_F(ExtensionProtocolTest, AllowFrameRequests) {
             extension->GetResourceURL("test.dat"), net::DEFAULT_PRIORITY,
             &test_delegate_));
     StartRequest(request.get(), content::RESOURCE_TYPE_MEDIA);
-    EXPECT_EQ(net::URLRequestStatus::FAILED, request->status().status());
+    EXPECT_EQ(net::ERR_BLOCKED_BY_CLIENT, test_delegate_.request_status());
   }
 }
 
@@ -390,19 +387,19 @@ TEST_F(ExtensionProtocolTest, MetadataFolder) {
   ASSERT_NE(extension.get(), nullptr) << "error: " << error;
 
   // Loading "/test.html" should succeed.
-  EXPECT_EQ(net::URLRequestStatus::SUCCESS, DoRequest(*extension, "test.html"));
+  EXPECT_EQ(net::OK, DoRequest(*extension, "test.html"));
 
   // Loading "/_metadata/verified_contents.json" should fail.
   base::FilePath relative_path =
       base::FilePath(kMetadataFolder).Append(kVerifiedContentsFilename);
   EXPECT_TRUE(base::PathExists(extension_dir.Append(relative_path)));
-  EXPECT_EQ(net::URLRequestStatus::FAILED,
+  EXPECT_EQ(net::ERR_FAILED,
             DoRequest(*extension, relative_path.AsUTF8Unsafe()));
 
   // Loading "/_metadata/a.txt" should also fail.
   relative_path = base::FilePath(kMetadataFolder).AppendASCII("a.txt");
   EXPECT_TRUE(base::PathExists(extension_dir.Append(relative_path)));
-  EXPECT_EQ(net::URLRequestStatus::FAILED,
+  EXPECT_EQ(net::ERR_FAILED,
             DoRequest(*extension, relative_path.AsUTF8Unsafe()));
 }
 

chrome/browser/loader/chrome_resource_dispatcher_host_delegate.cc

@@ -793,14 +793,16 @@ void ChromeResourceDispatcherHostDelegate::RequestComplete(
     net::URLRequest* url_request) {
   if (!url_request)
     return;
+  // TODO(maksims): remove this and use net_error argument in RequestComplete
+  // once ResourceDispatcherHostDelegate is modified.
+  int net_error = url_request->status().error();
   const ResourceRequestInfo* info =
       ResourceRequestInfo::ForRequest(url_request);
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&NotifyUIThreadOfRequestComplete,
                  info->GetWebContentsGetterForRequest(), url_request->url(),
-                 info->GetResourceType(), url_request->was_cached(),
-                 url_request->status().error(),
+                 info->GetResourceType(), url_request->was_cached(), net_error,
                  url_request->GetTotalReceivedBytes(),
                  base::TimeTicks::Now() - url_request->creation_time()));
 }

chrome/browser/net/chrome_extensions_network_delegate.cc

@@ -107,7 +107,7 @@ class ChromeExtensionsNetworkDelegateImpl
 
  private:
   // ChromeExtensionsNetworkDelegate implementation.
-  void ForwardProxyErrors(net::URLRequest* request) override;
+  void ForwardProxyErrors(net::URLRequest* request, int net_error) override;
   void ForwardStartRequestStatus(net::URLRequest* request) override;
   void ForwardDoneRequestStatus(net::URLRequest* request) override;
   int OnBeforeURLRequest(net::URLRequest* request,
@@ -126,8 +126,10 @@ class ChromeExtensionsNetworkDelegateImpl
       GURL* allowed_unsafe_redirect_url) override;
   void OnBeforeRedirect(net::URLRequest* request,
                         const GURL& new_location) override;
-  void OnResponseStarted(net::URLRequest* request) override;
-  void OnCompleted(net::URLRequest* request, bool started) override;
+  void OnResponseStarted(net::URLRequest* request, int net_error) override;
+  void OnCompleted(net::URLRequest* request,
+                   bool started,
+                   int net_error) override;
   void OnURLRequestDestroyed(net::URLRequest* request) override;
   void OnPACScriptError(int line_number, const base::string16& error) override;
   net::NetworkDelegate::AuthRequiredResponse OnAuthRequired(
@@ -150,14 +152,15 @@ ChromeExtensionsNetworkDelegateImpl::ChromeExtensionsNetworkDelegateImpl(
 ChromeExtensionsNetworkDelegateImpl::~ChromeExtensionsNetworkDelegateImpl() {}
 
 void ChromeExtensionsNetworkDelegateImpl::ForwardProxyErrors(
-    net::URLRequest* request) {
-  if (request->status().status() == net::URLRequestStatus::FAILED) {
-    switch (request->status().error()) {
+    net::URLRequest* request,
+    int net_error) {
+  if (net_error != net::OK) {
+    switch (net_error) {
       case net::ERR_PROXY_AUTH_UNSUPPORTED:
       case net::ERR_PROXY_CONNECTION_FAILED:
       case net::ERR_TUNNEL_CONNECTION_FAILED:
         extensions::ProxyEventRouter::GetInstance()->OnProxyError(
-            event_router_.get(), profile_, request->status().error());
+            event_router_.get(), profile_, net_error);
     }
   }
 }
@@ -244,39 +247,35 @@ void ChromeExtensionsNetworkDelegateImpl::OnBeforeRedirect(
       GetExtensionNavigationUIData(request), request, new_location);
 }
 
-
 void ChromeExtensionsNetworkDelegateImpl::OnResponseStarted(
-    net::URLRequest* request) {
+    net::URLRequest* request,
+    int net_error) {
   ExtensionWebRequestEventRouter::GetInstance()->OnResponseStarted(
       profile_, extension_info_map_.get(),
-      GetExtensionNavigationUIData(request), request);
-  ForwardProxyErrors(request);
+      GetExtensionNavigationUIData(request), request, net_error);
+  ForwardProxyErrors(request, net_error);
 }
 
-void ChromeExtensionsNetworkDelegateImpl::OnCompleted(
-    net::URLRequest* request,
-    bool started) {
-  if (request->status().status() == net::URLRequestStatus::SUCCESS) {
-    bool is_redirect = request->response_headers() &&
-        net::HttpResponseHeaders::IsRedirectResponseCode(
-            request->response_headers()->response_code());
-    if (!is_redirect) {
-      ExtensionWebRequestEventRouter::GetInstance()->OnCompleted(
-          profile_, extension_info_map_.get(),
-          GetExtensionNavigationUIData(request), request);
-    }
-    return;
-  }
+void ChromeExtensionsNetworkDelegateImpl::OnCompleted(net::URLRequest* request,
+                                                      bool started,
+                                                      int net_error) {
+  DCHECK_NE(net::ERR_IO_PENDING, net_error);
 
-  if (request->status().status() == net::URLRequestStatus::FAILED ||
-      request->status().status() == net::URLRequestStatus::CANCELED) {
+  if (net_error != net::OK) {
     ExtensionWebRequestEventRouter::GetInstance()->OnErrorOccurred(
         profile_, extension_info_map_.get(),
-        GetExtensionNavigationUIData(request), request, started);
+        GetExtensionNavigationUIData(request), request, started, net_error);
     return;
   }
 
-  NOTREACHED();
+  bool is_redirect = request->response_headers() &&
+                     net::HttpResponseHeaders::IsRedirectResponseCode(
+                         request->response_headers()->response_code());
+  if (!is_redirect) {
+    ExtensionWebRequestEventRouter::GetInstance()->OnCompleted(
+        profile_, extension_info_map_.get(),
+        GetExtensionNavigationUIData(request), request, net_error);
+  }
 }
 
 void ChromeExtensionsNetworkDelegateImpl::OnURLRequestDestroyed(
@@ -332,8 +331,8 @@ void ChromeExtensionsNetworkDelegate::set_extension_info_map(
 }
 
 void ChromeExtensionsNetworkDelegate::ForwardProxyErrors(
-    net::URLRequest* request) {
-}
+    net::URLRequest* request,
+    int net_error) {}
 
 void ChromeExtensionsNetworkDelegate::ForwardStartRequestStatus(
     net::URLRequest* request) {
@@ -375,15 +374,13 @@ void ChromeExtensionsNetworkDelegate::OnBeforeRedirect(
     const GURL& new_location) {
 }
 
-
 void ChromeExtensionsNetworkDelegate::OnResponseStarted(
-    net::URLRequest* request) {
-}
-
-void ChromeExtensionsNetworkDelegate::OnCompleted(
     net::URLRequest* request,
-    bool started) {
-}
+    int net_error) {}
+
+void ChromeExtensionsNetworkDelegate::OnCompleted(net::URLRequest* request,
+                                                  bool started,
+                                                  int net_error) {}
 
 void ChromeExtensionsNetworkDelegate::OnURLRequestDestroyed(
     net::URLRequest* request) {

chrome/browser/net/chrome_extensions_network_delegate.h

@@ -36,7 +36,7 @@ class ChromeExtensionsNetworkDelegate : public net::NetworkDelegateImpl {
 
   // If the |request| failed due to problems with a proxy, forward the error to
   // the proxy extension API.
-  virtual void ForwardProxyErrors(net::URLRequest* request);
+  virtual void ForwardProxyErrors(net::URLRequest* request, int net_error);
 
   // Notifies the extensions::ProcessManager for the associated RenderFrame, if
   // any, that a request has started or stopped.
@@ -60,8 +60,10 @@ class ChromeExtensionsNetworkDelegate : public net::NetworkDelegateImpl {
       GURL* allowed_unsafe_redirect_url) override;
   void OnBeforeRedirect(net::URLRequest* request,
                         const GURL& new_location) override;
-  void OnResponseStarted(net::URLRequest* request) override;
-  void OnCompleted(net::URLRequest* request, bool started) override;
+  void OnResponseStarted(net::URLRequest* request, int net_error) override;
+  void OnCompleted(net::URLRequest* request,
+                   bool started,
+                   int net_error) override;
   void OnURLRequestDestroyed(net::URLRequest* request) override;
   void OnPACScriptError(int line_number, const base::string16& error) override;
   net::NetworkDelegate::AuthRequiredResponse OnAuthRequired(

chrome/browser/net/chrome_network_delegate.cc

@@ -127,15 +127,15 @@ void ReportInvalidReferrerSend(const GURL& target_url,
 
 // Record network errors that HTTP requests complete with, including OK and
 // ABORTED.
-void RecordNetworkErrorHistograms(const net::URLRequest* request) {
+void RecordNetworkErrorHistograms(const net::URLRequest* request,
+                                  int net_error) {
   if (request->url().SchemeIs("http")) {
     UMA_HISTOGRAM_SPARSE_SLOWLY("Net.HttpRequestCompletionErrorCodes",
-                                std::abs(request->status().error()));
+                                std::abs(net_error));
 
     if (request->load_flags() & net::LOAD_MAIN_FRAME_DEPRECATED) {
       UMA_HISTOGRAM_SPARSE_SLOWLY(
-          "Net.HttpRequestCompletionErrorCodes.MainFrame",
-          std::abs(request->status().error()));
+          "Net.HttpRequestCompletionErrorCodes.MainFrame", std::abs(net_error));
     }
   }
 }
@@ -352,9 +352,9 @@ void ChromeNetworkDelegate::OnBeforeRedirect(net::URLRequest* request,
   extensions_delegate_->OnBeforeRedirect(request, new_location);
 }
 
-
-void ChromeNetworkDelegate::OnResponseStarted(net::URLRequest* request) {
-  extensions_delegate_->OnResponseStarted(request);
+void ChromeNetworkDelegate::OnResponseStarted(net::URLRequest* request,
+                                              int net_error) {
+  extensions_delegate_->OnResponseStarted(request, net_error);
 }
 
 void ChromeNetworkDelegate::OnNetworkBytesReceived(net::URLRequest* request,
@@ -376,25 +376,26 @@ void ChromeNetworkDelegate::OnNetworkBytesSent(net::URLRequest* request,
 }
 
 void ChromeNetworkDelegate::OnCompleted(net::URLRequest* request,
-                                        bool started) {
+                                        bool started,
+                                        int net_error) {
+  DCHECK_NE(net::ERR_IO_PENDING, net_error);
+
+  // TODO(amohammadkhan): Verify that there is no double recording in data use
+  // of redirected requests.
   data_use_measurement_.OnCompleted(*request, started);
-  RecordNetworkErrorHistograms(request);
+  RecordNetworkErrorHistograms(request, net_error);
 
-  if (request->status().status() == net::URLRequestStatus::SUCCESS) {
+  if (net_error == net::OK) {
 #if BUILDFLAG(ANDROID_JAVA_UI)
     precache::UpdatePrecacheMetricsAndState(request, profile_);
 #endif  // BUILDFLAG(ANDROID_JAVA_UI)
-    extensions_delegate_->OnCompleted(request, started);
-  } else if (request->status().status() == net::URLRequestStatus::FAILED ||
-             request->status().status() == net::URLRequestStatus::CANCELED) {
-    extensions_delegate_->OnCompleted(request, started);
-  } else {
-    NOTREACHED();
   }
+
+  extensions_delegate_->OnCompleted(request, started, net_error);
   if (domain_reliability_monitor_)
     domain_reliability_monitor_->OnCompleted(request, started);
   RecordRequestSourceBandwidth(request, started);
-  extensions_delegate_->ForwardProxyErrors(request);
+  extensions_delegate_->ForwardProxyErrors(request, net_error);
   extensions_delegate_->ForwardDoneRequestStatus(request);
 }
 

chrome/browser/net/chrome_network_delegate.h

@@ -157,12 +157,14 @@ class ChromeNetworkDelegate : public net::NetworkDelegateImpl {
       GURL* allowed_unsafe_redirect_url) override;
   void OnBeforeRedirect(net::URLRequest* request,
                         const GURL& new_location) override;
-  void OnResponseStarted(net::URLRequest* request) override;
+  void OnResponseStarted(net::URLRequest* request, int net_error) override;
   void OnNetworkBytesReceived(net::URLRequest* request,
                               int64_t bytes_received) override;
   void OnNetworkBytesSent(net::URLRequest* request,
                           int64_t bytes_sent) override;
-  void OnCompleted(net::URLRequest* request, bool started) override;
+  void OnCompleted(net::URLRequest* request,
+                   bool started,
+                   int net_error) override;
   void OnURLRequestDestroyed(net::URLRequest* request) override;
   void OnPACScriptError(int line_number, const base::string16& error) override;
   net::NetworkDelegate::AuthRequiredResponse OnAuthRequired(

chrome/browser/predictors/resource_prefetch_predictor_unittest.cc

@@ -46,7 +46,7 @@ scoped_refptr<net::HttpResponseHeaders> MakeResponseHeaders(
 }
 
 class EmptyURLRequestDelegate : public net::URLRequest::Delegate {
-  void OnResponseStarted(net::URLRequest* request) override {}
+  void OnResponseStarted(net::URLRequest* request, int net_error) override {}
   void OnReadCompleted(net::URLRequest* request, int bytes_read) override {}
 };
 

chrome/browser/predictors/resource_prefetcher.cc

@@ -22,6 +22,7 @@ static const size_t kResourceBufferSizeBytes = 50000;
 }  // namespace
 
 namespace predictors {
+
 ResourcePrefetcher::ResourcePrefetcher(
     Delegate* delegate,
     const ResourcePrefetchPredictorConfig& config,
@@ -137,33 +138,19 @@ void ResourcePrefetcher::FinishRequest(net::URLRequest* request) {
 }
 
 void ResourcePrefetcher::ReadFullResponse(net::URLRequest* request) {
-  bool status = true;
-  while (status) {
-    int bytes_read = 0;
+  int bytes_read = 0;
+  do {
     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().is_success()) {
+    bytes_read = request->Read(buffer.get(), kResourceBufferSizeBytes);
+    if (bytes_read == net::ERR_IO_PENDING) {
+      return;
+    } else if (bytes_read <= 0) {
       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())
-      FinishRequest(request);
-    else
-      FinishRequest(request);
-    return false;
-  }
 
-  return true;
+  } while (bytes_read > 0);
 }
 
 void ResourcePrefetcher::OnReceivedRedirect(
@@ -190,22 +177,29 @@ void ResourcePrefetcher::OnSSLCertificateError(net::URLRequest* request,
   FinishRequest(request);
 }
 
-void ResourcePrefetcher::OnResponseStarted(net::URLRequest* request) {
-  // TODO(shishir): Do not read cached entries, or ones that are not cacheable.
-  if (request->status().is_success())
-    ReadFullResponse(request);
-  else
+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.
+  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))
+  if (bytes_read > 0)
     ReadFullResponse(request);
 }
 

chrome/browser/predictors/resource_prefetcher.h

@@ -81,10 +81,6 @@ class ResourcePrefetcher : public net::URLRequest::Delegate {
   // be cached correctly. Stubbed out during testing.
   virtual void ReadFullResponse(net::URLRequest* request);
 
-  // Returns true if the request has more data that needs to be read. If it
-  // returns false, the request should not be referenced again.
-  bool ShouldContinueReadingRequest(net::URLRequest* request, int bytes_read);
-
   // net::URLRequest::Delegate methods.
   void OnReceivedRedirect(net::URLRequest* request,
                           const net::RedirectInfo& redirect_info,
@@ -97,7 +93,7 @@ class ResourcePrefetcher : public net::URLRequest::Delegate {
   void OnSSLCertificateError(net::URLRequest* request,
                              const net::SSLInfo& ssl_info,
                              bool fatal) override;
-  void OnResponseStarted(net::URLRequest* request) override;
+  void OnResponseStarted(net::URLRequest* request, int net_error) override;
   void OnReadCompleted(net::URLRequest* request, int bytes_read) override;
 
   enum PrefetcherState {

chrome/browser/predictors/resource_prefetcher_unittest.cc

@@ -125,7 +125,7 @@ class ResourcePrefetcherTest : public testing::Test {
                                        net::SSLInfo(), false);
   }
   void OnResponse(const std::string& url) {
-    prefetcher_->OnResponseStarted(GetInFlightRequest(url));
+    prefetcher_->OnResponseStarted(GetInFlightRequest(url), net::OK);
   }
 
   base::MessageLoop loop_;

chrome/browser/prerender/prerender_resource_throttle_unittest.cc

@@ -126,7 +126,7 @@ class DeferredRedirectDelegate : public net::URLRequest::Delegate,
     throttle_->WillRedirectRequest(redirect_info, &was_deferred_);
     run_loop_->Quit();
   }
-  void OnResponseStarted(net::URLRequest* request) override {}
+  void OnResponseStarted(net::URLRequest* request, int net_error) override {}
   void OnReadCompleted(net::URLRequest* request, int bytes_read) override {}
 
   // content::ResourceController implementation:

chrome/browser/ui/search/new_tab_page_interceptor_service.cc

@@ -65,6 +65,8 @@ class NewTabPageInterceptor : public net::URLRequestInterceptor {
       return nullptr;
     }
     // User has canceled this navigation so it shouldn't be redirected.
+    // TODO(maksims): Remove request->status() and use int net_error
+    // once MaybeInterceptResponse() starts to pass that.
     if (request->status().status() == net::URLRequestStatus::CANCELED ||
         (request->status().status() == net::URLRequestStatus::FAILED &&
          request->status().error() == net::ERR_ABORTED)) {
@@ -72,6 +74,8 @@ class NewTabPageInterceptor : public net::URLRequestInterceptor {
     }
 
     // Request to NTP was successful.
+    // TODO(maksims): Remove request->status() and use int net_error
+    // once MaybeInterceptResponse() starts to pass that.
     if (request->status().is_success() &&
         request->GetResponseCode() != net::HTTP_NO_CONTENT &&
         request->GetResponseCode() < 400) {