Reland of Add received audio/video call duration metrics based on packets.

webrtc/call/call.cc

 /*
  *  Copyright (c) 2013 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 307 matching lines @@
 
   webrtc::RtcEventLog* event_log_;
 
   // The following members are only accessed (exclusively) from one thread and
   // from the destructor, and therefore doesn't need any explicit
   // synchronization.
   RateCounter received_bytes_per_second_counter_;
   RateCounter received_audio_bytes_per_second_counter_;
   RateCounter received_video_bytes_per_second_counter_;
   RateCounter received_rtcp_bytes_per_second_counter_;
+  rtc::Optional<int64_t> first_received_rtp_audio_ms_;
+  rtc::Optional<int64_t> last_received_rtp_audio_ms_;
+  rtc::Optional<int64_t> first_received_rtp_video_ms_;
+  rtc::Optional<int64_t> last_received_rtp_video_ms_;
 
   // TODO(holmer): Remove this lock once BitrateController no longer calls
   // OnNetworkChanged from multiple threads.
   rtc::CriticalSection bitrate_crit_;
   uint32_t min_allocated_send_bitrate_bps_ GUARDED_BY(&bitrate_crit_);
   uint32_t configured_max_padding_bitrate_bps_ GUARDED_BY(&bitrate_crit_);
   AvgCounter estimated_send_bitrate_kbps_counter_ GUARDED_BY(&bitrate_crit_);
   AvgCounter pacer_bitrate_kbps_counter_ GUARDED_BY(&bitrate_crit_);
 
   std::map<std::string, rtc::NetworkRoute> network_routes_;
@@ skipping 185 matching lines @@
       pacer_bitrate_kbps_counter_.ProcessAndGetStats();
   if (pacer_bitrate_stats.num_samples > kMinRequiredPeriodicSamples) {
     RTC_HISTOGRAM_COUNTS_100000("WebRTC.Call.PacerBitrateInKbps",
                                 pacer_bitrate_stats.average);
     LOG(LS_INFO) << "WebRTC.Call.PacerBitrateInKbps, "
                  << pacer_bitrate_stats.ToString();
   }
 }
 
 void Call::UpdateReceiveHistograms() {
+  if (first_received_rtp_audio_ms_) {
+    RTC_HISTOGRAM_COUNTS_100000(
+        "WebRTC.Call.TimeReceivingAudioRtpPacketsInSeconds",
+        (*last_received_rtp_audio_ms_ - *first_received_rtp_audio_ms_) / 1000);
+  }
+  if (first_received_rtp_video_ms_) {
+    RTC_HISTOGRAM_COUNTS_100000(
+        "WebRTC.Call.TimeReceivingVideoRtpPacketsInSeconds",
+        (*last_received_rtp_video_ms_ - *first_received_rtp_video_ms_) / 1000);
+  }
   const int kMinRequiredPeriodicSamples = 5;
   AggregatedStats video_bytes_per_sec =
       received_video_bytes_per_second_counter_.GetStats();
   if (video_bytes_per_sec.num_samples > kMinRequiredPeriodicSamples) {
     RTC_HISTOGRAM_COUNTS_100000("WebRTC.Call.VideoBitrateReceivedInKbps",
                                 video_bytes_per_sec.average * 8 / 1000);
     LOG(LS_INFO) << "WebRTC.Call.VideoBitrateReceivedInBps, "
                  << video_bytes_per_sec.ToStringWithMultiplier(8);
   }
   AggregatedStats audio_bytes_per_sec =
@@ skipping 767 matching lines @@
   }
   parsed_packet->IdentifyExtensions(it->second.extensions);
 
   NotifyBweOfReceivedPacket(*parsed_packet, media_type);
 
   if (media_type == MediaType::AUDIO) {
     if (audio_receiver_controller_.OnRtpPacket(*parsed_packet)) {
       received_bytes_per_second_counter_.Add(static_cast<int>(length));
       received_audio_bytes_per_second_counter_.Add(static_cast<int>(length));
       event_log_->LogRtpHeader(kIncomingPacket, packet, length);
+      const int64_t arrival_time_ms = parsed_packet->arrival_time_ms();
+      if (!first_received_rtp_audio_ms_) {
+        first_received_rtp_audio_ms_.emplace(arrival_time_ms);
+      }
+      last_received_rtp_audio_ms_.emplace(arrival_time_ms);
       return DELIVERY_OK;
     }
   } else if (media_type == MediaType::VIDEO) {
     if (video_receiver_controller_.OnRtpPacket(*parsed_packet)) {
       received_bytes_per_second_counter_.Add(static_cast<int>(length));
       received_video_bytes_per_second_counter_.Add(static_cast<int>(length));
       event_log_->LogRtpHeader(kIncomingPacket, packet, length);
+      const int64_t arrival_time_ms = parsed_packet->arrival_time_ms();
+      if (!first_received_rtp_video_ms_) {
+        first_received_rtp_video_ms_.emplace(arrival_time_ms);
+      }
+      last_received_rtp_video_ms_.emplace(arrival_time_ms);
       return DELIVERY_OK;
     }
   }
   return DELIVERY_UNKNOWN_SSRC;
 }
 
 PacketReceiver::DeliveryStatus Call::DeliverPacket(
     MediaType media_type,
     const uint8_t* packet,
     size_t length,
@@ skipping 46 matching lines @@
       (use_send_side_bwe && header.extension.hasTransportSequenceNumber)) {
     receive_side_cc_.OnReceivedPacket(
         packet.arrival_time_ms(), packet.payload_size() + packet.padding_size(),
         header);
   }
 }
 
 }  // namespace internal
 
 }  // namespace webrtc