Landing Recent QUIC changes until 12:43 PM, Nov 5, 2016 UTC+8

net/quic/core/quic_spdy_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/core/quic_spdy_stream.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "net/quic/core/quic_connection.h"
 #include "net/quic/core/quic_utils.h"
 #include "net/quic/core/quic_write_blocked_list.h"
 #include "net/quic/core/spdy_utils.h"
 #include "net/quic/test_tools/quic_flow_controller_peer.h"
 #include "net/quic/test_tools/quic_session_peer.h"
+#include "net/quic/test_tools/quic_stream_peer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
-#include "net/quic/test_tools/reliable_quic_stream_peer.h"
 #include "net/test/gtest_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using base::StringPiece;
 using std::min;
 using std::string;
 using testing::AnyNumber;
 using testing::Invoke;
 using testing::Return;
 using testing::StrictMock;
@@ skipping 18 matching lines @@
       return;
     }
     char buffer[2048];
     struct iovec vec;
     vec.iov_base = buffer;
     vec.iov_len = arraysize(buffer);
     size_t bytes_read = Readv(&vec, 1);
     data_ += string(buffer, bytes_read);
   }
 
-  using ReliableQuicStream::WriteOrBufferData;
-  using ReliableQuicStream::CloseWriteSide;
+  using QuicStream::WriteOrBufferData;
+  using QuicStream::CloseWriteSide;
 
   const string& data() const { return data_; }
 
  private:
   bool should_process_data_;
   string data_;
 };
 
 class QuicSpdyStreamTest : public ::testing::TestWithParam<QuicVersion> {
  public:
@@ skipping 325 matching lines @@
   EXPECT_CALL(*connection_, SendBlocked(kClientDataStreamId1));
   EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _))
       .WillOnce(Return(QuicConsumedData(kWindow, true)));
   stream_->WriteOrBufferData(body, false, nullptr);
 
   // Should have sent as much as possible, resulting in no send window left.
   EXPECT_EQ(0u,
             QuicFlowControllerPeer::SendWindowSize(stream_->flow_controller()));
 
   // And we should have queued the overflowed data.
-  EXPECT_EQ(kOverflow, ReliableQuicStreamPeer::SizeOfQueuedData(stream_));
+  EXPECT_EQ(kOverflow, QuicStreamPeer::SizeOfQueuedData(stream_));
 }
 
 TEST_P(QuicSpdyStreamTest, StreamFlowControlNoWindowUpdateIfNotConsumed) {
   // The flow control receive window decreases whenever we add new bytes to the
   // sequencer, whether they are consumed immediately or buffered. However we
   // only send WINDOW_UPDATE frames based on increasing number of bytes
   // consumed.
 
   // Don't process data - it will be buffered instead.
   Initialize(!kShouldProcessData);
@@ skipping 515 matching lines @@
 
   // Writing Trailers should fail, as the FIN has already been sent.
   // populated with the number of body bytes written.
   EXPECT_QUIC_BUG(stream_->WriteTrailers(SpdyHeaderBlock(), nullptr),
                   "Trailers cannot be sent after a FIN");
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net