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

talk/session/media/channel_unittest.cc

 /*
  * libjingle
  * Copyright 2009 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 15 matching lines @@
  */
 
 #include "talk/media/base/fakemediaengine.h"
 #include "talk/media/base/fakertp.h"
 #include "talk/media/base/fakescreencapturerfactory.h"
 #include "talk/media/base/fakevideocapturer.h"
 #include "talk/media/base/mediachannel.h"
 #include "talk/media/base/rtpdump.h"
 #include "talk/media/base/screencastid.h"
 #include "talk/media/base/testutils.h"
-#include "webrtc/p2p/base/faketransportcontroller.h"
+#include "talk/media/webrtc/fakewebrtccall.h"
+#include "talk/app/webrtc/fakemediacontroller.h"
 #include "talk/session/media/channel.h"
 #include "webrtc/base/fileutils.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/helpers.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/pathutils.h"
 #include "webrtc/base/signalthread.h"
 #include "webrtc/base/ssladapter.h"
 #include "webrtc/base/sslidentity.h"
 #include "webrtc/base/window.h"
+#include "webrtc/p2p/base/faketransportcontroller.h"
 
 #define MAYBE_SKIP_TEST(feature)                    \
   if (!(rtc::SSLStreamAdapter::feature())) {  \
     LOG(LS_INFO) << "Feature disabled... skipping"; \
     return;                                         \
   }
 
 using cricket::CA_OFFER;
 using cricket::CA_PRANSWER;
 using cricket::CA_ANSWER;
@@ skipping 70 matching lines @@
                DTLS = 0x10 };
 
   ChannelTest(bool verify_playout,
               const uint8* rtp_data,
               int rtp_len,
               const uint8* rtcp_data,
               int rtcp_len)
       : verify_playout_(verify_playout),
         transport_controller1_(cricket::ICEROLE_CONTROLLING),
         transport_controller2_(cricket::ICEROLE_CONTROLLED),
+        call_(webrtc::Call::Config()),
+        media_controller_(&call_),
         media_channel1_(NULL),
         media_channel2_(NULL),
         rtp_packet_(reinterpret_cast<const char*>(rtp_data), rtp_len),
         rtcp_packet_(reinterpret_cast<const char*>(rtcp_data), rtcp_len),
         media_info_callbacks1_(),
         media_info_callbacks2_() {}
 
   void CreateChannels(int flags1, int flags2) {
     CreateChannels(new typename T::MediaChannel(NULL, typename T::Options()),
                    new typename T::MediaChannel(NULL, typename T::Options()),
                    flags1, flags2, rtc::Thread::Current());
   }
   void CreateChannels(
       typename T::MediaChannel* ch1, typename T::MediaChannel* ch2,
       int flags1, int flags2, rtc::Thread* thread) {
     media_channel1_ = ch1;
     media_channel2_ = ch2;
     channel1_.reset(CreateChannel(thread, &media_engine_, ch1,
-                                  &transport_controller1_,
+                                  &media_controller_, &transport_controller1_,
                                   (flags1 & RTCP) != 0));
     channel2_.reset(CreateChannel(thread, &media_engine_, ch2,
-                                  &transport_controller2_,
+                                  &media_controller_, &transport_controller2_,
                                   (flags2 & RTCP) != 0));
     channel1_->SignalMediaMonitor.connect(
         this, &ChannelTest<T>::OnMediaMonitor);
     channel2_->SignalMediaMonitor.connect(
         this, &ChannelTest<T>::OnMediaMonitor);
     if ((flags1 & DTLS) && (flags2 & DTLS)) {
       flags1 = (flags1 & ~SECURE);
       flags2 = (flags2 & ~SECURE);
     }
     CreateContent(flags1, kPcmuCodec, kH264Codec,
@@ skipping 29 matching lines @@
       AddLegacyStreamInContent(kSsrc1, flags1, &remote_media_content1_);
     }
     if (flags2 & SSRC_MUX) {
       AddLegacyStreamInContent(kSsrc2, flags2, &remote_media_content2_);
     }
   }
   typename T::Channel* CreateChannel(
       rtc::Thread* thread,
       cricket::MediaEngineInterface* engine,
       typename T::MediaChannel* ch,
+      webrtc::MediaControllerInterface* media_controller,
       cricket::TransportController* transport_controller,
       bool rtcp) {
-    typename T::Channel* channel = new typename T::Channel(
-        thread, engine, ch, transport_controller, cricket::CN_AUDIO, rtcp);
+    typename T::Channel* channel =
+        new typename T::Channel(thread, engine, ch, media_controller,
+                                transport_controller, cricket::CN_AUDIO, rtcp);
     if (!channel->Init()) {
       delete channel;
       channel = NULL;
     }
     return channel;
   }
 
   bool SendInitiate() {
     bool result = channel1_->SetLocalContent(&local_media_content1_,
                                              CA_OFFER, NULL);
@@ skipping 1560 matching lines @@
     EXPECT_FALSE(media_channel1_->ready_to_send());
   }
 
  protected:
   // TODO(pbos): Remove playout from all media channels and let renderers mute
   // themselves.
   const bool verify_playout_;
   cricket::FakeTransportController transport_controller1_;
   cricket::FakeTransportController transport_controller2_;
   cricket::FakeMediaEngine media_engine_;
+  cricket::FakeCall call_;
+  cricket::FakeMediaController media_controller_;
   // The media channels are owned by the voice channel objects below.
   typename T::MediaChannel* media_channel1_;
   typename T::MediaChannel* media_channel2_;
   rtc::scoped_ptr<typename T::Channel> channel1_;
   rtc::scoped_ptr<typename T::Channel> channel2_;
   typename T::Content local_media_content1_;
   typename T::Content local_media_content2_;
   typename T::Content remote_media_content1_;
   typename T::Content remote_media_content2_;
   // The RTP and RTCP packets to send in the tests.
@@ skipping 49 matching lines @@
              kRtcpReport,
              sizeof(kRtcpReport)) {}
 };
 
 // override to add NULL parameter
 template <>
 cricket::VideoChannel* ChannelTest<VideoTraits>::CreateChannel(
     rtc::Thread* thread,
     cricket::MediaEngineInterface* engine,
     cricket::FakeVideoMediaChannel* ch,
+    webrtc::MediaControllerInterface* media_controller,
     cricket::TransportController* transport_controller,
     bool rtcp) {
-  cricket::VideoChannel* channel = new cricket::VideoChannel(
-      thread, ch, transport_controller, cricket::CN_VIDEO, rtcp);
+  cricket::VideoChannel* channel =
+      new cricket::VideoChannel(thread, ch, media_controller,
+                                transport_controller, cricket::CN_VIDEO, rtcp);
   if (!channel->Init()) {
     delete channel;
     channel = NULL;
   }
   return channel;
 }
 
 // override to add 0 parameter
 template<>
 bool ChannelTest<VideoTraits>::AddStream1(int id) {
@@ skipping 648 matching lines @@
 }
 
 TEST_F(VideoChannelTest, TestOnReadyToSend) {
   Base::TestOnReadyToSend();
 }
 
 TEST_F(VideoChannelTest, TestOnReadyToSendWithRtcpMux) {
   Base::TestOnReadyToSendWithRtcpMux();
 }
 
+TEST_F(VideoChannelTest, OnSentPacketIsCalled) {
+  Base::SendRtpToRtp();
+  EXPECT_TRUE(call_.on_packet_sent_called());
+}
+
 TEST_F(VideoChannelTest, TestApplyViewRequest) {
   CreateChannels(0, 0);
   cricket::StreamParams stream2;
   stream2.id = "stream2";
   stream2.ssrcs.push_back(2222);
   local_media_content1_.AddStream(stream2);
 
   EXPECT_TRUE(SendInitiate());
   EXPECT_TRUE(SendAccept());
 
@@ skipping 62 matching lines @@
              kRtcpReport,
              sizeof(kRtcpReport)) {}
 };
 
 // Override to avoid engine channel parameter.
 template <>
 cricket::DataChannel* ChannelTest<DataTraits>::CreateChannel(
     rtc::Thread* thread,
     cricket::MediaEngineInterface* engine,
     cricket::FakeDataMediaChannel* ch,
+    webrtc::MediaControllerInterface* media_controller,
     cricket::TransportController* transport_controller,
     bool rtcp) {
   cricket::DataChannel* channel = new cricket::DataChannel(
       thread, ch, transport_controller, cricket::CN_DATA, rtcp);
   if (!channel->Init()) {
     delete channel;
     channel = NULL;
   }
   return channel;
 }
@@ skipping 169 matching lines @@
   };
   rtc::Buffer payload(data, 3);
   cricket::SendDataResult result;
   ASSERT_TRUE(media_channel1_->SendData(params, payload, &result));
   EXPECT_EQ(params.ssrc,
             media_channel1_->last_sent_data_params().ssrc);
   EXPECT_EQ("foo", media_channel1_->last_sent_data());
 }
 
 // TODO(pthatcher): TestSetReceiver?