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_ack_notifier.h"
 #include "net/quic/quic_connection.h"
 #include "net/quic/quic_spdy_compressor.h"
 #include "net/quic/quic_spdy_decompressor.h"
@@ skipping 15 matching lines @@
 using testing::StrEq;
 using testing::StrictMock;
 
 namespace net {
 namespace test {
 namespace {
 
 const char kData1[] = "FooAndBar";
 const char kData2[] = "EepAndBaz";
 const size_t kDataLen = 9;
-const QuicGuid kStreamId = 3;
+const QuicConnectionId kStreamId = 3;
 const bool kIsServer = true;
 const bool kShouldProcessData = true;
 
 class TestStream : public ReliableQuicStream {
  public:
   TestStream(QuicStreamId id,
              QuicSession* session,
              bool should_process_data)
       : ReliableQuicStream(id, session),
         should_process_data_(should_process_data) {}
@@ skipping 78 matching lines @@
   scoped_ptr<QuicSpdyDecompressor> decompressor_;
   SpdyHeaderBlock headers_;
   QuicWriteBlockedList* write_blocked_list_;
 };
 
 TEST_F(ReliableQuicStreamTest, WriteAllData) {
   Initialize(kShouldProcessData);
 
   connection_->options()->max_packet_length =
       1 + QuicPacketCreator::StreamFramePacketOverhead(
-          connection_->version(), PACKET_8BYTE_GUID, !kIncludeVersion,
+          connection_->version(), PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion,
           PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP);
   EXPECT_CALL(*session_, WritevData(kStreamId, _, _, _, _)).WillOnce(
       Return(QuicConsumedData(kDataLen, true)));
   stream_->WriteOrBufferData(kData1, false);
   EXPECT_FALSE(write_blocked_list_->HasWriteBlockedStreams());
 }
 
 TEST_F(ReliableQuicStreamTest, NoBlockingIfNoDataOrFin) {
   Initialize(kShouldProcessData);
 
@@ skipping 38 matching lines @@
   stream_->WriteOrBufferData(StringPiece(), true);
   ASSERT_EQ(1u, write_blocked_list_->NumBlockedStreams());
 }
 
 TEST_F(ReliableQuicStreamTest, WriteOrBufferData) {
   Initialize(kShouldProcessData);
 
   EXPECT_FALSE(write_blocked_list_->HasWriteBlockedStreams());
   connection_->options()->max_packet_length =
       1 + QuicPacketCreator::StreamFramePacketOverhead(
-          connection_->version(), PACKET_8BYTE_GUID, !kIncludeVersion,
+          connection_->version(), PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion,
           PACKET_6BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP);
   EXPECT_CALL(*session_, WritevData(_, _, _, _, _)).WillOnce(
       Return(QuicConsumedData(kDataLen - 1, false)));
   stream_->WriteOrBufferData(kData1, false);
   EXPECT_TRUE(write_blocked_list_->HasWriteBlockedStreams());
 
   // Queue a bytes_consumed write.
   stream_->WriteOrBufferData(kData2, false);
 
   // Make sure we get the tail of the first write followed by the bytes_consumed
@@ skipping 87 matching lines @@
   // Now close the stream (any further resets being sent would break the
   // expectation above).
   stream_->OnClose();
   EXPECT_FALSE(fin_sent());
   EXPECT_TRUE(rst_sent());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net