src/cc/output/gl_renderer_unittest.cc

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