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