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

net/quic/quartc/quartc_stream_test.cc

 // Copyright (c) 2016 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/quartc/quartc_stream.h"
 
 #include "base/threading/thread_task_runner_handle.h"
 #include "net/quic/core/crypto/quic_random.h"
 #include "net/quic/core/quic_session.h"
 #include "net/quic/core/quic_simple_buffer_allocator.h"
 #include "net/quic/quartc/quartc_alarm_factory.h"
 #include "net/quic/quartc/quartc_stream_interface.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 namespace test {
 namespace {
 
 static const SpdyPriority kDefaultPriority = 3;
 static const QuicStreamId kStreamId = 5;
 static const QuartcStreamInterface::WriteParameters kDefaultParam;
 
 // MockQuicSession that does not create streams and writes data from
-// ReliableQuicStream to a string.
+// QuicStream to a string.
 class MockQuicSession : public QuicSession {
  public:
   MockQuicSession(QuicConnection* connection,
                   const QuicConfig& config,
                   std::string* write_buffer)
       : QuicSession(connection, nullptr /*visitor*/, config),
         write_buffer_(write_buffer) {}
 
-  // Writes outgoing data from ReliableQuicStream to a string.
+  // Writes outgoing data from QuicStream to a string.
   QuicConsumedData WritevData(
-      ReliableQuicStream* stream,
+      QuicStream* stream,
       QuicStreamId id,
       QuicIOVector iovector,
       QuicStreamOffset offset,
       bool fin,
       QuicAckListenerInterface* ack_notifier_delegate) override {
     if (!writable_) {
       return QuicConsumedData(0, false);
     }
 
     const char* data = reinterpret_cast<const char*>(iovector.iov->iov_base);
     size_t len = iovector.total_length;
     write_buffer_->append(data, len);
     return QuicConsumedData(len, fin);
   }
 
   QuartcStream* CreateIncomingDynamicStream(QuicStreamId id) override {
     return nullptr;
   }
 
   QuartcStream* CreateOutgoingDynamicStream(SpdyPriority priority) override {
     return nullptr;
   }
 
   QuicCryptoStream* GetCryptoStream() override { return nullptr; }
 
-  // Called by ReliableQuicStream when they want to close stream.
+  // Called by QuicStream when they want to close stream.
   void SendRstStream(QuicStreamId id,
                      QuicRstStreamErrorCode error,
                      QuicStreamOffset bytes_written) override {}
 
   // Sets whether data is written to buffer, or else if this is write blocked.
   void set_writable(bool writable) { writable_ = writable; }
 
   // Tracks whether the stream is write blocked and its priority.
   void RegisterReliableStream(QuicStreamId stream_id, SpdyPriority priority) {
     write_blocked_streams()->RegisterStream(stream_id, priority);
   }
 
   // The session take ownership of the stream.
-  void ActivateReliableStream(std::unique_ptr<ReliableQuicStream> stream) {
+  void ActivateReliableStream(std::unique_ptr<QuicStream> stream) {
     ActivateStream(std::move(stream));
   }
 
  private:
   // Stores written data from ReliableQuicStreamAdapter.
   std::string* write_buffer_;
   // Whether data is written to write_buffer_.
   bool writable_ = true;
 };
 
@@ skipping 43 matching lines @@
   void OnClose(QuartcStreamInterface* stream, int error_code) override {
     closed_ = true;
   }
 
   bool closed() { return closed_; }
 
   int queued_bytes_amount() { return queued_bytes_amount_; }
 
  protected:
   uint32_t id_;
-  // Data read by the ReliableQuicStream.
+  // Data read by the QuicStream.
   std::string& read_buffer_;
-  // Whether the ReliableQuicStream is closed.
+  // Whether the QuicStream is closed.
   bool closed_ = false;
   int queued_bytes_amount_ = -1;
 };
 
 class QuartcStreamTest : public ::testing::Test,
                          public QuicConnectionHelperInterface {
  public:
   void CreateReliableQuicStream() {
     // Arbitrary values for QuicConnection.
     Perspective perspective = Perspective::IS_SERVER;
@@ skipping 101 matching lines @@
 TEST_F(QuartcStreamTest, CloseStream) {
   CreateReliableQuicStream();
   EXPECT_FALSE(mock_stream_delegate_->closed());
   stream_->OnClose();
   EXPECT_TRUE(mock_stream_delegate_->closed());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net