gpu/command_buffer/tests/gl_compressed_copy_texture_CHROMIUM_unittest.cc - chromium/src.git - Git at Google

 // Copyright (c) 2015 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 <stdint.h>

 #include <memory>

 #include "base/memory/ptr_util.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"

 #define SHADER(src) #src

 namespace gpu {

 namespace {

 const uint8_t kCompressedImageColor[4] = {255u, 0u, 0u, 255u};

 // Single compressed ATC block of source pixels all set to:
 // kCompressedImageColor.
 const uint8_t kCompressedImageATC[8] = {0x0,  0x7c, 0x0,  0xf8,
                                         0x55, 0x55, 0x55, 0x55};

 // Single compressed ATCIA block of source pixels all set to:
 // kCompressedImageColor.
 const uint8_t kCompressedImageATCIA[16] = {0xff, 0xff, 0x0,  0x0,  0x0, 0x0,
                                            0x0,  0x0,  0x0,  0x7c, 0x0, 0xf8,
                                            0x55, 0x55, 0x55, 0x55};

 // Single compressed DXT1 block of source pixels all set to:
 // kCompressedImageColor.
 const uint8_t kCompressedImageDXT1[8] = {0x00, 0xf8, 0x00, 0xf8,
                                          0xaa, 0xaa, 0xaa, 0xaa};

 // Single compressed DXT5 block of source pixels all set to:
 // kCompressedImageColor.
 const uint8_t kCompressedImageDXT5[16] = {0xff, 0xff, 0x0,  0x0,  0x0, 0x0,
                                           0x0,  0x0,  0x0,  0xf8, 0x0, 0xf8,
                                           0xaa, 0xaa, 0xaa, 0xaa};

 // Single compressed DXT1 block of source pixels all set to:
 // kCompressedImageColor.
 const uint8_t kCompressedImageETC1[8] = {0x0,  0x0,  0xf8, 0x2,
                                          0xff, 0xff, 0x0,  0x0};

 void glEnableDisable(GLint param, GLboolean value) {
   if (value)
     glEnable(param);
   else
     glDisable(param);
 }

 }  // unnamed namespace

 // A collection of tests that exercise the GL_CHROMIUM_copy_texture extension.
 class GLCompressedCopyTextureCHROMIUMTest
     : public testing::Test {
  protected:
   void SetUp() override {
     gl_.Initialize(GLManager::Options());

     glGenTextures(2, textures_);
   }

   void TearDown() override {
     glDeleteTextures(2, textures_);
     gl_.Destroy();
   }

   GLuint LoadProgram() {
     const char* v_shader_src = SHADER(
         attribute vec2 a_position;
         varying vec2 v_texcoord;
         void main() {
           gl_Position = vec4(a_position, 0.0, 1.0);
           v_texcoord = (a_position + 1.0) * 0.5;
         }
     );
     const char* f_shader_src = SHADER(
         precision mediump float;
         uniform sampler2D u_texture;
         varying vec2 v_texcoord;
         void main() {
           gl_FragColor = texture2D(u_texture, v_texcoord);
         }
     );
     return GLTestHelper::LoadProgram(v_shader_src, f_shader_src);
   }

   GLManager gl_;
   GLuint textures_[2];
   GLuint framebuffer_id_;
 };

 // Test to ensure that the basic functionality of the extension works.
 TEST_F(GLCompressedCopyTextureCHROMIUMTest, Basic) {
   if (!GLTestHelper::HasExtension("GL_EXT_texture_compression_dxt1")) {
     LOG(INFO) <<
         "GL_EXT_texture_compression_dxt1 not supported. Skipping test...";
     return;
   }

   glBindTexture(GL_TEXTURE_2D, textures_[0]);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
   glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGB_S3TC_DXT1_EXT,
                          4, 4, 0,
                          sizeof(kCompressedImageDXT1), kCompressedImageDXT1);
   EXPECT_TRUE(glGetError() == GL_NO_ERROR);

   glBindTexture(GL_TEXTURE_2D, textures_[1]);
   glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
   glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
   glCompressedCopyTextureCHROMIUM(textures_[0], textures_[1]);
   EXPECT_TRUE(glGetError() == GL_NO_ERROR);

   // Load shader program.
   GLuint program = LoadProgram();
   ASSERT_NE(program, 0u);
   GLint position_loc = glGetAttribLocation(program, "a_position");
   GLint texture_loc = glGetUniformLocation(program, "u_texture");
   ASSERT_NE(position_loc, -1);
   ASSERT_NE(texture_loc, -1);
   glUseProgram(program);

   // Load geometry.
   GLuint vbo = GLTestHelper::SetupUnitQuad(position_loc);
   ASSERT_NE(vbo, 0u);

   // Load texture.
   glActiveTexture(GL_TEXTURE0);
   glBindTexture(GL_TEXTURE_2D, textures_[1]);
   glUniform1i(texture_loc, 0);

   // Draw.
   glDrawArrays(GL_TRIANGLES, 0, 6);
   glFlush();

   GLTestHelper::CheckPixels(0, 0, 4, 4, 0, kCompressedImageColor, nullptr);
   EXPECT_TRUE(GL_NO_ERROR == glGetError());
 }

 TEST_F(GLCompressedCopyTextureCHROMIUMTest, InternalFormat) {
   struct Image {
     const GLint format;
     const uint8_t* data;
     const GLsizei data_size;

     Image(const GLint format, const uint8_t* data, const GLsizei data_size)
         : format(format), data(data), data_size(data_size) {}
   };
   std::vector<std::unique_ptr<Image>> supported_formats;

   if (GLTestHelper::HasExtension("GL_AMD_compressed_ATC_texture") ||
       GLTestHelper::HasExtension("GL_ATI_texture_compression_atitc")) {
     supported_formats.push_back(base::MakeUnique<Image>(
         GL_ATC_RGB_AMD, kCompressedImageATC, sizeof(kCompressedImageATC)));
     supported_formats.push_back(base::MakeUnique<Image>(
         GL_ATC_RGBA_INTERPOLATED_ALPHA_AMD, kCompressedImageATCIA,
         sizeof(kCompressedImageATCIA)));
   }
   if (GLTestHelper::HasExtension("GL_EXT_texture_compression_dxt1")) {
     supported_formats.push_back(base::MakeUnique<Image>(
         GL_COMPRESSED_RGB_S3TC_DXT1_EXT, kCompressedImageDXT1,
         sizeof(kCompressedImageDXT1)));
   }
   if (GLTestHelper::HasExtension("GL_ANGLE_texture_compression_dxt5") ||
       GLTestHelper::HasExtension("GL_EXT_texture_compression_s3tc")) {
     supported_formats.push_back(base::MakeUnique<Image>(
         GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, kCompressedImageDXT5,
         sizeof(kCompressedImageDXT5)));
   }
   if (GLTestHelper::HasExtension("GL_OES_compressed_ETC1_RGB8_texture")) {
     supported_formats.push_back(base::MakeUnique<Image>(
         GL_ETC1_RGB8_OES, kCompressedImageETC1, sizeof(kCompressedImageETC1)));
   }

   for (const auto& image : supported_formats) {
     glBindTexture(GL_TEXTURE_2D, textures_[0]);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
     glCompressedTexImage2D(GL_TEXTURE_2D, 0, image->format,
                            4, 4, 0, image->data_size, image->data);
     EXPECT_TRUE(GL_NO_ERROR == glGetError());

     glBindTexture(GL_TEXTURE_2D, textures_[1]);
     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
     glCompressedCopyTextureCHROMIUM(textures_[0], textures_[1]);
     EXPECT_TRUE(GL_NO_ERROR == glGetError());
   }
 }

 TEST_F(GLCompressedCopyTextureCHROMIUMTest, InternalFormatNotSupported) {
   if (!GLTestHelper::HasExtension("GL_EXT_texture_compression_dxt1")) {
     LOG(INFO) <<
         "GL_EXT_texture_compression_dxt1 not supported. Skipping test...";
     return;
   }

   const uint8_t kUncompressedPixels[1 * 4] = {255u, 0u, 0u, 255u};

   glBindTexture(GL_TEXTURE_2D, textures_[0]);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
   glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                kUncompressedPixels);
   EXPECT_TRUE(glGetError() == GL_NO_ERROR);

   glBindTexture(GL_TEXTURE_2D, textures_[1]);
   glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
   glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

   // Check that the GL_RGBA format reports an error.
   glCompressedCopyTextureCHROMIUM(textures_[0], textures_[1]);
   EXPECT_TRUE(GL_INVALID_OPERATION == glGetError());
 }

 TEST_F(GLCompressedCopyTextureCHROMIUMTest, InvalidTextureIds) {
   if (!GLTestHelper::HasExtension("GL_EXT_texture_compression_dxt1")) {
     LOG(INFO)
         << "GL_EXT_texture_compression_dxt1 not supported. Skipping test...";
     return;
   }

   glBindTexture(GL_TEXTURE_2D, textures_[0]);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
   glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGB_S3TC_DXT1_EXT, 4,
                          4, 0, sizeof(kCompressedImageDXT1),
                          kCompressedImageDXT1);
   EXPECT_TRUE(glGetError() == GL_NO_ERROR);

   glBindTexture(GL_TEXTURE_2D, textures_[1]);
   glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
   glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

   glCompressedCopyTextureCHROMIUM(textures_[0], 99993);
   EXPECT_TRUE(glGetError() == GL_INVALID_VALUE);

   glCompressedCopyTextureCHROMIUM(99994, textures_[1]);
   EXPECT_TRUE(glGetError() == GL_INVALID_VALUE);

   glCompressedCopyTextureCHROMIUM(99995, 99996);
   EXPECT_TRUE(glGetError() == GL_INVALID_VALUE);

   glCompressedCopyTextureCHROMIUM(textures_[0], textures_[1]);
   EXPECT_TRUE(glGetError() == GL_NO_ERROR);
 }

 TEST_F(GLCompressedCopyTextureCHROMIUMTest, InvalidTextureTarget) {
   glBindTexture(GL_TEXTURE_CUBE_MAP, textures_[0]);
   glBindTexture(GL_TEXTURE_CUBE_MAP, textures_[1]);
   glCompressedCopyTextureCHROMIUM(textures_[0], textures_[1]);
   EXPECT_TRUE(glGetError() == GL_INVALID_VALUE);
 }

 // Validate that some basic GL state is not touched upon execution of
 // the extension.
 TEST_F(GLCompressedCopyTextureCHROMIUMTest, BasicStatePreservation) {
   if (!GLTestHelper::HasExtension("GL_EXT_texture_compression_dxt1")) {
     LOG(INFO) <<
         "GL_EXT_texture_compression_dxt1 not supported. Skipping test...";
     return;
   }

   glBindTexture(GL_TEXTURE_2D, textures_[0]);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
   glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGB_S3TC_DXT1_EXT,
                          4, 4, 0,
                          sizeof(kCompressedImageDXT1), kCompressedImageDXT1);
   EXPECT_TRUE(glGetError() == GL_NO_ERROR);

   glBindTexture(GL_TEXTURE_2D, textures_[1]);
   glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
   glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

   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);
     glCompressedCopyTextureCHROMIUM(textures_[0], textures_[1]);
     EXPECT_TRUE(glGetError() == GL_NO_ERROR);

     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_F(GLCompressedCopyTextureCHROMIUMTest, TextureStatePreserved) {
   if (!GLTestHelper::HasExtension("GL_EXT_texture_compression_dxt1")) {
     LOG(INFO) <<
         "GL_EXT_texture_compression_dxt1 not supported. Skipping test...";
     return;
   }

   glBindTexture(GL_TEXTURE_2D, textures_[0]);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
   glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGB_S3TC_DXT1_EXT,
                          4, 4, 0,
                          sizeof(kCompressedImageDXT1), kCompressedImageDXT1);
   EXPECT_TRUE(glGetError() == GL_NO_ERROR);

   glBindTexture(GL_TEXTURE_2D, textures_[1]);
   glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
   glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

   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]);

   glCompressedCopyTextureCHROMIUM(textures_[0], textures_[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));
   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());
 }

 }  // namespace gpu
	// Copyright (c) 2015 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 <stdint.h>

	#include <memory>

	#include "base/memory/ptr_util.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"

	#define SHADER(src) #src

	namespace gpu {

	namespace {

	const uint8_t kCompressedImageColor[4] = {255u, 0u, 0u, 255u};

	// Single compressed ATC block of source pixels all set to:
	// kCompressedImageColor.
	const uint8_t kCompressedImageATC[8] = {0x0, 0x7c, 0x0, 0xf8,
	0x55, 0x55, 0x55, 0x55};

	// Single compressed ATCIA block of source pixels all set to:
	// kCompressedImageColor.
	const uint8_t kCompressedImageATCIA[16] = {0xff, 0xff, 0x0, 0x0, 0x0, 0x0,
	0x0, 0x0, 0x0, 0x7c, 0x0, 0xf8,
	0x55, 0x55, 0x55, 0x55};

	// Single compressed DXT1 block of source pixels all set to:
	// kCompressedImageColor.
	const uint8_t kCompressedImageDXT1[8] = {0x00, 0xf8, 0x00, 0xf8,
	0xaa, 0xaa, 0xaa, 0xaa};

	// Single compressed DXT5 block of source pixels all set to:
	// kCompressedImageColor.
	const uint8_t kCompressedImageDXT5[16] = {0xff, 0xff, 0x0, 0x0, 0x0, 0x0,
	0x0, 0x0, 0x0, 0xf8, 0x0, 0xf8,
	0xaa, 0xaa, 0xaa, 0xaa};

	// Single compressed DXT1 block of source pixels all set to:
	// kCompressedImageColor.
	const uint8_t kCompressedImageETC1[8] = {0x0, 0x0, 0xf8, 0x2,
	0xff, 0xff, 0x0, 0x0};

	void glEnableDisable(GLint param, GLboolean value) {
	if (value)
	glEnable(param);
	else
	glDisable(param);
	}

	} // unnamed namespace

	// A collection of tests that exercise the GL_CHROMIUM_copy_texture extension.
	class GLCompressedCopyTextureCHROMIUMTest
	: public testing::Test {
	protected:
	void SetUp() override {
	gl_.Initialize(GLManager::Options());

	glGenTextures(2, textures_);
	}

	void TearDown() override {
	glDeleteTextures(2, textures_);
	gl_.Destroy();
	}

	GLuint LoadProgram() {
	const char* v_shader_src = SHADER(
	attribute vec2 a_position;
	varying vec2 v_texcoord;
	void main() {
	gl_Position = vec4(a_position, 0.0, 1.0);
	v_texcoord = (a_position + 1.0) * 0.5;
	}
	);
	const char* f_shader_src = SHADER(
	precision mediump float;
	uniform sampler2D u_texture;
	varying vec2 v_texcoord;
	void main() {
	gl_FragColor = texture2D(u_texture, v_texcoord);
	}
	);
	return GLTestHelper::LoadProgram(v_shader_src, f_shader_src);
	}

	GLManager gl_;
	GLuint textures_[2];
	GLuint framebuffer_id_;
	};

	// Test to ensure that the basic functionality of the extension works.
	TEST_F(GLCompressedCopyTextureCHROMIUMTest, Basic) {
	if (!GLTestHelper::HasExtension("GL_EXT_texture_compression_dxt1")) {
	LOG(INFO) <<
	"GL_EXT_texture_compression_dxt1 not supported. Skipping test...";
	return;
	}

	glBindTexture(GL_TEXTURE_2D, textures_[0]);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGB_S3TC_DXT1_EXT,
	4, 4, 0,
	sizeof(kCompressedImageDXT1), kCompressedImageDXT1);
	EXPECT_TRUE(glGetError() == GL_NO_ERROR);

	glBindTexture(GL_TEXTURE_2D, textures_[1]);
	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	glCompressedCopyTextureCHROMIUM(textures_[0], textures_[1]);
	EXPECT_TRUE(glGetError() == GL_NO_ERROR);

	// Load shader program.
	GLuint program = LoadProgram();
	ASSERT_NE(program, 0u);
	GLint position_loc = glGetAttribLocation(program, "a_position");
	GLint texture_loc = glGetUniformLocation(program, "u_texture");
	ASSERT_NE(position_loc, -1);
	ASSERT_NE(texture_loc, -1);
	glUseProgram(program);

	// Load geometry.
	GLuint vbo = GLTestHelper::SetupUnitQuad(position_loc);
	ASSERT_NE(vbo, 0u);

	// Load texture.
	glActiveTexture(GL_TEXTURE0);
	glBindTexture(GL_TEXTURE_2D, textures_[1]);
	glUniform1i(texture_loc, 0);

	// Draw.
	glDrawArrays(GL_TRIANGLES, 0, 6);
	glFlush();

	GLTestHelper::CheckPixels(0, 0, 4, 4, 0, kCompressedImageColor, nullptr);
	EXPECT_TRUE(GL_NO_ERROR == glGetError());
	}

	TEST_F(GLCompressedCopyTextureCHROMIUMTest, InternalFormat) {
	struct Image {
	const GLint format;
	const uint8_t* data;
	const GLsizei data_size;

	Image(const GLint format, const uint8_t* data, const GLsizei data_size)
	: format(format), data(data), data_size(data_size) {}
	};
	std::vector<std::unique_ptr<Image>> supported_formats;

	if (GLTestHelper::HasExtension("GL_AMD_compressed_ATC_texture") \|\|
	GLTestHelper::HasExtension("GL_ATI_texture_compression_atitc")) {
	supported_formats.push_back(base::MakeUnique<Image>(
	GL_ATC_RGB_AMD, kCompressedImageATC, sizeof(kCompressedImageATC)));
	supported_formats.push_back(base::MakeUnique<Image>(
	GL_ATC_RGBA_INTERPOLATED_ALPHA_AMD, kCompressedImageATCIA,
	sizeof(kCompressedImageATCIA)));
	}
	if (GLTestHelper::HasExtension("GL_EXT_texture_compression_dxt1")) {
	supported_formats.push_back(base::MakeUnique<Image>(
	GL_COMPRESSED_RGB_S3TC_DXT1_EXT, kCompressedImageDXT1,
	sizeof(kCompressedImageDXT1)));
	}
	if (GLTestHelper::HasExtension("GL_ANGLE_texture_compression_dxt5") \|\|
	GLTestHelper::HasExtension("GL_EXT_texture_compression_s3tc")) {
	supported_formats.push_back(base::MakeUnique<Image>(
	GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, kCompressedImageDXT5,
	sizeof(kCompressedImageDXT5)));
	}
	if (GLTestHelper::HasExtension("GL_OES_compressed_ETC1_RGB8_texture")) {
	supported_formats.push_back(base::MakeUnique<Image>(
	GL_ETC1_RGB8_OES, kCompressedImageETC1, sizeof(kCompressedImageETC1)));
	}

	for (const auto& image : supported_formats) {
	glBindTexture(GL_TEXTURE_2D, textures_[0]);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	glCompressedTexImage2D(GL_TEXTURE_2D, 0, image->format,
	4, 4, 0, image->data_size, image->data);
	EXPECT_TRUE(GL_NO_ERROR == glGetError());

	glBindTexture(GL_TEXTURE_2D, textures_[1]);
	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	glCompressedCopyTextureCHROMIUM(textures_[0], textures_[1]);
	EXPECT_TRUE(GL_NO_ERROR == glGetError());
	}
	}

	TEST_F(GLCompressedCopyTextureCHROMIUMTest, InternalFormatNotSupported) {
	if (!GLTestHelper::HasExtension("GL_EXT_texture_compression_dxt1")) {
	LOG(INFO) <<
	"GL_EXT_texture_compression_dxt1 not supported. Skipping test...";
	return;
	}

	const uint8_t kUncompressedPixels[1 * 4] = {255u, 0u, 0u, 255u};

	glBindTexture(GL_TEXTURE_2D, textures_[0]);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
	kUncompressedPixels);
	EXPECT_TRUE(glGetError() == GL_NO_ERROR);

	glBindTexture(GL_TEXTURE_2D, textures_[1]);
	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

	// Check that the GL_RGBA format reports an error.
	glCompressedCopyTextureCHROMIUM(textures_[0], textures_[1]);
	EXPECT_TRUE(GL_INVALID_OPERATION == glGetError());
	}

	TEST_F(GLCompressedCopyTextureCHROMIUMTest, InvalidTextureIds) {
	if (!GLTestHelper::HasExtension("GL_EXT_texture_compression_dxt1")) {
	LOG(INFO)
	<< "GL_EXT_texture_compression_dxt1 not supported. Skipping test...";
	return;
	}

	glBindTexture(GL_TEXTURE_2D, textures_[0]);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGB_S3TC_DXT1_EXT, 4,
	4, 0, sizeof(kCompressedImageDXT1),
	kCompressedImageDXT1);
	EXPECT_TRUE(glGetError() == GL_NO_ERROR);

	glBindTexture(GL_TEXTURE_2D, textures_[1]);
	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

	glCompressedCopyTextureCHROMIUM(textures_[0], 99993);
	EXPECT_TRUE(glGetError() == GL_INVALID_VALUE);

	glCompressedCopyTextureCHROMIUM(99994, textures_[1]);
	EXPECT_TRUE(glGetError() == GL_INVALID_VALUE);

	glCompressedCopyTextureCHROMIUM(99995, 99996);
	EXPECT_TRUE(glGetError() == GL_INVALID_VALUE);

	glCompressedCopyTextureCHROMIUM(textures_[0], textures_[1]);
	EXPECT_TRUE(glGetError() == GL_NO_ERROR);
	}

	TEST_F(GLCompressedCopyTextureCHROMIUMTest, InvalidTextureTarget) {
	glBindTexture(GL_TEXTURE_CUBE_MAP, textures_[0]);
	glBindTexture(GL_TEXTURE_CUBE_MAP, textures_[1]);
	glCompressedCopyTextureCHROMIUM(textures_[0], textures_[1]);
	EXPECT_TRUE(glGetError() == GL_INVALID_VALUE);
	}

	// Validate that some basic GL state is not touched upon execution of
	// the extension.
	TEST_F(GLCompressedCopyTextureCHROMIUMTest, BasicStatePreservation) {
	if (!GLTestHelper::HasExtension("GL_EXT_texture_compression_dxt1")) {
	LOG(INFO) <<
	"GL_EXT_texture_compression_dxt1 not supported. Skipping test...";
	return;
	}

	glBindTexture(GL_TEXTURE_2D, textures_[0]);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGB_S3TC_DXT1_EXT,
	4, 4, 0,
	sizeof(kCompressedImageDXT1), kCompressedImageDXT1);
	EXPECT_TRUE(glGetError() == GL_NO_ERROR);

	glBindTexture(GL_TEXTURE_2D, textures_[1]);
	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

	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);
	glCompressedCopyTextureCHROMIUM(textures_[0], textures_[1]);
	EXPECT_TRUE(glGetError() == GL_NO_ERROR);

	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_F(GLCompressedCopyTextureCHROMIUMTest, TextureStatePreserved) {
	if (!GLTestHelper::HasExtension("GL_EXT_texture_compression_dxt1")) {
	LOG(INFO) <<
	"GL_EXT_texture_compression_dxt1 not supported. Skipping test...";
	return;
	}

	glBindTexture(GL_TEXTURE_2D, textures_[0]);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGB_S3TC_DXT1_EXT,
	4, 4, 0,
	sizeof(kCompressedImageDXT1), kCompressedImageDXT1);
	EXPECT_TRUE(glGetError() == GL_NO_ERROR);

	glBindTexture(GL_TEXTURE_2D, textures_[1]);
	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

	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]);

	glCompressedCopyTextureCHROMIUM(textures_[0], textures_[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));
	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());
	}

	} // namespace gpu