Support recovery from SSL errors for new WebSocket implementation

net/websockets/websocket_stream_test.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 <algorithm>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/memory/scoped_vector.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/histogram_samples.h"
 #include "base/metrics/statistics_recorder.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "net/base/net_errors.h"
+#include "net/base/test_data_directory.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_response_headers.h"
 #include "net/socket/client_socket_handle.h"
 #include "net/socket/socket_test_util.h"
+#include "net/test/cert_test_util.h"
 #include "net/url_request/url_request_test_util.h"
 #include "net/websockets/websocket_basic_handshake_stream.h"
 #include "net/websockets/websocket_frame.h"
 #include "net/websockets/websocket_handshake_request_info.h"
 #include "net/websockets/websocket_handshake_response_info.h"
 #include "net/websockets/websocket_handshake_stream_create_helper.h"
 #include "net/websockets/websocket_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 #include "url/origin.h"
@@ skipping 39 matching lines @@
     // This will break in an obvious way if the type created by
     // CreateBasicStream() changes.
     static_cast<WebSocketBasicHandshakeStream*>(stream())
         ->SetWebSocketKeyForTesting("dGhlIHNhbXBsZSBub25jZQ==");
     return stream();
   }
 };
 
 class WebSocketStreamCreateTest : public ::testing::Test {
  public:
-  WebSocketStreamCreateTest(): has_failed_(false) {}
+  WebSocketStreamCreateTest() : has_failed_(false), ssl_fatal_(false) {}
 
   void CreateAndConnectCustomResponse(
       const std::string& socket_url,
       const std::string& socket_path,
       const std::vector<std::string>& sub_protocols,
       const std::string& origin,
       const std::string& extra_request_headers,
       const std::string& response_body) {
     url_request_context_host_.SetExpectations(
         WebSocketStandardRequest(socket_path, origin, extra_request_headers),
@@ skipping 16 matching lines @@
         origin,
         extra_request_headers,
         WebSocketStandardResponse(extra_response_headers));
   }
 
   void CreateAndConnectRawExpectations(
       const std::string& socket_url,
       const std::vector<std::string>& sub_protocols,
       const std::string& origin,
       scoped_ptr<DeterministicSocketData> socket_data) {
-    url_request_context_host_.SetRawExpectations(socket_data.Pass());
+    url_request_context_host_.AddRawExpectations(socket_data.Pass());
     CreateAndConnectStream(socket_url, sub_protocols, origin);
   }
 
   // A wrapper for CreateAndConnectStreamForTesting that knows about our default
   // parameters.
   void CreateAndConnectStream(const std::string& socket_url,
                               const std::vector<std::string>& sub_protocols,
                               const std::string& origin) {
+    for (size_t i = 0; i < ssl_data_.size(); ++i) {
+      scoped_ptr<SSLSocketDataProvider> ssl_data(ssl_data_[i]);
+      ssl_data_[i] = NULL;
+      url_request_context_host_.AddSSLSocketDataProvider(ssl_data.Pass());
+    }
+    ssl_data_.clear();
     scoped_ptr<WebSocketStream::ConnectDelegate> connect_delegate(
         new TestConnectDelegate(this));
     WebSocketStream::ConnectDelegate* delegate = connect_delegate.get();
     stream_request_ = ::net::CreateAndConnectStreamForTesting(
         GURL(socket_url),
         scoped_ptr<WebSocketHandshakeStreamCreateHelper>(
             new DeterministicKeyWebSocketHandshakeStreamCreateHelper(
                 delegate, sub_protocols)),
         url::Origin(origin),
         url_request_context_host_.GetURLRequestContext(),
@@ skipping 30 matching lines @@
       if (owner_->request_info_)
         ADD_FAILURE();
       owner_->request_info_ = request.Pass();
     }
     virtual void OnFinishOpeningHandshake(
         scoped_ptr<WebSocketHandshakeResponseInfo> response) OVERRIDE {
       if (owner_->response_info_)
         ADD_FAILURE();
       owner_->response_info_ = response.Pass();
     }
+    virtual void OnSSLCertificateError(
+        scoped_ptr<WebSocketEventInterface::SSLErrorCallbacks>
+            ssl_error_callbacks,
+        const SSLInfo& ssl_info,
+        bool fatal) OVERRIDE {
+      owner_->ssl_error_callbacks_ = ssl_error_callbacks.Pass();
+      owner_->ssl_info_ = ssl_info;
+      owner_->ssl_fatal_ = fatal;
+    }
 
    private:
     WebSocketStreamCreateTest* owner_;
   };
 
   WebSocketTestURLRequestContextHost url_request_context_host_;
   scoped_ptr<WebSocketStreamRequest> stream_request_;
   // Only set if the connection succeeded.
   scoped_ptr<WebSocketStream> stream_;
   // Only set if the connection failed.
   std::string failure_message_;
   bool has_failed_;
   scoped_ptr<WebSocketHandshakeRequestInfo> request_info_;
   scoped_ptr<WebSocketHandshakeResponseInfo> response_info_;
+  scoped_ptr<WebSocketEventInterface::SSLErrorCallbacks> ssl_error_callbacks_;
+  SSLInfo ssl_info_;
+  bool ssl_fatal_;
+  ScopedVector<SSLSocketDataProvider> ssl_data_;
 };
 
 // There are enough tests of the Sec-WebSocket-Extensions header that they
 // deserve their own test fixture.
 class WebSocketStreamCreateExtensionTest : public WebSocketStreamCreateTest {
  public:
   // Performs a standard connect, with the value of the Sec-WebSocket-Extensions
   // header in the response set to |extensions_header_value|. Runs the event
   // loop to allow the connect to complete.
   void CreateAndConnectWithExtensions(
@@ skipping 823 matching lines @@
                                   "http://localhost",
                                   make_scoped_ptr(socket_data));
   socket_data->RunFor(2);
   EXPECT_TRUE(has_failed());
   EXPECT_FALSE(stream_);
   EXPECT_FALSE(response_info_);
   EXPECT_EQ("Connection closed before receiving a handshake response",
             failure_message());
 }
 
+TEST_F(WebSocketStreamCreateTest, SelfSignedCertificateFailure) {
+  ssl_data_.push_back(
+      new SSLSocketDataProvider(ASYNC, ERR_CERT_AUTHORITY_INVALID));
+  ssl_data_[0]->cert =
+      ImportCertFromFile(GetTestCertsDirectory(), "unittest.selfsigned.der");
+  ASSERT_TRUE(ssl_data_[0]->cert);
+  scoped_ptr<DeterministicSocketData> raw_socket_data(
+      new DeterministicSocketData(NULL, 0, NULL, 0));
+  CreateAndConnectRawExpectations("wss://localhost/",
+                                  NoSubProtocols(),
+                                  "http://localhost",
+                                  raw_socket_data.Pass());
+  RunUntilIdle();
+  EXPECT_FALSE(has_failed());
+  ASSERT_TRUE(ssl_error_callbacks_);
+  ssl_error_callbacks_->CancelSSLRequest(ERR_CERT_AUTHORITY_INVALID,
+                                         &ssl_info_);
+  RunUntilIdle();
+  EXPECT_TRUE(has_failed());
+}
+
+TEST_F(WebSocketStreamCreateTest, SelfSignedCertificateSuccess) {
+  scoped_ptr<SSLSocketDataProvider> ssl_data(
+      new SSLSocketDataProvider(ASYNC, ERR_CERT_AUTHORITY_INVALID));
+  ssl_data->cert =
+      ImportCertFromFile(GetTestCertsDirectory(), "unittest.selfsigned.der");
+  ASSERT_TRUE(ssl_data->cert);
+  ssl_data_.push_back(ssl_data.release());
+  ssl_data.reset(new SSLSocketDataProvider(ASYNC, OK));
+  ssl_data_.push_back(ssl_data.release());
+  url_request_context_host_.AddRawExpectations(
+      make_scoped_ptr(new DeterministicSocketData(NULL, 0, NULL, 0)));
+  CreateAndConnectStandard(
+      "wss://localhost/", "/", NoSubProtocols(), "http://localhost", "", "");
+  RunUntilIdle();
+  ASSERT_TRUE(ssl_error_callbacks_);
+  ssl_error_callbacks_->ContinueSSLRequest();
+  RunUntilIdle();
+  EXPECT_FALSE(has_failed());
+  EXPECT_TRUE(stream_);
+}
+
 TEST_F(WebSocketStreamCreateUMATest, Incomplete) {
   const std::string name("Net.WebSocket.HandshakeResult");
   scoped_ptr<base::HistogramSamples> original(GetSamples(name));
 
   {
     StreamCreation creation;
     creation.CreateAndConnectStandard("ws://localhost/",
                                       "/",
                                       creation.NoSubProtocols(),
                                       "http://localhost",
@@ skipping 55 matching lines @@
                                             "",
                                             kInvalidStatusCodeResponse);
     creation.RunUntilIdle();
   }
 
   scoped_ptr<base::HistogramSamples> samples(GetSamples(name));
   ASSERT_TRUE(samples);
   if (original) {
     samples->Subtract(*original);  // Cancel the original values.
   }
-  EXPECT_EQ(0, samples->GetCount(INCOMPLETE));
+  EXPECT_EQ(1, samples->GetCount(INCOMPLETE));
   EXPECT_EQ(0, samples->GetCount(CONNECTED));
-  EXPECT_EQ(1, samples->GetCount(FAILED));
+  EXPECT_EQ(0, samples->GetCount(FAILED));
 }
 
 }  // namespace
 }  // namespace net