OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 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 "cc/base/scoped_ptr_vector.h" | 5 #include "cc/base/scoped_ptr_vector.h" |
6 #include "cc/output/gl_renderer.h" | 6 #include "cc/output/gl_renderer.h" |
7 #include "cc/output/output_surface.h" | 7 #include "cc/output/output_surface.h" |
8 #include "cc/output/output_surface_client.h" | 8 #include "cc/output/output_surface_client.h" |
9 #include "cc/output/overlay_candidate_validator.h" | 9 #include "cc/output/overlay_candidate_validator.h" |
10 #include "cc/output/overlay_processor.h" | 10 #include "cc/output/overlay_processor.h" |
(...skipping 111 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
122 TextureMailbox mailbox = | 122 TextureMailbox mailbox = |
123 TextureMailbox(gpu::Mailbox::Generate(), GL_TEXTURE_2D, sync_point); | 123 TextureMailbox(gpu::Mailbox::Generate(), GL_TEXTURE_2D, sync_point); |
124 mailbox.set_allow_overlay(true); | 124 mailbox.set_allow_overlay(true); |
125 scoped_ptr<SingleReleaseCallback> release_callback = | 125 scoped_ptr<SingleReleaseCallback> release_callback = |
126 SingleReleaseCallback::Create(base::Bind(&MailboxReleased)); | 126 SingleReleaseCallback::Create(base::Bind(&MailboxReleased)); |
127 | 127 |
128 return resource_provider->CreateResourceFromTextureMailbox( | 128 return resource_provider->CreateResourceFromTextureMailbox( |
129 mailbox, release_callback.Pass()); | 129 mailbox, release_callback.Pass()); |
130 } | 130 } |
131 | 131 |
132 scoped_ptr<TextureDrawQuad> CreateCandidateQuad( | 132 TextureDrawQuad* CreateCandidateQuad(ResourceProvider* resource_provider, |
133 ResourceProvider* resource_provider, | 133 const SharedQuadState* shared_quad_state, |
134 const SharedQuadState* shared_quad_state) { | 134 RenderPass* render_pass) { |
135 ResourceProvider::ResourceId resource_id = CreateResource(resource_provider); | 135 ResourceProvider::ResourceId resource_id = CreateResource(resource_provider); |
136 bool premultiplied_alpha = false; | 136 bool premultiplied_alpha = false; |
137 bool flipped = false; | 137 bool flipped = false; |
138 float vertex_opacity[4] = {1.0f, 1.0f, 1.0f, 1.0f}; | 138 float vertex_opacity[4] = {1.0f, 1.0f, 1.0f, 1.0f}; |
139 | 139 |
140 scoped_ptr<TextureDrawQuad> overlay_quad = TextureDrawQuad::Create(); | 140 TextureDrawQuad* overlay_quad = |
| 141 render_pass->CreateAndAppendDrawQuad<TextureDrawQuad>(); |
141 overlay_quad->SetNew(shared_quad_state, | 142 overlay_quad->SetNew(shared_quad_state, |
142 kOverlayRect, | 143 kOverlayRect, |
143 kOverlayRect, | 144 kOverlayRect, |
144 kOverlayRect, | 145 kOverlayRect, |
145 resource_id, | 146 resource_id, |
146 premultiplied_alpha, | 147 premultiplied_alpha, |
147 kUVTopLeft, | 148 kUVTopLeft, |
148 kUVBottomRight, | 149 kUVBottomRight, |
149 SK_ColorTRANSPARENT, | 150 SK_ColorTRANSPARENT, |
150 vertex_opacity, | 151 vertex_opacity, |
151 flipped); | 152 flipped); |
152 | 153 |
153 return overlay_quad.Pass(); | 154 return overlay_quad; |
154 } | 155 } |
155 | 156 |
156 scoped_ptr<DrawQuad> CreateCheckeredQuad( | 157 void CreateCheckeredQuad(ResourceProvider* resource_provider, |
157 ResourceProvider* resource_provider, | 158 const SharedQuadState* shared_quad_state, |
158 const SharedQuadState* shared_quad_state) { | 159 RenderPass* render_pass) { |
159 scoped_ptr<CheckerboardDrawQuad> checkerboard_quad = | 160 CheckerboardDrawQuad* checkerboard_quad = |
160 CheckerboardDrawQuad::Create(); | 161 render_pass->CreateAndAppendDrawQuad<CheckerboardDrawQuad>(); |
161 checkerboard_quad->SetNew( | 162 checkerboard_quad->SetNew( |
162 shared_quad_state, kOverlayRect, kOverlayRect, SkColor()); | 163 shared_quad_state, kOverlayRect, kOverlayRect, SkColor()); |
163 return checkerboard_quad.PassAs<DrawQuad>(); | |
164 } | 164 } |
165 | 165 |
166 static void CompareRenderPassLists(const RenderPassList& expected_list, | 166 static void CompareRenderPassLists(const RenderPassList& expected_list, |
167 const RenderPassList& actual_list) { | 167 const RenderPassList& actual_list) { |
168 EXPECT_EQ(expected_list.size(), actual_list.size()); | 168 EXPECT_EQ(expected_list.size(), actual_list.size()); |
169 for (size_t i = 0; i < actual_list.size(); ++i) { | 169 for (size_t i = 0; i < actual_list.size(); ++i) { |
170 RenderPass* expected = expected_list[i]; | 170 RenderPass* expected = expected_list[i]; |
171 RenderPass* actual = actual_list[i]; | 171 RenderPass* actual = actual_list[i]; |
172 | 172 |
173 EXPECT_EQ(expected->id, actual->id); | 173 EXPECT_EQ(expected->id, actual->id); |
(...skipping 68 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
242 scoped_refptr<TestContextProvider> provider_; | 242 scoped_refptr<TestContextProvider> provider_; |
243 scoped_ptr<OverlayOutputSurface> output_surface_; | 243 scoped_ptr<OverlayOutputSurface> output_surface_; |
244 FakeOutputSurfaceClient client_; | 244 FakeOutputSurfaceClient client_; |
245 scoped_ptr<SharedBitmapManager> shared_bitmap_manager_; | 245 scoped_ptr<SharedBitmapManager> shared_bitmap_manager_; |
246 scoped_ptr<ResourceProvider> resource_provider_; | 246 scoped_ptr<ResourceProvider> resource_provider_; |
247 scoped_ptr<SingleOverlayProcessor> overlay_processor_; | 247 scoped_ptr<SingleOverlayProcessor> overlay_processor_; |
248 }; | 248 }; |
249 | 249 |
250 TEST_F(SingleOverlayOnTopTest, SuccessfullOverlay) { | 250 TEST_F(SingleOverlayOnTopTest, SuccessfullOverlay) { |
251 scoped_ptr<RenderPass> pass = CreateRenderPass(); | 251 scoped_ptr<RenderPass> pass = CreateRenderPass(); |
252 scoped_ptr<TextureDrawQuad> original_quad = CreateCandidateQuad( | 252 TextureDrawQuad* original_quad = |
253 resource_provider_.get(), pass->shared_quad_state_list.back()); | 253 CreateCandidateQuad(resource_provider_.get(), |
| 254 pass->shared_quad_state_list.back(), |
| 255 pass.get()); |
| 256 unsigned original_resource_id = original_quad->resource_id; |
254 | 257 |
255 pass->quad_list.push_back( | |
256 original_quad->Copy(pass->shared_quad_state_list.back())); | |
257 // Add something behind it. | 258 // Add something behind it. |
258 pass->quad_list.push_back(CreateCheckeredQuad( | 259 CreateCheckeredQuad(resource_provider_.get(), |
259 resource_provider_.get(), pass->shared_quad_state_list.back())); | 260 pass->shared_quad_state_list.back(), |
260 pass->quad_list.push_back(CreateCheckeredQuad( | 261 pass.get()); |
261 resource_provider_.get(), pass->shared_quad_state_list.back())); | 262 CreateCheckeredQuad(resource_provider_.get(), |
| 263 pass->shared_quad_state_list.back(), |
| 264 pass.get()); |
262 | 265 |
263 RenderPassList pass_list; | 266 RenderPassList pass_list; |
264 pass_list.push_back(pass.Pass()); | 267 pass_list.push_back(pass.Pass()); |
265 | 268 |
266 // Check for potential candidates. | 269 // Check for potential candidates. |
267 OverlayCandidateList candidate_list; | 270 OverlayCandidateList candidate_list; |
268 overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list); | 271 overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list); |
269 | 272 |
270 ASSERT_EQ(1U, pass_list.size()); | 273 ASSERT_EQ(1U, pass_list.size()); |
271 ASSERT_EQ(2U, candidate_list.size()); | 274 ASSERT_EQ(2U, candidate_list.size()); |
272 | 275 |
273 RenderPass* main_pass = pass_list.back(); | 276 RenderPass* main_pass = pass_list.back(); |
274 // Check that the quad is gone. | 277 // Check that the quad is gone. |
275 EXPECT_EQ(2U, main_pass->quad_list.size()); | 278 EXPECT_EQ(2U, main_pass->quad_list.size()); |
276 const QuadList& quad_list = main_pass->quad_list; | 279 const QuadList& quad_list = main_pass->quad_list; |
277 for (QuadList::ConstBackToFrontIterator it = quad_list.BackToFrontBegin(); | 280 for (QuadList::ConstBackToFrontIterator it = quad_list.BackToFrontBegin(); |
278 it != quad_list.BackToFrontEnd(); | 281 it != quad_list.BackToFrontEnd(); |
279 ++it) { | 282 ++it) { |
280 EXPECT_NE(DrawQuad::TEXTURE_CONTENT, (*it)->material); | 283 EXPECT_NE(DrawQuad::TEXTURE_CONTENT, (*it)->material); |
281 } | 284 } |
282 | 285 |
283 // Check that the right resource id got extracted. | 286 // Check that the right resource id got extracted. |
284 EXPECT_EQ(original_quad->resource_id, candidate_list.back().resource_id); | 287 EXPECT_EQ(original_resource_id, candidate_list.back().resource_id); |
285 } | 288 } |
286 | 289 |
287 TEST_F(SingleOverlayOnTopTest, NoCandidates) { | 290 TEST_F(SingleOverlayOnTopTest, NoCandidates) { |
288 scoped_ptr<RenderPass> pass = CreateRenderPass(); | 291 scoped_ptr<RenderPass> pass = CreateRenderPass(); |
289 pass->quad_list.push_back(CreateCheckeredQuad( | 292 CreateCheckeredQuad(resource_provider_.get(), |
290 resource_provider_.get(), pass->shared_quad_state_list.back())); | 293 pass->shared_quad_state_list.back(), |
291 pass->quad_list.push_back(CreateCheckeredQuad( | 294 pass.get()); |
292 resource_provider_.get(), pass->shared_quad_state_list.back())); | 295 CreateCheckeredQuad(resource_provider_.get(), |
| 296 pass->shared_quad_state_list.back(), |
| 297 pass.get()); |
293 | 298 |
294 RenderPassList pass_list; | 299 RenderPassList pass_list; |
295 pass_list.push_back(pass.Pass()); | 300 pass_list.push_back(pass.Pass()); |
296 | 301 |
297 RenderPassList original_pass_list; | 302 RenderPassList original_pass_list; |
298 RenderPass::CopyAll(pass_list, &original_pass_list); | 303 RenderPass::CopyAll(pass_list, &original_pass_list); |
299 | 304 |
300 OverlayCandidateList candidate_list; | 305 OverlayCandidateList candidate_list; |
301 overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list); | 306 overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list); |
302 EXPECT_EQ(0U, candidate_list.size()); | 307 EXPECT_EQ(0U, candidate_list.size()); |
303 // There should be nothing new here. | 308 // There should be nothing new here. |
304 CompareRenderPassLists(pass_list, original_pass_list); | 309 CompareRenderPassLists(pass_list, original_pass_list); |
305 } | 310 } |
306 | 311 |
307 TEST_F(SingleOverlayOnTopTest, OccludedCandidates) { | 312 TEST_F(SingleOverlayOnTopTest, OccludedCandidates) { |
308 scoped_ptr<RenderPass> pass = CreateRenderPass(); | 313 scoped_ptr<RenderPass> pass = CreateRenderPass(); |
309 pass->quad_list.push_back(CreateCheckeredQuad( | 314 CreateCheckeredQuad(resource_provider_.get(), |
310 resource_provider_.get(), pass->shared_quad_state_list.back())); | 315 pass->shared_quad_state_list.back(), |
311 pass->quad_list.push_back(CreateCheckeredQuad( | 316 pass.get()); |
312 resource_provider_.get(), pass->shared_quad_state_list.back())); | 317 CreateCheckeredQuad(resource_provider_.get(), |
| 318 pass->shared_quad_state_list.back(), |
| 319 pass.get()); |
313 | 320 |
314 pass->quad_list.push_back( | 321 CreateCandidateQuad(resource_provider_.get(), |
315 CreateCandidateQuad(resource_provider_.get(), | 322 pass->shared_quad_state_list.back(), |
316 pass->shared_quad_state_list.back()) | 323 pass.get()); |
317 .PassAs<DrawQuad>()); | |
318 | 324 |
319 RenderPassList pass_list; | 325 RenderPassList pass_list; |
320 pass_list.push_back(pass.Pass()); | 326 pass_list.push_back(pass.Pass()); |
321 | 327 |
322 RenderPassList original_pass_list; | 328 RenderPassList original_pass_list; |
323 RenderPass::CopyAll(pass_list, &original_pass_list); | 329 RenderPass::CopyAll(pass_list, &original_pass_list); |
324 | 330 |
325 OverlayCandidateList candidate_list; | 331 OverlayCandidateList candidate_list; |
326 overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list); | 332 overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list); |
327 EXPECT_EQ(0U, candidate_list.size()); | 333 EXPECT_EQ(0U, candidate_list.size()); |
328 // There should be nothing new here. | 334 // There should be nothing new here. |
329 CompareRenderPassLists(pass_list, original_pass_list); | 335 CompareRenderPassLists(pass_list, original_pass_list); |
330 } | 336 } |
331 | 337 |
332 // Test with multiple render passes. | 338 // Test with multiple render passes. |
333 TEST_F(SingleOverlayOnTopTest, MultipleRenderPasses) { | 339 TEST_F(SingleOverlayOnTopTest, MultipleRenderPasses) { |
334 RenderPassList pass_list; | 340 RenderPassList pass_list; |
335 pass_list.push_back(CreateRenderPass()); | 341 pass_list.push_back(CreateRenderPass()); |
336 | 342 |
337 scoped_ptr<RenderPass> pass = CreateRenderPass(); | 343 scoped_ptr<RenderPass> pass = CreateRenderPass(); |
338 scoped_ptr<TextureDrawQuad> original_quad = CreateCandidateQuad( | 344 CreateCandidateQuad(resource_provider_.get(), |
339 resource_provider_.get(), pass->shared_quad_state_list.back()); | 345 pass->shared_quad_state_list.back(), |
| 346 pass.get()); |
340 | 347 |
341 pass->quad_list.push_back( | |
342 original_quad->Copy(pass->shared_quad_state_list.back())); | |
343 // Add something behind it. | 348 // Add something behind it. |
344 pass->quad_list.push_back(CreateCheckeredQuad( | 349 CreateCheckeredQuad(resource_provider_.get(), |
345 resource_provider_.get(), pass->shared_quad_state_list.back())); | 350 pass->shared_quad_state_list.back(), |
346 pass->quad_list.push_back(CreateCheckeredQuad( | 351 pass.get()); |
347 resource_provider_.get(), pass->shared_quad_state_list.back())); | 352 CreateCheckeredQuad(resource_provider_.get(), |
| 353 pass->shared_quad_state_list.back(), |
| 354 pass.get()); |
348 | 355 |
349 pass_list.push_back(pass.Pass()); | 356 pass_list.push_back(pass.Pass()); |
350 | 357 |
351 RenderPassList original_pass_list; | 358 RenderPassList original_pass_list; |
352 RenderPass::CopyAll(pass_list, &original_pass_list); | 359 RenderPass::CopyAll(pass_list, &original_pass_list); |
353 | 360 |
354 // Check for potential candidates. | 361 // Check for potential candidates. |
355 OverlayCandidateList candidate_list; | 362 OverlayCandidateList candidate_list; |
356 overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list); | 363 overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list); |
357 EXPECT_EQ(2U, candidate_list.size()); | 364 EXPECT_EQ(2U, candidate_list.size()); |
358 | 365 |
359 // This should be the same. | 366 // This should be the same. |
360 ASSERT_EQ(2U, pass_list.size()); | 367 ASSERT_EQ(2U, pass_list.size()); |
361 } | 368 } |
362 | 369 |
363 TEST_F(SingleOverlayOnTopTest, RejectPremultipliedAlpha) { | 370 TEST_F(SingleOverlayOnTopTest, RejectPremultipliedAlpha) { |
364 scoped_ptr<RenderPass> pass = CreateRenderPass(); | 371 scoped_ptr<RenderPass> pass = CreateRenderPass(); |
365 scoped_ptr<TextureDrawQuad> quad = CreateCandidateQuad( | 372 TextureDrawQuad* quad = |
366 resource_provider_.get(), pass->shared_quad_state_list.back()); | 373 CreateCandidateQuad(resource_provider_.get(), |
| 374 pass->shared_quad_state_list.back(), |
| 375 pass.get()); |
367 quad->premultiplied_alpha = true; | 376 quad->premultiplied_alpha = true; |
368 | 377 |
369 pass->quad_list.push_back(quad.PassAs<DrawQuad>()); | |
370 RenderPassList pass_list; | 378 RenderPassList pass_list; |
371 pass_list.push_back(pass.Pass()); | 379 pass_list.push_back(pass.Pass()); |
372 OverlayCandidateList candidate_list; | 380 OverlayCandidateList candidate_list; |
373 overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list); | 381 overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list); |
374 EXPECT_EQ(1U, pass_list.size()); | 382 EXPECT_EQ(1U, pass_list.size()); |
375 EXPECT_EQ(0U, candidate_list.size()); | 383 EXPECT_EQ(0U, candidate_list.size()); |
376 } | 384 } |
377 | 385 |
378 TEST_F(SingleOverlayOnTopTest, RejectBlending) { | 386 TEST_F(SingleOverlayOnTopTest, RejectBlending) { |
379 scoped_ptr<RenderPass> pass = CreateRenderPass(); | 387 scoped_ptr<RenderPass> pass = CreateRenderPass(); |
380 scoped_ptr<TextureDrawQuad> quad = CreateCandidateQuad( | 388 TextureDrawQuad* quad = |
381 resource_provider_.get(), pass->shared_quad_state_list.back()); | 389 CreateCandidateQuad(resource_provider_.get(), |
| 390 pass->shared_quad_state_list.back(), |
| 391 pass.get()); |
382 quad->needs_blending = true; | 392 quad->needs_blending = true; |
383 | 393 |
384 pass->quad_list.push_back(quad.PassAs<DrawQuad>()); | |
385 RenderPassList pass_list; | 394 RenderPassList pass_list; |
386 pass_list.push_back(pass.Pass()); | 395 pass_list.push_back(pass.Pass()); |
387 OverlayCandidateList candidate_list; | 396 OverlayCandidateList candidate_list; |
388 overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list); | 397 overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list); |
389 ASSERT_EQ(1U, pass_list.size()); | 398 ASSERT_EQ(1U, pass_list.size()); |
390 EXPECT_EQ(0U, candidate_list.size()); | 399 EXPECT_EQ(0U, candidate_list.size()); |
391 } | 400 } |
392 | 401 |
393 TEST_F(SingleOverlayOnTopTest, RejectBackgroundColor) { | 402 TEST_F(SingleOverlayOnTopTest, RejectBackgroundColor) { |
394 scoped_ptr<RenderPass> pass = CreateRenderPass(); | 403 scoped_ptr<RenderPass> pass = CreateRenderPass(); |
395 scoped_ptr<TextureDrawQuad> quad = CreateCandidateQuad( | 404 TextureDrawQuad* quad = |
396 resource_provider_.get(), pass->shared_quad_state_list.back()); | 405 CreateCandidateQuad(resource_provider_.get(), |
| 406 pass->shared_quad_state_list.back(), |
| 407 pass.get()); |
397 quad->background_color = SK_ColorBLACK; | 408 quad->background_color = SK_ColorBLACK; |
398 | 409 |
399 pass->quad_list.push_back(quad.PassAs<DrawQuad>()); | |
400 RenderPassList pass_list; | 410 RenderPassList pass_list; |
401 pass_list.push_back(pass.Pass()); | 411 pass_list.push_back(pass.Pass()); |
402 OverlayCandidateList candidate_list; | 412 OverlayCandidateList candidate_list; |
403 overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list); | 413 overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list); |
404 ASSERT_EQ(1U, pass_list.size()); | 414 ASSERT_EQ(1U, pass_list.size()); |
405 EXPECT_EQ(0U, candidate_list.size()); | 415 EXPECT_EQ(0U, candidate_list.size()); |
406 } | 416 } |
407 | 417 |
408 TEST_F(SingleOverlayOnTopTest, RejectBlendMode) { | 418 TEST_F(SingleOverlayOnTopTest, RejectBlendMode) { |
409 scoped_ptr<RenderPass> pass = CreateRenderPass(); | 419 scoped_ptr<RenderPass> pass = CreateRenderPass(); |
410 scoped_ptr<TextureDrawQuad> quad = CreateCandidateQuad( | 420 CreateCandidateQuad(resource_provider_.get(), |
411 resource_provider_.get(), pass->shared_quad_state_list.back()); | 421 pass->shared_quad_state_list.back(), |
| 422 pass.get()); |
412 pass->shared_quad_state_list.back()->blend_mode = SkXfermode::kScreen_Mode; | 423 pass->shared_quad_state_list.back()->blend_mode = SkXfermode::kScreen_Mode; |
413 | 424 |
414 pass->quad_list.push_back(quad.PassAs<DrawQuad>()); | |
415 RenderPassList pass_list; | 425 RenderPassList pass_list; |
416 pass_list.push_back(pass.Pass()); | 426 pass_list.push_back(pass.Pass()); |
417 OverlayCandidateList candidate_list; | 427 OverlayCandidateList candidate_list; |
418 overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list); | 428 overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list); |
419 ASSERT_EQ(1U, pass_list.size()); | 429 ASSERT_EQ(1U, pass_list.size()); |
420 EXPECT_EQ(0U, candidate_list.size()); | 430 EXPECT_EQ(0U, candidate_list.size()); |
421 } | 431 } |
422 | 432 |
423 TEST_F(SingleOverlayOnTopTest, RejectOpacity) { | 433 TEST_F(SingleOverlayOnTopTest, RejectOpacity) { |
424 scoped_ptr<RenderPass> pass = CreateRenderPass(); | 434 scoped_ptr<RenderPass> pass = CreateRenderPass(); |
425 scoped_ptr<TextureDrawQuad> quad = CreateCandidateQuad( | 435 CreateCandidateQuad(resource_provider_.get(), |
426 resource_provider_.get(), pass->shared_quad_state_list.back()); | 436 pass->shared_quad_state_list.back(), |
| 437 pass.get()); |
427 pass->shared_quad_state_list.back()->opacity = 0.5f; | 438 pass->shared_quad_state_list.back()->opacity = 0.5f; |
428 | 439 |
429 pass->quad_list.push_back(quad.PassAs<DrawQuad>()); | |
430 RenderPassList pass_list; | 440 RenderPassList pass_list; |
431 pass_list.push_back(pass.Pass()); | 441 pass_list.push_back(pass.Pass()); |
432 OverlayCandidateList candidate_list; | 442 OverlayCandidateList candidate_list; |
433 overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list); | 443 overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list); |
434 ASSERT_EQ(1U, pass_list.size()); | 444 ASSERT_EQ(1U, pass_list.size()); |
435 EXPECT_EQ(0U, candidate_list.size()); | 445 EXPECT_EQ(0U, candidate_list.size()); |
436 } | 446 } |
437 | 447 |
438 TEST_F(SingleOverlayOnTopTest, RejectTransform) { | 448 TEST_F(SingleOverlayOnTopTest, RejectTransform) { |
439 scoped_ptr<RenderPass> pass = CreateRenderPass(); | 449 scoped_ptr<RenderPass> pass = CreateRenderPass(); |
440 scoped_ptr<TextureDrawQuad> quad = CreateCandidateQuad( | 450 CreateCandidateQuad(resource_provider_.get(), |
441 resource_provider_.get(), pass->shared_quad_state_list.back()); | 451 pass->shared_quad_state_list.back(), |
| 452 pass.get()); |
442 pass->shared_quad_state_list.back()->content_to_target_transform.Scale(2.f, | 453 pass->shared_quad_state_list.back()->content_to_target_transform.Scale(2.f, |
443 2.f); | 454 2.f); |
444 | 455 |
445 pass->quad_list.push_back(quad.PassAs<DrawQuad>()); | |
446 RenderPassList pass_list; | 456 RenderPassList pass_list; |
447 pass_list.push_back(pass.Pass()); | 457 pass_list.push_back(pass.Pass()); |
448 OverlayCandidateList candidate_list; | 458 OverlayCandidateList candidate_list; |
449 overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list); | 459 overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list); |
450 ASSERT_EQ(1U, pass_list.size()); | 460 ASSERT_EQ(1U, pass_list.size()); |
451 EXPECT_EQ(0U, candidate_list.size()); | 461 EXPECT_EQ(0U, candidate_list.size()); |
452 } | 462 } |
453 | 463 |
454 class OverlayInfoRendererGL : public GLRenderer { | 464 class OverlayInfoRendererGL : public GLRenderer { |
455 public: | 465 public: |
(...skipping 86 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
542 }; | 552 }; |
543 | 553 |
544 TEST_F(GLRendererWithOverlaysTest, OverlayQuadNotDrawn) { | 554 TEST_F(GLRendererWithOverlaysTest, OverlayQuadNotDrawn) { |
545 bool use_validator = true; | 555 bool use_validator = true; |
546 Init(use_validator); | 556 Init(use_validator); |
547 renderer_->set_expect_overlays(true); | 557 renderer_->set_expect_overlays(true); |
548 gfx::Rect viewport_rect(16, 16); | 558 gfx::Rect viewport_rect(16, 16); |
549 | 559 |
550 scoped_ptr<RenderPass> pass = CreateRenderPass(); | 560 scoped_ptr<RenderPass> pass = CreateRenderPass(); |
551 | 561 |
552 pass->quad_list.push_back( | 562 CreateCandidateQuad(resource_provider_.get(), |
553 CreateCandidateQuad(resource_provider_.get(), | 563 pass->shared_quad_state_list.back(), |
554 pass->shared_quad_state_list.back()) | 564 pass.get()); |
555 .PassAs<DrawQuad>()); | |
556 | 565 |
557 pass->quad_list.push_back(CreateCheckeredQuad( | 566 CreateCheckeredQuad(resource_provider_.get(), |
558 resource_provider_.get(), pass->shared_quad_state_list.back())); | 567 pass->shared_quad_state_list.back(), |
559 pass->quad_list.push_back(CreateCheckeredQuad( | 568 pass.get()); |
560 resource_provider_.get(), pass->shared_quad_state_list.back())); | 569 CreateCheckeredQuad(resource_provider_.get(), |
| 570 pass->shared_quad_state_list.back(), |
| 571 pass.get()); |
561 | 572 |
562 RenderPassList pass_list; | 573 RenderPassList pass_list; |
563 pass_list.push_back(pass.Pass()); | 574 pass_list.push_back(pass.Pass()); |
564 | 575 |
565 // Candidate pass was taken out and extra skipped pass added, | 576 // Candidate pass was taken out and extra skipped pass added, |
566 // so only draw 2 quads. | 577 // so only draw 2 quads. |
567 EXPECT_CALL(*renderer_, DoDrawQuad(_, _)).Times(2); | 578 EXPECT_CALL(*renderer_, DoDrawQuad(_, _)).Times(2); |
568 EXPECT_CALL(scheduler_, | 579 EXPECT_CALL(scheduler_, |
569 Schedule(1, | 580 Schedule(1, |
570 gfx::OVERLAY_TRANSFORM_NONE, | 581 gfx::OVERLAY_TRANSFORM_NONE, |
571 _, | 582 _, |
572 kOverlayRect, | 583 kOverlayRect, |
573 BoundingRect(kUVTopLeft, kUVBottomRight))).Times(1); | 584 BoundingRect(kUVTopLeft, kUVBottomRight))).Times(1); |
574 renderer_->DrawFrame(&pass_list, 1.f, viewport_rect, viewport_rect, false); | 585 renderer_->DrawFrame(&pass_list, 1.f, viewport_rect, viewport_rect, false); |
575 | 586 |
576 SwapBuffers(); | 587 SwapBuffers(); |
577 | 588 |
578 Mock::VerifyAndClearExpectations(renderer_.get()); | 589 Mock::VerifyAndClearExpectations(renderer_.get()); |
579 Mock::VerifyAndClearExpectations(&scheduler_); | 590 Mock::VerifyAndClearExpectations(&scheduler_); |
580 } | 591 } |
581 | 592 |
582 TEST_F(GLRendererWithOverlaysTest, OccludedQuadDrawn) { | 593 TEST_F(GLRendererWithOverlaysTest, OccludedQuadDrawn) { |
583 bool use_validator = true; | 594 bool use_validator = true; |
584 Init(use_validator); | 595 Init(use_validator); |
585 renderer_->set_expect_overlays(false); | 596 renderer_->set_expect_overlays(false); |
586 gfx::Rect viewport_rect(16, 16); | 597 gfx::Rect viewport_rect(16, 16); |
587 | 598 |
588 scoped_ptr<RenderPass> pass = CreateRenderPass(); | 599 scoped_ptr<RenderPass> pass = CreateRenderPass(); |
589 | 600 |
590 pass->quad_list.push_back(CreateCheckeredQuad( | 601 CreateCheckeredQuad(resource_provider_.get(), |
591 resource_provider_.get(), pass->shared_quad_state_list.back())); | 602 pass->shared_quad_state_list.back(), |
592 pass->quad_list.push_back(CreateCheckeredQuad( | 603 pass.get()); |
593 resource_provider_.get(), pass->shared_quad_state_list.back())); | 604 CreateCheckeredQuad(resource_provider_.get(), |
| 605 pass->shared_quad_state_list.back(), |
| 606 pass.get()); |
594 | 607 |
595 pass->quad_list.push_back( | 608 CreateCandidateQuad(resource_provider_.get(), |
596 CreateCandidateQuad(resource_provider_.get(), | 609 pass->shared_quad_state_list.back(), |
597 pass->shared_quad_state_list.back()) | 610 pass.get()); |
598 .PassAs<DrawQuad>()); | |
599 | 611 |
600 RenderPassList pass_list; | 612 RenderPassList pass_list; |
601 pass_list.push_back(pass.Pass()); | 613 pass_list.push_back(pass.Pass()); |
602 | 614 |
603 // 3 quads in the pass, all should draw. | 615 // 3 quads in the pass, all should draw. |
604 EXPECT_CALL(*renderer_, DoDrawQuad(_, _)).Times(3); | 616 EXPECT_CALL(*renderer_, DoDrawQuad(_, _)).Times(3); |
605 EXPECT_CALL(scheduler_, Schedule(_, _, _, _, _)).Times(0); | 617 EXPECT_CALL(scheduler_, Schedule(_, _, _, _, _)).Times(0); |
606 renderer_->DrawFrame(&pass_list, 1.f, viewport_rect, viewport_rect, false); | 618 renderer_->DrawFrame(&pass_list, 1.f, viewport_rect, viewport_rect, false); |
607 | 619 |
608 SwapBuffers(); | 620 SwapBuffers(); |
609 | 621 |
610 Mock::VerifyAndClearExpectations(renderer_.get()); | 622 Mock::VerifyAndClearExpectations(renderer_.get()); |
611 Mock::VerifyAndClearExpectations(&scheduler_); | 623 Mock::VerifyAndClearExpectations(&scheduler_); |
612 } | 624 } |
613 | 625 |
614 TEST_F(GLRendererWithOverlaysTest, NoValidatorNoOverlay) { | 626 TEST_F(GLRendererWithOverlaysTest, NoValidatorNoOverlay) { |
615 bool use_validator = false; | 627 bool use_validator = false; |
616 Init(use_validator); | 628 Init(use_validator); |
617 renderer_->set_expect_overlays(false); | 629 renderer_->set_expect_overlays(false); |
618 gfx::Rect viewport_rect(16, 16); | 630 gfx::Rect viewport_rect(16, 16); |
619 | 631 |
620 scoped_ptr<RenderPass> pass = CreateRenderPass(); | 632 scoped_ptr<RenderPass> pass = CreateRenderPass(); |
621 | 633 |
622 pass->quad_list.push_back( | 634 CreateCandidateQuad(resource_provider_.get(), |
623 CreateCandidateQuad(resource_provider_.get(), | 635 pass->shared_quad_state_list.back(), |
624 pass->shared_quad_state_list.back()) | 636 pass.get()); |
625 .PassAs<DrawQuad>()); | |
626 | 637 |
627 pass->quad_list.push_back(CreateCheckeredQuad( | 638 CreateCheckeredQuad(resource_provider_.get(), |
628 resource_provider_.get(), pass->shared_quad_state_list.back())); | 639 pass->shared_quad_state_list.back(), |
629 pass->quad_list.push_back(CreateCheckeredQuad( | 640 pass.get()); |
630 resource_provider_.get(), pass->shared_quad_state_list.back())); | 641 CreateCheckeredQuad(resource_provider_.get(), |
| 642 pass->shared_quad_state_list.back(), |
| 643 pass.get()); |
631 | 644 |
632 RenderPassList pass_list; | 645 RenderPassList pass_list; |
633 pass_list.push_back(pass.Pass()); | 646 pass_list.push_back(pass.Pass()); |
634 | 647 |
635 // Should see no overlays. | 648 // Should see no overlays. |
636 EXPECT_CALL(*renderer_, DoDrawQuad(_, _)).Times(3); | 649 EXPECT_CALL(*renderer_, DoDrawQuad(_, _)).Times(3); |
637 EXPECT_CALL(scheduler_, Schedule(_, _, _, _, _)).Times(0); | 650 EXPECT_CALL(scheduler_, Schedule(_, _, _, _, _)).Times(0); |
638 renderer_->DrawFrame(&pass_list, 1.f, viewport_rect, viewport_rect, false); | 651 renderer_->DrawFrame(&pass_list, 1.f, viewport_rect, viewport_rect, false); |
639 | 652 |
640 SwapBuffers(); | 653 SwapBuffers(); |
(...skipping 77 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
718 renderer_->set_expect_overlays(false); | 731 renderer_->set_expect_overlays(false); |
719 renderer_->FinishDrawingFrame(&frame3); | 732 renderer_->FinishDrawingFrame(&frame3); |
720 EXPECT_TRUE(resource_provider_->InUseByConsumer(resource1)); | 733 EXPECT_TRUE(resource_provider_->InUseByConsumer(resource1)); |
721 SwapBuffers(); | 734 SwapBuffers(); |
722 EXPECT_FALSE(resource_provider_->InUseByConsumer(resource1)); | 735 EXPECT_FALSE(resource_provider_->InUseByConsumer(resource1)); |
723 Mock::VerifyAndClearExpectations(&scheduler_); | 736 Mock::VerifyAndClearExpectations(&scheduler_); |
724 } | 737 } |
725 | 738 |
726 } // namespace | 739 } // namespace |
727 } // namespace cc | 740 } // namespace cc |
OLD | NEW |