1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #ifndef GL_GLEXT_PROTOTYPES 6 #define GL_GLEXT_PROTOTYPES 7 #endif 8 9 #include <GLES2/gl2.h> 10 #include <GLES2/gl2ext.h> 11 #include <GLES2/gl2extchromium.h> 12 13 #include "gpu/command_buffer/tests/gl_manager.h" 14 #include "gpu/command_buffer/tests/gl_test_utils.h" 15 #include "testing/gmock/include/gmock/gmock.h" 16 #include "testing/gtest/include/gtest/gtest.h" 17 18 namespace gpu { 19 20 // A collection of tests that exercise the GL_CHROMIUM_copy_texture extension. 21 class GLCopyTextureCHROMIUMTest : public testing::Test { 22 protected: 23 virtual void SetUp() { 24 gl_.Initialize(GLManager::Options()); 25 26 glGenTextures(2, textures_); 27 glBindTexture(GL_TEXTURE_2D, textures_[1]); 28 29 // Some drivers (NVidia/SGX) require texture settings to be a certain way or 30 // they won't report FRAMEBUFFER_COMPLETE. 31 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); 32 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); 33 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 34 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); 35 36 glGenFramebuffers(1, &framebuffer_id_); 37 glBindFramebuffer(GL_FRAMEBUFFER, framebuffer_id_); 38 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 39 textures_[1], 0); 40 } 41 42 virtual void TearDown() { 43 glDeleteTextures(2, textures_); 44 glDeleteFramebuffers(1, &framebuffer_id_); 45 gl_.Destroy(); 46 } 47 48 GLManager gl_; 49 GLuint textures_[2]; 50 GLuint framebuffer_id_; 51 }; 52 53 // Test to ensure that the basic functionality of the extension works. 54 TEST_F(GLCopyTextureCHROMIUMTest, Basic) { 55 uint8 pixels[1 * 4] = { 255u, 0u, 0u, 255u }; 56 57 glBindTexture(GL_TEXTURE_2D, textures_[0]); 58 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 59 pixels); 60 61 glCopyTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 0, GL_RGBA, 62 GL_UNSIGNED_BYTE); 63 EXPECT_TRUE(glGetError() == GL_NO_ERROR); 64 65 // Check the FB is still bound. 66 GLint value = 0; 67 glGetIntegerv(GL_FRAMEBUFFER_BINDING, &value); 68 GLuint fb_id = value; 69 EXPECT_EQ(framebuffer_id_, fb_id); 70 71 // Check that FB is complete. 72 EXPECT_EQ(static_cast<GLenum>(GL_FRAMEBUFFER_COMPLETE), 73 glCheckFramebufferStatus(GL_FRAMEBUFFER)); 74 75 GLTestHelper::CheckPixels(0, 0, 1, 1, 0, pixels); 76 EXPECT_TRUE(GL_NO_ERROR == glGetError()); 77 } 78 79 // Test that the extension respects the flip-y pixel storage setting. 80 TEST_F(GLCopyTextureCHROMIUMTest, FlipY) { 81 uint8 pixels[2][2][4]; 82 for (int x = 0; x < 2; ++x) { 83 for (int y = 0; y < 2; ++y) { 84 pixels[y][x][0] = x + y; 85 pixels[y][x][1] = x + y; 86 pixels[y][x][2] = x + y; 87 pixels[y][x][3] = 255u; 88 } 89 } 90 91 glBindTexture(GL_TEXTURE_2D, textures_[0]); 92 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, 93 pixels); 94 95 glPixelStorei(GL_UNPACK_FLIP_Y_CHROMIUM, GL_TRUE); 96 glCopyTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 0, GL_RGBA, 97 GL_UNSIGNED_BYTE); 98 EXPECT_TRUE(GL_NO_ERROR == glGetError()); 99 100 uint8 copied_pixels[2][2][4] = {{{0}}}; 101 glReadPixels(0, 0, 2, 2, GL_RGBA, GL_UNSIGNED_BYTE, copied_pixels); 102 for (int x = 0; x < 2; ++x) { 103 for (int y = 0; y < 2; ++y) { 104 EXPECT_EQ(pixels[1-y][x][0], copied_pixels[y][x][0]); 105 EXPECT_EQ(pixels[1-y][x][1], copied_pixels[y][x][1]); 106 EXPECT_EQ(pixels[1-y][x][2], copied_pixels[y][x][2]); 107 EXPECT_EQ(pixels[1-y][x][3], copied_pixels[y][x][3]); 108 } 109 } 110 111 EXPECT_TRUE(GL_NO_ERROR == glGetError()); 112 } 113 114 // Test that the extension respects the GL_UNPACK_PREMULTIPLY_ALPHA_CHROMIUM 115 // storage setting. 116 TEST_F(GLCopyTextureCHROMIUMTest, PremultiplyAlpha) { 117 uint8 pixels[1 * 4] = { 2, 2, 2, 128 }; 118 119 glBindTexture(GL_TEXTURE_2D, textures_[0]); 120 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 121 pixels); 122 123 glPixelStorei(GL_UNPACK_PREMULTIPLY_ALPHA_CHROMIUM, GL_TRUE); 124 glCopyTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 0, GL_RGBA, 125 GL_UNSIGNED_BYTE); 126 EXPECT_TRUE(GL_NO_ERROR == glGetError()); 127 128 uint8 copied_pixels[1 * 4] = {0}; 129 glReadPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, copied_pixels); 130 EXPECT_EQ(1u, copied_pixels[0]); 131 EXPECT_EQ(1u, copied_pixels[1]); 132 EXPECT_EQ(1u, copied_pixels[2]); 133 EXPECT_EQ(128u, copied_pixels[3]); 134 135 EXPECT_TRUE(GL_NO_ERROR == glGetError()); 136 } 137 138 // Test that the extension respects the GL_UNPACK_UNPREMULTIPLY_ALPHA_CHROMIUM 139 // storage setting. 140 TEST_F(GLCopyTextureCHROMIUMTest, UnpremultiplyAlpha) { 141 uint8 pixels[1 * 4] = { 16, 16, 16, 128 }; 142 143 glBindTexture(GL_TEXTURE_2D, textures_[0]); 144 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 145 pixels); 146 147 glPixelStorei(GL_UNPACK_UNPREMULTIPLY_ALPHA_CHROMIUM, GL_TRUE); 148 glCopyTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 0, GL_RGBA, 149 GL_UNSIGNED_BYTE); 150 EXPECT_TRUE(GL_NO_ERROR == glGetError()); 151 152 uint8 copied_pixels[1 * 4] = {0}; 153 glReadPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, copied_pixels); 154 EXPECT_EQ(32u, copied_pixels[0]); 155 EXPECT_EQ(32u, copied_pixels[1]); 156 EXPECT_EQ(32u, copied_pixels[2]); 157 EXPECT_EQ(128u, copied_pixels[3]); 158 159 EXPECT_TRUE(GL_NO_ERROR == glGetError()); 160 } 161 162 TEST_F(GLCopyTextureCHROMIUMTest, FlipYAndPremultiplyAlpha) { 163 uint8 pixels[2][2][4]; 164 for (int x = 0; x < 2; ++x) { 165 for (int y = 0; y < 2; ++y) { 166 uint8 color = 16 * x + 16 * y; 167 pixels[y][x][0] = color; 168 pixels[y][x][1] = color; 169 pixels[y][x][2] = color; 170 pixels[y][x][3] = 128u; 171 } 172 } 173 174 glBindTexture(GL_TEXTURE_2D, textures_[0]); 175 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, 176 pixels); 177 178 glPixelStorei(GL_UNPACK_FLIP_Y_CHROMIUM, GL_TRUE); 179 glPixelStorei(GL_UNPACK_PREMULTIPLY_ALPHA_CHROMIUM, GL_TRUE); 180 glCopyTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 0, GL_RGBA, 181 GL_UNSIGNED_BYTE); 182 EXPECT_TRUE(GL_NO_ERROR == glGetError()); 183 184 uint8 copied_pixels[2][2][4] = {{{0}}}; 185 glReadPixels(0, 0, 2, 2, GL_RGBA, GL_UNSIGNED_BYTE, copied_pixels); 186 for (int x = 0; x < 2; ++x) { 187 for (int y = 0; y < 2; ++y) { 188 EXPECT_EQ(pixels[1-y][x][0] / 2, copied_pixels[y][x][0]); 189 EXPECT_EQ(pixels[1-y][x][1] / 2, copied_pixels[y][x][1]); 190 EXPECT_EQ(pixels[1-y][x][2] / 2, copied_pixels[y][x][2]); 191 EXPECT_EQ(pixels[1-y][x][3], copied_pixels[y][x][3]); 192 } 193 } 194 195 EXPECT_TRUE(GL_NO_ERROR == glGetError()); 196 } 197 198 TEST_F(GLCopyTextureCHROMIUMTest, FlipYAndUnpremultiplyAlpha) { 199 uint8 pixels[2][2][4]; 200 for (int x = 0; x < 2; ++x) { 201 for (int y = 0; y < 2; ++y) { 202 uint8 color = 16 * x + 16 * y; 203 pixels[y][x][0] = color; 204 pixels[y][x][1] = color; 205 pixels[y][x][2] = color; 206 pixels[y][x][3] = 128u; 207 } 208 } 209 210 glBindTexture(GL_TEXTURE_2D, textures_[0]); 211 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, 212 pixels); 213 214 glPixelStorei(GL_UNPACK_FLIP_Y_CHROMIUM, GL_TRUE); 215 glPixelStorei(GL_UNPACK_UNPREMULTIPLY_ALPHA_CHROMIUM, GL_TRUE); 216 glCopyTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 0, GL_RGBA, 217 GL_UNSIGNED_BYTE); 218 EXPECT_TRUE(GL_NO_ERROR == glGetError()); 219 220 uint8 copied_pixels[2][2][4] = {{{0}}}; 221 glReadPixels(0, 0, 2, 2, GL_RGBA, GL_UNSIGNED_BYTE, copied_pixels); 222 for (int x = 0; x < 2; ++x) { 223 for (int y = 0; y < 2; ++y) { 224 EXPECT_EQ(pixels[1-y][x][0] * 2, copied_pixels[y][x][0]); 225 EXPECT_EQ(pixels[1-y][x][1] * 2, copied_pixels[y][x][1]); 226 EXPECT_EQ(pixels[1-y][x][2] * 2, copied_pixels[y][x][2]); 227 EXPECT_EQ(pixels[1-y][x][3], copied_pixels[y][x][3]); 228 } 229 } 230 231 EXPECT_TRUE(GL_NO_ERROR == glGetError()); 232 } 233 234 namespace { 235 236 void glEnableDisable(GLint param, GLboolean value) { 237 if (value) 238 glEnable(param); 239 else 240 glDisable(param); 241 } 242 243 } // unnamed namespace 244 245 // Validate that some basic GL state is not touched upon execution of 246 // the extension. 247 TEST_F(GLCopyTextureCHROMIUMTest, BasicStatePreservation) { 248 uint8 pixels[1 * 4] = { 255u, 0u, 0u, 255u }; 249 250 glBindFramebuffer(GL_FRAMEBUFFER, 0); 251 252 glBindTexture(GL_TEXTURE_2D, textures_[0]); 253 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 254 pixels); 255 256 GLboolean reference_settings[2] = { GL_TRUE, GL_FALSE }; 257 for (int x = 0; x < 2; ++x) { 258 GLboolean setting = reference_settings[x]; 259 glEnableDisable(GL_DEPTH_TEST, setting); 260 glEnableDisable(GL_SCISSOR_TEST, setting); 261 glEnableDisable(GL_STENCIL_TEST, setting); 262 glEnableDisable(GL_CULL_FACE, setting); 263 glEnableDisable(GL_BLEND, setting); 264 glColorMask(setting, setting, setting, setting); 265 glDepthMask(setting); 266 267 glActiveTexture(GL_TEXTURE1 + x); 268 269 glCopyTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 0, 270 GL_RGBA, GL_UNSIGNED_BYTE); 271 EXPECT_TRUE(GL_NO_ERROR == glGetError()); 272 273 EXPECT_EQ(setting, glIsEnabled(GL_DEPTH_TEST)); 274 EXPECT_EQ(setting, glIsEnabled(GL_SCISSOR_TEST)); 275 EXPECT_EQ(setting, glIsEnabled(GL_STENCIL_TEST)); 276 EXPECT_EQ(setting, glIsEnabled(GL_CULL_FACE)); 277 EXPECT_EQ(setting, glIsEnabled(GL_BLEND)); 278 279 GLboolean bool_array[4] = { GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE }; 280 glGetBooleanv(GL_DEPTH_WRITEMASK, bool_array); 281 EXPECT_EQ(setting, bool_array[0]); 282 283 bool_array[0] = GL_FALSE; 284 glGetBooleanv(GL_COLOR_WRITEMASK, bool_array); 285 EXPECT_EQ(setting, bool_array[0]); 286 EXPECT_EQ(setting, bool_array[1]); 287 EXPECT_EQ(setting, bool_array[2]); 288 EXPECT_EQ(setting, bool_array[3]); 289 290 GLint active_texture = 0; 291 glGetIntegerv(GL_ACTIVE_TEXTURE, &active_texture); 292 EXPECT_EQ(GL_TEXTURE1 + x, active_texture); 293 } 294 295 EXPECT_TRUE(GL_NO_ERROR == glGetError()); 296 }; 297 298 // Verify that invocation of the extension does not modify the bound 299 // texture state. 300 TEST_F(GLCopyTextureCHROMIUMTest, TextureStatePreserved) { 301 // Setup the texture used for the extension invocation. 302 uint8 pixels[1 * 4] = { 255u, 0u, 0u, 255u }; 303 glBindTexture(GL_TEXTURE_2D, textures_[0]); 304 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 305 pixels); 306 307 GLuint texture_ids[2]; 308 glGenTextures(2, texture_ids); 309 310 glActiveTexture(GL_TEXTURE0); 311 glBindTexture(GL_TEXTURE_2D, texture_ids[0]); 312 313 glActiveTexture(GL_TEXTURE1); 314 glBindTexture(GL_TEXTURE_2D, texture_ids[1]); 315 316 glCopyTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 0, 317 GL_RGBA, GL_UNSIGNED_BYTE); 318 EXPECT_TRUE(GL_NO_ERROR == glGetError()); 319 320 GLint active_texture = 0; 321 glGetIntegerv(GL_ACTIVE_TEXTURE, &active_texture); 322 EXPECT_EQ(GL_TEXTURE1, active_texture); 323 324 GLint bound_texture = 0; 325 glGetIntegerv(GL_TEXTURE_BINDING_2D, &bound_texture); 326 EXPECT_EQ(texture_ids[1], static_cast<GLuint>(bound_texture)); 327 glBindTexture(GL_TEXTURE_2D, 0); 328 329 bound_texture = 0; 330 glActiveTexture(GL_TEXTURE0); 331 glGetIntegerv(GL_TEXTURE_BINDING_2D, &bound_texture); 332 EXPECT_EQ(texture_ids[0], static_cast<GLuint>(bound_texture)); 333 glBindTexture(GL_TEXTURE_2D, 0); 334 335 glDeleteTextures(2, texture_ids); 336 337 EXPECT_TRUE(GL_NO_ERROR == glGetError()); 338 } 339 340 // Verify that invocation of the extension does not perturb the currently 341 // bound FBO state. 342 TEST_F(GLCopyTextureCHROMIUMTest, FBOStatePreserved) { 343 // Setup the texture used for the extension invocation. 344 uint8 pixels[1 * 4] = { 255u, 0u, 0u, 255u }; 345 glBindTexture(GL_TEXTURE_2D, textures_[0]); 346 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 347 pixels); 348 349 GLuint texture_id; 350 glGenTextures(1, &texture_id); 351 glBindTexture(GL_TEXTURE_2D, texture_id); 352 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 353 0); 354 355 GLuint renderbuffer_id; 356 glGenRenderbuffers(1, &renderbuffer_id); 357 glBindRenderbuffer(GL_RENDERBUFFER, renderbuffer_id); 358 glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT16, 1, 1); 359 360 GLuint framebuffer_id; 361 glGenFramebuffers(1, &framebuffer_id); 362 glBindFramebuffer(GL_FRAMEBUFFER, framebuffer_id); 363 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 364 texture_id, 0); 365 glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, 366 GL_RENDERBUFFER, renderbuffer_id); 367 EXPECT_TRUE( 368 GL_FRAMEBUFFER_COMPLETE == glCheckFramebufferStatus(GL_FRAMEBUFFER)); 369 370 // Test that we can write to the bound framebuffer 371 uint8 expected_color[4] = { 255u, 255u, 0, 255u }; 372 glClearColor(1.0, 1.0, 0, 1.0); 373 glClear(GL_COLOR_BUFFER_BIT); 374 GLTestHelper::CheckPixels(0, 0, 1, 1, 0, expected_color); 375 376 glCopyTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 0, 377 GL_RGBA, GL_UNSIGNED_BYTE); 378 EXPECT_TRUE(GL_NO_ERROR == glGetError()); 379 380 EXPECT_TRUE(glIsFramebuffer(framebuffer_id)); 381 382 // Ensure that reading from the framebuffer produces correct pixels. 383 GLTestHelper::CheckPixels(0, 0, 1, 1, 0, expected_color); 384 385 uint8 expected_color2[4] = { 255u, 0, 255u, 255u }; 386 glClearColor(1.0, 0, 1.0, 1.0); 387 glClear(GL_COLOR_BUFFER_BIT); 388 GLTestHelper::CheckPixels(0, 0, 1, 1, 0, expected_color2); 389 390 GLint bound_fbo = 0; 391 glGetIntegerv(GL_FRAMEBUFFER_BINDING, &bound_fbo); 392 EXPECT_EQ(framebuffer_id, static_cast<GLuint>(bound_fbo)); 393 394 GLint fbo_params = 0; 395 glGetFramebufferAttachmentParameteriv(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, 396 GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE, 397 &fbo_params); 398 EXPECT_EQ(GL_TEXTURE, fbo_params); 399 400 fbo_params = 0; 401 glGetFramebufferAttachmentParameteriv(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, 402 GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME, 403 &fbo_params); 404 EXPECT_EQ(texture_id, static_cast<GLuint>(fbo_params)); 405 406 fbo_params = 0; 407 glGetFramebufferAttachmentParameteriv(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, 408 GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE, 409 &fbo_params); 410 EXPECT_EQ(GL_RENDERBUFFER, fbo_params); 411 412 fbo_params = 0; 413 glGetFramebufferAttachmentParameteriv(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, 414 GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME, 415 &fbo_params); 416 EXPECT_EQ(renderbuffer_id, static_cast<GLuint>(fbo_params)); 417 418 glDeleteRenderbuffers(1, &renderbuffer_id); 419 glDeleteTextures(1, &texture_id); 420 glDeleteFramebuffers(1, &framebuffer_id); 421 422 EXPECT_TRUE(GL_NO_ERROR == glGetError()); 423 } 424 425 TEST_F(GLCopyTextureCHROMIUMTest, ProgramStatePreservation) { 426 // unbind the one created in setup. 427 glBindFramebuffer(GL_FRAMEBUFFER, 0); 428 glBindTexture(GL_TEXTURE_2D, 0); 429 430 GLManager gl2; 431 GLManager::Options options; 432 options.size = gfx::Size(16, 16); 433 options.share_group_manager = &gl_; 434 gl2.Initialize(options); 435 gl_.MakeCurrent(); 436 437 static const char* v_shader_str = 438 "attribute vec4 g_Position;\n" 439 "void main()\n" 440 "{\n" 441 " gl_Position = g_Position;\n" 442 "}\n"; 443 static const char* f_shader_str = 444 "precision mediump float;\n" 445 "void main()\n" 446 "{\n" 447 " gl_FragColor = vec4(0,1,0,1);\n" 448 "}\n"; 449 450 GLuint program = GLTestHelper::LoadProgram(v_shader_str, f_shader_str); 451 glUseProgram(program); 452 GLuint position_loc = glGetAttribLocation(program, "g_Position"); 453 glFlush(); 454 455 // Delete program from other context. 456 gl2.MakeCurrent(); 457 glDeleteProgram(program); 458 EXPECT_TRUE(GL_NO_ERROR == glGetError()); 459 glFlush(); 460 461 // Program should still be usable on this context. 462 gl_.MakeCurrent(); 463 464 GLTestHelper::SetupUnitQuad(position_loc); 465 466 // test using program before 467 uint8 expected[] = { 0, 255, 0, 255, }; 468 uint8 zero[] = { 0, 0, 0, 0, }; 469 glClear(GL_COLOR_BUFFER_BIT); 470 EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, 1, 1, 0, zero)); 471 glDrawArrays(GL_TRIANGLES, 0, 6); 472 EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, 1, 1, 0, expected)); 473 474 // Call copyTextureCHROMIUM 475 uint8 pixels[1 * 4] = { 255u, 0u, 0u, 255u }; 476 glBindTexture(GL_TEXTURE_2D, textures_[0]); 477 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 478 pixels); 479 glCopyTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 0, GL_RGBA, 480 GL_UNSIGNED_BYTE); 481 482 // test using program after 483 glClear(GL_COLOR_BUFFER_BIT); 484 EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, 1, 1, 0, zero)); 485 glDrawArrays(GL_TRIANGLES, 0, 6); 486 EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, 1, 1, 0, expected)); 487 488 EXPECT_TRUE(GL_NO_ERROR == glGetError()); 489 490 gl2.MakeCurrent(); 491 gl2.Destroy(); 492 gl_.MakeCurrent(); 493 } 494 495 // Test that glCopyTextureCHROMIUM doesn't leak uninitialized textures. 496 TEST_F(GLCopyTextureCHROMIUMTest, UninitializedSource) { 497 const GLsizei kWidth = 64, kHeight = 64; 498 glBindTexture(GL_TEXTURE_2D, textures_[0]); 499 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, kWidth, kHeight, 500 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); 501 502 glCopyTextureCHROMIUM(GL_TEXTURE_2D, textures_[0], textures_[1], 0, GL_RGBA, 503 GL_UNSIGNED_BYTE); 504 EXPECT_TRUE(GL_NO_ERROR == glGetError()); 505 506 uint8 pixels[kHeight][kWidth][4] = {{{1}}}; 507 glReadPixels(0, 0, kWidth, kHeight, GL_RGBA, GL_UNSIGNED_BYTE, pixels); 508 for (int x = 0; x < kWidth; ++x) { 509 for (int y = 0; y < kHeight; ++y) { 510 EXPECT_EQ(0, pixels[y][x][0]); 511 EXPECT_EQ(0, pixels[y][x][1]); 512 EXPECT_EQ(0, pixels[y][x][2]); 513 EXPECT_EQ(0, pixels[y][x][3]); 514 } 515 } 516 517 EXPECT_TRUE(GL_NO_ERROR == glGetError()); 518 } 519 520 } // namespace gpu 521
