Reland of: Separating SCTP code from BaseChannel/MediaChannel.

webrtc/api/webrtcsession_unittest.cc

 /*
  *  Copyright 2012 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 22 matching lines @@
 #include "webrtc/base/sslidentity.h"
 #include "webrtc/base/sslstreamadapter.h"
 #include "webrtc/base/stringutils.h"
 #include "webrtc/base/thread.h"
 #include "webrtc/base/virtualsocketserver.h"
 #include "webrtc/logging/rtc_event_log/rtc_event_log.h"
 #include "webrtc/media/base/fakemediaengine.h"
 #include "webrtc/media/base/fakevideorenderer.h"
 #include "webrtc/media/base/mediachannel.h"
 #include "webrtc/media/engine/fakewebrtccall.h"
+#include "webrtc/media/sctp/sctptransportinternal.h"
 #include "webrtc/p2p/base/packettransportinterface.h"
 #include "webrtc/p2p/base/stunserver.h"
 #include "webrtc/p2p/base/teststunserver.h"
 #include "webrtc/p2p/base/testturnserver.h"
 #include "webrtc/p2p/base/transportchannel.h"
 #include "webrtc/p2p/client/basicportallocator.h"
 #include "webrtc/pc/channelmanager.h"
 #include "webrtc/pc/mediasession.h"
 
 #define MAYBE_SKIP_TEST(feature)                    \
@@ skipping 49 matching lines @@
 static const char kSessionVersion[] = "1";
 
 // Media index of candidates belonging to the first media content.
 static const int kMediaContentIndex0 = 0;
 static const char kMediaContentName0[] = "audio";
 
 // Media index of candidates belonging to the second media content.
 static const int kMediaContentIndex1 = 1;
 static const char kMediaContentName1[] = "video";
 
+static const int kDefaultTimeout = 10000;  // 10 seconds.
 static const int kIceCandidatesTimeout = 10000;
 // STUN timeout with all retransmissions is a total of 9500ms.
 static const int kStunTimeout = 9500;
 
 static const char kFakeDtlsFingerprint[] =
     "BB:CD:72:F7:2F:D0:BA:43:F3:68:B1:0C:23:72:B6:4A:"
     "0F:DE:34:06:BC:E0:FE:01:BC:73:C8:6D:F4:65:D5:24";
 
 static const char kTooLongIceUfragPwd[] =
     "IceUfragIceUfragIceUfragIceUfragIceUfragIceUfragIceUfragIceUfragIceUfrag"
@@ skipping 82 matching lines @@
   bool oncandidatesready_;
   std::vector<cricket::Candidate> mline_0_candidates_;
   std::vector<cricket::Candidate> mline_1_candidates_;
   PeerConnectionInterface::IceConnectionState ice_connection_state_;
   PeerConnectionInterface::IceGatheringState ice_gathering_state_;
   std::vector<PeerConnectionInterface::IceConnectionState>
       ice_connection_state_history_;
   size_t num_candidates_removed_ = 0;
 };
 
+// Used for tests in this file to verify that WebRtcSession responds to signals
+// from the SctpTransport correctly, and calls Start with the correct
+// local/remote ports.
+class FakeSctpTransport : public cricket::SctpTransportInternal {
+ public:
+  void SetTransportChannel(cricket::TransportChannel* channel) override {}
+  bool Start(int local_port, int remote_port) override {
+    local_port_ = local_port;
+    remote_port_ = remote_port;
+    return true;
+  }
+  bool OpenStream(int sid) override { return true; }
+  bool ResetStream(int sid) override { return true; }
+  bool SendData(const cricket::SendDataParams& params,
+                const rtc::CopyOnWriteBuffer& payload,
+                cricket::SendDataResult* result = nullptr) override {
+    return true;
+  }
+  bool ReadyToSendData() override { return true; }
+  void set_debug_name_for_testing(const char* debug_name) override {}
+
+  int local_port() const { return local_port_; }
+  int remote_port() const { return remote_port_; }
+
+ private:
+  int local_port_ = -1;
+  int remote_port_ = -1;
+};
+
+class FakeSctpTransportFactory : public cricket::SctpTransportInternalFactory {
+ public:
+  std::unique_ptr<cricket::SctpTransportInternal> CreateSctpTransport(
+      cricket::TransportChannel*) override {
+    last_fake_sctp_transport_ = new FakeSctpTransport();
+    return std::unique_ptr<cricket::SctpTransportInternal>(
+        last_fake_sctp_transport_);
+  }
+
+  FakeSctpTransport* last_fake_sctp_transport() {
+    return last_fake_sctp_transport_;
+  }
+
+ private:
+  FakeSctpTransport* last_fake_sctp_transport_ = nullptr;
+};
+
 class WebRtcSessionForTest : public webrtc::WebRtcSession {
  public:
   WebRtcSessionForTest(
       webrtc::MediaControllerInterface* media_controller,
       rtc::Thread* network_thread,
       rtc::Thread* worker_thread,
       rtc::Thread* signaling_thread,
       cricket::PortAllocator* port_allocator,
       webrtc::IceObserver* ice_observer,
-      std::unique_ptr<cricket::TransportController> transport_controller)
+      std::unique_ptr<cricket::TransportController> transport_controller,
+      std::unique_ptr<FakeSctpTransportFactory> sctp_factory)
       : WebRtcSession(media_controller,
                       network_thread,
                       worker_thread,
                       signaling_thread,
                       port_allocator,
-                      std::move(transport_controller)) {
+                      std::move(transport_controller),
+                      std::move(sctp_factory)) {
     RegisterIceObserver(ice_observer);
   }
   virtual ~WebRtcSessionForTest() {}
 
   // Note that these methods are only safe to use if the signaling thread
   // is the same as the worker thread
   rtc::PacketTransportInterface* voice_rtp_transport_channel() {
     return rtp_transport_channel(voice_channel());
   }
 
   rtc::PacketTransportInterface* voice_rtcp_transport_channel() {
     return rtcp_transport_channel(voice_channel());
   }
 
   rtc::PacketTransportInterface* video_rtp_transport_channel() {
     return rtp_transport_channel(video_channel());
   }
 
   rtc::PacketTransportInterface* video_rtcp_transport_channel() {
     return rtcp_transport_channel(video_channel());
   }
 
-  rtc::PacketTransportInterface* data_rtp_transport_channel() {
-    return rtp_transport_channel(data_channel());
-  }
-
-  rtc::PacketTransportInterface* data_rtcp_transport_channel() {
-    return rtcp_transport_channel(data_channel());
-  }
-
  private:
   rtc::PacketTransportInterface* rtp_transport_channel(
       cricket::BaseChannel* ch) {
     if (!ch) {
       return nullptr;
     }
     return ch->transport_channel();
   }
 
   rtc::PacketTransportInterface* rtcp_transport_channel(
@@ skipping 109 matching lines @@
   }
 
   // If |cert_generator| != null or |rtc_configuration| contains |certificates|
   // then DTLS will be enabled unless explicitly disabled by |rtc_configuration|
   // options. When DTLS is enabled a certificate will be used if provided,
   // otherwise one will be generated using the |cert_generator|.
   void Init(
       std::unique_ptr<rtc::RTCCertificateGeneratorInterface> cert_generator,
       PeerConnectionInterface::RtcpMuxPolicy rtcp_mux_policy) {
     ASSERT_TRUE(session_.get() == NULL);
+    fake_sctp_transport_factory_ = new FakeSctpTransportFactory();
     session_.reset(new WebRtcSessionForTest(
         media_controller_.get(), rtc::Thread::Current(), rtc::Thread::Current(),
         rtc::Thread::Current(), allocator_.get(), &observer_,
         std::unique_ptr<cricket::TransportController>(
             new cricket::TransportController(rtc::Thread::Current(),
                                              rtc::Thread::Current(),
-                                             allocator_.get()))));
+                                             allocator_.get())),
+        std::unique_ptr<FakeSctpTransportFactory>(
+            fake_sctp_transport_factory_)));
     session_->SignalDataChannelOpenMessage.connect(
         this, &WebRtcSessionTest::OnDataChannelOpenMessage);
     session_->GetOnDestroyedSignal()->connect(
         this, &WebRtcSessionTest::OnSessionDestroyed);
 
     configuration_.rtcp_mux_policy = rtcp_mux_policy;
     EXPECT_EQ(PeerConnectionInterface::kIceConnectionNew,
         observer_.ice_connection_state_);
     EXPECT_EQ(PeerConnectionInterface::kIceGatheringNew,
         observer_.ice_gathering_state_);
@@ skipping 1083 matching lines @@
     turn_server.ports.push_back(
         cricket::ProtocolAddress(kTurnUdpIntAddr, cricket::PROTO_UDP));
     allocator_->AddTurnServer(turn_server);
     allocator_->set_step_delay(cricket::kMinimumStepDelay);
     allocator_->set_flags(cricket::PORTALLOCATOR_DISABLE_TCP);
   }
 
   webrtc::RtcEventLogNullImpl event_log_;
   cricket::FakeMediaEngine* media_engine_;
   cricket::FakeDataEngine* data_engine_;
+  // Actually owned by session_.
+  FakeSctpTransportFactory* fake_sctp_transport_factory_ = nullptr;
   std::unique_ptr<cricket::ChannelManager> channel_manager_;
   cricket::FakeCall fake_call_;
   std::unique_ptr<webrtc::MediaControllerInterface> media_controller_;
   std::unique_ptr<cricket::TransportDescriptionFactory> tdesc_factory_;
   std::unique_ptr<cricket::MediaSessionDescriptionFactory> desc_factory_;
   std::unique_ptr<rtc::PhysicalSocketServer> pss_;
   std::unique_ptr<rtc::VirtualSocketServer> vss_;
   std::unique_ptr<rtc::FirewallSocketServer> fss_;
   rtc::SocketServerScope ss_scope_;
   rtc::SocketAddress stun_socket_addr_;
@@ skipping 2359 matching lines @@
   allocator_->set_flags(cricket::PORTALLOCATOR_DISABLE_TCP |
                         cricket::PORTALLOCATOR_DISABLE_RELAY);
   TestLoopbackCall();
 }
 
 TEST_F(WebRtcSessionTest, TestRtpDataChannel) {
   configuration_.enable_rtp_data_channel = true;
   Init();
   SetLocalDescriptionWithDataChannel();
   ASSERT_TRUE(data_engine_);
-  EXPECT_EQ(cricket::DCT_RTP, data_engine_->last_channel_type());
+  EXPECT_NE(nullptr, data_engine_->GetChannel(0));
 }
 
 TEST_P(WebRtcSessionTest, TestRtpDataChannelConstraintTakesPrecedence) {
   MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
 
   configuration_.enable_rtp_data_channel = true;
   options_.disable_sctp_data_channels = false;
 
   InitWithDtls(GetParam());
 
   SetLocalDescriptionWithDataChannel();
-  EXPECT_EQ(cricket::DCT_RTP, data_engine_->last_channel_type());
+  EXPECT_NE(nullptr, data_engine_->GetChannel(0));
+}
+
+// Test that sctp_content_name/sctp_transport_name (used for stats) are correct
+// before and after BUNDLE is negotiated.
+TEST_P(WebRtcSessionTest, SctpContentAndTransportName) {
+  MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
+  SetFactoryDtlsSrtp();
+  InitWithDtls(GetParam());
+
+  // Initially these fields should be empty.
+  EXPECT_FALSE(session_->sctp_content_name());
+  EXPECT_FALSE(session_->sctp_transport_name());
+
+  // Create offer with audio/video/data.
+  // Default bundle policy is "balanced", so data should be using its own
+  // transport.
+  SendAudioVideoStream1();
+  CreateDataChannel();
+  InitiateCall();
+  ASSERT_TRUE(session_->sctp_content_name());
+  ASSERT_TRUE(session_->sctp_transport_name());
+  EXPECT_EQ("data", *session_->sctp_content_name());
+  EXPECT_EQ("data", *session_->sctp_transport_name());
+
+  // Create answer that finishes BUNDLE negotiation, which means everything
+  // should be bundled on the first transport (audio).
+  cricket::MediaSessionOptions answer_options;
+  answer_options.recv_video = true;
+  answer_options.bundle_enabled = true;
+  answer_options.data_channel_type = cricket::DCT_SCTP;
+  SetRemoteDescriptionWithoutError(CreateRemoteAnswer(
+      session_->local_description(), answer_options, cricket::SEC_DISABLED));
+  ASSERT_TRUE(session_->sctp_content_name());
+  ASSERT_TRUE(session_->sctp_transport_name());
+  EXPECT_EQ("data", *session_->sctp_content_name());
+  EXPECT_EQ("audio", *session_->sctp_transport_name());
 }
 
 TEST_P(WebRtcSessionTest, TestCreateOfferWithSctpEnabledWithoutStreams) {
   MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
 
   InitWithDtls(GetParam());
 
   std::unique_ptr<SessionDescriptionInterface> offer(CreateOffer());
   EXPECT_TRUE(offer->description()->GetContentByName("data") == NULL);
   EXPECT_TRUE(offer->description()->GetTransportInfoByName("data") == NULL);
@@ skipping 11 matching lines @@
       CreateRemoteOffer(options, cricket::SEC_DISABLED);
   SetRemoteDescriptionWithoutError(offer);
 
   // Verifies the answer contains SCTP.
   std::unique_ptr<SessionDescriptionInterface> answer(CreateAnswer());
   EXPECT_TRUE(answer != NULL);
   EXPECT_TRUE(answer->description()->GetContentByName("data") != NULL);
   EXPECT_TRUE(answer->description()->GetTransportInfoByName("data") != NULL);
 }
 
+// Test that if DTLS is disabled, we don't end up with an SctpTransport
+// created (or an RtpDataChannel).
 TEST_P(WebRtcSessionTest, TestSctpDataChannelWithoutDtls) {
   configuration_.enable_dtls_srtp = rtc::Optional<bool>(false);
   InitWithDtls(GetParam());
 
   SetLocalDescriptionWithDataChannel();
-  EXPECT_EQ(cricket::DCT_NONE, data_engine_->last_channel_type());
+  EXPECT_EQ(nullptr, data_engine_->GetChannel(0));
+  EXPECT_EQ(nullptr, fake_sctp_transport_factory_->last_fake_sctp_transport());
 }
 
+// Test that if DTLS is enabled, we end up with an SctpTransport created
+// (and not an RtpDataChannel).
 TEST_P(WebRtcSessionTest, TestSctpDataChannelWithDtls) {
   MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
 
   InitWithDtls(GetParam());
 
   SetLocalDescriptionWithDataChannel();
-  EXPECT_EQ(cricket::DCT_SCTP, data_engine_->last_channel_type());
+  EXPECT_EQ(nullptr, data_engine_->GetChannel(0));
+  EXPECT_NE(nullptr, fake_sctp_transport_factory_->last_fake_sctp_transport());
 }
 
+// Test that if SCTP is disabled, we don't end up with an SctpTransport
+// created (or an RtpDataChannel).
 TEST_P(WebRtcSessionTest, TestDisableSctpDataChannels) {
   MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
   options_.disable_sctp_data_channels = true;
   InitWithDtls(GetParam());
 
   SetLocalDescriptionWithDataChannel();
-  EXPECT_EQ(cricket::DCT_NONE, data_engine_->last_channel_type());
+  EXPECT_EQ(nullptr, data_engine_->GetChannel(0));
+  EXPECT_EQ(nullptr, fake_sctp_transport_factory_->last_fake_sctp_transport());
 }
 
 TEST_P(WebRtcSessionTest, TestSctpDataChannelSendPortParsing) {
   MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
   const int new_send_port = 9998;
   const int new_recv_port = 7775;
 
   InitWithDtls(GetParam());
   SetFactoryDtlsSrtp();
 
@@ skipping 10 matching lines @@
 
   SessionDescriptionInterface* answer =
       ChangeSDPSctpPort(new_recv_port, CreateAnswer());
   ASSERT_TRUE(answer != NULL);
 
   // Now set the local description, which'll take ownership of the answer.
   SetLocalDescriptionWithoutError(answer);
 
   // TEST PLAN: Set the port number to something new, set it in the SDP,
   // and pass it all the way down.
-  EXPECT_EQ(cricket::DCT_SCTP, data_engine_->last_channel_type());
+  EXPECT_EQ(nullptr, data_engine_->GetChannel(0));
   CreateDataChannel();
-
-  cricket::FakeDataMediaChannel* ch = data_engine_->GetChannel(0);
-  int portnum = -1;
-  ASSERT_TRUE(ch != NULL);
-  ASSERT_EQ(1UL, ch->send_codecs().size());
-  EXPECT_EQ(cricket::kGoogleSctpDataCodecPlType, ch->send_codecs()[0].id);
-  EXPECT_EQ(0, strcmp(cricket::kGoogleSctpDataCodecName,
-                      ch->send_codecs()[0].name.c_str()));
-  EXPECT_TRUE(ch->send_codecs()[0].GetParam(cricket::kCodecParamPort,
-                                            &portnum));
-  EXPECT_EQ(new_send_port, portnum);
-
-  ASSERT_EQ(1UL, ch->recv_codecs().size());
-  EXPECT_EQ(cricket::kGoogleSctpDataCodecPlType, ch->recv_codecs()[0].id);
-  EXPECT_EQ(0, strcmp(cricket::kGoogleSctpDataCodecName,
-                      ch->recv_codecs()[0].name.c_str()));
-  EXPECT_TRUE(ch->recv_codecs()[0].GetParam(cricket::kCodecParamPort,
-                                            &portnum));
-  EXPECT_EQ(new_recv_port, portnum);
+  ASSERT_NE(nullptr, fake_sctp_transport_factory_->last_fake_sctp_transport());
+  EXPECT_EQ(
+      new_recv_port,
+      fake_sctp_transport_factory_->last_fake_sctp_transport()->local_port());
+  EXPECT_EQ(
+      new_send_port,
+      fake_sctp_transport_factory_->last_fake_sctp_transport()->remote_port());
 }
 
-// Verifies that when a session's DataChannel receives an OPEN message,
-// WebRtcSession signals the DataChannel creation request with the expected
+// Verifies that when a session's SctpTransport receives an OPEN message,
+// WebRtcSession signals the SctpTransport creation request with the expected
 // config.
 TEST_P(WebRtcSessionTest, TestSctpDataChannelOpenMessage) {
   MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
 
   InitWithDtls(GetParam());
 
   SetLocalDescriptionWithDataChannel();
-  EXPECT_EQ(cricket::DCT_SCTP, data_engine_->last_channel_type());
+  EXPECT_EQ(nullptr, data_engine_->GetChannel(0));
+  ASSERT_NE(nullptr, fake_sctp_transport_factory_->last_fake_sctp_transport());
 
+  // Make the fake SCTP transport pretend it received an OPEN message.
   webrtc::DataChannelInit config;
   config.id = 1;
   rtc::CopyOnWriteBuffer payload;
   webrtc::WriteDataChannelOpenMessage("a", config, &payload);
   cricket::ReceiveDataParams params;
   params.ssrc = config.id;
   params.type = cricket::DMT_CONTROL;
+  fake_sctp_transport_factory_->last_fake_sctp_transport()->SignalDataReceived(
+      params, payload);
 
-  cricket::DataChannel* data_channel = session_->data_channel();
-  data_channel->SignalDataReceived(data_channel, params, payload);
-
-  EXPECT_EQ("a", last_data_channel_label_);
+  EXPECT_EQ_WAIT("a", last_data_channel_label_, kDefaultTimeout);
   EXPECT_EQ(config.id, last_data_channel_config_.id);
   EXPECT_FALSE(last_data_channel_config_.negotiated);
   EXPECT_EQ(webrtc::InternalDataChannelInit::kAcker,
             last_data_channel_config_.open_handshake_role);
 }
 
 TEST_P(WebRtcSessionTest, TestUsesProvidedCertificate) {
   rtc::scoped_refptr<rtc::RTCCertificate> certificate =
       FakeRTCCertificateGenerator::GenerateCertificate();
 
@@ skipping 329 matching lines @@
 }
 
 // TODO(bemasc): Add a TestIceStatesBundle with BUNDLE enabled.  That test
 // currently fails because upon disconnection and reconnection OnIceComplete is
 // called more than once without returning to IceGatheringGathering.
 
 INSTANTIATE_TEST_CASE_P(WebRtcSessionTests,
                         WebRtcSessionTest,
                         testing::Values(ALREADY_GENERATED,
                                         DTLS_IDENTITY_STORE));