Clean up compositor initialization/destruction.

content/common/gpu/client/gl_helper.cc

 // 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.
 
 #include "content/common/gpu/client/gl_helper.h"
 
 #include <queue>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 136 matching lines @@
   // Reads back bytes from the currently bound frame buffer.
   // Note that dst_size is specified in bytes, not pixels.
   void ReadbackAsync(
       const gfx::Size& dst_size,
       int32 bytes_per_row,     // generally dst_size.width() * 4
       int32 row_stride_bytes,  // generally dst_size.width() * 4
       unsigned char* out,
       const base::Callback<void(bool)>& callback);
 
   void ReadbackPlane(TextureFrameBufferPair* source,
-                     media::VideoFrame* target,
+                     const scoped_refptr<media::VideoFrame>& target,
                      int plane,
                      int size_shift,
                      const gfx::Rect& dst_subrect,
                      const base::Callback<void(bool)>& callback);
 
   WebKit::WebGLId CopyAndScaleTexture(WebGLId texture,
                                       const gfx::Size& src_size,
                                       const gfx::Size& dst_size,
                                       bool vertically_flip_texture,
                                       GLHelper::ScalerQuality quality);
@@ skipping 57 matching lines @@
                     GLHelper::ScalerQuality quality,
                     const gfx::Size& src_size,
                     const gfx::Rect& src_subrect,
                     const gfx::Size& dst_size,
                     const gfx::Rect& dst_subrect,
                     bool flip_vertically);
 
     virtual void ReadbackYUV(
         const gpu::Mailbox& mailbox,
         uint32 sync_point,
-        media::VideoFrame* target,
+        const scoped_refptr<media::VideoFrame>& target,
         const base::Callback<void(bool)>& callback) OVERRIDE;
 
     virtual ScalerInterface* scaler() OVERRIDE {
       return scaler_.scaler();
     }
 
    private:
     WebGraphicsContext3D* context_;
     CopyTextureToImpl* copy_impl_;
     gfx::Size dst_size_;
@@ skipping 17 matching lines @@
                     GLHelper::ScalerQuality quality,
                     const gfx::Size& src_size,
                     const gfx::Rect& src_subrect,
                     const gfx::Size& dst_size,
                     const gfx::Rect& dst_subrect,
                     bool flip_vertically);
 
     virtual void ReadbackYUV(
         const gpu::Mailbox& mailbox,
         uint32 sync_point,
-        media::VideoFrame* target,
+        const scoped_refptr<media::VideoFrame>& target,
         const base::Callback<void(bool)>& callback) OVERRIDE;
 
     virtual ScalerInterface* scaler() OVERRIDE {
       return scaler_.scaler();
     }
 
    private:
     WebGraphicsContext3D* context_;
     CopyTextureToImpl* copy_impl_;
     gfx::Size dst_size_;
@@ skipping 438 matching lines @@
                                     const gfx::Size& size) {
   content::ScopedTextureBinder<GL_TEXTURE_2D> texture_binder(context_, texture);
   context_->copyTexImage2D(GL_TEXTURE_2D, 0,
                            GL_RGB,
                            0, 0,
                            size.width(), size.height(), 0);
 }
 
 void GLHelper::CopyTextureToImpl::ReadbackPlane(
     TextureFrameBufferPair* source,
-    media::VideoFrame* target,
+    const scoped_refptr<media::VideoFrame>& target,
     int plane,
     int size_shift,
     const gfx::Rect& dst_subrect,
     const base::Callback<void(bool)>& callback) {
   context_->bindFramebuffer(GL_FRAMEBUFFER, source->framebuffer());
   size_t offset = target->stride(plane) * (dst_subrect.y() >> size_shift) +
       (dst_subrect.x() >> size_shift);
   ReadbackAsync(
       source->size(),
       dst_subrect.width() >> size_shift,
@@ skipping 63 matching lines @@
           false,
           kRGBtoVColorWeights)) {
   DCHECK(!(dst_size.width() & 1));
   DCHECK(!(dst_size.height() & 1));
   DCHECK(!(dst_subrect.width() & 1));
   DCHECK(!(dst_subrect.height() & 1));
   DCHECK(!(dst_subrect.x() & 1));
   DCHECK(!(dst_subrect.y() & 1));
 }
 
+static void CallbackKeepingVideoFrameAlive(
+    scoped_refptr<media::VideoFrame> video_frame,
+    const base::Callback<void(bool)>& callback,
+    bool success) {
+  callback.Run(success);
+}
 
 void GLHelper::CopyTextureToImpl::ReadbackYUVImpl::ReadbackYUV(
     const gpu::Mailbox& mailbox,
     uint32 sync_point,
-    media::VideoFrame *target,
+    const scoped_refptr<media::VideoFrame>& target,
     const base::Callback<void(bool)>& callback) {
   WebGLId mailbox_texture =
       copy_impl_->ConsumeMailboxToTexture(mailbox, sync_point);
 
   // Scale texture to right size.
   scaler_.Scale(mailbox_texture);
   context_->deleteTexture(mailbox_texture);
 
   // Convert the scaled texture in to Y, U and V planes.
   y_.Scale(scaler_.texture());
   u_.Scale(scaler_.texture());
   v_.Scale(scaler_.texture());
 
   if (target->coded_size() != dst_size_) {
     DCHECK(target->coded_size() == dst_size_);
     LOG(ERROR) << "ReadbackYUV size error!";
     callback.Run(false);
     return;
   }
 
-  // Read back planes, one at a time.
+  // Read back planes, one at a time. Keep the video frame alive while doing the
+  // readback.
   copy_impl_->ReadbackPlane(y_.texture_and_framebuffer(),
                             target,
                             media::VideoFrame::kYPlane,
                             0,
                             dst_subrect_,
                             base::Bind(&nullcallback));
   copy_impl_->ReadbackPlane(u_.texture_and_framebuffer(),
                             target,
                             media::VideoFrame::kUPlane,
                             1,
                             dst_subrect_,
                             base::Bind(&nullcallback));
   copy_impl_->ReadbackPlane(v_.texture_and_framebuffer(),
                             target,
                             media::VideoFrame::kVPlane,
                             1,
                             dst_subrect_,
-                            callback);
+                            base::Bind(&CallbackKeepingVideoFrameAlive,
+                                       target,
+                                       callback));
   context_->bindFramebuffer(GL_FRAMEBUFFER, 0);
   media::LetterboxYUV(target, dst_subrect_);
 }
 
 // YUV readback constructors. Initiates the main scaler pipeline and
 // one planar scaler for each of the Y, U and V planes.
 GLHelper::CopyTextureToImpl::ReadbackYUV_MRT::ReadbackYUV_MRT(
     WebGraphicsContext3D* context,
     CopyTextureToImpl* copy_impl,
     GLHelperScaling* scaler_impl,
@@ skipping 56 matching lines @@
   DCHECK(!(dst_size.height() & 1));
   DCHECK(!(dst_subrect.width() & 1));
   DCHECK(!(dst_subrect.height() & 1));
   DCHECK(!(dst_subrect.x() & 1));
   DCHECK(!(dst_subrect.y() & 1));
 }
 
 void GLHelper::CopyTextureToImpl::ReadbackYUV_MRT::ReadbackYUV(
     const gpu::Mailbox& mailbox,
     uint32 sync_point,
-    media::VideoFrame *target,
+    const scoped_refptr<media::VideoFrame>& target,
     const base::Callback<void(bool)>& callback) {
   WebGLId mailbox_texture =
       copy_impl_->ConsumeMailboxToTexture(mailbox, sync_point);
 
   // Scale texture to right size.
   scaler_.Scale(mailbox_texture);
   context_->deleteTexture(mailbox_texture);
 
   std::vector<WebKit::WebGLId> outputs(2);
   // Convert the scaled texture in to Y, U and V planes.
@@ skipping 22 matching lines @@
                             target,
                             media::VideoFrame::kUPlane,
                             1,
                             dst_subrect_,
                             base::Bind(&nullcallback));
   copy_impl_->ReadbackPlane(&v_,
                             target,
                             media::VideoFrame::kVPlane,
                             1,
                             dst_subrect_,
-                            callback);
+                            base::Bind(&CallbackKeepingVideoFrameAlive,
+                                       target,
+                                       callback));
   context_->bindFramebuffer(GL_FRAMEBUFFER, 0);
   media::LetterboxYUV(target, dst_subrect_);
 }
 
 ReadbackYUVInterface*
 GLHelper::CopyTextureToImpl::CreateReadbackPipelineYUV(
     GLHelper::ScalerQuality quality,
     const gfx::Size& src_size,
     const gfx::Rect& src_subrect,
     const gfx::Size& dst_size,
@@ skipping 39 matching lines @@
       quality,
       src_size,
       src_subrect,
       dst_size,
       dst_subrect,
       flip_vertically,
       use_mrt);
 }
 
 }  // namespace content