Remove offscreen compositor contexts.

cc/output/gl_renderer_unittest.cc

 // Copyright 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/output/gl_renderer.h"
 
 #include <set>
 
 #include "cc/base/math_util.h"
 #include "cc/output/compositor_frame_metadata.h"
@@ skipping 322 matching lines @@
   EXPECT_TRUE(renderer_->IsBackbufferDiscarded());
   EXPECT_EQ(1, renderer_client_.set_full_root_layer_damage_count());
 
   AddRenderPass(&render_passes_in_draw_order_,
                 RenderPass::Id(1, 0),
                 viewport_rect,
                 gfx::Transform());
 
   renderer_->SetVisible(true);
   renderer_->DrawFrame(&render_passes_in_draw_order_,
-                       NULL,
                        1.f,
                        viewport_rect,
                        viewport_rect,
                        false);
   EXPECT_FALSE(renderer_->IsBackbufferDiscarded());
 
   SwapBuffers();
   EXPECT_EQ(1u, output_surface_->num_sent_frames());
 }
 
 TEST_F(GLRendererWithDefaultHarnessTest,
        FramebufferDiscardedAfterReadbackWhenNotVisible) {
   gfx::Rect viewport_rect(1, 1);
   renderer_->SetVisible(false);
   EXPECT_TRUE(renderer_->IsBackbufferDiscarded());
   EXPECT_EQ(1, renderer_client_.set_full_root_layer_damage_count());
 
   AddRenderPass(&render_passes_in_draw_order_,
                 RenderPass::Id(1, 0),
                 viewport_rect,
                 gfx::Transform());
 
   char pixels[4];
   renderer_->DrawFrame(&render_passes_in_draw_order_,
-                       NULL,
                        1.f,
                        viewport_rect,
                        viewport_rect,
                        false);
   EXPECT_FALSE(renderer_->IsBackbufferDiscarded());
 
   renderer_->GetFramebufferPixels(pixels, gfx::Rect(0, 0, 1, 1));
   EXPECT_TRUE(renderer_->IsBackbufferDiscarded());
   EXPECT_EQ(2, renderer_client_.set_full_root_layer_damage_count());
 }
 
 TEST_F(GLRendererWithDefaultHarnessTest, ExternalStencil) {
   gfx::Rect viewport_rect(1, 1);
   EXPECT_FALSE(renderer_->stencil_enabled());
 
   output_surface_->set_has_external_stencil_test(true);
 
   TestRenderPass* root_pass = AddRenderPass(&render_passes_in_draw_order_,
                                             RenderPass::Id(1, 0),
                                             viewport_rect,
                                             gfx::Transform());
   root_pass->has_transparent_background = false;
 
   renderer_->DrawFrame(&render_passes_in_draw_order_,
-                       NULL,
                        1.f,
                        viewport_rect,
                        viewport_rect,
                        false);
   EXPECT_TRUE(renderer_->stencil_enabled());
 }
 
 class ForbidSynchronousCallContext : public TestWebGraphicsContext3D {
  public:
   ForbidSynchronousCallContext() {}
@@ skipping 209 matching lines @@
   // easily see regions that were not drawn on the screen.
   EXPECT_CALL(*context, discardFramebufferEXT(GL_FRAMEBUFFER, _, _))
       .With(Args<2, 1>(ElementsAre(GL_COLOR_EXT)))
       .Times(1);
 #ifdef NDEBUG
   EXPECT_CALL(*context, clear(_)).Times(0);
 #else
   EXPECT_CALL(*context, clear(_)).Times(1);
 #endif
   renderer.DrawFrame(&render_passes_in_draw_order_,
-                     NULL,
                      1.f,
                      viewport_rect,
                      viewport_rect,
                      false);
   Mock::VerifyAndClearExpectations(context);
 }
 
 TEST_F(GLRendererTest, TransparentBackground) {
   scoped_ptr<ClearCountingContext> context_owned(new ClearCountingContext);
   ClearCountingContext* context = context_owned.get();
@@ skipping 18 matching lines @@
   gfx::Rect viewport_rect(1, 1);
   TestRenderPass* root_pass = AddRenderPass(&render_passes_in_draw_order_,
                                             RenderPass::Id(1, 0),
                                             viewport_rect,
                                             gfx::Transform());
   root_pass->has_transparent_background = true;
 
   EXPECT_CALL(*context, discardFramebufferEXT(GL_FRAMEBUFFER, 1, _)).Times(1);
   EXPECT_CALL(*context, clear(_)).Times(1);
   renderer.DrawFrame(&render_passes_in_draw_order_,
-                     NULL,
                      1.f,
                      viewport_rect,
                      viewport_rect,
                      false);
 
   Mock::VerifyAndClearExpectations(context);
 }
 
 TEST_F(GLRendererTest, OffscreenOutputSurface) {
   scoped_ptr<ClearCountingContext> context_owned(new ClearCountingContext);
@@ skipping 20 matching lines @@
   AddRenderPass(&render_passes_in_draw_order_,
                 RenderPass::Id(1, 0),
                 viewport_rect,
                 gfx::Transform());
 
   EXPECT_CALL(*context, discardFramebufferEXT(GL_FRAMEBUFFER, _, _))
       .With(Args<2, 1>(ElementsAre(GL_COLOR_ATTACHMENT0)))
       .Times(1);
   EXPECT_CALL(*context, clear(_)).Times(AnyNumber());
   renderer.DrawFrame(&render_passes_in_draw_order_,
-                     NULL,
                      1.f,
                      viewport_rect,
                      viewport_rect,
                      false);
   Mock::VerifyAndClearExpectations(context);
 }
 
 class VisibilityChangeIsLastCallTrackingContext
     : public TestWebGraphicsContext3D {
  public:
@@ skipping 63 matching lines @@
                 viewport_rect,
                 gfx::Transform());
 
   // Ensure that the call to SetSurfaceVisible is the last call issue to the
   // GPU process, after glFlush is called, and after the RendererClient's
   // SetManagedMemoryPolicy is called. Plumb this tracking between both the
   // RenderClient and the Context by giving them both a pointer to a variable on
   // the stack.
   renderer.SetVisible(true);
   renderer.DrawFrame(&render_passes_in_draw_order_,
-                     NULL,
                      1.f,
                      viewport_rect,
                      viewport_rect,
                      false);
   renderer.SetVisible(false);
   EXPECT_TRUE(context->last_call_was_set_visibility());
 }
 
 class TextureStateTrackingContext : public TestWebGraphicsContext3D {
  public:
@@ skipping 74 matching lines @@
     // scaled_tile_quad also uses GL_LINEAR.
     EXPECT_CALL(*context, drawElements(_, _, _, _));
 
     // The remaining quads also use GL_LINEAR because nearest neighbor
     // filtering is currently only used with tile quads.
     EXPECT_CALL(*context, drawElements(_, _, _, _)).Times(6);
   }
 
   gfx::Rect viewport_rect(100, 100);
   renderer.DrawFrame(&render_passes_in_draw_order_,
-                     NULL,
                      1.f,
                      viewport_rect,
                      viewport_rect,
                      false);
   Mock::VerifyAndClearExpectations(context);
 }
 
 class NoClearRootRenderPassMockContext : public TestWebGraphicsContext3D {
  public:
   MOCK_METHOD1(clear, void(GLbitfield mask));
@@ skipping 57 matching lines @@
 
   // The second render pass is the root one, clearing should be prevented.
   EXPECT_CALL(*mock_context, clear(clear_bits)).Times(0).After(
       first_render_pass);
 
   EXPECT_CALL(*mock_context, drawElements(_, _, _, _)).Times(AnyNumber()).After(
       first_render_pass);
 
   renderer.DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_);
   renderer.DrawFrame(&render_passes_in_draw_order_,
-                     NULL,
                      1.f,
                      viewport_rect,
                      viewport_rect,
                      false);
 
   // In multiple render passes all but the root pass should clear the
   // framebuffer.
   Mock::VerifyAndClearExpectations(&mock_context);
 }
 
@@ skipping 63 matching lines @@
                                             root_pass_id,
                                             viewport_rect,
                                             gfx::Transform());
   AddQuad(root_pass, viewport_rect, SK_ColorGREEN);
 
   AddRenderPassQuad(root_pass, child_pass);
   AddRenderPassQuad(child_pass, grand_child_pass);
 
   renderer.DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_);
   renderer.DrawFrame(&render_passes_in_draw_order_,
-                     NULL,
                      1.f,
                      viewport_rect,
                      viewport_rect,
                      false);
 }
 
 class DiscardCheckingContext : public TestWebGraphicsContext3D {
  public:
   DiscardCheckingContext() : discarded_(0) {
     set_have_post_sub_buffer(true);
@@ skipping 58 matching lines @@
     RenderPass::Id root_pass_id(1, 0);
     TestRenderPass* root_pass = AddRenderPass(&render_passes_in_draw_order_,
                                               root_pass_id,
                                               viewport_rect,
                                               gfx::Transform());
     AddQuad(root_pass, viewport_rect, SK_ColorGREEN);
     root_pass->damage_rect = gfx::Rect(2, 2, 3, 3);
 
     renderer.DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_);
     renderer.DrawFrame(&render_passes_in_draw_order_,
-                       NULL,
                        1.f,
                        viewport_rect,
                        clip_rect,
                        false);
     EXPECT_EQ(0, context->discarded());
     context->reset();
   }
   {
     // Full frame, should discard.
     RenderPass::Id root_pass_id(1, 0);
     TestRenderPass* root_pass = AddRenderPass(&render_passes_in_draw_order_,
                                               root_pass_id,
                                               viewport_rect,
                                               gfx::Transform());
     AddQuad(root_pass, viewport_rect, SK_ColorGREEN);
     root_pass->damage_rect = root_pass->output_rect;
 
     renderer.DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_);
     renderer.DrawFrame(&render_passes_in_draw_order_,
-                       NULL,
                        1.f,
                        viewport_rect,
                        clip_rect,
                        false);
     EXPECT_EQ(1, context->discarded());
     context->reset();
   }
   {
     // Full frame, external scissor is set, should not discard.
     output_surface->set_has_external_stencil_test(true);
     RenderPass::Id root_pass_id(1, 0);
     TestRenderPass* root_pass = AddRenderPass(&render_passes_in_draw_order_,
                                               root_pass_id,
                                               viewport_rect,
                                               gfx::Transform());
     AddQuad(root_pass, viewport_rect, SK_ColorGREEN);
     root_pass->damage_rect = root_pass->output_rect;
     root_pass->has_transparent_background = false;
 
     renderer.DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_);
     renderer.DrawFrame(&render_passes_in_draw_order_,
-                       NULL,
                        1.f,
                        viewport_rect,
                        clip_rect,
                        false);
     EXPECT_EQ(0, context->discarded());
     context->reset();
     output_surface->set_has_external_stencil_test(false);
   }
   {
     // Full frame, clipped, should not discard.
     clip_rect = gfx::Rect(10, 10, 10, 10);
     RenderPass::Id root_pass_id(1, 0);
     TestRenderPass* root_pass = AddRenderPass(&render_passes_in_draw_order_,
                                               root_pass_id,
                                               viewport_rect,
                                               gfx::Transform());
     AddQuad(root_pass, viewport_rect, SK_ColorGREEN);
     root_pass->damage_rect = root_pass->output_rect;
 
     renderer.DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_);
     renderer.DrawFrame(&render_passes_in_draw_order_,
-                       NULL,
                        1.f,
                        viewport_rect,
                        clip_rect,
                        false);
     EXPECT_EQ(0, context->discarded());
     context->reset();
   }
   {
     // Full frame, doesn't cover the surface, should not discard.
     viewport_rect = gfx::Rect(10, 10, 10, 10);
     RenderPass::Id root_pass_id(1, 0);
     TestRenderPass* root_pass = AddRenderPass(&render_passes_in_draw_order_,
                                               root_pass_id,
                                               viewport_rect,
                                               gfx::Transform());
     AddQuad(root_pass, viewport_rect, SK_ColorGREEN);
     root_pass->damage_rect = root_pass->output_rect;
 
     renderer.DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_);
     renderer.DrawFrame(&render_passes_in_draw_order_,
-                       NULL,
                        1.f,
                        viewport_rect,
                        clip_rect,
                        false);
     EXPECT_EQ(0, context->discarded());
     context->reset();
   }
   {
     // Full frame, doesn't cover the surface (no offset), should not discard.
     clip_rect = gfx::Rect(100, 100);
     viewport_rect = gfx::Rect(50, 50);
     RenderPass::Id root_pass_id(1, 0);
     TestRenderPass* root_pass = AddRenderPass(&render_passes_in_draw_order_,
                                               root_pass_id,
                                               viewport_rect,
                                               gfx::Transform());
     AddQuad(root_pass, viewport_rect, SK_ColorGREEN);
     root_pass->damage_rect = root_pass->output_rect;
 
     renderer.DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_);
     renderer.DrawFrame(&render_passes_in_draw_order_,
-                       NULL,
                        1.f,
                        viewport_rect,
                        clip_rect,
                        false);
     EXPECT_EQ(0, context->discarded());
     context->reset();
   }
 }
 
 class FlippedScissorAndViewportContext : public TestWebGraphicsContext3D {
@@ skipping 60 matching lines @@
 
   RenderPass::Id root_pass_id(1, 0);
   TestRenderPass* root_pass = AddRenderPass(&render_passes_in_draw_order_,
                                             root_pass_id,
                                             viewport_rect,
                                             gfx::Transform());
   AddClippedQuad(root_pass, quad_rect, SK_ColorGREEN);
 
   renderer.DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_);
   renderer.DrawFrame(&render_passes_in_draw_order_,
-                     NULL,
                      1.f,
                      device_viewport_rect,
                      device_viewport_rect,
                      false);
 }
 
 TEST_F(GLRendererShaderTest, DrawRenderPassQuadShaderPermutations) {
   gfx::Rect viewport_rect(1, 1);
 
   gfx::Rect child_rect(50, 50);
@@ skipping 45 matching lines @@
   root_pass = AddRenderPass(&render_passes_in_draw_order_,
                             root_pass_id,
                             viewport_rect,
                             gfx::Transform());
 
   AddRenderPassQuad(
       root_pass, child_pass, 0, FilterOperations(), gfx::Transform());
 
   renderer_->DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_);
   renderer_->DrawFrame(&render_passes_in_draw_order_,
-                       NULL,
                        1.f,
                        viewport_rect,
                        viewport_rect,
                        false);
   TestRenderPassProgram(TexCoordPrecisionMedium);
 
   // RenderPassColorMatrixProgram
   render_passes_in_draw_order_.clear();
 
   child_pass = AddRenderPass(&render_passes_in_draw_order_,
                              child_pass_id,
                              child_rect,
                              transform_causing_aa);
 
   root_pass = AddRenderPass(&render_passes_in_draw_order_,
                             root_pass_id,
                             viewport_rect,
                             gfx::Transform());
 
   AddRenderPassQuad(root_pass, child_pass, 0, filters, gfx::Transform());
 
   renderer_->DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_);
   renderer_->DrawFrame(&render_passes_in_draw_order_,
-                       NULL,
                        1.f,
                        viewport_rect,
                        viewport_rect,
                        false);
   TestRenderPassColorMatrixProgram(TexCoordPrecisionMedium);
 
   // RenderPassMaskProgram
   render_passes_in_draw_order_.clear();
 
   child_pass = AddRenderPass(&render_passes_in_draw_order_,
                              child_pass_id,
                              child_rect,
                              gfx::Transform());
 
   root_pass = AddRenderPass(&render_passes_in_draw_order_,
                             root_pass_id,
                             viewport_rect,
                             gfx::Transform());
 
   AddRenderPassQuad(
       root_pass, child_pass, mask, FilterOperations(), gfx::Transform());
 
   renderer_->DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_);
   renderer_->DrawFrame(&render_passes_in_draw_order_,
-                       NULL,
                        1.f,
                        viewport_rect,
                        viewport_rect,
                        false);
   TestRenderPassMaskProgram(TexCoordPrecisionMedium);
 
   // RenderPassMaskColorMatrixProgram
   render_passes_in_draw_order_.clear();
 
   child_pass = AddRenderPass(&render_passes_in_draw_order_,
                              child_pass_id,
                              child_rect,
                              gfx::Transform());
 
   root_pass = AddRenderPass(&render_passes_in_draw_order_,
                             root_pass_id,
                             viewport_rect,
                             gfx::Transform());
 
   AddRenderPassQuad(root_pass, child_pass, mask, filters, gfx::Transform());
 
   renderer_->DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_);
   renderer_->DrawFrame(&render_passes_in_draw_order_,
-                       NULL,
                        1.f,
                        viewport_rect,
                        viewport_rect,
                        false);
   TestRenderPassMaskColorMatrixProgram(TexCoordPrecisionMedium);
 
   // RenderPassProgramAA
   render_passes_in_draw_order_.clear();
 
   child_pass = AddRenderPass(&render_passes_in_draw_order_,
                              child_pass_id,
                              child_rect,
                              transform_causing_aa);
 
   root_pass = AddRenderPass(&render_passes_in_draw_order_,
                             root_pass_id,
                             viewport_rect,
                             gfx::Transform());
 
   AddRenderPassQuad(
       root_pass, child_pass, 0, FilterOperations(), transform_causing_aa);
 
   renderer_->DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_);
   renderer_->DrawFrame(&render_passes_in_draw_order_,
-                       NULL,
                        1.f,
                        viewport_rect,
                        viewport_rect,
                        false);
   TestRenderPassProgramAA(TexCoordPrecisionMedium);
 
   // RenderPassColorMatrixProgramAA
   render_passes_in_draw_order_.clear();
 
   child_pass = AddRenderPass(&render_passes_in_draw_order_,
                              child_pass_id,
                              child_rect,
                              transform_causing_aa);
 
   root_pass = AddRenderPass(&render_passes_in_draw_order_,
                             root_pass_id,
                             viewport_rect,
                             gfx::Transform());
 
   AddRenderPassQuad(root_pass, child_pass, 0, filters, transform_causing_aa);
 
   renderer_->DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_);
   renderer_->DrawFrame(&render_passes_in_draw_order_,
-                       NULL,
                        1.f,
                        viewport_rect,
                        viewport_rect,
                        false);
   TestRenderPassColorMatrixProgramAA(TexCoordPrecisionMedium);
 
   // RenderPassMaskProgramAA
   render_passes_in_draw_order_.clear();
 
   child_pass = AddRenderPass(&render_passes_in_draw_order_,
                              child_pass_id,
                              child_rect,
                              transform_causing_aa);
 
   root_pass = AddRenderPass(&render_passes_in_draw_order_,
                             root_pass_id,
                             viewport_rect,
                             gfx::Transform());
 
   AddRenderPassQuad(
       root_pass, child_pass, mask, FilterOperations(), transform_causing_aa);
 
   renderer_->DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_);
   renderer_->DrawFrame(&render_passes_in_draw_order_,
-                       NULL,
                        1.f,
                        viewport_rect,
                        viewport_rect,
                        false);
   TestRenderPassMaskProgramAA(TexCoordPrecisionMedium);
 
   // RenderPassMaskColorMatrixProgramAA
   render_passes_in_draw_order_.clear();
 
   child_pass = AddRenderPass(&render_passes_in_draw_order_,
                              child_pass_id,
                              child_rect,
                              transform_causing_aa);
 
   root_pass = AddRenderPass(&render_passes_in_draw_order_,
                             root_pass_id,
                             viewport_rect,
                             transform_causing_aa);
 
   AddRenderPassQuad(root_pass, child_pass, mask, filters, transform_causing_aa);
 
   renderer_->DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_);
   renderer_->DrawFrame(&render_passes_in_draw_order_,
-                       NULL,
                        1.f,
                        viewport_rect,
                        viewport_rect,
                        false);
   TestRenderPassMaskColorMatrixProgramAA(TexCoordPrecisionMedium);
 }
 
 // At this time, the AA code path cannot be taken if the surface's rect would
 // project incorrectly by the given transform, because of w<0 clipping.
 TEST_F(GLRendererShaderTest, DrawRenderPassQuadSkipsAAForClippingTransform) {
@@ skipping 24 matching lines @@
   root_pass = AddRenderPass(&render_passes_in_draw_order_,
                             root_pass_id,
                             viewport_rect,
                             gfx::Transform());
 
   AddRenderPassQuad(
       root_pass, child_pass, 0, FilterOperations(), transform_preventing_aa);
 
   renderer_->DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_);
   renderer_->DrawFrame(&render_passes_in_draw_order_,
-                       NULL,
                        1.f,
                        viewport_rect,
                        viewport_rect,
                        false);
 
   // If use_aa incorrectly ignores clipping, it will use the
   // RenderPassProgramAA shader instead of the RenderPassProgram.
   TestRenderPassProgram(TexCoordPrecisionMedium);
 }
 
@@ skipping 10 matching lines @@
                             root_pass_id,
                             viewport_rect,
                             gfx::Transform());
   AddTransformedQuad(root_pass,
                      viewport_rect,
                      SK_ColorYELLOW,
                      pixel_aligned_transform_causing_aa);
 
   renderer_->DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_);
   renderer_->DrawFrame(&render_passes_in_draw_order_,
-                       NULL,
                        1.f,
                        viewport_rect,
                        viewport_rect,
                        false);
 
   TestSolidColorProgramAA();
 }
 
 class OutputSurfaceMockContext : public TestWebGraphicsContext3D {
  public:
@@ skipping 61 matching lines @@
                 Reshape(device_viewport_rect.size(), device_scale_factor))
         .Times(1);
 
     EXPECT_CALL(output_surface_, BindFramebuffer()).Times(1);
 
     EXPECT_CALL(*Context(), drawElements(_, _, _, _)).Times(1);
 
     renderer_->DecideRenderPassAllocationsForFrame(
         render_passes_in_draw_order_);
     renderer_->DrawFrame(&render_passes_in_draw_order_,
-                         NULL,
                          device_scale_factor,
                          device_viewport_rect,
                          device_viewport_rect,
                          false);
   }
 
   OutputSurfaceMockContext* Context() {
     return static_cast<OutputSurfaceMockContext*>(
         static_cast<TestContextProvider*>(
             output_surface_.context_provider().get())->TestContext3d());
@@ skipping 110 matching lines @@
   base::MessageLoop::current()->Run();
 
   // The sync point should have happened.
   EXPECT_EQ(1, sync_point_callback_count);
   EXPECT_EQ(1, other_callback_count);
 }
 #endif  // OS_ANDROID
 
 }  // namespace
 }  // namespace cc