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 3 // found in the LICENSE file. 4 5 #include "base/message_loop/message_loop.h" 6 #include "cc/layers/append_quads_data.h" 7 #include "cc/output/gl_renderer.h" 8 #include "cc/quads/draw_quad.h" 9 #include "cc/quads/picture_draw_quad.h" 10 #include "cc/quads/texture_draw_quad.h" 11 #include "cc/resources/video_resource_updater.h" 12 #include "cc/test/fake_picture_pile_impl.h" 13 #include "cc/test/pixel_test.h" 14 #include "gpu/command_buffer/client/gles2_interface.h" 15 #include "media/base/video_frame.h" 16 #include "third_party/skia/include/core/SkColorPriv.h" 17 #include "third_party/skia/include/core/SkImageFilter.h" 18 #include "third_party/skia/include/core/SkMatrix.h" 19 #include "third_party/skia/include/effects/SkColorFilterImageFilter.h" 20 #include "third_party/skia/include/effects/SkColorMatrixFilter.h" 21 #include "ui/gfx/geometry/rect_conversions.h" 22 23 using gpu::gles2::GLES2Interface; 24 25 namespace cc { 26 namespace { 27 28 #if !defined(OS_ANDROID) 29 scoped_ptr<RenderPass> CreateTestRootRenderPass(RenderPassId id, 30 const gfx::Rect& rect) { 31 scoped_ptr<RenderPass> pass = RenderPass::Create(); 32 const gfx::Rect output_rect = rect; 33 const gfx::Rect damage_rect = rect; 34 const gfx::Transform transform_to_root_target; 35 pass->SetNew(id, output_rect, damage_rect, transform_to_root_target); 36 return pass.Pass(); 37 } 38 39 scoped_ptr<RenderPass> CreateTestRenderPass( 40 RenderPassId id, 41 const gfx::Rect& rect, 42 const gfx::Transform& transform_to_root_target) { 43 scoped_ptr<RenderPass> pass = RenderPass::Create(); 44 const gfx::Rect output_rect = rect; 45 const gfx::Rect damage_rect = rect; 46 pass->SetNew(id, output_rect, damage_rect, transform_to_root_target); 47 return pass.Pass(); 48 } 49 50 SharedQuadState* CreateTestSharedQuadState( 51 gfx::Transform content_to_target_transform, 52 const gfx::Rect& rect, 53 RenderPass* render_pass) { 54 const gfx::Size content_bounds = rect.size(); 55 const gfx::Rect visible_content_rect = rect; 56 const gfx::Rect clip_rect = rect; 57 const bool is_clipped = false; 58 const float opacity = 1.0f; 59 const SkXfermode::Mode blend_mode = SkXfermode::kSrcOver_Mode; 60 int sorting_context_id = 0; 61 SharedQuadState* shared_state = render_pass->CreateAndAppendSharedQuadState(); 62 shared_state->SetAll(content_to_target_transform, 63 content_bounds, 64 visible_content_rect, 65 clip_rect, 66 is_clipped, 67 opacity, 68 blend_mode, 69 sorting_context_id); 70 return shared_state; 71 } 72 73 SharedQuadState* CreateTestSharedQuadStateClipped( 74 gfx::Transform content_to_target_transform, 75 const gfx::Rect& rect, 76 const gfx::Rect& clip_rect, 77 RenderPass* render_pass) { 78 const gfx::Size content_bounds = rect.size(); 79 const gfx::Rect visible_content_rect = clip_rect; 80 const bool is_clipped = true; 81 const float opacity = 1.0f; 82 const SkXfermode::Mode blend_mode = SkXfermode::kSrcOver_Mode; 83 int sorting_context_id = 0; 84 SharedQuadState* shared_state = render_pass->CreateAndAppendSharedQuadState(); 85 shared_state->SetAll(content_to_target_transform, 86 content_bounds, 87 visible_content_rect, 88 clip_rect, 89 is_clipped, 90 opacity, 91 blend_mode, 92 sorting_context_id); 93 return shared_state; 94 } 95 96 void CreateTestRenderPassDrawQuad(const SharedQuadState* shared_state, 97 const gfx::Rect& rect, 98 RenderPassId pass_id, 99 RenderPass* render_pass) { 100 RenderPassDrawQuad* quad = 101 render_pass->CreateAndAppendDrawQuad<RenderPassDrawQuad>(); 102 quad->SetNew(shared_state, 103 rect, 104 rect, 105 pass_id, 106 0, // mask_resource_id 107 gfx::RectF(1.f, 1.f), // mask_uv_rect 108 FilterOperations(), // foreground filters 109 gfx::Vector2dF(), // filters scale 110 FilterOperations()); // background filters 111 } 112 113 void CreateTestTextureDrawQuad(const gfx::Rect& rect, 114 SkColor texel_color, 115 SkColor background_color, 116 bool premultiplied_alpha, 117 const SharedQuadState* shared_state, 118 ResourceProvider* resource_provider, 119 RenderPass* render_pass) { 120 SkPMColor pixel_color = premultiplied_alpha ? 121 SkPreMultiplyColor(texel_color) : 122 SkPackARGB32NoCheck(SkColorGetA(texel_color), 123 SkColorGetR(texel_color), 124 SkColorGetG(texel_color), 125 SkColorGetB(texel_color)); 126 std::vector<uint32_t> pixels(rect.size().GetArea(), pixel_color); 127 128 ResourceProvider::ResourceId resource = 129 resource_provider->CreateResource(rect.size(), 130 GL_CLAMP_TO_EDGE, 131 ResourceProvider::TextureHintImmutable, 132 RGBA_8888); 133 resource_provider->SetPixels( 134 resource, 135 reinterpret_cast<uint8_t*>(&pixels.front()), 136 rect, 137 rect, 138 gfx::Vector2d()); 139 140 float vertex_opacity[4] = {1.0f, 1.0f, 1.0f, 1.0f}; 141 142 TextureDrawQuad* quad = 143 render_pass->CreateAndAppendDrawQuad<TextureDrawQuad>(); 144 quad->SetNew(shared_state, 145 rect, 146 gfx::Rect(), 147 rect, 148 resource, 149 premultiplied_alpha, 150 gfx::PointF(0.0f, 0.0f), // uv_top_left 151 gfx::PointF(1.0f, 1.0f), // uv_bottom_right 152 background_color, 153 vertex_opacity, 154 false); // flipped 155 } 156 157 typedef ::testing::Types<GLRenderer, 158 SoftwareRenderer, 159 GLRendererWithExpandedViewport, 160 SoftwareRendererWithExpandedViewport> RendererTypes; 161 TYPED_TEST_CASE(RendererPixelTest, RendererTypes); 162 163 template <typename RendererType> 164 class FuzzyForSoftwareOnlyPixelComparator : public PixelComparator { 165 public: 166 explicit FuzzyForSoftwareOnlyPixelComparator(bool discard_alpha) 167 : fuzzy_(discard_alpha), exact_(discard_alpha) {} 168 169 virtual bool Compare(const SkBitmap& actual_bmp, 170 const SkBitmap& expected_bmp) const; 171 172 private: 173 FuzzyPixelOffByOneComparator fuzzy_; 174 ExactPixelComparator exact_; 175 }; 176 177 template<> 178 bool FuzzyForSoftwareOnlyPixelComparator<SoftwareRenderer>::Compare( 179 const SkBitmap& actual_bmp, 180 const SkBitmap& expected_bmp) const { 181 return fuzzy_.Compare(actual_bmp, expected_bmp); 182 } 183 184 template <> 185 bool FuzzyForSoftwareOnlyPixelComparator< 186 SoftwareRendererWithExpandedViewport>::Compare( 187 const SkBitmap& actual_bmp, 188 const SkBitmap& expected_bmp) const { 189 return fuzzy_.Compare(actual_bmp, expected_bmp); 190 } 191 192 template<typename RendererType> 193 bool FuzzyForSoftwareOnlyPixelComparator<RendererType>::Compare( 194 const SkBitmap& actual_bmp, 195 const SkBitmap& expected_bmp) const { 196 return exact_.Compare(actual_bmp, expected_bmp); 197 } 198 199 TYPED_TEST(RendererPixelTest, SimpleGreenRect) { 200 gfx::Rect rect(this->device_viewport_size_); 201 202 RenderPassId id(1, 1); 203 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); 204 205 SharedQuadState* shared_state = 206 CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); 207 208 SolidColorDrawQuad* color_quad = 209 pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); 210 color_quad->SetNew(shared_state, rect, rect, SK_ColorGREEN, false); 211 212 RenderPassList pass_list; 213 pass_list.push_back(pass.Pass()); 214 215 EXPECT_TRUE(this->RunPixelTest( 216 &pass_list, 217 base::FilePath(FILE_PATH_LITERAL("green.png")), 218 ExactPixelComparator(true))); 219 } 220 221 TYPED_TEST(RendererPixelTest, SimpleGreenRect_NonRootRenderPass) { 222 gfx::Rect rect(this->device_viewport_size_); 223 gfx::Rect small_rect(100, 100); 224 225 RenderPassId child_id(2, 1); 226 scoped_ptr<RenderPass> child_pass = 227 CreateTestRenderPass(child_id, small_rect, gfx::Transform()); 228 229 SharedQuadState* child_shared_state = 230 CreateTestSharedQuadState(gfx::Transform(), small_rect, child_pass.get()); 231 232 SolidColorDrawQuad* color_quad = 233 child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); 234 color_quad->SetNew(child_shared_state, rect, rect, SK_ColorGREEN, false); 235 236 RenderPassId root_id(1, 1); 237 scoped_ptr<RenderPass> root_pass = 238 CreateTestRenderPass(root_id, rect, gfx::Transform()); 239 240 SharedQuadState* root_shared_state = 241 CreateTestSharedQuadState(gfx::Transform(), rect, root_pass.get()); 242 243 CreateTestRenderPassDrawQuad( 244 root_shared_state, small_rect, child_id, root_pass.get()); 245 246 RenderPass* child_pass_ptr = child_pass.get(); 247 248 RenderPassList pass_list; 249 pass_list.push_back(child_pass.Pass()); 250 pass_list.push_back(root_pass.Pass()); 251 252 EXPECT_TRUE(this->RunPixelTestWithReadbackTarget( 253 &pass_list, 254 child_pass_ptr, 255 base::FilePath(FILE_PATH_LITERAL("green_small.png")), 256 ExactPixelComparator(true))); 257 } 258 259 TYPED_TEST(RendererPixelTest, PremultipliedTextureWithoutBackground) { 260 gfx::Rect rect(this->device_viewport_size_); 261 262 RenderPassId id(1, 1); 263 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); 264 265 SharedQuadState* shared_state = 266 CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); 267 268 CreateTestTextureDrawQuad(gfx::Rect(this->device_viewport_size_), 269 SkColorSetARGB(128, 0, 255, 0), // Texel color. 270 SK_ColorTRANSPARENT, // Background color. 271 true, // Premultiplied alpha. 272 shared_state, 273 this->resource_provider_.get(), 274 pass.get()); 275 276 SolidColorDrawQuad* color_quad = 277 pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); 278 color_quad->SetNew(shared_state, rect, rect, SK_ColorWHITE, false); 279 280 RenderPassList pass_list; 281 pass_list.push_back(pass.Pass()); 282 283 EXPECT_TRUE(this->RunPixelTest( 284 &pass_list, 285 base::FilePath(FILE_PATH_LITERAL("green_alpha.png")), 286 FuzzyPixelOffByOneComparator(true))); 287 } 288 289 TYPED_TEST(RendererPixelTest, PremultipliedTextureWithBackground) { 290 gfx::Rect rect(this->device_viewport_size_); 291 292 RenderPassId id(1, 1); 293 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); 294 295 SharedQuadState* texture_quad_state = 296 CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); 297 texture_quad_state->opacity = 0.8f; 298 299 CreateTestTextureDrawQuad(gfx::Rect(this->device_viewport_size_), 300 SkColorSetARGB(204, 120, 255, 120), // Texel color. 301 SK_ColorGREEN, // Background color. 302 true, // Premultiplied alpha. 303 texture_quad_state, 304 this->resource_provider_.get(), 305 pass.get()); 306 307 SharedQuadState* color_quad_state = 308 CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); 309 SolidColorDrawQuad* color_quad = 310 pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); 311 color_quad->SetNew(color_quad_state, rect, rect, SK_ColorWHITE, false); 312 313 RenderPassList pass_list; 314 pass_list.push_back(pass.Pass()); 315 316 EXPECT_TRUE(this->RunPixelTest( 317 &pass_list, 318 base::FilePath(FILE_PATH_LITERAL("green_alpha.png")), 319 FuzzyPixelOffByOneComparator(true))); 320 } 321 322 // TODO(skaslev): The software renderer does not support non-premultplied alpha. 323 TEST_F(GLRendererPixelTest, NonPremultipliedTextureWithoutBackground) { 324 gfx::Rect rect(this->device_viewport_size_); 325 326 RenderPassId id(1, 1); 327 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); 328 329 SharedQuadState* shared_state = 330 CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); 331 332 CreateTestTextureDrawQuad(gfx::Rect(this->device_viewport_size_), 333 SkColorSetARGB(128, 0, 255, 0), // Texel color. 334 SK_ColorTRANSPARENT, // Background color. 335 false, // Premultiplied alpha. 336 shared_state, 337 this->resource_provider_.get(), 338 pass.get()); 339 340 SolidColorDrawQuad* color_quad = 341 pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); 342 color_quad->SetNew(shared_state, rect, rect, SK_ColorWHITE, false); 343 344 RenderPassList pass_list; 345 pass_list.push_back(pass.Pass()); 346 347 EXPECT_TRUE(this->RunPixelTest( 348 &pass_list, 349 base::FilePath(FILE_PATH_LITERAL("green_alpha.png")), 350 FuzzyPixelOffByOneComparator(true))); 351 } 352 353 // TODO(skaslev): The software renderer does not support non-premultplied alpha. 354 TEST_F(GLRendererPixelTest, NonPremultipliedTextureWithBackground) { 355 gfx::Rect rect(this->device_viewport_size_); 356 357 RenderPassId id(1, 1); 358 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); 359 360 SharedQuadState* texture_quad_state = 361 CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); 362 texture_quad_state->opacity = 0.8f; 363 364 CreateTestTextureDrawQuad(gfx::Rect(this->device_viewport_size_), 365 SkColorSetARGB(204, 120, 255, 120), // Texel color. 366 SK_ColorGREEN, // Background color. 367 false, // Premultiplied alpha. 368 texture_quad_state, 369 this->resource_provider_.get(), 370 pass.get()); 371 372 SharedQuadState* color_quad_state = 373 CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); 374 SolidColorDrawQuad* color_quad = 375 pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); 376 color_quad->SetNew(color_quad_state, rect, rect, SK_ColorWHITE, false); 377 378 RenderPassList pass_list; 379 pass_list.push_back(pass.Pass()); 380 381 EXPECT_TRUE(this->RunPixelTest( 382 &pass_list, 383 base::FilePath(FILE_PATH_LITERAL("green_alpha.png")), 384 FuzzyPixelOffByOneComparator(true))); 385 } 386 387 class VideoGLRendererPixelTest : public GLRendererPixelTest { 388 protected: 389 void CreateTestYUVVideoDrawQuad_Striped(const SharedQuadState* shared_state, 390 media::VideoFrame::Format format, 391 bool is_transparent, 392 const gfx::RectF& tex_coord_rect, 393 RenderPass* render_pass) { 394 const gfx::Rect rect(this->device_viewport_size_); 395 396 scoped_refptr<media::VideoFrame> video_frame = 397 media::VideoFrame::CreateFrame( 398 format, rect.size(), rect, rect.size(), base::TimeDelta()); 399 400 // YUV values representing a striped pattern, for validating texture 401 // coordinates for sampling. 402 uint8_t y_value = 0; 403 uint8_t u_value = 0; 404 uint8_t v_value = 0; 405 for (int i = 0; i < video_frame->rows(media::VideoFrame::kYPlane); ++i) { 406 uint8_t* y_row = video_frame->data(media::VideoFrame::kYPlane) + 407 video_frame->stride(media::VideoFrame::kYPlane) * i; 408 for (int j = 0; j < video_frame->row_bytes(media::VideoFrame::kYPlane); 409 ++j) { 410 y_row[j] = (y_value += 1); 411 } 412 } 413 for (int i = 0; i < video_frame->rows(media::VideoFrame::kUPlane); ++i) { 414 uint8_t* u_row = video_frame->data(media::VideoFrame::kUPlane) + 415 video_frame->stride(media::VideoFrame::kUPlane) * i; 416 uint8_t* v_row = video_frame->data(media::VideoFrame::kVPlane) + 417 video_frame->stride(media::VideoFrame::kVPlane) * i; 418 for (int j = 0; j < video_frame->row_bytes(media::VideoFrame::kUPlane); 419 ++j) { 420 u_row[j] = (u_value += 3); 421 v_row[j] = (v_value += 5); 422 } 423 } 424 CreateTestYUVVideoDrawQuad_FromVideoFrame( 425 shared_state, video_frame, is_transparent, tex_coord_rect, render_pass); 426 } 427 428 void CreateTestYUVVideoDrawQuad_Solid(const SharedQuadState* shared_state, 429 media::VideoFrame::Format format, 430 bool is_transparent, 431 const gfx::RectF& tex_coord_rect, 432 uint8 y, 433 uint8 u, 434 uint8 v, 435 RenderPass* render_pass) { 436 const gfx::Rect rect(this->device_viewport_size_); 437 438 scoped_refptr<media::VideoFrame> video_frame = 439 media::VideoFrame::CreateFrame( 440 format, rect.size(), rect, rect.size(), base::TimeDelta()); 441 442 // YUV values of a solid, constant, color. Useful for testing that color 443 // space/color range are being handled properly. 444 memset(video_frame->data(media::VideoFrame::kYPlane), 445 y, 446 video_frame->stride(media::VideoFrame::kYPlane) * 447 video_frame->rows(media::VideoFrame::kYPlane)); 448 memset(video_frame->data(media::VideoFrame::kUPlane), 449 u, 450 video_frame->stride(media::VideoFrame::kUPlane) * 451 video_frame->rows(media::VideoFrame::kUPlane)); 452 memset(video_frame->data(media::VideoFrame::kVPlane), 453 v, 454 video_frame->stride(media::VideoFrame::kVPlane) * 455 video_frame->rows(media::VideoFrame::kVPlane)); 456 457 CreateTestYUVVideoDrawQuad_FromVideoFrame( 458 shared_state, video_frame, is_transparent, tex_coord_rect, render_pass); 459 } 460 461 void CreateTestYUVVideoDrawQuad_FromVideoFrame( 462 const SharedQuadState* shared_state, 463 scoped_refptr<media::VideoFrame> video_frame, 464 bool is_transparent, 465 const gfx::RectF& tex_coord_rect, 466 RenderPass* render_pass) { 467 const bool with_alpha = (video_frame->format() == media::VideoFrame::YV12A); 468 const YUVVideoDrawQuad::ColorSpace color_space = 469 (video_frame->format() == media::VideoFrame::YV12J 470 ? YUVVideoDrawQuad::REC_601_JPEG 471 : YUVVideoDrawQuad::REC_601); 472 const gfx::Rect rect(this->device_viewport_size_); 473 const gfx::Rect opaque_rect(0, 0, 0, 0); 474 475 if (with_alpha) 476 memset(video_frame->data(media::VideoFrame::kAPlane), 477 is_transparent ? 0 : 128, 478 video_frame->stride(media::VideoFrame::kAPlane) * 479 video_frame->rows(media::VideoFrame::kAPlane)); 480 481 VideoFrameExternalResources resources = 482 video_resource_updater_->CreateExternalResourcesFromVideoFrame( 483 video_frame); 484 485 EXPECT_EQ(VideoFrameExternalResources::YUV_RESOURCE, resources.type); 486 EXPECT_EQ(media::VideoFrame::NumPlanes(video_frame->format()), 487 resources.mailboxes.size()); 488 EXPECT_EQ(media::VideoFrame::NumPlanes(video_frame->format()), 489 resources.release_callbacks.size()); 490 491 ResourceProvider::ResourceId y_resource = 492 resource_provider_->CreateResourceFromTextureMailbox( 493 resources.mailboxes[media::VideoFrame::kYPlane], 494 SingleReleaseCallbackImpl::Create( 495 resources.release_callbacks[media::VideoFrame::kYPlane])); 496 ResourceProvider::ResourceId u_resource = 497 resource_provider_->CreateResourceFromTextureMailbox( 498 resources.mailboxes[media::VideoFrame::kUPlane], 499 SingleReleaseCallbackImpl::Create( 500 resources.release_callbacks[media::VideoFrame::kUPlane])); 501 ResourceProvider::ResourceId v_resource = 502 resource_provider_->CreateResourceFromTextureMailbox( 503 resources.mailboxes[media::VideoFrame::kVPlane], 504 SingleReleaseCallbackImpl::Create( 505 resources.release_callbacks[media::VideoFrame::kVPlane])); 506 ResourceProvider::ResourceId a_resource = 0; 507 if (with_alpha) { 508 a_resource = resource_provider_->CreateResourceFromTextureMailbox( 509 resources.mailboxes[media::VideoFrame::kAPlane], 510 SingleReleaseCallbackImpl::Create( 511 resources.release_callbacks[media::VideoFrame::kAPlane])); 512 } 513 514 YUVVideoDrawQuad* yuv_quad = 515 render_pass->CreateAndAppendDrawQuad<YUVVideoDrawQuad>(); 516 yuv_quad->SetNew(shared_state, 517 rect, 518 opaque_rect, 519 rect, 520 tex_coord_rect, 521 y_resource, 522 u_resource, 523 v_resource, 524 a_resource, 525 color_space); 526 } 527 528 virtual void SetUp() OVERRIDE { 529 GLRendererPixelTest::SetUp(); 530 video_resource_updater_.reset(new VideoResourceUpdater( 531 output_surface_->context_provider(), resource_provider_.get())); 532 } 533 534 private: 535 scoped_ptr<VideoResourceUpdater> video_resource_updater_; 536 }; 537 538 TEST_F(VideoGLRendererPixelTest, SimpleYUVRect) { 539 gfx::Rect rect(this->device_viewport_size_); 540 541 RenderPassId id(1, 1); 542 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); 543 544 SharedQuadState* shared_state = 545 CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); 546 547 CreateTestYUVVideoDrawQuad_Striped(shared_state, 548 media::VideoFrame::YV12, 549 false, 550 gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), 551 pass.get()); 552 553 RenderPassList pass_list; 554 pass_list.push_back(pass.Pass()); 555 556 EXPECT_TRUE( 557 this->RunPixelTest(&pass_list, 558 base::FilePath(FILE_PATH_LITERAL("yuv_stripes.png")), 559 FuzzyPixelOffByOneComparator(true))); 560 } 561 562 TEST_F(VideoGLRendererPixelTest, OffsetYUVRect) { 563 gfx::Rect rect(this->device_viewport_size_); 564 565 RenderPassId id(1, 1); 566 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); 567 568 SharedQuadState* shared_state = 569 CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); 570 571 // Intentionally sets frame format to I420 for testing coverage. 572 CreateTestYUVVideoDrawQuad_Striped(shared_state, 573 media::VideoFrame::I420, 574 false, 575 gfx::RectF(0.125f, 0.25f, 0.75f, 0.5f), 576 pass.get()); 577 578 RenderPassList pass_list; 579 pass_list.push_back(pass.Pass()); 580 581 EXPECT_TRUE(this->RunPixelTest( 582 &pass_list, 583 base::FilePath(FILE_PATH_LITERAL("yuv_stripes_offset.png")), 584 FuzzyPixelOffByOneComparator(true))); 585 } 586 587 TEST_F(VideoGLRendererPixelTest, SimpleYUVRectBlack) { 588 gfx::Rect rect(this->device_viewport_size_); 589 590 RenderPassId id(1, 1); 591 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); 592 593 SharedQuadState* shared_state = 594 CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); 595 596 // In MPEG color range YUV values of (15,128,128) should produce black. 597 CreateTestYUVVideoDrawQuad_Solid(shared_state, 598 media::VideoFrame::YV12, 599 false, 600 gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), 601 15, 602 128, 603 128, 604 pass.get()); 605 606 RenderPassList pass_list; 607 pass_list.push_back(pass.Pass()); 608 609 // If we didn't get black out of the YUV values above, then we probably have a 610 // color range issue. 611 EXPECT_TRUE(this->RunPixelTest(&pass_list, 612 base::FilePath(FILE_PATH_LITERAL("black.png")), 613 FuzzyPixelOffByOneComparator(true))); 614 } 615 616 TEST_F(VideoGLRendererPixelTest, SimpleYUVJRect) { 617 gfx::Rect rect(this->device_viewport_size_); 618 619 RenderPassId id(1, 1); 620 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); 621 622 SharedQuadState* shared_state = 623 CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); 624 625 // YUV of (149,43,21) should be green (0,255,0) in RGB. 626 CreateTestYUVVideoDrawQuad_Solid(shared_state, 627 media::VideoFrame::YV12J, 628 false, 629 gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), 630 149, 631 43, 632 21, 633 pass.get()); 634 635 RenderPassList pass_list; 636 pass_list.push_back(pass.Pass()); 637 638 EXPECT_TRUE(this->RunPixelTest(&pass_list, 639 base::FilePath(FILE_PATH_LITERAL("green.png")), 640 FuzzyPixelOffByOneComparator(true))); 641 } 642 643 TEST_F(VideoGLRendererPixelTest, SimpleYUVJRectGrey) { 644 gfx::Rect rect(this->device_viewport_size_); 645 646 RenderPassId id(1, 1); 647 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); 648 649 SharedQuadState* shared_state = 650 CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); 651 652 // Dark grey in JPEG color range (in MPEG, this is black). 653 CreateTestYUVVideoDrawQuad_Solid(shared_state, 654 media::VideoFrame::YV12J, 655 false, 656 gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), 657 15, 658 128, 659 128, 660 pass.get()); 661 662 RenderPassList pass_list; 663 pass_list.push_back(pass.Pass()); 664 665 EXPECT_TRUE( 666 this->RunPixelTest(&pass_list, 667 base::FilePath(FILE_PATH_LITERAL("dark_grey.png")), 668 FuzzyPixelOffByOneComparator(true))); 669 } 670 671 TEST_F(VideoGLRendererPixelTest, SimpleYUVARect) { 672 gfx::Rect rect(this->device_viewport_size_); 673 674 RenderPassId id(1, 1); 675 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); 676 677 SharedQuadState* shared_state = 678 CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); 679 680 CreateTestYUVVideoDrawQuad_Striped(shared_state, 681 media::VideoFrame::YV12A, 682 false, 683 gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), 684 pass.get()); 685 686 SolidColorDrawQuad* color_quad = 687 pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); 688 color_quad->SetNew(shared_state, rect, rect, SK_ColorWHITE, false); 689 690 RenderPassList pass_list; 691 pass_list.push_back(pass.Pass()); 692 693 EXPECT_TRUE(this->RunPixelTest( 694 &pass_list, 695 base::FilePath(FILE_PATH_LITERAL("yuv_stripes_alpha.png")), 696 FuzzyPixelOffByOneComparator(true))); 697 } 698 699 TEST_F(VideoGLRendererPixelTest, FullyTransparentYUVARect) { 700 gfx::Rect rect(this->device_viewport_size_); 701 702 RenderPassId id(1, 1); 703 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); 704 705 SharedQuadState* shared_state = 706 CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); 707 708 CreateTestYUVVideoDrawQuad_Striped(shared_state, 709 media::VideoFrame::YV12A, 710 true, 711 gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), 712 pass.get()); 713 714 SolidColorDrawQuad* color_quad = 715 pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); 716 color_quad->SetNew(shared_state, rect, rect, SK_ColorBLACK, false); 717 718 RenderPassList pass_list; 719 pass_list.push_back(pass.Pass()); 720 721 EXPECT_TRUE(this->RunPixelTest( 722 &pass_list, 723 base::FilePath(FILE_PATH_LITERAL("black.png")), 724 ExactPixelComparator(true))); 725 } 726 727 TYPED_TEST(RendererPixelTest, FastPassColorFilterAlpha) { 728 gfx::Rect viewport_rect(this->device_viewport_size_); 729 730 RenderPassId root_pass_id(1, 1); 731 scoped_ptr<RenderPass> root_pass = 732 CreateTestRootRenderPass(root_pass_id, viewport_rect); 733 734 RenderPassId child_pass_id(2, 2); 735 gfx::Rect pass_rect(this->device_viewport_size_); 736 gfx::Transform transform_to_root; 737 scoped_ptr<RenderPass> child_pass = 738 CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root); 739 740 gfx::Transform content_to_target_transform; 741 SharedQuadState* shared_state = CreateTestSharedQuadState( 742 content_to_target_transform, viewport_rect, child_pass.get()); 743 shared_state->opacity = 0.5f; 744 745 gfx::Rect blue_rect(0, 746 0, 747 this->device_viewport_size_.width(), 748 this->device_viewport_size_.height() / 2); 749 SolidColorDrawQuad* blue = 750 child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); 751 blue->SetNew(shared_state, blue_rect, blue_rect, SK_ColorBLUE, false); 752 gfx::Rect yellow_rect(0, 753 this->device_viewport_size_.height() / 2, 754 this->device_viewport_size_.width(), 755 this->device_viewport_size_.height() / 2); 756 SolidColorDrawQuad* yellow = 757 child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); 758 yellow->SetNew(shared_state, yellow_rect, yellow_rect, SK_ColorYELLOW, false); 759 760 SharedQuadState* blank_state = CreateTestSharedQuadState( 761 content_to_target_transform, viewport_rect, child_pass.get()); 762 763 SolidColorDrawQuad* white = 764 child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); 765 white->SetNew( 766 blank_state, viewport_rect, viewport_rect, SK_ColorWHITE, false); 767 768 SharedQuadState* pass_shared_state = 769 CreateTestSharedQuadState(gfx::Transform(), pass_rect, root_pass.get()); 770 771 SkScalar matrix[20]; 772 float amount = 0.5f; 773 matrix[0] = 0.213f + 0.787f * amount; 774 matrix[1] = 0.715f - 0.715f * amount; 775 matrix[2] = 1.f - (matrix[0] + matrix[1]); 776 matrix[3] = matrix[4] = 0; 777 matrix[5] = 0.213f - 0.213f * amount; 778 matrix[6] = 0.715f + 0.285f * amount; 779 matrix[7] = 1.f - (matrix[5] + matrix[6]); 780 matrix[8] = matrix[9] = 0; 781 matrix[10] = 0.213f - 0.213f * amount; 782 matrix[11] = 0.715f - 0.715f * amount; 783 matrix[12] = 1.f - (matrix[10] + matrix[11]); 784 matrix[13] = matrix[14] = 0; 785 matrix[15] = matrix[16] = matrix[17] = matrix[19] = 0; 786 matrix[18] = 1; 787 skia::RefPtr<SkColorFilter> colorFilter( 788 skia::AdoptRef(SkColorMatrixFilter::Create(matrix))); 789 skia::RefPtr<SkImageFilter> filter = 790 skia::AdoptRef(SkColorFilterImageFilter::Create(colorFilter.get(), NULL)); 791 FilterOperations filters; 792 filters.Append(FilterOperation::CreateReferenceFilter(filter)); 793 794 RenderPassDrawQuad* render_pass_quad = 795 root_pass->CreateAndAppendDrawQuad<RenderPassDrawQuad>(); 796 render_pass_quad->SetNew(pass_shared_state, 797 pass_rect, 798 pass_rect, 799 child_pass_id, 800 0, 801 gfx::RectF(), 802 filters, 803 gfx::Vector2dF(), 804 FilterOperations()); 805 806 RenderPassList pass_list; 807 pass_list.push_back(child_pass.Pass()); 808 pass_list.push_back(root_pass.Pass()); 809 810 // This test has alpha=254 for the software renderer vs. alpha=255 for the gl 811 // renderer so use a fuzzy comparator. 812 EXPECT_TRUE(this->RunPixelTest( 813 &pass_list, 814 base::FilePath(FILE_PATH_LITERAL("blue_yellow_alpha.png")), 815 FuzzyForSoftwareOnlyPixelComparator<TypeParam>(false))); 816 } 817 818 TYPED_TEST(RendererPixelTest, FastPassSaturateFilter) { 819 gfx::Rect viewport_rect(this->device_viewport_size_); 820 821 RenderPassId root_pass_id(1, 1); 822 scoped_ptr<RenderPass> root_pass = 823 CreateTestRootRenderPass(root_pass_id, viewport_rect); 824 825 RenderPassId child_pass_id(2, 2); 826 gfx::Rect pass_rect(this->device_viewport_size_); 827 gfx::Transform transform_to_root; 828 scoped_ptr<RenderPass> child_pass = 829 CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root); 830 831 gfx::Transform content_to_target_transform; 832 SharedQuadState* shared_state = CreateTestSharedQuadState( 833 content_to_target_transform, viewport_rect, child_pass.get()); 834 shared_state->opacity = 0.5f; 835 836 gfx::Rect blue_rect(0, 837 0, 838 this->device_viewport_size_.width(), 839 this->device_viewport_size_.height() / 2); 840 SolidColorDrawQuad* blue = 841 child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); 842 blue->SetNew(shared_state, blue_rect, blue_rect, SK_ColorBLUE, false); 843 gfx::Rect yellow_rect(0, 844 this->device_viewport_size_.height() / 2, 845 this->device_viewport_size_.width(), 846 this->device_viewport_size_.height() / 2); 847 SolidColorDrawQuad* yellow = 848 child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); 849 yellow->SetNew(shared_state, yellow_rect, yellow_rect, SK_ColorYELLOW, false); 850 851 SharedQuadState* blank_state = CreateTestSharedQuadState( 852 content_to_target_transform, viewport_rect, child_pass.get()); 853 854 SolidColorDrawQuad* white = 855 child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); 856 white->SetNew( 857 blank_state, viewport_rect, viewport_rect, SK_ColorWHITE, false); 858 859 SharedQuadState* pass_shared_state = 860 CreateTestSharedQuadState(gfx::Transform(), pass_rect, root_pass.get()); 861 862 FilterOperations filters; 863 filters.Append(FilterOperation::CreateSaturateFilter(0.5f)); 864 865 RenderPassDrawQuad* render_pass_quad = 866 root_pass->CreateAndAppendDrawQuad<RenderPassDrawQuad>(); 867 render_pass_quad->SetNew(pass_shared_state, 868 pass_rect, 869 pass_rect, 870 child_pass_id, 871 0, 872 gfx::RectF(), 873 filters, 874 gfx::Vector2dF(), 875 FilterOperations()); 876 877 RenderPassList pass_list; 878 pass_list.push_back(child_pass.Pass()); 879 pass_list.push_back(root_pass.Pass()); 880 881 EXPECT_TRUE(this->RunPixelTest( 882 &pass_list, 883 base::FilePath(FILE_PATH_LITERAL("blue_yellow_alpha.png")), 884 ExactPixelComparator(true))); 885 } 886 887 TYPED_TEST(RendererPixelTest, FastPassFilterChain) { 888 gfx::Rect viewport_rect(this->device_viewport_size_); 889 890 RenderPassId root_pass_id(1, 1); 891 scoped_ptr<RenderPass> root_pass = 892 CreateTestRootRenderPass(root_pass_id, viewport_rect); 893 894 RenderPassId child_pass_id(2, 2); 895 gfx::Rect pass_rect(this->device_viewport_size_); 896 gfx::Transform transform_to_root; 897 scoped_ptr<RenderPass> child_pass = 898 CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root); 899 900 gfx::Transform content_to_target_transform; 901 SharedQuadState* shared_state = CreateTestSharedQuadState( 902 content_to_target_transform, viewport_rect, child_pass.get()); 903 shared_state->opacity = 0.5f; 904 905 gfx::Rect blue_rect(0, 906 0, 907 this->device_viewport_size_.width(), 908 this->device_viewport_size_.height() / 2); 909 SolidColorDrawQuad* blue = 910 child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); 911 blue->SetNew(shared_state, blue_rect, blue_rect, SK_ColorBLUE, false); 912 gfx::Rect yellow_rect(0, 913 this->device_viewport_size_.height() / 2, 914 this->device_viewport_size_.width(), 915 this->device_viewport_size_.height() / 2); 916 SolidColorDrawQuad* yellow = 917 child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); 918 yellow->SetNew(shared_state, yellow_rect, yellow_rect, SK_ColorYELLOW, false); 919 920 SharedQuadState* blank_state = CreateTestSharedQuadState( 921 content_to_target_transform, viewport_rect, child_pass.get()); 922 923 SolidColorDrawQuad* white = 924 child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); 925 white->SetNew( 926 blank_state, viewport_rect, viewport_rect, SK_ColorWHITE, false); 927 928 SharedQuadState* pass_shared_state = 929 CreateTestSharedQuadState(gfx::Transform(), pass_rect, root_pass.get()); 930 931 FilterOperations filters; 932 filters.Append(FilterOperation::CreateGrayscaleFilter(1.f)); 933 filters.Append(FilterOperation::CreateBrightnessFilter(0.5f)); 934 935 RenderPassDrawQuad* render_pass_quad = 936 root_pass->CreateAndAppendDrawQuad<RenderPassDrawQuad>(); 937 render_pass_quad->SetNew(pass_shared_state, 938 pass_rect, 939 pass_rect, 940 child_pass_id, 941 0, 942 gfx::RectF(), 943 filters, 944 gfx::Vector2dF(), 945 FilterOperations()); 946 947 RenderPassList pass_list; 948 pass_list.push_back(child_pass.Pass()); 949 pass_list.push_back(root_pass.Pass()); 950 951 EXPECT_TRUE(this->RunPixelTest( 952 &pass_list, 953 base::FilePath(FILE_PATH_LITERAL("blue_yellow_filter_chain.png")), 954 ExactPixelComparator(true))); 955 } 956 957 TYPED_TEST(RendererPixelTest, FastPassColorFilterAlphaTranslation) { 958 gfx::Rect viewport_rect(this->device_viewport_size_); 959 960 RenderPassId root_pass_id(1, 1); 961 scoped_ptr<RenderPass> root_pass = 962 CreateTestRootRenderPass(root_pass_id, viewport_rect); 963 964 RenderPassId child_pass_id(2, 2); 965 gfx::Rect pass_rect(this->device_viewport_size_); 966 gfx::Transform transform_to_root; 967 scoped_ptr<RenderPass> child_pass = 968 CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root); 969 970 gfx::Transform content_to_target_transform; 971 SharedQuadState* shared_state = CreateTestSharedQuadState( 972 content_to_target_transform, viewport_rect, child_pass.get()); 973 shared_state->opacity = 0.5f; 974 975 gfx::Rect blue_rect(0, 976 0, 977 this->device_viewport_size_.width(), 978 this->device_viewport_size_.height() / 2); 979 SolidColorDrawQuad* blue = 980 child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); 981 blue->SetNew(shared_state, blue_rect, blue_rect, SK_ColorBLUE, false); 982 gfx::Rect yellow_rect(0, 983 this->device_viewport_size_.height() / 2, 984 this->device_viewport_size_.width(), 985 this->device_viewport_size_.height() / 2); 986 SolidColorDrawQuad* yellow = 987 child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); 988 yellow->SetNew(shared_state, yellow_rect, yellow_rect, SK_ColorYELLOW, false); 989 990 SharedQuadState* blank_state = CreateTestSharedQuadState( 991 content_to_target_transform, viewport_rect, child_pass.get()); 992 993 SolidColorDrawQuad* white = 994 child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); 995 white->SetNew( 996 blank_state, viewport_rect, viewport_rect, SK_ColorWHITE, false); 997 998 SharedQuadState* pass_shared_state = 999 CreateTestSharedQuadState(gfx::Transform(), pass_rect, root_pass.get()); 1000 1001 SkScalar matrix[20]; 1002 float amount = 0.5f; 1003 matrix[0] = 0.213f + 0.787f * amount; 1004 matrix[1] = 0.715f - 0.715f * amount; 1005 matrix[2] = 1.f - (matrix[0] + matrix[1]); 1006 matrix[3] = 0; 1007 matrix[4] = 20.f; 1008 matrix[5] = 0.213f - 0.213f * amount; 1009 matrix[6] = 0.715f + 0.285f * amount; 1010 matrix[7] = 1.f - (matrix[5] + matrix[6]); 1011 matrix[8] = 0; 1012 matrix[9] = 200.f; 1013 matrix[10] = 0.213f - 0.213f * amount; 1014 matrix[11] = 0.715f - 0.715f * amount; 1015 matrix[12] = 1.f - (matrix[10] + matrix[11]); 1016 matrix[13] = 0; 1017 matrix[14] = 1.5f; 1018 matrix[15] = matrix[16] = matrix[17] = matrix[19] = 0; 1019 matrix[18] = 1; 1020 skia::RefPtr<SkColorFilter> colorFilter( 1021 skia::AdoptRef(SkColorMatrixFilter::Create(matrix))); 1022 skia::RefPtr<SkImageFilter> filter = 1023 skia::AdoptRef(SkColorFilterImageFilter::Create(colorFilter.get(), NULL)); 1024 FilterOperations filters; 1025 filters.Append(FilterOperation::CreateReferenceFilter(filter)); 1026 1027 RenderPassDrawQuad* render_pass_quad = 1028 root_pass->CreateAndAppendDrawQuad<RenderPassDrawQuad>(); 1029 render_pass_quad->SetNew(pass_shared_state, 1030 pass_rect, 1031 pass_rect, 1032 child_pass_id, 1033 0, 1034 gfx::RectF(), 1035 filters, 1036 gfx::Vector2dF(), 1037 FilterOperations()); 1038 1039 RenderPassList pass_list; 1040 1041 pass_list.push_back(child_pass.Pass()); 1042 pass_list.push_back(root_pass.Pass()); 1043 1044 // This test has alpha=254 for the software renderer vs. alpha=255 for the gl 1045 // renderer so use a fuzzy comparator. 1046 EXPECT_TRUE(this->RunPixelTest( 1047 &pass_list, 1048 base::FilePath(FILE_PATH_LITERAL("blue_yellow_alpha_translate.png")), 1049 FuzzyForSoftwareOnlyPixelComparator<TypeParam>(false))); 1050 } 1051 1052 TYPED_TEST(RendererPixelTest, EnlargedRenderPassTexture) { 1053 gfx::Rect viewport_rect(this->device_viewport_size_); 1054 1055 RenderPassId root_pass_id(1, 1); 1056 scoped_ptr<RenderPass> root_pass = 1057 CreateTestRootRenderPass(root_pass_id, viewport_rect); 1058 1059 RenderPassId child_pass_id(2, 2); 1060 gfx::Rect pass_rect(this->device_viewport_size_); 1061 gfx::Transform transform_to_root; 1062 scoped_ptr<RenderPass> child_pass = 1063 CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root); 1064 1065 gfx::Transform content_to_target_transform; 1066 SharedQuadState* shared_state = CreateTestSharedQuadState( 1067 content_to_target_transform, viewport_rect, child_pass.get()); 1068 1069 gfx::Rect blue_rect(0, 1070 0, 1071 this->device_viewport_size_.width(), 1072 this->device_viewport_size_.height() / 2); 1073 SolidColorDrawQuad* blue = 1074 child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); 1075 blue->SetNew(shared_state, blue_rect, blue_rect, SK_ColorBLUE, false); 1076 gfx::Rect yellow_rect(0, 1077 this->device_viewport_size_.height() / 2, 1078 this->device_viewport_size_.width(), 1079 this->device_viewport_size_.height() / 2); 1080 SolidColorDrawQuad* yellow = 1081 child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); 1082 yellow->SetNew(shared_state, yellow_rect, yellow_rect, SK_ColorYELLOW, false); 1083 1084 SharedQuadState* pass_shared_state = 1085 CreateTestSharedQuadState(gfx::Transform(), pass_rect, root_pass.get()); 1086 CreateTestRenderPassDrawQuad( 1087 pass_shared_state, pass_rect, child_pass_id, root_pass.get()); 1088 1089 RenderPassList pass_list; 1090 pass_list.push_back(child_pass.Pass()); 1091 pass_list.push_back(root_pass.Pass()); 1092 1093 this->renderer_->SetEnlargePassTextureAmountForTesting(gfx::Vector2d(50, 75)); 1094 1095 EXPECT_TRUE(this->RunPixelTest( 1096 &pass_list, 1097 base::FilePath(FILE_PATH_LITERAL("blue_yellow.png")), 1098 ExactPixelComparator(true))); 1099 } 1100 1101 TYPED_TEST(RendererPixelTest, EnlargedRenderPassTextureWithAntiAliasing) { 1102 gfx::Rect viewport_rect(this->device_viewport_size_); 1103 1104 RenderPassId root_pass_id(1, 1); 1105 scoped_ptr<RenderPass> root_pass = 1106 CreateTestRootRenderPass(root_pass_id, viewport_rect); 1107 1108 RenderPassId child_pass_id(2, 2); 1109 gfx::Rect pass_rect(this->device_viewport_size_); 1110 gfx::Transform transform_to_root; 1111 scoped_ptr<RenderPass> child_pass = 1112 CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root); 1113 1114 gfx::Transform content_to_target_transform; 1115 SharedQuadState* shared_state = CreateTestSharedQuadState( 1116 content_to_target_transform, viewport_rect, child_pass.get()); 1117 1118 gfx::Rect blue_rect(0, 1119 0, 1120 this->device_viewport_size_.width(), 1121 this->device_viewport_size_.height() / 2); 1122 SolidColorDrawQuad* blue = 1123 child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); 1124 blue->SetNew(shared_state, blue_rect, blue_rect, SK_ColorBLUE, false); 1125 gfx::Rect yellow_rect(0, 1126 this->device_viewport_size_.height() / 2, 1127 this->device_viewport_size_.width(), 1128 this->device_viewport_size_.height() / 2); 1129 SolidColorDrawQuad* yellow = 1130 child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); 1131 yellow->SetNew(shared_state, yellow_rect, yellow_rect, SK_ColorYELLOW, false); 1132 1133 gfx::Transform aa_transform; 1134 aa_transform.Translate(0.5, 0.0); 1135 1136 SharedQuadState* pass_shared_state = 1137 CreateTestSharedQuadState(aa_transform, pass_rect, root_pass.get()); 1138 CreateTestRenderPassDrawQuad( 1139 pass_shared_state, pass_rect, child_pass_id, root_pass.get()); 1140 1141 SharedQuadState* root_shared_state = CreateTestSharedQuadState( 1142 gfx::Transform(), viewport_rect, root_pass.get()); 1143 SolidColorDrawQuad* background = 1144 root_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); 1145 background->SetNew(root_shared_state, 1146 gfx::Rect(this->device_viewport_size_), 1147 gfx::Rect(this->device_viewport_size_), 1148 SK_ColorWHITE, 1149 false); 1150 1151 RenderPassList pass_list; 1152 pass_list.push_back(child_pass.Pass()); 1153 pass_list.push_back(root_pass.Pass()); 1154 1155 this->renderer_->SetEnlargePassTextureAmountForTesting(gfx::Vector2d(50, 75)); 1156 1157 EXPECT_TRUE(this->RunPixelTest( 1158 &pass_list, 1159 base::FilePath(FILE_PATH_LITERAL("blue_yellow_anti_aliasing.png")), 1160 FuzzyPixelOffByOneComparator(true))); 1161 } 1162 1163 // This tests the case where we have a RenderPass with a mask, but the quad 1164 // for the masked surface does not include the full surface texture. 1165 TYPED_TEST(RendererPixelTest, RenderPassAndMaskWithPartialQuad) { 1166 gfx::Rect viewport_rect(this->device_viewport_size_); 1167 1168 RenderPassId root_pass_id(1, 1); 1169 scoped_ptr<RenderPass> root_pass = 1170 CreateTestRootRenderPass(root_pass_id, viewport_rect); 1171 SharedQuadState* root_pass_shared_state = CreateTestSharedQuadState( 1172 gfx::Transform(), viewport_rect, root_pass.get()); 1173 1174 RenderPassId child_pass_id(2, 2); 1175 gfx::Transform transform_to_root; 1176 scoped_ptr<RenderPass> child_pass = 1177 CreateTestRenderPass(child_pass_id, viewport_rect, transform_to_root); 1178 SharedQuadState* child_pass_shared_state = CreateTestSharedQuadState( 1179 gfx::Transform(), viewport_rect, child_pass.get()); 1180 1181 // The child render pass is just a green box. 1182 static const SkColor kCSSGreen = 0xff008000; 1183 SolidColorDrawQuad* green = 1184 child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); 1185 green->SetNew( 1186 child_pass_shared_state, viewport_rect, viewport_rect, kCSSGreen, false); 1187 1188 // Make a mask. 1189 gfx::Rect mask_rect = viewport_rect; 1190 SkBitmap bitmap; 1191 bitmap.allocPixels( 1192 SkImageInfo::MakeN32Premul(mask_rect.width(), mask_rect.height())); 1193 SkCanvas canvas(bitmap); 1194 SkPaint paint; 1195 paint.setStyle(SkPaint::kStroke_Style); 1196 paint.setStrokeWidth(SkIntToScalar(4)); 1197 paint.setColor(SK_ColorWHITE); 1198 canvas.clear(SK_ColorTRANSPARENT); 1199 gfx::Rect rect = mask_rect; 1200 while (!rect.IsEmpty()) { 1201 rect.Inset(6, 6, 4, 4); 1202 canvas.drawRect( 1203 SkRect::MakeXYWH(rect.x(), rect.y(), rect.width(), rect.height()), 1204 paint); 1205 rect.Inset(6, 6, 4, 4); 1206 } 1207 1208 ResourceProvider::ResourceId mask_resource_id = 1209 this->resource_provider_->CreateResource( 1210 mask_rect.size(), 1211 GL_CLAMP_TO_EDGE, 1212 ResourceProvider::TextureHintImmutable, 1213 RGBA_8888); 1214 { 1215 SkAutoLockPixels lock(bitmap); 1216 this->resource_provider_->SetPixels( 1217 mask_resource_id, 1218 reinterpret_cast<uint8_t*>(bitmap.getPixels()), 1219 mask_rect, 1220 mask_rect, 1221 gfx::Vector2d()); 1222 } 1223 1224 // This RenderPassDrawQuad does not include the full |viewport_rect| which is 1225 // the size of the child render pass. 1226 gfx::Rect sub_rect = gfx::Rect(50, 50, 100, 100); 1227 EXPECT_NE(sub_rect.x(), child_pass->output_rect.x()); 1228 EXPECT_NE(sub_rect.y(), child_pass->output_rect.y()); 1229 EXPECT_NE(sub_rect.right(), child_pass->output_rect.right()); 1230 EXPECT_NE(sub_rect.bottom(), child_pass->output_rect.bottom()); 1231 EXPECT_TRUE(child_pass->output_rect.Contains(sub_rect)); 1232 1233 // Set up a mask on the RenderPassDrawQuad. 1234 RenderPassDrawQuad* mask_quad = 1235 root_pass->CreateAndAppendDrawQuad<RenderPassDrawQuad>(); 1236 mask_quad->SetNew(root_pass_shared_state, 1237 sub_rect, 1238 sub_rect, 1239 child_pass_id, 1240 mask_resource_id, 1241 gfx::RectF(1.f, 1.f), // mask_uv_rect 1242 FilterOperations(), // foreground filters 1243 gfx::Vector2dF(), // filters scale 1244 FilterOperations()); // background filters 1245 1246 // White background behind the masked render pass. 1247 SolidColorDrawQuad* white = 1248 root_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); 1249 white->SetNew(root_pass_shared_state, 1250 viewport_rect, 1251 viewport_rect, 1252 SK_ColorWHITE, 1253 false); 1254 1255 RenderPassList pass_list; 1256 pass_list.push_back(child_pass.Pass()); 1257 pass_list.push_back(root_pass.Pass()); 1258 1259 EXPECT_TRUE(this->RunPixelTest( 1260 &pass_list, 1261 base::FilePath(FILE_PATH_LITERAL("image_mask_of_layer.png")), 1262 ExactPixelComparator(true))); 1263 } 1264 1265 template <typename RendererType> 1266 class RendererPixelTestWithBackgroundFilter 1267 : public RendererPixelTest<RendererType> { 1268 protected: 1269 void SetUpRenderPassList() { 1270 gfx::Rect device_viewport_rect(this->device_viewport_size_); 1271 1272 RenderPassId root_id(1, 1); 1273 scoped_ptr<RenderPass> root_pass = 1274 CreateTestRootRenderPass(root_id, device_viewport_rect); 1275 root_pass->has_transparent_background = false; 1276 1277 gfx::Transform identity_content_to_target_transform; 1278 1279 RenderPassId filter_pass_id(2, 1); 1280 gfx::Transform transform_to_root; 1281 scoped_ptr<RenderPass> filter_pass = 1282 CreateTestRenderPass(filter_pass_id, 1283 filter_pass_content_rect_, 1284 transform_to_root); 1285 1286 // A non-visible quad in the filtering render pass. 1287 { 1288 SharedQuadState* shared_state = 1289 CreateTestSharedQuadState(identity_content_to_target_transform, 1290 filter_pass_content_rect_, 1291 filter_pass.get()); 1292 SolidColorDrawQuad* color_quad = 1293 filter_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); 1294 color_quad->SetNew(shared_state, 1295 filter_pass_content_rect_, 1296 filter_pass_content_rect_, 1297 SK_ColorTRANSPARENT, 1298 false); 1299 } 1300 1301 { 1302 SharedQuadState* shared_state = 1303 CreateTestSharedQuadState(filter_pass_to_target_transform_, 1304 filter_pass_content_rect_, 1305 filter_pass.get()); 1306 RenderPassDrawQuad* filter_pass_quad = 1307 root_pass->CreateAndAppendDrawQuad<RenderPassDrawQuad>(); 1308 filter_pass_quad->SetNew( 1309 shared_state, 1310 filter_pass_content_rect_, 1311 filter_pass_content_rect_, 1312 filter_pass_id, 1313 0, // mask_resource_id 1314 gfx::RectF(), // mask_uv_rect 1315 FilterOperations(), // filters 1316 gfx::Vector2dF(), // filters_scale 1317 this->background_filters_); 1318 } 1319 1320 const int kColumnWidth = device_viewport_rect.width() / 3; 1321 1322 gfx::Rect left_rect = gfx::Rect(0, 0, kColumnWidth, 20); 1323 for (int i = 0; left_rect.y() < device_viewport_rect.height(); ++i) { 1324 SharedQuadState* shared_state = CreateTestSharedQuadState( 1325 identity_content_to_target_transform, left_rect, root_pass.get()); 1326 SolidColorDrawQuad* color_quad = 1327 root_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); 1328 color_quad->SetNew( 1329 shared_state, left_rect, left_rect, SK_ColorGREEN, false); 1330 left_rect += gfx::Vector2d(0, left_rect.height() + 1); 1331 } 1332 1333 gfx::Rect middle_rect = gfx::Rect(kColumnWidth+1, 0, kColumnWidth, 20); 1334 for (int i = 0; middle_rect.y() < device_viewport_rect.height(); ++i) { 1335 SharedQuadState* shared_state = CreateTestSharedQuadState( 1336 identity_content_to_target_transform, middle_rect, root_pass.get()); 1337 SolidColorDrawQuad* color_quad = 1338 root_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); 1339 color_quad->SetNew( 1340 shared_state, middle_rect, middle_rect, SK_ColorRED, false); 1341 middle_rect += gfx::Vector2d(0, middle_rect.height() + 1); 1342 } 1343 1344 gfx::Rect right_rect = gfx::Rect((kColumnWidth+1)*2, 0, kColumnWidth, 20); 1345 for (int i = 0; right_rect.y() < device_viewport_rect.height(); ++i) { 1346 SharedQuadState* shared_state = CreateTestSharedQuadState( 1347 identity_content_to_target_transform, right_rect, root_pass.get()); 1348 SolidColorDrawQuad* color_quad = 1349 root_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); 1350 color_quad->SetNew( 1351 shared_state, right_rect, right_rect, SK_ColorBLUE, false); 1352 right_rect += gfx::Vector2d(0, right_rect.height() + 1); 1353 } 1354 1355 SharedQuadState* shared_state = 1356 CreateTestSharedQuadState(identity_content_to_target_transform, 1357 device_viewport_rect, 1358 root_pass.get()); 1359 SolidColorDrawQuad* background_quad = 1360 root_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); 1361 background_quad->SetNew(shared_state, 1362 device_viewport_rect, 1363 device_viewport_rect, 1364 SK_ColorWHITE, 1365 false); 1366 1367 pass_list_.push_back(filter_pass.Pass()); 1368 pass_list_.push_back(root_pass.Pass()); 1369 } 1370 1371 RenderPassList pass_list_; 1372 FilterOperations background_filters_; 1373 gfx::Transform filter_pass_to_target_transform_; 1374 gfx::Rect filter_pass_content_rect_; 1375 }; 1376 1377 typedef ::testing::Types<GLRenderer, SoftwareRenderer> 1378 BackgroundFilterRendererTypes; 1379 TYPED_TEST_CASE(RendererPixelTestWithBackgroundFilter, 1380 BackgroundFilterRendererTypes); 1381 1382 typedef RendererPixelTestWithBackgroundFilter<GLRenderer> 1383 GLRendererPixelTestWithBackgroundFilter; 1384 1385 // TODO(skaslev): The software renderer does not support filters yet. 1386 TEST_F(GLRendererPixelTestWithBackgroundFilter, InvertFilter) { 1387 this->background_filters_.Append( 1388 FilterOperation::CreateInvertFilter(1.f)); 1389 1390 this->filter_pass_content_rect_ = gfx::Rect(this->device_viewport_size_); 1391 this->filter_pass_content_rect_.Inset(12, 14, 16, 18); 1392 1393 this->SetUpRenderPassList(); 1394 EXPECT_TRUE(this->RunPixelTest( 1395 &this->pass_list_, 1396 base::FilePath(FILE_PATH_LITERAL("background_filter.png")), 1397 ExactPixelComparator(true))); 1398 } 1399 1400 class ExternalStencilPixelTest : public GLRendererPixelTest { 1401 protected: 1402 void ClearBackgroundToGreen() { 1403 GLES2Interface* gl = output_surface_->context_provider()->ContextGL(); 1404 output_surface_->EnsureBackbuffer(); 1405 output_surface_->Reshape(device_viewport_size_, 1); 1406 gl->ClearColor(0.f, 1.f, 0.f, 1.f); 1407 gl->Clear(GL_COLOR_BUFFER_BIT); 1408 } 1409 1410 void PopulateStencilBuffer() { 1411 // Set two quadrants of the stencil buffer to 1. 1412 GLES2Interface* gl = output_surface_->context_provider()->ContextGL(); 1413 output_surface_->EnsureBackbuffer(); 1414 output_surface_->Reshape(device_viewport_size_, 1); 1415 gl->ClearStencil(0); 1416 gl->Clear(GL_STENCIL_BUFFER_BIT); 1417 gl->Enable(GL_SCISSOR_TEST); 1418 gl->ClearStencil(1); 1419 gl->Scissor(0, 1420 0, 1421 device_viewport_size_.width() / 2, 1422 device_viewport_size_.height() / 2); 1423 gl->Clear(GL_STENCIL_BUFFER_BIT); 1424 gl->Scissor(device_viewport_size_.width() / 2, 1425 device_viewport_size_.height() / 2, 1426 device_viewport_size_.width(), 1427 device_viewport_size_.height()); 1428 gl->Clear(GL_STENCIL_BUFFER_BIT); 1429 } 1430 }; 1431 1432 TEST_F(ExternalStencilPixelTest, StencilTestEnabled) { 1433 ClearBackgroundToGreen(); 1434 PopulateStencilBuffer(); 1435 this->EnableExternalStencilTest(); 1436 1437 // Draw a blue quad that covers the entire device viewport. It should be 1438 // clipped to the bottom left and top right corners by the external stencil. 1439 gfx::Rect rect(this->device_viewport_size_); 1440 RenderPassId id(1, 1); 1441 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); 1442 SharedQuadState* blue_shared_state = 1443 CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); 1444 SolidColorDrawQuad* blue = 1445 pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); 1446 blue->SetNew(blue_shared_state, rect, rect, SK_ColorBLUE, false); 1447 pass->has_transparent_background = false; 1448 RenderPassList pass_list; 1449 pass_list.push_back(pass.Pass()); 1450 1451 EXPECT_TRUE(this->RunPixelTest( 1452 &pass_list, 1453 base::FilePath(FILE_PATH_LITERAL("four_blue_green_checkers.png")), 1454 ExactPixelComparator(true))); 1455 } 1456 1457 TEST_F(ExternalStencilPixelTest, StencilTestDisabled) { 1458 PopulateStencilBuffer(); 1459 1460 // Draw a green quad that covers the entire device viewport. The stencil 1461 // buffer should be ignored. 1462 gfx::Rect rect(this->device_viewport_size_); 1463 RenderPassId id(1, 1); 1464 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); 1465 SharedQuadState* green_shared_state = 1466 CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); 1467 SolidColorDrawQuad* green = 1468 pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); 1469 green->SetNew(green_shared_state, rect, rect, SK_ColorGREEN, false); 1470 RenderPassList pass_list; 1471 pass_list.push_back(pass.Pass()); 1472 1473 EXPECT_TRUE(this->RunPixelTest( 1474 &pass_list, 1475 base::FilePath(FILE_PATH_LITERAL("green.png")), 1476 ExactPixelComparator(true))); 1477 } 1478 1479 TEST_F(ExternalStencilPixelTest, RenderSurfacesIgnoreStencil) { 1480 // The stencil test should apply only to the final render pass. 1481 ClearBackgroundToGreen(); 1482 PopulateStencilBuffer(); 1483 this->EnableExternalStencilTest(); 1484 1485 gfx::Rect viewport_rect(this->device_viewport_size_); 1486 1487 RenderPassId root_pass_id(1, 1); 1488 scoped_ptr<RenderPass> root_pass = 1489 CreateTestRootRenderPass(root_pass_id, viewport_rect); 1490 root_pass->has_transparent_background = false; 1491 1492 RenderPassId child_pass_id(2, 2); 1493 gfx::Rect pass_rect(this->device_viewport_size_); 1494 gfx::Transform transform_to_root; 1495 scoped_ptr<RenderPass> child_pass = 1496 CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root); 1497 1498 gfx::Transform content_to_target_transform; 1499 SharedQuadState* shared_state = CreateTestSharedQuadState( 1500 content_to_target_transform, viewport_rect, child_pass.get()); 1501 1502 gfx::Rect blue_rect(0, 1503 0, 1504 this->device_viewport_size_.width(), 1505 this->device_viewport_size_.height()); 1506 SolidColorDrawQuad* blue = 1507 child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); 1508 blue->SetNew(shared_state, blue_rect, blue_rect, SK_ColorBLUE, false); 1509 1510 SharedQuadState* pass_shared_state = 1511 CreateTestSharedQuadState(gfx::Transform(), pass_rect, root_pass.get()); 1512 CreateTestRenderPassDrawQuad( 1513 pass_shared_state, pass_rect, child_pass_id, root_pass.get()); 1514 RenderPassList pass_list; 1515 pass_list.push_back(child_pass.Pass()); 1516 pass_list.push_back(root_pass.Pass()); 1517 1518 EXPECT_TRUE(this->RunPixelTest( 1519 &pass_list, 1520 base::FilePath(FILE_PATH_LITERAL("four_blue_green_checkers.png")), 1521 ExactPixelComparator(true))); 1522 } 1523 1524 TEST_F(ExternalStencilPixelTest, DeviceClip) { 1525 ClearBackgroundToGreen(); 1526 gfx::Rect clip_rect(gfx::Point(150, 150), gfx::Size(50, 50)); 1527 this->ForceDeviceClip(clip_rect); 1528 1529 // Draw a blue quad that covers the entire device viewport. It should be 1530 // clipped to the bottom right corner by the device clip. 1531 gfx::Rect rect(this->device_viewport_size_); 1532 RenderPassId id(1, 1); 1533 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); 1534 SharedQuadState* blue_shared_state = 1535 CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); 1536 SolidColorDrawQuad* blue = 1537 pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); 1538 blue->SetNew(blue_shared_state, rect, rect, SK_ColorBLUE, false); 1539 RenderPassList pass_list; 1540 pass_list.push_back(pass.Pass()); 1541 1542 EXPECT_TRUE(this->RunPixelTest( 1543 &pass_list, 1544 base::FilePath(FILE_PATH_LITERAL("green_with_blue_corner.png")), 1545 ExactPixelComparator(true))); 1546 } 1547 1548 // Software renderer does not support anti-aliased edges. 1549 TEST_F(GLRendererPixelTest, AntiAliasing) { 1550 gfx::Rect rect(this->device_viewport_size_); 1551 1552 RenderPassId id(1, 1); 1553 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); 1554 1555 gfx::Transform red_content_to_target_transform; 1556 red_content_to_target_transform.Rotate(10); 1557 SharedQuadState* red_shared_state = CreateTestSharedQuadState( 1558 red_content_to_target_transform, rect, pass.get()); 1559 1560 SolidColorDrawQuad* red = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); 1561 red->SetNew(red_shared_state, rect, rect, SK_ColorRED, false); 1562 1563 gfx::Transform yellow_content_to_target_transform; 1564 yellow_content_to_target_transform.Rotate(5); 1565 SharedQuadState* yellow_shared_state = CreateTestSharedQuadState( 1566 yellow_content_to_target_transform, rect, pass.get()); 1567 1568 SolidColorDrawQuad* yellow = 1569 pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); 1570 yellow->SetNew(yellow_shared_state, rect, rect, SK_ColorYELLOW, false); 1571 1572 gfx::Transform blue_content_to_target_transform; 1573 SharedQuadState* blue_shared_state = CreateTestSharedQuadState( 1574 blue_content_to_target_transform, rect, pass.get()); 1575 1576 SolidColorDrawQuad* blue = 1577 pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); 1578 blue->SetNew(blue_shared_state, rect, rect, SK_ColorBLUE, false); 1579 1580 RenderPassList pass_list; 1581 pass_list.push_back(pass.Pass()); 1582 1583 EXPECT_TRUE(this->RunPixelTest( 1584 &pass_list, 1585 base::FilePath(FILE_PATH_LITERAL("anti_aliasing.png")), 1586 FuzzyPixelOffByOneComparator(true))); 1587 } 1588 1589 // This test tests that anti-aliasing works for axis aligned quads. 1590 // Anti-aliasing is only supported in the gl renderer. 1591 TEST_F(GLRendererPixelTest, AxisAligned) { 1592 gfx::Rect rect(this->device_viewport_size_); 1593 1594 RenderPassId id(1, 1); 1595 gfx::Transform transform_to_root; 1596 scoped_ptr<RenderPass> pass = 1597 CreateTestRenderPass(id, rect, transform_to_root); 1598 1599 gfx::Transform red_content_to_target_transform; 1600 red_content_to_target_transform.Translate(50, 50); 1601 red_content_to_target_transform.Scale( 1602 0.5f + 1.0f / (rect.width() * 2.0f), 1603 0.5f + 1.0f / (rect.height() * 2.0f)); 1604 SharedQuadState* red_shared_state = CreateTestSharedQuadState( 1605 red_content_to_target_transform, rect, pass.get()); 1606 1607 SolidColorDrawQuad* red = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); 1608 red->SetNew(red_shared_state, rect, rect, SK_ColorRED, false); 1609 1610 gfx::Transform yellow_content_to_target_transform; 1611 yellow_content_to_target_transform.Translate(25.5f, 25.5f); 1612 yellow_content_to_target_transform.Scale(0.5f, 0.5f); 1613 SharedQuadState* yellow_shared_state = CreateTestSharedQuadState( 1614 yellow_content_to_target_transform, rect, pass.get()); 1615 1616 SolidColorDrawQuad* yellow = 1617 pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); 1618 yellow->SetNew(yellow_shared_state, rect, rect, SK_ColorYELLOW, false); 1619 1620 gfx::Transform blue_content_to_target_transform; 1621 SharedQuadState* blue_shared_state = CreateTestSharedQuadState( 1622 blue_content_to_target_transform, rect, pass.get()); 1623 1624 SolidColorDrawQuad* blue = 1625 pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); 1626 blue->SetNew(blue_shared_state, rect, rect, SK_ColorBLUE, false); 1627 1628 RenderPassList pass_list; 1629 pass_list.push_back(pass.Pass()); 1630 1631 EXPECT_TRUE(this->RunPixelTest( 1632 &pass_list, 1633 base::FilePath(FILE_PATH_LITERAL("axis_aligned.png")), 1634 ExactPixelComparator(true))); 1635 } 1636 1637 // This test tests that forcing anti-aliasing off works as expected. 1638 // Anti-aliasing is only supported in the gl renderer. 1639 TEST_F(GLRendererPixelTest, ForceAntiAliasingOff) { 1640 gfx::Rect rect(this->device_viewport_size_); 1641 1642 RenderPassId id(1, 1); 1643 gfx::Transform transform_to_root; 1644 scoped_ptr<RenderPass> pass = 1645 CreateTestRenderPass(id, rect, transform_to_root); 1646 1647 gfx::Transform hole_content_to_target_transform; 1648 hole_content_to_target_transform.Translate(50, 50); 1649 hole_content_to_target_transform.Scale( 1650 0.5f + 1.0f / (rect.width() * 2.0f), 1651 0.5f + 1.0f / (rect.height() * 2.0f)); 1652 SharedQuadState* hole_shared_state = CreateTestSharedQuadState( 1653 hole_content_to_target_transform, rect, pass.get()); 1654 1655 SolidColorDrawQuad* hole = 1656 pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); 1657 hole->SetAll( 1658 hole_shared_state, rect, rect, rect, false, SK_ColorTRANSPARENT, true); 1659 1660 gfx::Transform green_content_to_target_transform; 1661 SharedQuadState* green_shared_state = CreateTestSharedQuadState( 1662 green_content_to_target_transform, rect, pass.get()); 1663 1664 SolidColorDrawQuad* green = 1665 pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); 1666 green->SetNew(green_shared_state, rect, rect, SK_ColorGREEN, false); 1667 1668 RenderPassList pass_list; 1669 pass_list.push_back(pass.Pass()); 1670 1671 EXPECT_TRUE(this->RunPixelTest( 1672 &pass_list, 1673 base::FilePath(FILE_PATH_LITERAL("force_anti_aliasing_off.png")), 1674 ExactPixelComparator(false))); 1675 } 1676 1677 TEST_F(GLRendererPixelTest, AntiAliasingPerspective) { 1678 gfx::Rect rect(this->device_viewport_size_); 1679 1680 scoped_ptr<RenderPass> pass = 1681 CreateTestRootRenderPass(RenderPassId(1, 1), rect); 1682 1683 gfx::Rect red_rect(0, 0, 180, 500); 1684 gfx::Transform red_content_to_target_transform( 1685 1.0f, 2.4520f, 10.6206f, 19.0f, 1686 0.0f, 0.3528f, 5.9737f, 9.5f, 1687 0.0f, -0.2250f, -0.9744f, 0.0f, 1688 0.0f, 0.0225f, 0.0974f, 1.0f); 1689 SharedQuadState* red_shared_state = CreateTestSharedQuadState( 1690 red_content_to_target_transform, red_rect, pass.get()); 1691 SolidColorDrawQuad* red = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); 1692 red->SetNew(red_shared_state, red_rect, red_rect, SK_ColorRED, false); 1693 1694 gfx::Rect green_rect(19, 7, 180, 10); 1695 SharedQuadState* green_shared_state = 1696 CreateTestSharedQuadState(gfx::Transform(), green_rect, pass.get()); 1697 SolidColorDrawQuad* green = 1698 pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); 1699 green->SetNew( 1700 green_shared_state, green_rect, green_rect, SK_ColorGREEN, false); 1701 1702 SharedQuadState* blue_shared_state = 1703 CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); 1704 SolidColorDrawQuad* blue = 1705 pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); 1706 blue->SetNew(blue_shared_state, rect, rect, SK_ColorBLUE, false); 1707 1708 RenderPassList pass_list; 1709 pass_list.push_back(pass.Pass()); 1710 1711 EXPECT_TRUE(this->RunPixelTest( 1712 &pass_list, 1713 base::FilePath(FILE_PATH_LITERAL("anti_aliasing_perspective.png")), 1714 FuzzyPixelOffByOneComparator(true))); 1715 } 1716 1717 TYPED_TEST(RendererPixelTest, PictureDrawQuadIdentityScale) { 1718 gfx::Size pile_tile_size(1000, 1000); 1719 gfx::Rect viewport(this->device_viewport_size_); 1720 // TODO(enne): the renderer should figure this out on its own. 1721 ResourceFormat texture_format = RGBA_8888; 1722 1723 RenderPassId id(1, 1); 1724 gfx::Transform transform_to_root; 1725 scoped_ptr<RenderPass> pass = 1726 CreateTestRenderPass(id, viewport, transform_to_root); 1727 1728 // One clipped blue quad in the lower right corner. Outside the clip 1729 // is red, which should not appear. 1730 gfx::Rect blue_rect(gfx::Size(100, 100)); 1731 gfx::Rect blue_clip_rect(gfx::Point(50, 50), gfx::Size(50, 50)); 1732 scoped_refptr<FakePicturePileImpl> blue_pile = 1733 FakePicturePileImpl::CreateFilledPile(pile_tile_size, blue_rect.size()); 1734 SkPaint red_paint; 1735 red_paint.setColor(SK_ColorRED); 1736 blue_pile->add_draw_rect_with_paint(blue_rect, red_paint); 1737 SkPaint blue_paint; 1738 blue_paint.setColor(SK_ColorBLUE); 1739 blue_pile->add_draw_rect_with_paint(blue_clip_rect, blue_paint); 1740 blue_pile->RerecordPile(); 1741 1742 gfx::Transform blue_content_to_target_transform; 1743 gfx::Vector2d offset(viewport.bottom_right() - blue_rect.bottom_right()); 1744 blue_content_to_target_transform.Translate(offset.x(), offset.y()); 1745 gfx::RectF blue_scissor_rect = blue_clip_rect; 1746 blue_content_to_target_transform.TransformRect(&blue_scissor_rect); 1747 SharedQuadState* blue_shared_state = 1748 CreateTestSharedQuadStateClipped(blue_content_to_target_transform, 1749 blue_rect, 1750 gfx::ToEnclosingRect(blue_scissor_rect), 1751 pass.get()); 1752 1753 PictureDrawQuad* blue_quad = pass->CreateAndAppendDrawQuad<PictureDrawQuad>(); 1754 1755 blue_quad->SetNew(blue_shared_state, 1756 viewport, // Intentionally bigger than clip. 1757 gfx::Rect(), 1758 viewport, 1759 gfx::RectF(viewport), 1760 viewport.size(), 1761 texture_format, 1762 viewport, 1763 1.f, 1764 PicturePileImpl::CreateFromOther(blue_pile.get())); 1765 1766 // One viewport-filling green quad. 1767 scoped_refptr<FakePicturePileImpl> green_pile = 1768 FakePicturePileImpl::CreateFilledPile(pile_tile_size, viewport.size()); 1769 SkPaint green_paint; 1770 green_paint.setColor(SK_ColorGREEN); 1771 green_pile->add_draw_rect_with_paint(viewport, green_paint); 1772 green_pile->RerecordPile(); 1773 1774 gfx::Transform green_content_to_target_transform; 1775 SharedQuadState* green_shared_state = CreateTestSharedQuadState( 1776 green_content_to_target_transform, viewport, pass.get()); 1777 1778 PictureDrawQuad* green_quad = 1779 pass->CreateAndAppendDrawQuad<PictureDrawQuad>(); 1780 green_quad->SetNew(green_shared_state, 1781 viewport, 1782 gfx::Rect(), 1783 viewport, 1784 gfx::RectF(0.f, 0.f, 1.f, 1.f), 1785 viewport.size(), 1786 texture_format, 1787 viewport, 1788 1.f, 1789 PicturePileImpl::CreateFromOther(green_pile.get())); 1790 1791 RenderPassList pass_list; 1792 pass_list.push_back(pass.Pass()); 1793 1794 EXPECT_TRUE(this->RunPixelTest( 1795 &pass_list, 1796 base::FilePath(FILE_PATH_LITERAL("green_with_blue_corner.png")), 1797 ExactPixelComparator(true))); 1798 } 1799 1800 // Not WithSkiaGPUBackend since that path currently requires tiles for opacity. 1801 TYPED_TEST(RendererPixelTest, PictureDrawQuadOpacity) { 1802 gfx::Size pile_tile_size(1000, 1000); 1803 gfx::Rect viewport(this->device_viewport_size_); 1804 ResourceFormat texture_format = RGBA_8888; 1805 1806 RenderPassId id(1, 1); 1807 gfx::Transform transform_to_root; 1808 scoped_ptr<RenderPass> pass = 1809 CreateTestRenderPass(id, viewport, transform_to_root); 1810 1811 // One viewport-filling 0.5-opacity green quad. 1812 scoped_refptr<FakePicturePileImpl> green_pile = 1813 FakePicturePileImpl::CreateFilledPile(pile_tile_size, viewport.size()); 1814 SkPaint green_paint; 1815 green_paint.setColor(SK_ColorGREEN); 1816 green_pile->add_draw_rect_with_paint(viewport, green_paint); 1817 green_pile->RerecordPile(); 1818 1819 gfx::Transform green_content_to_target_transform; 1820 SharedQuadState* green_shared_state = CreateTestSharedQuadState( 1821 green_content_to_target_transform, viewport, pass.get()); 1822 green_shared_state->opacity = 0.5f; 1823 1824 PictureDrawQuad* green_quad = 1825 pass->CreateAndAppendDrawQuad<PictureDrawQuad>(); 1826 green_quad->SetNew(green_shared_state, 1827 viewport, 1828 gfx::Rect(), 1829 viewport, 1830 gfx::RectF(0, 0, 1, 1), 1831 viewport.size(), 1832 texture_format, 1833 viewport, 1834 1.f, 1835 PicturePileImpl::CreateFromOther(green_pile.get())); 1836 1837 // One viewport-filling white quad. 1838 scoped_refptr<FakePicturePileImpl> white_pile = 1839 FakePicturePileImpl::CreateFilledPile(pile_tile_size, viewport.size()); 1840 SkPaint white_paint; 1841 white_paint.setColor(SK_ColorWHITE); 1842 white_pile->add_draw_rect_with_paint(viewport, white_paint); 1843 white_pile->RerecordPile(); 1844 1845 gfx::Transform white_content_to_target_transform; 1846 SharedQuadState* white_shared_state = CreateTestSharedQuadState( 1847 white_content_to_target_transform, viewport, pass.get()); 1848 1849 PictureDrawQuad* white_quad = 1850 pass->CreateAndAppendDrawQuad<PictureDrawQuad>(); 1851 white_quad->SetNew(white_shared_state, 1852 viewport, 1853 gfx::Rect(), 1854 viewport, 1855 gfx::RectF(0, 0, 1, 1), 1856 viewport.size(), 1857 texture_format, 1858 viewport, 1859 1.f, 1860 PicturePileImpl::CreateFromOther(white_pile.get())); 1861 1862 RenderPassList pass_list; 1863 pass_list.push_back(pass.Pass()); 1864 1865 EXPECT_TRUE(this->RunPixelTest( 1866 &pass_list, 1867 base::FilePath(FILE_PATH_LITERAL("green_alpha.png")), 1868 FuzzyPixelOffByOneComparator(true))); 1869 } 1870 1871 template<typename TypeParam> bool IsSoftwareRenderer() { 1872 return false; 1873 } 1874 1875 template<> 1876 bool IsSoftwareRenderer<SoftwareRenderer>() { 1877 return true; 1878 } 1879 1880 template<> 1881 bool IsSoftwareRenderer<SoftwareRendererWithExpandedViewport>() { 1882 return true; 1883 } 1884 1885 // If we disable image filtering, then a 2x2 bitmap should appear as four 1886 // huge sharp squares. 1887 TYPED_TEST(RendererPixelTest, PictureDrawQuadDisableImageFiltering) { 1888 // We only care about this in software mode since bilinear filtering is 1889 // cheap in hardware. 1890 if (!IsSoftwareRenderer<TypeParam>()) 1891 return; 1892 1893 gfx::Size pile_tile_size(1000, 1000); 1894 gfx::Rect viewport(this->device_viewport_size_); 1895 ResourceFormat texture_format = RGBA_8888; 1896 1897 RenderPassId id(1, 1); 1898 gfx::Transform transform_to_root; 1899 scoped_ptr<RenderPass> pass = 1900 CreateTestRenderPass(id, viewport, transform_to_root); 1901 1902 SkBitmap bitmap; 1903 bitmap.allocN32Pixels(2, 2); 1904 { 1905 SkAutoLockPixels lock(bitmap); 1906 SkCanvas canvas(bitmap); 1907 canvas.drawPoint(0, 0, SK_ColorGREEN); 1908 canvas.drawPoint(0, 1, SK_ColorBLUE); 1909 canvas.drawPoint(1, 0, SK_ColorBLUE); 1910 canvas.drawPoint(1, 1, SK_ColorGREEN); 1911 } 1912 1913 scoped_refptr<FakePicturePileImpl> pile = 1914 FakePicturePileImpl::CreateFilledPile(pile_tile_size, viewport.size()); 1915 SkPaint paint; 1916 paint.setFilterLevel(SkPaint::kLow_FilterLevel); 1917 pile->add_draw_bitmap_with_paint(bitmap, gfx::Point(), paint); 1918 pile->RerecordPile(); 1919 1920 gfx::Transform content_to_target_transform; 1921 SharedQuadState* shared_state = CreateTestSharedQuadState( 1922 content_to_target_transform, viewport, pass.get()); 1923 1924 PictureDrawQuad* quad = pass->CreateAndAppendDrawQuad<PictureDrawQuad>(); 1925 quad->SetNew(shared_state, 1926 viewport, 1927 gfx::Rect(), 1928 viewport, 1929 gfx::RectF(0, 0, 2, 2), 1930 viewport.size(), 1931 texture_format, 1932 viewport, 1933 1.f, 1934 PicturePileImpl::CreateFromOther(pile.get())); 1935 1936 RenderPassList pass_list; 1937 pass_list.push_back(pass.Pass()); 1938 1939 this->disable_picture_quad_image_filtering_ = true; 1940 1941 EXPECT_TRUE(this->RunPixelTest( 1942 &pass_list, 1943 base::FilePath(FILE_PATH_LITERAL("four_blue_green_checkers.png")), 1944 ExactPixelComparator(true))); 1945 } 1946 1947 TYPED_TEST(RendererPixelTest, PictureDrawQuadNonIdentityScale) { 1948 gfx::Size pile_tile_size(1000, 1000); 1949 gfx::Rect viewport(this->device_viewport_size_); 1950 // TODO(enne): the renderer should figure this out on its own. 1951 ResourceFormat texture_format = RGBA_8888; 1952 1953 RenderPassId id(1, 1); 1954 gfx::Transform transform_to_root; 1955 scoped_ptr<RenderPass> pass = 1956 CreateTestRenderPass(id, viewport, transform_to_root); 1957 1958 // As scaling up the blue checkerboards will cause sampling on the GPU, 1959 // a few extra "cleanup rects" need to be added to clobber the blending 1960 // to make the output image more clean. This will also test subrects 1961 // of the layer. 1962 gfx::Transform green_content_to_target_transform; 1963 gfx::Rect green_rect1(gfx::Point(80, 0), gfx::Size(20, 100)); 1964 gfx::Rect green_rect2(gfx::Point(0, 80), gfx::Size(100, 20)); 1965 scoped_refptr<FakePicturePileImpl> green_pile = 1966 FakePicturePileImpl::CreateFilledPile(pile_tile_size, viewport.size()); 1967 SkPaint red_paint; 1968 red_paint.setColor(SK_ColorRED); 1969 green_pile->add_draw_rect_with_paint(viewport, red_paint); 1970 SkPaint green_paint; 1971 green_paint.setColor(SK_ColorGREEN); 1972 green_pile->add_draw_rect_with_paint(green_rect1, green_paint); 1973 green_pile->add_draw_rect_with_paint(green_rect2, green_paint); 1974 green_pile->RerecordPile(); 1975 1976 SharedQuadState* top_right_green_shared_quad_state = 1977 CreateTestSharedQuadState( 1978 green_content_to_target_transform, viewport, pass.get()); 1979 1980 PictureDrawQuad* green_quad1 = 1981 pass->CreateAndAppendDrawQuad<PictureDrawQuad>(); 1982 green_quad1->SetNew(top_right_green_shared_quad_state, 1983 green_rect1, 1984 gfx::Rect(), 1985 green_rect1, 1986 gfx::RectF(green_rect1.size()), 1987 green_rect1.size(), 1988 texture_format, 1989 green_rect1, 1990 1.f, 1991 PicturePileImpl::CreateFromOther(green_pile.get())); 1992 1993 PictureDrawQuad* green_quad2 = 1994 pass->CreateAndAppendDrawQuad<PictureDrawQuad>(); 1995 green_quad2->SetNew(top_right_green_shared_quad_state, 1996 green_rect2, 1997 gfx::Rect(), 1998 green_rect2, 1999 gfx::RectF(green_rect2.size()), 2000 green_rect2.size(), 2001 texture_format, 2002 green_rect2, 2003 1.f, 2004 PicturePileImpl::CreateFromOther(green_pile.get())); 2005 2006 // Add a green clipped checkerboard in the bottom right to help test 2007 // interleaving picture quad content and solid color content. 2008 gfx::Rect bottom_right_rect( 2009 gfx::Point(viewport.width() / 2, viewport.height() / 2), 2010 gfx::Size(viewport.width() / 2, viewport.height() / 2)); 2011 SharedQuadState* bottom_right_green_shared_state = 2012 CreateTestSharedQuadStateClipped(green_content_to_target_transform, 2013 viewport, 2014 bottom_right_rect, 2015 pass.get()); 2016 SolidColorDrawQuad* bottom_right_color_quad = 2017 pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); 2018 bottom_right_color_quad->SetNew(bottom_right_green_shared_state, 2019 viewport, 2020 viewport, 2021 SK_ColorGREEN, 2022 false); 2023 2024 // Add two blue checkerboards taking up the bottom left and top right, 2025 // but use content scales as content rects to make this happen. 2026 // The content is at a 4x content scale. 2027 gfx::Rect layer_rect(gfx::Size(20, 30)); 2028 float contents_scale = 4.f; 2029 // Two rects that touch at their corners, arbitrarily placed in the layer. 2030 gfx::RectF blue_layer_rect1(gfx::PointF(5.5f, 9.0f), gfx::SizeF(2.5f, 2.5f)); 2031 gfx::RectF blue_layer_rect2(gfx::PointF(8.0f, 6.5f), gfx::SizeF(2.5f, 2.5f)); 2032 gfx::RectF union_layer_rect = blue_layer_rect1; 2033 union_layer_rect.Union(blue_layer_rect2); 2034 2035 // Because scaling up will cause sampling outside the rects, add one extra 2036 // pixel of buffer at the final content scale. 2037 float inset = -1.f / contents_scale; 2038 blue_layer_rect1.Inset(inset, inset, inset, inset); 2039 blue_layer_rect2.Inset(inset, inset, inset, inset); 2040 2041 scoped_refptr<FakePicturePileImpl> pile = 2042 FakePicturePileImpl::CreateFilledPile(pile_tile_size, layer_rect.size()); 2043 2044 Region outside(layer_rect); 2045 outside.Subtract(gfx::ToEnclosingRect(union_layer_rect)); 2046 for (Region::Iterator iter(outside); iter.has_rect(); iter.next()) { 2047 pile->add_draw_rect_with_paint(iter.rect(), red_paint); 2048 } 2049 2050 SkPaint blue_paint; 2051 blue_paint.setColor(SK_ColorBLUE); 2052 pile->add_draw_rect_with_paint(blue_layer_rect1, blue_paint); 2053 pile->add_draw_rect_with_paint(blue_layer_rect2, blue_paint); 2054 pile->RerecordPile(); 2055 2056 gfx::Rect content_rect( 2057 gfx::ScaleToEnclosingRect(layer_rect, contents_scale)); 2058 gfx::Rect content_union_rect( 2059 gfx::ToEnclosingRect(gfx::ScaleRect(union_layer_rect, contents_scale))); 2060 2061 // At a scale of 4x the rectangles with a width of 2.5 will take up 10 pixels, 2062 // so scale an additional 10x to make them 100x100. 2063 gfx::Transform content_to_target_transform; 2064 content_to_target_transform.Scale(10.0, 10.0); 2065 gfx::Rect quad_content_rect(gfx::Size(20, 20)); 2066 SharedQuadState* blue_shared_state = CreateTestSharedQuadState( 2067 content_to_target_transform, quad_content_rect, pass.get()); 2068 2069 PictureDrawQuad* blue_quad = pass->CreateAndAppendDrawQuad<PictureDrawQuad>(); 2070 blue_quad->SetNew(blue_shared_state, 2071 quad_content_rect, 2072 gfx::Rect(), 2073 quad_content_rect, 2074 gfx::RectF(quad_content_rect), 2075 content_union_rect.size(), 2076 texture_format, 2077 content_union_rect, 2078 contents_scale, 2079 PicturePileImpl::CreateFromOther(pile.get())); 2080 2081 // Fill left half of viewport with green. 2082 gfx::Transform half_green_content_to_target_transform; 2083 gfx::Rect half_green_rect(gfx::Size(viewport.width() / 2, viewport.height())); 2084 SharedQuadState* half_green_shared_state = CreateTestSharedQuadState( 2085 half_green_content_to_target_transform, half_green_rect, pass.get()); 2086 SolidColorDrawQuad* half_color_quad = 2087 pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); 2088 half_color_quad->SetNew(half_green_shared_state, 2089 half_green_rect, 2090 half_green_rect, 2091 SK_ColorGREEN, 2092 false); 2093 2094 RenderPassList pass_list; 2095 pass_list.push_back(pass.Pass()); 2096 2097 EXPECT_TRUE(this->RunPixelTest( 2098 &pass_list, 2099 base::FilePath(FILE_PATH_LITERAL("four_blue_green_checkers.png")), 2100 ExactPixelComparator(true))); 2101 } 2102 2103 TEST_F(GLRendererPixelTest, PictureDrawQuadTexture4444) { 2104 gfx::Size pile_tile_size(1000, 1000); 2105 gfx::Rect viewport(this->device_viewport_size_); 2106 ResourceFormat texture_format = RGBA_4444; 2107 2108 RenderPassId id(1, 1); 2109 gfx::Transform transform_to_root; 2110 scoped_ptr<RenderPass> pass = 2111 CreateTestRenderPass(id, viewport, transform_to_root); 2112 2113 // One viewport-filling blue quad 2114 scoped_refptr<FakePicturePileImpl> blue_pile = 2115 FakePicturePileImpl::CreateFilledPile(pile_tile_size, viewport.size()); 2116 SkPaint blue_paint; 2117 blue_paint.setColor(SK_ColorBLUE); 2118 blue_pile->add_draw_rect_with_paint(viewport, blue_paint); 2119 blue_pile->RerecordPile(); 2120 2121 gfx::Transform blue_content_to_target_transform; 2122 SharedQuadState* blue_shared_state = CreateTestSharedQuadState( 2123 blue_content_to_target_transform, viewport, pass.get()); 2124 2125 PictureDrawQuad* blue_quad = pass->CreateAndAppendDrawQuad<PictureDrawQuad>(); 2126 blue_quad->SetNew(blue_shared_state, 2127 viewport, 2128 gfx::Rect(), 2129 viewport, 2130 gfx::RectF(0.f, 0.f, 1.f, 1.f), 2131 viewport.size(), 2132 texture_format, 2133 viewport, 2134 1.f, 2135 PicturePileImpl::CreateFromOther(blue_pile.get())); 2136 2137 RenderPassList pass_list; 2138 pass_list.push_back(pass.Pass()); 2139 2140 EXPECT_TRUE(this->RunPixelTest(&pass_list, 2141 base::FilePath(FILE_PATH_LITERAL("blue.png")), 2142 ExactPixelComparator(true))); 2143 } 2144 2145 TYPED_TEST(RendererPixelTest, WrapModeRepeat) { 2146 gfx::Rect rect(this->device_viewport_size_); 2147 2148 RenderPassId id(1, 1); 2149 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); 2150 2151 SharedQuadState* shared_state = 2152 CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); 2153 2154 gfx::Rect texture_rect(4, 4); 2155 SkPMColor colors[4] = { 2156 SkPreMultiplyColor(SkColorSetARGB(255, 0, 255, 0)), 2157 SkPreMultiplyColor(SkColorSetARGB(255, 0, 128, 0)), 2158 SkPreMultiplyColor(SkColorSetARGB(255, 0, 64, 0)), 2159 SkPreMultiplyColor(SkColorSetARGB(255, 0, 0, 0)), 2160 }; 2161 uint32_t pixels[16] = { 2162 colors[0], colors[0], colors[1], colors[1], 2163 colors[0], colors[0], colors[1], colors[1], 2164 colors[2], colors[2], colors[3], colors[3], 2165 colors[2], colors[2], colors[3], colors[3], 2166 }; 2167 ResourceProvider::ResourceId resource = 2168 this->resource_provider_->CreateResource( 2169 texture_rect.size(), 2170 GL_REPEAT, 2171 ResourceProvider::TextureHintImmutable, 2172 RGBA_8888); 2173 this->resource_provider_->SetPixels( 2174 resource, 2175 reinterpret_cast<uint8_t*>(pixels), 2176 texture_rect, 2177 texture_rect, 2178 gfx::Vector2d()); 2179 2180 float vertex_opacity[4] = {1.0f, 1.0f, 1.0f, 1.0f}; 2181 TextureDrawQuad* texture_quad = 2182 pass->CreateAndAppendDrawQuad<TextureDrawQuad>(); 2183 texture_quad->SetNew( 2184 shared_state, 2185 gfx::Rect(this->device_viewport_size_), 2186 gfx::Rect(), 2187 gfx::Rect(this->device_viewport_size_), 2188 resource, 2189 true, // premultiplied_alpha 2190 gfx::PointF(0.0f, 0.0f), // uv_top_left 2191 gfx::PointF( // uv_bottom_right 2192 this->device_viewport_size_.width() / texture_rect.width(), 2193 this->device_viewport_size_.height() / texture_rect.height()), 2194 SK_ColorWHITE, 2195 vertex_opacity, 2196 false); // flipped 2197 2198 RenderPassList pass_list; 2199 pass_list.push_back(pass.Pass()); 2200 2201 EXPECT_TRUE(this->RunPixelTest( 2202 &pass_list, 2203 base::FilePath(FILE_PATH_LITERAL("wrap_mode_repeat.png")), 2204 FuzzyPixelOffByOneComparator(true))); 2205 } 2206 2207 #endif // !defined(OS_ANDROID) 2208 2209 } // namespace 2210 } // namespace cc 2211
