Land Recent QUIC changes.

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 "net/quic/quic_connection.h"
 #include "net/quic/quic_spdy_compressor.h"
 #include "net/quic/quic_spdy_decompressor.h"
 #include "net/quic/quic_utils.h"
@@ skipping 76 matching lines @@
   scoped_ptr<TestStream> stream2_;
   scoped_ptr<QuicSpdyCompressor> compressor_;
   scoped_ptr<QuicSpdyDecompressor> decompressor_;
   SpdyHeaderBlock headers_;
 };
 
 TEST_F(ReliableQuicStreamTest, WriteAllData) {
   Initialize(kShouldProcessData);
 
   connection_->options()->max_packet_length =
-      1 + QuicPacketCreator::StreamFramePacketOverhead(1, !kIncludeVersion);
+      1 + QuicPacketCreator::StreamFramePacketOverhead(
+          1, PACKET_8BYTE_GUID, !kIncludeVersion, NOT_IN_FEC_GROUP);
   // TODO(rch): figure out how to get StrEq working here.
   //EXPECT_CALL(*session_, WriteData(kStreamId, StrEq(kData1), _, _)).WillOnce(
   EXPECT_CALL(*session_, WriteData(kStreamId, _, _, _)).WillOnce(
       Return(QuicConsumedData(kDataLen, true)));
   EXPECT_EQ(kDataLen, stream_->WriteData(kData1, false).bytes_consumed);
 }
 
 TEST_F(ReliableQuicStreamTest, WriteData) {
   Initialize(kShouldProcessData);
 
   connection_->options()->max_packet_length =
-      1 + QuicPacketCreator::StreamFramePacketOverhead(1, !kIncludeVersion);
+      1 + QuicPacketCreator::StreamFramePacketOverhead(
+          1, PACKET_8BYTE_GUID, !kIncludeVersion, NOT_IN_FEC_GROUP);
   // TODO(rch): figure out how to get StrEq working here.
   //EXPECT_CALL(*session_, WriteData(_, StrEq(kData1), _, _)).WillOnce(
   EXPECT_CALL(*session_, WriteData(_, _, _, _)).WillOnce(
       Return(QuicConsumedData(kDataLen - 1, false)));
   // The return will be kDataLen, because the last byte gets buffered.
   EXPECT_EQ(kDataLen, stream_->WriteData(kData1, false).bytes_consumed);
 
   // Queue a bytes_consumed write.
   EXPECT_EQ(kDataLen, stream_->WriteData(kData2, false).bytes_consumed);
 
@@ skipping 182 matching lines @@
   stream2_->OnStreamFrame(frame2);
   EXPECT_EQ("", stream_->data());
 
   stream_->OnStreamFrame(frame1);
   EXPECT_EQ(decompressed_headers1, stream_->data());
 
   EXPECT_EQ(2u, session_->decompressor()->current_header_id());
   stream2_->OnDecompressorAvailable();
   EXPECT_EQ(decompressed_headers2, stream2_->data());
 }
+
 TEST_F(ReliableQuicStreamTest, ProcessHeadersDelay) {
   Initialize(!kShouldProcessData);
 
   string compressed_headers = compressor_->CompressHeaders(headers_);
   QuicStreamFrame frame1(stream_->id(), false, 0, compressed_headers);
   string decompressed_headers =
       SpdyUtils::SerializeUncompressedHeaders(headers_);
 
   // Send the headers to the stream and verify they were decompressed.
   stream_->OnStreamFrame(frame1);
   EXPECT_EQ(2u, session_->decompressor()->current_header_id());
 
   // Verify that we are now able to handle the body data,
   // even though the stream has not processed the headers.
   EXPECT_CALL(*connection_, SendConnectionClose(QUIC_INVALID_HEADER_ID))
       .Times(0);
   QuicStreamFrame frame2(stream_->id(), false, compressed_headers.length(),
                          "body data");
   stream_->OnStreamFrame(frame2);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net