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 564 matching lines @@
     TransportChannel* channel,
     CandidatePairInterface* selected_candidate_pair,
     int last_sent_packet_id,
     bool ready_to_send) {
   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) {
+    selected_candidate_pair_ =
+        rtc::Optional<CandidatePair>(CandidatePair(*selected_candidate_pair));

[honghaiz3, 2016/10/31 17:42:09]

You don't need to save a copy of CandidatePair here. 
It should be sufficient to just use the pointer as the pointer is only accessed
in this class on the network thread and if the candidate pair is deleted, it
should be notified here. 

If you really want to save a copy to avoid the risk of accessing the pointer in
the future, I think we can save either
1. The local candidate, or
2. the overhead itself. 

By doing that, we don't need the changes in p2p/base dir. 

+
     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()));
+  } else {
+    selected_candidate_pair_ = rtc::Optional<CandidatePair>();
   }
   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) {
@@ skipping 424 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() {
+  constexpr int kIpv4Overhaed = 20;
+  constexpr int kIpv6Overhaed = 40;
+  constexpr int kUdpOverhaed = 8;
+  constexpr int kTcpOverhaed = 20;

[honghaiz3, 2016/10/31 17:42:09]

If you just use the saved selected_candidate_pair pointer, add a RTC_DCHECK to
make sure it is in the network thread. 

[michaelt, 2016/11/01 08:31:37]

Done.

+
+  int transport_overhead_per_packet = 0;
+
+  if (selected_candidate_pair_) {

[honghaiz3, 2016/10/31 17:42:09]

Can you use an early return? That would be more readable. 
if (!selected_candidate_pair_) {
  return 0;
}
....

[michaelt, 2016/11/01 08:31:37]

Done.

+    transport_overhead_per_packet +=
+        selected_candidate_pair_->local_candidate().protocol() ==
+                TCP_PROTOCOL_NAME
+            ? kTcpOverhaed
+            : kUdpOverhaed;
+    transport_overhead_per_packet +=
+        selected_candidate_pair_->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