OLD | NEW |
1 // Copyright 2012 The Chromium Authors. All rights reserved. | 1 // Copyright 2012 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "base/message_loop/message_loop.h" | 5 #include "base/message_loop/message_loop.h" |
6 #include "cc/layers/append_quads_data.h" | 6 #include "cc/layers/append_quads_data.h" |
7 #include "cc/output/gl_renderer.h" | 7 #include "cc/output/gl_renderer.h" |
8 #include "cc/quads/draw_quad.h" | 8 #include "cc/quads/draw_quad.h" |
9 #include "cc/quads/picture_draw_quad.h" | 9 #include "cc/quads/picture_draw_quad.h" |
10 #include "cc/quads/texture_draw_quad.h" | 10 #include "cc/quads/texture_draw_quad.h" |
11 #include "cc/resources/video_resource_updater.h" | 11 #include "cc/resources/video_resource_updater.h" |
12 #include "cc/test/fake_picture_pile_impl.h" | 12 #include "cc/test/fake_picture_pile_impl.h" |
13 #include "cc/test/pixel_test.h" | 13 #include "cc/test/pixel_test.h" |
14 #include "gpu/command_buffer/client/gles2_interface.h" | 14 #include "gpu/command_buffer/client/gles2_interface.h" |
15 #include "media/base/video_frame.h" | 15 #include "media/base/video_frame.h" |
16 #include "third_party/skia/include/core/SkBitmapDevice.h" | 16 #include "third_party/skia/include/core/SkBitmapDevice.h" |
17 #include "third_party/skia/include/core/SkColorPriv.h" | 17 #include "third_party/skia/include/core/SkColorPriv.h" |
18 #include "third_party/skia/include/core/SkImageFilter.h" | 18 #include "third_party/skia/include/core/SkImageFilter.h" |
19 #include "third_party/skia/include/core/SkMatrix.h" | 19 #include "third_party/skia/include/core/SkMatrix.h" |
20 #include "third_party/skia/include/effects/SkColorFilterImageFilter.h" | 20 #include "third_party/skia/include/effects/SkColorFilterImageFilter.h" |
21 #include "third_party/skia/include/effects/SkColorMatrixFilter.h" | 21 #include "third_party/skia/include/effects/SkColorMatrixFilter.h" |
22 #include "ui/gfx/geometry/rect_conversions.h" | 22 #include "ui/gfx/geometry/rect_conversions.h" |
23 | 23 |
24 using gpu::gles2::GLES2Interface; | 24 using gpu::gles2::GLES2Interface; |
25 | 25 |
26 namespace cc { | 26 namespace cc { |
27 namespace { | 27 namespace { |
28 | 28 |
29 #if !defined(OS_ANDROID) | 29 #if !defined(OS_ANDROID) |
30 scoped_ptr<RenderPass> CreateTestRootRenderPass(RenderPass::Id id, | 30 scoped_ptr<RenderPass> CreateTestRootRenderPass(RenderPassId id, |
31 const gfx::Rect& rect) { | 31 const gfx::Rect& rect) { |
32 scoped_ptr<RenderPass> pass = RenderPass::Create(); | 32 scoped_ptr<RenderPass> pass = RenderPass::Create(); |
33 const gfx::Rect output_rect = rect; | 33 const gfx::Rect output_rect = rect; |
34 const gfx::Rect damage_rect = rect; | 34 const gfx::Rect damage_rect = rect; |
35 const gfx::Transform transform_to_root_target; | 35 const gfx::Transform transform_to_root_target; |
36 pass->SetNew(id, output_rect, damage_rect, transform_to_root_target); | 36 pass->SetNew(id, output_rect, damage_rect, transform_to_root_target); |
37 return pass.Pass(); | 37 return pass.Pass(); |
38 } | 38 } |
39 | 39 |
40 scoped_ptr<RenderPass> CreateTestRenderPass( | 40 scoped_ptr<RenderPass> CreateTestRenderPass( |
41 RenderPass::Id id, | 41 RenderPassId id, |
42 const gfx::Rect& rect, | 42 const gfx::Rect& rect, |
43 const gfx::Transform& transform_to_root_target) { | 43 const gfx::Transform& transform_to_root_target) { |
44 scoped_ptr<RenderPass> pass = RenderPass::Create(); | 44 scoped_ptr<RenderPass> pass = RenderPass::Create(); |
45 const gfx::Rect output_rect = rect; | 45 const gfx::Rect output_rect = rect; |
46 const gfx::Rect damage_rect = rect; | 46 const gfx::Rect damage_rect = rect; |
47 pass->SetNew(id, output_rect, damage_rect, transform_to_root_target); | 47 pass->SetNew(id, output_rect, damage_rect, transform_to_root_target); |
48 return pass.Pass(); | 48 return pass.Pass(); |
49 } | 49 } |
50 | 50 |
51 SharedQuadState* CreateTestSharedQuadState( | 51 SharedQuadState* CreateTestSharedQuadState( |
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
89 clip_rect, | 89 clip_rect, |
90 is_clipped, | 90 is_clipped, |
91 opacity, | 91 opacity, |
92 blend_mode, | 92 blend_mode, |
93 sorting_context_id); | 93 sorting_context_id); |
94 return shared_state; | 94 return shared_state; |
95 } | 95 } |
96 | 96 |
97 void CreateTestRenderPassDrawQuad(const SharedQuadState* shared_state, | 97 void CreateTestRenderPassDrawQuad(const SharedQuadState* shared_state, |
98 const gfx::Rect& rect, | 98 const gfx::Rect& rect, |
99 RenderPass::Id pass_id, | 99 RenderPassId pass_id, |
100 RenderPass* render_pass) { | 100 RenderPass* render_pass) { |
101 RenderPassDrawQuad* quad = | 101 RenderPassDrawQuad* quad = |
102 render_pass->CreateAndAppendDrawQuad<RenderPassDrawQuad>(); | 102 render_pass->CreateAndAppendDrawQuad<RenderPassDrawQuad>(); |
103 quad->SetNew(shared_state, | 103 quad->SetNew(shared_state, |
104 rect, | 104 rect, |
105 rect, | 105 rect, |
106 pass_id, | 106 pass_id, |
107 0, // mask_resource_id | 107 0, // mask_resource_id |
108 gfx::RectF(1.f, 1.f), // mask_uv_rect | 108 gfx::RectF(1.f, 1.f), // mask_uv_rect |
109 FilterOperations(), // foreground filters | 109 FilterOperations(), // foreground filters |
(...skipping 90 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
200 template<typename RendererType> | 200 template<typename RendererType> |
201 bool FuzzyForSoftwareOnlyPixelComparator<RendererType>::Compare( | 201 bool FuzzyForSoftwareOnlyPixelComparator<RendererType>::Compare( |
202 const SkBitmap& actual_bmp, | 202 const SkBitmap& actual_bmp, |
203 const SkBitmap& expected_bmp) const { | 203 const SkBitmap& expected_bmp) const { |
204 return exact_.Compare(actual_bmp, expected_bmp); | 204 return exact_.Compare(actual_bmp, expected_bmp); |
205 } | 205 } |
206 | 206 |
207 TYPED_TEST(RendererPixelTest, SimpleGreenRect) { | 207 TYPED_TEST(RendererPixelTest, SimpleGreenRect) { |
208 gfx::Rect rect(this->device_viewport_size_); | 208 gfx::Rect rect(this->device_viewport_size_); |
209 | 209 |
210 RenderPass::Id id(1, 1); | 210 RenderPassId id(1, 1); |
211 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); | 211 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); |
212 | 212 |
213 SharedQuadState* shared_state = | 213 SharedQuadState* shared_state = |
214 CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); | 214 CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); |
215 | 215 |
216 SolidColorDrawQuad* color_quad = | 216 SolidColorDrawQuad* color_quad = |
217 pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); | 217 pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); |
218 color_quad->SetNew(shared_state, rect, rect, SK_ColorGREEN, false); | 218 color_quad->SetNew(shared_state, rect, rect, SK_ColorGREEN, false); |
219 | 219 |
220 RenderPassList pass_list; | 220 RenderPassList pass_list; |
221 pass_list.push_back(pass.Pass()); | 221 pass_list.push_back(pass.Pass()); |
222 | 222 |
223 EXPECT_TRUE(this->RunPixelTest( | 223 EXPECT_TRUE(this->RunPixelTest( |
224 &pass_list, | 224 &pass_list, |
225 base::FilePath(FILE_PATH_LITERAL("green.png")), | 225 base::FilePath(FILE_PATH_LITERAL("green.png")), |
226 ExactPixelComparator(true))); | 226 ExactPixelComparator(true))); |
227 } | 227 } |
228 | 228 |
229 TYPED_TEST(RendererPixelTest, SimpleGreenRect_NonRootRenderPass) { | 229 TYPED_TEST(RendererPixelTest, SimpleGreenRect_NonRootRenderPass) { |
230 gfx::Rect rect(this->device_viewport_size_); | 230 gfx::Rect rect(this->device_viewport_size_); |
231 gfx::Rect small_rect(100, 100); | 231 gfx::Rect small_rect(100, 100); |
232 | 232 |
233 RenderPass::Id child_id(2, 1); | 233 RenderPassId child_id(2, 1); |
234 scoped_ptr<RenderPass> child_pass = | 234 scoped_ptr<RenderPass> child_pass = |
235 CreateTestRenderPass(child_id, small_rect, gfx::Transform()); | 235 CreateTestRenderPass(child_id, small_rect, gfx::Transform()); |
236 | 236 |
237 SharedQuadState* child_shared_state = | 237 SharedQuadState* child_shared_state = |
238 CreateTestSharedQuadState(gfx::Transform(), small_rect, child_pass.get()); | 238 CreateTestSharedQuadState(gfx::Transform(), small_rect, child_pass.get()); |
239 | 239 |
240 SolidColorDrawQuad* color_quad = | 240 SolidColorDrawQuad* color_quad = |
241 child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); | 241 child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); |
242 color_quad->SetNew(child_shared_state, rect, rect, SK_ColorGREEN, false); | 242 color_quad->SetNew(child_shared_state, rect, rect, SK_ColorGREEN, false); |
243 | 243 |
244 RenderPass::Id root_id(1, 1); | 244 RenderPassId root_id(1, 1); |
245 scoped_ptr<RenderPass> root_pass = | 245 scoped_ptr<RenderPass> root_pass = |
246 CreateTestRenderPass(root_id, rect, gfx::Transform()); | 246 CreateTestRenderPass(root_id, rect, gfx::Transform()); |
247 | 247 |
248 SharedQuadState* root_shared_state = | 248 SharedQuadState* root_shared_state = |
249 CreateTestSharedQuadState(gfx::Transform(), rect, root_pass.get()); | 249 CreateTestSharedQuadState(gfx::Transform(), rect, root_pass.get()); |
250 | 250 |
251 CreateTestRenderPassDrawQuad( | 251 CreateTestRenderPassDrawQuad( |
252 root_shared_state, small_rect, child_id, root_pass.get()); | 252 root_shared_state, small_rect, child_id, root_pass.get()); |
253 | 253 |
254 RenderPass* child_pass_ptr = child_pass.get(); | 254 RenderPass* child_pass_ptr = child_pass.get(); |
255 | 255 |
256 RenderPassList pass_list; | 256 RenderPassList pass_list; |
257 pass_list.push_back(child_pass.Pass()); | 257 pass_list.push_back(child_pass.Pass()); |
258 pass_list.push_back(root_pass.Pass()); | 258 pass_list.push_back(root_pass.Pass()); |
259 | 259 |
260 EXPECT_TRUE(this->RunPixelTestWithReadbackTarget( | 260 EXPECT_TRUE(this->RunPixelTestWithReadbackTarget( |
261 &pass_list, | 261 &pass_list, |
262 child_pass_ptr, | 262 child_pass_ptr, |
263 base::FilePath(FILE_PATH_LITERAL("green_small.png")), | 263 base::FilePath(FILE_PATH_LITERAL("green_small.png")), |
264 ExactPixelComparator(true))); | 264 ExactPixelComparator(true))); |
265 } | 265 } |
266 | 266 |
267 TYPED_TEST(RendererPixelTest, PremultipliedTextureWithoutBackground) { | 267 TYPED_TEST(RendererPixelTest, PremultipliedTextureWithoutBackground) { |
268 gfx::Rect rect(this->device_viewport_size_); | 268 gfx::Rect rect(this->device_viewport_size_); |
269 | 269 |
270 RenderPass::Id id(1, 1); | 270 RenderPassId id(1, 1); |
271 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); | 271 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); |
272 | 272 |
273 SharedQuadState* shared_state = | 273 SharedQuadState* shared_state = |
274 CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); | 274 CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); |
275 | 275 |
276 CreateTestTextureDrawQuad(gfx::Rect(this->device_viewport_size_), | 276 CreateTestTextureDrawQuad(gfx::Rect(this->device_viewport_size_), |
277 SkColorSetARGB(128, 0, 255, 0), // Texel color. | 277 SkColorSetARGB(128, 0, 255, 0), // Texel color. |
278 SK_ColorTRANSPARENT, // Background color. | 278 SK_ColorTRANSPARENT, // Background color. |
279 true, // Premultiplied alpha. | 279 true, // Premultiplied alpha. |
280 shared_state, | 280 shared_state, |
281 this->resource_provider_.get(), | 281 this->resource_provider_.get(), |
282 pass.get()); | 282 pass.get()); |
283 | 283 |
284 SolidColorDrawQuad* color_quad = | 284 SolidColorDrawQuad* color_quad = |
285 pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); | 285 pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); |
286 color_quad->SetNew(shared_state, rect, rect, SK_ColorWHITE, false); | 286 color_quad->SetNew(shared_state, rect, rect, SK_ColorWHITE, false); |
287 | 287 |
288 RenderPassList pass_list; | 288 RenderPassList pass_list; |
289 pass_list.push_back(pass.Pass()); | 289 pass_list.push_back(pass.Pass()); |
290 | 290 |
291 EXPECT_TRUE(this->RunPixelTest( | 291 EXPECT_TRUE(this->RunPixelTest( |
292 &pass_list, | 292 &pass_list, |
293 base::FilePath(FILE_PATH_LITERAL("green_alpha.png")), | 293 base::FilePath(FILE_PATH_LITERAL("green_alpha.png")), |
294 FuzzyPixelOffByOneComparator(true))); | 294 FuzzyPixelOffByOneComparator(true))); |
295 } | 295 } |
296 | 296 |
297 TYPED_TEST(RendererPixelTest, PremultipliedTextureWithBackground) { | 297 TYPED_TEST(RendererPixelTest, PremultipliedTextureWithBackground) { |
298 gfx::Rect rect(this->device_viewport_size_); | 298 gfx::Rect rect(this->device_viewport_size_); |
299 | 299 |
300 RenderPass::Id id(1, 1); | 300 RenderPassId id(1, 1); |
301 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); | 301 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); |
302 | 302 |
303 SharedQuadState* texture_quad_state = | 303 SharedQuadState* texture_quad_state = |
304 CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); | 304 CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); |
305 texture_quad_state->opacity = 0.8f; | 305 texture_quad_state->opacity = 0.8f; |
306 | 306 |
307 CreateTestTextureDrawQuad(gfx::Rect(this->device_viewport_size_), | 307 CreateTestTextureDrawQuad(gfx::Rect(this->device_viewport_size_), |
308 SkColorSetARGB(204, 120, 255, 120), // Texel color. | 308 SkColorSetARGB(204, 120, 255, 120), // Texel color. |
309 SK_ColorGREEN, // Background color. | 309 SK_ColorGREEN, // Background color. |
310 true, // Premultiplied alpha. | 310 true, // Premultiplied alpha. |
(...skipping 13 matching lines...) Expand all Loading... |
324 EXPECT_TRUE(this->RunPixelTest( | 324 EXPECT_TRUE(this->RunPixelTest( |
325 &pass_list, | 325 &pass_list, |
326 base::FilePath(FILE_PATH_LITERAL("green_alpha.png")), | 326 base::FilePath(FILE_PATH_LITERAL("green_alpha.png")), |
327 FuzzyPixelOffByOneComparator(true))); | 327 FuzzyPixelOffByOneComparator(true))); |
328 } | 328 } |
329 | 329 |
330 // TODO(skaslev): The software renderer does not support non-premultplied alpha. | 330 // TODO(skaslev): The software renderer does not support non-premultplied alpha. |
331 TEST_F(GLRendererPixelTest, NonPremultipliedTextureWithoutBackground) { | 331 TEST_F(GLRendererPixelTest, NonPremultipliedTextureWithoutBackground) { |
332 gfx::Rect rect(this->device_viewport_size_); | 332 gfx::Rect rect(this->device_viewport_size_); |
333 | 333 |
334 RenderPass::Id id(1, 1); | 334 RenderPassId id(1, 1); |
335 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); | 335 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); |
336 | 336 |
337 SharedQuadState* shared_state = | 337 SharedQuadState* shared_state = |
338 CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); | 338 CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); |
339 | 339 |
340 CreateTestTextureDrawQuad(gfx::Rect(this->device_viewport_size_), | 340 CreateTestTextureDrawQuad(gfx::Rect(this->device_viewport_size_), |
341 SkColorSetARGB(128, 0, 255, 0), // Texel color. | 341 SkColorSetARGB(128, 0, 255, 0), // Texel color. |
342 SK_ColorTRANSPARENT, // Background color. | 342 SK_ColorTRANSPARENT, // Background color. |
343 false, // Premultiplied alpha. | 343 false, // Premultiplied alpha. |
344 shared_state, | 344 shared_state, |
(...skipping 10 matching lines...) Expand all Loading... |
355 EXPECT_TRUE(this->RunPixelTest( | 355 EXPECT_TRUE(this->RunPixelTest( |
356 &pass_list, | 356 &pass_list, |
357 base::FilePath(FILE_PATH_LITERAL("green_alpha.png")), | 357 base::FilePath(FILE_PATH_LITERAL("green_alpha.png")), |
358 FuzzyPixelOffByOneComparator(true))); | 358 FuzzyPixelOffByOneComparator(true))); |
359 } | 359 } |
360 | 360 |
361 // TODO(skaslev): The software renderer does not support non-premultplied alpha. | 361 // TODO(skaslev): The software renderer does not support non-premultplied alpha. |
362 TEST_F(GLRendererPixelTest, NonPremultipliedTextureWithBackground) { | 362 TEST_F(GLRendererPixelTest, NonPremultipliedTextureWithBackground) { |
363 gfx::Rect rect(this->device_viewport_size_); | 363 gfx::Rect rect(this->device_viewport_size_); |
364 | 364 |
365 RenderPass::Id id(1, 1); | 365 RenderPassId id(1, 1); |
366 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); | 366 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); |
367 | 367 |
368 SharedQuadState* texture_quad_state = | 368 SharedQuadState* texture_quad_state = |
369 CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); | 369 CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); |
370 texture_quad_state->opacity = 0.8f; | 370 texture_quad_state->opacity = 0.8f; |
371 | 371 |
372 CreateTestTextureDrawQuad(gfx::Rect(this->device_viewport_size_), | 372 CreateTestTextureDrawQuad(gfx::Rect(this->device_viewport_size_), |
373 SkColorSetARGB(204, 120, 255, 120), // Texel color. | 373 SkColorSetARGB(204, 120, 255, 120), // Texel color. |
374 SK_ColorGREEN, // Background color. | 374 SK_ColorGREEN, // Background color. |
375 false, // Premultiplied alpha. | 375 false, // Premultiplied alpha. |
(...skipping 163 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
539 output_surface_->context_provider().get(), resource_provider_.get())); | 539 output_surface_->context_provider().get(), resource_provider_.get())); |
540 } | 540 } |
541 | 541 |
542 private: | 542 private: |
543 scoped_ptr<VideoResourceUpdater> video_resource_updater_; | 543 scoped_ptr<VideoResourceUpdater> video_resource_updater_; |
544 }; | 544 }; |
545 | 545 |
546 TEST_F(VideoGLRendererPixelTest, SimpleYUVRect) { | 546 TEST_F(VideoGLRendererPixelTest, SimpleYUVRect) { |
547 gfx::Rect rect(this->device_viewport_size_); | 547 gfx::Rect rect(this->device_viewport_size_); |
548 | 548 |
549 RenderPass::Id id(1, 1); | 549 RenderPassId id(1, 1); |
550 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); | 550 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); |
551 | 551 |
552 SharedQuadState* shared_state = | 552 SharedQuadState* shared_state = |
553 CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); | 553 CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); |
554 | 554 |
555 CreateTestYUVVideoDrawQuad_Striped(shared_state, | 555 CreateTestYUVVideoDrawQuad_Striped(shared_state, |
556 media::VideoFrame::YV12, | 556 media::VideoFrame::YV12, |
557 false, | 557 false, |
558 gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), | 558 gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), |
559 pass.get()); | 559 pass.get()); |
560 | 560 |
561 RenderPassList pass_list; | 561 RenderPassList pass_list; |
562 pass_list.push_back(pass.Pass()); | 562 pass_list.push_back(pass.Pass()); |
563 | 563 |
564 EXPECT_TRUE( | 564 EXPECT_TRUE( |
565 this->RunPixelTest(&pass_list, | 565 this->RunPixelTest(&pass_list, |
566 base::FilePath(FILE_PATH_LITERAL("yuv_stripes.png")), | 566 base::FilePath(FILE_PATH_LITERAL("yuv_stripes.png")), |
567 FuzzyPixelOffByOneComparator(true))); | 567 FuzzyPixelOffByOneComparator(true))); |
568 } | 568 } |
569 | 569 |
570 TEST_F(VideoGLRendererPixelTest, OffsetYUVRect) { | 570 TEST_F(VideoGLRendererPixelTest, OffsetYUVRect) { |
571 gfx::Rect rect(this->device_viewport_size_); | 571 gfx::Rect rect(this->device_viewport_size_); |
572 | 572 |
573 RenderPass::Id id(1, 1); | 573 RenderPassId id(1, 1); |
574 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); | 574 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); |
575 | 575 |
576 SharedQuadState* shared_state = | 576 SharedQuadState* shared_state = |
577 CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); | 577 CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); |
578 | 578 |
579 // Intentionally sets frame format to I420 for testing coverage. | 579 // Intentionally sets frame format to I420 for testing coverage. |
580 CreateTestYUVVideoDrawQuad_Striped(shared_state, | 580 CreateTestYUVVideoDrawQuad_Striped(shared_state, |
581 media::VideoFrame::I420, | 581 media::VideoFrame::I420, |
582 false, | 582 false, |
583 gfx::RectF(0.125f, 0.25f, 0.75f, 0.5f), | 583 gfx::RectF(0.125f, 0.25f, 0.75f, 0.5f), |
584 pass.get()); | 584 pass.get()); |
585 | 585 |
586 RenderPassList pass_list; | 586 RenderPassList pass_list; |
587 pass_list.push_back(pass.Pass()); | 587 pass_list.push_back(pass.Pass()); |
588 | 588 |
589 EXPECT_TRUE(this->RunPixelTest( | 589 EXPECT_TRUE(this->RunPixelTest( |
590 &pass_list, | 590 &pass_list, |
591 base::FilePath(FILE_PATH_LITERAL("yuv_stripes_offset.png")), | 591 base::FilePath(FILE_PATH_LITERAL("yuv_stripes_offset.png")), |
592 FuzzyPixelOffByOneComparator(true))); | 592 FuzzyPixelOffByOneComparator(true))); |
593 } | 593 } |
594 | 594 |
595 TEST_F(VideoGLRendererPixelTest, SimpleYUVRectBlack) { | 595 TEST_F(VideoGLRendererPixelTest, SimpleYUVRectBlack) { |
596 gfx::Rect rect(this->device_viewport_size_); | 596 gfx::Rect rect(this->device_viewport_size_); |
597 | 597 |
598 RenderPass::Id id(1, 1); | 598 RenderPassId id(1, 1); |
599 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); | 599 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); |
600 | 600 |
601 SharedQuadState* shared_state = | 601 SharedQuadState* shared_state = |
602 CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); | 602 CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); |
603 | 603 |
604 // In MPEG color range YUV values of (15,128,128) should produce black. | 604 // In MPEG color range YUV values of (15,128,128) should produce black. |
605 CreateTestYUVVideoDrawQuad_Solid(shared_state, | 605 CreateTestYUVVideoDrawQuad_Solid(shared_state, |
606 media::VideoFrame::YV12, | 606 media::VideoFrame::YV12, |
607 false, | 607 false, |
608 gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), | 608 gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), |
609 15, | 609 15, |
610 128, | 610 128, |
611 128, | 611 128, |
612 pass.get()); | 612 pass.get()); |
613 | 613 |
614 RenderPassList pass_list; | 614 RenderPassList pass_list; |
615 pass_list.push_back(pass.Pass()); | 615 pass_list.push_back(pass.Pass()); |
616 | 616 |
617 // If we didn't get black out of the YUV values above, then we probably have a | 617 // If we didn't get black out of the YUV values above, then we probably have a |
618 // color range issue. | 618 // color range issue. |
619 EXPECT_TRUE(this->RunPixelTest(&pass_list, | 619 EXPECT_TRUE(this->RunPixelTest(&pass_list, |
620 base::FilePath(FILE_PATH_LITERAL("black.png")), | 620 base::FilePath(FILE_PATH_LITERAL("black.png")), |
621 FuzzyPixelOffByOneComparator(true))); | 621 FuzzyPixelOffByOneComparator(true))); |
622 } | 622 } |
623 | 623 |
624 TEST_F(VideoGLRendererPixelTest, SimpleYUVJRect) { | 624 TEST_F(VideoGLRendererPixelTest, SimpleYUVJRect) { |
625 gfx::Rect rect(this->device_viewport_size_); | 625 gfx::Rect rect(this->device_viewport_size_); |
626 | 626 |
627 RenderPass::Id id(1, 1); | 627 RenderPassId id(1, 1); |
628 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); | 628 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); |
629 | 629 |
630 SharedQuadState* shared_state = | 630 SharedQuadState* shared_state = |
631 CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); | 631 CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); |
632 | 632 |
633 // YUV of (149,43,21) should be green (0,255,0) in RGB. | 633 // YUV of (149,43,21) should be green (0,255,0) in RGB. |
634 CreateTestYUVVideoDrawQuad_Solid(shared_state, | 634 CreateTestYUVVideoDrawQuad_Solid(shared_state, |
635 media::VideoFrame::YV12J, | 635 media::VideoFrame::YV12J, |
636 false, | 636 false, |
637 gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), | 637 gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), |
638 149, | 638 149, |
639 43, | 639 43, |
640 21, | 640 21, |
641 pass.get()); | 641 pass.get()); |
642 | 642 |
643 RenderPassList pass_list; | 643 RenderPassList pass_list; |
644 pass_list.push_back(pass.Pass()); | 644 pass_list.push_back(pass.Pass()); |
645 | 645 |
646 EXPECT_TRUE(this->RunPixelTest(&pass_list, | 646 EXPECT_TRUE(this->RunPixelTest(&pass_list, |
647 base::FilePath(FILE_PATH_LITERAL("green.png")), | 647 base::FilePath(FILE_PATH_LITERAL("green.png")), |
648 FuzzyPixelOffByOneComparator(true))); | 648 FuzzyPixelOffByOneComparator(true))); |
649 } | 649 } |
650 | 650 |
651 TEST_F(VideoGLRendererPixelTest, SimpleYUVJRectGrey) { | 651 TEST_F(VideoGLRendererPixelTest, SimpleYUVJRectGrey) { |
652 gfx::Rect rect(this->device_viewport_size_); | 652 gfx::Rect rect(this->device_viewport_size_); |
653 | 653 |
654 RenderPass::Id id(1, 1); | 654 RenderPassId id(1, 1); |
655 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); | 655 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); |
656 | 656 |
657 SharedQuadState* shared_state = | 657 SharedQuadState* shared_state = |
658 CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); | 658 CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); |
659 | 659 |
660 // Dark grey in JPEG color range (in MPEG, this is black). | 660 // Dark grey in JPEG color range (in MPEG, this is black). |
661 CreateTestYUVVideoDrawQuad_Solid(shared_state, | 661 CreateTestYUVVideoDrawQuad_Solid(shared_state, |
662 media::VideoFrame::YV12J, | 662 media::VideoFrame::YV12J, |
663 false, | 663 false, |
664 gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), | 664 gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), |
665 15, | 665 15, |
666 128, | 666 128, |
667 128, | 667 128, |
668 pass.get()); | 668 pass.get()); |
669 | 669 |
670 RenderPassList pass_list; | 670 RenderPassList pass_list; |
671 pass_list.push_back(pass.Pass()); | 671 pass_list.push_back(pass.Pass()); |
672 | 672 |
673 EXPECT_TRUE( | 673 EXPECT_TRUE( |
674 this->RunPixelTest(&pass_list, | 674 this->RunPixelTest(&pass_list, |
675 base::FilePath(FILE_PATH_LITERAL("dark_grey.png")), | 675 base::FilePath(FILE_PATH_LITERAL("dark_grey.png")), |
676 FuzzyPixelOffByOneComparator(true))); | 676 FuzzyPixelOffByOneComparator(true))); |
677 } | 677 } |
678 | 678 |
679 TEST_F(VideoGLRendererPixelTest, SimpleYUVARect) { | 679 TEST_F(VideoGLRendererPixelTest, SimpleYUVARect) { |
680 gfx::Rect rect(this->device_viewport_size_); | 680 gfx::Rect rect(this->device_viewport_size_); |
681 | 681 |
682 RenderPass::Id id(1, 1); | 682 RenderPassId id(1, 1); |
683 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); | 683 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); |
684 | 684 |
685 SharedQuadState* shared_state = | 685 SharedQuadState* shared_state = |
686 CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); | 686 CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); |
687 | 687 |
688 CreateTestYUVVideoDrawQuad_Striped(shared_state, | 688 CreateTestYUVVideoDrawQuad_Striped(shared_state, |
689 media::VideoFrame::YV12A, | 689 media::VideoFrame::YV12A, |
690 false, | 690 false, |
691 gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), | 691 gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), |
692 pass.get()); | 692 pass.get()); |
693 | 693 |
694 SolidColorDrawQuad* color_quad = | 694 SolidColorDrawQuad* color_quad = |
695 pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); | 695 pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); |
696 color_quad->SetNew(shared_state, rect, rect, SK_ColorWHITE, false); | 696 color_quad->SetNew(shared_state, rect, rect, SK_ColorWHITE, false); |
697 | 697 |
698 RenderPassList pass_list; | 698 RenderPassList pass_list; |
699 pass_list.push_back(pass.Pass()); | 699 pass_list.push_back(pass.Pass()); |
700 | 700 |
701 EXPECT_TRUE(this->RunPixelTest( | 701 EXPECT_TRUE(this->RunPixelTest( |
702 &pass_list, | 702 &pass_list, |
703 base::FilePath(FILE_PATH_LITERAL("yuv_stripes_alpha.png")), | 703 base::FilePath(FILE_PATH_LITERAL("yuv_stripes_alpha.png")), |
704 FuzzyPixelOffByOneComparator(true))); | 704 FuzzyPixelOffByOneComparator(true))); |
705 } | 705 } |
706 | 706 |
707 TEST_F(VideoGLRendererPixelTest, FullyTransparentYUVARect) { | 707 TEST_F(VideoGLRendererPixelTest, FullyTransparentYUVARect) { |
708 gfx::Rect rect(this->device_viewport_size_); | 708 gfx::Rect rect(this->device_viewport_size_); |
709 | 709 |
710 RenderPass::Id id(1, 1); | 710 RenderPassId id(1, 1); |
711 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); | 711 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); |
712 | 712 |
713 SharedQuadState* shared_state = | 713 SharedQuadState* shared_state = |
714 CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); | 714 CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); |
715 | 715 |
716 CreateTestYUVVideoDrawQuad_Striped(shared_state, | 716 CreateTestYUVVideoDrawQuad_Striped(shared_state, |
717 media::VideoFrame::YV12A, | 717 media::VideoFrame::YV12A, |
718 true, | 718 true, |
719 gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), | 719 gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), |
720 pass.get()); | 720 pass.get()); |
721 | 721 |
722 SolidColorDrawQuad* color_quad = | 722 SolidColorDrawQuad* color_quad = |
723 pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); | 723 pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); |
724 color_quad->SetNew(shared_state, rect, rect, SK_ColorBLACK, false); | 724 color_quad->SetNew(shared_state, rect, rect, SK_ColorBLACK, false); |
725 | 725 |
726 RenderPassList pass_list; | 726 RenderPassList pass_list; |
727 pass_list.push_back(pass.Pass()); | 727 pass_list.push_back(pass.Pass()); |
728 | 728 |
729 EXPECT_TRUE(this->RunPixelTest( | 729 EXPECT_TRUE(this->RunPixelTest( |
730 &pass_list, | 730 &pass_list, |
731 base::FilePath(FILE_PATH_LITERAL("black.png")), | 731 base::FilePath(FILE_PATH_LITERAL("black.png")), |
732 ExactPixelComparator(true))); | 732 ExactPixelComparator(true))); |
733 } | 733 } |
734 | 734 |
735 TYPED_TEST(RendererPixelTest, FastPassColorFilterAlpha) { | 735 TYPED_TEST(RendererPixelTest, FastPassColorFilterAlpha) { |
736 gfx::Rect viewport_rect(this->device_viewport_size_); | 736 gfx::Rect viewport_rect(this->device_viewport_size_); |
737 | 737 |
738 RenderPass::Id root_pass_id(1, 1); | 738 RenderPassId root_pass_id(1, 1); |
739 scoped_ptr<RenderPass> root_pass = | 739 scoped_ptr<RenderPass> root_pass = |
740 CreateTestRootRenderPass(root_pass_id, viewport_rect); | 740 CreateTestRootRenderPass(root_pass_id, viewport_rect); |
741 | 741 |
742 RenderPass::Id child_pass_id(2, 2); | 742 RenderPassId child_pass_id(2, 2); |
743 gfx::Rect pass_rect(this->device_viewport_size_); | 743 gfx::Rect pass_rect(this->device_viewport_size_); |
744 gfx::Transform transform_to_root; | 744 gfx::Transform transform_to_root; |
745 scoped_ptr<RenderPass> child_pass = | 745 scoped_ptr<RenderPass> child_pass = |
746 CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root); | 746 CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root); |
747 | 747 |
748 gfx::Transform content_to_target_transform; | 748 gfx::Transform content_to_target_transform; |
749 SharedQuadState* shared_state = CreateTestSharedQuadState( | 749 SharedQuadState* shared_state = CreateTestSharedQuadState( |
750 content_to_target_transform, viewport_rect, child_pass.get()); | 750 content_to_target_transform, viewport_rect, child_pass.get()); |
751 shared_state->opacity = 0.5f; | 751 shared_state->opacity = 0.5f; |
752 | 752 |
(...skipping 66 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
819 // renderer so use a fuzzy comparator. | 819 // renderer so use a fuzzy comparator. |
820 EXPECT_TRUE(this->RunPixelTest( | 820 EXPECT_TRUE(this->RunPixelTest( |
821 &pass_list, | 821 &pass_list, |
822 base::FilePath(FILE_PATH_LITERAL("blue_yellow_alpha.png")), | 822 base::FilePath(FILE_PATH_LITERAL("blue_yellow_alpha.png")), |
823 FuzzyForSoftwareOnlyPixelComparator<TypeParam>(false))); | 823 FuzzyForSoftwareOnlyPixelComparator<TypeParam>(false))); |
824 } | 824 } |
825 | 825 |
826 TYPED_TEST(RendererPixelTest, FastPassSaturateFilter) { | 826 TYPED_TEST(RendererPixelTest, FastPassSaturateFilter) { |
827 gfx::Rect viewport_rect(this->device_viewport_size_); | 827 gfx::Rect viewport_rect(this->device_viewport_size_); |
828 | 828 |
829 RenderPass::Id root_pass_id(1, 1); | 829 RenderPassId root_pass_id(1, 1); |
830 scoped_ptr<RenderPass> root_pass = | 830 scoped_ptr<RenderPass> root_pass = |
831 CreateTestRootRenderPass(root_pass_id, viewport_rect); | 831 CreateTestRootRenderPass(root_pass_id, viewport_rect); |
832 | 832 |
833 RenderPass::Id child_pass_id(2, 2); | 833 RenderPassId child_pass_id(2, 2); |
834 gfx::Rect pass_rect(this->device_viewport_size_); | 834 gfx::Rect pass_rect(this->device_viewport_size_); |
835 gfx::Transform transform_to_root; | 835 gfx::Transform transform_to_root; |
836 scoped_ptr<RenderPass> child_pass = | 836 scoped_ptr<RenderPass> child_pass = |
837 CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root); | 837 CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root); |
838 | 838 |
839 gfx::Transform content_to_target_transform; | 839 gfx::Transform content_to_target_transform; |
840 SharedQuadState* shared_state = CreateTestSharedQuadState( | 840 SharedQuadState* shared_state = CreateTestSharedQuadState( |
841 content_to_target_transform, viewport_rect, child_pass.get()); | 841 content_to_target_transform, viewport_rect, child_pass.get()); |
842 shared_state->opacity = 0.5f; | 842 shared_state->opacity = 0.5f; |
843 | 843 |
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
888 | 888 |
889 EXPECT_TRUE(this->RunPixelTest( | 889 EXPECT_TRUE(this->RunPixelTest( |
890 &pass_list, | 890 &pass_list, |
891 base::FilePath(FILE_PATH_LITERAL("blue_yellow_alpha.png")), | 891 base::FilePath(FILE_PATH_LITERAL("blue_yellow_alpha.png")), |
892 ExactPixelComparator(true))); | 892 ExactPixelComparator(true))); |
893 } | 893 } |
894 | 894 |
895 TYPED_TEST(RendererPixelTest, FastPassFilterChain) { | 895 TYPED_TEST(RendererPixelTest, FastPassFilterChain) { |
896 gfx::Rect viewport_rect(this->device_viewport_size_); | 896 gfx::Rect viewport_rect(this->device_viewport_size_); |
897 | 897 |
898 RenderPass::Id root_pass_id(1, 1); | 898 RenderPassId root_pass_id(1, 1); |
899 scoped_ptr<RenderPass> root_pass = | 899 scoped_ptr<RenderPass> root_pass = |
900 CreateTestRootRenderPass(root_pass_id, viewport_rect); | 900 CreateTestRootRenderPass(root_pass_id, viewport_rect); |
901 | 901 |
902 RenderPass::Id child_pass_id(2, 2); | 902 RenderPassId child_pass_id(2, 2); |
903 gfx::Rect pass_rect(this->device_viewport_size_); | 903 gfx::Rect pass_rect(this->device_viewport_size_); |
904 gfx::Transform transform_to_root; | 904 gfx::Transform transform_to_root; |
905 scoped_ptr<RenderPass> child_pass = | 905 scoped_ptr<RenderPass> child_pass = |
906 CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root); | 906 CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root); |
907 | 907 |
908 gfx::Transform content_to_target_transform; | 908 gfx::Transform content_to_target_transform; |
909 SharedQuadState* shared_state = CreateTestSharedQuadState( | 909 SharedQuadState* shared_state = CreateTestSharedQuadState( |
910 content_to_target_transform, viewport_rect, child_pass.get()); | 910 content_to_target_transform, viewport_rect, child_pass.get()); |
911 shared_state->opacity = 0.5f; | 911 shared_state->opacity = 0.5f; |
912 | 912 |
(...skipping 45 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
958 | 958 |
959 EXPECT_TRUE(this->RunPixelTest( | 959 EXPECT_TRUE(this->RunPixelTest( |
960 &pass_list, | 960 &pass_list, |
961 base::FilePath(FILE_PATH_LITERAL("blue_yellow_filter_chain.png")), | 961 base::FilePath(FILE_PATH_LITERAL("blue_yellow_filter_chain.png")), |
962 ExactPixelComparator(true))); | 962 ExactPixelComparator(true))); |
963 } | 963 } |
964 | 964 |
965 TYPED_TEST(RendererPixelTest, FastPassColorFilterAlphaTranslation) { | 965 TYPED_TEST(RendererPixelTest, FastPassColorFilterAlphaTranslation) { |
966 gfx::Rect viewport_rect(this->device_viewport_size_); | 966 gfx::Rect viewport_rect(this->device_viewport_size_); |
967 | 967 |
968 RenderPass::Id root_pass_id(1, 1); | 968 RenderPassId root_pass_id(1, 1); |
969 scoped_ptr<RenderPass> root_pass = | 969 scoped_ptr<RenderPass> root_pass = |
970 CreateTestRootRenderPass(root_pass_id, viewport_rect); | 970 CreateTestRootRenderPass(root_pass_id, viewport_rect); |
971 | 971 |
972 RenderPass::Id child_pass_id(2, 2); | 972 RenderPassId child_pass_id(2, 2); |
973 gfx::Rect pass_rect(this->device_viewport_size_); | 973 gfx::Rect pass_rect(this->device_viewport_size_); |
974 gfx::Transform transform_to_root; | 974 gfx::Transform transform_to_root; |
975 scoped_ptr<RenderPass> child_pass = | 975 scoped_ptr<RenderPass> child_pass = |
976 CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root); | 976 CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root); |
977 | 977 |
978 gfx::Transform content_to_target_transform; | 978 gfx::Transform content_to_target_transform; |
979 SharedQuadState* shared_state = CreateTestSharedQuadState( | 979 SharedQuadState* shared_state = CreateTestSharedQuadState( |
980 content_to_target_transform, viewport_rect, child_pass.get()); | 980 content_to_target_transform, viewport_rect, child_pass.get()); |
981 shared_state->opacity = 0.5f; | 981 shared_state->opacity = 0.5f; |
982 | 982 |
(...skipping 70 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1053 // renderer so use a fuzzy comparator. | 1053 // renderer so use a fuzzy comparator. |
1054 EXPECT_TRUE(this->RunPixelTest( | 1054 EXPECT_TRUE(this->RunPixelTest( |
1055 &pass_list, | 1055 &pass_list, |
1056 base::FilePath(FILE_PATH_LITERAL("blue_yellow_alpha_translate.png")), | 1056 base::FilePath(FILE_PATH_LITERAL("blue_yellow_alpha_translate.png")), |
1057 FuzzyForSoftwareOnlyPixelComparator<TypeParam>(false))); | 1057 FuzzyForSoftwareOnlyPixelComparator<TypeParam>(false))); |
1058 } | 1058 } |
1059 | 1059 |
1060 TYPED_TEST(RendererPixelTest, EnlargedRenderPassTexture) { | 1060 TYPED_TEST(RendererPixelTest, EnlargedRenderPassTexture) { |
1061 gfx::Rect viewport_rect(this->device_viewport_size_); | 1061 gfx::Rect viewport_rect(this->device_viewport_size_); |
1062 | 1062 |
1063 RenderPass::Id root_pass_id(1, 1); | 1063 RenderPassId root_pass_id(1, 1); |
1064 scoped_ptr<RenderPass> root_pass = | 1064 scoped_ptr<RenderPass> root_pass = |
1065 CreateTestRootRenderPass(root_pass_id, viewport_rect); | 1065 CreateTestRootRenderPass(root_pass_id, viewport_rect); |
1066 | 1066 |
1067 RenderPass::Id child_pass_id(2, 2); | 1067 RenderPassId child_pass_id(2, 2); |
1068 gfx::Rect pass_rect(this->device_viewport_size_); | 1068 gfx::Rect pass_rect(this->device_viewport_size_); |
1069 gfx::Transform transform_to_root; | 1069 gfx::Transform transform_to_root; |
1070 scoped_ptr<RenderPass> child_pass = | 1070 scoped_ptr<RenderPass> child_pass = |
1071 CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root); | 1071 CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root); |
1072 | 1072 |
1073 gfx::Transform content_to_target_transform; | 1073 gfx::Transform content_to_target_transform; |
1074 SharedQuadState* shared_state = CreateTestSharedQuadState( | 1074 SharedQuadState* shared_state = CreateTestSharedQuadState( |
1075 content_to_target_transform, viewport_rect, child_pass.get()); | 1075 content_to_target_transform, viewport_rect, child_pass.get()); |
1076 | 1076 |
1077 gfx::Rect blue_rect(0, | 1077 gfx::Rect blue_rect(0, |
(...skipping 24 matching lines...) Expand all Loading... |
1102 | 1102 |
1103 EXPECT_TRUE(this->RunPixelTest( | 1103 EXPECT_TRUE(this->RunPixelTest( |
1104 &pass_list, | 1104 &pass_list, |
1105 base::FilePath(FILE_PATH_LITERAL("blue_yellow.png")), | 1105 base::FilePath(FILE_PATH_LITERAL("blue_yellow.png")), |
1106 ExactPixelComparator(true))); | 1106 ExactPixelComparator(true))); |
1107 } | 1107 } |
1108 | 1108 |
1109 TYPED_TEST(RendererPixelTest, EnlargedRenderPassTextureWithAntiAliasing) { | 1109 TYPED_TEST(RendererPixelTest, EnlargedRenderPassTextureWithAntiAliasing) { |
1110 gfx::Rect viewport_rect(this->device_viewport_size_); | 1110 gfx::Rect viewport_rect(this->device_viewport_size_); |
1111 | 1111 |
1112 RenderPass::Id root_pass_id(1, 1); | 1112 RenderPassId root_pass_id(1, 1); |
1113 scoped_ptr<RenderPass> root_pass = | 1113 scoped_ptr<RenderPass> root_pass = |
1114 CreateTestRootRenderPass(root_pass_id, viewport_rect); | 1114 CreateTestRootRenderPass(root_pass_id, viewport_rect); |
1115 | 1115 |
1116 RenderPass::Id child_pass_id(2, 2); | 1116 RenderPassId child_pass_id(2, 2); |
1117 gfx::Rect pass_rect(this->device_viewport_size_); | 1117 gfx::Rect pass_rect(this->device_viewport_size_); |
1118 gfx::Transform transform_to_root; | 1118 gfx::Transform transform_to_root; |
1119 scoped_ptr<RenderPass> child_pass = | 1119 scoped_ptr<RenderPass> child_pass = |
1120 CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root); | 1120 CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root); |
1121 | 1121 |
1122 gfx::Transform content_to_target_transform; | 1122 gfx::Transform content_to_target_transform; |
1123 SharedQuadState* shared_state = CreateTestSharedQuadState( | 1123 SharedQuadState* shared_state = CreateTestSharedQuadState( |
1124 content_to_target_transform, viewport_rect, child_pass.get()); | 1124 content_to_target_transform, viewport_rect, child_pass.get()); |
1125 | 1125 |
1126 gfx::Rect blue_rect(0, | 1126 gfx::Rect blue_rect(0, |
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1166 &pass_list, | 1166 &pass_list, |
1167 base::FilePath(FILE_PATH_LITERAL("blue_yellow_anti_aliasing.png")), | 1167 base::FilePath(FILE_PATH_LITERAL("blue_yellow_anti_aliasing.png")), |
1168 FuzzyPixelOffByOneComparator(true))); | 1168 FuzzyPixelOffByOneComparator(true))); |
1169 } | 1169 } |
1170 | 1170 |
1171 // This tests the case where we have a RenderPass with a mask, but the quad | 1171 // This tests the case where we have a RenderPass with a mask, but the quad |
1172 // for the masked surface does not include the full surface texture. | 1172 // for the masked surface does not include the full surface texture. |
1173 TYPED_TEST(RendererPixelTest, RenderPassAndMaskWithPartialQuad) { | 1173 TYPED_TEST(RendererPixelTest, RenderPassAndMaskWithPartialQuad) { |
1174 gfx::Rect viewport_rect(this->device_viewport_size_); | 1174 gfx::Rect viewport_rect(this->device_viewport_size_); |
1175 | 1175 |
1176 RenderPass::Id root_pass_id(1, 1); | 1176 RenderPassId root_pass_id(1, 1); |
1177 scoped_ptr<RenderPass> root_pass = | 1177 scoped_ptr<RenderPass> root_pass = |
1178 CreateTestRootRenderPass(root_pass_id, viewport_rect); | 1178 CreateTestRootRenderPass(root_pass_id, viewport_rect); |
1179 SharedQuadState* root_pass_shared_state = CreateTestSharedQuadState( | 1179 SharedQuadState* root_pass_shared_state = CreateTestSharedQuadState( |
1180 gfx::Transform(), viewport_rect, root_pass.get()); | 1180 gfx::Transform(), viewport_rect, root_pass.get()); |
1181 | 1181 |
1182 RenderPass::Id child_pass_id(2, 2); | 1182 RenderPassId child_pass_id(2, 2); |
1183 gfx::Transform transform_to_root; | 1183 gfx::Transform transform_to_root; |
1184 scoped_ptr<RenderPass> child_pass = | 1184 scoped_ptr<RenderPass> child_pass = |
1185 CreateTestRenderPass(child_pass_id, viewport_rect, transform_to_root); | 1185 CreateTestRenderPass(child_pass_id, viewport_rect, transform_to_root); |
1186 SharedQuadState* child_pass_shared_state = CreateTestSharedQuadState( | 1186 SharedQuadState* child_pass_shared_state = CreateTestSharedQuadState( |
1187 gfx::Transform(), viewport_rect, child_pass.get()); | 1187 gfx::Transform(), viewport_rect, child_pass.get()); |
1188 | 1188 |
1189 // The child render pass is just a green box. | 1189 // The child render pass is just a green box. |
1190 static const SkColor kCSSGreen = 0xff008000; | 1190 static const SkColor kCSSGreen = 0xff008000; |
1191 SolidColorDrawQuad* green = | 1191 SolidColorDrawQuad* green = |
1192 child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); | 1192 child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); |
(...skipping 77 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1270 ExactPixelComparator(true))); | 1270 ExactPixelComparator(true))); |
1271 } | 1271 } |
1272 | 1272 |
1273 template <typename RendererType> | 1273 template <typename RendererType> |
1274 class RendererPixelTestWithBackgroundFilter | 1274 class RendererPixelTestWithBackgroundFilter |
1275 : public RendererPixelTest<RendererType> { | 1275 : public RendererPixelTest<RendererType> { |
1276 protected: | 1276 protected: |
1277 void SetUpRenderPassList() { | 1277 void SetUpRenderPassList() { |
1278 gfx::Rect device_viewport_rect(this->device_viewport_size_); | 1278 gfx::Rect device_viewport_rect(this->device_viewport_size_); |
1279 | 1279 |
1280 RenderPass::Id root_id(1, 1); | 1280 RenderPassId root_id(1, 1); |
1281 scoped_ptr<RenderPass> root_pass = | 1281 scoped_ptr<RenderPass> root_pass = |
1282 CreateTestRootRenderPass(root_id, device_viewport_rect); | 1282 CreateTestRootRenderPass(root_id, device_viewport_rect); |
1283 root_pass->has_transparent_background = false; | 1283 root_pass->has_transparent_background = false; |
1284 | 1284 |
1285 gfx::Transform identity_content_to_target_transform; | 1285 gfx::Transform identity_content_to_target_transform; |
1286 | 1286 |
1287 RenderPass::Id filter_pass_id(2, 1); | 1287 RenderPassId filter_pass_id(2, 1); |
1288 gfx::Transform transform_to_root; | 1288 gfx::Transform transform_to_root; |
1289 scoped_ptr<RenderPass> filter_pass = | 1289 scoped_ptr<RenderPass> filter_pass = |
1290 CreateTestRenderPass(filter_pass_id, | 1290 CreateTestRenderPass(filter_pass_id, |
1291 filter_pass_content_rect_, | 1291 filter_pass_content_rect_, |
1292 transform_to_root); | 1292 transform_to_root); |
1293 | 1293 |
1294 // A non-visible quad in the filtering render pass. | 1294 // A non-visible quad in the filtering render pass. |
1295 { | 1295 { |
1296 SharedQuadState* shared_state = | 1296 SharedQuadState* shared_state = |
1297 CreateTestSharedQuadState(identity_content_to_target_transform, | 1297 CreateTestSharedQuadState(identity_content_to_target_transform, |
(...skipping 140 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1438 }; | 1438 }; |
1439 | 1439 |
1440 TEST_F(ExternalStencilPixelTest, StencilTestEnabled) { | 1440 TEST_F(ExternalStencilPixelTest, StencilTestEnabled) { |
1441 ClearBackgroundToGreen(); | 1441 ClearBackgroundToGreen(); |
1442 PopulateStencilBuffer(); | 1442 PopulateStencilBuffer(); |
1443 this->EnableExternalStencilTest(); | 1443 this->EnableExternalStencilTest(); |
1444 | 1444 |
1445 // Draw a blue quad that covers the entire device viewport. It should be | 1445 // Draw a blue quad that covers the entire device viewport. It should be |
1446 // clipped to the bottom left and top right corners by the external stencil. | 1446 // clipped to the bottom left and top right corners by the external stencil. |
1447 gfx::Rect rect(this->device_viewport_size_); | 1447 gfx::Rect rect(this->device_viewport_size_); |
1448 RenderPass::Id id(1, 1); | 1448 RenderPassId id(1, 1); |
1449 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); | 1449 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); |
1450 SharedQuadState* blue_shared_state = | 1450 SharedQuadState* blue_shared_state = |
1451 CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); | 1451 CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); |
1452 SolidColorDrawQuad* blue = | 1452 SolidColorDrawQuad* blue = |
1453 pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); | 1453 pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); |
1454 blue->SetNew(blue_shared_state, rect, rect, SK_ColorBLUE, false); | 1454 blue->SetNew(blue_shared_state, rect, rect, SK_ColorBLUE, false); |
1455 pass->has_transparent_background = false; | 1455 pass->has_transparent_background = false; |
1456 RenderPassList pass_list; | 1456 RenderPassList pass_list; |
1457 pass_list.push_back(pass.Pass()); | 1457 pass_list.push_back(pass.Pass()); |
1458 | 1458 |
1459 EXPECT_TRUE(this->RunPixelTest( | 1459 EXPECT_TRUE(this->RunPixelTest( |
1460 &pass_list, | 1460 &pass_list, |
1461 base::FilePath(FILE_PATH_LITERAL("four_blue_green_checkers.png")), | 1461 base::FilePath(FILE_PATH_LITERAL("four_blue_green_checkers.png")), |
1462 ExactPixelComparator(true))); | 1462 ExactPixelComparator(true))); |
1463 } | 1463 } |
1464 | 1464 |
1465 TEST_F(ExternalStencilPixelTest, StencilTestDisabled) { | 1465 TEST_F(ExternalStencilPixelTest, StencilTestDisabled) { |
1466 PopulateStencilBuffer(); | 1466 PopulateStencilBuffer(); |
1467 | 1467 |
1468 // Draw a green quad that covers the entire device viewport. The stencil | 1468 // Draw a green quad that covers the entire device viewport. The stencil |
1469 // buffer should be ignored. | 1469 // buffer should be ignored. |
1470 gfx::Rect rect(this->device_viewport_size_); | 1470 gfx::Rect rect(this->device_viewport_size_); |
1471 RenderPass::Id id(1, 1); | 1471 RenderPassId id(1, 1); |
1472 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); | 1472 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); |
1473 SharedQuadState* green_shared_state = | 1473 SharedQuadState* green_shared_state = |
1474 CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); | 1474 CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); |
1475 SolidColorDrawQuad* green = | 1475 SolidColorDrawQuad* green = |
1476 pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); | 1476 pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); |
1477 green->SetNew(green_shared_state, rect, rect, SK_ColorGREEN, false); | 1477 green->SetNew(green_shared_state, rect, rect, SK_ColorGREEN, false); |
1478 RenderPassList pass_list; | 1478 RenderPassList pass_list; |
1479 pass_list.push_back(pass.Pass()); | 1479 pass_list.push_back(pass.Pass()); |
1480 | 1480 |
1481 EXPECT_TRUE(this->RunPixelTest( | 1481 EXPECT_TRUE(this->RunPixelTest( |
1482 &pass_list, | 1482 &pass_list, |
1483 base::FilePath(FILE_PATH_LITERAL("green.png")), | 1483 base::FilePath(FILE_PATH_LITERAL("green.png")), |
1484 ExactPixelComparator(true))); | 1484 ExactPixelComparator(true))); |
1485 } | 1485 } |
1486 | 1486 |
1487 TEST_F(ExternalStencilPixelTest, RenderSurfacesIgnoreStencil) { | 1487 TEST_F(ExternalStencilPixelTest, RenderSurfacesIgnoreStencil) { |
1488 // The stencil test should apply only to the final render pass. | 1488 // The stencil test should apply only to the final render pass. |
1489 ClearBackgroundToGreen(); | 1489 ClearBackgroundToGreen(); |
1490 PopulateStencilBuffer(); | 1490 PopulateStencilBuffer(); |
1491 this->EnableExternalStencilTest(); | 1491 this->EnableExternalStencilTest(); |
1492 | 1492 |
1493 gfx::Rect viewport_rect(this->device_viewport_size_); | 1493 gfx::Rect viewport_rect(this->device_viewport_size_); |
1494 | 1494 |
1495 RenderPass::Id root_pass_id(1, 1); | 1495 RenderPassId root_pass_id(1, 1); |
1496 scoped_ptr<RenderPass> root_pass = | 1496 scoped_ptr<RenderPass> root_pass = |
1497 CreateTestRootRenderPass(root_pass_id, viewport_rect); | 1497 CreateTestRootRenderPass(root_pass_id, viewport_rect); |
1498 root_pass->has_transparent_background = false; | 1498 root_pass->has_transparent_background = false; |
1499 | 1499 |
1500 RenderPass::Id child_pass_id(2, 2); | 1500 RenderPassId child_pass_id(2, 2); |
1501 gfx::Rect pass_rect(this->device_viewport_size_); | 1501 gfx::Rect pass_rect(this->device_viewport_size_); |
1502 gfx::Transform transform_to_root; | 1502 gfx::Transform transform_to_root; |
1503 scoped_ptr<RenderPass> child_pass = | 1503 scoped_ptr<RenderPass> child_pass = |
1504 CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root); | 1504 CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root); |
1505 | 1505 |
1506 gfx::Transform content_to_target_transform; | 1506 gfx::Transform content_to_target_transform; |
1507 SharedQuadState* shared_state = CreateTestSharedQuadState( | 1507 SharedQuadState* shared_state = CreateTestSharedQuadState( |
1508 content_to_target_transform, viewport_rect, child_pass.get()); | 1508 content_to_target_transform, viewport_rect, child_pass.get()); |
1509 | 1509 |
1510 gfx::Rect blue_rect(0, | 1510 gfx::Rect blue_rect(0, |
(...skipping 19 matching lines...) Expand all Loading... |
1530 } | 1530 } |
1531 | 1531 |
1532 TEST_F(ExternalStencilPixelTest, DeviceClip) { | 1532 TEST_F(ExternalStencilPixelTest, DeviceClip) { |
1533 ClearBackgroundToGreen(); | 1533 ClearBackgroundToGreen(); |
1534 gfx::Rect clip_rect(gfx::Point(150, 150), gfx::Size(50, 50)); | 1534 gfx::Rect clip_rect(gfx::Point(150, 150), gfx::Size(50, 50)); |
1535 this->ForceDeviceClip(clip_rect); | 1535 this->ForceDeviceClip(clip_rect); |
1536 | 1536 |
1537 // Draw a blue quad that covers the entire device viewport. It should be | 1537 // Draw a blue quad that covers the entire device viewport. It should be |
1538 // clipped to the bottom right corner by the device clip. | 1538 // clipped to the bottom right corner by the device clip. |
1539 gfx::Rect rect(this->device_viewport_size_); | 1539 gfx::Rect rect(this->device_viewport_size_); |
1540 RenderPass::Id id(1, 1); | 1540 RenderPassId id(1, 1); |
1541 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); | 1541 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); |
1542 SharedQuadState* blue_shared_state = | 1542 SharedQuadState* blue_shared_state = |
1543 CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); | 1543 CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); |
1544 SolidColorDrawQuad* blue = | 1544 SolidColorDrawQuad* blue = |
1545 pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); | 1545 pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); |
1546 blue->SetNew(blue_shared_state, rect, rect, SK_ColorBLUE, false); | 1546 blue->SetNew(blue_shared_state, rect, rect, SK_ColorBLUE, false); |
1547 RenderPassList pass_list; | 1547 RenderPassList pass_list; |
1548 pass_list.push_back(pass.Pass()); | 1548 pass_list.push_back(pass.Pass()); |
1549 | 1549 |
1550 EXPECT_TRUE(this->RunPixelTest( | 1550 EXPECT_TRUE(this->RunPixelTest( |
1551 &pass_list, | 1551 &pass_list, |
1552 base::FilePath(FILE_PATH_LITERAL("green_with_blue_corner.png")), | 1552 base::FilePath(FILE_PATH_LITERAL("green_with_blue_corner.png")), |
1553 ExactPixelComparator(true))); | 1553 ExactPixelComparator(true))); |
1554 } | 1554 } |
1555 | 1555 |
1556 // Software renderer does not support anti-aliased edges. | 1556 // Software renderer does not support anti-aliased edges. |
1557 TEST_F(GLRendererPixelTest, AntiAliasing) { | 1557 TEST_F(GLRendererPixelTest, AntiAliasing) { |
1558 gfx::Rect rect(this->device_viewport_size_); | 1558 gfx::Rect rect(this->device_viewport_size_); |
1559 | 1559 |
1560 RenderPass::Id id(1, 1); | 1560 RenderPassId id(1, 1); |
1561 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); | 1561 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); |
1562 | 1562 |
1563 gfx::Transform red_content_to_target_transform; | 1563 gfx::Transform red_content_to_target_transform; |
1564 red_content_to_target_transform.Rotate(10); | 1564 red_content_to_target_transform.Rotate(10); |
1565 SharedQuadState* red_shared_state = CreateTestSharedQuadState( | 1565 SharedQuadState* red_shared_state = CreateTestSharedQuadState( |
1566 red_content_to_target_transform, rect, pass.get()); | 1566 red_content_to_target_transform, rect, pass.get()); |
1567 | 1567 |
1568 SolidColorDrawQuad* red = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); | 1568 SolidColorDrawQuad* red = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); |
1569 red->SetNew(red_shared_state, rect, rect, SK_ColorRED, false); | 1569 red->SetNew(red_shared_state, rect, rect, SK_ColorRED, false); |
1570 | 1570 |
(...skipping 21 matching lines...) Expand all Loading... |
1592 &pass_list, | 1592 &pass_list, |
1593 base::FilePath(FILE_PATH_LITERAL("anti_aliasing.png")), | 1593 base::FilePath(FILE_PATH_LITERAL("anti_aliasing.png")), |
1594 FuzzyPixelOffByOneComparator(true))); | 1594 FuzzyPixelOffByOneComparator(true))); |
1595 } | 1595 } |
1596 | 1596 |
1597 // This test tests that anti-aliasing works for axis aligned quads. | 1597 // This test tests that anti-aliasing works for axis aligned quads. |
1598 // Anti-aliasing is only supported in the gl renderer. | 1598 // Anti-aliasing is only supported in the gl renderer. |
1599 TEST_F(GLRendererPixelTest, AxisAligned) { | 1599 TEST_F(GLRendererPixelTest, AxisAligned) { |
1600 gfx::Rect rect(this->device_viewport_size_); | 1600 gfx::Rect rect(this->device_viewport_size_); |
1601 | 1601 |
1602 RenderPass::Id id(1, 1); | 1602 RenderPassId id(1, 1); |
1603 gfx::Transform transform_to_root; | 1603 gfx::Transform transform_to_root; |
1604 scoped_ptr<RenderPass> pass = | 1604 scoped_ptr<RenderPass> pass = |
1605 CreateTestRenderPass(id, rect, transform_to_root); | 1605 CreateTestRenderPass(id, rect, transform_to_root); |
1606 | 1606 |
1607 gfx::Transform red_content_to_target_transform; | 1607 gfx::Transform red_content_to_target_transform; |
1608 red_content_to_target_transform.Translate(50, 50); | 1608 red_content_to_target_transform.Translate(50, 50); |
1609 red_content_to_target_transform.Scale( | 1609 red_content_to_target_transform.Scale( |
1610 0.5f + 1.0f / (rect.width() * 2.0f), | 1610 0.5f + 1.0f / (rect.width() * 2.0f), |
1611 0.5f + 1.0f / (rect.height() * 2.0f)); | 1611 0.5f + 1.0f / (rect.height() * 2.0f)); |
1612 SharedQuadState* red_shared_state = CreateTestSharedQuadState( | 1612 SharedQuadState* red_shared_state = CreateTestSharedQuadState( |
(...skipping 27 matching lines...) Expand all Loading... |
1640 &pass_list, | 1640 &pass_list, |
1641 base::FilePath(FILE_PATH_LITERAL("axis_aligned.png")), | 1641 base::FilePath(FILE_PATH_LITERAL("axis_aligned.png")), |
1642 ExactPixelComparator(true))); | 1642 ExactPixelComparator(true))); |
1643 } | 1643 } |
1644 | 1644 |
1645 // This test tests that forcing anti-aliasing off works as expected. | 1645 // This test tests that forcing anti-aliasing off works as expected. |
1646 // Anti-aliasing is only supported in the gl renderer. | 1646 // Anti-aliasing is only supported in the gl renderer. |
1647 TEST_F(GLRendererPixelTest, ForceAntiAliasingOff) { | 1647 TEST_F(GLRendererPixelTest, ForceAntiAliasingOff) { |
1648 gfx::Rect rect(this->device_viewport_size_); | 1648 gfx::Rect rect(this->device_viewport_size_); |
1649 | 1649 |
1650 RenderPass::Id id(1, 1); | 1650 RenderPassId id(1, 1); |
1651 gfx::Transform transform_to_root; | 1651 gfx::Transform transform_to_root; |
1652 scoped_ptr<RenderPass> pass = | 1652 scoped_ptr<RenderPass> pass = |
1653 CreateTestRenderPass(id, rect, transform_to_root); | 1653 CreateTestRenderPass(id, rect, transform_to_root); |
1654 | 1654 |
1655 gfx::Transform hole_content_to_target_transform; | 1655 gfx::Transform hole_content_to_target_transform; |
1656 hole_content_to_target_transform.Translate(50, 50); | 1656 hole_content_to_target_transform.Translate(50, 50); |
1657 hole_content_to_target_transform.Scale( | 1657 hole_content_to_target_transform.Scale( |
1658 0.5f + 1.0f / (rect.width() * 2.0f), | 1658 0.5f + 1.0f / (rect.width() * 2.0f), |
1659 0.5f + 1.0f / (rect.height() * 2.0f)); | 1659 0.5f + 1.0f / (rect.height() * 2.0f)); |
1660 SharedQuadState* hole_shared_state = CreateTestSharedQuadState( | 1660 SharedQuadState* hole_shared_state = CreateTestSharedQuadState( |
(...skipping 18 matching lines...) Expand all Loading... |
1679 EXPECT_TRUE(this->RunPixelTest( | 1679 EXPECT_TRUE(this->RunPixelTest( |
1680 &pass_list, | 1680 &pass_list, |
1681 base::FilePath(FILE_PATH_LITERAL("force_anti_aliasing_off.png")), | 1681 base::FilePath(FILE_PATH_LITERAL("force_anti_aliasing_off.png")), |
1682 ExactPixelComparator(false))); | 1682 ExactPixelComparator(false))); |
1683 } | 1683 } |
1684 | 1684 |
1685 TEST_F(GLRendererPixelTest, AntiAliasingPerspective) { | 1685 TEST_F(GLRendererPixelTest, AntiAliasingPerspective) { |
1686 gfx::Rect rect(this->device_viewport_size_); | 1686 gfx::Rect rect(this->device_viewport_size_); |
1687 | 1687 |
1688 scoped_ptr<RenderPass> pass = | 1688 scoped_ptr<RenderPass> pass = |
1689 CreateTestRootRenderPass(RenderPass::Id(1, 1), rect); | 1689 CreateTestRootRenderPass(RenderPassId(1, 1), rect); |
1690 | 1690 |
1691 gfx::Rect red_rect(0, 0, 180, 500); | 1691 gfx::Rect red_rect(0, 0, 180, 500); |
1692 gfx::Transform red_content_to_target_transform( | 1692 gfx::Transform red_content_to_target_transform( |
1693 1.0f, 2.4520f, 10.6206f, 19.0f, | 1693 1.0f, 2.4520f, 10.6206f, 19.0f, |
1694 0.0f, 0.3528f, 5.9737f, 9.5f, | 1694 0.0f, 0.3528f, 5.9737f, 9.5f, |
1695 0.0f, -0.2250f, -0.9744f, 0.0f, | 1695 0.0f, -0.2250f, -0.9744f, 0.0f, |
1696 0.0f, 0.0225f, 0.0974f, 1.0f); | 1696 0.0f, 0.0225f, 0.0974f, 1.0f); |
1697 SharedQuadState* red_shared_state = CreateTestSharedQuadState( | 1697 SharedQuadState* red_shared_state = CreateTestSharedQuadState( |
1698 red_content_to_target_transform, red_rect, pass.get()); | 1698 red_content_to_target_transform, red_rect, pass.get()); |
1699 SolidColorDrawQuad* red = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); | 1699 SolidColorDrawQuad* red = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); |
(...skipping 21 matching lines...) Expand all Loading... |
1721 base::FilePath(FILE_PATH_LITERAL("anti_aliasing_perspective.png")), | 1721 base::FilePath(FILE_PATH_LITERAL("anti_aliasing_perspective.png")), |
1722 FuzzyPixelOffByOneComparator(true))); | 1722 FuzzyPixelOffByOneComparator(true))); |
1723 } | 1723 } |
1724 | 1724 |
1725 TYPED_TEST(RendererPixelTest, PictureDrawQuadIdentityScale) { | 1725 TYPED_TEST(RendererPixelTest, PictureDrawQuadIdentityScale) { |
1726 gfx::Size pile_tile_size(1000, 1000); | 1726 gfx::Size pile_tile_size(1000, 1000); |
1727 gfx::Rect viewport(this->device_viewport_size_); | 1727 gfx::Rect viewport(this->device_viewport_size_); |
1728 // TODO(enne): the renderer should figure this out on its own. | 1728 // TODO(enne): the renderer should figure this out on its own. |
1729 ResourceFormat texture_format = RGBA_8888; | 1729 ResourceFormat texture_format = RGBA_8888; |
1730 | 1730 |
1731 RenderPass::Id id(1, 1); | 1731 RenderPassId id(1, 1); |
1732 gfx::Transform transform_to_root; | 1732 gfx::Transform transform_to_root; |
1733 scoped_ptr<RenderPass> pass = | 1733 scoped_ptr<RenderPass> pass = |
1734 CreateTestRenderPass(id, viewport, transform_to_root); | 1734 CreateTestRenderPass(id, viewport, transform_to_root); |
1735 | 1735 |
1736 // One clipped blue quad in the lower right corner. Outside the clip | 1736 // One clipped blue quad in the lower right corner. Outside the clip |
1737 // is red, which should not appear. | 1737 // is red, which should not appear. |
1738 gfx::Rect blue_rect(gfx::Size(100, 100)); | 1738 gfx::Rect blue_rect(gfx::Size(100, 100)); |
1739 gfx::Rect blue_clip_rect(gfx::Point(50, 50), gfx::Size(50, 50)); | 1739 gfx::Rect blue_clip_rect(gfx::Point(50, 50), gfx::Size(50, 50)); |
1740 scoped_refptr<FakePicturePileImpl> blue_pile = | 1740 scoped_refptr<FakePicturePileImpl> blue_pile = |
1741 FakePicturePileImpl::CreateFilledPile(pile_tile_size, blue_rect.size()); | 1741 FakePicturePileImpl::CreateFilledPile(pile_tile_size, blue_rect.size()); |
(...skipping 62 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1804 base::FilePath(FILE_PATH_LITERAL("green_with_blue_corner.png")), | 1804 base::FilePath(FILE_PATH_LITERAL("green_with_blue_corner.png")), |
1805 ExactPixelComparator(true))); | 1805 ExactPixelComparator(true))); |
1806 } | 1806 } |
1807 | 1807 |
1808 // Not WithSkiaGPUBackend since that path currently requires tiles for opacity. | 1808 // Not WithSkiaGPUBackend since that path currently requires tiles for opacity. |
1809 TYPED_TEST(RendererPixelTest, PictureDrawQuadOpacity) { | 1809 TYPED_TEST(RendererPixelTest, PictureDrawQuadOpacity) { |
1810 gfx::Size pile_tile_size(1000, 1000); | 1810 gfx::Size pile_tile_size(1000, 1000); |
1811 gfx::Rect viewport(this->device_viewport_size_); | 1811 gfx::Rect viewport(this->device_viewport_size_); |
1812 ResourceFormat texture_format = RGBA_8888; | 1812 ResourceFormat texture_format = RGBA_8888; |
1813 | 1813 |
1814 RenderPass::Id id(1, 1); | 1814 RenderPassId id(1, 1); |
1815 gfx::Transform transform_to_root; | 1815 gfx::Transform transform_to_root; |
1816 scoped_ptr<RenderPass> pass = | 1816 scoped_ptr<RenderPass> pass = |
1817 CreateTestRenderPass(id, viewport, transform_to_root); | 1817 CreateTestRenderPass(id, viewport, transform_to_root); |
1818 | 1818 |
1819 // One viewport-filling 0.5-opacity green quad. | 1819 // One viewport-filling 0.5-opacity green quad. |
1820 scoped_refptr<FakePicturePileImpl> green_pile = | 1820 scoped_refptr<FakePicturePileImpl> green_pile = |
1821 FakePicturePileImpl::CreateFilledPile(pile_tile_size, viewport.size()); | 1821 FakePicturePileImpl::CreateFilledPile(pile_tile_size, viewport.size()); |
1822 SkPaint green_paint; | 1822 SkPaint green_paint; |
1823 green_paint.setColor(SK_ColorGREEN); | 1823 green_paint.setColor(SK_ColorGREEN); |
1824 green_pile->add_draw_rect_with_paint(viewport, green_paint); | 1824 green_pile->add_draw_rect_with_paint(viewport, green_paint); |
(...skipping 70 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1895 TYPED_TEST(RendererPixelTest, PictureDrawQuadDisableImageFiltering) { | 1895 TYPED_TEST(RendererPixelTest, PictureDrawQuadDisableImageFiltering) { |
1896 // We only care about this in software mode since bilinear filtering is | 1896 // We only care about this in software mode since bilinear filtering is |
1897 // cheap in hardware. | 1897 // cheap in hardware. |
1898 if (!IsSoftwareRenderer<TypeParam>()) | 1898 if (!IsSoftwareRenderer<TypeParam>()) |
1899 return; | 1899 return; |
1900 | 1900 |
1901 gfx::Size pile_tile_size(1000, 1000); | 1901 gfx::Size pile_tile_size(1000, 1000); |
1902 gfx::Rect viewport(this->device_viewport_size_); | 1902 gfx::Rect viewport(this->device_viewport_size_); |
1903 ResourceFormat texture_format = RGBA_8888; | 1903 ResourceFormat texture_format = RGBA_8888; |
1904 | 1904 |
1905 RenderPass::Id id(1, 1); | 1905 RenderPassId id(1, 1); |
1906 gfx::Transform transform_to_root; | 1906 gfx::Transform transform_to_root; |
1907 scoped_ptr<RenderPass> pass = | 1907 scoped_ptr<RenderPass> pass = |
1908 CreateTestRenderPass(id, viewport, transform_to_root); | 1908 CreateTestRenderPass(id, viewport, transform_to_root); |
1909 | 1909 |
1910 SkBitmap bitmap; | 1910 SkBitmap bitmap; |
1911 bitmap.allocN32Pixels(2, 2); | 1911 bitmap.allocN32Pixels(2, 2); |
1912 { | 1912 { |
1913 SkAutoLockPixels lock(bitmap); | 1913 SkAutoLockPixels lock(bitmap); |
1914 SkCanvas canvas(bitmap); | 1914 SkCanvas canvas(bitmap); |
1915 canvas.drawPoint(0, 0, SK_ColorGREEN); | 1915 canvas.drawPoint(0, 0, SK_ColorGREEN); |
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1951 base::FilePath(FILE_PATH_LITERAL("four_blue_green_checkers.png")), | 1951 base::FilePath(FILE_PATH_LITERAL("four_blue_green_checkers.png")), |
1952 ExactPixelComparator(true))); | 1952 ExactPixelComparator(true))); |
1953 } | 1953 } |
1954 | 1954 |
1955 TYPED_TEST(RendererPixelTest, PictureDrawQuadNonIdentityScale) { | 1955 TYPED_TEST(RendererPixelTest, PictureDrawQuadNonIdentityScale) { |
1956 gfx::Size pile_tile_size(1000, 1000); | 1956 gfx::Size pile_tile_size(1000, 1000); |
1957 gfx::Rect viewport(this->device_viewport_size_); | 1957 gfx::Rect viewport(this->device_viewport_size_); |
1958 // TODO(enne): the renderer should figure this out on its own. | 1958 // TODO(enne): the renderer should figure this out on its own. |
1959 ResourceFormat texture_format = RGBA_8888; | 1959 ResourceFormat texture_format = RGBA_8888; |
1960 | 1960 |
1961 RenderPass::Id id(1, 1); | 1961 RenderPassId id(1, 1); |
1962 gfx::Transform transform_to_root; | 1962 gfx::Transform transform_to_root; |
1963 scoped_ptr<RenderPass> pass = | 1963 scoped_ptr<RenderPass> pass = |
1964 CreateTestRenderPass(id, viewport, transform_to_root); | 1964 CreateTestRenderPass(id, viewport, transform_to_root); |
1965 | 1965 |
1966 // As scaling up the blue checkerboards will cause sampling on the GPU, | 1966 // As scaling up the blue checkerboards will cause sampling on the GPU, |
1967 // a few extra "cleanup rects" need to be added to clobber the blending | 1967 // a few extra "cleanup rects" need to be added to clobber the blending |
1968 // to make the output image more clean. This will also test subrects | 1968 // to make the output image more clean. This will also test subrects |
1969 // of the layer. | 1969 // of the layer. |
1970 gfx::Transform green_content_to_target_transform; | 1970 gfx::Transform green_content_to_target_transform; |
1971 gfx::Rect green_rect1(gfx::Point(80, 0), gfx::Size(20, 100)); | 1971 gfx::Rect green_rect1(gfx::Point(80, 0), gfx::Size(20, 100)); |
(...skipping 134 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2106 &pass_list, | 2106 &pass_list, |
2107 base::FilePath(FILE_PATH_LITERAL("four_blue_green_checkers.png")), | 2107 base::FilePath(FILE_PATH_LITERAL("four_blue_green_checkers.png")), |
2108 ExactPixelComparator(true))); | 2108 ExactPixelComparator(true))); |
2109 } | 2109 } |
2110 | 2110 |
2111 TEST_F(GLRendererPixelTest, PictureDrawQuadTexture4444) { | 2111 TEST_F(GLRendererPixelTest, PictureDrawQuadTexture4444) { |
2112 gfx::Size pile_tile_size(1000, 1000); | 2112 gfx::Size pile_tile_size(1000, 1000); |
2113 gfx::Rect viewport(this->device_viewport_size_); | 2113 gfx::Rect viewport(this->device_viewport_size_); |
2114 ResourceFormat texture_format = RGBA_4444; | 2114 ResourceFormat texture_format = RGBA_4444; |
2115 | 2115 |
2116 RenderPass::Id id(1, 1); | 2116 RenderPassId id(1, 1); |
2117 gfx::Transform transform_to_root; | 2117 gfx::Transform transform_to_root; |
2118 scoped_ptr<RenderPass> pass = | 2118 scoped_ptr<RenderPass> pass = |
2119 CreateTestRenderPass(id, viewport, transform_to_root); | 2119 CreateTestRenderPass(id, viewport, transform_to_root); |
2120 | 2120 |
2121 // One viewport-filling blue quad | 2121 // One viewport-filling blue quad |
2122 scoped_refptr<FakePicturePileImpl> blue_pile = | 2122 scoped_refptr<FakePicturePileImpl> blue_pile = |
2123 FakePicturePileImpl::CreateFilledPile(pile_tile_size, viewport.size()); | 2123 FakePicturePileImpl::CreateFilledPile(pile_tile_size, viewport.size()); |
2124 SkPaint blue_paint; | 2124 SkPaint blue_paint; |
2125 blue_paint.setColor(SK_ColorBLUE); | 2125 blue_paint.setColor(SK_ColorBLUE); |
2126 blue_pile->add_draw_rect_with_paint(viewport, blue_paint); | 2126 blue_pile->add_draw_rect_with_paint(viewport, blue_paint); |
(...skipping 19 matching lines...) Expand all Loading... |
2146 pass_list.push_back(pass.Pass()); | 2146 pass_list.push_back(pass.Pass()); |
2147 | 2147 |
2148 EXPECT_TRUE(this->RunPixelTest(&pass_list, | 2148 EXPECT_TRUE(this->RunPixelTest(&pass_list, |
2149 base::FilePath(FILE_PATH_LITERAL("blue.png")), | 2149 base::FilePath(FILE_PATH_LITERAL("blue.png")), |
2150 ExactPixelComparator(true))); | 2150 ExactPixelComparator(true))); |
2151 } | 2151 } |
2152 | 2152 |
2153 TYPED_TEST(RendererPixelTest, WrapModeRepeat) { | 2153 TYPED_TEST(RendererPixelTest, WrapModeRepeat) { |
2154 gfx::Rect rect(this->device_viewport_size_); | 2154 gfx::Rect rect(this->device_viewport_size_); |
2155 | 2155 |
2156 RenderPass::Id id(1, 1); | 2156 RenderPassId id(1, 1); |
2157 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); | 2157 scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); |
2158 | 2158 |
2159 SharedQuadState* shared_state = | 2159 SharedQuadState* shared_state = |
2160 CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); | 2160 CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); |
2161 | 2161 |
2162 gfx::Rect texture_rect(4, 4); | 2162 gfx::Rect texture_rect(4, 4); |
2163 SkPMColor colors[4] = { | 2163 SkPMColor colors[4] = { |
2164 SkPreMultiplyColor(SkColorSetARGB(255, 0, 255, 0)), | 2164 SkPreMultiplyColor(SkColorSetARGB(255, 0, 255, 0)), |
2165 SkPreMultiplyColor(SkColorSetARGB(255, 0, 128, 0)), | 2165 SkPreMultiplyColor(SkColorSetARGB(255, 0, 128, 0)), |
2166 SkPreMultiplyColor(SkColorSetARGB(255, 0, 64, 0)), | 2166 SkPreMultiplyColor(SkColorSetARGB(255, 0, 64, 0)), |
(...skipping 42 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2209 EXPECT_TRUE(this->RunPixelTest( | 2209 EXPECT_TRUE(this->RunPixelTest( |
2210 &pass_list, | 2210 &pass_list, |
2211 base::FilePath(FILE_PATH_LITERAL("wrap_mode_repeat.png")), | 2211 base::FilePath(FILE_PATH_LITERAL("wrap_mode_repeat.png")), |
2212 FuzzyPixelOffByOneComparator(true))); | 2212 FuzzyPixelOffByOneComparator(true))); |
2213 } | 2213 } |
2214 | 2214 |
2215 #endif // !defined(OS_ANDROID) | 2215 #endif // !defined(OS_ANDROID) |
2216 | 2216 |
2217 } // namespace | 2217 } // namespace |
2218 } // namespace cc | 2218 } // namespace cc |
OLD | NEW |