QUIC: support diversified keys with version 33.

net/quic/reliable_quic_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/reliable_quic_stream.h"
 
 #include <memory>
 
 #include "net/quic/quic_connection.h"
 #include "net/quic/quic_flags.h"
@@ skipping 147 matching lines @@
   QuicWriteBlockedList* write_blocked_list_;
   uint32_t initial_flow_control_window_bytes_;
   QuicTime::Delta zero_;
   QuicVersionVector supported_versions_;
   const QuicStreamId kTestStreamId = 5u;
 };
 
 TEST_F(ReliableQuicStreamTest, WriteAllData) {
   Initialize(kShouldProcessData);
 
-  size_t length = 1 + QuicPacketCreator::StreamFramePacketOverhead(
-                          PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion,
-                          !kIncludePathId, PACKET_6BYTE_PACKET_NUMBER, 0u);
+  size_t length =
+      1 + QuicPacketCreator::StreamFramePacketOverhead(
+              PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion, !kIncludePathId,
+              !kIncludeDiversificationNonce, PACKET_6BYTE_PACKET_NUMBER, 0u);
   connection_->SetMaxPacketLength(length);
 
   EXPECT_CALL(*session_, WritevData(kTestStreamId, _, _, _, _))
       .WillOnce(Return(QuicConsumedData(kDataLen, true)));
   stream_->WriteOrBufferData(kData1, false, nullptr);
   EXPECT_FALSE(HasWriteBlockedStreams());
 }
 
 TEST_F(ReliableQuicStreamTest, NoBlockingIfNoDataOrFin) {
   Initialize(kShouldProcessData);
@@ skipping 49 matching lines @@
   EXPECT_CALL(*session_, WritevData(kTestStreamId, _, _, _, _))
       .WillOnce(Invoke(this, &ReliableQuicStreamTest::CloseStreamOnWriteError));
   stream_->WriteOrBufferData(StringPiece(kData1, 2), false, nullptr);
   ASSERT_EQ(0u, write_blocked_list_->NumBlockedStreams());
 }
 
 TEST_F(ReliableQuicStreamTest, WriteOrBufferData) {
   Initialize(kShouldProcessData);
 
   EXPECT_FALSE(HasWriteBlockedStreams());
-  size_t length = 1 + QuicPacketCreator::StreamFramePacketOverhead(
-                          PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion,
-                          !kIncludePathId, PACKET_6BYTE_PACKET_NUMBER, 0u);
+  size_t length =
+      1 + QuicPacketCreator::StreamFramePacketOverhead(
+              PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion, !kIncludePathId,
+              !kIncludeDiversificationNonce, PACKET_6BYTE_PACKET_NUMBER, 0u);
   connection_->SetMaxPacketLength(length);
 
   EXPECT_CALL(*session_, WritevData(_, _, _, _, _))
       .WillOnce(Return(QuicConsumedData(kDataLen - 1, false)));
   stream_->WriteOrBufferData(kData1, false, nullptr);
   EXPECT_TRUE(HasWriteBlockedStreams());
 
   // Queue a bytes_consumed write.
   stream_->WriteOrBufferData(kData2, false, nullptr);
 
@@ skipping 407 matching lines @@
   // Receive remaining data and FIN for the request.
   QuicStreamFrame frame2(stream_->id(), true, 0, StringPiece("End"));
   stream_->OnStreamFrame(frame2);
   EXPECT_TRUE(stream_->fin_received());
   EXPECT_TRUE(stream_->HasFinalReceivedByteOffset());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net