[Media] Record time it takes to start rendering audio and video

media/renderers/renderer_impl.cc

 // Copyright 2014 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/renderers/renderer_impl.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
+#include "base/metrics/histogram_macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/audio_renderer.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/demuxer_stream_provider.h"
 #include "media/base/media_switches.h"
 #include "media/base/renderer_client.h"
 #include "media/base/time_source.h"
 #include "media/base/video_decoder_config.h"
@@ skipping 183 matching lines @@
   DVLOG(1) << __func__;
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   if (state_ != STATE_PLAYING) {
     DCHECK_EQ(state_, STATE_ERROR);
     return;
   }
 
   time_source_->SetMediaTime(time);
 
-  if (audio_renderer_)
+  if (audio_renderer_) {
+    audio_preroll_start_time_ = base::TimeTicks::Now();
     audio_renderer_->StartPlaying();
-  if (video_renderer_)
+  }
+  if (video_renderer_) {
+    video_preroll_start_time_ = base::TimeTicks::Now();
     video_renderer_->StartPlayingFrom(time);
+  }
 }
 
 void RendererImpl::RestartStreamPlayback(DemuxerStream* stream,
                                          bool enabled,
                                          base::TimeDelta time) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(stream);
   bool video = (stream->type() == DemuxerStream::VIDEO);
   DVLOG(1) << __func__ << (video ? " video" : " audio") << " stream=" << stream
            << " enabled=" << stream->enabled() << " time=" << time.InSecondsF();
@@ skipping 455 matching lines @@
 
   // Renderer underflowed.
   if (!was_waiting_for_enough_data && WaitingForEnoughData()) {
     PausePlayback();
     client_->OnBufferingStateChange(BUFFERING_HAVE_NOTHING);
     return;
   }
 
   // Renderer prerolled.
   if (was_waiting_for_enough_data && !WaitingForEnoughData()) {
+    if (type == DemuxerStream::AUDIO && !audio_preroll_start_time_.is_null()) {
+      UMA_HISTOGRAM_MEDIUM_TIMES(
+          "Media.Audio.PrerollTime",
+          base::TimeTicks::Now() - audio_preroll_start_time_);
+    } else if (type == DemuxerStream::VIDEO &&
+               !video_preroll_start_time_.is_null()) {
+      UMA_HISTOGRAM_MEDIUM_TIMES(
+          "Media.Video.PrerollTime",
+          base::TimeTicks::Now() - video_preroll_start_time_);
+      video_preroll_start_time_ = base::TimeTicks();
+    }
+
     StartPlayback();
     client_->OnBufferingStateChange(BUFFERING_HAVE_ENOUGH);
     return;
   }
 }
 
 bool RendererImpl::WaitingForEnoughData() const {
   DCHECK(task_runner_->BelongsToCurrentThread());
   if (state_ != STATE_PLAYING)
     return false;
@@ skipping 132 matching lines @@
   DCHECK(task_runner_->BelongsToCurrentThread());
   client_->OnVideoNaturalSizeChange(size);
 }
 
 void RendererImpl::OnVideoOpacityChange(bool opaque) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   client_->OnVideoOpacityChange(opaque);
 }
 
 }  // namespace media