QUIC - enabled FLAGS_allow_truncated_connection_ids_for_quic

net/quic/quic_http_stream_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_http_stream.h"
 
 #include <vector>
 
 #include "net/base/chunked_upload_data_stream.h"
 #include "net/base/elements_upload_data_stream.h"
@@ skipping 247 matching lines @@
     response_headers_ = maker_.GetResponseHeaders(status);
     response_data_ = body;
   }
 
   scoped_ptr<QuicEncryptedPacket> ConstructDataPacket(
       QuicPacketSequenceNumber sequence_number,
       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,
       bool fin) {
     return maker_.MakeRequestHeadersPacket(
-        sequence_number, stream_id_, kIncludeVersion, fin, request_headers_);
+        sequence_number, stream_id_, PACKET_8BYTE_CONNECTION_ID,
+        kIncludeVersion, fin, request_headers_);
   }
 
   scoped_ptr<QuicEncryptedPacket> ConstructResponseHeadersPacket(
       QuicPacketSequenceNumber sequence_number,
       bool fin) {
     return maker_.MakeResponseHeadersPacket(
-        sequence_number, stream_id_, !kIncludeVersion, fin, response_headers_);
+        sequence_number, stream_id_, PACKET_0BYTE_CONNECTION_ID,
+        !kIncludeVersion, fin, response_headers_);
   }
 
   scoped_ptr<QuicEncryptedPacket> ConstructRstStreamPacket(
       QuicPacketSequenceNumber sequence_number) {
     return maker_.MakeRstPacket(
-        sequence_number, true, stream_id_,
+        sequence_number, PACKET_8BYTE_CONNECTION_ID, true, stream_id_,
         AdjustErrorForVersion(QUIC_RST_ACKNOWLEDGEMENT, GetParam()));
   }
 
   scoped_ptr<QuicEncryptedPacket> ConstructAckAndRstStreamPacket(
       QuicPacketSequenceNumber sequence_number) {
-    return maker_.MakeAckAndRstPacket(
-        sequence_number, !kIncludeVersion, stream_id_, QUIC_STREAM_CANCELLED,
-        2, 1, !kIncludeCongestionFeedback);
+    return maker_.MakeAckAndRstPacket(sequence_number, !kIncludeVersion,
+                                      stream_id_, QUIC_STREAM_CANCELLED, 2, 1,
+                                      !kIncludeCongestionFeedback);
   }
 
   scoped_ptr<QuicEncryptedPacket> ConstructAckPacket(
       QuicPacketSequenceNumber sequence_number,
       QuicPacketSequenceNumber largest_received,
       QuicPacketSequenceNumber least_unacked) {
-    return maker_.MakeAckPacket(sequence_number, largest_received,
-                                least_unacked, !kIncludeCongestionFeedback);
+    return maker_.MakeAckPacket(sequence_number, PACKET_8BYTE_CONNECTION_ID,
+                                largest_received, least_unacked,
+                                !kIncludeCongestionFeedback);
   }
 
   BoundNetLog net_log_;
   bool use_closing_stream_;
   MockSendAlgorithm* send_algorithm_;
   TestReceiveAlgorithm* receive_algorithm_;
   scoped_refptr<TestTaskRunner> runner_;
   scoped_ptr<MockWrite[]> mock_writes_;
   MockClock clock_;
   TestQuicConnection* connection_;
@@ skipping 458 matching lines @@
   // Set Delegate to nullptr and make sure EffectivePriority returns highest
   // priority.
   reliable_stream->SetDelegate(nullptr);
   DCHECK_EQ(QuicWriteBlockedList::kHighestPriority,
             reliable_stream->EffectivePriority());
   reliable_stream->SetDelegate(delegate);
 }
 
 }  // namespace test
 }  // namespace net