Add QuicTransportChannel methods for QUIC streams

webrtc/p2p/quic/reliablequicstream_unittest.cc

 /*
  *  Copyright 2016 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 145 matching lines @@
     QuicConnection* connection = new QuicConnection(
         0, IPEndPoint(ip, 0), quic_helper, new DummyPacketWriter(), owns_writer,
         perspective, net::QuicSupportedVersions());
 
     session_.reset(
         new MockQuicSession(connection, QuicConfig(), &write_buffer_));
     stream_.reset(new ReliableQuicStream(kStreamId, session_.get()));
     stream_->SignalDataReceived.connect(
         this, &ReliableQuicStreamTest::OnDataReceived);
     stream_->SignalClosed.connect(this, &ReliableQuicStreamTest::OnClosed);
+    stream_->SignalQueuedBytesWritten.connect(
+        this, &ReliableQuicStreamTest::OnQueuedBytesWritten);
 
     session_->register_write_blocked_stream(stream_->id(), kDefaultPriority);
   }
 
   void OnDataReceived(QuicStreamId id, const char* data, size_t length) {
     ASSERT_EQ(id, stream_->id());
     read_buffer_.append(data, length);
   }
 
-  void OnClosed(QuicStreamId id, QuicErrorCode err) { closed_ = true; }
+  void OnClosed(QuicStreamId id, int err) { closed_ = true; }
+
+  void OnQueuedBytesWritten(QuicStreamId id, uint64_t queued_bytes_written) {
+    queued_bytes_written_ = queued_bytes_written;
+  }
 
  protected:
   rtc::scoped_ptr<ReliableQuicStream> stream_;
   rtc::scoped_ptr<MockQuicSession> session_;
 
   // Data written by the ReliableQuicStream.
   std::string write_buffer_;
   // Data read by the ReliableQuicStream.
   std::string read_buffer_;
   // Whether the ReliableQuicStream is closed.
   bool closed_ = false;
+  // Bytes written by OnCanWrite().
+  uint64_t queued_bytes_written_;
 };
 
 // Write an entire string.
 TEST_F(ReliableQuicStreamTest, WriteDataWhole) {
   CreateReliableQuicStream();
   EXPECT_EQ(SR_SUCCESS, stream_->Write("Foo bar", 7));
 
   EXPECT_EQ("Foo bar", write_buffer_);
 }
 
 // Write part of a string.
 TEST_F(ReliableQuicStreamTest, WriteDataPartial) {
   CreateReliableQuicStream();
   EXPECT_EQ(SR_SUCCESS, stream_->Write("Hello, World!", 8));
   EXPECT_EQ("Hello, W", write_buffer_);
 }
 
 // Test that strings are buffered correctly.
 TEST_F(ReliableQuicStreamTest, BufferData) {
   CreateReliableQuicStream();
 
   session_->set_writable(false);
   EXPECT_EQ(SR_BLOCK, stream_->Write("Foo bar", 7));
 
   EXPECT_EQ(0ul, write_buffer_.size());
   EXPECT_TRUE(stream_->HasBufferedData());
 
   session_->set_writable(true);
   stream_->OnCanWrite();
+  EXPECT_EQ(7ul, queued_bytes_written_);
 
   EXPECT_FALSE(stream_->HasBufferedData());
   EXPECT_EQ("Foo bar", write_buffer_);
 
   EXPECT_EQ(SR_SUCCESS, stream_->Write("xyzzy", 5));
   EXPECT_EQ("Foo barxyzzy", write_buffer_);
 }
 
 // Read an entire string.
 TEST_F(ReliableQuicStreamTest, ReadDataWhole) {
@@ skipping 14 matching lines @@
   EXPECT_EQ("Hello", read_buffer_);
 }
 
 // Test that closing the stream results in a callback.
 TEST_F(ReliableQuicStreamTest, CloseStream) {
   CreateReliableQuicStream();
   EXPECT_FALSE(closed_);
   stream_->OnClose();
   EXPECT_TRUE(closed_);
 }