Implement TextureImageTransportSurface using texture mailbox

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 "base/bind.h"
 #include "base/lazy_instance.h"
@@ skipping 253 matching lines @@
       const gfx::Size& dst_size,
       unsigned char* out,
       const base::Callback<void(bool)>& callback);
 
   void ReadbackTextureSync(WebGLId texture,
                            const gfx::Size& size,
                            unsigned char* out);
 
   WebKit::WebGLId CopyAndScaleTexture(WebGLId texture,
                                       const gfx::Size& src_size,
-                                      const gfx::Size& dst_size);
+                                      const gfx::Size& dst_size,
+                                      WebKit::WebGLId texture_out = 0);
 
  private:
   // A single request to CropScaleReadbackAndCleanTexture.
   // Thread-safety notes: the main thread creates instances of this class. The
   // main thread can cancel the request, before it's handled by the helper
   // thread, by resetting the texture and pixels fields. Alternatively, the
   // thread marks that it handles the request by resetting the pixels field
   // (meaning it guarantees that the callback with be called).
   // In either case, the callback must be called exactly once, and the texture
   // must be deleted by the main thread context.
@@ skipping 25 matching lines @@
     friend class base::RefCountedThreadSafe<Request>;
     ~Request() {}
   };
 
   // Copies the block of pixels specified with |src_subrect| from |src_texture|,
   // scales it to |dst_size|, writes it into a texture, and returns its ID.
   // |src_size| is the size of |src_texture|.
   WebGLId ScaleTexture(WebGLId src_texture,
                        const gfx::Size& src_size,
                        const gfx::Rect& src_subrect,
-                       const gfx::Size& dst_size);
+                       const gfx::Size& dst_size,
+                       WebKit::WebGLId texture_out);
 
   // Deletes the context for GLHelperThread.
   void DeleteContextForThread();
   static void ReadBackFramebuffer(scoped_refptr<Request> request,
                                   WebGraphicsContext3D* context,
                                   scoped_refptr<base::TaskRunner> reply_loop);
   static void ReadBackFramebufferComplete(scoped_refptr<Request> request,
                                           bool result);
   void FinishRequest(scoped_refptr<Request> request);
   void CancelRequests();
@@ skipping 85 matching lines @@
   position_location_ = context_->getAttribLocation(program_, "a_position");
   texcoord_location_ = context_->getAttribLocation(program_, "a_texcoord");
   texture_location_ = context_->getUniformLocation(program_, "s_texture");
   src_subrect_location_ = context_->getUniformLocation(program_, "src_subrect");
 }
 
 WebGLId GLHelper::CopyTextureToImpl::ScaleTexture(
     WebGLId src_texture,
     const gfx::Size& src_size,
     const gfx::Rect& src_subrect,
-    const gfx::Size& dst_size) {
-  WebGLId dst_texture = context_->createTexture();
+    const gfx::Size& dst_size,
+    WebKit::WebGLId texture_out) {
+  WebGLId dst_texture = texture_out ? texture_out : context_->createTexture();
   {
     ScopedFramebuffer dst_framebuffer(context_, context_->createFramebuffer());
     ScopedFramebufferBinder<GL_FRAMEBUFFER> framebuffer_binder(
         context_, dst_framebuffer);
     {
       ScopedTextureBinder<GL_TEXTURE_2D> texture_binder(
           context_, dst_texture);
       context_->texImage2D(GL_TEXTURE_2D,
                            0,
                            GL_RGBA,
@@ skipping 68 matching lines @@
     const gfx::Size& src_size,
     const gfx::Rect& src_subrect,
     const gfx::Size& dst_size,
     unsigned char* out,
     const base::Callback<void(bool)>& callback) {
   if (!context_for_thread_) {
     callback.Run(false);
     return;
   }
 
-  WebGLId texture = ScaleTexture(src_texture, src_size, src_subrect, dst_size);
+  WebGLId texture = ScaleTexture(src_texture, src_size, src_subrect, dst_size, 0);
   context_->flush();
   scoped_refptr<Request> request =
       new Request(this, texture, dst_size, out, callback);
   request_queue_.push(request);
 
   g_gl_helper_thread.Pointer()->message_loop_proxy()->PostTask(FROM_HERE,
       base::Bind(&ReadBackFramebuffer,
                  request,
                  context_for_thread_,
                  base::MessageLoopProxy::current()));
@@ skipping 16 matching lines @@
                        size.width(),
                        size.height(),
                        GL_RGBA,
                        GL_UNSIGNED_BYTE,
                        out);
 }
 
 WebKit::WebGLId GLHelper::CopyTextureToImpl::CopyAndScaleTexture(
     WebGLId src_texture,
     const gfx::Size& src_size,
-    const gfx::Size& dst_size) {
-  return ScaleTexture(src_texture, src_size, gfx::Rect(src_size), dst_size);
+    const gfx::Size& dst_size,
+    WebKit::WebGLId texture_out) {
+  return ScaleTexture(src_texture, src_size, gfx::Rect(src_size), dst_size,
+                      texture_out);
 }
 
 void GLHelper::CopyTextureToImpl::ReadBackFramebuffer(
     scoped_refptr<Request> request,
     WebGraphicsContext3D* context,
     scoped_refptr<base::TaskRunner> reply_loop) {
   DCHECK(context);
   if (!context->makeContextCurrent() || context->isContextLost()) {
     base::AutoLock auto_lock(request->lock);
     if (request->pixels) {
@@ skipping 141 matching lines @@
 void GLHelper::ReadbackTextureSync(WebKit::WebGLId texture,
                                    const gfx::Size& size,
                                    unsigned char* out) {
   InitCopyTextToImpl();
   copy_texture_to_impl_->ReadbackTextureSync(texture,
                                              size,
                                              out);
 }
 
 WebKit::WebGLId GLHelper::CopyTexture(WebKit::WebGLId texture,
-                                      const gfx::Size& size) {
+                                      const gfx::Size& size,
+                                      WebKit::WebGLId texture_out) {
   InitCopyTextToImpl();
-  return copy_texture_to_impl_->CopyAndScaleTexture(texture, size, size);
+  return copy_texture_to_impl_->CopyAndScaleTexture(texture, size, size,
+                                                    texture_out);
 }
 
 WebKit::WebGLId GLHelper::CopyAndScaleTexture(WebKit::WebGLId texture,
                                               const gfx::Size& src_size,
-                                              const gfx::Size& dst_size) {
+                                              const gfx::Size& dst_size,
+                                              WebKit::WebGLId texture_out) {
   InitCopyTextToImpl();
   return copy_texture_to_impl_->CopyAndScaleTexture(texture,
                                                     src_size,
-                                                    dst_size);
+                                                    dst_size,
+                                                    texture_out);
 }
 
 WebGLId GLHelper::CompileShaderFromSource(
     const WebKit::WGC3Dchar* source,
     WebKit::WGC3Denum type) {
   ScopedShader shader(context_, context_->createShader(type));
   context_->shaderSource(shader, source);
   context_->compileShader(shader);
   WebKit::WGC3Dint compile_status = 0;
   context_->getShaderiv(shader, GL_COMPILE_STATUS, &compile_status);
   if (!compile_status) {
     LOG(ERROR) << std::string(context_->getShaderInfoLog(shader).utf8());
     return 0;
   }
   return shader.Detach();
 }
 
 void GLHelper::InitCopyTextToImpl() {
   // Lazily initialize |copy_texture_to_impl_|
   if (!copy_texture_to_impl_.get())
     copy_texture_to_impl_.reset(new CopyTextureToImpl(context_,
                                                       context_for_thread_,
                                                       this));
 
 }
 
 }  // namespace content