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