Added UMA metrics for MediaSourcePlayer and MediaCodecPlayer

media/base/android/audio_decoder_job.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 "media/base/android/audio_decoder_job.h"
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/threading/thread.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/timestamp_constants.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 {
 
 class AudioDecoderThread : public base::Thread {
  public:
   AudioDecoderThread() : base::Thread("MediaSource_AudioDecoderThread") {
     Start();
   }
 };
 
 // TODO(qinmin): Check if it is tolerable to use worker pool to handle all the
 // decoding tasks so that we don't need a global thread here.
 // http://crbug.com/245750
 base::LazyInstance<AudioDecoderThread>::Leaky
     g_audio_decoder_thread = LAZY_INSTANCE_INITIALIZER;
 
 AudioDecoderJob::AudioDecoderJob(
     const base::Closure& request_data_cb,
-    const base::Closure& on_demuxer_config_changed_cb)
+    const base::Closure& on_demuxer_config_changed_cb,
+    FrameStatistics* frame_statistics)
     : MediaDecoderJob(g_audio_decoder_thread.Pointer()->task_runner(),
                       request_data_cb,
-                      on_demuxer_config_changed_cb),
+                      on_demuxer_config_changed_cb,
+                      frame_statistics),
       audio_codec_(kUnknownAudioCodec),
       num_channels_(0),
       config_sampling_rate_(0),
       volume_(-1.0),
       bytes_per_frame_(0),
       output_sampling_rate_(0),
       frame_count_(0) {
 }
 
 AudioDecoderJob::~AudioDecoderJob() {}
@@ skipping 47 matching lines @@
     size_t offset,
     size_t size,
     bool render_output,
     base::TimeDelta current_presentation_timestamp,
     const ReleaseOutputCompletionCallback& callback) {
   render_output = render_output && (size != 0u);
   if (render_output) {
     int64 head_position = (static_cast<AudioCodecBridge*>(
         media_codec_bridge_.get()))->PlayOutputBuffer(
             output_buffer_index, size, offset);
+
+    base::TimeTicks current_time = base::TimeTicks::Now();
+
     size_t new_frames_count = size / bytes_per_frame_;
     frame_count_ += new_frames_count;
     audio_timestamp_helper_->AddFrames(new_frames_count);
     int64 frames_to_play = frame_count_ - head_position;
     DCHECK_GE(frames_to_play, 0);
+
+    const base::TimeDelta last_buffered =
+        audio_timestamp_helper_->GetTimestamp();
+
     current_presentation_timestamp =
-        audio_timestamp_helper_->GetTimestamp() -
+        last_buffered -
         audio_timestamp_helper_->GetFrameDuration(frames_to_play);
+
+    if (!next_frame_time_limit_.is_null() &&
+        next_frame_time_limit_ < current_time) {
+      frame_statistics_->IncrementLateFrameCount();
+    }
+
+    next_frame_time_limit_ =
+        current_time + (last_buffered - current_presentation_timestamp);
   } else {
     current_presentation_timestamp = kNoTimestamp();
   }
   media_codec_bridge_->ReleaseOutputBuffer(output_buffer_index, false);
 
   callback.Run(current_presentation_timestamp,
                audio_timestamp_helper_->GetTimestamp());
 }
 
 bool AudioDecoderJob::ComputeTimeToRender() const {
@@ skipping 45 matching lines @@
 void AudioDecoderJob::OnOutputFormatChanged() {
   DCHECK(media_codec_bridge_);
 
   int old_sampling_rate = output_sampling_rate_;
   output_sampling_rate_ = media_codec_bridge_->GetOutputSamplingRate();
   if (output_sampling_rate_ != old_sampling_rate)
     ResetTimestampHelper();
 }
 
 }  // namespace media