Support recovery from SSL errors for new WebSocket implementation

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 "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "net/base/load_flags.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_status_code.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 #include "net/websockets/websocket_errors.h"
+#include "net/websockets/websocket_event_interface.h"
 #include "net/websockets/websocket_handshake_constants.h"
 #include "net/websockets/websocket_handshake_stream_base.h"
 #include "net/websockets/websocket_handshake_stream_create_helper.h"
 #include "net/websockets/websocket_test_util.h"
 #include "url/gurl.h"
 #include "url/origin.h"
 
 namespace net {
 namespace {
 
 class StreamRequestImpl;
 
 class Delegate : public URLRequest::Delegate {
  public:
   enum HandshakeResult {
     INCOMPLETE,
     CONNECTED,
     FAILED,
     NUM_HANDSHAKE_RESULT_TYPES,
   };
 
   explicit Delegate(StreamRequestImpl* owner)
       : owner_(owner), result_(INCOMPLETE) {}
   virtual ~Delegate() {
     UMA_HISTOGRAM_ENUMERATION(
         "Net.WebSocket.HandshakeResult", result_, NUM_HANDSHAKE_RESULT_TYPES);
   }
 
   // Implementation of URLRequest::Delegate methods.
+  virtual void OnReceivedRedirect(URLRequest* request,
+                                  const GURL& new_url,
+                                  bool* defer_redirect) OVERRIDE {
+    // HTTP status codes returned by HttpStreamParser are filtered by
+    // WebSocketBasicHandshakeStream, and only 101, 401 and 407 are permitted
+    // back up the stack to HttpNetworkTransaction. In particular, redirect
+    // codes are never allowed, and so URLRequest never sees a redirect on a
+    // WebSocket request.
+    NOTREACHED();
+  }
+
   virtual void OnResponseStarted(URLRequest* request) OVERRIDE;
 
   virtual void OnAuthRequired(URLRequest* request,
                               AuthChallengeInfo* auth_info) OVERRIDE;
 
   virtual void OnCertificateRequested(URLRequest* request,
                                       SSLCertRequestInfo* cert_request_info)
       OVERRIDE;
 
   virtual void OnSSLCertificateError(URLRequest* request,
@@ skipping 63 matching lines @@
         case URLRequestStatus::FAILED:
           failure_message =
               std::string("Error in connection establishment: ") +
               ErrorToString(url_request_.status().error());
           break;
       }
     }
     connect_delegate_->OnFailure(failure_message);
   }
 
+  WebSocketStream::ConnectDelegate* connect_delegate() const {
+    return connect_delegate_.get();
+  }
+
  private:
   // |delegate_| needs to be declared before |url_request_| so that it gets
   // initialised first.
   scoped_ptr<Delegate> delegate_;
 
   // Deleting the StreamRequestImpl object deletes this URLRequest object,
   // cancelling the whole connection.
   URLRequest url_request_;
 
   scoped_ptr<WebSocketStream::ConnectDelegate> connect_delegate_;
 
   // Owned by the URLRequest.
   WebSocketHandshakeStreamCreateHelper* create_helper_;
 };
 
+class SSLErrorCallbacks : public WebSocketEventInterface::SSLErrorCallbacks {
+ public:
+  explicit SSLErrorCallbacks(URLRequest* url_request)
+      : url_request_(url_request) {}
+
+  virtual void CancelSSLRequest(int error, const SSLInfo* ssl_info) OVERRIDE {
+    if (ssl_info) {
+      url_request_->CancelWithSSLError(error, *ssl_info);
+    } else {
+      url_request_->CancelWithError(error);
+    }
+  }
+
+  virtual void ContinueSSLRequest() OVERRIDE {
+    url_request_->ContinueDespiteLastError();
+  }
+
+ private:
+  URLRequest* url_request_;
+};
+
 void Delegate::OnResponseStarted(URLRequest* request) {
+  if (!request->status().is_success()) {
+    DVLOG(3) << "OnResponseStarted (request failed)";
+    owner_->ReportFailure();
+    return;
+  }
+  DVLOG(3) << "OnResponseStarted (response code " << request->GetResponseCode()
+           << ")";
   switch (request->GetResponseCode()) {
     case HTTP_SWITCHING_PROTOCOLS:
       result_ = CONNECTED;
       owner_->PerformUpgrade();
       return;
 
     case HTTP_UNAUTHORIZED:
     case HTTP_PROXY_AUTHENTICATION_REQUIRED:
       return;
 
     default:
       result_ = FAILED;
       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,
                                       SSLCertRequestInfo* cert_request_info) {
-  request->ContinueWithCertificate(NULL);
+  // This method is called when a client certificate is requested, and the
+  // request context does not already contain a client certificate selection for
+  // the endpoint. In this case, a main frame resource request would pop-up UI
+  // to permit selection of a client certificate, but since WebSockets are
+  // sub-resources they should not pop-up UI and so there is nothing more we can
+  // do.
+  request->Cancel();
 }
 
 void Delegate::OnSSLCertificateError(URLRequest* request,
                                      const SSLInfo& ssl_info,
                                      bool fatal) {
-  request->Cancel();
+  owner_->connect_delegate()->OnSSLCertificateError(
+      scoped_ptr<WebSocketEventInterface::SSLErrorCallbacks>(
+          new SSLErrorCallbacks(request)),
+      ssl_info,
+      fatal);
 }
 
 void Delegate::OnReadCompleted(URLRequest* request, int bytes_read) {
   NOTREACHED();
 }
 
 }  // namespace
 
 WebSocketStreamRequest::~WebSocketStreamRequest() {}
 
@@ skipping 34 matching lines @@
       new StreamRequestImpl(socket_url,
                             url_request_context,
                             origin,
                             connect_delegate.Pass(),
                             create_helper.Pass()));
   request->Start();
   return request.PassAs<WebSocketStreamRequest>();
 }
 
 }  // namespace net