QUIC - enabled FLAGS_allow_truncated_connection_ids_for_quic

net/quic/quic_stream_factory_test.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 "net/quic/quic_stream_factory.h"
 
 #include "base/run_loop.h"
 #include "base/strings/string_util.h"
 #include "net/base/test_data_directory.h"
 #include "net/cert/cert_verifier.h"
@@ skipping 147 matching lines @@
                  clock_,
                  kDefaultMaxPacketSize,
                  std::string(),
                  SupportedVersions(GetParam()),
                  /*enable_port_selection=*/true,
                  /*always_require_handshake_confirmation=*/false,
                  /*disable_connection_pooling=*/false,
                  /*load_server_info_timeout=*/0u,
                  /*disable_loading_server_info_for_new_servers=*/false,
                  /*load_server_info_timeout_srtt_multiplier=*/0.0f,
+                 /*disable_truncated_connection_ids=*/false,
                  QuicTagVector()),
         host_port_pair_(kDefaultServerHostName, kDefaultServerPort),
         is_https_(false),
         privacy_mode_(PRIVACY_MODE_DISABLED) {
     factory_.set_require_confirmation(false);
     clock_->AdvanceTime(QuicTime::Delta::FromSeconds(1));
   }
 
   scoped_ptr<QuicHttpStream> CreateIfSessionExists(
       const HostPortPair& host_port_pair,
@@ skipping 58 matching lines @@
     factory_.OnSessionClosed(session);
     EXPECT_EQ(nullptr, CreateIfSessionExists(destination, net_log_).get());
     EXPECT_TRUE(socket_data.at_read_eof());
     EXPECT_TRUE(socket_data.at_write_eof());
     return port;
   }
 
   scoped_ptr<QuicEncryptedPacket> ConstructRstPacket() {
     QuicStreamId stream_id = kClientDataStreamId1;
     return maker_.MakeRstPacket(
-        1, true, stream_id,
+        1, PACKET_0BYTE_CONNECTION_ID, true, stream_id,
         AdjustErrorForVersion(QUIC_RST_ACKNOWLEDGEMENT, GetParam()));
   }
 
   MockQuicServerInfoFactory quic_server_info_factory_;
   MockHostResolver host_resolver_;
   DeterministicMockClientSocketFactory socket_factory_;
   MockCryptoClientStreamFactory crypto_client_stream_factory_;
   MockRandom random_generator_;
   MockClock* clock_;  // Owned by factory_.
   scoped_refptr<TestTaskRunner> runner_;
@@ skipping 816 matching lines @@
   EXPECT_TRUE(socket_data.at_write_eof());
   EXPECT_TRUE(socket_data2.at_read_eof());
   EXPECT_TRUE(socket_data2.at_write_eof());
 }
 
 TEST_P(QuicStreamFactoryTest, MaxOpenStream) {
   MockRead reads[] = {
     MockRead(ASYNC, OK, 0)  // EOF
   };
   QuicStreamId stream_id = kClientDataStreamId1;
-  scoped_ptr<QuicEncryptedPacket> rst(
-      maker_.MakeRstPacket(1, true, stream_id, QUIC_STREAM_CANCELLED));
+  scoped_ptr<QuicEncryptedPacket> rst(maker_.MakeRstPacket(
+      1, PACKET_0BYTE_CONNECTION_ID, true, stream_id, QUIC_STREAM_CANCELLED));
   MockWrite writes[] = {
     MockWrite(ASYNC, rst->data(), rst->length(), 1),
   };
   DeterministicSocketData socket_data(reads, arraysize(reads),
                                       writes, arraysize(writes));
   socket_factory_.AddSocketDataProvider(&socket_data);
   socket_data.StopAfter(1);
 
   HttpRequestInfo request_info;
   std::vector<QuicHttpStream*> streams;
@@ skipping 504 matching lines @@
   ASSERT_EQ(0u, runner_->GetPostedTasks().size());
 
   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
   EXPECT_TRUE(stream.get());
   EXPECT_TRUE(socket_data.at_read_eof());
   EXPECT_TRUE(socket_data.at_write_eof());
 }
 
 }  // namespace test
 }  // namespace net