Modify Copy{Sub}TextureCHROMIUM entry point to add level argument

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 310 matching lines @@
     glBindTexture(target, textures_[1]);
     glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
     glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
     glTexParameteri(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
     EXPECT_TRUE(glGetError() == GL_NO_ERROR);
 
     // TODO(qiankun.miao@intel.com): Upgrade glCopyTextureCHROMIUM and
     // glCopySubTextureCHROMIUM to support copying from level > 0 of source
     // texture to level > 0 of dest texture.
     if (copy_type == TexImage) {
-      glCopyTextureCHROMIUM(textures_[0], textures_[1],
+      glCopyTextureCHROMIUM(textures_[0], 0, textures_[1], 0,
                             dest_format_type.internal_format,
                             dest_format_type.type, false, false, false);
     } else {
       glBindTexture(target, textures_[1]);
       glTexImage2D(target, dest_level, dest_format_type.internal_format, width_,
                    height_, 0, dest_format_type.format, dest_format_type.type,
                    nullptr);
 
-      glCopySubTextureCHROMIUM(textures_[0], textures_[1], 0, 0, 0, 0, width_,
-                               height_, false, false, false);
+      glCopySubTextureCHROMIUM(textures_[0], 0, textures_[1], 0, 0, 0, 0, 0,
+                               width_, height_, false, false, false);
     }
     EXPECT_TRUE(glGetError() == GL_NO_ERROR);
 
     // Draw destination texture to a fbo with a texture attachment in RGBA
     // format.
     GLuint texture = CreateDrawingTexture(target, width_, height_);
     GLuint framebuffer = CreateDrawingFBO(target, texture);
     EXPECT_EQ(static_cast<GLenum>(GL_FRAMEBUFFER_COMPLETE),
               glCheckFramebufferStatus(GL_FRAMEBUFFER));
     glViewport(0, 0, width_, height_);
@@ skipping 96 matching lines @@
 TEST_P(GLCopyTextureCHROMIUMTest, Basic) {
   CopyType copy_type = GetParam();
   uint8_t pixels[1 * 4] = {255u, 0u, 0u, 255u};
 
   CreateAndBindDestinationTextureAndFBO(GL_TEXTURE_2D);
   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(textures_[0], textures_[1], GL_RGBA,
+    glCopyTextureCHROMIUM(textures_[0], 0, textures_[1], 0, GL_RGBA,
                           GL_UNSIGNED_BYTE, false, false, false);
   } else {
     glBindTexture(GL_TEXTURE_2D, textures_[1]);
     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                  nullptr);
 
-    glCopySubTextureCHROMIUM(textures_[0], textures_[1], 0, 0, 0,
-                             0, 1, 1, false, false, false);
+    glCopySubTextureCHROMIUM(textures_[0], 0, textures_[1], 0, 0, 0, 0, 0, 1, 1,
+                             false, false, false);
   }
   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 111 matching lines @@
                       ExtractFormatFrom(src_internal_format), GL_UNSIGNED_BYTE,
                       pixels);
 
       glBindTexture(GL_TEXTURE_2D, textures_[1]);
       glTexStorage2DEXT(GL_TEXTURE_2D, 1, dest_internal_format, 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(textures_[0], textures_[1],
+        glCopyTextureCHROMIUM(textures_[0], 0, textures_[1], 0,
                               ExtractFormatFrom(dest_internal_format),
                               GL_UNSIGNED_BYTE, false, false, false);
         EXPECT_TRUE(glGetError() == GL_INVALID_OPERATION);
       } else {
-        glCopySubTextureCHROMIUM(textures_[0], textures_[1], 0, 0, 0, 0, 1, 1,
-                                 false, false, false);
+        glCopySubTextureCHROMIUM(textures_[0], 0, textures_[1], 0, 0, 0, 0, 0,
+                                 1, 1, false, false, false);
         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 17 matching lines @@
   for (size_t src_index = 0; src_index < arraysize(src_formats); src_index++) {
     for (size_t dest_index = 0; dest_index < arraysize(dest_formats);
          dest_index++) {
       CreateAndBindDestinationTextureAndFBO(GL_TEXTURE_2D);
       glBindTexture(GL_TEXTURE_2D, textures_[0]);
       glTexImage2D(GL_TEXTURE_2D, 0, src_formats[src_index], 1, 1, 0,
                    src_formats[src_index], GL_UNSIGNED_BYTE, nullptr);
       EXPECT_TRUE(GL_NO_ERROR == glGetError());
 
       if (copy_type == TexImage) {
-        glCopyTextureCHROMIUM(textures_[0], textures_[1],
-                              dest_formats[dest_index], GL_UNSIGNED_BYTE,
-                              false, false, false);
+        glCopyTextureCHROMIUM(textures_[0], 0, textures_[1], 0,
+                              dest_formats[dest_index], GL_UNSIGNED_BYTE, false,
+                              false, false);
       } 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(textures_[0], textures_[1], 0,
-                                 0, 0, 0, 1, 1, false, false, false);
+        glCopySubTextureCHROMIUM(textures_[0], 0, textures_[1], 0, 0, 0, 0, 0,
+                                 1, 1, false, false, false);
       }
 
       EXPECT_TRUE(GL_NO_ERROR == glGetError()) << "src_index:" << src_index
                                                << " dest_index:" << dest_index;
       glDeleteTextures(2, textures_);
       glDeleteFramebuffers(1, &framebuffer_id_);
     }
   }
 }
 
 TEST_P(GLCopyTextureCHROMIUMTest, InternalFormatNotSupported) {
   CopyType copy_type = GetParam();
   CreateAndBindDestinationTextureAndFBO(GL_TEXTURE_2D);
   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_RED, GL_RG};
   for (size_t dest_index = 0; dest_index < arraysize(unsupported_dest_formats);
        dest_index++) {
     if (copy_type == TexImage) {
-      glCopyTextureCHROMIUM(textures_[0], textures_[1],
+      glCopyTextureCHROMIUM(textures_[0], 0, textures_[1], 0,
                             unsupported_dest_formats[dest_index],
                             GL_UNSIGNED_BYTE, false, false, false);
     } 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(textures_[0], textures_[1], 0, 0,
-                               0, 0, 1, 1, false, false, false);
+      glCopySubTextureCHROMIUM(textures_[0], 0, textures_[1], 0, 0, 0, 0, 0, 1,
+                               1, false, false, false);
     }
     EXPECT_TRUE(GL_INVALID_OPERATION == glGetError())
         << "dest_index:" << dest_index;
   }
   glDeleteTextures(2, textures_);
   glDeleteFramebuffers(1, &framebuffer_id_);
 }
 
 TEST_F(GLCopyTextureCHROMIUMTest, InternalFormatTypeCombinationNotSupported) {
   CreateAndBindDestinationTextureAndFBO(GL_TEXTURE_2D);
   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 internal_format/type combination reports error.
   struct FormatType { GLenum format, type; };
   FormatType unsupported_format_types[] = {
     {GL_RGB, GL_UNSIGNED_SHORT_4_4_4_4},
     {GL_RGB, GL_UNSIGNED_SHORT_5_5_5_1},
     {GL_RGBA, GL_UNSIGNED_SHORT_5_6_5},
   };
   for (size_t dest_index = 0; dest_index < arraysize(unsupported_format_types);
        dest_index++) {
-    glCopyTextureCHROMIUM(
-        textures_[0], textures_[1], unsupported_format_types[dest_index].format,
-        unsupported_format_types[dest_index].type, false, false, false);
+    glCopyTextureCHROMIUM(textures_[0], 0, textures_[1], 0,
+                          unsupported_format_types[dest_index].format,
+                          unsupported_format_types[dest_index].type, false,
+                          false, false);
     EXPECT_TRUE(GL_INVALID_OPERATION == glGetError())
         << "dest_index:" << dest_index;
   }
   glDeleteTextures(2, textures_);
   glDeleteFramebuffers(1, &framebuffer_id_);
 }
 
 TEST_P(GLCopyTextureCHROMIUMTest, CopyTextureLevel) {
   CopyType copy_type = GetParam();
 
@@ skipping 66 matching lines @@
   glTexSubImage2D(
       GL_TEXTURE_2D, 0, 0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
   EXPECT_TRUE(GL_INVALID_OPERATION == glGetError());
   // GL_INVALID_VALUE due to bad dimensions.
   glTexSubImage2D(
       GL_TEXTURE_2D, 0, 1, 1, 1, 1, GL_BGRA_EXT, GL_UNSIGNED_BYTE, pixels);
   EXPECT_TRUE(GL_INVALID_VALUE == glGetError());
 
   // If the dest texture has different properties, glCopyTextureCHROMIUM()
   // redefines them.
-  glCopyTextureCHROMIUM(textures_[0], textures_[1], GL_RGBA,
+  glCopyTextureCHROMIUM(textures_[0], 0, textures_[1], 0, GL_RGBA,
                         GL_UNSIGNED_BYTE, false, false, false);
   EXPECT_TRUE(GL_NO_ERROR == glGetError());
 
   // glTexSubImage2D() succeeds because textures_[1] is redefined into 2x2
   // dimension and GL_RGBA format.
   glBindTexture(GL_TEXTURE_2D, textures_[1]);
   glTexSubImage2D(
       GL_TEXTURE_2D, 0, 1, 1, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
   EXPECT_TRUE(GL_NO_ERROR == glGetError());
 
@@ skipping 52 matching lines @@
     glEnableDisable(GL_SCISSOR_TEST, setting);
     glEnableDisable(GL_STENCIL_TEST, setting);
     glEnableDisable(GL_CULL_FACE, setting);
     glEnableDisable(GL_BLEND, setting);
     glColorMask(setting, setting, setting, setting);
     glDepthMask(setting);
 
     glActiveTexture(GL_TEXTURE1 + x);
 
     if (copy_type == TexImage) {
-      glCopyTextureCHROMIUM(textures_[0], textures_[1], GL_RGBA,
+      glCopyTextureCHROMIUM(textures_[0], 0, textures_[1], 0, GL_RGBA,
                             GL_UNSIGNED_BYTE, false, false, false);
     } else {
-      glCopySubTextureCHROMIUM(textures_[0], textures_[1], 0, 0,
-                               0, 0, 1, 1, false, false, false);
+      glCopySubTextureCHROMIUM(textures_[0], 0, textures_[1], 0, 0, 0, 0, 0, 1,
+                               1, false, false, false);
     }
     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 38 matching lines @@
   GLuint texture_ids[2];
   glGenTextures(2, texture_ids);
 
   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(textures_[0], textures_[1], GL_RGBA,
+    glCopyTextureCHROMIUM(textures_[0], 0, textures_[1], 0, GL_RGBA,
                           GL_UNSIGNED_BYTE, false, false, false);
   } else {
-    glCopySubTextureCHROMIUM(textures_[0], textures_[1], 0, 0, 0,
-                             0, 1, 1, false, false, false);
+    glCopySubTextureCHROMIUM(textures_[0], 0, textures_[1], 0, 0, 0, 0, 0, 1, 1,
+                             false, false, false);
   }
   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 @@
   EXPECT_TRUE(
       GL_FRAMEBUFFER_COMPLETE == glCheckFramebufferStatus(GL_FRAMEBUFFER));
 
   // Test that we can write to the bound framebuffer
   uint8_t 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, nullptr);
 
   if (copy_type == TexImage) {
-    glCopyTextureCHROMIUM(textures_[0], textures_[1], GL_RGBA,
+    glCopyTextureCHROMIUM(textures_[0], 0, textures_[1], 0, GL_RGBA,
                           GL_UNSIGNED_BYTE, false, false, false);
   } else {
-    glCopySubTextureCHROMIUM(textures_[0], textures_[1], 0, 0, 0,
-                             0, 1, 1, false, false, false);
+    glCopySubTextureCHROMIUM(textures_[0], 0, textures_[1], 0, 0, 0, 0, 0, 1, 1,
+                             false, false, false);
   }
   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, nullptr);
 
   uint8_t expected_color2[4] = {255u, 0, 255u, 255u};
   glClearColor(1.0, 0, 1.0, 1.0);
@@ skipping 90 matching lines @@
   EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, 1, 1, 0, zero, nullptr));
   glDrawArrays(GL_TRIANGLES, 0, 6);
   EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, 1, 1, 0, expected, nullptr));
 
   // Call copyTextureCHROMIUM
   uint8_t pixels[1 * 4] = {255u, 0u, 0u, 255u};
   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(textures_[0], textures_[1], GL_RGBA,
+    glCopyTextureCHROMIUM(textures_[0], 0, textures_[1], 0, GL_RGBA,
                           GL_UNSIGNED_BYTE, false, false, false);
   } else {
     glBindTexture(GL_TEXTURE_2D, textures_[1]);
     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                  nullptr);
-    glCopySubTextureCHROMIUM(textures_[0], textures_[1], 0, 0, 0,
-                             0, 1, 1, false, false, false);
+    glCopySubTextureCHROMIUM(textures_[0], 0, textures_[1], 0, 0, 0, 0, 0, 1, 1,
+                             false, false, false);
   }
 
   // test using program after
   glClear(GL_COLOR_BUFFER_BIT);
   EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, 1, 1, 0, zero, nullptr));
   glDrawArrays(GL_TRIANGLES, 0, 6);
   EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, 1, 1, 0, expected, nullptr));
 
   glDeleteTextures(2, textures_);
   glDeleteFramebuffers(1, &framebuffer_id_);
 
   EXPECT_TRUE(GL_NO_ERROR == glGetError());
 
   gl2.MakeCurrent();
   gl2.Destroy();
   gl_.MakeCurrent();
 }
 
 // Test that glCopyTextureCHROMIUM doesn't leak uninitialized textures.
 TEST_P(GLCopyTextureCHROMIUMTest, UninitializedSource) {
   CopyType copy_type = GetParam();
   const GLsizei kWidth = 64, kHeight = 64;
   CreateAndBindDestinationTextureAndFBO(GL_TEXTURE_2D);
   glBindTexture(GL_TEXTURE_2D, textures_[0]);
   glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, kWidth, kHeight, 0, GL_RGBA,
                GL_UNSIGNED_BYTE, nullptr);
 
   if (copy_type == TexImage) {
-    glCopyTextureCHROMIUM(textures_[0], textures_[1], GL_RGBA,
+    glCopyTextureCHROMIUM(textures_[0], 0, textures_[1], 0, GL_RGBA,
                           GL_UNSIGNED_BYTE, false, false, false);
   } else {
     glBindTexture(GL_TEXTURE_2D, textures_[1]);
     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, kWidth, kHeight, 0, GL_RGBA,
                  GL_UNSIGNED_BYTE, nullptr);
-    glCopySubTextureCHROMIUM(textures_[0], textures_[1], 0, 0, 0,
-                             0, kWidth, kHeight, false, false, false);
+    glCopySubTextureCHROMIUM(textures_[0], 0, textures_[1], 0, 0, 0, 0, 0,
+                             kWidth, kHeight, false, false, false);
   }
   EXPECT_TRUE(GL_NO_ERROR == glGetError());
 
   uint8_t 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]);
@@ skipping 10 matching lines @@
 TEST_F(GLCopyTextureCHROMIUMTest, CopySubTextureDimension) {
   CreateAndBindDestinationTextureAndFBO(GL_TEXTURE_2D);
   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(textures_[0], textures_[1], 1, 1, 0,
-                           0, 1, 1, false, false, false);
+  glCopySubTextureCHROMIUM(textures_[0], 0, textures_[1], 0, 1, 1, 0, 0, 1, 1,
+                           false, false, false);
   EXPECT_TRUE(GL_NO_ERROR == glGetError());
 
   // xoffset < 0
-  glCopySubTextureCHROMIUM(textures_[0], textures_[1], -1, 1, 0,
-                           0, 1, 1, false, false, false);
+  glCopySubTextureCHROMIUM(textures_[0], 0, textures_[1], 0, -1, 1, 0, 0, 1, 1,
+                           false, false, false);
   EXPECT_TRUE(glGetError() == GL_INVALID_VALUE);
 
   // x < 0
-  glCopySubTextureCHROMIUM(textures_[0], textures_[1], 1, 1, -1,
-                           0, 1, 1, false, false, false);
+  glCopySubTextureCHROMIUM(textures_[0], 0, textures_[1], 0, 1, 1, -1, 0, 1, 1,
+                           false, false, false);
   EXPECT_TRUE(glGetError() == GL_INVALID_VALUE);
 
   // xoffset + width > dest_width
-  glCopySubTextureCHROMIUM(textures_[0], textures_[1], 2, 2, 0,
-                           0, 2, 2, false, false, false);
+  glCopySubTextureCHROMIUM(textures_[0], 0, textures_[1], 0, 2, 2, 0, 0, 2, 2,
+                           false, false, false);
   EXPECT_TRUE(glGetError() == GL_INVALID_VALUE);
 
   // x + width > source_width
-  glCopySubTextureCHROMIUM(textures_[0], textures_[1], 0, 0, 1,
-                           1, 2, 2, false, false, false);
+  glCopySubTextureCHROMIUM(textures_[0], 0, textures_[1], 0, 0, 0, 1, 1, 2, 2,
+                           false, false, false);
   EXPECT_TRUE(glGetError() == GL_INVALID_VALUE);
 
   glDeleteTextures(2, textures_);
   glDeleteFramebuffers(1, &framebuffer_id_);
 }
 
 TEST_F(GLCopyTextureCHROMIUMTest, CopyTextureInvalidTextureIds) {
   CreateAndBindDestinationTextureAndFBO(GL_TEXTURE_2D);
   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);
 
-  glCopyTextureCHROMIUM(textures_[0], 99993, GL_RGBA,
-                        GL_UNSIGNED_BYTE, false, false, false);
-  EXPECT_TRUE(GL_INVALID_VALUE == glGetError());
-
-  glCopyTextureCHROMIUM(99994, textures_[1], GL_RGBA,
-                        GL_UNSIGNED_BYTE, false, false, false);
-  EXPECT_TRUE(GL_INVALID_VALUE == glGetError());
-
-  glCopyTextureCHROMIUM(99995, 99996, GL_RGBA, GL_UNSIGNED_BYTE,
+  glCopyTextureCHROMIUM(textures_[0], 0, 99993, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                         false, false, false);
   EXPECT_TRUE(GL_INVALID_VALUE == glGetError());
 
-  glCopyTextureCHROMIUM(textures_[0], textures_[1], GL_RGBA,
+  glCopyTextureCHROMIUM(99994, 0, textures_[1], 0, GL_RGBA, GL_UNSIGNED_BYTE,
+                        false, false, false);
+  EXPECT_TRUE(GL_INVALID_VALUE == glGetError());
+
+  glCopyTextureCHROMIUM(99995, 0, 99996, 0, GL_RGBA, GL_UNSIGNED_BYTE, false,
+                        false, false);
+  EXPECT_TRUE(GL_INVALID_VALUE == glGetError());
+
+  glCopyTextureCHROMIUM(textures_[0], 0, textures_[1], 0, GL_RGBA,
                         GL_UNSIGNED_BYTE, false, false, false);
   EXPECT_TRUE(GL_NO_ERROR == glGetError());
 
   glDeleteTextures(2, textures_);
   glDeleteFramebuffers(1, &framebuffer_id_);
 }
 
 TEST_F(GLCopyTextureCHROMIUMTest, CopySubTextureInvalidTextureIds) {
   CreateAndBindDestinationTextureAndFBO(GL_TEXTURE_2D);
   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(textures_[0], 99993, 1, 1, 0, 0, 1, 1,
-                           false, false, false);
-  EXPECT_TRUE(GL_INVALID_VALUE == glGetError());
-
-  glCopySubTextureCHROMIUM(99994, textures_[1], 1, 1, 0, 0, 1, 1,
-                           false, false, false);
-  EXPECT_TRUE(GL_INVALID_VALUE == glGetError());
-
-  glCopySubTextureCHROMIUM(99995, 99996, 1, 1, 0, 0, 1, 1, false,
+  glCopySubTextureCHROMIUM(textures_[0], 0, 99993, 0, 1, 1, 0, 0, 1, 1, false,
                            false, false);
   EXPECT_TRUE(GL_INVALID_VALUE == glGetError());
 
-  glCopySubTextureCHROMIUM(textures_[0], textures_[1], 1, 1, 0,
-                           0, 1, 1, false, false, false);
+  glCopySubTextureCHROMIUM(99994, 0, textures_[1], 0, 1, 1, 0, 0, 1, 1, false,
+                           false, false);
+  EXPECT_TRUE(GL_INVALID_VALUE == glGetError());
+
+  glCopySubTextureCHROMIUM(99995, 0, 99996, 0, 1, 1, 0, 0, 1, 1, false, false,
+                           false);
+  EXPECT_TRUE(GL_INVALID_VALUE == glGetError());
+
+  glCopySubTextureCHROMIUM(textures_[0], 0, textures_[1], 0, 1, 1, 0, 0, 1, 1,
+                           false, false, false);
   EXPECT_TRUE(GL_NO_ERROR == glGetError());
 
   glDeleteTextures(2, textures_);
   glDeleteFramebuffers(1, &framebuffer_id_);
 }
 
 TEST_F(GLCopyTextureCHROMIUMTest, CopySubTextureOffset) {
   uint8_t rgba_pixels[4 * 4] = {255u, 0u, 0u,   255u, 0u, 255u, 0u, 255u,
                                 0u,   0u, 255u, 255u, 0u, 0u,   0u, 255u};
   CreateAndBindDestinationTextureAndFBO(GL_TEXTURE_2D);
   glBindTexture(GL_TEXTURE_2D, textures_[0]);
   glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                rgba_pixels);
 
   uint8_t 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_pixels);
 
-  glCopySubTextureCHROMIUM(textures_[0], textures_[1], 1, 1, 0,
-                           0, 1, 1, false, false, false);
+  glCopySubTextureCHROMIUM(textures_[0], 0, textures_[1], 0, 1, 1, 0, 0, 1, 1,
+                           false, false, false);
   EXPECT_TRUE(glGetError() == GL_NO_ERROR);
-  glCopySubTextureCHROMIUM(textures_[0], textures_[1], 1, 0, 1,
-                           0, 1, 1, false, false, false);
+  glCopySubTextureCHROMIUM(textures_[0], 0, textures_[1], 0, 1, 0, 1, 0, 1, 1,
+                           false, false, false);
   EXPECT_TRUE(glGetError() == GL_NO_ERROR);
-  glCopySubTextureCHROMIUM(textures_[0], textures_[1], 0, 1, 0,
-                           1, 1, 1, false, false, false);
+  glCopySubTextureCHROMIUM(textures_[0], 0, textures_[1], 0, 0, 1, 0, 1, 1, 1,
+                           false, false, false);
   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 69 matching lines @@
         }
       }
 
       glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, dest_target,
                              textures_[1], 0);
       glBindTexture(dest_target, textures_[1]);
 
       // Copy the subtexture x=[13,18) y=[6,9) to the destination.
       glClearColor(grey[0] / 255.f, grey[1] / 255.f, grey[2] / 255.f, 1.0);
       glClear(GL_COLOR_BUFFER_BIT);
-      glCopySubTextureCHROMIUM(textures_[0], textures_[1], copy_region_x,
+      glCopySubTextureCHROMIUM(textures_[0], 0, textures_[1], 0, copy_region_x,
                                copy_region_y, 13, 6, copy_region_width,
                                copy_region_height, false, false, false);
       EXPECT_TRUE(GL_NO_ERROR == glGetError());
 
       for (GLint x = 0; x < dest_width; ++x) {
         for (GLint y = 0; y < dest_height; ++y) {
           if (x < copy_region_x || x >= copy_region_x + copy_region_width ||
               y < copy_region_y || y >= copy_region_y + copy_region_height) {
             GLTestHelper::CheckPixels(x, y, 1, 1, 0, grey, nullptr);
             continue;
           }
 
           uint8_t* expected_color;
           if (x < copy_region_x + 2) {
             expected_color = y < copy_region_y + 1 ? red : green;
           } else {
             expected_color = y < copy_region_y + 1 ? blue : white;
           }
           GLTestHelper::CheckPixels(x, y, 1, 1, 0, expected_color, nullptr);
         }
       }
 
       glDeleteTextures(2, textures_);
       glDeleteFramebuffers(1, &framebuffer_id_);
     }
   }
 }
 
 }  // namespace gpu