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

talk/app/webrtc/webrtcsession.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 27 matching lines @@
 #include "talk/app/webrtc/mediaconstraintsinterface.h"
 #include "talk/app/webrtc/mediastreamsignaling.h"
 #include "talk/app/webrtc/peerconnectioninterface.h"
 #include "talk/app/webrtc/webrtcsessiondescriptionfactory.h"
 #include "talk/media/base/constants.h"
 #include "talk/media/base/videocapturer.h"
 #include "talk/session/media/channel.h"
 #include "talk/session/media/channelmanager.h"
 #include "talk/session/media/mediasession.h"
 #include "webrtc/base/basictypes.h"
+#include "webrtc/base/bind.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/helpers.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/stringencode.h"
 #include "webrtc/base/stringutils.h"
 #include "webrtc/p2p/base/portallocator.h"
+#include "webrtc/p2p/base/transportchannel.h"
 
 using cricket::ContentInfo;
 using cricket::ContentInfos;
 using cricket::MediaContentDescription;
 using cricket::SessionDescription;
 using cricket::TransportInfo;
 
 using cricket::LOCAL_PORT_TYPE;
 using cricket::STUN_PORT_TYPE;
 using cricket::RELAY_PORT_TYPE;
 using cricket::PRFLX_PORT_TYPE;
 
+using rtc::Bind;
+
 namespace webrtc {
 
 // Error messages
 const char kBundleWithoutRtcpMux[] = "RTCP-MUX must be enabled when BUNDLE "
                                      "is enabled.";
 const char kCreateChannelFailed[] = "Failed to create channels.";
 const char kInvalidCandidates[] = "Description contains invalid candidates.";
 const char kInvalidSdp[] = "Invalid session description.";
 const char kMlineMismatch[] =
     "Offer and answer descriptions m-lines are not matching. Rejecting answer.";
@@ skipping 453 matching lines @@
         return true;
       }
     }
     return false;
   }
 
  private:
   bool ice_restart_;
 };
 
-WebRtcSession::WebRtcSession(
-    cricket::ChannelManager* channel_manager,
-    rtc::Thread* signaling_thread,
-    rtc::Thread* worker_thread,
-    cricket::PortAllocator* port_allocator,
-    MediaStreamSignaling* mediastream_signaling)
+WebRtcSession::WebRtcSession(webrtc::MediaControllerInterface* media_controller,
+                             rtc::Thread* signaling_thread,
+                             rtc::Thread* worker_thread,
+                             cricket::PortAllocator* port_allocator,
+                             MediaStreamSignaling* mediastream_signaling)
     : cricket::BaseSession(signaling_thread,
                            worker_thread,
                            port_allocator,
                            rtc::ToString(rtc::CreateRandomId64() & LLONG_MAX),
                            false),
       // RFC 3264: The numeric value of the session id and version in the
       // o line MUST be representable with a "64 bit signed integer".
       // Due to this constraint session id |sid_| is max limited to LLONG_MAX.
-      channel_manager_(channel_manager),
+      media_controller_(media_controller),
+      channel_manager_(media_controller_->channel_manager()),
       mediastream_signaling_(mediastream_signaling),
       ice_observer_(NULL),
       ice_connection_state_(PeerConnectionInterface::kIceConnectionNew),
       ice_connection_receiving_(true),
       older_version_remote_peer_(false),
       dtls_enabled_(false),
       data_channel_type_(cricket::DCT_NONE),
       ice_restart_latch_(new IceRestartAnswerLatch),
       metrics_observer_(NULL) {
   transport_controller()->SignalConnectionState.connect(
@@ skipping 205 matching lines @@
   }
   port_allocator()->set_candidate_filter(
       ConvertIceTransportTypeToCandidateFilter(rtc_configuration.type));
 
   if (rtc_configuration.enable_localhost_ice_candidate) {
     port_allocator()->set_flags(
         port_allocator()->flags() |
         cricket::PORTALLOCATOR_ENABLE_LOCALHOST_CANDIDATE);
   }
 
-  media_controller_.reset(MediaControllerInterface::Create(
-      worker_thread(), channel_manager_->media_engine()->GetVoE()));
-
   return true;
 }
 
 cricket::IceConfig WebRtcSession::ParseIceConfig(
     const PeerConnectionInterface::RTCConfiguration& config) const {
   cricket::IceConfig ice_config;
   ice_config.receiving_timeout_ms = config.ice_connection_receiving_timeout;
   ice_config.gather_continually = (config.continual_gathering_policy ==
                                    PeerConnectionInterface::GATHER_CONTINUALLY);
   return ice_config;
@@ skipping 1020 matching lines @@
       LOG(LS_WARNING) << "max-bundle failed to enable bundling.";
       return false;
     }
   }
 
   return true;
 }
 
 bool WebRtcSession::CreateVoiceChannel(const cricket::ContentInfo* content) {
   voice_channel_.reset(channel_manager_->CreateVoiceChannel(
-      media_controller_.get(), transport_controller(), content->name, true,
+      media_controller_, transport_controller(), content->name, true,
       audio_options_));
   if (!voice_channel_) {
     return false;
   }
 
   voice_channel_->SignalDtlsSetupFailure.connect(
       this, &WebRtcSession::OnDtlsSetupFailure);
+  voice_channel_->transport_channel()->SignalSentPacket.connect(
+      this, &WebRtcSession::OnSentPacket);
   return true;
 }
 
 bool WebRtcSession::CreateVideoChannel(const cricket::ContentInfo* content) {
   video_channel_.reset(channel_manager_->CreateVideoChannel(
-      media_controller_.get(), transport_controller(), content->name, true,
+      media_controller_, transport_controller(), content->name, true,
       video_options_));
   if (!video_channel_) {
     return false;
   }
 
   video_channel_->SignalDtlsSetupFailure.connect(
       this, &WebRtcSession::OnDtlsSetupFailure);
+  video_channel_->transport_channel()->SignalSentPacket.connect(
+      this, &WebRtcSession::OnSentPacket);
   return true;
 }
 
 bool WebRtcSession::CreateDataChannel(const cricket::ContentInfo* content) {
   bool sctp = (data_channel_type_ == cricket::DCT_SCTP);
   data_channel_.reset(channel_manager_->CreateDataChannel(
       transport_controller(), content->name, !sctp, data_channel_type_));
   if (!data_channel_) {
     return false;
   }
 
   if (sctp) {
     mediastream_signaling_->OnDataTransportCreatedForSctp();
     data_channel_->SignalDataReceived.connect(
         this, &WebRtcSession::OnDataChannelMessageReceived);
     data_channel_->SignalStreamClosedRemotely.connect(
         mediastream_signaling_,
         &MediaStreamSignaling::OnRemoteSctpDataChannelClosed);
   }
 
   data_channel_->SignalDtlsSetupFailure.connect(
       this, &WebRtcSession::OnDtlsSetupFailure);
+  data_channel_->transport_channel()->SignalSentPacket.connect(
+      this, &WebRtcSession::OnSentPacket);
   return true;
 }
 
 void WebRtcSession::OnDtlsSetupFailure(cricket::BaseChannel*, bool rtcp) {
   SetError(BaseSession::ERROR_TRANSPORT, rtcp ? kDtlsSetupFailureRtcp :
            kDtlsSetupFailureRtp);
 }
 
 void WebRtcSession::CopySavedCandidates(
     SessionDescriptionInterface* dest_desc) {
@@ skipping 303 matching lines @@
 
   if (!srtp_cipher.empty()) {
     metrics_observer_->IncrementSparseEnumCounter(
         srtp_counter_type, rtc::GetSrtpCryptoSuiteFromName(srtp_cipher));
   }
   if (ssl_cipher) {
     metrics_observer_->IncrementSparseEnumCounter(ssl_counter_type, ssl_cipher);
   }
 }
 
+void WebRtcSession::OnSentPacket(cricket::TransportChannel* channel,
+                                 const rtc::SentPacket& sent_packet) {
+  worker_thread()->Invoke<void>(
+      rtc::Bind(&WebRtcSession::OnSentPacket_w, this, sent_packet));
+  media_controller_->call_w()->OnSentPacket(sent_packet);

[pthatcher1, 2015/10/13 05:31:13]

Two things:

1.  If you hop to the worker thread, shouldn't you remove the call to
OnSentPacket here?  Otherwise, you have two calls.

2.  Shouldn't OnSentPacket always happen on the worker thread?  A
TransportChannel lives on the worker thread and is only accessed via the worker
thread.  It shouldn't fire this except on the worker thread.  So I don't see why
the extra thread hop is needed.

[stefan-webrtc, 2015/10/13 08:09:20]

You are right, it should. Keeping OnSentPacket_w.

+}
+
+void WebRtcSession::OnSentPacket_w(const rtc::SentPacket& sent_packet) {
+  RTC_DCHECK(worker_thread()->IsCurrent());
+  media_controller_->call_w()->OnSentPacket(sent_packet);
+}
+
 }  // namespace webrtc