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 GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_DECODER_UNITTEST_BASE_H_ 6 #define GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_DECODER_UNITTEST_BASE_H_ 7 8 #include "gpu/command_buffer/common/gles2_cmd_format.h" 9 #include "gpu/command_buffer/common/gles2_cmd_utils.h" 10 #include "gpu/command_buffer/service/buffer_manager.h" 11 #include "gpu/command_buffer/service/cmd_buffer_engine.h" 12 #include "gpu/command_buffer/service/context_group.h" 13 #include "gpu/command_buffer/service/framebuffer_manager.h" 14 #include "gpu/command_buffer/service/gles2_cmd_decoder.h" 15 #include "gpu/command_buffer/service/gles2_cmd_decoder_mock.h" 16 #include "gpu/command_buffer/service/program_manager.h" 17 #include "gpu/command_buffer/service/query_manager.h" 18 #include "gpu/command_buffer/service/renderbuffer_manager.h" 19 #include "gpu/command_buffer/service/shader_manager.h" 20 #include "gpu/command_buffer/service/test_helper.h" 21 #include "gpu/command_buffer/service/texture_manager.h" 22 #include "gpu/command_buffer/service/vertex_array_manager.h" 23 #include "testing/gtest/include/gtest/gtest.h" 24 #include "ui/gl/gl_context_stub_with_extensions.h" 25 #include "ui/gl/gl_surface_stub.h" 26 #include "ui/gl/gl_mock.h" 27 28 namespace base { 29 class CommandLine; 30 } 31 32 namespace gpu { 33 namespace gles2 { 34 35 class MemoryTracker; 36 37 class GLES2DecoderTestBase : public ::testing::TestWithParam<bool> { 38 public: 39 GLES2DecoderTestBase(); 40 virtual ~GLES2DecoderTestBase(); 41 42 // Template to call glGenXXX functions. 43 template <typename T> 44 void GenHelper(GLuint client_id) { 45 int8 buffer[sizeof(T) + sizeof(client_id)]; 46 T& cmd = *reinterpret_cast<T*>(&buffer); 47 cmd.Init(1, &client_id); 48 EXPECT_EQ(error::kNoError, 49 ExecuteImmediateCmd(cmd, sizeof(client_id))); 50 } 51 52 // This template exists solely so we can specialize it for 53 // certain commands. 54 template <typename T, int id> 55 void SpecializedSetup(bool valid) { 56 } 57 58 template <typename T> 59 T* GetImmediateAs() { 60 return reinterpret_cast<T*>(immediate_buffer_); 61 } 62 63 template <typename T, typename Command> 64 T GetImmediateDataAs(Command* cmd) { 65 return reinterpret_cast<T>(ImmediateDataAddress(cmd)); 66 } 67 68 void ClearSharedMemory() { 69 engine_->ClearSharedMemory(); 70 } 71 72 virtual void SetUp() OVERRIDE; 73 virtual void TearDown() OVERRIDE; 74 75 template <typename T> 76 error::Error ExecuteCmd(const T& cmd) { 77 COMPILE_ASSERT(T::kArgFlags == cmd::kFixed, Cmd_kArgFlags_not_kFixed); 78 return decoder_->DoCommand(cmd.kCmdId, 79 ComputeNumEntries(sizeof(cmd)) - 1, 80 &cmd); 81 } 82 83 template <typename T> 84 error::Error ExecuteImmediateCmd(const T& cmd, size_t data_size) { 85 COMPILE_ASSERT(T::kArgFlags == cmd::kAtLeastN, Cmd_kArgFlags_not_kAtLeastN); 86 return decoder_->DoCommand(cmd.kCmdId, 87 ComputeNumEntries(sizeof(cmd) + data_size) - 1, 88 &cmd); 89 } 90 91 template <typename T> 92 T GetSharedMemoryAs() { 93 return reinterpret_cast<T>(shared_memory_address_); 94 } 95 96 template <typename T> 97 T GetSharedMemoryAsWithOffset(uint32 offset) { 98 void* ptr = reinterpret_cast<int8*>(shared_memory_address_) + offset; 99 return reinterpret_cast<T>(ptr); 100 } 101 102 IdAllocatorInterface* GetIdAllocator(GLuint namespace_id) { 103 return group_->GetIdAllocator(namespace_id); 104 } 105 106 Buffer* GetBuffer(GLuint service_id) { 107 return group_->buffer_manager()->GetBuffer(service_id); 108 } 109 110 Framebuffer* GetFramebuffer(GLuint service_id) { 111 return group_->framebuffer_manager()->GetFramebuffer(service_id); 112 } 113 114 Renderbuffer* GetRenderbuffer( 115 GLuint service_id) { 116 return group_->renderbuffer_manager()->GetRenderbuffer(service_id); 117 } 118 119 TextureRef* GetTexture(GLuint client_id) { 120 return group_->texture_manager()->GetTexture(client_id); 121 } 122 123 Shader* GetShader(GLuint client_id) { 124 return group_->shader_manager()->GetShader(client_id); 125 } 126 127 Program* GetProgram(GLuint client_id) { 128 return group_->program_manager()->GetProgram(client_id); 129 } 130 131 QueryManager::Query* GetQueryInfo(GLuint client_id) { 132 return decoder_->GetQueryManager()->GetQuery(client_id); 133 } 134 135 // This name doesn't match the underlying function, but doing it this way 136 // prevents the need to special-case the unit test generation 137 VertexAttribManager* GetVertexArrayInfo(GLuint client_id) { 138 return decoder_->GetVertexArrayManager()->GetVertexAttribManager(client_id); 139 } 140 141 ProgramManager* program_manager() { 142 return group_->program_manager(); 143 } 144 145 void DoCreateProgram(GLuint client_id, GLuint service_id); 146 void DoCreateShader(GLenum shader_type, GLuint client_id, GLuint service_id); 147 148 void SetBucketAsCString(uint32 bucket_id, const char* str); 149 150 void set_memory_tracker(MemoryTracker* memory_tracker) { 151 memory_tracker_ = memory_tracker; 152 } 153 154 struct InitState { 155 InitState(); 156 157 std::string extensions; 158 std::string gl_version; 159 bool has_alpha; 160 bool has_depth; 161 bool has_stencil; 162 bool request_alpha; 163 bool request_depth; 164 bool request_stencil; 165 bool bind_generates_resource; 166 bool lose_context_when_out_of_memory; 167 bool use_native_vao; // default is true. 168 }; 169 170 void InitDecoder(const InitState& init); 171 void InitDecoderWithCommandLine(const InitState& init, 172 const base::CommandLine* command_line); 173 174 void ResetDecoder(); 175 176 const ContextGroup& group() const { 177 return *group_.get(); 178 } 179 180 ::testing::StrictMock< ::gfx::MockGLInterface>* GetGLMock() const { 181 return gl_.get(); 182 } 183 184 GLES2Decoder* GetDecoder() const { 185 return decoder_.get(); 186 } 187 188 typedef TestHelper::AttribInfo AttribInfo; 189 typedef TestHelper::UniformInfo UniformInfo; 190 191 void SetupShader( 192 AttribInfo* attribs, size_t num_attribs, 193 UniformInfo* uniforms, size_t num_uniforms, 194 GLuint client_id, GLuint service_id, 195 GLuint vertex_shader_client_id, GLuint vertex_shader_service_id, 196 GLuint fragment_shader_client_id, GLuint fragment_shader_service_id); 197 198 void SetupInitCapabilitiesExpectations(); 199 void SetupInitStateExpectations(); 200 void ExpectEnableDisable(GLenum cap, bool enable); 201 202 // Setups up a shader for testing glUniform. 203 void SetupShaderForUniform(GLenum uniform_type); 204 void SetupDefaultProgram(); 205 void SetupCubemapProgram(); 206 void SetupSamplerExternalProgram(); 207 void SetupTexture(); 208 209 // Note that the error is returned as GLint instead of GLenum. 210 // This is because there is a mismatch in the types of GLenum and 211 // the error values GL_NO_ERROR, GL_INVALID_ENUM, etc. GLenum is 212 // typedef'd as unsigned int while the error values are defined as 213 // integers. This is problematic for template functions such as 214 // EXPECT_EQ that expect both types to be the same. 215 GLint GetGLError(); 216 217 void DoBindBuffer(GLenum target, GLuint client_id, GLuint service_id); 218 void DoBindFramebuffer(GLenum target, GLuint client_id, GLuint service_id); 219 void DoBindRenderbuffer(GLenum target, GLuint client_id, GLuint service_id); 220 void DoBindTexture(GLenum target, GLuint client_id, GLuint service_id); 221 void DoBindVertexArrayOES(GLuint client_id, GLuint service_id); 222 223 bool DoIsBuffer(GLuint client_id); 224 bool DoIsFramebuffer(GLuint client_id); 225 bool DoIsProgram(GLuint client_id); 226 bool DoIsRenderbuffer(GLuint client_id); 227 bool DoIsShader(GLuint client_id); 228 bool DoIsTexture(GLuint client_id); 229 230 void DoDeleteBuffer(GLuint client_id, GLuint service_id); 231 void DoDeleteFramebuffer( 232 GLuint client_id, GLuint service_id, 233 bool reset_draw, GLenum draw_target, GLuint draw_id, 234 bool reset_read, GLenum read_target, GLuint read_id); 235 void DoDeleteProgram(GLuint client_id, GLuint service_id); 236 void DoDeleteRenderbuffer(GLuint client_id, GLuint service_id); 237 void DoDeleteShader(GLuint client_id, GLuint service_id); 238 void DoDeleteTexture(GLuint client_id, GLuint service_id); 239 240 void DoCompressedTexImage2D( 241 GLenum target, GLint level, GLenum format, 242 GLsizei width, GLsizei height, GLint border, 243 GLsizei size, uint32 bucket_id); 244 void DoTexImage2D( 245 GLenum target, GLint level, GLenum internal_format, 246 GLsizei width, GLsizei height, GLint border, 247 GLenum format, GLenum type, 248 uint32 shared_memory_id, uint32 shared_memory_offset); 249 void DoTexImage2DConvertInternalFormat( 250 GLenum target, GLint level, GLenum requested_internal_format, 251 GLsizei width, GLsizei height, GLint border, 252 GLenum format, GLenum type, 253 uint32 shared_memory_id, uint32 shared_memory_offset, 254 GLenum expected_internal_format); 255 void DoRenderbufferStorage( 256 GLenum target, GLenum internal_format, GLenum actual_format, 257 GLsizei width, GLsizei height, GLenum error); 258 void DoFramebufferRenderbuffer( 259 GLenum target, 260 GLenum attachment, 261 GLenum renderbuffer_target, 262 GLuint renderbuffer_client_id, 263 GLuint renderbuffer_service_id, 264 GLenum error); 265 void DoFramebufferTexture2D( 266 GLenum target, GLenum attachment, GLenum tex_target, 267 GLuint texture_client_id, GLuint texture_service_id, 268 GLint level, GLenum error); 269 void DoVertexAttribPointer( 270 GLuint index, GLint size, GLenum type, GLsizei stride, GLuint offset); 271 void DoVertexAttribDivisorANGLE(GLuint index, GLuint divisor); 272 273 void DoEnableDisable(GLenum cap, bool enable); 274 275 void DoEnableVertexAttribArray(GLint index); 276 277 void DoBufferData(GLenum target, GLsizei size); 278 279 void DoBufferSubData( 280 GLenum target, GLint offset, GLsizei size, const void* data); 281 282 void SetupVertexBuffer(); 283 void SetupAllNeededVertexBuffers(); 284 285 void SetupIndexBuffer(); 286 287 void DeleteVertexBuffer(); 288 289 void DeleteIndexBuffer(); 290 291 void SetupClearTextureExpectations( 292 GLuint service_id, 293 GLuint old_service_id, 294 GLenum bind_target, 295 GLenum target, 296 GLint level, 297 GLenum internal_format, 298 GLenum format, 299 GLenum type, 300 GLsizei width, 301 GLsizei height); 302 303 void SetupExpectationsForRestoreClearState( 304 GLclampf restore_red, 305 GLclampf restore_green, 306 GLclampf restore_blue, 307 GLclampf restore_alpha, 308 GLuint restore_stencil, 309 GLclampf restore_depth, 310 bool restore_scissor_test); 311 312 void SetupExpectationsForFramebufferClearing( 313 GLenum target, 314 GLuint clear_bits, 315 GLclampf restore_red, 316 GLclampf restore_green, 317 GLclampf restore_blue, 318 GLclampf restore_alpha, 319 GLuint restore_stencil, 320 GLclampf restore_depth, 321 bool restore_scissor_test); 322 323 void SetupExpectationsForFramebufferClearingMulti( 324 GLuint read_framebuffer_service_id, 325 GLuint draw_framebuffer_service_id, 326 GLenum target, 327 GLuint clear_bits, 328 GLclampf restore_red, 329 GLclampf restore_green, 330 GLclampf restore_blue, 331 GLclampf restore_alpha, 332 GLuint restore_stencil, 333 GLclampf restore_depth, 334 bool restore_scissor_test); 335 336 void SetupExpectationsForDepthMask(bool mask); 337 void SetupExpectationsForEnableDisable(GLenum cap, bool enable); 338 void SetupExpectationsForColorMask(bool red, 339 bool green, 340 bool blue, 341 bool alpha); 342 void SetupExpectationsForStencilMask(uint32 front_mask, 343 uint32 back_mask); 344 345 void SetupExpectationsForApplyingDirtyState( 346 bool framebuffer_is_rgb, 347 bool framebuffer_has_depth, 348 bool framebuffer_has_stencil, 349 GLuint color_bits, // NOTE! bits are 0x1000, 0x0100, 0x0010, and 0x0001 350 bool depth_mask, 351 bool depth_enabled, 352 GLuint front_stencil_mask, 353 GLuint back_stencil_mask, 354 bool stencil_enabled); 355 356 void SetupExpectationsForApplyingDefaultDirtyState(); 357 358 void AddExpectationsForSimulatedAttrib0WithError( 359 GLsizei num_vertices, GLuint buffer_id, GLenum error); 360 361 void AddExpectationsForSimulatedAttrib0( 362 GLsizei num_vertices, GLuint buffer_id); 363 364 void AddExpectationsForGenVertexArraysOES(); 365 void AddExpectationsForDeleteVertexArraysOES(); 366 void AddExpectationsForDeleteBoundVertexArraysOES(); 367 void AddExpectationsForBindVertexArrayOES(); 368 void AddExpectationsForRestoreAttribState(GLuint attrib); 369 370 GLvoid* BufferOffset(unsigned i) { 371 return static_cast<int8 *>(NULL)+(i); 372 } 373 374 template <typename Command, typename Result> 375 bool IsObjectHelper(GLuint client_id) { 376 Result* result = static_cast<Result*>(shared_memory_address_); 377 Command cmd; 378 cmd.Init(client_id, kSharedMemoryId, kSharedMemoryOffset); 379 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 380 bool isObject = static_cast<bool>(*result); 381 EXPECT_EQ(GL_NO_ERROR, GetGLError()); 382 return isObject; 383 } 384 385 protected: 386 static const int kBackBufferWidth = 128; 387 static const int kBackBufferHeight = 64; 388 389 static const GLint kMaxTextureSize = 2048; 390 static const GLint kMaxCubeMapTextureSize = 256; 391 static const GLint kNumVertexAttribs = 16; 392 static const GLint kNumTextureUnits = 8; 393 static const GLint kMaxTextureImageUnits = 8; 394 static const GLint kMaxVertexTextureImageUnits = 2; 395 static const GLint kMaxFragmentUniformVectors = 16; 396 static const GLint kMaxVaryingVectors = 8; 397 static const GLint kMaxVertexUniformVectors = 128; 398 static const GLint kMaxViewportWidth = 8192; 399 static const GLint kMaxViewportHeight = 8192; 400 401 static const GLint kViewportX = 0; 402 static const GLint kViewportY = 0; 403 static const GLint kViewportWidth = kBackBufferWidth; 404 static const GLint kViewportHeight = kBackBufferHeight; 405 406 static const GLuint kServiceAttrib0BufferId = 801; 407 static const GLuint kServiceFixedAttribBufferId = 802; 408 409 static const GLuint kServiceBufferId = 301; 410 static const GLuint kServiceFramebufferId = 302; 411 static const GLuint kServiceRenderbufferId = 303; 412 static const GLuint kServiceTextureId = 304; 413 static const GLuint kServiceProgramId = 305; 414 static const GLuint kServiceShaderId = 306; 415 static const GLuint kServiceElementBufferId = 308; 416 static const GLuint kServiceQueryId = 309; 417 static const GLuint kServiceVertexArrayId = 310; 418 419 static const int32 kSharedMemoryId = 401; 420 static const size_t kSharedBufferSize = 2048; 421 static const uint32 kSharedMemoryOffset = 132; 422 static const int32 kInvalidSharedMemoryId = 402; 423 static const uint32 kInvalidSharedMemoryOffset = kSharedBufferSize + 1; 424 static const uint32 kInitialResult = 0xBDBDBDBDu; 425 static const uint8 kInitialMemoryValue = 0xBDu; 426 427 static const uint32 kNewClientId = 501; 428 static const uint32 kNewServiceId = 502; 429 static const uint32 kInvalidClientId = 601; 430 431 static const GLuint kServiceVertexShaderId = 321; 432 static const GLuint kServiceFragmentShaderId = 322; 433 434 static const GLuint kServiceCopyTextureChromiumShaderId = 701; 435 static const GLuint kServiceCopyTextureChromiumProgramId = 721; 436 437 static const GLuint kServiceCopyTextureChromiumTextureBufferId = 751; 438 static const GLuint kServiceCopyTextureChromiumVertexBufferId = 752; 439 static const GLuint kServiceCopyTextureChromiumFBOId = 753; 440 static const GLuint kServiceCopyTextureChromiumPositionAttrib = 761; 441 static const GLuint kServiceCopyTextureChromiumTexAttrib = 762; 442 static const GLuint kServiceCopyTextureChromiumSamplerLocation = 763; 443 444 static const GLsizei kNumVertices = 100; 445 static const GLsizei kNumIndices = 10; 446 static const int kValidIndexRangeStart = 1; 447 static const int kValidIndexRangeCount = 7; 448 static const int kInvalidIndexRangeStart = 0; 449 static const int kInvalidIndexRangeCount = 7; 450 static const int kOutOfRangeIndexRangeEnd = 10; 451 static const GLuint kMaxValidIndex = 7; 452 453 static const GLint kMaxAttribLength = 10; 454 static const char* kAttrib1Name; 455 static const char* kAttrib2Name; 456 static const char* kAttrib3Name; 457 static const GLint kAttrib1Size = 1; 458 static const GLint kAttrib2Size = 1; 459 static const GLint kAttrib3Size = 1; 460 static const GLint kAttrib1Location = 0; 461 static const GLint kAttrib2Location = 1; 462 static const GLint kAttrib3Location = 2; 463 static const GLenum kAttrib1Type = GL_FLOAT_VEC4; 464 static const GLenum kAttrib2Type = GL_FLOAT_VEC2; 465 static const GLenum kAttrib3Type = GL_FLOAT_VEC3; 466 static const GLint kInvalidAttribLocation = 30; 467 static const GLint kBadAttribIndex = kNumVertexAttribs; 468 469 static const GLint kMaxUniformLength = 12; 470 static const char* kUniform1Name; 471 static const char* kUniform2Name; 472 static const char* kUniform3Name; 473 static const GLint kUniform1Size = 1; 474 static const GLint kUniform2Size = 3; 475 static const GLint kUniform3Size = 2; 476 static const GLint kUniform1RealLocation = 3; 477 static const GLint kUniform2RealLocation = 10; 478 static const GLint kUniform2ElementRealLocation = 12; 479 static const GLint kUniform3RealLocation = 20; 480 static const GLint kUniform1FakeLocation = 0; // These are 481 static const GLint kUniform2FakeLocation = 1; // hardcoded 482 static const GLint kUniform2ElementFakeLocation = 0x10001; // to match 483 static const GLint kUniform3FakeLocation = 2; // ProgramManager. 484 static const GLint kUniform1DesiredLocation = -1; 485 static const GLint kUniform2DesiredLocation = -1; 486 static const GLint kUniform3DesiredLocation = -1; 487 static const GLenum kUniform1Type = GL_SAMPLER_2D; 488 static const GLenum kUniform2Type = GL_INT_VEC2; 489 static const GLenum kUniform3Type = GL_FLOAT_VEC3; 490 static const GLenum kUniformSamplerExternalType = GL_SAMPLER_EXTERNAL_OES; 491 static const GLenum kUniformCubemapType = GL_SAMPLER_CUBE; 492 static const GLint kInvalidUniformLocation = 30; 493 static const GLint kBadUniformIndex = 1000; 494 495 // Use StrictMock to make 100% sure we know how GL will be called. 496 scoped_ptr< ::testing::StrictMock< ::gfx::MockGLInterface> > gl_; 497 scoped_refptr<gfx::GLSurfaceStub> surface_; 498 scoped_refptr<gfx::GLContextStubWithExtensions> context_; 499 scoped_ptr<MockGLES2Decoder> mock_decoder_; 500 scoped_ptr<GLES2Decoder> decoder_; 501 MemoryTracker* memory_tracker_; 502 503 GLuint client_buffer_id_; 504 GLuint client_framebuffer_id_; 505 GLuint client_program_id_; 506 GLuint client_renderbuffer_id_; 507 GLuint client_shader_id_; 508 GLuint client_texture_id_; 509 GLuint client_element_buffer_id_; 510 GLuint client_vertex_shader_id_; 511 GLuint client_fragment_shader_id_; 512 GLuint client_query_id_; 513 GLuint client_vertexarray_id_; 514 515 uint32 shared_memory_id_; 516 uint32 shared_memory_offset_; 517 void* shared_memory_address_; 518 void* shared_memory_base_; 519 520 int8 immediate_buffer_[256]; 521 522 const bool ignore_cached_state_for_test_; 523 bool cached_color_mask_red_; 524 bool cached_color_mask_green_; 525 bool cached_color_mask_blue_; 526 bool cached_color_mask_alpha_; 527 bool cached_depth_mask_; 528 uint32 cached_stencil_front_mask_; 529 uint32 cached_stencil_back_mask_; 530 531 struct EnableFlags { 532 EnableFlags(); 533 bool cached_blend; 534 bool cached_cull_face; 535 bool cached_depth_test; 536 bool cached_dither; 537 bool cached_polygon_offset_fill; 538 bool cached_sample_alpha_to_coverage; 539 bool cached_sample_coverage; 540 bool cached_scissor_test; 541 bool cached_stencil_test; 542 }; 543 544 EnableFlags enable_flags_; 545 546 private: 547 class MockCommandBufferEngine : public CommandBufferEngine { 548 public: 549 MockCommandBufferEngine(); 550 551 virtual ~MockCommandBufferEngine(); 552 553 virtual scoped_refptr<gpu::Buffer> GetSharedMemoryBuffer(int32 shm_id) 554 OVERRIDE; 555 556 void ClearSharedMemory() { 557 memset(valid_buffer_->memory(), kInitialMemoryValue, kSharedBufferSize); 558 } 559 560 virtual void set_token(int32 token) OVERRIDE; 561 562 virtual bool SetGetBuffer(int32 /* transfer_buffer_id */) OVERRIDE; 563 564 // Overridden from CommandBufferEngine. 565 virtual bool SetGetOffset(int32 offset) OVERRIDE; 566 567 // Overridden from CommandBufferEngine. 568 virtual int32 GetGetOffset() OVERRIDE; 569 570 private: 571 scoped_refptr<gpu::Buffer> valid_buffer_; 572 scoped_refptr<gpu::Buffer> invalid_buffer_; 573 }; 574 575 // MockGLStates is used to track GL states and emulate driver 576 // behaviors on top of MockGLInterface. 577 class MockGLStates { 578 public: 579 MockGLStates() 580 : bound_array_buffer_object_(0), 581 bound_vertex_array_object_(0) { 582 } 583 584 ~MockGLStates() { 585 } 586 587 void OnBindArrayBuffer(GLuint id) { 588 bound_array_buffer_object_ = id; 589 } 590 591 void OnBindVertexArrayOES(GLuint id) { 592 bound_vertex_array_object_ = id; 593 } 594 595 void OnVertexAttribNullPointer() { 596 // When a vertex array object is bound, some drivers (AMD Linux, 597 // Qualcomm, etc.) have a bug where it incorrectly generates an 598 // GL_INVALID_OPERATION on glVertexAttribPointer() if pointer 599 // is NULL, no buffer is bound on GL_ARRAY_BUFFER. 600 // Make sure we don't trigger this bug. 601 if (bound_vertex_array_object_ != 0) 602 EXPECT_TRUE(bound_array_buffer_object_ != 0); 603 } 604 605 private: 606 GLuint bound_array_buffer_object_; 607 GLuint bound_vertex_array_object_; 608 }; // class MockGLStates 609 610 void AddExpectationsForVertexAttribManager(); 611 void SetupMockGLBehaviors(); 612 613 scoped_ptr< ::testing::StrictMock<MockCommandBufferEngine> > engine_; 614 scoped_refptr<ContextGroup> group_; 615 MockGLStates gl_states_; 616 }; 617 618 class GLES2DecoderWithShaderTestBase : public GLES2DecoderTestBase { 619 public: 620 GLES2DecoderWithShaderTestBase() 621 : GLES2DecoderTestBase() { 622 } 623 624 protected: 625 virtual void SetUp() OVERRIDE; 626 virtual void TearDown() OVERRIDE; 627 628 }; 629 630 // SpecializedSetup specializations that are needed in multiple unittest files. 631 template <> 632 void GLES2DecoderTestBase::SpecializedSetup<cmds::LinkProgram, 0>(bool valid); 633 634 } // namespace gles2 635 } // namespace gpu 636 637 #endif // GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_DECODER_UNITTEST_BASE_H_ 638