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/gles2_cmd_decoder_unittest_base.h"
6
7#include <algorithm>
8#include <string>
9#include <vector>
10
11#include "base/strings/string_number_conversions.h"
12#include "base/strings/string_split.h"
13#include "gpu/command_buffer/common/gles2_cmd_format.h"
14#include "gpu/command_buffer/common/gles2_cmd_utils.h"
15#include "gpu/command_buffer/service/cmd_buffer_engine.h"
16#include "gpu/command_buffer/service/context_group.h"
17#include "gpu/command_buffer/service/logger.h"
18#include "gpu/command_buffer/service/mailbox_manager.h"
19#include "gpu/command_buffer/service/program_manager.h"
20#include "gpu/command_buffer/service/test_helper.h"
21#include "gpu/command_buffer/service/vertex_attrib_manager.h"
22#include "testing/gtest/include/gtest/gtest.h"
23#include "ui/gl/gl_implementation.h"
24#include "ui/gl/gl_mock.h"
25#include "ui/gl/gl_surface.h"
26
27using ::gfx::MockGLInterface;
28using ::testing::_;
29using ::testing::DoAll;
30using ::testing::InSequence;
31using ::testing::Invoke;
32using ::testing::InvokeWithoutArgs;
33using ::testing::MatcherCast;
34using ::testing::Pointee;
35using ::testing::Return;
36using ::testing::SetArrayArgument;
37using ::testing::SetArgPointee;
38using ::testing::SetArgumentPointee;
39using ::testing::StrEq;
40using ::testing::StrictMock;
41using ::testing::WithArg;
42
43namespace {
44
45void NormalizeInitState(gpu::gles2::GLES2DecoderTestBase::InitState* init) {
46  CHECK(init);
47  const char* kVAOExtensions[] = {
48      "GL_OES_vertex_array_object",
49      "GL_ARB_vertex_array_object",
50      "GL_APPLE_vertex_array_object"
51  };
52  bool contains_vao_extension = false;
53  for (size_t ii = 0; ii < arraysize(kVAOExtensions); ++ii) {
54    if (init->extensions.find(kVAOExtensions[ii]) != std::string::npos) {
55      contains_vao_extension = true;
56      break;
57    }
58  }
59  if (init->use_native_vao) {
60    if (contains_vao_extension)
61      return;
62    if (!init->extensions.empty())
63      init->extensions += " ";
64    if (StartsWithASCII(init->gl_version, "opengl es", false)) {
65      init->extensions += kVAOExtensions[0];
66    } else {
67#if !defined(OS_MACOSX)
68      init->extensions += kVAOExtensions[1];
69#else
70      init->extensions += kVAOExtensions[2];
71#endif  // OS_MACOSX
72    }
73  } else {
74    // Make sure we don't set up an invalid InitState.
75    CHECK(!contains_vao_extension);
76  }
77}
78
79}  // namespace Anonymous
80
81namespace gpu {
82namespace gles2 {
83
84GLES2DecoderTestBase::GLES2DecoderTestBase()
85    : surface_(NULL),
86      context_(NULL),
87      memory_tracker_(NULL),
88      client_buffer_id_(100),
89      client_framebuffer_id_(101),
90      client_program_id_(102),
91      client_renderbuffer_id_(103),
92      client_shader_id_(104),
93      client_texture_id_(106),
94      client_element_buffer_id_(107),
95      client_vertex_shader_id_(121),
96      client_fragment_shader_id_(122),
97      client_query_id_(123),
98      client_vertexarray_id_(124),
99      service_renderbuffer_id_(0),
100      service_renderbuffer_valid_(false),
101      ignore_cached_state_for_test_(GetParam()),
102      cached_color_mask_red_(true),
103      cached_color_mask_green_(true),
104      cached_color_mask_blue_(true),
105      cached_color_mask_alpha_(true),
106      cached_depth_mask_(true),
107      cached_stencil_front_mask_(static_cast<GLuint>(-1)),
108      cached_stencil_back_mask_(static_cast<GLuint>(-1)) {
109  memset(immediate_buffer_, 0xEE, sizeof(immediate_buffer_));
110}
111
112GLES2DecoderTestBase::~GLES2DecoderTestBase() {}
113
114void GLES2DecoderTestBase::SetUp() {
115  InitState init;
116  init.gl_version = "3.0";
117  init.has_alpha = true;
118  init.has_depth = true;
119  init.request_alpha = true;
120  init.request_depth = true;
121  init.bind_generates_resource = true;
122  InitDecoder(init);
123}
124
125void GLES2DecoderTestBase::AddExpectationsForVertexAttribManager() {
126  for (GLint ii = 0; ii < kNumVertexAttribs; ++ii) {
127    EXPECT_CALL(*gl_, VertexAttrib4f(ii, 0.0f, 0.0f, 0.0f, 1.0f))
128        .Times(1)
129        .RetiresOnSaturation();
130  }
131}
132
133GLES2DecoderTestBase::InitState::InitState()
134    : has_alpha(false),
135      has_depth(false),
136      has_stencil(false),
137      request_alpha(false),
138      request_depth(false),
139      request_stencil(false),
140      bind_generates_resource(false),
141      lose_context_when_out_of_memory(false),
142      use_native_vao(true) {
143}
144
145void GLES2DecoderTestBase::InitDecoder(const InitState& init) {
146  InitDecoderWithCommandLine(init, NULL);
147}
148
149void GLES2DecoderTestBase::InitDecoderWithCommandLine(
150    const InitState& init,
151    const base::CommandLine* command_line) {
152  InitState normalized_init = init;
153  NormalizeInitState(&normalized_init);
154  Framebuffer::ClearFramebufferCompleteComboMap();
155
156  gfx::SetGLGetProcAddressProc(gfx::MockGLInterface::GetGLProcAddress);
157  gfx::GLSurface::InitializeOneOffWithMockBindingsForTests();
158
159  gl_.reset(new StrictMock<MockGLInterface>());
160  ::gfx::MockGLInterface::SetGLInterface(gl_.get());
161
162  SetupMockGLBehaviors();
163
164  // Only create stream texture manager if extension is requested.
165  std::vector<std::string> list;
166  base::SplitString(normalized_init.extensions, ' ', &list);
167  scoped_refptr<FeatureInfo> feature_info;
168  if (command_line)
169    feature_info = new FeatureInfo(*command_line);
170  group_ = scoped_refptr<ContextGroup>(
171      new ContextGroup(NULL,
172                       memory_tracker_,
173                       new ShaderTranslatorCache,
174                       feature_info.get(),
175                       normalized_init.bind_generates_resource));
176  bool use_default_textures = normalized_init.bind_generates_resource;
177
178  InSequence sequence;
179
180  surface_ = new gfx::GLSurfaceStub;
181  surface_->SetSize(gfx::Size(kBackBufferWidth, kBackBufferHeight));
182
183  // Context needs to be created before initializing ContextGroup, which will
184  // in turn initialize FeatureInfo, which needs a context to determine
185  // extension support.
186  context_ = new gfx::GLContextStubWithExtensions;
187  context_->AddExtensionsString(normalized_init.extensions.c_str());
188  context_->SetGLVersionString(normalized_init.gl_version.c_str());
189
190  context_->MakeCurrent(surface_.get());
191  gfx::GLSurface::InitializeDynamicMockBindingsForTests(context_.get());
192
193  TestHelper::SetupContextGroupInitExpectations(
194      gl_.get(),
195      DisallowedFeatures(),
196      normalized_init.extensions.c_str(),
197      normalized_init.gl_version.c_str(),
198      normalized_init.bind_generates_resource);
199
200  // We initialize the ContextGroup with a MockGLES2Decoder so that
201  // we can use the ContextGroup to figure out how the real GLES2Decoder
202  // will initialize itself.
203  mock_decoder_.reset(new MockGLES2Decoder());
204
205  // Install FakeDoCommands handler so we can use individual DoCommand()
206  // expectations.
207  EXPECT_CALL(*mock_decoder_, DoCommands(_, _, _, _)).WillRepeatedly(
208      Invoke(mock_decoder_.get(), &MockGLES2Decoder::FakeDoCommands));
209
210  EXPECT_TRUE(
211      group_->Initialize(mock_decoder_.get(), DisallowedFeatures()));
212
213  if (group_->feature_info()->feature_flags().native_vertex_array_object) {
214    EXPECT_CALL(*gl_, GenVertexArraysOES(1, _))
215      .WillOnce(SetArgumentPointee<1>(kServiceVertexArrayId))
216        .RetiresOnSaturation();
217    EXPECT_CALL(*gl_, BindVertexArrayOES(_)).Times(1).RetiresOnSaturation();
218  }
219
220  if (group_->feature_info()->workarounds().init_vertex_attributes)
221    AddExpectationsForVertexAttribManager();
222
223  AddExpectationsForBindVertexArrayOES();
224
225  EXPECT_CALL(*gl_, EnableVertexAttribArray(0))
226      .Times(1)
227      .RetiresOnSaturation();
228  static GLuint attrib_0_id[] = {
229    kServiceAttrib0BufferId,
230  };
231  static GLuint fixed_attrib_buffer_id[] = {
232    kServiceFixedAttribBufferId,
233  };
234  EXPECT_CALL(*gl_, GenBuffersARB(arraysize(attrib_0_id), _))
235      .WillOnce(SetArrayArgument<1>(attrib_0_id,
236                                    attrib_0_id + arraysize(attrib_0_id)))
237      .RetiresOnSaturation();
238  EXPECT_CALL(*gl_, BindBuffer(GL_ARRAY_BUFFER, kServiceAttrib0BufferId))
239      .Times(1)
240      .RetiresOnSaturation();
241  EXPECT_CALL(*gl_, VertexAttribPointer(0, 1, GL_FLOAT, GL_FALSE, 0, NULL))
242      .Times(1)
243      .RetiresOnSaturation();
244  EXPECT_CALL(*gl_, BindBuffer(GL_ARRAY_BUFFER, 0))
245      .Times(1)
246      .RetiresOnSaturation();
247  EXPECT_CALL(*gl_, GenBuffersARB(arraysize(fixed_attrib_buffer_id), _))
248      .WillOnce(SetArrayArgument<1>(
249          fixed_attrib_buffer_id,
250          fixed_attrib_buffer_id + arraysize(fixed_attrib_buffer_id)))
251      .RetiresOnSaturation();
252
253  for (GLint tt = 0; tt < TestHelper::kNumTextureUnits; ++tt) {
254    EXPECT_CALL(*gl_, ActiveTexture(GL_TEXTURE0 + tt))
255        .Times(1)
256        .RetiresOnSaturation();
257    if (group_->feature_info()->feature_flags().oes_egl_image_external) {
258      EXPECT_CALL(*gl_,
259                  BindTexture(GL_TEXTURE_EXTERNAL_OES,
260                              use_default_textures
261                                  ? TestHelper::kServiceDefaultExternalTextureId
262                                  : 0))
263          .Times(1)
264          .RetiresOnSaturation();
265    }
266    if (group_->feature_info()->feature_flags().arb_texture_rectangle) {
267      EXPECT_CALL(
268          *gl_,
269          BindTexture(GL_TEXTURE_RECTANGLE_ARB,
270                      use_default_textures
271                          ? TestHelper::kServiceDefaultRectangleTextureId
272                          : 0))
273          .Times(1)
274          .RetiresOnSaturation();
275    }
276    EXPECT_CALL(*gl_,
277                BindTexture(GL_TEXTURE_CUBE_MAP,
278                            use_default_textures
279                                ? TestHelper::kServiceDefaultTextureCubemapId
280                                : 0))
281        .Times(1)
282        .RetiresOnSaturation();
283    EXPECT_CALL(
284        *gl_,
285        BindTexture(
286            GL_TEXTURE_2D,
287            use_default_textures ? TestHelper::kServiceDefaultTexture2dId : 0))
288        .Times(1)
289        .RetiresOnSaturation();
290  }
291  EXPECT_CALL(*gl_, ActiveTexture(GL_TEXTURE0))
292      .Times(1)
293      .RetiresOnSaturation();
294
295  EXPECT_CALL(*gl_, BindFramebufferEXT(GL_FRAMEBUFFER, 0))
296      .Times(1)
297      .RetiresOnSaturation();
298  EXPECT_CALL(*gl_, GetIntegerv(GL_ALPHA_BITS, _))
299      .WillOnce(SetArgumentPointee<1>(normalized_init.has_alpha ? 8 : 0))
300      .RetiresOnSaturation();
301  EXPECT_CALL(*gl_, GetIntegerv(GL_DEPTH_BITS, _))
302      .WillOnce(SetArgumentPointee<1>(normalized_init.has_depth ? 24 : 0))
303      .RetiresOnSaturation();
304  EXPECT_CALL(*gl_, GetIntegerv(GL_STENCIL_BITS, _))
305      .WillOnce(SetArgumentPointee<1>(normalized_init.has_stencil ? 8 : 0))
306      .RetiresOnSaturation();
307
308  EXPECT_CALL(*gl_, Enable(GL_VERTEX_PROGRAM_POINT_SIZE))
309      .Times(1)
310      .RetiresOnSaturation();
311
312  EXPECT_CALL(*gl_, Enable(GL_POINT_SPRITE))
313      .Times(1)
314      .RetiresOnSaturation();
315
316  static GLint max_viewport_dims[] = {
317    kMaxViewportWidth,
318    kMaxViewportHeight
319  };
320  EXPECT_CALL(*gl_, GetIntegerv(GL_MAX_VIEWPORT_DIMS, _))
321      .WillOnce(SetArrayArgument<1>(
322          max_viewport_dims, max_viewport_dims + arraysize(max_viewport_dims)))
323      .RetiresOnSaturation();
324
325  SetupInitCapabilitiesExpectations();
326  SetupInitStateExpectations();
327
328  EXPECT_CALL(*gl_, ActiveTexture(GL_TEXTURE0))
329      .Times(1)
330      .RetiresOnSaturation();
331
332  EXPECT_CALL(*gl_, BindBuffer(GL_ARRAY_BUFFER, 0))
333      .Times(1)
334      .RetiresOnSaturation();
335  EXPECT_CALL(*gl_, BindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0))
336      .Times(1)
337      .RetiresOnSaturation();
338  EXPECT_CALL(*gl_, BindFramebufferEXT(GL_FRAMEBUFFER, 0))
339      .Times(1)
340      .RetiresOnSaturation();
341  EXPECT_CALL(*gl_, BindRenderbufferEXT(GL_RENDERBUFFER, 0))
342      .Times(1)
343      .RetiresOnSaturation();
344
345  // TODO(boliu): Remove OS_ANDROID once crbug.com/259023 is fixed and the
346  // workaround has been reverted.
347#if !defined(OS_ANDROID)
348  EXPECT_CALL(*gl_, Clear(
349      GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT))
350      .Times(1)
351      .RetiresOnSaturation();
352#endif
353
354  engine_.reset(new StrictMock<MockCommandBufferEngine>());
355  scoped_refptr<gpu::Buffer> buffer =
356      engine_->GetSharedMemoryBuffer(kSharedMemoryId);
357  shared_memory_offset_ = kSharedMemoryOffset;
358  shared_memory_address_ =
359      reinterpret_cast<int8*>(buffer->memory()) + shared_memory_offset_;
360  shared_memory_id_ = kSharedMemoryId;
361  shared_memory_base_ = buffer->memory();
362
363  static const int32 kLoseContextWhenOutOfMemory = 0x10002;
364
365  int32 attributes[] = {
366      EGL_ALPHA_SIZE,
367      normalized_init.request_alpha ? 8 : 0,
368      EGL_DEPTH_SIZE,
369      normalized_init.request_depth ? 24 : 0,
370      EGL_STENCIL_SIZE,
371      normalized_init.request_stencil ? 8 : 0,
372      kLoseContextWhenOutOfMemory,
373      normalized_init.lose_context_when_out_of_memory ? 1 : 0, };
374  std::vector<int32> attribs(attributes, attributes + arraysize(attributes));
375
376  decoder_.reset(GLES2Decoder::Create(group_.get()));
377  decoder_->SetIgnoreCachedStateForTest(ignore_cached_state_for_test_);
378  decoder_->GetLogger()->set_log_synthesized_gl_errors(false);
379  decoder_->Initialize(surface_,
380                       context_,
381                       false,
382                       surface_->GetSize(),
383                       DisallowedFeatures(),
384                       attribs);
385  decoder_->MakeCurrent();
386  decoder_->set_engine(engine_.get());
387  decoder_->BeginDecoding();
388
389  EXPECT_CALL(*gl_, GenBuffersARB(_, _))
390      .WillOnce(SetArgumentPointee<1>(kServiceBufferId))
391      .RetiresOnSaturation();
392  GenHelper<cmds::GenBuffersImmediate>(client_buffer_id_);
393  EXPECT_CALL(*gl_, GenFramebuffersEXT(_, _))
394      .WillOnce(SetArgumentPointee<1>(kServiceFramebufferId))
395      .RetiresOnSaturation();
396  GenHelper<cmds::GenFramebuffersImmediate>(client_framebuffer_id_);
397  EXPECT_CALL(*gl_, GenRenderbuffersEXT(_, _))
398      .WillOnce(SetArgumentPointee<1>(kServiceRenderbufferId))
399      .RetiresOnSaturation();
400  GenHelper<cmds::GenRenderbuffersImmediate>(client_renderbuffer_id_);
401  EXPECT_CALL(*gl_, GenTextures(_, _))
402      .WillOnce(SetArgumentPointee<1>(kServiceTextureId))
403      .RetiresOnSaturation();
404  GenHelper<cmds::GenTexturesImmediate>(client_texture_id_);
405  EXPECT_CALL(*gl_, GenBuffersARB(_, _))
406      .WillOnce(SetArgumentPointee<1>(kServiceElementBufferId))
407      .RetiresOnSaturation();
408  GenHelper<cmds::GenBuffersImmediate>(client_element_buffer_id_);
409
410  DoCreateProgram(client_program_id_, kServiceProgramId);
411  DoCreateShader(GL_VERTEX_SHADER, client_shader_id_, kServiceShaderId);
412
413  EXPECT_EQ(GL_NO_ERROR, GetGLError());
414}
415
416void GLES2DecoderTestBase::ResetDecoder() {
417  if (!decoder_.get())
418    return;
419  // All Tests should have read all their GLErrors before getting here.
420  EXPECT_EQ(GL_NO_ERROR, GetGLError());
421
422  EXPECT_CALL(*gl_, DeleteBuffersARB(1, _))
423      .Times(2)
424      .RetiresOnSaturation();
425  if (group_->feature_info()->feature_flags().native_vertex_array_object) {
426    EXPECT_CALL(*gl_, DeleteVertexArraysOES(1, Pointee(kServiceVertexArrayId)))
427        .Times(1)
428        .RetiresOnSaturation();
429  }
430
431  decoder_->EndDecoding();
432  decoder_->Destroy(true);
433  decoder_.reset();
434  group_->Destroy(mock_decoder_.get(), false);
435  engine_.reset();
436  ::gfx::MockGLInterface::SetGLInterface(NULL);
437  gl_.reset();
438  gfx::ClearGLBindings();
439}
440
441void GLES2DecoderTestBase::TearDown() {
442  ResetDecoder();
443}
444
445void GLES2DecoderTestBase::ExpectEnableDisable(GLenum cap, bool enable) {
446  if (enable) {
447    EXPECT_CALL(*gl_, Enable(cap))
448        .Times(1)
449        .RetiresOnSaturation();
450  } else {
451    EXPECT_CALL(*gl_, Disable(cap))
452        .Times(1)
453        .RetiresOnSaturation();
454  }
455}
456
457
458GLint GLES2DecoderTestBase::GetGLError() {
459  EXPECT_CALL(*gl_, GetError())
460      .WillOnce(Return(GL_NO_ERROR))
461      .RetiresOnSaturation();
462  cmds::GetError cmd;
463  cmd.Init(shared_memory_id_, shared_memory_offset_);
464  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
465  return static_cast<GLint>(*GetSharedMemoryAs<GLenum*>());
466}
467
468void GLES2DecoderTestBase::DoCreateShader(
469    GLenum shader_type, GLuint client_id, GLuint service_id) {
470  EXPECT_CALL(*gl_, CreateShader(shader_type))
471      .Times(1)
472      .WillOnce(Return(service_id))
473      .RetiresOnSaturation();
474  cmds::CreateShader cmd;
475  cmd.Init(shader_type, client_id);
476  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
477}
478
479bool GLES2DecoderTestBase::DoIsShader(GLuint client_id) {
480  return IsObjectHelper<cmds::IsShader, cmds::IsShader::Result>(client_id);
481}
482
483void GLES2DecoderTestBase::DoDeleteShader(
484    GLuint client_id, GLuint service_id) {
485  EXPECT_CALL(*gl_, DeleteShader(service_id))
486      .Times(1)
487      .RetiresOnSaturation();
488  cmds::DeleteShader cmd;
489  cmd.Init(client_id);
490  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
491}
492
493void GLES2DecoderTestBase::DoCreateProgram(
494    GLuint client_id, GLuint service_id) {
495  EXPECT_CALL(*gl_, CreateProgram())
496      .Times(1)
497      .WillOnce(Return(service_id))
498      .RetiresOnSaturation();
499  cmds::CreateProgram cmd;
500  cmd.Init(client_id);
501  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
502}
503
504bool GLES2DecoderTestBase::DoIsProgram(GLuint client_id) {
505  return IsObjectHelper<cmds::IsProgram, cmds::IsProgram::Result>(client_id);
506}
507
508void GLES2DecoderTestBase::DoDeleteProgram(
509    GLuint client_id, GLuint /* service_id */) {
510  cmds::DeleteProgram cmd;
511  cmd.Init(client_id);
512  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
513}
514
515void GLES2DecoderTestBase::SetBucketAsCString(
516    uint32 bucket_id, const char* str) {
517  uint32 size = str ? (strlen(str) + 1) : 0;
518  cmd::SetBucketSize cmd1;
519  cmd1.Init(bucket_id, size);
520  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd1));
521  if (str) {
522    memcpy(shared_memory_address_, str, size);
523    cmd::SetBucketData cmd2;
524    cmd2.Init(bucket_id, 0, size, kSharedMemoryId, kSharedMemoryOffset);
525    EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
526    ClearSharedMemory();
527  }
528}
529
530void GLES2DecoderTestBase::SetupClearTextureExpectations(
531      GLuint service_id,
532      GLuint old_service_id,
533      GLenum bind_target,
534      GLenum target,
535      GLint level,
536      GLenum internal_format,
537      GLenum format,
538      GLenum type,
539      GLsizei width,
540      GLsizei height) {
541  EXPECT_CALL(*gl_, BindTexture(bind_target, service_id))
542      .Times(1)
543      .RetiresOnSaturation();
544  EXPECT_CALL(*gl_, TexImage2D(
545      target, level, internal_format, width, height, 0, format, type, _))
546      .Times(1)
547      .RetiresOnSaturation();
548  EXPECT_CALL(*gl_, BindTexture(bind_target, old_service_id))
549      .Times(1)
550      .RetiresOnSaturation();
551}
552
553void GLES2DecoderTestBase::SetupExpectationsForFramebufferClearing(
554    GLenum target,
555    GLuint clear_bits,
556    GLclampf restore_red,
557    GLclampf restore_green,
558    GLclampf restore_blue,
559    GLclampf restore_alpha,
560    GLuint restore_stencil,
561    GLclampf restore_depth,
562    bool restore_scissor_test) {
563  SetupExpectationsForFramebufferClearingMulti(
564      0,
565      0,
566      target,
567      clear_bits,
568      restore_red,
569      restore_green,
570      restore_blue,
571      restore_alpha,
572      restore_stencil,
573      restore_depth,
574      restore_scissor_test);
575}
576
577void GLES2DecoderTestBase::SetupExpectationsForRestoreClearState(
578    GLclampf restore_red,
579    GLclampf restore_green,
580    GLclampf restore_blue,
581    GLclampf restore_alpha,
582    GLuint restore_stencil,
583    GLclampf restore_depth,
584    bool restore_scissor_test) {
585  EXPECT_CALL(*gl_, ClearColor(
586      restore_red, restore_green, restore_blue, restore_alpha))
587      .Times(1)
588      .RetiresOnSaturation();
589  EXPECT_CALL(*gl_, ClearStencil(restore_stencil))
590      .Times(1)
591      .RetiresOnSaturation();
592  EXPECT_CALL(*gl_, ClearDepth(restore_depth))
593      .Times(1)
594      .RetiresOnSaturation();
595  if (restore_scissor_test) {
596    EXPECT_CALL(*gl_, Enable(GL_SCISSOR_TEST))
597        .Times(1)
598        .RetiresOnSaturation();
599  }
600}
601
602void GLES2DecoderTestBase::SetupExpectationsForFramebufferClearingMulti(
603    GLuint read_framebuffer_service_id,
604    GLuint draw_framebuffer_service_id,
605    GLenum target,
606    GLuint clear_bits,
607    GLclampf restore_red,
608    GLclampf restore_green,
609    GLclampf restore_blue,
610    GLclampf restore_alpha,
611    GLuint restore_stencil,
612    GLclampf restore_depth,
613    bool restore_scissor_test) {
614  // TODO(gman): Figure out why InSequence stopped working.
615  // InSequence sequence;
616  EXPECT_CALL(*gl_, CheckFramebufferStatusEXT(target))
617      .WillOnce(Return(GL_FRAMEBUFFER_COMPLETE))
618      .RetiresOnSaturation();
619  if (target == GL_READ_FRAMEBUFFER_EXT) {
620    EXPECT_CALL(*gl_, BindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, 0))
621        .Times(1)
622        .RetiresOnSaturation();
623    EXPECT_CALL(*gl_, BindFramebufferEXT(
624        GL_DRAW_FRAMEBUFFER_EXT, read_framebuffer_service_id))
625        .Times(1)
626        .RetiresOnSaturation();
627  }
628  if ((clear_bits & GL_COLOR_BUFFER_BIT) != 0) {
629    EXPECT_CALL(*gl_, ClearColor(0.0f, 0.0f, 0.0f, 0.0f))
630        .Times(1)
631        .RetiresOnSaturation();
632    SetupExpectationsForColorMask(true, true, true, true);
633  }
634  if ((clear_bits & GL_STENCIL_BUFFER_BIT) != 0) {
635    EXPECT_CALL(*gl_, ClearStencil(0))
636        .Times(1)
637        .RetiresOnSaturation();
638    EXPECT_CALL(*gl_, StencilMask(static_cast<GLuint>(-1)))
639        .Times(1)
640        .RetiresOnSaturation();
641  }
642  if ((clear_bits & GL_DEPTH_BUFFER_BIT) != 0) {
643    EXPECT_CALL(*gl_, ClearDepth(1.0f))
644        .Times(1)
645        .RetiresOnSaturation();
646    SetupExpectationsForDepthMask(true);
647  }
648  SetupExpectationsForEnableDisable(GL_SCISSOR_TEST, false);
649  EXPECT_CALL(*gl_, Clear(clear_bits))
650      .Times(1)
651      .RetiresOnSaturation();
652  SetupExpectationsForRestoreClearState(
653      restore_red, restore_green, restore_blue, restore_alpha,
654      restore_stencil, restore_depth, restore_scissor_test);
655  if (target == GL_READ_FRAMEBUFFER_EXT) {
656    EXPECT_CALL(*gl_, BindFramebufferEXT(
657        GL_READ_FRAMEBUFFER_EXT, read_framebuffer_service_id))
658        .Times(1)
659        .RetiresOnSaturation();
660    EXPECT_CALL(*gl_, BindFramebufferEXT(
661        GL_DRAW_FRAMEBUFFER_EXT, draw_framebuffer_service_id))
662        .Times(1)
663        .RetiresOnSaturation();
664  }
665}
666
667void GLES2DecoderTestBase::SetupShaderForUniform(GLenum uniform_type) {
668  static AttribInfo attribs[] = {
669    { "foo", 1, GL_FLOAT, 1, },
670    { "goo", 1, GL_FLOAT, 2, },
671  };
672  UniformInfo uniforms[] = {
673    { "bar", 1, uniform_type, 0, 2, -1, },
674    { "car", 4, uniform_type, 1, 1, -1, },
675  };
676  const GLuint kClientVertexShaderId = 5001;
677  const GLuint kServiceVertexShaderId = 6001;
678  const GLuint kClientFragmentShaderId = 5002;
679  const GLuint kServiceFragmentShaderId = 6002;
680  SetupShader(attribs, arraysize(attribs), uniforms, arraysize(uniforms),
681              client_program_id_, kServiceProgramId,
682              kClientVertexShaderId, kServiceVertexShaderId,
683              kClientFragmentShaderId, kServiceFragmentShaderId);
684
685  EXPECT_CALL(*gl_, UseProgram(kServiceProgramId))
686      .Times(1)
687      .RetiresOnSaturation();
688  cmds::UseProgram cmd;
689  cmd.Init(client_program_id_);
690  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
691}
692
693void GLES2DecoderTestBase::DoBindBuffer(
694    GLenum target, GLuint client_id, GLuint service_id) {
695  EXPECT_CALL(*gl_, BindBuffer(target, service_id))
696      .Times(1)
697      .RetiresOnSaturation();
698  cmds::BindBuffer cmd;
699  cmd.Init(target, client_id);
700  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
701}
702
703bool GLES2DecoderTestBase::DoIsBuffer(GLuint client_id) {
704  return IsObjectHelper<cmds::IsBuffer, cmds::IsBuffer::Result>(client_id);
705}
706
707void GLES2DecoderTestBase::DoDeleteBuffer(
708    GLuint client_id, GLuint service_id) {
709  EXPECT_CALL(*gl_, DeleteBuffersARB(1, Pointee(service_id)))
710      .Times(1)
711      .RetiresOnSaturation();
712  GenHelper<cmds::DeleteBuffersImmediate>(client_id);
713}
714
715void GLES2DecoderTestBase::SetupExpectationsForColorMask(bool red,
716                                                         bool green,
717                                                         bool blue,
718                                                         bool alpha) {
719  if (ignore_cached_state_for_test_ || cached_color_mask_red_ != red ||
720      cached_color_mask_green_ != green || cached_color_mask_blue_ != blue ||
721      cached_color_mask_alpha_ != alpha) {
722    cached_color_mask_red_ = red;
723    cached_color_mask_green_ = green;
724    cached_color_mask_blue_ = blue;
725    cached_color_mask_alpha_ = alpha;
726    EXPECT_CALL(*gl_, ColorMask(red, green, blue, alpha))
727        .Times(1)
728        .RetiresOnSaturation();
729  }
730}
731
732void GLES2DecoderTestBase::SetupExpectationsForDepthMask(bool mask) {
733  if (ignore_cached_state_for_test_ || cached_depth_mask_ != mask) {
734    cached_depth_mask_ = mask;
735    EXPECT_CALL(*gl_, DepthMask(mask)).Times(1).RetiresOnSaturation();
736  }
737}
738
739void GLES2DecoderTestBase::SetupExpectationsForStencilMask(GLuint front_mask,
740                                                           GLuint back_mask) {
741  if (ignore_cached_state_for_test_ ||
742      cached_stencil_front_mask_ != front_mask) {
743    cached_stencil_front_mask_ = front_mask;
744    EXPECT_CALL(*gl_, StencilMaskSeparate(GL_FRONT, front_mask))
745        .Times(1)
746        .RetiresOnSaturation();
747  }
748
749  if (ignore_cached_state_for_test_ ||
750      cached_stencil_back_mask_ != back_mask) {
751    cached_stencil_back_mask_ = back_mask;
752    EXPECT_CALL(*gl_, StencilMaskSeparate(GL_BACK, back_mask))
753        .Times(1)
754        .RetiresOnSaturation();
755  }
756}
757
758void GLES2DecoderTestBase::SetupExpectationsForEnableDisable(GLenum cap,
759                                                             bool enable) {
760  switch (cap) {
761    case GL_BLEND:
762      if (enable_flags_.cached_blend == enable &&
763          !ignore_cached_state_for_test_)
764        return;
765      enable_flags_.cached_blend = enable;
766      break;
767    case GL_CULL_FACE:
768      if (enable_flags_.cached_cull_face == enable &&
769          !ignore_cached_state_for_test_)
770        return;
771      enable_flags_.cached_cull_face = enable;
772      break;
773    case GL_DEPTH_TEST:
774      if (enable_flags_.cached_depth_test == enable &&
775          !ignore_cached_state_for_test_)
776        return;
777      enable_flags_.cached_depth_test = enable;
778      break;
779    case GL_DITHER:
780      if (enable_flags_.cached_dither == enable &&
781          !ignore_cached_state_for_test_)
782        return;
783      enable_flags_.cached_dither = enable;
784      break;
785    case GL_POLYGON_OFFSET_FILL:
786      if (enable_flags_.cached_polygon_offset_fill == enable &&
787          !ignore_cached_state_for_test_)
788        return;
789      enable_flags_.cached_polygon_offset_fill = enable;
790      break;
791    case GL_SAMPLE_ALPHA_TO_COVERAGE:
792      if (enable_flags_.cached_sample_alpha_to_coverage == enable &&
793          !ignore_cached_state_for_test_)
794        return;
795      enable_flags_.cached_sample_alpha_to_coverage = enable;
796      break;
797    case GL_SAMPLE_COVERAGE:
798      if (enable_flags_.cached_sample_coverage == enable &&
799          !ignore_cached_state_for_test_)
800        return;
801      enable_flags_.cached_sample_coverage = enable;
802      break;
803    case GL_SCISSOR_TEST:
804      if (enable_flags_.cached_scissor_test == enable &&
805          !ignore_cached_state_for_test_)
806        return;
807      enable_flags_.cached_scissor_test = enable;
808      break;
809    case GL_STENCIL_TEST:
810      if (enable_flags_.cached_stencil_test == enable &&
811          !ignore_cached_state_for_test_)
812        return;
813      enable_flags_.cached_stencil_test = enable;
814      break;
815    default:
816      NOTREACHED();
817      return;
818  }
819  if (enable) {
820    EXPECT_CALL(*gl_, Enable(cap)).Times(1).RetiresOnSaturation();
821  } else {
822    EXPECT_CALL(*gl_, Disable(cap)).Times(1).RetiresOnSaturation();
823  }
824}
825
826void GLES2DecoderTestBase::SetupExpectationsForApplyingDirtyState(
827    bool framebuffer_is_rgb,
828    bool framebuffer_has_depth,
829    bool framebuffer_has_stencil,
830    GLuint color_bits,
831    bool depth_mask,
832    bool depth_enabled,
833    GLuint front_stencil_mask,
834    GLuint back_stencil_mask,
835    bool stencil_enabled) {
836  bool color_mask_red = (color_bits & 0x1000) != 0;
837  bool color_mask_green = (color_bits & 0x0100) != 0;
838  bool color_mask_blue = (color_bits & 0x0010) != 0;
839  bool color_mask_alpha = (color_bits & 0x0001) && !framebuffer_is_rgb;
840
841  SetupExpectationsForColorMask(
842      color_mask_red, color_mask_green, color_mask_blue, color_mask_alpha);
843  SetupExpectationsForDepthMask(depth_mask);
844  SetupExpectationsForStencilMask(front_stencil_mask, back_stencil_mask);
845  SetupExpectationsForEnableDisable(GL_DEPTH_TEST,
846                                    framebuffer_has_depth && depth_enabled);
847  SetupExpectationsForEnableDisable(GL_STENCIL_TEST,
848                                    framebuffer_has_stencil && stencil_enabled);
849}
850
851void GLES2DecoderTestBase::SetupExpectationsForApplyingDefaultDirtyState() {
852  SetupExpectationsForApplyingDirtyState(false,   // Framebuffer is RGB
853                                         false,   // Framebuffer has depth
854                                         false,   // Framebuffer has stencil
855                                         0x1111,  // color bits
856                                         true,    // depth mask
857                                         false,   // depth enabled
858                                         0,       // front stencil mask
859                                         0,       // back stencil mask
860                                         false);  // stencil enabled
861}
862
863GLES2DecoderTestBase::EnableFlags::EnableFlags()
864    : cached_blend(false),
865      cached_cull_face(false),
866      cached_depth_test(false),
867      cached_dither(true),
868      cached_polygon_offset_fill(false),
869      cached_sample_alpha_to_coverage(false),
870      cached_sample_coverage(false),
871      cached_scissor_test(false),
872      cached_stencil_test(false) {
873}
874
875void GLES2DecoderTestBase::DoBindFramebuffer(
876    GLenum target, GLuint client_id, GLuint service_id) {
877  EXPECT_CALL(*gl_, BindFramebufferEXT(target, service_id))
878      .Times(1)
879      .RetiresOnSaturation();
880  cmds::BindFramebuffer cmd;
881  cmd.Init(target, client_id);
882  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
883}
884
885bool GLES2DecoderTestBase::DoIsFramebuffer(GLuint client_id) {
886  return IsObjectHelper<cmds::IsFramebuffer, cmds::IsFramebuffer::Result>(
887      client_id);
888}
889
890void GLES2DecoderTestBase::DoDeleteFramebuffer(
891    GLuint client_id, GLuint service_id,
892    bool reset_draw, GLenum draw_target, GLuint draw_id,
893    bool reset_read, GLenum read_target, GLuint read_id) {
894  if (reset_draw) {
895    EXPECT_CALL(*gl_, BindFramebufferEXT(draw_target, draw_id))
896        .Times(1)
897        .RetiresOnSaturation();
898  }
899  if (reset_read) {
900    EXPECT_CALL(*gl_, BindFramebufferEXT(read_target, read_id))
901        .Times(1)
902        .RetiresOnSaturation();
903  }
904  EXPECT_CALL(*gl_, DeleteFramebuffersEXT(1, Pointee(service_id)))
905      .Times(1)
906      .RetiresOnSaturation();
907  GenHelper<cmds::DeleteFramebuffersImmediate>(client_id);
908}
909
910void GLES2DecoderTestBase::DoBindRenderbuffer(
911    GLenum target, GLuint client_id, GLuint service_id) {
912  service_renderbuffer_id_ = service_id;
913  service_renderbuffer_valid_ = true;
914  EXPECT_CALL(*gl_, BindRenderbufferEXT(target, service_id))
915      .Times(1)
916      .RetiresOnSaturation();
917  cmds::BindRenderbuffer cmd;
918  cmd.Init(target, client_id);
919  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
920}
921
922void GLES2DecoderTestBase::DoRenderbufferStorageMultisampleCHROMIUM(
923    GLenum target,
924    GLsizei samples,
925    GLenum internal_format,
926    GLenum gl_format,
927    GLsizei width,
928    GLsizei height) {
929  EXPECT_CALL(*gl_, GetError())
930      .WillOnce(Return(GL_NO_ERROR))
931      .RetiresOnSaturation();
932  EXPECT_CALL(*gl_,
933              RenderbufferStorageMultisampleEXT(
934                  target, samples, gl_format, width, height))
935      .Times(1)
936      .RetiresOnSaturation();
937  EXPECT_CALL(*gl_, GetError())
938      .WillOnce(Return(GL_NO_ERROR))
939      .RetiresOnSaturation();
940  cmds::RenderbufferStorageMultisampleCHROMIUM cmd;
941  cmd.Init(target, samples, internal_format, width, height);
942  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
943  EXPECT_EQ(GL_NO_ERROR, GetGLError());
944}
945
946void GLES2DecoderTestBase::RestoreRenderbufferBindings() {
947  GetDecoder()->RestoreRenderbufferBindings();
948  service_renderbuffer_valid_ = false;
949}
950
951void GLES2DecoderTestBase::EnsureRenderbufferBound(bool expect_bind) {
952  EXPECT_NE(expect_bind, service_renderbuffer_valid_);
953
954  if (expect_bind) {
955    service_renderbuffer_valid_ = true;
956    EXPECT_CALL(*gl_,
957                BindRenderbufferEXT(GL_RENDERBUFFER, service_renderbuffer_id_))
958        .Times(1)
959        .RetiresOnSaturation();
960  } else {
961    EXPECT_CALL(*gl_, BindRenderbufferEXT(_, _)).Times(0);
962  }
963}
964
965bool GLES2DecoderTestBase::DoIsRenderbuffer(GLuint client_id) {
966  return IsObjectHelper<cmds::IsRenderbuffer, cmds::IsRenderbuffer::Result>(
967      client_id);
968}
969
970void GLES2DecoderTestBase::DoDeleteRenderbuffer(
971    GLuint client_id, GLuint service_id) {
972  EXPECT_CALL(*gl_, DeleteRenderbuffersEXT(1, Pointee(service_id)))
973      .Times(1)
974      .RetiresOnSaturation();
975  GenHelper<cmds::DeleteRenderbuffersImmediate>(client_id);
976}
977
978void GLES2DecoderTestBase::DoBindTexture(
979    GLenum target, GLuint client_id, GLuint service_id) {
980  EXPECT_CALL(*gl_, BindTexture(target, service_id))
981      .Times(1)
982      .RetiresOnSaturation();
983  cmds::BindTexture cmd;
984  cmd.Init(target, client_id);
985  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
986}
987
988bool GLES2DecoderTestBase::DoIsTexture(GLuint client_id) {
989  return IsObjectHelper<cmds::IsTexture, cmds::IsTexture::Result>(client_id);
990}
991
992void GLES2DecoderTestBase::DoDeleteTexture(
993    GLuint client_id, GLuint service_id) {
994  EXPECT_CALL(*gl_, DeleteTextures(1, Pointee(service_id)))
995      .Times(1)
996      .RetiresOnSaturation();
997  GenHelper<cmds::DeleteTexturesImmediate>(client_id);
998}
999
1000void GLES2DecoderTestBase::DoTexImage2D(
1001    GLenum target, GLint level, GLenum internal_format,
1002    GLsizei width, GLsizei height, GLint border,
1003    GLenum format, GLenum type,
1004    uint32 shared_memory_id, uint32 shared_memory_offset) {
1005  EXPECT_CALL(*gl_, GetError())
1006      .WillOnce(Return(GL_NO_ERROR))
1007      .RetiresOnSaturation();
1008  EXPECT_CALL(*gl_, TexImage2D(target, level, internal_format,
1009                               width, height, border, format, type, _))
1010      .Times(1)
1011      .RetiresOnSaturation();
1012  EXPECT_CALL(*gl_, GetError())
1013      .WillOnce(Return(GL_NO_ERROR))
1014      .RetiresOnSaturation();
1015  cmds::TexImage2D cmd;
1016  cmd.Init(target, level, internal_format, width, height, format,
1017           type, shared_memory_id, shared_memory_offset);
1018  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1019}
1020
1021void GLES2DecoderTestBase::DoTexImage2DConvertInternalFormat(
1022    GLenum target, GLint level, GLenum requested_internal_format,
1023    GLsizei width, GLsizei height, GLint border,
1024    GLenum format, GLenum type,
1025    uint32 shared_memory_id, uint32 shared_memory_offset,
1026    GLenum expected_internal_format) {
1027  EXPECT_CALL(*gl_, GetError())
1028      .WillOnce(Return(GL_NO_ERROR))
1029      .RetiresOnSaturation();
1030  EXPECT_CALL(*gl_, TexImage2D(target, level, expected_internal_format,
1031                               width, height, border, format, type, _))
1032      .Times(1)
1033      .RetiresOnSaturation();
1034  EXPECT_CALL(*gl_, GetError())
1035      .WillOnce(Return(GL_NO_ERROR))
1036      .RetiresOnSaturation();
1037  cmds::TexImage2D cmd;
1038  cmd.Init(target, level, requested_internal_format, width, height,
1039           format, type, shared_memory_id, shared_memory_offset);
1040  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1041}
1042
1043void GLES2DecoderTestBase::DoCompressedTexImage2D(
1044    GLenum target, GLint level, GLenum format,
1045    GLsizei width, GLsizei height, GLint border,
1046    GLsizei size, uint32 bucket_id) {
1047  EXPECT_CALL(*gl_, GetError())
1048      .WillOnce(Return(GL_NO_ERROR))
1049      .RetiresOnSaturation();
1050  EXPECT_CALL(*gl_, CompressedTexImage2D(
1051      target, level, format, width, height, border, size, _))
1052      .Times(1)
1053      .RetiresOnSaturation();
1054  EXPECT_CALL(*gl_, GetError())
1055      .WillOnce(Return(GL_NO_ERROR))
1056      .RetiresOnSaturation();
1057  CommonDecoder::Bucket* bucket = decoder_->CreateBucket(bucket_id);
1058  bucket->SetSize(size);
1059  cmds::CompressedTexImage2DBucket cmd;
1060  cmd.Init(
1061      target, level, format, width, height,
1062      bucket_id);
1063  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1064}
1065
1066void GLES2DecoderTestBase::DoRenderbufferStorage(
1067    GLenum target, GLenum internal_format, GLenum actual_format,
1068    GLsizei width, GLsizei height,  GLenum error) {
1069  EXPECT_CALL(*gl_, GetError())
1070      .WillOnce(Return(GL_NO_ERROR))
1071      .RetiresOnSaturation();
1072  EXPECT_CALL(*gl_, RenderbufferStorageEXT(
1073      target, actual_format, width, height))
1074      .Times(1)
1075      .RetiresOnSaturation();
1076  EXPECT_CALL(*gl_, GetError())
1077      .WillOnce(Return(error))
1078      .RetiresOnSaturation();
1079  cmds::RenderbufferStorage cmd;
1080  cmd.Init(target, internal_format, width, height);
1081  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1082}
1083
1084void GLES2DecoderTestBase::DoFramebufferTexture2D(
1085    GLenum target, GLenum attachment, GLenum textarget,
1086    GLuint texture_client_id, GLuint texture_service_id, GLint level,
1087    GLenum error) {
1088  EXPECT_CALL(*gl_, GetError())
1089      .WillOnce(Return(GL_NO_ERROR))
1090      .RetiresOnSaturation();
1091  EXPECT_CALL(*gl_, FramebufferTexture2DEXT(
1092      target, attachment, textarget, texture_service_id, level))
1093      .Times(1)
1094      .RetiresOnSaturation();
1095  EXPECT_CALL(*gl_, GetError())
1096      .WillOnce(Return(error))
1097      .RetiresOnSaturation();
1098  cmds::FramebufferTexture2D cmd;
1099  cmd.Init(target, attachment, textarget, texture_client_id);
1100  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1101}
1102
1103void GLES2DecoderTestBase::DoFramebufferRenderbuffer(
1104    GLenum target,
1105    GLenum attachment,
1106    GLenum renderbuffer_target,
1107    GLuint renderbuffer_client_id,
1108    GLuint renderbuffer_service_id,
1109    GLenum error) {
1110  EXPECT_CALL(*gl_, GetError())
1111      .WillOnce(Return(GL_NO_ERROR))
1112      .RetiresOnSaturation();
1113  EXPECT_CALL(*gl_, FramebufferRenderbufferEXT(
1114      target, attachment, renderbuffer_target, renderbuffer_service_id))
1115      .Times(1)
1116      .RetiresOnSaturation();
1117  EXPECT_CALL(*gl_, GetError())
1118      .WillOnce(Return(error))
1119      .RetiresOnSaturation();
1120  cmds::FramebufferRenderbuffer cmd;
1121  cmd.Init(target, attachment, renderbuffer_target, renderbuffer_client_id);
1122  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1123}
1124
1125void GLES2DecoderTestBase::DoVertexAttribPointer(
1126    GLuint index, GLint size, GLenum type, GLsizei stride, GLuint offset) {
1127  EXPECT_CALL(*gl_,
1128              VertexAttribPointer(index, size, type, GL_FALSE, stride,
1129                                  BufferOffset(offset)))
1130      .Times(1)
1131      .RetiresOnSaturation();
1132  cmds::VertexAttribPointer cmd;
1133  cmd.Init(index, size, GL_FLOAT, GL_FALSE, stride, offset);
1134  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1135}
1136
1137void GLES2DecoderTestBase::DoVertexAttribDivisorANGLE(
1138    GLuint index, GLuint divisor) {
1139  EXPECT_CALL(*gl_,
1140              VertexAttribDivisorANGLE(index, divisor))
1141      .Times(1)
1142      .RetiresOnSaturation();
1143  cmds::VertexAttribDivisorANGLE cmd;
1144  cmd.Init(index, divisor);
1145  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1146}
1147
1148void GLES2DecoderTestBase::AddExpectationsForGenVertexArraysOES(){
1149  if (group_->feature_info()->feature_flags().native_vertex_array_object) {
1150      EXPECT_CALL(*gl_, GenVertexArraysOES(1, _))
1151          .WillOnce(SetArgumentPointee<1>(kServiceVertexArrayId))
1152          .RetiresOnSaturation();
1153  }
1154}
1155
1156void GLES2DecoderTestBase::AddExpectationsForDeleteVertexArraysOES(){
1157  if (group_->feature_info()->feature_flags().native_vertex_array_object) {
1158      EXPECT_CALL(*gl_, DeleteVertexArraysOES(1, _))
1159          .Times(1)
1160          .RetiresOnSaturation();
1161  }
1162}
1163
1164void GLES2DecoderTestBase::AddExpectationsForDeleteBoundVertexArraysOES() {
1165  // Expectations are the same as a delete, followed by binding VAO 0.
1166  AddExpectationsForDeleteVertexArraysOES();
1167  AddExpectationsForBindVertexArrayOES();
1168}
1169
1170void GLES2DecoderTestBase::AddExpectationsForBindVertexArrayOES() {
1171  if (group_->feature_info()->feature_flags().native_vertex_array_object) {
1172    EXPECT_CALL(*gl_, BindVertexArrayOES(_))
1173      .Times(1)
1174      .RetiresOnSaturation();
1175  } else {
1176    for (uint32 vv = 0; vv < group_->max_vertex_attribs(); ++vv) {
1177      AddExpectationsForRestoreAttribState(vv);
1178    }
1179
1180    EXPECT_CALL(*gl_, BindBuffer(GL_ELEMENT_ARRAY_BUFFER, _))
1181      .Times(1)
1182      .RetiresOnSaturation();
1183  }
1184}
1185
1186void GLES2DecoderTestBase::AddExpectationsForRestoreAttribState(GLuint attrib) {
1187  EXPECT_CALL(*gl_, BindBuffer(GL_ARRAY_BUFFER, _))
1188      .Times(1)
1189      .RetiresOnSaturation();
1190
1191  EXPECT_CALL(*gl_, VertexAttribPointer(attrib, _, _, _, _, _))
1192      .Times(1)
1193      .RetiresOnSaturation();
1194
1195  EXPECT_CALL(*gl_, VertexAttribDivisorANGLE(attrib, _))
1196        .Times(testing::AtMost(1))
1197        .RetiresOnSaturation();
1198
1199  EXPECT_CALL(*gl_, BindBuffer(GL_ARRAY_BUFFER, _))
1200      .Times(1)
1201      .RetiresOnSaturation();
1202
1203  if (attrib != 0 ||
1204      gfx::GetGLImplementation() == gfx::kGLImplementationEGLGLES2) {
1205
1206      // TODO(bajones): Not sure if I can tell which of these will be called
1207      EXPECT_CALL(*gl_, EnableVertexAttribArray(attrib))
1208          .Times(testing::AtMost(1))
1209          .RetiresOnSaturation();
1210
1211      EXPECT_CALL(*gl_, DisableVertexAttribArray(attrib))
1212          .Times(testing::AtMost(1))
1213          .RetiresOnSaturation();
1214  }
1215}
1216
1217// GCC requires these declarations, but MSVC requires they not be present
1218#ifndef COMPILER_MSVC
1219const int GLES2DecoderTestBase::kBackBufferWidth;
1220const int GLES2DecoderTestBase::kBackBufferHeight;
1221
1222const GLint GLES2DecoderTestBase::kMaxTextureSize;
1223const GLint GLES2DecoderTestBase::kMaxCubeMapTextureSize;
1224const GLint GLES2DecoderTestBase::kNumVertexAttribs;
1225const GLint GLES2DecoderTestBase::kNumTextureUnits;
1226const GLint GLES2DecoderTestBase::kMaxTextureImageUnits;
1227const GLint GLES2DecoderTestBase::kMaxVertexTextureImageUnits;
1228const GLint GLES2DecoderTestBase::kMaxFragmentUniformVectors;
1229const GLint GLES2DecoderTestBase::kMaxVaryingVectors;
1230const GLint GLES2DecoderTestBase::kMaxVertexUniformVectors;
1231const GLint GLES2DecoderTestBase::kMaxViewportWidth;
1232const GLint GLES2DecoderTestBase::kMaxViewportHeight;
1233
1234const GLint GLES2DecoderTestBase::kViewportX;
1235const GLint GLES2DecoderTestBase::kViewportY;
1236const GLint GLES2DecoderTestBase::kViewportWidth;
1237const GLint GLES2DecoderTestBase::kViewportHeight;
1238
1239const GLuint GLES2DecoderTestBase::kServiceAttrib0BufferId;
1240const GLuint GLES2DecoderTestBase::kServiceFixedAttribBufferId;
1241
1242const GLuint GLES2DecoderTestBase::kServiceBufferId;
1243const GLuint GLES2DecoderTestBase::kServiceFramebufferId;
1244const GLuint GLES2DecoderTestBase::kServiceRenderbufferId;
1245const GLuint GLES2DecoderTestBase::kServiceTextureId;
1246const GLuint GLES2DecoderTestBase::kServiceProgramId;
1247const GLuint GLES2DecoderTestBase::kServiceShaderId;
1248const GLuint GLES2DecoderTestBase::kServiceElementBufferId;
1249const GLuint GLES2DecoderTestBase::kServiceQueryId;
1250const GLuint GLES2DecoderTestBase::kServiceVertexArrayId;
1251
1252const int32 GLES2DecoderTestBase::kSharedMemoryId;
1253const size_t GLES2DecoderTestBase::kSharedBufferSize;
1254const uint32 GLES2DecoderTestBase::kSharedMemoryOffset;
1255const int32 GLES2DecoderTestBase::kInvalidSharedMemoryId;
1256const uint32 GLES2DecoderTestBase::kInvalidSharedMemoryOffset;
1257const uint32 GLES2DecoderTestBase::kInitialResult;
1258const uint8 GLES2DecoderTestBase::kInitialMemoryValue;
1259
1260const uint32 GLES2DecoderTestBase::kNewClientId;
1261const uint32 GLES2DecoderTestBase::kNewServiceId;
1262const uint32 GLES2DecoderTestBase::kInvalidClientId;
1263
1264const GLuint GLES2DecoderTestBase::kServiceVertexShaderId;
1265const GLuint GLES2DecoderTestBase::kServiceFragmentShaderId;
1266
1267const GLuint GLES2DecoderTestBase::kServiceCopyTextureChromiumShaderId;
1268const GLuint GLES2DecoderTestBase::kServiceCopyTextureChromiumProgramId;
1269
1270const GLuint GLES2DecoderTestBase::kServiceCopyTextureChromiumTextureBufferId;
1271const GLuint GLES2DecoderTestBase::kServiceCopyTextureChromiumVertexBufferId;
1272const GLuint GLES2DecoderTestBase::kServiceCopyTextureChromiumFBOId;
1273const GLuint GLES2DecoderTestBase::kServiceCopyTextureChromiumPositionAttrib;
1274const GLuint GLES2DecoderTestBase::kServiceCopyTextureChromiumTexAttrib;
1275const GLuint GLES2DecoderTestBase::kServiceCopyTextureChromiumSamplerLocation;
1276
1277const GLsizei GLES2DecoderTestBase::kNumVertices;
1278const GLsizei GLES2DecoderTestBase::kNumIndices;
1279const int GLES2DecoderTestBase::kValidIndexRangeStart;
1280const int GLES2DecoderTestBase::kValidIndexRangeCount;
1281const int GLES2DecoderTestBase::kInvalidIndexRangeStart;
1282const int GLES2DecoderTestBase::kInvalidIndexRangeCount;
1283const int GLES2DecoderTestBase::kOutOfRangeIndexRangeEnd;
1284const GLuint GLES2DecoderTestBase::kMaxValidIndex;
1285
1286const GLint GLES2DecoderTestBase::kMaxAttribLength;
1287const GLint GLES2DecoderTestBase::kAttrib1Size;
1288const GLint GLES2DecoderTestBase::kAttrib2Size;
1289const GLint GLES2DecoderTestBase::kAttrib3Size;
1290const GLint GLES2DecoderTestBase::kAttrib1Location;
1291const GLint GLES2DecoderTestBase::kAttrib2Location;
1292const GLint GLES2DecoderTestBase::kAttrib3Location;
1293const GLenum GLES2DecoderTestBase::kAttrib1Type;
1294const GLenum GLES2DecoderTestBase::kAttrib2Type;
1295const GLenum GLES2DecoderTestBase::kAttrib3Type;
1296const GLint GLES2DecoderTestBase::kInvalidAttribLocation;
1297const GLint GLES2DecoderTestBase::kBadAttribIndex;
1298
1299const GLint GLES2DecoderTestBase::kMaxUniformLength;
1300const GLint GLES2DecoderTestBase::kUniform1Size;
1301const GLint GLES2DecoderTestBase::kUniform2Size;
1302const GLint GLES2DecoderTestBase::kUniform3Size;
1303const GLint GLES2DecoderTestBase::kUniform1RealLocation;
1304const GLint GLES2DecoderTestBase::kUniform2RealLocation;
1305const GLint GLES2DecoderTestBase::kUniform2ElementRealLocation;
1306const GLint GLES2DecoderTestBase::kUniform3RealLocation;
1307const GLint GLES2DecoderTestBase::kUniform1FakeLocation;
1308const GLint GLES2DecoderTestBase::kUniform2FakeLocation;
1309const GLint GLES2DecoderTestBase::kUniform2ElementFakeLocation;
1310const GLint GLES2DecoderTestBase::kUniform3FakeLocation;
1311const GLint GLES2DecoderTestBase::kUniform1DesiredLocation;
1312const GLint GLES2DecoderTestBase::kUniform2DesiredLocation;
1313const GLint GLES2DecoderTestBase::kUniform3DesiredLocation;
1314const GLenum GLES2DecoderTestBase::kUniform1Type;
1315const GLenum GLES2DecoderTestBase::kUniform2Type;
1316const GLenum GLES2DecoderTestBase::kUniform3Type;
1317const GLenum GLES2DecoderTestBase::kUniformCubemapType;
1318const GLint GLES2DecoderTestBase::kInvalidUniformLocation;
1319const GLint GLES2DecoderTestBase::kBadUniformIndex;
1320
1321#endif
1322
1323const char* GLES2DecoderTestBase::kAttrib1Name = "attrib1";
1324const char* GLES2DecoderTestBase::kAttrib2Name = "attrib2";
1325const char* GLES2DecoderTestBase::kAttrib3Name = "attrib3";
1326const char* GLES2DecoderTestBase::kUniform1Name = "uniform1";
1327const char* GLES2DecoderTestBase::kUniform2Name = "uniform2[0]";
1328const char* GLES2DecoderTestBase::kUniform3Name = "uniform3[0]";
1329
1330void GLES2DecoderTestBase::SetupDefaultProgram() {
1331  {
1332    static AttribInfo attribs[] = {
1333      { kAttrib1Name, kAttrib1Size, kAttrib1Type, kAttrib1Location, },
1334      { kAttrib2Name, kAttrib2Size, kAttrib2Type, kAttrib2Location, },
1335      { kAttrib3Name, kAttrib3Size, kAttrib3Type, kAttrib3Location, },
1336    };
1337    static UniformInfo uniforms[] = {
1338      { kUniform1Name, kUniform1Size, kUniform1Type,
1339        kUniform1FakeLocation, kUniform1RealLocation,
1340        kUniform1DesiredLocation },
1341      { kUniform2Name, kUniform2Size, kUniform2Type,
1342        kUniform2FakeLocation, kUniform2RealLocation,
1343        kUniform2DesiredLocation },
1344      { kUniform3Name, kUniform3Size, kUniform3Type,
1345        kUniform3FakeLocation, kUniform3RealLocation,
1346        kUniform3DesiredLocation },
1347    };
1348    SetupShader(attribs, arraysize(attribs), uniforms, arraysize(uniforms),
1349                client_program_id_, kServiceProgramId,
1350                client_vertex_shader_id_, kServiceVertexShaderId,
1351                client_fragment_shader_id_, kServiceFragmentShaderId);
1352  }
1353
1354  {
1355    EXPECT_CALL(*gl_, UseProgram(kServiceProgramId))
1356        .Times(1)
1357        .RetiresOnSaturation();
1358    cmds::UseProgram cmd;
1359    cmd.Init(client_program_id_);
1360    EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1361  }
1362}
1363
1364void GLES2DecoderTestBase::SetupCubemapProgram() {
1365  {
1366    static AttribInfo attribs[] = {
1367      { kAttrib1Name, kAttrib1Size, kAttrib1Type, kAttrib1Location, },
1368      { kAttrib2Name, kAttrib2Size, kAttrib2Type, kAttrib2Location, },
1369      { kAttrib3Name, kAttrib3Size, kAttrib3Type, kAttrib3Location, },
1370    };
1371    static UniformInfo uniforms[] = {
1372      { kUniform1Name, kUniform1Size, kUniformCubemapType,
1373        kUniform1FakeLocation, kUniform1RealLocation,
1374        kUniform1DesiredLocation, },
1375      { kUniform2Name, kUniform2Size, kUniform2Type,
1376        kUniform2FakeLocation, kUniform2RealLocation,
1377        kUniform2DesiredLocation, },
1378      { kUniform3Name, kUniform3Size, kUniform3Type,
1379        kUniform3FakeLocation, kUniform3RealLocation,
1380        kUniform3DesiredLocation, },
1381    };
1382    SetupShader(attribs, arraysize(attribs), uniforms, arraysize(uniforms),
1383                client_program_id_, kServiceProgramId,
1384                client_vertex_shader_id_, kServiceVertexShaderId,
1385                client_fragment_shader_id_, kServiceFragmentShaderId);
1386  }
1387
1388  {
1389    EXPECT_CALL(*gl_, UseProgram(kServiceProgramId))
1390        .Times(1)
1391        .RetiresOnSaturation();
1392    cmds::UseProgram cmd;
1393    cmd.Init(client_program_id_);
1394    EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1395  }
1396}
1397
1398void GLES2DecoderTestBase::SetupSamplerExternalProgram() {
1399  {
1400    static AttribInfo attribs[] = {
1401      { kAttrib1Name, kAttrib1Size, kAttrib1Type, kAttrib1Location, },
1402      { kAttrib2Name, kAttrib2Size, kAttrib2Type, kAttrib2Location, },
1403      { kAttrib3Name, kAttrib3Size, kAttrib3Type, kAttrib3Location, },
1404    };
1405    static UniformInfo uniforms[] = {
1406      { kUniform1Name, kUniform1Size, kUniformSamplerExternalType,
1407        kUniform1FakeLocation, kUniform1RealLocation,
1408        kUniform1DesiredLocation, },
1409      { kUniform2Name, kUniform2Size, kUniform2Type,
1410        kUniform2FakeLocation, kUniform2RealLocation,
1411        kUniform2DesiredLocation, },
1412      { kUniform3Name, kUniform3Size, kUniform3Type,
1413        kUniform3FakeLocation, kUniform3RealLocation,
1414        kUniform3DesiredLocation, },
1415    };
1416    SetupShader(attribs, arraysize(attribs), uniforms, arraysize(uniforms),
1417                client_program_id_, kServiceProgramId,
1418                client_vertex_shader_id_, kServiceVertexShaderId,
1419                client_fragment_shader_id_, kServiceFragmentShaderId);
1420  }
1421
1422  {
1423    EXPECT_CALL(*gl_, UseProgram(kServiceProgramId))
1424        .Times(1)
1425        .RetiresOnSaturation();
1426    cmds::UseProgram cmd;
1427    cmd.Init(client_program_id_);
1428    EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1429  }
1430}
1431
1432void GLES2DecoderWithShaderTestBase::TearDown() {
1433  GLES2DecoderTestBase::TearDown();
1434}
1435
1436void GLES2DecoderTestBase::SetupShader(
1437    GLES2DecoderTestBase::AttribInfo* attribs, size_t num_attribs,
1438    GLES2DecoderTestBase::UniformInfo* uniforms, size_t num_uniforms,
1439    GLuint program_client_id, GLuint program_service_id,
1440    GLuint vertex_shader_client_id, GLuint vertex_shader_service_id,
1441    GLuint fragment_shader_client_id, GLuint fragment_shader_service_id) {
1442  {
1443    InSequence s;
1444
1445    EXPECT_CALL(*gl_,
1446                AttachShader(program_service_id, vertex_shader_service_id))
1447        .Times(1)
1448        .RetiresOnSaturation();
1449    EXPECT_CALL(*gl_,
1450                AttachShader(program_service_id, fragment_shader_service_id))
1451        .Times(1)
1452        .RetiresOnSaturation();
1453    TestHelper::SetupShader(
1454        gl_.get(), attribs, num_attribs, uniforms, num_uniforms,
1455        program_service_id);
1456  }
1457
1458  DoCreateShader(
1459      GL_VERTEX_SHADER, vertex_shader_client_id, vertex_shader_service_id);
1460  DoCreateShader(
1461      GL_FRAGMENT_SHADER, fragment_shader_client_id,
1462      fragment_shader_service_id);
1463
1464  TestHelper::SetShaderStates(
1465      gl_.get(), GetShader(vertex_shader_client_id), true);
1466  TestHelper::SetShaderStates(
1467      gl_.get(), GetShader(fragment_shader_client_id), true);
1468
1469  cmds::AttachShader attach_cmd;
1470  attach_cmd.Init(program_client_id, vertex_shader_client_id);
1471  EXPECT_EQ(error::kNoError, ExecuteCmd(attach_cmd));
1472
1473  attach_cmd.Init(program_client_id, fragment_shader_client_id);
1474  EXPECT_EQ(error::kNoError, ExecuteCmd(attach_cmd));
1475
1476  cmds::LinkProgram link_cmd;
1477  link_cmd.Init(program_client_id);
1478
1479  EXPECT_EQ(error::kNoError, ExecuteCmd(link_cmd));
1480}
1481
1482void GLES2DecoderTestBase::DoEnableDisable(GLenum cap, bool enable) {
1483  SetupExpectationsForEnableDisable(cap, enable);
1484  if (enable) {
1485    cmds::Enable cmd;
1486    cmd.Init(cap);
1487    EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1488  } else {
1489    cmds::Disable cmd;
1490    cmd.Init(cap);
1491    EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1492  }
1493}
1494
1495void GLES2DecoderTestBase::DoEnableVertexAttribArray(GLint index) {
1496  EXPECT_CALL(*gl_, EnableVertexAttribArray(index))
1497      .Times(1)
1498      .RetiresOnSaturation();
1499  cmds::EnableVertexAttribArray cmd;
1500  cmd.Init(index);
1501  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1502}
1503
1504void GLES2DecoderTestBase::DoBufferData(GLenum target, GLsizei size) {
1505  EXPECT_CALL(*gl_, GetError())
1506      .WillOnce(Return(GL_NO_ERROR))
1507      .RetiresOnSaturation();
1508  EXPECT_CALL(*gl_, BufferData(target, size, _, GL_STREAM_DRAW))
1509      .Times(1)
1510      .RetiresOnSaturation();
1511  EXPECT_CALL(*gl_, GetError())
1512      .WillOnce(Return(GL_NO_ERROR))
1513      .RetiresOnSaturation();
1514  cmds::BufferData cmd;
1515  cmd.Init(target, size, 0, 0, GL_STREAM_DRAW);
1516  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1517}
1518
1519void GLES2DecoderTestBase::DoBufferSubData(
1520    GLenum target, GLint offset, GLsizei size, const void* data) {
1521  EXPECT_CALL(*gl_, BufferSubData(target, offset, size,
1522                                  shared_memory_address_))
1523      .Times(1)
1524      .RetiresOnSaturation();
1525  memcpy(shared_memory_address_, data, size);
1526  cmds::BufferSubData cmd;
1527  cmd.Init(target, offset, size, shared_memory_id_, shared_memory_offset_);
1528  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1529}
1530
1531void GLES2DecoderTestBase::SetupVertexBuffer() {
1532  DoEnableVertexAttribArray(1);
1533  DoBindBuffer(GL_ARRAY_BUFFER, client_buffer_id_, kServiceBufferId);
1534  GLfloat f = 0;
1535  DoBufferData(GL_ARRAY_BUFFER, kNumVertices * 2 * sizeof(f));
1536}
1537
1538void GLES2DecoderTestBase::SetupAllNeededVertexBuffers() {
1539  DoBindBuffer(GL_ARRAY_BUFFER, client_buffer_id_, kServiceBufferId);
1540  DoBufferData(GL_ARRAY_BUFFER, kNumVertices * 16 * sizeof(float));
1541  DoEnableVertexAttribArray(0);
1542  DoEnableVertexAttribArray(1);
1543  DoEnableVertexAttribArray(2);
1544  DoVertexAttribPointer(0, 2, GL_FLOAT, 0, 0);
1545  DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
1546  DoVertexAttribPointer(2, 2, GL_FLOAT, 0, 0);
1547}
1548
1549void GLES2DecoderTestBase::SetupIndexBuffer() {
1550  DoBindBuffer(GL_ELEMENT_ARRAY_BUFFER,
1551               client_element_buffer_id_,
1552               kServiceElementBufferId);
1553  static const GLshort indices[] = {100, 1, 2, 3, 4, 5, 6, 7, 100, 9};
1554  COMPILE_ASSERT(arraysize(indices) == kNumIndices, Indices_is_not_10);
1555  DoBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices));
1556  DoBufferSubData(GL_ELEMENT_ARRAY_BUFFER, 0, 2, indices);
1557  DoBufferSubData(GL_ELEMENT_ARRAY_BUFFER, 2, sizeof(indices) - 2, &indices[1]);
1558}
1559
1560void GLES2DecoderTestBase::SetupTexture() {
1561  DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
1562  DoTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
1563               kSharedMemoryId, kSharedMemoryOffset);
1564};
1565
1566void GLES2DecoderTestBase::DeleteVertexBuffer() {
1567  DoDeleteBuffer(client_buffer_id_, kServiceBufferId);
1568}
1569
1570void GLES2DecoderTestBase::DeleteIndexBuffer() {
1571  DoDeleteBuffer(client_element_buffer_id_, kServiceElementBufferId);
1572}
1573
1574void GLES2DecoderTestBase::AddExpectationsForSimulatedAttrib0WithError(
1575    GLsizei num_vertices, GLuint buffer_id, GLenum error) {
1576  if (gfx::GetGLImplementation() == gfx::kGLImplementationEGLGLES2) {
1577    return;
1578  }
1579
1580  EXPECT_CALL(*gl_, GetError())
1581      .WillOnce(Return(GL_NO_ERROR))
1582      .WillOnce(Return(error))
1583      .RetiresOnSaturation();
1584  EXPECT_CALL(*gl_, BindBuffer(GL_ARRAY_BUFFER, kServiceAttrib0BufferId))
1585      .Times(1)
1586      .RetiresOnSaturation();
1587  EXPECT_CALL(*gl_, BufferData(GL_ARRAY_BUFFER,
1588                               num_vertices * sizeof(GLfloat) * 4,
1589                               _, GL_DYNAMIC_DRAW))
1590      .Times(1)
1591      .RetiresOnSaturation();
1592  if (error == GL_NO_ERROR) {
1593    EXPECT_CALL(*gl_, BufferSubData(
1594        GL_ARRAY_BUFFER, 0, num_vertices * sizeof(GLfloat) * 4, _))
1595        .Times(1)
1596        .RetiresOnSaturation();
1597    EXPECT_CALL(*gl_, VertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, NULL))
1598        .Times(1)
1599        .RetiresOnSaturation();
1600    EXPECT_CALL(*gl_, BindBuffer(GL_ARRAY_BUFFER, buffer_id))
1601        .Times(1)
1602        .RetiresOnSaturation();
1603  }
1604}
1605
1606void GLES2DecoderTestBase::AddExpectationsForSimulatedAttrib0(
1607    GLsizei num_vertices, GLuint buffer_id) {
1608  AddExpectationsForSimulatedAttrib0WithError(
1609      num_vertices, buffer_id, GL_NO_ERROR);
1610}
1611
1612void GLES2DecoderTestBase::SetupMockGLBehaviors() {
1613  ON_CALL(*gl_, BindVertexArrayOES(_))
1614      .WillByDefault(Invoke(
1615          &gl_states_,
1616          &GLES2DecoderTestBase::MockGLStates::OnBindVertexArrayOES));
1617  ON_CALL(*gl_, BindBuffer(GL_ARRAY_BUFFER, _))
1618      .WillByDefault(WithArg<1>(Invoke(
1619          &gl_states_,
1620          &GLES2DecoderTestBase::MockGLStates::OnBindArrayBuffer)));
1621  ON_CALL(*gl_, VertexAttribPointer(_, _, _, _, _, NULL))
1622      .WillByDefault(InvokeWithoutArgs(
1623          &gl_states_,
1624          &GLES2DecoderTestBase::MockGLStates::OnVertexAttribNullPointer));
1625}
1626
1627GLES2DecoderWithShaderTestBase::MockCommandBufferEngine::
1628MockCommandBufferEngine() {
1629
1630  scoped_ptr<base::SharedMemory> shm(new base::SharedMemory());
1631  shm->CreateAndMapAnonymous(kSharedBufferSize);
1632  valid_buffer_ = MakeBufferFromSharedMemory(shm.Pass(), kSharedBufferSize);
1633
1634  ClearSharedMemory();
1635}
1636
1637GLES2DecoderWithShaderTestBase::MockCommandBufferEngine::
1638~MockCommandBufferEngine() {}
1639
1640scoped_refptr<gpu::Buffer>
1641GLES2DecoderWithShaderTestBase::MockCommandBufferEngine::GetSharedMemoryBuffer(
1642    int32 shm_id) {
1643  return shm_id == kSharedMemoryId ? valid_buffer_ : invalid_buffer_;
1644}
1645
1646void GLES2DecoderWithShaderTestBase::MockCommandBufferEngine::set_token(
1647    int32 token) {
1648  DCHECK(false);
1649}
1650
1651bool GLES2DecoderWithShaderTestBase::MockCommandBufferEngine::SetGetBuffer(
1652    int32 /* transfer_buffer_id */) {
1653  DCHECK(false);
1654  return false;
1655}
1656
1657bool GLES2DecoderWithShaderTestBase::MockCommandBufferEngine::SetGetOffset(
1658   int32 offset) {
1659  DCHECK(false);
1660  return false;
1661}
1662
1663int32 GLES2DecoderWithShaderTestBase::MockCommandBufferEngine::GetGetOffset() {
1664  DCHECK(false);
1665  return 0;
1666}
1667
1668void GLES2DecoderWithShaderTestBase::SetUp() {
1669  GLES2DecoderTestBase::SetUp();
1670  SetupDefaultProgram();
1671}
1672
1673// Include the auto-generated part of this file. We split this because it means
1674// we can easily edit the non-auto generated parts right here in this file
1675// instead of having to edit some template or the code generator.
1676#include "gpu/command_buffer/service/gles2_cmd_decoder_unittest_0_autogen.h"
1677
1678}  // namespace gles2
1679}  // namespace gpu
1680