Added UMA metrics for MediaSourcePlayer and MediaCodecPlayer

media/base/android/media_codec_player.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_player.h"
 
 #include "base/barrier_closure.h"
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
@@ skipping 81 matching lines @@
   // Currently the unit tests wait for the MediaCodecPlayer destruction by
   // watching the demuxer, which is destroyed as one of the member variables.
   // Release the codecs here, before any member variable is destroyed to make
   // the unit tests happy.
 
   if (video_decoder_)
     video_decoder_->ReleaseDecoderResources();
   if (audio_decoder_)
     audio_decoder_->ReleaseDecoderResources();
 
+  media_stat_->StopAndReport(GetInterpolatedTime());
+
   if (drm_bridge_) {
     DCHECK(cdm_registration_id_);
     drm_bridge_->UnregisterPlayer(cdm_registration_id_);
   }
 }
 
 void MediaCodecPlayer::Initialize() {
   DVLOG(1) << __FUNCTION__;
   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
 
@@ skipping 688 matching lines @@
     default:
       // DVLOG(0) << __FUNCTION__ << " illegal state: " << AsString(state_);
       // NOTREACHED();
       // Ignore! There can be a race condition: audio posts OnStopDone,
       // then video posts, then first OnStopDone arrives at which point
       // both streams are already stopped, then second OnStopDone arrives. When
       // the second one arrives, the state us not kStateStopping any more.
       return;
   }
 
+  media_stat_->StopAndReport(GetInterpolatedTime());
+
   // DetachListener to UI thread
   ui_task_runner_->PostTask(FROM_HERE, detach_listener_cb_);
 
   if (AudioFinished() && VideoFinished())
     ui_task_runner_->PostTask(FROM_HERE, completion_cb_);
 }
 
 void MediaCodecPlayer::OnKeyRequired(DemuxerStream::Type type) {
   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
   DVLOG(1) << __FUNCTION__ << " " << type;
@@ skipping 24 matching lines @@
 void MediaCodecPlayer::OnStarvation(DemuxerStream::Type type) {
   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
   DVLOG(1) << __FUNCTION__ << " stream type:" << type;
 
   if (state_ != kStatePlaying)
     return;  // Ignore
 
   SetState(kStateStopping);
   RequestToStopDecoders();
   SetPendingStart(true);
+
+  media_stat_->AddStarvation();
 }
 
 void MediaCodecPlayer::OnTimeIntervalUpdate(DemuxerStream::Type type,
                                             base::TimeDelta now_playing,
                                             base::TimeDelta last_buffered,
                                             bool postpone) {
   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
 
   DVLOG(2) << __FUNCTION__ << ": stream type:" << type << " [" << now_playing
            << "," << last_buffered << "]" << (postpone ? " postpone" : "");
@@ skipping 376 matching lines @@
 MediaCodecPlayer::StartStatus MediaCodecPlayer::StartDecoders() {
   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
 
   if (!interpolator_.interpolating())
     interpolator_.StartInterpolating();
 
   base::TimeDelta current_time = GetInterpolatedTime();
 
   DVLOG(1) << __FUNCTION__ << " current_time:" << current_time;
 
+  // This methos needs to be called when decoder threads are not processing

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

s/methos/method

Also, I don't quite understand this comment. Could you please elaborate?

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

Changed to:
  At this point decoder threads are either not running at all or their
  message pumps are in the idel state after the preroll is done.

+  // frames.
+  media_stat_->Start(current_time);
+
   if (!AudioFinished()) {
     if (!audio_decoder_->Start(current_time))
       return kStartFailed;
 
     // Attach listener on UI thread
     ui_task_runner_->PostTask(FROM_HERE, attach_listener_cb_);
   }
 
   if (!VideoFinished()) {
     if (!video_decoder_->Start(current_time))
       return kStartFailed;
   }
 
   return kStartOk;
 }
 
 void MediaCodecPlayer::StopDecoders() {
   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
   DVLOG(1) << __FUNCTION__;
 
   video_decoder_->SyncStop();
   audio_decoder_->SyncStop();
+
+  media_stat_->StopAndReport(GetInterpolatedTime());
 }
 
 void MediaCodecPlayer::RequestToStopDecoders() {
   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
   DVLOG(1) << __FUNCTION__;
 
   bool do_audio = false;
   bool do_video = false;
 
   if (audio_decoder_->IsPrefetchingOrPlaying())
@@ skipping 37 matching lines @@
 
   if (audio_decoder_)
     audio_decoder_->ReleaseDecoderResources();
 
   if (video_decoder_)
     video_decoder_->ReleaseDecoderResources();
 
   // At this point decoder threads should not be running
   if (interpolator_.interpolating())
     interpolator_.StopInterpolating();
+
+  media_stat_->StopAndReport(GetInterpolatedTime());
 }
 
 void MediaCodecPlayer::CreateDecoders() {
   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
   DVLOG(1) << __FUNCTION__;
 
   internal_error_cb_ = base::Bind(&MediaCodecPlayer::OnError, media_weak_this_);
 
+  media_stat_.reset(new MediaStatistics());
+
   audio_decoder_.reset(new MediaCodecAudioDecoder(
       GetMediaTaskRunner(), base::Bind(&MediaCodecPlayer::RequestDemuxerData,
                                        media_weak_this_, DemuxerStream::AUDIO),
       base::Bind(&MediaCodecPlayer::OnStarvation, media_weak_this_,
                  DemuxerStream::AUDIO),
       base::Bind(&MediaCodecPlayer::OnDecoderDrained, media_weak_this_,
                  DemuxerStream::AUDIO),
       base::Bind(&MediaCodecPlayer::OnStopDone, media_weak_this_,
                  DemuxerStream::AUDIO),
       base::Bind(&MediaCodecPlayer::OnKeyRequired, media_weak_this_,
                  DemuxerStream::AUDIO),
       internal_error_cb_,
       base::Bind(&MediaCodecPlayer::OnTimeIntervalUpdate, media_weak_this_,
-                 DemuxerStream::AUDIO)));
+                 DemuxerStream::AUDIO),
+      &media_stat_->audio_frames()));
 
   video_decoder_.reset(new MediaCodecVideoDecoder(
       GetMediaTaskRunner(), base::Bind(&MediaCodecPlayer::RequestDemuxerData,
                                        media_weak_this_, DemuxerStream::VIDEO),
       base::Bind(&MediaCodecPlayer::OnStarvation, media_weak_this_,
                  DemuxerStream::VIDEO),
       base::Bind(&MediaCodecPlayer::OnDecoderDrained, media_weak_this_,
                  DemuxerStream::VIDEO),
       base::Bind(&MediaCodecPlayer::OnStopDone, media_weak_this_,
                  DemuxerStream::VIDEO),
       base::Bind(&MediaCodecPlayer::OnKeyRequired, media_weak_this_,
                  DemuxerStream::VIDEO),
       internal_error_cb_,
       base::Bind(&MediaCodecPlayer::OnTimeIntervalUpdate, media_weak_this_,
                  DemuxerStream::VIDEO),
       base::Bind(&MediaCodecPlayer::OnVideoResolutionChanged, media_weak_this_),
-      base::Bind(&MediaCodecPlayer::OnVideoCodecCreated, media_weak_this_)));
+      base::Bind(&MediaCodecPlayer::OnVideoCodecCreated, media_weak_this_),
+      &media_stat_->video_frames()));
 }
 
 bool MediaCodecPlayer::AudioFinished() const {
   return audio_decoder_->IsCompleted() || !audio_decoder_->HasStream();
 }
 
 bool MediaCodecPlayer::VideoFinished() const {
   return video_decoder_->IsCompleted() || !video_decoder_->HasStream();
 }
 
@@ skipping 22 matching lines @@
     RETURN_STRING(kStateWaitingForCrypto);
     RETURN_STRING(kStateWaitingForSeek);
     RETURN_STRING(kStateError);
   }
   return nullptr;  // crash early
 }
 
 #undef RETURN_STRING
 
 }  // namespace media