rendering_helper - Wait for rendering before resetting the decoder.

content/common/gpu/media/rendering_helper.cc

 // Copyright 2013 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.
 
 #include "content/common/gpu/media/rendering_helper.h"
 
 #include <algorithm>
 #include <numeric>
 #include <vector>
 
@@ skipping 370 matching lines @@
 
   // Need to flush the GL commands before we return the tnumbnail texture to
   // the decoder.
   glFlush();
   ++frame_count_;
 }
 
 void RenderingHelper::QueueVideoFrame(size_t window_id,
                                       scoped_refptr<VideoFrame> video_frame) {
   RenderedVideo* video = &videos_[window_id];
+  DCHECK(!video->is_flushing);
 
   // Pop the front if it has been rendered.
   if (video->last_frame_rendered) {
     DCHECK(!video->pending_frames.empty());
     video->pending_frames.pop_front();
     video->last_frame_rendered = false;
   }
 
   video->pending_frames.push_back(video_frame);
 }
@@ skipping 84 matching lines @@
     *rgb_ptr++ = *rgba_ptr++;
     *rgb_ptr++ = *rgba_ptr++;
     solid = solid && (*rgba_ptr == 0xff);
     rgba_ptr++;
   }
   *alpha_solid = solid;
 
   done->Signal();
 }
 
+void RenderingHelper::Flush(size_t window_id,
+                            const base::Closure& flush_done_cb) {
+  RenderedVideo* video = &videos_[window_id];
+  if (video->pending_frames.empty()) {
+    // The rendering has been completed.
+    flush_done_cb.Run();
+    return;
+  }
+  video->is_flushing = true;
+  video->flush_done_cb = flush_done_cb;
+}
+
 void RenderingHelper::RenderContent() {
   CHECK_EQ(base::MessageLoop::current(), message_loop_);
   glUniform1i(glGetUniformLocation(program_, "tex_flip"), 1);
 
   // To keep the frame before SwapBuffers()
   std::vector<scoped_refptr<VideoFrame> > frames_to_be_returned;
 
   if (render_as_thumbnails_) {
     // In render_as_thumbnails_ mode, we render the FBO content on the
     // screen instead of the decoded textures.
     GLSetViewPort(videos_[0].render_area);
     RenderTexture(GL_TEXTURE_2D, thumbnails_texture_id_);
   } else {
     for (size_t i = 0; i < videos_.size(); ++i) {
       RenderedVideo* video = &videos_[i];
       if (video->pending_frames.empty())
         continue;
       scoped_refptr<VideoFrame> frame = video->pending_frames.front();
       GLSetViewPort(video->render_area);
       RenderTexture(frame->texture_target(), frame->texture_id());
 
-      if (video->pending_frames.size() > 1) {
+      if (video->pending_frames.size() > 1 || video->is_flushing) {
         frames_to_be_returned.push_back(video->pending_frames.front());
         video->pending_frames.pop_front();
       } else {
         video->last_frame_rendered = true;
       }
+
+      if (video->is_flushing && video->pending_frames.empty() &&
+          !video->flush_done_cb.is_null())
+        base::ResetAndReturn(&video->flush_done_cb).Run();
     }
   }
 
   gl_surface_->SwapBuffers();
 }
 
 // Helper function for the LayoutRenderingAreas(). The |lengths| are the
 // heights(widths) of the rows(columns). It scales the elements in
 // |lengths| proportionally so that the sum of them equal to |total_length|.
 // It also outputs the coordinates of the rows(columns) to |offsets|.
@@ skipping 40 matching lines @@
     scale = std::min(1.0f, scale);
 
     size_t w = scale * size.width();
     size_t h = scale * size.height();
     size_t x = offset_x[i % cols] + (widths[i % cols] - w) / 2;
     size_t y = offset_y[i / cols] + (heights[i / cols] - h) / 2;
     videos_[i].render_area = gfx::Rect(x, y, w, h);
   }
 }
 }  // namespace content