Connect the new video rendering path to the compositor.

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 "base/callback.h"
 #include "base/memory/ref_counted.h"
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/lock.h"
+#include "base/time/tick_clock.h"
 #include "cc/layers/video_frame_provider.h"
 #include "media/base/media_export.h"
 #include "media/base/video_renderer_sink.h"
 #include "ui/gfx/geometry/size.h"
 
 namespace media {
 class VideoFrame;
 
 // VideoFrameCompositor acts as a bridge between the media and cc layers for
 // rendering video frames. I.e. a media::VideoRenderer will talk to this class
@@ skipping 62 matching lines @@
   scoped_refptr<VideoFrame> GetCurrentFrame() override;
   void PutCurrentFrame() override;
 
   // VideoRendererSink implementation. These methods must be called from the
   // same thread (typically the media thread).
   void Start(RenderCallback* callback) override;
   void Stop() override;
   void PaintFrameUsingOldRenderingPath(
       const scoped_refptr<VideoFrame>& frame) override;
 
+  void set_tick_clock_for_testing(scoped_ptr<base::TickClock> tick_clock) {
+    tick_clock_ = tick_clock.Pass();
+  }
+
+  base::TimeDelta get_stale_frame_threshold_for_testing() const {
+    return stale_frame_threshold_;
+  }
+
+  void clear_current_frame_for_testing() {
+    current_frame_ = nullptr;
+  }
+
  private:
   // Called on the compositor thread to start or stop rendering if rendering was
-  // previously started or stopped before we had a |callback_|.
-  void OnRendererStateUpdate();
+  // previously started or stopped before we had a |client_|. Will only call
+  // StopRendering() if |stop_if_not_rendering| is true.
+  void OnRendererStateUpdate(bool new_state);
 
   scoped_refptr<base::SingleThreadTaskRunner> compositor_task_runner_;
+  scoped_ptr<base::TickClock> tick_clock_;
 
   // These callbacks are executed on the compositor thread.
   base::Callback<void(gfx::Size)> natural_size_changed_cb_;
   base::Callback<void(bool)> opacity_changed_cb_;
 
   // These values are only set and read on the compositor thread.
   cc::VideoFrameProvider::Client* client_;
   scoped_refptr<VideoFrame> current_frame_;
+  base::TimeTicks last_frame_update_time_;
+  base::TimeDelta last_interval_;
+  base::TimeDelta stale_frame_threshold_;
+  bool rendering_;
 
   // These values are updated and read from the media and compositor threads.
   base::Lock lock_;
-  bool rendering_;
+  bool rendered_last_frame_;
   VideoRendererSink::RenderCallback* callback_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoFrameCompositor);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BLINK_VIDEO_FRAME_COMPOSITOR_H_