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