QUIC - enabled FLAGS_allow_truncated_connection_ids_for_quic

net/quic/quic_network_transaction_unittest.cc

 // Copyright (c) 2012 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 <vector>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
@@ skipping 124 matching lines @@
     base::MessageLoop::current()->RunUntilIdle();
   }
 
   scoped_ptr<QuicEncryptedPacket> ConstructConnectionClosePacket(
       QuicPacketSequenceNumber num) {
     return maker_.MakeConnectionClosePacket(num);
   }
 
   scoped_ptr<QuicEncryptedPacket> ConstructAckPacket(
       QuicPacketSequenceNumber largest_received,
-      QuicPacketSequenceNumber least_unacked) {
-    return maker_.MakeAckPacket(2, largest_received, least_unacked, true);
+      QuicPacketSequenceNumber least_unacked,
+      QuicConnectionIdLength connection_id_length) {
+    return maker_.MakeAckPacket(2, connection_id_length, largest_received,
+                                least_unacked, true);
   }
 
   SpdyHeaderBlock GetRequestHeaders(const std::string& method,
                                     const std::string& scheme,
                                     const std::string& path) {
     return maker_.GetRequestHeaders(method, scheme, path);
   }
 
   SpdyHeaderBlock GetResponseHeaders(const std::string& status) {
     return maker_.GetResponseHeaders(status);
   }
 
   scoped_ptr<QuicEncryptedPacket> ConstructDataPacket(
       QuicPacketSequenceNumber sequence_number,
       QuicStreamId stream_id,
       bool should_include_version,
       bool fin,
       QuicStreamOffset offset,
       base::StringPiece data) {
-    return maker_.MakeDataPacket(
-        sequence_number, stream_id, should_include_version, fin, offset, data);
+    return maker_.MakeDataPacket(sequence_number, stream_id,
+                                 should_include_version, fin, offset, data);
   }
 
   scoped_ptr<QuicEncryptedPacket> ConstructRequestHeadersPacket(
       QuicPacketSequenceNumber sequence_number,
       QuicStreamId stream_id,
+      QuicConnectionIdLength connection_id_length,
       bool should_include_version,
       bool fin,
       const SpdyHeaderBlock& headers) {
     return maker_.MakeRequestHeadersPacket(
-        sequence_number, stream_id, should_include_version, fin, headers);
+        sequence_number, stream_id, connection_id_length,
+        should_include_version, fin, headers);
   }
 
   scoped_ptr<QuicEncryptedPacket> ConstructResponseHeadersPacket(
       QuicPacketSequenceNumber sequence_number,
       QuicStreamId stream_id,
+      QuicConnectionIdLength connection_id_length,
       bool should_include_version,
       bool fin,
       const SpdyHeaderBlock& headers) {
     return maker_.MakeResponseHeadersPacket(
-        sequence_number, stream_id, should_include_version, fin, headers);
+        sequence_number, stream_id, connection_id_length,
+        should_include_version, fin, headers);
   }
 
   void CreateSession() {
     CreateSessionWithFactory(&socket_factory_, false);
   }
 
   void CreateSessionWithNextProtos() {
     CreateSessionWithFactory(&socket_factory_, true);
   }
 
@@ skipping 126 matching lines @@
 };
 
 INSTANTIATE_TEST_CASE_P(Version, QuicNetworkTransactionTest,
                         ::testing::ValuesIn(QuicSupportedVersions()));
 
 TEST_P(QuicNetworkTransactionTest, ForceQuic) {
   params_.origin_to_force_quic_on =
       HostPortPair::FromString("www.google.com:80");
 
   MockQuicData mock_quic_data;
-  mock_quic_data.AddWrite(
-      ConstructRequestHeadersPacket(1, kClientDataStreamId1, true, true,
-                                    GetRequestHeaders("GET", "http", "/")));
-  mock_quic_data.AddRead(
-      ConstructResponseHeadersPacket(1, kClientDataStreamId1, false, false,
-                                     GetResponseHeaders("200 OK")));
+  mock_quic_data.AddWrite(ConstructRequestHeadersPacket(
+      1, kClientDataStreamId1, PACKET_0BYTE_CONNECTION_ID, true, true,

[Ryan Hamilton, 2015/01/08 18:35:44]

As discussed offline, we should probably change the MockCryptoClientStream to
specify a TCID of 8.

[ramant (doing other things), 2015/01/08 22:21:15]

Done.

+      GetRequestHeaders("GET", "http", "/")));
+  mock_quic_data.AddRead(ConstructResponseHeadersPacket(
+      1, kClientDataStreamId1, PACKET_0BYTE_CONNECTION_ID, false, false,
+      GetResponseHeaders("200 OK")));
   mock_quic_data.AddRead(
       ConstructDataPacket(2, kClientDataStreamId1, false, true, 0, "hello!"));
-  mock_quic_data.AddWrite(ConstructAckPacket(2, 1));
+  mock_quic_data.AddWrite(ConstructAckPacket(2, 1, PACKET_0BYTE_CONNECTION_ID));
   mock_quic_data.AddRead(SYNCHRONOUS, 0);  // EOF
 
   mock_quic_data.AddDelayedSocketDataToFactory(&socket_factory_, 1);
 
   // The non-alternate protocol job needs to hang in order to guarantee that
   // the alternate-protocol job will "win".
   AddHangingNonAlternateProtocolSocketData();
 
   CreateSession();
 
@@ skipping 33 matching lines @@
   int log_stream_id;
   ASSERT_TRUE(entries[pos].GetIntegerValue("stream_id", &log_stream_id));
   EXPECT_EQ(3, log_stream_id);
 }
 
 TEST_P(QuicNetworkTransactionTest, QuicProxy) {
   proxy_service_.reset(
       ProxyService::CreateFixedFromPacResult("QUIC myproxy:70"));
 
   MockQuicData mock_quic_data;
-  mock_quic_data.AddWrite(
-      ConstructRequestHeadersPacket(1, kClientDataStreamId1, true, true,
-                                    GetRequestHeaders("GET", "http", "/")));
-  mock_quic_data.AddRead(
-      ConstructResponseHeadersPacket(1, kClientDataStreamId1, false, false,
-                                     GetResponseHeaders("200 OK")));
+  mock_quic_data.AddWrite(ConstructRequestHeadersPacket(
+      1, kClientDataStreamId1, PACKET_0BYTE_CONNECTION_ID, true, true,
+      GetRequestHeaders("GET", "http", "/")));
+  mock_quic_data.AddRead(ConstructResponseHeadersPacket(
+      1, kClientDataStreamId1, PACKET_0BYTE_CONNECTION_ID, false, false,
+      GetResponseHeaders("200 OK")));
   mock_quic_data.AddRead(
       ConstructDataPacket(2, kClientDataStreamId1, false, true, 0, "hello!"));
-  mock_quic_data.AddWrite(ConstructAckPacket(2, 1));
+  mock_quic_data.AddWrite(ConstructAckPacket(2, 1, PACKET_0BYTE_CONNECTION_ID));
   mock_quic_data.AddRead(SYNCHRONOUS, 0);  // EOF
 
   mock_quic_data.AddDelayedSocketDataToFactory(&socket_factory_, 1);
 
   // There is no need to set up an alternate protocol job, because
   // no attempt will be made to speak to the proxy over TCP.
 
   CreateSession();
 
   SendRequestAndExpectQuicResponse("hello!");
@@ skipping 47 matching lines @@
     MockRead("hello world"),
     MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
     MockRead(ASYNC, OK)
   };
 
   StaticSocketDataProvider http_data(http_reads, arraysize(http_reads),
                                      nullptr, 0);
   socket_factory_.AddSocketDataProvider(&http_data);
 
   MockQuicData mock_quic_data;
-  mock_quic_data.AddWrite(
-      ConstructRequestHeadersPacket(1, kClientDataStreamId1, true, true,
-                                    GetRequestHeaders("GET", "http", "/")));
-  mock_quic_data.AddRead(
-      ConstructResponseHeadersPacket(1, kClientDataStreamId1, false, false,
-                                     GetResponseHeaders("200 OK")));
+  mock_quic_data.AddWrite(ConstructRequestHeadersPacket(
+      1, kClientDataStreamId1, PACKET_0BYTE_CONNECTION_ID, true, true,
+      GetRequestHeaders("GET", "http", "/")));
+  mock_quic_data.AddRead(ConstructResponseHeadersPacket(
+      1, kClientDataStreamId1, PACKET_0BYTE_CONNECTION_ID, false, false,
+      GetResponseHeaders("200 OK")));
   mock_quic_data.AddRead(
       ConstructDataPacket(2, kClientDataStreamId1, false, true, 0, "hello!"));
-  mock_quic_data.AddWrite(ConstructAckPacket(2, 1));
+  mock_quic_data.AddWrite(ConstructAckPacket(2, 1, PACKET_0BYTE_CONNECTION_ID));
   mock_quic_data.AddRead(SYNCHRONOUS, 0);  // EOF
 
   mock_quic_data.AddDelayedSocketDataToFactory(&socket_factory_, 1);
 
   // The non-alternate protocol job needs to hang in order to guarantee that
   // the alternate-protocol job will "win".
   AddHangingNonAlternateProtocolSocketData();
 
   CreateSessionWithNextProtos();
 
   SendRequestAndExpectHttpResponse("hello world");
   SendRequestAndExpectQuicResponse("hello!");
 }
 
 TEST_P(QuicNetworkTransactionTest, UseAlternateProtocolProbabilityForQuic) {
   MockRead http_reads[] = {
     MockRead("HTTP/1.1 200 OK\r\n"),
     MockRead(kQuicAlternateProtocol50pctHttpHeader),
     MockRead("hello world"),
     MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
     MockRead(ASYNC, OK)
   };
 
   StaticSocketDataProvider http_data(http_reads, arraysize(http_reads),
                                      nullptr, 0);
   socket_factory_.AddSocketDataProvider(&http_data);
 
   MockQuicData mock_quic_data;
-  mock_quic_data.AddWrite(
-      ConstructRequestHeadersPacket(1, kClientDataStreamId1, true, true,
-                                    GetRequestHeaders("GET", "http", "/")));
-  mock_quic_data.AddRead(
-      ConstructResponseHeadersPacket(1, kClientDataStreamId1, false, false,
-                                     GetResponseHeaders("200 OK")));
+  mock_quic_data.AddWrite(ConstructRequestHeadersPacket(
+      1, kClientDataStreamId1, PACKET_0BYTE_CONNECTION_ID, true, true,
+      GetRequestHeaders("GET", "http", "/")));
+  mock_quic_data.AddRead(ConstructResponseHeadersPacket(
+      1, kClientDataStreamId1, PACKET_0BYTE_CONNECTION_ID, false, false,
+      GetResponseHeaders("200 OK")));
   mock_quic_data.AddRead(
       ConstructDataPacket(2, kClientDataStreamId1, false, true, 0, "hello!"));
-  mock_quic_data.AddWrite(ConstructAckPacket(2, 1));
+  mock_quic_data.AddWrite(ConstructAckPacket(2, 1, PACKET_0BYTE_CONNECTION_ID));
   mock_quic_data.AddRead(SYNCHRONOUS, 0);  // EOF
 
   mock_quic_data.AddDelayedSocketDataToFactory(&socket_factory_, 1);
 
   // The non-alternate protocol job needs to hang in order to guarantee that
   // the alternate-protocol job will "win".
   AddHangingNonAlternateProtocolSocketData();
 
   params_.alternate_protocol_probability_threshold = .25;
   CreateSessionWithNextProtos();
@@ skipping 55 matching lines @@
     MockRead("hello world"),
     MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
     MockRead(ASYNC, OK)
   };
 
   StaticSocketDataProvider http_data(http_reads, arraysize(http_reads),
                                      nullptr, 0);
   socket_factory_.AddSocketDataProvider(&http_data);
 
   MockQuicData mock_quic_data;
-  mock_quic_data.AddWrite(
-      ConstructRequestHeadersPacket(1, kClientDataStreamId1, true, true,
-                                    GetRequestHeaders("GET", "http", "/")));
-  mock_quic_data.AddRead(
-      ConstructResponseHeadersPacket(1, kClientDataStreamId1, false, false,
-                                     GetResponseHeaders("200 OK")));
+  mock_quic_data.AddWrite(ConstructRequestHeadersPacket(
+      1, kClientDataStreamId1, PACKET_0BYTE_CONNECTION_ID, true, true,
+      GetRequestHeaders("GET", "http", "/")));
+  mock_quic_data.AddRead(ConstructResponseHeadersPacket(
+      1, kClientDataStreamId1, PACKET_0BYTE_CONNECTION_ID, false, false,
+      GetResponseHeaders("200 OK")));
   mock_quic_data.AddRead(
       ConstructDataPacket(2, kClientDataStreamId1, false, true, 0, "hello!"));
-  mock_quic_data.AddWrite(ConstructAckPacket(2, 1));
+  mock_quic_data.AddWrite(ConstructAckPacket(2, 1, PACKET_0BYTE_CONNECTION_ID));
   mock_quic_data.AddRead(SYNCHRONOUS, 0);  // EOF
 
   mock_quic_data.AddDelayedSocketDataToFactory(&socket_factory_, 1);
 
   // The non-alternate protocol job needs to hang in order to guarantee that
   // the alternate-protocol job will "win".
   AddHangingNonAlternateProtocolSocketData();
 
   CreateSessionWithNextProtos();
 
@@ skipping 54 matching lines @@
   SendRequestAndExpectHttpResponse("hello world");
 
   ASSERT_TRUE(http_data2.at_read_eof());
   ASSERT_TRUE(http_data2.at_write_eof());
   ASSERT_TRUE(!quic_data.at_read_eof());
   ASSERT_TRUE(!quic_data.at_write_eof());
 }
 
 TEST_P(QuicNetworkTransactionTest, ZeroRTTWithHttpRace) {
   MockQuicData mock_quic_data;
-  mock_quic_data.AddWrite(
-      ConstructRequestHeadersPacket(1, kClientDataStreamId1, true, true,
-                                    GetRequestHeaders("GET", "http", "/")));
-  mock_quic_data.AddRead(
-      ConstructResponseHeadersPacket(1, kClientDataStreamId1, false, false,
-                                     GetResponseHeaders("200 OK")));
+  mock_quic_data.AddWrite(ConstructRequestHeadersPacket(
+      1, kClientDataStreamId1, PACKET_8BYTE_CONNECTION_ID, true, true,
+      GetRequestHeaders("GET", "http", "/")));
+  mock_quic_data.AddRead(ConstructResponseHeadersPacket(
+      1, kClientDataStreamId1, PACKET_8BYTE_CONNECTION_ID, false, false,
+      GetResponseHeaders("200 OK")));
   mock_quic_data.AddRead(
       ConstructDataPacket(2, kClientDataStreamId1, false, true, 0, "hello!"));
-  mock_quic_data.AddWrite(ConstructAckPacket(2, 1));
+  mock_quic_data.AddWrite(ConstructAckPacket(2, 1, PACKET_8BYTE_CONNECTION_ID));
   mock_quic_data.AddRead(SYNCHRONOUS, 0);  // EOF
 
   mock_quic_data.AddDelayedSocketDataToFactory(&socket_factory_, 1);
 
   // The non-alternate protocol job needs to hang in order to guarantee that
   // the alternate-protocol job will "win".
   AddHangingNonAlternateProtocolSocketData();
 
   CreateSessionWithNextProtos();
   AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT);
   SendRequestAndExpectQuicResponse("hello!");
 }
 
 TEST_P(QuicNetworkTransactionTest, ZeroRTTWithNoHttpRace) {
   MockQuicData mock_quic_data;
-  mock_quic_data.AddWrite(
-      ConstructRequestHeadersPacket(1, kClientDataStreamId1, true, true,
-                                    GetRequestHeaders("GET", "http", "/")));
-  mock_quic_data.AddRead(
-      ConstructResponseHeadersPacket(1, kClientDataStreamId1, false, false,
-                                     GetResponseHeaders("200 OK")));
+  mock_quic_data.AddWrite(ConstructRequestHeadersPacket(
+      1, kClientDataStreamId1, PACKET_8BYTE_CONNECTION_ID, true, true,
+      GetRequestHeaders("GET", "http", "/")));
+  mock_quic_data.AddRead(ConstructResponseHeadersPacket(
+      1, kClientDataStreamId1, PACKET_8BYTE_CONNECTION_ID, false, false,
+      GetResponseHeaders("200 OK")));
   mock_quic_data.AddRead(
       ConstructDataPacket(2, kClientDataStreamId1, false, true, 0, "hello!"));
-  mock_quic_data.AddWrite(ConstructAckPacket(2, 1));
+  mock_quic_data.AddWrite(ConstructAckPacket(2, 1, PACKET_8BYTE_CONNECTION_ID));
   mock_quic_data.AddRead(SYNCHRONOUS, 0);  // EOF
   mock_quic_data.AddDelayedSocketDataToFactory(&socket_factory_, 1);
 
   // In order for a new QUIC session to be established via alternate-protocol
   // without racing an HTTP connection, we need the host resolution to happen
   // synchronously.
   host_resolver_.set_synchronous_mode(true);
   host_resolver_.rules()->AddIPLiteralRule("www.google.com", "192.168.0.1", "");
   HostResolver::RequestInfo info(HostPortPair("www.google.com", 80));
   AddressList address;
@@ skipping 45 matching lines @@
                          nullptr,
                          net_log_.bound());
 
   CreateSessionWithNextProtos();
   AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT);
   SendRequestAndExpectHttpResponse("hello world");
 }
 
 TEST_P(QuicNetworkTransactionTest, ZeroRTTWithConfirmationRequired) {
   MockQuicData mock_quic_data;
-  mock_quic_data.AddWrite(
-      ConstructRequestHeadersPacket(1, kClientDataStreamId1, true, true,
-                                    GetRequestHeaders("GET", "http", "/")));
-  mock_quic_data.AddRead(
-      ConstructResponseHeadersPacket(1, kClientDataStreamId1, false, false,
-                                     GetResponseHeaders("200 OK")));
+  mock_quic_data.AddWrite(ConstructRequestHeadersPacket(
+      1, kClientDataStreamId1, PACKET_0BYTE_CONNECTION_ID, true, true,
+      GetRequestHeaders("GET", "http", "/")));
+  mock_quic_data.AddRead(ConstructResponseHeadersPacket(
+      1, kClientDataStreamId1, PACKET_0BYTE_CONNECTION_ID, false, false,
+      GetResponseHeaders("200 OK")));
   mock_quic_data.AddRead(
       ConstructDataPacket(2, kClientDataStreamId1, false, true, 0, "hello!"));
-  mock_quic_data.AddWrite(ConstructAckPacket(2, 1));
+  mock_quic_data.AddWrite(ConstructAckPacket(2, 1, PACKET_0BYTE_CONNECTION_ID));
   mock_quic_data.AddRead(SYNCHRONOUS, 0);  // EOF
   mock_quic_data.AddDelayedSocketDataToFactory(&socket_factory_, 1);
 
   // The non-alternate protocol job needs to hang in order to guarantee that
   // the alternate-protocol job will "win".
   AddHangingNonAlternateProtocolSocketData();
 
   // In order for a new QUIC session to be established via alternate-protocol
   // without racing an HTTP connection, we need the host resolution to happen
   // synchronously.  Of course, even though QUIC *could* perform a 0-RTT
@@ skipping 199 matching lines @@
   CreateSessionWithNextProtos();
   AddQuicAlternateProtocolMapping(MockCryptoClientStream::COLD_START);
   SendRequestAndExpectHttpResponse("hello from http");
 
   ExpectBrokenAlternateProtocolMapping();
 }
 
 TEST_P(QuicNetworkTransactionTest, ConnectionCloseDuringConnect) {
   MockQuicData mock_quic_data;
   mock_quic_data.AddRead(ConstructConnectionClosePacket(1));
-  mock_quic_data.AddWrite(
-      ConstructRequestHeadersPacket(1, kClientDataStreamId1, true, true,
-                                    GetRequestHeaders("GET", "http", "/")));
-  mock_quic_data.AddWrite(ConstructAckPacket(2, 1));
+  mock_quic_data.AddWrite(ConstructRequestHeadersPacket(
+      1, kClientDataStreamId1, PACKET_0BYTE_CONNECTION_ID, true, true,
+      GetRequestHeaders("GET", "http", "/")));
+  mock_quic_data.AddWrite(ConstructAckPacket(2, 1, PACKET_0BYTE_CONNECTION_ID));
   mock_quic_data.AddDelayedSocketDataToFactory(&socket_factory_, 0);
 
   // When the QUIC connection fails, we will try the request again over HTTP.
   MockRead http_reads[] = {
     MockRead("HTTP/1.1 200 OK\r\n"),
     MockRead(kQuicAlternateProtocolHttpHeader),
     MockRead("hello world"),
     MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
     MockRead(ASYNC, OK)
   };
@@ skipping 16 matching lines @@
                          nullptr,
                          net_log_.bound());
 
   CreateSessionWithNextProtos();
   AddQuicAlternateProtocolMapping(MockCryptoClientStream::ZERO_RTT);
   SendRequestAndExpectHttpResponse("hello world");
 }
 
 }  // namespace test
 }  // namespace net