Revert of gpu: introduce glCopySubTextureCHROMIUM

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>
 #include <GLES2/gl2extchromium.h>
 
 #include "gpu/command_buffer/tests/gl_manager.h"
 #include "gpu/command_buffer/tests/gl_test_utils.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace gpu {
 
-namespace {
-enum CopyType { TexImage, TexSubImage };
-const CopyType kCopyTypes[] = {
-    TexImage,
-    TexSubImage,
-};
-}
-
 // A collection of tests that exercise the GL_CHROMIUM_copy_texture extension.
-class GLCopyTextureCHROMIUMTest
-    : public testing::Test,
-      public ::testing::WithParamInterface<CopyType> {
+class GLCopyTextureCHROMIUMTest : public testing::Test {
  protected:
   void SetUp() override {
     gl_.Initialize(GLManager::Options());
 
     glGenTextures(2, textures_);
     glBindTexture(GL_TEXTURE_2D, textures_[1]);
 
     // Some drivers (NVidia/SGX) require texture settings to be a certain way or
     // they won't report FRAMEBUFFER_COMPLETE.
     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
@@ skipping 11 matching lines @@
     glDeleteTextures(2, textures_);
     glDeleteFramebuffers(1, &framebuffer_id_);
     gl_.Destroy();
   }
 
   GLManager gl_;
   GLuint textures_[2];
   GLuint framebuffer_id_;
 };
 
-INSTANTIATE_TEST_CASE_P(CopyType,
-                        GLCopyTextureCHROMIUMTest,
-                        ::testing::ValuesIn(kCopyTypes));
-
 // Test to ensure that the basic functionality of the extension works.
-TEST_P(GLCopyTextureCHROMIUMTest, Basic) {
-  CopyType copy_type = GetParam();
+TEST_F(GLCopyTextureCHROMIUMTest, Basic) {
   uint8 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(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);
-  }
+  glCopyTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 0, GL_RGBA,
+                        GL_UNSIGNED_BYTE);
   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));
 
   GLTestHelper::CheckPixels(0, 0, 1, 1, 0, pixels);
   EXPECT_TRUE(GL_NO_ERROR == glGetError());
 }
 
-TEST_P(GLCopyTextureCHROMIUMTest, ImmutableTexture) {
-  if (!GLTestHelper::HasExtension("GL_EXT_texture_storage")) {
-    LOG(INFO) << "GL_EXT_texture_storage not supported. Skipping test...";
-    return;
-  }
-  CopyType copy_type = GetParam();
-
-  uint8 pixels[1 * 4] = {255u, 0u, 0u, 255u};
-
-  glBindTexture(GL_TEXTURE_2D, textures_[0]);
-  glTexStorage2DEXT(GL_TEXTURE_2D, 1, GL_RGBA8_OES, 1, 1);
-  glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE,
-                  pixels);
-
-  glBindTexture(GL_TEXTURE_2D, textures_[1]);
-  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);
-    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));
-
-    GLTestHelper::CheckPixels(0, 0, 1, 1, 0, pixels);
-    EXPECT_TRUE(GL_NO_ERROR == glGetError());
-  }
-}
-
-TEST_P(GLCopyTextureCHROMIUMTest, InternalFormat) {
-  CopyType copy_type = GetParam();
+TEST_F(GLCopyTextureCHROMIUMTest, InternalFormat) {
   GLint src_formats[] = {GL_ALPHA,     GL_RGB,             GL_RGBA,
                          GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_BGRA_EXT};
   GLint dest_formats[] = {GL_RGB, GL_RGBA};
 
   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++) {
       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);
+      glTexImage2D(GL_TEXTURE_2D,
+                   0,
+                   src_formats[src_index],
+                   1,
+                   1,
+                   0,
+                   src_formats[src_index],
+                   GL_UNSIGNED_BYTE,
+                   NULL);
       EXPECT_TRUE(GL_NO_ERROR == glGetError());
 
-      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);
-      }
-
+      glCopyTextureCHROMIUM(GL_TEXTURE_2D,
+                            textures_[0],
+                            textures_[1],
+                            0,
+                            dest_formats[dest_index],
+                            GL_UNSIGNED_BYTE);
       EXPECT_TRUE(GL_NO_ERROR == glGetError()) << "src_index:" << src_index
                                                << " dest_index:" << dest_index;
     }
   }
 }
 
-TEST_P(GLCopyTextureCHROMIUMTest, InternalFormatNotSupported) {
-  CopyType copy_type = GetParam();
+TEST_F(GLCopyTextureCHROMIUMTest, InternalFormatNotSupported) {
   glBindTexture(GL_TEXTURE_2D, textures_[0]);
-  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
-               nullptr);
+  glTexImage2D(
+      GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
   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);
-    }
+    glCopyTextureCHROMIUM(GL_TEXTURE_2D,
+                          textures_[0],
+                          textures_[1],
+                          0,
+                          unsupported_dest_formats[dest_index],
+                          GL_UNSIGNED_BYTE);
     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,
                          255u, 0u, 0u, 255u, 255u, 0u, 0u, 255u};
@@ skipping 18 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(GL_TEXTURE_2D, textures_[0], textures_[1], GL_RGBA,
-                        GL_UNSIGNED_BYTE);
+  glCopyTextureCHROMIUM(
+      GL_TEXTURE_2D, textures_[0], textures_[1], 0, GL_RGBA, GL_UNSIGNED_BYTE);
   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());
 
   // 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));
 
   GLTestHelper::CheckPixels(1, 1, 1, 1, 0, &pixels[12]);
   EXPECT_TRUE(GL_NO_ERROR == glGetError());
 }
 
 // Test that the extension respects the flip-y pixel storage setting.
-TEST_P(GLCopyTextureCHROMIUMTest, FlipY) {
-  CopyType copy_type = GetParam();
+TEST_F(GLCopyTextureCHROMIUMTest, FlipY) {
   uint8 pixels[2][2][4];
   for (int x = 0; x < 2; ++x) {
     for (int y = 0; y < 2; ++y) {
       pixels[y][x][0] = x + y;
       pixels[y][x][1] = x + y;
       pixels[y][x][2] = x + y;
       pixels[y][x][3] = 255u;
     }
   }
 
   glBindTexture(GL_TEXTURE_2D, textures_[0]);
   glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                pixels);
 
   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);
-  }
+  glCopyTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 0, GL_RGBA,
+                        GL_UNSIGNED_BYTE);
   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]);
       EXPECT_EQ(pixels[1-y][x][3], copied_pixels[y][x][3]);
     }
   }
 
   EXPECT_TRUE(GL_NO_ERROR == glGetError());
 }
 
 // Test that the extension respects the GL_UNPACK_PREMULTIPLY_ALPHA_CHROMIUM
 // storage setting.
-TEST_P(GLCopyTextureCHROMIUMTest, PremultiplyAlpha) {
-  CopyType copy_type = GetParam();
+TEST_F(GLCopyTextureCHROMIUMTest, PremultiplyAlpha) {
   uint8 pixels[1 * 4] = { 2, 2, 2, 128 };
 
   glBindTexture(GL_TEXTURE_2D, textures_[0]);
   glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                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);
-  }
+  glCopyTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 0, GL_RGBA,
+                       GL_UNSIGNED_BYTE);
   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]);
 
   EXPECT_TRUE(GL_NO_ERROR == glGetError());
 }
 
 // Test that the extension respects the GL_UNPACK_UNPREMULTIPLY_ALPHA_CHROMIUM
 // storage setting.
-TEST_P(GLCopyTextureCHROMIUMTest, UnpremultiplyAlpha) {
-  CopyType copy_type = GetParam();
+TEST_F(GLCopyTextureCHROMIUMTest, UnpremultiplyAlpha) {
   uint8 pixels[1 * 4] = { 16, 16, 16, 128 };
 
   glBindTexture(GL_TEXTURE_2D, textures_[0]);
   glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                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);
-  }
+  glCopyTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 0, GL_RGBA,
+                        GL_UNSIGNED_BYTE);
   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]);
 
   EXPECT_TRUE(GL_NO_ERROR == glGetError());
 }
 
-TEST_P(GLCopyTextureCHROMIUMTest, FlipYAndPremultiplyAlpha) {
-  CopyType copy_type = GetParam();
+TEST_F(GLCopyTextureCHROMIUMTest, FlipYAndPremultiplyAlpha) {
   uint8 pixels[2][2][4];
   for (int x = 0; x < 2; ++x) {
     for (int y = 0; y < 2; ++y) {
       uint8 color = 16 * x + 16 * y;
       pixels[y][x][0] = color;
       pixels[y][x][1] = color;
       pixels[y][x][2] = color;
       pixels[y][x][3] = 128u;
     }
   }
 
   glBindTexture(GL_TEXTURE_2D, textures_[0]);
   glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                pixels);
 
   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);
-  }
+  glCopyTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 0, GL_RGBA,
+                        GL_UNSIGNED_BYTE);
   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]);
       EXPECT_EQ(pixels[1-y][x][3], copied_pixels[y][x][3]);
     }
   }
 
   EXPECT_TRUE(GL_NO_ERROR == glGetError());
 }
 
-TEST_P(GLCopyTextureCHROMIUMTest, FlipYAndUnpremultiplyAlpha) {
-  CopyType copy_type = GetParam();
+TEST_F(GLCopyTextureCHROMIUMTest, FlipYAndUnpremultiplyAlpha) {
   uint8 pixels[2][2][4];
   for (int x = 0; x < 2; ++x) {
     for (int y = 0; y < 2; ++y) {
       uint8 color = 16 * x + 16 * y;
       pixels[y][x][0] = color;
       pixels[y][x][1] = color;
       pixels[y][x][2] = color;
       pixels[y][x][3] = 128u;
     }
   }
 
   glBindTexture(GL_TEXTURE_2D, textures_[0]);
   glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                pixels);
 
   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);
-  }
+  glCopyTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 0, GL_RGBA,
+                        GL_UNSIGNED_BYTE);
   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]);
       EXPECT_EQ(pixels[1-y][x][3], copied_pixels[y][x][3]);
     }
   }
 
   EXPECT_TRUE(GL_NO_ERROR == glGetError());
 }
 
 namespace {
 
 void glEnableDisable(GLint param, GLboolean value) {
   if (value)
     glEnable(param);
   else
     glDisable(param);
 }
 
 }  // unnamed namespace
 
 // Validate that some basic GL state is not touched upon execution of
 // the extension.
-TEST_P(GLCopyTextureCHROMIUMTest, BasicStatePreservation) {
-  CopyType copy_type = GetParam();
+TEST_F(GLCopyTextureCHROMIUMTest, BasicStatePreservation) {
   uint8 pixels[1 * 4] = { 255u, 0u, 0u, 255u };
 
   glBindFramebuffer(GL_FRAMEBUFFER, 0);
 
   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 == TexSubImage) {
-    glBindTexture(GL_TEXTURE_2D, textures_[1]);
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
-                 nullptr);
-  }
-
   GLboolean reference_settings[2] = { GL_TRUE, GL_FALSE };
   for (int x = 0; x < 2; ++x) {
     GLboolean setting = reference_settings[x];
     glEnableDisable(GL_DEPTH_TEST, setting);
     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(GL_TEXTURE_2D, textures_[0], textures_[1], GL_RGBA,
-                            GL_UNSIGNED_BYTE);
-    } else {
-      glCopySubTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 0, 0);
-    }
+    glCopyTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 0,
+                          GL_RGBA, GL_UNSIGNED_BYTE);
     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 };
     glGetBooleanv(GL_DEPTH_WRITEMASK, bool_array);
     EXPECT_EQ(setting, bool_array[0]);
 
     bool_array[0] = GL_FALSE;
     glGetBooleanv(GL_COLOR_WRITEMASK, bool_array);
     EXPECT_EQ(setting, bool_array[0]);
     EXPECT_EQ(setting, bool_array[1]);
     EXPECT_EQ(setting, bool_array[2]);
     EXPECT_EQ(setting, bool_array[3]);
 
     GLint active_texture = 0;
     glGetIntegerv(GL_ACTIVE_TEXTURE, &active_texture);
     EXPECT_EQ(GL_TEXTURE1 + x, active_texture);
   }
 
   EXPECT_TRUE(GL_NO_ERROR == glGetError());
 };
 
 // Verify that invocation of the extension does not modify the bound
 // texture state.
-TEST_P(GLCopyTextureCHROMIUMTest, TextureStatePreserved) {
-  CopyType copy_type = GetParam();
+TEST_F(GLCopyTextureCHROMIUMTest, TextureStatePreserved) {
   // Setup the texture used for the extension invocation.
   uint8 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 == TexSubImage) {
-    glBindTexture(GL_TEXTURE_2D, textures_[1]);
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
-                 nullptr);
-  }
-
   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(GL_TEXTURE_2D, textures_[0], textures_[1], GL_RGBA,
-                          GL_UNSIGNED_BYTE);
-  } else {
-    glCopySubTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 0, 0);
-  }
+  glCopyTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 0,
+                        GL_RGBA, GL_UNSIGNED_BYTE);
   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));
   glBindTexture(GL_TEXTURE_2D, 0);
 
   bound_texture = 0;
   glActiveTexture(GL_TEXTURE0);
   glGetIntegerv(GL_TEXTURE_BINDING_2D, &bound_texture);
   EXPECT_EQ(texture_ids[0], static_cast<GLuint>(bound_texture));
   glBindTexture(GL_TEXTURE_2D, 0);
 
   glDeleteTextures(2, texture_ids);
 
   EXPECT_TRUE(GL_NO_ERROR == glGetError());
 }
 
 // Verify that invocation of the extension does not perturb the currently
 // bound FBO state.
-TEST_P(GLCopyTextureCHROMIUMTest, FBOStatePreserved) {
-  CopyType copy_type = GetParam();
+TEST_F(GLCopyTextureCHROMIUMTest, FBOStatePreserved) {
   // Setup the texture used for the extension invocation.
   uint8 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 == TexSubImage) {
-    glBindTexture(GL_TEXTURE_2D, textures_[1]);
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
-                 nullptr);
-  }
-
   GLuint texture_id;
   glGenTextures(1, &texture_id);
   glBindTexture(GL_TEXTURE_2D, texture_id);
   glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                0);
 
   GLuint renderbuffer_id;
   glGenRenderbuffers(1, &renderbuffer_id);
   glBindRenderbuffer(GL_RENDERBUFFER, renderbuffer_id);
   glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT16, 1, 1);
 
   GLuint framebuffer_id;
   glGenFramebuffers(1, &framebuffer_id);
   glBindFramebuffer(GL_FRAMEBUFFER, framebuffer_id);
   glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
                          texture_id, 0);
   glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
                             GL_RENDERBUFFER, renderbuffer_id);
   EXPECT_TRUE(
       GL_FRAMEBUFFER_COMPLETE == glCheckFramebufferStatus(GL_FRAMEBUFFER));
 
   // 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);
-  }
+  glCopyTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 0,
+                        GL_RGBA, GL_UNSIGNED_BYTE);
   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);
   glClear(GL_COLOR_BUFFER_BIT);
@@ skipping 27 matching lines @@
                                         &fbo_params);
   EXPECT_EQ(renderbuffer_id, static_cast<GLuint>(fbo_params));
 
   glDeleteRenderbuffers(1, &renderbuffer_id);
   glDeleteTextures(1, &texture_id);
   glDeleteFramebuffers(1, &framebuffer_id);
 
   EXPECT_TRUE(GL_NO_ERROR == glGetError());
 }
 
-TEST_P(GLCopyTextureCHROMIUMTest, ProgramStatePreservation) {
-  CopyType copy_type = GetParam();
+TEST_F(GLCopyTextureCHROMIUMTest, ProgramStatePreservation) {
   // unbind the one created in setup.
   glBindFramebuffer(GL_FRAMEBUFFER, 0);
   glBindTexture(GL_TEXTURE_2D, 0);
 
   GLManager gl2;
   GLManager::Options options;
   options.size = gfx::Size(16, 16);
   options.share_group_manager = &gl_;
   gl2.Initialize(options);
   gl_.MakeCurrent();
@@ skipping 33 matching lines @@
   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));
 
   // Call copyTextureCHROMIUM
   uint8 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(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);
-  }
+  glCopyTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 0, GL_RGBA,
+                        GL_UNSIGNED_BYTE);
 
   // 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());
 
   gl2.MakeCurrent();
   gl2.Destroy();
   gl_.MakeCurrent();
 }
 
 // Test that glCopyTextureCHROMIUM doesn't leak uninitialized textures.
-TEST_P(GLCopyTextureCHROMIUMTest, UninitializedSource) {
-  CopyType copy_type = GetParam();
+TEST_F(GLCopyTextureCHROMIUMTest, UninitializedSource) {
   const GLsizei kWidth = 64, kHeight = 64;
   glBindTexture(GL_TEXTURE_2D, textures_[0]);
-  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, kWidth, kHeight, 0, GL_RGBA,
-               GL_UNSIGNED_BYTE, nullptr);
+  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, kWidth, kHeight,
+               0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
 
-  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);
-  }
+  glCopyTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 0, GL_RGBA,
+                        GL_UNSIGNED_BYTE);
   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);
-  EXPECT_TRUE(GL_NO_ERROR == glGetError());
-
-  // xoffset < 0
-  glCopySubTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], -1, 1);
-  EXPECT_TRUE(glGetError() == GL_INVALID_VALUE);
-
-  // xoffset + source_width > dest_width
-  glCopySubTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 2, 2);
-  EXPECT_TRUE(glGetError() == GL_INVALID_VALUE);
-}
-
-TEST_F(GLCopyTextureCHROMIUMTest, CopySubTextureOffset) {
-  uint8 red[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,
-               red);
-
-  uint8 transparent_pixel[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);
-
-  glCopySubTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[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};
-  GLTestHelper::CheckPixels(0, 0, 1, 1, 0, transparent);
-  GLTestHelper::CheckPixels(1, 1, 1, 1, 0, red);
-  EXPECT_TRUE(GL_NO_ERROR == glGetError());
-}
-
 }  // namespace gpu