Fix QuicSession to unbuffer data when the QuicTransportChannel reconnects

webrtc/p2p/quic/quictransportchannel_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 77 matching lines @@
 
 // Peer who establishes a handshake using a QuicTransportChannel, which wraps
 // a FailableTransportChannel to simulate network connectivity and ICE
 // negotiation.
 class QuicTestPeer : public sigslot::has_slots<> {
  public:
   explicit QuicTestPeer(const std::string& name)
       : name_(name),
         bytes_sent_(0),
         ice_channel_(name_, 0),
-        quic_channel_(&ice_channel_) {
+        quic_channel_(&ice_channel_),
+        num_incoming_quic_streams_(0) {
     quic_channel_.SignalReadPacket.connect(
         this, &QuicTestPeer::OnTransportChannelReadPacket);
     quic_channel_.SignalIncomingStream.connect(this,
                                                &QuicTestPeer::OnIncomingStream);
     quic_channel_.SignalClosed.connect(this, &QuicTestPeer::OnClosed);
     ice_channel_.SetAsync(true);
     rtc::scoped_refptr<rtc::RTCCertificate> local_cert =
         rtc::RTCCertificate::Create(rtc::scoped_ptr<rtc::SSLIdentity>(
             rtc::SSLIdentity::Generate(name_, rtc::KT_DEFAULT)));
     quic_channel_.SetLocalCertificate(local_cert);
@@ skipping 88 matching lines @@
   FailableTransportChannel* ice_channel() { return &ice_channel_; }
 
   QuicTransportChannel* quic_channel() { return &quic_channel_; }
 
   rtc::scoped_ptr<rtc::SSLFingerprint>& local_fingerprint() {
     return local_fingerprint_;
   }
 
   ReliableQuicStream* incoming_quic_stream() { return incoming_quic_stream_; }
 
+  size_t num_incoming_quic_streams() const {
+    return num_incoming_quic_streams_;

[pthatcher1, 2016/04/29 20:15:46]

I'd prefer incoming_stream_count() and incoming_stream_count_.

[mikescarlett, 2016/04/29 23:29:50]

Done.

+  }
+
   bool signal_closed_emitted() const { return signal_closed_emitted_; }
 
  private:
   // QuicTransportChannel callbacks.
   void OnTransportChannelReadPacket(TransportChannel* channel,
                                     const char* data,
                                     size_t size,
                                     const rtc::PacketTime& packet_time,
                                     int flags) {
     bytes_received_ += size;
     // Only SRTP packets should have the bypass flag set.
     int expected_flags = IsRtpLeadByte(data[0]) ? cricket::PF_SRTP_BYPASS : 0;
     ASSERT_EQ(expected_flags, flags);
   }
   void OnIncomingStream(ReliableQuicStream* stream) {
     incoming_quic_stream_ = stream;
+    ++num_incoming_quic_streams_;
   }
   void OnClosed() { signal_closed_emitted_ = true; }
 
   std::string name_;                      // Channel name.
   size_t bytes_sent_;                     // Bytes sent by QUIC channel.
   size_t bytes_received_;                 // Bytes received by QUIC channel.
   FailableTransportChannel ice_channel_;  // Simulates an ICE channel.
   QuicTransportChannel quic_channel_;     // QUIC channel to test.
   rtc::scoped_ptr<rtc::SSLFingerprint> local_fingerprint_;
   ReliableQuicStream* incoming_quic_stream_ = nullptr;
+  size_t num_incoming_quic_streams_;
   bool signal_closed_emitted_ = false;
 };
 
 class QuicTransportChannelTest : public testing::Test {
  public:
   QuicTransportChannelTest() : peer1_("P1"), peer2_("P2") {}
 
   // Performs negotiation before QUIC handshake, then connects the fake
   // transport channels of each peer. As a side effect, the QUIC channels
   // start sending handshake messages. |peer1_| has a client role and |peer2_|
@@ skipping 264 matching lines @@
   Connect();
   EXPECT_EQ(nullptr, peer1_.quic_channel()->CreateQuicStream());
   ASSERT_TRUE_WAIT(quic_connected(), kTimeoutMs);
   ReliableQuicStream* stream = peer1_.quic_channel()->CreateQuicStream();
   ASSERT_NE(nullptr, stream);
   stream->Write("Hi", 2);
   EXPECT_TRUE_WAIT(peer2_.incoming_quic_stream() != nullptr, kTimeoutMs);
   EXPECT_EQ(stream->id(), peer2_.incoming_quic_stream()->id());
 }
 
+// Test that if the QuicTransportChannel is unwritable, then all outgoing QUIC
+// streams can send data once the QuicTransprotChannel becomes writable again.
+TEST_F(QuicTransportChannelTest, OutgoingQuicStreamSendsDataAfterReconnect) {
+  Connect();
+  ASSERT_TRUE_WAIT(quic_connected(), kTimeoutMs);
+  ReliableQuicStream* stream1 = peer1_.quic_channel()->CreateQuicStream();
+  ASSERT_NE(nullptr, stream1);
+  ReliableQuicStream* stream2 = peer1_.quic_channel()->CreateQuicStream();
+  ASSERT_NE(nullptr, stream2);
+  ReliableQuicStream* stream3 = peer1_.quic_channel()->CreateQuicStream();
+  ASSERT_NE(nullptr, stream3);
+  ReliableQuicStream* stream4 = peer1_.quic_channel()->CreateQuicStream();
+  ASSERT_NE(nullptr, stream4);

[pthatcher1, 2016/04/29 20:15:47]

Why do we need 4 streams for this?  Isn't 1 or 2 enough?

[mikescarlett, 2016/04/29 23:29:50]

2 is fine. I agree 4 is redundant but wanted to test that >1 stream can be
queued.

+
+  peer1_.ice_channel()->SetWritable(false);
+  stream1->Write("First", 5);
+  EXPECT_EQ(5u, stream1->queued_data_bytes());
+  stream2->Write("Second", 6);
+  EXPECT_EQ(6u, stream2->queued_data_bytes());
+  stream3->Write("Third", 5);
+  EXPECT_EQ(5u, stream3->queued_data_bytes());
+  stream4->Write("Fourth", 6);
+  EXPECT_EQ(6u, stream4->queued_data_bytes());
+  EXPECT_EQ(0u, peer2_.num_incoming_quic_streams());
+
+  peer1_.ice_channel()->SetWritable(true);
+  EXPECT_EQ_WAIT(0u, stream1->queued_data_bytes(), kTimeoutMs);
+  EXPECT_EQ_WAIT(0u, stream2->queued_data_bytes(), kTimeoutMs);
+  EXPECT_EQ_WAIT(0u, stream3->queued_data_bytes(), kTimeoutMs);
+  EXPECT_EQ_WAIT(0u, stream4->queued_data_bytes(), kTimeoutMs);
+  EXPECT_EQ_WAIT(4u, peer2_.num_incoming_quic_streams(), kTimeoutMs);
+}
+
 // Test that SignalClosed is emitted when the QuicConnection closes.
 TEST_F(QuicTransportChannelTest, SignalClosedEmitted) {
   Connect();
   ASSERT_TRUE_WAIT(quic_connected(), kTimeoutMs);
   ASSERT_FALSE(peer1_.signal_closed_emitted());
   ReliableQuicStream* stream = peer1_.quic_channel()->CreateQuicStream();
   ASSERT_NE(nullptr, stream);
   stream->CloseConnectionWithDetails(net::QuicErrorCode::QUIC_NO_ERROR,
                                      "Closing QUIC for testing");
   EXPECT_TRUE(peer1_.signal_closed_emitted());
   EXPECT_TRUE_WAIT(peer2_.signal_closed_emitted(), kTimeoutMs);
 }