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