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