Adjust callers and networking delegates in chrome/ to modified APIs

chrome/browser/net/chrome_extensions_network_delegate.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/net/chrome_extensions_network_delegate.h"
 
 #include <stdint.h>
 
 #include "base/macros.h"
 #include "net/base/net_errors.h"
@@ skipping 73 matching lines @@
 
 class ChromeExtensionsNetworkDelegateImpl
     : public ChromeExtensionsNetworkDelegate {
  public:
   explicit ChromeExtensionsNetworkDelegateImpl(
       extensions::EventRouterForwarder* event_router);
   ~ChromeExtensionsNetworkDelegateImpl() override;
 
  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,
                          const net::CompletionCallback& callback,
                          GURL* new_url) override;
   int OnBeforeStartTransaction(net::URLRequest* request,
                                const net::CompletionCallback& callback,
                                net::HttpRequestHeaders* headers) override;
   void OnStartTransaction(net::URLRequest* request,
                           const net::HttpRequestHeaders& headers) override;
   int OnHeadersReceived(
       net::URLRequest* request,
       const net::CompletionCallback& callback,
       const net::HttpResponseHeaders* original_response_headers,
       scoped_refptr<net::HttpResponseHeaders>* override_response_headers,
       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(
       net::URLRequest* request,
       const net::AuthChallengeInfo& auth_info,
       const AuthCallback& callback,
       net::AuthCredentials* credentials) override;
 
   scoped_refptr<extensions::EventRouterForwarder> event_router_;
 
   DISALLOW_COPY_AND_ASSIGN(ChromeExtensionsNetworkDelegateImpl);
 };
 
 ChromeExtensionsNetworkDelegateImpl::ChromeExtensionsNetworkDelegateImpl(
     extensions::EventRouterForwarder* event_router) {
   DCHECK(event_router);
   event_router_ = event_router;
 }
 
 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);
     }
   }
 }
 
 void ChromeExtensionsNetworkDelegateImpl::ForwardStartRequestStatus(
     net::URLRequest* request) {
   ForwardRequestStatus(REQUEST_STARTED, request, profile_);
 }
 
 void ChromeExtensionsNetworkDelegateImpl::ForwardDoneRequestStatus(
@@ skipping 55 matching lines @@
       allowed_unsafe_redirect_url);
 }
 
 void ChromeExtensionsNetworkDelegateImpl::OnBeforeRedirect(
     net::URLRequest* request,
     const GURL& new_location) {
   ExtensionWebRequestEventRouter::GetInstance()->OnBeforeRedirect(
       profile_, extension_info_map_.get(), request, new_location);
 }
 
-
 void ChromeExtensionsNetworkDelegateImpl::OnResponseStarted(
-    net::URLRequest* request) {
+    net::URLRequest* request,
+    int net_error) {
   ExtensionWebRequestEventRouter::GetInstance()->OnResponseStarted(
-      profile_, extension_info_map_.get(), request);
-  ForwardProxyErrors(request);
+      profile_, extension_info_map_.get(), 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(), request);
-    }
+void ChromeExtensionsNetworkDelegateImpl::OnCompleted(net::URLRequest* request,
+                                                      bool started,
+                                                      int net_error) {
+  DCHECK_NE(net::ERR_IO_PENDING, net_error);
+
+  if (net_error != net::OK) {
+    ExtensionWebRequestEventRouter::GetInstance()->OnErrorOccurred(
+        profile_, extension_info_map_.get(), request, started, net_error);
     return;
   }
 
-  if (request->status().status() == net::URLRequestStatus::FAILED ||
-      request->status().status() == net::URLRequestStatus::CANCELED) {
-    ExtensionWebRequestEventRouter::GetInstance()->OnErrorOccurred(
-        profile_, extension_info_map_.get(), request, started);
-    return;
+  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(), request, net_error);
   }
-
-  NOTREACHED();
 }
 
 void ChromeExtensionsNetworkDelegateImpl::OnURLRequestDestroyed(
     net::URLRequest* request) {
   ExtensionWebRequestEventRouter::GetInstance()->OnURLRequestDestroyed(
       profile_, request);
 }
 
 void ChromeExtensionsNetworkDelegateImpl::OnPACScriptError(
     int line_number,
@@ skipping 34 matching lines @@
 ChromeExtensionsNetworkDelegate::~ChromeExtensionsNetworkDelegate() {}
 
 void ChromeExtensionsNetworkDelegate::set_extension_info_map(
     extensions::InfoMap* extension_info_map) {
 #if defined(ENABLE_EXTENSIONS)
   extension_info_map_ = extension_info_map;
 #endif
 }
 
 void ChromeExtensionsNetworkDelegate::ForwardProxyErrors(
-    net::URLRequest* request) {
-}
+    net::URLRequest* request,
+    int net_error) {}
 
 void ChromeExtensionsNetworkDelegate::ForwardStartRequestStatus(
     net::URLRequest* request) {
 }
 
 void ChromeExtensionsNetworkDelegate::ForwardDoneRequestStatus(
     net::URLRequest* request) {
 }
 
 int ChromeExtensionsNetworkDelegate::OnBeforeURLRequest(
@@ skipping 21 matching lines @@
     scoped_refptr<net::HttpResponseHeaders>* override_response_headers,
     GURL* allowed_unsafe_redirect_url) {
   return net::OK;
 }
 
 void ChromeExtensionsNetworkDelegate::OnBeforeRedirect(
     net::URLRequest* request,
     const GURL& new_location) {
 }
 
+void ChromeExtensionsNetworkDelegate::OnResponseStarted(
+    net::URLRequest* request,
+    int net_error) {}
 
-void ChromeExtensionsNetworkDelegate::OnResponseStarted(
-    net::URLRequest* request) {
-}
-
-void ChromeExtensionsNetworkDelegate::OnCompleted(
-    net::URLRequest* request,
-    bool started) {
-}
+void ChromeExtensionsNetworkDelegate::OnCompleted(net::URLRequest* request,
+                                                  bool started,
+                                                  int net_error) {}
 
 void ChromeExtensionsNetworkDelegate::OnURLRequestDestroyed(
     net::URLRequest* request) {
 }
 
 void ChromeExtensionsNetworkDelegate::OnPACScriptError(
     int line_number,
     const base::string16& error) {
 }
 
 net::NetworkDelegate::AuthRequiredResponse
 ChromeExtensionsNetworkDelegate::OnAuthRequired(
     net::URLRequest* request,
     const net::AuthChallengeInfo& auth_info,
     const AuthCallback& callback,
     net::AuthCredentials* credentials) {
   return net::NetworkDelegate::AUTH_REQUIRED_RESPONSE_NO_ACTION;
 }