Set actual transport overhead in rtp_rtcp

webrtc/pc/channel.cc

 /*
  *  Copyright 2004 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 568 matching lines @@
   RTC_DCHECK(channel == transport_channel_ ||
              channel == rtcp_transport_channel_);
   RTC_DCHECK(network_thread_->IsCurrent());
   std::string transport_name = channel->transport_name();
   rtc::NetworkRoute network_route;
   if (selected_candidate_pair) {
     network_route = rtc::NetworkRoute(
         ready_to_send, selected_candidate_pair->local_candidate().network_id(),
         selected_candidate_pair->remote_candidate().network_id(),
         last_sent_packet_id);
+
+    invoker_.AsyncInvoke<void>(
+        RTC_FROM_HERE, worker_thread_,
+        Bind(&MediaChannel::OnTransportOverheadChange, media_channel_,
+             GetTransportOverheadPerPacket(
+                 selected_candidate_pair->local_candidate())));
   }
+
   invoker_.AsyncInvoke<void>(
       RTC_FROM_HERE, worker_thread_,
       Bind(&MediaChannel::OnNetworkRouteChanged, media_channel_, transport_name,
            network_route));
 }
 
 void BaseChannel::SetTransportChannelReadyToSend(bool rtcp, bool ready) {
   RTC_DCHECK(network_thread_->IsCurrent());
   if (rtcp) {
     rtcp_ready_to_send_ = ready;
@@ skipping 423 matching lines @@
                                      static_cast<int>(send_key->size()),
                                      selected_crypto_suite, &(*recv_key)[0],
                                      static_cast<int>(recv_key->size()));
   } else {
     ret = srtp_filter_.SetRtpParams(selected_crypto_suite, &(*send_key)[0],
                                     static_cast<int>(send_key->size()),
                                     selected_crypto_suite, &(*recv_key)[0],
                                     static_cast<int>(recv_key->size()));
   }
 
-  if (!ret)
+  if (!ret) {
     LOG(LS_WARNING) << "DTLS-SRTP key installation failed";
-  else
+  } else {
     dtls_keyed_ = true;
-
+    invoker_.AsyncInvoke<void>(
+        RTC_FROM_HERE, worker_thread_,
+        Bind(&MediaChannel::OnTransportOverheadChange, media_channel_,
+             GetTransportOverheadPerPacket()));
+  }
   return ret;
 }
 
 void BaseChannel::MaybeSetupDtlsSrtp_n() {
   if (srtp_filter_.IsActive()) {
     return;
   }
 
   if (!ShouldSetupDtlsSrtp_n()) {
     return;
@@ skipping 606 matching lines @@
   }
 }
 
 void BaseChannel::UpdateMediaSendRecvState() {
   RTC_DCHECK(network_thread_->IsCurrent());
   invoker_.AsyncInvoke<void>(
       RTC_FROM_HERE, worker_thread_,
       Bind(&BaseChannel::UpdateMediaSendRecvState_w, this));
 }
 
+int BaseChannel::GetTransportOverheadPerPacket() {
+  if (transport_channel_) {
+    std::vector<ConnectionInfo> connection_infos;
+    transport_channel_->GetStats(&connection_infos);

[honghaiz3, 2016/10/27 18:57:44]

Does it make sense to just remember the last signaled candidate pair so that you
don't have to find the best connection via GetStats?
That way, you don't need two methods to get the overhead. 
Another choice would be to add a virtual method selected_connection in the
transportchannel. 

[michaelt, 2016/10/31 09:59:26]

store now the last signaled candidate pair in channel.

+    for (auto& connection_info : connection_infos) {
+      if (connection_info.best_connection) {
+        return GetTransportOverheadPerPacket(connection_info.local_candidate);
+        break;

[honghaiz3, 2016/10/27 18:57:44]

You don't need a break after return. 

[michaelt, 2016/10/31 09:59:26]

:)
I removed the function.

+      }
+    }
+  }
+  return 0;
+}
+
+int BaseChannel::GetTransportOverheadPerPacket(
+    const Candidate& local_candidate) {
+  constexpr int kIpv4Overhaed = 20;
+  constexpr int kIpv6Overhaed = 40;
+  constexpr int kUdpOverhaed = 8;
+  constexpr int kTcpOverhaed = 20;
+
+  int transport_overhead_per_packet = 0;
+  transport_overhead_per_packet +=
+      local_candidate.protocol() == TCP_PROTOCOL_NAME ? kTcpOverhaed
+                                                      : kUdpOverhaed;
+  transport_overhead_per_packet += local_candidate.address().family() == AF_INET
+                                       ? kIpv4Overhaed
+                                       : kIpv6Overhaed;
+  if (secure()) {
+    int srtp_overhead = 0;
+    if (srtp_filter_.GetSrtpOverhead(&srtp_overhead))
+      transport_overhead_per_packet += srtp_overhead;
+  }
+  return transport_overhead_per_packet;
+}
+
 void VoiceChannel::UpdateMediaSendRecvState_w() {
   // Render incoming data if we're the active call, and we have the local
   // content. We receive data on the default channel and multiplexed streams.
   bool recv = IsReadyToReceiveMedia_w();
   media_channel()->SetPlayout(recv);
 
   // Send outgoing data if we're the active call, we have the remote content,
   // and we have had some form of connectivity.
   bool send = IsReadyToSendMedia_w();
   media_channel()->SetSend(send);
@@ skipping 736 matching lines @@
 }
 
 void DataChannel::OnStreamClosedRemotely(uint32_t sid) {
   rtc::TypedMessageData<uint32_t>* message =
       new rtc::TypedMessageData<uint32_t>(sid);
   signaling_thread()->Post(RTC_FROM_HERE, this, MSG_STREAMCLOSEDREMOTELY,
                            message);
 }
 
 }  // namespace cricket