Add WebSocket cookie tests.

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/compiler_specific.h"
 #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 "base/timer/mock_timer.h"
 #include "base/timer/timer.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_stream_create_test_base.h"
 #include "net/websockets/websocket_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 #include "url/origin.h"
 
 namespace net {
 namespace {
 
-typedef std::pair<std::string, std::string> HeaderKeyValuePair;
-
-std::vector<HeaderKeyValuePair> ToVector(const HttpRequestHeaders& headers) {
-  HttpRequestHeaders::Iterator it(headers);
-  std::vector<HeaderKeyValuePair> result;
-  while (it.GetNext())
-    result.push_back(HeaderKeyValuePair(it.name(), it.value()));
-  return result;
-}
-
-std::vector<HeaderKeyValuePair> ToVector(const HttpResponseHeaders& headers) {
-  void* iter = NULL;
-  std::string name, value;
-  std::vector<HeaderKeyValuePair> result;
-  while (headers.EnumerateHeaderLines(&iter, &name, &value))
-    result.push_back(HeaderKeyValuePair(name, value));
-  return result;
-}
-
 // Simple builder for a DeterministicSocketData object to save repetitive code.
 // It always sets the connect data to MockConnect(SYNCHRONOUS, OK), so it cannot
 // be used in tests where the connect fails. In practice, those tests never have
 // any read/write data and so can't benefit from it anyway.  The arrays are not
 // copied. It is up to the caller to ensure they stay in scope until the test
 // ends.
 template <size_t reads_count, size_t writes_count>
 scoped_ptr<DeterministicSocketData> BuildSocketData(
     MockRead (&reads)[reads_count],
     MockWrite (&writes)[writes_count]) {
@@ skipping 10 matching lines @@
   return make_scoped_ptr(new DeterministicSocketData(NULL, 0, NULL, 0));
 }
 
 class MockWeakTimer : public base::MockTimer,
                       public base::SupportsWeakPtr<MockWeakTimer> {
  public:
   MockWeakTimer(bool retain_user_task, bool is_repeating)
       : MockTimer(retain_user_task, is_repeating) {}
 };
 
-// A sub-class of WebSocketHandshakeStreamCreateHelper which always sets a
-// deterministic key to use in the WebSocket handshake.
-class DeterministicKeyWebSocketHandshakeStreamCreateHelper
-    : public WebSocketHandshakeStreamCreateHelper {
+class WebSocketStreamCreateTest : public ::testing::Test,
+                                  public WebSocketStreamCreateTestBase {
  public:
-  DeterministicKeyWebSocketHandshakeStreamCreateHelper(
-      WebSocketStream::ConnectDelegate* connect_delegate,
-      const std::vector<std::string>& requested_subprotocols)
-      : WebSocketHandshakeStreamCreateHelper(connect_delegate,
-                                             requested_subprotocols) {}
-
-  void OnStreamCreated(WebSocketBasicHandshakeStream* stream) override {
-    stream->SetWebSocketKeyForTesting("dGhlIHNhbXBsZSBub25jZQ==");
-  }
-};
-
-class WebSocketStreamCreateTest : public ::testing::Test {
- public:
-  WebSocketStreamCreateTest() : has_failed_(false), ssl_fatal_(false) {}
   ~WebSocketStreamCreateTest() override {
     // Permit any endpoint locks to be released.
     stream_request_.reset();
     stream_.reset();
     RunUntilIdle();
   }
 
   void CreateAndConnectCustomResponse(
       const std::string& socket_url,
       const std::string& socket_host,
@@ skipping 34 matching lines @@
       scoped_ptr<DeterministicSocketData> socket_data,
       scoped_ptr<base::Timer> timer = scoped_ptr<base::Timer>()) {
     AddRawExpectations(socket_data.Pass());
     CreateAndConnectStream(socket_url, sub_protocols, origin, timer.Pass());
   }
 
   // Add additional raw expectations for sockets created before the final one.
   void AddRawExpectations(scoped_ptr<DeterministicSocketData> socket_data) {
     url_request_context_host_.AddRawExpectations(socket_data.Pass());
   }
-
-  // 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,
-                              scoped_ptr<base::Timer> timer) {
-    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();
-    scoped_ptr<WebSocketHandshakeStreamCreateHelper> create_helper(
-        new DeterministicKeyWebSocketHandshakeStreamCreateHelper(
-            delegate, sub_protocols));
-    stream_request_ = ::net::CreateAndConnectStreamForTesting(
-        GURL(socket_url),
-        create_helper.Pass(),
-        url::Origin(origin),
-        url_request_context_host_.GetURLRequestContext(),
-        BoundNetLog(),
-        connect_delegate.Pass(),
-        timer ? timer.Pass() : scoped_ptr<base::Timer>(
-            new base::Timer(false, false)));
-  }
-
-  static void RunUntilIdle() { base::RunLoop().RunUntilIdle(); }
-
-  // A simple function to make the tests more readable. Creates an empty vector.
-  static std::vector<std::string> NoSubProtocols() {
-    return std::vector<std::string>();
-  }
-
-  const std::string& failure_message() const { return failure_message_; }
-  bool has_failed() const { return has_failed_; }
-
-  class TestConnectDelegate : public WebSocketStream::ConnectDelegate {
-   public:
-    explicit TestConnectDelegate(WebSocketStreamCreateTest* owner)
-        : owner_(owner) {}
-
-    void OnSuccess(scoped_ptr<WebSocketStream> stream) override {
-      stream.swap(owner_->stream_);
-    }
-
-    void OnFailure(const std::string& message) override {
-      owner_->has_failed_ = true;
-      owner_->failure_message_ = message;
-    }
-
-    void OnStartOpeningHandshake(
-        scoped_ptr<WebSocketHandshakeRequestInfo> request) override {
-      // Can be called multiple times (in the case of HTTP auth). Last call
-      // wins.
-      owner_->request_info_ = request.Pass();
-    }
-    void OnFinishOpeningHandshake(
-        scoped_ptr<WebSocketHandshakeResponseInfo> response) override {
-      if (owner_->response_info_)
-        ADD_FAILURE();
-      owner_->response_info_ = response.Pass();
-    }
-    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_;
-  ScopedWebSocketEndpointZeroUnlockDelay zero_unlock_delay_;
 };
 
 // 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 1139 matching lines @@
       BuildSocketData(reads, writes));
   socket_data->set_connect_data(MockConnect(SYNCHRONOUS, OK));
   CreateAndConnectRawExpectations("ws://localhost/", NoSubProtocols(),
                                   "http://localhost", socket_data.Pass());
   RunUntilIdle();
   EXPECT_TRUE(has_failed());
 }
 
 }  // namespace
 }  // namespace net