gles2_cmd_decoder_unittest_base.h revision 46d4c2bc3267f3f028f39e7e311b0f89aba2e4fd 
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
28namespace base {
29class CommandLine;
30}
31
32namespace gpu {
33namespace gles2 {
34
35class MemoryTracker;
36
37class 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
618class 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.
631template <>
632void 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