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

talk/app/webrtc/peerconnectionfactory.cc

 /*
  * libjingle
  * Copyright 2004--2011 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 134 matching lines @@
   ASSERT(worker_thread != NULL);
   ASSERT(signaling_thread != NULL);
   // TODO: Currently there is no way creating an external adm in
   // libjingle source tree. So we can 't currently assert if this is NULL.
   // ASSERT(default_adm != NULL);
 }
 
 PeerConnectionFactory::~PeerConnectionFactory() {
   RTC_DCHECK(signaling_thread_->IsCurrent());
   channel_manager_.reset(nullptr);
+  media_controller_.reset(nullptr);
   default_allocator_factory_ = nullptr;
 
   // Make sure |worker_thread_| and |signaling_thread_| outlive
   // |dtls_identity_store_|.
   dtls_identity_store_ = nullptr;
 
   if (owns_ptrs_) {
     if (wraps_current_thread_)
       rtc::ThreadManager::Instance()->UnwrapCurrentThread();
     delete worker_thread_;
@@ skipping 15 matching lines @@
       &PeerConnectionFactory::CreateMediaEngine_w, this));
 
   channel_manager_.reset(
       new cricket::ChannelManager(media_engine, worker_thread_));
 
   channel_manager_->SetVideoRtxEnabled(true);
   if (!channel_manager_->Init()) {
     return false;
   }
 
+  media_controller_.reset(MediaControllerInterface::Create(
+      worker_thread(), channel_manager_.get()));
+
   dtls_identity_store_ = new RefCountedDtlsIdentityStore(
       signaling_thread_, worker_thread_);
 
   return true;
 }
 
 rtc::scoped_refptr<AudioSourceInterface>
 PeerConnectionFactory::CreateAudioSource(
     const MediaConstraintsInterface* constraints) {
   RTC_DCHECK(signaling_thread_->IsCurrent());
@@ skipping 71 matching lines @@
 
 rtc::scoped_refptr<AudioTrackInterface>
 PeerConnectionFactory::CreateAudioTrack(const std::string& id,
                                         AudioSourceInterface* source) {
   RTC_DCHECK(signaling_thread_->IsCurrent());
   rtc::scoped_refptr<AudioTrackInterface> track(
       AudioTrack::Create(id, source));
   return AudioTrackProxy::Create(signaling_thread_, track);
 }
 
-cricket::ChannelManager* PeerConnectionFactory::channel_manager() {
-  RTC_DCHECK(signaling_thread_->IsCurrent());
-  return channel_manager_.get();
+webrtc::MediaControllerInterface* PeerConnectionFactory::media_controller()
+    const {
+  return media_controller_.get();
 }
 
 rtc::Thread* PeerConnectionFactory::signaling_thread() {
   // This method can be called on a different thread when the factory is
   // created in CreatePeerConnectionFactory().
   return signaling_thread_;
 }
 
 rtc::Thread* PeerConnectionFactory::worker_thread() {
   RTC_DCHECK(signaling_thread_->IsCurrent());
   return worker_thread_;
 }
 
 cricket::MediaEngineInterface* PeerConnectionFactory::CreateMediaEngine_w() {
   ASSERT(worker_thread_ == rtc::Thread::Current());
   return cricket::WebRtcMediaEngineFactory::Create(
       default_adm_.get(), video_encoder_factory_.get(),
       video_decoder_factory_.get());
 }
 
 }  // namespace webrtc