Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(58)

Side by Side Diff: cc/output/renderer_pixeltest.cc

Issue 251343002: Remove offscreen compositor contexts. (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: rm-offscreencontext: include Created 6 years, 8 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
« no previous file with comments | « cc/output/renderer.cc ('k') | cc/output/software_renderer_unittest.cc » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
OLDNEW
« no previous file with comments | « cc/output/renderer.cc ('k') | cc/output/software_renderer_unittest.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698