Add QuicTransportChannel methods for QUIC streams

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.
  */
 
 #include "webrtc/p2p/quic/quictransportchannel.h"
 
 #include <set>
 #include <string>
 #include <vector>
 
 #include "webrtc/base/common.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/sslidentity.h"
 #include "webrtc/p2p/base/faketransportcontroller.h"
 
 using cricket::ConnectionRole;
 using cricket::IceRole;
 using cricket::QuicTransportChannel;
+using cricket::ReliableQuicStream;
 using cricket::TransportChannel;
 using cricket::TransportDescription;
 
 // Timeout in milliseconds for asynchronous operations in unit tests.
 static const int kTimeoutMs = 1000;
 
 // Export keying material parameters.
 static const char kExporterLabel[] = "label";
 static const uint8_t kExporterContext[] = "context";
 static const size_t kExporterContextLength = sizeof(kExporterContext);
@@ skipping 54 matching lines @@
 // 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_.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);
     local_fingerprint_.reset(CreateFingerprint(local_cert.get()));
   }
 
   // Connects |ice_channel_| to that of the other peer.
   void Connect(QuicTestPeer* other_peer) {
@@ skipping 81 matching lines @@
   size_t bytes_sent() const { return bytes_sent_; }
 
   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_; }
+
+  bool signal_closed_emitted() const { return signal_closed_emitted_; }
+
  private:
-  // QUIC channel callback.
+  // 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;
+  }
+  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;
+  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_|
   // has server role in the QUIC handshake.
@@ skipping 249 matching lines @@
 
 // Test that if the ICE channel becomes receiving before the QUIC channel is
 // connected, then the QUIC channel becomes receiving.
 TEST_F(QuicTransportChannelTest, IceReceivingBeforeConnected) {
   Connect();
   peer1_.ice_channel()->SetReceiving(true);
   ASSERT_TRUE(peer1_.ice_channel()->receiving());
   ASSERT_TRUE_WAIT(quic_connected(), kTimeoutMs);
   EXPECT_TRUE(peer1_.quic_channel()->receiving());
 }
+
+// Test that when peer 1 creates an outgoing stream, peer 2 creates an incoming
+// QUIC stream with the same ID and fires OnIncomingStream.
+TEST_F(QuicTransportChannelTest, CreateOutgoingAndIncomingQuicStream) {
+  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 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);
+}