Add unittest to document Websocket behavior.

Add unittest to document existing Websocket behavior with existing
HTTP/2 connection: if there is an HTTP/2 connection open to a server, a
Websocket request should not use it, but instead open a new connection
with HTTP/2 disabled.

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

net/spdy/chromium/spdy_network_transaction_unittest.cc

@@ -54,6 +54,7 @@
 #include "net/test/test_data_directory.h"
 #include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
 #include "net/url_request/url_request_test_util.h"
+#include "net/websockets/websocket_test_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/platform_test.h"
 
@@ -7020,4 +7021,103 @@ TEST_F(SpdyNetworkTransactionTest, PushCanceledByServerAfterClaimed) {
   helper.VerifyDataConsumed();
 }
 
+#if BUILDFLAG(ENABLE_WEBSOCKETS)
+TEST_F(SpdyNetworkTransactionTest, WebsocketOpensNewConnection) {
+  NormalSpdyTransactionHelper helper(request_, DEFAULT_PRIORITY, log_, nullptr);
+  helper.RunPreTestSetup();
+
+  // First request opens up an HTTP/2 connection.
+  SpdySerializedFrame req(
+      spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
+  MockWrite writes1[] = {CreateMockWrite(req, 0)};
+
+  SpdySerializedFrame resp(spdy_util_.ConstructSpdyGetReply(nullptr, 0, 1));
+  SpdySerializedFrame body(spdy_util_.ConstructSpdyDataFrame(1, true));
+  MockRead reads1[] = {CreateMockRead(resp, 1), CreateMockRead(body, 2),
+                       MockRead(ASYNC, ERR_IO_PENDING, 3),
+                       MockRead(ASYNC, 0, 4)};
+
+  SequencedSocketData data1(reads1, arraysize(reads1), writes1,
+                            arraysize(writes1));
+  helper.AddData(&data1);
+
+  // Websocket request opens a new connection with HTTP/2 disabled.
+  MockWrite writes2[] = {
+      MockWrite("GET / HTTP/1.1\r\n"
+                "Host: www.example.org\r\n"
+                "Connection: Upgrade\r\n"
+                "Upgrade: websocket\r\n"
+                "Origin: http://www.example.org\r\n"
+                "Sec-WebSocket-Version: 13\r\n"
+                "Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n\r\n")};
+
+  MockRead reads2[] = {MockRead("HTTP/1.1 200 Connection Established\r\n\r\n")};
+  StaticSocketDataProvider data2(reads2, arraysize(reads2), writes2,
+                                 arraysize(writes2));
+
+  auto ssl_provider2 = std::make_unique<SSLSocketDataProvider>(ASYNC, OK);
+  // Test that request has empty |alpn_protos|, that is, HTTP/2 is disabled.
+  ssl_provider2->next_protos_expected_in_ssl_config = NextProtoVector{};
+  // Force socket to use HTTP/1.1, the default protocol without ALPN.
+  ssl_provider2->next_proto = kProtoHTTP11;
+  ssl_provider2->ssl_info.cert =
+      ImportCertFromFile(GetTestCertsDirectory(), "spdy_pooling.pem");
+  helper.AddDataWithSSLSocketDataProvider(&data2, std::move(ssl_provider2));
+
+  TestCompletionCallback callback1;
+  HttpNetworkTransaction trans1(DEFAULT_PRIORITY, helper.session());
+  int rv = trans1.Start(&request_, callback1.callback(), log_);
+  ASSERT_THAT(rv, IsError(ERR_IO_PENDING));
+  rv = callback1.WaitForResult();
+  ASSERT_THAT(rv, IsOk());
+
+  const HttpResponseInfo* response = trans1.GetResponseInfo();
+  ASSERT_TRUE(response->headers);
+  EXPECT_TRUE(response->was_fetched_via_spdy);
+  EXPECT_EQ("HTTP/1.1 200", response->headers->GetStatusLine());
+
+  std::string response_data;
+  rv = ReadTransaction(&trans1, &response_data);
+  EXPECT_THAT(rv, IsOk());
+  EXPECT_EQ("hello!", response_data);
+
+  SpdySessionKey key(HostPortPair::FromURL(request_.url), ProxyServer::Direct(),
+                     PRIVACY_MODE_DISABLED, SocketTag());
+  base::WeakPtr<SpdySession> spdy_session =
+      helper.session()->spdy_session_pool()->FindAvailableSession(
+          key, /* enable_ip_based_pooling = */ true, log_);
+  ASSERT_TRUE(spdy_session);
+
+  HttpRequestInfo request2;
+  request2.method = "GET";
+  request2.url = GURL("wss://www.example.org/");
+  EXPECT_TRUE(HostPortPair::FromURL(request_.url)
+                  .Equals(HostPortPair::FromURL(request2.url)));
+  request2.extra_headers.SetHeader("Connection", "Upgrade");
+  request2.extra_headers.SetHeader("Upgrade", "websocket");
+  request2.extra_headers.SetHeader("Origin", "http://www.example.org");
+  request2.extra_headers.SetHeader("Sec-WebSocket-Version", "13");
+  request2.extra_headers.SetHeader("Sec-WebSocket-Key",
+                                   "dGhlIHNhbXBsZSBub25jZQ==");
+
+  HttpNetworkTransaction trans2(DEFAULT_PRIORITY, helper.session());
+  FakeWebSocketStreamCreateHelper websocket_stream_create_helper;
+  trans2.SetWebSocketHandshakeStreamCreateHelper(
+      &websocket_stream_create_helper);
+
+  TestCompletionCallback callback2;
+  rv = trans2.Start(&request2, callback2.callback(), log_);
+  ASSERT_THAT(rv, IsError(ERR_IO_PENDING));
+  rv = callback2.WaitForResult();
+  ASSERT_THAT(rv, IsOk());
+
+  // HTTP/2 connection is still open, but Websocket request did not pool to it.
+  ASSERT_TRUE(spdy_session);
+
+  base::RunLoop().RunUntilIdle();
+  data1.Resume();
+  helper.VerifyDataConsumed();
+}
+#endif  // BUILDFLAG(ENABLE_WEBSOCKETS)
+
 }  // namespace net