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 #include "gpu/command_buffer/service/test_helper.h" 6 7 #include <algorithm> 8 #include <string> 9 10 #include "base/strings/string_number_conversions.h" 11 #include "base/strings/string_tokenizer.h" 12 #include "gpu/command_buffer/service/buffer_manager.h" 13 #include "gpu/command_buffer/service/error_state_mock.h" 14 #include "gpu/command_buffer/service/gl_utils.h" 15 #include "gpu/command_buffer/service/gpu_switches.h" 16 #include "gpu/command_buffer/service/mocks.h" 17 #include "gpu/command_buffer/service/program_manager.h" 18 #include "gpu/command_buffer/service/texture_manager.h" 19 #include "testing/gtest/include/gtest/gtest.h" 20 #include "ui/gl/gl_mock.h" 21 22 using ::testing::_; 23 using ::testing::DoAll; 24 using ::testing::InSequence; 25 using ::testing::MatcherCast; 26 using ::testing::Pointee; 27 using ::testing::NotNull; 28 using ::testing::Return; 29 using ::testing::SetArrayArgument; 30 using ::testing::SetArgumentPointee; 31 using ::testing::StrEq; 32 using ::testing::StrictMock; 33 34 namespace gpu { 35 namespace gles2 { 36 37 // GCC requires these declarations, but MSVC requires they not be present 38 #ifndef COMPILER_MSVC 39 const GLuint TestHelper::kServiceBlackTexture2dId; 40 const GLuint TestHelper::kServiceDefaultTexture2dId; 41 const GLuint TestHelper::kServiceBlackTextureCubemapId; 42 const GLuint TestHelper::kServiceDefaultTextureCubemapId; 43 const GLuint TestHelper::kServiceBlackExternalTextureId; 44 const GLuint TestHelper::kServiceDefaultExternalTextureId; 45 const GLuint TestHelper::kServiceBlackRectangleTextureId; 46 const GLuint TestHelper::kServiceDefaultRectangleTextureId; 47 48 const GLint TestHelper::kMaxSamples; 49 const GLint TestHelper::kMaxRenderbufferSize; 50 const GLint TestHelper::kMaxTextureSize; 51 const GLint TestHelper::kMaxCubeMapTextureSize; 52 const GLint TestHelper::kNumVertexAttribs; 53 const GLint TestHelper::kNumTextureUnits; 54 const GLint TestHelper::kMaxTextureImageUnits; 55 const GLint TestHelper::kMaxVertexTextureImageUnits; 56 const GLint TestHelper::kMaxFragmentUniformVectors; 57 const GLint TestHelper::kMaxFragmentUniformComponents; 58 const GLint TestHelper::kMaxVaryingVectors; 59 const GLint TestHelper::kMaxVaryingFloats; 60 const GLint TestHelper::kMaxVertexUniformVectors; 61 const GLint TestHelper::kMaxVertexUniformComponents; 62 #endif 63 64 void TestHelper::SetupTextureInitializationExpectations( 65 ::gfx::MockGLInterface* gl, 66 GLenum target, 67 bool use_default_textures) { 68 InSequence sequence; 69 70 bool needs_initialization = (target != GL_TEXTURE_EXTERNAL_OES); 71 bool needs_faces = (target == GL_TEXTURE_CUBE_MAP); 72 73 static GLuint texture_2d_ids[] = { 74 kServiceBlackTexture2dId, 75 kServiceDefaultTexture2dId }; 76 static GLuint texture_cube_map_ids[] = { 77 kServiceBlackTextureCubemapId, 78 kServiceDefaultTextureCubemapId }; 79 static GLuint texture_external_oes_ids[] = { 80 kServiceBlackExternalTextureId, 81 kServiceDefaultExternalTextureId }; 82 static GLuint texture_rectangle_arb_ids[] = { 83 kServiceBlackRectangleTextureId, 84 kServiceDefaultRectangleTextureId }; 85 86 const GLuint* texture_ids = NULL; 87 switch (target) { 88 case GL_TEXTURE_2D: 89 texture_ids = &texture_2d_ids[0]; 90 break; 91 case GL_TEXTURE_CUBE_MAP: 92 texture_ids = &texture_cube_map_ids[0]; 93 break; 94 case GL_TEXTURE_EXTERNAL_OES: 95 texture_ids = &texture_external_oes_ids[0]; 96 break; 97 case GL_TEXTURE_RECTANGLE_ARB: 98 texture_ids = &texture_rectangle_arb_ids[0]; 99 break; 100 default: 101 NOTREACHED(); 102 } 103 104 int array_size = use_default_textures ? 2 : 1; 105 106 EXPECT_CALL(*gl, GenTextures(array_size, _)) 107 .WillOnce(SetArrayArgument<1>(texture_ids, 108 texture_ids + array_size)) 109 .RetiresOnSaturation(); 110 for (int ii = 0; ii < array_size; ++ii) { 111 EXPECT_CALL(*gl, BindTexture(target, texture_ids[ii])) 112 .Times(1) 113 .RetiresOnSaturation(); 114 if (needs_initialization) { 115 if (needs_faces) { 116 static GLenum faces[] = { 117 GL_TEXTURE_CUBE_MAP_POSITIVE_X, 118 GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 119 GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 120 GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 121 GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 122 GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 123 }; 124 for (size_t ii = 0; ii < arraysize(faces); ++ii) { 125 EXPECT_CALL(*gl, TexImage2D(faces[ii], 0, GL_RGBA, 1, 1, 0, GL_RGBA, 126 GL_UNSIGNED_BYTE, _)) 127 .Times(1) 128 .RetiresOnSaturation(); 129 } 130 } else { 131 EXPECT_CALL(*gl, TexImage2D(target, 0, GL_RGBA, 1, 1, 0, GL_RGBA, 132 GL_UNSIGNED_BYTE, _)) 133 .Times(1) 134 .RetiresOnSaturation(); 135 } 136 } 137 } 138 EXPECT_CALL(*gl, BindTexture(target, 0)) 139 .Times(1) 140 .RetiresOnSaturation(); 141 } 142 143 void TestHelper::SetupTextureManagerInitExpectations( 144 ::gfx::MockGLInterface* gl, 145 const char* extensions, 146 bool use_default_textures) { 147 InSequence sequence; 148 149 SetupTextureInitializationExpectations( 150 gl, GL_TEXTURE_2D, use_default_textures); 151 SetupTextureInitializationExpectations( 152 gl, GL_TEXTURE_CUBE_MAP, use_default_textures); 153 154 bool ext_image_external = false; 155 bool arb_texture_rectangle = false; 156 base::CStringTokenizer t(extensions, extensions + strlen(extensions), " "); 157 while (t.GetNext()) { 158 if (t.token() == "GL_OES_EGL_image_external") { 159 ext_image_external = true; 160 break; 161 } 162 if (t.token() == "GL_ARB_texture_rectangle") { 163 arb_texture_rectangle = true; 164 break; 165 } 166 } 167 168 if (ext_image_external) { 169 SetupTextureInitializationExpectations( 170 gl, GL_TEXTURE_EXTERNAL_OES, use_default_textures); 171 } 172 if (arb_texture_rectangle) { 173 SetupTextureInitializationExpectations( 174 gl, GL_TEXTURE_RECTANGLE_ARB, use_default_textures); 175 } 176 } 177 178 void TestHelper::SetupTextureDestructionExpectations( 179 ::gfx::MockGLInterface* gl, 180 GLenum target, 181 bool use_default_textures) { 182 if (!use_default_textures) 183 return; 184 185 GLuint texture_id = 0; 186 switch (target) { 187 case GL_TEXTURE_2D: 188 texture_id = kServiceDefaultTexture2dId; 189 break; 190 case GL_TEXTURE_CUBE_MAP: 191 texture_id = kServiceDefaultTextureCubemapId; 192 break; 193 case GL_TEXTURE_EXTERNAL_OES: 194 texture_id = kServiceDefaultExternalTextureId; 195 break; 196 case GL_TEXTURE_RECTANGLE_ARB: 197 texture_id = kServiceDefaultRectangleTextureId; 198 break; 199 default: 200 NOTREACHED(); 201 } 202 203 EXPECT_CALL(*gl, DeleteTextures(1, Pointee(texture_id))) 204 .Times(1) 205 .RetiresOnSaturation(); 206 } 207 208 void TestHelper::SetupTextureManagerDestructionExpectations( 209 ::gfx::MockGLInterface* gl, 210 const char* extensions, 211 bool use_default_textures) { 212 SetupTextureDestructionExpectations(gl, GL_TEXTURE_2D, use_default_textures); 213 SetupTextureDestructionExpectations( 214 gl, GL_TEXTURE_CUBE_MAP, use_default_textures); 215 216 bool ext_image_external = false; 217 bool arb_texture_rectangle = false; 218 base::CStringTokenizer t(extensions, extensions + strlen(extensions), " "); 219 while (t.GetNext()) { 220 if (t.token() == "GL_OES_EGL_image_external") { 221 ext_image_external = true; 222 break; 223 } 224 if (t.token() == "GL_ARB_texture_rectangle") { 225 arb_texture_rectangle = true; 226 break; 227 } 228 } 229 230 if (ext_image_external) { 231 SetupTextureDestructionExpectations( 232 gl, GL_TEXTURE_EXTERNAL_OES, use_default_textures); 233 } 234 if (arb_texture_rectangle) { 235 SetupTextureDestructionExpectations( 236 gl, GL_TEXTURE_RECTANGLE_ARB, use_default_textures); 237 } 238 239 EXPECT_CALL(*gl, DeleteTextures(4, _)) 240 .Times(1) 241 .RetiresOnSaturation(); 242 } 243 244 void TestHelper::SetupContextGroupInitExpectations( 245 ::gfx::MockGLInterface* gl, 246 const DisallowedFeatures& disallowed_features, 247 const char* extensions, 248 const char* gl_version, 249 bool bind_generates_resource) { 250 InSequence sequence; 251 252 SetupFeatureInfoInitExpectationsWithGLVersion(gl, extensions, "", gl_version); 253 254 std::string l_version(base::StringToLowerASCII(std::string(gl_version))); 255 bool is_es3 = (l_version.substr(0, 12) == "opengl es 3."); 256 257 EXPECT_CALL(*gl, GetIntegerv(GL_MAX_RENDERBUFFER_SIZE, _)) 258 .WillOnce(SetArgumentPointee<1>(kMaxRenderbufferSize)) 259 .RetiresOnSaturation(); 260 if (strstr(extensions, "GL_EXT_framebuffer_multisample") || 261 strstr(extensions, "GL_EXT_multisampled_render_to_texture") || is_es3) { 262 EXPECT_CALL(*gl, GetIntegerv(GL_MAX_SAMPLES, _)) 263 .WillOnce(SetArgumentPointee<1>(kMaxSamples)) 264 .RetiresOnSaturation(); 265 } else if (strstr(extensions, "GL_IMG_multisampled_render_to_texture")) { 266 EXPECT_CALL(*gl, GetIntegerv(GL_MAX_SAMPLES_IMG, _)) 267 .WillOnce(SetArgumentPointee<1>(kMaxSamples)) 268 .RetiresOnSaturation(); 269 } 270 EXPECT_CALL(*gl, GetIntegerv(GL_MAX_VERTEX_ATTRIBS, _)) 271 .WillOnce(SetArgumentPointee<1>(kNumVertexAttribs)) 272 .RetiresOnSaturation(); 273 EXPECT_CALL(*gl, GetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, _)) 274 .WillOnce(SetArgumentPointee<1>(kNumTextureUnits)) 275 .RetiresOnSaturation(); 276 EXPECT_CALL(*gl, GetIntegerv(GL_MAX_TEXTURE_SIZE, _)) 277 .WillOnce(SetArgumentPointee<1>(kMaxTextureSize)) 278 .RetiresOnSaturation(); 279 EXPECT_CALL(*gl, GetIntegerv(GL_MAX_CUBE_MAP_TEXTURE_SIZE, _)) 280 .WillOnce(SetArgumentPointee<1>(kMaxCubeMapTextureSize)) 281 .RetiresOnSaturation(); 282 EXPECT_CALL(*gl, GetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, _)) 283 .WillOnce(SetArgumentPointee<1>(kMaxTextureImageUnits)) 284 .RetiresOnSaturation(); 285 EXPECT_CALL(*gl, GetIntegerv(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS, _)) 286 .WillOnce(SetArgumentPointee<1>(kMaxVertexTextureImageUnits)) 287 .RetiresOnSaturation(); 288 EXPECT_CALL(*gl, GetIntegerv(GL_MAX_FRAGMENT_UNIFORM_COMPONENTS, _)) 289 .WillOnce(SetArgumentPointee<1>(kMaxFragmentUniformComponents)) 290 .RetiresOnSaturation(); 291 EXPECT_CALL(*gl, GetIntegerv(GL_MAX_VARYING_FLOATS, _)) 292 .WillOnce(SetArgumentPointee<1>(kMaxVaryingFloats)) 293 .RetiresOnSaturation(); 294 EXPECT_CALL(*gl, GetIntegerv(GL_MAX_VERTEX_UNIFORM_COMPONENTS, _)) 295 .WillOnce(SetArgumentPointee<1>(kMaxVertexUniformComponents)) 296 .RetiresOnSaturation(); 297 298 bool use_default_textures = bind_generates_resource; 299 SetupTextureManagerInitExpectations(gl, extensions, use_default_textures); 300 } 301 302 void TestHelper::SetupFeatureInfoInitExpectations( 303 ::gfx::MockGLInterface* gl, const char* extensions) { 304 SetupFeatureInfoInitExpectationsWithGLVersion(gl, extensions, "", ""); 305 } 306 307 void TestHelper::SetupFeatureInfoInitExpectationsWithGLVersion( 308 ::gfx::MockGLInterface* gl, 309 const char* extensions, 310 const char* gl_renderer, 311 const char* gl_version) { 312 InSequence sequence; 313 314 EXPECT_CALL(*gl, GetString(GL_EXTENSIONS)) 315 .WillOnce(Return(reinterpret_cast<const uint8*>(extensions))) 316 .RetiresOnSaturation(); 317 EXPECT_CALL(*gl, GetString(GL_RENDERER)) 318 .WillOnce(Return(reinterpret_cast<const uint8*>(gl_renderer))) 319 .RetiresOnSaturation(); 320 EXPECT_CALL(*gl, GetString(GL_VERSION)) 321 .WillOnce(Return(reinterpret_cast<const uint8*>(gl_version))) 322 .RetiresOnSaturation(); 323 324 std::string l_version(base::StringToLowerASCII(std::string(gl_version))); 325 bool is_es3 = (l_version.substr(0, 12) == "opengl es 3."); 326 327 if (strstr(extensions, "GL_ARB_texture_float") || 328 (is_es3 && strstr(extensions, "GL_EXT_color_buffer_float"))) { 329 static const GLuint gl_ids[] = {101, 102}; 330 const GLsizei width = 16; 331 EXPECT_CALL(*gl, GetIntegerv(GL_FRAMEBUFFER_BINDING, _)) 332 .WillOnce(SetArgumentPointee<1>(gl_ids[0])) 333 .RetiresOnSaturation(); 334 EXPECT_CALL(*gl, GetIntegerv(GL_TEXTURE_BINDING_2D, _)) 335 .WillOnce(SetArgumentPointee<1>(gl_ids[0])) 336 .RetiresOnSaturation(); 337 EXPECT_CALL(*gl, GenTextures(1, _)) 338 .WillOnce(SetArrayArgument<1>(gl_ids + 1, gl_ids + 2)) 339 .RetiresOnSaturation(); 340 EXPECT_CALL(*gl, GenFramebuffersEXT(1, _)) 341 .WillOnce(SetArrayArgument<1>(gl_ids + 1, gl_ids + 2)) 342 .RetiresOnSaturation(); 343 EXPECT_CALL(*gl, BindTexture(GL_TEXTURE_2D, gl_ids[1])) 344 .Times(1) 345 .RetiresOnSaturation(); 346 EXPECT_CALL(*gl, TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, 347 GL_NEAREST)) 348 .Times(1) 349 .RetiresOnSaturation(); 350 EXPECT_CALL(*gl, TexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, width, width, 0, 351 GL_RGBA, GL_FLOAT, _)) 352 .Times(1) 353 .RetiresOnSaturation(); 354 EXPECT_CALL(*gl, BindFramebufferEXT(GL_FRAMEBUFFER, gl_ids[1])) 355 .Times(1) 356 .RetiresOnSaturation(); 357 EXPECT_CALL(*gl, FramebufferTexture2DEXT(GL_FRAMEBUFFER, 358 GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, gl_ids[1], 0)) 359 .Times(1) 360 .RetiresOnSaturation(); 361 EXPECT_CALL(*gl, CheckFramebufferStatusEXT(GL_FRAMEBUFFER)) 362 .WillOnce(Return(GL_FRAMEBUFFER_COMPLETE)) 363 .RetiresOnSaturation(); 364 EXPECT_CALL(*gl, TexImage2D(GL_TEXTURE_2D, 0, GL_RGB32F, width, width, 0, 365 GL_RGB, GL_FLOAT, _)) 366 .Times(1) 367 .RetiresOnSaturation(); 368 if (is_es3) { 369 EXPECT_CALL(*gl, CheckFramebufferStatusEXT(GL_FRAMEBUFFER)) 370 .WillOnce(Return(GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT)) 371 .RetiresOnSaturation(); 372 } else { 373 EXPECT_CALL(*gl, CheckFramebufferStatusEXT(GL_FRAMEBUFFER)) 374 .WillOnce(Return(GL_FRAMEBUFFER_COMPLETE)) 375 .RetiresOnSaturation(); 376 } 377 EXPECT_CALL(*gl, DeleteFramebuffersEXT(1, _)) 378 .Times(1) 379 .RetiresOnSaturation(); 380 EXPECT_CALL(*gl, DeleteTextures(1, _)) 381 .Times(1) 382 .RetiresOnSaturation(); 383 EXPECT_CALL(*gl, BindFramebufferEXT(GL_FRAMEBUFFER, gl_ids[0])) 384 .Times(1) 385 .RetiresOnSaturation(); 386 EXPECT_CALL(*gl, BindTexture(GL_TEXTURE_2D, gl_ids[0])) 387 .Times(1) 388 .RetiresOnSaturation(); 389 #if DCHECK_IS_ON 390 EXPECT_CALL(*gl, GetError()) 391 .WillOnce(Return(GL_NO_ERROR)) 392 .RetiresOnSaturation(); 393 #endif 394 } 395 } 396 397 void TestHelper::SetupExpectationsForClearingUniforms( 398 ::gfx::MockGLInterface* gl, UniformInfo* uniforms, size_t num_uniforms) { 399 for (size_t ii = 0; ii < num_uniforms; ++ii) { 400 const UniformInfo& info = uniforms[ii]; 401 switch (info.type) { 402 case GL_FLOAT: 403 EXPECT_CALL(*gl, Uniform1fv(info.real_location, info.size, _)) 404 .Times(1) 405 .RetiresOnSaturation(); 406 break; 407 case GL_FLOAT_VEC2: 408 EXPECT_CALL(*gl, Uniform2fv(info.real_location, info.size, _)) 409 .Times(1) 410 .RetiresOnSaturation(); 411 break; 412 case GL_FLOAT_VEC3: 413 EXPECT_CALL(*gl, Uniform3fv(info.real_location, info.size, _)) 414 .Times(1) 415 .RetiresOnSaturation(); 416 break; 417 case GL_FLOAT_VEC4: 418 EXPECT_CALL(*gl, Uniform4fv(info.real_location, info.size, _)) 419 .Times(1) 420 .RetiresOnSaturation(); 421 break; 422 case GL_INT: 423 case GL_BOOL: 424 case GL_SAMPLER_2D: 425 case GL_SAMPLER_CUBE: 426 case GL_SAMPLER_EXTERNAL_OES: 427 case GL_SAMPLER_3D_OES: 428 case GL_SAMPLER_2D_RECT_ARB: 429 EXPECT_CALL(*gl, Uniform1iv(info.real_location, info.size, _)) 430 .Times(1) 431 .RetiresOnSaturation(); 432 break; 433 case GL_INT_VEC2: 434 case GL_BOOL_VEC2: 435 EXPECT_CALL(*gl, Uniform2iv(info.real_location, info.size, _)) 436 .Times(1) 437 .RetiresOnSaturation(); 438 break; 439 case GL_INT_VEC3: 440 case GL_BOOL_VEC3: 441 EXPECT_CALL(*gl, Uniform3iv(info.real_location, info.size, _)) 442 .Times(1) 443 .RetiresOnSaturation(); 444 break; 445 case GL_INT_VEC4: 446 case GL_BOOL_VEC4: 447 EXPECT_CALL(*gl, Uniform4iv(info.real_location, info.size, _)) 448 .Times(1) 449 .RetiresOnSaturation(); 450 break; 451 case GL_FLOAT_MAT2: 452 EXPECT_CALL(*gl, UniformMatrix2fv( 453 info.real_location, info.size, false, _)) 454 .Times(1) 455 .RetiresOnSaturation(); 456 break; 457 case GL_FLOAT_MAT3: 458 EXPECT_CALL(*gl, UniformMatrix3fv( 459 info.real_location, info.size, false, _)) 460 .Times(1) 461 .RetiresOnSaturation(); 462 break; 463 case GL_FLOAT_MAT4: 464 EXPECT_CALL(*gl, UniformMatrix4fv( 465 info.real_location, info.size, false, _)) 466 .Times(1) 467 .RetiresOnSaturation(); 468 break; 469 default: 470 NOTREACHED(); 471 break; 472 } 473 } 474 } 475 476 void TestHelper::SetupProgramSuccessExpectations( 477 ::gfx::MockGLInterface* gl, 478 AttribInfo* attribs, size_t num_attribs, 479 UniformInfo* uniforms, size_t num_uniforms, 480 GLuint service_id) { 481 EXPECT_CALL(*gl, 482 GetProgramiv(service_id, GL_LINK_STATUS, _)) 483 .WillOnce(SetArgumentPointee<2>(1)) 484 .RetiresOnSaturation(); 485 EXPECT_CALL(*gl, 486 GetProgramiv(service_id, GL_INFO_LOG_LENGTH, _)) 487 .WillOnce(SetArgumentPointee<2>(0)) 488 .RetiresOnSaturation(); 489 EXPECT_CALL(*gl, 490 GetProgramiv(service_id, GL_ACTIVE_ATTRIBUTES, _)) 491 .WillOnce(SetArgumentPointee<2>(num_attribs)) 492 .RetiresOnSaturation(); 493 size_t max_attrib_len = 0; 494 for (size_t ii = 0; ii < num_attribs; ++ii) { 495 size_t len = strlen(attribs[ii].name) + 1; 496 max_attrib_len = std::max(max_attrib_len, len); 497 } 498 EXPECT_CALL(*gl, 499 GetProgramiv(service_id, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, _)) 500 .WillOnce(SetArgumentPointee<2>(max_attrib_len)) 501 .RetiresOnSaturation(); 502 503 for (size_t ii = 0; ii < num_attribs; ++ii) { 504 const AttribInfo& info = attribs[ii]; 505 EXPECT_CALL(*gl, 506 GetActiveAttrib(service_id, ii, 507 max_attrib_len, _, _, _, _)) 508 .WillOnce(DoAll( 509 SetArgumentPointee<3>(strlen(info.name)), 510 SetArgumentPointee<4>(info.size), 511 SetArgumentPointee<5>(info.type), 512 SetArrayArgument<6>(info.name, 513 info.name + strlen(info.name) + 1))) 514 .RetiresOnSaturation(); 515 if (!ProgramManager::IsInvalidPrefix(info.name, strlen(info.name))) { 516 EXPECT_CALL(*gl, GetAttribLocation(service_id, StrEq(info.name))) 517 .WillOnce(Return(info.location)) 518 .RetiresOnSaturation(); 519 } 520 } 521 EXPECT_CALL(*gl, 522 GetProgramiv(service_id, GL_ACTIVE_UNIFORMS, _)) 523 .WillOnce(SetArgumentPointee<2>(num_uniforms)) 524 .RetiresOnSaturation(); 525 526 size_t max_uniform_len = 0; 527 for (size_t ii = 0; ii < num_uniforms; ++ii) { 528 size_t len = strlen(uniforms[ii].name) + 1; 529 max_uniform_len = std::max(max_uniform_len, len); 530 } 531 EXPECT_CALL(*gl, 532 GetProgramiv(service_id, GL_ACTIVE_UNIFORM_MAX_LENGTH, _)) 533 .WillOnce(SetArgumentPointee<2>(max_uniform_len)) 534 .RetiresOnSaturation(); 535 for (size_t ii = 0; ii < num_uniforms; ++ii) { 536 const UniformInfo& info = uniforms[ii]; 537 EXPECT_CALL(*gl, 538 GetActiveUniform(service_id, ii, 539 max_uniform_len, _, _, _, _)) 540 .WillOnce(DoAll( 541 SetArgumentPointee<3>(strlen(info.name)), 542 SetArgumentPointee<4>(info.size), 543 SetArgumentPointee<5>(info.type), 544 SetArrayArgument<6>(info.name, 545 info.name + strlen(info.name) + 1))) 546 .RetiresOnSaturation(); 547 } 548 549 for (int pass = 0; pass < 2; ++pass) { 550 for (size_t ii = 0; ii < num_uniforms; ++ii) { 551 const UniformInfo& info = uniforms[ii]; 552 if (ProgramManager::IsInvalidPrefix(info.name, strlen(info.name))) { 553 continue; 554 } 555 if (pass == 0) { 556 EXPECT_CALL(*gl, GetUniformLocation(service_id, StrEq(info.name))) 557 .WillOnce(Return(info.real_location)) 558 .RetiresOnSaturation(); 559 } 560 if ((pass == 0 && info.desired_location >= 0) || 561 (pass == 1 && info.desired_location < 0)) { 562 if (info.size > 1) { 563 std::string base_name = info.name; 564 size_t array_pos = base_name.rfind("[0]"); 565 if (base_name.size() > 3 && array_pos == base_name.size() - 3) { 566 base_name = base_name.substr(0, base_name.size() - 3); 567 } 568 for (GLsizei jj = 1; jj < info.size; ++jj) { 569 std::string element_name( 570 std::string(base_name) + "[" + base::IntToString(jj) + "]"); 571 EXPECT_CALL(*gl, GetUniformLocation( 572 service_id, StrEq(element_name))) 573 .WillOnce(Return(info.real_location + jj * 2)) 574 .RetiresOnSaturation(); 575 } 576 } 577 } 578 } 579 } 580 } 581 582 void TestHelper::SetupShader( 583 ::gfx::MockGLInterface* gl, 584 AttribInfo* attribs, size_t num_attribs, 585 UniformInfo* uniforms, size_t num_uniforms, 586 GLuint service_id) { 587 InSequence s; 588 589 EXPECT_CALL(*gl, 590 LinkProgram(service_id)) 591 .Times(1) 592 .RetiresOnSaturation(); 593 594 SetupProgramSuccessExpectations( 595 gl, attribs, num_attribs, uniforms, num_uniforms, service_id); 596 } 597 598 void TestHelper::DoBufferData( 599 ::gfx::MockGLInterface* gl, MockErrorState* error_state, 600 BufferManager* manager, Buffer* buffer, GLsizeiptr size, GLenum usage, 601 const GLvoid* data, GLenum error) { 602 EXPECT_CALL(*error_state, CopyRealGLErrorsToWrapper(_, _, _)) 603 .Times(1) 604 .RetiresOnSaturation(); 605 if (manager->IsUsageClientSideArray(usage)) { 606 EXPECT_CALL(*gl, BufferData( 607 buffer->target(), 0, _, usage)) 608 .Times(1) 609 .RetiresOnSaturation(); 610 } else { 611 EXPECT_CALL(*gl, BufferData( 612 buffer->target(), size, _, usage)) 613 .Times(1) 614 .RetiresOnSaturation(); 615 } 616 EXPECT_CALL(*error_state, PeekGLError(_, _, _)) 617 .WillOnce(Return(error)) 618 .RetiresOnSaturation(); 619 manager->DoBufferData(error_state, buffer, size, usage, data); 620 } 621 622 void TestHelper::SetTexParameteriWithExpectations( 623 ::gfx::MockGLInterface* gl, MockErrorState* error_state, 624 TextureManager* manager, TextureRef* texture_ref, 625 GLenum pname, GLint value, GLenum error) { 626 if (error == GL_NO_ERROR) { 627 if (pname != GL_TEXTURE_POOL_CHROMIUM) { 628 EXPECT_CALL(*gl, TexParameteri(texture_ref->texture()->target(), 629 pname, value)) 630 .Times(1) 631 .RetiresOnSaturation(); 632 } 633 } else if (error == GL_INVALID_ENUM) { 634 EXPECT_CALL(*error_state, SetGLErrorInvalidEnum(_, _, _, value, _)) 635 .Times(1) 636 .RetiresOnSaturation(); 637 } else { 638 EXPECT_CALL(*error_state, SetGLErrorInvalidParami(_, _, error, _, _, _)) 639 .Times(1) 640 .RetiresOnSaturation(); 641 } 642 manager->SetParameteri("", error_state, texture_ref, pname, value); 643 } 644 645 // static 646 void TestHelper::SetShaderStates( 647 ::gfx::MockGLInterface* gl, Shader* shader, 648 bool expected_valid, 649 const std::string* const expected_log_info, 650 const std::string* const expected_translated_source, 651 const ShaderTranslatorInterface::VariableMap* const expected_attrib_map, 652 const ShaderTranslatorInterface::VariableMap* const expected_uniform_map, 653 const ShaderTranslatorInterface::VariableMap* const expected_varying_map, 654 const ShaderTranslatorInterface::NameMap* const expected_name_map) { 655 const std::string empty_log_info; 656 const std::string* log_info = (expected_log_info && !expected_valid) ? 657 expected_log_info : &empty_log_info; 658 const std::string empty_translated_source; 659 const std::string* translated_source = 660 (expected_translated_source && expected_valid) ? 661 expected_translated_source : &empty_translated_source; 662 const ShaderTranslatorInterface::VariableMap empty_attrib_map; 663 const ShaderTranslatorInterface::VariableMap* attrib_map = 664 (expected_attrib_map && expected_valid) ? 665 expected_attrib_map : &empty_attrib_map; 666 const ShaderTranslatorInterface::VariableMap empty_uniform_map; 667 const ShaderTranslatorInterface::VariableMap* uniform_map = 668 (expected_uniform_map && expected_valid) ? 669 expected_uniform_map : &empty_uniform_map; 670 const ShaderTranslatorInterface::VariableMap empty_varying_map; 671 const ShaderTranslatorInterface::VariableMap* varying_map = 672 (expected_varying_map && expected_valid) ? 673 expected_varying_map : &empty_varying_map; 674 const ShaderTranslatorInterface::NameMap empty_name_map; 675 const ShaderTranslatorInterface::NameMap* name_map = 676 (expected_name_map && expected_valid) ? 677 expected_name_map : &empty_name_map; 678 679 MockShaderTranslator translator; 680 EXPECT_CALL(translator, Translate(_, 681 NotNull(), // log_info 682 NotNull(), // translated_source 683 NotNull(), // attrib_map 684 NotNull(), // uniform_map 685 NotNull(), // varying_map 686 NotNull())) // name_map 687 .WillOnce(DoAll(SetArgumentPointee<1>(*log_info), 688 SetArgumentPointee<2>(*translated_source), 689 SetArgumentPointee<3>(*attrib_map), 690 SetArgumentPointee<4>(*uniform_map), 691 SetArgumentPointee<5>(*varying_map), 692 SetArgumentPointee<6>(*name_map), 693 Return(expected_valid))) 694 .RetiresOnSaturation(); 695 if (expected_valid) { 696 EXPECT_CALL(*gl, ShaderSource(shader->service_id(), 1, _, NULL)) 697 .Times(1) 698 .RetiresOnSaturation(); 699 EXPECT_CALL(*gl, CompileShader(shader->service_id())) 700 .Times(1) 701 .RetiresOnSaturation(); 702 EXPECT_CALL(*gl, GetShaderiv(shader->service_id(), 703 GL_COMPILE_STATUS, 704 NotNull())) // status 705 .WillOnce(SetArgumentPointee<2>(GL_TRUE)) 706 .RetiresOnSaturation(); 707 } 708 shader->DoCompile(&translator, Shader::kGL); 709 } 710 711 // static 712 void TestHelper::SetShaderStates( 713 ::gfx::MockGLInterface* gl, Shader* shader, bool valid) { 714 SetShaderStates(gl, shader, valid, NULL, NULL, NULL, NULL, NULL, NULL); 715 } 716 717 ScopedGLImplementationSetter::ScopedGLImplementationSetter( 718 gfx::GLImplementation implementation) 719 : old_implementation_(gfx::GetGLImplementation()) { 720 gfx::SetGLImplementation(implementation); 721 } 722 723 ScopedGLImplementationSetter::~ScopedGLImplementationSetter() { 724 gfx::SetGLImplementation(old_implementation_); 725 } 726 727 } // namespace gles2 728 } // namespace gpu 729 730
