Subrect snapshot support.

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 255 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::Rect& src_rect,
                                       const gfx::Size& dst_size,
                                       bool vertically_flip_texture);
 
  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).
@@ skipping 288 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::Rect& src_rect,
     const gfx::Size& dst_size,
     bool vertically_flip_texture) {
   return ScaleTexture(src_texture,
                       src_size,
-                      gfx::Rect(src_size),
+                      src_rect,
                       dst_size,
                       vertically_flip_texture);
 }
 
 void GLHelper::CopyTextureToImpl::ReadBackFramebuffer(
     scoped_refptr<Request> request,
     WebGraphicsContext3D* context,
     scoped_refptr<base::TaskRunner> reply_loop) {
   DCHECK(context);
   if (!context->makeContextCurrent() || context->isContextLost()) {
@@ skipping 147 matching lines @@
   copy_texture_to_impl_->ReadbackTextureSync(texture,
                                              size,
                                              out);
 }
 
 WebKit::WebGLId GLHelper::CopyTexture(WebKit::WebGLId texture,
                                       const gfx::Size& size) {
   InitCopyTextToImpl();
   return copy_texture_to_impl_->CopyAndScaleTexture(texture,
                                                     size,
+                                                    gfx::Rect(size),
                                                     size,
                                                     false);
 }
 
 WebKit::WebGLId GLHelper::CopyAndScaleTexture(WebKit::WebGLId texture,
                                               const gfx::Size& src_size,
+                                              const gfx::Rect& src_rect,
                                               const gfx::Size& dst_size,
                                               bool vertically_flip_texture) {
   InitCopyTextToImpl();
   return copy_texture_to_impl_->CopyAndScaleTexture(texture,
                                                     src_size,
+                                                    src_rect,
                                                     dst_size,
                                                     vertically_flip_texture);
 }
 
 WebGLId GLHelper::CompileShaderFromSource(
     const WebKit::WGC3Dchar* source,
     WebKit::WGC3Denum type) {
   ScopedShader shader(context_, context_->createShader(type));
   context_->shaderSource(shader, source);
   context_->compileShader(shader);
@@ skipping 35 matching lines @@
       context_->copyTexSubImage2D(GL_TEXTURE_2D, 0,
                                   rect.x(), rect.y(),
                                   rect.x(), rect.y(),
                                   rect.width(), rect.height());
     }
     context_->flush();
   }
 }
 
 }  // namespace content