1 // Copyright 2014 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.h"
6
7 #include "base/command_line.h"
8 #include "base/strings/string_number_conversions.h"
9 #include "gpu/command_buffer/common/gles2_cmd_format.h"
10 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
11 #include "gpu/command_buffer/common/id_allocator.h"
12 #include "gpu/command_buffer/service/async_pixel_transfer_delegate_mock.h"
13 #include "gpu/command_buffer/service/async_pixel_transfer_manager.h"
14 #include "gpu/command_buffer/service/async_pixel_transfer_manager_mock.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/context_state.h"
18 #include "gpu/command_buffer/service/gl_surface_mock.h"
19 #include "gpu/command_buffer/service/gles2_cmd_decoder_unittest.h"
20
21 #include "gpu/command_buffer/service/gpu_switches.h"
22 #include "gpu/command_buffer/service/image_manager.h"
23 #include "gpu/command_buffer/service/mailbox_manager.h"
24 #include "gpu/command_buffer/service/mocks.h"
25 #include "gpu/command_buffer/service/program_manager.h"
26 #include "gpu/command_buffer/service/test_helper.h"
27 #include "testing/gtest/include/gtest/gtest.h"
28 #include "ui/gl/gl_implementation.h"
29 #include "ui/gl/gl_mock.h"
30 #include "ui/gl/gl_surface_stub.h"
31
32 #if !defined(GL_DEPTH24_STENCIL8)
33 #define GL_DEPTH24_STENCIL8 0x88F0
34 #endif
35
36 using ::gfx::MockGLInterface;
37 using ::testing::_;
38 using ::testing::DoAll;
39 using ::testing::InSequence;
40 using ::testing::Invoke;
41 using ::testing::MatcherCast;
42 using ::testing::Mock;
43 using ::testing::Pointee;
44 using ::testing::Return;
45 using ::testing::SaveArg;
46 using ::testing::SetArrayArgument;
47 using ::testing::SetArgumentPointee;
48 using ::testing::SetArgPointee;
49 using ::testing::StrEq;
50 using ::testing::StrictMock;
51
52 namespace gpu {
53 namespace gles2 {
54
55 using namespace cmds;
56
57 class GLES2DecoderGeometryInstancingTest : public GLES2DecoderWithShaderTest {
58 public:
GLES2DecoderGeometryInstancingTest()59 GLES2DecoderGeometryInstancingTest() : GLES2DecoderWithShaderTest() {}
60
SetUp()61 virtual void SetUp() {
62 InitState init;
63 init.extensions = "GL_ANGLE_instanced_arrays";
64 init.gl_version = "opengl es 2.0";
65 init.has_alpha = true;
66 init.has_depth = true;
67 init.request_alpha = true;
68 init.request_depth = true;
69 init.bind_generates_resource = true;
70 InitDecoder(init);
71 SetupDefaultProgram();
72 }
73 };
74
75 INSTANTIATE_TEST_CASE_P(Service,
76 GLES2DecoderGeometryInstancingTest,
77 ::testing::Bool());
78
DirtyStateMaskTest(GLuint color_bits,bool depth_mask,GLuint front_stencil_mask,GLuint back_stencil_mask)79 void GLES2DecoderManualInitTest::DirtyStateMaskTest(GLuint color_bits,
80 bool depth_mask,
81 GLuint front_stencil_mask,
82 GLuint back_stencil_mask) {
83 ColorMask color_mask_cmd;
84 color_mask_cmd.Init((color_bits & 0x1000) != 0,
85 (color_bits & 0x0100) != 0,
86 (color_bits & 0x0010) != 0,
87 (color_bits & 0x0001) != 0);
88 EXPECT_EQ(error::kNoError, ExecuteCmd(color_mask_cmd));
89 EXPECT_EQ(GL_NO_ERROR, GetGLError());
90
91 DepthMask depth_mask_cmd;
92 depth_mask_cmd.Init(depth_mask);
93 EXPECT_EQ(error::kNoError, ExecuteCmd(depth_mask_cmd));
94 EXPECT_EQ(GL_NO_ERROR, GetGLError());
95
96 StencilMaskSeparate front_stencil_mask_cmd;
97 front_stencil_mask_cmd.Init(GL_FRONT, front_stencil_mask);
98 EXPECT_EQ(error::kNoError, ExecuteCmd(front_stencil_mask_cmd));
99 EXPECT_EQ(GL_NO_ERROR, GetGLError());
100
101 StencilMaskSeparate back_stencil_mask_cmd;
102 back_stencil_mask_cmd.Init(GL_BACK, back_stencil_mask);
103 EXPECT_EQ(error::kNoError, ExecuteCmd(back_stencil_mask_cmd));
104 EXPECT_EQ(GL_NO_ERROR, GetGLError());
105
106 SetupExpectationsForApplyingDirtyState(
107 false, // Framebuffer is RGB
108 true, // Framebuffer has depth
109 true, // Framebuffer has stencil
110 color_bits, // color bits
111 depth_mask, // depth mask
112 false, // depth enabled
113 front_stencil_mask, // front stencil mask
114 back_stencil_mask, // back stencil mask
115 false); // stencil enabled
116
117 EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices))
118 .Times(1)
119 .RetiresOnSaturation();
120 DrawArrays draw_cmd;
121 draw_cmd.Init(GL_TRIANGLES, 0, kNumVertices);
122 EXPECT_EQ(error::kNoError, ExecuteCmd(draw_cmd));
123 EXPECT_EQ(GL_NO_ERROR, GetGLError());
124 }
125
126 // Test that with an RGB backbuffer if we set the color mask to 1,1,1,1 it is
127 // set to 1,1,1,0 at Draw time but is 1,1,1,1 at query time.
TEST_P(GLES2DecoderRGBBackbufferTest,RGBBackbufferColorMask)128 TEST_P(GLES2DecoderRGBBackbufferTest, RGBBackbufferColorMask) {
129 ColorMask cmd;
130 cmd.Init(true, true, true, true);
131 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
132 EXPECT_EQ(GL_NO_ERROR, GetGLError());
133
134 SetupTexture();
135 AddExpectationsForSimulatedAttrib0(kNumVertices, 0);
136 SetupExpectationsForApplyingDirtyState(true, // Framebuffer is RGB
137 false, // Framebuffer has depth
138 false, // Framebuffer has stencil
139 0x1110, // color bits
140 false, // depth mask
141 false, // depth enabled
142 0, // front stencil mask
143 0, // back stencil mask
144 false); // stencil enabled
145
146 EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices))
147 .Times(1)
148 .RetiresOnSaturation();
149 DrawArrays draw_cmd;
150 draw_cmd.Init(GL_TRIANGLES, 0, kNumVertices);
151 EXPECT_EQ(error::kNoError, ExecuteCmd(draw_cmd));
152 EXPECT_EQ(GL_NO_ERROR, GetGLError());
153
154 EXPECT_CALL(*gl_, GetError())
155 .WillOnce(Return(GL_NO_ERROR))
156 .WillOnce(Return(GL_NO_ERROR))
157 .RetiresOnSaturation();
158 typedef GetIntegerv::Result Result;
159 Result* result = static_cast<Result*>(shared_memory_address_);
160 EXPECT_CALL(*gl_, GetIntegerv(GL_COLOR_WRITEMASK, result->GetData()))
161 .Times(0);
162 result->size = 0;
163 GetIntegerv cmd2;
164 cmd2.Init(GL_COLOR_WRITEMASK, shared_memory_id_, shared_memory_offset_);
165 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
166 EXPECT_EQ(
167 decoder_->GetGLES2Util()->GLGetNumValuesReturned(GL_COLOR_WRITEMASK),
168 result->GetNumResults());
169 EXPECT_EQ(GL_NO_ERROR, GetGLError());
170 EXPECT_EQ(1, result->GetData()[0]);
171 EXPECT_EQ(1, result->GetData()[1]);
172 EXPECT_EQ(1, result->GetData()[2]);
173 EXPECT_EQ(1, result->GetData()[3]);
174 }
175
176 // Test that with no depth if we set DepthMask true that it's set to false at
177 // draw time but querying it returns true.
TEST_P(GLES2DecoderRGBBackbufferTest,RGBBackbufferDepthMask)178 TEST_P(GLES2DecoderRGBBackbufferTest, RGBBackbufferDepthMask) {
179 EXPECT_CALL(*gl_, DepthMask(true)).Times(0).RetiresOnSaturation();
180 DepthMask cmd;
181 cmd.Init(true);
182 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
183 EXPECT_EQ(GL_NO_ERROR, GetGLError());
184
185 SetupTexture();
186 AddExpectationsForSimulatedAttrib0(kNumVertices, 0);
187 SetupExpectationsForApplyingDirtyState(true, // Framebuffer is RGB
188 false, // Framebuffer has depth
189 false, // Framebuffer has stencil
190 0x1110, // color bits
191 false, // depth mask
192 false, // depth enabled
193 0, // front stencil mask
194 0, // back stencil mask
195 false); // stencil enabled
196
197 EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices))
198 .Times(1)
199 .RetiresOnSaturation();
200 DrawArrays draw_cmd;
201 draw_cmd.Init(GL_TRIANGLES, 0, kNumVertices);
202 EXPECT_EQ(error::kNoError, ExecuteCmd(draw_cmd));
203 EXPECT_EQ(GL_NO_ERROR, GetGLError());
204
205 EXPECT_CALL(*gl_, GetError())
206 .WillOnce(Return(GL_NO_ERROR))
207 .WillOnce(Return(GL_NO_ERROR))
208 .RetiresOnSaturation();
209 typedef GetIntegerv::Result Result;
210 Result* result = static_cast<Result*>(shared_memory_address_);
211 EXPECT_CALL(*gl_, GetIntegerv(GL_DEPTH_WRITEMASK, result->GetData()))
212 .Times(0);
213 result->size = 0;
214 GetIntegerv cmd2;
215 cmd2.Init(GL_DEPTH_WRITEMASK, shared_memory_id_, shared_memory_offset_);
216 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
217 EXPECT_EQ(
218 decoder_->GetGLES2Util()->GLGetNumValuesReturned(GL_DEPTH_WRITEMASK),
219 result->GetNumResults());
220 EXPECT_EQ(GL_NO_ERROR, GetGLError());
221 EXPECT_EQ(1, result->GetData()[0]);
222 }
223
224 // Test that with no stencil if we set the stencil mask it's still set to 0 at
225 // draw time but gets our value if we query.
TEST_P(GLES2DecoderRGBBackbufferTest,RGBBackbufferStencilMask)226 TEST_P(GLES2DecoderRGBBackbufferTest, RGBBackbufferStencilMask) {
227 const GLint kMask = 123;
228 EXPECT_CALL(*gl_, StencilMask(kMask)).Times(0).RetiresOnSaturation();
229 StencilMask cmd;
230 cmd.Init(kMask);
231 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
232 EXPECT_EQ(GL_NO_ERROR, GetGLError());
233
234 SetupTexture();
235 AddExpectationsForSimulatedAttrib0(kNumVertices, 0);
236 SetupExpectationsForApplyingDirtyState(true, // Framebuffer is RGB
237 false, // Framebuffer has depth
238 false, // Framebuffer has stencil
239 0x1110, // color bits
240 false, // depth mask
241 false, // depth enabled
242 0, // front stencil mask
243 0, // back stencil mask
244 false); // stencil enabled
245
246 EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices))
247 .Times(1)
248 .RetiresOnSaturation();
249 DrawArrays draw_cmd;
250 draw_cmd.Init(GL_TRIANGLES, 0, kNumVertices);
251 EXPECT_EQ(error::kNoError, ExecuteCmd(draw_cmd));
252 EXPECT_EQ(GL_NO_ERROR, GetGLError());
253
254 EXPECT_CALL(*gl_, GetError())
255 .WillOnce(Return(GL_NO_ERROR))
256 .WillOnce(Return(GL_NO_ERROR))
257 .RetiresOnSaturation();
258 typedef GetIntegerv::Result Result;
259 Result* result = static_cast<Result*>(shared_memory_address_);
260 EXPECT_CALL(*gl_, GetIntegerv(GL_STENCIL_WRITEMASK, result->GetData()))
261 .Times(0);
262 result->size = 0;
263 GetIntegerv cmd2;
264 cmd2.Init(GL_STENCIL_WRITEMASK, shared_memory_id_, shared_memory_offset_);
265 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
266 EXPECT_EQ(
267 decoder_->GetGLES2Util()->GLGetNumValuesReturned(GL_STENCIL_WRITEMASK),
268 result->GetNumResults());
269 EXPECT_EQ(GL_NO_ERROR, GetGLError());
270 EXPECT_EQ(kMask, result->GetData()[0]);
271 }
272
273 // Test that if an FBO is bound we get the correct masks.
TEST_P(GLES2DecoderRGBBackbufferTest,RGBBackbufferColorMaskFBO)274 TEST_P(GLES2DecoderRGBBackbufferTest, RGBBackbufferColorMaskFBO) {
275 ColorMask cmd;
276 cmd.Init(true, true, true, true);
277 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
278 EXPECT_EQ(GL_NO_ERROR, GetGLError());
279
280 SetupTexture();
281 SetupVertexBuffer();
282 DoEnableVertexAttribArray(0);
283 DoVertexAttribPointer(0, 2, GL_FLOAT, 0, 0);
284 DoEnableVertexAttribArray(1);
285 DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
286 DoEnableVertexAttribArray(2);
287 DoVertexAttribPointer(2, 2, GL_FLOAT, 0, 0);
288 SetupExpectationsForApplyingDirtyState(true, // Framebuffer is RGB
289 false, // Framebuffer has depth
290 false, // Framebuffer has stencil
291 0x1110, // color bits
292 false, // depth mask
293 false, // depth enabled
294 0, // front stencil mask
295 0, // back stencil mask
296 false); // stencil enabled
297
298 EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices))
299 .Times(1)
300 .RetiresOnSaturation();
301 DrawArrays draw_cmd;
302 draw_cmd.Init(GL_TRIANGLES, 0, kNumVertices);
303 EXPECT_EQ(error::kNoError, ExecuteCmd(draw_cmd));
304 EXPECT_EQ(GL_NO_ERROR, GetGLError());
305
306 // Check that no extra calls are made on the next draw.
307 EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices))
308 .Times(1)
309 .RetiresOnSaturation();
310 EXPECT_EQ(error::kNoError, ExecuteCmd(draw_cmd));
311 EXPECT_EQ(GL_NO_ERROR, GetGLError());
312
313 // Setup Frame buffer.
314 // needs to be 1x1 or else it's not renderable.
315 const GLsizei kWidth = 1;
316 const GLsizei kHeight = 1;
317 const GLenum kFormat = GL_RGB;
318 DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
319 // Pass some data so the texture will be marked as cleared.
320 DoTexImage2D(GL_TEXTURE_2D,
321 0,
322 kFormat,
323 kWidth,
324 kHeight,
325 0,
326 kFormat,
327 GL_UNSIGNED_BYTE,
328 kSharedMemoryId,
329 kSharedMemoryOffset);
330 DoBindFramebuffer(
331 GL_FRAMEBUFFER, client_framebuffer_id_, kServiceFramebufferId);
332 DoFramebufferTexture2D(GL_FRAMEBUFFER,
333 GL_COLOR_ATTACHMENT0,
334 GL_TEXTURE_2D,
335 client_texture_id_,
336 kServiceTextureId,
337 0,
338 GL_NO_ERROR);
339 EXPECT_CALL(*gl_, CheckFramebufferStatusEXT(GL_FRAMEBUFFER))
340 .WillOnce(Return(GL_FRAMEBUFFER_COMPLETE))
341 .RetiresOnSaturation();
342
343 // This time state needs to be set.
344 SetupExpectationsForApplyingDirtyState(false, // Framebuffer is RGB
345 false, // Framebuffer has depth
346 false, // Framebuffer has stencil
347 0x1110, // color bits
348 false, // depth mask
349 false, // depth enabled
350 0, // front stencil mask
351 0, // back stencil mask
352 false); // stencil enabled
353
354 EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices))
355 .Times(1)
356 .RetiresOnSaturation();
357 EXPECT_EQ(error::kNoError, ExecuteCmd(draw_cmd));
358 EXPECT_EQ(GL_NO_ERROR, GetGLError());
359
360 // Check that no extra calls are made on the next draw.
361 EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices))
362 .Times(1)
363 .RetiresOnSaturation();
364 EXPECT_EQ(error::kNoError, ExecuteCmd(draw_cmd));
365 EXPECT_EQ(GL_NO_ERROR, GetGLError());
366
367 // Unbind
368 DoBindFramebuffer(GL_FRAMEBUFFER, 0, 0);
369
370 SetupExpectationsForApplyingDirtyState(true, // Framebuffer is RGB
371 false, // Framebuffer has depth
372 false, // Framebuffer has stencil
373 0x1110, // color bits
374 false, // depth mask
375 false, // depth enabled
376 0, // front stencil mask
377 0, // back stencil mask
378 false); // stencil enabled
379
380 EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices))
381 .Times(1)
382 .RetiresOnSaturation();
383 EXPECT_EQ(error::kNoError, ExecuteCmd(draw_cmd));
384 EXPECT_EQ(GL_NO_ERROR, GetGLError());
385 }
386
TEST_P(GLES2DecoderManualInitTest,DepthEnableWithDepth)387 TEST_P(GLES2DecoderManualInitTest, DepthEnableWithDepth) {
388 InitState init;
389 init.gl_version = "3.0";
390 init.has_depth = true;
391 init.request_depth = true;
392 init.bind_generates_resource = true;
393 InitDecoder(init);
394
395 Enable cmd;
396 cmd.Init(GL_DEPTH_TEST);
397 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
398 EXPECT_EQ(GL_NO_ERROR, GetGLError());
399
400 SetupDefaultProgram();
401 SetupTexture();
402 AddExpectationsForSimulatedAttrib0(kNumVertices, 0);
403 SetupExpectationsForApplyingDirtyState(true, // Framebuffer is RGB
404 true, // Framebuffer has depth
405 false, // Framebuffer has stencil
406 0x1110, // color bits
407 true, // depth mask
408 true, // depth enabled
409 0, // front stencil mask
410 0, // back stencil mask
411 false); // stencil enabled
412
413 EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices))
414 .Times(1)
415 .RetiresOnSaturation();
416 DrawArrays draw_cmd;
417 draw_cmd.Init(GL_TRIANGLES, 0, kNumVertices);
418 EXPECT_EQ(error::kNoError, ExecuteCmd(draw_cmd));
419 EXPECT_EQ(GL_NO_ERROR, GetGLError());
420
421 EXPECT_CALL(*gl_, GetError())
422 .WillOnce(Return(GL_NO_ERROR))
423 .WillOnce(Return(GL_NO_ERROR))
424 .RetiresOnSaturation();
425 typedef GetIntegerv::Result Result;
426 Result* result = static_cast<Result*>(shared_memory_address_);
427 EXPECT_CALL(*gl_, GetIntegerv(GL_DEPTH_TEST, _))
428 .Times(0)
429 .RetiresOnSaturation();
430 result->size = 0;
431 GetIntegerv cmd2;
432 cmd2.Init(GL_DEPTH_TEST, shared_memory_id_, shared_memory_offset_);
433 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
434 EXPECT_EQ(decoder_->GetGLES2Util()->GLGetNumValuesReturned(GL_DEPTH_TEST),
435 result->GetNumResults());
436 EXPECT_EQ(GL_NO_ERROR, GetGLError());
437 EXPECT_EQ(1, result->GetData()[0]);
438 }
439
TEST_P(GLES2DecoderManualInitTest,DepthEnableWithoutRequestedDepth)440 TEST_P(GLES2DecoderManualInitTest, DepthEnableWithoutRequestedDepth) {
441 InitState init;
442 init.gl_version = "3.0";
443 init.has_depth = true;
444 init.bind_generates_resource = true;
445 InitDecoder(init);
446
447 Enable cmd;
448 cmd.Init(GL_DEPTH_TEST);
449 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
450 EXPECT_EQ(GL_NO_ERROR, GetGLError());
451
452 SetupDefaultProgram();
453 SetupTexture();
454 AddExpectationsForSimulatedAttrib0(kNumVertices, 0);
455 SetupExpectationsForApplyingDirtyState(true, // Framebuffer is RGB
456 false, // Framebuffer has depth
457 false, // Framebuffer has stencil
458 0x1110, // color bits
459 false, // depth mask
460 false, // depth enabled
461 0, // front stencil mask
462 0, // back stencil mask
463 false); // stencil enabled
464
465 EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices))
466 .Times(1)
467 .RetiresOnSaturation();
468 DrawArrays draw_cmd;
469 draw_cmd.Init(GL_TRIANGLES, 0, kNumVertices);
470 EXPECT_EQ(error::kNoError, ExecuteCmd(draw_cmd));
471 EXPECT_EQ(GL_NO_ERROR, GetGLError());
472
473 EXPECT_CALL(*gl_, GetError())
474 .WillOnce(Return(GL_NO_ERROR))
475 .WillOnce(Return(GL_NO_ERROR))
476 .RetiresOnSaturation();
477 typedef GetIntegerv::Result Result;
478 Result* result = static_cast<Result*>(shared_memory_address_);
479 EXPECT_CALL(*gl_, GetIntegerv(GL_DEPTH_TEST, _))
480 .Times(0)
481 .RetiresOnSaturation();
482 result->size = 0;
483 GetIntegerv cmd2;
484 cmd2.Init(GL_DEPTH_TEST, shared_memory_id_, shared_memory_offset_);
485 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
486 EXPECT_EQ(decoder_->GetGLES2Util()->GLGetNumValuesReturned(GL_DEPTH_TEST),
487 result->GetNumResults());
488 EXPECT_EQ(GL_NO_ERROR, GetGLError());
489 EXPECT_EQ(1, result->GetData()[0]);
490 }
491
TEST_P(GLES2DecoderManualInitTest,StencilEnableWithStencil)492 TEST_P(GLES2DecoderManualInitTest, StencilEnableWithStencil) {
493 InitState init;
494 init.gl_version = "3.0";
495 init.has_stencil = true;
496 init.request_stencil = true;
497 init.bind_generates_resource = true;
498 InitDecoder(init);
499
500 Enable cmd;
501 cmd.Init(GL_STENCIL_TEST);
502 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
503 EXPECT_EQ(GL_NO_ERROR, GetGLError());
504
505 SetupDefaultProgram();
506 SetupTexture();
507 AddExpectationsForSimulatedAttrib0(kNumVertices, 0);
508 SetupExpectationsForApplyingDirtyState(
509 true, // Framebuffer is RGB
510 false, // Framebuffer has depth
511 true, // Framebuffer has stencil
512 0x1110, // color bits
513 false, // depth mask
514 false, // depth enabled
515 GLES2Decoder::kDefaultStencilMask, // front stencil mask
516 GLES2Decoder::kDefaultStencilMask, // back stencil mask
517 true); // stencil enabled
518
519 EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices))
520 .Times(1)
521 .RetiresOnSaturation();
522 DrawArrays draw_cmd;
523 draw_cmd.Init(GL_TRIANGLES, 0, kNumVertices);
524 EXPECT_EQ(error::kNoError, ExecuteCmd(draw_cmd));
525 EXPECT_EQ(GL_NO_ERROR, GetGLError());
526
527 EXPECT_CALL(*gl_, GetError())
528 .WillOnce(Return(GL_NO_ERROR))
529 .WillOnce(Return(GL_NO_ERROR))
530 .RetiresOnSaturation();
531 typedef GetIntegerv::Result Result;
532 Result* result = static_cast<Result*>(shared_memory_address_);
533 EXPECT_CALL(*gl_, GetIntegerv(GL_STENCIL_TEST, _))
534 .Times(0)
535 .RetiresOnSaturation();
536 result->size = 0;
537 GetIntegerv cmd2;
538 cmd2.Init(GL_STENCIL_TEST, shared_memory_id_, shared_memory_offset_);
539 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
540 EXPECT_EQ(decoder_->GetGLES2Util()->GLGetNumValuesReturned(GL_STENCIL_TEST),
541 result->GetNumResults());
542 EXPECT_EQ(GL_NO_ERROR, GetGLError());
543 EXPECT_EQ(1, result->GetData()[0]);
544 }
545
TEST_P(GLES2DecoderManualInitTest,StencilEnableWithoutRequestedStencil)546 TEST_P(GLES2DecoderManualInitTest, StencilEnableWithoutRequestedStencil) {
547 InitState init;
548 init.gl_version = "3.0";
549 init.has_stencil = true;
550 init.bind_generates_resource = true;
551 InitDecoder(init);
552
553 Enable cmd;
554 cmd.Init(GL_STENCIL_TEST);
555 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
556 EXPECT_EQ(GL_NO_ERROR, GetGLError());
557
558 SetupDefaultProgram();
559 SetupTexture();
560 AddExpectationsForSimulatedAttrib0(kNumVertices, 0);
561 SetupExpectationsForApplyingDirtyState(true, // Framebuffer is RGB
562 false, // Framebuffer has depth
563 false, // Framebuffer has stencil
564 0x1110, // color bits
565 false, // depth mask
566 false, // depth enabled
567 0, // front stencil mask
568 0, // back stencil mask
569 false); // stencil enabled
570
571 EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices))
572 .Times(1)
573 .RetiresOnSaturation();
574 DrawArrays draw_cmd;
575 draw_cmd.Init(GL_TRIANGLES, 0, kNumVertices);
576 EXPECT_EQ(error::kNoError, ExecuteCmd(draw_cmd));
577 EXPECT_EQ(GL_NO_ERROR, GetGLError());
578
579 EXPECT_CALL(*gl_, GetError())
580 .WillOnce(Return(GL_NO_ERROR))
581 .WillOnce(Return(GL_NO_ERROR))
582 .RetiresOnSaturation();
583 typedef GetIntegerv::Result Result;
584 Result* result = static_cast<Result*>(shared_memory_address_);
585 EXPECT_CALL(*gl_, GetIntegerv(GL_STENCIL_TEST, _))
586 .Times(0)
587 .RetiresOnSaturation();
588 result->size = 0;
589 GetIntegerv cmd2;
590 cmd2.Init(GL_STENCIL_TEST, shared_memory_id_, shared_memory_offset_);
591 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
592 EXPECT_EQ(decoder_->GetGLES2Util()->GLGetNumValuesReturned(GL_STENCIL_TEST),
593 result->GetNumResults());
594 EXPECT_EQ(GL_NO_ERROR, GetGLError());
595 EXPECT_EQ(1, result->GetData()[0]);
596 }
597
TEST_P(GLES2DecoderManualInitTest,CachedColorMask)598 TEST_P(GLES2DecoderManualInitTest, CachedColorMask) {
599 InitState init;
600 init.gl_version = "3.0";
601 init.has_alpha = true;
602 init.has_depth = true;
603 init.has_stencil = true;
604 init.request_alpha = true;
605 init.request_depth = true;
606 init.request_stencil = true;
607 init.bind_generates_resource = true;
608 InitDecoder(init);
609
610 SetupDefaultProgram();
611 SetupAllNeededVertexBuffers();
612 SetupTexture();
613
614 // Test all color_bits combinations twice.
615 for (int i = 0; i < 32; i++) {
616 GLuint color_bits = (i & 1 ? 0x0001 : 0x0000) | (i & 2 ? 0x0010 : 0x0000) |
617 (i & 4 ? 0x0100 : 0x0000) | (i & 8 ? 0x1000 : 0x0000);
618
619 // Toggle depth_test to force ApplyDirtyState each time.
620 DirtyStateMaskTest(color_bits, false, 0xffffffff, 0xffffffff);
621 DirtyStateMaskTest(color_bits, true, 0xffffffff, 0xffffffff);
622 DirtyStateMaskTest(color_bits, false, 0xffffffff, 0xffffffff);
623 }
624 }
625
TEST_P(GLES2DecoderManualInitTest,CachedDepthMask)626 TEST_P(GLES2DecoderManualInitTest, CachedDepthMask) {
627 InitState init;
628 init.gl_version = "3.0";
629 init.has_alpha = true;
630 init.has_depth = true;
631 init.has_stencil = true;
632 init.request_alpha = true;
633 init.request_depth = true;
634 init.request_stencil = true;
635 init.bind_generates_resource = true;
636 InitDecoder(init);
637
638 SetupDefaultProgram();
639 SetupAllNeededVertexBuffers();
640 SetupTexture();
641
642 // Test all depth_mask combinations twice.
643 for (int i = 0; i < 4; i++) {
644 bool depth_mask = (i & 1) == 1;
645
646 // Toggle color masks to force ApplyDirtyState each time.
647 DirtyStateMaskTest(0x1010, depth_mask, 0xffffffff, 0xffffffff);
648 DirtyStateMaskTest(0x0101, depth_mask, 0xffffffff, 0xffffffff);
649 DirtyStateMaskTest(0x1010, depth_mask, 0xffffffff, 0xffffffff);
650 }
651 }
652
TEST_P(GLES2DecoderManualInitTest,CachedStencilMask)653 TEST_P(GLES2DecoderManualInitTest, CachedStencilMask) {
654 InitState init;
655 init.gl_version = "3.0";
656 init.has_alpha = true;
657 init.has_depth = true;
658 init.has_stencil = true;
659 init.request_alpha = true;
660 init.request_depth = true;
661 init.request_stencil = true;
662 init.bind_generates_resource = true;
663 InitDecoder(init);
664
665 SetupDefaultProgram();
666 SetupAllNeededVertexBuffers();
667 SetupTexture();
668
669 // Test all stencil_mask combinations twice.
670 for (int i = 0; i < 4; i++) {
671 GLuint stencil_mask = (i & 1) ? 0xf0f0f0f0 : 0x0f0f0f0f;
672
673 // Toggle color masks to force ApplyDirtyState each time.
674 DirtyStateMaskTest(0x1010, true, stencil_mask, 0xffffffff);
675 DirtyStateMaskTest(0x0101, true, stencil_mask, 0xffffffff);
676 DirtyStateMaskTest(0x1010, true, stencil_mask, 0xffffffff);
677 }
678
679 for (int i = 0; i < 4; i++) {
680 GLuint stencil_mask = (i & 1) ? 0xf0f0f0f0 : 0x0f0f0f0f;
681
682 // Toggle color masks to force ApplyDirtyState each time.
683 DirtyStateMaskTest(0x1010, true, 0xffffffff, stencil_mask);
684 DirtyStateMaskTest(0x0101, true, 0xffffffff, stencil_mask);
685 DirtyStateMaskTest(0x1010, true, 0xffffffff, stencil_mask);
686 }
687 }
688
TEST_P(GLES2DecoderWithShaderTest,DrawArraysNoAttributesSucceeds)689 TEST_P(GLES2DecoderWithShaderTest, DrawArraysNoAttributesSucceeds) {
690 SetupTexture();
691 AddExpectationsForSimulatedAttrib0(kNumVertices, 0);
692 SetupExpectationsForApplyingDefaultDirtyState();
693
694 EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices))
695 .Times(1)
696 .RetiresOnSaturation();
697 DrawArrays cmd;
698 cmd.Init(GL_TRIANGLES, 0, kNumVertices);
699 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
700 EXPECT_EQ(GL_NO_ERROR, GetGLError());
701 }
702
703 // Tests when the math overflows (0x40000000 * sizeof GLfloat)
TEST_P(GLES2DecoderWithShaderTest,DrawArraysSimulatedAttrib0OverflowFails)704 TEST_P(GLES2DecoderWithShaderTest, DrawArraysSimulatedAttrib0OverflowFails) {
705 const GLsizei kLargeCount = 0x40000000;
706 SetupTexture();
707 EXPECT_CALL(*gl_, DrawArrays(_, _, _)).Times(0).RetiresOnSaturation();
708 DrawArrays cmd;
709 cmd.Init(GL_TRIANGLES, 0, kLargeCount);
710 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
711 EXPECT_EQ(GL_OUT_OF_MEMORY, GetGLError());
712 EXPECT_FALSE(GetDecoder()->WasContextLost());
713 }
714
715 // Tests when the math overflows (0x7FFFFFFF + 1 = 0x8000000 verts)
TEST_P(GLES2DecoderWithShaderTest,DrawArraysSimulatedAttrib0PosToNegFails)716 TEST_P(GLES2DecoderWithShaderTest, DrawArraysSimulatedAttrib0PosToNegFails) {
717 const GLsizei kLargeCount = 0x7FFFFFFF;
718 SetupTexture();
719 EXPECT_CALL(*gl_, DrawArrays(_, _, _)).Times(0).RetiresOnSaturation();
720 DrawArrays cmd;
721 cmd.Init(GL_TRIANGLES, 0, kLargeCount);
722 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
723 EXPECT_EQ(GL_OUT_OF_MEMORY, GetGLError());
724 EXPECT_FALSE(GetDecoder()->WasContextLost());
725 }
726
727 // Tests when the driver returns an error
TEST_P(GLES2DecoderWithShaderTest,DrawArraysSimulatedAttrib0OOMFails)728 TEST_P(GLES2DecoderWithShaderTest, DrawArraysSimulatedAttrib0OOMFails) {
729 const GLsizei kFakeLargeCount = 0x1234;
730 SetupTexture();
731 AddExpectationsForSimulatedAttrib0WithError(
732 kFakeLargeCount, 0, GL_OUT_OF_MEMORY);
733 EXPECT_CALL(*gl_, DrawArrays(_, _, _)).Times(0).RetiresOnSaturation();
734 DrawArrays cmd;
735 cmd.Init(GL_TRIANGLES, 0, kFakeLargeCount);
736 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
737 EXPECT_EQ(GL_OUT_OF_MEMORY, GetGLError());
738 EXPECT_FALSE(GetDecoder()->WasContextLost());
739 }
740
741 // Test that we lose context.
TEST_P(GLES2DecoderManualInitTest,LoseContextWhenOOM)742 TEST_P(GLES2DecoderManualInitTest, LoseContextWhenOOM) {
743 InitState init;
744 init.gl_version = "3.0";
745 init.has_alpha = true;
746 init.has_depth = true;
747 init.request_alpha = true;
748 init.request_depth = true;
749 init.bind_generates_resource = true;
750 init.lose_context_when_out_of_memory = true;
751 InitDecoder(init);
752 SetupDefaultProgram();
753
754 const GLsizei kFakeLargeCount = 0x1234;
755 SetupTexture();
756 AddExpectationsForSimulatedAttrib0WithError(
757 kFakeLargeCount, 0, GL_OUT_OF_MEMORY);
758 EXPECT_CALL(*gl_, DrawArrays(_, _, _)).Times(0).RetiresOnSaturation();
759 // Other contexts in the group should be lost also.
760 EXPECT_CALL(*mock_decoder_, LoseContext(GL_UNKNOWN_CONTEXT_RESET_ARB))
761 .Times(1)
762 .RetiresOnSaturation();
763 DrawArrays cmd;
764 cmd.Init(GL_TRIANGLES, 0, kFakeLargeCount);
765 // This context should be lost.
766 EXPECT_EQ(error::kLostContext, ExecuteCmd(cmd));
767 EXPECT_EQ(GL_OUT_OF_MEMORY, GetGLError());
768 EXPECT_TRUE(decoder_->WasContextLost());
769 }
770
TEST_P(GLES2DecoderWithShaderTest,DrawArraysBadTextureUsesBlack)771 TEST_P(GLES2DecoderWithShaderTest, DrawArraysBadTextureUsesBlack) {
772 DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
773 // This is an NPOT texture. As the default filtering requires mips
774 // this should trigger replacing with black textures before rendering.
775 DoTexImage2D(GL_TEXTURE_2D,
776 0,
777 GL_RGBA,
778 3,
779 1,
780 0,
781 GL_RGBA,
782 GL_UNSIGNED_BYTE,
783 kSharedMemoryId,
784 kSharedMemoryOffset);
785 AddExpectationsForSimulatedAttrib0(kNumVertices, 0);
786 {
787 InSequence sequence;
788 EXPECT_CALL(*gl_, ActiveTexture(GL_TEXTURE0))
789 .Times(1)
790 .RetiresOnSaturation();
791 EXPECT_CALL(
792 *gl_, BindTexture(GL_TEXTURE_2D, TestHelper::kServiceBlackTexture2dId))
793 .Times(1)
794 .RetiresOnSaturation();
795 EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices))
796 .Times(1)
797 .RetiresOnSaturation();
798 EXPECT_CALL(*gl_, ActiveTexture(GL_TEXTURE0))
799 .Times(1)
800 .RetiresOnSaturation();
801 EXPECT_CALL(*gl_, BindTexture(GL_TEXTURE_2D, kServiceTextureId))
802 .Times(1)
803 .RetiresOnSaturation();
804 EXPECT_CALL(*gl_, ActiveTexture(GL_TEXTURE0))
805 .Times(1)
806 .RetiresOnSaturation();
807 }
808 SetupExpectationsForApplyingDefaultDirtyState();
809 DrawArrays cmd;
810 cmd.Init(GL_TRIANGLES, 0, kNumVertices);
811 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
812 EXPECT_EQ(GL_NO_ERROR, GetGLError());
813 }
814
TEST_P(GLES2DecoderWithShaderTest,DrawArraysMissingAttributesFails)815 TEST_P(GLES2DecoderWithShaderTest, DrawArraysMissingAttributesFails) {
816 DoEnableVertexAttribArray(1);
817
818 EXPECT_CALL(*gl_, DrawArrays(_, _, _)).Times(0);
819 DrawArrays cmd;
820 cmd.Init(GL_TRIANGLES, 0, kNumVertices);
821 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
822 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
823 }
824
TEST_P(GLES2DecoderWithShaderTest,DrawArraysMissingAttributesZeroCountSucceeds)825 TEST_P(GLES2DecoderWithShaderTest,
826 DrawArraysMissingAttributesZeroCountSucceeds) {
827 DoEnableVertexAttribArray(1);
828
829 EXPECT_CALL(*gl_, DrawArrays(_, _, _)).Times(0);
830 DrawArrays cmd;
831 cmd.Init(GL_TRIANGLES, 0, 0);
832 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
833 EXPECT_EQ(GL_NO_ERROR, GetGLError());
834 }
835
TEST_P(GLES2DecoderWithShaderTest,DrawArraysValidAttributesSucceeds)836 TEST_P(GLES2DecoderWithShaderTest, DrawArraysValidAttributesSucceeds) {
837 SetupTexture();
838 SetupVertexBuffer();
839 DoEnableVertexAttribArray(1);
840 DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
841 AddExpectationsForSimulatedAttrib0(kNumVertices, kServiceBufferId);
842 SetupExpectationsForApplyingDefaultDirtyState();
843
844 EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices))
845 .Times(1)
846 .RetiresOnSaturation();
847 DrawArrays cmd;
848 cmd.Init(GL_TRIANGLES, 0, kNumVertices);
849 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
850 EXPECT_EQ(GL_NO_ERROR, GetGLError());
851 }
852
853 // Same as DrawArraysValidAttributesSucceeds, but with workaround
854 // |init_vertex_attributes|.
TEST_P(GLES2DecoderManualInitTest,InitVertexAttributes)855 TEST_P(GLES2DecoderManualInitTest, InitVertexAttributes) {
856 CommandLine command_line(0, NULL);
857 command_line.AppendSwitchASCII(
858 switches::kGpuDriverBugWorkarounds,
859 base::IntToString(gpu::INIT_VERTEX_ATTRIBUTES));
860 InitState init;
861 init.gl_version = "3.0";
862 init.has_alpha = true;
863 init.has_depth = true;
864 init.request_alpha = true;
865 init.request_depth = true;
866 init.bind_generates_resource = true;
867 InitDecoderWithCommandLine(init, &command_line);
868 SetupDefaultProgram();
869 SetupTexture();
870 SetupVertexBuffer();
871 DoEnableVertexAttribArray(1);
872 DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
873 AddExpectationsForSimulatedAttrib0(kNumVertices, kServiceBufferId);
874 SetupExpectationsForApplyingDefaultDirtyState();
875
876 EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices))
877 .Times(1)
878 .RetiresOnSaturation();
879 DrawArrays cmd;
880 cmd.Init(GL_TRIANGLES, 0, kNumVertices);
881 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
882 EXPECT_EQ(GL_NO_ERROR, GetGLError());
883 }
884
TEST_P(GLES2DecoderWithShaderTest,DrawArraysDeletedBufferFails)885 TEST_P(GLES2DecoderWithShaderTest, DrawArraysDeletedBufferFails) {
886 SetupVertexBuffer();
887 DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
888 DeleteVertexBuffer();
889
890 EXPECT_CALL(*gl_, DrawArrays(_, _, _)).Times(0);
891 DrawArrays cmd;
892 cmd.Init(GL_TRIANGLES, 0, kNumVertices);
893 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
894 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
895 }
896
TEST_P(GLES2DecoderWithShaderTest,DrawArraysDeletedProgramSucceeds)897 TEST_P(GLES2DecoderWithShaderTest, DrawArraysDeletedProgramSucceeds) {
898 SetupTexture();
899 AddExpectationsForSimulatedAttrib0(kNumVertices, 0);
900 SetupExpectationsForApplyingDefaultDirtyState();
901 DoDeleteProgram(client_program_id_, kServiceProgramId);
902
903 EXPECT_CALL(*gl_, DrawArrays(_, _, _)).Times(1).RetiresOnSaturation();
904 EXPECT_CALL(*gl_, DeleteProgram(kServiceProgramId)).Times(1);
905 DrawArrays cmd;
906 cmd.Init(GL_TRIANGLES, 0, kNumVertices);
907 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
908 EXPECT_EQ(GL_NO_ERROR, GetGLError());
909 }
910
TEST_P(GLES2DecoderWithShaderTest,DrawArraysWithInvalidModeFails)911 TEST_P(GLES2DecoderWithShaderTest, DrawArraysWithInvalidModeFails) {
912 SetupVertexBuffer();
913 DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
914
915 EXPECT_CALL(*gl_, DrawArrays(_, _, _)).Times(0);
916 DrawArrays cmd;
917 cmd.Init(GL_QUADS, 0, 1);
918 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
919 EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
920 cmd.Init(GL_POLYGON, 0, 1);
921 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
922 EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
923 }
924
TEST_P(GLES2DecoderWithShaderTest,DrawArraysInvalidCountFails)925 TEST_P(GLES2DecoderWithShaderTest, DrawArraysInvalidCountFails) {
926 SetupVertexBuffer();
927 DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
928
929 // Try start > 0
930 EXPECT_CALL(*gl_, DrawArrays(_, _, _)).Times(0);
931 DrawArrays cmd;
932 cmd.Init(GL_TRIANGLES, 1, kNumVertices);
933 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
934 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
935 EXPECT_EQ(GL_NO_ERROR, GetGLError());
936
937 // Try with count > size
938 cmd.Init(GL_TRIANGLES, 0, kNumVertices + 1);
939 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
940 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
941 EXPECT_EQ(GL_NO_ERROR, GetGLError());
942
943 // Try with attrib offset > 0
944 cmd.Init(GL_TRIANGLES, 0, kNumVertices);
945 DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 4);
946 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
947 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
948 EXPECT_EQ(GL_NO_ERROR, GetGLError());
949
950 // Try with size > 2 (ie, vec3 instead of vec2)
951 DoVertexAttribPointer(1, 3, GL_FLOAT, 0, 0);
952 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
953 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
954 EXPECT_EQ(GL_NO_ERROR, GetGLError());
955
956 // Try with stride > 8 (vec2 + vec2 byte)
957 DoVertexAttribPointer(1, 2, GL_FLOAT, sizeof(GLfloat) * 3, 0);
958 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
959 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
960 EXPECT_EQ(GL_NO_ERROR, GetGLError());
961 }
962
TEST_P(GLES2DecoderWithShaderTest,DrawArraysInstancedANGLEFails)963 TEST_P(GLES2DecoderWithShaderTest, DrawArraysInstancedANGLEFails) {
964 SetupTexture();
965 SetupVertexBuffer();
966 DoEnableVertexAttribArray(1);
967 DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
968
969 EXPECT_CALL(*gl_, DrawArraysInstancedANGLE(_, _, _, _))
970 .Times(0)
971 .RetiresOnSaturation();
972 DrawArraysInstancedANGLE cmd;
973 cmd.Init(GL_TRIANGLES, 0, kNumVertices, 1);
974 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
975 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
976 }
977
TEST_P(GLES2DecoderWithShaderTest,VertexAttribDivisorANGLEFails)978 TEST_P(GLES2DecoderWithShaderTest, VertexAttribDivisorANGLEFails) {
979 SetupTexture();
980 SetupVertexBuffer();
981 DoEnableVertexAttribArray(1);
982 DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
983
984 EXPECT_CALL(*gl_, VertexAttribDivisorANGLE(_, _))
985 .Times(0)
986 .RetiresOnSaturation();
987
988 VertexAttribDivisorANGLE cmd;
989 cmd.Init(0, 1);
990 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
991 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
992 }
993
TEST_P(GLES2DecoderGeometryInstancingTest,DrawArraysInstancedANGLENoAttributesFails)994 TEST_P(GLES2DecoderGeometryInstancingTest,
995 DrawArraysInstancedANGLENoAttributesFails) {
996 SetupTexture();
997
998 EXPECT_CALL(*gl_, DrawArraysInstancedANGLE(_, _, _, _))
999 .Times(0)
1000 .RetiresOnSaturation();
1001 DrawArraysInstancedANGLE cmd;
1002 cmd.Init(GL_TRIANGLES, 0, kNumVertices, 1);
1003 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1004 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
1005 }
1006
TEST_P(GLES2DecoderGeometryInstancingTest,DrawArraysInstancedANGLESimulatedAttrib0)1007 TEST_P(GLES2DecoderGeometryInstancingTest,
1008 DrawArraysInstancedANGLESimulatedAttrib0) {
1009 SetupTexture();
1010 SetupVertexBuffer();
1011 DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
1012
1013 AddExpectationsForSimulatedAttrib0(kNumVertices, kServiceBufferId);
1014 SetupExpectationsForApplyingDefaultDirtyState();
1015
1016 DoVertexAttribDivisorANGLE(0, 1);
1017 EXPECT_CALL(*gl_, DrawArraysInstancedANGLE(GL_TRIANGLES, 0, kNumVertices, 3))
1018 .Times(1)
1019 .RetiresOnSaturation();
1020 EXPECT_CALL(*gl_, VertexAttribDivisorANGLE(0, 0))
1021 .Times(1)
1022 .RetiresOnSaturation();
1023 EXPECT_CALL(*gl_, VertexAttribDivisorANGLE(0, 1))
1024 .Times(1)
1025 .RetiresOnSaturation();
1026 DrawArraysInstancedANGLE cmd;
1027 cmd.Init(GL_TRIANGLES, 0, kNumVertices, 3);
1028 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1029 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1030 }
1031
TEST_P(GLES2DecoderGeometryInstancingTest,DrawArraysInstancedANGLEMissingAttributesFails)1032 TEST_P(GLES2DecoderGeometryInstancingTest,
1033 DrawArraysInstancedANGLEMissingAttributesFails) {
1034 DoEnableVertexAttribArray(1);
1035
1036 EXPECT_CALL(*gl_, DrawArraysInstancedANGLE(_, _, _, _)).Times(0);
1037 DrawArraysInstancedANGLE cmd;
1038 cmd.Init(GL_TRIANGLES, 0, kNumVertices, 1);
1039 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1040 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
1041 }
1042
TEST_P(GLES2DecoderGeometryInstancingTest,DrawArraysInstancedANGLEMissingAttributesZeroCountSucceeds)1043 TEST_P(GLES2DecoderGeometryInstancingTest,
1044 DrawArraysInstancedANGLEMissingAttributesZeroCountSucceeds) {
1045 DoEnableVertexAttribArray(1);
1046
1047 EXPECT_CALL(*gl_, DrawArraysInstancedANGLE(_, _, _, _)).Times(0);
1048 DrawArraysInstancedANGLE cmd;
1049 cmd.Init(GL_TRIANGLES, 0, 0, 1);
1050 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1051 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1052 }
1053
TEST_P(GLES2DecoderGeometryInstancingTest,DrawArraysInstancedANGLEValidAttributesSucceeds)1054 TEST_P(GLES2DecoderGeometryInstancingTest,
1055 DrawArraysInstancedANGLEValidAttributesSucceeds) {
1056 SetupTexture();
1057 SetupVertexBuffer();
1058 DoEnableVertexAttribArray(1);
1059 DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
1060 AddExpectationsForSimulatedAttrib0(kNumVertices, kServiceBufferId);
1061 SetupExpectationsForApplyingDefaultDirtyState();
1062
1063 EXPECT_CALL(*gl_, DrawArraysInstancedANGLE(GL_TRIANGLES, 0, kNumVertices, 1))
1064 .Times(1)
1065 .RetiresOnSaturation();
1066 DrawArraysInstancedANGLE cmd;
1067 cmd.Init(GL_TRIANGLES, 0, kNumVertices, 1);
1068 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1069 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1070 }
1071
TEST_P(GLES2DecoderGeometryInstancingTest,DrawArraysInstancedANGLEWithInvalidModeFails)1072 TEST_P(GLES2DecoderGeometryInstancingTest,
1073 DrawArraysInstancedANGLEWithInvalidModeFails) {
1074 SetupVertexBuffer();
1075 DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
1076
1077 EXPECT_CALL(*gl_, DrawArraysInstancedANGLE(_, _, _, _)).Times(0);
1078 DrawArraysInstancedANGLE cmd;
1079 cmd.Init(GL_QUADS, 0, 1, 1);
1080 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1081 EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
1082 cmd.Init(GL_POLYGON, 0, 1, 1);
1083 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1084 EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
1085 }
1086
TEST_P(GLES2DecoderGeometryInstancingTest,DrawArraysInstancedANGLEInvalidPrimcountFails)1087 TEST_P(GLES2DecoderGeometryInstancingTest,
1088 DrawArraysInstancedANGLEInvalidPrimcountFails) {
1089 SetupVertexBuffer();
1090 DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
1091
1092 EXPECT_CALL(*gl_, DrawArraysInstancedANGLE(_, _, _, _)).Times(0);
1093 DrawArraysInstancedANGLE cmd;
1094 cmd.Init(GL_TRIANGLES, 0, 1, -1);
1095 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1096 EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
1097 }
1098
1099 // Per-instance data is twice as large, but number of instances is half
TEST_P(GLES2DecoderGeometryInstancingTest,DrawArraysInstancedANGLELargeInstanceSucceeds)1100 TEST_P(GLES2DecoderGeometryInstancingTest,
1101 DrawArraysInstancedANGLELargeInstanceSucceeds) {
1102 SetupTexture();
1103 SetupVertexBuffer();
1104 SetupExpectationsForApplyingDefaultDirtyState();
1105 DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
1106
1107 DoEnableVertexAttribArray(0);
1108 DoVertexAttribPointer(0, 4, GL_FLOAT, 0, 0);
1109 DoVertexAttribDivisorANGLE(0, 1);
1110 EXPECT_CALL(
1111 *gl_,
1112 DrawArraysInstancedANGLE(GL_TRIANGLES, 0, kNumVertices, kNumVertices / 2))
1113 .Times(1)
1114 .RetiresOnSaturation();
1115 DrawArraysInstancedANGLE cmd;
1116 cmd.Init(GL_TRIANGLES, 0, kNumVertices, kNumVertices / 2);
1117 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1118 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1119 }
1120
1121 // Regular drawArrays takes the divisor into account
TEST_P(GLES2DecoderGeometryInstancingTest,DrawArraysWithDivisorSucceeds)1122 TEST_P(GLES2DecoderGeometryInstancingTest,
1123 DrawArraysWithDivisorSucceeds) {
1124 SetupTexture();
1125 SetupVertexBuffer();
1126 SetupExpectationsForApplyingDefaultDirtyState();
1127 DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
1128
1129 DoEnableVertexAttribArray(0);
1130 // Access the data right at the end of the buffer.
1131 DoVertexAttribPointer(
1132 0, 2, GL_FLOAT, 0, (kNumVertices - 1) * 2 * sizeof(GLfloat));
1133 DoVertexAttribDivisorANGLE(0, 1);
1134 EXPECT_CALL(
1135 *gl_,
1136 DrawArrays(GL_TRIANGLES, 0, kNumVertices))
1137 .Times(1)
1138 .RetiresOnSaturation();
1139 DrawArrays cmd;
1140 cmd.Init(GL_TRIANGLES, 0, kNumVertices);
1141 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1142 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1143 }
1144
1145 // Per-instance data is twice as large, but divisor is twice
TEST_P(GLES2DecoderGeometryInstancingTest,DrawArraysInstancedANGLELargeDivisorSucceeds)1146 TEST_P(GLES2DecoderGeometryInstancingTest,
1147 DrawArraysInstancedANGLELargeDivisorSucceeds) {
1148 SetupTexture();
1149 SetupVertexBuffer();
1150 SetupExpectationsForApplyingDefaultDirtyState();
1151 DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
1152
1153 DoEnableVertexAttribArray(0);
1154 DoVertexAttribPointer(0, 4, GL_FLOAT, 0, 0);
1155 DoVertexAttribDivisorANGLE(0, 2);
1156 EXPECT_CALL(
1157 *gl_,
1158 DrawArraysInstancedANGLE(GL_TRIANGLES, 0, kNumVertices, kNumVertices))
1159 .Times(1)
1160 .RetiresOnSaturation();
1161 DrawArraysInstancedANGLE cmd;
1162 cmd.Init(GL_TRIANGLES, 0, kNumVertices, kNumVertices);
1163 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1164 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1165 }
1166
TEST_P(GLES2DecoderGeometryInstancingTest,DrawArraysInstancedANGLELargeFails)1167 TEST_P(GLES2DecoderGeometryInstancingTest, DrawArraysInstancedANGLELargeFails) {
1168 SetupTexture();
1169 SetupVertexBuffer();
1170 DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
1171
1172 DoEnableVertexAttribArray(0);
1173 DoVertexAttribPointer(0, 2, GL_FLOAT, 0, 0);
1174 DoVertexAttribDivisorANGLE(0, 1);
1175 EXPECT_CALL(*gl_, DrawArraysInstancedANGLE(_, _, _, _))
1176 .Times(0)
1177 .RetiresOnSaturation();
1178 DrawArraysInstancedANGLE cmd;
1179 cmd.Init(GL_TRIANGLES, 0, kNumVertices, kNumVertices + 1);
1180 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1181 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
1182 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1183
1184 EXPECT_CALL(*gl_, DrawArraysInstancedANGLE(_, _, _, _))
1185 .Times(0)
1186 .RetiresOnSaturation();
1187 cmd.Init(GL_TRIANGLES, 0, kNumVertices + 1, kNumVertices);
1188 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1189 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
1190 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1191 }
1192
1193 // Per-index data is twice as large, but number of indices is half
TEST_P(GLES2DecoderGeometryInstancingTest,DrawArraysInstancedANGLELargeIndexSucceeds)1194 TEST_P(GLES2DecoderGeometryInstancingTest,
1195 DrawArraysInstancedANGLELargeIndexSucceeds) {
1196 SetupTexture();
1197 SetupVertexBuffer();
1198 SetupExpectationsForApplyingDefaultDirtyState();
1199 DoVertexAttribPointer(1, 4, GL_FLOAT, 0, 0);
1200
1201 DoEnableVertexAttribArray(0);
1202 DoVertexAttribPointer(0, 2, GL_FLOAT, 0, 0);
1203 DoVertexAttribDivisorANGLE(0, 1);
1204 EXPECT_CALL(
1205 *gl_,
1206 DrawArraysInstancedANGLE(GL_TRIANGLES, 0, kNumVertices / 2, kNumVertices))
1207 .Times(1)
1208 .RetiresOnSaturation();
1209 DrawArraysInstancedANGLE cmd;
1210 cmd.Init(GL_TRIANGLES, 0, kNumVertices / 2, kNumVertices);
1211 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1212 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1213 }
1214
TEST_P(GLES2DecoderGeometryInstancingTest,DrawArraysInstancedANGLENoDivisor0Fails)1215 TEST_P(GLES2DecoderGeometryInstancingTest,
1216 DrawArraysInstancedANGLENoDivisor0Fails) {
1217 SetupTexture();
1218 SetupVertexBuffer();
1219 DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
1220
1221 DoEnableVertexAttribArray(0);
1222 DoVertexAttribPointer(0, 2, GL_FLOAT, 0, 0);
1223 DoVertexAttribDivisorANGLE(0, 1);
1224 DoVertexAttribDivisorANGLE(1, 1);
1225 EXPECT_CALL(*gl_, DrawArraysInstancedANGLE(_, _, _, _))
1226 .Times(0)
1227 .RetiresOnSaturation();
1228 DrawArraysInstancedANGLE cmd;
1229 cmd.Init(GL_TRIANGLES, 0, kNumVertices, 1);
1230 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1231 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
1232 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1233 }
1234
TEST_P(GLES2DecoderGeometryInstancingTest,DrawArraysNoDivisor0Fails)1235 TEST_P(GLES2DecoderGeometryInstancingTest,
1236 DrawArraysNoDivisor0Fails) {
1237 SetupTexture();
1238 SetupVertexBuffer();
1239 DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
1240
1241 DoEnableVertexAttribArray(0);
1242 DoVertexAttribPointer(0, 2, GL_FLOAT, 0, 0);
1243 DoVertexAttribDivisorANGLE(0, 1);
1244 DoVertexAttribDivisorANGLE(1, 1);
1245 EXPECT_CALL(*gl_, DrawArrays(_, _, _))
1246 .Times(0)
1247 .RetiresOnSaturation();
1248 DrawArrays cmd;
1249 cmd.Init(GL_TRIANGLES, 0, kNumVertices);
1250 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1251 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
1252 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1253 }
1254
TEST_P(GLES2DecoderWithShaderTest,DrawElementsNoAttributesSucceeds)1255 TEST_P(GLES2DecoderWithShaderTest, DrawElementsNoAttributesSucceeds) {
1256 SetupTexture();
1257 SetupIndexBuffer();
1258 AddExpectationsForSimulatedAttrib0(kMaxValidIndex + 1, 0);
1259 SetupExpectationsForApplyingDefaultDirtyState();
1260 EXPECT_CALL(*gl_,
1261 DrawElements(GL_TRIANGLES,
1262 kValidIndexRangeCount,
1263 GL_UNSIGNED_SHORT,
1264 BufferOffset(kValidIndexRangeStart * 2)))
1265 .Times(1)
1266 .RetiresOnSaturation();
1267 DrawElements cmd;
1268 cmd.Init(GL_TRIANGLES,
1269 kValidIndexRangeCount,
1270 GL_UNSIGNED_SHORT,
1271 kValidIndexRangeStart * 2);
1272 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1273 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1274 }
1275
TEST_P(GLES2DecoderWithShaderTest,DrawElementsMissingAttributesFails)1276 TEST_P(GLES2DecoderWithShaderTest, DrawElementsMissingAttributesFails) {
1277 SetupIndexBuffer();
1278 DoEnableVertexAttribArray(1);
1279
1280 EXPECT_CALL(*gl_, DrawElements(_, _, _, _)).Times(0);
1281 DrawElements cmd;
1282 cmd.Init(GL_TRIANGLES,
1283 kValidIndexRangeCount,
1284 GL_UNSIGNED_SHORT,
1285 kValidIndexRangeStart * 2);
1286 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1287 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
1288 }
1289
TEST_P(GLES2DecoderWithShaderTest,DrawElementsMissingAttributesZeroCountSucceeds)1290 TEST_P(GLES2DecoderWithShaderTest,
1291 DrawElementsMissingAttributesZeroCountSucceeds) {
1292 SetupIndexBuffer();
1293 DoEnableVertexAttribArray(1);
1294
1295 EXPECT_CALL(*gl_, DrawElements(_, _, _, _)).Times(0);
1296 DrawElements cmd;
1297 cmd.Init(GL_TRIANGLES, 0, GL_UNSIGNED_SHORT, kValidIndexRangeStart * 2);
1298 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1299 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1300 }
1301
TEST_P(GLES2DecoderWithShaderTest,DrawElementsExtraAttributesFails)1302 TEST_P(GLES2DecoderWithShaderTest, DrawElementsExtraAttributesFails) {
1303 SetupIndexBuffer();
1304 DoEnableVertexAttribArray(6);
1305
1306 EXPECT_CALL(*gl_, DrawElements(_, _, _, _)).Times(0);
1307 DrawElements cmd;
1308 cmd.Init(GL_TRIANGLES,
1309 kValidIndexRangeCount,
1310 GL_UNSIGNED_SHORT,
1311 kValidIndexRangeStart * 2);
1312 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1313 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
1314 }
1315
TEST_P(GLES2DecoderWithShaderTest,DrawElementsValidAttributesSucceeds)1316 TEST_P(GLES2DecoderWithShaderTest, DrawElementsValidAttributesSucceeds) {
1317 SetupTexture();
1318 SetupVertexBuffer();
1319 SetupIndexBuffer();
1320 DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
1321 AddExpectationsForSimulatedAttrib0(kMaxValidIndex + 1, kServiceBufferId);
1322 SetupExpectationsForApplyingDefaultDirtyState();
1323
1324 EXPECT_CALL(*gl_,
1325 DrawElements(GL_TRIANGLES,
1326 kValidIndexRangeCount,
1327 GL_UNSIGNED_SHORT,
1328 BufferOffset(kValidIndexRangeStart * 2)))
1329 .Times(1)
1330 .RetiresOnSaturation();
1331 DrawElements cmd;
1332 cmd.Init(GL_TRIANGLES,
1333 kValidIndexRangeCount,
1334 GL_UNSIGNED_SHORT,
1335 kValidIndexRangeStart * 2);
1336 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1337 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1338 }
1339
TEST_P(GLES2DecoderWithShaderTest,DrawElementsDeletedBufferFails)1340 TEST_P(GLES2DecoderWithShaderTest, DrawElementsDeletedBufferFails) {
1341 SetupVertexBuffer();
1342 SetupIndexBuffer();
1343 DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
1344 DeleteIndexBuffer();
1345
1346 EXPECT_CALL(*gl_, DrawElements(_, _, _, _)).Times(0);
1347 DrawElements cmd;
1348 cmd.Init(GL_TRIANGLES,
1349 kValidIndexRangeCount,
1350 GL_UNSIGNED_SHORT,
1351 kValidIndexRangeStart * 2);
1352 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1353 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
1354 }
1355
TEST_P(GLES2DecoderWithShaderTest,DrawElementsDeletedProgramSucceeds)1356 TEST_P(GLES2DecoderWithShaderTest, DrawElementsDeletedProgramSucceeds) {
1357 SetupTexture();
1358 SetupIndexBuffer();
1359 AddExpectationsForSimulatedAttrib0(kMaxValidIndex + 1, 0);
1360 SetupExpectationsForApplyingDefaultDirtyState();
1361 DoDeleteProgram(client_program_id_, kServiceProgramId);
1362
1363 EXPECT_CALL(*gl_, DrawElements(_, _, _, _)).Times(1);
1364 EXPECT_CALL(*gl_, DeleteProgram(kServiceProgramId)).Times(1);
1365 DrawElements cmd;
1366 cmd.Init(GL_TRIANGLES,
1367 kValidIndexRangeCount,
1368 GL_UNSIGNED_SHORT,
1369 kValidIndexRangeStart * 2);
1370 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1371 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1372 }
1373
TEST_P(GLES2DecoderWithShaderTest,DrawElementsWithInvalidModeFails)1374 TEST_P(GLES2DecoderWithShaderTest, DrawElementsWithInvalidModeFails) {
1375 SetupVertexBuffer();
1376 SetupIndexBuffer();
1377 DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
1378
1379 EXPECT_CALL(*gl_, DrawElements(_, _, _, _)).Times(0);
1380 DrawElements cmd;
1381 cmd.Init(GL_QUADS,
1382 kValidIndexRangeCount,
1383 GL_UNSIGNED_SHORT,
1384 kValidIndexRangeStart * 2);
1385 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1386 EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
1387 cmd.Init(GL_POLYGON,
1388 kValidIndexRangeCount,
1389 GL_UNSIGNED_SHORT,
1390 kValidIndexRangeStart);
1391 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1392 EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
1393 }
1394
TEST_P(GLES2DecoderWithShaderTest,DrawElementsInvalidCountFails)1395 TEST_P(GLES2DecoderWithShaderTest, DrawElementsInvalidCountFails) {
1396 SetupVertexBuffer();
1397 SetupIndexBuffer();
1398 DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
1399
1400 // Try start > 0
1401 EXPECT_CALL(*gl_, DrawElements(_, _, _, _)).Times(0);
1402 DrawElements cmd;
1403 cmd.Init(GL_TRIANGLES, kNumIndices, GL_UNSIGNED_SHORT, 2);
1404 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1405 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
1406 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1407
1408 // Try with count > size
1409 cmd.Init(GL_TRIANGLES, kNumIndices + 1, GL_UNSIGNED_SHORT, 0);
1410 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1411 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
1412 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1413 }
1414
TEST_P(GLES2DecoderWithShaderTest,DrawElementsOutOfRangeIndicesFails)1415 TEST_P(GLES2DecoderWithShaderTest, DrawElementsOutOfRangeIndicesFails) {
1416 SetupVertexBuffer();
1417 SetupIndexBuffer();
1418 DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
1419
1420 EXPECT_CALL(*gl_, DrawElements(_, _, _, _)).Times(0);
1421 DrawElements cmd;
1422 cmd.Init(GL_TRIANGLES,
1423 kInvalidIndexRangeCount,
1424 GL_UNSIGNED_SHORT,
1425 kInvalidIndexRangeStart * 2);
1426 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1427 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
1428 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1429 }
1430
TEST_P(GLES2DecoderWithShaderTest,DrawElementsOddOffsetForUint16Fails)1431 TEST_P(GLES2DecoderWithShaderTest, DrawElementsOddOffsetForUint16Fails) {
1432 SetupVertexBuffer();
1433 SetupIndexBuffer();
1434 DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
1435
1436 EXPECT_CALL(*gl_, DrawElements(_, _, _, _)).Times(0);
1437 DrawElements cmd;
1438 cmd.Init(GL_TRIANGLES, kInvalidIndexRangeCount, GL_UNSIGNED_SHORT, 1);
1439 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1440 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
1441 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1442 }
1443
TEST_P(GLES2DecoderWithShaderTest,DrawElementsInstancedANGLEFails)1444 TEST_P(GLES2DecoderWithShaderTest, DrawElementsInstancedANGLEFails) {
1445 SetupTexture();
1446 SetupVertexBuffer();
1447 SetupIndexBuffer();
1448 DoEnableVertexAttribArray(1);
1449 DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
1450
1451 EXPECT_CALL(*gl_, DrawElementsInstancedANGLE(_, _, _, _, _))
1452 .Times(0)
1453 .RetiresOnSaturation();
1454 DrawElementsInstancedANGLE cmd;
1455 cmd.Init(GL_TRIANGLES,
1456 kValidIndexRangeCount,
1457 GL_UNSIGNED_SHORT,
1458 kValidIndexRangeStart * 2,
1459 1);
1460 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1461 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
1462 }
1463
TEST_P(GLES2DecoderGeometryInstancingTest,DrawElementsInstancedANGLENoAttributesFails)1464 TEST_P(GLES2DecoderGeometryInstancingTest,
1465 DrawElementsInstancedANGLENoAttributesFails) {
1466 SetupTexture();
1467 SetupIndexBuffer();
1468
1469 EXPECT_CALL(*gl_, DrawElementsInstancedANGLE(_, _, _, _, _))
1470 .Times(0)
1471 .RetiresOnSaturation();
1472 DrawElementsInstancedANGLE cmd;
1473 cmd.Init(GL_TRIANGLES,
1474 kValidIndexRangeCount,
1475 GL_UNSIGNED_SHORT,
1476 kValidIndexRangeStart * 2,
1477 1);
1478 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1479 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
1480 }
1481
TEST_P(GLES2DecoderGeometryInstancingTest,DrawElementsInstancedANGLESimulatedAttrib0)1482 TEST_P(GLES2DecoderGeometryInstancingTest,
1483 DrawElementsInstancedANGLESimulatedAttrib0) {
1484 SetupTexture();
1485 SetupVertexBuffer();
1486 SetupIndexBuffer();
1487 DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
1488
1489 AddExpectationsForSimulatedAttrib0(kMaxValidIndex + 1, kServiceBufferId);
1490 SetupExpectationsForApplyingDefaultDirtyState();
1491
1492 DoVertexAttribDivisorANGLE(0, 1);
1493 EXPECT_CALL(
1494 *gl_,
1495 DrawElementsInstancedANGLE(GL_TRIANGLES,
1496 kValidIndexRangeCount,
1497 GL_UNSIGNED_SHORT,
1498 BufferOffset(kValidIndexRangeStart * 2),
1499 3))
1500 .Times(1)
1501 .RetiresOnSaturation();
1502 EXPECT_CALL(*gl_, VertexAttribDivisorANGLE(0, 0))
1503 .Times(1)
1504 .RetiresOnSaturation();
1505 EXPECT_CALL(*gl_, VertexAttribDivisorANGLE(0, 1))
1506 .Times(1)
1507 .RetiresOnSaturation();
1508 DrawElementsInstancedANGLE cmd;
1509 cmd.Init(GL_TRIANGLES,
1510 kValidIndexRangeCount,
1511 GL_UNSIGNED_SHORT,
1512 kValidIndexRangeStart * 2,
1513 3);
1514 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1515 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1516 }
1517
TEST_P(GLES2DecoderGeometryInstancingTest,DrawElementsInstancedANGLEMissingAttributesFails)1518 TEST_P(GLES2DecoderGeometryInstancingTest,
1519 DrawElementsInstancedANGLEMissingAttributesFails) {
1520 SetupIndexBuffer();
1521 DoEnableVertexAttribArray(1);
1522
1523 EXPECT_CALL(*gl_, DrawElementsInstancedANGLE(_, _, _, _, _)).Times(0);
1524 DrawElementsInstancedANGLE cmd;
1525 cmd.Init(GL_TRIANGLES,
1526 kValidIndexRangeCount,
1527 GL_UNSIGNED_SHORT,
1528 kValidIndexRangeStart * 2,
1529 1);
1530 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1531 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
1532 }
1533
TEST_P(GLES2DecoderGeometryInstancingTest,DrawElementsInstancedANGLEMissingAttributesZeroCountSucceeds)1534 TEST_P(GLES2DecoderGeometryInstancingTest,
1535 DrawElementsInstancedANGLEMissingAttributesZeroCountSucceeds) {
1536 SetupIndexBuffer();
1537 DoEnableVertexAttribArray(1);
1538
1539 EXPECT_CALL(*gl_, DrawElementsInstancedANGLE(_, _, _, _, _)).Times(0);
1540 DrawElementsInstancedANGLE cmd;
1541 cmd.Init(GL_TRIANGLES, 0, GL_UNSIGNED_SHORT, kValidIndexRangeStart * 2, 1);
1542 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1543 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1544 }
1545
TEST_P(GLES2DecoderGeometryInstancingTest,DrawElementsInstancedANGLEValidAttributesSucceeds)1546 TEST_P(GLES2DecoderGeometryInstancingTest,
1547 DrawElementsInstancedANGLEValidAttributesSucceeds) {
1548 SetupIndexBuffer();
1549 SetupTexture();
1550 SetupVertexBuffer();
1551 DoEnableVertexAttribArray(1);
1552 DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
1553 AddExpectationsForSimulatedAttrib0(kMaxValidIndex + 1, kServiceBufferId);
1554 SetupExpectationsForApplyingDefaultDirtyState();
1555
1556 EXPECT_CALL(
1557 *gl_,
1558 DrawElementsInstancedANGLE(GL_TRIANGLES,
1559 kValidIndexRangeCount,
1560 GL_UNSIGNED_SHORT,
1561 BufferOffset(kValidIndexRangeStart * 2),
1562 1))
1563 .Times(1)
1564 .RetiresOnSaturation();
1565 DrawElementsInstancedANGLE cmd;
1566 cmd.Init(GL_TRIANGLES,
1567 kValidIndexRangeCount,
1568 GL_UNSIGNED_SHORT,
1569 kValidIndexRangeStart * 2,
1570 1);
1571 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1572 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1573 }
1574
TEST_P(GLES2DecoderGeometryInstancingTest,DrawElementsInstancedANGLEWithInvalidModeFails)1575 TEST_P(GLES2DecoderGeometryInstancingTest,
1576 DrawElementsInstancedANGLEWithInvalidModeFails) {
1577 SetupIndexBuffer();
1578 SetupVertexBuffer();
1579 DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
1580
1581 EXPECT_CALL(*gl_, DrawElementsInstancedANGLE(_, _, _, _, _)).Times(0);
1582 DrawElementsInstancedANGLE cmd;
1583 cmd.Init(GL_QUADS,
1584 kValidIndexRangeCount,
1585 GL_UNSIGNED_SHORT,
1586 kValidIndexRangeStart * 2,
1587 1);
1588 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1589 EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
1590 cmd.Init(GL_INVALID_ENUM,
1591 kValidIndexRangeCount,
1592 GL_UNSIGNED_SHORT,
1593 kValidIndexRangeStart * 2,
1594 1);
1595 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1596 EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
1597 }
1598
1599 // Per-instance data is twice as large, but number of instances is half
TEST_P(GLES2DecoderGeometryInstancingTest,DrawElementsInstancedANGLELargeInstanceSucceeds)1600 TEST_P(GLES2DecoderGeometryInstancingTest,
1601 DrawElementsInstancedANGLELargeInstanceSucceeds) {
1602 SetupTexture();
1603 SetupIndexBuffer();
1604 SetupVertexBuffer();
1605 SetupExpectationsForApplyingDefaultDirtyState();
1606 // Add offset so we're sure we're accessing data near the end of the buffer.
1607 DoVertexAttribPointer(
1608 1,
1609 2,
1610 GL_FLOAT,
1611 0,
1612 (kNumVertices - kMaxValidIndex - 1) * 2 * sizeof(GLfloat));
1613
1614 DoEnableVertexAttribArray(0);
1615 DoVertexAttribPointer(0, 4, GL_FLOAT, 0, 0);
1616 DoVertexAttribDivisorANGLE(0, 1);
1617 EXPECT_CALL(
1618 *gl_,
1619 DrawElementsInstancedANGLE(GL_TRIANGLES,
1620 kValidIndexRangeCount,
1621 GL_UNSIGNED_SHORT,
1622 BufferOffset(kValidIndexRangeStart * 2),
1623 kNumVertices / 2))
1624 .Times(1)
1625 .RetiresOnSaturation();
1626 DrawElementsInstancedANGLE cmd;
1627 cmd.Init(GL_TRIANGLES,
1628 kValidIndexRangeCount,
1629 GL_UNSIGNED_SHORT,
1630 kValidIndexRangeStart * 2,
1631 kNumVertices / 2);
1632 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1633 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1634 }
1635
1636 // Regular drawElements takes the divisor into account
TEST_P(GLES2DecoderGeometryInstancingTest,DrawElementsWithDivisorSucceeds)1637 TEST_P(GLES2DecoderGeometryInstancingTest,
1638 DrawElementsWithDivisorSucceeds) {
1639 SetupTexture();
1640 SetupIndexBuffer();
1641 SetupVertexBuffer();
1642 SetupExpectationsForApplyingDefaultDirtyState();
1643 // Add offset so we're sure we're accessing data near the end of the buffer.
1644 DoVertexAttribPointer(
1645 1,
1646 2,
1647 GL_FLOAT,
1648 0,
1649 (kNumVertices - kMaxValidIndex - 1) * 2 * sizeof(GLfloat));
1650
1651 DoEnableVertexAttribArray(0);
1652 // Access the data right at the end of the buffer.
1653 DoVertexAttribPointer(
1654 0, 2, GL_FLOAT, 0, (kNumVertices - 1) * 2 * sizeof(GLfloat));
1655 DoVertexAttribDivisorANGLE(0, 1);
1656 EXPECT_CALL(
1657 *gl_,
1658 DrawElements(GL_TRIANGLES,
1659 kValidIndexRangeCount,
1660 GL_UNSIGNED_SHORT,
1661 BufferOffset(kValidIndexRangeStart * 2)))
1662 .Times(1)
1663 .RetiresOnSaturation();
1664 DrawElements cmd;
1665 cmd.Init(GL_TRIANGLES,
1666 kValidIndexRangeCount,
1667 GL_UNSIGNED_SHORT,
1668 kValidIndexRangeStart * 2);
1669 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1670 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1671 }
1672
1673 // Per-instance data is twice as large, but divisor is twice
TEST_P(GLES2DecoderGeometryInstancingTest,DrawElementsInstancedANGLELargeDivisorSucceeds)1674 TEST_P(GLES2DecoderGeometryInstancingTest,
1675 DrawElementsInstancedANGLELargeDivisorSucceeds) {
1676 SetupTexture();
1677 SetupIndexBuffer();
1678 SetupVertexBuffer();
1679 SetupExpectationsForApplyingDefaultDirtyState();
1680 DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
1681
1682 DoEnableVertexAttribArray(0);
1683 DoVertexAttribPointer(0, 4, GL_FLOAT, 0, 0);
1684 DoVertexAttribDivisorANGLE(0, 2);
1685 EXPECT_CALL(
1686 *gl_,
1687 DrawElementsInstancedANGLE(GL_TRIANGLES,
1688 kValidIndexRangeCount,
1689 GL_UNSIGNED_SHORT,
1690 BufferOffset(kValidIndexRangeStart * 2),
1691 kNumVertices))
1692 .Times(1)
1693 .RetiresOnSaturation();
1694 DrawElementsInstancedANGLE cmd;
1695 cmd.Init(GL_TRIANGLES,
1696 kValidIndexRangeCount,
1697 GL_UNSIGNED_SHORT,
1698 kValidIndexRangeStart * 2,
1699 kNumVertices);
1700 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1701 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1702 }
1703
TEST_P(GLES2DecoderGeometryInstancingTest,DrawElementsInstancedANGLELargeFails)1704 TEST_P(GLES2DecoderGeometryInstancingTest,
1705 DrawElementsInstancedANGLELargeFails) {
1706 SetupTexture();
1707 SetupIndexBuffer();
1708 SetupVertexBuffer();
1709 DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
1710
1711 DoEnableVertexAttribArray(0);
1712 DoVertexAttribPointer(0, 2, GL_FLOAT, 0, 0);
1713 DoVertexAttribDivisorANGLE(0, 1);
1714 EXPECT_CALL(*gl_, DrawElementsInstancedANGLE(_, _, _, _, _))
1715 .Times(0)
1716 .RetiresOnSaturation();
1717 DrawElementsInstancedANGLE cmd;
1718 cmd.Init(GL_TRIANGLES,
1719 kValidIndexRangeCount,
1720 GL_UNSIGNED_SHORT,
1721 kValidIndexRangeStart * 2,
1722 kNumVertices + 1);
1723 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1724 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
1725 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1726
1727 EXPECT_CALL(*gl_, DrawElementsInstancedANGLE(_, _, _, _, _))
1728 .Times(0)
1729 .RetiresOnSaturation();
1730 cmd.Init(GL_TRIANGLES,
1731 kInvalidIndexRangeCount,
1732 GL_UNSIGNED_SHORT,
1733 kInvalidIndexRangeStart * 2,
1734 kNumVertices);
1735 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1736 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
1737 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1738 }
1739
TEST_P(GLES2DecoderGeometryInstancingTest,DrawElementsInstancedANGLEInvalidPrimcountFails)1740 TEST_P(GLES2DecoderGeometryInstancingTest,
1741 DrawElementsInstancedANGLEInvalidPrimcountFails) {
1742 SetupTexture();
1743 SetupIndexBuffer();
1744 SetupVertexBuffer();
1745 DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
1746
1747 DoEnableVertexAttribArray(0);
1748 DoVertexAttribPointer(0, 2, GL_FLOAT, 0, 0);
1749 DoVertexAttribDivisorANGLE(0, 1);
1750 EXPECT_CALL(*gl_, DrawElementsInstancedANGLE(_, _, _, _, _))
1751 .Times(0)
1752 .RetiresOnSaturation();
1753 DrawElementsInstancedANGLE cmd;
1754 cmd.Init(GL_TRIANGLES,
1755 kValidIndexRangeCount,
1756 GL_UNSIGNED_SHORT,
1757 kValidIndexRangeStart * 2,
1758 -1);
1759 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1760 EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
1761 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1762 }
1763
1764 // Per-index data is twice as large, but values of indices are smaller
TEST_P(GLES2DecoderGeometryInstancingTest,DrawElementsInstancedANGLELargeIndexSucceeds)1765 TEST_P(GLES2DecoderGeometryInstancingTest,
1766 DrawElementsInstancedANGLELargeIndexSucceeds) {
1767 SetupTexture();
1768 SetupIndexBuffer();
1769 SetupVertexBuffer();
1770 SetupExpectationsForApplyingDefaultDirtyState();
1771 DoVertexAttribPointer(1, 4, GL_FLOAT, 0, 0);
1772
1773 DoEnableVertexAttribArray(0);
1774 DoVertexAttribPointer(0, 2, GL_FLOAT, 0, 0);
1775 DoVertexAttribDivisorANGLE(0, 1);
1776 EXPECT_CALL(
1777 *gl_,
1778 DrawElementsInstancedANGLE(GL_TRIANGLES,
1779 kValidIndexRangeCount,
1780 GL_UNSIGNED_SHORT,
1781 BufferOffset(kValidIndexRangeStart * 2),
1782 kNumVertices))
1783 .Times(1)
1784 .RetiresOnSaturation();
1785 DrawElementsInstancedANGLE cmd;
1786 cmd.Init(GL_TRIANGLES,
1787 kValidIndexRangeCount,
1788 GL_UNSIGNED_SHORT,
1789 kValidIndexRangeStart * 2,
1790 kNumVertices);
1791 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1792 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1793 }
1794
TEST_P(GLES2DecoderGeometryInstancingTest,DrawElementsInstancedANGLENoDivisor0Fails)1795 TEST_P(GLES2DecoderGeometryInstancingTest,
1796 DrawElementsInstancedANGLENoDivisor0Fails) {
1797 SetupTexture();
1798 SetupIndexBuffer();
1799 SetupVertexBuffer();
1800 DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
1801
1802 DoEnableVertexAttribArray(0);
1803 DoVertexAttribPointer(0, 2, GL_FLOAT, 0, 0);
1804 DoVertexAttribDivisorANGLE(0, 1);
1805 DoVertexAttribDivisorANGLE(1, 1);
1806 EXPECT_CALL(*gl_, DrawElementsInstancedANGLE(_, _, _, _, _))
1807 .Times(0)
1808 .RetiresOnSaturation();
1809 DrawElementsInstancedANGLE cmd;
1810 cmd.Init(GL_TRIANGLES,
1811 kValidIndexRangeCount,
1812 GL_UNSIGNED_SHORT,
1813 kValidIndexRangeStart * 2,
1814 kNumVertices);
1815 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1816 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
1817 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1818 }
1819
TEST_P(GLES2DecoderGeometryInstancingTest,DrawElementsNoDivisor0Fails)1820 TEST_P(GLES2DecoderGeometryInstancingTest,
1821 DrawElementsNoDivisor0Fails) {
1822 SetupTexture();
1823 SetupIndexBuffer();
1824 SetupVertexBuffer();
1825 DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
1826
1827 DoEnableVertexAttribArray(0);
1828 DoVertexAttribPointer(0, 2, GL_FLOAT, 0, 0);
1829 DoVertexAttribDivisorANGLE(0, 1);
1830 DoVertexAttribDivisorANGLE(1, 1);
1831 EXPECT_CALL(*gl_, DrawElements(_, _, _, _))
1832 .Times(0)
1833 .RetiresOnSaturation();
1834 DrawElements cmd;
1835 cmd.Init(GL_TRIANGLES,
1836 kValidIndexRangeCount,
1837 GL_UNSIGNED_SHORT,
1838 kValidIndexRangeStart * 2);
1839 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1840 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
1841 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1842 }
1843
TEST_P(GLES2DecoderWithShaderTest,DrawArraysClearsAfterTexImage2DNULL)1844 TEST_P(GLES2DecoderWithShaderTest, DrawArraysClearsAfterTexImage2DNULL) {
1845 SetupAllNeededVertexBuffers();
1846 DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
1847 // Create an uncleared texture with 2 levels.
1848 DoTexImage2D(
1849 GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0, 0);
1850 DoTexImage2D(
1851 GL_TEXTURE_2D, 1, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0, 0);
1852 // Expect 2 levels will be cleared.
1853 SetupClearTextureExpectations(kServiceTextureId,
1854 kServiceTextureId,
1855 GL_TEXTURE_2D,
1856 GL_TEXTURE_2D,
1857 0,
1858 GL_RGBA,
1859 GL_RGBA,
1860 GL_UNSIGNED_BYTE,
1861 2,
1862 2);
1863 SetupClearTextureExpectations(kServiceTextureId,
1864 kServiceTextureId,
1865 GL_TEXTURE_2D,
1866 GL_TEXTURE_2D,
1867 1,
1868 GL_RGBA,
1869 GL_RGBA,
1870 GL_UNSIGNED_BYTE,
1871 1,
1872 1);
1873 SetupExpectationsForApplyingDefaultDirtyState();
1874 EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices))
1875 .Times(1)
1876 .RetiresOnSaturation();
1877 DrawArrays cmd;
1878 cmd.Init(GL_TRIANGLES, 0, kNumVertices);
1879 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1880 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1881
1882 // But not again
1883 EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices))
1884 .Times(1)
1885 .RetiresOnSaturation();
1886 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1887 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1888 }
1889
TEST_P(GLES2DecoderWithShaderTest,DrawElementsClearsAfterTexImage2DNULL)1890 TEST_P(GLES2DecoderWithShaderTest, DrawElementsClearsAfterTexImage2DNULL) {
1891 SetupAllNeededVertexBuffers();
1892 SetupIndexBuffer();
1893 DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
1894 // Create an uncleared texture with 2 levels.
1895 DoTexImage2D(
1896 GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0, 0);
1897 DoTexImage2D(
1898 GL_TEXTURE_2D, 1, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0, 0);
1899 // Expect 2 levels will be cleared.
1900 SetupClearTextureExpectations(kServiceTextureId,
1901 kServiceTextureId,
1902 GL_TEXTURE_2D,
1903 GL_TEXTURE_2D,
1904 0,
1905 GL_RGBA,
1906 GL_RGBA,
1907 GL_UNSIGNED_BYTE,
1908 2,
1909 2);
1910 SetupClearTextureExpectations(kServiceTextureId,
1911 kServiceTextureId,
1912 GL_TEXTURE_2D,
1913 GL_TEXTURE_2D,
1914 1,
1915 GL_RGBA,
1916 GL_RGBA,
1917 GL_UNSIGNED_BYTE,
1918 1,
1919 1);
1920 SetupExpectationsForApplyingDefaultDirtyState();
1921
1922 EXPECT_CALL(*gl_,
1923 DrawElements(GL_TRIANGLES,
1924 kValidIndexRangeCount,
1925 GL_UNSIGNED_SHORT,
1926 BufferOffset(kValidIndexRangeStart * 2)))
1927 .Times(1)
1928 .RetiresOnSaturation();
1929 DrawElements cmd;
1930 cmd.Init(GL_TRIANGLES,
1931 kValidIndexRangeCount,
1932 GL_UNSIGNED_SHORT,
1933 kValidIndexRangeStart * 2);
1934 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1935 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1936
1937 // But not again
1938 EXPECT_CALL(*gl_,
1939 DrawElements(GL_TRIANGLES,
1940 kValidIndexRangeCount,
1941 GL_UNSIGNED_SHORT,
1942 BufferOffset(kValidIndexRangeStart * 2)))
1943 .Times(1)
1944 .RetiresOnSaturation();
1945 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1946 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1947 }
1948
TEST_P(GLES2DecoderWithShaderTest,DrawClearsAfterTexImage2DNULLInFBO)1949 TEST_P(GLES2DecoderWithShaderTest, DrawClearsAfterTexImage2DNULLInFBO) {
1950 const GLuint kFBOClientTextureId = 4100;
1951 const GLuint kFBOServiceTextureId = 4101;
1952
1953 SetupAllNeededVertexBuffers();
1954 // Register a texture id.
1955 EXPECT_CALL(*gl_, GenTextures(_, _))
1956 .WillOnce(SetArgumentPointee<1>(kFBOServiceTextureId))
1957 .RetiresOnSaturation();
1958 GenHelper<GenTexturesImmediate>(kFBOClientTextureId);
1959
1960 // Setup "render to" texture.
1961 DoBindTexture(GL_TEXTURE_2D, kFBOClientTextureId, kFBOServiceTextureId);
1962 DoTexImage2D(
1963 GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0, 0);
1964 DoBindFramebuffer(
1965 GL_FRAMEBUFFER, client_framebuffer_id_, kServiceFramebufferId);
1966 DoFramebufferTexture2D(GL_FRAMEBUFFER,
1967 GL_COLOR_ATTACHMENT0,
1968 GL_TEXTURE_2D,
1969 kFBOClientTextureId,
1970 kFBOServiceTextureId,
1971 0,
1972 GL_NO_ERROR);
1973
1974 // Setup "render from" texture.
1975 SetupTexture();
1976
1977 SetupExpectationsForFramebufferClearing(GL_FRAMEBUFFER, // target
1978 GL_COLOR_BUFFER_BIT, // clear bits
1979 0,
1980 0,
1981 0,
1982 0, // color
1983 0, // stencil
1984 1.0f, // depth
1985 false); // scissor test
1986
1987 SetupExpectationsForApplyingDirtyState(false, // Framebuffer is RGB
1988 false, // Framebuffer has depth
1989 false, // Framebuffer has stencil
1990 0x1111, // color bits
1991 false, // depth mask
1992 false, // depth enabled
1993 0, // front stencil mask
1994 0, // back stencil mask
1995 false); // stencil enabled
1996
1997 EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices))
1998 .Times(1)
1999 .RetiresOnSaturation();
2000 DrawArrays cmd;
2001 cmd.Init(GL_TRIANGLES, 0, kNumVertices);
2002 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
2003 EXPECT_EQ(GL_NO_ERROR, GetGLError());
2004
2005 // But not again.
2006 EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices))
2007 .Times(1)
2008 .RetiresOnSaturation();
2009 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
2010 EXPECT_EQ(GL_NO_ERROR, GetGLError());
2011 }
2012
TEST_P(GLES2DecoderWithShaderTest,DrawWitFBOThatCantClearDoesNotDraw)2013 TEST_P(GLES2DecoderWithShaderTest, DrawWitFBOThatCantClearDoesNotDraw) {
2014 const GLuint kFBOClientTextureId = 4100;
2015 const GLuint kFBOServiceTextureId = 4101;
2016
2017 // Register a texture id.
2018 EXPECT_CALL(*gl_, GenTextures(_, _))
2019 .WillOnce(SetArgumentPointee<1>(kFBOServiceTextureId))
2020 .RetiresOnSaturation();
2021 GenHelper<GenTexturesImmediate>(kFBOClientTextureId);
2022
2023 // Setup "render to" texture.
2024 DoBindTexture(GL_TEXTURE_2D, kFBOClientTextureId, kFBOServiceTextureId);
2025 DoTexImage2D(
2026 GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0, 0);
2027 DoBindFramebuffer(
2028 GL_FRAMEBUFFER, client_framebuffer_id_, kServiceFramebufferId);
2029 DoFramebufferTexture2D(GL_FRAMEBUFFER,
2030 GL_COLOR_ATTACHMENT0,
2031 GL_TEXTURE_2D,
2032 kFBOClientTextureId,
2033 kFBOServiceTextureId,
2034 0,
2035 GL_NO_ERROR);
2036
2037 // Setup "render from" texture.
2038 SetupTexture();
2039
2040 EXPECT_CALL(*gl_, CheckFramebufferStatusEXT(GL_FRAMEBUFFER))
2041 .WillOnce(Return(GL_FRAMEBUFFER_UNSUPPORTED))
2042 .RetiresOnSaturation();
2043 EXPECT_CALL(*gl_, DrawArrays(_, _, _)).Times(0).RetiresOnSaturation();
2044 DrawArrays cmd;
2045 cmd.Init(GL_TRIANGLES, 0, kNumVertices);
2046 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
2047 EXPECT_EQ(GL_INVALID_FRAMEBUFFER_OPERATION, GetGLError());
2048 }
2049
TEST_P(GLES2DecoderWithShaderTest,DrawClearsAfterRenderbufferStorageInFBO)2050 TEST_P(GLES2DecoderWithShaderTest, DrawClearsAfterRenderbufferStorageInFBO) {
2051 SetupTexture();
2052 DoBindRenderbuffer(
2053 GL_RENDERBUFFER, client_renderbuffer_id_, kServiceRenderbufferId);
2054 DoBindFramebuffer(
2055 GL_FRAMEBUFFER, client_framebuffer_id_, kServiceFramebufferId);
2056 DoRenderbufferStorage(
2057 GL_RENDERBUFFER, GL_RGBA4, GL_RGBA, 100, 50, GL_NO_ERROR);
2058 DoFramebufferRenderbuffer(GL_FRAMEBUFFER,
2059 GL_COLOR_ATTACHMENT0,
2060 GL_RENDERBUFFER,
2061 client_renderbuffer_id_,
2062 kServiceRenderbufferId,
2063 GL_NO_ERROR);
2064
2065 SetupExpectationsForFramebufferClearing(GL_FRAMEBUFFER, // target
2066 GL_COLOR_BUFFER_BIT, // clear bits
2067 0,
2068 0,
2069 0,
2070 0, // color
2071 0, // stencil
2072 1.0f, // depth
2073 false); // scissor test
2074
2075 AddExpectationsForSimulatedAttrib0(kNumVertices, 0);
2076 SetupExpectationsForApplyingDirtyState(false, // Framebuffer is RGB
2077 false, // Framebuffer has depth
2078 false, // Framebuffer has stencil
2079 0x1111, // color bits
2080 false, // depth mask
2081 false, // depth enabled
2082 0, // front stencil mask
2083 0, // back stencil mask
2084 false); // stencil enabled
2085
2086 EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices))
2087 .Times(1)
2088 .RetiresOnSaturation();
2089 DrawArrays cmd;
2090 cmd.Init(GL_TRIANGLES, 0, kNumVertices);
2091 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
2092 EXPECT_EQ(GL_NO_ERROR, GetGLError());
2093 }
2094
TEST_P(GLES2DecoderManualInitTest,DrawArraysClearsAfterTexImage2DNULLCubemap)2095 TEST_P(GLES2DecoderManualInitTest, DrawArraysClearsAfterTexImage2DNULLCubemap) {
2096 InitState init;
2097 init.gl_version = "opengl es 2.0";
2098 init.has_alpha = true;
2099 init.has_depth = true;
2100 init.request_alpha = true;
2101 init.request_depth = true;
2102 InitDecoder(init);
2103
2104 static const GLenum faces[] = {
2105 GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X,
2106 GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y,
2107 GL_TEXTURE_CUBE_MAP_POSITIVE_Z, GL_TEXTURE_CUBE_MAP_NEGATIVE_Z,
2108 };
2109 SetupCubemapProgram();
2110 DoBindTexture(GL_TEXTURE_CUBE_MAP, client_texture_id_, kServiceTextureId);
2111 // Fill out all the faces for 2 levels, leave 2 uncleared.
2112 for (int ii = 0; ii < 6; ++ii) {
2113 GLenum face = faces[ii];
2114 int32 shm_id =
2115 (face == GL_TEXTURE_CUBE_MAP_NEGATIVE_Y) ? 0 : kSharedMemoryId;
2116 uint32 shm_offset =
2117 (face == GL_TEXTURE_CUBE_MAP_NEGATIVE_Y) ? 0 : kSharedMemoryOffset;
2118 DoTexImage2D(face,
2119 0,
2120 GL_RGBA,
2121 2,
2122 2,
2123 0,
2124 GL_RGBA,
2125 GL_UNSIGNED_BYTE,
2126 shm_id,
2127 shm_offset);
2128 DoTexImage2D(face,
2129 1,
2130 GL_RGBA,
2131 1,
2132 1,
2133 0,
2134 GL_RGBA,
2135 GL_UNSIGNED_BYTE,
2136 shm_id,
2137 shm_offset);
2138 }
2139 // Expect 2 levels will be cleared.
2140 SetupClearTextureExpectations(kServiceTextureId,
2141 kServiceTextureId,
2142 GL_TEXTURE_CUBE_MAP,
2143 GL_TEXTURE_CUBE_MAP_NEGATIVE_Y,
2144 0,
2145 GL_RGBA,
2146 GL_RGBA,
2147 GL_UNSIGNED_BYTE,
2148 2,
2149 2);
2150 SetupClearTextureExpectations(kServiceTextureId,
2151 kServiceTextureId,
2152 GL_TEXTURE_CUBE_MAP,
2153 GL_TEXTURE_CUBE_MAP_NEGATIVE_Y,
2154 1,
2155 GL_RGBA,
2156 GL_RGBA,
2157 GL_UNSIGNED_BYTE,
2158 1,
2159 1);
2160 AddExpectationsForSimulatedAttrib0(kNumVertices, 0);
2161 SetupExpectationsForApplyingDefaultDirtyState();
2162 EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices))
2163 .Times(1)
2164 .RetiresOnSaturation();
2165 DrawArrays cmd;
2166 cmd.Init(GL_TRIANGLES, 0, kNumVertices);
2167 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
2168 }
2169
TEST_P(GLES2DecoderWithShaderTest,DrawClearsAfterRenderbuffersWithMultipleAttachments)2170 TEST_P(GLES2DecoderWithShaderTest,
2171 DrawClearsAfterRenderbuffersWithMultipleAttachments) {
2172 const GLuint kFBOClientTextureId = 4100;
2173 const GLuint kFBOServiceTextureId = 4101;
2174
2175 // Register a texture id.
2176 EXPECT_CALL(*gl_, GenTextures(_, _))
2177 .WillOnce(SetArgumentPointee<1>(kFBOServiceTextureId))
2178 .RetiresOnSaturation();
2179 GenHelper<GenTexturesImmediate>(kFBOClientTextureId);
2180
2181 // Setup "render to" texture.
2182 DoBindTexture(GL_TEXTURE_2D, kFBOClientTextureId, kFBOServiceTextureId);
2183 DoTexImage2D(
2184 GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0, 0);
2185 DoBindFramebuffer(
2186 GL_FRAMEBUFFER, client_framebuffer_id_, kServiceFramebufferId);
2187 DoFramebufferTexture2D(GL_FRAMEBUFFER,
2188 GL_COLOR_ATTACHMENT0,
2189 GL_TEXTURE_2D,
2190 kFBOClientTextureId,
2191 kFBOServiceTextureId,
2192 0,
2193 GL_NO_ERROR);
2194
2195 DoBindRenderbuffer(
2196 GL_RENDERBUFFER, client_renderbuffer_id_, kServiceRenderbufferId);
2197 DoBindFramebuffer(
2198 GL_FRAMEBUFFER, client_framebuffer_id_, kServiceFramebufferId);
2199 DoRenderbufferStorage(GL_RENDERBUFFER,
2200 GL_DEPTH_COMPONENT16,
2201 GL_DEPTH_COMPONENT,
2202 1,
2203 1,
2204 GL_NO_ERROR);
2205 DoFramebufferRenderbuffer(GL_FRAMEBUFFER,
2206 GL_DEPTH_ATTACHMENT,
2207 GL_RENDERBUFFER,
2208 client_renderbuffer_id_,
2209 kServiceRenderbufferId,
2210 GL_NO_ERROR);
2211
2212 SetupTexture();
2213 SetupExpectationsForFramebufferClearing(
2214 GL_FRAMEBUFFER, // target
2215 GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT, // clear bits
2216 0,
2217 0,
2218 0,
2219 0, // color
2220 0, // stencil
2221 1.0f, // depth
2222 false); // scissor test
2223
2224 AddExpectationsForSimulatedAttrib0(kNumVertices, 0);
2225 SetupExpectationsForApplyingDirtyState(false, // Framebuffer is RGB
2226 true, // Framebuffer has depth
2227 false, // Framebuffer has stencil
2228 0x1111, // color bits
2229 true, // depth mask
2230 false, // depth enabled
2231 0, // front stencil mask
2232 0, // back stencil mask
2233 false); // stencil enabled
2234
2235 EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices))
2236 .Times(1)
2237 .RetiresOnSaturation();
2238 DrawArrays cmd;
2239 cmd.Init(GL_TRIANGLES, 0, kNumVertices);
2240 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
2241 EXPECT_EQ(GL_NO_ERROR, GetGLError());
2242 }
2243
TEST_P(GLES2DecoderWithShaderTest,DrawingWithFBOTwiceChecksForFBOCompleteOnce)2244 TEST_P(GLES2DecoderWithShaderTest,
2245 DrawingWithFBOTwiceChecksForFBOCompleteOnce) {
2246 const GLuint kFBOClientTextureId = 4100;
2247 const GLuint kFBOServiceTextureId = 4101;
2248
2249 SetupAllNeededVertexBuffers();
2250
2251 // Register a texture id.
2252 EXPECT_CALL(*gl_, GenTextures(_, _))
2253 .WillOnce(SetArgumentPointee<1>(kFBOServiceTextureId))
2254 .RetiresOnSaturation();
2255 GenHelper<GenTexturesImmediate>(kFBOClientTextureId);
2256
2257 // Setup "render to" texture that is cleared.
2258 DoBindTexture(GL_TEXTURE_2D, kFBOClientTextureId, kFBOServiceTextureId);
2259 DoTexImage2D(GL_TEXTURE_2D,
2260 0,
2261 GL_RGBA,
2262 1,
2263 1,
2264 0,
2265 GL_RGBA,
2266 GL_UNSIGNED_BYTE,
2267 kSharedMemoryId,
2268 kSharedMemoryOffset);
2269 DoBindFramebuffer(
2270 GL_FRAMEBUFFER, client_framebuffer_id_, kServiceFramebufferId);
2271 DoFramebufferTexture2D(GL_FRAMEBUFFER,
2272 GL_COLOR_ATTACHMENT0,
2273 GL_TEXTURE_2D,
2274 kFBOClientTextureId,
2275 kFBOServiceTextureId,
2276 0,
2277 GL_NO_ERROR);
2278
2279 // Setup "render from" texture.
2280 SetupTexture();
2281
2282 // Make sure we check for framebuffer complete.
2283 EXPECT_CALL(*gl_, CheckFramebufferStatusEXT(GL_FRAMEBUFFER))
2284 .WillOnce(Return(GL_FRAMEBUFFER_COMPLETE))
2285 .RetiresOnSaturation();
2286
2287 SetupExpectationsForApplyingDirtyState(false, // Framebuffer is RGB
2288 false, // Framebuffer has depth
2289 false, // Framebuffer has stencil
2290 0x1111, // color bits
2291 false, // depth mask
2292 false, // depth enabled
2293 0, // front stencil mask
2294 0, // back stencil mask
2295 false); // stencil enabled
2296
2297 EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices))
2298 .Times(1)
2299 .RetiresOnSaturation();
2300 DrawArrays cmd;
2301 cmd.Init(GL_TRIANGLES, 0, kNumVertices);
2302 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
2303 EXPECT_EQ(GL_NO_ERROR, GetGLError());
2304
2305 // But not again.
2306 EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices))
2307 .Times(1)
2308 .RetiresOnSaturation();
2309 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
2310 EXPECT_EQ(GL_NO_ERROR, GetGLError());
2311 }
2312
TEST_P(GLES2DecoderManualInitTest,DrawClearsDepthTexture)2313 TEST_P(GLES2DecoderManualInitTest, DrawClearsDepthTexture) {
2314 InitState init;
2315 init.extensions = "GL_ANGLE_depth_texture";
2316 init.gl_version = "opengl es 2.0";
2317 init.has_alpha = true;
2318 init.has_depth = true;
2319 init.request_alpha = true;
2320 init.request_depth = true;
2321 init.bind_generates_resource = true;
2322 InitDecoder(init);
2323
2324 SetupDefaultProgram();
2325 SetupAllNeededVertexBuffers();
2326 const GLenum attachment = GL_DEPTH_ATTACHMENT;
2327 const GLenum target = GL_TEXTURE_2D;
2328 const GLint level = 0;
2329 DoBindTexture(target, client_texture_id_, kServiceTextureId);
2330
2331 // Create a depth texture.
2332 DoTexImage2D(target,
2333 level,
2334 GL_DEPTH_COMPONENT,
2335 1,
2336 1,
2337 0,
2338 GL_DEPTH_COMPONENT,
2339 GL_UNSIGNED_INT,
2340 0,
2341 0);
2342
2343 // Enable GL_SCISSOR_TEST to make sure we disable it in the clear,
2344 // then re-enable it.
2345 DoEnableDisable(GL_SCISSOR_TEST, true);
2346
2347 EXPECT_CALL(*gl_, GenFramebuffersEXT(1, _)).Times(1).RetiresOnSaturation();
2348 EXPECT_CALL(*gl_, BindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, _))
2349 .Times(1)
2350 .RetiresOnSaturation();
2351
2352 EXPECT_CALL(*gl_,
2353 FramebufferTexture2DEXT(GL_DRAW_FRAMEBUFFER_EXT,
2354 attachment,
2355 target,
2356 kServiceTextureId,
2357 level))
2358 .Times(1)
2359 .RetiresOnSaturation();
2360 EXPECT_CALL(*gl_, CheckFramebufferStatusEXT(GL_DRAW_FRAMEBUFFER_EXT))
2361 .WillOnce(Return(GL_FRAMEBUFFER_COMPLETE))
2362 .RetiresOnSaturation();
2363
2364 EXPECT_CALL(*gl_, ClearStencil(0)).Times(1).RetiresOnSaturation();
2365 SetupExpectationsForStencilMask(GLES2Decoder::kDefaultStencilMask,
2366 GLES2Decoder::kDefaultStencilMask);
2367 EXPECT_CALL(*gl_, ClearDepth(1.0f)).Times(1).RetiresOnSaturation();
2368 SetupExpectationsForDepthMask(true);
2369 SetupExpectationsForEnableDisable(GL_SCISSOR_TEST, false);
2370
2371 EXPECT_CALL(*gl_, Clear(GL_DEPTH_BUFFER_BIT)).Times(1).RetiresOnSaturation();
2372
2373 SetupExpectationsForRestoreClearState(0.0f, 0.0f, 0.0f, 0.0f, 0, 1.0f, true);
2374
2375 EXPECT_CALL(*gl_, DeleteFramebuffersEXT(1, _)).Times(1).RetiresOnSaturation();
2376 EXPECT_CALL(*gl_, BindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, 0))
2377 .Times(1)
2378 .RetiresOnSaturation();
2379
2380 SetupExpectationsForApplyingDefaultDirtyState();
2381 EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices))
2382 .Times(1)
2383 .RetiresOnSaturation();
2384 DrawArrays cmd;
2385 cmd.Init(GL_TRIANGLES, 0, kNumVertices);
2386 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
2387 EXPECT_EQ(GL_NO_ERROR, GetGLError());
2388 }
2389
2390 } // namespace gles2
2391 } // namespace gpu
2392