?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Handle account removal correctly on all platforms.
[chromium-blink-merge.git] / gpu / command_buffer / service / gles2_cmd_decoder_unittest_framebuffers.cc
blobeb8bf4c07b3bd2552db9a7cb913bf75177942b35
1 // Copyright 2014 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
6
7 #include "base/command_line.h"
8 #include "base/strings/string_number_conversions.h"
9 #include "gpu/command_buffer/common/gles2_cmd_format.h"
10 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
11 #include "gpu/command_buffer/common/id_allocator.h"
12 #include "gpu/command_buffer/service/async_pixel_transfer_delegate_mock.h"
13 #include "gpu/command_buffer/service/async_pixel_transfer_manager.h"
14 #include "gpu/command_buffer/service/async_pixel_transfer_manager_mock.h"
15 #include "gpu/command_buffer/service/cmd_buffer_engine.h"
16 #include "gpu/command_buffer/service/context_group.h"
17 #include "gpu/command_buffer/service/context_state.h"
18 #include "gpu/command_buffer/service/gl_surface_mock.h"
19 #include "gpu/command_buffer/service/gles2_cmd_decoder_unittest.h"
20
21 #include "gpu/command_buffer/service/gpu_switches.h"
22 #include "gpu/command_buffer/service/image_manager.h"
23 #include "gpu/command_buffer/service/mailbox_manager.h"
24 #include "gpu/command_buffer/service/mocks.h"
25 #include "gpu/command_buffer/service/program_manager.h"
26 #include "gpu/command_buffer/service/test_helper.h"
27 #include "testing/gtest/include/gtest/gtest.h"
28 #include "ui/gl/gl_implementation.h"
29 #include "ui/gl/gl_mock.h"
30 #include "ui/gl/gl_surface_stub.h"
31
32 #if !defined(GL_DEPTH24_STENCIL8)
33 #define GL_DEPTH24_STENCIL8 0x88F0
34 #endif
35
36 using ::gfx::MockGLInterface;
37 using ::testing::_;
38 using ::testing::DoAll;
39 using ::testing::InSequence;
40 using ::testing::Invoke;
41 using ::testing::MatcherCast;
42 using ::testing::Mock;
43 using ::testing::Pointee;
44 using ::testing::Return;
45 using ::testing::SaveArg;
46 using ::testing::SetArrayArgument;
47 using ::testing::SetArgumentPointee;
48 using ::testing::SetArgPointee;
49 using ::testing::StrEq;
50 using ::testing::StrictMock;
51
52 namespace gpu {
53 namespace gles2 {
54
55 using namespace cmds;
56
57 class GLES2DecoderTestWithExtensionsOnGLES2 : public GLES2DecoderTest {
58 public:
59 GLES2DecoderTestWithExtensionsOnGLES2() {}
60
61 virtual void SetUp() {}
62 void Init(const char* extensions) {
63 InitState init;
64 init.extensions = extensions;
65 init.gl_version = "opengl es 2.0";
66 init.has_alpha = true;
67 init.has_depth = true;
68 init.request_alpha = true;
69 init.request_depth = true;
70 InitDecoder(init);
71 }
72 };
73
74 TEST_P(GLES2DecoderTest, CheckFramebufferStatusWithNoBoundTarget) {
75 EXPECT_CALL(*gl_, CheckFramebufferStatusEXT(_)).Times(0);
76 CheckFramebufferStatus::Result* result =
77 static_cast<CheckFramebufferStatus::Result*>(shared_memory_address_);
78 *result = 0;
79 CheckFramebufferStatus cmd;
80 cmd.Init(GL_FRAMEBUFFER, shared_memory_id_, shared_memory_offset_);
81 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
82 EXPECT_EQ(static_cast<GLenum>(GL_FRAMEBUFFER_COMPLETE), *result);
83 }
84
85 TEST_P(GLES2DecoderWithShaderTest, BindAndDeleteFramebuffer) {
86 SetupTexture();
87 AddExpectationsForSimulatedAttrib0(kNumVertices, 0);
88 SetupExpectationsForApplyingDefaultDirtyState();
89 DoBindFramebuffer(
90 GL_FRAMEBUFFER, client_framebuffer_id_, kServiceFramebufferId);
91 DoDeleteFramebuffer(client_framebuffer_id_,
92 kServiceFramebufferId,
93 true,
94 GL_FRAMEBUFFER,
95 0,
96 true,
97 GL_FRAMEBUFFER,
98 0);
99 EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices))
100 .Times(1)
101 .RetiresOnSaturation();
102 DrawArrays cmd;
103 cmd.Init(GL_TRIANGLES, 0, kNumVertices);
104 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
105 EXPECT_EQ(GL_NO_ERROR, GetGLError());
106 }
107
108 TEST_P(GLES2DecoderTest, FramebufferRenderbufferWithNoBoundTarget) {
109 EXPECT_CALL(*gl_, FramebufferRenderbufferEXT(_, _, _, _)).Times(0);
110 FramebufferRenderbuffer cmd;
111 cmd.Init(GL_FRAMEBUFFER,
112 GL_COLOR_ATTACHMENT0,
113 GL_RENDERBUFFER,
114 client_renderbuffer_id_);
115 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
116 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
117 }
118
119 TEST_P(GLES2DecoderTest, FramebufferTexture2DWithNoBoundTarget) {
120 EXPECT_CALL(*gl_, FramebufferTexture2DEXT(_, _, _, _, _)).Times(0);
121 FramebufferTexture2D cmd;
122 cmd.Init(GL_FRAMEBUFFER,
123 GL_COLOR_ATTACHMENT0,
124 GL_TEXTURE_2D,
125 client_texture_id_);
126 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
127 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
128 }
129
130 TEST_P(GLES2DecoderTest, GetFramebufferAttachmentParameterivWithNoBoundTarget) {
131 EXPECT_CALL(*gl_, GetError())
132 .WillOnce(Return(GL_NO_ERROR))
133 .WillOnce(Return(GL_NO_ERROR))
134 .RetiresOnSaturation();
135 EXPECT_CALL(*gl_, GetFramebufferAttachmentParameterivEXT(_, _, _, _))
136 .Times(0);
137 GetFramebufferAttachmentParameteriv cmd;
138 cmd.Init(GL_FRAMEBUFFER,
139 GL_COLOR_ATTACHMENT0,
140 GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE,
141 shared_memory_id_,
142 shared_memory_offset_);
143 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
144 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
145 }
146
147 TEST_P(GLES2DecoderTest, GetFramebufferAttachmentParameterivWithRenderbuffer) {
148 DoBindFramebuffer(
149 GL_FRAMEBUFFER, client_framebuffer_id_, kServiceFramebufferId);
150 EXPECT_CALL(*gl_, GetError())
151 .WillOnce(Return(GL_NO_ERROR))
152 .RetiresOnSaturation();
153 EXPECT_CALL(*gl_,
154 FramebufferRenderbufferEXT(GL_FRAMEBUFFER,
155 GL_COLOR_ATTACHMENT0,
156 GL_RENDERBUFFER,
157 kServiceRenderbufferId))
158 .Times(1)
159 .RetiresOnSaturation();
160 EXPECT_CALL(*gl_, GetError())
161 .WillOnce(Return(GL_NO_ERROR))
162 .RetiresOnSaturation();
163 EXPECT_CALL(*gl_, GetError())
164 .WillOnce(Return(GL_NO_ERROR))
165 .WillOnce(Return(GL_NO_ERROR))
166 .RetiresOnSaturation();
167 GetFramebufferAttachmentParameteriv::Result* result =
168 static_cast<GetFramebufferAttachmentParameteriv::Result*>(
169 shared_memory_address_);
170 result->size = 0;
171 const GLint* result_value = result->GetData();
172 FramebufferRenderbuffer fbrb_cmd;
173 GetFramebufferAttachmentParameteriv cmd;
174 fbrb_cmd.Init(GL_FRAMEBUFFER,
175 GL_COLOR_ATTACHMENT0,
176 GL_RENDERBUFFER,
177 client_renderbuffer_id_);
178 cmd.Init(GL_FRAMEBUFFER,
179 GL_COLOR_ATTACHMENT0,
180 GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME,
181 shared_memory_id_,
182 shared_memory_offset_);
183 EXPECT_EQ(error::kNoError, ExecuteCmd(fbrb_cmd));
184 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
185 EXPECT_EQ(GL_NO_ERROR, GetGLError());
186 EXPECT_EQ(static_cast<GLuint>(*result_value), client_renderbuffer_id_);
187 }
188
189 TEST_P(GLES2DecoderTest, GetFramebufferAttachmentParameterivWithTexture) {
190 DoBindFramebuffer(
191 GL_FRAMEBUFFER, client_framebuffer_id_, kServiceFramebufferId);
192 EXPECT_CALL(*gl_, GetError())
193 .WillOnce(Return(GL_NO_ERROR))
194 .RetiresOnSaturation();
195 EXPECT_CALL(*gl_,
196 FramebufferTexture2DEXT(GL_FRAMEBUFFER,
197 GL_COLOR_ATTACHMENT0,
198 GL_TEXTURE_2D,
199 kServiceTextureId,
200 0))
201 .Times(1)
202 .RetiresOnSaturation();
203 EXPECT_CALL(*gl_, GetError())
204 .WillOnce(Return(GL_NO_ERROR))
205 .RetiresOnSaturation();
206 EXPECT_CALL(*gl_, GetError())
207 .WillOnce(Return(GL_NO_ERROR))
208 .WillOnce(Return(GL_NO_ERROR))
209 .RetiresOnSaturation();
210 GetFramebufferAttachmentParameteriv::Result* result =
211 static_cast<GetFramebufferAttachmentParameteriv::Result*>(
212 shared_memory_address_);
213 result->SetNumResults(0);
214 const GLint* result_value = result->GetData();
215 FramebufferTexture2D fbtex_cmd;
216 GetFramebufferAttachmentParameteriv cmd;
217 fbtex_cmd.Init(GL_FRAMEBUFFER,
218 GL_COLOR_ATTACHMENT0,
219 GL_TEXTURE_2D,
220 client_texture_id_);
221 cmd.Init(GL_FRAMEBUFFER,
222 GL_COLOR_ATTACHMENT0,
223 GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME,
224 shared_memory_id_,
225 shared_memory_offset_);
226 EXPECT_EQ(error::kNoError, ExecuteCmd(fbtex_cmd));
227 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
228 EXPECT_EQ(GL_NO_ERROR, GetGLError());
229 EXPECT_EQ(static_cast<GLuint>(*result_value), client_texture_id_);
230 }
231
232 TEST_P(GLES2DecoderWithShaderTest,
233 GetRenderbufferParameterivRebindRenderbuffer) {
234 SetupTexture();
235 DoBindRenderbuffer(
236 GL_RENDERBUFFER, client_renderbuffer_id_, kServiceRenderbufferId);
237 DoRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA4, GL_RGBA, 1, 1, GL_NO_ERROR);
238
239 GetRenderbufferParameteriv cmd;
240 cmd.Init(GL_RENDERBUFFER,
241 GL_RENDERBUFFER_RED_SIZE,
242 shared_memory_id_,
243 shared_memory_offset_);
244
245 RestoreRenderbufferBindings();
246 EnsureRenderbufferBound(true);
247
248 EXPECT_CALL(*gl_, GetError())
249 .WillOnce(Return(GL_NO_ERROR))
250 .WillOnce(Return(GL_NO_ERROR))
251 .RetiresOnSaturation();
252 EXPECT_CALL(*gl_,
253 GetRenderbufferParameterivEXT(
254 GL_RENDERBUFFER, GL_RENDERBUFFER_RED_SIZE, _));
255 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
256 EXPECT_EQ(GL_NO_ERROR, GetGLError());
257 }
258
259 TEST_P(GLES2DecoderTest, GetRenderbufferParameterivWithNoBoundTarget) {
260 EXPECT_CALL(*gl_, GetError())
261 .WillOnce(Return(GL_NO_ERROR))
262 .WillOnce(Return(GL_NO_ERROR))
263 .RetiresOnSaturation();
264 EXPECT_CALL(*gl_, GetRenderbufferParameterivEXT(_, _, _)).Times(0);
265 GetRenderbufferParameteriv cmd;
266 cmd.Init(GL_RENDERBUFFER,
267 GL_RENDERBUFFER_WIDTH,
268 shared_memory_id_,
269 shared_memory_offset_);
270 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
271 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
272 }
273
274 TEST_P(GLES2DecoderWithShaderTest, RenderbufferStorageRebindRenderbuffer) {
275 SetupTexture();
276 DoBindRenderbuffer(
277 GL_RENDERBUFFER, client_renderbuffer_id_, kServiceRenderbufferId);
278 RestoreRenderbufferBindings();
279 EnsureRenderbufferBound(true);
280 DoRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA4, GL_RGBA, 1, 1, GL_NO_ERROR);
281 }
282
283 TEST_P(GLES2DecoderTest, RenderbufferStorageWithNoBoundTarget) {
284 EXPECT_CALL(*gl_, RenderbufferStorageEXT(_, _, _, _)).Times(0);
285 RenderbufferStorage cmd;
286 cmd.Init(GL_RENDERBUFFER, GL_RGBA4, 3, 4);
287 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
288 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
289 }
290
291 namespace {
292
293 // A class to emulate glReadPixels
294 class ReadPixelsEmulator {
295 public:
296 // pack_alignment is the alignment you want ReadPixels to use
297 // when copying. The actual data passed in pixels should be contiguous.
298 ReadPixelsEmulator(GLsizei width,
299 GLsizei height,
300 GLint bytes_per_pixel,
301 const void* src_pixels,
302 const void* expected_pixels,
303 GLint pack_alignment)
304 : width_(width),
305 height_(height),
306 pack_alignment_(pack_alignment),
307 bytes_per_pixel_(bytes_per_pixel),
308 src_pixels_(reinterpret_cast<const int8*>(src_pixels)),
309 expected_pixels_(reinterpret_cast<const int8*>(expected_pixels)) {}
310
311 void ReadPixels(GLint x,
312 GLint y,
313 GLsizei width,
314 GLsizei height,
315 GLenum format,
316 GLenum type,
317 void* pixels) const {
318 DCHECK_GE(x, 0);
319 DCHECK_GE(y, 0);
320 DCHECK_LE(x + width, width_);
321 DCHECK_LE(y + height, height_);
322 for (GLint yy = 0; yy < height; ++yy) {
323 const int8* src = GetPixelAddress(src_pixels_, x, y + yy);
324 const void* dst = ComputePackAlignmentAddress(0, yy, width, pixels);
325 memcpy(const_cast<void*>(dst), src, width * bytes_per_pixel_);
326 }
327 }
328
329 bool CompareRowSegment(GLint x,
330 GLint y,
331 GLsizei width,
332 const void* data) const {
333 DCHECK(x + width <= width_ || width == 0);
334 return memcmp(data,
335 GetPixelAddress(expected_pixels_, x, y),
336 width * bytes_per_pixel_) == 0;
337 }
338
339 // Helper to compute address of pixel in pack aligned data.
340 const void* ComputePackAlignmentAddress(GLint x,
341 GLint y,
342 GLsizei width,
343 const void* address) const {
344 GLint unpadded_row_size = ComputeImageDataSize(width, 1);
345 GLint two_rows_size = ComputeImageDataSize(width, 2);
346 GLsizei padded_row_size = two_rows_size - unpadded_row_size;
347 GLint offset = y * padded_row_size + x * bytes_per_pixel_;
348 return static_cast<const int8*>(address) + offset;
349 }
350
351 GLint ComputeImageDataSize(GLint width, GLint height) const {
352 GLint row_size = width * bytes_per_pixel_;
353 if (height > 1) {
354 GLint temp = row_size + pack_alignment_ - 1;
355 GLint padded_row_size = (temp / pack_alignment_) * pack_alignment_;
356 GLint size_of_all_but_last_row = (height - 1) * padded_row_size;
357 return size_of_all_but_last_row + row_size;
358 } else {
359 return height * row_size;
360 }
361 }
362
363 private:
364 const int8* GetPixelAddress(const int8* base, GLint x, GLint y) const {
365 return base + (width_ * y + x) * bytes_per_pixel_;
366 }
367
368 GLsizei width_;
369 GLsizei height_;
370 GLint pack_alignment_;
371 GLint bytes_per_pixel_;
372 const int8* src_pixels_;
373 const int8* expected_pixels_;
374 };
375
376 } // anonymous namespace
377
378 void GLES2DecoderTest::CheckReadPixelsOutOfRange(GLint in_read_x,
379 GLint in_read_y,
380 GLsizei in_read_width,
381 GLsizei in_read_height,
382 bool init) {
383 const GLsizei kWidth = 5;
384 const GLsizei kHeight = 3;
385 const GLint kBytesPerPixel = 3;
386 const GLint kPackAlignment = 4;
387 const GLenum kFormat = GL_RGB;
388 static const int8 kSrcPixels[kWidth * kHeight * kBytesPerPixel] = {
389 12, 13, 14, 18, 19, 18, 19, 12, 13, 14, 18, 19, 18, 19, 13,
390 29, 28, 23, 22, 21, 22, 21, 29, 28, 23, 22, 21, 22, 21, 28,
391 31, 34, 39, 37, 32, 37, 32, 31, 34, 39, 37, 32, 37, 32, 34,
392 };
393
394 ClearSharedMemory();
395
396 // We need to setup an FBO so we can know the max size that ReadPixels will
397 // access
398 if (init) {
399 DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
400 DoTexImage2D(GL_TEXTURE_2D,
401 0,
402 kFormat,
403 kWidth,
404 kHeight,
405 0,
406 kFormat,
407 GL_UNSIGNED_BYTE,
408 kSharedMemoryId,
409 kSharedMemoryOffset);
410 DoBindFramebuffer(
411 GL_FRAMEBUFFER, client_framebuffer_id_, kServiceFramebufferId);
412 DoFramebufferTexture2D(GL_FRAMEBUFFER,
413 GL_COLOR_ATTACHMENT0,
414 GL_TEXTURE_2D,
415 client_texture_id_,
416 kServiceTextureId,
417 0,
418 GL_NO_ERROR);
419 EXPECT_CALL(*gl_, CheckFramebufferStatusEXT(GL_FRAMEBUFFER))
420 .WillOnce(Return(GL_FRAMEBUFFER_COMPLETE))
421 .RetiresOnSaturation();
422 }
423
424 ReadPixelsEmulator emu(
425 kWidth, kHeight, kBytesPerPixel, kSrcPixels, kSrcPixels, kPackAlignment);
426 typedef ReadPixels::Result Result;
427 Result* result = GetSharedMemoryAs<Result*>();
428 uint32 result_shm_id = kSharedMemoryId;
429 uint32 result_shm_offset = kSharedMemoryOffset;
430 uint32 pixels_shm_id = kSharedMemoryId;
431 uint32 pixels_shm_offset = kSharedMemoryOffset + sizeof(*result);
432 void* dest = &result[1];
433 EXPECT_CALL(*gl_, GetError())
434 .WillOnce(Return(GL_NO_ERROR))
435 .WillOnce(Return(GL_NO_ERROR))
436 .RetiresOnSaturation();
437 // ReadPixels will be called for valid size only even though the command
438 // is requesting a larger size.
439 GLint read_x = std::max(0, in_read_x);
440 GLint read_y = std::max(0, in_read_y);
441 GLint read_end_x = std::max(0, std::min(kWidth, in_read_x + in_read_width));
442 GLint read_end_y = std::max(0, std::min(kHeight, in_read_y + in_read_height));
443 GLint read_width = read_end_x - read_x;
444 GLint read_height = read_end_y - read_y;
445 if (read_width > 0 && read_height > 0) {
446 for (GLint yy = read_y; yy < read_end_y; ++yy) {
447 EXPECT_CALL(
448 *gl_,
449 ReadPixels(read_x, yy, read_width, 1, kFormat, GL_UNSIGNED_BYTE, _))
450 .WillOnce(Invoke(&emu, &ReadPixelsEmulator::ReadPixels))
451 .RetiresOnSaturation();
452 }
453 }
454 ReadPixels cmd;
455 cmd.Init(in_read_x,
456 in_read_y,
457 in_read_width,
458 in_read_height,
459 kFormat,
460 GL_UNSIGNED_BYTE,
461 pixels_shm_id,
462 pixels_shm_offset,
463 result_shm_id,
464 result_shm_offset,
465 false);
466 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
467
468 GLint unpadded_row_size = emu.ComputeImageDataSize(in_read_width, 1);
469 scoped_ptr<int8[]> zero(new int8[unpadded_row_size]);
470 scoped_ptr<int8[]> pack(new int8[kPackAlignment]);
471 memset(zero.get(), 0, unpadded_row_size);
472 memset(pack.get(), kInitialMemoryValue, kPackAlignment);
473 for (GLint yy = 0; yy < in_read_height; ++yy) {
474 const int8* row = static_cast<const int8*>(
475 emu.ComputePackAlignmentAddress(0, yy, in_read_width, dest));
476 GLint y = in_read_y + yy;
477 if (y < 0 || y >= kHeight) {
478 EXPECT_EQ(0, memcmp(zero.get(), row, unpadded_row_size));
479 } else {
480 // check off left.
481 GLint num_left_pixels = std::max(-in_read_x, 0);
482 GLint num_left_bytes = num_left_pixels * kBytesPerPixel;
483 EXPECT_EQ(0, memcmp(zero.get(), row, num_left_bytes));
484
485 // check off right.
486 GLint num_right_pixels = std::max(in_read_x + in_read_width - kWidth, 0);
487 GLint num_right_bytes = num_right_pixels * kBytesPerPixel;
488 EXPECT_EQ(0,
489 memcmp(zero.get(),
490 row + unpadded_row_size - num_right_bytes,
491 num_right_bytes));
492
493 // check middle.
494 GLint x = std::max(in_read_x, 0);
495 GLint num_middle_pixels =
496 std::max(in_read_width - num_left_pixels - num_right_pixels, 0);
497 EXPECT_TRUE(
498 emu.CompareRowSegment(x, y, num_middle_pixels, row + num_left_bytes));
499 }
500
501 // check padding
502 if (yy != in_read_height - 1) {
503 GLint num_padding_bytes =
504 (kPackAlignment - 1) - (unpadded_row_size % kPackAlignment);
505 EXPECT_EQ(0,
506 memcmp(pack.get(), row + unpadded_row_size, num_padding_bytes));
507 }
508 }
509 }
510
511 TEST_P(GLES2DecoderTest, ReadPixels) {
512 const GLsizei kWidth = 5;
513 const GLsizei kHeight = 3;
514 const GLint kBytesPerPixel = 3;
515 const GLint kPackAlignment = 4;
516 static const int8 kSrcPixels[kWidth * kHeight * kBytesPerPixel] = {
517 12, 13, 14, 18, 19, 18, 19, 12, 13, 14, 18, 19, 18, 19, 13,
518 29, 28, 23, 22, 21, 22, 21, 29, 28, 23, 22, 21, 22, 21, 28,
519 31, 34, 39, 37, 32, 37, 32, 31, 34, 39, 37, 32, 37, 32, 34,
520 };
521
522 surface_->SetSize(gfx::Size(INT_MAX, INT_MAX));
523
524 ReadPixelsEmulator emu(
525 kWidth, kHeight, kBytesPerPixel, kSrcPixels, kSrcPixels, kPackAlignment);
526 typedef ReadPixels::Result Result;
527 Result* result = GetSharedMemoryAs<Result*>();
528 uint32 result_shm_id = kSharedMemoryId;
529 uint32 result_shm_offset = kSharedMemoryOffset;
530 uint32 pixels_shm_id = kSharedMemoryId;
531 uint32 pixels_shm_offset = kSharedMemoryOffset + sizeof(*result);
532 void* dest = &result[1];
533 EXPECT_CALL(*gl_, GetError())
534 .WillOnce(Return(GL_NO_ERROR))
535 .WillOnce(Return(GL_NO_ERROR))
536 .RetiresOnSaturation();
537 EXPECT_CALL(*gl_,
538 ReadPixels(0, 0, kWidth, kHeight, GL_RGB, GL_UNSIGNED_BYTE, _))
539 .WillOnce(Invoke(&emu, &ReadPixelsEmulator::ReadPixels));
540 ReadPixels cmd;
541 cmd.Init(0,
542 0,
543 kWidth,
544 kHeight,
545 GL_RGB,
546 GL_UNSIGNED_BYTE,
547 pixels_shm_id,
548 pixels_shm_offset,
549 result_shm_id,
550 result_shm_offset,
551 false);
552 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
553 for (GLint yy = 0; yy < kHeight; ++yy) {
554 EXPECT_TRUE(emu.CompareRowSegment(
555 0, yy, kWidth, emu.ComputePackAlignmentAddress(0, yy, kWidth, dest)));
556 }
557 }
558
559 TEST_P(GLES2DecoderRGBBackbufferTest, ReadPixelsNoAlphaBackbuffer) {
560 const GLsizei kWidth = 3;
561 const GLsizei kHeight = 3;
562 const GLint kBytesPerPixel = 4;
563 const GLint kPackAlignment = 4;
564 static const uint8 kExpectedPixels[kWidth * kHeight * kBytesPerPixel] = {
565 12, 13, 14, 255, 19, 18, 19, 255, 13, 14, 18, 255,
566 29, 28, 23, 255, 21, 22, 21, 255, 28, 23, 22, 255,
567 31, 34, 39, 255, 32, 37, 32, 255, 34, 39, 37, 255,
568 };
569 static const uint8 kSrcPixels[kWidth * kHeight * kBytesPerPixel] = {
570 12, 13, 14, 18, 19, 18, 19, 12, 13, 14, 18, 19, 29, 28, 23, 22, 21, 22,
571 21, 29, 28, 23, 22, 21, 31, 34, 39, 37, 32, 37, 32, 31, 34, 39, 37, 32,
572 };
573
574 surface_->SetSize(gfx::Size(INT_MAX, INT_MAX));
575
576 ReadPixelsEmulator emu(kWidth,
577 kHeight,
578 kBytesPerPixel,
579 kSrcPixels,
580 kExpectedPixels,
581 kPackAlignment);
582 typedef ReadPixels::Result Result;
583 Result* result = GetSharedMemoryAs<Result*>();
584 uint32 result_shm_id = kSharedMemoryId;
585 uint32 result_shm_offset = kSharedMemoryOffset;
586 uint32 pixels_shm_id = kSharedMemoryId;
587 uint32 pixels_shm_offset = kSharedMemoryOffset + sizeof(*result);
588 void* dest = &result[1];
589 EXPECT_CALL(*gl_, GetError())
590 .WillOnce(Return(GL_NO_ERROR))
591 .WillOnce(Return(GL_NO_ERROR))
592 .RetiresOnSaturation();
593 EXPECT_CALL(*gl_,
594 ReadPixels(0, 0, kWidth, kHeight, GL_RGBA, GL_UNSIGNED_BYTE, _))
595 .WillOnce(Invoke(&emu, &ReadPixelsEmulator::ReadPixels));
596 ReadPixels cmd;
597 cmd.Init(0,
598 0,
599 kWidth,
600 kHeight,
601 GL_RGBA,
602 GL_UNSIGNED_BYTE,
603 pixels_shm_id,
604 pixels_shm_offset,
605 result_shm_id,
606 result_shm_offset,
607 false);
608 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
609 for (GLint yy = 0; yy < kHeight; ++yy) {
610 EXPECT_TRUE(emu.CompareRowSegment(
611 0, yy, kWidth, emu.ComputePackAlignmentAddress(0, yy, kWidth, dest)));
612 }
613 }
614
615 TEST_P(GLES2DecoderTest, ReadPixelsOutOfRange) {
616 static GLint tests[][4] = {
617 {
618 -2, -1, 9, 5,
619 }, // out of range on all sides
620 {
621 2, 1, 9, 5,
622 }, // out of range on right, bottom
623 {
624 -7, -4, 9, 5,
625 }, // out of range on left, top
626 {
627 0, -5, 9, 5,
628 }, // completely off top
629 {
630 0, 3, 9, 5,
631 }, // completely off bottom
632 {
633 -9, 0, 9, 5,
634 }, // completely off left
635 {
636 5, 0, 9, 5,
637 }, // completely off right
638 };
639
640 for (size_t tt = 0; tt < arraysize(tests); ++tt) {
641 CheckReadPixelsOutOfRange(
642 tests[tt][0], tests[tt][1], tests[tt][2], tests[tt][3], tt == 0);
643 }
644 }
645
646 TEST_P(GLES2DecoderTest, ReadPixelsInvalidArgs) {
647 typedef ReadPixels::Result Result;
648 Result* result = GetSharedMemoryAs<Result*>();
649 uint32 result_shm_id = kSharedMemoryId;
650 uint32 result_shm_offset = kSharedMemoryOffset;
651 uint32 pixels_shm_id = kSharedMemoryId;
652 uint32 pixels_shm_offset = kSharedMemoryOffset + sizeof(*result);
653 EXPECT_CALL(*gl_, ReadPixels(_, _, _, _, _, _, _)).Times(0);
654 ReadPixels cmd;
655 cmd.Init(0,
656 0,
657 -1,
658 1,
659 GL_RGB,
660 GL_UNSIGNED_BYTE,
661 pixels_shm_id,
662 pixels_shm_offset,
663 result_shm_id,
664 result_shm_offset,
665 false);
666 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
667 EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
668 cmd.Init(0,
669 0,
670 1,
671 -1,
672 GL_RGB,
673 GL_UNSIGNED_BYTE,
674 pixels_shm_id,
675 pixels_shm_offset,
676 result_shm_id,
677 result_shm_offset,
678 false);
679 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
680 EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
681 cmd.Init(0,
682 0,
683 1,
684 1,
685 GL_RGB,
686 GL_INT,
687 pixels_shm_id,
688 pixels_shm_offset,
689 result_shm_id,
690 result_shm_offset,
691 false);
692 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
693 EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
694 cmd.Init(0,
695 0,
696 1,
697 1,
698 GL_RGB,
699 GL_UNSIGNED_BYTE,
700 kInvalidSharedMemoryId,
701 pixels_shm_offset,
702 result_shm_id,
703 result_shm_offset,
704 false);
705 EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
706 cmd.Init(0,
707 0,
708 1,
709 1,
710 GL_RGB,
711 GL_UNSIGNED_BYTE,
712 pixels_shm_id,
713 kInvalidSharedMemoryOffset,
714 result_shm_id,
715 result_shm_offset,
716 false);
717 EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
718 cmd.Init(0,
719 0,
720 1,
721 1,
722 GL_RGB,
723 GL_UNSIGNED_BYTE,
724 pixels_shm_id,
725 pixels_shm_offset,
726 kInvalidSharedMemoryId,
727 result_shm_offset,
728 false);
729 EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
730 cmd.Init(0,
731 0,
732 1,
733 1,
734 GL_RGB,
735 GL_UNSIGNED_BYTE,
736 pixels_shm_id,
737 pixels_shm_offset,
738 result_shm_id,
739 kInvalidSharedMemoryOffset,
740 false);
741 EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
742 }
743
744 TEST_P(GLES2DecoderManualInitTest, ReadPixelsAsyncError) {
745 InitState init;
746 init.extensions = "GL_ARB_sync";
747 init.gl_version = "opengl es 3.0";
748 init.has_alpha = true;
749 init.request_alpha = true;
750 init.bind_generates_resource = true;
751 InitDecoder(init);
752
753 typedef ReadPixels::Result Result;
754 Result* result = GetSharedMemoryAs<Result*>();
755
756 const GLsizei kWidth = 4;
757 const GLsizei kHeight = 4;
758 uint32 result_shm_id = kSharedMemoryId;
759 uint32 result_shm_offset = kSharedMemoryOffset;
760 uint32 pixels_shm_id = kSharedMemoryId;
761 uint32 pixels_shm_offset = kSharedMemoryOffset + sizeof(*result);
762
763 EXPECT_CALL(*gl_, GetError())
764 // first error check must pass to get to the test
765 .WillOnce(Return(GL_NO_ERROR))
766 // second check is after BufferData, simulate fail here
767 .WillOnce(Return(GL_INVALID_OPERATION))
768 // third error check is fall-through call to sync ReadPixels
769 .WillOnce(Return(GL_NO_ERROR))
770 .RetiresOnSaturation();
771
772 EXPECT_CALL(*gl_,
773 ReadPixels(0, 0, kWidth, kHeight, GL_RGB, GL_UNSIGNED_BYTE, _))
774 .Times(1);
775 EXPECT_CALL(*gl_, GenBuffersARB(1, _)).Times(1);
776 EXPECT_CALL(*gl_, BindBuffer(GL_PIXEL_PACK_BUFFER_ARB, _)).Times(2);
777 EXPECT_CALL(*gl_,
778 BufferData(GL_PIXEL_PACK_BUFFER_ARB, _, NULL, GL_STREAM_READ))
779 .Times(1);
780
781 ReadPixels cmd;
782 cmd.Init(0,
783 0,
784 kWidth,
785 kHeight,
786 GL_RGB,
787 GL_UNSIGNED_BYTE,
788 pixels_shm_id,
789 pixels_shm_offset,
790 result_shm_id,
791 result_shm_offset,
792 true);
793 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
794 }
795
796 // Check that if a renderbuffer is attached and GL returns
797 // GL_FRAMEBUFFER_COMPLETE that the buffer is cleared and state is restored.
798 TEST_P(GLES2DecoderTest, FramebufferRenderbufferClearColor) {
799 DoBindFramebuffer(
800 GL_FRAMEBUFFER, client_framebuffer_id_, kServiceFramebufferId);
801 ClearColor color_cmd;
802 ColorMask color_mask_cmd;
803 Enable enable_cmd;
804 FramebufferRenderbuffer cmd;
805 color_cmd.Init(0.1f, 0.2f, 0.3f, 0.4f);
806 color_mask_cmd.Init(0, 1, 0, 1);
807 enable_cmd.Init(GL_SCISSOR_TEST);
808 cmd.Init(GL_FRAMEBUFFER,
809 GL_COLOR_ATTACHMENT0,
810 GL_RENDERBUFFER,
811 client_renderbuffer_id_);
812 InSequence sequence;
813 EXPECT_CALL(*gl_, ClearColor(0.1f, 0.2f, 0.3f, 0.4f))
814 .Times(1)
815 .RetiresOnSaturation();
816 SetupExpectationsForEnableDisable(GL_SCISSOR_TEST, true);
817 EXPECT_CALL(*gl_, GetError())
818 .WillOnce(Return(GL_NO_ERROR))
819 .RetiresOnSaturation();
820 EXPECT_CALL(*gl_,
821 FramebufferRenderbufferEXT(GL_FRAMEBUFFER,
822 GL_COLOR_ATTACHMENT0,
823 GL_RENDERBUFFER,
824 kServiceRenderbufferId))
825 .Times(1)
826 .RetiresOnSaturation();
827 EXPECT_CALL(*gl_, GetError())
828 .WillOnce(Return(GL_NO_ERROR))
829 .RetiresOnSaturation();
830 EXPECT_EQ(error::kNoError, ExecuteCmd(color_cmd));
831 EXPECT_EQ(error::kNoError, ExecuteCmd(color_mask_cmd));
832 EXPECT_EQ(error::kNoError, ExecuteCmd(enable_cmd));
833 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
834 }
835
836 TEST_P(GLES2DecoderTest, FramebufferRenderbufferClearDepth) {
837 DoBindFramebuffer(
838 GL_FRAMEBUFFER, client_framebuffer_id_, kServiceFramebufferId);
839 ClearDepthf depth_cmd;
840 DepthMask depth_mask_cmd;
841 FramebufferRenderbuffer cmd;
842 depth_cmd.Init(0.5f);
843 depth_mask_cmd.Init(false);
844 cmd.Init(GL_FRAMEBUFFER,
845 GL_DEPTH_ATTACHMENT,
846 GL_RENDERBUFFER,
847 client_renderbuffer_id_);
848 InSequence sequence;
849 EXPECT_CALL(*gl_, ClearDepth(0.5f)).Times(1).RetiresOnSaturation();
850 EXPECT_CALL(*gl_, GetError())
851 .WillOnce(Return(GL_NO_ERROR))
852 .RetiresOnSaturation();
853 EXPECT_CALL(*gl_,
854 FramebufferRenderbufferEXT(GL_FRAMEBUFFER,
855 GL_DEPTH_ATTACHMENT,
856 GL_RENDERBUFFER,
857 kServiceRenderbufferId))
858 .Times(1)
859 .RetiresOnSaturation();
860 EXPECT_CALL(*gl_, GetError())
861 .WillOnce(Return(GL_NO_ERROR))
862 .RetiresOnSaturation();
863 EXPECT_EQ(error::kNoError, ExecuteCmd(depth_cmd));
864 EXPECT_EQ(error::kNoError, ExecuteCmd(depth_mask_cmd));
865 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
866 }
867
868 TEST_P(GLES2DecoderTest, FramebufferRenderbufferClearStencil) {
869 DoBindFramebuffer(
870 GL_FRAMEBUFFER, client_framebuffer_id_, kServiceFramebufferId);
871 ClearStencil stencil_cmd;
872 StencilMaskSeparate stencil_mask_separate_cmd;
873 FramebufferRenderbuffer cmd;
874 stencil_cmd.Init(123);
875 stencil_mask_separate_cmd.Init(GL_BACK, 0x1234u);
876 cmd.Init(GL_FRAMEBUFFER,
877 GL_STENCIL_ATTACHMENT,
878 GL_RENDERBUFFER,
879 client_renderbuffer_id_);
880 InSequence sequence;
881 EXPECT_CALL(*gl_, ClearStencil(123)).Times(1).RetiresOnSaturation();
882 EXPECT_CALL(*gl_, GetError())
883 .WillOnce(Return(GL_NO_ERROR))
884 .RetiresOnSaturation();
885 EXPECT_CALL(*gl_,
886 FramebufferRenderbufferEXT(GL_FRAMEBUFFER,
887 GL_STENCIL_ATTACHMENT,
888 GL_RENDERBUFFER,
889 kServiceRenderbufferId))
890 .Times(1)
891 .RetiresOnSaturation();
892 EXPECT_CALL(*gl_, GetError())
893 .WillOnce(Return(GL_NO_ERROR))
894 .RetiresOnSaturation();
895 EXPECT_EQ(error::kNoError, ExecuteCmd(stencil_cmd));
896 EXPECT_EQ(error::kNoError, ExecuteCmd(stencil_mask_separate_cmd));
897 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
898 }
899
900 #if 0 // Turn this test on once we allow GL_DEPTH_STENCIL_ATTACHMENT
901 TEST_P(GLES2DecoderTest, FramebufferRenderbufferClearDepthStencil) {
902 DoBindFramebuffer(GL_FRAMEBUFFER, client_framebuffer_id_,
903 kServiceFramebufferId);
904 ClearDepthf depth_cmd;
905 ClearStencil stencil_cmd;
906 FramebufferRenderbuffer cmd;
907 depth_cmd.Init(0.5f);
908 stencil_cmd.Init(123);
909 cmd.Init(
910 GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER,
911 client_renderbuffer_id_);
912 InSequence sequence;
913 EXPECT_CALL(*gl_, ClearDepth(0.5f))
914 .Times(1)
915 .RetiresOnSaturation();
916 EXPECT_CALL(*gl_, ClearStencil(123))
917 .Times(1)
918 .RetiresOnSaturation();
919 EXPECT_CALL(*gl_, FramebufferRenderbufferEXT(
920 GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER,
921 kServiceRenderbufferId))
922 .Times(1)
923 .RetiresOnSaturation();
924 EXPECT_EQ(error::kNoError, ExecuteCmd(depth_cmd));
925 EXPECT_EQ(error::kNoError, ExecuteCmd(stencil_cmd));
926 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
927 }
928 #endif
929
930 TEST_P(GLES2DecoderManualInitTest, ActualAlphaMatchesRequestedAlpha) {
931 InitState init;
932 init.gl_version = "3.0";
933 init.has_alpha = true;
934 init.request_alpha = true;
935 init.bind_generates_resource = true;
936 InitDecoder(init);
937
938 EXPECT_CALL(*gl_, GetError())
939 .WillOnce(Return(GL_NO_ERROR))
940 .WillOnce(Return(GL_NO_ERROR))
941 .RetiresOnSaturation();
942 typedef GetIntegerv::Result Result;
943 Result* result = static_cast<Result*>(shared_memory_address_);
944 EXPECT_CALL(*gl_, GetIntegerv(GL_ALPHA_BITS, _))
945 .WillOnce(SetArgumentPointee<1>(8))
946 .RetiresOnSaturation();
947 result->size = 0;
948 GetIntegerv cmd2;
949 cmd2.Init(GL_ALPHA_BITS, shared_memory_id_, shared_memory_offset_);
950 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
951 EXPECT_EQ(decoder_->GetGLES2Util()->GLGetNumValuesReturned(GL_ALPHA_BITS),
952 result->GetNumResults());
953 EXPECT_EQ(GL_NO_ERROR, GetGLError());
954 EXPECT_EQ(8, result->GetData()[0]);
955 }
956
957 TEST_P(GLES2DecoderManualInitTest, ActualAlphaDoesNotMatchRequestedAlpha) {
958 InitState init;
959 init.gl_version = "3.0";
960 init.has_alpha = true;
961 init.bind_generates_resource = true;
962 InitDecoder(init);
963
964 EXPECT_CALL(*gl_, GetError())
965 .WillOnce(Return(GL_NO_ERROR))
966 .WillOnce(Return(GL_NO_ERROR))
967 .RetiresOnSaturation();
968 typedef GetIntegerv::Result Result;
969 Result* result = static_cast<Result*>(shared_memory_address_);
970 EXPECT_CALL(*gl_, GetIntegerv(GL_ALPHA_BITS, _))
971 .WillOnce(SetArgumentPointee<1>(8))
972 .RetiresOnSaturation();
973 result->size = 0;
974 GetIntegerv cmd2;
975 cmd2.Init(GL_ALPHA_BITS, shared_memory_id_, shared_memory_offset_);
976 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
977 EXPECT_EQ(decoder_->GetGLES2Util()->GLGetNumValuesReturned(GL_ALPHA_BITS),
978 result->GetNumResults());
979 EXPECT_EQ(GL_NO_ERROR, GetGLError());
980 EXPECT_EQ(0, result->GetData()[0]);
981 }
982
983 TEST_P(GLES2DecoderManualInitTest, ActualDepthMatchesRequestedDepth) {
984 InitState init;
985 init.gl_version = "3.0";
986 init.has_depth = true;
987 init.request_depth = true;
988 init.bind_generates_resource = true;
989 InitDecoder(init);
990
991 EXPECT_CALL(*gl_, GetError())
992 .WillOnce(Return(GL_NO_ERROR))
993 .WillOnce(Return(GL_NO_ERROR))
994 .RetiresOnSaturation();
995 typedef GetIntegerv::Result Result;
996 Result* result = static_cast<Result*>(shared_memory_address_);
997 EXPECT_CALL(*gl_, GetIntegerv(GL_DEPTH_BITS, _))
998 .WillOnce(SetArgumentPointee<1>(24))
999 .RetiresOnSaturation();
1000 result->size = 0;
1001 GetIntegerv cmd2;
1002 cmd2.Init(GL_DEPTH_BITS, shared_memory_id_, shared_memory_offset_);
1003 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
1004 EXPECT_EQ(decoder_->GetGLES2Util()->GLGetNumValuesReturned(GL_DEPTH_BITS),
1005 result->GetNumResults());
1006 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1007 EXPECT_EQ(24, result->GetData()[0]);
1008 }
1009
1010 TEST_P(GLES2DecoderManualInitTest, ActualDepthDoesNotMatchRequestedDepth) {
1011 InitState init;
1012 init.gl_version = "3.0";
1013 init.has_depth = true;
1014 init.bind_generates_resource = true;
1015 InitDecoder(init);
1016
1017 EXPECT_CALL(*gl_, GetError())
1018 .WillOnce(Return(GL_NO_ERROR))
1019 .WillOnce(Return(GL_NO_ERROR))
1020 .RetiresOnSaturation();
1021 typedef GetIntegerv::Result Result;
1022 Result* result = static_cast<Result*>(shared_memory_address_);
1023 EXPECT_CALL(*gl_, GetIntegerv(GL_DEPTH_BITS, _))
1024 .WillOnce(SetArgumentPointee<1>(24))
1025 .RetiresOnSaturation();
1026 result->size = 0;
1027 GetIntegerv cmd2;
1028 cmd2.Init(GL_DEPTH_BITS, shared_memory_id_, shared_memory_offset_);
1029 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
1030 EXPECT_EQ(decoder_->GetGLES2Util()->GLGetNumValuesReturned(GL_DEPTH_BITS),
1031 result->GetNumResults());
1032 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1033 EXPECT_EQ(0, result->GetData()[0]);
1034 }
1035
1036 TEST_P(GLES2DecoderManualInitTest, ActualStencilMatchesRequestedStencil) {
1037 InitState init;
1038 init.gl_version = "3.0";
1039 init.has_stencil = true;
1040 init.request_stencil = true;
1041 init.bind_generates_resource = true;
1042 InitDecoder(init);
1043
1044 EXPECT_CALL(*gl_, GetError())
1045 .WillOnce(Return(GL_NO_ERROR))
1046 .WillOnce(Return(GL_NO_ERROR))
1047 .RetiresOnSaturation();
1048 typedef GetIntegerv::Result Result;
1049 Result* result = static_cast<Result*>(shared_memory_address_);
1050 EXPECT_CALL(*gl_, GetIntegerv(GL_STENCIL_BITS, _))
1051 .WillOnce(SetArgumentPointee<1>(8))
1052 .RetiresOnSaturation();
1053 result->size = 0;
1054 GetIntegerv cmd2;
1055 cmd2.Init(GL_STENCIL_BITS, shared_memory_id_, shared_memory_offset_);
1056 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
1057 EXPECT_EQ(decoder_->GetGLES2Util()->GLGetNumValuesReturned(GL_STENCIL_BITS),
1058 result->GetNumResults());
1059 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1060 EXPECT_EQ(8, result->GetData()[0]);
1061 }
1062
1063 TEST_P(GLES2DecoderManualInitTest, ActualStencilDoesNotMatchRequestedStencil) {
1064 InitState init;
1065 init.gl_version = "3.0";
1066 init.has_stencil = true;
1067 init.bind_generates_resource = true;
1068 InitDecoder(init);
1069
1070 EXPECT_CALL(*gl_, GetError())
1071 .WillOnce(Return(GL_NO_ERROR))
1072 .WillOnce(Return(GL_NO_ERROR))
1073 .RetiresOnSaturation();
1074 typedef GetIntegerv::Result Result;
1075 Result* result = static_cast<Result*>(shared_memory_address_);
1076 EXPECT_CALL(*gl_, GetIntegerv(GL_STENCIL_BITS, _))
1077 .WillOnce(SetArgumentPointee<1>(8))
1078 .RetiresOnSaturation();
1079 result->size = 0;
1080 GetIntegerv cmd2;
1081 cmd2.Init(GL_STENCIL_BITS, shared_memory_id_, shared_memory_offset_);
1082 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
1083 EXPECT_EQ(decoder_->GetGLES2Util()->GLGetNumValuesReturned(GL_STENCIL_BITS),
1084 result->GetNumResults());
1085 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1086 EXPECT_EQ(0, result->GetData()[0]);
1087 }
1088
1089 TEST_P(GLES2DecoderManualInitTest, PackedDepthStencilReportsCorrectValues) {
1090 InitState init;
1091 init.extensions = "GL_OES_packed_depth_stencil";
1092 init.gl_version = "opengl es 2.0";
1093 init.has_depth = true;
1094 init.has_stencil = true;
1095 init.request_depth = true;
1096 init.request_stencil = true;
1097 init.bind_generates_resource = true;
1098 InitDecoder(init);
1099
1100 EXPECT_CALL(*gl_, GetError())
1101 .WillOnce(Return(GL_NO_ERROR))
1102 .WillOnce(Return(GL_NO_ERROR))
1103 .WillOnce(Return(GL_NO_ERROR))
1104 .WillOnce(Return(GL_NO_ERROR))
1105 .RetiresOnSaturation();
1106 typedef GetIntegerv::Result Result;
1107 Result* result = static_cast<Result*>(shared_memory_address_);
1108 result->size = 0;
1109 GetIntegerv cmd2;
1110 cmd2.Init(GL_STENCIL_BITS, shared_memory_id_, shared_memory_offset_);
1111 EXPECT_CALL(*gl_, GetIntegerv(GL_STENCIL_BITS, _))
1112 .WillOnce(SetArgumentPointee<1>(8))
1113 .RetiresOnSaturation();
1114 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
1115 EXPECT_EQ(decoder_->GetGLES2Util()->GLGetNumValuesReturned(GL_STENCIL_BITS),
1116 result->GetNumResults());
1117 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1118 EXPECT_EQ(8, result->GetData()[0]);
1119 result->size = 0;
1120 cmd2.Init(GL_DEPTH_BITS, shared_memory_id_, shared_memory_offset_);
1121 EXPECT_CALL(*gl_, GetIntegerv(GL_DEPTH_BITS, _))
1122 .WillOnce(SetArgumentPointee<1>(24))
1123 .RetiresOnSaturation();
1124 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
1125 EXPECT_EQ(decoder_->GetGLES2Util()->GLGetNumValuesReturned(GL_DEPTH_BITS),
1126 result->GetNumResults());
1127 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1128 EXPECT_EQ(24, result->GetData()[0]);
1129 }
1130
1131 TEST_P(GLES2DecoderManualInitTest, PackedDepthStencilNoRequestedStencil) {
1132 InitState init;
1133 init.extensions = "GL_OES_packed_depth_stencil";
1134 init.gl_version = "opengl es 2.0";
1135 init.has_depth = true;
1136 init.has_stencil = true;
1137 init.request_depth = true;
1138 init.bind_generates_resource = true;
1139 InitDecoder(init);
1140
1141 EXPECT_CALL(*gl_, GetError())
1142 .WillOnce(Return(GL_NO_ERROR))
1143 .WillOnce(Return(GL_NO_ERROR))
1144 .WillOnce(Return(GL_NO_ERROR))
1145 .WillOnce(Return(GL_NO_ERROR))
1146 .RetiresOnSaturation();
1147 typedef GetIntegerv::Result Result;
1148 Result* result = static_cast<Result*>(shared_memory_address_);
1149 result->size = 0;
1150 GetIntegerv cmd2;
1151 cmd2.Init(GL_STENCIL_BITS, shared_memory_id_, shared_memory_offset_);
1152 EXPECT_CALL(*gl_, GetIntegerv(GL_STENCIL_BITS, _))
1153 .WillOnce(SetArgumentPointee<1>(8))
1154 .RetiresOnSaturation();
1155 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
1156 EXPECT_EQ(decoder_->GetGLES2Util()->GLGetNumValuesReturned(GL_STENCIL_BITS),
1157 result->GetNumResults());
1158 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1159 EXPECT_EQ(0, result->GetData()[0]);
1160 result->size = 0;
1161 cmd2.Init(GL_DEPTH_BITS, shared_memory_id_, shared_memory_offset_);
1162 EXPECT_CALL(*gl_, GetIntegerv(GL_DEPTH_BITS, _))
1163 .WillOnce(SetArgumentPointee<1>(24))
1164 .RetiresOnSaturation();
1165 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
1166 EXPECT_EQ(decoder_->GetGLES2Util()->GLGetNumValuesReturned(GL_DEPTH_BITS),
1167 result->GetNumResults());
1168 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1169 EXPECT_EQ(24, result->GetData()[0]);
1170 }
1171
1172 TEST_P(GLES2DecoderManualInitTest, PackedDepthStencilRenderbufferDepth) {
1173 InitState init;
1174 init.extensions = "GL_OES_packed_depth_stencil";
1175 init.gl_version = "opengl es 2.0";
1176 init.bind_generates_resource = true;
1177 InitDecoder(init);
1178 DoBindRenderbuffer(
1179 GL_RENDERBUFFER, client_renderbuffer_id_, kServiceRenderbufferId);
1180 DoBindFramebuffer(
1181 GL_FRAMEBUFFER, client_framebuffer_id_, kServiceFramebufferId);
1182
1183 EnsureRenderbufferBound(false);
1184 EXPECT_CALL(*gl_, GetError())
1185 .WillOnce(Return(GL_NO_ERROR)) // for RenderbufferStoage
1186 .WillOnce(Return(GL_NO_ERROR))
1187 .WillOnce(Return(GL_NO_ERROR)) // for FramebufferRenderbuffer
1188 .WillOnce(Return(GL_NO_ERROR))
1189 .WillOnce(Return(GL_NO_ERROR)) // for GetIntegerv
1190 .WillOnce(Return(GL_NO_ERROR))
1191 .WillOnce(Return(GL_NO_ERROR)) // for GetIntegerv
1192 .WillOnce(Return(GL_NO_ERROR))
1193 .RetiresOnSaturation();
1194
1195 EXPECT_CALL(
1196 *gl_,
1197 RenderbufferStorageEXT(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, 100, 50))
1198 .Times(1)
1199 .RetiresOnSaturation();
1200 RenderbufferStorage cmd;
1201 cmd.Init(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, 100, 50);
1202 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1203 EXPECT_CALL(*gl_,
1204 FramebufferRenderbufferEXT(GL_FRAMEBUFFER,
1205 GL_DEPTH_ATTACHMENT,
1206 GL_RENDERBUFFER,
1207 kServiceRenderbufferId))
1208 .Times(1)
1209 .RetiresOnSaturation();
1210 FramebufferRenderbuffer fbrb_cmd;
1211 fbrb_cmd.Init(GL_FRAMEBUFFER,
1212 GL_DEPTH_ATTACHMENT,
1213 GL_RENDERBUFFER,
1214 client_renderbuffer_id_);
1215 EXPECT_EQ(error::kNoError, ExecuteCmd(fbrb_cmd));
1216
1217 typedef GetIntegerv::Result Result;
1218 Result* result = static_cast<Result*>(shared_memory_address_);
1219 result->size = 0;
1220 GetIntegerv cmd2;
1221 cmd2.Init(GL_STENCIL_BITS, shared_memory_id_, shared_memory_offset_);
1222 EXPECT_CALL(*gl_, GetIntegerv(GL_STENCIL_BITS, _))
1223 .WillOnce(SetArgumentPointee<1>(8))
1224 .RetiresOnSaturation();
1225 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
1226 EXPECT_EQ(decoder_->GetGLES2Util()->GLGetNumValuesReturned(GL_STENCIL_BITS),
1227 result->GetNumResults());
1228 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1229 EXPECT_EQ(0, result->GetData()[0]);
1230 result->size = 0;
1231 cmd2.Init(GL_DEPTH_BITS, shared_memory_id_, shared_memory_offset_);
1232 EXPECT_CALL(*gl_, GetIntegerv(GL_DEPTH_BITS, _))
1233 .WillOnce(SetArgumentPointee<1>(24))
1234 .RetiresOnSaturation();
1235 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
1236 EXPECT_EQ(decoder_->GetGLES2Util()->GLGetNumValuesReturned(GL_DEPTH_BITS),
1237 result->GetNumResults());
1238 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1239 EXPECT_EQ(24, result->GetData()[0]);
1240 }
1241
1242 TEST_P(GLES2DecoderManualInitTest, PackedDepthStencilRenderbufferStencil) {
1243 InitState init;
1244 init.extensions = "GL_OES_packed_depth_stencil";
1245 init.gl_version = "opengl es 2.0";
1246 init.bind_generates_resource = true;
1247 InitDecoder(init);
1248 DoBindRenderbuffer(
1249 GL_RENDERBUFFER, client_renderbuffer_id_, kServiceRenderbufferId);
1250 DoBindFramebuffer(
1251 GL_FRAMEBUFFER, client_framebuffer_id_, kServiceFramebufferId);
1252
1253 EnsureRenderbufferBound(false);
1254 EXPECT_CALL(*gl_, GetError())
1255 .WillOnce(Return(GL_NO_ERROR)) // for RenderbufferStoage
1256 .WillOnce(Return(GL_NO_ERROR))
1257 .WillOnce(Return(GL_NO_ERROR)) // for FramebufferRenderbuffer
1258 .WillOnce(Return(GL_NO_ERROR))
1259 .WillOnce(Return(GL_NO_ERROR)) // for GetIntegerv
1260 .WillOnce(Return(GL_NO_ERROR))
1261 .WillOnce(Return(GL_NO_ERROR)) // for GetIntegerv
1262 .WillOnce(Return(GL_NO_ERROR))
1263 .RetiresOnSaturation();
1264
1265 EXPECT_CALL(
1266 *gl_,
1267 RenderbufferStorageEXT(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, 100, 50))
1268 .Times(1)
1269 .RetiresOnSaturation();
1270 RenderbufferStorage cmd;
1271 cmd.Init(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, 100, 50);
1272 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1273 EXPECT_CALL(*gl_,
1274 FramebufferRenderbufferEXT(GL_FRAMEBUFFER,
1275 GL_STENCIL_ATTACHMENT,
1276 GL_RENDERBUFFER,
1277 kServiceRenderbufferId))
1278 .Times(1)
1279 .RetiresOnSaturation();
1280 FramebufferRenderbuffer fbrb_cmd;
1281 fbrb_cmd.Init(GL_FRAMEBUFFER,
1282 GL_STENCIL_ATTACHMENT,
1283 GL_RENDERBUFFER,
1284 client_renderbuffer_id_);
1285 EXPECT_EQ(error::kNoError, ExecuteCmd(fbrb_cmd));
1286
1287 typedef GetIntegerv::Result Result;
1288 Result* result = static_cast<Result*>(shared_memory_address_);
1289 result->size = 0;
1290 GetIntegerv cmd2;
1291 cmd2.Init(GL_STENCIL_BITS, shared_memory_id_, shared_memory_offset_);
1292 EXPECT_CALL(*gl_, GetIntegerv(GL_STENCIL_BITS, _))
1293 .WillOnce(SetArgumentPointee<1>(8))
1294 .RetiresOnSaturation();
1295 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
1296 EXPECT_EQ(decoder_->GetGLES2Util()->GLGetNumValuesReturned(GL_STENCIL_BITS),
1297 result->GetNumResults());
1298 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1299 EXPECT_EQ(8, result->GetData()[0]);
1300 result->size = 0;
1301 cmd2.Init(GL_DEPTH_BITS, shared_memory_id_, shared_memory_offset_);
1302 EXPECT_CALL(*gl_, GetIntegerv(GL_DEPTH_BITS, _))
1303 .WillOnce(SetArgumentPointee<1>(24))
1304 .RetiresOnSaturation();
1305 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
1306 EXPECT_EQ(decoder_->GetGLES2Util()->GLGetNumValuesReturned(GL_DEPTH_BITS),
1307 result->GetNumResults());
1308 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1309 EXPECT_EQ(0, result->GetData()[0]);
1310 }
1311
1312 TEST_P(GLES2DecoderTest, FramebufferRenderbufferGLError) {
1313 DoBindFramebuffer(
1314 GL_FRAMEBUFFER, client_framebuffer_id_, kServiceFramebufferId);
1315 EXPECT_CALL(*gl_, GetError())
1316 .WillOnce(Return(GL_NO_ERROR))
1317 .WillOnce(Return(GL_OUT_OF_MEMORY))
1318 .RetiresOnSaturation();
1319 EXPECT_CALL(*gl_,
1320 FramebufferRenderbufferEXT(GL_FRAMEBUFFER,
1321 GL_COLOR_ATTACHMENT0,
1322 GL_RENDERBUFFER,
1323 kServiceRenderbufferId))
1324 .Times(1)
1325 .RetiresOnSaturation();
1326 FramebufferRenderbuffer cmd;
1327 cmd.Init(GL_FRAMEBUFFER,
1328 GL_COLOR_ATTACHMENT0,
1329 GL_RENDERBUFFER,
1330 client_renderbuffer_id_);
1331 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1332 EXPECT_EQ(GL_OUT_OF_MEMORY, GetGLError());
1333 }
1334
1335 TEST_P(GLES2DecoderTest, FramebufferTexture2DGLError) {
1336 const GLsizei kWidth = 5;
1337 const GLsizei kHeight = 3;
1338 const GLenum kFormat = GL_RGB;
1339 DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
1340 DoTexImage2D(GL_TEXTURE_2D,
1341 0,
1342 kFormat,
1343 kWidth,
1344 kHeight,
1345 0,
1346 kFormat,
1347 GL_UNSIGNED_BYTE,
1348 0,
1349 0);
1350 DoBindFramebuffer(
1351 GL_FRAMEBUFFER, client_framebuffer_id_, kServiceFramebufferId);
1352 EXPECT_CALL(*gl_, GetError())
1353 .WillOnce(Return(GL_NO_ERROR))
1354 .WillOnce(Return(GL_OUT_OF_MEMORY))
1355 .RetiresOnSaturation();
1356 EXPECT_CALL(*gl_,
1357 FramebufferTexture2DEXT(GL_FRAMEBUFFER,
1358 GL_COLOR_ATTACHMENT0,
1359 GL_TEXTURE_2D,
1360 kServiceTextureId,
1361 0))
1362 .Times(1)
1363 .RetiresOnSaturation();
1364 FramebufferTexture2D fbtex_cmd;
1365 fbtex_cmd.Init(GL_FRAMEBUFFER,
1366 GL_COLOR_ATTACHMENT0,
1367 GL_TEXTURE_2D,
1368 client_texture_id_);
1369 EXPECT_EQ(error::kNoError, ExecuteCmd(fbtex_cmd));
1370 EXPECT_EQ(GL_OUT_OF_MEMORY, GetGLError());
1371 }
1372
1373 TEST_P(GLES2DecoderTest, RenderbufferStorageGLError) {
1374 DoBindRenderbuffer(
1375 GL_RENDERBUFFER, client_renderbuffer_id_, kServiceRenderbufferId);
1376 EnsureRenderbufferBound(false);
1377 EXPECT_CALL(*gl_, GetError())
1378 .WillOnce(Return(GL_NO_ERROR))
1379 .WillOnce(Return(GL_OUT_OF_MEMORY))
1380 .RetiresOnSaturation();
1381 EXPECT_CALL(*gl_, RenderbufferStorageEXT(GL_RENDERBUFFER, GL_RGBA, 100, 50))
1382 .Times(1)
1383 .RetiresOnSaturation();
1384 RenderbufferStorage cmd;
1385 cmd.Init(GL_RENDERBUFFER, GL_RGBA4, 100, 50);
1386 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1387 EXPECT_EQ(GL_OUT_OF_MEMORY, GetGLError());
1388 }
1389
1390 TEST_P(GLES2DecoderTest, RenderbufferStorageBadArgs) {
1391 DoBindRenderbuffer(
1392 GL_RENDERBUFFER, client_renderbuffer_id_, kServiceRenderbufferId);
1393 EXPECT_CALL(*gl_, RenderbufferStorageEXT(_, _, _, _))
1394 .Times(0)
1395 .RetiresOnSaturation();
1396 RenderbufferStorage cmd;
1397 cmd.Init(GL_RENDERBUFFER, GL_RGBA4, TestHelper::kMaxRenderbufferSize + 1, 1);
1398 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1399 EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
1400 cmd.Init(GL_RENDERBUFFER, GL_RGBA4, 1, TestHelper::kMaxRenderbufferSize + 1);
1401 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1402 EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
1403 }
1404
1405 TEST_P(GLES2DecoderManualInitTest,
1406 RenderbufferStorageMultisampleCHROMIUMGLError) {
1407 InitState init;
1408 init.extensions = "GL_EXT_framebuffer_multisample";
1409 init.gl_version = "2.1";
1410 init.bind_generates_resource = true;
1411 InitDecoder(init);
1412 DoBindRenderbuffer(
1413 GL_RENDERBUFFER, client_renderbuffer_id_, kServiceRenderbufferId);
1414 EnsureRenderbufferBound(false);
1415 EXPECT_CALL(*gl_, GetError())
1416 .WillOnce(Return(GL_NO_ERROR))
1417 .WillOnce(Return(GL_OUT_OF_MEMORY))
1418 .RetiresOnSaturation();
1419 EXPECT_CALL(
1420 *gl_,
1421 RenderbufferStorageMultisampleEXT(GL_RENDERBUFFER, 1, GL_RGBA, 100, 50))
1422 .Times(1)
1423 .RetiresOnSaturation();
1424 RenderbufferStorageMultisampleCHROMIUM cmd;
1425 cmd.Init(GL_RENDERBUFFER, 1, GL_RGBA4, 100, 50);
1426 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1427 EXPECT_EQ(GL_OUT_OF_MEMORY, GetGLError());
1428 }
1429
1430 TEST_P(GLES2DecoderManualInitTest,
1431 RenderbufferStorageMultisampleCHROMIUMBadArgs) {
1432 InitState init;
1433 init.extensions = "GL_EXT_framebuffer_multisample";
1434 init.gl_version = "2.1";
1435 init.bind_generates_resource = true;
1436 InitDecoder(init);
1437 DoBindRenderbuffer(
1438 GL_RENDERBUFFER, client_renderbuffer_id_, kServiceRenderbufferId);
1439 EXPECT_CALL(*gl_, RenderbufferStorageMultisampleEXT(_, _, _, _, _))
1440 .Times(0)
1441 .RetiresOnSaturation();
1442 RenderbufferStorageMultisampleCHROMIUM cmd;
1443 cmd.Init(GL_RENDERBUFFER,
1444 TestHelper::kMaxSamples + 1,
1445 GL_RGBA4,
1446 TestHelper::kMaxRenderbufferSize,
1447 1);
1448 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1449 EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
1450 cmd.Init(GL_RENDERBUFFER,
1451 TestHelper::kMaxSamples,
1452 GL_RGBA4,
1453 TestHelper::kMaxRenderbufferSize + 1,
1454 1);
1455 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1456 EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
1457 cmd.Init(GL_RENDERBUFFER,
1458 TestHelper::kMaxSamples,
1459 GL_RGBA4,
1460 1,
1461 TestHelper::kMaxRenderbufferSize + 1);
1462 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1463 EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
1464 }
1465
1466 TEST_P(GLES2DecoderManualInitTest, RenderbufferStorageMultisampleCHROMIUM) {
1467 InitState init;
1468 init.extensions = "GL_EXT_framebuffer_multisample";
1469 init.gl_version = "2.1";
1470 InitDecoder(init);
1471 DoBindRenderbuffer(
1472 GL_RENDERBUFFER, client_renderbuffer_id_, kServiceRenderbufferId);
1473 InSequence sequence;
1474 EnsureRenderbufferBound(false);
1475 DoRenderbufferStorageMultisampleCHROMIUM(GL_RENDERBUFFER,
1476 TestHelper::kMaxSamples,
1477 GL_RGBA4,
1478 GL_RGBA,
1479 TestHelper::kMaxRenderbufferSize,
1480 1);
1481 }
1482
1483 TEST_P(GLES2DecoderManualInitTest,
1484 RenderbufferStorageMultisampleCHROMIUMRebindRenderbuffer) {
1485 InitState init;
1486 init.extensions = "GL_EXT_framebuffer_multisample";
1487 init.gl_version = "2.1";
1488 InitDecoder(init);
1489 DoBindRenderbuffer(
1490 GL_RENDERBUFFER, client_renderbuffer_id_, kServiceRenderbufferId);
1491 RestoreRenderbufferBindings();
1492 InSequence sequence;
1493 EnsureRenderbufferBound(true);
1494 DoRenderbufferStorageMultisampleCHROMIUM(GL_RENDERBUFFER,
1495 TestHelper::kMaxSamples,
1496 GL_RGBA4,
1497 GL_RGBA,
1498 TestHelper::kMaxRenderbufferSize,
1499 1);
1500 }
1501
1502 TEST_P(GLES2DecoderManualInitTest,
1503 RenderbufferStorageMultisampleEXTNotSupported) {
1504 InitState init;
1505 init.extensions = "GL_EXT_framebuffer_multisample";
1506 init.gl_version = "2.1";
1507 init.bind_generates_resource = true;
1508 InitDecoder(init);
1509 DoBindRenderbuffer(
1510 GL_RENDERBUFFER, client_renderbuffer_id_, kServiceRenderbufferId);
1511 InSequence sequence;
1512 // GL_EXT_framebuffer_multisample uses RenderbufferStorageMultisampleCHROMIUM.
1513 RenderbufferStorageMultisampleEXT cmd;
1514 cmd.Init(GL_RENDERBUFFER,
1515 TestHelper::kMaxSamples,
1516 GL_RGBA4,
1517 TestHelper::kMaxRenderbufferSize,
1518 1);
1519 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1520 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
1521 }
1522
1523 class GLES2DecoderMultisampledRenderToTextureTest
1524 : public GLES2DecoderTestWithExtensionsOnGLES2 {
1525 public:
1526 void TestNotCompatibleWithRenderbufferStorageMultisampleCHROMIUM() {
1527 DoBindRenderbuffer(
1528 GL_RENDERBUFFER, client_renderbuffer_id_, kServiceRenderbufferId);
1529 RenderbufferStorageMultisampleCHROMIUM cmd;
1530 cmd.Init(GL_RENDERBUFFER,
1531 TestHelper::kMaxSamples,
1532 GL_RGBA4,
1533 TestHelper::kMaxRenderbufferSize,
1534 1);
1535 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1536 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
1537 }
1538
1539 void TestRenderbufferStorageMultisampleEXT(const char* extension,
1540 bool rb_rebind) {
1541 DoBindRenderbuffer(
1542 GL_RENDERBUFFER, client_renderbuffer_id_, kServiceRenderbufferId);
1543 InSequence sequence;
1544 if (rb_rebind) {
1545 RestoreRenderbufferBindings();
1546 EnsureRenderbufferBound(true);
1547 } else {
1548 EnsureRenderbufferBound(false);
1549 }
1550
1551 EXPECT_CALL(*gl_, GetError())
1552 .WillOnce(Return(GL_NO_ERROR))
1553 .RetiresOnSaturation();
1554 if (strstr(extension, "GL_IMG_multisampled_render_to_texture")) {
1555 EXPECT_CALL(
1556 *gl_,
1557 RenderbufferStorageMultisampleIMG(GL_RENDERBUFFER,
1558 TestHelper::kMaxSamples,
1559 GL_RGBA,
1560 TestHelper::kMaxRenderbufferSize,
1561 1))
1562 .Times(1)
1563 .RetiresOnSaturation();
1564 } else {
1565 EXPECT_CALL(
1566 *gl_,
1567 RenderbufferStorageMultisampleEXT(GL_RENDERBUFFER,
1568 TestHelper::kMaxSamples,
1569 GL_RGBA,
1570 TestHelper::kMaxRenderbufferSize,
1571 1))
1572 .Times(1)
1573 .RetiresOnSaturation();
1574 }
1575 EXPECT_CALL(*gl_, GetError())
1576 .WillOnce(Return(GL_NO_ERROR))
1577 .RetiresOnSaturation();
1578 RenderbufferStorageMultisampleEXT cmd;
1579 cmd.Init(GL_RENDERBUFFER,
1580 TestHelper::kMaxSamples,
1581 GL_RGBA4,
1582 TestHelper::kMaxRenderbufferSize,
1583 1);
1584 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1585 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1586 }
1587 };
1588
1589 INSTANTIATE_TEST_CASE_P(Service,
1590 GLES2DecoderMultisampledRenderToTextureTest,
1591 ::testing::Bool());
1592
1593 TEST_P(GLES2DecoderMultisampledRenderToTextureTest,
1594 NotCompatibleWithRenderbufferStorageMultisampleCHROMIUM_EXT) {
1595 Init("GL_EXT_multisampled_render_to_texture");
1596 TestNotCompatibleWithRenderbufferStorageMultisampleCHROMIUM();
1597 }
1598
1599 TEST_P(GLES2DecoderMultisampledRenderToTextureTest,
1600 NotCompatibleWithRenderbufferStorageMultisampleCHROMIUM_IMG) {
1601 Init("GL_IMG_multisampled_render_to_texture");
1602 TestNotCompatibleWithRenderbufferStorageMultisampleCHROMIUM();
1603 }
1604
1605 TEST_P(GLES2DecoderMultisampledRenderToTextureTest,
1606 RenderbufferStorageMultisampleEXT_EXT) {
1607 Init("GL_EXT_multisampled_render_to_texture");
1608 TestRenderbufferStorageMultisampleEXT("GL_EXT_multisampled_render_to_texture",
1609 false);
1610 }
1611
1612 TEST_P(GLES2DecoderMultisampledRenderToTextureTest,
1613 RenderbufferStorageMultisampleEXT_IMG) {
1614 Init("GL_IMG_multisampled_render_to_texture");
1615 TestRenderbufferStorageMultisampleEXT("GL_IMG_multisampled_render_to_texture",
1616 false);
1617 }
1618
1619 TEST_P(GLES2DecoderMultisampledRenderToTextureTest,
1620 RenderbufferStorageMultisampleEXT_EXT_RebindRenderbuffer) {
1621 Init("GL_EXT_multisampled_render_to_texture");
1622 TestRenderbufferStorageMultisampleEXT("GL_EXT_multisampled_render_to_texture",
1623 true);
1624 }
1625
1626 TEST_P(GLES2DecoderMultisampledRenderToTextureTest,
1627 RenderbufferStorageMultisampleEXT_IMG_RebindRenderbuffer) {
1628 Init("GL_IMG_multisampled_render_to_texture");
1629 TestRenderbufferStorageMultisampleEXT("GL_IMG_multisampled_render_to_texture",
1630 true);
1631 }
1632
1633 TEST_P(GLES2DecoderTest, ReadPixelsGLError) {
1634 GLenum kFormat = GL_RGBA;
1635 GLint x = 0;
1636 GLint y = 0;
1637 GLsizei width = 2;
1638 GLsizei height = 4;
1639 typedef ReadPixels::Result Result;
1640 Result* result = GetSharedMemoryAs<Result*>();
1641 uint32 result_shm_id = kSharedMemoryId;
1642 uint32 result_shm_offset = kSharedMemoryOffset;
1643 uint32 pixels_shm_id = kSharedMemoryId;
1644 uint32 pixels_shm_offset = kSharedMemoryOffset + sizeof(*result);
1645 EXPECT_CALL(*gl_, GetError())
1646 .WillOnce(Return(GL_NO_ERROR))
1647 .WillOnce(Return(GL_OUT_OF_MEMORY))
1648 .RetiresOnSaturation();
1649 EXPECT_CALL(*gl_,
1650 ReadPixels(x, y, width, height, kFormat, GL_UNSIGNED_BYTE, _))
1651 .Times(1)
1652 .RetiresOnSaturation();
1653 ReadPixels cmd;
1654 cmd.Init(x,
1655 y,
1656 width,
1657 height,
1658 kFormat,
1659 GL_UNSIGNED_BYTE,
1660 pixels_shm_id,
1661 pixels_shm_offset,
1662 result_shm_id,
1663 result_shm_offset,
1664 false);
1665 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1666 EXPECT_EQ(GL_OUT_OF_MEMORY, GetGLError());
1667 }
1668
1669 TEST_P(GLES2DecoderWithShaderTest, UnClearedAttachmentsGetClearedOnClear) {
1670 const GLuint kFBOClientTextureId = 4100;
1671 const GLuint kFBOServiceTextureId = 4101;
1672
1673 // Register a texture id.
1674 EXPECT_CALL(*gl_, GenTextures(_, _))
1675 .WillOnce(SetArgumentPointee<1>(kFBOServiceTextureId))
1676 .RetiresOnSaturation();
1677 GenHelper<GenTexturesImmediate>(kFBOClientTextureId);
1678
1679 // Setup "render to" texture.
1680 DoBindTexture(GL_TEXTURE_2D, kFBOClientTextureId, kFBOServiceTextureId);
1681 DoTexImage2D(
1682 GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0, 0);
1683 DoBindFramebuffer(
1684 GL_FRAMEBUFFER, client_framebuffer_id_, kServiceFramebufferId);
1685 DoFramebufferTexture2D(GL_FRAMEBUFFER,
1686 GL_COLOR_ATTACHMENT0,
1687 GL_TEXTURE_2D,
1688 kFBOClientTextureId,
1689 kFBOServiceTextureId,
1690 0,
1691 GL_NO_ERROR);
1692
1693 // Setup "render from" texture.
1694 SetupTexture();
1695
1696 SetupExpectationsForFramebufferClearing(GL_FRAMEBUFFER, // target
1697 GL_COLOR_BUFFER_BIT, // clear bits
1698 0,
1699 0,
1700 0,
1701 0, // color
1702 0, // stencil
1703 1.0f, // depth
1704 false); // scissor test
1705 SetupExpectationsForApplyingDirtyState(false, // Framebuffer is RGB
1706 false, // Framebuffer has depth
1707 false, // Framebuffer has stencil
1708 0x1111, // color bits
1709 false, // depth mask
1710 false, // depth enabled
1711 0, // front stencil mask
1712 0, // back stencil mask
1713 false); // stencil enabled
1714
1715 EXPECT_CALL(*gl_, Clear(GL_COLOR_BUFFER_BIT)).Times(1).RetiresOnSaturation();
1716
1717 Clear cmd;
1718 cmd.Init(GL_COLOR_BUFFER_BIT);
1719 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1720 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1721 }
1722
1723 TEST_P(GLES2DecoderWithShaderTest, UnClearedAttachmentsGetClearedOnReadPixels) {
1724 const GLuint kFBOClientTextureId = 4100;
1725 const GLuint kFBOServiceTextureId = 4101;
1726
1727 // Register a texture id.
1728 EXPECT_CALL(*gl_, GenTextures(_, _))
1729 .WillOnce(SetArgumentPointee<1>(kFBOServiceTextureId))
1730 .RetiresOnSaturation();
1731 GenHelper<GenTexturesImmediate>(kFBOClientTextureId);
1732
1733 // Setup "render to" texture.
1734 DoBindTexture(GL_TEXTURE_2D, kFBOClientTextureId, kFBOServiceTextureId);
1735 DoTexImage2D(
1736 GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0, 0);
1737 DoBindFramebuffer(
1738 GL_FRAMEBUFFER, client_framebuffer_id_, kServiceFramebufferId);
1739 DoFramebufferTexture2D(GL_FRAMEBUFFER,
1740 GL_COLOR_ATTACHMENT0,
1741 GL_TEXTURE_2D,
1742 kFBOClientTextureId,
1743 kFBOServiceTextureId,
1744 0,
1745 GL_NO_ERROR);
1746
1747 // Setup "render from" texture.
1748 SetupTexture();
1749
1750 SetupExpectationsForFramebufferClearing(GL_FRAMEBUFFER, // target
1751 GL_COLOR_BUFFER_BIT, // clear bits
1752 0,
1753 0,
1754 0,
1755 0, // color
1756 0, // stencil
1757 1.0f, // depth
1758 false); // scissor test
1759
1760 EXPECT_CALL(*gl_, GetError())
1761 .WillOnce(Return(GL_NO_ERROR))
1762 .WillOnce(Return(GL_NO_ERROR))
1763 .RetiresOnSaturation();
1764 EXPECT_CALL(*gl_, ReadPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, _))
1765 .Times(1)
1766 .RetiresOnSaturation();
1767 typedef ReadPixels::Result Result;
1768 Result* result = GetSharedMemoryAs<Result*>();
1769 uint32 result_shm_id = kSharedMemoryId;
1770 uint32 result_shm_offset = kSharedMemoryOffset;
1771 uint32 pixels_shm_id = kSharedMemoryId;
1772 uint32 pixels_shm_offset = kSharedMemoryOffset + sizeof(*result);
1773 ReadPixels cmd;
1774 cmd.Init(0,
1775 0,
1776 1,
1777 1,
1778 GL_RGBA,
1779 GL_UNSIGNED_BYTE,
1780 pixels_shm_id,
1781 pixels_shm_offset,
1782 result_shm_id,
1783 result_shm_offset,
1784 false);
1785 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1786 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1787 }
1788
1789 TEST_P(GLES2DecoderManualInitTest,
1790 UnClearedAttachmentsGetClearedOnReadPixelsAndDrawBufferGetsRestored) {
1791 InitState init;
1792 init.extensions = "GL_EXT_framebuffer_multisample";
1793 init.gl_version = "2.1";
1794 init.bind_generates_resource = true;
1795 InitDecoder(init);
1796 const GLuint kFBOClientTextureId = 4100;
1797 const GLuint kFBOServiceTextureId = 4101;
1798
1799 // Register a texture id.
1800 EXPECT_CALL(*gl_, GenTextures(_, _))
1801 .WillOnce(SetArgumentPointee<1>(kFBOServiceTextureId))
1802 .RetiresOnSaturation();
1803 GenHelper<GenTexturesImmediate>(kFBOClientTextureId);
1804
1805 // Setup "render from" texture.
1806 DoBindTexture(GL_TEXTURE_2D, kFBOClientTextureId, kFBOServiceTextureId);
1807 DoTexImage2D(
1808 GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0, 0);
1809 DoBindFramebuffer(
1810 GL_READ_FRAMEBUFFER, client_framebuffer_id_, kServiceFramebufferId);
1811 DoFramebufferTexture2D(GL_READ_FRAMEBUFFER,
1812 GL_COLOR_ATTACHMENT0,
1813 GL_TEXTURE_2D,
1814 kFBOClientTextureId,
1815 kFBOServiceTextureId,
1816 0,
1817 GL_NO_ERROR);
1818
1819 // Enable GL_SCISSOR_TEST to make sure we disable it in the clear,
1820 // then re-enable after.
1821 DoEnableDisable(GL_SCISSOR_TEST, true);
1822
1823 SetupExpectationsForFramebufferClearingMulti(
1824 kServiceFramebufferId, // read framebuffer service id
1825 0, // backbuffer service id
1826 GL_READ_FRAMEBUFFER, // target
1827 GL_COLOR_BUFFER_BIT, // clear bits
1828 0,
1829 0,
1830 0,
1831 0, // color
1832 0, // stencil
1833 1.0f, // depth
1834 true); // scissor test
1835
1836 EXPECT_CALL(*gl_, GetError())
1837 .WillOnce(Return(GL_NO_ERROR))
1838 .WillOnce(Return(GL_NO_ERROR))
1839 .RetiresOnSaturation();
1840 EXPECT_CALL(*gl_, ReadPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, _))
1841 .Times(1)
1842 .RetiresOnSaturation();
1843 typedef ReadPixels::Result Result;
1844 uint32 result_shm_id = kSharedMemoryId;
1845 uint32 result_shm_offset = kSharedMemoryOffset;
1846 uint32 pixels_shm_id = kSharedMemoryId;
1847 uint32 pixels_shm_offset = kSharedMemoryOffset + sizeof(Result);
1848 ReadPixels cmd;
1849 cmd.Init(0,
1850 0,
1851 1,
1852 1,
1853 GL_RGBA,
1854 GL_UNSIGNED_BYTE,
1855 pixels_shm_id,
1856 pixels_shm_offset,
1857 result_shm_id,
1858 result_shm_offset,
1859 false);
1860 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1861 EXPECT_EQ(GL_NO_ERROR, GetGLError());
1862 }
1863
1864 TEST_P(GLES2DecoderWithShaderTest, CopyTexImageWithInCompleteFBOFails) {
1865 GLenum target = GL_TEXTURE_2D;
1866 GLint level = 0;
1867 GLenum internal_format = GL_RGBA;
1868 GLsizei width = 2;
1869 GLsizei height = 4;
1870 SetupTexture();
1871 DoBindRenderbuffer(
1872 GL_RENDERBUFFER, client_renderbuffer_id_, kServiceRenderbufferId);
1873 DoBindFramebuffer(
1874 GL_FRAMEBUFFER, client_framebuffer_id_, kServiceFramebufferId);
1875 DoRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA4, GL_RGBA, 0, 0, GL_NO_ERROR);
1876 DoFramebufferRenderbuffer(GL_FRAMEBUFFER,
1877 GL_COLOR_ATTACHMENT0,
1878 GL_RENDERBUFFER,
1879 client_renderbuffer_id_,
1880 kServiceRenderbufferId,
1881 GL_NO_ERROR);
1882
1883 EXPECT_CALL(*gl_, CopyTexImage2D(_, _, _, _, _, _, _, _))
1884 .Times(0)
1885 .RetiresOnSaturation();
1886 CopyTexImage2D cmd;
1887 cmd.Init(target, level, internal_format, 0, 0, width, height);
1888 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1889 EXPECT_EQ(GL_INVALID_FRAMEBUFFER_OPERATION, GetGLError());
1890 }
1891
1892 void GLES2DecoderWithShaderTest::CheckRenderbufferChangesMarkFBOAsNotComplete(
1893 bool bound_fbo) {
1894 FramebufferManager* framebuffer_manager = group().framebuffer_manager();
1895 SetupTexture();
1896 DoBindRenderbuffer(
1897 GL_RENDERBUFFER, client_renderbuffer_id_, kServiceRenderbufferId);
1898 DoBindFramebuffer(
1899 GL_FRAMEBUFFER, client_framebuffer_id_, kServiceFramebufferId);
1900 DoRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA4, GL_RGBA, 1, 1, GL_NO_ERROR);
1901 DoFramebufferRenderbuffer(GL_FRAMEBUFFER,
1902 GL_COLOR_ATTACHMENT0,
1903 GL_RENDERBUFFER,
1904 client_renderbuffer_id_,
1905 kServiceRenderbufferId,
1906 GL_NO_ERROR);
1907
1908 if (!bound_fbo) {
1909 DoBindFramebuffer(GL_FRAMEBUFFER, 0, 0);
1910 }
1911
1912 Framebuffer* framebuffer =
1913 framebuffer_manager->GetFramebuffer(client_framebuffer_id_);
1914 ASSERT_TRUE(framebuffer != NULL);
1915 framebuffer_manager->MarkAsComplete(framebuffer);
1916 EXPECT_TRUE(framebuffer_manager->IsComplete(framebuffer));
1917
1918 // Test that renderbufferStorage marks fbo as not complete.
1919 DoRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA4, GL_RGBA, 1, 1, GL_NO_ERROR);
1920 EXPECT_FALSE(framebuffer_manager->IsComplete(framebuffer));
1921 framebuffer_manager->MarkAsComplete(framebuffer);
1922 EXPECT_TRUE(framebuffer_manager->IsComplete(framebuffer));
1923
1924 // Test deleting renderbuffer marks fbo as not complete.
1925 DoDeleteRenderbuffer(client_renderbuffer_id_, kServiceRenderbufferId);
1926 if (bound_fbo) {
1927 EXPECT_FALSE(framebuffer_manager->IsComplete(framebuffer));
1928 } else {
1929 EXPECT_TRUE(framebuffer_manager->IsComplete(framebuffer));
1930 }
1931 // Cleanup
1932 DoDeleteFramebuffer(client_framebuffer_id_,
1933 kServiceFramebufferId,
1934 bound_fbo,
1935 GL_FRAMEBUFFER,
1936 0,
1937 bound_fbo,
1938 GL_FRAMEBUFFER,
1939 0);
1940 }
1941
1942 TEST_P(GLES2DecoderWithShaderTest,
1943 RenderbufferChangesMarkFBOAsNotCompleteBoundFBO) {
1944 CheckRenderbufferChangesMarkFBOAsNotComplete(true);
1945 }
1946
1947 TEST_P(GLES2DecoderWithShaderTest,
1948 RenderbufferChangesMarkFBOAsNotCompleteUnboundFBO) {
1949 CheckRenderbufferChangesMarkFBOAsNotComplete(false);
1950 }
1951
1952 void GLES2DecoderWithShaderTest::CheckTextureChangesMarkFBOAsNotComplete(
1953 bool bound_fbo) {
1954 FramebufferManager* framebuffer_manager = group().framebuffer_manager();
1955 const GLuint kFBOClientTextureId = 4100;
1956 const GLuint kFBOServiceTextureId = 4101;
1957
1958 // Register a texture id.
1959 EXPECT_CALL(*gl_, GenTextures(_, _))
1960 .WillOnce(SetArgumentPointee<1>(kFBOServiceTextureId))
1961 .RetiresOnSaturation();
1962 GenHelper<GenTexturesImmediate>(kFBOClientTextureId);
1963
1964 SetupTexture();
1965
1966 // Setup "render to" texture.
1967 DoBindTexture(GL_TEXTURE_2D, kFBOClientTextureId, kFBOServiceTextureId);
1968 DoTexImage2D(
1969 GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0, 0);
1970 DoBindFramebuffer(
1971 GL_FRAMEBUFFER, client_framebuffer_id_, kServiceFramebufferId);
1972 DoFramebufferTexture2D(GL_FRAMEBUFFER,
1973 GL_COLOR_ATTACHMENT0,
1974 GL_TEXTURE_2D,
1975 kFBOClientTextureId,
1976 kFBOServiceTextureId,
1977 0,
1978 GL_NO_ERROR);
1979
1980 DoBindRenderbuffer(
1981 GL_RENDERBUFFER, client_renderbuffer_id_, kServiceRenderbufferId);
1982 DoBindFramebuffer(
1983 GL_FRAMEBUFFER, client_framebuffer_id_, kServiceFramebufferId);
1984 DoRenderbufferStorage(GL_RENDERBUFFER,
1985 GL_DEPTH_COMPONENT16,
1986 GL_DEPTH_COMPONENT,
1987 1,
1988 1,
1989 GL_NO_ERROR);
1990 DoFramebufferRenderbuffer(GL_FRAMEBUFFER,
1991 GL_DEPTH_ATTACHMENT,
1992 GL_RENDERBUFFER,
1993 client_renderbuffer_id_,
1994 kServiceRenderbufferId,
1995 GL_NO_ERROR);
1996
1997 if (!bound_fbo) {
1998 DoBindFramebuffer(GL_FRAMEBUFFER, 0, 0);
1999 }
2000
2001 Framebuffer* framebuffer =
2002 framebuffer_manager->GetFramebuffer(client_framebuffer_id_);
2003 ASSERT_TRUE(framebuffer != NULL);
2004 framebuffer_manager->MarkAsComplete(framebuffer);
2005 EXPECT_TRUE(framebuffer_manager->IsComplete(framebuffer));
2006
2007 // Test TexImage2D marks fbo as not complete.
2008 DoTexImage2D(
2009 GL_TEXTURE_2D, 0, GL_RGB, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, 0, 0);
2010 EXPECT_FALSE(framebuffer_manager->IsComplete(framebuffer));
2011 framebuffer_manager->MarkAsComplete(framebuffer);
2012 EXPECT_TRUE(framebuffer_manager->IsComplete(framebuffer));
2013
2014 // Test CopyImage2D marks fbo as not complete.
2015 EXPECT_CALL(*gl_, GetError())
2016 .WillOnce(Return(GL_NO_ERROR))
2017 .RetiresOnSaturation();
2018 EXPECT_CALL(*gl_, CopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 0, 0, 1, 1, 0))
2019 .Times(1)
2020 .RetiresOnSaturation();
2021 EXPECT_CALL(*gl_, GetError())
2022 .WillOnce(Return(GL_NO_ERROR))
2023 .RetiresOnSaturation();
2024 CopyTexImage2D cmd;
2025 cmd.Init(GL_TEXTURE_2D, 0, GL_RGB, 0, 0, 1, 1);
2026 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
2027 EXPECT_FALSE(framebuffer_manager->IsComplete(framebuffer));
2028
2029 // Test deleting texture marks fbo as not complete.
2030 framebuffer_manager->MarkAsComplete(framebuffer);
2031 EXPECT_TRUE(framebuffer_manager->IsComplete(framebuffer));
2032 DoDeleteTexture(kFBOClientTextureId, kFBOServiceTextureId);
2033
2034 if (bound_fbo) {
2035 EXPECT_FALSE(framebuffer_manager->IsComplete(framebuffer));
2036 } else {
2037 EXPECT_TRUE(framebuffer_manager->IsComplete(framebuffer));
2038 }
2039 // Cleanup
2040 DoDeleteFramebuffer(client_framebuffer_id_,
2041 kServiceFramebufferId,
2042 bound_fbo,
2043 GL_FRAMEBUFFER,
2044 0,
2045 bound_fbo,
2046 GL_FRAMEBUFFER,
2047 0);
2048 }
2049
2050 TEST_P(GLES2DecoderWithShaderTest, TextureChangesMarkFBOAsNotCompleteBoundFBO) {
2051 CheckTextureChangesMarkFBOAsNotComplete(true);
2052 }
2053
2054 TEST_P(GLES2DecoderWithShaderTest,
2055 TextureChangesMarkFBOAsNotCompleteUnboundFBO) {
2056 CheckTextureChangesMarkFBOAsNotComplete(false);
2057 }
2058
2059 TEST_P(GLES2DecoderTest, CanChangeSurface) {
2060 scoped_refptr<GLSurfaceMock> other_surface(new GLSurfaceMock);
2061 EXPECT_CALL(*other_surface.get(), GetBackingFrameBufferObject())
2062 .WillOnce(Return(7));
2063 EXPECT_CALL(*gl_, BindFramebufferEXT(GL_FRAMEBUFFER_EXT, 7));
2064
2065 decoder_->SetSurface(other_surface);
2066 }
2067
2068 TEST_P(GLES2DecoderTest, DrawBuffersEXTImmediateSuccceeds) {
2069 const GLsizei count = 1;
2070 const GLenum bufs[] = {GL_COLOR_ATTACHMENT0};
2071 DrawBuffersEXTImmediate& cmd = *GetImmediateAs<DrawBuffersEXTImmediate>();
2072 cmd.Init(count, bufs);
2073
2074 DoBindFramebuffer(
2075 GL_FRAMEBUFFER, client_framebuffer_id_, kServiceFramebufferId);
2076 EXPECT_CALL(*gl_, DrawBuffersARB(count, _)).Times(1).RetiresOnSaturation();
2077 EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(bufs)));
2078 EXPECT_EQ(GL_NO_ERROR, GetGLError());
2079 }
2080
2081 TEST_P(GLES2DecoderTest, DrawBuffersEXTImmediateFails) {
2082 const GLsizei count = 1;
2083 const GLenum bufs[] = {GL_COLOR_ATTACHMENT1_EXT};
2084 DrawBuffersEXTImmediate& cmd = *GetImmediateAs<DrawBuffersEXTImmediate>();
2085 cmd.Init(count, bufs);
2086
2087 DoBindFramebuffer(
2088 GL_FRAMEBUFFER, client_framebuffer_id_, kServiceFramebufferId);
2089 EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(bufs)));
2090 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
2091 }
2092
2093 TEST_P(GLES2DecoderTest, DrawBuffersEXTImmediateBackbuffer) {
2094 const GLsizei count = 1;
2095 const GLenum bufs[] = {GL_BACK};
2096 DrawBuffersEXTImmediate& cmd = *GetImmediateAs<DrawBuffersEXTImmediate>();
2097 cmd.Init(count, bufs);
2098
2099 DoBindFramebuffer(
2100 GL_FRAMEBUFFER, client_framebuffer_id_, kServiceFramebufferId);
2101 EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(bufs)));
2102 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
2103
2104 DoBindFramebuffer(GL_FRAMEBUFFER, 0, 0); // unbind
2105
2106 EXPECT_CALL(*gl_, DrawBuffersARB(count, _)).Times(1).RetiresOnSaturation();
2107
2108 EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(bufs)));
2109 EXPECT_EQ(GL_NO_ERROR, GetGLError());
2110 }
2111
2112 TEST_P(GLES2DecoderManualInitTest, InvalidateFramebufferBinding) {
2113 InitState init;
2114 init.gl_version = "opengl es 3.0";
2115 InitDecoder(init);
2116
2117 // EXPECT_EQ can't be used to compare function pointers
2118 EXPECT_TRUE(
2119 gfx::MockGLInterface::GetGLProcAddress("glInvalidateFramebuffer") ==
2120 gfx::g_driver_gl.fn.glDiscardFramebufferEXTFn);
2121 EXPECT_TRUE(
2122 gfx::MockGLInterface::GetGLProcAddress("glInvalidateFramebuffer") !=
2123 gfx::MockGLInterface::GetGLProcAddress("glDiscardFramebufferEXT"));
2124 }
2125
2126 TEST_P(GLES2DecoderManualInitTest, DiscardFramebufferEXT) {
2127 InitState init;
2128 init.extensions = "GL_EXT_discard_framebuffer";
2129 init.gl_version = "opengl es 2.0";
2130 InitDecoder(init);
2131
2132 // EXPECT_EQ can't be used to compare function pointers
2133 EXPECT_TRUE(
2134 gfx::MockGLInterface::GetGLProcAddress("glDiscardFramebufferEXT") ==
2135 gfx::g_driver_gl.fn.glDiscardFramebufferEXTFn);
2136
2137 const GLenum target = GL_FRAMEBUFFER;
2138 const GLsizei count = 1;
2139 const GLenum attachments[] = {GL_COLOR_ATTACHMENT0};
2140
2141 SetupTexture();
2142 DoBindFramebuffer(
2143 GL_FRAMEBUFFER, client_framebuffer_id_, kServiceFramebufferId);
2144 DoFramebufferTexture2D(GL_FRAMEBUFFER,
2145 GL_COLOR_ATTACHMENT0,
2146 GL_TEXTURE_2D,
2147 client_texture_id_,
2148 kServiceTextureId,
2149 0,
2150 GL_NO_ERROR);
2151 FramebufferManager* framebuffer_manager = group().framebuffer_manager();
2152 Framebuffer* framebuffer =
2153 framebuffer_manager->GetFramebuffer(client_framebuffer_id_);
2154 EXPECT_TRUE(framebuffer->IsCleared());
2155
2156 EXPECT_CALL(*gl_, DiscardFramebufferEXT(target, count, _))
2157 .Times(1)
2158 .RetiresOnSaturation();
2159 DiscardFramebufferEXTImmediate& cmd =
2160 *GetImmediateAs<DiscardFramebufferEXTImmediate>();
2161 cmd.Init(target, count, attachments);
2162
2163 EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(attachments)));
2164 EXPECT_EQ(GL_NO_ERROR, GetGLError());
2165 EXPECT_FALSE(framebuffer->IsCleared());
2166 }
2167
2168 TEST_P(GLES2DecoderTest, DiscardFramebufferEXTUnsupported) {
2169 const GLenum target = GL_FRAMEBUFFER;
2170 const GLsizei count = 1;
2171 const GLenum attachments[] = {GL_COLOR_EXT};
2172 DiscardFramebufferEXTImmediate& cmd =
2173 *GetImmediateAs<DiscardFramebufferEXTImmediate>();
2174 cmd.Init(target, count, attachments);
2175
2176 // Should not result into a call into GL.
2177 EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(attachments)));
2178 EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
2179 }
2180
2181 TEST_P(GLES2DecoderManualInitTest,
2182 DiscardedAttachmentsEXTMarksFramebufferIncomplete) {
2183 InitState init;
2184 init.extensions = "GL_EXT_discard_framebuffer";
2185 init.gl_version = "opengl es 2.0";
2186 init.has_alpha = true;
2187 init.bind_generates_resource = true;
2188 InitDecoder(init);
2189
2190 const GLuint kFBOClientTextureId = 4100;
2191 const GLuint kFBOServiceTextureId = 4101;
2192
2193 // Register a texture id.
2194 EXPECT_CALL(*gl_, GenTextures(_, _))
2195 .WillOnce(SetArgumentPointee<1>(kFBOServiceTextureId))
2196 .RetiresOnSaturation();
2197 GenHelper<GenTexturesImmediate>(kFBOClientTextureId);
2198
2199 // Setup "render to" texture.
2200 DoBindTexture(GL_TEXTURE_2D, kFBOClientTextureId, kFBOServiceTextureId);
2201 DoTexImage2D(
2202 GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0, 0);
2203 DoBindFramebuffer(
2204 GL_FRAMEBUFFER, client_framebuffer_id_, kServiceFramebufferId);
2205 DoFramebufferTexture2D(GL_FRAMEBUFFER,
2206 GL_COLOR_ATTACHMENT0,
2207 GL_TEXTURE_2D,
2208 kFBOClientTextureId,
2209 kFBOServiceTextureId,
2210 0,
2211 GL_NO_ERROR);
2212
2213 // Setup "render from" texture.
2214 SetupTexture();
2215
2216 SetupExpectationsForFramebufferClearing(GL_FRAMEBUFFER, // target
2217 GL_COLOR_BUFFER_BIT, // clear bits
2218 0,
2219 0,
2220 0,
2221 0, // color
2222 0, // stencil
2223 1.0f, // depth
2224 false); // scissor test
2225 SetupExpectationsForApplyingDirtyState(false, // Framebuffer is RGB
2226 false, // Framebuffer has depth
2227 false, // Framebuffer has stencil
2228 0x1111, // color bits
2229 false, // depth mask
2230 false, // depth enabled
2231 0, // front stencil mask
2232 0, // back stencil mask
2233 false); // stencil enabled
2234
2235 EXPECT_CALL(*gl_, Clear(GL_COLOR_BUFFER_BIT)).Times(1).RetiresOnSaturation();
2236
2237 Clear clear_cmd;
2238 clear_cmd.Init(GL_COLOR_BUFFER_BIT);
2239 EXPECT_EQ(error::kNoError, ExecuteCmd(clear_cmd));
2240 EXPECT_EQ(GL_NO_ERROR, GetGLError());
2241
2242 // Check that framebuffer is cleared and complete.
2243 FramebufferManager* framebuffer_manager = group().framebuffer_manager();
2244 Framebuffer* framebuffer =
2245 framebuffer_manager->GetFramebuffer(client_framebuffer_id_);
2246 EXPECT_TRUE(framebuffer->IsCleared());
2247 EXPECT_TRUE(framebuffer_manager->IsComplete(framebuffer));
2248
2249 // Check that Discard GL_COLOR_ATTACHMENT0, sets the attachment as uncleared
2250 // and the framebuffer as incomplete.
2251 EXPECT_TRUE(
2252 gfx::MockGLInterface::GetGLProcAddress("glDiscardFramebufferEXT") ==
2253 gfx::g_driver_gl.fn.glDiscardFramebufferEXTFn);
2254
2255 const GLenum target = GL_FRAMEBUFFER;
2256 const GLsizei count = 1;
2257 const GLenum attachments[] = {GL_COLOR_ATTACHMENT0};
2258
2259 DiscardFramebufferEXTImmediate& discard_cmd =
2260 *GetImmediateAs<DiscardFramebufferEXTImmediate>();
2261 discard_cmd.Init(target, count, attachments);
2262
2263 EXPECT_CALL(*gl_, DiscardFramebufferEXT(target, count, _))
2264 .Times(1)
2265 .RetiresOnSaturation();
2266 EXPECT_EQ(error::kNoError,
2267 ExecuteImmediateCmd(discard_cmd, sizeof(attachments)));
2268 EXPECT_EQ(GL_NO_ERROR, GetGLError());
2269 EXPECT_FALSE(framebuffer->IsCleared());
2270 EXPECT_FALSE(framebuffer_manager->IsComplete(framebuffer));
2271 }
2272
2273 TEST_P(GLES2DecoderManualInitTest, ReadFormatExtension) {
2274 InitState init;
2275 init.extensions = "GL_OES_read_format";
2276 init.gl_version = "2.1";
2277 init.bind_generates_resource = true;
2278 InitDecoder(init);
2279
2280 EXPECT_CALL(*gl_, GetError())
2281 .WillOnce(Return(GL_NO_ERROR))
2282 .WillOnce(Return(GL_NO_ERROR))
2283 .WillOnce(Return(GL_NO_ERROR))
2284 .WillOnce(Return(GL_NO_ERROR))
2285 .RetiresOnSaturation();
2286 EXPECT_CALL(*gl_, GetError()).Times(6).RetiresOnSaturation();
2287
2288 typedef GetIntegerv::Result Result;
2289 Result* result = static_cast<Result*>(shared_memory_address_);
2290 GetIntegerv cmd;
2291 const GLuint kFBOClientTextureId = 4100;
2292 const GLuint kFBOServiceTextureId = 4101;
2293
2294 // Register a texture id.
2295 EXPECT_CALL(*gl_, GenTextures(_, _))
2296 .WillOnce(SetArgumentPointee<1>(kFBOServiceTextureId))
2297 .RetiresOnSaturation();
2298 GenHelper<GenTexturesImmediate>(kFBOClientTextureId);
2299
2300 // Setup "render to" texture.
2301 DoBindTexture(GL_TEXTURE_2D, kFBOClientTextureId, kFBOServiceTextureId);
2302 DoTexImage2D(
2303 GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0, 0);
2304 DoBindFramebuffer(
2305 GL_FRAMEBUFFER, client_framebuffer_id_, kServiceFramebufferId);
2306 DoFramebufferTexture2D(GL_FRAMEBUFFER,
2307 GL_COLOR_ATTACHMENT0,
2308 GL_TEXTURE_2D,
2309 kFBOClientTextureId,
2310 kFBOServiceTextureId,
2311 0,
2312 GL_NO_ERROR);
2313
2314 result->size = 0;
2315 EXPECT_CALL(*gl_, GetIntegerv(_, _)).Times(1).RetiresOnSaturation();
2316 cmd.Init(GL_IMPLEMENTATION_COLOR_READ_FORMAT,
2317 shared_memory_id_,
2318 shared_memory_offset_);
2319 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
2320 EXPECT_EQ(1, result->GetNumResults());
2321 EXPECT_EQ(GL_NO_ERROR, GetGLError());
2322
2323 result->size = 0;
2324 EXPECT_CALL(*gl_, GetIntegerv(_, _)).Times(1).RetiresOnSaturation();
2325 cmd.Init(GL_IMPLEMENTATION_COLOR_READ_TYPE,
2326 shared_memory_id_,
2327 shared_memory_offset_);
2328 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
2329 EXPECT_EQ(1, result->GetNumResults());
2330 EXPECT_EQ(GL_NO_ERROR, GetGLError());
2331 }
2332
2333 TEST_P(GLES2DecoderManualInitTest, NoReadFormatExtension) {
2334 InitState init;
2335 init.gl_version = "2.1";
2336 init.bind_generates_resource = true;
2337 InitDecoder(init);
2338
2339 EXPECT_CALL(*gl_, GetError())
2340 .WillOnce(Return(GL_NO_ERROR))
2341 .WillOnce(Return(GL_NO_ERROR))
2342 .WillOnce(Return(GL_NO_ERROR))
2343 .WillOnce(Return(GL_NO_ERROR))
2344 .RetiresOnSaturation();
2345
2346 typedef GetIntegerv::Result Result;
2347 Result* result = static_cast<Result*>(shared_memory_address_);
2348 GetIntegerv cmd;
2349 const GLuint kFBOClientTextureId = 4100;
2350 const GLuint kFBOServiceTextureId = 4101;
2351
2352 // Register a texture id.
2353 EXPECT_CALL(*gl_, GenTextures(_, _))
2354 .WillOnce(SetArgumentPointee<1>(kFBOServiceTextureId))
2355 .RetiresOnSaturation();
2356 GenHelper<GenTexturesImmediate>(kFBOClientTextureId);
2357
2358 // Setup "render to" texture.
2359 DoBindTexture(GL_TEXTURE_2D, kFBOClientTextureId, kFBOServiceTextureId);
2360 DoTexImage2D(
2361 GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0, 0);
2362 DoBindFramebuffer(
2363 GL_FRAMEBUFFER, client_framebuffer_id_, kServiceFramebufferId);
2364 DoFramebufferTexture2D(GL_FRAMEBUFFER,
2365 GL_COLOR_ATTACHMENT0,
2366 GL_TEXTURE_2D,
2367 kFBOClientTextureId,
2368 kFBOServiceTextureId,
2369 0,
2370 GL_NO_ERROR);
2371
2372 result->size = 0;
2373 EXPECT_CALL(*gl_, GetIntegerv(_, _)).Times(0).RetiresOnSaturation();
2374 cmd.Init(GL_IMPLEMENTATION_COLOR_READ_FORMAT,
2375 shared_memory_id_,
2376 shared_memory_offset_);
2377 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
2378 EXPECT_EQ(1, result->GetNumResults());
2379 EXPECT_EQ(GL_NO_ERROR, GetGLError());
2380
2381 result->size = 0;
2382 EXPECT_CALL(*gl_, GetIntegerv(_, _)).Times(0).RetiresOnSaturation();
2383 cmd.Init(GL_IMPLEMENTATION_COLOR_READ_TYPE,
2384 shared_memory_id_,
2385 shared_memory_offset_);
2386 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
2387 EXPECT_EQ(1, result->GetNumResults());
2388 EXPECT_EQ(GL_NO_ERROR, GetGLError());
2389 }
2390
2391 // TODO(gman): PixelStorei
2392
2393 // TODO(gman): SwapBuffers
2394
2395 } // namespace gles2
2396 } // namespace gpu