rendering_helper - Wait for rendering before resetting the decoder.

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 <deque>
 #include <map>
 #include <vector>
@@ skipping 81 matching lines @@
   // Render thumbnail in the |texture_id| to the FBO buffer using target
   // |texture_target|.
   void RenderThumbnail(uint32 texture_target, uint32 texture_id);
 
   // Queues the VideoFrame for rendering.
   void QueueVideoFrame(size_t window_id, scoped_refptr<VideoFrame> video_frame);
 
   // Drops all the pending video frames of the specified window.
   void DropPendingFrames(size_t window_id);
 
+  // Flushes the pending frames and calls the given callback when it is done.
+  void Flush(size_t window_id, const base::Closure& flush_done_cb);

[Pawel Osciak, 2014/08/15 06:06:43]

You misunderstood me. I don't think we need flush_done_cb. You can just do flush
done check in ReturnPicture in the client. You need to keep a counter of
frames_at_render_ in the client for this and if it reaches 0 when in flushing in
ReturnPicture, we are done.

[Owen Lin, 2014/08/18 10:06:36]

Ah! I see. Thanks. We can save one CB.

+
   // Delete |texture_id|.
   void DeleteTexture(uint32 texture_id);
 
   // Get the platform specific handle to the OpenGL display.
   void* GetGLDisplay();
 
   // Get the platform specific handle to the OpenGL context.
   void* GetGLContext();
 
   // Get rendered thumbnails as RGB.
   // 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;
 
     // Ture if the last (and the only one) frame in pending_frames has
     // been rendered.
     bool last_frame_rendered;
 
+    // True if there won't be any new video frames comming.
+    bool is_flushing;
+
     // The video frames pending for rendering.
     std::deque<scoped_refptr<VideoFrame> > pending_frames;
 
-    RenderedVideo() : last_frame_rendered(false) {}
+    // Callback calls when all pending frames are rendered.
+    base::Closure flush_done_cb;
+
+    RenderedVideo() : last_frame_rendered(false), is_flushing(false) {}
   };
 
   void Clear();
 
   void RenderContent();
 
   void LayoutRenderingAreas(const std::vector<gfx::Size>& window_sizes);
 
   // Render |texture_id| to the current view port of the screen using target
   // |texture_target|.
@@ skipping 20 matching lines @@
   gfx::Size thumbnail_size_;
   GLuint program_;
   base::TimeDelta frame_duration_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderingHelper);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_COMMON_GPU_MEDIA_RENDERING_HELPER_H_