cc: Delete the RendererClient class.

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 <stdint.h>
 
 #include <set>
 
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "cc/base/math_util.h"
 #include "cc/output/compositor_frame_metadata.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/output/copy_output_result.h"
 #include "cc/output/overlay_strategy_single_on_top.h"
 #include "cc/output/overlay_strategy_underlay.h"
 #include "cc/output/texture_mailbox_deleter.h"
 #include "cc/quads/texture_draw_quad.h"
 #include "cc/resources/resource_provider.h"
 #include "cc/test/fake_impl_task_runner_provider.h"
 #include "cc/test/fake_layer_tree_host_impl.h"
 #include "cc/test/fake_output_surface.h"
 #include "cc/test/fake_output_surface_client.h"
-#include "cc/test/fake_renderer_client.h"
 #include "cc/test/fake_resource_provider.h"
 #include "cc/test/pixel_test.h"
 #include "cc/test/render_pass_test_utils.h"
 #include "cc/test/test_gles2_interface.h"
 #include "cc/test/test_shared_bitmap_manager.h"
 #include "cc/test/test_web_graphics_context_3d.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "gpu/command_buffer/client/context_support.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 270 matching lines @@
                         MaskShaderPixelTest,
                         ::testing::Combine(::testing::ValuesIn(kPrecisionList),
                                            ::testing::ValuesIn(kSamplerList),
                                            ::testing::ValuesIn(kBlendModeList),
                                            ::testing::Bool()));
 
 #endif
 
 class FakeRendererGL : public GLRenderer {
  public:
-  FakeRendererGL(RendererClient* client,
-                 const RendererSettings* settings,
+  FakeRendererGL(const RendererSettings* settings,
                  OutputSurface* output_surface,
                  ResourceProvider* resource_provider)
-      : GLRenderer(client,
-                   settings,
-                   output_surface,
-                   resource_provider,
-                   NULL,
-                   0) {}
+      : GLRenderer(settings, output_surface, resource_provider, nullptr, 0) {}
 
-  FakeRendererGL(RendererClient* client,
-                 const RendererSettings* settings,
+  FakeRendererGL(const RendererSettings* settings,
                  OutputSurface* output_surface,
                  ResourceProvider* resource_provider,
                  TextureMailboxDeleter* texture_mailbox_deleter)
-      : GLRenderer(client,
-                   settings,
+      : GLRenderer(settings,
                    output_surface,
                    resource_provider,
                    texture_mailbox_deleter,
                    0) {}
 
   void SetOverlayProcessor(OverlayProcessor* processor) {
     overlay_processor_.reset(processor);
   }
 
   // GLRenderer methods.
 
   // Changing visibility to public.
-  using GLRenderer::IsBackbufferDiscarded;
   using GLRenderer::DoDrawQuad;
   using GLRenderer::BeginDrawingFrame;
   using GLRenderer::FinishDrawingQuadList;
   using GLRenderer::stencil_enabled;
 };
 
 class GLRendererWithDefaultHarnessTest : public GLRendererTest {
  protected:
   GLRendererWithDefaultHarnessTest() {
     output_surface_ =
         FakeOutputSurface::Create3d(TestWebGraphicsContext3D::Create());
     CHECK(output_surface_->BindToClient(&output_surface_client_));
 
     shared_bitmap_manager_.reset(new TestSharedBitmapManager());
     resource_provider_ = FakeResourceProvider::Create(
         output_surface_.get(), shared_bitmap_manager_.get());
-    renderer_ = base::WrapUnique(
-        new FakeRendererGL(&renderer_client_, &settings_, output_surface_.get(),
-                           resource_provider_.get()));
+    renderer_ = base::WrapUnique(new FakeRendererGL(
+        &settings_, output_surface_.get(), resource_provider_.get()));
     renderer_->SetVisible(true);
   }
 
   void SwapBuffers() { renderer_->SwapBuffers(CompositorFrameMetadata()); }
 
   RendererSettings settings_;
   FakeOutputSurfaceClient output_surface_client_;
   std::unique_ptr<FakeOutputSurface> output_surface_;
-  FakeRendererClient renderer_client_;
   std::unique_ptr<SharedBitmapManager> shared_bitmap_manager_;
   std::unique_ptr<ResourceProvider> resource_provider_;
   std::unique_ptr<FakeRendererGL> renderer_;
 };
 
 // Closing the namespace here so that GLRendererShaderTest can take advantage
 // of the friend relationship with GLRenderer and all of the mock classes
 // declared above it.
 }  // namespace
 
 class GLRendererShaderTest : public GLRendererTest {
  protected:
   GLRendererShaderTest() {
     output_surface_ = FakeOutputSurface::Create3d();
     CHECK(output_surface_->BindToClient(&output_surface_client_));
 
     shared_bitmap_manager_.reset(new TestSharedBitmapManager());
     resource_provider_ = FakeResourceProvider::Create(
         output_surface_.get(), shared_bitmap_manager_.get());
-    renderer_.reset(new FakeRendererGL(&renderer_client_,
-                                       &settings_,
-                                       output_surface_.get(),
+    renderer_.reset(new FakeRendererGL(&settings_, output_surface_.get(),
                                        resource_provider_.get()));
     renderer_->SetVisible(true);
   }
 
   void TestRenderPassProgram(TexCoordPrecision precision,
                              BlendMode blend_mode) {
     EXPECT_PROGRAM_VALID(
         &renderer_->render_pass_program_[precision][blend_mode]);
     EXPECT_EQ(renderer_->render_pass_program_[precision][blend_mode].program(),
               renderer_->program_shadow_);
@@ skipping 80 matching lines @@
 
   void TestSolidColorProgramAA() {
     EXPECT_PROGRAM_VALID(&renderer_->solid_color_program_aa_);
     EXPECT_EQ(renderer_->solid_color_program_aa_.program(),
               renderer_->program_shadow_);
   }
 
   RendererSettings settings_;
   FakeOutputSurfaceClient output_surface_client_;
   std::unique_ptr<FakeOutputSurface> output_surface_;
-  FakeRendererClient renderer_client_;
   std::unique_ptr<SharedBitmapManager> shared_bitmap_manager_;
   std::unique_ptr<ResourceProvider> resource_provider_;
   std::unique_ptr<FakeRendererGL> renderer_;
 };
 
 namespace {
 
-// Test GLRenderer DiscardBackbuffer functionality:
-// Suggest discarding framebuffer when one exists and the renderer is not
-// visible.
-// Expected: it is discarded and damage tracker is reset.
-TEST_F(
-    GLRendererWithDefaultHarnessTest,
-    SuggestBackbufferNoShouldDiscardBackbufferAndDamageRootLayerIfNotVisible) {
-  renderer_->SetVisible(false);
-  EXPECT_EQ(1, renderer_client_.set_full_root_layer_damage_count());
-  EXPECT_TRUE(renderer_->IsBackbufferDiscarded());
-}
-
-// Test GLRenderer DiscardBackbuffer functionality:
-// Suggest discarding framebuffer when one exists and the renderer is visible.
-// Expected: the allocation is ignored.
-TEST_F(GLRendererWithDefaultHarnessTest,
-       SuggestBackbufferNoDoNothingWhenVisible) {
-  renderer_->SetVisible(true);
-  EXPECT_EQ(0, renderer_client_.set_full_root_layer_damage_count());
-  EXPECT_FALSE(renderer_->IsBackbufferDiscarded());
-}
-
-// Test GLRenderer DiscardBackbuffer functionality:
-// Suggest discarding framebuffer when one does not exist.
-// Expected: it does nothing.
-TEST_F(GLRendererWithDefaultHarnessTest,
-       SuggestBackbufferNoWhenItDoesntExistShouldDoNothing) {
-  renderer_->SetVisible(false);
-  EXPECT_EQ(1, renderer_client_.set_full_root_layer_damage_count());
-  EXPECT_TRUE(renderer_->IsBackbufferDiscarded());
-
-  EXPECT_EQ(1, renderer_client_.set_full_root_layer_damage_count());
-  EXPECT_TRUE(renderer_->IsBackbufferDiscarded());
-}
-
-// Test GLRenderer DiscardBackbuffer functionality:
-// Begin drawing a frame while a framebuffer is discarded.
-// Expected: will recreate framebuffer.
-TEST_F(GLRendererWithDefaultHarnessTest,
-       DiscardedBackbufferIsRecreatedForScopeDuration) {
-  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_,
-                RenderPassId(1, 0),
-                viewport_rect,
-                gfx::Transform());
-
-  renderer_->SetVisible(true);
-  DrawFrame(renderer_.get(), viewport_rect);
-  EXPECT_FALSE(renderer_->IsBackbufferDiscarded());
-
-  SwapBuffers();
-  EXPECT_EQ(1u, output_surface_->num_sent_frames());
-}
-
 TEST_F(GLRendererWithDefaultHarnessTest, ExternalStencil) {
   gfx::Rect viewport_rect(1, 1);
   EXPECT_FALSE(renderer_->stencil_enabled());
 
   output_surface_->set_has_external_stencil_test(true);
 
   RenderPass* root_pass =
       AddRenderPass(&render_passes_in_draw_order_, RenderPassId(1, 0),
                     viewport_rect, gfx::Transform());
   root_pass->has_transparent_background = false;
@@ skipping 106 matching lines @@
           new ForbidSynchronousCallContext)));
   CHECK(output_surface->BindToClient(&output_surface_client));
 
   std::unique_ptr<SharedBitmapManager> shared_bitmap_manager(
       new TestSharedBitmapManager());
   std::unique_ptr<ResourceProvider> resource_provider =
       FakeResourceProvider::Create(output_surface.get(),
                                    shared_bitmap_manager.get());
 
   RendererSettings settings;
-  FakeRendererClient renderer_client;
-  FakeRendererGL renderer(&renderer_client,
-                          &settings,
-                          output_surface.get(),
+  FakeRendererGL renderer(&settings, output_surface.get(),
                           resource_provider.get());
 }
 
 class LoseContextOnFirstGetContext : public TestWebGraphicsContext3D {
  public:
   LoseContextOnFirstGetContext() {}
 
   void getProgramiv(GLuint program, GLenum pname, GLint* value) override {
     context_lost_ = true;
     *value = 0;
@@ skipping 12 matching lines @@
           new LoseContextOnFirstGetContext)));
   CHECK(output_surface->BindToClient(&output_surface_client));
 
   std::unique_ptr<SharedBitmapManager> shared_bitmap_manager(
       new TestSharedBitmapManager());
   std::unique_ptr<ResourceProvider> resource_provider =
       FakeResourceProvider::Create(output_surface.get(),
                                    shared_bitmap_manager.get());
 
   RendererSettings settings;
-  FakeRendererClient renderer_client;
-  FakeRendererGL renderer(&renderer_client,
-                          &settings,
-                          output_surface.get(),
+  FakeRendererGL renderer(&settings, output_surface.get(),
                           resource_provider.get());
 }
 
 class ClearCountingContext : public TestWebGraphicsContext3D {
  public:
   ClearCountingContext() { test_capabilities_.discard_framebuffer = true; }
 
   MOCK_METHOD3(discardFramebufferEXT,
                void(GLenum target,
                     GLsizei numAttachments,
@@ skipping 10 matching lines @@
       FakeOutputSurface::Create3d(std::move(context_owned)));
   CHECK(output_surface->BindToClient(&output_surface_client));
 
   std::unique_ptr<SharedBitmapManager> shared_bitmap_manager(
       new TestSharedBitmapManager());
   std::unique_ptr<ResourceProvider> resource_provider =
       FakeResourceProvider::Create(output_surface.get(),
                                    shared_bitmap_manager.get());
 
   RendererSettings settings;
-  FakeRendererClient renderer_client;
-  FakeRendererGL renderer(&renderer_client,
-                          &settings,
-                          output_surface.get(),
+  FakeRendererGL renderer(&settings, output_surface.get(),
                           resource_provider.get());
   renderer.SetVisible(true);
 
   gfx::Rect viewport_rect(1, 1);
   RenderPass* root_pass =
       AddRenderPass(&render_passes_in_draw_order_, RenderPassId(1, 0),
                     viewport_rect, gfx::Transform());
   root_pass->has_transparent_background = false;
 
   // On DEBUG builds, render passes with opaque background clear to blue to
@@ skipping 19 matching lines @@
       FakeOutputSurface::Create3d(std::move(context_owned)));
   CHECK(output_surface->BindToClient(&output_surface_client));
 
   std::unique_ptr<SharedBitmapManager> shared_bitmap_manager(
       new TestSharedBitmapManager());
   std::unique_ptr<ResourceProvider> resource_provider =
       FakeResourceProvider::Create(output_surface.get(),
                                    shared_bitmap_manager.get());
 
   RendererSettings settings;
-  FakeRendererClient renderer_client;
-  FakeRendererGL renderer(&renderer_client,
-                          &settings,
-                          output_surface.get(),
+  FakeRendererGL renderer(&settings, output_surface.get(),
                           resource_provider.get());
   renderer.SetVisible(true);
 
   gfx::Rect viewport_rect(1, 1);
   RenderPass* root_pass =
       AddRenderPass(&render_passes_in_draw_order_, RenderPassId(1, 0),
                     viewport_rect, gfx::Transform());
   root_pass->has_transparent_background = true;
 
   EXPECT_CALL(*context, discardFramebufferEXT(GL_FRAMEBUFFER, 1, _)).Times(1);
@@ skipping 12 matching lines @@
       FakeOutputSurface::CreateOffscreen(std::move(context_owned)));
   CHECK(output_surface->BindToClient(&output_surface_client));
 
   std::unique_ptr<SharedBitmapManager> shared_bitmap_manager(
       new TestSharedBitmapManager());
   std::unique_ptr<ResourceProvider> resource_provider =
       FakeResourceProvider::Create(output_surface.get(),
                                    shared_bitmap_manager.get());
 
   RendererSettings settings;
-  FakeRendererClient renderer_client;
-  FakeRendererGL renderer(&renderer_client,
-                          &settings,
-                          output_surface.get(),
+  FakeRendererGL renderer(&settings, output_surface.get(),
                           resource_provider.get());
   renderer.SetVisible(true);
 
   gfx::Rect viewport_rect(1, 1);
   AddRenderPass(&render_passes_in_draw_order_,
                 RenderPassId(1, 0),
                 viewport_rect,
                 gfx::Transform());
 
   EXPECT_CALL(*context, discardFramebufferEXT(GL_FRAMEBUFFER, _, _))
@@ skipping 36 matching lines @@
       FakeOutputSurface::Create3d(std::move(context_owned)));
   CHECK(output_surface->BindToClient(&output_surface_client));
 
   std::unique_ptr<SharedBitmapManager> shared_bitmap_manager(
       new TestSharedBitmapManager());
   std::unique_ptr<ResourceProvider> resource_provider =
       FakeResourceProvider::Create(output_surface.get(),
                                    shared_bitmap_manager.get());
 
   RendererSettings settings;
-  FakeRendererClient renderer_client;
-  FakeRendererGL renderer(&renderer_client,
-                          &settings,
-                          output_surface.get(),
+  FakeRendererGL renderer(&settings, output_surface.get(),
                           resource_provider.get());
   renderer.SetVisible(true);
 
   // During initialization we are allowed to set any texture parameters.
   EXPECT_CALL(*context, texParameteri(_, _, _)).Times(AnyNumber());
 
   RenderPass* root_pass =
       AddRenderPass(&render_passes_in_draw_order_, RenderPassId(1, 1),
                     gfx::Rect(100, 100), gfx::Transform());
   gpu::SyncToken mailbox_sync_token;
@@ skipping 61 matching lines @@
 
   std::unique_ptr<SharedBitmapManager> shared_bitmap_manager(
       new TestSharedBitmapManager());
   std::unique_ptr<ResourceProvider> resource_provider =
       FakeResourceProvider::Create(output_surface.get(),
                                    shared_bitmap_manager.get());
 
   RendererSettings settings;
   settings.should_clear_root_render_pass = false;
 
-  FakeRendererClient renderer_client;
-  FakeRendererGL renderer(&renderer_client,
-                          &settings,
-                          output_surface.get(),
+  FakeRendererGL renderer(&settings, output_surface.get(),
                           resource_provider.get());
   renderer.SetVisible(true);
 
   gfx::Rect viewport_rect(10, 10);
 
   RenderPassId child_pass_id(2, 0);
   RenderPass* child_pass =
       AddRenderPass(&render_passes_in_draw_order_, child_pass_id, viewport_rect,
                     gfx::Transform());
   AddQuad(child_pass, viewport_rect, SK_ColorBLUE);
@@ skipping 62 matching lines @@
       TestContextProvider::Create(std::move(gl_owned))));
   CHECK(output_surface->BindToClient(&output_surface_client));
 
   std::unique_ptr<SharedBitmapManager> shared_bitmap_manager(
       new TestSharedBitmapManager());
   std::unique_ptr<ResourceProvider> resource_provider =
       FakeResourceProvider::Create(output_surface.get(),
                                    shared_bitmap_manager.get());
 
   RendererSettings settings;
-  FakeRendererClient renderer_client;
-  FakeRendererGL renderer(&renderer_client,
-                          &settings,
-                          output_surface.get(),
+  FakeRendererGL renderer(&settings, output_surface.get(),
                           resource_provider.get());
   EXPECT_FALSE(renderer.Capabilities().using_partial_swap);
   renderer.SetVisible(true);
 
   gfx::Rect viewport_rect(1, 1);
 
   gfx::Rect grand_child_rect(25, 25);
   RenderPassId grand_child_pass_id(3, 0);
   RenderPass* grand_child_pass =
       AddRenderPass(&render_passes_in_draw_order_, grand_child_pass_id,
@@ skipping 68 matching lines @@
   output_surface->set_fixed_size(gfx::Size(100, 100));
 
   std::unique_ptr<SharedBitmapManager> shared_bitmap_manager(
       new TestSharedBitmapManager());
   std::unique_ptr<ResourceProvider> resource_provider =
       FakeResourceProvider::Create(output_surface.get(),
                                    shared_bitmap_manager.get());
 
   RendererSettings settings;
   settings.partial_swap_enabled = true;
-  FakeRendererClient renderer_client;
-  FakeRendererGL renderer(&renderer_client,
-                          &settings,
-                          output_surface.get(),
+  FakeRendererGL renderer(&settings, output_surface.get(),
                           resource_provider.get());
   EXPECT_TRUE(renderer.Capabilities().using_partial_swap);
   renderer.SetVisible(true);
 
   gfx::Rect viewport_rect(100, 100);
   gfx::Rect clip_rect(100, 100);
 
   {
     // Partial frame, should not discard.
     RenderPassId root_pass_id(1, 0);
@@ skipping 111 matching lines @@
       new NonReshapableOutputSurface(std::move(gl_owned)));
   CHECK(output_surface->BindToClient(&output_surface_client));
 
   std::unique_ptr<SharedBitmapManager> shared_bitmap_manager(
       new TestSharedBitmapManager());
   std::unique_ptr<ResourceProvider> resource_provider =
       FakeResourceProvider::Create(output_surface.get(),
                                    shared_bitmap_manager.get());
 
   RendererSettings settings;
-  FakeRendererClient renderer_client;
-  FakeRendererGL renderer(&renderer_client,
-                          &settings,
-                          output_surface.get(),
+  FakeRendererGL renderer(&settings, output_surface.get(),
                           resource_provider.get());
   EXPECT_FALSE(renderer.Capabilities().using_partial_swap);
   renderer.SetVisible(true);
 
   gfx::Rect device_viewport_rect(10, 10, 100, 100);
   gfx::Rect viewport_rect(device_viewport_rect.size());
   gfx::Rect quad_rect = gfx::Rect(20, 20, 20, 20);
 
   RenderPassId root_pass_id(1, 0);
   RenderPass* root_pass =
@@ skipping 16 matching lines @@
       FakeOutputSurface::Create3d(TestWebGraphicsContext3D::Create()));
   CHECK(output_surface->BindToClient(&output_surface_client));
 
   std::unique_ptr<SharedBitmapManager> shared_bitmap_manager(
       new TestSharedBitmapManager());
   std::unique_ptr<ResourceProvider> resource_provider =
       FakeResourceProvider::Create(output_surface.get(),
                                    shared_bitmap_manager.get());
 
   RendererSettings settings;
-  FakeRendererClient renderer_client;
-  FakeRendererGL renderer(&renderer_client, &settings, output_surface.get(),
+  FakeRendererGL renderer(&settings, output_surface.get(),
                           resource_provider.get());
   EXPECT_FALSE(renderer.Capabilities().using_partial_swap);
   renderer.SetVisible(true);
 
   gfx::Rect device_viewport_rect(0, 0, 100, 100);
   gfx::Rect viewport_rect(device_viewport_rect.size());
   gfx::Rect quad_rect = gfx::Rect(20, 20, 20, 20);
 
   RenderPassId root_pass_id(1, 0);
   RenderPass* root_pass =
@@ skipping 362 matching lines @@
 class MockOutputSurfaceTest : public GLRendererTest {
  protected:
   virtual void SetUp() {
     FakeOutputSurfaceClient output_surface_client_;
     CHECK(output_surface_.BindToClient(&output_surface_client_));
 
     shared_bitmap_manager_.reset(new TestSharedBitmapManager());
     resource_provider_ = FakeResourceProvider::Create(
         &output_surface_, shared_bitmap_manager_.get());
 
-    renderer_.reset(new FakeRendererGL(&renderer_client_,
-                                       &settings_,
-                                       &output_surface_,
+    renderer_.reset(new FakeRendererGL(&settings_, &output_surface_,
                                        resource_provider_.get()));
+
+    EXPECT_CALL(output_surface_, EnsureBackbuffer()).Times(1);
     renderer_->SetVisible(true);
   }
 
   void SwapBuffers() { renderer_->SwapBuffers(CompositorFrameMetadata()); }
 
   void DrawFrame(float device_scale_factor,
                  const gfx::Rect& device_viewport_rect,
                  bool transparent) {
     RenderPassId render_pass_id(1, 0);
     RenderPass* render_pass =
@@ skipping 23 matching lines @@
     return static_cast<OutputSurfaceMockContext*>(
         static_cast<TestContextProvider*>(output_surface_.context_provider())
             ->TestContext3d());
   }
 
   RendererSettings settings_;
   FakeOutputSurfaceClient output_surface_client_;
   StrictMock<MockOutputSurface> output_surface_;
   std::unique_ptr<SharedBitmapManager> shared_bitmap_manager_;
   std::unique_ptr<ResourceProvider> resource_provider_;
-  FakeRendererClient renderer_client_;
   std::unique_ptr<FakeRendererGL> renderer_;
 };
 
+TEST_F(MockOutputSurfaceTest, BackbufferDiscard) {
+  // Drop backbuffer on hide.
+  EXPECT_CALL(output_surface_, DiscardBackbuffer()).Times(1);
+  renderer_->SetVisible(false);
+  // Restore backbuffer on show.
+  EXPECT_CALL(output_surface_, EnsureBackbuffer()).Times(1);
+  renderer_->SetVisible(true);
+}
+
 TEST_F(MockOutputSurfaceTest, DrawFrameAndSwap) {
   gfx::Rect device_viewport_rect(1, 1);
   DrawFrame(1.f, device_viewport_rect, true);
 
   EXPECT_CALL(output_surface_, SwapBuffers_(_)).Times(1);
   renderer_->SwapBuffers(CompositorFrameMetadata());
 }
 
 TEST_F(MockOutputSurfaceTest, DrawOpaqueFrameAndSwap) {
   gfx::Rect device_viewport_rect(1, 1);
@@ skipping 80 matching lines @@
 
   std::unique_ptr<SharedBitmapManager> shared_bitmap_manager(
       new TestSharedBitmapManager());
   std::unique_ptr<ResourceProvider> resource_provider =
       FakeResourceProvider::Create(output_surface.get(),
                                    shared_bitmap_manager.get());
   std::unique_ptr<TextureMailboxDeleter> mailbox_deleter(
       new TextureMailboxDeleter(base::ThreadTaskRunnerHandle::Get()));
 
   RendererSettings settings;
-  FakeRendererClient renderer_client;
-  FakeRendererGL renderer(&renderer_client, &settings, output_surface.get(),
+  FakeRendererGL renderer(&settings, output_surface.get(),
                           resource_provider.get(), mailbox_deleter.get());
   renderer.SetVisible(true);
 
   TestOverlayProcessor* processor =
       new TestOverlayProcessor(output_surface.get());
   processor->Initialize();
   renderer.SetOverlayProcessor(processor);
   std::unique_ptr<TestOverlayProcessor::Validator> validator(
       new TestOverlayProcessor::Validator);
   output_surface->SetOverlayCandidateValidator(validator.get());
@@ skipping 137 matching lines @@
 
   std::unique_ptr<SharedBitmapManager> shared_bitmap_manager(
       new TestSharedBitmapManager());
   std::unique_ptr<ResourceProvider> resource_provider =
       FakeResourceProvider::Create(output_surface.get(),
                                    shared_bitmap_manager.get());
   std::unique_ptr<TextureMailboxDeleter> mailbox_deleter(
       new TextureMailboxDeleter(base::ThreadTaskRunnerHandle::Get()));
 
   RendererSettings settings;
-  FakeRendererClient renderer_client;
-  FakeRendererGL renderer(&renderer_client, &settings, output_surface.get(),
+  FakeRendererGL renderer(&settings, output_surface.get(),
                           resource_provider.get(), mailbox_deleter.get());
   renderer.SetVisible(true);
 
   SingleOverlayOnTopProcessor* processor =
       new SingleOverlayOnTopProcessor(output_surface.get());
   processor->Initialize();
   renderer.SetOverlayProcessor(processor);
 
   gfx::Rect viewport_rect(1, 1);
   RenderPass* root_pass =
@@ skipping 57 matching lines @@
     FakeOutputSurfaceClient output_surface_client;
     std::unique_ptr<FakeOutputSurface> output_surface(
         FakeOutputSurface::Create3d(std::move(gl_owned)));
     CHECK(output_surface->BindToClient(&output_surface_client));
 
     std::unique_ptr<ResourceProvider> resource_provider =
         FakeResourceProvider::Create(output_surface.get(), nullptr);
 
     RendererSettings settings;
     settings.partial_swap_enabled = partial_swap;
-    FakeRendererClient renderer_client;
-    FakeRendererGL renderer(&renderer_client, &settings, output_surface.get(),
+    FakeRendererGL renderer(&settings, output_surface.get(),
                             resource_provider.get());
     EXPECT_EQ(partial_swap, renderer.Capabilities().using_partial_swap);
     renderer.SetVisible(true);
 
     gfx::Rect viewport_rect(100, 100);
     gfx::Rect clip_rect(100, 100);
 
     {
       RenderPassId root_pass_id(1, 0);
       RenderPass* root_pass =
@@ skipping 67 matching lines @@
   };
 
   void SetUp() override {
     auto context_support = base::MakeUnique<MockContextSupport>();
     context_support_ptr_ = context_support.get();
     context_provider_ = new MockContextProvider(std::move(context_support));
     output_surface_ = FakeOutputSurface::Create3d(context_provider_);
     output_surface_->BindToClient(&output_surface_client_);
     resource_provider_ =
         FakeResourceProvider::Create(output_surface_.get(), nullptr);
-    renderer_ = base::MakeUnique<GLRenderer>(
-        &renderer_client_, &settings_, output_surface_.get(),
-        resource_provider_.get(), nullptr, 0);
+    renderer_ =
+        base::MakeUnique<GLRenderer>(&settings_, output_surface_.get(),
+                                     resource_provider_.get(), nullptr, 0);
   }
 
-  FakeRendererClient renderer_client_;
   RendererSettings settings_;
   FakeOutputSurfaceClient output_surface_client_;
   MockContextSupport* context_support_ptr_;
   scoped_refptr<MockContextProvider> context_provider_;
   std::unique_ptr<OutputSurface> output_surface_;
   std::unique_ptr<ResourceProvider> resource_provider_;
   std::unique_ptr<Renderer> renderer_;
 };
 
 TEST_F(GLRendererWithMockContextTest,
@@ skipping 16 matching lines @@
   EXPECT_CALL(*context_provider_, DeleteCachedResources());
   EXPECT_CALL(*context_support_ptr_, SetAggressivelyFreeResources(true));
   renderer_->SetVisible(false);
   Mock::VerifyAndClearExpectations(context_support_ptr_);
 
   EXPECT_FALSE(renderer_->visible());
 }
 
 }  // namespace
 }  // namespace cc