Added UMA metrics for MediaSourcePlayer and MediaCodecPlayer

media/base/android/media_source_player.cc

 // Copyright (c) 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/media_source_player.h"
 
 #include <limits>
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_string.h"
@@ skipping 29 matching lines @@
       doing_browser_seek_(false),
       pending_seek_(false),
       drm_bridge_(NULL),
       cdm_registration_id_(0),
       is_waiting_for_key_(false),
       key_added_while_decode_pending_(false),
       is_waiting_for_audio_decoder_(false),
       is_waiting_for_video_decoder_(false),
       prerolling_(true),
       weak_factory_(this) {
+  media_stat_.reset(new MediaStatistics());
+
   audio_decoder_job_.reset(new AudioDecoderJob(
       base::Bind(&DemuxerAndroid::RequestDemuxerData,
                  base::Unretained(demuxer_.get()),
                  DemuxerStream::AUDIO),
       base::Bind(&MediaSourcePlayer::OnDemuxerConfigsChanged,
-                 weak_factory_.GetWeakPtr())));
+                 weak_factory_.GetWeakPtr()),
+      &media_stat_->audio_frames()));
   video_decoder_job_.reset(new VideoDecoderJob(
       base::Bind(&DemuxerAndroid::RequestDemuxerData,
                  base::Unretained(demuxer_.get()),
                  DemuxerStream::VIDEO),
       base::Bind(request_media_resources_cb_, player_id),
       base::Bind(&MediaSourcePlayer::OnDemuxerConfigsChanged,
-                 weak_factory_.GetWeakPtr())));
+                 weak_factory_.GetWeakPtr()),
+      &media_stat_->video_frames()));
+
   demuxer_->Initialize(this);
   interpolator_.SetUpperBound(base::TimeDelta());
   weak_this_ = weak_factory_.GetWeakPtr();
 }
 
 MediaSourcePlayer::~MediaSourcePlayer() {
   Release();
   DCHECK_EQ(!drm_bridge_, !cdm_registration_id_);
   if (drm_bridge_) {
     drm_bridge_->UnregisterPlayer(cdm_registration_id_);
@@ skipping 387 matching lines @@
 
   bool is_clock_manager = is_audio || !HasAudio();
 
   if (is_clock_manager)
     decoder_starvation_callback_.Cancel();
 
   if (status == MEDIA_CODEC_ERROR) {
     DVLOG(1) << __FUNCTION__ << " : decode error";
     Release();
     manager()->OnError(player_id(), MEDIA_ERROR_DECODE);
+    media_stat_->StopAndReport(GetCurrentTime());
     return;
   }
 
   DCHECK(!IsEventPending(PREFETCH_DONE_EVENT_PENDING));
 
   // Let |SEEK_EVENT_PENDING| (the highest priority event outside of
   // |PREFETCH_DONE_EVENT_PENDING|) preempt output EOS detection here. Process
   // any other pending events only after handling EOS detection.
   if (IsEventPending(SEEK_EVENT_PENDING)) {
     ProcessPendingEvents();
+    media_stat_->StopAndReport(GetCurrentTime());
     return;
   }
 
   if ((status == MEDIA_CODEC_OK || status == MEDIA_CODEC_INPUT_END_OF_STREAM) &&
       is_clock_manager && current_presentation_timestamp != kNoTimestamp()) {
     UpdateTimestamps(current_presentation_timestamp,
                      max_presentation_timestamp);
   }
 
   if (status == MEDIA_CODEC_OUTPUT_END_OF_STREAM) {
     PlaybackCompleted(is_audio);
     if (is_clock_manager)
       interpolator_.StopInterpolating();
   }
 
   if (pending_event_ != NO_EVENT_PENDING) {
     ProcessPendingEvents();
+    media_stat_->StopAndReport(GetCurrentTime());
     return;
   }
 
-  if (status == MEDIA_CODEC_OUTPUT_END_OF_STREAM)
+  if (status == MEDIA_CODEC_OUTPUT_END_OF_STREAM) {
+    media_stat_->StopAndReport(GetCurrentTime());
     return;
+  }
 
   if (!playing_) {
     if (is_clock_manager)
       interpolator_.StopInterpolating();
 
+    media_stat_->StopAndReport(GetCurrentTime());
     return;
   }
 
   if (status == MEDIA_CODEC_NO_KEY) {
     if (key_added_while_decode_pending_) {
       DVLOG(2) << __FUNCTION__ << ": Key was added during decoding.";
       ResumePlaybackAfterKeyAdded();
     } else {
       is_waiting_for_key_ = true;
       manager()->OnWaitingForDecryptionKey(player_id());
     }
+    media_stat_->StopAndReport(GetCurrentTime());

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

Why should we StopAndReport() after ResumePlaybackAfterKeyAdded() on l.524?

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

Aha, this is the place that you explained to me!
Unfortunately in the current simple implementation we will wipe out the
statistics accumulated before this point by calling media_stat_->Start:
ResumePlaybackAfterkeyAdded() will call StartInternal which does prefetch and at
the end of prefetch we start collecting again.
This StopAndReport() gathers the prior portion.

     return;
   }
 
   // If |key_added_while_decode_pending_| is true and both audio and video
   // decoding succeeded, we should clear |key_added_while_decode_pending_| here.
   // But that would add more complexity into this function. If we don't clear it
   // here, the worst case would be we call ResumePlaybackAfterKeyAdded() when
   // we don't really have a new key. This should rarely happen and the
   // performance impact should be pretty small.
   // TODO(qinmin/xhwang): This class is complicated because we handle both audio
   // and video in one file. If we separate them, we should be able to remove a
   // lot of duplication.
 
   // If the status is MEDIA_CODEC_ABORT, stop decoding new data. The player is
   // in the middle of a seek or stop event and needs to wait for the IPCs to
   // come.
-  if (status == MEDIA_CODEC_ABORT)
+  if (status == MEDIA_CODEC_ABORT) {
+    media_stat_->StopAndReport(GetCurrentTime());
     return;
+  }
 
   if (prerolling_ && IsPrerollFinished(is_audio)) {
     if (IsPrerollFinished(!is_audio)) {
       prerolling_ = false;
       StartInternal();
     }
     return;
   }
 
   if (is_clock_manager) {
@@ skipping 101 matching lines @@
   return audio_decoder_job_->OutputEOSReached() || !HasAudio();
 }
 
 bool MediaSourcePlayer::VideoFinished() {
   return video_decoder_job_->OutputEOSReached() || !HasVideo();
 }
 
 void MediaSourcePlayer::OnDecoderStarved() {
   DVLOG(1) << __FUNCTION__;
 
+  media_stat_->AddStarvation();
+
   SetPendingEvent(PREFETCH_REQUEST_EVENT_PENDING);
   ProcessPendingEvents();
 }
 
 void MediaSourcePlayer::StartStarvationCallback(
     base::TimeDelta current_presentation_timestamp,
     base::TimeDelta max_presentation_timestamp) {
   // 20ms was chosen because it is the typical size of a compressed audio frame.
   // Anything smaller than this would likely cause unnecessary cycling in and
   // out of the prefetch state.
@@ skipping 46 matching lines @@
   }
 
   if (!playing_)
     return;
 
   start_time_ticks_ = base::TimeTicks::Now();
   start_presentation_timestamp_ = GetCurrentTime();
   if (!interpolator_.interpolating())
     interpolator_.StartInterpolating();
 
+  media_stat_->Start(start_presentation_timestamp_);
+
   if (!AudioFinished())
     DecodeMoreAudio();
 
   if (!VideoFinished())
     DecodeMoreVideo();
 }
 
 void MediaSourcePlayer::OnDemuxerConfigsChanged() {
   manager()->OnMediaMetadataChanged(
       player_id(), duration_, GetVideoWidth(), GetVideoHeight(), true);
@@ skipping 84 matching lines @@
   // support setMediaKeys(0) (see http://crbug.com/330324), or when we release
   // MediaDrm when the video is paused, or when the device goes to sleep (see
   // http://crbug.com/272421).
   audio_decoder_job_->SetDrmBridge(NULL);
   video_decoder_job_->SetDrmBridge(NULL);
   cdm_registration_id_ = 0;
   drm_bridge_ = NULL;
 }
 
 }  // namespace media