[Video] Only start tracking foreground time if the video was resumed.

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"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
+#include "base/optional.h"
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/lock.h"
 #include "base/time/tick_clock.h"
 #include "base/timer/timer.h"
 #include "cc/layers/video_frame_provider.h"
 #include "media/base/video_renderer_sink.h"
 #include "media/blink/media_blink_export.h"
 #include "ui/gfx/geometry/size.h"
 
 namespace base {
@@ skipping 73 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 media player is brought to the foreground.
+  // Enumerates the ways background video could be optimized.
+  enum class BackgroundVideoOptimization { Paused, DisabledTrack };
+
+  // Called when the media player is brought to the foreground and was or could
+  // be optimized when in the background.
   // Used to record the time it takes to process the first frame after that.
   // Must be called on the compositor thread.
-  void SetForegroundTime(base::TimeTicks when);
+  void SetForegroundTime(base::TimeTicks when,
+                         BackgroundVideoOptimization optimization);
 
   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
@@ skipping 36 matching lines @@
 
   // 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 foreground_time_;
+  base::Optional<BackgroundVideoOptimization> background_video_optimization_;
 
   // 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_