Add WebSocket cookie tests.

net/websockets/websocket_stream_create_test_base.cc

Index: net/websockets/websocket_stream_create_test_base.cc
diff --git a/net/websockets/websocket_stream_create_test_base.cc b/net/websockets/websocket_stream_create_test_base.cc
new file mode 100644
index 0000000000000000000000000000000000000000..57e90259577b83336c2cba0ece6be1198845bdab
--- /dev/null
+++ b/net/websockets/websocket_stream_create_test_base.cc
@@ -0,0 +1,138 @@
+// Copyright 2015 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_create_test_base.h"
+
+#include "base/run_loop.h"
+#include "net/http/http_request_headers.h"
+#include "net/http/http_response_headers.h"
+#include "net/websockets/websocket_basic_handshake_stream.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.h"
+#include "url/gurl.h"
+#include "url/origin.h"
+
+namespace net {
+
+using HeaderKeyValuePair = WebSocketStreamCreateTestBase::HeaderKeyValuePair;
+
+// A sub-class of WebSocketHandshakeStreamCreateHelper which always sets a
+// deterministic key to use in the WebSocket handshake.
+class DeterministicKeyWebSocketHandshakeStreamCreateHelper
+    : public WebSocketHandshakeStreamCreateHelper {
+ 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==");
+  }
+};

[Ryan Sleevi, 2015/02/10 01:26:49]

private:
 DISALLOW_COPY_AND_ASSIGN(...);

[yhirano, 2015/02/10 03:14:03]

Done.

+
+class WebSocketStreamCreateTestBase::TestConnectDelegate
+    : public WebSocketStream::ConnectDelegate {
+ public:
+  explicit TestConnectDelegate(WebSocketStreamCreateTestBase* 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(

[Ryan Sleevi, 2015/02/10 01:26:49]

nit newline after }

[yhirano, 2015/02/10 03:14:03]

Done.

+      scoped_ptr<WebSocketHandshakeResponseInfo> response) override {
+    if (owner_->response_info_)
+      ADD_FAILURE();
+    owner_->response_info_ = response.Pass();
+  }
+  void OnSSLCertificateError(

[Ryan Sleevi, 2015/02/10 01:26:49]

nit: newline after }

[yhirano, 2015/02/10 03:14:02]

Done.

+      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:
+  WebSocketStreamCreateTestBase* owner_;
+};

[Ryan Sleevi, 2015/02/10 01:26:49]

DISALLOW_COPY_AND_ASSIGN(...)

[yhirano, 2015/02/10 03:14:02]

Done.

+
+WebSocketStreamCreateTestBase::WebSocketStreamCreateTestBase()
+    : has_failed_(false), ssl_fatal_(false) {
+}
+
+WebSocketStreamCreateTestBase::~WebSocketStreamCreateTestBase() {
+}

[Ryan Sleevi, 2015/02/10 01:26:49]

git cl format do this? I thought it preferred {} still.

[yhirano, 2015/02/10 03:14:02]

Yes, it likes this style.

+
+void WebSocketStreamCreateTestBase::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();

[Ryan Sleevi, 2015/02/10 01:26:48]

Doesn't it make more sense to remove line 93 and use weak_clear() instead here?

(Clears, but doesn't delete any elements)

[yhirano, 2015/02/10 03:14:02]

Done.

+  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(

[Ryan Sleevi, 2015/02/10 01:26:49]

You're in net::, no need for ::net:: here

[yhirano, 2015/02/10 03:14:02]

Done.

+      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)));
+}
+
+std::vector<HeaderKeyValuePair> WebSocketStreamCreateTestBase::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> WebSocketStreamCreateTestBase::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;
+}
+
+void WebSocketStreamCreateTestBase::RunUntilIdle() {
+  base::RunLoop().RunUntilIdle();
+}
+
+std::vector<std::string> WebSocketStreamCreateTestBase::NoSubProtocols() {
+  return std::vector<std::string>();
+}
+
+}  // namespace net