Support copying a partial rectangle region from the compositing surface on Aura and GTK.

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"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop.h"
 #include "base/synchronization/lock.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebCString.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebString.h"
+#include "ui/gfx/rect.h"
 #include "ui/gfx/size.h"
 #include "ui/gl/gl_bindings.h"
 
 using WebKit::WebGLId;
 using WebKit::WebGraphicsContext3D;
 
 namespace {
 
 const char kGLHelperThreadName[] = "GLHelperThread";
 
@@ skipping 217 matching lines @@
   ~CopyTextureToImpl() {
     CancelRequests();
     DeleteContextForThread();
   }
 
   void InitBuffer();
   void InitProgram();
 
   void CopyTextureTo(WebGLId src_texture,
                      const gfx::Size& src_size,
+                     const gfx::Rect& src_subrect,
                      const gfx::Size& dst_size,
                      unsigned char* out,
                      const base::Callback<void(bool)>& callback);
  private:
   // A single request to CopyTextureTo.
   // 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).
@@ skipping 21 matching lines @@
     // Locks access to below members, which can be accessed on any thread.
     base::Lock lock;
     WebGLId texture;
     unsigned char* pixels;
 
    private:
     friend class base::RefCountedThreadSafe<Request>;
     ~Request() {}
   };
 
-  // Returns the id of a framebuffer that
+  // 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::Size& dst_size);
+                       const gfx::Size& src_size,
+                       const gfx::Rect& src_subrect,
+                       const gfx::Size& dst_size);
 
   // 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 16 matching lines @@
   ScopedProgram program_;
   // The buffer that holds the vertices and the texture coordinates data for
   // drawing a quad.
   ScopedBuffer vertex_attributes_buffer_;
   // The location of the position in the program.
   WebKit::WGC3Dint position_location_;
   // The location of the texture coordinate in the program.
   WebKit::WGC3Dint texcoord_location_;
   // The location of the source texture in the program.
   WebKit::WGC3Dint texture_location_;
+  // The location of the texture coordinate of the sub-rectangle in the program.
+  WebKit::WGC3Dint src_subrect_location_;
   std::queue<scoped_refptr<Request> > request_queue_;
 };
 
 const WebKit::WGC3Dfloat GLHelper::CopyTextureToImpl::kVertexAttributes[] = {
   -1.0f, -1.0f, 0.0f, 0.0f,
   1.0f, -1.0f, 1.0f, 0.0f,
   -1.0f, 1.0f, 0.0f, 1.0f,
   1.0f, 1.0f, 1.0f, 1.0f,
 };
 
 const WebKit::WGC3Dchar GLHelper::CopyTextureToImpl::kCopyVertexShader[] =
     "attribute vec2 a_position;"
     "attribute vec2 a_texcoord;"
     "varying vec2 v_texcoord;"
+    "uniform vec4 src_subrect;"
     "void main() {"
     "  gl_Position = vec4(a_position, 0.0, 1.0);"
-    "  v_texcoord = a_texcoord;"
+    "  v_texcoord = src_subrect.xy + a_texcoord * src_subrect.zw;"
     "}";
 
 const WebKit::WGC3Dchar GLHelper::CopyTextureToImpl::kCopyFragmentShader[] =
     "precision mediump float;"
     "varying vec2 v_texcoord;"
     "uniform sampler2D s_texture;"
     "void main() {"
     "  gl_FragColor = texture2D(s_texture, v_texcoord);"
     "}";
 
@@ skipping 21 matching lines @@
   WebKit::WGC3Dint link_status = 0;
   context_->getProgramiv(program_, GL_LINK_STATUS, &link_status);
   if (!link_status) {
     LOG(ERROR) << std::string(context_->getProgramInfoLog(program_).utf8());
     return;
   }
 
   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();
   {
     ScopedFramebuffer dst_framebuffer(context_, context_->createFramebuffer());
     ScopedFramebufferBinder<GL_DRAW_FRAMEBUFFER> framebuffer_binder(
         context_, dst_framebuffer);
     {
       ScopedTextureBinder<GL_TEXTURE_2D> texture_binder(
           context_, dst_texture);
       context_->texImage2D(GL_TEXTURE_2D,
@@ skipping 32 matching lines @@
     context_->vertexAttribPointer(texcoord_location_,
                                   2,
                                   GL_FLOAT,
                                   GL_FALSE,
                                   4 * sizeof(WebKit::WGC3Dfloat),
                                   offset);
     context_->enableVertexAttribArray(texcoord_location_);
 
     context_->uniform1i(texture_location_, 0);
 
+    // Convert |src_subrect| to texture coordinates.
+    GLfloat src_subrect_texcoord[] = {
+      static_cast<float>(src_subrect.x()) / src_size.width(),
+      static_cast<float>(src_subrect.y()) / src_size.height(),
+      static_cast<float>(src_subrect.width()) / src_size.width(),
+      static_cast<float>(src_subrect.height()) / src_size.height(),
+    };
+    context_->uniform4fv(src_subrect_location_, 1, src_subrect_texcoord);
+
     // Conduct texture mapping by drawing a quad composed of two triangles.
     context_->drawArrays(GL_TRIANGLE_STRIP, 0, 4);
   }
   return dst_texture;
 }
 
 void GLHelper::CopyTextureToImpl::DeleteContextForThread() {
   if (!context_for_thread_)
     return;
 
   g_gl_helper_thread.Pointer()->message_loop_proxy()->PostTask(
       FROM_HERE,
       base::Bind(&DeleteContext,
                  context_for_thread_));
   context_for_thread_ = NULL;
 }
 
 void GLHelper::CopyTextureToImpl::CopyTextureTo(
     WebGLId src_texture,
     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, dst_size);
+  WebGLId texture = ScaleTexture(src_texture, src_size, src_subrect, dst_size);
   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 127 matching lines @@
     event.Wait();
   }
 }
 
 WebGraphicsContext3D* GLHelper::context() const {
   return context_;
 }
 
 void GLHelper::CopyTextureTo(WebGLId src_texture,
                              const gfx::Size& src_size,
+                             const gfx::Rect& src_subrect,
                              const gfx::Size& dst_size,
                              unsigned char* out,
                              const base::Callback<void(bool)>& callback) {
   // Lazily initialize |copy_texture_to_impl_|
   if (!copy_texture_to_impl_.get())
     copy_texture_to_impl_.reset(new CopyTextureToImpl(context_,
                                                       context_for_thread_,
                                                       this));
 
   copy_texture_to_impl_->CopyTextureTo(src_texture,
                                        src_size,
+                                       src_subrect,
                                        dst_size,
                                        out,
                                        callback);
 }
 
 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();
 }
 
 }  // namespace content