Handle zero timestamp in RTCVideoEncoder timestamp matching & add UMA

content/renderer/media/gpu/rtc_video_encoder.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/renderer/media/gpu/rtc_video_encoder.h"
 
 #include <string.h>
 
 #include <deque>
 #include <memory>
@@ skipping 190 matching lines @@
   // requirements.
   bool RequiresSizeChange(const scoped_refptr<media::VideoFrame>& frame) const;
 
   // Return an encoded output buffer to WebRTC.
   void ReturnEncodedImage(const webrtc::EncodedImage& image,
                           int32_t bitstream_buffer_id,
                           uint16_t picture_id);
 
   void SetStatus(int32_t status);
 
+  // Records |failed_timestamp_match_| value after a session.
+  void RecordTimestampMatchUMA() const;
+
   // This is attached to |gpu_task_runner_|, not the thread class is constructed
   // on.
   base::ThreadChecker thread_checker_;
 
   // Factory for creating VEAs, shared memory buffers, etc.
   media::GpuVideoAcceleratorFactories* gpu_factories_;
 
   // webrtc::VideoEncoder expects InitEncode() and Encode() to be synchronous.
   // Do this by waiting on the |async_waiter_| and returning the return value in
   // |async_retval_| when initialization completes, encoding completes, or
@@ skipping 182 matching lines @@
   if (IsBitrateTooHigh(bitrate))
     return;
 
   if (video_encoder_)
     video_encoder_->RequestEncodingParametersChange(bitrate * 1000, framerate);
 }
 
 void RTCVideoEncoder::Impl::Destroy(base::WaitableEvent* async_waiter) {
   DVLOG(3) << "Impl::Destroy()";
   DCHECK(thread_checker_.CalledOnValidThread());
+  RecordTimestampMatchUMA();
   if (video_encoder_) {
     video_encoder_.reset();
     SetStatus(WEBRTC_VIDEO_CODEC_UNINITIALIZED);
   }
   async_waiter->Signal();
 }
 
 int32_t RTCVideoEncoder::Impl::GetStatus() const {
   base::AutoLock lock(status_lock_);
   return status_;
 }
 
 void RTCVideoEncoder::Impl::SetStatus(int32_t status) {
   base::AutoLock lock(status_lock_);
   status_ = status;
 }
 
+void RTCVideoEncoder::Impl::RecordTimestampMatchUMA() const {
+  UMA_HISTOGRAM_BOOLEAN("Media.RTCVideoEncoderTimestampMatchSuccess",
+                        failed_timestamp_match_ == false);
+}
+
 void RTCVideoEncoder::Impl::RequireBitstreamBuffers(
     unsigned int input_count,
     const gfx::Size& input_coded_size,
     size_t output_buffer_size) {
   DVLOG(3) << "Impl::RequireBitstreamBuffers(): input_count=" << input_count
            << ", input_coded_size=" << input_coded_size.ToString()
            << ", output_buffer_size=" << output_buffer_size;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!video_encoder_)
@@ skipping 65 matching lines @@
   // greater than the last.
   const int64_t capture_time_us = rtc::TimeMicros();
   int64_t capture_time_ms =
       capture_time_us / base::Time::kMicrosecondsPerMillisecond;
   capture_time_ms = std::max(capture_time_ms, last_capture_time_ms_ + 1);
   last_capture_time_ms_ = capture_time_ms;
 
   // Find RTP timestamp by going through |pending_timestamps_|. Derive it from
   // capture time otherwise.
   base::Optional<uint32_t> rtp_timestamp;
-  if (!timestamp.is_zero() && !failed_timestamp_match_) {
+  if (!failed_timestamp_match_) {
     // Pop timestamps until we have a match.
     while (!pending_timestamps_.empty()) {
       const auto& front_timestamps = pending_timestamps_.front();
       if (front_timestamps.media_timestamp_ == timestamp) {
         rtp_timestamp = front_timestamps.rtp_timestamp;
         pending_timestamps_.pop_front();
         break;
       }
       pending_timestamps_.pop_front();
     }
@@ skipping 419 matching lines @@
   UMA_HISTOGRAM_BOOLEAN("Media.RTCVideoEncoderInitEncodeSuccess",
                         init_retval == WEBRTC_VIDEO_CODEC_OK);
   if (init_retval == WEBRTC_VIDEO_CODEC_OK) {
     UMA_HISTOGRAM_ENUMERATION("Media.RTCVideoEncoderProfile",
                               profile,
                               media::VIDEO_CODEC_PROFILE_MAX + 1);
   }
 }
 
 }  // namespace content