Refactor Websocket test classes.

Factor out FakeWebSocketBasicHandshakeStream and
FakeWebSocketHandshakeStream into websocket_test_util.

Bug: 801564
Change-Id: I093667de806f7d4879144bac447e45663219c5a1
Reviewed-on: https://chromium-review.googlesource.com/891444
Commit-Queue: Bence Béky <bnc@chromium.org>
Reviewed-by: Adam Rice <ricea@chromium.org>
Cr-Commit-Position: refs/heads/master@{#532853}

net/url_request/url_request_http_job_unittest.cc

@@ -40,6 +40,7 @@
 #include "net/url_request/url_request_status.h"
 #include "net/url_request/url_request_test_util.h"
 #include "net/websockets/websocket_handshake_stream_base.h"
+#include "net/websockets/websocket_test_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
@@ -1515,6 +1516,8 @@ TEST_F(URLRequestHttpJobTest, AndroidCleartextPermittedTest) {
 }
 #endif
 
+#if BUILDFLAG(ENABLE_WEBSOCKETS)
+
 // This base class just serves to set up some things before the TestURLRequest
 // constructor is called.
 class URLRequestHttpJobWebSocketTestBase : public ::testing::Test {
@@ -1566,17 +1569,15 @@ class MockCreateHelper : public WebSocketHandshakeStreamBase::CreateHelper {
                WebSocketHandshakeStreamBase*());
 };
 
-#if BUILDFLAG(ENABLE_WEBSOCKETS)
-
-class FakeWebSocketHandshakeStream : public WebSocketHandshakeStreamBase {
+class AsyncFakeWebSocketHandshakeStream
+    : public FakeWebSocketHandshakeStreamBase {
  public:
-  FakeWebSocketHandshakeStream() : initialize_stream_was_called_(false) {}
+  AsyncFakeWebSocketHandshakeStream() : initialize_stream_was_called_(false) {}
 
   bool initialize_stream_was_called() const {
     return initialize_stream_was_called_;
   }
 
-  // Fake implementation of HttpStreamBase methods.
   int InitializeStream(const HttpRequestInfo* request_info,
                        bool can_send_early,
                        RequestPriority priority,
@@ -1596,59 +1597,8 @@ class FakeWebSocketHandshakeStream : public WebSocketHandshakeStreamBase {
     return ERR_IO_PENDING;
   }
 
-  int ReadResponseBody(IOBuffer* buf,
-                       int buf_len,
-                       const CompletionCallback& callback) override {
-    return ERR_IO_PENDING;
-  }
-
   void Close(bool not_reusable) override {}
 
-  bool IsResponseBodyComplete() const override { return false; }
-
-  bool IsConnectionReused() const override { return false; }
-  void SetConnectionReused() override {}
-
-  bool CanReuseConnection() const override { return false; }
-
-  int64_t GetTotalReceivedBytes() const override { return 0; }
-  int64_t GetTotalSentBytes() const override { return 0; }
-
-  bool GetLoadTimingInfo(LoadTimingInfo* load_timing_info) const override {
-    return false;
-  }
-
-  bool GetAlternativeService(
-      AlternativeService* alternative_service) const override {
-    return false;
-  }
-
-  void GetSSLInfo(SSLInfo* ssl_info) override {}
-
-  void GetSSLCertRequestInfo(SSLCertRequestInfo* cert_request_info) override {}
-
-  bool GetRemoteEndpoint(IPEndPoint* endpoint) override { return false; }
-
-  Error GetTokenBindingSignature(crypto::ECPrivateKey* key,
-                                 TokenBindingType tb_type,
-                                 std::vector<uint8_t>* out) override {
-    ADD_FAILURE();
-    return ERR_NOT_IMPLEMENTED;
-  }
-
-  void Drain(HttpNetworkSession* session) override {}
-
-  void PopulateNetErrorDetails(NetErrorDetails* details) override { return; }
-
-  void SetPriority(RequestPriority priority) override {}
-
-  HttpStream* RenewStreamForAuth() override { return nullptr; }
-
-  // Fake implementation of WebSocketHandshakeStreamBase method(s)
-  std::unique_ptr<WebSocketStream> Upgrade() override {
-    return std::unique_ptr<WebSocketStream>();
-  }
-
  private:
   bool initialize_stream_was_called_;
 };
@@ -1662,8 +1612,7 @@ TEST_F(URLRequestHttpJobWebSocketTest, RejectedWithoutCreateHelper) {
 TEST_F(URLRequestHttpJobWebSocketTest, CreateHelperPassedThrough) {
   std::unique_ptr<MockCreateHelper> create_helper =
       std::make_unique<::testing::StrictMock<MockCreateHelper>>();
-  FakeWebSocketHandshakeStream* fake_handshake_stream(
-      new FakeWebSocketHandshakeStream);
+  auto* fake_handshake_stream = new AsyncFakeWebSocketHandshakeStream;
   // Ownership of fake_handshake_stream is transferred when CreateBasicStream()
   // is called.
   EXPECT_CALL(*create_helper, CreateBasicStreamMock())

net/websockets/websocket_test_util.cc

@@ -188,4 +188,128 @@ WebSocketTestURLRequestContextHost::GetURLRequestContext() {
   return &url_request_context_;
 }
 
+int FakeWebSocketHandshakeStreamBase::ReadResponseBody(
+    IOBuffer* buf,
+    int buf_len,
+    const CompletionCallback& callback) {
+  NOTREACHED();
+  return ERR_IO_PENDING;
+}
+
+bool FakeWebSocketHandshakeStreamBase::IsResponseBodyComplete() const {
+  NOTREACHED();
+  return false;
+}
+
+bool FakeWebSocketHandshakeStreamBase::IsConnectionReused() const {
+  NOTREACHED();
+  return false;
+}
+void FakeWebSocketHandshakeStreamBase::SetConnectionReused() {
+  NOTREACHED();
+}
+
+bool FakeWebSocketHandshakeStreamBase::CanReuseConnection() const {
+  return false;
+}
+
+int64_t FakeWebSocketHandshakeStreamBase::GetTotalReceivedBytes() const {
+  return 0;
+}
+
+int64_t FakeWebSocketHandshakeStreamBase::GetTotalSentBytes() const {
+  return 0;
+}
+
+bool FakeWebSocketHandshakeStreamBase::GetLoadTimingInfo(
+    LoadTimingInfo* load_timing_info) const {
+  NOTREACHED();
+  return false;
+}
+
+bool FakeWebSocketHandshakeStreamBase::GetAlternativeService(
+    AlternativeService* alternative_service) const {
+  NOTREACHED();
+  return false;
+}
+
+void FakeWebSocketHandshakeStreamBase::GetSSLInfo(SSLInfo* ssl_info) {}
+
+void FakeWebSocketHandshakeStreamBase::GetSSLCertRequestInfo(
+    SSLCertRequestInfo* cert_request_info) {
+  NOTREACHED();
+}
+
+bool FakeWebSocketHandshakeStreamBase::GetRemoteEndpoint(IPEndPoint* endpoint) {
+  return false;
+}
+
+Error FakeWebSocketHandshakeStreamBase::GetTokenBindingSignature(
+    crypto::ECPrivateKey* key,
+    TokenBindingType tb_type,
+    std::vector<uint8_t>* out) {
+  NOTREACHED();
+  return ERR_NOT_IMPLEMENTED;
+}
+
+void FakeWebSocketHandshakeStreamBase::Drain(HttpNetworkSession* session) {
+  NOTREACHED();
+}
+
+void FakeWebSocketHandshakeStreamBase::PopulateNetErrorDetails(
+    NetErrorDetails* details) {
+  NOTREACHED();
+}
+
+void FakeWebSocketHandshakeStreamBase::SetPriority(RequestPriority priority) {
+  NOTREACHED();
+}
+
+HttpStream* FakeWebSocketHandshakeStreamBase::RenewStreamForAuth() {
+  NOTREACHED();
+  return nullptr;
+}
+
+std::unique_ptr<WebSocketStream> FakeWebSocketHandshakeStreamBase::Upgrade() {
+  NOTREACHED();
+  return std::unique_ptr<WebSocketStream>();
+}
+
+int FakeWebSocketHandshakeStream::InitializeStream(
+    const HttpRequestInfo* request_info,
+    bool can_send_early,
+    RequestPriority priority,
+    const NetLogWithSource& net_log,
+    const CompletionCallback& callback) {
+  state_.Initialize(request_info, can_send_early, priority, net_log, callback);
+  return OK;
+}
+
+int FakeWebSocketHandshakeStream::SendRequest(
+    const HttpRequestHeaders& request_headers,
+    HttpResponseInfo* response,
+    const CompletionCallback& callback) {
+  return parser()->SendRequest(state_.GenerateRequestLine(), request_headers,
+                               TRAFFIC_ANNOTATION_FOR_TESTS, response,
+                               callback);
+}
+
+int FakeWebSocketHandshakeStream::ReadResponseHeaders(
+    const CompletionCallback& callback) {
+  return parser()->ReadResponseHeaders(callback);
+}
+
+void FakeWebSocketHandshakeStream::Close(bool not_reusable) {
+  if (parser())
+    parser()->Close(true);
+}
+
+std::unique_ptr<WebSocketHandshakeStreamBase>
+FakeWebSocketStreamCreateHelper::CreateBasicStream(
+    std::unique_ptr<ClientSocketHandle> connection,
+    bool using_proxy) {
+  return std::make_unique<FakeWebSocketHandshakeStream>(std::move(connection),
+                                                        using_proxy);
+}
+
 }  // namespace net

net/websockets/websocket_test_util.h

@@ -11,6 +11,10 @@
 #include <string>
 
 #include "base/macros.h"
+#include "net/http/http_basic_state.h"
+#include "net/http/http_stream_parser.h"
+#include "net/socket/client_socket_handle.h"
+#include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
 #include "net/url_request/url_request_test_util.h"
 #include "net/websockets/websocket_stream.h"
 
@@ -140,6 +144,82 @@ struct WebSocketTestURLRequestContextHost {
   DISALLOW_COPY_AND_ASSIGN(WebSocketTestURLRequestContextHost);
 };
 
+// Dummy WebSocketHandshakeStreamBase implementation to reduce boilerplate in
+// tests.
+class FakeWebSocketHandshakeStreamBase : public WebSocketHandshakeStreamBase {
+ public:
+  FakeWebSocketHandshakeStreamBase() = default;
+
+  // HttpStreamBase methods.
+  int ReadResponseBody(IOBuffer* buf,
+                       int buf_len,
+                       const CompletionCallback& callback) override;
+  bool IsResponseBodyComplete() const override;
+  bool IsConnectionReused() const override;
+  void SetConnectionReused() override;
+  bool CanReuseConnection() const override;
+  int64_t GetTotalReceivedBytes() const override;
+  int64_t GetTotalSentBytes() const override;
+  bool GetLoadTimingInfo(LoadTimingInfo* load_timing_info) const override;
+  bool GetAlternativeService(
+      AlternativeService* alternative_service) const override;
+  void GetSSLInfo(SSLInfo* ssl_info) override;
+  void GetSSLCertRequestInfo(SSLCertRequestInfo* cert_request_info) override;
+  bool GetRemoteEndpoint(IPEndPoint* endpoint) override;
+  Error GetTokenBindingSignature(crypto::ECPrivateKey* key,
+                                 TokenBindingType tb_type,
+                                 std::vector<uint8_t>* out) override;
+  void Drain(HttpNetworkSession* session) override;
+  void PopulateNetErrorDetails(NetErrorDetails* details) override;
+  void SetPriority(RequestPriority priority) override;
+  HttpStream* RenewStreamForAuth() override;
+
+  // WebSocketHandshakeStreamBase method.
+  std::unique_ptr<WebSocketStream> Upgrade() override;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(FakeWebSocketHandshakeStreamBase);
+};
+
+// Fake WebSocketHandshakeStreamBase implementation that implements SendRequest
+// and ReadResponseHeaders to send data on the mock socket.
+class FakeWebSocketHandshakeStream : public FakeWebSocketHandshakeStreamBase {
+ public:
+  FakeWebSocketHandshakeStream(std::unique_ptr<ClientSocketHandle> connection,
+                               bool using_proxy)
+      : state_(std::move(connection), using_proxy, false) {}
+
+  // HttpStreamBase methods.
+  int InitializeStream(const HttpRequestInfo* request_info,
+                       bool can_send_early,
+                       RequestPriority priority,
+                       const NetLogWithSource& net_log,
+                       const CompletionCallback& callback) override;
+
+  int SendRequest(const HttpRequestHeaders& request_headers,
+                  HttpResponseInfo* response,
+                  const CompletionCallback& callback) override;
+
+  int ReadResponseHeaders(const CompletionCallback& callback) override;
+
+  void Close(bool not_reusable) override;
+
+ private:
+  HttpStreamParser* parser() const { return state_.parser(); }
+  HttpBasicState state_;
+
+  DISALLOW_COPY_AND_ASSIGN(FakeWebSocketHandshakeStream);
+};
+
+class FakeWebSocketStreamCreateHelper
+    : public WebSocketHandshakeStreamBase::CreateHelper {
+ public:
+  std::unique_ptr<WebSocketHandshakeStreamBase> CreateBasicStream(
+      std::unique_ptr<ClientSocketHandle> connection,
+      bool using_proxy) override;
+  ~FakeWebSocketStreamCreateHelper() override = default;
+};
+
 }  // namespace net
 
 #endif  // NET_WEBSOCKETS_WEBSOCKET_TEST_UTIL_H_