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