1 // Copyright 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "cc/output/gl_renderer.h" 6 7 #include <set> 8 9 #include "cc/base/math_util.h" 10 #include "cc/output/compositor_frame_metadata.h" 11 #include "cc/resources/resource_provider.h" 12 #include "cc/test/fake_impl_proxy.h" 13 #include "cc/test/fake_layer_tree_host_impl.h" 14 #include "cc/test/fake_output_surface.h" 15 #include "cc/test/fake_output_surface_client.h" 16 #include "cc/test/fake_renderer_client.h" 17 #include "cc/test/pixel_test.h" 18 #include "cc/test/render_pass_test_common.h" 19 #include "cc/test/render_pass_test_utils.h" 20 #include "cc/test/test_shared_bitmap_manager.h" 21 #include "cc/test/test_web_graphics_context_3d.h" 22 #include "gpu/GLES2/gl2extchromium.h" 23 #include "gpu/command_buffer/client/context_support.h" 24 #include "testing/gmock/include/gmock/gmock.h" 25 #include "testing/gtest/include/gtest/gtest.h" 26 #include "third_party/skia/include/core/SkImageFilter.h" 27 #include "third_party/skia/include/core/SkMatrix.h" 28 #include "third_party/skia/include/effects/SkColorFilterImageFilter.h" 29 #include "third_party/skia/include/effects/SkColorMatrixFilter.h" 30 #include "ui/gfx/transform.h" 31 32 using testing::_; 33 using testing::AnyNumber; 34 using testing::Args; 35 using testing::AtLeast; 36 using testing::ElementsAre; 37 using testing::Expectation; 38 using testing::InSequence; 39 using testing::Mock; 40 using testing::Return; 41 using testing::StrictMock; 42 43 namespace cc { 44 45 class GLRendererTest : public testing::Test { 46 protected: 47 RenderPass* root_render_pass() { return render_passes_in_draw_order_.back(); } 48 49 RenderPassList render_passes_in_draw_order_; 50 }; 51 52 #define EXPECT_PROGRAM_VALID(program_binding) \ 53 do { \ 54 EXPECT_TRUE((program_binding)->program()); \ 55 EXPECT_TRUE((program_binding)->initialized()); \ 56 } while (false) 57 58 // Explicitly named to be a friend in GLRenderer for shader access. 59 class GLRendererShaderPixelTest : public GLRendererPixelTest { 60 public: 61 void TestShaders() { 62 ASSERT_FALSE(renderer()->IsContextLost()); 63 EXPECT_PROGRAM_VALID(renderer()->GetTileCheckerboardProgram()); 64 EXPECT_PROGRAM_VALID(renderer()->GetDebugBorderProgram()); 65 EXPECT_PROGRAM_VALID(renderer()->GetSolidColorProgram()); 66 EXPECT_PROGRAM_VALID(renderer()->GetSolidColorProgramAA()); 67 TestShadersWithTexCoordPrecision(TexCoordPrecisionMedium); 68 TestShadersWithTexCoordPrecision(TexCoordPrecisionHigh); 69 ASSERT_FALSE(renderer()->IsContextLost()); 70 } 71 72 void TestShadersWithTexCoordPrecision(TexCoordPrecision precision) { 73 EXPECT_PROGRAM_VALID(renderer()->GetRenderPassProgram(precision)); 74 EXPECT_PROGRAM_VALID(renderer()->GetRenderPassProgramAA(precision)); 75 EXPECT_PROGRAM_VALID(renderer()->GetRenderPassMaskProgram(precision)); 76 EXPECT_PROGRAM_VALID(renderer()->GetRenderPassMaskProgramAA(precision)); 77 EXPECT_PROGRAM_VALID( 78 renderer()->GetRenderPassColorMatrixProgram(precision)); 79 EXPECT_PROGRAM_VALID( 80 renderer()->GetRenderPassMaskColorMatrixProgramAA(precision)); 81 EXPECT_PROGRAM_VALID( 82 renderer()->GetRenderPassColorMatrixProgramAA(precision)); 83 EXPECT_PROGRAM_VALID( 84 renderer()->GetRenderPassMaskColorMatrixProgram(precision)); 85 EXPECT_PROGRAM_VALID(renderer()->GetTextureProgram(precision)); 86 EXPECT_PROGRAM_VALID( 87 renderer()->GetNonPremultipliedTextureProgram(precision)); 88 EXPECT_PROGRAM_VALID(renderer()->GetTextureBackgroundProgram(precision)); 89 EXPECT_PROGRAM_VALID( 90 renderer()->GetNonPremultipliedTextureBackgroundProgram(precision)); 91 EXPECT_PROGRAM_VALID(renderer()->GetTextureIOSurfaceProgram(precision)); 92 EXPECT_PROGRAM_VALID(renderer()->GetVideoYUVProgram(precision)); 93 EXPECT_PROGRAM_VALID(renderer()->GetVideoYUVAProgram(precision)); 94 // This is unlikely to be ever true in tests due to usage of osmesa. 95 if (renderer()->Capabilities().using_egl_image) 96 EXPECT_PROGRAM_VALID(renderer()->GetVideoStreamTextureProgram(precision)); 97 else 98 EXPECT_FALSE(renderer()->GetVideoStreamTextureProgram(precision)); 99 TestShadersWithSamplerType(precision, SamplerType2D); 100 TestShadersWithSamplerType(precision, SamplerType2DRect); 101 // This is unlikely to be ever true in tests due to usage of osmesa. 102 if (renderer()->Capabilities().using_egl_image) 103 TestShadersWithSamplerType(precision, SamplerTypeExternalOES); 104 } 105 106 void TestShadersWithSamplerType(TexCoordPrecision precision, 107 SamplerType sampler) { 108 EXPECT_PROGRAM_VALID(renderer()->GetTileProgram(precision, sampler)); 109 EXPECT_PROGRAM_VALID(renderer()->GetTileProgramOpaque(precision, sampler)); 110 EXPECT_PROGRAM_VALID(renderer()->GetTileProgramAA(precision, sampler)); 111 EXPECT_PROGRAM_VALID(renderer()->GetTileProgramSwizzle(precision, sampler)); 112 EXPECT_PROGRAM_VALID( 113 renderer()->GetTileProgramSwizzleOpaque(precision, sampler)); 114 EXPECT_PROGRAM_VALID( 115 renderer()->GetTileProgramSwizzleAA(precision, sampler)); 116 } 117 }; 118 119 namespace { 120 121 #if !defined(OS_ANDROID) 122 TEST_F(GLRendererShaderPixelTest, AllShadersCompile) { TestShaders(); } 123 #endif 124 125 class FakeRendererGL : public GLRenderer { 126 public: 127 FakeRendererGL(RendererClient* client, 128 const LayerTreeSettings* settings, 129 OutputSurface* output_surface, 130 ResourceProvider* resource_provider) 131 : GLRenderer(client, 132 settings, 133 output_surface, 134 resource_provider, 135 NULL, 136 0) {} 137 138 // GLRenderer methods. 139 140 // Changing visibility to public. 141 using GLRenderer::IsBackbufferDiscarded; 142 using GLRenderer::DoDrawQuad; 143 using GLRenderer::BeginDrawingFrame; 144 using GLRenderer::FinishDrawingQuadList; 145 using GLRenderer::stencil_enabled; 146 }; 147 148 class GLRendererWithDefaultHarnessTest : public GLRendererTest { 149 protected: 150 GLRendererWithDefaultHarnessTest() { 151 output_surface_ = 152 FakeOutputSurface::Create3d(TestWebGraphicsContext3D::Create()).Pass(); 153 CHECK(output_surface_->BindToClient(&output_surface_client_)); 154 155 shared_bitmap_manager_.reset(new TestSharedBitmapManager()); 156 resource_provider_ = ResourceProvider::Create(output_surface_.get(), 157 shared_bitmap_manager_.get(), 158 NULL, 159 0, 160 false, 161 1, 162 false).Pass(); 163 renderer_ = make_scoped_ptr(new FakeRendererGL(&renderer_client_, 164 &settings_, 165 output_surface_.get(), 166 resource_provider_.get())); 167 } 168 169 void SwapBuffers() { renderer_->SwapBuffers(CompositorFrameMetadata()); } 170 171 LayerTreeSettings settings_; 172 FakeOutputSurfaceClient output_surface_client_; 173 scoped_ptr<FakeOutputSurface> output_surface_; 174 FakeRendererClient renderer_client_; 175 scoped_ptr<SharedBitmapManager> shared_bitmap_manager_; 176 scoped_ptr<ResourceProvider> resource_provider_; 177 scoped_ptr<FakeRendererGL> renderer_; 178 }; 179 180 // Closing the namespace here so that GLRendererShaderTest can take advantage 181 // of the friend relationship with GLRenderer and all of the mock classes 182 // declared above it. 183 } // namespace 184 185 class GLRendererShaderTest : public GLRendererTest { 186 protected: 187 GLRendererShaderTest() { 188 output_surface_ = FakeOutputSurface::Create3d().Pass(); 189 CHECK(output_surface_->BindToClient(&output_surface_client_)); 190 191 shared_bitmap_manager_.reset(new TestSharedBitmapManager()); 192 resource_provider_ = ResourceProvider::Create(output_surface_.get(), 193 shared_bitmap_manager_.get(), 194 NULL, 195 0, 196 false, 197 1, 198 false).Pass(); 199 renderer_.reset(new FakeRendererGL(&renderer_client_, 200 &settings_, 201 output_surface_.get(), 202 resource_provider_.get())); 203 } 204 205 void TestRenderPassProgram(TexCoordPrecision precision) { 206 EXPECT_PROGRAM_VALID(&renderer_->render_pass_program_[precision]); 207 EXPECT_EQ(renderer_->render_pass_program_[precision].program(), 208 renderer_->program_shadow_); 209 } 210 211 void TestRenderPassColorMatrixProgram(TexCoordPrecision precision) { 212 EXPECT_PROGRAM_VALID( 213 &renderer_->render_pass_color_matrix_program_[precision]); 214 EXPECT_EQ(renderer_->render_pass_color_matrix_program_[precision].program(), 215 renderer_->program_shadow_); 216 } 217 218 void TestRenderPassMaskProgram(TexCoordPrecision precision) { 219 EXPECT_PROGRAM_VALID(&renderer_->render_pass_mask_program_[precision]); 220 EXPECT_EQ(renderer_->render_pass_mask_program_[precision].program(), 221 renderer_->program_shadow_); 222 } 223 224 void TestRenderPassMaskColorMatrixProgram(TexCoordPrecision precision) { 225 EXPECT_PROGRAM_VALID( 226 &renderer_->render_pass_mask_color_matrix_program_[precision]); 227 EXPECT_EQ( 228 renderer_->render_pass_mask_color_matrix_program_[precision].program(), 229 renderer_->program_shadow_); 230 } 231 232 void TestRenderPassProgramAA(TexCoordPrecision precision) { 233 EXPECT_PROGRAM_VALID(&renderer_->render_pass_program_aa_[precision]); 234 EXPECT_EQ(renderer_->render_pass_program_aa_[precision].program(), 235 renderer_->program_shadow_); 236 } 237 238 void TestRenderPassColorMatrixProgramAA(TexCoordPrecision precision) { 239 EXPECT_PROGRAM_VALID( 240 &renderer_->render_pass_color_matrix_program_aa_[precision]); 241 EXPECT_EQ( 242 renderer_->render_pass_color_matrix_program_aa_[precision].program(), 243 renderer_->program_shadow_); 244 } 245 246 void TestRenderPassMaskProgramAA(TexCoordPrecision precision) { 247 EXPECT_PROGRAM_VALID(&renderer_->render_pass_mask_program_aa_[precision]); 248 EXPECT_EQ(renderer_->render_pass_mask_program_aa_[precision].program(), 249 renderer_->program_shadow_); 250 } 251 252 void TestRenderPassMaskColorMatrixProgramAA(TexCoordPrecision precision) { 253 EXPECT_PROGRAM_VALID( 254 &renderer_->render_pass_mask_color_matrix_program_aa_[precision]); 255 EXPECT_EQ(renderer_->render_pass_mask_color_matrix_program_aa_[precision] 256 .program(), 257 renderer_->program_shadow_); 258 } 259 260 void TestSolidColorProgramAA() { 261 EXPECT_PROGRAM_VALID(&renderer_->solid_color_program_aa_); 262 EXPECT_EQ(renderer_->solid_color_program_aa_.program(), 263 renderer_->program_shadow_); 264 } 265 266 LayerTreeSettings settings_; 267 FakeOutputSurfaceClient output_surface_client_; 268 scoped_ptr<FakeOutputSurface> output_surface_; 269 FakeRendererClient renderer_client_; 270 scoped_ptr<SharedBitmapManager> shared_bitmap_manager_; 271 scoped_ptr<ResourceProvider> resource_provider_; 272 scoped_ptr<FakeRendererGL> renderer_; 273 }; 274 275 namespace { 276 277 // Test GLRenderer DiscardBackbuffer functionality: 278 // Suggest discarding framebuffer when one exists and the renderer is not 279 // visible. 280 // Expected: it is discarded and damage tracker is reset. 281 TEST_F( 282 GLRendererWithDefaultHarnessTest, 283 SuggestBackbufferNoShouldDiscardBackbufferAndDamageRootLayerIfNotVisible) { 284 renderer_->SetVisible(false); 285 EXPECT_EQ(1, renderer_client_.set_full_root_layer_damage_count()); 286 EXPECT_TRUE(renderer_->IsBackbufferDiscarded()); 287 } 288 289 // Test GLRenderer DiscardBackbuffer functionality: 290 // Suggest discarding framebuffer when one exists and the renderer is visible. 291 // Expected: the allocation is ignored. 292 TEST_F(GLRendererWithDefaultHarnessTest, 293 SuggestBackbufferNoDoNothingWhenVisible) { 294 renderer_->SetVisible(true); 295 EXPECT_EQ(0, renderer_client_.set_full_root_layer_damage_count()); 296 EXPECT_FALSE(renderer_->IsBackbufferDiscarded()); 297 } 298 299 // Test GLRenderer DiscardBackbuffer functionality: 300 // Suggest discarding framebuffer when one does not exist. 301 // Expected: it does nothing. 302 TEST_F(GLRendererWithDefaultHarnessTest, 303 SuggestBackbufferNoWhenItDoesntExistShouldDoNothing) { 304 renderer_->SetVisible(false); 305 EXPECT_EQ(1, renderer_client_.set_full_root_layer_damage_count()); 306 EXPECT_TRUE(renderer_->IsBackbufferDiscarded()); 307 308 EXPECT_EQ(1, renderer_client_.set_full_root_layer_damage_count()); 309 EXPECT_TRUE(renderer_->IsBackbufferDiscarded()); 310 } 311 312 // Test GLRenderer DiscardBackbuffer functionality: 313 // Begin drawing a frame while a framebuffer is discarded. 314 // Expected: will recreate framebuffer. 315 TEST_F(GLRendererWithDefaultHarnessTest, 316 DiscardedBackbufferIsRecreatedForScopeDuration) { 317 gfx::Rect viewport_rect(1, 1); 318 renderer_->SetVisible(false); 319 EXPECT_TRUE(renderer_->IsBackbufferDiscarded()); 320 EXPECT_EQ(1, renderer_client_.set_full_root_layer_damage_count()); 321 322 AddRenderPass(&render_passes_in_draw_order_, 323 RenderPassId(1, 0), 324 viewport_rect, 325 gfx::Transform()); 326 327 renderer_->SetVisible(true); 328 renderer_->DrawFrame(&render_passes_in_draw_order_, 329 1.f, 330 viewport_rect, 331 viewport_rect, 332 false); 333 EXPECT_FALSE(renderer_->IsBackbufferDiscarded()); 334 335 SwapBuffers(); 336 EXPECT_EQ(1u, output_surface_->num_sent_frames()); 337 } 338 339 TEST_F(GLRendererWithDefaultHarnessTest, ExternalStencil) { 340 gfx::Rect viewport_rect(1, 1); 341 EXPECT_FALSE(renderer_->stencil_enabled()); 342 343 output_surface_->set_has_external_stencil_test(true); 344 345 TestRenderPass* root_pass = AddRenderPass(&render_passes_in_draw_order_, 346 RenderPassId(1, 0), 347 viewport_rect, 348 gfx::Transform()); 349 root_pass->has_transparent_background = false; 350 351 renderer_->DrawFrame(&render_passes_in_draw_order_, 352 1.f, 353 viewport_rect, 354 viewport_rect, 355 false); 356 EXPECT_TRUE(renderer_->stencil_enabled()); 357 } 358 359 class ForbidSynchronousCallContext : public TestWebGraphicsContext3D { 360 public: 361 ForbidSynchronousCallContext() {} 362 363 virtual void getAttachedShaders(GLuint program, 364 GLsizei max_count, 365 GLsizei* count, 366 GLuint* shaders) OVERRIDE { 367 ADD_FAILURE(); 368 } 369 virtual GLint getAttribLocation(GLuint program, const GLchar* name) OVERRIDE { 370 ADD_FAILURE(); 371 return 0; 372 } 373 virtual void getBooleanv(GLenum pname, GLboolean* value) OVERRIDE { 374 ADD_FAILURE(); 375 } 376 virtual void getBufferParameteriv(GLenum target, 377 GLenum pname, 378 GLint* value) OVERRIDE { 379 ADD_FAILURE(); 380 } 381 virtual GLenum getError() OVERRIDE { 382 ADD_FAILURE(); 383 return GL_NO_ERROR; 384 } 385 virtual void getFloatv(GLenum pname, GLfloat* value) OVERRIDE { 386 ADD_FAILURE(); 387 } 388 virtual void getFramebufferAttachmentParameteriv(GLenum target, 389 GLenum attachment, 390 GLenum pname, 391 GLint* value) OVERRIDE { 392 ADD_FAILURE(); 393 } 394 virtual void getIntegerv(GLenum pname, GLint* value) OVERRIDE { 395 if (pname == GL_MAX_TEXTURE_SIZE) { 396 // MAX_TEXTURE_SIZE is cached client side, so it's OK to query. 397 *value = 1024; 398 } else { 399 ADD_FAILURE(); 400 } 401 } 402 403 // We allow querying the shader compilation and program link status in debug 404 // mode, but not release. 405 virtual void getProgramiv(GLuint program, 406 GLenum pname, 407 GLint* value) OVERRIDE { 408 #ifndef NDEBUG 409 *value = 1; 410 #else 411 ADD_FAILURE(); 412 #endif 413 } 414 415 virtual void getShaderiv(GLuint shader, GLenum pname, GLint* value) OVERRIDE { 416 #ifndef NDEBUG 417 *value = 1; 418 #else 419 ADD_FAILURE(); 420 #endif 421 } 422 423 virtual void getRenderbufferParameteriv(GLenum target, 424 GLenum pname, 425 GLint* value) OVERRIDE { 426 ADD_FAILURE(); 427 } 428 429 virtual void getShaderPrecisionFormat(GLenum shadertype, 430 GLenum precisiontype, 431 GLint* range, 432 GLint* precision) OVERRIDE { 433 ADD_FAILURE(); 434 } 435 virtual void getTexParameterfv(GLenum target, 436 GLenum pname, 437 GLfloat* value) OVERRIDE { 438 ADD_FAILURE(); 439 } 440 virtual void getTexParameteriv(GLenum target, 441 GLenum pname, 442 GLint* value) OVERRIDE { 443 ADD_FAILURE(); 444 } 445 virtual void getUniformfv(GLuint program, 446 GLint location, 447 GLfloat* value) OVERRIDE { 448 ADD_FAILURE(); 449 } 450 virtual void getUniformiv(GLuint program, 451 GLint location, 452 GLint* value) OVERRIDE { 453 ADD_FAILURE(); 454 } 455 virtual GLint getUniformLocation(GLuint program, 456 const GLchar* name) OVERRIDE { 457 ADD_FAILURE(); 458 return 0; 459 } 460 virtual void getVertexAttribfv(GLuint index, 461 GLenum pname, 462 GLfloat* value) OVERRIDE { 463 ADD_FAILURE(); 464 } 465 virtual void getVertexAttribiv(GLuint index, 466 GLenum pname, 467 GLint* value) OVERRIDE { 468 ADD_FAILURE(); 469 } 470 virtual GLsizeiptr getVertexAttribOffset(GLuint index, 471 GLenum pname) OVERRIDE { 472 ADD_FAILURE(); 473 return 0; 474 } 475 }; 476 TEST_F(GLRendererTest, InitializationDoesNotMakeSynchronousCalls) { 477 FakeOutputSurfaceClient output_surface_client; 478 scoped_ptr<OutputSurface> output_surface(FakeOutputSurface::Create3d( 479 scoped_ptr<TestWebGraphicsContext3D>(new ForbidSynchronousCallContext))); 480 CHECK(output_surface->BindToClient(&output_surface_client)); 481 482 scoped_ptr<SharedBitmapManager> shared_bitmap_manager( 483 new TestSharedBitmapManager()); 484 scoped_ptr<ResourceProvider> resource_provider( 485 ResourceProvider::Create(output_surface.get(), 486 shared_bitmap_manager.get(), 487 NULL, 488 0, 489 false, 490 1, 491 false)); 492 493 LayerTreeSettings settings; 494 FakeRendererClient renderer_client; 495 FakeRendererGL renderer(&renderer_client, 496 &settings, 497 output_surface.get(), 498 resource_provider.get()); 499 } 500 501 class LoseContextOnFirstGetContext : public TestWebGraphicsContext3D { 502 public: 503 LoseContextOnFirstGetContext() {} 504 505 virtual void getProgramiv(GLuint program, 506 GLenum pname, 507 GLint* value) OVERRIDE { 508 context_lost_ = true; 509 *value = 0; 510 } 511 512 virtual void getShaderiv(GLuint shader, GLenum pname, GLint* value) OVERRIDE { 513 context_lost_ = true; 514 *value = 0; 515 } 516 }; 517 518 TEST_F(GLRendererTest, InitializationWithQuicklyLostContextDoesNotAssert) { 519 FakeOutputSurfaceClient output_surface_client; 520 scoped_ptr<OutputSurface> output_surface(FakeOutputSurface::Create3d( 521 scoped_ptr<TestWebGraphicsContext3D>(new LoseContextOnFirstGetContext))); 522 CHECK(output_surface->BindToClient(&output_surface_client)); 523 524 scoped_ptr<SharedBitmapManager> shared_bitmap_manager( 525 new TestSharedBitmapManager()); 526 scoped_ptr<ResourceProvider> resource_provider( 527 ResourceProvider::Create(output_surface.get(), 528 shared_bitmap_manager.get(), 529 NULL, 530 0, 531 false, 532 1, 533 false)); 534 535 LayerTreeSettings settings; 536 FakeRendererClient renderer_client; 537 FakeRendererGL renderer(&renderer_client, 538 &settings, 539 output_surface.get(), 540 resource_provider.get()); 541 } 542 543 class ClearCountingContext : public TestWebGraphicsContext3D { 544 public: 545 ClearCountingContext() { test_capabilities_.gpu.discard_framebuffer = true; } 546 547 MOCK_METHOD3(discardFramebufferEXT, 548 void(GLenum target, 549 GLsizei numAttachments, 550 const GLenum* attachments)); 551 MOCK_METHOD1(clear, void(GLbitfield mask)); 552 }; 553 554 TEST_F(GLRendererTest, OpaqueBackground) { 555 scoped_ptr<ClearCountingContext> context_owned(new ClearCountingContext); 556 ClearCountingContext* context = context_owned.get(); 557 558 FakeOutputSurfaceClient output_surface_client; 559 scoped_ptr<OutputSurface> output_surface(FakeOutputSurface::Create3d( 560 context_owned.PassAs<TestWebGraphicsContext3D>())); 561 CHECK(output_surface->BindToClient(&output_surface_client)); 562 563 scoped_ptr<SharedBitmapManager> shared_bitmap_manager( 564 new TestSharedBitmapManager()); 565 scoped_ptr<ResourceProvider> resource_provider( 566 ResourceProvider::Create(output_surface.get(), 567 shared_bitmap_manager.get(), 568 NULL, 569 0, 570 false, 571 1, 572 false)); 573 574 LayerTreeSettings settings; 575 FakeRendererClient renderer_client; 576 FakeRendererGL renderer(&renderer_client, 577 &settings, 578 output_surface.get(), 579 resource_provider.get()); 580 581 gfx::Rect viewport_rect(1, 1); 582 TestRenderPass* root_pass = AddRenderPass(&render_passes_in_draw_order_, 583 RenderPassId(1, 0), 584 viewport_rect, 585 gfx::Transform()); 586 root_pass->has_transparent_background = false; 587 588 // On DEBUG builds, render passes with opaque background clear to blue to 589 // easily see regions that were not drawn on the screen. 590 EXPECT_CALL(*context, discardFramebufferEXT(GL_FRAMEBUFFER, _, _)) 591 .With(Args<2, 1>(ElementsAre(GL_COLOR_EXT))) 592 .Times(1); 593 #ifdef NDEBUG 594 EXPECT_CALL(*context, clear(_)).Times(0); 595 #else 596 EXPECT_CALL(*context, clear(_)).Times(1); 597 #endif 598 renderer.DrawFrame(&render_passes_in_draw_order_, 599 1.f, 600 viewport_rect, 601 viewport_rect, 602 false); 603 Mock::VerifyAndClearExpectations(context); 604 } 605 606 TEST_F(GLRendererTest, TransparentBackground) { 607 scoped_ptr<ClearCountingContext> context_owned(new ClearCountingContext); 608 ClearCountingContext* context = context_owned.get(); 609 610 FakeOutputSurfaceClient output_surface_client; 611 scoped_ptr<OutputSurface> output_surface(FakeOutputSurface::Create3d( 612 context_owned.PassAs<TestWebGraphicsContext3D>())); 613 CHECK(output_surface->BindToClient(&output_surface_client)); 614 615 scoped_ptr<SharedBitmapManager> shared_bitmap_manager( 616 new TestSharedBitmapManager()); 617 scoped_ptr<ResourceProvider> resource_provider( 618 ResourceProvider::Create(output_surface.get(), 619 shared_bitmap_manager.get(), 620 NULL, 621 0, 622 false, 623 1, 624 false)); 625 626 LayerTreeSettings settings; 627 FakeRendererClient renderer_client; 628 FakeRendererGL renderer(&renderer_client, 629 &settings, 630 output_surface.get(), 631 resource_provider.get()); 632 633 gfx::Rect viewport_rect(1, 1); 634 TestRenderPass* root_pass = AddRenderPass(&render_passes_in_draw_order_, 635 RenderPassId(1, 0), 636 viewport_rect, 637 gfx::Transform()); 638 root_pass->has_transparent_background = true; 639 640 EXPECT_CALL(*context, discardFramebufferEXT(GL_FRAMEBUFFER, 1, _)).Times(1); 641 EXPECT_CALL(*context, clear(_)).Times(1); 642 renderer.DrawFrame(&render_passes_in_draw_order_, 643 1.f, 644 viewport_rect, 645 viewport_rect, 646 false); 647 648 Mock::VerifyAndClearExpectations(context); 649 } 650 651 TEST_F(GLRendererTest, OffscreenOutputSurface) { 652 scoped_ptr<ClearCountingContext> context_owned(new ClearCountingContext); 653 ClearCountingContext* context = context_owned.get(); 654 655 FakeOutputSurfaceClient output_surface_client; 656 scoped_ptr<OutputSurface> output_surface(FakeOutputSurface::CreateOffscreen( 657 context_owned.PassAs<TestWebGraphicsContext3D>())); 658 CHECK(output_surface->BindToClient(&output_surface_client)); 659 660 scoped_ptr<SharedBitmapManager> shared_bitmap_manager( 661 new TestSharedBitmapManager()); 662 scoped_ptr<ResourceProvider> resource_provider( 663 ResourceProvider::Create(output_surface.get(), 664 shared_bitmap_manager.get(), 665 NULL, 666 0, 667 false, 668 1, 669 false)); 670 671 LayerTreeSettings settings; 672 FakeRendererClient renderer_client; 673 FakeRendererGL renderer(&renderer_client, 674 &settings, 675 output_surface.get(), 676 resource_provider.get()); 677 678 gfx::Rect viewport_rect(1, 1); 679 AddRenderPass(&render_passes_in_draw_order_, 680 RenderPassId(1, 0), 681 viewport_rect, 682 gfx::Transform()); 683 684 EXPECT_CALL(*context, discardFramebufferEXT(GL_FRAMEBUFFER, _, _)) 685 .With(Args<2, 1>(ElementsAre(GL_COLOR_ATTACHMENT0))) 686 .Times(1); 687 EXPECT_CALL(*context, clear(_)).Times(AnyNumber()); 688 renderer.DrawFrame(&render_passes_in_draw_order_, 689 1.f, 690 viewport_rect, 691 viewport_rect, 692 false); 693 Mock::VerifyAndClearExpectations(context); 694 } 695 696 class VisibilityChangeIsLastCallTrackingContext 697 : public TestWebGraphicsContext3D { 698 public: 699 VisibilityChangeIsLastCallTrackingContext() 700 : last_call_was_set_visibility_(false) {} 701 702 // TestWebGraphicsContext3D methods. 703 virtual void flush() OVERRIDE { last_call_was_set_visibility_ = false; } 704 virtual void deleteTexture(GLuint) OVERRIDE { 705 last_call_was_set_visibility_ = false; 706 } 707 virtual void deleteFramebuffer(GLuint) OVERRIDE { 708 last_call_was_set_visibility_ = false; 709 } 710 virtual void deleteQueryEXT(GLuint) OVERRIDE { 711 last_call_was_set_visibility_ = false; 712 } 713 virtual void deleteRenderbuffer(GLuint) OVERRIDE { 714 last_call_was_set_visibility_ = false; 715 } 716 717 // Methods added for test. 718 void set_last_call_was_visibility(bool visible) { 719 DCHECK(last_call_was_set_visibility_ == false); 720 last_call_was_set_visibility_ = true; 721 } 722 bool last_call_was_set_visibility() const { 723 return last_call_was_set_visibility_; 724 } 725 726 private: 727 bool last_call_was_set_visibility_; 728 }; 729 730 TEST_F(GLRendererTest, VisibilityChangeIsLastCall) { 731 scoped_ptr<VisibilityChangeIsLastCallTrackingContext> context_owned( 732 new VisibilityChangeIsLastCallTrackingContext); 733 VisibilityChangeIsLastCallTrackingContext* context = context_owned.get(); 734 735 scoped_refptr<TestContextProvider> provider = TestContextProvider::Create( 736 context_owned.PassAs<TestWebGraphicsContext3D>()); 737 738 provider->support()->SetSurfaceVisibleCallback(base::Bind( 739 &VisibilityChangeIsLastCallTrackingContext::set_last_call_was_visibility, 740 base::Unretained(context))); 741 742 FakeOutputSurfaceClient output_surface_client; 743 scoped_ptr<OutputSurface> output_surface( 744 FakeOutputSurface::Create3d(provider)); 745 CHECK(output_surface->BindToClient(&output_surface_client)); 746 747 scoped_ptr<SharedBitmapManager> shared_bitmap_manager( 748 new TestSharedBitmapManager()); 749 scoped_ptr<ResourceProvider> resource_provider( 750 ResourceProvider::Create(output_surface.get(), 751 shared_bitmap_manager.get(), 752 NULL, 753 0, 754 false, 755 1, 756 false)); 757 758 LayerTreeSettings settings; 759 FakeRendererClient renderer_client; 760 FakeRendererGL renderer(&renderer_client, 761 &settings, 762 output_surface.get(), 763 resource_provider.get()); 764 765 gfx::Rect viewport_rect(1, 1); 766 AddRenderPass(&render_passes_in_draw_order_, 767 RenderPassId(1, 0), 768 viewport_rect, 769 gfx::Transform()); 770 771 // Ensure that the call to SetSurfaceVisible is the last call issue to the 772 // GPU process, after glFlush is called, and after the RendererClient's 773 // SetManagedMemoryPolicy is called. Plumb this tracking between both the 774 // RenderClient and the Context by giving them both a pointer to a variable on 775 // the stack. 776 renderer.SetVisible(true); 777 renderer.DrawFrame(&render_passes_in_draw_order_, 778 1.f, 779 viewport_rect, 780 viewport_rect, 781 false); 782 renderer.SetVisible(false); 783 EXPECT_TRUE(context->last_call_was_set_visibility()); 784 } 785 786 class TextureStateTrackingContext : public TestWebGraphicsContext3D { 787 public: 788 TextureStateTrackingContext() : active_texture_(GL_INVALID_ENUM) { 789 test_capabilities_.gpu.egl_image_external = true; 790 } 791 792 MOCK_METHOD1(waitSyncPoint, void(unsigned sync_point)); 793 MOCK_METHOD3(texParameteri, void(GLenum target, GLenum pname, GLint param)); 794 MOCK_METHOD4(drawElements, 795 void(GLenum mode, GLsizei count, GLenum type, GLintptr offset)); 796 797 virtual void activeTexture(GLenum texture) { 798 EXPECT_NE(texture, active_texture_); 799 active_texture_ = texture; 800 } 801 802 GLenum active_texture() const { return active_texture_; } 803 804 private: 805 GLenum active_texture_; 806 }; 807 808 TEST_F(GLRendererTest, ActiveTextureState) { 809 scoped_ptr<TextureStateTrackingContext> context_owned( 810 new TextureStateTrackingContext); 811 TextureStateTrackingContext* context = context_owned.get(); 812 813 FakeOutputSurfaceClient output_surface_client; 814 scoped_ptr<OutputSurface> output_surface(FakeOutputSurface::Create3d( 815 context_owned.PassAs<TestWebGraphicsContext3D>())); 816 CHECK(output_surface->BindToClient(&output_surface_client)); 817 818 scoped_ptr<SharedBitmapManager> shared_bitmap_manager( 819 new TestSharedBitmapManager()); 820 scoped_ptr<ResourceProvider> resource_provider( 821 ResourceProvider::Create(output_surface.get(), 822 shared_bitmap_manager.get(), 823 NULL, 824 0, 825 false, 826 1, 827 false)); 828 829 LayerTreeSettings settings; 830 FakeRendererClient renderer_client; 831 FakeRendererGL renderer(&renderer_client, 832 &settings, 833 output_surface.get(), 834 resource_provider.get()); 835 836 // During initialization we are allowed to set any texture parameters. 837 EXPECT_CALL(*context, texParameteri(_, _, _)).Times(AnyNumber()); 838 839 RenderPassId id(1, 1); 840 TestRenderPass* root_pass = AddRenderPass( 841 &render_passes_in_draw_order_, id, gfx::Rect(100, 100), gfx::Transform()); 842 root_pass->AppendOneOfEveryQuadType(resource_provider.get(), 843 RenderPassId(2, 1)); 844 845 renderer.DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_); 846 847 // Set up expected texture filter state transitions that match the quads 848 // created in AppendOneOfEveryQuadType(). 849 Mock::VerifyAndClearExpectations(context); 850 { 851 InSequence sequence; 852 853 // The sync points for all quads are waited on first. This sync point is 854 // for a texture quad drawn later in the frame. 855 EXPECT_CALL(*context, 856 waitSyncPoint(TestRenderPass::kSyncPointForMailboxTextureQuad)) 857 .Times(1); 858 859 // yuv_quad is drawn with the default linear filter. 860 EXPECT_CALL(*context, drawElements(_, _, _, _)); 861 862 // tile_quad is drawn with GL_NEAREST because it is not transformed or 863 // scaled. 864 EXPECT_CALL( 865 *context, 866 texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST)); 867 EXPECT_CALL( 868 *context, 869 texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)); 870 EXPECT_CALL(*context, drawElements(_, _, _, _)); 871 872 // transformed_tile_quad uses GL_LINEAR. 873 EXPECT_CALL(*context, drawElements(_, _, _, _)); 874 875 // scaled_tile_quad also uses GL_LINEAR. 876 EXPECT_CALL(*context, drawElements(_, _, _, _)); 877 878 // The remaining quads also use GL_LINEAR because nearest neighbor 879 // filtering is currently only used with tile quads. 880 EXPECT_CALL(*context, drawElements(_, _, _, _)).Times(7); 881 } 882 883 gfx::Rect viewport_rect(100, 100); 884 renderer.DrawFrame(&render_passes_in_draw_order_, 885 1.f, 886 viewport_rect, 887 viewport_rect, 888 false); 889 Mock::VerifyAndClearExpectations(context); 890 } 891 892 class NoClearRootRenderPassMockContext : public TestWebGraphicsContext3D { 893 public: 894 MOCK_METHOD1(clear, void(GLbitfield mask)); 895 MOCK_METHOD4(drawElements, 896 void(GLenum mode, GLsizei count, GLenum type, GLintptr offset)); 897 }; 898 899 TEST_F(GLRendererTest, ShouldClearRootRenderPass) { 900 scoped_ptr<NoClearRootRenderPassMockContext> mock_context_owned( 901 new NoClearRootRenderPassMockContext); 902 NoClearRootRenderPassMockContext* mock_context = mock_context_owned.get(); 903 904 FakeOutputSurfaceClient output_surface_client; 905 scoped_ptr<OutputSurface> output_surface(FakeOutputSurface::Create3d( 906 mock_context_owned.PassAs<TestWebGraphicsContext3D>())); 907 CHECK(output_surface->BindToClient(&output_surface_client)); 908 909 scoped_ptr<SharedBitmapManager> shared_bitmap_manager( 910 new TestSharedBitmapManager()); 911 scoped_ptr<ResourceProvider> resource_provider( 912 ResourceProvider::Create(output_surface.get(), 913 shared_bitmap_manager.get(), 914 NULL, 915 0, 916 false, 917 1, 918 false)); 919 920 LayerTreeSettings settings; 921 settings.should_clear_root_render_pass = false; 922 923 FakeRendererClient renderer_client; 924 FakeRendererGL renderer(&renderer_client, 925 &settings, 926 output_surface.get(), 927 resource_provider.get()); 928 929 gfx::Rect viewport_rect(10, 10); 930 931 RenderPassId root_pass_id(1, 0); 932 TestRenderPass* root_pass = AddRenderPass(&render_passes_in_draw_order_, 933 root_pass_id, 934 viewport_rect, 935 gfx::Transform()); 936 AddQuad(root_pass, viewport_rect, SK_ColorGREEN); 937 938 RenderPassId child_pass_id(2, 0); 939 TestRenderPass* child_pass = AddRenderPass(&render_passes_in_draw_order_, 940 child_pass_id, 941 viewport_rect, 942 gfx::Transform()); 943 AddQuad(child_pass, viewport_rect, SK_ColorBLUE); 944 945 AddRenderPassQuad(root_pass, child_pass); 946 947 #ifdef NDEBUG 948 GLint clear_bits = GL_COLOR_BUFFER_BIT; 949 #else 950 GLint clear_bits = GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT; 951 #endif 952 953 // First render pass is not the root one, clearing should happen. 954 EXPECT_CALL(*mock_context, clear(clear_bits)).Times(AtLeast(1)); 955 956 Expectation first_render_pass = 957 EXPECT_CALL(*mock_context, drawElements(_, _, _, _)).Times(1); 958 959 // The second render pass is the root one, clearing should be prevented. 960 EXPECT_CALL(*mock_context, clear(clear_bits)).Times(0).After( 961 first_render_pass); 962 963 EXPECT_CALL(*mock_context, drawElements(_, _, _, _)).Times(AnyNumber()).After( 964 first_render_pass); 965 966 renderer.DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_); 967 renderer.DrawFrame(&render_passes_in_draw_order_, 968 1.f, 969 viewport_rect, 970 viewport_rect, 971 false); 972 973 // In multiple render passes all but the root pass should clear the 974 // framebuffer. 975 Mock::VerifyAndClearExpectations(&mock_context); 976 } 977 978 class ScissorTestOnClearCheckingContext : public TestWebGraphicsContext3D { 979 public: 980 ScissorTestOnClearCheckingContext() : scissor_enabled_(false) {} 981 982 virtual void clear(GLbitfield) OVERRIDE { EXPECT_FALSE(scissor_enabled_); } 983 984 virtual void enable(GLenum cap) OVERRIDE { 985 if (cap == GL_SCISSOR_TEST) 986 scissor_enabled_ = true; 987 } 988 989 virtual void disable(GLenum cap) OVERRIDE { 990 if (cap == GL_SCISSOR_TEST) 991 scissor_enabled_ = false; 992 } 993 994 private: 995 bool scissor_enabled_; 996 }; 997 998 TEST_F(GLRendererTest, ScissorTestWhenClearing) { 999 scoped_ptr<ScissorTestOnClearCheckingContext> context_owned( 1000 new ScissorTestOnClearCheckingContext); 1001 1002 FakeOutputSurfaceClient output_surface_client; 1003 scoped_ptr<OutputSurface> output_surface(FakeOutputSurface::Create3d( 1004 context_owned.PassAs<TestWebGraphicsContext3D>())); 1005 CHECK(output_surface->BindToClient(&output_surface_client)); 1006 1007 scoped_ptr<SharedBitmapManager> shared_bitmap_manager( 1008 new TestSharedBitmapManager()); 1009 scoped_ptr<ResourceProvider> resource_provider( 1010 ResourceProvider::Create(output_surface.get(), 1011 shared_bitmap_manager.get(), 1012 NULL, 1013 0, 1014 false, 1015 1, 1016 false)); 1017 1018 LayerTreeSettings settings; 1019 FakeRendererClient renderer_client; 1020 FakeRendererGL renderer(&renderer_client, 1021 &settings, 1022 output_surface.get(), 1023 resource_provider.get()); 1024 EXPECT_FALSE(renderer.Capabilities().using_partial_swap); 1025 1026 gfx::Rect viewport_rect(1, 1); 1027 1028 gfx::Rect grand_child_rect(25, 25); 1029 RenderPassId grand_child_pass_id(3, 0); 1030 TestRenderPass* grand_child_pass = 1031 AddRenderPass(&render_passes_in_draw_order_, 1032 grand_child_pass_id, 1033 grand_child_rect, 1034 gfx::Transform()); 1035 AddClippedQuad(grand_child_pass, grand_child_rect, SK_ColorYELLOW); 1036 1037 gfx::Rect child_rect(50, 50); 1038 RenderPassId child_pass_id(2, 0); 1039 TestRenderPass* child_pass = AddRenderPass(&render_passes_in_draw_order_, 1040 child_pass_id, 1041 child_rect, 1042 gfx::Transform()); 1043 AddQuad(child_pass, child_rect, SK_ColorBLUE); 1044 1045 RenderPassId root_pass_id(1, 0); 1046 TestRenderPass* root_pass = AddRenderPass(&render_passes_in_draw_order_, 1047 root_pass_id, 1048 viewport_rect, 1049 gfx::Transform()); 1050 AddQuad(root_pass, viewport_rect, SK_ColorGREEN); 1051 1052 AddRenderPassQuad(root_pass, child_pass); 1053 AddRenderPassQuad(child_pass, grand_child_pass); 1054 1055 renderer.DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_); 1056 renderer.DrawFrame(&render_passes_in_draw_order_, 1057 1.f, 1058 viewport_rect, 1059 viewport_rect, 1060 false); 1061 } 1062 1063 class DiscardCheckingContext : public TestWebGraphicsContext3D { 1064 public: 1065 DiscardCheckingContext() : discarded_(0) { 1066 set_have_post_sub_buffer(true); 1067 set_have_discard_framebuffer(true); 1068 } 1069 1070 virtual void discardFramebufferEXT(GLenum target, 1071 GLsizei numAttachments, 1072 const GLenum* attachments) OVERRIDE { 1073 ++discarded_; 1074 } 1075 1076 int discarded() const { return discarded_; } 1077 void reset() { discarded_ = 0; } 1078 1079 private: 1080 int discarded_; 1081 }; 1082 1083 class NonReshapableOutputSurface : public FakeOutputSurface { 1084 public: 1085 explicit NonReshapableOutputSurface( 1086 scoped_ptr<TestWebGraphicsContext3D> context3d) 1087 : FakeOutputSurface(TestContextProvider::Create(context3d.Pass()), 1088 false) { 1089 surface_size_ = gfx::Size(500, 500); 1090 } 1091 virtual void Reshape(const gfx::Size& size, float scale_factor) OVERRIDE {} 1092 void set_fixed_size(const gfx::Size& size) { surface_size_ = size; } 1093 }; 1094 1095 TEST_F(GLRendererTest, NoDiscardOnPartialUpdates) { 1096 scoped_ptr<DiscardCheckingContext> context_owned(new DiscardCheckingContext); 1097 DiscardCheckingContext* context = context_owned.get(); 1098 1099 FakeOutputSurfaceClient output_surface_client; 1100 scoped_ptr<NonReshapableOutputSurface> output_surface( 1101 new NonReshapableOutputSurface( 1102 context_owned.PassAs<TestWebGraphicsContext3D>())); 1103 CHECK(output_surface->BindToClient(&output_surface_client)); 1104 output_surface->set_fixed_size(gfx::Size(100, 100)); 1105 1106 scoped_ptr<SharedBitmapManager> shared_bitmap_manager( 1107 new TestSharedBitmapManager()); 1108 scoped_ptr<ResourceProvider> resource_provider( 1109 ResourceProvider::Create(output_surface.get(), 1110 shared_bitmap_manager.get(), 1111 NULL, 1112 0, 1113 false, 1114 1, 1115 false)); 1116 1117 LayerTreeSettings settings; 1118 settings.partial_swap_enabled = true; 1119 FakeRendererClient renderer_client; 1120 FakeRendererGL renderer(&renderer_client, 1121 &settings, 1122 output_surface.get(), 1123 resource_provider.get()); 1124 EXPECT_TRUE(renderer.Capabilities().using_partial_swap); 1125 1126 gfx::Rect viewport_rect(100, 100); 1127 gfx::Rect clip_rect(100, 100); 1128 1129 { 1130 // Partial frame, should not discard. 1131 RenderPassId root_pass_id(1, 0); 1132 TestRenderPass* root_pass = AddRenderPass(&render_passes_in_draw_order_, 1133 root_pass_id, 1134 viewport_rect, 1135 gfx::Transform()); 1136 AddQuad(root_pass, viewport_rect, SK_ColorGREEN); 1137 root_pass->damage_rect = gfx::Rect(2, 2, 3, 3); 1138 1139 renderer.DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_); 1140 renderer.DrawFrame(&render_passes_in_draw_order_, 1141 1.f, 1142 viewport_rect, 1143 clip_rect, 1144 false); 1145 EXPECT_EQ(0, context->discarded()); 1146 context->reset(); 1147 } 1148 { 1149 // Full frame, should discard. 1150 RenderPassId root_pass_id(1, 0); 1151 TestRenderPass* root_pass = AddRenderPass(&render_passes_in_draw_order_, 1152 root_pass_id, 1153 viewport_rect, 1154 gfx::Transform()); 1155 AddQuad(root_pass, viewport_rect, SK_ColorGREEN); 1156 root_pass->damage_rect = root_pass->output_rect; 1157 1158 renderer.DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_); 1159 renderer.DrawFrame(&render_passes_in_draw_order_, 1160 1.f, 1161 viewport_rect, 1162 clip_rect, 1163 false); 1164 EXPECT_EQ(1, context->discarded()); 1165 context->reset(); 1166 } 1167 { 1168 // Full frame, external scissor is set, should not discard. 1169 output_surface->set_has_external_stencil_test(true); 1170 RenderPassId root_pass_id(1, 0); 1171 TestRenderPass* root_pass = AddRenderPass(&render_passes_in_draw_order_, 1172 root_pass_id, 1173 viewport_rect, 1174 gfx::Transform()); 1175 AddQuad(root_pass, viewport_rect, SK_ColorGREEN); 1176 root_pass->damage_rect = root_pass->output_rect; 1177 root_pass->has_transparent_background = false; 1178 1179 renderer.DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_); 1180 renderer.DrawFrame(&render_passes_in_draw_order_, 1181 1.f, 1182 viewport_rect, 1183 clip_rect, 1184 false); 1185 EXPECT_EQ(0, context->discarded()); 1186 context->reset(); 1187 output_surface->set_has_external_stencil_test(false); 1188 } 1189 { 1190 // Full frame, clipped, should not discard. 1191 clip_rect = gfx::Rect(10, 10, 10, 10); 1192 RenderPassId root_pass_id(1, 0); 1193 TestRenderPass* root_pass = AddRenderPass(&render_passes_in_draw_order_, 1194 root_pass_id, 1195 viewport_rect, 1196 gfx::Transform()); 1197 AddQuad(root_pass, viewport_rect, SK_ColorGREEN); 1198 root_pass->damage_rect = root_pass->output_rect; 1199 1200 renderer.DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_); 1201 renderer.DrawFrame(&render_passes_in_draw_order_, 1202 1.f, 1203 viewport_rect, 1204 clip_rect, 1205 false); 1206 EXPECT_EQ(0, context->discarded()); 1207 context->reset(); 1208 } 1209 { 1210 // Full frame, doesn't cover the surface, should not discard. 1211 viewport_rect = gfx::Rect(10, 10, 10, 10); 1212 RenderPassId root_pass_id(1, 0); 1213 TestRenderPass* root_pass = AddRenderPass(&render_passes_in_draw_order_, 1214 root_pass_id, 1215 viewport_rect, 1216 gfx::Transform()); 1217 AddQuad(root_pass, viewport_rect, SK_ColorGREEN); 1218 root_pass->damage_rect = root_pass->output_rect; 1219 1220 renderer.DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_); 1221 renderer.DrawFrame(&render_passes_in_draw_order_, 1222 1.f, 1223 viewport_rect, 1224 clip_rect, 1225 false); 1226 EXPECT_EQ(0, context->discarded()); 1227 context->reset(); 1228 } 1229 { 1230 // Full frame, doesn't cover the surface (no offset), should not discard. 1231 clip_rect = gfx::Rect(100, 100); 1232 viewport_rect = gfx::Rect(50, 50); 1233 RenderPassId root_pass_id(1, 0); 1234 TestRenderPass* root_pass = AddRenderPass(&render_passes_in_draw_order_, 1235 root_pass_id, 1236 viewport_rect, 1237 gfx::Transform()); 1238 AddQuad(root_pass, viewport_rect, SK_ColorGREEN); 1239 root_pass->damage_rect = root_pass->output_rect; 1240 1241 renderer.DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_); 1242 renderer.DrawFrame(&render_passes_in_draw_order_, 1243 1.f, 1244 viewport_rect, 1245 clip_rect, 1246 false); 1247 EXPECT_EQ(0, context->discarded()); 1248 context->reset(); 1249 } 1250 } 1251 1252 class FlippedScissorAndViewportContext : public TestWebGraphicsContext3D { 1253 public: 1254 FlippedScissorAndViewportContext() 1255 : did_call_viewport_(false), did_call_scissor_(false) {} 1256 virtual ~FlippedScissorAndViewportContext() { 1257 EXPECT_TRUE(did_call_viewport_); 1258 EXPECT_TRUE(did_call_scissor_); 1259 } 1260 1261 virtual void viewport(GLint x, GLint y, GLsizei width, GLsizei height) 1262 OVERRIDE { 1263 EXPECT_EQ(10, x); 1264 EXPECT_EQ(390, y); 1265 EXPECT_EQ(100, width); 1266 EXPECT_EQ(100, height); 1267 did_call_viewport_ = true; 1268 } 1269 1270 virtual void scissor(GLint x, GLint y, GLsizei width, GLsizei height) 1271 OVERRIDE { 1272 EXPECT_EQ(30, x); 1273 EXPECT_EQ(450, y); 1274 EXPECT_EQ(20, width); 1275 EXPECT_EQ(20, height); 1276 did_call_scissor_ = true; 1277 } 1278 1279 private: 1280 bool did_call_viewport_; 1281 bool did_call_scissor_; 1282 }; 1283 1284 TEST_F(GLRendererTest, ScissorAndViewportWithinNonreshapableSurface) { 1285 // In Android WebView, the OutputSurface is unable to respect reshape() calls 1286 // and maintains a fixed size. This test verifies that glViewport and 1287 // glScissor's Y coordinate is flipped correctly in this environment, and that 1288 // the glViewport can be at a nonzero origin within the surface. 1289 scoped_ptr<FlippedScissorAndViewportContext> context_owned( 1290 new FlippedScissorAndViewportContext); 1291 1292 FakeOutputSurfaceClient output_surface_client; 1293 scoped_ptr<OutputSurface> output_surface(new NonReshapableOutputSurface( 1294 context_owned.PassAs<TestWebGraphicsContext3D>())); 1295 CHECK(output_surface->BindToClient(&output_surface_client)); 1296 1297 scoped_ptr<SharedBitmapManager> shared_bitmap_manager( 1298 new TestSharedBitmapManager()); 1299 scoped_ptr<ResourceProvider> resource_provider( 1300 ResourceProvider::Create(output_surface.get(), 1301 shared_bitmap_manager.get(), 1302 NULL, 1303 0, 1304 false, 1305 1, 1306 false)); 1307 1308 LayerTreeSettings settings; 1309 FakeRendererClient renderer_client; 1310 FakeRendererGL renderer(&renderer_client, 1311 &settings, 1312 output_surface.get(), 1313 resource_provider.get()); 1314 EXPECT_FALSE(renderer.Capabilities().using_partial_swap); 1315 1316 gfx::Rect device_viewport_rect(10, 10, 100, 100); 1317 gfx::Rect viewport_rect(device_viewport_rect.size()); 1318 gfx::Rect quad_rect = gfx::Rect(20, 20, 20, 20); 1319 1320 RenderPassId root_pass_id(1, 0); 1321 TestRenderPass* root_pass = AddRenderPass(&render_passes_in_draw_order_, 1322 root_pass_id, 1323 viewport_rect, 1324 gfx::Transform()); 1325 AddClippedQuad(root_pass, quad_rect, SK_ColorGREEN); 1326 1327 renderer.DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_); 1328 renderer.DrawFrame(&render_passes_in_draw_order_, 1329 1.f, 1330 device_viewport_rect, 1331 device_viewport_rect, 1332 false); 1333 } 1334 1335 TEST_F(GLRendererShaderTest, DrawRenderPassQuadShaderPermutations) { 1336 gfx::Rect viewport_rect(1, 1); 1337 1338 gfx::Rect child_rect(50, 50); 1339 RenderPassId child_pass_id(2, 0); 1340 TestRenderPass* child_pass; 1341 1342 RenderPassId root_pass_id(1, 0); 1343 TestRenderPass* root_pass; 1344 1345 ResourceProvider::ResourceId mask = resource_provider_->CreateResource( 1346 gfx::Size(20, 12), 1347 GL_CLAMP_TO_EDGE, 1348 ResourceProvider::TextureHintImmutable, 1349 resource_provider_->best_texture_format()); 1350 resource_provider_->AllocateForTesting(mask); 1351 1352 SkScalar matrix[20]; 1353 float amount = 0.5f; 1354 matrix[0] = 0.213f + 0.787f * amount; 1355 matrix[1] = 0.715f - 0.715f * amount; 1356 matrix[2] = 1.f - (matrix[0] + matrix[1]); 1357 matrix[3] = matrix[4] = 0; 1358 matrix[5] = 0.213f - 0.213f * amount; 1359 matrix[6] = 0.715f + 0.285f * amount; 1360 matrix[7] = 1.f - (matrix[5] + matrix[6]); 1361 matrix[8] = matrix[9] = 0; 1362 matrix[10] = 0.213f - 0.213f * amount; 1363 matrix[11] = 0.715f - 0.715f * amount; 1364 matrix[12] = 1.f - (matrix[10] + matrix[11]); 1365 matrix[13] = matrix[14] = 0; 1366 matrix[15] = matrix[16] = matrix[17] = matrix[19] = 0; 1367 matrix[18] = 1; 1368 skia::RefPtr<SkColorFilter> color_filter( 1369 skia::AdoptRef(SkColorMatrixFilter::Create(matrix))); 1370 skia::RefPtr<SkImageFilter> filter = skia::AdoptRef( 1371 SkColorFilterImageFilter::Create(color_filter.get(), NULL)); 1372 FilterOperations filters; 1373 filters.Append(FilterOperation::CreateReferenceFilter(filter)); 1374 1375 gfx::Transform transform_causing_aa; 1376 transform_causing_aa.Rotate(20.0); 1377 1378 // RenderPassProgram 1379 child_pass = AddRenderPass(&render_passes_in_draw_order_, 1380 child_pass_id, 1381 child_rect, 1382 gfx::Transform()); 1383 1384 root_pass = AddRenderPass(&render_passes_in_draw_order_, 1385 root_pass_id, 1386 viewport_rect, 1387 gfx::Transform()); 1388 1389 AddRenderPassQuad( 1390 root_pass, child_pass, 0, FilterOperations(), gfx::Transform()); 1391 1392 renderer_->DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_); 1393 renderer_->DrawFrame(&render_passes_in_draw_order_, 1394 1.f, 1395 viewport_rect, 1396 viewport_rect, 1397 false); 1398 TestRenderPassProgram(TexCoordPrecisionMedium); 1399 1400 // RenderPassColorMatrixProgram 1401 render_passes_in_draw_order_.clear(); 1402 1403 child_pass = AddRenderPass(&render_passes_in_draw_order_, 1404 child_pass_id, 1405 child_rect, 1406 transform_causing_aa); 1407 1408 root_pass = AddRenderPass(&render_passes_in_draw_order_, 1409 root_pass_id, 1410 viewport_rect, 1411 gfx::Transform()); 1412 1413 AddRenderPassQuad(root_pass, child_pass, 0, filters, gfx::Transform()); 1414 1415 renderer_->DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_); 1416 renderer_->DrawFrame(&render_passes_in_draw_order_, 1417 1.f, 1418 viewport_rect, 1419 viewport_rect, 1420 false); 1421 TestRenderPassColorMatrixProgram(TexCoordPrecisionMedium); 1422 1423 // RenderPassMaskProgram 1424 render_passes_in_draw_order_.clear(); 1425 1426 child_pass = AddRenderPass(&render_passes_in_draw_order_, 1427 child_pass_id, 1428 child_rect, 1429 gfx::Transform()); 1430 1431 root_pass = AddRenderPass(&render_passes_in_draw_order_, 1432 root_pass_id, 1433 viewport_rect, 1434 gfx::Transform()); 1435 1436 AddRenderPassQuad( 1437 root_pass, child_pass, mask, FilterOperations(), gfx::Transform()); 1438 1439 renderer_->DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_); 1440 renderer_->DrawFrame(&render_passes_in_draw_order_, 1441 1.f, 1442 viewport_rect, 1443 viewport_rect, 1444 false); 1445 TestRenderPassMaskProgram(TexCoordPrecisionMedium); 1446 1447 // RenderPassMaskColorMatrixProgram 1448 render_passes_in_draw_order_.clear(); 1449 1450 child_pass = AddRenderPass(&render_passes_in_draw_order_, 1451 child_pass_id, 1452 child_rect, 1453 gfx::Transform()); 1454 1455 root_pass = AddRenderPass(&render_passes_in_draw_order_, 1456 root_pass_id, 1457 viewport_rect, 1458 gfx::Transform()); 1459 1460 AddRenderPassQuad(root_pass, child_pass, mask, filters, gfx::Transform()); 1461 1462 renderer_->DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_); 1463 renderer_->DrawFrame(&render_passes_in_draw_order_, 1464 1.f, 1465 viewport_rect, 1466 viewport_rect, 1467 false); 1468 TestRenderPassMaskColorMatrixProgram(TexCoordPrecisionMedium); 1469 1470 // RenderPassProgramAA 1471 render_passes_in_draw_order_.clear(); 1472 1473 child_pass = AddRenderPass(&render_passes_in_draw_order_, 1474 child_pass_id, 1475 child_rect, 1476 transform_causing_aa); 1477 1478 root_pass = AddRenderPass(&render_passes_in_draw_order_, 1479 root_pass_id, 1480 viewport_rect, 1481 gfx::Transform()); 1482 1483 AddRenderPassQuad( 1484 root_pass, child_pass, 0, FilterOperations(), transform_causing_aa); 1485 1486 renderer_->DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_); 1487 renderer_->DrawFrame(&render_passes_in_draw_order_, 1488 1.f, 1489 viewport_rect, 1490 viewport_rect, 1491 false); 1492 TestRenderPassProgramAA(TexCoordPrecisionMedium); 1493 1494 // RenderPassColorMatrixProgramAA 1495 render_passes_in_draw_order_.clear(); 1496 1497 child_pass = AddRenderPass(&render_passes_in_draw_order_, 1498 child_pass_id, 1499 child_rect, 1500 transform_causing_aa); 1501 1502 root_pass = AddRenderPass(&render_passes_in_draw_order_, 1503 root_pass_id, 1504 viewport_rect, 1505 gfx::Transform()); 1506 1507 AddRenderPassQuad(root_pass, child_pass, 0, filters, transform_causing_aa); 1508 1509 renderer_->DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_); 1510 renderer_->DrawFrame(&render_passes_in_draw_order_, 1511 1.f, 1512 viewport_rect, 1513 viewport_rect, 1514 false); 1515 TestRenderPassColorMatrixProgramAA(TexCoordPrecisionMedium); 1516 1517 // RenderPassMaskProgramAA 1518 render_passes_in_draw_order_.clear(); 1519 1520 child_pass = AddRenderPass(&render_passes_in_draw_order_, 1521 child_pass_id, 1522 child_rect, 1523 transform_causing_aa); 1524 1525 root_pass = AddRenderPass(&render_passes_in_draw_order_, 1526 root_pass_id, 1527 viewport_rect, 1528 gfx::Transform()); 1529 1530 AddRenderPassQuad( 1531 root_pass, child_pass, mask, FilterOperations(), transform_causing_aa); 1532 1533 renderer_->DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_); 1534 renderer_->DrawFrame(&render_passes_in_draw_order_, 1535 1.f, 1536 viewport_rect, 1537 viewport_rect, 1538 false); 1539 TestRenderPassMaskProgramAA(TexCoordPrecisionMedium); 1540 1541 // RenderPassMaskColorMatrixProgramAA 1542 render_passes_in_draw_order_.clear(); 1543 1544 child_pass = AddRenderPass(&render_passes_in_draw_order_, 1545 child_pass_id, 1546 child_rect, 1547 transform_causing_aa); 1548 1549 root_pass = AddRenderPass(&render_passes_in_draw_order_, 1550 root_pass_id, 1551 viewport_rect, 1552 transform_causing_aa); 1553 1554 AddRenderPassQuad(root_pass, child_pass, mask, filters, transform_causing_aa); 1555 1556 renderer_->DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_); 1557 renderer_->DrawFrame(&render_passes_in_draw_order_, 1558 1.f, 1559 viewport_rect, 1560 viewport_rect, 1561 false); 1562 TestRenderPassMaskColorMatrixProgramAA(TexCoordPrecisionMedium); 1563 } 1564 1565 // At this time, the AA code path cannot be taken if the surface's rect would 1566 // project incorrectly by the given transform, because of w<0 clipping. 1567 TEST_F(GLRendererShaderTest, DrawRenderPassQuadSkipsAAForClippingTransform) { 1568 gfx::Rect child_rect(50, 50); 1569 RenderPassId child_pass_id(2, 0); 1570 TestRenderPass* child_pass; 1571 1572 gfx::Rect viewport_rect(1, 1); 1573 RenderPassId root_pass_id(1, 0); 1574 TestRenderPass* root_pass; 1575 1576 gfx::Transform transform_preventing_aa; 1577 transform_preventing_aa.ApplyPerspectiveDepth(40.0); 1578 transform_preventing_aa.RotateAboutYAxis(-20.0); 1579 transform_preventing_aa.Scale(30.0, 1.0); 1580 1581 // Verify that the test transform and test rect actually do cause the clipped 1582 // flag to trigger. Otherwise we are not testing the intended scenario. 1583 bool clipped = false; 1584 MathUtil::MapQuad(transform_preventing_aa, gfx::QuadF(child_rect), &clipped); 1585 ASSERT_TRUE(clipped); 1586 1587 child_pass = AddRenderPass(&render_passes_in_draw_order_, 1588 child_pass_id, 1589 child_rect, 1590 transform_preventing_aa); 1591 1592 root_pass = AddRenderPass(&render_passes_in_draw_order_, 1593 root_pass_id, 1594 viewport_rect, 1595 gfx::Transform()); 1596 1597 AddRenderPassQuad( 1598 root_pass, child_pass, 0, FilterOperations(), transform_preventing_aa); 1599 1600 renderer_->DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_); 1601 renderer_->DrawFrame(&render_passes_in_draw_order_, 1602 1.f, 1603 viewport_rect, 1604 viewport_rect, 1605 false); 1606 1607 // If use_aa incorrectly ignores clipping, it will use the 1608 // RenderPassProgramAA shader instead of the RenderPassProgram. 1609 TestRenderPassProgram(TexCoordPrecisionMedium); 1610 } 1611 1612 TEST_F(GLRendererShaderTest, DrawSolidColorShader) { 1613 gfx::Rect viewport_rect(1, 1); 1614 RenderPassId root_pass_id(1, 0); 1615 TestRenderPass* root_pass; 1616 1617 gfx::Transform pixel_aligned_transform_causing_aa; 1618 pixel_aligned_transform_causing_aa.Translate(25.5f, 25.5f); 1619 pixel_aligned_transform_causing_aa.Scale(0.5f, 0.5f); 1620 1621 root_pass = AddRenderPass(&render_passes_in_draw_order_, 1622 root_pass_id, 1623 viewport_rect, 1624 gfx::Transform()); 1625 AddTransformedQuad(root_pass, 1626 viewport_rect, 1627 SK_ColorYELLOW, 1628 pixel_aligned_transform_causing_aa); 1629 1630 renderer_->DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_); 1631 renderer_->DrawFrame(&render_passes_in_draw_order_, 1632 1.f, 1633 viewport_rect, 1634 viewport_rect, 1635 false); 1636 1637 TestSolidColorProgramAA(); 1638 } 1639 1640 class OutputSurfaceMockContext : public TestWebGraphicsContext3D { 1641 public: 1642 OutputSurfaceMockContext() { test_capabilities_.gpu.post_sub_buffer = true; } 1643 1644 // Specifically override methods even if they are unused (used in conjunction 1645 // with StrictMock). We need to make sure that GLRenderer does not issue 1646 // framebuffer-related GLuint calls directly. Instead these are supposed to go 1647 // through the OutputSurface abstraction. 1648 MOCK_METHOD2(bindFramebuffer, void(GLenum target, GLuint framebuffer)); 1649 MOCK_METHOD3(reshapeWithScaleFactor, 1650 void(int width, int height, float scale_factor)); 1651 MOCK_METHOD4(drawElements, 1652 void(GLenum mode, GLsizei count, GLenum type, GLintptr offset)); 1653 }; 1654 1655 class MockOutputSurface : public OutputSurface { 1656 public: 1657 MockOutputSurface() 1658 : OutputSurface( 1659 TestContextProvider::Create(scoped_ptr<TestWebGraphicsContext3D>( 1660 new StrictMock<OutputSurfaceMockContext>))) { 1661 surface_size_ = gfx::Size(100, 100); 1662 } 1663 virtual ~MockOutputSurface() {} 1664 1665 MOCK_METHOD0(EnsureBackbuffer, void()); 1666 MOCK_METHOD0(DiscardBackbuffer, void()); 1667 MOCK_METHOD2(Reshape, void(const gfx::Size& size, float scale_factor)); 1668 MOCK_METHOD0(BindFramebuffer, void()); 1669 MOCK_METHOD1(SwapBuffers, void(CompositorFrame* frame)); 1670 }; 1671 1672 class MockOutputSurfaceTest : public GLRendererTest { 1673 protected: 1674 virtual void SetUp() { 1675 FakeOutputSurfaceClient output_surface_client_; 1676 CHECK(output_surface_.BindToClient(&output_surface_client_)); 1677 1678 shared_bitmap_manager_.reset(new TestSharedBitmapManager()); 1679 resource_provider_ = ResourceProvider::Create(&output_surface_, 1680 shared_bitmap_manager_.get(), 1681 NULL, 1682 0, 1683 false, 1684 1, 1685 false).Pass(); 1686 1687 renderer_.reset(new FakeRendererGL(&renderer_client_, 1688 &settings_, 1689 &output_surface_, 1690 resource_provider_.get())); 1691 } 1692 1693 void SwapBuffers() { renderer_->SwapBuffers(CompositorFrameMetadata()); } 1694 1695 void DrawFrame(float device_scale_factor, 1696 const gfx::Rect& device_viewport_rect) { 1697 RenderPassId render_pass_id(1, 0); 1698 TestRenderPass* render_pass = AddRenderPass(&render_passes_in_draw_order_, 1699 render_pass_id, 1700 device_viewport_rect, 1701 gfx::Transform()); 1702 AddQuad(render_pass, device_viewport_rect, SK_ColorGREEN); 1703 1704 EXPECT_CALL(output_surface_, EnsureBackbuffer()).WillRepeatedly(Return()); 1705 1706 EXPECT_CALL(output_surface_, 1707 Reshape(device_viewport_rect.size(), device_scale_factor)) 1708 .Times(1); 1709 1710 EXPECT_CALL(output_surface_, BindFramebuffer()).Times(1); 1711 1712 EXPECT_CALL(*Context(), drawElements(_, _, _, _)).Times(1); 1713 1714 renderer_->DecideRenderPassAllocationsForFrame( 1715 render_passes_in_draw_order_); 1716 renderer_->DrawFrame(&render_passes_in_draw_order_, 1717 device_scale_factor, 1718 device_viewport_rect, 1719 device_viewport_rect, 1720 false); 1721 } 1722 1723 OutputSurfaceMockContext* Context() { 1724 return static_cast<OutputSurfaceMockContext*>( 1725 static_cast<TestContextProvider*>(output_surface_.context_provider()) 1726 ->TestContext3d()); 1727 } 1728 1729 LayerTreeSettings settings_; 1730 FakeOutputSurfaceClient output_surface_client_; 1731 StrictMock<MockOutputSurface> output_surface_; 1732 scoped_ptr<SharedBitmapManager> shared_bitmap_manager_; 1733 scoped_ptr<ResourceProvider> resource_provider_; 1734 FakeRendererClient renderer_client_; 1735 scoped_ptr<FakeRendererGL> renderer_; 1736 }; 1737 1738 TEST_F(MockOutputSurfaceTest, DrawFrameAndSwap) { 1739 gfx::Rect device_viewport_rect(1, 1); 1740 DrawFrame(1.f, device_viewport_rect); 1741 1742 EXPECT_CALL(output_surface_, SwapBuffers(_)).Times(1); 1743 renderer_->SwapBuffers(CompositorFrameMetadata()); 1744 } 1745 1746 TEST_F(MockOutputSurfaceTest, DrawFrameAndResizeAndSwap) { 1747 gfx::Rect device_viewport_rect(1, 1); 1748 1749 DrawFrame(1.f, device_viewport_rect); 1750 EXPECT_CALL(output_surface_, SwapBuffers(_)).Times(1); 1751 renderer_->SwapBuffers(CompositorFrameMetadata()); 1752 1753 device_viewport_rect = gfx::Rect(2, 2); 1754 1755 DrawFrame(2.f, device_viewport_rect); 1756 EXPECT_CALL(output_surface_, SwapBuffers(_)).Times(1); 1757 renderer_->SwapBuffers(CompositorFrameMetadata()); 1758 1759 DrawFrame(2.f, device_viewport_rect); 1760 EXPECT_CALL(output_surface_, SwapBuffers(_)).Times(1); 1761 renderer_->SwapBuffers(CompositorFrameMetadata()); 1762 1763 device_viewport_rect = gfx::Rect(1, 1); 1764 1765 DrawFrame(1.f, device_viewport_rect); 1766 EXPECT_CALL(output_surface_, SwapBuffers(_)).Times(1); 1767 renderer_->SwapBuffers(CompositorFrameMetadata()); 1768 } 1769 1770 class GLRendererTestSyncPoint : public GLRendererPixelTest { 1771 protected: 1772 static void SyncPointCallback(int* callback_count) { 1773 ++(*callback_count); 1774 base::MessageLoop::current()->QuitWhenIdle(); 1775 } 1776 1777 static void OtherCallback(int* callback_count) { 1778 ++(*callback_count); 1779 base::MessageLoop::current()->QuitWhenIdle(); 1780 } 1781 }; 1782 1783 #if !defined(OS_ANDROID) 1784 TEST_F(GLRendererTestSyncPoint, SignalSyncPointOnLostContext) { 1785 int sync_point_callback_count = 0; 1786 int other_callback_count = 0; 1787 gpu::gles2::GLES2Interface* gl = 1788 output_surface_->context_provider()->ContextGL(); 1789 gpu::ContextSupport* context_support = 1790 output_surface_->context_provider()->ContextSupport(); 1791 1792 uint32 sync_point = gl->InsertSyncPointCHROMIUM(); 1793 1794 gl->LoseContextCHROMIUM(GL_GUILTY_CONTEXT_RESET_ARB, 1795 GL_INNOCENT_CONTEXT_RESET_ARB); 1796 1797 context_support->SignalSyncPoint( 1798 sync_point, base::Bind(&SyncPointCallback, &sync_point_callback_count)); 1799 EXPECT_EQ(0, sync_point_callback_count); 1800 EXPECT_EQ(0, other_callback_count); 1801 1802 // Make the sync point happen. 1803 gl->Finish(); 1804 // Post a task after the sync point. 1805 base::MessageLoop::current()->PostTask( 1806 FROM_HERE, base::Bind(&OtherCallback, &other_callback_count)); 1807 1808 base::MessageLoop::current()->Run(); 1809 1810 // The sync point shouldn't have happened since the context was lost. 1811 EXPECT_EQ(0, sync_point_callback_count); 1812 EXPECT_EQ(1, other_callback_count); 1813 } 1814 1815 TEST_F(GLRendererTestSyncPoint, SignalSyncPoint) { 1816 int sync_point_callback_count = 0; 1817 int other_callback_count = 0; 1818 1819 gpu::gles2::GLES2Interface* gl = 1820 output_surface_->context_provider()->ContextGL(); 1821 gpu::ContextSupport* context_support = 1822 output_surface_->context_provider()->ContextSupport(); 1823 1824 uint32 sync_point = gl->InsertSyncPointCHROMIUM(); 1825 1826 context_support->SignalSyncPoint( 1827 sync_point, base::Bind(&SyncPointCallback, &sync_point_callback_count)); 1828 EXPECT_EQ(0, sync_point_callback_count); 1829 EXPECT_EQ(0, other_callback_count); 1830 1831 // Make the sync point happen. 1832 gl->Finish(); 1833 // Post a task after the sync point. 1834 base::MessageLoop::current()->PostTask( 1835 FROM_HERE, base::Bind(&OtherCallback, &other_callback_count)); 1836 1837 base::MessageLoop::current()->Run(); 1838 1839 // The sync point should have happened. 1840 EXPECT_EQ(1, sync_point_callback_count); 1841 EXPECT_EQ(1, other_callback_count); 1842 } 1843 #endif // OS_ANDROID 1844 1845 } // namespace 1846 } // namespace cc 1847
