Revert of Adjust callers and networking delegates in net/ to modified APIs

net/websockets/websocket_stream.cc

 // Copyright 2013 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 "net/websockets/websocket_stream.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/logging.h"
@@ skipping 43 matching lines @@
   ~Delegate() override {
     UMA_HISTOGRAM_ENUMERATION(
         "Net.WebSocket.HandshakeResult", result_, NUM_HANDSHAKE_RESULT_TYPES);
   }
 
   // Implementation of URLRequest::Delegate methods.
   void OnReceivedRedirect(URLRequest* request,
                           const RedirectInfo& redirect_info,
                           bool* defer_redirect) override;
 
-  void OnResponseStarted(URLRequest* request, int net_error) override;
+  void OnResponseStarted(URLRequest* request) override;
 
   void OnAuthRequired(URLRequest* request,
                       AuthChallengeInfo* auth_info) override;
 
   void OnCertificateRequested(URLRequest* request,
                               SSLCertRequestInfo* cert_request_info) override;
 
   void OnSSLCertificateError(URLRequest* request,
                              const SSLInfo& ssl_info,
                              bool fatal) override;
@@ skipping 71 matching lines @@
     DCHECK(timer_);
     DCHECK(handshake_stream_);
 
     timer_->Stop();
 
     WebSocketHandshakeStreamBase* handshake_stream = handshake_stream_;
     handshake_stream_ = nullptr;
     connect_delegate_->OnSuccess(handshake_stream->Upgrade());
   }
 
-  std::string FailureMessageFromNetError(int net_error) {
-    if (net_error == ERR_TUNNEL_CONNECTION_FAILED) {
+  std::string FailureMessageFromNetError() {
+    int error = url_request_->status().error();
+    if (error == ERR_TUNNEL_CONNECTION_FAILED) {
       // This error is common and confusing, so special-case it.
       // TODO(ricea): Include the HostPortPair of the selected proxy server in
       // the error message. This is not currently possible because it isn't set
       // in HttpResponseInfo when a ERR_TUNNEL_CONNECTION_FAILED error happens.
       return "Establishing a tunnel via proxy server failed.";
     } else {
       return std::string("Error in connection establishment: ") +
-             ErrorToString(net_error);
+             ErrorToString(url_request_->status().error());
     }
   }
 
-  void ReportFailure(int net_error) {
+  void ReportFailure() {
     DCHECK(timer_);
     timer_->Stop();
     if (failure_message_.empty()) {
-      switch (net_error) {
-        case OK:
-        case ERR_IO_PENDING:
+      switch (url_request_->status().status()) {
+        case URLRequestStatus::SUCCESS:
+        case URLRequestStatus::IO_PENDING:
           break;
-        case ERR_ABORTED:
-          failure_message_ = "WebSocket opening handshake was canceled";
+        case URLRequestStatus::CANCELED:
+          if (url_request_->status().error() == ERR_TIMED_OUT)
+            failure_message_ = "WebSocket opening handshake timed out";
+          else
+            failure_message_ = "WebSocket opening handshake was canceled";
           break;
-        case ERR_TIMED_OUT:
-          failure_message_ = "WebSocket opening handshake timed out";
-          break;
-        default:
-          failure_message_ = FailureMessageFromNetError(net_error);
+        case URLRequestStatus::FAILED:
+          failure_message_ = FailureMessageFromNetError();
           break;
       }
     }
     ReportFailureWithMessage(failure_message_);
   }
 
   void ReportFailureWithMessage(const std::string& failure_message) {
     connect_delegate_->OnFailure(failure_message);
   }
 
@@ skipping 79 matching lines @@
   if (redirect_info.new_method != "GET" ||
       redirect_info.new_url != expected_url) {
     // This should not happen.
     DLOG(FATAL) << "Unauthorized WebSocket redirect to "
                 << redirect_info.new_method << " "
                 << redirect_info.new_url.spec();
     request->Cancel();
   }
 }
 
-void Delegate::OnResponseStarted(URLRequest* request, int net_error) {
-  DCHECK_NE(ERR_IO_PENDING, net_error);
+void Delegate::OnResponseStarted(URLRequest* request) {
   // All error codes, including OK and ABORTED, as with
   // Net.ErrorCodesForMainFrame3
-  UMA_HISTOGRAM_SPARSE_SLOWLY("Net.WebSocket.ErrorCodes", -net_error);
-  if (net_error != OK) {
+  UMA_HISTOGRAM_SPARSE_SLOWLY("Net.WebSocket.ErrorCodes",
+                              -request->status().error());
+  if (!request->status().is_success()) {
     DVLOG(3) << "OnResponseStarted (request failed)";
-    owner_->ReportFailure(net_error);
+    owner_->ReportFailure();
     return;
   }
   const int response_code = request->GetResponseCode();
   DVLOG(3) << "OnResponseStarted (response code " << response_code << ")";
   switch (response_code) {
     case HTTP_SWITCHING_PROTOCOLS:
       result_ = CONNECTED;
       owner_->PerformUpgrade();
       return;
 
     case HTTP_UNAUTHORIZED:
       result_ = FAILED;
       owner_->OnFinishOpeningHandshake();
       owner_->ReportFailureWithMessage(
           "HTTP Authentication failed; no valid credentials available");
       return;
 
     case HTTP_PROXY_AUTHENTICATION_REQUIRED:
       result_ = FAILED;
       owner_->OnFinishOpeningHandshake();
       owner_->ReportFailureWithMessage("Proxy authentication failed");
       return;
 
     default:
       result_ = FAILED;
-      owner_->ReportFailure(net_error);
+      owner_->ReportFailure();
   }
 }
 
 void Delegate::OnAuthRequired(URLRequest* request,
                               AuthChallengeInfo* auth_info) {
   // This should only be called if credentials are not already stored.
   request->CancelAuth();
 }
 
 void Delegate::OnCertificateRequested(URLRequest* request,
@@ skipping 75 matching lines @@
   DCHECK(connect_delegate);
   if (headers.get()) {
     connect_delegate->OnFinishOpeningHandshake(
         base::WrapUnique(new WebSocketHandshakeResponseInfo(
             url, headers->response_code(), headers->GetStatusText(), headers,
             response_time)));
   }
 }
 
 }  // namespace net