Support recovery from SSL errors for new WebSocket implementation

net/websockets/websocket_channel_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_channel.h"
 
 #include <limits.h>
 #include <string.h>
 
 #include <iostream>
@@ skipping 79 matching lines @@
 }
 
 namespace {
 
 using ::base::TimeDelta;
 
 using ::testing::AnyNumber;
 using ::testing::DefaultValue;
 using ::testing::InSequence;
 using ::testing::MockFunction;
+using ::testing::NotNull;
 using ::testing::Return;
 using ::testing::SaveArg;
 using ::testing::StrictMock;
 using ::testing::_;
 
 // A selection of characters that have traditionally been mangled in some
 // environment or other, for testing 8-bit cleanliness.
 const char kBinaryBlob[] = {'\n',   '\r',    // BACKWARDS CRNL
                             '\0',            // nul
                             '\x7F',          // DEL
@@ skipping 54 matching lines @@
   ChannelState OnStartOpeningHandshake(
       scoped_ptr<WebSocketHandshakeRequestInfo>) OVERRIDE {
     OnStartOpeningHandshakeCalled();
     return CHANNEL_ALIVE;
   }
   ChannelState OnFinishOpeningHandshake(
       scoped_ptr<WebSocketHandshakeResponseInfo>) OVERRIDE {
     OnFinishOpeningHandshakeCalled();
     return CHANNEL_ALIVE;
   }
+  virtual ChannelState OnSSLCertificateError(
+      scoped_ptr<SSLErrorCallbacks> ssl_error_callbacks,
+      const GURL& url,
+      const SSLInfo& ssl_info,
+      bool fatal) OVERRIDE {
+    OnSSLCertificateErrorCalled(
+        ssl_error_callbacks.get(), url, ssl_info, fatal);
+    return CHANNEL_ALIVE;
+  }
 
   MOCK_METHOD0(OnStartOpeningHandshakeCalled, void());  // NOLINT
   MOCK_METHOD0(OnFinishOpeningHandshakeCalled, void());  // NOLINT
+  MOCK_METHOD4(
+      OnSSLCertificateErrorCalled,
+      void(SSLErrorCallbacks*, const GURL&, const SSLInfo&, bool));  // NOLINT
 };
 
 // This fake EventInterface is for tests which need a WebSocketEventInterface
 // implementation but are not verifying how it is used.
 class FakeWebSocketEventInterface : public WebSocketEventInterface {
   virtual ChannelState OnAddChannelResponse(
       bool fail,
       const std::string& selected_protocol,
       const std::string& extensions) OVERRIDE {
     return fail ? CHANNEL_DELETED : CHANNEL_ALIVE;
@@ skipping 16 matching lines @@
     return CHANNEL_DELETED;
   }
   virtual ChannelState OnStartOpeningHandshake(
       scoped_ptr<WebSocketHandshakeRequestInfo> request) OVERRIDE {
     return CHANNEL_ALIVE;
   }
   virtual ChannelState OnFinishOpeningHandshake(
       scoped_ptr<WebSocketHandshakeResponseInfo> response) OVERRIDE {
     return CHANNEL_ALIVE;
   }
+  virtual ChannelState OnSSLCertificateError(
+      scoped_ptr<SSLErrorCallbacks> ssl_error_callbacks,
+      const GURL& url,
+      const SSLInfo& ssl_info,
+      bool fatal) OVERRIDE {
+    return CHANNEL_ALIVE;
+  }
 };
 
 // This fake WebSocketStream is for tests that require a WebSocketStream but are
 // not testing the way it is used. It has minimal functionality to return
 // the |protocol| and |extensions| that it was constructed with.
 class FakeWebSocketStream : public WebSocketStream {
  public:
   // Constructs with empty protocol and extensions.
   FakeWebSocketStream() {}
 
@@ skipping 483 matching lines @@
   scoped_ptr<WebSocketStream::ConnectDelegate> connect_delegate;
 };
 
 // Converts a std::string to a std::vector<char>. For test purposes, it is
 // convenient to be able to specify data as a string, but the
 // WebSocketEventInterface requires the vector<char> type.
 std::vector<char> AsVector(const std::string& s) {
   return std::vector<char>(s.begin(), s.end());
 }
 
+class FakeSSLErrorCallbacks
+    : public WebSocketEventInterface::SSLErrorCallbacks {
+ public:
+  virtual void CancelSSLRequest(int error, const SSLInfo* ssl_info) OVERRIDE {}
+  virtual void ContinueSSLRequest() OVERRIDE {}
+};
+
 // Base class for all test fixtures.
 class WebSocketChannelTest : public ::testing::Test {
  protected:
   WebSocketChannelTest() : stream_(new FakeWebSocketStream) {}
 
   // Creates a new WebSocketChannel and connects it, using the settings stored
   // in |connect_data_|.
   void CreateChannelAndConnect() {
     channel_.reset(new WebSocketChannel(CreateEventInterface(),
                                         &connect_data_.url_request_context));
@@ skipping 64 matching lines @@
 // in order to instruct WebSocketChannelDeletingTest when it should fail.
 enum EventInterfaceCall {
   EVENT_ON_ADD_CHANNEL_RESPONSE = 0x1,
   EVENT_ON_DATA_FRAME = 0x2,
   EVENT_ON_FLOW_CONTROL = 0x4,
   EVENT_ON_CLOSING_HANDSHAKE = 0x8,
   EVENT_ON_FAIL_CHANNEL = 0x10,
   EVENT_ON_DROP_CHANNEL = 0x20,
   EVENT_ON_START_OPENING_HANDSHAKE = 0x40,
   EVENT_ON_FINISH_OPENING_HANDSHAKE = 0x80,
+  EVENT_ON_SSL_CERTIFICATE_ERROR = 0x100,
 };
 
 class WebSocketChannelDeletingTest : public WebSocketChannelTest {
  public:
   ChannelState DeleteIfDeleting(EventInterfaceCall call) {
     if (deleting_ & call) {
       channel_.reset();
       return CHANNEL_DELETED;
     } else {
       return CHANNEL_ALIVE;
     }
   }
 
  protected:
   WebSocketChannelDeletingTest()
       : deleting_(EVENT_ON_ADD_CHANNEL_RESPONSE | EVENT_ON_DATA_FRAME |
                   EVENT_ON_FLOW_CONTROL |
                   EVENT_ON_CLOSING_HANDSHAKE |
                   EVENT_ON_FAIL_CHANNEL |
                   EVENT_ON_DROP_CHANNEL |
                   EVENT_ON_START_OPENING_HANDSHAKE |
-                  EVENT_ON_FINISH_OPENING_HANDSHAKE) {}
+                  EVENT_ON_FINISH_OPENING_HANDSHAKE |
+                  EVENT_ON_SSL_CERTIFICATE_ERROR) {}
   // Create a ChannelDeletingFakeWebSocketEventInterface. Defined out-of-line to
   // avoid circular dependency.
   virtual scoped_ptr<WebSocketEventInterface> CreateEventInterface() OVERRIDE;
 
   // Tests can set deleting_ to a bitmap of EventInterfaceCall members that they
   // want to cause Channel deletion. The default is for all calls to cause
   // deletion.
   int deleting_;
 };
 
@@ skipping 38 matching lines @@
   }
 
   virtual ChannelState OnStartOpeningHandshake(
       scoped_ptr<WebSocketHandshakeRequestInfo> request) OVERRIDE {
     return fixture_->DeleteIfDeleting(EVENT_ON_START_OPENING_HANDSHAKE);
   }
   virtual ChannelState OnFinishOpeningHandshake(
       scoped_ptr<WebSocketHandshakeResponseInfo> response) OVERRIDE {
     return fixture_->DeleteIfDeleting(EVENT_ON_FINISH_OPENING_HANDSHAKE);
   }
+  virtual ChannelState OnSSLCertificateError(
+      scoped_ptr<SSLErrorCallbacks> ssl_error_callbacks,
+      const GURL& url,
+      const SSLInfo& ssl_info,
+      bool fatal) OVERRIDE {
+    return fixture_->DeleteIfDeleting(EVENT_ON_SSL_CERTIFICATE_ERROR);
+  }
 
  private:
   // A pointer to the test fixture. Owned by the test harness; this object will
   // be deleted before it is.
   WebSocketChannelDeletingTest* fixture_;
 };
 
 scoped_ptr<WebSocketEventInterface>
 WebSocketChannelDeletingTest::CreateEventInterface() {
   return scoped_ptr<WebSocketEventInterface>(
@@ skipping 2312 matching lines @@
 
   EXPECT_CALL(*event_interface_, OnAddChannelResponse(false, _, _));
   EXPECT_CALL(*event_interface_, OnFlowControl(kDefaultInitialQuota));
   EXPECT_CALL(
       *event_interface_,
       OnDataFrame(true, WebSocketFrameHeader::kOpCodeText, AsVector("")));
 
   CreateChannelAndConnectSuccessfully();
 }
 
+// Calls to OnSSLCertificateError() must be passed through to the event
+// interface with the correct URL attached.
+TEST_F(WebSocketChannelEventInterfaceTest, OnSSLCertificateErrorCalled) {
+  const GURL wss_url("wss://example.com/sslerror");
+  connect_data_.socket_url = wss_url;
+  const SSLInfo ssl_info;
+  const bool fatal = true;
+  scoped_ptr<WebSocketEventInterface::SSLErrorCallbacks> fake_callbacks(
+      new FakeSSLErrorCallbacks);
+
+  EXPECT_CALL(*event_interface_,
+              OnSSLCertificateErrorCalled(NotNull(), wss_url, _, fatal));
+
+  CreateChannelAndConnect();
+  connect_data_.creator.connect_delegate->OnSSLCertificateError(
+      fake_callbacks.Pass(), ssl_info, fatal);
+}
+
 // If we receive another frame after Close, it is not valid. It is not
 // completely clear what behaviour is required from the standard in this case,
 // but the current implementation fails the connection. Since a Close has
 // already been sent, this just means closing the connection.
 TEST_F(WebSocketChannelStreamTest, PingAfterCloseIsRejected) {
   static const InitFrame frames[] = {
       {FINAL_FRAME, WebSocketFrameHeader::kOpCodeClose,
        NOT_MASKED,  CLOSE_DATA(NORMAL_CLOSURE, "OK")},
       {FINAL_FRAME, WebSocketFrameHeader::kOpCodePing,
        NOT_MASKED,  "Ping body"}};
@@ skipping 152 matching lines @@
   channel_->StartClosingHandshake(kWebSocketNormalClosure, "OK");
   ASSERT_TRUE(read_frames);
   // Provide the "Close" message from the server.
   *read_frames = CreateFrameVector(frames);
   read_callback.Run(OK);
   completion.WaitForResult();
 }
 
 }  // namespace
 }  // namespace net