Merged: Trigger MSE players UMA by user events only

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/bind_helpers.h"
 #include "base/lazy_instance.h"
@@ skipping 69 matching lines @@
   // Finish initializaton on Media thread
   GetMediaTaskRunner()->PostTask(
       FROM_HERE, base::Bind(&MediaCodecPlayer::Initialize, media_weak_this_));
 }
 
 MediaCodecPlayer::~MediaCodecPlayer()
 {
   DVLOG(1) << "MediaCodecPlayer::~MediaCodecPlayer";
   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
 
+  media_stat_->StopAndReport(GetInterpolatedTime());
+
   // 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 (cdm_) {
     DCHECK(cdm_registration_id_);
     static_cast<MediaDrmBridge*>(cdm_.get())
         ->UnregisterPlayer(cdm_registration_id_);
   }
 }
 
 void MediaCodecPlayer::Initialize() {
   DVLOG(1) << __FUNCTION__;
   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
@@ skipping 128 matching lines @@
       NOTREACHED();
       break;
   }
 }
 
 void MediaCodecPlayer::Pause(bool is_media_related_action) {
   RUN_ON_MEDIA_THREAD(Pause, is_media_related_action);
 
   DVLOG(1) << __FUNCTION__;
 
+  media_stat_->StopAndReport(GetInterpolatedTime());
+
   SetPendingStart(false);
 
   switch (state_) {
     case kStateWaitingForConfig:
     case kStateWaitingForPermission:
     case kStatePrefetching:
     case kStateWaitingForSurface:
     case kStateWaitingForKey:
     case kStateWaitingForMediaCrypto:
       SetState(kStatePaused);
@@ skipping 12 matching lines @@
       NOTREACHED();
       break;
   }
 }
 
 void MediaCodecPlayer::SeekTo(base::TimeDelta timestamp) {
   RUN_ON_MEDIA_THREAD(SeekTo, timestamp);
 
   DVLOG(1) << __FUNCTION__ << " " << timestamp;
 
+  media_stat_->StopAndReport(GetInterpolatedTime());
+
   switch (state_) {
     case kStatePaused:
       SetState(kStateWaitingForSeek);
       RequestDemuxerSeek(timestamp);
       break;
     case kStateWaitingForConfig:
     case kStateWaitingForPermission:
     case kStatePrefetching:
     case kStateWaitingForSurface:
     case kStateWaitingForKey:
@@ skipping 30 matching lines @@
   // track the active players. We should pass
   // MediaThrottler::OnDecodeRequestFinished() to this class in the ctor, but
   // also need a way for BrowserMediaPlayerManager to track active players.
   if (ui_task_runner_->BelongsToCurrentThread())
     on_decoder_resources_released_cb_.Run(player_id());
 
   RUN_ON_MEDIA_THREAD(Release);
 
   DVLOG(1) << __FUNCTION__;
 
+  media_stat_->StopAndReport(GetInterpolatedTime());
+
   // Stop decoding threads and delete MediaCodecs, but keep IPC between browser
   // and renderer processes going. Seek should work across and after Release().
 
   ReleaseDecoderResources();
 
   SetPendingStart(false);
 
   if (state_ != kStateWaitingForSeek)
     SetState(kStatePaused);
 
@@ skipping 473 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())
+  if (AudioFinished() && VideoFinished()) {
+    media_stat_->StopAndReport(GetInterpolatedTime());
     ui_task_runner_->PostTask(FROM_HERE, completion_cb_);
+  }
 }
 
 void MediaCodecPlayer::OnMissingKeyReported(DemuxerStream::Type type) {
   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
   DVLOG(1) << __FUNCTION__ << " " << type;
 
   // Request stop and restart to pick up the key.
   key_is_required_ = true;
 
   if (state_ == kStatePlaying) {
+    media_stat_->StopAndReport(GetInterpolatedTime());
+
     SetState(kStateStopping);
     RequestToStopDecoders();
     SetPendingStart(true);
   }
 }
 
 void MediaCodecPlayer::OnError() {
   DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread());
   DVLOG(1) << __FUNCTION__;
 
+  media_stat_->StopAndReport(GetInterpolatedTime());
+
   // kStateError blocks all events
   SetState(kStateError);
 
   ReleaseDecoderResources();
 
   ui_task_runner_->PostTask(FROM_HERE,
                             base::Bind(error_cb_, MEDIA_ERROR_DECODE));
 }
 
 void MediaCodecPlayer::OnStarvation(DemuxerStream::Type type) {
@@ skipping 366 matching lines @@
 
   if (!interpolator_.interpolating())
     interpolator_.StartInterpolating();
 
   base::TimeDelta current_time = GetInterpolatedTime();
 
   DVLOG(1) << __FUNCTION__ << " current_time:" << current_time;
 
   // At this point decoder threads are either not running at all or their
   // message pumps are in the idle state after the preroll is done.
-  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;
   }
 
+  media_stat_->Start(current_time);
+
   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());
 
@@ skipping 65 matching lines @@
     RETURN_STRING(kStateWaitingForMediaCrypto);
     RETURN_STRING(kStateWaitingForSeek);
     RETURN_STRING(kStateError);
   }
   return nullptr;  // crash early
 }
 
 #undef RETURN_STRING
 
 }  // namespace media