gpu: Extend CopyTextureCHROMIUM with support for copying part of source texture.

gpu/command_buffer/tests/gl_copy_texture_CHROMIUM_unittest.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.
 
 #ifndef GL_GLEXT_PROTOTYPES
 #define GL_GLEXT_PROTOTYPES
 #endif
 
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
@@ skipping 63 matching lines @@
                pixels);
 
   if (copy_type == TexImage) {
     glCopyTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], GL_RGBA,
                           GL_UNSIGNED_BYTE);
   } else {
     glBindTexture(GL_TEXTURE_2D, textures_[1]);
     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                  nullptr);
 
-    glCopySubTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 0, 0);
+    glCopySubTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 0, 0, 0,
+                             0, 1, 1);
   }
   EXPECT_TRUE(glGetError() == GL_NO_ERROR);
 
   // Check the FB is still bound.
   GLint value = 0;
   glGetIntegerv(GL_FRAMEBUFFER_BINDING, &value);
   GLuint fb_id = value;
   EXPECT_EQ(framebuffer_id_, fb_id);
 
   // Check that FB is complete.
@@ skipping 22 matching lines @@
   glTexStorage2DEXT(GL_TEXTURE_2D, 1, GL_RGBA8_OES, 1, 1);
   glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
                          textures_[1], 0);
   EXPECT_TRUE(glGetError() == GL_NO_ERROR);
 
   if (copy_type == TexImage) {
     glCopyTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], GL_RGBA,
                           GL_UNSIGNED_BYTE);
     EXPECT_TRUE(glGetError() == GL_INVALID_OPERATION);
   } else {
-    glCopySubTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 0, 0);
+    glCopySubTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 0, 0, 0,
+                             0, 1, 1);
     EXPECT_TRUE(glGetError() == GL_NO_ERROR);
 
     // Check the FB is still bound.
     GLint value = 0;
     glGetIntegerv(GL_FRAMEBUFFER_BINDING, &value);
     GLuint fb_id = value;
     EXPECT_EQ(framebuffer_id_, fb_id);
 
     // Check that FB is complete.
     EXPECT_EQ(static_cast<GLenum>(GL_FRAMEBUFFER_COMPLETE),
@@ skipping 21 matching lines @@
       if (copy_type == TexImage) {
         glCopyTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1],
                               dest_formats[dest_index], GL_UNSIGNED_BYTE);
       } else {
         glBindTexture(GL_TEXTURE_2D, textures_[1]);
         glTexImage2D(GL_TEXTURE_2D, 0, dest_formats[dest_index], 1, 1, 0,
                      dest_formats[dest_index], GL_UNSIGNED_BYTE, nullptr);
         EXPECT_TRUE(GL_NO_ERROR == glGetError());
 
         glCopySubTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 0,
-                                 0);
+                                 0, 0, 0, 1, 1);
       }
 
       EXPECT_TRUE(GL_NO_ERROR == glGetError()) << "src_index:" << src_index
                                                << " dest_index:" << dest_index;
     }
   }
 }
 
 TEST_P(GLCopyTextureCHROMIUMTest, InternalFormatNotSupported) {
   CopyType copy_type = GetParam();
   glBindTexture(GL_TEXTURE_2D, textures_[0]);
   glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                nullptr);
   EXPECT_TRUE(GL_NO_ERROR == glGetError());
 
   // Check unsupported format reports error.
   GLint unsupported_dest_formats[] = {GL_ALPHA, GL_LUMINANCE,
                                       GL_LUMINANCE_ALPHA};
   for (size_t dest_index = 0; dest_index < arraysize(unsupported_dest_formats);
        dest_index++) {
     if (copy_type == TexImage) {
       glCopyTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1],
                             unsupported_dest_formats[dest_index],
                             GL_UNSIGNED_BYTE);
     } else {
       glBindTexture(GL_TEXTURE_2D, textures_[1]);
       glTexImage2D(GL_TEXTURE_2D, 0, unsupported_dest_formats[dest_index], 1, 1,
                    0, unsupported_dest_formats[dest_index], GL_UNSIGNED_BYTE,
                    nullptr);
-      glCopySubTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 0, 0);
+      glCopySubTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 0, 0,
+                               0, 0, 1, 1);
     }
     EXPECT_TRUE(GL_INVALID_OPERATION == glGetError())
         << "dest_index:" << dest_index;
   }
 }
 
 // Test to ensure that the destination texture is redefined if the properties
 // are different.
 TEST_F(GLCopyTextureCHROMIUMTest, RedefineDestinationTexture) {
   uint8 pixels[4 * 4] = {255u, 0u, 0u, 255u, 255u, 0u, 0u, 255u,
@@ skipping 70 matching lines @@
 
   glPixelStorei(GL_UNPACK_FLIP_Y_CHROMIUM, GL_TRUE);
 
   if (copy_type == TexImage) {
     glCopyTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], GL_RGBA,
                           GL_UNSIGNED_BYTE);
   } else {
     glBindTexture(GL_TEXTURE_2D, textures_[1]);
     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                  nullptr);
-    glCopySubTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 0, 0);
+    glCopySubTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 0, 0, 0,
+                             0, 2, 2);
   }
   EXPECT_TRUE(GL_NO_ERROR == glGetError());
 
   uint8 copied_pixels[2][2][4] = {{{0}}};
   glReadPixels(0, 0, 2, 2, GL_RGBA, GL_UNSIGNED_BYTE, copied_pixels);
   for (int x = 0; x < 2; ++x) {
     for (int y = 0; y < 2; ++y) {
       EXPECT_EQ(pixels[1-y][x][0], copied_pixels[y][x][0]);
       EXPECT_EQ(pixels[1-y][x][1], copied_pixels[y][x][1]);
       EXPECT_EQ(pixels[1-y][x][2], copied_pixels[y][x][2]);
@@ skipping 15 matching lines @@
                pixels);
 
   glPixelStorei(GL_UNPACK_PREMULTIPLY_ALPHA_CHROMIUM, GL_TRUE);
   if (copy_type == TexImage) {
     glCopyTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], GL_RGBA,
                           GL_UNSIGNED_BYTE);
   } else {
     glBindTexture(GL_TEXTURE_2D, textures_[1]);
     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                  nullptr);
-    glCopySubTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 0, 0);
+    glCopySubTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 0, 0, 0,
+                             0, 1, 1);
   }
   EXPECT_TRUE(GL_NO_ERROR == glGetError());
 
   uint8 copied_pixels[1 * 4] = {0};
   glReadPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, copied_pixels);
   EXPECT_EQ(1u, copied_pixels[0]);
   EXPECT_EQ(1u, copied_pixels[1]);
   EXPECT_EQ(1u, copied_pixels[2]);
   EXPECT_EQ(128u, copied_pixels[3]);
 
@@ skipping 11 matching lines @@
                pixels);
 
   glPixelStorei(GL_UNPACK_UNPREMULTIPLY_ALPHA_CHROMIUM, GL_TRUE);
   if (copy_type == TexImage) {
     glCopyTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], GL_RGBA,
                           GL_UNSIGNED_BYTE);
   } else {
     glBindTexture(GL_TEXTURE_2D, textures_[1]);
     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                  nullptr);
-    glCopySubTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 0, 0);
+    glCopySubTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 0, 0, 0,
+                             0, 1, 1);
   }
   EXPECT_TRUE(GL_NO_ERROR == glGetError());
 
   uint8 copied_pixels[1 * 4] = {0};
   glReadPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, copied_pixels);
   EXPECT_EQ(32u, copied_pixels[0]);
   EXPECT_EQ(32u, copied_pixels[1]);
   EXPECT_EQ(32u, copied_pixels[2]);
   EXPECT_EQ(128u, copied_pixels[3]);
 
@@ skipping 19 matching lines @@
 
   glPixelStorei(GL_UNPACK_FLIP_Y_CHROMIUM, GL_TRUE);
   glPixelStorei(GL_UNPACK_PREMULTIPLY_ALPHA_CHROMIUM, GL_TRUE);
   if (copy_type == TexImage) {
     glCopyTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], GL_RGBA,
                           GL_UNSIGNED_BYTE);
   } else {
     glBindTexture(GL_TEXTURE_2D, textures_[1]);
     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                  nullptr);
-    glCopySubTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 0, 0);
+    glCopySubTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 0, 0, 0,
+                             0, 2, 2);
   }
   EXPECT_TRUE(GL_NO_ERROR == glGetError());
 
   uint8 copied_pixels[2][2][4] = {{{0}}};
   glReadPixels(0, 0, 2, 2, GL_RGBA, GL_UNSIGNED_BYTE, copied_pixels);
   for (int x = 0; x < 2; ++x) {
     for (int y = 0; y < 2; ++y) {
       EXPECT_EQ(pixels[1-y][x][0] / 2, copied_pixels[y][x][0]);
       EXPECT_EQ(pixels[1-y][x][1] / 2, copied_pixels[y][x][1]);
       EXPECT_EQ(pixels[1-y][x][2] / 2, copied_pixels[y][x][2]);
@@ skipping 23 matching lines @@
 
   glPixelStorei(GL_UNPACK_FLIP_Y_CHROMIUM, GL_TRUE);
   glPixelStorei(GL_UNPACK_UNPREMULTIPLY_ALPHA_CHROMIUM, GL_TRUE);
   if (copy_type == TexImage) {
     glCopyTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], GL_RGBA,
                           GL_UNSIGNED_BYTE);
   } else {
     glBindTexture(GL_TEXTURE_2D, textures_[1]);
     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                  nullptr);
-    glCopySubTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 0, 0);
+    glCopySubTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 0, 0, 0,
+                             0, 2, 2);
   }
   EXPECT_TRUE(GL_NO_ERROR == glGetError());
 
   uint8 copied_pixels[2][2][4] = {{{0}}};
   glReadPixels(0, 0, 2, 2, GL_RGBA, GL_UNSIGNED_BYTE, copied_pixels);
   for (int x = 0; x < 2; ++x) {
     for (int y = 0; y < 2; ++y) {
       EXPECT_EQ(pixels[1-y][x][0] * 2, copied_pixels[y][x][0]);
       EXPECT_EQ(pixels[1-y][x][1] * 2, copied_pixels[y][x][1]);
       EXPECT_EQ(pixels[1-y][x][2] * 2, copied_pixels[y][x][2]);
@@ skipping 43 matching lines @@
     glEnableDisable(GL_BLEND, setting);
     glColorMask(setting, setting, setting, setting);
     glDepthMask(setting);
 
     glActiveTexture(GL_TEXTURE1 + x);
 
     if (copy_type == TexImage) {
       glCopyTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], GL_RGBA,
                             GL_UNSIGNED_BYTE);
     } else {
-      glCopySubTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 0, 0);
+      glCopySubTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 0, 0,
+                               0, 0, 1, 1);
     }
     EXPECT_TRUE(GL_NO_ERROR == glGetError());
 
     EXPECT_EQ(setting, glIsEnabled(GL_DEPTH_TEST));
     EXPECT_EQ(setting, glIsEnabled(GL_SCISSOR_TEST));
     EXPECT_EQ(setting, glIsEnabled(GL_STENCIL_TEST));
     EXPECT_EQ(setting, glIsEnabled(GL_CULL_FACE));
     EXPECT_EQ(setting, glIsEnabled(GL_BLEND));
 
     GLboolean bool_array[4] = { GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE };
@@ skipping 37 matching lines @@
   glActiveTexture(GL_TEXTURE0);
   glBindTexture(GL_TEXTURE_2D, texture_ids[0]);
 
   glActiveTexture(GL_TEXTURE1);
   glBindTexture(GL_TEXTURE_2D, texture_ids[1]);
 
   if (copy_type == TexImage) {
     glCopyTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], GL_RGBA,
                           GL_UNSIGNED_BYTE);
   } else {
-    glCopySubTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 0, 0);
+    glCopySubTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 0, 0, 0,
+                             0, 1, 1);
   }
   EXPECT_TRUE(GL_NO_ERROR == glGetError());
 
   GLint active_texture = 0;
   glGetIntegerv(GL_ACTIVE_TEXTURE, &active_texture);
   EXPECT_EQ(GL_TEXTURE1, active_texture);
 
   GLint bound_texture = 0;
   glGetIntegerv(GL_TEXTURE_BINDING_2D, &bound_texture);
   EXPECT_EQ(texture_ids[1], static_cast<GLuint>(bound_texture));
@@ skipping 50 matching lines @@
   // Test that we can write to the bound framebuffer
   uint8 expected_color[4] = { 255u, 255u, 0, 255u };
   glClearColor(1.0, 1.0, 0, 1.0);
   glClear(GL_COLOR_BUFFER_BIT);
   GLTestHelper::CheckPixels(0, 0, 1, 1, 0, expected_color);
 
   if (copy_type == TexImage) {
     glCopyTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], GL_RGBA,
                           GL_UNSIGNED_BYTE);
   } else {
-    glCopySubTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 0, 0);
+    glCopySubTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 0, 0, 0,
+                             0, 1, 1);
   }
   EXPECT_TRUE(GL_NO_ERROR == glGetError());
 
   EXPECT_TRUE(glIsFramebuffer(framebuffer_id));
 
   // Ensure that reading from the framebuffer produces correct pixels.
   GLTestHelper::CheckPixels(0, 0, 1, 1, 0, expected_color);
 
   uint8 expected_color2[4] = { 255u, 0, 255u, 255u };
   glClearColor(1.0, 0, 1.0, 1.0);
@@ skipping 90 matching lines @@
   glBindTexture(GL_TEXTURE_2D, textures_[0]);
   glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                pixels);
   if (copy_type == TexImage) {
     glCopyTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], GL_RGBA,
                           GL_UNSIGNED_BYTE);
   } else {
     glBindTexture(GL_TEXTURE_2D, textures_[1]);
     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                  nullptr);
-    glCopySubTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 0, 0);
+    glCopySubTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 0, 0, 0,
+                             0, 1, 1);
   }
 
   // test using program after
   glClear(GL_COLOR_BUFFER_BIT);
   EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, 1, 1, 0, zero));
   glDrawArrays(GL_TRIANGLES, 0, 6);
   EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, 1, 1, 0, expected));
 
   EXPECT_TRUE(GL_NO_ERROR == glGetError());
 
@@ skipping 10 matching lines @@
   glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, kWidth, kHeight, 0, GL_RGBA,
                GL_UNSIGNED_BYTE, nullptr);
 
   if (copy_type == TexImage) {
     glCopyTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], GL_RGBA,
                           GL_UNSIGNED_BYTE);
   } else {
     glBindTexture(GL_TEXTURE_2D, textures_[1]);
     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, kWidth, kHeight, 0, GL_RGBA,
                  GL_UNSIGNED_BYTE, nullptr);
-    glCopySubTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 0, 0);
+    glCopySubTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 0, 0, 0,
+                             0, kWidth, kHeight);
   }
   EXPECT_TRUE(GL_NO_ERROR == glGetError());
 
   uint8 pixels[kHeight][kWidth][4] = {{{1}}};
   glReadPixels(0, 0, kWidth, kHeight, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
   for (int x = 0; x < kWidth; ++x) {
     for (int y = 0; y < kHeight; ++y) {
       EXPECT_EQ(0, pixels[y][x][0]);
       EXPECT_EQ(0, pixels[y][x][1]);
       EXPECT_EQ(0, pixels[y][x][2]);
       EXPECT_EQ(0, pixels[y][x][3]);
     }
   }
 
   EXPECT_TRUE(GL_NO_ERROR == glGetError());
 }
 
 TEST_F(GLCopyTextureCHROMIUMTest, CopySubTextureDimension) {
   glBindTexture(GL_TEXTURE_2D, textures_[0]);
   glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                nullptr);
 
   glBindTexture(GL_TEXTURE_2D, textures_[1]);
   glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 3, 3, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                nullptr);
 
-  glCopySubTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 1, 1);
+  glCopySubTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 1, 1, 0,
+                           0, 1, 1);
   EXPECT_TRUE(GL_NO_ERROR == glGetError());
 
   // xoffset < 0
-  glCopySubTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], -1, 1);
+  glCopySubTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], -1, 1, 0,
+                           0, 1, 1);
   EXPECT_TRUE(glGetError() == GL_INVALID_VALUE);
 
-  // xoffset + source_width > dest_width
-  glCopySubTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 2, 2);
+  // x < 0
+  glCopySubTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 1, 1, -1,
+                           0, 1, 1);
+  EXPECT_TRUE(glGetError() == GL_INVALID_VALUE);
+
+  // xoffset + width > dest_width
+  glCopySubTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 2, 2, 0,
+                           0, 2, 2);
+  EXPECT_TRUE(glGetError() == GL_INVALID_VALUE);
+
+  // x + width > source_width
+  glCopySubTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 0, 0, 1,
+                           1, 2, 2);
   EXPECT_TRUE(glGetError() == GL_INVALID_VALUE);
 }
 
 TEST_F(GLCopyTextureCHROMIUMTest, CopySubTextureOffset) {
-  uint8 red[1 * 4] = {255u, 0u, 0u, 255u};
+  uint8 rgba_pixels[4 * 4] = {255u,
+                              0u,
+                              0u,
+                              255u,
+                              0u,
+                              255u,
+                              0u,
+                              255u,
+                              0u,
+                              0u,
+                              255u,
+                              255u,
+                              0u,
+                              0u,
+                              0u,
+                              255u};
   glBindTexture(GL_TEXTURE_2D, textures_[0]);
-  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
-               red);
+  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE,
+               rgba_pixels);
 
-  uint8 transparent_pixel[4 * 4] = {
+  uint8 transparent_pixels[4 * 4] = {
       0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u};
   glBindTexture(GL_TEXTURE_2D, textures_[1]);
   glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE,
-               transparent_pixel);
+               transparent_pixels);
 
-  glCopySubTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 1, 1);
+  glCopySubTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 1, 1, 0,
+                           0, 1, 1);
+  EXPECT_TRUE(glGetError() == GL_NO_ERROR);
+  glCopySubTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 1, 0, 1,
+                           0, 1, 1);
+  EXPECT_TRUE(glGetError() == GL_NO_ERROR);
+  glCopySubTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 0, 1, 0,
+                           1, 1, 1);
   EXPECT_TRUE(glGetError() == GL_NO_ERROR);
 
   // Check the FB is still bound.
   GLint value = 0;
   glGetIntegerv(GL_FRAMEBUFFER_BINDING, &value);
   GLuint fb_id = value;
   EXPECT_EQ(framebuffer_id_, fb_id);
 
   // Check that FB is complete.
   EXPECT_EQ(static_cast<GLenum>(GL_FRAMEBUFFER_COMPLETE),
             glCheckFramebufferStatus(GL_FRAMEBUFFER));
 
   uint8 transparent[1 * 4] = {0u, 0u, 0u, 0u};
+  uint8 red[1 * 4] = {255u, 0u, 0u, 255u};
+  uint8 green[1 * 4] = {0u, 255u, 0u, 255u};
+  uint8 blue[1 * 4] = {0u, 0u, 255u, 255u};
   GLTestHelper::CheckPixels(0, 0, 1, 1, 0, transparent);
   GLTestHelper::CheckPixels(1, 1, 1, 1, 0, red);
+  GLTestHelper::CheckPixels(1, 0, 1, 1, 0, green);
+  GLTestHelper::CheckPixels(0, 1, 1, 1, 0, blue);
   EXPECT_TRUE(GL_NO_ERROR == glGetError());
 }
 
 }  // namespace gpu