Support copying a partial rectangle region from the compositing surface on Mac.

content/browser/renderer_host/compositing_iosurface_mac.h

 // 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.
 
 #ifndef CONTENT_BROWSER_RENDERER_HOST_ACCELERATED_COMPOSITING_VIEW_MAC_H
 #define CONTENT_BROWSER_RENDERER_HOST_ACCELERATED_COMPOSITING_VIEW_MAC_H
 
 #import <Cocoa/Cocoa.h>
 #include <QuartzCore/QuartzCore.h>
 
 #include "base/mac/scoped_cftyperef.h"
 #include "base/memory/scoped_nsobject.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/gfx/size.h"
 
 class IOSurfaceSupport;
 
+namespace gfx {
+class Rect;
+}
+
 namespace content {
 
 // This class manages an OpenGL context and IOSurface for the accelerated
 // compositing code path. The GL context is attached to
 // RenderWidgetHostViewCocoa for blitting the IOSurface.
 class CompositingIOSurfaceMac {
  public:
   // Returns NULL if IOSurface support is missing or GL APIs fail.
   static CompositingIOSurfaceMac* Create();
   ~CompositingIOSurfaceMac();
 
   // Set IOSurface that will be drawn on the next NSView drawRect.
   void SetIOSurface(uint64 io_surface_handle);
 
   // Blit the IOSurface at the upper-left corner of the |view|. If |view| window
   // size is larger than the IOSurface, the remaining right and bottom edges
   // will be white. |scaleFactor| is 1 in normal views, 2 in HiDPI views.
   void DrawIOSurface(NSView* view, float scale_factor);
 
   // Copy the data of the "live" OpenGL texture referring to this IOSurfaceRef
-  // into |out|. The image data is transformed so that it fits in |dst_size|.
+  // into |out|. The copied region is specified with |src_pixel_subrect| and
+  // the data is transformed so that it fits in |dst_pixel_size|.
+  // |src_pixel_subrect| and |dst_pixel_size| are not in DIP but in pixel.
   // Caller must ensure that |out| is allocated with the size no less than
-  // |4 * dst_size.width() * dst_size.height()| bytes.
-  bool CopyTo(const gfx::Size& dst_size, void* out);
+  // |4 * dst_pixel_size.width() * dst_pixel_size.height()| bytes.
+  bool CopyTo(const gfx::Rect& src_pixel_subrect,
+              const gfx::Size& dst_pixel_size,
+              void* out);
 
   // Unref the IOSurface and delete the associated GL texture. If the GPU
   // process is no longer referencing it, this will delete the IOSurface.
   void UnrefIOSurface();
 
   // Call when globalFrameDidChange is received on the NSView.
   void GlobalFrameDidChange();
 
   // Disassociate the GL context with the NSView and unref the IOSurface. Do
   // this to switch to software drawing mode.
   void ClearDrawable();
 
   bool HasIOSurface() { return !!io_surface_.get(); }
 
   const gfx::Size& pixel_io_surface_size() const {
     return pixel_io_surface_size_;
   }
   // In cocoa view units / DIPs.
   const gfx::Size& io_surface_size() const { return io_surface_size_; }
 
   bool is_vsync_disabled() const { return is_vsync_disabled_; }
 
  private:
   // Vertex structure for use in glDraw calls.
   struct SurfaceVertex {
     SurfaceVertex() : x_(0.0f), y_(0.0f), tx_(0.0f), ty_(0.0f) { }
-    // Currently the texture coords are always the same as vertex coords.
     void set(float x, float y, float tx, float ty) {
       x_ = x;
       y_ = y;
       tx_ = tx;
       ty_ = ty;
     }
     void set_position(float x, float y) {
       x_ = x;
       y_ = y;
     }
+    void set_texcoord(float tx, float ty) {
+      tx_ = tx;
+      ty_ = ty;
+    }
     float x_;
     float y_;
     float tx_;
     float ty_;
   };
 
   // Counter-clockwise verts starting from upper-left corner (0, 0).
   struct SurfaceQuad {
     void set_size(gfx::Size vertex_size, gfx::Size texcoord_size) {
       // Texture coordinates are flipped vertically so they can be drawn on
       // a projection with a flipped y-axis (origin is top left).
       float vw = static_cast<float>(vertex_size.width());
       float vh = static_cast<float>(vertex_size.height());
       float tw = static_cast<float>(texcoord_size.width());
       float th = static_cast<float>(texcoord_size.height());
       verts_[0].set(0.0f, 0.0f, 0.0f, th);
       verts_[1].set(0.0f, vh, 0.0f, 0.0f);
       verts_[2].set(vw, vh, tw, 0.0f);
       verts_[3].set(vw, 0.0f, tw, th);
     }
     void set_rect(float x1, float y1, float x2, float y2) {
       verts_[0].set_position(x1, y1);
       verts_[1].set_position(x1, y2);
       verts_[2].set_position(x2, y2);
       verts_[3].set_position(x2, y1);
     }
+    void set_texcoord_rect(float tx1, float ty1, float tx2, float ty2) {
+      // Texture coordinates are flipped vertically so they can be drawn on
+      // a projection with a flipped y-axis (origin is top left).
+      verts_[0].set_texcoord(tx1, ty2);
+      verts_[1].set_texcoord(tx1, ty1);
+      verts_[2].set_texcoord(tx2, ty1);
+      verts_[3].set_texcoord(tx2, ty2);
+    }
     SurfaceVertex verts_[4];
   };
 
   CompositingIOSurfaceMac(IOSurfaceSupport* io_surface_support,
                           NSOpenGLContext* glContext,
                           CGLContextObj cglContext,
                           GLuint shader_program_blit_rgb,
                           GLint blit_rgb_sampler_location,
                           GLuint shader_program_white,
                           bool is_vsync_disabled);
@@ skipping 33 matching lines @@
   GLuint shader_program_white_;
 
   SurfaceQuad quad_;
 
   bool is_vsync_disabled_;
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_RENDERER_HOST_ACCELERATED_COMPOSITING_VIEW_MAC_H