Land Recent QUIC Changes.

net/quic/quic_data_stream_test.cc

 // Copyright 2013 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_data_stream.h"
 
 #include "net/quic/quic_ack_notifier.h"
 #include "net/quic/quic_connection.h"
 #include "net/quic/quic_flags.h"
 #include "net/quic/quic_utils.h"
@@ skipping 12 matching lines @@
 using testing::AnyNumber;
 using testing::InSequence;
 using testing::Return;
 using testing::SaveArg;
 using testing::StrictMock;
 
 namespace net {
 namespace test {
 namespace {
 
-const QuicConnectionId kStreamId = 3;
+// First non-reserved client stream ID.
+const QuicStreamId kStreamId = 5;
+
 const bool kIsServer = true;
 const bool kShouldProcessData = true;
 
 class TestStream : public QuicDataStream {
  public:
   TestStream(QuicStreamId id,
              QuicSession* session,
              bool should_process_data)
       : QuicDataStream(id, session),
         should_process_data_(should_process_data) {}
@@ skipping 384 matching lines @@
   // Set a small flow control limit for streams and connection.
   const uint64 kWindow = 36;
   QuicFlowControllerPeer::SetReceiveWindowOffset(stream_->flow_controller(),
                                                  kWindow);
   QuicFlowControllerPeer::SetMaxReceiveWindow(stream_->flow_controller(),
                                               kWindow);
   QuicFlowControllerPeer::SetReceiveWindowOffset(stream2_->flow_controller(),
                                                  kWindow);
   QuicFlowControllerPeer::SetMaxReceiveWindow(stream2_->flow_controller(),
                                               kWindow);
-  QuicFlowControllerPeer::SetReceiveWindowOffset(connection_->flow_controller(),
+  QuicFlowControllerPeer::SetReceiveWindowOffset(session_->flow_controller(),
                                                  kWindow);
-  QuicFlowControllerPeer::SetMaxReceiveWindow(connection_->flow_controller(),
+  QuicFlowControllerPeer::SetMaxReceiveWindow(session_->flow_controller(),
                                               kWindow);
 
   // Supply headers to both streams so that they are happy to receive data.
   string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
   stream_->OnStreamHeaders(headers);
   stream_->OnStreamHeadersComplete(false, headers.size());
   stream2_->OnStreamHeaders(headers);
   stream2_->OnStreamHeadersComplete(false, headers.size());
 
   // Each stream gets a quarter window of data. This should not trigger a
   // WINDOW_UPDATE for either stream, nor for the connection.
   string body;
   GenerateBody(&body, kWindow / 4);
   QuicStreamFrame frame1(kStreamId, false, 0, MakeIOVector(body));
   stream_->OnStreamFrame(frame1);
   QuicStreamFrame frame2(kStreamId + 2, false, 0, MakeIOVector(body));
   stream2_->OnStreamFrame(frame2);
 
   // Now receive a further single byte on one stream - again this does not
   // trigger a stream WINDOW_UPDATE, but now the connection flow control window
   // is over half full and thus a connection WINDOW_UPDATE is sent.
   EXPECT_CALL(*connection_, SendWindowUpdate(kStreamId, _)).Times(0);
   EXPECT_CALL(*connection_, SendWindowUpdate(kStreamId + 2, _)).Times(0);
   EXPECT_CALL(*connection_,
               SendWindowUpdate(0, QuicFlowControllerPeer::ReceiveWindowOffset(
-                                      connection_->flow_controller()) +
+                                      session_->flow_controller()) +
                                       1 + kWindow / 2));
   QuicStreamFrame frame3(kStreamId, false, (kWindow / 4), MakeIOVector("a"));
   stream_->OnStreamFrame(frame3);
 }
 
 TEST_P(QuicDataStreamTest, StreamFlowControlViolation) {
   // Tests that on if the peer sends too much data (i.e. violates the flow
   // control protocol), then we terminate the connection.
   if (GetParam() < QUIC_VERSION_17) {
     return;
@@ skipping 34 matching lines @@
 
   // Stream should not process data, so that data gets buffered in the
   // sequencer, triggering flow control limits.
   Initialize(!kShouldProcessData);
 
   // Set a small flow control window on streams, and connection.
   const uint64 kStreamWindow = 50;
   const uint64 kConnectionWindow = 10;
   QuicFlowControllerPeer::SetReceiveWindowOffset(stream_->flow_controller(),
                                                  kStreamWindow);
-  QuicFlowControllerPeer::SetReceiveWindowOffset(connection_->flow_controller(),
+  QuicFlowControllerPeer::SetReceiveWindowOffset(session_->flow_controller(),
                                                  kConnectionWindow);
 
   string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
   stream_->OnStreamHeaders(headers);
   EXPECT_EQ(headers, stream_->data());
   stream_->OnStreamHeadersComplete(false, headers.size());
 
   // Send enough data to overflow the connection level flow control window.
   string body;
   GenerateBody(&body, kConnectionWindow + 1);
@@ skipping 26 matching lines @@
   EXPECT_CALL(*connection_, SendBlocked(kStreamId)).Times(0);
   EXPECT_CALL(*session_, WritevData(kStreamId, _, _, _, _)).WillOnce(
       Return(QuicConsumedData(0, fin)));
 
   stream_->WriteOrBufferData(body, fin, NULL);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net