Wire up transport sequence number / send time callbacks to webrtc via libjingle.

talk/app/webrtc/webrtcsession_unittest.cc

 /*
  * libjingle
  * Copyright 2012 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 24 matching lines @@
 #include "talk/app/webrtc/streamcollection.h"
 #include "talk/app/webrtc/test/fakeconstraints.h"
 #include "talk/app/webrtc/test/fakedtlsidentitystore.h"
 #include "talk/app/webrtc/test/fakemediastreamsignaling.h"
 #include "talk/app/webrtc/videotrack.h"
 #include "talk/app/webrtc/webrtcsession.h"
 #include "talk/app/webrtc/webrtcsessiondescriptionfactory.h"
 #include "talk/media/base/fakemediaengine.h"
 #include "talk/media/base/fakevideorenderer.h"
 #include "talk/media/base/mediachannel.h"
+#include "talk/media/webrtc/fakewebrtccall.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 "talk/session/media/channelmanager.h"
 #include "talk/session/media/mediasession.h"
 #include "webrtc/base/fakenetwork.h"
 #include "webrtc/base/firewallsocketserver.h"
 #include "webrtc/base/gunit.h"
@@ skipping 176 matching lines @@
   PeerConnectionInterface::IceGatheringState ice_gathering_state_;
 };
 
 class WebRtcSessionForTest : public webrtc::WebRtcSession {
  public:
   WebRtcSessionForTest(cricket::ChannelManager* cmgr,
                        rtc::Thread* signaling_thread,
                        rtc::Thread* worker_thread,
                        cricket::PortAllocator* port_allocator,
                        webrtc::IceObserver* ice_observer,
-                       webrtc::MediaStreamSignaling* mediastream_signaling)
-    : WebRtcSession(cmgr, signaling_thread, worker_thread, port_allocator,
-                    mediastream_signaling) {
+                       webrtc::MediaStreamSignaling* mediastream_signaling,
+                       webrtc::CallFactory* call_factory)
+      : WebRtcSession(cmgr,
+                      signaling_thread,
+                      worker_thread,
+                      port_allocator,
+                      mediastream_signaling,
+                      call_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
   cricket::TransportChannel* voice_rtp_transport_channel() {
     return rtp_transport_channel(voice_channel());
   }
 
@@ skipping 92 matching lines @@
   }
   void SetSink(Sink* sink) override { sink_ = sink; }
 
   int channel_id() const { return channel_id_; }
   cricket::AudioRenderer::Sink* sink() const { return sink_; }
  private:
   int channel_id_;
   cricket::AudioRenderer::Sink* sink_;
 };
 
+class FakeCallFactory : public webrtc::CallFactory {
+ public:
+  FakeCallFactory() : fake_call_(nullptr) {}
+
+  webrtc::Call* CreateCall(const webrtc::Call::Config& config) override {
+    fake_call_ = new cricket::FakeCall(config);
+    return fake_call_;
+  }
+
+  cricket::FakeCall* fake_call() const { return fake_call_; }
+
+ private:
+  // Since ownership of fake_call_ is handed over to the caller of CreateCall,
+  // this pointer is only valid until the caller has deleted it.
+  cricket::FakeCall* fake_call_;
+};
+
 class WebRtcSessionTest
     : public testing::TestWithParam<RTCCertificateGenerationMethod> {
  protected:
   // TODO Investigate why ChannelManager crashes, if it's created
   // after stun_server.
   WebRtcSessionTest()
     : media_engine_(new cricket::FakeMediaEngine()),
       data_engine_(new cricket::FakeDataEngine()),
       channel_manager_(new cricket::ChannelManager(
          media_engine_, data_engine_, new cricket::CaptureManager(),
@@ skipping 32 matching lines @@
   // If |dtls_identity_store| != 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
   // |dtls_identity_store|.
   void Init(
       rtc::scoped_ptr<webrtc::DtlsIdentityStoreInterface> dtls_identity_store,
       const PeerConnectionInterface::RTCConfiguration& rtc_configuration) {
     ASSERT_TRUE(session_.get() == NULL);
     session_.reset(new WebRtcSessionForTest(
-        channel_manager_.get(), rtc::Thread::Current(),
-        rtc::Thread::Current(), allocator_.get(),
-        &observer_,
-        &mediastream_signaling_));
+        channel_manager_.get(), rtc::Thread::Current(), rtc::Thread::Current(),
+        allocator_.get(), &observer_, &mediastream_signaling_, &call_factory_));
 
     EXPECT_EQ(PeerConnectionInterface::kIceConnectionNew,
         observer_.ice_connection_state_);
     EXPECT_EQ(PeerConnectionInterface::kIceGatheringNew,
         observer_.ice_gathering_state_);
 
     EXPECT_TRUE(session_->Initialize(options_, constraints_.get(),
                                      dtls_identity_store.Pass(),
                                      rtc_configuration));
     session_->set_metrics_observer(metrics_observer_);
@@ skipping 699 matching lines @@
   // This code is placed in a method so that it can be invoked
   // by multiple tests with different allocators (e.g. with and without BUNDLE).
   // While running the call, this method also checks if the session goes through
   // the correct sequence of ICE states when a connection is established,
   // broken, and re-established.
   // The Connection state should go:
   // New -> Checking -> (Connected) -> Completed -> Disconnected -> Completed
   //     -> Failed.
   // The Gathering state should go: New -> Gathering -> Completed.
 
-  void TestLoopbackCall(const LoopbackNetworkConfiguration& config) {
-    LoopbackNetworkManager loopback_network_manager(this, config);
+  void SetupLoopbackCall() {
     Init();
     mediastream_signaling_.SendAudioVideoStream1();
     SessionDescriptionInterface* offer = CreateOffer();
 
     EXPECT_EQ(PeerConnectionInterface::kIceGatheringNew,
               observer_.ice_gathering_state_);
     SetLocalDescriptionWithoutError(offer);
     EXPECT_EQ(PeerConnectionInterface::kIceConnectionNew,
               observer_.ice_connection_state_);
     EXPECT_EQ_WAIT(PeerConnectionInterface::kIceGatheringGathering,
-                   observer_.ice_gathering_state_,
-                   kIceCandidatesTimeout);
+                   observer_.ice_gathering_state_, kIceCandidatesTimeout);
     EXPECT_TRUE_WAIT(observer_.oncandidatesready_, kIceCandidatesTimeout);
     EXPECT_EQ_WAIT(PeerConnectionInterface::kIceGatheringComplete,
-                   observer_.ice_gathering_state_,
-                   kIceCandidatesTimeout);
+                   observer_.ice_gathering_state_, kIceCandidatesTimeout);
 
     std::string sdp;
     offer->ToString(&sdp);
-    SessionDescriptionInterface* desc =
-        webrtc::CreateSessionDescription(
-            JsepSessionDescription::kAnswer, sdp, nullptr);
+    SessionDescriptionInterface* desc = webrtc::CreateSessionDescription(
+        JsepSessionDescription::kAnswer, sdp, nullptr);
     ASSERT_TRUE(desc != NULL);
     SetRemoteDescriptionWithoutError(desc);
 
     EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionChecking,
-                   observer_.ice_connection_state_,
-                   kIceCandidatesTimeout);
+                   observer_.ice_connection_state_, kIceCandidatesTimeout);
 
     // The ice connection state is "Connected" too briefly to catch in a test.
     EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionCompleted,
-                   observer_.ice_connection_state_,
-                   kIceCandidatesTimeout);
+                   observer_.ice_connection_state_, kIceCandidatesTimeout);
+  }
 
+  void TestLoopbackCall(const LoopbackNetworkConfiguration& config) {
+    LoopbackNetworkManager loopback_network_manager(this, config);
+    SetupLoopbackCall();
     config.VerifyBestConnectionAfterIceConverge(metrics_observer_);
     // Adding firewall rule to block ping requests, which should cause
     // transport channel failure.
 
     loopback_network_manager.ApplyFirewallRules(fss_.get());
 
     LOG(LS_INFO) << "Firewall Rules applied";
     EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionDisconnected,
                    observer_.ice_connection_state_,
                    kIceCandidatesTimeout);
@@ skipping 18 matching lines @@
     EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionDisconnected,
                    observer_.ice_connection_state_,
                    kIceCandidatesTimeout + port_timeout);
   }
 
   void TestLoopbackCall() {
     LoopbackNetworkConfiguration config;
     TestLoopbackCall(config);
   }
 
+  void TestPacketOptions() {
+    LoopbackNetworkConfiguration config;
+    LoopbackNetworkManager loopback_network_manager(this, config);
+
+    SetupLoopbackCall();

[pthatcher1, 2015/10/09 20:57:48]

For testing, this would be more thorough if we made sure it works even if
everything is bundled over the data channel transport.  The easiest way to do
that is to probably change the offer that comes from CreateOffer() in this file
such that offer->GetGroupByName(GROUP_TYPE_BUNDLE)->content_names()[0] ==
CN_DATA.  Right now [0] == CN_AUDIO and [2] == CN_DATA.  You could probably
accomplish that with:

ContentGroup* bundle = offer->GetGroupByName(GROUP_TYPE_BUNDLE);
if (bundle) {
  // Re-add audio and and video so that data shows up first.
  if(bundle->RemoveContentName(CN_AUDIO)) {
    bundle->AddContentName(CN_AUDIO);
  }
  if (bundle->RemoveContentName(CN_VIDEO)) {
    bundle->AddContentName(CN_VIDEO);
  }
}

[stefan-webrtc, 2015/10/10 15:32:51]

I don't think that method works, since the ContentGroup returned by
SessionDescription::GetGroupByName is const. I tried building a group from
scratch instead, but it seems like my offer doesn't contain a data channel. I'm
currently stuck trying to offer both audio, video and data as I can't seem to
find any examples doing that in this file, and data doesn't seem to be added in
the same way audio and video is?

Any clues? :)

+
+    uint8_t test_packet[15] = {0};
+    rtc::PacketOptions options;
+    options.packet_id = 10;
+    media_engine_->GetVideoChannel(0)
+        ->SendRtp(test_packet, sizeof(test_packet), options);
+
+    const int kPacketTimeout = 2000;
+    EXPECT_EQ_WAIT(call_factory_.fake_call()->last_sent_packet().packet_id, 10,
+                   kPacketTimeout);
+    EXPECT_GT(call_factory_.fake_call()->last_sent_packet().send_time_ms, -1);
+  }
+
   // Adds CN codecs to FakeMediaEngine and MediaDescriptionFactory.
   void AddCNCodecs() {
     const cricket::AudioCodec kCNCodec1(102, "CN", 8000, 0, 1, 0);
     const cricket::AudioCodec kCNCodec2(103, "CN", 16000, 0, 1, 0);
 
     // Add kCNCodec for dtmf test.
     std::vector<cricket::AudioCodec> codecs = media_engine_->audio_codecs();;
     codecs.push_back(kCNCodec1);
     codecs.push_back(kCNCodec2);
     media_engine_->SetAudioCodecs(codecs);
@@ skipping 99 matching lines @@
   rtc::FakeNetworkManager network_manager_;
   rtc::scoped_ptr<cricket::BasicPortAllocator> allocator_;
   PeerConnectionFactoryInterface::Options options_;
   rtc::scoped_ptr<FakeConstraints> constraints_;
   FakeMediaStreamSignaling mediastream_signaling_;
   rtc::scoped_ptr<WebRtcSessionForTest> session_;
   MockIceObserver observer_;
   cricket::FakeVideoMediaChannel* video_channel_;
   cricket::FakeVoiceMediaChannel* voice_channel_;
   rtc::scoped_refptr<FakeMetricsObserver> metrics_observer_;
+  FakeCallFactory call_factory_;
 };
 
 TEST_P(WebRtcSessionTest, TestInitializeWithDtls) {
   InitWithDtls(GetParam());
   // SDES is disabled when DTLS is on.
   EXPECT_EQ(cricket::SEC_DISABLED, session_->SdesPolicy());
 }
 
 TEST_F(WebRtcSessionTest, TestInitializeWithoutDtls) {
   Init();
@@ skipping 2691 matching lines @@
 
   for (auto& o : observers) {
     // We expect to have received a notification now even if the session was
     // terminated.  The offer creation may or may not have succeeded, but we
     // must have received a notification which, so the only invalid state
     // is kInit.
     EXPECT_NE(WebRtcSessionCreateSDPObserverForTest::kInit, o->state());
   }
 }
 
+TEST_F(WebRtcSessionTest, TestPacketOptionsAndOnPacketSent) {
+  TestPacketOptions();
+}
+
 // 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));