rendering_helper - Schedule RenderContent() based on VSync.

content/common/gpu/media/rendering_helper.h

 // Copyright (c) 2012 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 CONTENT_COMMON_GPU_MEDIA_RENDERING_HELPER_H_
 #define CONTENT_COMMON_GPU_MEDIA_RENDERING_HELPER_H_
 
 #include <map>
 #include <queue>
 #include <vector>
@@ skipping 111 matching lines @@
   // Sets alpha_solid to true if the alpha channel is entirely 0xff.
   void GetThumbnailsAsRGB(std::vector<unsigned char>* rgb,
                           bool* alpha_solid,
                           base::WaitableEvent* done);
 
  private:
   struct RenderedVideo {
     // The rect on the screen where the video will be rendered.
     gfx::Rect render_area;
 
-    // True if the last (and the only one) frame in pending_frames has
-    // been rendered. We keep the last remaining frame in pending_frames even
-    // after it has been rendered, so that we have something to display if the
-    // client is falling behind on providing us with new frames during
-    // timer-driven playback.
-    bool last_frame_rendered;
-
     // True if there won't be any new video frames comming.
     bool is_flushing;
 
-    // The number of frames need to be dropped to catch up the rendering.
+    // The number of frames need to be dropped to catch up the rendering. We
+    // always keep the last remaining frame in pending_frames even after it
+    // has been rendered, so that we have something to display if the client
+    // is falling behind on providing us with new frames during timer-driven
+    // playback.
     int frames_to_drop;
 
     // The video frames pending for rendering.
     std::queue<scoped_refptr<VideoFrameTexture> > pending_frames;
 
     RenderedVideo();
     ~RenderedVideo();
   };
 
   void Clear();
 
   void RenderContent();
 
   void WarmUpRendering(int warm_up_iterations);
 
   void LayoutRenderingAreas(const std::vector<gfx::Size>& window_sizes);
 
+  void UpdateVSyncParameters(base::WaitableEvent* done,
+                             const base::TimeTicks timebase,
+                             const base::TimeDelta interval);
+
+  void DropOneFrameForAllVideos();
+  void ScheduleNextRenderContent();
+
   // Render |texture_id| to the current view port of the screen using target
   // |texture_target|.
   void RenderTexture(uint32 texture_target, uint32 texture_id);
 
   base::MessageLoop* message_loop_;
 
   scoped_refptr<gfx::GLContext> gl_context_;
   scoped_refptr<gfx::GLSurface> gl_surface_;
 
   gfx::AcceleratedWidget window_;
 
   gfx::Size screen_size_;
 
   std::vector<RenderedVideo> videos_;
 
   bool render_as_thumbnails_;
   int frame_count_;
   GLuint thumbnails_fbo_id_;
   GLuint thumbnails_texture_id_;
   gfx::Size thumbnails_fbo_size_;
   gfx::Size thumbnail_size_;
   GLuint program_;
   base::TimeDelta frame_duration_;
   base::TimeTicks scheduled_render_time_;
   base::CancelableClosure render_task_;
+  base::TimeTicks vsync_timebase_;
+  base::TimeDelta vsync_interval_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderingHelper);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_COMMON_GPU_MEDIA_RENDERING_HELPER_H_