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

media/blink/video_frame_compositor.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/blink/video_frame_compositor.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
+#include "base/metrics/histogram_macros.h"
 #include "base/time/default_tick_clock.h"
 #include "base/trace_event/auto_open_close_event.h"
 #include "base/trace_event/trace_event.h"
 #include "media/base/video_frame.h"
 
 namespace media {
 
 // Amount of time to wait between UpdateCurrentFrame() callbacks before starting
 // background rendering to keep the Render() callbacks moving.
 const int kBackgroundRenderingTimeoutMs = 250;
@@ skipping 162 matching lines @@
 base::TimeDelta VideoFrameCompositor::GetCurrentFrameTimestamp() const {
   // When the VFC is stopped, |callback_| is cleared; this synchronously
   // prevents CallRender() from invoking ProcessNewFrame(), and so
   // |current_frame_| won't change again until after Start(). (Assuming that
   // PaintSingleFrame() is not also called while stopped.)
   if (!current_frame_)
     return base::TimeDelta();
   return current_frame_->timestamp();
 }
 
+void VideoFrameCompositor::SetForegroundTime(base::TimeTicks when) {
+  DCHECK(compositor_task_runner_->BelongsToCurrentThread());
+  foreground_time_ = when;
+}
+
 bool VideoFrameCompositor::ProcessNewFrame(
     const scoped_refptr<VideoFrame>& frame,
     bool repaint_duplicate_frame) {
   DCHECK(compositor_task_runner_->BelongsToCurrentThread());
 
   if (frame && current_frame_ && !repaint_duplicate_frame &&
       frame->unique_id() == current_frame_->unique_id()) {
     return false;
   }
 
   // Set the flag indicating that the current frame is unrendered, if we get a
   // subsequent PutCurrentFrame() call it will mark it as rendered.
   rendered_last_frame_ = false;
 
   current_frame_ = frame;
+
+  if (!foreground_time_.is_null()) {
+    base::TimeDelta time_to_first_frame =
+        base::TimeTicks::Now() - foreground_time_;
+    UMA_HISTOGRAM_TIMES("Media.Video.TimeFromForegroundToFirstFrame",
+                        time_to_first_frame);
+    foreground_time_ = base::TimeTicks();
+  }
+
   return true;
 }
 
 void VideoFrameCompositor::BackgroundRender() {
   DCHECK(compositor_task_runner_->BelongsToCurrentThread());
   const base::TimeTicks now = tick_clock_->NowTicks();
   last_background_render_ = now;
   bool new_frame = CallRender(now, now + last_interval_, true);
   if (new_frame && client_)
     client_->DidReceiveFrame();
@@ skipping 34 matching lines @@
   last_interval_ = deadline_max - deadline_min;
 
   // Restart the background rendering timer whether we're background rendering
   // or not; in either case we should wait for |kBackgroundRenderingTimeoutMs|.
   if (background_rendering_enabled_)
     background_rendering_timer_.Reset();
   return new_frame || had_new_background_frame;
 }
 
 }  // namespace media