Added UMA metrics for MediaSourcePlayer and MediaCodecPlayer

media/base/android/media_codec_audio_decoder.cc

 // Copyright 2015 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 "media/base/android/media_codec_audio_decoder.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "media/base/android/media_codec_bridge.h"
+#include "media/base/android/media_statistics.h"
 #include "media/base/audio_timestamp_helper.h"
 #include "media/base/demuxer_stream.h"
 
 namespace {
 
 // Use 16bit PCM for audio output. Keep this value in sync with the output
 // format we passed to AudioTrack in MediaCodecBridge.
 const int kBytesPerAudioOutputSample = 2;
 }
 
 namespace media {
 
 MediaCodecAudioDecoder::MediaCodecAudioDecoder(
     const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner,
     const base::Closure& request_data_cb,
     const base::Closure& starvation_cb,
     const base::Closure& decoder_drained_cb,
     const base::Closure& stop_done_cb,
     const base::Closure& key_required_cb,
     const base::Closure& error_cb,
-    const SetTimeCallback& update_current_time_cb)
+    const SetTimeCallback& update_current_time_cb,
+    FrameStatistics* frame_statistics)
     : MediaCodecDecoder(media_task_runner,
                         request_data_cb,
                         starvation_cb,
                         decoder_drained_cb,
                         stop_done_cb,
                         key_required_cb,
                         error_cb,
-                        "AudioDecoder"),
+                        "AudioDecoder",
+                        frame_statistics),
       volume_(-1.0),
       bytes_per_frame_(0),
       output_sampling_rate_(0),
       frame_count_(0),
       update_current_time_cb_(update_current_time_cb) {
 }
 
 MediaCodecAudioDecoder::~MediaCodecAudioDecoder() {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
   DVLOG(1) << "AudioDecoder::~AudioDecoder()";
@@ skipping 149 matching lines @@
     AudioCodecBridge* audio_codec =
         static_cast<AudioCodecBridge*>(media_codec_bridge_.get());
 
     DCHECK(audio_codec);
 
     const bool postpone = (render_mode == kRenderAfterPreroll);
 
     int64 head_position =
         audio_codec->PlayOutputBuffer(buffer_index, size, offset, postpone);
 
+    base::TimeTicks current_time = base::TimeTicks::Now();
+
+    if (frame_statistics_)
+      frame_statistics_->AddFrame();

[xhwang, 2015/09/30 21:02:57]

When can frame_statistics_ be null? Is it only in unit tests? If so, can we fix
the test and always make sure frame_statistics_ is non-null?

[Tima Vaisburd, 2015/10/01 20:05:15]

Done.

+
     // Reset the base timestamp if we have not started playing.
     // SetBaseTimestamp() must be called before AddFrames() since it resets the
     // internal frame count.
     if (postpone && !frame_count_)
       SetBaseTimestamp(pts);
 
     size_t new_frames_count = size / bytes_per_frame_;
     frame_count_ += new_frames_count;
     audio_timestamp_helper_->AddFrames(new_frames_count);
 
@@ skipping 13 matching lines @@
                                    << " head_position:" << head_position;
 
       base::TimeDelta last_buffered = audio_timestamp_helper_->GetTimestamp();
       base::TimeDelta now_playing =
           last_buffered -
           audio_timestamp_helper_->GetFrameDuration(frames_to_play);
 
       DVLOG(2) << class_name() << "::" << __FUNCTION__ << " pts:" << pts
                << " will play: [" << now_playing << "," << last_buffered << "]";
 
+      // Statistics
+      if (frame_statistics_ && !next_frame_time_limit_.is_null() &&
+          next_frame_time_limit_ < current_time)
+        frame_statistics_->AddLateFrame(current_time - next_frame_time_limit_);
+
+      next_frame_time_limit_ = current_time + (last_buffered - now_playing);
+
       media_task_runner_->PostTask(
           FROM_HERE, base::Bind(update_current_time_cb_, now_playing,
                                 last_buffered, false));
     }
   }
 
   media_codec_bridge_->ReleaseOutputBuffer(buffer_index, false);
 
-  CheckLastFrame(eos_encountered, false);  // no delayed tasks
+  if (CheckLastFrame(eos_encountered, false)) {  // no delayed tasks
+    // This is the last frame
+    next_frame_time_limit_ = base::TimeTicks();
+  }
 }
 
 void MediaCodecAudioDecoder::SetVolumeInternal() {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   if (media_codec_bridge_) {
     static_cast<AudioCodecBridge*>(media_codec_bridge_.get())
         ->SetVolume(volume_);
   }
 }
 
 void MediaCodecAudioDecoder::ResetTimestampHelper() {
   // Media thread or Decoder thread
   // When this method is called on Media thread, decoder thread
   // should not be running.
 
   if (audio_timestamp_helper_)
     base_timestamp_ = audio_timestamp_helper_->GetTimestamp();
 
   audio_timestamp_helper_.reset(
       new AudioTimestampHelper(configs_.audio_sampling_rate));
 
   audio_timestamp_helper_->SetBaseTimestamp(base_timestamp_);
 }
 
 }  // namespace media