?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Revert of Linux MSan: enable swarming/sharding for browser_tests. (patchset #1 id...
[chromium-blink-merge.git] / cc / output / renderer_pixeltest.cc
blobd503cc4462160623e84d19d49898a5875334b475
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 bool Compare(const SkBitmap& actual_bmp,
172 const SkBitmap& expected_bmp) const override;
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 uint8 alpha_value = is_transparent ? 0 : 128;
427 CreateTestYUVVideoDrawQuad_FromVideoFrame(
428 shared_state, video_frame, alpha_value, tex_coord_rect, render_pass);
429 }
430
431 void CreateTestYUVVideoDrawQuad_Solid(const SharedQuadState* shared_state,
432 media::VideoFrame::Format format,
433 bool is_transparent,
434 const gfx::RectF& tex_coord_rect,
435 uint8 y,
436 uint8 u,
437 uint8 v,
438 RenderPass* render_pass) {
439 const gfx::Rect rect(this->device_viewport_size_);
440
441 scoped_refptr<media::VideoFrame> video_frame =
442 media::VideoFrame::CreateFrame(
443 format, rect.size(), rect, rect.size(), base::TimeDelta());
444
445 // YUV values of a solid, constant, color. Useful for testing that color
446 // space/color range are being handled properly.
447 memset(video_frame->data(media::VideoFrame::kYPlane),
448 y,
449 video_frame->stride(media::VideoFrame::kYPlane) *
450 video_frame->rows(media::VideoFrame::kYPlane));
451 memset(video_frame->data(media::VideoFrame::kUPlane),
452 u,
453 video_frame->stride(media::VideoFrame::kUPlane) *
454 video_frame->rows(media::VideoFrame::kUPlane));
455 memset(video_frame->data(media::VideoFrame::kVPlane),
456 v,
457 video_frame->stride(media::VideoFrame::kVPlane) *
458 video_frame->rows(media::VideoFrame::kVPlane));
459
460 uint8 alpha_value = is_transparent ? 0 : 128;
461 CreateTestYUVVideoDrawQuad_FromVideoFrame(
462 shared_state, video_frame, alpha_value, tex_coord_rect, render_pass);
463 }
464
465 void CreateEdgeBleedPass(media::VideoFrame::Format format,
466 RenderPassList* pass_list) {
467 gfx::Rect rect(200, 200);
468
469 RenderPassId id(1, 1);
470 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect);
471
472 // Scale the video up so that bilinear filtering kicks in to sample more
473 // than just nearest neighbor would.
474 gfx::Transform scale_by_2;
475 scale_by_2.Scale(2.f, 2.f);
476 gfx::Rect half_rect(100, 100);
477 SharedQuadState* shared_state =
478 CreateTestSharedQuadState(scale_by_2, half_rect, pass.get());
479
480 gfx::Size background_size(200, 200);
481 gfx::Rect green_rect(16, 20, 100, 100);
482 gfx::RectF tex_coord_rect(
483 static_cast<float>(green_rect.x()) / background_size.width(),
484 static_cast<float>(green_rect.y()) / background_size.height(),
485 static_cast<float>(green_rect.width()) / background_size.width(),
486 static_cast<float>(green_rect.height()) / background_size.height());
487
488 // YUV of (149,43,21) should be green (0,255,0) in RGB.
489 // Create a video frame that has a non-green background rect, with a
490 // green sub-rectangle that should be the only thing displayed in
491 // the final image. Bleeding will appear on all four sides of the video
492 // if the tex coords are not clamped.
493 CreateTestYUVVideoDrawQuad_TwoColor(shared_state, format, false,
494 tex_coord_rect, background_size, 0, 0,
495 0, green_rect, 149, 43, 21, pass.get());
496 pass_list->push_back(pass.Pass());
497 }
498
499 // Creates a video frame of size background_size filled with yuv_background,
500 // and then draws a foreground rectangle in a different color on top of
501 // that. The foreground rectangle must have coordinates that are divisible
502 // by 2 because YUV is a block format.
503 void CreateTestYUVVideoDrawQuad_TwoColor(const SharedQuadState* shared_state,
504 media::VideoFrame::Format format,
505 bool is_transparent,
506 const gfx::RectF& tex_coord_rect,
507 const gfx::Size& background_size,
508 uint8 y_background,
509 uint8 u_background,
510 uint8 v_background,
511 const gfx::Rect& foreground_rect,
512 uint8 y_foreground,
513 uint8 u_foreground,
514 uint8 v_foreground,
515 RenderPass* render_pass) {
516 const gfx::Rect rect(background_size);
517
518 scoped_refptr<media::VideoFrame> video_frame =
519 media::VideoFrame::CreateFrame(format, background_size, foreground_rect,
520 foreground_rect.size(),
521 base::TimeDelta());
522
523 int planes[] = {media::VideoFrame::kYPlane,
524 media::VideoFrame::kUPlane,
525 media::VideoFrame::kVPlane};
526 uint8 yuv_background[] = {y_background, u_background, v_background};
527 uint8 yuv_foreground[] = {y_foreground, u_foreground, v_foreground};
528 int sample_size[] = {1, 2, 2};
529
530 for (int i = 0; i < 3; ++i) {
531 memset(video_frame->data(planes[i]), yuv_background[i],
532 video_frame->stride(planes[i]) * video_frame->rows(planes[i]));
533 }
534
535 for (int i = 0; i < 3; ++i) {
536 // Since yuv encoding uses block encoding, widths have to be divisible
537 // by the sample size in order for this function to behave properly.
538 DCHECK_EQ(foreground_rect.x() % sample_size[i], 0);
539 DCHECK_EQ(foreground_rect.y() % sample_size[i], 0);
540 DCHECK_EQ(foreground_rect.width() % sample_size[i], 0);
541 DCHECK_EQ(foreground_rect.height() % sample_size[i], 0);
542
543 gfx::Rect sample_rect(foreground_rect.x() / sample_size[i],
544 foreground_rect.y() / sample_size[i],
545 foreground_rect.width() / sample_size[i],
546 foreground_rect.height() / sample_size[i]);
547 for (int y = sample_rect.y(); y < sample_rect.bottom(); ++y) {
548 for (int x = sample_rect.x(); x < sample_rect.right(); ++x) {
549 size_t offset = y * video_frame->stride(planes[i]) + x;
550 video_frame->data(planes[i])[offset] = yuv_foreground[i];
551 }
552 }
553 }
554
555 uint8 alpha_value = 255;
556 CreateTestYUVVideoDrawQuad_FromVideoFrame(
557 shared_state, video_frame, alpha_value, tex_coord_rect, render_pass);
558 }
559
560 void CreateTestYUVVideoDrawQuad_FromVideoFrame(
561 const SharedQuadState* shared_state,
562 scoped_refptr<media::VideoFrame> video_frame,
563 uint8 alpha_value,
564 const gfx::RectF& tex_coord_rect,
565 RenderPass* render_pass) {
566 const bool with_alpha = (video_frame->format() == media::VideoFrame::YV12A);
567 const YUVVideoDrawQuad::ColorSpace color_space =
568 (video_frame->format() == media::VideoFrame::YV12J
569 ? YUVVideoDrawQuad::REC_601_JPEG
570 : YUVVideoDrawQuad::REC_601);
571 const gfx::Rect rect(shared_state->content_bounds);
572 const gfx::Rect opaque_rect(0, 0, 0, 0);
573
574 if (with_alpha)
575 memset(video_frame->data(media::VideoFrame::kAPlane), alpha_value,
576 video_frame->stride(media::VideoFrame::kAPlane) *
577 video_frame->rows(media::VideoFrame::kAPlane));
578
579 VideoFrameExternalResources resources =
580 video_resource_updater_->CreateExternalResourcesFromVideoFrame(
581 video_frame);
582
583 EXPECT_EQ(VideoFrameExternalResources::YUV_RESOURCE, resources.type);
584 EXPECT_EQ(media::VideoFrame::NumPlanes(video_frame->format()),
585 resources.mailboxes.size());
586 EXPECT_EQ(media::VideoFrame::NumPlanes(video_frame->format()),
587 resources.release_callbacks.size());
588
589 ResourceProvider::ResourceId y_resource =
590 resource_provider_->CreateResourceFromTextureMailbox(
591 resources.mailboxes[media::VideoFrame::kYPlane],
592 SingleReleaseCallbackImpl::Create(
593 resources.release_callbacks[media::VideoFrame::kYPlane]));
594 ResourceProvider::ResourceId u_resource =
595 resource_provider_->CreateResourceFromTextureMailbox(
596 resources.mailboxes[media::VideoFrame::kUPlane],
597 SingleReleaseCallbackImpl::Create(
598 resources.release_callbacks[media::VideoFrame::kUPlane]));
599 ResourceProvider::ResourceId v_resource =
600 resource_provider_->CreateResourceFromTextureMailbox(
601 resources.mailboxes[media::VideoFrame::kVPlane],
602 SingleReleaseCallbackImpl::Create(
603 resources.release_callbacks[media::VideoFrame::kVPlane]));
604 ResourceProvider::ResourceId a_resource = 0;
605 if (with_alpha) {
606 a_resource = resource_provider_->CreateResourceFromTextureMailbox(
607 resources.mailboxes[media::VideoFrame::kAPlane],
608 SingleReleaseCallbackImpl::Create(
609 resources.release_callbacks[media::VideoFrame::kAPlane]));
610 }
611
612 YUVVideoDrawQuad* yuv_quad =
613 render_pass->CreateAndAppendDrawQuad<YUVVideoDrawQuad>();
614 yuv_quad->SetNew(shared_state, rect, opaque_rect, rect, tex_coord_rect,
615 video_frame->coded_size(), y_resource, u_resource,
616 v_resource, a_resource, color_space);
617 }
618
619 void SetUp() override {
620 GLRendererPixelTest::SetUp();
621 video_resource_updater_.reset(new VideoResourceUpdater(
622 output_surface_->context_provider(), resource_provider_.get()));
623 }
624
625 private:
626 scoped_ptr<VideoResourceUpdater> video_resource_updater_;
627 };
628
629 TEST_F(VideoGLRendererPixelTest, SimpleYUVRect) {
630 gfx::Rect rect(this->device_viewport_size_);
631
632 RenderPassId id(1, 1);
633 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect);
634
635 SharedQuadState* shared_state =
636 CreateTestSharedQuadState(gfx::Transform(), rect, pass.get());
637
638 CreateTestYUVVideoDrawQuad_Striped(shared_state,
639 media::VideoFrame::YV12,
640 false,
641 gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f),
642 pass.get());
643
644 RenderPassList pass_list;
645 pass_list.push_back(pass.Pass());
646
647 EXPECT_TRUE(
648 this->RunPixelTest(&pass_list,
649 base::FilePath(FILE_PATH_LITERAL("yuv_stripes.png")),
650 FuzzyPixelOffByOneComparator(true)));
651 }
652
653 TEST_F(VideoGLRendererPixelTest, OffsetYUVRect) {
654 gfx::Rect rect(this->device_viewport_size_);
655
656 RenderPassId id(1, 1);
657 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect);
658
659 SharedQuadState* shared_state =
660 CreateTestSharedQuadState(gfx::Transform(), rect, pass.get());
661
662 // Intentionally sets frame format to I420 for testing coverage.
663 CreateTestYUVVideoDrawQuad_Striped(shared_state,
664 media::VideoFrame::I420,
665 false,
666 gfx::RectF(0.125f, 0.25f, 0.75f, 0.5f),
667 pass.get());
668
669 RenderPassList pass_list;
670 pass_list.push_back(pass.Pass());
671
672 EXPECT_TRUE(this->RunPixelTest(
673 &pass_list,
674 base::FilePath(FILE_PATH_LITERAL("yuv_stripes_offset.png")),
675 FuzzyPixelOffByOneComparator(true)));
676 }
677
678 TEST_F(VideoGLRendererPixelTest, SimpleYUVRectBlack) {
679 gfx::Rect rect(this->device_viewport_size_);
680
681 RenderPassId id(1, 1);
682 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect);
683
684 SharedQuadState* shared_state =
685 CreateTestSharedQuadState(gfx::Transform(), rect, pass.get());
686
687 // In MPEG color range YUV values of (15,128,128) should produce black.
688 CreateTestYUVVideoDrawQuad_Solid(shared_state,
689 media::VideoFrame::YV12,
690 false,
691 gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f),
692 15,
693 128,
694 128,
695 pass.get());
696
697 RenderPassList pass_list;
698 pass_list.push_back(pass.Pass());
699
700 // If we didn't get black out of the YUV values above, then we probably have a
701 // color range issue.
702 EXPECT_TRUE(this->RunPixelTest(&pass_list,
703 base::FilePath(FILE_PATH_LITERAL("black.png")),
704 FuzzyPixelOffByOneComparator(true)));
705 }
706
707 TEST_F(VideoGLRendererPixelTest, SimpleYUVJRect) {
708 gfx::Rect rect(this->device_viewport_size_);
709
710 RenderPassId id(1, 1);
711 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect);
712
713 SharedQuadState* shared_state =
714 CreateTestSharedQuadState(gfx::Transform(), rect, pass.get());
715
716 // YUV of (149,43,21) should be green (0,255,0) in RGB.
717 CreateTestYUVVideoDrawQuad_Solid(shared_state,
718 media::VideoFrame::YV12J,
719 false,
720 gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f),
721 149,
722 43,
723 21,
724 pass.get());
725
726 RenderPassList pass_list;
727 pass_list.push_back(pass.Pass());
728
729 EXPECT_TRUE(this->RunPixelTest(&pass_list,
730 base::FilePath(FILE_PATH_LITERAL("green.png")),
731 FuzzyPixelOffByOneComparator(true)));
732 }
733
734 // Test that a YUV video doesn't bleed outside of its tex coords when the
735 // tex coord rect is only a partial subrectangle of the coded contents.
736 TEST_F(VideoGLRendererPixelTest, YUVEdgeBleed) {
737 RenderPassList pass_list;
738 CreateEdgeBleedPass(media::VideoFrame::YV12J, &pass_list);
739 EXPECT_TRUE(this->RunPixelTest(&pass_list,
740 base::FilePath(FILE_PATH_LITERAL("green.png")),
741 FuzzyPixelOffByOneComparator(true)));
742 }
743
744 TEST_F(VideoGLRendererPixelTest, YUVAEdgeBleed) {
745 RenderPassList pass_list;
746 CreateEdgeBleedPass(media::VideoFrame::YV12A, &pass_list);
747 EXPECT_TRUE(this->RunPixelTest(&pass_list,
748 base::FilePath(FILE_PATH_LITERAL("green.png")),
749 FuzzyPixelOffByOneComparator(true)));
750 }
751
752 TEST_F(VideoGLRendererPixelTest, SimpleYUVJRectGrey) {
753 gfx::Rect rect(this->device_viewport_size_);
754
755 RenderPassId id(1, 1);
756 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect);
757
758 SharedQuadState* shared_state =
759 CreateTestSharedQuadState(gfx::Transform(), rect, pass.get());
760
761 // Dark grey in JPEG color range (in MPEG, this is black).
762 CreateTestYUVVideoDrawQuad_Solid(shared_state,
763 media::VideoFrame::YV12J,
764 false,
765 gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f),
766 15,
767 128,
768 128,
769 pass.get());
770
771 RenderPassList pass_list;
772 pass_list.push_back(pass.Pass());
773
774 EXPECT_TRUE(
775 this->RunPixelTest(&pass_list,
776 base::FilePath(FILE_PATH_LITERAL("dark_grey.png")),
777 FuzzyPixelOffByOneComparator(true)));
778 }
779
780 TEST_F(VideoGLRendererPixelTest, SimpleYUVARect) {
781 gfx::Rect rect(this->device_viewport_size_);
782
783 RenderPassId id(1, 1);
784 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect);
785
786 SharedQuadState* shared_state =
787 CreateTestSharedQuadState(gfx::Transform(), rect, pass.get());
788
789 CreateTestYUVVideoDrawQuad_Striped(shared_state,
790 media::VideoFrame::YV12A,
791 false,
792 gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f),
793 pass.get());
794
795 SolidColorDrawQuad* color_quad =
796 pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
797 color_quad->SetNew(shared_state, rect, rect, SK_ColorWHITE, false);
798
799 RenderPassList pass_list;
800 pass_list.push_back(pass.Pass());
801
802 EXPECT_TRUE(this->RunPixelTest(
803 &pass_list,
804 base::FilePath(FILE_PATH_LITERAL("yuv_stripes_alpha.png")),
805 FuzzyPixelOffByOneComparator(true)));
806 }
807
808 TEST_F(VideoGLRendererPixelTest, FullyTransparentYUVARect) {
809 gfx::Rect rect(this->device_viewport_size_);
810
811 RenderPassId id(1, 1);
812 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect);
813
814 SharedQuadState* shared_state =
815 CreateTestSharedQuadState(gfx::Transform(), rect, pass.get());
816
817 CreateTestYUVVideoDrawQuad_Striped(shared_state,
818 media::VideoFrame::YV12A,
819 true,
820 gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f),
821 pass.get());
822
823 SolidColorDrawQuad* color_quad =
824 pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
825 color_quad->SetNew(shared_state, rect, rect, SK_ColorBLACK, false);
826
827 RenderPassList pass_list;
828 pass_list.push_back(pass.Pass());
829
830 EXPECT_TRUE(this->RunPixelTest(
831 &pass_list,
832 base::FilePath(FILE_PATH_LITERAL("black.png")),
833 ExactPixelComparator(true)));
834 }
835
836 TYPED_TEST(RendererPixelTest, FastPassColorFilterAlpha) {
837 gfx::Rect viewport_rect(this->device_viewport_size_);
838
839 RenderPassId root_pass_id(1, 1);
840 scoped_ptr<RenderPass> root_pass =
841 CreateTestRootRenderPass(root_pass_id, viewport_rect);
842
843 RenderPassId child_pass_id(2, 2);
844 gfx::Rect pass_rect(this->device_viewport_size_);
845 gfx::Transform transform_to_root;
846 scoped_ptr<RenderPass> child_pass =
847 CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root);
848
849 gfx::Transform content_to_target_transform;
850 SharedQuadState* shared_state = CreateTestSharedQuadState(
851 content_to_target_transform, viewport_rect, child_pass.get());
852 shared_state->opacity = 0.5f;
853
854 gfx::Rect blue_rect(0,
855 0,
856 this->device_viewport_size_.width(),
857 this->device_viewport_size_.height() / 2);
858 SolidColorDrawQuad* blue =
859 child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
860 blue->SetNew(shared_state, blue_rect, blue_rect, SK_ColorBLUE, false);
861 gfx::Rect yellow_rect(0,
862 this->device_viewport_size_.height() / 2,
863 this->device_viewport_size_.width(),
864 this->device_viewport_size_.height() / 2);
865 SolidColorDrawQuad* yellow =
866 child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
867 yellow->SetNew(shared_state, yellow_rect, yellow_rect, SK_ColorYELLOW, false);
868
869 SharedQuadState* blank_state = CreateTestSharedQuadState(
870 content_to_target_transform, viewport_rect, child_pass.get());
871
872 SolidColorDrawQuad* white =
873 child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
874 white->SetNew(
875 blank_state, viewport_rect, viewport_rect, SK_ColorWHITE, false);
876
877 SharedQuadState* pass_shared_state =
878 CreateTestSharedQuadState(gfx::Transform(), pass_rect, root_pass.get());
879
880 SkScalar matrix[20];
881 float amount = 0.5f;
882 matrix[0] = 0.213f + 0.787f * amount;
883 matrix[1] = 0.715f - 0.715f * amount;
884 matrix[2] = 1.f - (matrix[0] + matrix[1]);
885 matrix[3] = matrix[4] = 0;
886 matrix[5] = 0.213f - 0.213f * amount;
887 matrix[6] = 0.715f + 0.285f * amount;
888 matrix[7] = 1.f - (matrix[5] + matrix[6]);
889 matrix[8] = matrix[9] = 0;
890 matrix[10] = 0.213f - 0.213f * amount;
891 matrix[11] = 0.715f - 0.715f * amount;
892 matrix[12] = 1.f - (matrix[10] + matrix[11]);
893 matrix[13] = matrix[14] = 0;
894 matrix[15] = matrix[16] = matrix[17] = matrix[19] = 0;
895 matrix[18] = 1;
896 skia::RefPtr<SkColorFilter> colorFilter(
897 skia::AdoptRef(SkColorMatrixFilter::Create(matrix)));
898 skia::RefPtr<SkImageFilter> filter =
899 skia::AdoptRef(SkColorFilterImageFilter::Create(colorFilter.get(), NULL));
900 FilterOperations filters;
901 filters.Append(FilterOperation::CreateReferenceFilter(filter));
902
903 RenderPassDrawQuad* render_pass_quad =
904 root_pass->CreateAndAppendDrawQuad<RenderPassDrawQuad>();
905 render_pass_quad->SetNew(pass_shared_state,
906 pass_rect,
907 pass_rect,
908 child_pass_id,
909 0,
910 gfx::Vector2dF(),
911 gfx::Size(),
912 filters,
913 gfx::Vector2dF(),
914 FilterOperations());
915
916 RenderPassList pass_list;
917 pass_list.push_back(child_pass.Pass());
918 pass_list.push_back(root_pass.Pass());
919
920 // This test has alpha=254 for the software renderer vs. alpha=255 for the gl
921 // renderer so use a fuzzy comparator.
922 EXPECT_TRUE(this->RunPixelTest(
923 &pass_list,
924 base::FilePath(FILE_PATH_LITERAL("blue_yellow_alpha.png")),
925 FuzzyForSoftwareOnlyPixelComparator<TypeParam>(false)));
926 }
927
928 TYPED_TEST(RendererPixelTest, FastPassSaturateFilter) {
929 gfx::Rect viewport_rect(this->device_viewport_size_);
930
931 RenderPassId root_pass_id(1, 1);
932 scoped_ptr<RenderPass> root_pass =
933 CreateTestRootRenderPass(root_pass_id, viewport_rect);
934
935 RenderPassId child_pass_id(2, 2);
936 gfx::Rect pass_rect(this->device_viewport_size_);
937 gfx::Transform transform_to_root;
938 scoped_ptr<RenderPass> child_pass =
939 CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root);
940
941 gfx::Transform content_to_target_transform;
942 SharedQuadState* shared_state = CreateTestSharedQuadState(
943 content_to_target_transform, viewport_rect, child_pass.get());
944 shared_state->opacity = 0.5f;
945
946 gfx::Rect blue_rect(0,
947 0,
948 this->device_viewport_size_.width(),
949 this->device_viewport_size_.height() / 2);
950 SolidColorDrawQuad* blue =
951 child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
952 blue->SetNew(shared_state, blue_rect, blue_rect, SK_ColorBLUE, false);
953 gfx::Rect yellow_rect(0,
954 this->device_viewport_size_.height() / 2,
955 this->device_viewport_size_.width(),
956 this->device_viewport_size_.height() / 2);
957 SolidColorDrawQuad* yellow =
958 child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
959 yellow->SetNew(shared_state, yellow_rect, yellow_rect, SK_ColorYELLOW, false);
960
961 SharedQuadState* blank_state = CreateTestSharedQuadState(
962 content_to_target_transform, viewport_rect, child_pass.get());
963
964 SolidColorDrawQuad* white =
965 child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
966 white->SetNew(
967 blank_state, viewport_rect, viewport_rect, SK_ColorWHITE, false);
968
969 SharedQuadState* pass_shared_state =
970 CreateTestSharedQuadState(gfx::Transform(), pass_rect, root_pass.get());
971
972 FilterOperations filters;
973 filters.Append(FilterOperation::CreateSaturateFilter(0.5f));
974
975 RenderPassDrawQuad* render_pass_quad =
976 root_pass->CreateAndAppendDrawQuad<RenderPassDrawQuad>();
977 render_pass_quad->SetNew(pass_shared_state,
978 pass_rect,
979 pass_rect,
980 child_pass_id,
981 0,
982 gfx::Vector2dF(),
983 gfx::Size(),
984 filters,
985 gfx::Vector2dF(),
986 FilterOperations());
987
988 RenderPassList pass_list;
989 pass_list.push_back(child_pass.Pass());
990 pass_list.push_back(root_pass.Pass());
991
992 EXPECT_TRUE(this->RunPixelTest(
993 &pass_list,
994 base::FilePath(FILE_PATH_LITERAL("blue_yellow_alpha.png")),
995 ExactPixelComparator(true)));
996 }
997
998 TYPED_TEST(RendererPixelTest, FastPassFilterChain) {
999 gfx::Rect viewport_rect(this->device_viewport_size_);
1000
1001 RenderPassId root_pass_id(1, 1);
1002 scoped_ptr<RenderPass> root_pass =
1003 CreateTestRootRenderPass(root_pass_id, viewport_rect);
1004
1005 RenderPassId child_pass_id(2, 2);
1006 gfx::Rect pass_rect(this->device_viewport_size_);
1007 gfx::Transform transform_to_root;
1008 scoped_ptr<RenderPass> child_pass =
1009 CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root);
1010
1011 gfx::Transform content_to_target_transform;
1012 SharedQuadState* shared_state = CreateTestSharedQuadState(
1013 content_to_target_transform, viewport_rect, child_pass.get());
1014 shared_state->opacity = 0.5f;
1015
1016 gfx::Rect blue_rect(0,
1017 0,
1018 this->device_viewport_size_.width(),
1019 this->device_viewport_size_.height() / 2);
1020 SolidColorDrawQuad* blue =
1021 child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
1022 blue->SetNew(shared_state, blue_rect, blue_rect, SK_ColorBLUE, false);
1023 gfx::Rect yellow_rect(0,
1024 this->device_viewport_size_.height() / 2,
1025 this->device_viewport_size_.width(),
1026 this->device_viewport_size_.height() / 2);
1027 SolidColorDrawQuad* yellow =
1028 child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
1029 yellow->SetNew(shared_state, yellow_rect, yellow_rect, SK_ColorYELLOW, false);
1030
1031 SharedQuadState* blank_state = CreateTestSharedQuadState(
1032 content_to_target_transform, viewport_rect, child_pass.get());
1033
1034 SolidColorDrawQuad* white =
1035 child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
1036 white->SetNew(
1037 blank_state, viewport_rect, viewport_rect, SK_ColorWHITE, false);
1038
1039 SharedQuadState* pass_shared_state =
1040 CreateTestSharedQuadState(gfx::Transform(), pass_rect, root_pass.get());
1041
1042 FilterOperations filters;
1043 filters.Append(FilterOperation::CreateGrayscaleFilter(1.f));
1044 filters.Append(FilterOperation::CreateBrightnessFilter(0.5f));
1045
1046 RenderPassDrawQuad* render_pass_quad =
1047 root_pass->CreateAndAppendDrawQuad<RenderPassDrawQuad>();
1048 render_pass_quad->SetNew(pass_shared_state,
1049 pass_rect,
1050 pass_rect,
1051 child_pass_id,
1052 0,
1053 gfx::Vector2dF(),
1054 gfx::Size(),
1055 filters,
1056 gfx::Vector2dF(),
1057 FilterOperations());
1058
1059 RenderPassList pass_list;
1060 pass_list.push_back(child_pass.Pass());
1061 pass_list.push_back(root_pass.Pass());
1062
1063 EXPECT_TRUE(this->RunPixelTest(
1064 &pass_list,
1065 base::FilePath(FILE_PATH_LITERAL("blue_yellow_filter_chain.png")),
1066 ExactPixelComparator(true)));
1067 }
1068
1069 TYPED_TEST(RendererPixelTest, FastPassColorFilterAlphaTranslation) {
1070 gfx::Rect viewport_rect(this->device_viewport_size_);
1071
1072 RenderPassId root_pass_id(1, 1);
1073 scoped_ptr<RenderPass> root_pass =
1074 CreateTestRootRenderPass(root_pass_id, viewport_rect);
1075
1076 RenderPassId child_pass_id(2, 2);
1077 gfx::Rect pass_rect(this->device_viewport_size_);
1078 gfx::Transform transform_to_root;
1079 scoped_ptr<RenderPass> child_pass =
1080 CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root);
1081
1082 gfx::Transform content_to_target_transform;
1083 SharedQuadState* shared_state = CreateTestSharedQuadState(
1084 content_to_target_transform, viewport_rect, child_pass.get());
1085 shared_state->opacity = 0.5f;
1086
1087 gfx::Rect blue_rect(0,
1088 0,
1089 this->device_viewport_size_.width(),
1090 this->device_viewport_size_.height() / 2);
1091 SolidColorDrawQuad* blue =
1092 child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
1093 blue->SetNew(shared_state, blue_rect, blue_rect, SK_ColorBLUE, false);
1094 gfx::Rect yellow_rect(0,
1095 this->device_viewport_size_.height() / 2,
1096 this->device_viewport_size_.width(),
1097 this->device_viewport_size_.height() / 2);
1098 SolidColorDrawQuad* yellow =
1099 child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
1100 yellow->SetNew(shared_state, yellow_rect, yellow_rect, SK_ColorYELLOW, false);
1101
1102 SharedQuadState* blank_state = CreateTestSharedQuadState(
1103 content_to_target_transform, viewport_rect, child_pass.get());
1104
1105 SolidColorDrawQuad* white =
1106 child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
1107 white->SetNew(
1108 blank_state, viewport_rect, viewport_rect, SK_ColorWHITE, false);
1109
1110 SharedQuadState* pass_shared_state =
1111 CreateTestSharedQuadState(gfx::Transform(), pass_rect, root_pass.get());
1112
1113 SkScalar matrix[20];
1114 float amount = 0.5f;
1115 matrix[0] = 0.213f + 0.787f * amount;
1116 matrix[1] = 0.715f - 0.715f * amount;
1117 matrix[2] = 1.f - (matrix[0] + matrix[1]);
1118 matrix[3] = 0;
1119 matrix[4] = 20.f;
1120 matrix[5] = 0.213f - 0.213f * amount;
1121 matrix[6] = 0.715f + 0.285f * amount;
1122 matrix[7] = 1.f - (matrix[5] + matrix[6]);
1123 matrix[8] = 0;
1124 matrix[9] = 200.f;
1125 matrix[10] = 0.213f - 0.213f * amount;
1126 matrix[11] = 0.715f - 0.715f * amount;
1127 matrix[12] = 1.f - (matrix[10] + matrix[11]);
1128 matrix[13] = 0;
1129 matrix[14] = 1.5f;
1130 matrix[15] = matrix[16] = matrix[17] = matrix[19] = 0;
1131 matrix[18] = 1;
1132 skia::RefPtr<SkColorFilter> colorFilter(
1133 skia::AdoptRef(SkColorMatrixFilter::Create(matrix)));
1134 skia::RefPtr<SkImageFilter> filter =
1135 skia::AdoptRef(SkColorFilterImageFilter::Create(colorFilter.get(), NULL));
1136 FilterOperations filters;
1137 filters.Append(FilterOperation::CreateReferenceFilter(filter));
1138
1139 RenderPassDrawQuad* render_pass_quad =
1140 root_pass->CreateAndAppendDrawQuad<RenderPassDrawQuad>();
1141 render_pass_quad->SetNew(pass_shared_state,
1142 pass_rect,
1143 pass_rect,
1144 child_pass_id,
1145 0,
1146 gfx::Vector2dF(),
1147 gfx::Size(),
1148 filters,
1149 gfx::Vector2dF(),
1150 FilterOperations());
1151
1152 RenderPassList pass_list;
1153
1154 pass_list.push_back(child_pass.Pass());
1155 pass_list.push_back(root_pass.Pass());
1156
1157 // This test has alpha=254 for the software renderer vs. alpha=255 for the gl
1158 // renderer so use a fuzzy comparator.
1159 EXPECT_TRUE(this->RunPixelTest(
1160 &pass_list,
1161 base::FilePath(FILE_PATH_LITERAL("blue_yellow_alpha_translate.png")),
1162 FuzzyForSoftwareOnlyPixelComparator<TypeParam>(false)));
1163 }
1164
1165 TYPED_TEST(RendererPixelTest, EnlargedRenderPassTexture) {
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
1172 RenderPassId child_pass_id(2, 2);
1173 gfx::Rect pass_rect(this->device_viewport_size_);
1174 gfx::Transform transform_to_root;
1175 scoped_ptr<RenderPass> child_pass =
1176 CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root);
1177
1178 gfx::Transform content_to_target_transform;
1179 SharedQuadState* shared_state = CreateTestSharedQuadState(
1180 content_to_target_transform, viewport_rect, child_pass.get());
1181
1182 gfx::Rect blue_rect(0,
1183 0,
1184 this->device_viewport_size_.width(),
1185 this->device_viewport_size_.height() / 2);
1186 SolidColorDrawQuad* blue =
1187 child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
1188 blue->SetNew(shared_state, blue_rect, blue_rect, SK_ColorBLUE, false);
1189 gfx::Rect yellow_rect(0,
1190 this->device_viewport_size_.height() / 2,
1191 this->device_viewport_size_.width(),
1192 this->device_viewport_size_.height() / 2);
1193 SolidColorDrawQuad* yellow =
1194 child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
1195 yellow->SetNew(shared_state, yellow_rect, yellow_rect, SK_ColorYELLOW, false);
1196
1197 SharedQuadState* pass_shared_state =
1198 CreateTestSharedQuadState(gfx::Transform(), pass_rect, root_pass.get());
1199 CreateTestRenderPassDrawQuad(
1200 pass_shared_state, pass_rect, child_pass_id, root_pass.get());
1201
1202 RenderPassList pass_list;
1203 pass_list.push_back(child_pass.Pass());
1204 pass_list.push_back(root_pass.Pass());
1205
1206 this->renderer_->SetEnlargePassTextureAmountForTesting(gfx::Vector2d(50, 75));
1207
1208 EXPECT_TRUE(this->RunPixelTest(
1209 &pass_list,
1210 base::FilePath(FILE_PATH_LITERAL("blue_yellow.png")),
1211 ExactPixelComparator(true)));
1212 }
1213
1214 TYPED_TEST(RendererPixelTest, EnlargedRenderPassTextureWithAntiAliasing) {
1215 gfx::Rect viewport_rect(this->device_viewport_size_);
1216
1217 RenderPassId root_pass_id(1, 1);
1218 scoped_ptr<RenderPass> root_pass =
1219 CreateTestRootRenderPass(root_pass_id, viewport_rect);
1220
1221 RenderPassId child_pass_id(2, 2);
1222 gfx::Rect pass_rect(this->device_viewport_size_);
1223 gfx::Transform transform_to_root;
1224 scoped_ptr<RenderPass> child_pass =
1225 CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root);
1226
1227 gfx::Transform content_to_target_transform;
1228 SharedQuadState* shared_state = CreateTestSharedQuadState(
1229 content_to_target_transform, viewport_rect, child_pass.get());
1230
1231 gfx::Rect blue_rect(0,
1232 0,
1233 this->device_viewport_size_.width(),
1234 this->device_viewport_size_.height() / 2);
1235 SolidColorDrawQuad* blue =
1236 child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
1237 blue->SetNew(shared_state, blue_rect, blue_rect, SK_ColorBLUE, false);
1238 gfx::Rect yellow_rect(0,
1239 this->device_viewport_size_.height() / 2,
1240 this->device_viewport_size_.width(),
1241 this->device_viewport_size_.height() / 2);
1242 SolidColorDrawQuad* yellow =
1243 child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
1244 yellow->SetNew(shared_state, yellow_rect, yellow_rect, SK_ColorYELLOW, false);
1245
1246 gfx::Transform aa_transform;
1247 aa_transform.Translate(0.5, 0.0);
1248
1249 SharedQuadState* pass_shared_state =
1250 CreateTestSharedQuadState(aa_transform, pass_rect, root_pass.get());
1251 CreateTestRenderPassDrawQuad(
1252 pass_shared_state, pass_rect, child_pass_id, root_pass.get());
1253
1254 SharedQuadState* root_shared_state = CreateTestSharedQuadState(
1255 gfx::Transform(), viewport_rect, root_pass.get());
1256 SolidColorDrawQuad* background =
1257 root_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
1258 background->SetNew(root_shared_state,
1259 gfx::Rect(this->device_viewport_size_),
1260 gfx::Rect(this->device_viewport_size_),
1261 SK_ColorWHITE,
1262 false);
1263
1264 RenderPassList pass_list;
1265 pass_list.push_back(child_pass.Pass());
1266 pass_list.push_back(root_pass.Pass());
1267
1268 this->renderer_->SetEnlargePassTextureAmountForTesting(gfx::Vector2d(50, 75));
1269
1270 EXPECT_TRUE(this->RunPixelTest(
1271 &pass_list,
1272 base::FilePath(FILE_PATH_LITERAL("blue_yellow_anti_aliasing.png")),
1273 FuzzyPixelOffByOneComparator(true)));
1274 }
1275
1276 // This tests the case where we have a RenderPass with a mask, but the quad
1277 // for the masked surface does not include the full surface texture.
1278 TYPED_TEST(RendererPixelTest, RenderPassAndMaskWithPartialQuad) {
1279 gfx::Rect viewport_rect(this->device_viewport_size_);
1280
1281 RenderPassId root_pass_id(1, 1);
1282 scoped_ptr<RenderPass> root_pass =
1283 CreateTestRootRenderPass(root_pass_id, viewport_rect);
1284 SharedQuadState* root_pass_shared_state = CreateTestSharedQuadState(
1285 gfx::Transform(), viewport_rect, root_pass.get());
1286
1287 RenderPassId child_pass_id(2, 2);
1288 gfx::Transform transform_to_root;
1289 scoped_ptr<RenderPass> child_pass =
1290 CreateTestRenderPass(child_pass_id, viewport_rect, transform_to_root);
1291 SharedQuadState* child_pass_shared_state = CreateTestSharedQuadState(
1292 gfx::Transform(), viewport_rect, child_pass.get());
1293
1294 // The child render pass is just a green box.
1295 static const SkColor kCSSGreen = 0xff008000;
1296 SolidColorDrawQuad* green =
1297 child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
1298 green->SetNew(
1299 child_pass_shared_state, viewport_rect, viewport_rect, kCSSGreen, false);
1300
1301 // Make a mask.
1302 gfx::Rect mask_rect = viewport_rect;
1303 SkBitmap bitmap;
1304 bitmap.allocPixels(
1305 SkImageInfo::MakeN32Premul(mask_rect.width(), mask_rect.height()));
1306 SkCanvas canvas(bitmap);
1307 SkPaint paint;
1308 paint.setStyle(SkPaint::kStroke_Style);
1309 paint.setStrokeWidth(SkIntToScalar(4));
1310 paint.setColor(SK_ColorWHITE);
1311 canvas.clear(SK_ColorTRANSPARENT);
1312 gfx::Rect rect = mask_rect;
1313 while (!rect.IsEmpty()) {
1314 rect.Inset(6, 6, 4, 4);
1315 canvas.drawRect(
1316 SkRect::MakeXYWH(rect.x(), rect.y(), rect.width(), rect.height()),
1317 paint);
1318 rect.Inset(6, 6, 4, 4);
1319 }
1320
1321 ResourceProvider::ResourceId mask_resource_id =
1322 this->resource_provider_->CreateResource(
1323 mask_rect.size(),
1324 GL_CLAMP_TO_EDGE,
1325 ResourceProvider::TextureHintImmutable,
1326 RGBA_8888);
1327 {
1328 SkAutoLockPixels lock(bitmap);
1329 this->resource_provider_->SetPixels(
1330 mask_resource_id,
1331 reinterpret_cast<uint8_t*>(bitmap.getPixels()),
1332 mask_rect,
1333 mask_rect,
1334 gfx::Vector2d());
1335 }
1336
1337 // This RenderPassDrawQuad does not include the full |viewport_rect| which is
1338 // the size of the child render pass.
1339 gfx::Rect sub_rect = gfx::Rect(50, 50, 200, 100);
1340 EXPECT_NE(sub_rect.x(), child_pass->output_rect.x());
1341 EXPECT_NE(sub_rect.y(), child_pass->output_rect.y());
1342 EXPECT_NE(sub_rect.right(), child_pass->output_rect.right());
1343 EXPECT_NE(sub_rect.bottom(), child_pass->output_rect.bottom());
1344
1345 // Set up a mask on the RenderPassDrawQuad.
1346 RenderPassDrawQuad* mask_quad =
1347 root_pass->CreateAndAppendDrawQuad<RenderPassDrawQuad>();
1348 mask_quad->SetNew(root_pass_shared_state,
1349 sub_rect,
1350 sub_rect,
1351 child_pass_id,
1352 mask_resource_id,
1353 gfx::Vector2dF(2.f, 1.f), // mask_uv_scale
1354 gfx::Size(mask_rect.size()), // mask_texture_size
1355 FilterOperations(), // foreground filters
1356 gfx::Vector2dF(), // filters scale
1357 FilterOperations()); // background filters
1358
1359 // White background behind the masked render pass.
1360 SolidColorDrawQuad* white =
1361 root_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
1362 white->SetNew(root_pass_shared_state,
1363 viewport_rect,
1364 viewport_rect,
1365 SK_ColorWHITE,
1366 false);
1367
1368 RenderPassList pass_list;
1369 pass_list.push_back(child_pass.Pass());
1370 pass_list.push_back(root_pass.Pass());
1371
1372 EXPECT_TRUE(this->RunPixelTest(
1373 &pass_list,
1374 base::FilePath(FILE_PATH_LITERAL("mask_bottom_right.png")),
1375 ExactPixelComparator(true)));
1376 }
1377
1378 template <typename RendererType>
1379 class RendererPixelTestWithBackgroundFilter
1380 : public RendererPixelTest<RendererType> {
1381 protected:
1382 void SetUpRenderPassList() {
1383 gfx::Rect device_viewport_rect(this->device_viewport_size_);
1384
1385 RenderPassId root_id(1, 1);
1386 scoped_ptr<RenderPass> root_pass =
1387 CreateTestRootRenderPass(root_id, device_viewport_rect);
1388 root_pass->has_transparent_background = false;
1389
1390 gfx::Transform identity_content_to_target_transform;
1391
1392 RenderPassId filter_pass_id(2, 1);
1393 gfx::Transform transform_to_root;
1394 scoped_ptr<RenderPass> filter_pass =
1395 CreateTestRenderPass(filter_pass_id,
1396 filter_pass_content_rect_,
1397 transform_to_root);
1398
1399 // A non-visible quad in the filtering render pass.
1400 {
1401 SharedQuadState* shared_state =
1402 CreateTestSharedQuadState(identity_content_to_target_transform,
1403 filter_pass_content_rect_,
1404 filter_pass.get());
1405 SolidColorDrawQuad* color_quad =
1406 filter_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
1407 color_quad->SetNew(shared_state,
1408 filter_pass_content_rect_,
1409 filter_pass_content_rect_,
1410 SK_ColorTRANSPARENT,
1411 false);
1412 }
1413
1414 {
1415 SharedQuadState* shared_state =
1416 CreateTestSharedQuadState(filter_pass_to_target_transform_,
1417 filter_pass_content_rect_,
1418 filter_pass.get());
1419 RenderPassDrawQuad* filter_pass_quad =
1420 root_pass->CreateAndAppendDrawQuad<RenderPassDrawQuad>();
1421 filter_pass_quad->SetNew(shared_state,
1422 filter_pass_content_rect_,
1423 filter_pass_content_rect_,
1424 filter_pass_id,
1425 0, // mask_resource_id
1426 gfx::Vector2dF(), // mask_uv_scale
1427 gfx::Size(), // mask_texture_size
1428 FilterOperations(), // filters
1429 gfx::Vector2dF(), // filters_scale
1430 this->background_filters_);
1431 }
1432
1433 const int kColumnWidth = device_viewport_rect.width() / 3;
1434
1435 gfx::Rect left_rect = gfx::Rect(0, 0, kColumnWidth, 20);
1436 for (int i = 0; left_rect.y() < device_viewport_rect.height(); ++i) {
1437 SharedQuadState* shared_state = CreateTestSharedQuadState(
1438 identity_content_to_target_transform, left_rect, root_pass.get());
1439 SolidColorDrawQuad* color_quad =
1440 root_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
1441 color_quad->SetNew(
1442 shared_state, left_rect, left_rect, SK_ColorGREEN, false);
1443 left_rect += gfx::Vector2d(0, left_rect.height() + 1);
1444 }
1445
1446 gfx::Rect middle_rect = gfx::Rect(kColumnWidth+1, 0, kColumnWidth, 20);
1447 for (int i = 0; middle_rect.y() < device_viewport_rect.height(); ++i) {
1448 SharedQuadState* shared_state = CreateTestSharedQuadState(
1449 identity_content_to_target_transform, middle_rect, root_pass.get());
1450 SolidColorDrawQuad* color_quad =
1451 root_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
1452 color_quad->SetNew(
1453 shared_state, middle_rect, middle_rect, SK_ColorRED, false);
1454 middle_rect += gfx::Vector2d(0, middle_rect.height() + 1);
1455 }
1456
1457 gfx::Rect right_rect = gfx::Rect((kColumnWidth+1)*2, 0, kColumnWidth, 20);
1458 for (int i = 0; right_rect.y() < device_viewport_rect.height(); ++i) {
1459 SharedQuadState* shared_state = CreateTestSharedQuadState(
1460 identity_content_to_target_transform, right_rect, root_pass.get());
1461 SolidColorDrawQuad* color_quad =
1462 root_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
1463 color_quad->SetNew(
1464 shared_state, right_rect, right_rect, SK_ColorBLUE, false);
1465 right_rect += gfx::Vector2d(0, right_rect.height() + 1);
1466 }
1467
1468 SharedQuadState* shared_state =
1469 CreateTestSharedQuadState(identity_content_to_target_transform,
1470 device_viewport_rect,
1471 root_pass.get());
1472 SolidColorDrawQuad* background_quad =
1473 root_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
1474 background_quad->SetNew(shared_state,
1475 device_viewport_rect,
1476 device_viewport_rect,
1477 SK_ColorWHITE,
1478 false);
1479
1480 pass_list_.push_back(filter_pass.Pass());
1481 pass_list_.push_back(root_pass.Pass());
1482 }
1483
1484 RenderPassList pass_list_;
1485 FilterOperations background_filters_;
1486 gfx::Transform filter_pass_to_target_transform_;
1487 gfx::Rect filter_pass_content_rect_;
1488 };
1489
1490 typedef ::testing::Types<GLRenderer, SoftwareRenderer>
1491 BackgroundFilterRendererTypes;
1492 TYPED_TEST_CASE(RendererPixelTestWithBackgroundFilter,
1493 BackgroundFilterRendererTypes);
1494
1495 typedef RendererPixelTestWithBackgroundFilter<GLRenderer>
1496 GLRendererPixelTestWithBackgroundFilter;
1497
1498 // TODO(skaslev): The software renderer does not support filters yet.
1499 TEST_F(GLRendererPixelTestWithBackgroundFilter, InvertFilter) {
1500 this->background_filters_.Append(
1501 FilterOperation::CreateInvertFilter(1.f));
1502
1503 this->filter_pass_content_rect_ = gfx::Rect(this->device_viewport_size_);
1504 this->filter_pass_content_rect_.Inset(12, 14, 16, 18);
1505
1506 this->SetUpRenderPassList();
1507 EXPECT_TRUE(this->RunPixelTest(
1508 &this->pass_list_,
1509 base::FilePath(FILE_PATH_LITERAL("background_filter.png")),
1510 ExactPixelComparator(true)));
1511 }
1512
1513 class ExternalStencilPixelTest : public GLRendererPixelTest {
1514 protected:
1515 void ClearBackgroundToGreen() {
1516 GLES2Interface* gl = output_surface_->context_provider()->ContextGL();
1517 output_surface_->EnsureBackbuffer();
1518 output_surface_->Reshape(device_viewport_size_, 1);
1519 gl->ClearColor(0.f, 1.f, 0.f, 1.f);
1520 gl->Clear(GL_COLOR_BUFFER_BIT);
1521 }
1522
1523 void PopulateStencilBuffer() {
1524 // Set two quadrants of the stencil buffer to 1.
1525 GLES2Interface* gl = output_surface_->context_provider()->ContextGL();
1526 output_surface_->EnsureBackbuffer();
1527 output_surface_->Reshape(device_viewport_size_, 1);
1528 gl->ClearStencil(0);
1529 gl->Clear(GL_STENCIL_BUFFER_BIT);
1530 gl->Enable(GL_SCISSOR_TEST);
1531 gl->ClearStencil(1);
1532 gl->Scissor(0,
1533 0,
1534 device_viewport_size_.width() / 2,
1535 device_viewport_size_.height() / 2);
1536 gl->Clear(GL_STENCIL_BUFFER_BIT);
1537 gl->Scissor(device_viewport_size_.width() / 2,
1538 device_viewport_size_.height() / 2,
1539 device_viewport_size_.width(),
1540 device_viewport_size_.height());
1541 gl->Clear(GL_STENCIL_BUFFER_BIT);
1542 }
1543 };
1544
1545 TEST_F(ExternalStencilPixelTest, StencilTestEnabled) {
1546 ClearBackgroundToGreen();
1547 PopulateStencilBuffer();
1548 this->EnableExternalStencilTest();
1549
1550 // Draw a blue quad that covers the entire device viewport. It should be
1551 // clipped to the bottom left and top right corners by the external stencil.
1552 gfx::Rect rect(this->device_viewport_size_);
1553 RenderPassId id(1, 1);
1554 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect);
1555 SharedQuadState* blue_shared_state =
1556 CreateTestSharedQuadState(gfx::Transform(), rect, pass.get());
1557 SolidColorDrawQuad* blue =
1558 pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
1559 blue->SetNew(blue_shared_state, rect, rect, SK_ColorBLUE, false);
1560 pass->has_transparent_background = false;
1561 RenderPassList pass_list;
1562 pass_list.push_back(pass.Pass());
1563
1564 EXPECT_TRUE(this->RunPixelTest(
1565 &pass_list,
1566 base::FilePath(FILE_PATH_LITERAL("four_blue_green_checkers.png")),
1567 ExactPixelComparator(true)));
1568 }
1569
1570 TEST_F(ExternalStencilPixelTest, StencilTestDisabled) {
1571 PopulateStencilBuffer();
1572
1573 // Draw a green quad that covers the entire device viewport. The stencil
1574 // buffer should be ignored.
1575 gfx::Rect rect(this->device_viewport_size_);
1576 RenderPassId id(1, 1);
1577 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect);
1578 SharedQuadState* green_shared_state =
1579 CreateTestSharedQuadState(gfx::Transform(), rect, pass.get());
1580 SolidColorDrawQuad* green =
1581 pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
1582 green->SetNew(green_shared_state, rect, rect, SK_ColorGREEN, false);
1583 RenderPassList pass_list;
1584 pass_list.push_back(pass.Pass());
1585
1586 EXPECT_TRUE(this->RunPixelTest(
1587 &pass_list,
1588 base::FilePath(FILE_PATH_LITERAL("green.png")),
1589 ExactPixelComparator(true)));
1590 }
1591
1592 TEST_F(ExternalStencilPixelTest, RenderSurfacesIgnoreStencil) {
1593 // The stencil test should apply only to the final render pass.
1594 ClearBackgroundToGreen();
1595 PopulateStencilBuffer();
1596 this->EnableExternalStencilTest();
1597
1598 gfx::Rect viewport_rect(this->device_viewport_size_);
1599
1600 RenderPassId root_pass_id(1, 1);
1601 scoped_ptr<RenderPass> root_pass =
1602 CreateTestRootRenderPass(root_pass_id, viewport_rect);
1603 root_pass->has_transparent_background = false;
1604
1605 RenderPassId child_pass_id(2, 2);
1606 gfx::Rect pass_rect(this->device_viewport_size_);
1607 gfx::Transform transform_to_root;
1608 scoped_ptr<RenderPass> child_pass =
1609 CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root);
1610
1611 gfx::Transform content_to_target_transform;
1612 SharedQuadState* shared_state = CreateTestSharedQuadState(
1613 content_to_target_transform, viewport_rect, child_pass.get());
1614
1615 gfx::Rect blue_rect(0,
1616 0,
1617 this->device_viewport_size_.width(),
1618 this->device_viewport_size_.height());
1619 SolidColorDrawQuad* blue =
1620 child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
1621 blue->SetNew(shared_state, blue_rect, blue_rect, SK_ColorBLUE, false);
1622
1623 SharedQuadState* pass_shared_state =
1624 CreateTestSharedQuadState(gfx::Transform(), pass_rect, root_pass.get());
1625 CreateTestRenderPassDrawQuad(
1626 pass_shared_state, pass_rect, child_pass_id, root_pass.get());
1627 RenderPassList pass_list;
1628 pass_list.push_back(child_pass.Pass());
1629 pass_list.push_back(root_pass.Pass());
1630
1631 EXPECT_TRUE(this->RunPixelTest(
1632 &pass_list,
1633 base::FilePath(FILE_PATH_LITERAL("four_blue_green_checkers.png")),
1634 ExactPixelComparator(true)));
1635 }
1636
1637 TEST_F(ExternalStencilPixelTest, DeviceClip) {
1638 ClearBackgroundToGreen();
1639 gfx::Rect clip_rect(gfx::Point(150, 150), gfx::Size(50, 50));
1640 this->ForceDeviceClip(clip_rect);
1641
1642 // Draw a blue quad that covers the entire device viewport. It should be
1643 // clipped to the bottom right corner by the device clip.
1644 gfx::Rect rect(this->device_viewport_size_);
1645 RenderPassId id(1, 1);
1646 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect);
1647 SharedQuadState* blue_shared_state =
1648 CreateTestSharedQuadState(gfx::Transform(), rect, pass.get());
1649 SolidColorDrawQuad* blue =
1650 pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
1651 blue->SetNew(blue_shared_state, rect, rect, SK_ColorBLUE, false);
1652 RenderPassList pass_list;
1653 pass_list.push_back(pass.Pass());
1654
1655 EXPECT_TRUE(this->RunPixelTest(
1656 &pass_list,
1657 base::FilePath(FILE_PATH_LITERAL("green_with_blue_corner.png")),
1658 ExactPixelComparator(true)));
1659 }
1660
1661 // Software renderer does not support anti-aliased edges.
1662 TEST_F(GLRendererPixelTest, AntiAliasing) {
1663 gfx::Rect rect(this->device_viewport_size_);
1664
1665 RenderPassId id(1, 1);
1666 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect);
1667
1668 gfx::Transform red_content_to_target_transform;
1669 red_content_to_target_transform.Rotate(10);
1670 SharedQuadState* red_shared_state = CreateTestSharedQuadState(
1671 red_content_to_target_transform, rect, pass.get());
1672
1673 SolidColorDrawQuad* red = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
1674 red->SetNew(red_shared_state, rect, rect, SK_ColorRED, false);
1675
1676 gfx::Transform yellow_content_to_target_transform;
1677 yellow_content_to_target_transform.Rotate(5);
1678 SharedQuadState* yellow_shared_state = CreateTestSharedQuadState(
1679 yellow_content_to_target_transform, rect, pass.get());
1680
1681 SolidColorDrawQuad* yellow =
1682 pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
1683 yellow->SetNew(yellow_shared_state, rect, rect, SK_ColorYELLOW, false);
1684
1685 gfx::Transform blue_content_to_target_transform;
1686 SharedQuadState* blue_shared_state = CreateTestSharedQuadState(
1687 blue_content_to_target_transform, rect, pass.get());
1688
1689 SolidColorDrawQuad* blue =
1690 pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
1691 blue->SetNew(blue_shared_state, rect, rect, SK_ColorBLUE, false);
1692
1693 RenderPassList pass_list;
1694 pass_list.push_back(pass.Pass());
1695
1696 EXPECT_TRUE(this->RunPixelTest(
1697 &pass_list,
1698 base::FilePath(FILE_PATH_LITERAL("anti_aliasing.png")),
1699 FuzzyPixelOffByOneComparator(true)));
1700 }
1701
1702 // This test tests that anti-aliasing works for axis aligned quads.
1703 // Anti-aliasing is only supported in the gl renderer.
1704 TEST_F(GLRendererPixelTest, AxisAligned) {
1705 gfx::Rect rect(this->device_viewport_size_);
1706
1707 RenderPassId id(1, 1);
1708 gfx::Transform transform_to_root;
1709 scoped_ptr<RenderPass> pass =
1710 CreateTestRenderPass(id, rect, transform_to_root);
1711
1712 gfx::Transform red_content_to_target_transform;
1713 red_content_to_target_transform.Translate(50, 50);
1714 red_content_to_target_transform.Scale(
1715 0.5f + 1.0f / (rect.width() * 2.0f),
1716 0.5f + 1.0f / (rect.height() * 2.0f));
1717 SharedQuadState* red_shared_state = CreateTestSharedQuadState(
1718 red_content_to_target_transform, rect, pass.get());
1719
1720 SolidColorDrawQuad* red = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
1721 red->SetNew(red_shared_state, rect, rect, SK_ColorRED, false);
1722
1723 gfx::Transform yellow_content_to_target_transform;
1724 yellow_content_to_target_transform.Translate(25.5f, 25.5f);
1725 yellow_content_to_target_transform.Scale(0.5f, 0.5f);
1726 SharedQuadState* yellow_shared_state = CreateTestSharedQuadState(
1727 yellow_content_to_target_transform, rect, pass.get());
1728
1729 SolidColorDrawQuad* yellow =
1730 pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
1731 yellow->SetNew(yellow_shared_state, rect, rect, SK_ColorYELLOW, false);
1732
1733 gfx::Transform blue_content_to_target_transform;
1734 SharedQuadState* blue_shared_state = CreateTestSharedQuadState(
1735 blue_content_to_target_transform, rect, pass.get());
1736
1737 SolidColorDrawQuad* blue =
1738 pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
1739 blue->SetNew(blue_shared_state, rect, rect, SK_ColorBLUE, false);
1740
1741 RenderPassList pass_list;
1742 pass_list.push_back(pass.Pass());
1743
1744 EXPECT_TRUE(this->RunPixelTest(
1745 &pass_list,
1746 base::FilePath(FILE_PATH_LITERAL("axis_aligned.png")),
1747 ExactPixelComparator(true)));
1748 }
1749
1750 // This test tests that forcing anti-aliasing off works as expected.
1751 // Anti-aliasing is only supported in the gl renderer.
1752 TEST_F(GLRendererPixelTest, ForceAntiAliasingOff) {
1753 gfx::Rect rect(this->device_viewport_size_);
1754
1755 RenderPassId id(1, 1);
1756 gfx::Transform transform_to_root;
1757 scoped_ptr<RenderPass> pass =
1758 CreateTestRenderPass(id, rect, transform_to_root);
1759
1760 gfx::Transform hole_content_to_target_transform;
1761 hole_content_to_target_transform.Translate(50, 50);
1762 hole_content_to_target_transform.Scale(
1763 0.5f + 1.0f / (rect.width() * 2.0f),
1764 0.5f + 1.0f / (rect.height() * 2.0f));
1765 SharedQuadState* hole_shared_state = CreateTestSharedQuadState(
1766 hole_content_to_target_transform, rect, pass.get());
1767
1768 SolidColorDrawQuad* hole =
1769 pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
1770 hole->SetAll(
1771 hole_shared_state, rect, rect, rect, false, SK_ColorTRANSPARENT, true);
1772
1773 gfx::Transform green_content_to_target_transform;
1774 SharedQuadState* green_shared_state = CreateTestSharedQuadState(
1775 green_content_to_target_transform, rect, pass.get());
1776
1777 SolidColorDrawQuad* green =
1778 pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
1779 green->SetNew(green_shared_state, rect, rect, SK_ColorGREEN, false);
1780
1781 RenderPassList pass_list;
1782 pass_list.push_back(pass.Pass());
1783
1784 EXPECT_TRUE(this->RunPixelTest(
1785 &pass_list,
1786 base::FilePath(FILE_PATH_LITERAL("force_anti_aliasing_off.png")),
1787 ExactPixelComparator(false)));
1788 }
1789
1790 TEST_F(GLRendererPixelTest, AntiAliasingPerspective) {
1791 gfx::Rect rect(this->device_viewport_size_);
1792
1793 scoped_ptr<RenderPass> pass =
1794 CreateTestRootRenderPass(RenderPassId(1, 1), rect);
1795
1796 gfx::Rect red_rect(0, 0, 180, 500);
1797 gfx::Transform red_content_to_target_transform(
1798 1.0f, 2.4520f, 10.6206f, 19.0f,
1799 0.0f, 0.3528f, 5.9737f, 9.5f,
1800 0.0f, -0.2250f, -0.9744f, 0.0f,
1801 0.0f, 0.0225f, 0.0974f, 1.0f);
1802 SharedQuadState* red_shared_state = CreateTestSharedQuadState(
1803 red_content_to_target_transform, red_rect, pass.get());
1804 SolidColorDrawQuad* red = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
1805 red->SetNew(red_shared_state, red_rect, red_rect, SK_ColorRED, false);
1806
1807 gfx::Rect green_rect(19, 7, 180, 10);
1808 SharedQuadState* green_shared_state =
1809 CreateTestSharedQuadState(gfx::Transform(), green_rect, pass.get());
1810 SolidColorDrawQuad* green =
1811 pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
1812 green->SetNew(
1813 green_shared_state, green_rect, green_rect, SK_ColorGREEN, false);
1814
1815 SharedQuadState* blue_shared_state =
1816 CreateTestSharedQuadState(gfx::Transform(), rect, pass.get());
1817 SolidColorDrawQuad* blue =
1818 pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
1819 blue->SetNew(blue_shared_state, rect, rect, SK_ColorBLUE, false);
1820
1821 RenderPassList pass_list;
1822 pass_list.push_back(pass.Pass());
1823
1824 EXPECT_TRUE(this->RunPixelTest(
1825 &pass_list,
1826 base::FilePath(FILE_PATH_LITERAL("anti_aliasing_perspective.png")),
1827 FuzzyPixelOffByOneComparator(true)));
1828 }
1829
1830 TYPED_TEST(RendererPixelTest, PictureDrawQuadIdentityScale) {
1831 gfx::Size pile_tile_size(1000, 1000);
1832 gfx::Rect viewport(this->device_viewport_size_);
1833 // TODO(enne): the renderer should figure this out on its own.
1834 ResourceFormat texture_format = RGBA_8888;
1835 bool nearest_neighbor = false;
1836
1837 RenderPassId id(1, 1);
1838 gfx::Transform transform_to_root;
1839 scoped_ptr<RenderPass> pass =
1840 CreateTestRenderPass(id, viewport, transform_to_root);
1841
1842 // One clipped blue quad in the lower right corner. Outside the clip
1843 // is red, which should not appear.
1844 gfx::Rect blue_rect(gfx::Size(100, 100));
1845 gfx::Rect blue_clip_rect(gfx::Point(50, 50), gfx::Size(50, 50));
1846 scoped_refptr<FakePicturePileImpl> blue_pile =
1847 FakePicturePileImpl::CreateFilledPile(pile_tile_size, blue_rect.size());
1848 SkPaint red_paint;
1849 red_paint.setColor(SK_ColorRED);
1850 blue_pile->add_draw_rect_with_paint(blue_rect, red_paint);
1851 SkPaint blue_paint;
1852 blue_paint.setColor(SK_ColorBLUE);
1853 blue_pile->add_draw_rect_with_paint(blue_clip_rect, blue_paint);
1854 blue_pile->RerecordPile();
1855
1856 gfx::Transform blue_content_to_target_transform;
1857 gfx::Vector2d offset(viewport.bottom_right() - blue_rect.bottom_right());
1858 blue_content_to_target_transform.Translate(offset.x(), offset.y());
1859 gfx::RectF blue_scissor_rect = blue_clip_rect;
1860 blue_content_to_target_transform.TransformRect(&blue_scissor_rect);
1861 SharedQuadState* blue_shared_state =
1862 CreateTestSharedQuadStateClipped(blue_content_to_target_transform,
1863 blue_rect,
1864 gfx::ToEnclosingRect(blue_scissor_rect),
1865 pass.get());
1866
1867 PictureDrawQuad* blue_quad = pass->CreateAndAppendDrawQuad<PictureDrawQuad>();
1868
1869 blue_quad->SetNew(blue_shared_state,
1870 viewport, // Intentionally bigger than clip.
1871 gfx::Rect(), viewport, gfx::RectF(viewport),
1872 viewport.size(), nearest_neighbor, texture_format, viewport,
1873 1.f, blue_pile.get());
1874
1875 // One viewport-filling green quad.
1876 scoped_refptr<FakePicturePileImpl> green_pile =
1877 FakePicturePileImpl::CreateFilledPile(pile_tile_size, viewport.size());
1878 SkPaint green_paint;
1879 green_paint.setColor(SK_ColorGREEN);
1880 green_pile->add_draw_rect_with_paint(viewport, green_paint);
1881 green_pile->RerecordPile();
1882
1883 gfx::Transform green_content_to_target_transform;
1884 SharedQuadState* green_shared_state = CreateTestSharedQuadState(
1885 green_content_to_target_transform, viewport, pass.get());
1886
1887 PictureDrawQuad* green_quad =
1888 pass->CreateAndAppendDrawQuad<PictureDrawQuad>();
1889 green_quad->SetNew(green_shared_state, viewport, gfx::Rect(), viewport,
1890 gfx::RectF(0.f, 0.f, 1.f, 1.f), viewport.size(),
1891 nearest_neighbor, texture_format, viewport, 1.f,
1892 green_pile.get());
1893
1894 RenderPassList pass_list;
1895 pass_list.push_back(pass.Pass());
1896
1897 EXPECT_TRUE(this->RunPixelTest(
1898 &pass_list,
1899 base::FilePath(FILE_PATH_LITERAL("green_with_blue_corner.png")),
1900 ExactPixelComparator(true)));
1901 }
1902
1903 // Not WithSkiaGPUBackend since that path currently requires tiles for opacity.
1904 TYPED_TEST(RendererPixelTest, PictureDrawQuadOpacity) {
1905 gfx::Size pile_tile_size(1000, 1000);
1906 gfx::Rect viewport(this->device_viewport_size_);
1907 ResourceFormat texture_format = RGBA_8888;
1908 bool nearest_neighbor = false;
1909
1910 RenderPassId id(1, 1);
1911 gfx::Transform transform_to_root;
1912 scoped_ptr<RenderPass> pass =
1913 CreateTestRenderPass(id, viewport, transform_to_root);
1914
1915 // One viewport-filling 0.5-opacity green quad.
1916 scoped_refptr<FakePicturePileImpl> green_pile =
1917 FakePicturePileImpl::CreateFilledPile(pile_tile_size, viewport.size());
1918 SkPaint green_paint;
1919 green_paint.setColor(SK_ColorGREEN);
1920 green_pile->add_draw_rect_with_paint(viewport, green_paint);
1921 green_pile->RerecordPile();
1922
1923 gfx::Transform green_content_to_target_transform;
1924 SharedQuadState* green_shared_state = CreateTestSharedQuadState(
1925 green_content_to_target_transform, viewport, pass.get());
1926 green_shared_state->opacity = 0.5f;
1927
1928 PictureDrawQuad* green_quad =
1929 pass->CreateAndAppendDrawQuad<PictureDrawQuad>();
1930 green_quad->SetNew(green_shared_state, viewport, gfx::Rect(), viewport,
1931 gfx::RectF(0, 0, 1, 1), viewport.size(), nearest_neighbor,
1932 texture_format, viewport, 1.f, green_pile.get());
1933
1934 // One viewport-filling white quad.
1935 scoped_refptr<FakePicturePileImpl> white_pile =
1936 FakePicturePileImpl::CreateFilledPile(pile_tile_size, viewport.size());
1937 SkPaint white_paint;
1938 white_paint.setColor(SK_ColorWHITE);
1939 white_pile->add_draw_rect_with_paint(viewport, white_paint);
1940 white_pile->RerecordPile();
1941
1942 gfx::Transform white_content_to_target_transform;
1943 SharedQuadState* white_shared_state = CreateTestSharedQuadState(
1944 white_content_to_target_transform, viewport, pass.get());
1945
1946 PictureDrawQuad* white_quad =
1947 pass->CreateAndAppendDrawQuad<PictureDrawQuad>();
1948 white_quad->SetNew(white_shared_state, viewport, gfx::Rect(), viewport,
1949 gfx::RectF(0, 0, 1, 1), viewport.size(), nearest_neighbor,
1950 texture_format, viewport, 1.f, white_pile.get());
1951
1952 RenderPassList pass_list;
1953 pass_list.push_back(pass.Pass());
1954
1955 EXPECT_TRUE(this->RunPixelTest(
1956 &pass_list,
1957 base::FilePath(FILE_PATH_LITERAL("green_alpha.png")),
1958 FuzzyPixelOffByOneComparator(true)));
1959 }
1960
1961 template<typename TypeParam> bool IsSoftwareRenderer() {
1962 return false;
1963 }
1964
1965 template<>
1966 bool IsSoftwareRenderer<SoftwareRenderer>() {
1967 return true;
1968 }
1969
1970 template<>
1971 bool IsSoftwareRenderer<SoftwareRendererWithExpandedViewport>() {
1972 return true;
1973 }
1974
1975 // If we disable image filtering, then a 2x2 bitmap should appear as four
1976 // huge sharp squares.
1977 TYPED_TEST(RendererPixelTest, PictureDrawQuadDisableImageFiltering) {
1978 // We only care about this in software mode since bilinear filtering is
1979 // cheap in hardware.
1980 if (!IsSoftwareRenderer<TypeParam>())
1981 return;
1982
1983 gfx::Size pile_tile_size(1000, 1000);
1984 gfx::Rect viewport(this->device_viewport_size_);
1985 ResourceFormat texture_format = RGBA_8888;
1986 bool nearest_neighbor = false;
1987
1988 RenderPassId id(1, 1);
1989 gfx::Transform transform_to_root;
1990 scoped_ptr<RenderPass> pass =
1991 CreateTestRenderPass(id, viewport, transform_to_root);
1992
1993 SkBitmap bitmap;
1994 bitmap.allocN32Pixels(2, 2);
1995 {
1996 SkAutoLockPixels lock(bitmap);
1997 SkCanvas canvas(bitmap);
1998 canvas.drawPoint(0, 0, SK_ColorGREEN);
1999 canvas.drawPoint(0, 1, SK_ColorBLUE);
2000 canvas.drawPoint(1, 0, SK_ColorBLUE);
2001 canvas.drawPoint(1, 1, SK_ColorGREEN);
2002 }
2003
2004 scoped_refptr<FakePicturePileImpl> pile =
2005 FakePicturePileImpl::CreateFilledPile(pile_tile_size, viewport.size());
2006 SkPaint paint;
2007 paint.setFilterLevel(SkPaint::kLow_FilterLevel);
2008 pile->add_draw_bitmap_with_paint(bitmap, gfx::Point(), paint);
2009 pile->RerecordPile();
2010
2011 gfx::Transform content_to_target_transform;
2012 SharedQuadState* shared_state = CreateTestSharedQuadState(
2013 content_to_target_transform, viewport, pass.get());
2014
2015 PictureDrawQuad* quad = pass->CreateAndAppendDrawQuad<PictureDrawQuad>();
2016 quad->SetNew(shared_state, viewport, gfx::Rect(), viewport,
2017 gfx::RectF(0, 0, 2, 2), viewport.size(), nearest_neighbor,
2018 texture_format, viewport, 1.f, pile.get());
2019
2020 RenderPassList pass_list;
2021 pass_list.push_back(pass.Pass());
2022
2023 this->disable_picture_quad_image_filtering_ = true;
2024
2025 EXPECT_TRUE(this->RunPixelTest(
2026 &pass_list,
2027 base::FilePath(FILE_PATH_LITERAL("four_blue_green_checkers.png")),
2028 ExactPixelComparator(true)));
2029 }
2030
2031 // This disables filtering by setting |nearest_neighbor| on the PictureDrawQuad.
2032 TYPED_TEST(RendererPixelTest, PictureDrawQuadNearestNeighbor) {
2033 gfx::Size pile_tile_size(1000, 1000);
2034 gfx::Rect viewport(this->device_viewport_size_);
2035 ResourceFormat texture_format = RGBA_8888;
2036 bool nearest_neighbor = true;
2037
2038 RenderPassId id(1, 1);
2039 gfx::Transform transform_to_root;
2040 scoped_ptr<RenderPass> pass =
2041 CreateTestRenderPass(id, viewport, transform_to_root);
2042
2043 SkBitmap bitmap;
2044 bitmap.allocN32Pixels(2, 2);
2045 {
2046 SkAutoLockPixels lock(bitmap);
2047 SkCanvas canvas(bitmap);
2048 canvas.drawPoint(0, 0, SK_ColorGREEN);
2049 canvas.drawPoint(0, 1, SK_ColorBLUE);
2050 canvas.drawPoint(1, 0, SK_ColorBLUE);
2051 canvas.drawPoint(1, 1, SK_ColorGREEN);
2052 }
2053
2054 scoped_refptr<FakePicturePileImpl> pile =
2055 FakePicturePileImpl::CreateFilledPile(pile_tile_size, viewport.size());
2056 SkPaint paint;
2057 paint.setFilterLevel(SkPaint::kLow_FilterLevel);
2058 pile->add_draw_bitmap_with_paint(bitmap, gfx::Point(), paint);
2059 pile->RerecordPile();
2060
2061 gfx::Transform content_to_target_transform;
2062 SharedQuadState* shared_state = CreateTestSharedQuadState(
2063 content_to_target_transform, viewport, pass.get());
2064
2065 PictureDrawQuad* quad = pass->CreateAndAppendDrawQuad<PictureDrawQuad>();
2066 quad->SetNew(shared_state, viewport, gfx::Rect(), viewport,
2067 gfx::RectF(0, 0, 2, 2), viewport.size(), nearest_neighbor,
2068 texture_format, viewport, 1.f, pile.get());
2069
2070 RenderPassList pass_list;
2071 pass_list.push_back(pass.Pass());
2072
2073 EXPECT_TRUE(this->RunPixelTest(
2074 &pass_list,
2075 base::FilePath(FILE_PATH_LITERAL("four_blue_green_checkers.png")),
2076 ExactPixelComparator(true)));
2077 }
2078
2079 // This disables filtering by setting |nearest_neighbor| on the TileDrawQuad.
2080 TYPED_TEST(RendererPixelTest, TileDrawQuadNearestNeighbor) {
2081 gfx::Rect viewport(this->device_viewport_size_);
2082 bool swizzle_contents = true;
2083 bool nearest_neighbor = true;
2084
2085 SkBitmap bitmap;
2086 bitmap.allocN32Pixels(2, 2);
2087 {
2088 SkAutoLockPixels lock(bitmap);
2089 SkCanvas canvas(bitmap);
2090 canvas.drawPoint(0, 0, SK_ColorGREEN);
2091 canvas.drawPoint(0, 1, SK_ColorBLUE);
2092 canvas.drawPoint(1, 0, SK_ColorBLUE);
2093 canvas.drawPoint(1, 1, SK_ColorGREEN);
2094 }
2095
2096 gfx::Size tile_size(2, 2);
2097 ResourceProvider::ResourceId resource =
2098 this->resource_provider_->CreateResource(
2099 tile_size,
2100 GL_CLAMP_TO_EDGE,
2101 ResourceProvider::TextureHintImmutable,
2102 RGBA_8888);
2103
2104 {
2105 SkAutoLockPixels lock(bitmap);
2106 this->resource_provider_->SetPixels(
2107 resource,
2108 static_cast<uint8_t*>(bitmap.getPixels()),
2109 gfx::Rect(tile_size),
2110 gfx::Rect(tile_size),
2111 gfx::Vector2d());
2112 }
2113
2114 RenderPassId id(1, 1);
2115 gfx::Transform transform_to_root;
2116 scoped_ptr<RenderPass> pass =
2117 CreateTestRenderPass(id, viewport, transform_to_root);
2118
2119 gfx::Transform content_to_target_transform;
2120 SharedQuadState* shared_state = CreateTestSharedQuadState(
2121 content_to_target_transform, viewport, pass.get());
2122
2123 TileDrawQuad* quad = pass->CreateAndAppendDrawQuad<TileDrawQuad>();
2124 quad->SetNew(shared_state, viewport, gfx::Rect(), viewport, resource,
2125 gfx::Rect(tile_size), tile_size, swizzle_contents,
2126 nearest_neighbor);
2127
2128 RenderPassList pass_list;
2129 pass_list.push_back(pass.Pass());
2130
2131 EXPECT_TRUE(this->RunPixelTest(
2132 &pass_list,
2133 base::FilePath(FILE_PATH_LITERAL("four_blue_green_checkers.png")),
2134 ExactPixelComparator(true)));
2135 }
2136
2137 TYPED_TEST(RendererPixelTest, PictureDrawQuadNonIdentityScale) {
2138 gfx::Size pile_tile_size(1000, 1000);
2139 gfx::Rect viewport(this->device_viewport_size_);
2140 // TODO(enne): the renderer should figure this out on its own.
2141 ResourceFormat texture_format = RGBA_8888;
2142 bool nearest_neighbor = false;
2143
2144 RenderPassId id(1, 1);
2145 gfx::Transform transform_to_root;
2146 scoped_ptr<RenderPass> pass =
2147 CreateTestRenderPass(id, viewport, transform_to_root);
2148
2149 // As scaling up the blue checkerboards will cause sampling on the GPU,
2150 // a few extra "cleanup rects" need to be added to clobber the blending
2151 // to make the output image more clean. This will also test subrects
2152 // of the layer.
2153 gfx::Transform green_content_to_target_transform;
2154 gfx::Rect green_rect1(gfx::Point(80, 0), gfx::Size(20, 100));
2155 gfx::Rect green_rect2(gfx::Point(0, 80), gfx::Size(100, 20));
2156 scoped_refptr<FakePicturePileImpl> green_pile =
2157 FakePicturePileImpl::CreateFilledPile(pile_tile_size, viewport.size());
2158 SkPaint red_paint;
2159 red_paint.setColor(SK_ColorRED);
2160 green_pile->add_draw_rect_with_paint(viewport, red_paint);
2161 SkPaint green_paint;
2162 green_paint.setColor(SK_ColorGREEN);
2163 green_pile->add_draw_rect_with_paint(green_rect1, green_paint);
2164 green_pile->add_draw_rect_with_paint(green_rect2, green_paint);
2165 green_pile->RerecordPile();
2166
2167 SharedQuadState* top_right_green_shared_quad_state =
2168 CreateTestSharedQuadState(
2169 green_content_to_target_transform, viewport, pass.get());
2170
2171 PictureDrawQuad* green_quad1 =
2172 pass->CreateAndAppendDrawQuad<PictureDrawQuad>();
2173 green_quad1->SetNew(top_right_green_shared_quad_state, green_rect1,
2174 gfx::Rect(), green_rect1, gfx::RectF(green_rect1.size()),
2175 green_rect1.size(), nearest_neighbor, texture_format,
2176 green_rect1, 1.f, green_pile.get());
2177
2178 PictureDrawQuad* green_quad2 =
2179 pass->CreateAndAppendDrawQuad<PictureDrawQuad>();
2180 green_quad2->SetNew(top_right_green_shared_quad_state, green_rect2,
2181 gfx::Rect(), green_rect2, gfx::RectF(green_rect2.size()),
2182 green_rect2.size(), nearest_neighbor, texture_format,
2183 green_rect2, 1.f, green_pile.get());
2184
2185 // Add a green clipped checkerboard in the bottom right to help test
2186 // interleaving picture quad content and solid color content.
2187 gfx::Rect bottom_right_rect(
2188 gfx::Point(viewport.width() / 2, viewport.height() / 2),
2189 gfx::Size(viewport.width() / 2, viewport.height() / 2));
2190 SharedQuadState* bottom_right_green_shared_state =
2191 CreateTestSharedQuadStateClipped(green_content_to_target_transform,
2192 viewport,
2193 bottom_right_rect,
2194 pass.get());
2195 SolidColorDrawQuad* bottom_right_color_quad =
2196 pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
2197 bottom_right_color_quad->SetNew(bottom_right_green_shared_state,
2198 viewport,
2199 viewport,
2200 SK_ColorGREEN,
2201 false);
2202
2203 // Add two blue checkerboards taking up the bottom left and top right,
2204 // but use content scales as content rects to make this happen.
2205 // The content is at a 4x content scale.
2206 gfx::Rect layer_rect(gfx::Size(20, 30));
2207 float contents_scale = 4.f;
2208 // Two rects that touch at their corners, arbitrarily placed in the layer.
2209 gfx::RectF blue_layer_rect1(gfx::PointF(5.5f, 9.0f), gfx::SizeF(2.5f, 2.5f));
2210 gfx::RectF blue_layer_rect2(gfx::PointF(8.0f, 6.5f), gfx::SizeF(2.5f, 2.5f));
2211 gfx::RectF union_layer_rect = blue_layer_rect1;
2212 union_layer_rect.Union(blue_layer_rect2);
2213
2214 // Because scaling up will cause sampling outside the rects, add one extra
2215 // pixel of buffer at the final content scale.
2216 float inset = -1.f / contents_scale;
2217 blue_layer_rect1.Inset(inset, inset, inset, inset);
2218 blue_layer_rect2.Inset(inset, inset, inset, inset);
2219
2220 scoped_refptr<FakePicturePileImpl> pile =
2221 FakePicturePileImpl::CreateFilledPile(pile_tile_size, layer_rect.size());
2222
2223 Region outside(layer_rect);
2224 outside.Subtract(gfx::ToEnclosingRect(union_layer_rect));
2225 for (Region::Iterator iter(outside); iter.has_rect(); iter.next()) {
2226 pile->add_draw_rect_with_paint(iter.rect(), red_paint);
2227 }
2228
2229 SkPaint blue_paint;
2230 blue_paint.setColor(SK_ColorBLUE);
2231 pile->add_draw_rect_with_paint(blue_layer_rect1, blue_paint);
2232 pile->add_draw_rect_with_paint(blue_layer_rect2, blue_paint);
2233 pile->RerecordPile();
2234
2235 gfx::Rect content_rect(
2236 gfx::ScaleToEnclosingRect(layer_rect, contents_scale));
2237 gfx::Rect content_union_rect(
2238 gfx::ToEnclosingRect(gfx::ScaleRect(union_layer_rect, contents_scale)));
2239
2240 // At a scale of 4x the rectangles with a width of 2.5 will take up 10 pixels,
2241 // so scale an additional 10x to make them 100x100.
2242 gfx::Transform content_to_target_transform;
2243 content_to_target_transform.Scale(10.0, 10.0);
2244 gfx::Rect quad_content_rect(gfx::Size(20, 20));
2245 SharedQuadState* blue_shared_state = CreateTestSharedQuadState(
2246 content_to_target_transform, quad_content_rect, pass.get());
2247
2248 PictureDrawQuad* blue_quad = pass->CreateAndAppendDrawQuad<PictureDrawQuad>();
2249 blue_quad->SetNew(blue_shared_state, quad_content_rect, gfx::Rect(),
2250 quad_content_rect, gfx::RectF(quad_content_rect),
2251 content_union_rect.size(), nearest_neighbor, texture_format,
2252 content_union_rect, contents_scale, pile.get());
2253
2254 // Fill left half of viewport with green.
2255 gfx::Transform half_green_content_to_target_transform;
2256 gfx::Rect half_green_rect(gfx::Size(viewport.width() / 2, viewport.height()));
2257 SharedQuadState* half_green_shared_state = CreateTestSharedQuadState(
2258 half_green_content_to_target_transform, half_green_rect, pass.get());
2259 SolidColorDrawQuad* half_color_quad =
2260 pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
2261 half_color_quad->SetNew(half_green_shared_state,
2262 half_green_rect,
2263 half_green_rect,
2264 SK_ColorGREEN,
2265 false);
2266
2267 RenderPassList pass_list;
2268 pass_list.push_back(pass.Pass());
2269
2270 EXPECT_TRUE(this->RunPixelTest(
2271 &pass_list,
2272 base::FilePath(FILE_PATH_LITERAL("four_blue_green_checkers.png")),
2273 ExactPixelComparator(true)));
2274 }
2275
2276 typedef RendererPixelTest<GLRendererWithFlippedSurface>
2277 GLRendererPixelTestWithFlippedOutputSurface;
2278
2279 TEST_F(GLRendererPixelTestWithFlippedOutputSurface, ExplicitFlipTest) {
2280 // This draws a blue rect above a yellow rect with an inverted output surface.
2281 gfx::Rect viewport_rect(this->device_viewport_size_);
2282
2283 RenderPassId root_pass_id(1, 1);
2284 scoped_ptr<RenderPass> root_pass =
2285 CreateTestRootRenderPass(root_pass_id, viewport_rect);
2286
2287 RenderPassId child_pass_id(2, 2);
2288 gfx::Rect pass_rect(this->device_viewport_size_);
2289 gfx::Transform transform_to_root;
2290 scoped_ptr<RenderPass> child_pass =
2291 CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root);
2292
2293 gfx::Transform content_to_target_transform;
2294 SharedQuadState* shared_state = CreateTestSharedQuadState(
2295 content_to_target_transform, viewport_rect, child_pass.get());
2296
2297 gfx::Rect blue_rect(0,
2298 0,
2299 this->device_viewport_size_.width(),
2300 this->device_viewport_size_.height() / 2);
2301 SolidColorDrawQuad* blue =
2302 child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
2303 blue->SetNew(shared_state, blue_rect, blue_rect, SK_ColorBLUE, false);
2304 gfx::Rect yellow_rect(0,
2305 this->device_viewport_size_.height() / 2,
2306 this->device_viewport_size_.width(),
2307 this->device_viewport_size_.height() / 2);
2308 SolidColorDrawQuad* yellow =
2309 child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
2310 yellow->SetNew(shared_state, yellow_rect, yellow_rect, SK_ColorYELLOW, false);
2311
2312 SharedQuadState* pass_shared_state =
2313 CreateTestSharedQuadState(gfx::Transform(), pass_rect, root_pass.get());
2314 CreateTestRenderPassDrawQuad(
2315 pass_shared_state, pass_rect, child_pass_id, root_pass.get());
2316
2317 RenderPassList pass_list;
2318 pass_list.push_back(child_pass.Pass());
2319 pass_list.push_back(root_pass.Pass());
2320
2321 EXPECT_TRUE(this->RunPixelTest(
2322 &pass_list,
2323 base::FilePath(FILE_PATH_LITERAL("blue_yellow_flipped.png")),
2324 ExactPixelComparator(true)));
2325 }
2326
2327 TEST_F(GLRendererPixelTestWithFlippedOutputSurface, CheckChildPassUnflipped) {
2328 // This draws a blue rect above a yellow rect with an inverted output surface.
2329 gfx::Rect viewport_rect(this->device_viewport_size_);
2330
2331 RenderPassId root_pass_id(1, 1);
2332 scoped_ptr<RenderPass> root_pass =
2333 CreateTestRootRenderPass(root_pass_id, viewport_rect);
2334
2335 RenderPassId child_pass_id(2, 2);
2336 gfx::Rect pass_rect(this->device_viewport_size_);
2337 gfx::Transform transform_to_root;
2338 scoped_ptr<RenderPass> child_pass =
2339 CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root);
2340
2341 gfx::Transform content_to_target_transform;
2342 SharedQuadState* shared_state = CreateTestSharedQuadState(
2343 content_to_target_transform, viewport_rect, child_pass.get());
2344
2345 gfx::Rect blue_rect(0,
2346 0,
2347 this->device_viewport_size_.width(),
2348 this->device_viewport_size_.height() / 2);
2349 SolidColorDrawQuad* blue =
2350 child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
2351 blue->SetNew(shared_state, blue_rect, blue_rect, SK_ColorBLUE, false);
2352 gfx::Rect yellow_rect(0,
2353 this->device_viewport_size_.height() / 2,
2354 this->device_viewport_size_.width(),
2355 this->device_viewport_size_.height() / 2);
2356 SolidColorDrawQuad* yellow =
2357 child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
2358 yellow->SetNew(shared_state, yellow_rect, yellow_rect, SK_ColorYELLOW, false);
2359
2360 SharedQuadState* pass_shared_state =
2361 CreateTestSharedQuadState(gfx::Transform(), pass_rect, root_pass.get());
2362 CreateTestRenderPassDrawQuad(
2363 pass_shared_state, pass_rect, child_pass_id, root_pass.get());
2364
2365 RenderPassList pass_list;
2366 pass_list.push_back(child_pass.Pass());
2367 pass_list.push_back(root_pass.Pass());
2368
2369 // Check that the child pass remains unflipped.
2370 EXPECT_TRUE(this->RunPixelTestWithReadbackTarget(
2371 &pass_list,
2372 pass_list.front(),
2373 base::FilePath(FILE_PATH_LITERAL("blue_yellow.png")),
2374 ExactPixelComparator(true)));
2375 }
2376
2377 TEST_F(GLRendererPixelTest, CheckReadbackSubset) {
2378 gfx::Rect viewport_rect(this->device_viewport_size_);
2379
2380 RenderPassId root_pass_id(1, 1);
2381 scoped_ptr<RenderPass> root_pass =
2382 CreateTestRootRenderPass(root_pass_id, viewport_rect);
2383
2384 RenderPassId child_pass_id(2, 2);
2385 gfx::Rect pass_rect(this->device_viewport_size_);
2386 gfx::Transform transform_to_root;
2387 scoped_ptr<RenderPass> child_pass =
2388 CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root);
2389
2390 gfx::Transform content_to_target_transform;
2391 SharedQuadState* shared_state = CreateTestSharedQuadState(
2392 content_to_target_transform, viewport_rect, child_pass.get());
2393
2394 // Draw a green quad full-size with a blue quad in the lower-right corner.
2395 gfx::Rect blue_rect(this->device_viewport_size_.width() * 3 / 4,
2396 this->device_viewport_size_.height() * 3 / 4,
2397 this->device_viewport_size_.width() * 3 / 4,
2398 this->device_viewport_size_.height() * 3 / 4);
2399 SolidColorDrawQuad* blue =
2400 child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
2401 blue->SetNew(shared_state, blue_rect, blue_rect, SK_ColorBLUE, false);
2402 gfx::Rect green_rect(0,
2403 0,
2404 this->device_viewport_size_.width(),
2405 this->device_viewport_size_.height());
2406 SolidColorDrawQuad* green =
2407 child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
2408 green->SetNew(shared_state, green_rect, green_rect, SK_ColorGREEN, false);
2409
2410 SharedQuadState* pass_shared_state =
2411 CreateTestSharedQuadState(gfx::Transform(), pass_rect, root_pass.get());
2412 CreateTestRenderPassDrawQuad(
2413 pass_shared_state, pass_rect, child_pass_id, root_pass.get());
2414
2415 RenderPassList pass_list;
2416 pass_list.push_back(child_pass.Pass());
2417 pass_list.push_back(root_pass.Pass());
2418
2419 // Check that the child pass remains unflipped.
2420 gfx::Rect capture_rect(this->device_viewport_size_.width() / 2,
2421 this->device_viewport_size_.height() / 2,
2422 this->device_viewport_size_.width() / 2,
2423 this->device_viewport_size_.height() / 2);
2424 EXPECT_TRUE(this->RunPixelTestWithReadbackTargetAndArea(
2425 &pass_list,
2426 pass_list.front(),
2427 base::FilePath(FILE_PATH_LITERAL("green_small_with_blue_corner.png")),
2428 ExactPixelComparator(true),
2429 &capture_rect));
2430 }
2431
2432 TEST_F(GLRendererPixelTest, PictureDrawQuadTexture4444) {
2433 gfx::Size pile_tile_size(1000, 1000);
2434 gfx::Rect viewport(this->device_viewport_size_);
2435 ResourceFormat texture_format = RGBA_4444;
2436 bool nearest_neighbor = false;
2437
2438 RenderPassId id(1, 1);
2439 gfx::Transform transform_to_root;
2440 scoped_ptr<RenderPass> pass =
2441 CreateTestRenderPass(id, viewport, transform_to_root);
2442
2443 // One viewport-filling blue quad
2444 scoped_refptr<FakePicturePileImpl> blue_pile =
2445 FakePicturePileImpl::CreateFilledPile(pile_tile_size, viewport.size());
2446 SkPaint blue_paint;
2447 blue_paint.setColor(SK_ColorBLUE);
2448 blue_pile->add_draw_rect_with_paint(viewport, blue_paint);
2449 blue_pile->RerecordPile();
2450
2451 gfx::Transform blue_content_to_target_transform;
2452 SharedQuadState* blue_shared_state = CreateTestSharedQuadState(
2453 blue_content_to_target_transform, viewport, pass.get());
2454
2455 PictureDrawQuad* blue_quad = pass->CreateAndAppendDrawQuad<PictureDrawQuad>();
2456 blue_quad->SetNew(blue_shared_state, viewport, gfx::Rect(), viewport,
2457 gfx::RectF(0.f, 0.f, 1.f, 1.f), viewport.size(),
2458 nearest_neighbor, texture_format, viewport, 1.f,
2459 blue_pile.get());
2460
2461 RenderPassList pass_list;
2462 pass_list.push_back(pass.Pass());
2463
2464 EXPECT_TRUE(this->RunPixelTest(&pass_list,
2465 base::FilePath(FILE_PATH_LITERAL("blue.png")),
2466 ExactPixelComparator(true)));
2467 }
2468
2469 TYPED_TEST(RendererPixelTest, WrapModeRepeat) {
2470 gfx::Rect rect(this->device_viewport_size_);
2471
2472 RenderPassId id(1, 1);
2473 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect);
2474
2475 SharedQuadState* shared_state =
2476 CreateTestSharedQuadState(gfx::Transform(), rect, pass.get());
2477
2478 gfx::Rect texture_rect(4, 4);
2479 SkPMColor colors[4] = {
2480 SkPreMultiplyColor(SkColorSetARGB(255, 0, 255, 0)),
2481 SkPreMultiplyColor(SkColorSetARGB(255, 0, 128, 0)),
2482 SkPreMultiplyColor(SkColorSetARGB(255, 0, 64, 0)),
2483 SkPreMultiplyColor(SkColorSetARGB(255, 0, 0, 0)),
2484 };
2485 uint32_t pixels[16] = {
2486 colors[0], colors[0], colors[1], colors[1],
2487 colors[0], colors[0], colors[1], colors[1],
2488 colors[2], colors[2], colors[3], colors[3],
2489 colors[2], colors[2], colors[3], colors[3],
2490 };
2491 ResourceProvider::ResourceId resource =
2492 this->resource_provider_->CreateResource(
2493 texture_rect.size(),
2494 GL_REPEAT,
2495 ResourceProvider::TextureHintImmutable,
2496 RGBA_8888);
2497 this->resource_provider_->SetPixels(
2498 resource,
2499 reinterpret_cast<uint8_t*>(pixels),
2500 texture_rect,
2501 texture_rect,
2502 gfx::Vector2d());
2503
2504 float vertex_opacity[4] = {1.0f, 1.0f, 1.0f, 1.0f};
2505 TextureDrawQuad* texture_quad =
2506 pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
2507 texture_quad->SetNew(
2508 shared_state,
2509 gfx::Rect(this->device_viewport_size_),
2510 gfx::Rect(),
2511 gfx::Rect(this->device_viewport_size_),
2512 resource,
2513 true, // premultiplied_alpha
2514 gfx::PointF(0.0f, 0.0f), // uv_top_left
2515 gfx::PointF( // uv_bottom_right
2516 this->device_viewport_size_.width() / texture_rect.width(),
2517 this->device_viewport_size_.height() / texture_rect.height()),
2518 SK_ColorWHITE,
2519 vertex_opacity,
2520 false, // flipped
2521 false); // nearest_neighbor
2522
2523 RenderPassList pass_list;
2524 pass_list.push_back(pass.Pass());
2525
2526 EXPECT_TRUE(this->RunPixelTest(
2527 &pass_list,
2528 base::FilePath(FILE_PATH_LITERAL("wrap_mode_repeat.png")),
2529 FuzzyPixelOffByOneComparator(true)));
2530 }
2531
2532 #endif // !defined(OS_ANDROID)
2533
2534 } // namespace
2535 } // namespace cc