OLD | NEW |
1 // Copyright 2012 The Chromium Authors. All rights reserved. | 1 // Copyright 2012 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "base/message_loop/message_loop.h" | 5 #include "base/message_loop/message_loop.h" |
6 #include "cc/layers/append_quads_data.h" | 6 #include "cc/layers/append_quads_data.h" |
7 #include "cc/output/gl_renderer.h" | 7 #include "cc/output/gl_renderer.h" |
8 #include "cc/quads/draw_quad.h" | 8 #include "cc/quads/draw_quad.h" |
9 #include "cc/quads/picture_draw_quad.h" | 9 #include "cc/quads/picture_draw_quad.h" |
10 #include "cc/quads/texture_draw_quad.h" | 10 #include "cc/quads/texture_draw_quad.h" |
(...skipping 200 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
211 scoped_ptr<SolidColorDrawQuad> color_quad = SolidColorDrawQuad::Create(); | 211 scoped_ptr<SolidColorDrawQuad> color_quad = SolidColorDrawQuad::Create(); |
212 color_quad->SetNew(shared_state.get(), rect, rect, SK_ColorGREEN, false); | 212 color_quad->SetNew(shared_state.get(), rect, rect, SK_ColorGREEN, false); |
213 | 213 |
214 pass->quad_list.push_back(color_quad.PassAs<DrawQuad>()); | 214 pass->quad_list.push_back(color_quad.PassAs<DrawQuad>()); |
215 | 215 |
216 RenderPassList pass_list; | 216 RenderPassList pass_list; |
217 pass_list.push_back(pass.Pass()); | 217 pass_list.push_back(pass.Pass()); |
218 | 218 |
219 EXPECT_TRUE(this->RunPixelTest( | 219 EXPECT_TRUE(this->RunPixelTest( |
220 &pass_list, | 220 &pass_list, |
221 PixelTest::NoOffscreenContext, | |
222 base::FilePath(FILE_PATH_LITERAL("green.png")), | 221 base::FilePath(FILE_PATH_LITERAL("green.png")), |
223 ExactPixelComparator(true))); | 222 ExactPixelComparator(true))); |
224 } | 223 } |
225 | 224 |
226 TYPED_TEST(RendererPixelTest, SimpleGreenRect_NonRootRenderPass) { | 225 TYPED_TEST(RendererPixelTest, SimpleGreenRect_NonRootRenderPass) { |
227 gfx::Rect rect(this->device_viewport_size_); | 226 gfx::Rect rect(this->device_viewport_size_); |
228 gfx::Rect small_rect(100, 100); | 227 gfx::Rect small_rect(100, 100); |
229 | 228 |
230 RenderPass::Id child_id(2, 1); | 229 RenderPass::Id child_id(2, 1); |
231 scoped_ptr<RenderPass> child_pass = | 230 scoped_ptr<RenderPass> child_pass = |
(...skipping 22 matching lines...) Expand all Loading... |
254 | 253 |
255 RenderPass* child_pass_ptr = child_pass.get(); | 254 RenderPass* child_pass_ptr = child_pass.get(); |
256 | 255 |
257 RenderPassList pass_list; | 256 RenderPassList pass_list; |
258 pass_list.push_back(child_pass.Pass()); | 257 pass_list.push_back(child_pass.Pass()); |
259 pass_list.push_back(root_pass.Pass()); | 258 pass_list.push_back(root_pass.Pass()); |
260 | 259 |
261 EXPECT_TRUE(this->RunPixelTestWithReadbackTarget( | 260 EXPECT_TRUE(this->RunPixelTestWithReadbackTarget( |
262 &pass_list, | 261 &pass_list, |
263 child_pass_ptr, | 262 child_pass_ptr, |
264 PixelTest::NoOffscreenContext, | |
265 base::FilePath(FILE_PATH_LITERAL("green_small.png")), | 263 base::FilePath(FILE_PATH_LITERAL("green_small.png")), |
266 ExactPixelComparator(true))); | 264 ExactPixelComparator(true))); |
267 } | 265 } |
268 | 266 |
269 TYPED_TEST(RendererPixelTest, PremultipliedTextureWithoutBackground) { | 267 TYPED_TEST(RendererPixelTest, PremultipliedTextureWithoutBackground) { |
270 gfx::Rect rect(this->device_viewport_size_); | 268 gfx::Rect rect(this->device_viewport_size_); |
271 | 269 |
272 RenderPass::Id id(1, 1); | 270 RenderPass::Id id(1, 1); |
273 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); | 271 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); |
274 | 272 |
(...skipping 11 matching lines...) Expand all Loading... |
286 | 284 |
287 scoped_ptr<SolidColorDrawQuad> color_quad = SolidColorDrawQuad::Create(); | 285 scoped_ptr<SolidColorDrawQuad> color_quad = SolidColorDrawQuad::Create(); |
288 color_quad->SetNew(shared_state.get(), rect, rect, SK_ColorWHITE, false); | 286 color_quad->SetNew(shared_state.get(), rect, rect, SK_ColorWHITE, false); |
289 pass->quad_list.push_back(color_quad.PassAs<DrawQuad>()); | 287 pass->quad_list.push_back(color_quad.PassAs<DrawQuad>()); |
290 | 288 |
291 RenderPassList pass_list; | 289 RenderPassList pass_list; |
292 pass_list.push_back(pass.Pass()); | 290 pass_list.push_back(pass.Pass()); |
293 | 291 |
294 EXPECT_TRUE(this->RunPixelTest( | 292 EXPECT_TRUE(this->RunPixelTest( |
295 &pass_list, | 293 &pass_list, |
296 PixelTest::NoOffscreenContext, | |
297 base::FilePath(FILE_PATH_LITERAL("green_alpha.png")), | 294 base::FilePath(FILE_PATH_LITERAL("green_alpha.png")), |
298 FuzzyPixelOffByOneComparator(true))); | 295 FuzzyPixelOffByOneComparator(true))); |
299 } | 296 } |
300 | 297 |
301 TYPED_TEST(RendererPixelTest, PremultipliedTextureWithBackground) { | 298 TYPED_TEST(RendererPixelTest, PremultipliedTextureWithBackground) { |
302 gfx::Rect rect(this->device_viewport_size_); | 299 gfx::Rect rect(this->device_viewport_size_); |
303 | 300 |
304 RenderPass::Id id(1, 1); | 301 RenderPass::Id id(1, 1); |
305 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); | 302 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); |
306 | 303 |
(...skipping 14 matching lines...) Expand all Loading... |
321 CreateTestSharedQuadState(gfx::Transform(), rect); | 318 CreateTestSharedQuadState(gfx::Transform(), rect); |
322 scoped_ptr<SolidColorDrawQuad> color_quad = SolidColorDrawQuad::Create(); | 319 scoped_ptr<SolidColorDrawQuad> color_quad = SolidColorDrawQuad::Create(); |
323 color_quad->SetNew(color_quad_state.get(), rect, rect, SK_ColorWHITE, false); | 320 color_quad->SetNew(color_quad_state.get(), rect, rect, SK_ColorWHITE, false); |
324 pass->quad_list.push_back(color_quad.PassAs<DrawQuad>()); | 321 pass->quad_list.push_back(color_quad.PassAs<DrawQuad>()); |
325 | 322 |
326 RenderPassList pass_list; | 323 RenderPassList pass_list; |
327 pass_list.push_back(pass.Pass()); | 324 pass_list.push_back(pass.Pass()); |
328 | 325 |
329 EXPECT_TRUE(this->RunPixelTest( | 326 EXPECT_TRUE(this->RunPixelTest( |
330 &pass_list, | 327 &pass_list, |
331 PixelTest::NoOffscreenContext, | |
332 base::FilePath(FILE_PATH_LITERAL("green_alpha.png")), | 328 base::FilePath(FILE_PATH_LITERAL("green_alpha.png")), |
333 FuzzyPixelOffByOneComparator(true))); | 329 FuzzyPixelOffByOneComparator(true))); |
334 } | 330 } |
335 | 331 |
336 // TODO(skaslev): The software renderer does not support non-premultplied alpha. | 332 // TODO(skaslev): The software renderer does not support non-premultplied alpha. |
337 TEST_F(GLRendererPixelTest, NonPremultipliedTextureWithoutBackground) { | 333 TEST_F(GLRendererPixelTest, NonPremultipliedTextureWithoutBackground) { |
338 gfx::Rect rect(this->device_viewport_size_); | 334 gfx::Rect rect(this->device_viewport_size_); |
339 | 335 |
340 RenderPass::Id id(1, 1); | 336 RenderPass::Id id(1, 1); |
341 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); | 337 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); |
(...skipping 12 matching lines...) Expand all Loading... |
354 | 350 |
355 scoped_ptr<SolidColorDrawQuad> color_quad = SolidColorDrawQuad::Create(); | 351 scoped_ptr<SolidColorDrawQuad> color_quad = SolidColorDrawQuad::Create(); |
356 color_quad->SetNew(shared_state.get(), rect, rect, SK_ColorWHITE, false); | 352 color_quad->SetNew(shared_state.get(), rect, rect, SK_ColorWHITE, false); |
357 pass->quad_list.push_back(color_quad.PassAs<DrawQuad>()); | 353 pass->quad_list.push_back(color_quad.PassAs<DrawQuad>()); |
358 | 354 |
359 RenderPassList pass_list; | 355 RenderPassList pass_list; |
360 pass_list.push_back(pass.Pass()); | 356 pass_list.push_back(pass.Pass()); |
361 | 357 |
362 EXPECT_TRUE(this->RunPixelTest( | 358 EXPECT_TRUE(this->RunPixelTest( |
363 &pass_list, | 359 &pass_list, |
364 PixelTest::NoOffscreenContext, | |
365 base::FilePath(FILE_PATH_LITERAL("green_alpha.png")), | 360 base::FilePath(FILE_PATH_LITERAL("green_alpha.png")), |
366 FuzzyPixelOffByOneComparator(true))); | 361 FuzzyPixelOffByOneComparator(true))); |
367 } | 362 } |
368 | 363 |
369 // TODO(skaslev): The software renderer does not support non-premultplied alpha. | 364 // TODO(skaslev): The software renderer does not support non-premultplied alpha. |
370 TEST_F(GLRendererPixelTest, NonPremultipliedTextureWithBackground) { | 365 TEST_F(GLRendererPixelTest, NonPremultipliedTextureWithBackground) { |
371 gfx::Rect rect(this->device_viewport_size_); | 366 gfx::Rect rect(this->device_viewport_size_); |
372 | 367 |
373 RenderPass::Id id(1, 1); | 368 RenderPass::Id id(1, 1); |
374 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); | 369 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); |
(...skipping 15 matching lines...) Expand all Loading... |
390 CreateTestSharedQuadState(gfx::Transform(), rect); | 385 CreateTestSharedQuadState(gfx::Transform(), rect); |
391 scoped_ptr<SolidColorDrawQuad> color_quad = SolidColorDrawQuad::Create(); | 386 scoped_ptr<SolidColorDrawQuad> color_quad = SolidColorDrawQuad::Create(); |
392 color_quad->SetNew(color_quad_state.get(), rect, rect, SK_ColorWHITE, false); | 387 color_quad->SetNew(color_quad_state.get(), rect, rect, SK_ColorWHITE, false); |
393 pass->quad_list.push_back(color_quad.PassAs<DrawQuad>()); | 388 pass->quad_list.push_back(color_quad.PassAs<DrawQuad>()); |
394 | 389 |
395 RenderPassList pass_list; | 390 RenderPassList pass_list; |
396 pass_list.push_back(pass.Pass()); | 391 pass_list.push_back(pass.Pass()); |
397 | 392 |
398 EXPECT_TRUE(this->RunPixelTest( | 393 EXPECT_TRUE(this->RunPixelTest( |
399 &pass_list, | 394 &pass_list, |
400 PixelTest::NoOffscreenContext, | |
401 base::FilePath(FILE_PATH_LITERAL("green_alpha.png")), | 395 base::FilePath(FILE_PATH_LITERAL("green_alpha.png")), |
402 FuzzyPixelOffByOneComparator(true))); | 396 FuzzyPixelOffByOneComparator(true))); |
403 } | 397 } |
404 | 398 |
405 class VideoGLRendererPixelTest : public GLRendererPixelTest { | 399 class VideoGLRendererPixelTest : public GLRendererPixelTest { |
406 protected: | 400 protected: |
407 scoped_ptr<YUVVideoDrawQuad> CreateTestYUVVideoDrawQuad( | 401 scoped_ptr<YUVVideoDrawQuad> CreateTestYUVVideoDrawQuad( |
408 SharedQuadState* shared_state, | 402 SharedQuadState* shared_state, |
409 media::VideoFrame::Format format, | 403 media::VideoFrame::Format format, |
410 bool is_transparent, | 404 bool is_transparent, |
(...skipping 106 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
517 false, | 511 false, |
518 gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f)); | 512 gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f)); |
519 | 513 |
520 pass->quad_list.push_back(yuv_quad.PassAs<DrawQuad>()); | 514 pass->quad_list.push_back(yuv_quad.PassAs<DrawQuad>()); |
521 | 515 |
522 RenderPassList pass_list; | 516 RenderPassList pass_list; |
523 pass_list.push_back(pass.Pass()); | 517 pass_list.push_back(pass.Pass()); |
524 | 518 |
525 EXPECT_TRUE( | 519 EXPECT_TRUE( |
526 this->RunPixelTest(&pass_list, | 520 this->RunPixelTest(&pass_list, |
527 PixelTest::NoOffscreenContext, | |
528 base::FilePath(FILE_PATH_LITERAL("yuv_stripes.png")), | 521 base::FilePath(FILE_PATH_LITERAL("yuv_stripes.png")), |
529 FuzzyPixelOffByOneComparator(true))); | 522 FuzzyPixelOffByOneComparator(true))); |
530 } | 523 } |
531 | 524 |
532 TEST_F(VideoGLRendererPixelTest, OffsetYUVRect) { | 525 TEST_F(VideoGLRendererPixelTest, OffsetYUVRect) { |
533 gfx::Rect rect(this->device_viewport_size_); | 526 gfx::Rect rect(this->device_viewport_size_); |
534 | 527 |
535 RenderPass::Id id(1, 1); | 528 RenderPass::Id id(1, 1); |
536 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); | 529 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); |
537 | 530 |
538 scoped_ptr<SharedQuadState> shared_state = | 531 scoped_ptr<SharedQuadState> shared_state = |
539 CreateTestSharedQuadState(gfx::Transform(), rect); | 532 CreateTestSharedQuadState(gfx::Transform(), rect); |
540 | 533 |
541 // Intentionally sets frame format to I420 for testing coverage. | 534 // Intentionally sets frame format to I420 for testing coverage. |
542 scoped_ptr<YUVVideoDrawQuad> yuv_quad = | 535 scoped_ptr<YUVVideoDrawQuad> yuv_quad = |
543 CreateTestYUVVideoDrawQuad(shared_state.get(), | 536 CreateTestYUVVideoDrawQuad(shared_state.get(), |
544 media::VideoFrame::I420, | 537 media::VideoFrame::I420, |
545 false, | 538 false, |
546 gfx::RectF(0.125f, 0.25f, 0.75f, 0.5f)); | 539 gfx::RectF(0.125f, 0.25f, 0.75f, 0.5f)); |
547 | 540 |
548 pass->quad_list.push_back(yuv_quad.PassAs<DrawQuad>()); | 541 pass->quad_list.push_back(yuv_quad.PassAs<DrawQuad>()); |
549 | 542 |
550 RenderPassList pass_list; | 543 RenderPassList pass_list; |
551 pass_list.push_back(pass.Pass()); | 544 pass_list.push_back(pass.Pass()); |
552 | 545 |
553 EXPECT_TRUE(this->RunPixelTest( | 546 EXPECT_TRUE(this->RunPixelTest( |
554 &pass_list, | 547 &pass_list, |
555 PixelTest::NoOffscreenContext, | |
556 base::FilePath(FILE_PATH_LITERAL("yuv_stripes_offset.png")), | 548 base::FilePath(FILE_PATH_LITERAL("yuv_stripes_offset.png")), |
557 FuzzyPixelOffByOneComparator(true))); | 549 FuzzyPixelOffByOneComparator(true))); |
558 } | 550 } |
559 | 551 |
560 TEST_F(VideoGLRendererPixelTest, SimpleYUVARect) { | 552 TEST_F(VideoGLRendererPixelTest, SimpleYUVARect) { |
561 gfx::Rect rect(this->device_viewport_size_); | 553 gfx::Rect rect(this->device_viewport_size_); |
562 | 554 |
563 RenderPass::Id id(1, 1); | 555 RenderPass::Id id(1, 1); |
564 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); | 556 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); |
565 | 557 |
(...skipping 11 matching lines...) Expand all Loading... |
577 scoped_ptr<SolidColorDrawQuad> color_quad = SolidColorDrawQuad::Create(); | 569 scoped_ptr<SolidColorDrawQuad> color_quad = SolidColorDrawQuad::Create(); |
578 color_quad->SetNew(shared_state.get(), rect, rect, SK_ColorWHITE, false); | 570 color_quad->SetNew(shared_state.get(), rect, rect, SK_ColorWHITE, false); |
579 | 571 |
580 pass->quad_list.push_back(color_quad.PassAs<DrawQuad>()); | 572 pass->quad_list.push_back(color_quad.PassAs<DrawQuad>()); |
581 | 573 |
582 RenderPassList pass_list; | 574 RenderPassList pass_list; |
583 pass_list.push_back(pass.Pass()); | 575 pass_list.push_back(pass.Pass()); |
584 | 576 |
585 EXPECT_TRUE(this->RunPixelTest( | 577 EXPECT_TRUE(this->RunPixelTest( |
586 &pass_list, | 578 &pass_list, |
587 PixelTest::NoOffscreenContext, | |
588 base::FilePath(FILE_PATH_LITERAL("yuv_stripes_alpha.png")), | 579 base::FilePath(FILE_PATH_LITERAL("yuv_stripes_alpha.png")), |
589 FuzzyPixelOffByOneComparator(true))); | 580 FuzzyPixelOffByOneComparator(true))); |
590 } | 581 } |
591 | 582 |
592 TEST_F(VideoGLRendererPixelTest, FullyTransparentYUVARect) { | 583 TEST_F(VideoGLRendererPixelTest, FullyTransparentYUVARect) { |
593 gfx::Rect rect(this->device_viewport_size_); | 584 gfx::Rect rect(this->device_viewport_size_); |
594 | 585 |
595 RenderPass::Id id(1, 1); | 586 RenderPass::Id id(1, 1); |
596 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); | 587 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); |
597 | 588 |
(...skipping 11 matching lines...) Expand all Loading... |
609 scoped_ptr<SolidColorDrawQuad> color_quad = SolidColorDrawQuad::Create(); | 600 scoped_ptr<SolidColorDrawQuad> color_quad = SolidColorDrawQuad::Create(); |
610 color_quad->SetNew(shared_state.get(), rect, rect, SK_ColorBLACK, false); | 601 color_quad->SetNew(shared_state.get(), rect, rect, SK_ColorBLACK, false); |
611 | 602 |
612 pass->quad_list.push_back(color_quad.PassAs<DrawQuad>()); | 603 pass->quad_list.push_back(color_quad.PassAs<DrawQuad>()); |
613 | 604 |
614 RenderPassList pass_list; | 605 RenderPassList pass_list; |
615 pass_list.push_back(pass.Pass()); | 606 pass_list.push_back(pass.Pass()); |
616 | 607 |
617 EXPECT_TRUE(this->RunPixelTest( | 608 EXPECT_TRUE(this->RunPixelTest( |
618 &pass_list, | 609 &pass_list, |
619 PixelTest::NoOffscreenContext, | |
620 base::FilePath(FILE_PATH_LITERAL("black.png")), | 610 base::FilePath(FILE_PATH_LITERAL("black.png")), |
621 ExactPixelComparator(true))); | 611 ExactPixelComparator(true))); |
622 } | 612 } |
623 | 613 |
624 TYPED_TEST(RendererPixelTest, FastPassColorFilterAlpha) { | 614 TYPED_TEST(RendererPixelTest, FastPassColorFilterAlpha) { |
625 gfx::Rect viewport_rect(this->device_viewport_size_); | 615 gfx::Rect viewport_rect(this->device_viewport_size_); |
626 | 616 |
627 RenderPass::Id root_pass_id(1, 1); | 617 RenderPass::Id root_pass_id(1, 1); |
628 scoped_ptr<RenderPass> root_pass = | 618 scoped_ptr<RenderPass> root_pass = |
629 CreateTestRootRenderPass(root_pass_id, viewport_rect); | 619 CreateTestRootRenderPass(root_pass_id, viewport_rect); |
(...skipping 76 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
706 root_pass->quad_list.push_back(render_pass_quad.PassAs<DrawQuad>()); | 696 root_pass->quad_list.push_back(render_pass_quad.PassAs<DrawQuad>()); |
707 | 697 |
708 RenderPassList pass_list; | 698 RenderPassList pass_list; |
709 pass_list.push_back(child_pass.Pass()); | 699 pass_list.push_back(child_pass.Pass()); |
710 pass_list.push_back(root_pass.Pass()); | 700 pass_list.push_back(root_pass.Pass()); |
711 | 701 |
712 // This test has alpha=254 for the software renderer vs. alpha=255 for the gl | 702 // This test has alpha=254 for the software renderer vs. alpha=255 for the gl |
713 // renderer so use a fuzzy comparator. | 703 // renderer so use a fuzzy comparator. |
714 EXPECT_TRUE(this->RunPixelTest( | 704 EXPECT_TRUE(this->RunPixelTest( |
715 &pass_list, | 705 &pass_list, |
716 PixelTest::NoOffscreenContext, | |
717 base::FilePath(FILE_PATH_LITERAL("blue_yellow_alpha.png")), | 706 base::FilePath(FILE_PATH_LITERAL("blue_yellow_alpha.png")), |
718 FuzzyForSoftwareOnlyPixelComparator<TypeParam>(false))); | 707 FuzzyForSoftwareOnlyPixelComparator<TypeParam>(false))); |
719 } | 708 } |
720 | 709 |
721 TYPED_TEST(RendererPixelTest, FastPassSaturateFilter) { | 710 TYPED_TEST(RendererPixelTest, FastPassSaturateFilter) { |
722 gfx::Rect viewport_rect(this->device_viewport_size_); | 711 gfx::Rect viewport_rect(this->device_viewport_size_); |
723 | 712 |
724 RenderPass::Id root_pass_id(1, 1); | 713 RenderPass::Id root_pass_id(1, 1); |
725 scoped_ptr<RenderPass> root_pass = | 714 scoped_ptr<RenderPass> root_pass = |
726 CreateTestRootRenderPass(root_pass_id, viewport_rect); | 715 CreateTestRootRenderPass(root_pass_id, viewport_rect); |
(...skipping 54 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
781 FilterOperations()); | 770 FilterOperations()); |
782 | 771 |
783 root_pass->quad_list.push_back(render_pass_quad.PassAs<DrawQuad>()); | 772 root_pass->quad_list.push_back(render_pass_quad.PassAs<DrawQuad>()); |
784 | 773 |
785 RenderPassList pass_list; | 774 RenderPassList pass_list; |
786 pass_list.push_back(child_pass.Pass()); | 775 pass_list.push_back(child_pass.Pass()); |
787 pass_list.push_back(root_pass.Pass()); | 776 pass_list.push_back(root_pass.Pass()); |
788 | 777 |
789 EXPECT_TRUE(this->RunPixelTest( | 778 EXPECT_TRUE(this->RunPixelTest( |
790 &pass_list, | 779 &pass_list, |
791 PixelTest::NoOffscreenContext, | |
792 base::FilePath(FILE_PATH_LITERAL("blue_yellow_alpha.png")), | 780 base::FilePath(FILE_PATH_LITERAL("blue_yellow_alpha.png")), |
793 ExactPixelComparator(true))); | 781 ExactPixelComparator(true))); |
794 } | 782 } |
795 | 783 |
796 TYPED_TEST(RendererPixelTest, FastPassFilterChain) { | 784 TYPED_TEST(RendererPixelTest, FastPassFilterChain) { |
797 gfx::Rect viewport_rect(this->device_viewport_size_); | 785 gfx::Rect viewport_rect(this->device_viewport_size_); |
798 | 786 |
799 RenderPass::Id root_pass_id(1, 1); | 787 RenderPass::Id root_pass_id(1, 1); |
800 scoped_ptr<RenderPass> root_pass = | 788 scoped_ptr<RenderPass> root_pass = |
801 CreateTestRootRenderPass(root_pass_id, viewport_rect); | 789 CreateTestRootRenderPass(root_pass_id, viewport_rect); |
(...skipping 55 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
857 FilterOperations()); | 845 FilterOperations()); |
858 | 846 |
859 root_pass->quad_list.push_back(render_pass_quad.PassAs<DrawQuad>()); | 847 root_pass->quad_list.push_back(render_pass_quad.PassAs<DrawQuad>()); |
860 | 848 |
861 RenderPassList pass_list; | 849 RenderPassList pass_list; |
862 pass_list.push_back(child_pass.Pass()); | 850 pass_list.push_back(child_pass.Pass()); |
863 pass_list.push_back(root_pass.Pass()); | 851 pass_list.push_back(root_pass.Pass()); |
864 | 852 |
865 EXPECT_TRUE(this->RunPixelTest( | 853 EXPECT_TRUE(this->RunPixelTest( |
866 &pass_list, | 854 &pass_list, |
867 PixelTest::NoOffscreenContext, | |
868 base::FilePath(FILE_PATH_LITERAL("blue_yellow_filter_chain.png")), | 855 base::FilePath(FILE_PATH_LITERAL("blue_yellow_filter_chain.png")), |
869 ExactPixelComparator(true))); | 856 ExactPixelComparator(true))); |
870 } | 857 } |
871 | 858 |
872 TYPED_TEST(RendererPixelTest, FastPassColorFilterAlphaTranslation) { | 859 TYPED_TEST(RendererPixelTest, FastPassColorFilterAlphaTranslation) { |
873 gfx::Rect viewport_rect(this->device_viewport_size_); | 860 gfx::Rect viewport_rect(this->device_viewport_size_); |
874 | 861 |
875 RenderPass::Id root_pass_id(1, 1); | 862 RenderPass::Id root_pass_id(1, 1); |
876 scoped_ptr<RenderPass> root_pass = | 863 scoped_ptr<RenderPass> root_pass = |
877 CreateTestRootRenderPass(root_pass_id, viewport_rect); | 864 CreateTestRootRenderPass(root_pass_id, viewport_rect); |
(...skipping 79 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
957 root_pass->quad_list.push_back(render_pass_quad.PassAs<DrawQuad>()); | 944 root_pass->quad_list.push_back(render_pass_quad.PassAs<DrawQuad>()); |
958 RenderPassList pass_list; | 945 RenderPassList pass_list; |
959 | 946 |
960 pass_list.push_back(child_pass.Pass()); | 947 pass_list.push_back(child_pass.Pass()); |
961 pass_list.push_back(root_pass.Pass()); | 948 pass_list.push_back(root_pass.Pass()); |
962 | 949 |
963 // This test has alpha=254 for the software renderer vs. alpha=255 for the gl | 950 // This test has alpha=254 for the software renderer vs. alpha=255 for the gl |
964 // renderer so use a fuzzy comparator. | 951 // renderer so use a fuzzy comparator. |
965 EXPECT_TRUE(this->RunPixelTest( | 952 EXPECT_TRUE(this->RunPixelTest( |
966 &pass_list, | 953 &pass_list, |
967 PixelTest::NoOffscreenContext, | |
968 base::FilePath(FILE_PATH_LITERAL("blue_yellow_alpha_translate.png")), | 954 base::FilePath(FILE_PATH_LITERAL("blue_yellow_alpha_translate.png")), |
969 FuzzyForSoftwareOnlyPixelComparator<TypeParam>(false))); | 955 FuzzyForSoftwareOnlyPixelComparator<TypeParam>(false))); |
970 } | 956 } |
971 | 957 |
972 TYPED_TEST(RendererPixelTest, EnlargedRenderPassTexture) { | 958 TYPED_TEST(RendererPixelTest, EnlargedRenderPassTexture) { |
973 gfx::Rect viewport_rect(this->device_viewport_size_); | 959 gfx::Rect viewport_rect(this->device_viewport_size_); |
974 | 960 |
975 RenderPass::Id root_pass_id(1, 1); | 961 RenderPass::Id root_pass_id(1, 1); |
976 scoped_ptr<RenderPass> root_pass = | 962 scoped_ptr<RenderPass> root_pass = |
977 CreateTestRootRenderPass(root_pass_id, viewport_rect); | 963 CreateTestRootRenderPass(root_pass_id, viewport_rect); |
(...skipping 33 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1011 child_pass_id)); | 997 child_pass_id)); |
1012 | 998 |
1013 RenderPassList pass_list; | 999 RenderPassList pass_list; |
1014 pass_list.push_back(child_pass.Pass()); | 1000 pass_list.push_back(child_pass.Pass()); |
1015 pass_list.push_back(root_pass.Pass()); | 1001 pass_list.push_back(root_pass.Pass()); |
1016 | 1002 |
1017 this->renderer_->SetEnlargePassTextureAmountForTesting(gfx::Vector2d(50, 75)); | 1003 this->renderer_->SetEnlargePassTextureAmountForTesting(gfx::Vector2d(50, 75)); |
1018 | 1004 |
1019 EXPECT_TRUE(this->RunPixelTest( | 1005 EXPECT_TRUE(this->RunPixelTest( |
1020 &pass_list, | 1006 &pass_list, |
1021 PixelTest::NoOffscreenContext, | |
1022 base::FilePath(FILE_PATH_LITERAL("blue_yellow.png")), | 1007 base::FilePath(FILE_PATH_LITERAL("blue_yellow.png")), |
1023 ExactPixelComparator(true))); | 1008 ExactPixelComparator(true))); |
1024 } | 1009 } |
1025 | 1010 |
1026 TYPED_TEST(RendererPixelTest, EnlargedRenderPassTextureWithAntiAliasing) { | 1011 TYPED_TEST(RendererPixelTest, EnlargedRenderPassTextureWithAntiAliasing) { |
1027 gfx::Rect viewport_rect(this->device_viewport_size_); | 1012 gfx::Rect viewport_rect(this->device_viewport_size_); |
1028 | 1013 |
1029 RenderPass::Id root_pass_id(1, 1); | 1014 RenderPass::Id root_pass_id(1, 1); |
1030 scoped_ptr<RenderPass> root_pass = | 1015 scoped_ptr<RenderPass> root_pass = |
1031 CreateTestRootRenderPass(root_pass_id, viewport_rect); | 1016 CreateTestRootRenderPass(root_pass_id, viewport_rect); |
(...skipping 46 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1078 root_pass->quad_list.push_back(background.PassAs<DrawQuad>()); | 1063 root_pass->quad_list.push_back(background.PassAs<DrawQuad>()); |
1079 | 1064 |
1080 RenderPassList pass_list; | 1065 RenderPassList pass_list; |
1081 pass_list.push_back(child_pass.Pass()); | 1066 pass_list.push_back(child_pass.Pass()); |
1082 pass_list.push_back(root_pass.Pass()); | 1067 pass_list.push_back(root_pass.Pass()); |
1083 | 1068 |
1084 this->renderer_->SetEnlargePassTextureAmountForTesting(gfx::Vector2d(50, 75)); | 1069 this->renderer_->SetEnlargePassTextureAmountForTesting(gfx::Vector2d(50, 75)); |
1085 | 1070 |
1086 EXPECT_TRUE(this->RunPixelTest( | 1071 EXPECT_TRUE(this->RunPixelTest( |
1087 &pass_list, | 1072 &pass_list, |
1088 PixelTest::NoOffscreenContext, | |
1089 base::FilePath(FILE_PATH_LITERAL("blue_yellow_anti_aliasing.png")), | 1073 base::FilePath(FILE_PATH_LITERAL("blue_yellow_anti_aliasing.png")), |
1090 FuzzyPixelOffByOneComparator(true))); | 1074 FuzzyPixelOffByOneComparator(true))); |
1091 } | 1075 } |
1092 | 1076 |
1093 // This tests the case where we have a RenderPass with a mask, but the quad | 1077 // This tests the case where we have a RenderPass with a mask, but the quad |
1094 // for the masked surface does not include the full surface texture. | 1078 // for the masked surface does not include the full surface texture. |
1095 TYPED_TEST(RendererPixelTest, RenderPassAndMaskWithPartialQuad) { | 1079 TYPED_TEST(RendererPixelTest, RenderPassAndMaskWithPartialQuad) { |
1096 gfx::Rect viewport_rect(this->device_viewport_size_); | 1080 gfx::Rect viewport_rect(this->device_viewport_size_); |
1097 | 1081 |
1098 RenderPass::Id root_pass_id(1, 1); | 1082 RenderPass::Id root_pass_id(1, 1); |
(...skipping 86 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1185 SK_ColorWHITE, | 1169 SK_ColorWHITE, |
1186 false); | 1170 false); |
1187 root_pass->quad_list.push_back(white.PassAs<DrawQuad>()); | 1171 root_pass->quad_list.push_back(white.PassAs<DrawQuad>()); |
1188 | 1172 |
1189 RenderPassList pass_list; | 1173 RenderPassList pass_list; |
1190 pass_list.push_back(child_pass.Pass()); | 1174 pass_list.push_back(child_pass.Pass()); |
1191 pass_list.push_back(root_pass.Pass()); | 1175 pass_list.push_back(root_pass.Pass()); |
1192 | 1176 |
1193 EXPECT_TRUE(this->RunPixelTest( | 1177 EXPECT_TRUE(this->RunPixelTest( |
1194 &pass_list, | 1178 &pass_list, |
1195 PixelTest::NoOffscreenContext, | |
1196 base::FilePath(FILE_PATH_LITERAL("image_mask_of_layer.png")), | 1179 base::FilePath(FILE_PATH_LITERAL("image_mask_of_layer.png")), |
1197 ExactPixelComparator(true))); | 1180 ExactPixelComparator(true))); |
1198 } | 1181 } |
1199 | 1182 |
1200 template <typename RendererType> | 1183 template <typename RendererType> |
1201 class RendererPixelTestWithBackgroundFilter | 1184 class RendererPixelTestWithBackgroundFilter |
1202 : public RendererPixelTest<RendererType> { | 1185 : public RendererPixelTest<RendererType> { |
1203 protected: | 1186 protected: |
1204 void SetUpRenderPassList() { | 1187 void SetUpRenderPassList() { |
1205 gfx::Rect device_viewport_rect(this->device_viewport_size_); | 1188 gfx::Rect device_viewport_rect(this->device_viewport_size_); |
(...skipping 124 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1330 TEST_F(GLRendererPixelTestWithBackgroundFilter, InvertFilter) { | 1313 TEST_F(GLRendererPixelTestWithBackgroundFilter, InvertFilter) { |
1331 this->background_filters_.Append( | 1314 this->background_filters_.Append( |
1332 FilterOperation::CreateInvertFilter(1.f)); | 1315 FilterOperation::CreateInvertFilter(1.f)); |
1333 | 1316 |
1334 this->filter_pass_content_rect_ = gfx::Rect(this->device_viewport_size_); | 1317 this->filter_pass_content_rect_ = gfx::Rect(this->device_viewport_size_); |
1335 this->filter_pass_content_rect_.Inset(12, 14, 16, 18); | 1318 this->filter_pass_content_rect_.Inset(12, 14, 16, 18); |
1336 | 1319 |
1337 this->SetUpRenderPassList(); | 1320 this->SetUpRenderPassList(); |
1338 EXPECT_TRUE(this->RunPixelTest( | 1321 EXPECT_TRUE(this->RunPixelTest( |
1339 &this->pass_list_, | 1322 &this->pass_list_, |
1340 PixelTest::WithOffscreenContext, | |
1341 base::FilePath(FILE_PATH_LITERAL("background_filter.png")), | 1323 base::FilePath(FILE_PATH_LITERAL("background_filter.png")), |
1342 ExactPixelComparator(true))); | 1324 ExactPixelComparator(true))); |
1343 } | 1325 } |
1344 | 1326 |
1345 class ExternalStencilPixelTest : public GLRendererPixelTest { | 1327 class ExternalStencilPixelTest : public GLRendererPixelTest { |
1346 protected: | 1328 protected: |
1347 void ClearBackgroundToGreen() { | 1329 void ClearBackgroundToGreen() { |
1348 GLES2Interface* gl = output_surface_->context_provider()->ContextGL(); | 1330 GLES2Interface* gl = output_surface_->context_provider()->ContextGL(); |
1349 output_surface_->EnsureBackbuffer(); | 1331 output_surface_->EnsureBackbuffer(); |
1350 output_surface_->Reshape(device_viewport_size_, 1); | 1332 output_surface_->Reshape(device_viewport_size_, 1); |
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1388 CreateTestSharedQuadState(gfx::Transform(), rect); | 1370 CreateTestSharedQuadState(gfx::Transform(), rect); |
1389 scoped_ptr<SolidColorDrawQuad> blue = SolidColorDrawQuad::Create(); | 1371 scoped_ptr<SolidColorDrawQuad> blue = SolidColorDrawQuad::Create(); |
1390 blue->SetNew(blue_shared_state.get(), rect, rect, SK_ColorBLUE, false); | 1372 blue->SetNew(blue_shared_state.get(), rect, rect, SK_ColorBLUE, false); |
1391 pass->quad_list.push_back(blue.PassAs<DrawQuad>()); | 1373 pass->quad_list.push_back(blue.PassAs<DrawQuad>()); |
1392 pass->has_transparent_background = false; | 1374 pass->has_transparent_background = false; |
1393 RenderPassList pass_list; | 1375 RenderPassList pass_list; |
1394 pass_list.push_back(pass.Pass()); | 1376 pass_list.push_back(pass.Pass()); |
1395 | 1377 |
1396 EXPECT_TRUE(this->RunPixelTest( | 1378 EXPECT_TRUE(this->RunPixelTest( |
1397 &pass_list, | 1379 &pass_list, |
1398 PixelTest::NoOffscreenContext, | |
1399 base::FilePath(FILE_PATH_LITERAL("four_blue_green_checkers.png")), | 1380 base::FilePath(FILE_PATH_LITERAL("four_blue_green_checkers.png")), |
1400 ExactPixelComparator(true))); | 1381 ExactPixelComparator(true))); |
1401 } | 1382 } |
1402 | 1383 |
1403 TEST_F(ExternalStencilPixelTest, StencilTestDisabled) { | 1384 TEST_F(ExternalStencilPixelTest, StencilTestDisabled) { |
1404 PopulateStencilBuffer(); | 1385 PopulateStencilBuffer(); |
1405 | 1386 |
1406 // Draw a green quad that covers the entire device viewport. The stencil | 1387 // Draw a green quad that covers the entire device viewport. The stencil |
1407 // buffer should be ignored. | 1388 // buffer should be ignored. |
1408 gfx::Rect rect(this->device_viewport_size_); | 1389 gfx::Rect rect(this->device_viewport_size_); |
1409 RenderPass::Id id(1, 1); | 1390 RenderPass::Id id(1, 1); |
1410 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); | 1391 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); |
1411 scoped_ptr<SharedQuadState> green_shared_state = | 1392 scoped_ptr<SharedQuadState> green_shared_state = |
1412 CreateTestSharedQuadState(gfx::Transform(), rect); | 1393 CreateTestSharedQuadState(gfx::Transform(), rect); |
1413 scoped_ptr<SolidColorDrawQuad> green = SolidColorDrawQuad::Create(); | 1394 scoped_ptr<SolidColorDrawQuad> green = SolidColorDrawQuad::Create(); |
1414 green->SetNew(green_shared_state.get(), rect, rect, SK_ColorGREEN, false); | 1395 green->SetNew(green_shared_state.get(), rect, rect, SK_ColorGREEN, false); |
1415 pass->quad_list.push_back(green.PassAs<DrawQuad>()); | 1396 pass->quad_list.push_back(green.PassAs<DrawQuad>()); |
1416 RenderPassList pass_list; | 1397 RenderPassList pass_list; |
1417 pass_list.push_back(pass.Pass()); | 1398 pass_list.push_back(pass.Pass()); |
1418 | 1399 |
1419 EXPECT_TRUE(this->RunPixelTest( | 1400 EXPECT_TRUE(this->RunPixelTest( |
1420 &pass_list, | 1401 &pass_list, |
1421 PixelTest::NoOffscreenContext, | |
1422 base::FilePath(FILE_PATH_LITERAL("green.png")), | 1402 base::FilePath(FILE_PATH_LITERAL("green.png")), |
1423 ExactPixelComparator(true))); | 1403 ExactPixelComparator(true))); |
1424 } | 1404 } |
1425 | 1405 |
1426 TEST_F(ExternalStencilPixelTest, RenderSurfacesIgnoreStencil) { | 1406 TEST_F(ExternalStencilPixelTest, RenderSurfacesIgnoreStencil) { |
1427 // The stencil test should apply only to the final render pass. | 1407 // The stencil test should apply only to the final render pass. |
1428 ClearBackgroundToGreen(); | 1408 ClearBackgroundToGreen(); |
1429 PopulateStencilBuffer(); | 1409 PopulateStencilBuffer(); |
1430 this->EnableExternalStencilTest(); | 1410 this->EnableExternalStencilTest(); |
1431 | 1411 |
(...skipping 27 matching lines...) Expand all Loading... |
1459 root_pass->quad_list.push_back( | 1439 root_pass->quad_list.push_back( |
1460 CreateTestRenderPassDrawQuad(pass_shared_state.get(), | 1440 CreateTestRenderPassDrawQuad(pass_shared_state.get(), |
1461 pass_rect, | 1441 pass_rect, |
1462 child_pass_id)); | 1442 child_pass_id)); |
1463 RenderPassList pass_list; | 1443 RenderPassList pass_list; |
1464 pass_list.push_back(child_pass.Pass()); | 1444 pass_list.push_back(child_pass.Pass()); |
1465 pass_list.push_back(root_pass.Pass()); | 1445 pass_list.push_back(root_pass.Pass()); |
1466 | 1446 |
1467 EXPECT_TRUE(this->RunPixelTest( | 1447 EXPECT_TRUE(this->RunPixelTest( |
1468 &pass_list, | 1448 &pass_list, |
1469 PixelTest::NoOffscreenContext, | |
1470 base::FilePath(FILE_PATH_LITERAL("four_blue_green_checkers.png")), | 1449 base::FilePath(FILE_PATH_LITERAL("four_blue_green_checkers.png")), |
1471 ExactPixelComparator(true))); | 1450 ExactPixelComparator(true))); |
1472 } | 1451 } |
1473 | 1452 |
1474 TEST_F(ExternalStencilPixelTest, DeviceClip) { | 1453 TEST_F(ExternalStencilPixelTest, DeviceClip) { |
1475 ClearBackgroundToGreen(); | 1454 ClearBackgroundToGreen(); |
1476 gfx::Rect clip_rect(gfx::Point(150, 150), gfx::Size(50, 50)); | 1455 gfx::Rect clip_rect(gfx::Point(150, 150), gfx::Size(50, 50)); |
1477 this->ForceDeviceClip(clip_rect); | 1456 this->ForceDeviceClip(clip_rect); |
1478 | 1457 |
1479 // Draw a blue quad that covers the entire device viewport. It should be | 1458 // Draw a blue quad that covers the entire device viewport. It should be |
1480 // clipped to the bottom right corner by the device clip. | 1459 // clipped to the bottom right corner by the device clip. |
1481 gfx::Rect rect(this->device_viewport_size_); | 1460 gfx::Rect rect(this->device_viewport_size_); |
1482 RenderPass::Id id(1, 1); | 1461 RenderPass::Id id(1, 1); |
1483 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); | 1462 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); |
1484 scoped_ptr<SharedQuadState> blue_shared_state = | 1463 scoped_ptr<SharedQuadState> blue_shared_state = |
1485 CreateTestSharedQuadState(gfx::Transform(), rect); | 1464 CreateTestSharedQuadState(gfx::Transform(), rect); |
1486 scoped_ptr<SolidColorDrawQuad> blue = SolidColorDrawQuad::Create(); | 1465 scoped_ptr<SolidColorDrawQuad> blue = SolidColorDrawQuad::Create(); |
1487 blue->SetNew(blue_shared_state.get(), rect, rect, SK_ColorBLUE, false); | 1466 blue->SetNew(blue_shared_state.get(), rect, rect, SK_ColorBLUE, false); |
1488 pass->quad_list.push_back(blue.PassAs<DrawQuad>()); | 1467 pass->quad_list.push_back(blue.PassAs<DrawQuad>()); |
1489 RenderPassList pass_list; | 1468 RenderPassList pass_list; |
1490 pass_list.push_back(pass.Pass()); | 1469 pass_list.push_back(pass.Pass()); |
1491 | 1470 |
1492 EXPECT_TRUE(this->RunPixelTest( | 1471 EXPECT_TRUE(this->RunPixelTest( |
1493 &pass_list, | 1472 &pass_list, |
1494 PixelTest::NoOffscreenContext, | |
1495 base::FilePath(FILE_PATH_LITERAL("green_with_blue_corner.png")), | 1473 base::FilePath(FILE_PATH_LITERAL("green_with_blue_corner.png")), |
1496 ExactPixelComparator(true))); | 1474 ExactPixelComparator(true))); |
1497 } | 1475 } |
1498 | 1476 |
1499 // Software renderer does not support anti-aliased edges. | 1477 // Software renderer does not support anti-aliased edges. |
1500 TEST_F(GLRendererPixelTest, AntiAliasing) { | 1478 TEST_F(GLRendererPixelTest, AntiAliasing) { |
1501 gfx::Rect rect(this->device_viewport_size_); | 1479 gfx::Rect rect(this->device_viewport_size_); |
1502 | 1480 |
1503 RenderPass::Id id(1, 1); | 1481 RenderPass::Id id(1, 1); |
1504 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); | 1482 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); |
(...skipping 25 matching lines...) Expand all Loading... |
1530 scoped_ptr<SolidColorDrawQuad> blue = SolidColorDrawQuad::Create(); | 1508 scoped_ptr<SolidColorDrawQuad> blue = SolidColorDrawQuad::Create(); |
1531 blue->SetNew(blue_shared_state.get(), rect, rect, SK_ColorBLUE, false); | 1509 blue->SetNew(blue_shared_state.get(), rect, rect, SK_ColorBLUE, false); |
1532 | 1510 |
1533 pass->quad_list.push_back(blue.PassAs<DrawQuad>()); | 1511 pass->quad_list.push_back(blue.PassAs<DrawQuad>()); |
1534 | 1512 |
1535 RenderPassList pass_list; | 1513 RenderPassList pass_list; |
1536 pass_list.push_back(pass.Pass()); | 1514 pass_list.push_back(pass.Pass()); |
1537 | 1515 |
1538 EXPECT_TRUE(this->RunPixelTest( | 1516 EXPECT_TRUE(this->RunPixelTest( |
1539 &pass_list, | 1517 &pass_list, |
1540 PixelTest::NoOffscreenContext, | |
1541 base::FilePath(FILE_PATH_LITERAL("anti_aliasing.png")), | 1518 base::FilePath(FILE_PATH_LITERAL("anti_aliasing.png")), |
1542 FuzzyPixelOffByOneComparator(true))); | 1519 FuzzyPixelOffByOneComparator(true))); |
1543 } | 1520 } |
1544 | 1521 |
1545 // This test tests that anti-aliasing works for axis aligned quads. | 1522 // This test tests that anti-aliasing works for axis aligned quads. |
1546 // Anti-aliasing is only supported in the gl renderer. | 1523 // Anti-aliasing is only supported in the gl renderer. |
1547 TEST_F(GLRendererPixelTest, AxisAligned) { | 1524 TEST_F(GLRendererPixelTest, AxisAligned) { |
1548 gfx::Rect rect(this->device_viewport_size_); | 1525 gfx::Rect rect(this->device_viewport_size_); |
1549 | 1526 |
1550 RenderPass::Id id(1, 1); | 1527 RenderPass::Id id(1, 1); |
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1583 scoped_ptr<SolidColorDrawQuad> blue = SolidColorDrawQuad::Create(); | 1560 scoped_ptr<SolidColorDrawQuad> blue = SolidColorDrawQuad::Create(); |
1584 blue->SetNew(blue_shared_state.get(), rect, rect, SK_ColorBLUE, false); | 1561 blue->SetNew(blue_shared_state.get(), rect, rect, SK_ColorBLUE, false); |
1585 | 1562 |
1586 pass->quad_list.push_back(blue.PassAs<DrawQuad>()); | 1563 pass->quad_list.push_back(blue.PassAs<DrawQuad>()); |
1587 | 1564 |
1588 RenderPassList pass_list; | 1565 RenderPassList pass_list; |
1589 pass_list.push_back(pass.Pass()); | 1566 pass_list.push_back(pass.Pass()); |
1590 | 1567 |
1591 EXPECT_TRUE(this->RunPixelTest( | 1568 EXPECT_TRUE(this->RunPixelTest( |
1592 &pass_list, | 1569 &pass_list, |
1593 PixelTest::NoOffscreenContext, | |
1594 base::FilePath(FILE_PATH_LITERAL("axis_aligned.png")), | 1570 base::FilePath(FILE_PATH_LITERAL("axis_aligned.png")), |
1595 ExactPixelComparator(true))); | 1571 ExactPixelComparator(true))); |
1596 } | 1572 } |
1597 | 1573 |
1598 // This test tests that forcing anti-aliasing off works as expected. | 1574 // This test tests that forcing anti-aliasing off works as expected. |
1599 // Anti-aliasing is only supported in the gl renderer. | 1575 // Anti-aliasing is only supported in the gl renderer. |
1600 TEST_F(GLRendererPixelTest, ForceAntiAliasingOff) { | 1576 TEST_F(GLRendererPixelTest, ForceAntiAliasingOff) { |
1601 gfx::Rect rect(this->device_viewport_size_); | 1577 gfx::Rect rect(this->device_viewport_size_); |
1602 | 1578 |
1603 RenderPass::Id id(1, 1); | 1579 RenderPass::Id id(1, 1); |
(...skipping 21 matching lines...) Expand all Loading... |
1625 scoped_ptr<SolidColorDrawQuad> green = SolidColorDrawQuad::Create(); | 1601 scoped_ptr<SolidColorDrawQuad> green = SolidColorDrawQuad::Create(); |
1626 green->SetNew(green_shared_state.get(), rect, rect, SK_ColorGREEN, false); | 1602 green->SetNew(green_shared_state.get(), rect, rect, SK_ColorGREEN, false); |
1627 | 1603 |
1628 pass->quad_list.push_back(green.PassAs<DrawQuad>()); | 1604 pass->quad_list.push_back(green.PassAs<DrawQuad>()); |
1629 | 1605 |
1630 RenderPassList pass_list; | 1606 RenderPassList pass_list; |
1631 pass_list.push_back(pass.Pass()); | 1607 pass_list.push_back(pass.Pass()); |
1632 | 1608 |
1633 EXPECT_TRUE(this->RunPixelTest( | 1609 EXPECT_TRUE(this->RunPixelTest( |
1634 &pass_list, | 1610 &pass_list, |
1635 PixelTest::NoOffscreenContext, | |
1636 base::FilePath(FILE_PATH_LITERAL("force_anti_aliasing_off.png")), | 1611 base::FilePath(FILE_PATH_LITERAL("force_anti_aliasing_off.png")), |
1637 ExactPixelComparator(false))); | 1612 ExactPixelComparator(false))); |
1638 } | 1613 } |
1639 | 1614 |
1640 TEST_F(GLRendererPixelTest, AntiAliasingPerspective) { | 1615 TEST_F(GLRendererPixelTest, AntiAliasingPerspective) { |
1641 gfx::Rect rect(this->device_viewport_size_); | 1616 gfx::Rect rect(this->device_viewport_size_); |
1642 | 1617 |
1643 scoped_ptr<RenderPass> pass = | 1618 scoped_ptr<RenderPass> pass = |
1644 CreateTestRootRenderPass(RenderPass::Id(1, 1), rect); | 1619 CreateTestRootRenderPass(RenderPass::Id(1, 1), rect); |
1645 | 1620 |
(...skipping 21 matching lines...) Expand all Loading... |
1667 CreateTestSharedQuadState(gfx::Transform(), rect); | 1642 CreateTestSharedQuadState(gfx::Transform(), rect); |
1668 scoped_ptr<SolidColorDrawQuad> blue = SolidColorDrawQuad::Create(); | 1643 scoped_ptr<SolidColorDrawQuad> blue = SolidColorDrawQuad::Create(); |
1669 blue->SetNew(blue_shared_state.get(), rect, rect, SK_ColorBLUE, false); | 1644 blue->SetNew(blue_shared_state.get(), rect, rect, SK_ColorBLUE, false); |
1670 pass->quad_list.push_back(blue.PassAs<DrawQuad>()); | 1645 pass->quad_list.push_back(blue.PassAs<DrawQuad>()); |
1671 | 1646 |
1672 RenderPassList pass_list; | 1647 RenderPassList pass_list; |
1673 pass_list.push_back(pass.Pass()); | 1648 pass_list.push_back(pass.Pass()); |
1674 | 1649 |
1675 EXPECT_TRUE(this->RunPixelTest( | 1650 EXPECT_TRUE(this->RunPixelTest( |
1676 &pass_list, | 1651 &pass_list, |
1677 PixelTest::NoOffscreenContext, | |
1678 base::FilePath(FILE_PATH_LITERAL("anti_aliasing_perspective.png")), | 1652 base::FilePath(FILE_PATH_LITERAL("anti_aliasing_perspective.png")), |
1679 FuzzyPixelOffByOneComparator(true))); | 1653 FuzzyPixelOffByOneComparator(true))); |
1680 } | 1654 } |
1681 | 1655 |
1682 TYPED_TEST(RendererPixelTest, PictureDrawQuadIdentityScale) { | 1656 TYPED_TEST(RendererPixelTest, PictureDrawQuadIdentityScale) { |
1683 gfx::Size pile_tile_size(1000, 1000); | 1657 gfx::Size pile_tile_size(1000, 1000); |
1684 gfx::Rect viewport(this->device_viewport_size_); | 1658 gfx::Rect viewport(this->device_viewport_size_); |
1685 // TODO(enne): the renderer should figure this out on its own. | 1659 // TODO(enne): the renderer should figure this out on its own. |
1686 ResourceFormat texture_format = RGBA_8888; | 1660 ResourceFormat texture_format = RGBA_8888; |
1687 | 1661 |
(...skipping 63 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1751 viewport, | 1725 viewport, |
1752 1.f, | 1726 1.f, |
1753 PicturePileImpl::CreateFromOther(green_pile)); | 1727 PicturePileImpl::CreateFromOther(green_pile)); |
1754 pass->quad_list.push_back(green_quad.PassAs<DrawQuad>()); | 1728 pass->quad_list.push_back(green_quad.PassAs<DrawQuad>()); |
1755 | 1729 |
1756 RenderPassList pass_list; | 1730 RenderPassList pass_list; |
1757 pass_list.push_back(pass.Pass()); | 1731 pass_list.push_back(pass.Pass()); |
1758 | 1732 |
1759 EXPECT_TRUE(this->RunPixelTest( | 1733 EXPECT_TRUE(this->RunPixelTest( |
1760 &pass_list, | 1734 &pass_list, |
1761 PixelTest::NoOffscreenContext, | |
1762 base::FilePath(FILE_PATH_LITERAL("green_with_blue_corner.png")), | 1735 base::FilePath(FILE_PATH_LITERAL("green_with_blue_corner.png")), |
1763 ExactPixelComparator(true))); | 1736 ExactPixelComparator(true))); |
1764 } | 1737 } |
1765 | 1738 |
1766 // Not WithSkiaGPUBackend since that path currently requires tiles for opacity. | 1739 // Not WithSkiaGPUBackend since that path currently requires tiles for opacity. |
1767 TYPED_TEST(RendererPixelTest, PictureDrawQuadOpacity) { | 1740 TYPED_TEST(RendererPixelTest, PictureDrawQuadOpacity) { |
1768 gfx::Size pile_tile_size(1000, 1000); | 1741 gfx::Size pile_tile_size(1000, 1000); |
1769 gfx::Rect viewport(this->device_viewport_size_); | 1742 gfx::Rect viewport(this->device_viewport_size_); |
1770 ResourceFormat texture_format = RGBA_8888; | 1743 ResourceFormat texture_format = RGBA_8888; |
1771 | 1744 |
(...skipping 51 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1823 viewport, | 1796 viewport, |
1824 1.f, | 1797 1.f, |
1825 PicturePileImpl::CreateFromOther(white_pile)); | 1798 PicturePileImpl::CreateFromOther(white_pile)); |
1826 pass->quad_list.push_back(white_quad.PassAs<DrawQuad>()); | 1799 pass->quad_list.push_back(white_quad.PassAs<DrawQuad>()); |
1827 | 1800 |
1828 RenderPassList pass_list; | 1801 RenderPassList pass_list; |
1829 pass_list.push_back(pass.Pass()); | 1802 pass_list.push_back(pass.Pass()); |
1830 | 1803 |
1831 EXPECT_TRUE(this->RunPixelTest( | 1804 EXPECT_TRUE(this->RunPixelTest( |
1832 &pass_list, | 1805 &pass_list, |
1833 PixelTest::NoOffscreenContext, | |
1834 base::FilePath(FILE_PATH_LITERAL("green_alpha.png")), | 1806 base::FilePath(FILE_PATH_LITERAL("green_alpha.png")), |
1835 FuzzyPixelOffByOneComparator(true))); | 1807 FuzzyPixelOffByOneComparator(true))); |
1836 } | 1808 } |
1837 | 1809 |
1838 template<typename TypeParam> bool IsSoftwareRenderer() { | 1810 template<typename TypeParam> bool IsSoftwareRenderer() { |
1839 return false; | 1811 return false; |
1840 } | 1812 } |
1841 | 1813 |
1842 template<> | 1814 template<> |
1843 bool IsSoftwareRenderer<SoftwareRenderer>() { | 1815 bool IsSoftwareRenderer<SoftwareRenderer>() { |
(...skipping 57 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1901 PicturePileImpl::CreateFromOther(pile)); | 1873 PicturePileImpl::CreateFromOther(pile)); |
1902 pass->quad_list.push_back(quad.PassAs<DrawQuad>()); | 1874 pass->quad_list.push_back(quad.PassAs<DrawQuad>()); |
1903 | 1875 |
1904 RenderPassList pass_list; | 1876 RenderPassList pass_list; |
1905 pass_list.push_back(pass.Pass()); | 1877 pass_list.push_back(pass.Pass()); |
1906 | 1878 |
1907 this->disable_picture_quad_image_filtering_ = true; | 1879 this->disable_picture_quad_image_filtering_ = true; |
1908 | 1880 |
1909 EXPECT_TRUE(this->RunPixelTest( | 1881 EXPECT_TRUE(this->RunPixelTest( |
1910 &pass_list, | 1882 &pass_list, |
1911 PixelTest::NoOffscreenContext, | |
1912 base::FilePath(FILE_PATH_LITERAL("four_blue_green_checkers.png")), | 1883 base::FilePath(FILE_PATH_LITERAL("four_blue_green_checkers.png")), |
1913 ExactPixelComparator(true))); | 1884 ExactPixelComparator(true))); |
1914 } | 1885 } |
1915 | 1886 |
1916 TYPED_TEST(RendererPixelTest, PictureDrawQuadNonIdentityScale) { | 1887 TYPED_TEST(RendererPixelTest, PictureDrawQuadNonIdentityScale) { |
1917 gfx::Size pile_tile_size(1000, 1000); | 1888 gfx::Size pile_tile_size(1000, 1000); |
1918 gfx::Rect viewport(this->device_viewport_size_); | 1889 gfx::Rect viewport(this->device_viewport_size_); |
1919 // TODO(enne): the renderer should figure this out on its own. | 1890 // TODO(enne): the renderer should figure this out on its own. |
1920 ResourceFormat texture_format = RGBA_8888; | 1891 ResourceFormat texture_format = RGBA_8888; |
1921 | 1892 |
(...skipping 136 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2058 half_green_rect, | 2029 half_green_rect, |
2059 SK_ColorGREEN, | 2030 SK_ColorGREEN, |
2060 false); | 2031 false); |
2061 pass->quad_list.push_back(half_color_quad.PassAs<DrawQuad>()); | 2032 pass->quad_list.push_back(half_color_quad.PassAs<DrawQuad>()); |
2062 | 2033 |
2063 RenderPassList pass_list; | 2034 RenderPassList pass_list; |
2064 pass_list.push_back(pass.Pass()); | 2035 pass_list.push_back(pass.Pass()); |
2065 | 2036 |
2066 EXPECT_TRUE(this->RunPixelTest( | 2037 EXPECT_TRUE(this->RunPixelTest( |
2067 &pass_list, | 2038 &pass_list, |
2068 PixelTest::NoOffscreenContext, | |
2069 base::FilePath(FILE_PATH_LITERAL("four_blue_green_checkers.png")), | 2039 base::FilePath(FILE_PATH_LITERAL("four_blue_green_checkers.png")), |
2070 ExactPixelComparator(true))); | 2040 ExactPixelComparator(true))); |
2071 } | 2041 } |
2072 | 2042 |
2073 TYPED_TEST(RendererPixelTest, WrapModeRepeat) { | 2043 TYPED_TEST(RendererPixelTest, WrapModeRepeat) { |
2074 gfx::Rect rect(this->device_viewport_size_); | 2044 gfx::Rect rect(this->device_viewport_size_); |
2075 | 2045 |
2076 RenderPass::Id id(1, 1); | 2046 RenderPass::Id id(1, 1); |
2077 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); | 2047 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); |
2078 | 2048 |
(...skipping 42 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2121 SK_ColorWHITE, | 2091 SK_ColorWHITE, |
2122 vertex_opacity, | 2092 vertex_opacity, |
2123 false); // flipped | 2093 false); // flipped |
2124 pass->quad_list.push_back(texture_quad.PassAs<DrawQuad>()); | 2094 pass->quad_list.push_back(texture_quad.PassAs<DrawQuad>()); |
2125 | 2095 |
2126 RenderPassList pass_list; | 2096 RenderPassList pass_list; |
2127 pass_list.push_back(pass.Pass()); | 2097 pass_list.push_back(pass.Pass()); |
2128 | 2098 |
2129 EXPECT_TRUE(this->RunPixelTest( | 2099 EXPECT_TRUE(this->RunPixelTest( |
2130 &pass_list, | 2100 &pass_list, |
2131 PixelTest::NoOffscreenContext, | |
2132 base::FilePath(FILE_PATH_LITERAL("wrap_mode_repeat.png")), | 2101 base::FilePath(FILE_PATH_LITERAL("wrap_mode_repeat.png")), |
2133 FuzzyPixelOffByOneComparator(true))); | 2102 FuzzyPixelOffByOneComparator(true))); |
2134 } | 2103 } |
2135 | 2104 |
2136 #endif // !defined(OS_ANDROID) | 2105 #endif // !defined(OS_ANDROID) |
2137 | 2106 |
2138 } // namespace | 2107 } // namespace |
2139 } // namespace cc | 2108 } // namespace cc |
OLD | NEW |