?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux: Depend on liberation-fonts package for RPMs.
[chromium-blink-merge.git] / gpu / command_buffer / service / gles2_cmd_decoder_unittest_textures.cc
blob1b30d0ba43dd00caf8d5e2e43254daaafd7e8106
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/cmd_buffer_engine.h"
13 #include "gpu/command_buffer/service/context_group.h"
14 #include "gpu/command_buffer/service/context_state.h"
15 #include "gpu/command_buffer/service/gl_surface_mock.h"
16 #include "gpu/command_buffer/service/gles2_cmd_decoder_unittest.h"
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_image_stub.h"
25 #include "ui/gl/gl_implementation.h"
26 #include "ui/gl/gl_mock.h"
27 #include "ui/gl/gl_surface_stub.h"
28
29 #if !defined(GL_DEPTH24_STENCIL8)
30 #define GL_DEPTH24_STENCIL8 0x88F0
31 #endif
32
33 using ::gfx::MockGLInterface;
34 using ::testing::_;
35 using ::testing::DoAll;
36 using ::testing::InSequence;
37 using ::testing::Invoke;
38 using ::testing::MatcherCast;
39 using ::testing::Mock;
40 using ::testing::Pointee;
41 using ::testing::Return;
42 using ::testing::SaveArg;
43 using ::testing::SetArrayArgument;
44 using ::testing::SetArgumentPointee;
45 using ::testing::SetArgPointee;
46 using ::testing::StrEq;
47 using ::testing::StrictMock;
48
49 namespace gpu {
50 namespace gles2 {
51
52 using namespace cmds;
53
54 TEST_P(GLES2DecoderTest, GenerateMipmapWrongFormatsFails) {
55 EXPECT_CALL(*gl_, GenerateMipmapEXT(_)).Times(0);
56 DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
57 DoTexImage2D(
58 GL_TEXTURE_2D, 0, GL_RGBA, 16, 17, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0, 0);
59 GenerateMipmap cmd;
60 cmd.Init(GL_TEXTURE_2D);
61 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
62 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
63 }
64
65 TEST_P(GLES2DecoderTest, GenerateMipmapHandlesOutOfMemory) {
66 DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
67 TextureManager* manager = group().texture_manager();
68 TextureRef* texture_ref = manager->GetTexture(client_texture_id_);
69 ASSERT_TRUE(texture_ref != NULL);
70 Texture* texture = texture_ref->texture();
71 GLint width = 0;
72 GLint height = 0;
73 EXPECT_FALSE(
74 texture->GetLevelSize(GL_TEXTURE_2D, 2, &width, &height, nullptr));
75 DoTexImage2D(GL_TEXTURE_2D,
76 0,
77 GL_RGBA,
78 16,
79 16,
80 0,
81 GL_RGBA,
82 GL_UNSIGNED_BYTE,
83 kSharedMemoryId,
84 kSharedMemoryOffset);
85 EXPECT_CALL(*gl_, GenerateMipmapEXT(GL_TEXTURE_2D)).Times(1);
86 EXPECT_CALL(*gl_, GetError())
87 .WillOnce(Return(GL_NO_ERROR))
88 .WillOnce(Return(GL_OUT_OF_MEMORY))
89 .RetiresOnSaturation();
90 GenerateMipmap cmd;
91 cmd.Init(GL_TEXTURE_2D);
92 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
93 EXPECT_EQ(GL_OUT_OF_MEMORY, GetGLError());
94 EXPECT_FALSE(
95 texture->GetLevelSize(GL_TEXTURE_2D, 2, &width, &height, nullptr));
96 }
97
98 TEST_P(GLES2DecoderTest, GenerateMipmapClearsUnclearedTexture) {
99 EXPECT_CALL(*gl_, GenerateMipmapEXT(_)).Times(0);
100 DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
101 DoTexImage2D(
102 GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0, 0);
103 SetupClearTextureExpectations(kServiceTextureId, kServiceTextureId,
104 GL_TEXTURE_2D, GL_TEXTURE_2D, 0, GL_RGBA,
105 GL_RGBA, GL_UNSIGNED_BYTE, 0, 0, 2, 2);
106 EXPECT_CALL(*gl_, GenerateMipmapEXT(GL_TEXTURE_2D));
107 EXPECT_CALL(*gl_, GetError())
108 .WillOnce(Return(GL_NO_ERROR))
109 .WillOnce(Return(GL_NO_ERROR))
110 .RetiresOnSaturation();
111 GenerateMipmap cmd;
112 cmd.Init(GL_TEXTURE_2D);
113 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
114 EXPECT_EQ(GL_NO_ERROR, GetGLError());
115 }
116
117 // Same as GenerateMipmapClearsUnclearedTexture, but with workaround
118 // |set_texture_filters_before_generating_mipmap|.
119 TEST_P(GLES2DecoderManualInitTest, SetTextureFiltersBeforeGenerateMipmap) {
120 base::CommandLine command_line(0, NULL);
121 command_line.AppendSwitchASCII(
122 switches::kGpuDriverBugWorkarounds,
123 base::IntToString(gpu::SET_TEXTURE_FILTER_BEFORE_GENERATING_MIPMAP));
124 InitState init;
125 init.bind_generates_resource = true;
126 InitDecoderWithCommandLine(init, &command_line);
127
128 EXPECT_CALL(*gl_, GenerateMipmapEXT(_)).Times(0);
129 DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
130 DoTexImage2D(
131 GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0, 0);
132 SetupClearTextureExpectations(kServiceTextureId, kServiceTextureId,
133 GL_TEXTURE_2D, GL_TEXTURE_2D, 0, GL_RGBA,
134 GL_RGBA, GL_UNSIGNED_BYTE, 0, 0, 2, 2);
135 EXPECT_CALL(
136 *gl_,
137 TexParameteri(
138 GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST))
139 .Times(1)
140 .RetiresOnSaturation();
141 EXPECT_CALL(*gl_, GenerateMipmapEXT(GL_TEXTURE_2D));
142 EXPECT_CALL(
143 *gl_,
144 TexParameteri(
145 GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_LINEAR))
146 .Times(1)
147 .RetiresOnSaturation();
148 EXPECT_CALL(*gl_, GetError())
149 .WillOnce(Return(GL_NO_ERROR))
150 .WillOnce(Return(GL_NO_ERROR))
151 .RetiresOnSaturation();
152 GenerateMipmap cmd;
153 cmd.Init(GL_TEXTURE_2D);
154 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
155 EXPECT_EQ(GL_NO_ERROR, GetGLError());
156 }
157
158 TEST_P(GLES2DecoderTest, ActiveTextureValidArgs) {
159 EXPECT_CALL(*gl_, ActiveTexture(GL_TEXTURE1));
160 SpecializedSetup<ActiveTexture, 0>(true);
161 ActiveTexture cmd;
162 cmd.Init(GL_TEXTURE1);
163 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
164 EXPECT_EQ(GL_NO_ERROR, GetGLError());
165 }
166
167 TEST_P(GLES2DecoderTest, ActiveTextureInvalidArgs) {
168 EXPECT_CALL(*gl_, ActiveTexture(_)).Times(0);
169 SpecializedSetup<ActiveTexture, 0>(false);
170 ActiveTexture cmd;
171 cmd.Init(GL_TEXTURE0 - 1);
172 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
173 EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
174 cmd.Init(kNumTextureUnits);
175 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
176 EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
177 }
178
179 TEST_P(GLES2DecoderTest, TexSubImage2DValidArgs) {
180 const int kWidth = 16;
181 const int kHeight = 8;
182 DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
183 DoTexImage2D(GL_TEXTURE_2D,
184 1,
185 GL_RGBA,
186 kWidth,
187 kHeight,
188 0,
189 GL_RGBA,
190 GL_UNSIGNED_BYTE,
191 kSharedMemoryId,
192 kSharedMemoryOffset);
193 EXPECT_CALL(*gl_,
194 TexSubImage2D(GL_TEXTURE_2D,
195 1,
196 1,
197 0,
198 kWidth - 1,
199 kHeight,
200 GL_RGBA,
201 GL_UNSIGNED_BYTE,
202 shared_memory_address_))
203 .Times(1)
204 .RetiresOnSaturation();
205 TexSubImage2D cmd;
206 cmd.Init(GL_TEXTURE_2D,
207 1,
208 1,
209 0,
210 kWidth - 1,
211 kHeight,
212 GL_RGBA,
213 GL_UNSIGNED_BYTE,
214 kSharedMemoryId,
215 kSharedMemoryOffset,
216 GL_FALSE);
217 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
218 EXPECT_EQ(GL_NO_ERROR, GetGLError());
219 }
220
221 TEST_P(GLES2DecoderTest, TexSubImage2DBadArgs) {
222 const int kWidth = 16;
223 const int kHeight = 8;
224 DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
225 DoTexImage2D(GL_TEXTURE_2D,
226 1,
227 GL_RGBA,
228 kWidth,
229 kHeight,
230 0,
231 GL_RGBA,
232 GL_UNSIGNED_BYTE,
233 0,
234 0);
235 TexSubImage2D cmd;
236 cmd.Init(GL_TEXTURE0,
237 1,
238 0,
239 0,
240 kWidth,
241 kHeight,
242 GL_RGBA,
243 GL_UNSIGNED_BYTE,
244 kSharedMemoryId,
245 kSharedMemoryOffset,
246 GL_FALSE);
247 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
248 EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
249 cmd.Init(GL_TEXTURE_2D,
250 1,
251 0,
252 0,
253 kWidth,
254 kHeight,
255 GL_TRUE,
256 GL_UNSIGNED_BYTE,
257 kSharedMemoryId,
258 kSharedMemoryOffset,
259 GL_FALSE);
260 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
261 EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
262 cmd.Init(GL_TEXTURE_2D,
263 1,
264 0,
265 0,
266 kWidth,
267 kHeight,
268 GL_RGBA,
269 GL_UNSIGNED_INT,
270 kSharedMemoryId,
271 kSharedMemoryOffset,
272 GL_FALSE);
273 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
274 EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
275 cmd.Init(GL_TEXTURE_2D,
276 1,
277 -1,
278 0,
279 kWidth,
280 kHeight,
281 GL_RGBA,
282 GL_UNSIGNED_BYTE,
283 kSharedMemoryId,
284 kSharedMemoryOffset,
285 GL_FALSE);
286 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
287 EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
288 cmd.Init(GL_TEXTURE_2D,
289 1,
290 1,
291 0,
292 kWidth,
293 kHeight,
294 GL_RGBA,
295 GL_UNSIGNED_BYTE,
296 kSharedMemoryId,
297 kSharedMemoryOffset,
298 GL_FALSE);
299 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
300 EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
301 cmd.Init(GL_TEXTURE_2D,
302 1,
303 0,
304 -1,
305 kWidth,
306 kHeight,
307 GL_RGBA,
308 GL_UNSIGNED_BYTE,
309 kSharedMemoryId,
310 kSharedMemoryOffset,
311 GL_FALSE);
312 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
313 EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
314 cmd.Init(GL_TEXTURE_2D,
315 1,
316 0,
317 1,
318 kWidth,
319 kHeight,
320 GL_RGBA,
321 GL_UNSIGNED_BYTE,
322 kSharedMemoryId,
323 kSharedMemoryOffset,
324 GL_FALSE);
325 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
326 EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
327 cmd.Init(GL_TEXTURE_2D,
328 1,
329 0,
330 0,
331 kWidth + 1,
332 kHeight,
333 GL_RGBA,
334 GL_UNSIGNED_BYTE,
335 kSharedMemoryId,
336 kSharedMemoryOffset,
337 GL_FALSE);
338 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
339 EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
340 cmd.Init(GL_TEXTURE_2D,
341 1,
342 0,
343 0,
344 kWidth,
345 kHeight + 1,
346 GL_RGBA,
347 GL_UNSIGNED_BYTE,
348 kSharedMemoryId,
349 kSharedMemoryOffset,
350 GL_FALSE);
351 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
352 EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
353 cmd.Init(GL_TEXTURE_2D,
354 1,
355 0,
356 0,
357 kWidth,
358 kHeight,
359 GL_RGB,
360 GL_UNSIGNED_BYTE,
361 kSharedMemoryId,
362 kSharedMemoryOffset,
363 GL_FALSE);
364 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
365 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
366 cmd.Init(GL_TEXTURE_2D,
367 1,
368 0,
369 0,
370 kWidth,
371 kHeight,
372 GL_RGBA,
373 GL_UNSIGNED_SHORT_4_4_4_4,
374 kSharedMemoryId,
375 kSharedMemoryOffset,
376 GL_FALSE);
377 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
378 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
379 cmd.Init(GL_TEXTURE_2D,
380 1,
381 0,
382 0,
383 kWidth,
384 kHeight,
385 GL_RGBA,
386 GL_UNSIGNED_BYTE,
387 kInvalidSharedMemoryId,
388 kSharedMemoryOffset,
389 GL_FALSE);
390 EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
391 cmd.Init(GL_TEXTURE_2D,
392 1,
393 0,
394 0,
395 kWidth,
396 kHeight,
397 GL_RGBA,
398 GL_UNSIGNED_BYTE,
399 kSharedMemoryId,
400 kInvalidSharedMemoryOffset,
401 GL_FALSE);
402 EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
403 }
404
405 TEST_P(GLES3DecoderTest, TexSubImage2DTypesDoNotMatchUnsizedFormat) {
406 const int kWidth = 16;
407 const int kHeight = 8;
408 DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
409 DoTexImage2D(GL_TEXTURE_2D,
410 1,
411 GL_RGBA,
412 kWidth,
413 kHeight,
414 0,
415 GL_RGBA,
416 GL_UNSIGNED_SHORT_4_4_4_4,
417 kSharedMemoryId,
418 kSharedMemoryOffset);
419 EXPECT_CALL(*gl_,
420 TexSubImage2D(GL_TEXTURE_2D,
421 1,
422 1,
423 0,
424 kWidth - 1,
425 kHeight,
426 GL_RGBA,
427 GL_UNSIGNED_BYTE,
428 shared_memory_address_))
429 .Times(1)
430 .RetiresOnSaturation();
431 TexSubImage2D cmd;
432 cmd.Init(GL_TEXTURE_2D,
433 1,
434 1,
435 0,
436 kWidth - 1,
437 kHeight,
438 GL_RGBA,
439 GL_UNSIGNED_BYTE,
440 kSharedMemoryId,
441 kSharedMemoryOffset,
442 GL_FALSE);
443 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
444 EXPECT_EQ(GL_NO_ERROR, GetGLError());
445 }
446
447 TEST_P(GLES3DecoderTest, TexSubImage2DTypesDoNotMatchSizedFormat) {
448 const int kWidth = 16;
449 const int kHeight = 8;
450 DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
451 DoTexImage2D(GL_TEXTURE_2D,
452 1,
453 GL_RGBA4,
454 kWidth,
455 kHeight,
456 0,
457 GL_RGBA,
458 GL_UNSIGNED_BYTE,
459 kSharedMemoryId,
460 kSharedMemoryOffset);
461 EXPECT_CALL(*gl_,
462 TexSubImage2D(GL_TEXTURE_2D,
463 1,
464 1,
465 0,
466 kWidth - 1,
467 kHeight,
468 GL_RGBA,
469 GL_UNSIGNED_SHORT_4_4_4_4,
470 shared_memory_address_))
471 .Times(1)
472 .RetiresOnSaturation();
473 TexSubImage2D cmd;
474 cmd.Init(GL_TEXTURE_2D,
475 1,
476 1,
477 0,
478 kWidth - 1,
479 kHeight,
480 GL_RGBA,
481 GL_UNSIGNED_SHORT_4_4_4_4,
482 kSharedMemoryId,
483 kSharedMemoryOffset,
484 GL_FALSE);
485 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
486 EXPECT_EQ(GL_NO_ERROR, GetGLError());
487 }
488
489 TEST_P(GLES2DecoderTest, CopyTexSubImage2DValidArgs) {
490 const int kWidth = 16;
491 const int kHeight = 8;
492 DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
493 DoTexImage2D(GL_TEXTURE_2D,
494 1,
495 GL_RGBA,
496 kWidth,
497 kHeight,
498 0,
499 GL_RGBA,
500 GL_UNSIGNED_BYTE,
501 kSharedMemoryId,
502 kSharedMemoryOffset);
503 EXPECT_CALL(*gl_,
504 CopyTexSubImage2D(GL_TEXTURE_2D, 1, 0, 0, 0, 0, kWidth, kHeight))
505 .Times(1)
506 .RetiresOnSaturation();
507 CopyTexSubImage2D cmd;
508 cmd.Init(GL_TEXTURE_2D, 1, 0, 0, 0, 0, kWidth, kHeight);
509 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
510 EXPECT_EQ(GL_NO_ERROR, GetGLError());
511 }
512
513 TEST_P(GLES2DecoderTest, CopyTexSubImage2DBadArgs) {
514 const int kWidth = 16;
515 const int kHeight = 8;
516 DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
517 DoTexImage2D(GL_TEXTURE_2D,
518 1,
519 GL_RGBA,
520 kWidth,
521 kHeight,
522 0,
523 GL_RGBA,
524 GL_UNSIGNED_BYTE,
525 0,
526 0);
527 CopyTexSubImage2D cmd;
528 cmd.Init(GL_TEXTURE0, 1, 0, 0, 0, 0, kWidth, kHeight);
529 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
530 EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
531 cmd.Init(GL_TEXTURE_2D, 1, -1, 0, 0, 0, kWidth, kHeight);
532 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
533 EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
534 cmd.Init(GL_TEXTURE_2D, 1, 1, 0, 0, 0, kWidth, kHeight);
535 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
536 EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
537 cmd.Init(GL_TEXTURE_2D, 1, 0, -1, 0, 0, kWidth, kHeight);
538 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
539 EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
540 cmd.Init(GL_TEXTURE_2D, 1, 0, 1, 0, 0, kWidth, kHeight);
541 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
542 EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
543 cmd.Init(GL_TEXTURE_2D, 1, 0, 0, 0, 0, kWidth + 1, kHeight);
544 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
545 EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
546 cmd.Init(GL_TEXTURE_2D, 1, 0, 0, 0, 0, kWidth, kHeight + 1);
547 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
548 EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
549 }
550
551 TEST_P(GLES2DecoderTest, TexImage2DRedefinitionSucceeds) {
552 const int kWidth = 16;
553 const int kHeight = 8;
554 DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
555 EXPECT_CALL(*gl_, GetError()).WillRepeatedly(Return(GL_NO_ERROR));
556 for (int ii = 0; ii < 2; ++ii) {
557 TexImage2D cmd;
558 if (ii == 0) {
559 EXPECT_CALL(*gl_,
560 TexImage2D(GL_TEXTURE_2D,
561 0,
562 GL_RGBA,
563 kWidth,
564 kHeight,
565 0,
566 GL_RGBA,
567 GL_UNSIGNED_BYTE,
568 _))
569 .Times(1)
570 .RetiresOnSaturation();
571 cmd.Init(GL_TEXTURE_2D,
572 0,
573 GL_RGBA,
574 kWidth,
575 kHeight,
576 GL_RGBA,
577 GL_UNSIGNED_BYTE,
578 kSharedMemoryId,
579 kSharedMemoryOffset);
580 } else {
581 cmd.Init(GL_TEXTURE_2D,
582 0,
583 GL_RGBA,
584 kWidth,
585 kHeight,
586 GL_RGBA,
587 GL_UNSIGNED_BYTE,
588 0,
589 0);
590 }
591 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
592 EXPECT_CALL(*gl_,
593 TexSubImage2D(GL_TEXTURE_2D,
594 0,
595 0,
596 0,
597 kWidth,
598 kHeight - 1,
599 GL_RGBA,
600 GL_UNSIGNED_BYTE,
601 shared_memory_address_))
602 .Times(1)
603 .RetiresOnSaturation();
604 // Consider this TexSubImage2D command part of the previous TexImage2D
605 // (last GL_TRUE argument). It will be skipped if there are bugs in the
606 // redefinition case.
607 TexSubImage2D cmd2;
608 cmd2.Init(GL_TEXTURE_2D,
609 0,
610 0,
611 0,
612 kWidth,
613 kHeight - 1,
614 GL_RGBA,
615 GL_UNSIGNED_BYTE,
616 kSharedMemoryId,
617 kSharedMemoryOffset,
618 GL_TRUE);
619 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
620 }
621 }
622
623 TEST_P(GLES2DecoderTest, TexImage2DGLError) {
624 GLenum target = GL_TEXTURE_2D;
625 GLint level = 0;
626 GLenum internal_format = GL_RGBA;
627 GLsizei width = 2;
628 GLsizei height = 4;
629 GLint border = 0;
630 GLenum format = GL_RGBA;
631 GLenum type = GL_UNSIGNED_BYTE;
632 DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
633 TextureManager* manager = group().texture_manager();
634 TextureRef* texture_ref = manager->GetTexture(client_texture_id_);
635 ASSERT_TRUE(texture_ref != NULL);
636 Texture* texture = texture_ref->texture();
637 EXPECT_FALSE(
638 texture->GetLevelSize(GL_TEXTURE_2D, level, &width, &height, nullptr));
639 EXPECT_CALL(*gl_, GetError())
640 .WillOnce(Return(GL_NO_ERROR))
641 .WillOnce(Return(GL_OUT_OF_MEMORY))
642 .RetiresOnSaturation();
643 EXPECT_CALL(*gl_,
644 TexImage2D(target,
645 level,
646 internal_format,
647 width,
648 height,
649 border,
650 format,
651 type,
652 _))
653 .Times(1)
654 .RetiresOnSaturation();
655 TexImage2D cmd;
656 cmd.Init(target,
657 level,
658 internal_format,
659 width,
660 height,
661 format,
662 type,
663 kSharedMemoryId,
664 kSharedMemoryOffset);
665 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
666 EXPECT_EQ(GL_OUT_OF_MEMORY, GetGLError());
667 EXPECT_FALSE(
668 texture->GetLevelSize(GL_TEXTURE_2D, level, &width, &height, nullptr));
669 }
670
671 TEST_P(GLES2DecoderTest, CopyTexImage2DGLError) {
672 GLenum target = GL_TEXTURE_2D;
673 GLint level = 0;
674 GLenum internal_format = GL_RGBA;
675 GLsizei width = 2;
676 GLsizei height = 4;
677 GLint border = 0;
678 DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
679 TextureManager* manager = group().texture_manager();
680 TextureRef* texture_ref = manager->GetTexture(client_texture_id_);
681 ASSERT_TRUE(texture_ref != NULL);
682 Texture* texture = texture_ref->texture();
683 EXPECT_FALSE(
684 texture->GetLevelSize(GL_TEXTURE_2D, level, &width, &height, nullptr));
685 EXPECT_CALL(*gl_, GetError())
686 .WillOnce(Return(GL_NO_ERROR))
687 .WillOnce(Return(GL_OUT_OF_MEMORY))
688 .RetiresOnSaturation();
689 EXPECT_CALL(*gl_,
690 CopyTexImage2D(
691 target, level, internal_format, 0, 0, width, height, border))
692 .Times(1)
693 .RetiresOnSaturation();
694 CopyTexImage2D cmd;
695 cmd.Init(target, level, internal_format, 0, 0, width, height);
696 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
697 EXPECT_EQ(GL_OUT_OF_MEMORY, GetGLError());
698 EXPECT_FALSE(
699 texture->GetLevelSize(GL_TEXTURE_2D, level, &width, &height, nullptr));
700 }
701
702 TEST_P(GLES3DecoderTest, CompressedTexImage3DBucket) {
703 const uint32 kBucketId = 123;
704 const uint32 kBadBucketId = 99;
705 const GLenum kTarget = GL_TEXTURE_2D_ARRAY;
706 const GLint kLevel = 0;
707 const GLenum kInternalFormat = GL_COMPRESSED_R11_EAC;
708 const GLsizei kWidth = 4;
709 const GLsizei kHeight = 4;
710 const GLsizei kDepth = 4;
711 const GLint kBorder = 0;
712 CommonDecoder::Bucket* bucket = decoder_->CreateBucket(kBucketId);
713 ASSERT_TRUE(bucket != NULL);
714 const GLsizei kImageSize = 32;
715 bucket->SetSize(kImageSize);
716
717 DoBindTexture(kTarget, client_texture_id_, kServiceTextureId);
718
719 CompressedTexImage3DBucket cmd;
720 cmd.Init(kTarget,
721 kLevel,
722 kInternalFormat,
723 kWidth,
724 kHeight,
725 kDepth,
726 kBadBucketId);
727 EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
728
729 cmd.Init(kTarget,
730 kLevel,
731 kInternalFormat,
732 kWidth,
733 kHeight,
734 kDepth,
735 kBucketId);
736 EXPECT_CALL(*gl_,
737 CompressedTexImage3D(kTarget, kLevel, kInternalFormat, kWidth,
738 kHeight, kDepth, kBorder, kImageSize, _))
739 .Times(1)
740 .RetiresOnSaturation();
741 EXPECT_CALL(*gl_, GetError())
742 .WillOnce(Return(GL_NO_ERROR))
743 .WillOnce(Return(GL_NO_ERROR))
744 .RetiresOnSaturation();
745 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
746 EXPECT_EQ(GL_NO_ERROR, GetGLError());
747 }
748
749 TEST_P(GLES2DecoderTest, CompressedTexImage3DFailsOnES2) {
750 const uint32 kBucketId = 123;
751 const GLenum kTarget = GL_TEXTURE_2D_ARRAY;
752 const GLint kLevel = 0;
753 const GLenum kInternalFormat = GL_COMPRESSED_R11_EAC;
754 const GLsizei kWidth = 4;
755 const GLsizei kHeight = 4;
756 const GLsizei kDepth = 4;
757 CommonDecoder::Bucket* bucket = decoder_->CreateBucket(kBucketId);
758 ASSERT_TRUE(bucket != NULL);
759 const GLsizei kImageSize = 32;
760 bucket->SetSize(kImageSize);
761
762 {
763 CompressedTexImage3DBucket cmd;
764 cmd.Init(kTarget,
765 kLevel,
766 kInternalFormat,
767 kWidth,
768 kHeight,
769 kDepth,
770 kBucketId);
771 EXPECT_EQ(error::kUnknownCommand, ExecuteCmd(cmd));
772 }
773
774 {
775 CompressedTexSubImage3DBucket cmd;
776 cmd.Init(kTarget,
777 kLevel,
778 0, 0, 0,
779 kWidth,
780 kHeight,
781 kDepth,
782 kInternalFormat,
783 kBucketId);
784 EXPECT_EQ(error::kUnknownCommand, ExecuteCmd(cmd));
785 }
786 }
787
788 TEST_P(GLES3DecoderTest, CompressedTexImage3DFailsWithBadImageSize) {
789 const uint32 kBucketId = 123;
790 const GLenum kTarget = GL_TEXTURE_2D_ARRAY;
791 const GLint kLevel = 0;
792 const GLenum kInternalFormat = GL_COMPRESSED_RGBA8_ETC2_EAC;
793 const GLsizei kWidth = 4;
794 const GLsizei kHeight = 8;
795 const GLsizei kDepth = 4;
796 CommonDecoder::Bucket* bucket = decoder_->CreateBucket(kBucketId);
797 ASSERT_TRUE(bucket != NULL);
798 const GLsizei kBadImageSize = 64;
799 bucket->SetSize(kBadImageSize);
800
801 DoBindTexture(kTarget, client_texture_id_, kServiceTextureId);
802
803 CompressedTexImage3DBucket cmd;
804 cmd.Init(kTarget,
805 kLevel,
806 kInternalFormat,
807 kWidth,
808 kHeight,
809 kDepth,
810 kBucketId);
811 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
812 EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
813 }
814
815 TEST_P(GLES3DecoderTest, CompressedTexSubImage3DFails) {
816 const uint32 kBucketId = 123;
817 const GLenum kTarget = GL_TEXTURE_2D_ARRAY;
818 const GLint kLevel = 0;
819 const GLenum kInternalFormat = GL_COMPRESSED_RGBA8_ETC2_EAC;
820 const GLsizei kWidth = 4;
821 const GLsizei kHeight = 8;
822 const GLsizei kDepth = 4;
823 const GLint kBorder = 0;
824 CommonDecoder::Bucket* bucket = decoder_->CreateBucket(kBucketId);
825 ASSERT_TRUE(bucket != NULL);
826 const GLsizei kImageSize = 128;
827 bucket->SetSize(kImageSize);
828
829 DoBindTexture(kTarget, client_texture_id_, kServiceTextureId);
830
831 CompressedTexImage3DBucket tex_cmd;
832 tex_cmd.Init(kTarget,
833 kLevel,
834 kInternalFormat,
835 kWidth,
836 kHeight,
837 kDepth,
838 kBucketId);
839 EXPECT_CALL(*gl_,
840 CompressedTexImage3D(kTarget, kLevel, kInternalFormat, kWidth,
841 kHeight, kDepth, kBorder, kImageSize, _))
842 .Times(1)
843 .RetiresOnSaturation();
844 EXPECT_CALL(*gl_, GetError())
845 .WillOnce(Return(GL_NO_ERROR))
846 .WillOnce(Return(GL_NO_ERROR))
847 .RetiresOnSaturation();
848 EXPECT_EQ(error::kNoError, ExecuteCmd(tex_cmd));
849 EXPECT_EQ(GL_NO_ERROR, GetGLError());
850
851 const GLint kXOffset = 0;
852 const GLint kYOffset = 0;
853 const GLint kZOffset = 0;
854 const GLint kSubWidth = 4;
855 const GLint kSubHeight = 4;
856 const GLint kSubDepth = 4;
857 const GLenum kFormat = kInternalFormat;
858 CompressedTexSubImage3DBucket cmd;
859
860 // Incorrect image size.
861 cmd.Init(kTarget,
862 kLevel,
863 kXOffset,
864 kYOffset,
865 kZOffset,
866 kSubWidth,
867 kSubHeight,
868 kSubDepth,
869 kFormat,
870 kBucketId);
871 const GLsizei kBadSubImageSize = 32;
872 const GLsizei kSubImageSize = 64;
873 bucket->SetSize(kBadSubImageSize);
874 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
875 EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
876
877 // Incorrect format.
878 const GLenum kBadFormat = GL_COMPRESSED_R11_EAC;
879 cmd.Init(kTarget,
880 kLevel,
881 kXOffset,
882 kYOffset,
883 kZOffset,
884 kSubWidth,
885 kSubHeight,
886 kSubDepth,
887 kBadFormat,
888 kBucketId);
889 bucket->SetSize(kSubImageSize);
890 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
891 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
892
893 // Negative offset.
894 cmd.Init(kTarget,
895 kLevel,
896 kXOffset,
897 -4,
898 kZOffset,
899 kSubWidth,
900 kSubHeight,
901 kSubDepth,
902 kFormat,
903 kBucketId);
904 bucket->SetSize(kSubImageSize);
905 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
906 EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
907
908 // offset + size > texture size
909 cmd.Init(kTarget,
910 kLevel,
911 kXOffset,
912 kYOffset + 8,
913 kZOffset,
914 kSubWidth,
915 kSubHeight,
916 kSubDepth,
917 kFormat,
918 kBucketId);
919 bucket->SetSize(kSubImageSize);
920 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
921 EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
922
923 // offset not a multiple of 4.
924 cmd.Init(kTarget,
925 kLevel,
926 kXOffset,
927 kYOffset + 1,
928 kZOffset,
929 kSubWidth,
930 kSubHeight,
931 kSubDepth,
932 kFormat,
933 kBucketId);
934 bucket->SetSize(kSubImageSize);
935 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
936 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
937
938 // offset + width not a multlple of 4 .
939 cmd.Init(kTarget,
940 kLevel,
941 kXOffset,
942 kYOffset,
943 kZOffset,
944 kSubWidth,
945 kSubHeight + 3,
946 kSubDepth,
947 kFormat,
948 kBucketId);
949 const GLsizei kSubImageSize2 = 128;
950 bucket->SetSize(kSubImageSize2);
951 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
952 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
953
954 // Bad bucket id.
955 const uint32 kBadBucketId = 444;
956 cmd.Init(kTarget,
957 kLevel,
958 kXOffset,
959 kYOffset,
960 kZOffset,
961 kSubWidth,
962 kSubHeight,
963 kSubDepth,
964 kFormat,
965 kBadBucketId);
966 bucket->SetSize(kSubImageSize);
967 EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
968 }
969
970 TEST_P(GLES2DecoderManualInitTest, CompressedTexImage2DBucketBadBucket) {
971 InitState init;
972 init.extensions = "GL_EXT_texture_compression_s3tc";
973 init.bind_generates_resource = true;
974 InitDecoder(init);
975
976 const uint32 kBadBucketId = 123;
977 DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
978 CompressedTexImage2DBucket cmd;
979 cmd.Init(GL_TEXTURE_2D,
980 0,
981 GL_COMPRESSED_RGBA_S3TC_DXT5_EXT,
982 4,
983 4,
984 kBadBucketId);
985 EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
986 CompressedTexSubImage2DBucket cmd2;
987 cmd2.Init(GL_TEXTURE_2D,
988 0,
989 0,
990 0,
991 4,
992 4,
993 GL_COMPRESSED_RGBA_S3TC_DXT5_EXT,
994 kBadBucketId);
995 EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
996 }
997
998 namespace {
999
1000 struct S3TCTestData {
1001 GLenum format;
1002 size_t block_size;
1003 };
1004
1005 } // anonymous namespace.
1006
1007 TEST_P(GLES2DecoderManualInitTest, CompressedTexImage2DS3TC) {
1008 InitState init;
1009 init.extensions = "GL_EXT_texture_compression_s3tc";
1010 init.bind_generates_resource = true;
1011 InitDecoder(init);
1012 const uint32 kBucketId = 123;
1013 CommonDecoder::Bucket* bucket = decoder_->CreateBucket(kBucketId);
1014 ASSERT_TRUE(bucket != NULL);
1015
1016 DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
1017
1018 static const S3TCTestData test_data[] = {
1019 {
1020 GL_COMPRESSED_RGB_S3TC_DXT1_EXT, 8,
1021 },
1022 {
1023 GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, 8,
1024 },
1025 {
1026 GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, 16,
1027 },
1028 {
1029 GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, 16,
1030 },
1031 };
1032
1033 for (size_t ii = 0; ii < arraysize(test_data); ++ii) {
1034 const S3TCTestData& test = test_data[ii];
1035 CompressedTexImage2DBucket cmd;
1036 // test small width.
1037 DoCompressedTexImage2D(
1038 GL_TEXTURE_2D, 0, test.format, 2, 4, 0, test.block_size, kBucketId);
1039 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1040
1041 // test bad width.
1042 cmd.Init(GL_TEXTURE_2D, 0, test.format, 5, 4, kBucketId);
1043 bucket->SetSize(test.block_size * 2);
1044 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1045 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
1046
1047 // test small height.
1048 DoCompressedTexImage2D(
1049 GL_TEXTURE_2D, 0, test.format, 4, 2, 0, test.block_size, kBucketId);
1050 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1051
1052 // test too bad height.
1053 cmd.Init(GL_TEXTURE_2D, 0, test.format, 4, 5, kBucketId);
1054 bucket->SetSize(test.block_size * 2);
1055 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1056 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
1057
1058 // test small for level 0.
1059 DoCompressedTexImage2D(
1060 GL_TEXTURE_2D, 0, test.format, 1, 1, 0, test.block_size, kBucketId);
1061 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1062
1063 // test small for level 0.
1064 DoCompressedTexImage2D(
1065 GL_TEXTURE_2D, 0, test.format, 2, 2, 0, test.block_size, kBucketId);
1066 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1067
1068 // test size too large.
1069 cmd.Init(GL_TEXTURE_2D, 0, test.format, 4, 4, kBucketId);
1070 bucket->SetSize(test.block_size * 2);
1071 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1072 EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
1073
1074 // test size too small.
1075 cmd.Init(GL_TEXTURE_2D, 0, test.format, 4, 4, kBucketId);
1076 bucket->SetSize(test.block_size / 2);
1077 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1078 EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
1079
1080 // test with 3 mips.
1081 DoCompressedTexImage2D(
1082 GL_TEXTURE_2D, 0, test.format, 4, 4, 0, test.block_size, kBucketId);
1083 DoCompressedTexImage2D(
1084 GL_TEXTURE_2D, 1, test.format, 2, 2, 0, test.block_size, kBucketId);
1085 DoCompressedTexImage2D(
1086 GL_TEXTURE_2D, 2, test.format, 1, 1, 0, test.block_size, kBucketId);
1087 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1088
1089 // Test a 16x16
1090 DoCompressedTexImage2D(GL_TEXTURE_2D,
1091 0,
1092 test.format,
1093 16,
1094 16,
1095 0,
1096 test.block_size * 4 * 4,
1097 kBucketId);
1098 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1099
1100 CompressedTexSubImage2DBucket sub_cmd;
1101 bucket->SetSize(test.block_size);
1102 // Test sub image bad xoffset
1103 sub_cmd.Init(GL_TEXTURE_2D, 0, 1, 0, 4, 4, test.format, kBucketId);
1104 EXPECT_EQ(error::kNoError, ExecuteCmd(sub_cmd));
1105 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
1106
1107 // Test sub image bad yoffset
1108 sub_cmd.Init(GL_TEXTURE_2D, 0, 0, 2, 4, 4, test.format, kBucketId);
1109 EXPECT_EQ(error::kNoError, ExecuteCmd(sub_cmd));
1110 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
1111
1112 // Test sub image bad width
1113 bucket->SetSize(test.block_size * 2);
1114 sub_cmd.Init(GL_TEXTURE_2D, 0, 0, 0, 5, 4, test.format, kBucketId);
1115 EXPECT_EQ(error::kNoError, ExecuteCmd(sub_cmd));
1116 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
1117
1118 // Test sub image bad height
1119 sub_cmd.Init(GL_TEXTURE_2D, 0, 0, 0, 4, 5, test.format, kBucketId);
1120 EXPECT_EQ(error::kNoError, ExecuteCmd(sub_cmd));
1121 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
1122
1123 // Test sub image bad size
1124 bucket->SetSize(test.block_size + 1);
1125 sub_cmd.Init(GL_TEXTURE_2D, 0, 0, 0, 4, 4, test.format, kBucketId);
1126 EXPECT_EQ(error::kNoError, ExecuteCmd(sub_cmd));
1127 EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
1128
1129 for (GLint yoffset = 0; yoffset <= 8; yoffset += 4) {
1130 for (GLint xoffset = 0; xoffset <= 8; xoffset += 4) {
1131 for (GLsizei height = 4; height <= 8; height += 4) {
1132 for (GLsizei width = 4; width <= 8; width += 4) {
1133 GLsizei size = test.block_size * (width / 4) * (height / 4);
1134 bucket->SetSize(size);
1135 EXPECT_CALL(*gl_,
1136 CompressedTexSubImage2D(GL_TEXTURE_2D,
1137 0,
1138 xoffset,
1139 yoffset,
1140 width,
1141 height,
1142 test.format,
1143 size,
1144 _))
1145 .Times(1)
1146 .RetiresOnSaturation();
1147 sub_cmd.Init(GL_TEXTURE_2D,
1148 0,
1149 xoffset,
1150 yoffset,
1151 width,
1152 height,
1153 test.format,
1154 kBucketId);
1155 EXPECT_EQ(error::kNoError, ExecuteCmd(sub_cmd));
1156 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1157 }
1158 }
1159 }
1160 }
1161 }
1162 }
1163
1164 TEST_P(GLES2DecoderManualInitTest, CompressedTexImage2DETC1) {
1165 InitState init;
1166 init.extensions = "GL_OES_compressed_ETC1_RGB8_texture";
1167 init.gl_version = "opengl es 2.0";
1168 init.bind_generates_resource = true;
1169 InitDecoder(init);
1170 const uint32 kBucketId = 123;
1171 CommonDecoder::Bucket* bucket = decoder_->CreateBucket(kBucketId);
1172 ASSERT_TRUE(bucket != NULL);
1173
1174 DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
1175
1176 const GLenum kFormat = GL_ETC1_RGB8_OES;
1177 const size_t kBlockSize = 8;
1178
1179 CompressedTexImage2DBucket cmd;
1180 // test small width.
1181 DoCompressedTexImage2D(GL_TEXTURE_2D, 0, kFormat, 4, 8, 0, 16, kBucketId);
1182 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1183
1184 // test small height.
1185 DoCompressedTexImage2D(GL_TEXTURE_2D, 0, kFormat, 8, 4, 0, 16, kBucketId);
1186 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1187
1188 // test size too large.
1189 cmd.Init(GL_TEXTURE_2D, 0, kFormat, 4, 4, kBucketId);
1190 bucket->SetSize(kBlockSize * 2);
1191 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1192 EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
1193
1194 // test size too small.
1195 cmd.Init(GL_TEXTURE_2D, 0, kFormat, 4, 4, kBucketId);
1196 bucket->SetSize(kBlockSize / 2);
1197 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1198 EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
1199
1200 // Test a 16x16
1201 DoCompressedTexImage2D(
1202 GL_TEXTURE_2D, 0, kFormat, 16, 16, 0, kBlockSize * 16, kBucketId);
1203 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1204
1205 // Test CompressedTexSubImage not allowed
1206 CompressedTexSubImage2DBucket sub_cmd;
1207 bucket->SetSize(kBlockSize);
1208 sub_cmd.Init(GL_TEXTURE_2D, 0, 0, 0, 4, 4, kFormat, kBucketId);
1209 EXPECT_EQ(error::kNoError, ExecuteCmd(sub_cmd));
1210 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
1211
1212 // Test TexSubImage not allowed for ETC1 compressed texture
1213 TextureRef* texture_ref = GetTexture(client_texture_id_);
1214 ASSERT_TRUE(texture_ref != NULL);
1215 Texture* texture = texture_ref->texture();
1216 GLenum type, internal_format;
1217 EXPECT_TRUE(texture->GetLevelType(GL_TEXTURE_2D, 0, &type, &internal_format));
1218 EXPECT_EQ(kFormat, internal_format);
1219 TexSubImage2D texsub_cmd;
1220 texsub_cmd.Init(GL_TEXTURE_2D,
1221 0,
1222 0,
1223 0,
1224 4,
1225 4,
1226 GL_RGBA,
1227 GL_UNSIGNED_BYTE,
1228 kSharedMemoryId,
1229 kSharedMemoryOffset,
1230 GL_FALSE);
1231 EXPECT_EQ(error::kNoError, ExecuteCmd(texsub_cmd));
1232 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
1233
1234 // Test CopyTexSubImage not allowed for ETC1 compressed texture
1235 CopyTexSubImage2D copy_cmd;
1236 copy_cmd.Init(GL_TEXTURE_2D, 0, 0, 0, 0, 0, 4, 4);
1237 EXPECT_EQ(error::kNoError, ExecuteCmd(copy_cmd));
1238 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
1239 }
1240
1241
1242
1243 TEST_P(GLES2DecoderManualInitTest, EGLImageExternalBindTexture) {
1244 InitState init;
1245 init.extensions = "GL_OES_EGL_image_external";
1246 init.gl_version = "opengl es 2.0";
1247 init.bind_generates_resource = true;
1248 InitDecoder(init);
1249 EXPECT_CALL(*gl_, BindTexture(GL_TEXTURE_EXTERNAL_OES, kNewServiceId));
1250 EXPECT_CALL(*gl_, GenTextures(1, _))
1251 .WillOnce(SetArgumentPointee<1>(kNewServiceId));
1252 BindTexture cmd;
1253 cmd.Init(GL_TEXTURE_EXTERNAL_OES, kNewClientId);
1254 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1255 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1256 TextureRef* texture_ref = GetTexture(kNewClientId);
1257 EXPECT_TRUE(texture_ref != NULL);
1258 EXPECT_TRUE(texture_ref->texture()->target() == GL_TEXTURE_EXTERNAL_OES);
1259 }
1260
1261 TEST_P(GLES2DecoderManualInitTest, EGLImageExternalGetBinding) {
1262 InitState init;
1263 init.extensions = "GL_OES_EGL_image_external";
1264 init.gl_version = "opengl es 2.0";
1265 init.bind_generates_resource = true;
1266 InitDecoder(init);
1267 DoBindTexture(GL_TEXTURE_EXTERNAL_OES, client_texture_id_, kServiceTextureId);
1268
1269 EXPECT_CALL(*gl_, GetError())
1270 .WillOnce(Return(GL_NO_ERROR))
1271 .WillOnce(Return(GL_NO_ERROR))
1272 .RetiresOnSaturation();
1273 typedef GetIntegerv::Result Result;
1274 Result* result = static_cast<Result*>(shared_memory_address_);
1275 EXPECT_CALL(*gl_,
1276 GetIntegerv(GL_TEXTURE_BINDING_EXTERNAL_OES, result->GetData()))
1277 .Times(0);
1278 result->size = 0;
1279 GetIntegerv cmd;
1280 cmd.Init(GL_TEXTURE_BINDING_EXTERNAL_OES,
1281 shared_memory_id_,
1282 shared_memory_offset_);
1283 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1284 EXPECT_EQ(decoder_->GetGLES2Util()->GLGetNumValuesReturned(
1285 GL_TEXTURE_BINDING_EXTERNAL_OES),
1286 result->GetNumResults());
1287 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1288 EXPECT_EQ(client_texture_id_, (uint32)result->GetData()[0]);
1289 }
1290
1291 TEST_P(GLES2DecoderManualInitTest, EGLImageExternalTextureDefaults) {
1292 InitState init;
1293 init.extensions = "GL_OES_EGL_image_external";
1294 init.gl_version = "opengl es 2.0";
1295 init.bind_generates_resource = true;
1296 InitDecoder(init);
1297 DoBindTexture(GL_TEXTURE_EXTERNAL_OES, client_texture_id_, kServiceTextureId);
1298
1299 TextureRef* texture_ref = GetTexture(client_texture_id_);
1300 EXPECT_TRUE(texture_ref != NULL);
1301 Texture* texture = texture_ref->texture();
1302 EXPECT_TRUE(texture->target() == GL_TEXTURE_EXTERNAL_OES);
1303 EXPECT_TRUE(texture->min_filter() == GL_LINEAR);
1304 EXPECT_TRUE(texture->wrap_s() == GL_CLAMP_TO_EDGE);
1305 EXPECT_TRUE(texture->wrap_t() == GL_CLAMP_TO_EDGE);
1306 }
1307
1308 TEST_P(GLES2DecoderManualInitTest, EGLImageExternalTextureParam) {
1309 InitState init;
1310 init.extensions = "GL_OES_EGL_image_external";
1311 init.gl_version = "opengl es 2.0";
1312 init.bind_generates_resource = true;
1313 InitDecoder(init);
1314 DoBindTexture(GL_TEXTURE_EXTERNAL_OES, client_texture_id_, kServiceTextureId);
1315
1316 EXPECT_CALL(*gl_,
1317 TexParameteri(
1318 GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MIN_FILTER, GL_NEAREST));
1319 EXPECT_CALL(
1320 *gl_,
1321 TexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
1322 EXPECT_CALL(
1323 *gl_,
1324 TexParameteri(
1325 GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE));
1326 EXPECT_CALL(
1327 *gl_,
1328 TexParameteri(
1329 GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE));
1330 TexParameteri cmd;
1331 cmd.Init(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
1332 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1333 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1334
1335 cmd.Init(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
1336 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1337 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1338
1339 cmd.Init(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
1340 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1341 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1342
1343 cmd.Init(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
1344 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1345 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1346
1347 TextureRef* texture_ref = GetTexture(client_texture_id_);
1348 EXPECT_TRUE(texture_ref != NULL);
1349 Texture* texture = texture_ref->texture();
1350 EXPECT_TRUE(texture->target() == GL_TEXTURE_EXTERNAL_OES);
1351 EXPECT_TRUE(texture->min_filter() == GL_LINEAR);
1352 EXPECT_TRUE(texture->wrap_s() == GL_CLAMP_TO_EDGE);
1353 EXPECT_TRUE(texture->wrap_t() == GL_CLAMP_TO_EDGE);
1354 }
1355
1356 TEST_P(GLES2DecoderManualInitTest, EGLImageExternalTextureParamInvalid) {
1357 InitState init;
1358 init.extensions = "GL_OES_EGL_image_external";
1359 init.gl_version = "opengl es 2.0";
1360 init.bind_generates_resource = true;
1361 InitDecoder(init);
1362 DoBindTexture(GL_TEXTURE_EXTERNAL_OES, client_texture_id_, kServiceTextureId);
1363
1364 TexParameteri cmd;
1365 cmd.Init(GL_TEXTURE_EXTERNAL_OES,
1366 GL_TEXTURE_MIN_FILTER,
1367 GL_NEAREST_MIPMAP_NEAREST);
1368 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1369 EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
1370
1371 cmd.Init(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_S, GL_REPEAT);
1372 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1373 EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
1374
1375 cmd.Init(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_T, GL_REPEAT);
1376 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1377 EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
1378
1379 TextureRef* texture_ref = GetTexture(client_texture_id_);
1380 EXPECT_TRUE(texture_ref != NULL);
1381 Texture* texture = texture_ref->texture();
1382 EXPECT_TRUE(texture->target() == GL_TEXTURE_EXTERNAL_OES);
1383 EXPECT_TRUE(texture->min_filter() == GL_LINEAR);
1384 EXPECT_TRUE(texture->wrap_s() == GL_CLAMP_TO_EDGE);
1385 EXPECT_TRUE(texture->wrap_t() == GL_CLAMP_TO_EDGE);
1386 }
1387
1388 TEST_P(GLES2DecoderManualInitTest, EGLImageExternalTexImage2DError) {
1389 InitState init;
1390 init.extensions = "GL_OES_EGL_image_external";
1391 init.gl_version = "opengl es 2.0";
1392 init.bind_generates_resource = true;
1393 InitDecoder(init);
1394
1395 GLenum target = GL_TEXTURE_EXTERNAL_OES;
1396 GLint level = 0;
1397 GLenum internal_format = GL_RGBA;
1398 GLsizei width = 2;
1399 GLsizei height = 4;
1400 GLenum format = GL_RGBA;
1401 GLenum type = GL_UNSIGNED_BYTE;
1402 DoBindTexture(GL_TEXTURE_EXTERNAL_OES, client_texture_id_, kServiceTextureId);
1403 ASSERT_TRUE(GetTexture(client_texture_id_) != NULL);
1404 TexImage2D cmd;
1405 cmd.Init(target,
1406 level,
1407 internal_format,
1408 width,
1409 height,
1410 format,
1411 type,
1412 kSharedMemoryId,
1413 kSharedMemoryOffset);
1414 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1415
1416 // TexImage2D is not allowed with GL_TEXTURE_EXTERNAL_OES targets.
1417 EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
1418 }
1419
1420 TEST_P(GLES2DecoderManualInitTest, DefaultTextureZero) {
1421 InitState init;
1422 InitDecoder(init);
1423
1424 BindTexture cmd1;
1425 cmd1.Init(GL_TEXTURE_2D, 0);
1426 EXPECT_CALL(*gl_, BindTexture(GL_TEXTURE_2D, 0));
1427 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd1));
1428 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1429
1430 BindTexture cmd2;
1431 cmd2.Init(GL_TEXTURE_CUBE_MAP, 0);
1432 EXPECT_CALL(*gl_, BindTexture(GL_TEXTURE_CUBE_MAP, 0));
1433 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
1434 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1435 }
1436
1437 TEST_P(GLES2DecoderManualInitTest, DefaultTextureBGR) {
1438 InitState init;
1439 init.bind_generates_resource = true;
1440 InitDecoder(init);
1441
1442 BindTexture cmd1;
1443 cmd1.Init(GL_TEXTURE_2D, 0);
1444 EXPECT_CALL(
1445 *gl_, BindTexture(GL_TEXTURE_2D, TestHelper::kServiceDefaultTexture2dId));
1446 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd1));
1447 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1448
1449 BindTexture cmd2;
1450 cmd2.Init(GL_TEXTURE_CUBE_MAP, 0);
1451 EXPECT_CALL(*gl_,
1452 BindTexture(GL_TEXTURE_CUBE_MAP,
1453 TestHelper::kServiceDefaultTextureCubemapId));
1454 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
1455 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1456 }
1457
1458 // Test that default texture 0 is immutable.
1459 TEST_P(GLES2DecoderManualInitTest, NoDefaultTexParameterf) {
1460 InitState init;
1461 InitDecoder(init);
1462
1463 {
1464 BindTexture cmd1;
1465 cmd1.Init(GL_TEXTURE_2D, 0);
1466 EXPECT_CALL(*gl_, BindTexture(GL_TEXTURE_2D, 0));
1467 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd1));
1468 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1469
1470 TexParameterf cmd2;
1471 cmd2.Init(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1472 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
1473 EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
1474 }
1475
1476 {
1477 BindTexture cmd1;
1478 cmd1.Init(GL_TEXTURE_CUBE_MAP, 0);
1479 EXPECT_CALL(*gl_, BindTexture(GL_TEXTURE_CUBE_MAP, 0));
1480 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd1));
1481 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1482
1483 TexParameterf cmd2;
1484 cmd2.Init(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1485 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
1486 EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
1487 }
1488 }
1489
1490 TEST_P(GLES2DecoderManualInitTest, NoDefaultTexParameteri) {
1491 InitState init;
1492 InitDecoder(init);
1493
1494 {
1495 BindTexture cmd1;
1496 cmd1.Init(GL_TEXTURE_2D, 0);
1497 EXPECT_CALL(*gl_, BindTexture(GL_TEXTURE_2D, 0));
1498 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd1));
1499 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1500
1501 TexParameteri cmd2;
1502 cmd2.Init(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1503 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
1504 EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
1505 }
1506
1507 {
1508 BindTexture cmd1;
1509 cmd1.Init(GL_TEXTURE_CUBE_MAP, 0);
1510 EXPECT_CALL(*gl_, BindTexture(GL_TEXTURE_CUBE_MAP, 0));
1511 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd1));
1512 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1513
1514 TexParameteri cmd2;
1515 cmd2.Init(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1516 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
1517 EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
1518 }
1519 }
1520
1521 TEST_P(GLES2DecoderManualInitTest, NoDefaultTexParameterfv) {
1522 InitState init;
1523 InitDecoder(init);
1524
1525 {
1526 BindTexture cmd1;
1527 cmd1.Init(GL_TEXTURE_2D, 0);
1528 EXPECT_CALL(*gl_, BindTexture(GL_TEXTURE_2D, 0));
1529 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd1));
1530 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1531
1532 GLfloat data = GL_NEAREST;
1533 TexParameterfvImmediate& cmd2 =
1534 *GetImmediateAs<TexParameterfvImmediate>();
1535 cmd2.Init(GL_TEXTURE_2D,
1536 GL_TEXTURE_MAG_FILTER,
1537 &data);
1538 EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd2, sizeof(data)));
1539 EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
1540 }
1541
1542 {
1543 BindTexture cmd1;
1544 cmd1.Init(GL_TEXTURE_CUBE_MAP, 0);
1545 EXPECT_CALL(*gl_, BindTexture(GL_TEXTURE_CUBE_MAP, 0));
1546 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd1));
1547 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1548
1549 GLfloat data = GL_NEAREST;
1550 TexParameterfvImmediate& cmd2 =
1551 *GetImmediateAs<TexParameterfvImmediate>();
1552 cmd2.Init(GL_TEXTURE_CUBE_MAP,
1553 GL_TEXTURE_MAG_FILTER,
1554 &data);
1555 EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd2, sizeof(data)));
1556 EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
1557 }
1558 }
1559
1560 TEST_P(GLES2DecoderManualInitTest, NoDefaultTexParameteriv) {
1561 InitState init;
1562 InitDecoder(init);
1563
1564 {
1565 BindTexture cmd1;
1566 cmd1.Init(GL_TEXTURE_2D, 0);
1567 EXPECT_CALL(*gl_, BindTexture(GL_TEXTURE_2D, 0));
1568 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd1));
1569 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1570
1571 GLfloat data = GL_NEAREST;
1572 TexParameterfvImmediate& cmd2 =
1573 *GetImmediateAs<TexParameterfvImmediate>();
1574 cmd2.Init(GL_TEXTURE_2D,
1575 GL_TEXTURE_MAG_FILTER,
1576 &data);
1577 EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd2, sizeof(data)));
1578 EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
1579 }
1580
1581 {
1582 BindTexture cmd1;
1583 cmd1.Init(GL_TEXTURE_CUBE_MAP, 0);
1584 EXPECT_CALL(*gl_, BindTexture(GL_TEXTURE_CUBE_MAP, 0));
1585 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd1));
1586 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1587
1588 GLfloat data = GL_NEAREST;
1589 TexParameterfvImmediate& cmd2 =
1590 *GetImmediateAs<TexParameterfvImmediate>();
1591 cmd2.Init(GL_TEXTURE_CUBE_MAP,
1592 GL_TEXTURE_MAG_FILTER,
1593 &data);
1594 EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd2, sizeof(data)));
1595 EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
1596 }
1597 }
1598
1599 TEST_P(GLES2DecoderManualInitTest, NoDefaultTexImage2D) {
1600 InitState init;
1601 InitDecoder(init);
1602
1603 BindTexture cmd1;
1604 cmd1.Init(GL_TEXTURE_2D, 0);
1605 EXPECT_CALL(*gl_, BindTexture(GL_TEXTURE_2D, 0));
1606 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd1));
1607 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1608
1609 TexImage2D cmd2;
1610 cmd2.Init(GL_TEXTURE_2D,
1611 0,
1612 GL_RGBA,
1613 2,
1614 2,
1615 GL_RGBA,
1616 GL_UNSIGNED_BYTE,
1617 kSharedMemoryId,
1618 kSharedMemoryOffset);
1619 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
1620 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
1621 }
1622
1623 TEST_P(GLES2DecoderManualInitTest, NoDefaultTexSubImage2D) {
1624 InitState init;
1625 InitDecoder(init);
1626
1627 BindTexture cmd1;
1628 cmd1.Init(GL_TEXTURE_2D, 0);
1629 EXPECT_CALL(*gl_, BindTexture(GL_TEXTURE_2D, 0));
1630 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd1));
1631 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1632
1633 TexSubImage2D cmd2;
1634 cmd2.Init(GL_TEXTURE_2D,
1635 0,
1636 1,
1637 1,
1638 1,
1639 1,
1640 GL_RGBA,
1641 GL_UNSIGNED_BYTE,
1642 kSharedMemoryId,
1643 kSharedMemoryOffset,
1644 GL_FALSE);
1645 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
1646 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
1647 }
1648
1649 TEST_P(GLES2DecoderManualInitTest, ARBTextureRectangleBindTexture) {
1650 InitState init;
1651 init.extensions = "GL_ARB_texture_rectangle";
1652 init.bind_generates_resource = true;
1653 InitDecoder(init);
1654 EXPECT_CALL(*gl_, BindTexture(GL_TEXTURE_RECTANGLE_ARB, kNewServiceId));
1655 EXPECT_CALL(*gl_, GenTextures(1, _))
1656 .WillOnce(SetArgumentPointee<1>(kNewServiceId));
1657 BindTexture cmd;
1658 cmd.Init(GL_TEXTURE_RECTANGLE_ARB, kNewClientId);
1659 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1660 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1661 Texture* texture = GetTexture(kNewClientId)->texture();
1662 EXPECT_TRUE(texture != NULL);
1663 EXPECT_TRUE(texture->target() == GL_TEXTURE_RECTANGLE_ARB);
1664 }
1665
1666 TEST_P(GLES2DecoderManualInitTest, ARBTextureRectangleGetBinding) {
1667 InitState init;
1668 init.extensions = "GL_ARB_texture_rectangle";
1669 init.bind_generates_resource = true;
1670 InitDecoder(init);
1671 DoBindTexture(
1672 GL_TEXTURE_RECTANGLE_ARB, client_texture_id_, kServiceTextureId);
1673
1674 EXPECT_CALL(*gl_, GetError())
1675 .WillOnce(Return(GL_NO_ERROR))
1676 .WillOnce(Return(GL_NO_ERROR))
1677 .RetiresOnSaturation();
1678 typedef GetIntegerv::Result Result;
1679 Result* result = static_cast<Result*>(shared_memory_address_);
1680 EXPECT_CALL(*gl_,
1681 GetIntegerv(GL_TEXTURE_BINDING_RECTANGLE_ARB, result->GetData()))
1682 .Times(0);
1683 result->size = 0;
1684 GetIntegerv cmd;
1685 cmd.Init(GL_TEXTURE_BINDING_RECTANGLE_ARB,
1686 shared_memory_id_,
1687 shared_memory_offset_);
1688 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1689 EXPECT_EQ(decoder_->GetGLES2Util()->GLGetNumValuesReturned(
1690 GL_TEXTURE_BINDING_RECTANGLE_ARB),
1691 result->GetNumResults());
1692 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1693 EXPECT_EQ(client_texture_id_, (uint32)result->GetData()[0]);
1694 }
1695
1696 TEST_P(GLES2DecoderManualInitTest, ARBTextureRectangleTextureDefaults) {
1697 InitState init;
1698 init.extensions = "GL_ARB_texture_rectangle";
1699 init.bind_generates_resource = true;
1700 InitDecoder(init);
1701 DoBindTexture(
1702 GL_TEXTURE_RECTANGLE_ARB, client_texture_id_, kServiceTextureId);
1703
1704 Texture* texture = GetTexture(client_texture_id_)->texture();
1705 EXPECT_TRUE(texture != NULL);
1706 EXPECT_TRUE(texture->target() == GL_TEXTURE_RECTANGLE_ARB);
1707 EXPECT_TRUE(texture->min_filter() == GL_LINEAR);
1708 EXPECT_TRUE(texture->wrap_s() == GL_CLAMP_TO_EDGE);
1709 EXPECT_TRUE(texture->wrap_t() == GL_CLAMP_TO_EDGE);
1710 }
1711
1712 TEST_P(GLES2DecoderManualInitTest, ARBTextureRectangleTextureParam) {
1713 InitState init;
1714 init.extensions = "GL_ARB_texture_rectangle";
1715 init.bind_generates_resource = true;
1716 InitDecoder(init);
1717
1718 DoBindTexture(
1719 GL_TEXTURE_RECTANGLE_ARB, client_texture_id_, kServiceTextureId);
1720
1721 EXPECT_CALL(*gl_,
1722 TexParameteri(
1723 GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_NEAREST));
1724 EXPECT_CALL(*gl_,
1725 TexParameteri(
1726 GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
1727 EXPECT_CALL(
1728 *gl_,
1729 TexParameteri(
1730 GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE));
1731 EXPECT_CALL(
1732 *gl_,
1733 TexParameteri(
1734 GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE));
1735 TexParameteri cmd;
1736 cmd.Init(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
1737 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1738 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1739
1740 cmd.Init(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
1741 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1742 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1743
1744 cmd.Init(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
1745 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1746 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1747
1748 cmd.Init(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
1749 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1750 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1751
1752 Texture* texture = GetTexture(client_texture_id_)->texture();
1753 EXPECT_TRUE(texture != NULL);
1754 EXPECT_TRUE(texture->target() == GL_TEXTURE_RECTANGLE_ARB);
1755 EXPECT_TRUE(texture->min_filter() == GL_LINEAR);
1756 EXPECT_TRUE(texture->wrap_s() == GL_CLAMP_TO_EDGE);
1757 EXPECT_TRUE(texture->wrap_t() == GL_CLAMP_TO_EDGE);
1758 }
1759
1760 TEST_P(GLES2DecoderManualInitTest, ARBTextureRectangleTextureParamInvalid) {
1761 InitState init;
1762 init.extensions = "GL_ARB_texture_rectangle";
1763 init.bind_generates_resource = true;
1764 InitDecoder(init);
1765
1766 DoBindTexture(
1767 GL_TEXTURE_RECTANGLE_ARB, client_texture_id_, kServiceTextureId);
1768
1769 TexParameteri cmd;
1770 cmd.Init(GL_TEXTURE_RECTANGLE_ARB,
1771 GL_TEXTURE_MIN_FILTER,
1772 GL_NEAREST_MIPMAP_NEAREST);
1773 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1774 EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
1775
1776 cmd.Init(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, GL_REPEAT);
1777 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1778 EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
1779
1780 cmd.Init(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, GL_REPEAT);
1781 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1782 EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
1783
1784 Texture* texture = GetTexture(client_texture_id_)->texture();
1785 EXPECT_TRUE(texture != NULL);
1786 EXPECT_TRUE(texture->target() == GL_TEXTURE_RECTANGLE_ARB);
1787 EXPECT_TRUE(texture->min_filter() == GL_LINEAR);
1788 EXPECT_TRUE(texture->wrap_s() == GL_CLAMP_TO_EDGE);
1789 EXPECT_TRUE(texture->wrap_t() == GL_CLAMP_TO_EDGE);
1790 }
1791
1792 TEST_P(GLES2DecoderManualInitTest, ARBTextureRectangleTexImage2D) {
1793 InitState init;
1794 init.extensions = "GL_ARB_texture_rectangle";
1795 init.bind_generates_resource = true;
1796 InitDecoder(init);
1797
1798 GLenum target = GL_TEXTURE_RECTANGLE_ARB;
1799 GLint level = 0;
1800 GLenum internal_format = GL_RGBA;
1801 GLsizei width = 2;
1802 GLsizei height = 4;
1803 GLenum format = GL_RGBA;
1804 GLenum type = GL_UNSIGNED_BYTE;
1805
1806 DoBindTexture(
1807 GL_TEXTURE_RECTANGLE_ARB, client_texture_id_, kServiceTextureId);
1808 ASSERT_TRUE(GetTexture(client_texture_id_) != NULL);
1809
1810 EXPECT_CALL(*gl_, GetError())
1811 .WillOnce(Return(GL_NO_ERROR))
1812 .WillOnce(Return(GL_NO_ERROR))
1813 .RetiresOnSaturation();
1814 EXPECT_CALL(*gl_,
1815 TexImage2D(target,
1816 level,
1817 internal_format,
1818 width,
1819 height,
1820 0,
1821 format,
1822 type,
1823 _))
1824 .Times(1)
1825 .RetiresOnSaturation();
1826 TexImage2D cmd;
1827 cmd.Init(target,
1828 level,
1829 internal_format,
1830 width,
1831 height,
1832 format,
1833 type,
1834 kSharedMemoryId,
1835 kSharedMemoryOffset);
1836 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1837
1838 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1839 }
1840
1841 TEST_P(GLES2DecoderManualInitTest, ARBTextureRectangleTexImage2DInvalid) {
1842 InitState init;
1843 init.extensions = "GL_ARB_texture_rectangle";
1844 init.bind_generates_resource = true;
1845 InitDecoder(init);
1846
1847 GLenum target = GL_TEXTURE_RECTANGLE_ARB;
1848 GLint level = 1;
1849 GLenum internal_format = GL_RGBA;
1850 GLsizei width = 2;
1851 GLsizei height = 4;
1852 GLenum format = GL_RGBA;
1853 GLenum type = GL_UNSIGNED_BYTE;
1854
1855 DoBindTexture(
1856 GL_TEXTURE_RECTANGLE_ARB, client_texture_id_, kServiceTextureId);
1857 ASSERT_TRUE(GetTexture(client_texture_id_) != NULL);
1858
1859 TexImage2D cmd;
1860 cmd.Init(target,
1861 level,
1862 internal_format,
1863 width,
1864 height,
1865 format,
1866 type,
1867 kSharedMemoryId,
1868 kSharedMemoryOffset);
1869 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1870
1871 // TexImage2D may only be used with level 0 on GL_TEXTURE_RECTANGLE_ARB
1872 // targets.
1873 EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
1874 }
1875
1876 TEST_P(GLES2DecoderManualInitTest, TexSubImage2DClearsAfterTexImage2DNULL) {
1877 InitState init;
1878 init.gl_version = "opengl es 2.0";
1879 init.has_alpha = true;
1880 init.has_depth = true;
1881 init.request_alpha = true;
1882 init.request_depth = true;
1883 InitDecoder(init);
1884
1885 DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
1886 DoTexImage2D(
1887 GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0, 0);
1888 SetupClearTextureExpectations(kServiceTextureId, kServiceTextureId,
1889 GL_TEXTURE_2D, GL_TEXTURE_2D, 0, GL_RGBA,
1890 GL_RGBA, GL_UNSIGNED_BYTE, 0, 1, 2, 1);
1891 EXPECT_CALL(*gl_, TexSubImage2D(GL_TEXTURE_2D, 0, 0, _, _, 1, GL_RGBA,
1892 GL_UNSIGNED_BYTE, shared_memory_address_))
1893 .Times(2)
1894 .RetiresOnSaturation();
1895 TexSubImage2D cmd;
1896 cmd.Init(GL_TEXTURE_2D, 0, 0, 0, 2, 1, GL_RGBA, GL_UNSIGNED_BYTE,
1897 kSharedMemoryId, kSharedMemoryOffset, GL_FALSE);
1898 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1899 cmd.Init(GL_TEXTURE_2D, 0, 0, 1, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE,
1900 kSharedMemoryId, kSharedMemoryOffset, GL_FALSE);
1901 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1902 // Test if we call it again it does not clear.
1903 EXPECT_CALL(*gl_, TexSubImage2D(GL_TEXTURE_2D, 0, 0, 1, 1, 1, GL_RGBA,
1904 GL_UNSIGNED_BYTE, shared_memory_address_))
1905 .Times(1)
1906 .RetiresOnSaturation();
1907 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1908 }
1909
1910 TEST_P(GLES2DecoderTest, TexSubImage2DDoesNotClearAfterTexImage2DNULLThenData) {
1911 DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
1912 DoTexImage2D(
1913 GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0, 0);
1914 DoTexImage2D(GL_TEXTURE_2D,
1915 0,
1916 GL_RGBA,
1917 2,
1918 2,
1919 0,
1920 GL_RGBA,
1921 GL_UNSIGNED_BYTE,
1922 kSharedMemoryId,
1923 kSharedMemoryOffset);
1924 EXPECT_CALL(*gl_,
1925 TexSubImage2D(GL_TEXTURE_2D,
1926 0,
1927 1,
1928 1,
1929 1,
1930 1,
1931 GL_RGBA,
1932 GL_UNSIGNED_BYTE,
1933 shared_memory_address_))
1934 .Times(1)
1935 .RetiresOnSaturation();
1936 TexSubImage2D cmd;
1937 cmd.Init(GL_TEXTURE_2D,
1938 0,
1939 1,
1940 1,
1941 1,
1942 1,
1943 GL_RGBA,
1944 GL_UNSIGNED_BYTE,
1945 kSharedMemoryId,
1946 kSharedMemoryOffset,
1947 GL_FALSE);
1948 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1949 // Test if we call it again it does not clear.
1950 EXPECT_CALL(*gl_,
1951 TexSubImage2D(GL_TEXTURE_2D,
1952 0,
1953 1,
1954 1,
1955 1,
1956 1,
1957 GL_RGBA,
1958 GL_UNSIGNED_BYTE,
1959 shared_memory_address_))
1960 .Times(1)
1961 .RetiresOnSaturation();
1962 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1963 }
1964
1965 TEST_P(
1966 GLES2DecoderManualInitTest,
1967 TexSubImage2DDoesNotClearAfterTexImage2DNULLThenDataWithTexImage2DIsFaster) {
1968 base::CommandLine command_line(0, NULL);
1969 command_line.AppendSwitchASCII(
1970 switches::kGpuDriverBugWorkarounds,
1971 base::IntToString(gpu::TEXSUBIMAGE_FASTER_THAN_TEXIMAGE));
1972 InitState init;
1973 init.bind_generates_resource = true;
1974 InitDecoderWithCommandLine(init, &command_line);
1975 DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
1976 DoTexImage2D(
1977 GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0, 0);
1978
1979 {
1980 // Uses texSubimage internally because the above workaround is active and
1981 // the update is for the full size of the texture.
1982 EXPECT_CALL(*gl_,
1983 TexSubImage2D(
1984 GL_TEXTURE_2D, 0, 0, 0, 2, 2, GL_RGBA, GL_UNSIGNED_BYTE, _))
1985 .Times(1)
1986 .RetiresOnSaturation();
1987 cmds::TexImage2D cmd;
1988 cmd.Init(GL_TEXTURE_2D,
1989 0,
1990 GL_RGBA,
1991 2,
1992 2,
1993 GL_RGBA,
1994 GL_UNSIGNED_BYTE,
1995 kSharedMemoryId,
1996 kSharedMemoryOffset);
1997 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1998 }
1999
2000 EXPECT_CALL(*gl_,
2001 TexSubImage2D(GL_TEXTURE_2D,
2002 0,
2003 1,
2004 1,
2005 1,
2006 1,
2007 GL_RGBA,
2008 GL_UNSIGNED_BYTE,
2009 shared_memory_address_))
2010 .Times(1)
2011 .RetiresOnSaturation();
2012 TexSubImage2D cmd;
2013 cmd.Init(GL_TEXTURE_2D,
2014 0,
2015 1,
2016 1,
2017 1,
2018 1,
2019 GL_RGBA,
2020 GL_UNSIGNED_BYTE,
2021 kSharedMemoryId,
2022 kSharedMemoryOffset,
2023 GL_FALSE);
2024 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
2025 // Test if we call it again it does not clear.
2026 EXPECT_CALL(*gl_,
2027 TexSubImage2D(GL_TEXTURE_2D,
2028 0,
2029 1,
2030 1,
2031 1,
2032 1,
2033 GL_RGBA,
2034 GL_UNSIGNED_BYTE,
2035 shared_memory_address_))
2036 .Times(1)
2037 .RetiresOnSaturation();
2038 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
2039 }
2040
2041 TEST_P(GLES2DecoderTest, TexSubImage2DClearsAfterTexImage2DWithDataThenNULL) {
2042 DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
2043 // Put in data (so it should be marked as cleared)
2044 DoTexImage2D(GL_TEXTURE_2D,
2045 0,
2046 GL_RGBA,
2047 2,
2048 2,
2049 0,
2050 GL_RGBA,
2051 GL_UNSIGNED_BYTE,
2052 kSharedMemoryId,
2053 kSharedMemoryOffset);
2054 // Put in no data.
2055 TexImage2D tex_cmd;
2056 tex_cmd.Init(
2057 GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, GL_RGBA, GL_UNSIGNED_BYTE, 0, 0);
2058 // It won't actually call TexImage2D, just mark it as uncleared.
2059 EXPECT_EQ(error::kNoError, ExecuteCmd(tex_cmd));
2060 // Next call to TexSubImage2d should clear.
2061 SetupClearTextureExpectations(kServiceTextureId, kServiceTextureId,
2062 GL_TEXTURE_2D, GL_TEXTURE_2D, 0, GL_RGBA,
2063 GL_RGBA, GL_UNSIGNED_BYTE, 0, 1, 2, 1);
2064 EXPECT_CALL(*gl_, TexSubImage2D(GL_TEXTURE_2D, 0, 0, _, _, 1, GL_RGBA,
2065 GL_UNSIGNED_BYTE, shared_memory_address_))
2066 .Times(2)
2067 .RetiresOnSaturation();
2068 TexSubImage2D cmd;
2069 cmd.Init(GL_TEXTURE_2D, 0, 0, 0, 2, 1, GL_RGBA, GL_UNSIGNED_BYTE,
2070 kSharedMemoryId, kSharedMemoryOffset, GL_FALSE);
2071 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
2072 cmd.Init(GL_TEXTURE_2D, 0, 0, 1, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE,
2073 kSharedMemoryId, kSharedMemoryOffset, GL_FALSE);
2074 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
2075 }
2076
2077 TEST_P(GLES2DecoderTest, CopyTexImage2DMarksTextureAsCleared) {
2078 DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
2079
2080 TextureManager* manager = group().texture_manager();
2081 TextureRef* texture_ref = manager->GetTexture(client_texture_id_);
2082 ASSERT_TRUE(texture_ref != NULL);
2083 Texture* texture = texture_ref->texture();
2084
2085 EXPECT_CALL(*gl_, GetError())
2086 .WillOnce(Return(GL_NO_ERROR))
2087 .RetiresOnSaturation();
2088 EXPECT_CALL(*gl_, CopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 0, 0, 1, 1, 0))
2089 .Times(1)
2090 .RetiresOnSaturation();
2091 EXPECT_CALL(*gl_, GetError())
2092 .WillOnce(Return(GL_NO_ERROR))
2093 .RetiresOnSaturation();
2094 CopyTexImage2D cmd;
2095 cmd.Init(GL_TEXTURE_2D, 0, GL_RGBA, 0, 0, 1, 1);
2096 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
2097
2098 EXPECT_TRUE(texture->SafeToRenderFrom());
2099 }
2100
2101 TEST_P(GLES2DecoderTest, CopyTexSubImage2DTwiceMarksTextureAsCleared) {
2102 DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
2103 DoTexImage2D(
2104 GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0, 0);
2105
2106 // This will initialize the top part.
2107 {
2108 EXPECT_CALL(*gl_, CopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, 2, 1))
2109 .Times(1)
2110 .RetiresOnSaturation();
2111 CopyTexSubImage2D cmd;
2112 cmd.Init(GL_TEXTURE_2D, 0, 0, 0, 0, 0, 2, 1);
2113 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
2114 }
2115
2116 // This will initialize the bottom part.
2117 {
2118 EXPECT_CALL(*gl_, CopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 1, 0, 0, 2, 1))
2119 .Times(1)
2120 .RetiresOnSaturation();
2121 CopyTexSubImage2D cmd;
2122 cmd.Init(GL_TEXTURE_2D, 0, 0, 1, 0, 0, 2, 1);
2123 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
2124 }
2125
2126 TextureManager* manager = group().texture_manager();
2127 TextureRef* texture_ref = manager->GetTexture(client_texture_id_);
2128 ASSERT_TRUE(texture_ref != NULL);
2129 Texture* texture = texture_ref->texture();
2130 EXPECT_TRUE(texture->SafeToRenderFrom());
2131 }
2132
2133 TEST_P(GLES2DecoderTest, CopyTexSubImage2DTwiceClearsUnclearedTexture) {
2134 DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
2135 DoTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0,
2136 0);
2137
2138 // This will initialize the top part.
2139 {
2140 EXPECT_CALL(*gl_, CopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, 2, 1))
2141 .Times(1)
2142 .RetiresOnSaturation();
2143 CopyTexSubImage2D cmd;
2144 cmd.Init(GL_TEXTURE_2D, 0, 0, 0, 0, 0, 2, 1);
2145 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
2146 }
2147
2148 SetupClearTextureExpectations(kServiceTextureId, kServiceTextureId,
2149 GL_TEXTURE_2D, GL_TEXTURE_2D, 0, GL_RGBA,
2150 GL_RGBA, GL_UNSIGNED_BYTE, 0, 1, 2, 1);
2151
2152 // This will clear the bottom part as a rectangle is not sufficient to keep
2153 // track of the initialized area.
2154 {
2155 EXPECT_CALL(*gl_, CopyTexSubImage2D(GL_TEXTURE_2D, 0, 1, 1, 0, 0, 1, 1))
2156 .Times(1)
2157 .RetiresOnSaturation();
2158 CopyTexSubImage2D cmd;
2159 cmd.Init(GL_TEXTURE_2D, 0, 1, 1, 0, 0, 1, 1);
2160 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
2161 }
2162
2163 TextureManager* manager = group().texture_manager();
2164 TextureRef* texture_ref = manager->GetTexture(client_texture_id_);
2165 ASSERT_TRUE(texture_ref != NULL);
2166 Texture* texture = texture_ref->texture();
2167 EXPECT_TRUE(texture->SafeToRenderFrom());
2168 }
2169
2170 TEST_P(GLES2DecoderTest, CopyTexSubImage2DClearsUnclearedBackBufferSizedTexture) {
2171 DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
2172 DoTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, kBackBufferWidth, kBackBufferHeight,
2173 0, GL_RGBA, GL_UNSIGNED_BYTE, 0, 0);
2174
2175 EXPECT_CALL(*gl_, CopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0,
2176 kBackBufferWidth, kBackBufferHeight))
2177 .Times(1)
2178 .RetiresOnSaturation();
2179 CopyTexSubImage2D cmd;
2180 cmd.Init(GL_TEXTURE_2D, 0, 0, 0, 0, 0, kBackBufferWidth, kBackBufferHeight);
2181 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
2182
2183 TextureManager* manager = group().texture_manager();
2184 TextureRef* texture_ref = manager->GetTexture(client_texture_id_);
2185 ASSERT_TRUE(texture_ref != NULL);
2186 Texture* texture = texture_ref->texture();
2187 EXPECT_TRUE(texture->SafeToRenderFrom());
2188 }
2189
2190 TEST_P(GLES2DecoderManualInitTest, CompressedImage2DMarksTextureAsCleared) {
2191 InitState init;
2192 init.extensions = "GL_EXT_texture_compression_s3tc";
2193 init.bind_generates_resource = true;
2194 InitDecoder(init);
2195
2196 DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
2197 EXPECT_CALL(*gl_, GetError())
2198 .WillOnce(Return(GL_NO_ERROR))
2199 .RetiresOnSaturation();
2200 EXPECT_CALL(
2201 *gl_,
2202 CompressedTexImage2D(
2203 GL_TEXTURE_2D, 0, GL_COMPRESSED_RGB_S3TC_DXT1_EXT, 4, 4, 0, 8, _))
2204 .Times(1)
2205 .RetiresOnSaturation();
2206 EXPECT_CALL(*gl_, GetError())
2207 .WillOnce(Return(GL_NO_ERROR))
2208 .RetiresOnSaturation();
2209 CompressedTexImage2D cmd;
2210 cmd.Init(GL_TEXTURE_2D,
2211 0,
2212 GL_COMPRESSED_RGB_S3TC_DXT1_EXT,
2213 4,
2214 4,
2215 8,
2216 kSharedMemoryId,
2217 kSharedMemoryOffset);
2218 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
2219 TextureManager* manager = group().texture_manager();
2220 TextureRef* texture_ref = manager->GetTexture(client_texture_id_);
2221 EXPECT_TRUE(texture_ref->texture()->SafeToRenderFrom());
2222 }
2223
2224 TEST_P(GLES2DecoderTest, TextureUsageAngleExtNotEnabledByDefault) {
2225 DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
2226
2227 TexParameteri cmd;
2228 cmd.Init(
2229 GL_TEXTURE_2D, GL_TEXTURE_USAGE_ANGLE, GL_FRAMEBUFFER_ATTACHMENT_ANGLE);
2230 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
2231 EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
2232 }
2233
2234 TEST_P(GLES2DecoderTest, ProduceAndConsumeTextureCHROMIUM) {
2235 Mailbox mailbox = Mailbox::Generate();
2236
2237 DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
2238 DoTexImage2D(
2239 GL_TEXTURE_2D, 0, GL_RGBA, 3, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0, 0);
2240 DoTexImage2D(
2241 GL_TEXTURE_2D, 1, GL_RGBA, 2, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0, 0);
2242 TextureRef* texture_ref =
2243 group().texture_manager()->GetTexture(client_texture_id_);
2244 ASSERT_TRUE(texture_ref != NULL);
2245 Texture* texture = texture_ref->texture();
2246 EXPECT_EQ(kServiceTextureId, texture->service_id());
2247
2248 ProduceTextureCHROMIUMImmediate& produce_cmd =
2249 *GetImmediateAs<ProduceTextureCHROMIUMImmediate>();
2250 produce_cmd.Init(GL_TEXTURE_2D, mailbox.name);
2251 EXPECT_EQ(error::kNoError,
2252 ExecuteImmediateCmd(produce_cmd, sizeof(mailbox.name)));
2253 EXPECT_EQ(GL_NO_ERROR, GetGLError());
2254
2255 // Texture didn't change.
2256 GLsizei width;
2257 GLsizei height;
2258 GLenum type;
2259 GLenum internal_format;
2260
2261 EXPECT_TRUE(
2262 texture->GetLevelSize(GL_TEXTURE_2D, 0, &width, &height, nullptr));
2263 EXPECT_EQ(3, width);
2264 EXPECT_EQ(1, height);
2265 EXPECT_TRUE(texture->GetLevelType(GL_TEXTURE_2D, 0, &type, &internal_format));
2266 EXPECT_EQ(static_cast<GLenum>(GL_RGBA), internal_format);
2267 EXPECT_EQ(static_cast<GLenum>(GL_UNSIGNED_BYTE), type);
2268
2269 EXPECT_TRUE(
2270 texture->GetLevelSize(GL_TEXTURE_2D, 1, &width, &height, nullptr));
2271 EXPECT_EQ(2, width);
2272 EXPECT_EQ(4, height);
2273 EXPECT_TRUE(texture->GetLevelType(GL_TEXTURE_2D, 1, &type, &internal_format));
2274 EXPECT_EQ(static_cast<GLenum>(GL_RGBA), internal_format);
2275 EXPECT_EQ(static_cast<GLenum>(GL_UNSIGNED_BYTE), type);
2276
2277 // Service ID has not changed.
2278 EXPECT_EQ(kServiceTextureId, texture->service_id());
2279
2280 // Create new texture for consume.
2281 EXPECT_CALL(*gl_, GenTextures(_, _))
2282 .WillOnce(SetArgumentPointee<1>(kNewServiceId))
2283 .RetiresOnSaturation();
2284 DoBindTexture(GL_TEXTURE_2D, kNewClientId, kNewServiceId);
2285
2286 // Assigns and binds original service size texture ID.
2287 EXPECT_CALL(*gl_, BindTexture(GL_TEXTURE_2D, 0))
2288 .Times(1)
2289 .RetiresOnSaturation();
2290 EXPECT_CALL(*gl_, DeleteTextures(1, _)).Times(1).RetiresOnSaturation();
2291 EXPECT_CALL(*gl_, BindTexture(GL_TEXTURE_2D, kServiceTextureId))
2292 .Times(1)
2293 .RetiresOnSaturation();
2294
2295 ConsumeTextureCHROMIUMImmediate& consume_cmd =
2296 *GetImmediateAs<ConsumeTextureCHROMIUMImmediate>();
2297 consume_cmd.Init(GL_TEXTURE_2D, mailbox.name);
2298 EXPECT_EQ(error::kNoError,
2299 ExecuteImmediateCmd(consume_cmd, sizeof(mailbox.name)));
2300 EXPECT_EQ(GL_NO_ERROR, GetGLError());
2301
2302 // Texture is redefined.
2303 EXPECT_TRUE(
2304 texture->GetLevelSize(GL_TEXTURE_2D, 0, &width, &height, nullptr));
2305 EXPECT_EQ(3, width);
2306 EXPECT_EQ(1, height);
2307 EXPECT_TRUE(texture->GetLevelType(GL_TEXTURE_2D, 0, &type, &internal_format));
2308 EXPECT_EQ(static_cast<GLenum>(GL_RGBA), internal_format);
2309 EXPECT_EQ(static_cast<GLenum>(GL_UNSIGNED_BYTE), type);
2310
2311 EXPECT_TRUE(
2312 texture->GetLevelSize(GL_TEXTURE_2D, 1, &width, &height, nullptr));
2313 EXPECT_EQ(2, width);
2314 EXPECT_EQ(4, height);
2315 EXPECT_TRUE(texture->GetLevelType(GL_TEXTURE_2D, 1, &type, &internal_format));
2316 EXPECT_EQ(static_cast<GLenum>(GL_RGBA), internal_format);
2317 EXPECT_EQ(static_cast<GLenum>(GL_UNSIGNED_BYTE), type);
2318
2319 // Service ID is restored.
2320 EXPECT_EQ(kServiceTextureId, texture->service_id());
2321 }
2322
2323 TEST_P(GLES2DecoderTest, ProduceAndConsumeDirectTextureCHROMIUM) {
2324 Mailbox mailbox = Mailbox::Generate();
2325
2326 DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
2327 DoTexImage2D(
2328 GL_TEXTURE_2D, 0, GL_RGBA, 3, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0, 0);
2329 DoTexImage2D(
2330 GL_TEXTURE_2D, 1, GL_RGBA, 2, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0, 0);
2331 TextureRef* texture_ref =
2332 group().texture_manager()->GetTexture(client_texture_id_);
2333 ASSERT_TRUE(texture_ref != NULL);
2334 Texture* texture = texture_ref->texture();
2335 EXPECT_EQ(kServiceTextureId, texture->service_id());
2336
2337 ProduceTextureDirectCHROMIUMImmediate& produce_cmd =
2338 *GetImmediateAs<ProduceTextureDirectCHROMIUMImmediate>();
2339 produce_cmd.Init(client_texture_id_, GL_TEXTURE_2D, mailbox.name);
2340 EXPECT_EQ(error::kNoError,
2341 ExecuteImmediateCmd(produce_cmd, sizeof(mailbox.name)));
2342 EXPECT_EQ(GL_NO_ERROR, GetGLError());
2343
2344 // Texture didn't change.
2345 GLsizei width;
2346 GLsizei height;
2347 GLenum type;
2348 GLenum internal_format;
2349
2350 EXPECT_TRUE(
2351 texture->GetLevelSize(GL_TEXTURE_2D, 0, &width, &height, nullptr));
2352 EXPECT_EQ(3, width);
2353 EXPECT_EQ(1, height);
2354 EXPECT_TRUE(texture->GetLevelType(GL_TEXTURE_2D, 0, &type, &internal_format));
2355 EXPECT_EQ(static_cast<GLenum>(GL_RGBA), internal_format);
2356 EXPECT_EQ(static_cast<GLenum>(GL_UNSIGNED_BYTE), type);
2357
2358 EXPECT_TRUE(
2359 texture->GetLevelSize(GL_TEXTURE_2D, 1, &width, &height, nullptr));
2360 EXPECT_EQ(2, width);
2361 EXPECT_EQ(4, height);
2362 EXPECT_TRUE(texture->GetLevelType(GL_TEXTURE_2D, 1, &type, &internal_format));
2363 EXPECT_EQ(static_cast<GLenum>(GL_RGBA), internal_format);
2364 EXPECT_EQ(static_cast<GLenum>(GL_UNSIGNED_BYTE), type);
2365
2366 // Service ID has not changed.
2367 EXPECT_EQ(kServiceTextureId, texture->service_id());
2368
2369 // Consume the texture into a new client ID.
2370 GLuint new_texture_id = kNewClientId;
2371 CreateAndConsumeTextureCHROMIUMImmediate& consume_cmd =
2372 *GetImmediateAs<CreateAndConsumeTextureCHROMIUMImmediate>();
2373 consume_cmd.Init(GL_TEXTURE_2D, new_texture_id, mailbox.name);
2374 EXPECT_EQ(error::kNoError,
2375 ExecuteImmediateCmd(consume_cmd, sizeof(mailbox.name)));
2376 EXPECT_EQ(GL_NO_ERROR, GetGLError());
2377
2378 // Make sure the new client ID is associated with the produced service ID.
2379 texture_ref = group().texture_manager()->GetTexture(new_texture_id);
2380 ASSERT_TRUE(texture_ref != NULL);
2381 texture = texture_ref->texture();
2382 EXPECT_EQ(kServiceTextureId, texture->service_id());
2383
2384 DoBindTexture(GL_TEXTURE_2D, kNewClientId, kServiceTextureId);
2385
2386 // Texture is redefined.
2387 EXPECT_TRUE(
2388 texture->GetLevelSize(GL_TEXTURE_2D, 0, &width, &height, nullptr));
2389 EXPECT_EQ(3, width);
2390 EXPECT_EQ(1, height);
2391 EXPECT_TRUE(texture->GetLevelType(GL_TEXTURE_2D, 0, &type, &internal_format));
2392 EXPECT_EQ(static_cast<GLenum>(GL_RGBA), internal_format);
2393 EXPECT_EQ(static_cast<GLenum>(GL_UNSIGNED_BYTE), type);
2394
2395 EXPECT_TRUE(
2396 texture->GetLevelSize(GL_TEXTURE_2D, 1, &width, &height, nullptr));
2397 EXPECT_EQ(2, width);
2398 EXPECT_EQ(4, height);
2399 EXPECT_TRUE(texture->GetLevelType(GL_TEXTURE_2D, 1, &type, &internal_format));
2400 EXPECT_EQ(static_cast<GLenum>(GL_RGBA), internal_format);
2401 EXPECT_EQ(static_cast<GLenum>(GL_UNSIGNED_BYTE), type);
2402 }
2403
2404 TEST_P(GLES2DecoderTest, ProduceTextureCHROMIUMInvalidTarget) {
2405 Mailbox mailbox = Mailbox::Generate();
2406
2407 DoBindTexture(GL_TEXTURE_CUBE_MAP, client_texture_id_, kServiceTextureId);
2408 DoTexImage2D(
2409 GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, GL_RGBA, 3, 1, 0, GL_RGBA,
2410 GL_UNSIGNED_BYTE, 0, 0);
2411 TextureRef* texture_ref =
2412 group().texture_manager()->GetTexture(client_texture_id_);
2413 ASSERT_TRUE(texture_ref != NULL);
2414 Texture* texture = texture_ref->texture();
2415 EXPECT_EQ(kServiceTextureId, texture->service_id());
2416
2417 ProduceTextureDirectCHROMIUMImmediate& produce_cmd =
2418 *GetImmediateAs<ProduceTextureDirectCHROMIUMImmediate>();
2419 produce_cmd.Init(client_texture_id_, GL_TEXTURE_2D, mailbox.name);
2420 EXPECT_EQ(error::kNoError,
2421 ExecuteImmediateCmd(produce_cmd, sizeof(mailbox.name)));
2422
2423 // ProduceTexture should fail it the texture and produce targets don't match.
2424 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
2425 }
2426
2427 TEST_P(GLES2DecoderTest, CreateAndConsumeTextureCHROMIUMInvalidMailbox) {
2428 // Attempt to consume the mailbox when no texture has been produced with it.
2429 Mailbox mailbox = Mailbox::Generate();
2430 GLuint new_texture_id = kNewClientId;
2431
2432 EXPECT_CALL(*gl_, GenTextures(1, _))
2433 .WillOnce(SetArgumentPointee<1>(kNewServiceId))
2434 .RetiresOnSaturation();
2435 EXPECT_CALL(*gl_, BindTexture(GL_TEXTURE_2D, _))
2436 .Times(2)
2437 .RetiresOnSaturation();
2438 EXPECT_CALL(*gl_, ActiveTexture(GL_TEXTURE0))
2439 .Times(1)
2440 .RetiresOnSaturation();
2441
2442 CreateAndConsumeTextureCHROMIUMImmediate& consume_cmd =
2443 *GetImmediateAs<CreateAndConsumeTextureCHROMIUMImmediate>();
2444 consume_cmd.Init(GL_TEXTURE_2D, new_texture_id, mailbox.name);
2445 EXPECT_EQ(error::kNoError,
2446 ExecuteImmediateCmd(consume_cmd, sizeof(mailbox.name)));
2447
2448 // CreateAndConsumeTexture should fail if the mailbox isn't associated with a
2449 // texture.
2450 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
2451
2452 // Make sure the new client_id is associated with a texture ref even though
2453 // CreateAndConsumeTexture failed.
2454 TextureRef* texture_ref =
2455 group().texture_manager()->GetTexture(new_texture_id);
2456 ASSERT_TRUE(texture_ref != NULL);
2457 Texture* texture = texture_ref->texture();
2458 // New texture should have the correct target type.
2459 EXPECT_TRUE(texture->target() == GL_TEXTURE_2D);
2460 // New texture should have a valid service_id.
2461 EXPECT_EQ(kNewServiceId, texture->service_id());
2462 }
2463
2464 TEST_P(GLES2DecoderTest, CreateAndConsumeTextureCHROMIUMInvalidTarget) {
2465 Mailbox mailbox = Mailbox::Generate();
2466
2467 DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
2468 TextureRef* texture_ref =
2469 group().texture_manager()->GetTexture(client_texture_id_);
2470 ASSERT_TRUE(texture_ref != NULL);
2471
2472 ProduceTextureDirectCHROMIUMImmediate& produce_cmd =
2473 *GetImmediateAs<ProduceTextureDirectCHROMIUMImmediate>();
2474 produce_cmd.Init(client_texture_id_, GL_TEXTURE_2D, mailbox.name);
2475 EXPECT_EQ(error::kNoError,
2476 ExecuteImmediateCmd(produce_cmd, sizeof(mailbox.name)));
2477 EXPECT_EQ(GL_NO_ERROR, GetGLError());
2478
2479 EXPECT_CALL(*gl_, GenTextures(1, _))
2480 .WillOnce(SetArgumentPointee<1>(kNewServiceId))
2481 .RetiresOnSaturation();
2482 EXPECT_CALL(*gl_, BindTexture(GL_TEXTURE_CUBE_MAP, _))
2483 .Times(2)
2484 .RetiresOnSaturation();
2485 EXPECT_CALL(*gl_, ActiveTexture(GL_TEXTURE0))
2486 .Times(1)
2487 .RetiresOnSaturation();
2488
2489 // Attempt to consume the mailbox with a different target.
2490 GLuint new_texture_id = kNewClientId;
2491 CreateAndConsumeTextureCHROMIUMImmediate& consume_cmd =
2492 *GetImmediateAs<CreateAndConsumeTextureCHROMIUMImmediate>();
2493 consume_cmd.Init(GL_TEXTURE_CUBE_MAP, new_texture_id, mailbox.name);
2494 EXPECT_EQ(error::kNoError,
2495 ExecuteImmediateCmd(consume_cmd, sizeof(mailbox.name)));
2496
2497 // CreateAndConsumeTexture should fail if the produced texture had a different
2498 // target.
2499 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
2500
2501 // Make sure the new client_id is associated with a texture ref even though
2502 // CreateAndConsumeTexture failed.
2503 texture_ref = group().texture_manager()->GetTexture(new_texture_id);
2504 ASSERT_TRUE(texture_ref != NULL);
2505 Texture* texture = texture_ref->texture();
2506 // New texture should have the correct target type.
2507 EXPECT_TRUE(texture->target() == GL_TEXTURE_CUBE_MAP);
2508 // New texture should have a valid service_id.
2509 EXPECT_EQ(kNewServiceId, texture->service_id());
2510
2511 // Make sure the client_id did not become associated with the produced texture
2512 // service_id.
2513 EXPECT_NE(kServiceTextureId, texture->service_id());
2514 }
2515
2516 TEST_P(GLES2DecoderManualInitTest, DepthTextureBadArgs) {
2517 InitState init;
2518 init.extensions = "GL_ANGLE_depth_texture";
2519 init.gl_version = "opengl es 2.0";
2520 init.has_depth = true;
2521 init.has_stencil = true;
2522 init.request_depth = true;
2523 init.request_stencil = true;
2524 init.bind_generates_resource = true;
2525 InitDecoder(init);
2526
2527 DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
2528 // Check trying to upload data fails.
2529 TexImage2D tex_cmd;
2530 tex_cmd.Init(GL_TEXTURE_2D,
2531 0,
2532 GL_DEPTH_COMPONENT,
2533 1,
2534 1,
2535 GL_DEPTH_COMPONENT,
2536 GL_UNSIGNED_INT,
2537 kSharedMemoryId,
2538 kSharedMemoryOffset);
2539 EXPECT_EQ(error::kNoError, ExecuteCmd(tex_cmd));
2540 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
2541 // Try level > 0.
2542 tex_cmd.Init(GL_TEXTURE_2D,
2543 1,
2544 GL_DEPTH_COMPONENT,
2545 1,
2546 1,
2547 GL_DEPTH_COMPONENT,
2548 GL_UNSIGNED_INT,
2549 0,
2550 0);
2551 EXPECT_EQ(error::kNoError, ExecuteCmd(tex_cmd));
2552 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
2553 // Make a 1 pixel depth texture.
2554 DoTexImage2D(GL_TEXTURE_2D,
2555 0,
2556 GL_DEPTH_COMPONENT,
2557 1,
2558 1,
2559 0,
2560 GL_DEPTH_COMPONENT,
2561 GL_UNSIGNED_INT,
2562 0,
2563 0);
2564 EXPECT_EQ(GL_NO_ERROR, GetGLError());
2565
2566 // Check that trying to update it fails.
2567 TexSubImage2D tex_sub_cmd;
2568 tex_sub_cmd.Init(GL_TEXTURE_2D,
2569 0,
2570 0,
2571 0,
2572 1,
2573 1,
2574 GL_DEPTH_COMPONENT,
2575 GL_UNSIGNED_INT,
2576 kSharedMemoryId,
2577 kSharedMemoryOffset,
2578 GL_FALSE);
2579 EXPECT_EQ(error::kNoError, ExecuteCmd(tex_sub_cmd));
2580 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
2581
2582 // Check that trying to CopyTexImage2D fails
2583 CopyTexImage2D copy_tex_cmd;
2584 copy_tex_cmd.Init(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, 0, 0, 1, 1);
2585 EXPECT_EQ(error::kNoError, ExecuteCmd(copy_tex_cmd));
2586 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
2587
2588 // Check that trying to CopyTexSubImage2D fails
2589 CopyTexSubImage2D copy_sub_cmd;
2590 copy_sub_cmd.Init(GL_TEXTURE_2D, 0, 0, 0, 0, 0, 1, 1);
2591 EXPECT_EQ(error::kNoError, ExecuteCmd(copy_sub_cmd));
2592 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
2593 }
2594
2595 TEST_P(GLES2DecoderManualInitTest, GenerateMipmapDepthTexture) {
2596 InitState init;
2597 init.extensions = "GL_ANGLE_depth_texture";
2598 init.gl_version = "opengl es 2.0";
2599 init.has_depth = true;
2600 init.has_stencil = true;
2601 init.request_depth = true;
2602 init.request_stencil = true;
2603 init.bind_generates_resource = true;
2604 InitDecoder(init);
2605 DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
2606 DoTexImage2D(GL_TEXTURE_2D,
2607 0,
2608 GL_DEPTH_COMPONENT,
2609 2,
2610 2,
2611 0,
2612 GL_DEPTH_COMPONENT,
2613 GL_UNSIGNED_INT,
2614 0,
2615 0);
2616 GenerateMipmap cmd;
2617 cmd.Init(GL_TEXTURE_2D);
2618 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
2619 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
2620 }
2621
2622 TEST_P(GLES2DecoderTest, BindTexImage2DCHROMIUM) {
2623 DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
2624 DoTexImage2D(
2625 GL_TEXTURE_2D, 0, GL_RGBA, 3, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0, 0);
2626 TextureRef* texture_ref =
2627 group().texture_manager()->GetTexture(client_texture_id_);
2628 ASSERT_TRUE(texture_ref != NULL);
2629 Texture* texture = texture_ref->texture();
2630 EXPECT_EQ(kServiceTextureId, texture->service_id());
2631
2632 scoped_refptr<gfx::GLImage> image(new gfx::GLImageStub);
2633 GetImageManager()->AddImage(image.get(), 1);
2634 EXPECT_FALSE(GetImageManager()->LookupImage(1) == NULL);
2635
2636 GLsizei width;
2637 GLsizei height;
2638 GLenum type;
2639 GLenum internal_format;
2640
2641 EXPECT_TRUE(
2642 texture->GetLevelSize(GL_TEXTURE_2D, 0, &width, &height, nullptr));
2643 EXPECT_EQ(3, width);
2644 EXPECT_EQ(1, height);
2645 EXPECT_TRUE(texture->GetLevelType(GL_TEXTURE_2D, 0, &type, &internal_format));
2646 EXPECT_EQ(static_cast<GLenum>(GL_RGBA), internal_format);
2647 EXPECT_EQ(static_cast<GLenum>(GL_UNSIGNED_BYTE), type);
2648 EXPECT_TRUE(texture->GetLevelImage(GL_TEXTURE_2D, 0) == NULL);
2649
2650 // Bind image to texture.
2651 // ScopedGLErrorSuppressor calls GetError on its constructor and destructor.
2652 DoBindTexImage2DCHROMIUM(GL_TEXTURE_2D, 1);
2653 EXPECT_TRUE(
2654 texture->GetLevelSize(GL_TEXTURE_2D, 0, &width, &height, nullptr));
2655 // Image should now be set.
2656 EXPECT_FALSE(texture->GetLevelImage(GL_TEXTURE_2D, 0) == NULL);
2657
2658 // Define new texture image.
2659 DoTexImage2D(
2660 GL_TEXTURE_2D, 0, GL_RGBA, 3, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0, 0);
2661 EXPECT_TRUE(
2662 texture->GetLevelSize(GL_TEXTURE_2D, 0, &width, &height, nullptr));
2663 // Image should no longer be set.
2664 EXPECT_TRUE(texture->GetLevelImage(GL_TEXTURE_2D, 0) == NULL);
2665 }
2666
2667 TEST_P(GLES2DecoderTest, BindTexImage2DCHROMIUMCubeMapNotAllowed) {
2668 scoped_refptr<gfx::GLImage> image(new gfx::GLImageStub);
2669 GetImageManager()->AddImage(image.get(), 1);
2670 DoBindTexture(GL_TEXTURE_CUBE_MAP, client_texture_id_, kServiceTextureId);
2671
2672 BindTexImage2DCHROMIUM bind_tex_image_2d_cmd;
2673 bind_tex_image_2d_cmd.Init(GL_TEXTURE_CUBE_MAP, 1);
2674 EXPECT_EQ(error::kNoError, ExecuteCmd(bind_tex_image_2d_cmd));
2675 EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
2676 }
2677
2678 TEST_P(GLES2DecoderTest, OrphanGLImageWithTexImage2D) {
2679 scoped_refptr<gfx::GLImage> image(new gfx::GLImageStub);
2680 GetImageManager()->AddImage(image.get(), 1);
2681 DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
2682
2683 DoBindTexImage2DCHROMIUM(GL_TEXTURE_2D, 1);
2684
2685 TextureRef* texture_ref =
2686 group().texture_manager()->GetTexture(client_texture_id_);
2687 ASSERT_TRUE(texture_ref != NULL);
2688 Texture* texture = texture_ref->texture();
2689
2690 EXPECT_TRUE(texture->GetLevelImage(GL_TEXTURE_2D, 0) == image.get());
2691 DoTexImage2D(
2692 GL_TEXTURE_2D, 0, GL_RGBA, 3, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0, 0);
2693 EXPECT_TRUE(texture->GetLevelImage(GL_TEXTURE_2D, 0) == NULL);
2694 }
2695
2696 TEST_P(GLES2DecoderTest, GLImageAttachedAfterSubTexImage2D) {
2697 // Specifically tests that TexSubImage2D is not optimized to TexImage2D
2698 // in the presence of image attachments.
2699 ASSERT_FALSE(
2700 feature_info()->workarounds().texsubimage_faster_than_teximage);
2701
2702 scoped_refptr<gfx::GLImage> image(new gfx::GLImageStub);
2703 GetImageManager()->AddImage(image.get(), 1);
2704 DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
2705
2706 GLenum target = GL_TEXTURE_2D;
2707 GLint level = 0;
2708 GLint xoffset = 0;
2709 GLint yoffset = 0;
2710 GLsizei width = 1;
2711 GLsizei height = 1;
2712 GLint border = 0;
2713 GLenum format = GL_RGBA;
2714 GLenum type = GL_UNSIGNED_BYTE;
2715 uint32_t pixels_shm_id = kSharedMemoryId;
2716 uint32_t pixels_shm_offset = kSharedMemoryOffset;
2717 GLboolean internal = 0;
2718
2719 // Define texture first.
2720 DoTexImage2D(target, level, format, width, height, border, format, type,
2721 pixels_shm_id, pixels_shm_offset);
2722
2723 // Bind texture to GLImage.
2724 DoBindTexImage2DCHROMIUM(GL_TEXTURE_2D, 1);
2725
2726 // Check binding.
2727 TextureRef* texture_ref =
2728 group().texture_manager()->GetTexture(client_texture_id_);
2729 ASSERT_TRUE(texture_ref != NULL);
2730 Texture* texture = texture_ref->texture();
2731 EXPECT_TRUE(texture->GetLevelImage(GL_TEXTURE_2D, 0) == image.get());
2732
2733 // TexSubImage2D should not unbind GLImage.
2734 EXPECT_CALL(*gl_, TexSubImage2D(target, level, xoffset, yoffset, width,
2735 height, format, type, _))
2736 .Times(1)
2737 .RetiresOnSaturation();
2738 cmds::TexSubImage2D tex_sub_image_2d_cmd;
2739 tex_sub_image_2d_cmd.Init(target, level, xoffset, yoffset, width, height,
2740 format, type, pixels_shm_id, pixels_shm_offset,
2741 internal);
2742 EXPECT_EQ(error::kNoError, ExecuteCmd(tex_sub_image_2d_cmd));
2743 EXPECT_TRUE(texture->GetLevelImage(GL_TEXTURE_2D, 0) == image.get());
2744 }
2745
2746 TEST_P(GLES2DecoderTest, GLImageAttachedAfterClearLevel) {
2747 scoped_refptr<gfx::GLImage> image(new gfx::GLImageStub);
2748 GetImageManager()->AddImage(image.get(), 1);
2749 DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
2750
2751 GLenum target = GL_TEXTURE_2D;
2752 GLint level = 0;
2753 GLint xoffset = 0;
2754 GLint yoffset = 0;
2755 GLsizei width = 1;
2756 GLsizei height = 1;
2757 GLint border = 0;
2758 GLenum format = GL_RGBA;
2759 GLenum type = GL_UNSIGNED_BYTE;
2760 uint32_t pixels_shm_id = kSharedMemoryId;
2761 uint32_t pixels_shm_offset = kSharedMemoryOffset;
2762
2763 // Define texture first.
2764 DoTexImage2D(target, level, format, width, height, border, format, type,
2765 pixels_shm_id, pixels_shm_offset);
2766
2767 // Bind texture to GLImage.
2768 DoBindTexImage2DCHROMIUM(GL_TEXTURE_2D, 1);
2769
2770 // Check binding.
2771 TextureRef* texture_ref =
2772 group().texture_manager()->GetTexture(client_texture_id_);
2773 ASSERT_TRUE(texture_ref != NULL);
2774 Texture* texture = texture_ref->texture();
2775 EXPECT_TRUE(texture->GetLevelImage(GL_TEXTURE_2D, 0) == image.get());
2776
2777 // ClearLevel should use glTexSubImage2D to avoid unbinding GLImage.
2778 EXPECT_CALL(*gl_, BindTexture(GL_TEXTURE_2D, kServiceTextureId))
2779 .Times(2)
2780 .RetiresOnSaturation();
2781 EXPECT_CALL(*gl_, TexSubImage2D(target, level, xoffset, yoffset, width,
2782 height, format, type, _))
2783 .Times(1)
2784 .RetiresOnSaturation();
2785 GetDecoder()->ClearLevel(texture, target, level, format, type, 0, 0, width,
2786 height);
2787 EXPECT_TRUE(texture->GetLevelImage(GL_TEXTURE_2D, 0) == image.get());
2788 }
2789
2790 TEST_P(GLES2DecoderTest, ReleaseTexImage2DCHROMIUM) {
2791 DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
2792 DoTexImage2D(
2793 GL_TEXTURE_2D, 0, GL_RGBA, 3, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0, 0);
2794 TextureRef* texture_ref =
2795 group().texture_manager()->GetTexture(client_texture_id_);
2796 ASSERT_TRUE(texture_ref != NULL);
2797 Texture* texture = texture_ref->texture();
2798 EXPECT_EQ(kServiceTextureId, texture->service_id());
2799
2800 scoped_refptr<gfx::GLImage> image(new gfx::GLImageStub);
2801 GetImageManager()->AddImage(image.get(), 1);
2802 EXPECT_FALSE(GetImageManager()->LookupImage(1) == NULL);
2803
2804 GLsizei width;
2805 GLsizei height;
2806 GLenum type;
2807 GLenum internal_format;
2808
2809 EXPECT_TRUE(
2810 texture->GetLevelSize(GL_TEXTURE_2D, 0, &width, &height, nullptr));
2811 EXPECT_EQ(3, width);
2812 EXPECT_EQ(1, height);
2813 EXPECT_TRUE(texture->GetLevelType(GL_TEXTURE_2D, 0, &type, &internal_format));
2814 EXPECT_EQ(static_cast<GLenum>(GL_RGBA), internal_format);
2815 EXPECT_EQ(static_cast<GLenum>(GL_UNSIGNED_BYTE), type);
2816 EXPECT_TRUE(texture->GetLevelImage(GL_TEXTURE_2D, 0) == NULL);
2817
2818 // Bind image to texture.
2819 // ScopedGLErrorSuppressor calls GetError on its constructor and destructor.
2820 DoBindTexImage2DCHROMIUM(GL_TEXTURE_2D, 1);
2821 EXPECT_TRUE(
2822 texture->GetLevelSize(GL_TEXTURE_2D, 0, &width, &height, nullptr));
2823 // Image should now be set.
2824 EXPECT_FALSE(texture->GetLevelImage(GL_TEXTURE_2D, 0) == NULL);
2825
2826 // Release image from texture.
2827 // ScopedGLErrorSuppressor calls GetError on its constructor and destructor.
2828 EXPECT_CALL(*gl_, GetError())
2829 .WillOnce(Return(GL_NO_ERROR))
2830 .WillOnce(Return(GL_NO_ERROR))
2831 .RetiresOnSaturation();
2832 ReleaseTexImage2DCHROMIUM release_tex_image_2d_cmd;
2833 release_tex_image_2d_cmd.Init(GL_TEXTURE_2D, 1);
2834 EXPECT_EQ(error::kNoError, ExecuteCmd(release_tex_image_2d_cmd));
2835 EXPECT_TRUE(
2836 texture->GetLevelSize(GL_TEXTURE_2D, 0, &width, &height, nullptr));
2837 // Image should no longer be set.
2838 EXPECT_TRUE(texture->GetLevelImage(GL_TEXTURE_2D, 0) == NULL);
2839 }
2840
2841 class MockGLImage : public gfx::GLImage {
2842 public:
2843 MockGLImage() {}
2844
2845 // Overridden from gfx::GLImage:
2846 MOCK_METHOD0(GetSize, gfx::Size());
2847 MOCK_METHOD0(GetInternalFormat, unsigned());
2848 MOCK_METHOD1(Destroy, void(bool));
2849 MOCK_METHOD1(BindTexImage, bool(unsigned));
2850 MOCK_METHOD1(ReleaseTexImage, void(unsigned));
2851 MOCK_METHOD3(CopyTexSubImage,
2852 bool(unsigned, const gfx::Point&, const gfx::Rect&));
2853 MOCK_METHOD0(WillUseTexImage, void());
2854 MOCK_METHOD0(DidUseTexImage, void());
2855 MOCK_METHOD0(WillModifyTexImage, void());
2856 MOCK_METHOD0(DidModifyTexImage, void());
2857 MOCK_METHOD5(ScheduleOverlayPlane, bool(gfx::AcceleratedWidget,
2858 int,
2859 gfx::OverlayTransform,
2860 const gfx::Rect&,
2861 const gfx::RectF&));
2862 MOCK_METHOD3(OnMemoryDump,
2863 void(base::trace_event::ProcessMemoryDump*,
2864 uint64_t,
2865 const std::string&));
2866
2867 protected:
2868 virtual ~MockGLImage() {}
2869 };
2870
2871 TEST_P(GLES2DecoderWithShaderTest, UseTexImage) {
2872 DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
2873 DoTexImage2D(GL_TEXTURE_2D,
2874 0,
2875 GL_RGBA,
2876 1,
2877 1,
2878 0,
2879 GL_RGBA,
2880 GL_UNSIGNED_BYTE,
2881 kSharedMemoryId,
2882 kSharedMemoryOffset);
2883
2884 TextureRef* texture_ref =
2885 group().texture_manager()->GetTexture(client_texture_id_);
2886 ASSERT_TRUE(texture_ref != NULL);
2887 Texture* texture = texture_ref->texture();
2888 EXPECT_EQ(kServiceTextureId, texture->service_id());
2889
2890 const int32 kImageId = 1;
2891 scoped_refptr<MockGLImage> image(new MockGLImage);
2892 GetImageManager()->AddImage(image.get(), kImageId);
2893
2894 // Bind image to texture.
2895 EXPECT_CALL(*image.get(), BindTexImage(GL_TEXTURE_2D))
2896 .Times(1)
2897 .WillOnce(Return(true))
2898 .RetiresOnSaturation();
2899 EXPECT_CALL(*image.get(), GetSize())
2900 .Times(1)
2901 .WillOnce(Return(gfx::Size(1, 1)))
2902 .RetiresOnSaturation();
2903 // ScopedGLErrorSuppressor calls GetError on its constructor and destructor.
2904 DoBindTexImage2DCHROMIUM(GL_TEXTURE_2D, kImageId);
2905
2906 AddExpectationsForSimulatedAttrib0(kNumVertices, 0);
2907 SetupExpectationsForApplyingDefaultDirtyState();
2908
2909 // ScopedGLErrorSuppressor calls GetError on its constructor and destructor.
2910 EXPECT_CALL(*gl_, GetError())
2911 .WillOnce(Return(GL_NO_ERROR))
2912 .WillOnce(Return(GL_NO_ERROR))
2913 .WillOnce(Return(GL_NO_ERROR))
2914 .WillOnce(Return(GL_NO_ERROR))
2915 .RetiresOnSaturation();
2916 EXPECT_CALL(*gl_, ActiveTexture(GL_TEXTURE0)).Times(3).RetiresOnSaturation();
2917 EXPECT_CALL(*image.get(), WillUseTexImage()).Times(1).RetiresOnSaturation();
2918 EXPECT_CALL(*image.get(), DidUseTexImage()).Times(1).RetiresOnSaturation();
2919 EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices))
2920 .Times(1)
2921 .RetiresOnSaturation();
2922 DrawArrays cmd;
2923 cmd.Init(GL_TRIANGLES, 0, kNumVertices);
2924 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
2925 EXPECT_EQ(GL_NO_ERROR, GetGLError());
2926
2927 DoBindFramebuffer(
2928 GL_FRAMEBUFFER, client_framebuffer_id_, kServiceFramebufferId);
2929 // ScopedGLErrorSuppressor calls GetError on its constructor and destructor.
2930 EXPECT_CALL(*gl_, GetError())
2931 .WillOnce(Return(GL_NO_ERROR))
2932 .WillOnce(Return(GL_NO_ERROR))
2933 .RetiresOnSaturation();
2934 EXPECT_CALL(*gl_, ActiveTexture(GL_TEXTURE0)).Times(1).RetiresOnSaturation();
2935 EXPECT_CALL(*gl_, BindTexture(GL_TEXTURE_2D, kServiceTextureId))
2936 .Times(2)
2937 .RetiresOnSaturation();
2938 // Image will be 'in use' as long as bound to a framebuffer.
2939 EXPECT_CALL(*image.get(), WillUseTexImage()).Times(1).RetiresOnSaturation();
2940 EXPECT_CALL(*gl_,
2941 FramebufferTexture2DEXT(GL_FRAMEBUFFER,
2942 GL_COLOR_ATTACHMENT0,
2943 GL_TEXTURE_2D,
2944 kServiceTextureId,
2945 0))
2946 .Times(1)
2947 .RetiresOnSaturation();
2948 EXPECT_CALL(*gl_, GetError())
2949 .WillOnce(Return(GL_NO_ERROR))
2950 .WillOnce(Return(GL_NO_ERROR))
2951 .RetiresOnSaturation();
2952 FramebufferTexture2D fbtex_cmd;
2953 fbtex_cmd.Init(GL_FRAMEBUFFER,
2954 GL_COLOR_ATTACHMENT0,
2955 GL_TEXTURE_2D,
2956 client_texture_id_);
2957 EXPECT_EQ(error::kNoError, ExecuteCmd(fbtex_cmd));
2958 EXPECT_EQ(GL_NO_ERROR, GetGLError());
2959
2960 // ScopedGLErrorSuppressor calls GetError on its constructor and destructor.
2961 EXPECT_CALL(*gl_, GetError())
2962 .WillOnce(Return(GL_NO_ERROR))
2963 .WillOnce(Return(GL_NO_ERROR))
2964 .RetiresOnSaturation();
2965 EXPECT_CALL(*gl_,
2966 FramebufferRenderbufferEXT(GL_FRAMEBUFFER,
2967 GL_COLOR_ATTACHMENT0,
2968 GL_RENDERBUFFER,
2969 kServiceRenderbufferId))
2970 .Times(1)
2971 .RetiresOnSaturation();
2972 EXPECT_CALL(*gl_, ActiveTexture(GL_TEXTURE0)).Times(1).RetiresOnSaturation();
2973 EXPECT_CALL(*gl_, BindTexture(GL_TEXTURE_2D, kServiceTextureId))
2974 .Times(2)
2975 .RetiresOnSaturation();
2976 // Image should no longer be 'in use' after being unbound from framebuffer.
2977 EXPECT_CALL(*image.get(), DidUseTexImage()).Times(1).RetiresOnSaturation();
2978 EXPECT_CALL(*gl_, GetError())
2979 .WillOnce(Return(GL_NO_ERROR))
2980 .WillOnce(Return(GL_NO_ERROR))
2981 .RetiresOnSaturation();
2982 FramebufferRenderbuffer fbrb_cmd;
2983 fbrb_cmd.Init(GL_FRAMEBUFFER,
2984 GL_COLOR_ATTACHMENT0,
2985 GL_RENDERBUFFER,
2986 client_renderbuffer_id_);
2987 EXPECT_EQ(error::kNoError, ExecuteCmd(fbrb_cmd));
2988 }
2989
2990 TEST_P(GLES2DecoderManualInitTest, DrawWithGLImageExternal) {
2991 InitState init;
2992 init.extensions = "GL_OES_EGL_image_external";
2993 init.gl_version = "opengl es 2.0";
2994 init.has_alpha = true;
2995 init.has_depth = true;
2996 init.request_alpha = true;
2997 init.request_depth = true;
2998 init.bind_generates_resource = true;
2999 InitDecoder(init);
3000
3001 TextureRef* texture_ref = GetTexture(client_texture_id_);
3002 scoped_refptr<MockGLImage> image(new MockGLImage);
3003 group().texture_manager()->SetTarget(texture_ref, GL_TEXTURE_EXTERNAL_OES);
3004 group().texture_manager()->SetLevelInfo(texture_ref, GL_TEXTURE_EXTERNAL_OES,
3005 0, GL_RGBA, 0, 0, 1, 0, GL_RGBA,
3006 GL_UNSIGNED_BYTE, gfx::Rect());
3007 group().texture_manager()->SetLevelImage(
3008 texture_ref, GL_TEXTURE_EXTERNAL_OES, 0, image.get());
3009
3010 DoBindTexture(GL_TEXTURE_EXTERNAL_OES, client_texture_id_, kServiceTextureId);
3011 EXPECT_EQ(GL_NO_ERROR, GetGLError());
3012
3013 SetupSamplerExternalProgram();
3014 SetupIndexBuffer();
3015 AddExpectationsForSimulatedAttrib0(kMaxValidIndex + 1, 0);
3016 SetupExpectationsForApplyingDefaultDirtyState();
3017 EXPECT_TRUE(group().texture_manager()->CanRender(texture_ref));
3018
3019 InSequence s;
3020 EXPECT_CALL(*gl_, GetError())
3021 .WillOnce(Return(GL_NO_ERROR))
3022 .RetiresOnSaturation();
3023 EXPECT_CALL(*gl_, ActiveTexture(GL_TEXTURE0)).Times(1).RetiresOnSaturation();
3024 EXPECT_CALL(*image.get(), WillUseTexImage()).Times(1).RetiresOnSaturation();
3025 EXPECT_CALL(*gl_, GetError())
3026 .WillOnce(Return(GL_NO_ERROR))
3027 .RetiresOnSaturation();
3028 EXPECT_CALL(*gl_, DrawElements(_, _, _, _)).Times(1);
3029 EXPECT_CALL(*gl_, GetError())
3030 .WillOnce(Return(GL_NO_ERROR))
3031 .RetiresOnSaturation();
3032 EXPECT_CALL(*gl_, ActiveTexture(GL_TEXTURE0)).Times(1).RetiresOnSaturation();
3033 EXPECT_CALL(*image.get(), DidUseTexImage()).Times(1).RetiresOnSaturation();
3034 EXPECT_CALL(*gl_, GetError())
3035 .WillOnce(Return(GL_NO_ERROR))
3036 .RetiresOnSaturation();
3037 EXPECT_CALL(*gl_, ActiveTexture(GL_TEXTURE0)).Times(1).RetiresOnSaturation();
3038 DrawElements cmd;
3039 cmd.Init(GL_TRIANGLES,
3040 kValidIndexRangeCount,
3041 GL_UNSIGNED_SHORT,
3042 kValidIndexRangeStart * 2);
3043 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
3044 EXPECT_EQ(GL_NO_ERROR, GetGLError());
3045 }
3046
3047 TEST_P(GLES2DecoderManualInitTest, TexImage2DFloatOnGLES2) {
3048 InitState init;
3049 init.extensions = "GL_OES_texture_float";
3050 init.gl_version = "opengl es 2.0";
3051 InitDecoder(init);
3052 DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
3053 DoTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 16, 17, 0, GL_RGBA, GL_FLOAT, 0, 0);
3054 DoTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 16, 17, 0, GL_RGB, GL_FLOAT, 0, 0);
3055 DoTexImage2D(
3056 GL_TEXTURE_2D, 0, GL_LUMINANCE, 16, 17, 0, GL_LUMINANCE, GL_FLOAT, 0, 0);
3057 DoTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, 16, 17, 0, GL_ALPHA, GL_FLOAT, 0, 0);
3058 DoTexImage2D(GL_TEXTURE_2D,
3059 0,
3060 GL_LUMINANCE_ALPHA,
3061 16,
3062 17,
3063 0,
3064 GL_LUMINANCE_ALPHA,
3065 GL_FLOAT,
3066 0,
3067 0);
3068 }
3069
3070 TEST_P(GLES2DecoderManualInitTest, TexImage2DFloatOnGLES3) {
3071 InitState init;
3072 init.extensions = "GL_OES_texture_float GL_EXT_color_buffer_float";
3073 init.gl_version = "opengl es 3.0";
3074 InitDecoder(init);
3075 DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
3076 DoTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 16, 17, 0, GL_RGBA, GL_FLOAT, 0, 0);
3077 DoTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 16, 17, 0, GL_RGB, GL_FLOAT, 0, 0);
3078 DoTexImage2D(
3079 GL_TEXTURE_2D, 0, GL_RGBA32F, 16, 17, 0, GL_RGBA, GL_FLOAT, 0, 0);
3080 DoTexImage2D(
3081 GL_TEXTURE_2D, 0, GL_LUMINANCE, 16, 17, 0, GL_LUMINANCE, GL_FLOAT, 0, 0);
3082 DoTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, 16, 17, 0, GL_ALPHA, GL_FLOAT, 0, 0);
3083 DoTexImage2D(GL_TEXTURE_2D,
3084 0,
3085 GL_LUMINANCE_ALPHA,
3086 16,
3087 17,
3088 0,
3089 GL_LUMINANCE_ALPHA,
3090 GL_FLOAT,
3091 0,
3092 0);
3093 }
3094
3095 TEST_P(GLES2DecoderManualInitTest, TexSubImage2DFloatOnGLES3) {
3096 InitState init;
3097 init.extensions = "GL_OES_texture_float GL_EXT_color_buffer_float";
3098 init.gl_version = "opengl es 3.0";
3099 InitDecoder(init);
3100 const int kWidth = 8;
3101 const int kHeight = 4;
3102 DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
3103 DoTexImage2D(GL_TEXTURE_2D,
3104 0,
3105 GL_RGBA32F,
3106 kWidth,
3107 kHeight,
3108 0,
3109 GL_RGBA,
3110 GL_FLOAT,
3111 0,
3112 0);
3113 EXPECT_CALL(*gl_,
3114 TexImage2D(GL_TEXTURE_2D,
3115 0,
3116 GL_RGBA32F,
3117 kWidth,
3118 kHeight,
3119 0,
3120 GL_RGBA,
3121 GL_FLOAT,
3122 shared_memory_address_))
3123 .Times(1)
3124 .RetiresOnSaturation();
3125 TexSubImage2D cmd;
3126 cmd.Init(GL_TEXTURE_2D,
3127 0,
3128 0,
3129 0,
3130 kWidth,
3131 kHeight,
3132 GL_RGBA,
3133 GL_FLOAT,
3134 kSharedMemoryId,
3135 kSharedMemoryOffset,
3136 GL_FALSE);
3137 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
3138 EXPECT_EQ(GL_NO_ERROR, GetGLError());
3139 }
3140
3141 TEST_P(GLES2DecoderManualInitTest, TexSubImage2DFloatDoesClearOnGLES3) {
3142 InitState init;
3143 init.extensions = "GL_OES_texture_float GL_EXT_color_buffer_float";
3144 init.gl_version = "opengl es 3.0";
3145 InitDecoder(init);
3146 const int kWidth = 8;
3147 const int kHeight = 4;
3148 DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
3149 DoTexImage2D(GL_TEXTURE_2D,
3150 0,
3151 GL_RGBA32F,
3152 kWidth,
3153 kHeight,
3154 0,
3155 GL_RGBA,
3156 GL_FLOAT,
3157 0,
3158 0);
3159 SetupClearTextureExpectations(kServiceTextureId, kServiceTextureId,
3160 GL_TEXTURE_2D, GL_TEXTURE_2D, 0, GL_RGBA32F,
3161 GL_RGBA, GL_FLOAT, 0, kHeight - 1, kWidth, 1);
3162 EXPECT_CALL(*gl_, TexSubImage2D(GL_TEXTURE_2D, 0, 0, _, _, _, GL_RGBA,
3163 GL_FLOAT, shared_memory_address_))
3164 .Times(2)
3165 .RetiresOnSaturation();
3166 TexSubImage2D cmd;
3167 cmd.Init(GL_TEXTURE_2D, 0, 0, 0, kWidth, kHeight - 1, GL_RGBA, GL_FLOAT,
3168 kSharedMemoryId, kSharedMemoryOffset, GL_FALSE);
3169 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
3170 cmd.Init(GL_TEXTURE_2D, 0, 0, kHeight - 1, kWidth - 1, 1, GL_RGBA, GL_FLOAT,
3171 kSharedMemoryId, kSharedMemoryOffset, GL_FALSE);
3172 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
3173 EXPECT_EQ(GL_NO_ERROR, GetGLError());
3174 }
3175
3176 TEST_P(GLES2DecoderManualInitTest, TexImage2DFloatConvertsFormatDesktop) {
3177 InitState init;
3178 init.extensions = "GL_ARB_texture_float";
3179 InitDecoder(init);
3180 DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
3181 DoTexImage2D(
3182 GL_TEXTURE_2D, 0, GL_RGBA32F, 16, 17, 0, GL_RGBA, GL_FLOAT, 0, 0);
3183 DoTexImage2D(GL_TEXTURE_2D, 0, GL_RGB32F, 16, 17, 0, GL_RGB, GL_FLOAT, 0, 0);
3184 DoTexImage2DConvertInternalFormat(GL_TEXTURE_2D,
3185 0,
3186 GL_RGBA,
3187 16,
3188 17,
3189 0,
3190 GL_RGBA,
3191 GL_FLOAT,
3192 0,
3193 0,
3194 GL_RGBA32F_ARB);
3195 DoTexImage2DConvertInternalFormat(GL_TEXTURE_2D,
3196 0,
3197 GL_RGB,
3198 16,
3199 17,
3200 0,
3201 GL_RGB,
3202 GL_FLOAT,
3203 0,
3204 0,
3205 GL_RGB32F_ARB);
3206 DoTexImage2DConvertInternalFormat(GL_TEXTURE_2D,
3207 0,
3208 GL_LUMINANCE,
3209 16,
3210 17,
3211 0,
3212 GL_LUMINANCE,
3213 GL_FLOAT,
3214 0,
3215 0,
3216 GL_LUMINANCE32F_ARB);
3217 DoTexImage2DConvertInternalFormat(GL_TEXTURE_2D,
3218 0,
3219 GL_ALPHA,
3220 16,
3221 17,
3222 0,
3223 GL_ALPHA,
3224 GL_FLOAT,
3225 0,
3226 0,
3227 GL_ALPHA32F_ARB);
3228 DoTexImage2DConvertInternalFormat(GL_TEXTURE_2D,
3229 0,
3230 GL_LUMINANCE_ALPHA,
3231 16,
3232 17,
3233 0,
3234 GL_LUMINANCE_ALPHA,
3235 GL_FLOAT,
3236 0,
3237 0,
3238 GL_LUMINANCE_ALPHA32F_ARB);
3239 }
3240
3241 class GLES2DecoderCompressedFormatsTest : public GLES2DecoderManualInitTest {
3242 public:
3243 GLES2DecoderCompressedFormatsTest() {}
3244
3245 static bool ValueInArray(GLint value, GLint* array, GLint count) {
3246 for (GLint ii = 0; ii < count; ++ii) {
3247 if (array[ii] == value) {
3248 return true;
3249 }
3250 }
3251 return false;
3252 }
3253
3254 void CheckFormats(const char* extension, const GLenum* formats, int count) {
3255 InitState init;
3256 init.extensions = extension;
3257 init.bind_generates_resource = true;
3258 InitDecoder(init);
3259
3260 EXPECT_CALL(*gl_, GetError())
3261 .WillOnce(Return(GL_NO_ERROR))
3262 .WillOnce(Return(GL_NO_ERROR))
3263 .WillOnce(Return(GL_NO_ERROR))
3264 .WillOnce(Return(GL_NO_ERROR))
3265 .RetiresOnSaturation();
3266
3267 typedef GetIntegerv::Result Result;
3268 Result* result = static_cast<Result*>(shared_memory_address_);
3269 GetIntegerv cmd;
3270 result->size = 0;
3271 EXPECT_CALL(*gl_, GetIntegerv(_, _)).Times(0).RetiresOnSaturation();
3272 cmd.Init(GL_NUM_COMPRESSED_TEXTURE_FORMATS,
3273 shared_memory_id_,
3274 shared_memory_offset_);
3275 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
3276 EXPECT_EQ(1, result->GetNumResults());
3277 GLint num_formats = result->GetData()[0];
3278 EXPECT_EQ(count, num_formats);
3279 EXPECT_EQ(GL_NO_ERROR, GetGLError());
3280
3281 result->size = 0;
3282 cmd.Init(GL_COMPRESSED_TEXTURE_FORMATS,
3283 shared_memory_id_,
3284 shared_memory_offset_);
3285 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
3286 EXPECT_EQ(num_formats, result->GetNumResults());
3287
3288 for (int i = 0; i < count; ++i) {
3289 EXPECT_TRUE(
3290 ValueInArray(formats[i], result->GetData(), result->GetNumResults()));
3291 }
3292
3293 EXPECT_EQ(GL_NO_ERROR, GetGLError());
3294 }
3295 };
3296
3297 INSTANTIATE_TEST_CASE_P(Service,
3298 GLES2DecoderCompressedFormatsTest,
3299 ::testing::Bool());
3300
3301 TEST_P(GLES2DecoderCompressedFormatsTest, GetCompressedTextureFormatsS3TC) {
3302 const GLenum formats[] = {
3303 GL_COMPRESSED_RGB_S3TC_DXT1_EXT, GL_COMPRESSED_RGBA_S3TC_DXT1_EXT,
3304 GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT};
3305 CheckFormats("GL_EXT_texture_compression_s3tc", formats, 4);
3306 }
3307
3308 TEST_P(GLES2DecoderCompressedFormatsTest, GetCompressedTextureFormatsATC) {
3309 const GLenum formats[] = {GL_ATC_RGB_AMD, GL_ATC_RGBA_EXPLICIT_ALPHA_AMD,
3310 GL_ATC_RGBA_INTERPOLATED_ALPHA_AMD};
3311 CheckFormats("GL_AMD_compressed_ATC_texture", formats, 3);
3312 }
3313
3314 TEST_P(GLES2DecoderCompressedFormatsTest, GetCompressedTextureFormatsPVRTC) {
3315 const GLenum formats[] = {
3316 GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG, GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG,
3317 GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG, GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG};
3318 CheckFormats("GL_IMG_texture_compression_pvrtc", formats, 4);
3319 }
3320
3321 TEST_P(GLES2DecoderCompressedFormatsTest, GetCompressedTextureFormatsETC1) {
3322 const GLenum formats[] = {GL_ETC1_RGB8_OES};
3323 CheckFormats("GL_OES_compressed_ETC1_RGB8_texture", formats, 1);
3324 }
3325
3326 TEST_P(GLES2DecoderCompressedFormatsTest, GetCompressedTextureFormatsASTC) {
3327 const GLenum formats[] = {
3328 GL_COMPRESSED_RGBA_ASTC_4x4_KHR,
3329 GL_COMPRESSED_RGBA_ASTC_5x4_KHR,
3330 GL_COMPRESSED_RGBA_ASTC_5x5_KHR,
3331 GL_COMPRESSED_RGBA_ASTC_6x5_KHR,
3332 GL_COMPRESSED_RGBA_ASTC_6x6_KHR,
3333 GL_COMPRESSED_RGBA_ASTC_8x5_KHR,
3334 GL_COMPRESSED_RGBA_ASTC_8x6_KHR,
3335 GL_COMPRESSED_RGBA_ASTC_8x8_KHR,
3336 GL_COMPRESSED_RGBA_ASTC_10x5_KHR,
3337 GL_COMPRESSED_RGBA_ASTC_10x6_KHR,
3338 GL_COMPRESSED_RGBA_ASTC_10x8_KHR,
3339 GL_COMPRESSED_RGBA_ASTC_10x10_KHR,
3340 GL_COMPRESSED_RGBA_ASTC_12x10_KHR,
3341 GL_COMPRESSED_RGBA_ASTC_12x12_KHR,
3342 GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR,
3343 GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR,
3344 GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR,
3345 GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR,
3346 GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR,
3347 GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR,
3348 GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR,
3349 GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR,
3350 GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR,
3351 GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR,
3352 GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR,
3353 GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR,
3354 GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR,
3355 GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR};
3356 CheckFormats("GL_KHR_texture_compression_astc_ldr", formats, 28);
3357 }
3358
3359 TEST_P(GLES2DecoderManualInitTest, GetNoCompressedTextureFormats) {
3360 InitState init;
3361 init.bind_generates_resource = true;
3362 InitDecoder(init);
3363
3364 EXPECT_CALL(*gl_, GetError())
3365 .WillOnce(Return(GL_NO_ERROR))
3366 .WillOnce(Return(GL_NO_ERROR))
3367 .WillOnce(Return(GL_NO_ERROR))
3368 .WillOnce(Return(GL_NO_ERROR))
3369 .RetiresOnSaturation();
3370
3371 typedef GetIntegerv::Result Result;
3372 Result* result = static_cast<Result*>(shared_memory_address_);
3373 GetIntegerv cmd;
3374 result->size = 0;
3375 EXPECT_CALL(*gl_, GetIntegerv(_, _)).Times(0).RetiresOnSaturation();
3376 cmd.Init(GL_NUM_COMPRESSED_TEXTURE_FORMATS,
3377 shared_memory_id_,
3378 shared_memory_offset_);
3379 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
3380 EXPECT_EQ(1, result->GetNumResults());
3381 GLint num_formats = result->GetData()[0];
3382 EXPECT_EQ(0, num_formats);
3383 EXPECT_EQ(GL_NO_ERROR, GetGLError());
3384
3385 result->size = 0;
3386 cmd.Init(
3387 GL_COMPRESSED_TEXTURE_FORMATS, shared_memory_id_, shared_memory_offset_);
3388 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
3389 EXPECT_EQ(num_formats, result->GetNumResults());
3390
3391 EXPECT_EQ(GL_NO_ERROR, GetGLError());
3392 }
3393
3394 // TODO(gman): Complete this test.
3395 // TEST_P(GLES2DecoderTest, CompressedTexImage2DGLError) {
3396 // }
3397
3398 // TODO(gman): CompressedTexImage2D
3399
3400 // TODO(gman): CompressedTexImage2DImmediate
3401
3402 // TODO(gman): CompressedTexSubImage2DImmediate
3403
3404 // TODO(gman): TexImage2D
3405
3406 // TODO(gman): TexImage2DImmediate
3407
3408 // TODO(gman): TexSubImage2DImmediate
3409
3410 } // namespace gles2
3411 } // namespace gpu