Unify texture and fbo creation for ES2 and ES3 in gl_tests

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 192 matching lines @@
     glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
 
     glGenFramebuffers(1, &framebuffer_id_);
     glBindFramebuffer(GL_FRAMEBUFFER, framebuffer_id_);
     glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, target,
                            textures_[1], 0);
   }
 
   void SetUp() override {
     gl_.Initialize(GLManager::Options());
-
-    CreateAndBindDestinationTextureAndFBO(GL_TEXTURE_2D);
   }
 
-  void TearDown() override {
-    glDeleteTextures(2, textures_);
-    glDeleteFramebuffers(1, &framebuffer_id_);
-    gl_.Destroy();
-  }
+  void TearDown() override { gl_.Destroy(); }
 
   void CreateBackingForTexture(GLenum target, GLsizei width, GLsizei height) {
     if (target == GL_TEXTURE_RECTANGLE_ARB) {
       GLuint image_id = glCreateGpuMemoryBufferImageCHROMIUM(
           width, height, GL_RGBA, GL_READ_WRITE_CHROMIUM);
       glBindTexImage2DCHROMIUM(target, image_id);
     } else {
       glTexImage2D(target, 0, GL_RGBA, width, height, 0, GL_RGBA,
                    GL_UNSIGNED_BYTE, nullptr);
     }
@@ skipping 20 matching lines @@
 
 class GLCopyTextureCHROMIUMES3Test : public GLCopyTextureCHROMIUMTest {
  protected:
   void SetUp() override {
     GLManager::Options options;
     options.context_type = gles2::CONTEXT_TYPE_OPENGLES3;
     options.size = gfx::Size(64, 64);
     gl_.Initialize(options);
   }
 
-  void TearDown() override { gl_.Destroy(); }
-
   // If a driver isn't capable of supporting ES3 context, creating
   // ContextGroup will fail. Just skip the test.
   bool ShouldSkipTest() const {
     return (!gl_.decoder() || !gl_.decoder()->GetContextGroup());
   }
 
   // RGB9_E5 isn't accepted by glCopyTexImage2D if underlying context is ES.
   // TODO(qiankun.miao@intel.com): we should support RGB9_E5 in ES context.
   // Maybe, we can add a readback path for RGB9_E5 format in ES context.
   bool ShouldSkipRGB9_E5() const {
@@ skipping 29 matching lines @@
 
 INSTANTIATE_TEST_CASE_P(CopyType,
                         GLCopyTextureCHROMIUMES3Test,
                         ::testing::ValuesIn(kCopyTypes));
 
 // Test to ensure that the basic functionality of the extension works.
 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,
                           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,
@@ skipping 225 matching lines @@
     return;
   }
   CopyType copy_type = GetParam();
   GLenum src_internal_formats[] = {GL_RGB8_OES, GL_RGBA8_OES, GL_BGRA8_EXT};
   GLenum dest_internal_formats[] = {GL_RGB8_OES, GL_RGBA8_OES, GL_BGRA8_EXT};
 
   uint8_t pixels[1 * 4] = {255u, 0u, 255u, 255u};
 
   for (auto src_internal_format : src_internal_formats) {
     for (auto dest_internal_format : dest_internal_formats) {
-      glDeleteTextures(2, textures_);
-      glDeleteFramebuffers(1, &framebuffer_id_);
       CreateAndBindDestinationTextureAndFBO(GL_TEXTURE_2D);
-
       glBindTexture(GL_TEXTURE_2D, textures_[0]);
       glTexStorage2DEXT(GL_TEXTURE_2D, 1, src_internal_format, 1, 1);
       glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 1, 1,
                       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);
@@ skipping 15 matching lines @@
         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());
       }
+      glDeleteTextures(2, textures_);
+      glDeleteFramebuffers(1, &framebuffer_id_);
     }
   }
 }
 
 TEST_P(GLCopyTextureCHROMIUMTest, InternalFormat) {
   CopyType copy_type = GetParam();
   GLint src_formats[] = {GL_ALPHA,     GL_RGB,             GL_RGBA,
                          GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_BGRA_EXT};
   GLint dest_formats[] = {GL_RGB, GL_RGBA, GL_BGRA_EXT};
 
   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);
       } 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);
       }
 
       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],
                             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);
     }
     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);
     EXPECT_TRUE(GL_INVALID_OPERATION == glGetError())
         << "dest_index:" << dest_index;
   }
+  glDeleteTextures(2, textures_);
+  glDeleteFramebuffers(1, &framebuffer_id_);
 }
 
 // Test to ensure that the destination texture is redefined if the properties
 // are different.
 TEST_F(GLCopyTextureCHROMIUMTest, RedefineDestinationTexture) {
   uint8_t pixels[4 * 4] = {255u, 0u, 0u, 255u, 255u, 0u, 0u, 255u,
                            255u, 0u, 0u, 255u, 255u, 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, pixels);
 
   glBindTexture(GL_TEXTURE_2D, textures_[1]);
   glTexImage2D(GL_TEXTURE_2D,
                0,
                GL_BGRA_EXT,
                1,
                1,
@@ skipping 29 matching lines @@
   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]);
+
+  glDeleteTextures(2, textures_);
+  glDeleteFramebuffers(1, &framebuffer_id_);
+
   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();
   uint8_t pixels[1 * 4] = {255u, 0u, 0u, 255u};
 
+  CreateAndBindDestinationTextureAndFBO(GL_TEXTURE_2D);
   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);
@@ skipping 36 matching lines @@
     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);
   }
 
+  glDeleteTextures(2, textures_);
+  glDeleteFramebuffers(1, &framebuffer_id_);
+
   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();
   // Setup the texture used for the extension invocation.
   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 == TexSubImage) {
     glBindTexture(GL_TEXTURE_2D, textures_[1]);
     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                  nullptr);
   }
 
@@ skipping 24 matching lines @@
   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);
+  glDeleteTextures(2, textures_);
+  glDeleteFramebuffers(1, &framebuffer_id_);
 
   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();
   // Setup the texture used for the extension invocation.
   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 == TexSubImage) {
     glBindTexture(GL_TEXTURE_2D, textures_[1]);
     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                  nullptr);
   }
 
@@ skipping 67 matching lines @@
 
   fbo_params = 0;
   glGetFramebufferAttachmentParameteriv(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
                                         GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME,
                                         &fbo_params);
   EXPECT_EQ(renderbuffer_id, static_cast<GLuint>(fbo_params));
 
   glDeleteRenderbuffers(1, &renderbuffer_id);
   glDeleteTextures(1, &texture_id);
   glDeleteFramebuffers(1, &framebuffer_id);
+  glDeleteTextures(2, textures_);
+  glDeleteFramebuffers(1, &framebuffer_id_);
 
   EXPECT_TRUE(GL_NO_ERROR == glGetError());
 }
 
 TEST_P(GLCopyTextureCHROMIUMTest, ProgramStatePreservation) {
   CopyType copy_type = GetParam();
-  // unbind the one created in setup.
+  CreateAndBindDestinationTextureAndFBO(GL_TEXTURE_2D);
   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 53 matching lines @@
     glCopySubTextureCHROMIUM(textures_[0], textures_[1], 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));
   glDrawArrays(GL_TRIANGLES, 0, 6);
   EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, 1, 1, 0, expected));
 
+  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,
                           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);
   }
   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]);
       EXPECT_EQ(0, pixels[y][x][3]);
     }
   }
 
+  glDeleteTextures(2, textures_);
+  glDeleteFramebuffers(1, &framebuffer_id_);
+
   EXPECT_TRUE(GL_NO_ERROR == glGetError());
 }
 
 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);
@@ skipping 11 matching lines @@
 
   // xoffset + width > dest_width
   glCopySubTextureCHROMIUM(textures_[0], textures_[1], 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);
   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,
                         false, false, false);
   EXPECT_TRUE(GL_INVALID_VALUE == glGetError());
 
   glCopyTextureCHROMIUM(textures_[0], textures_[1], 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,
                            false, false);
   EXPECT_TRUE(GL_INVALID_VALUE == glGetError());
 
   glCopySubTextureCHROMIUM(textures_[0], textures_[1], 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);
 
@@ skipping 19 matching lines @@
 
   uint8_t transparent[1 * 4] = {0u, 0u, 0u, 0u};
   uint8_t red[1 * 4] = {255u, 0u, 0u, 255u};
   uint8_t green[1 * 4] = {0u, 255u, 0u, 255u};
   uint8_t 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());
+
+  glDeleteTextures(2, textures_);
+  glDeleteFramebuffers(1, &framebuffer_id_);
 }
 
 TEST_F(GLCopyTextureCHROMIUMTest, CopyTextureBetweenTexture2DAndRectangleArb) {
   if (!GLTestHelper::HasExtension("GL_ARB_texture_rectangle")) {
     LOG(INFO) <<
         "GL_ARB_texture_rectangle not supported. Skipping test...";
     return;
   }
 
   GLenum src_targets[] = {GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_2D};
@@ skipping 11 matching lines @@
   uint8_t green[1 * 4] = {0u, 255u, 0, 255u};
   uint8_t white[1 * 4] = {255u, 255u, 255u, 255u};
   uint8_t grey[1 * 4] = {199u, 199u, 199u, 255u};
 
   for (size_t src_index = 0; src_index < arraysize(src_targets); src_index++) {
     GLenum src_target = src_targets[src_index];
     for (size_t dest_index = 0; dest_index < arraysize(dest_targets);
          dest_index++) {
       GLenum dest_target = dest_targets[dest_index];
 
-      // SetUp() sets up textures with the wrong parameters for this test, and
-      // TearDown() expects to successfully delete textures/framebuffers, so
-      // this is the right place for the delete/create calls.
-      glDeleteTextures(2, textures_);
-      glDeleteFramebuffers(1, &framebuffer_id_);
       CreateAndBindDestinationTextureAndFBO(dest_target);
 
       // Allocate source and destination textures.
       glBindTexture(src_target, textures_[0]);
       CreateBackingForTexture(src_target, src_width, src_height);
 
       glBindTexture(dest_target, textures_[1]);
       CreateBackingForTexture(dest_target, dest_width, dest_height);
 
       // The bottom left is red, bottom right is blue, top left is green, top
@@ skipping 36 matching lines @@
 
           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);
         }
       }
+
+      glDeleteTextures(2, textures_);
+      glDeleteFramebuffers(1, &framebuffer_id_);
     }
   }
 }
 
 }  // namespace gpu