Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(10)

Side by Side Diff: cc/output/renderer_pixeltest.cc

Issue 368403003: Use RenderPass to create DrawQuad in unittests (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@layerrawptrDQ
Patch Set: actually fix error this time Created 6 years, 5 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698