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

media/blink/video_frame_compositor.h

 // 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.
 
 #ifndef MEDIA_BLINK_VIDEO_FRAME_COMPOSITOR_H_
 #define MEDIA_BLINK_VIDEO_FRAME_COMPOSITOR_H_
 
 #include <utility>
 
 #include "base/callback.h"
@@ skipping 85 matching lines @@
   // does not receive a |client_|.  In this case, frame acquisition is driven by
   // the frequency of canvas or WebGL paints requested via JavaScript.
   scoped_refptr<VideoFrame> GetCurrentFrameAndUpdateIfStale();
 
   // Returns the timestamp of the current (possibly stale) frame, or
   // base::TimeDelta() if there is no current frame. This method may be called
   // from the media thread as long as the VFC is stopped. (Assuming that
   // PaintSingleFrame() is not also called while stopped.)
   base::TimeDelta GetCurrentFrameTimestamp() const;
 
+  // Called when the video becomes visible with the timestamp.

[DaleCurtis, 2017/01/05 22:38:43]

visible is a bit confusing in this context; instead you should write this in
terms of a background to foreground transition. Maybe something like
SetForegroundTime(). Per our typical lexicon Timestamp is only used for
TimeDelta's, so this should just be XXXTime().

[whywhat, 2017/01/05 23:15:44]

s/Timestamp/Time sgtm

Re: s/shown/foreground:
1) there's another "background" term used here w.r.t. the background thread
being used for rendering IIUC -- I already used |is_background_rendering_| in
some patchset here incorrectly because of the term reuse.
2) I hope in the future the term shown will suit these transitions better as
we'll reuse the media remoting work that detects when the media elements is in
the viewport and not (so visible/shown == tab is in foreground _and_ the element
is in the viewport)

Therefore I used Shown/Hidden to be consistent with OnHidden/OnShown in WMPI and
not to be confused with background render in VFC.

[DaleCurtis, 2017/01/05 23:21:46]

Background rendering and SetForegroundTime() would be fine, they are both
effectively triggered by the inverse of the other.

+  // Used to record the time it takes to process the first frame after that.
+  // Must be called on the compositor thread.
+  void SetShownTimestamp(base::TimeTicks when);
+
   void set_tick_clock_for_testing(std::unique_ptr<base::TickClock> tick_clock) {
     tick_clock_ = std::move(tick_clock);
   }
 
   void clear_current_frame_for_testing() { current_frame_ = nullptr; }
 
   // Enables or disables background rendering. If |enabled|, |timeout| is the
   // amount of time to wait after the last Render() call before starting the
   // background rendering mode.  Note, this can not disable the background
   // rendering call issues when a sink is started.
@@ skipping 34 matching lines @@
   base::Timer background_rendering_timer_;
 
   // These values are only set and read on the compositor thread.
   cc::VideoFrameProvider::Client* client_;
   bool rendering_;
   bool rendered_last_frame_;
   bool is_background_rendering_;
   bool new_background_frame_;
   base::TimeDelta last_interval_;
   base::TimeTicks last_background_render_;
+  base::TimeTicks last_shown_;
 
   // These values are set on the compositor thread, but also read on the media
   // thread when the VFC is stopped.
   scoped_refptr<VideoFrame> current_frame_;
 
   // These values are updated and read from the media and compositor threads.
   base::Lock callback_lock_;
   VideoRendererSink::RenderCallback* callback_;
 
   // AutoOpenCloseEvent for begin/end events.
   std::unique_ptr<base::trace_event::AutoOpenCloseEvent> auto_open_close_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoFrameCompositor);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BLINK_VIDEO_FRAME_COMPOSITOR_H_