cc: Delete the Renderer base 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_direct_renderer_client.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 20 matching lines @@
   gpu::SyncToken other;
   memcpy(&other, arg, sizeof(other));
   return other == sync_token;
 }
 
 class GLRendererTest : public testing::Test {
  protected:
   RenderPass* root_render_pass() {
     return render_passes_in_draw_order_.back().get();
   }
-  void DrawFrame(Renderer* renderer, const gfx::Rect& viewport_rect) {
+  void DrawFrame(GLRenderer* renderer, const gfx::Rect& viewport_rect) {
     renderer->DrawFrame(&render_passes_in_draw_order_, 1.f, gfx::ColorSpace(),
                         viewport_rect, viewport_rect);
   }
-  void DrawFrame(Renderer* renderer,
+  void DrawFrame(GLRenderer* renderer,
                  const gfx::Rect& viewport_rect,
                  const gfx::Rect& clip_rect) {
     renderer->DrawFrame(&render_passes_in_draw_order_, 1.f, gfx::ColorSpace(),
                         viewport_rect, clip_rect);
   }
 
   RenderPassList render_passes_in_draw_order_;
 };
 
 #define EXPECT_PROGRAM_VALID(program_binding)      \
@@ skipping 223 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,
+  FakeRendererGL(DirectRendererClient* client,
                  const RendererSettings* settings,
                  OutputSurface* output_surface,
                  ResourceProvider* resource_provider)
       : GLRenderer(client,
                    settings,
                    output_surface,
                    resource_provider,
                    NULL,
                    0) {}
 
-  FakeRendererGL(RendererClient* client,
+  FakeRendererGL(DirectRendererClient* client,
                  const RendererSettings* settings,
                  OutputSurface* output_surface,
                  ResourceProvider* resource_provider,
                  TextureMailboxDeleter* texture_mailbox_deleter)
       : GLRenderer(client,
                    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()));
   }
 
   void SwapBuffers() { renderer_->SwapBuffers(CompositorFrameMetadata()); }
 
   RendererSettings settings_;
   FakeOutputSurfaceClient output_surface_client_;
   std::unique_ptr<FakeOutputSurface> output_surface_;
-  FakeRendererClient renderer_client_;
+  FakeDirectRendererClient 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
 
@@ skipping 101 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_;
+  FakeDirectRendererClient 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;
+  FakeDirectRendererClient renderer_client;
   FakeRendererGL renderer(&renderer_client,
                           &settings,
                           output_surface.get(),
                           resource_provider.get());
 }
 
 class LoseContextOnFirstGetContext : public TestWebGraphicsContext3D {
  public:
   LoseContextOnFirstGetContext() {}
 
@@ skipping 15 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;
+  FakeDirectRendererClient renderer_client;
   FakeRendererGL renderer(&renderer_client,
                           &settings,
                           output_surface.get(),
                           resource_provider.get());
 }
 
 class ClearCountingContext : public TestWebGraphicsContext3D {
  public:
   ClearCountingContext() { test_capabilities_.discard_framebuffer = true; }
 
@@ skipping 13 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;
+  FakeDirectRendererClient renderer_client;
   FakeRendererGL renderer(&renderer_client,
                           &settings,
                           output_surface.get(),
                           resource_provider.get());
 
   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;
@@ skipping 21 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;
+  FakeDirectRendererClient renderer_client;
   FakeRendererGL renderer(&renderer_client,
                           &settings,
                           output_surface.get(),
                           resource_provider.get());
 
   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;
@@ skipping 14 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;
+  FakeDirectRendererClient renderer_client;
   FakeRendererGL renderer(&renderer_client,
                           &settings,
                           output_surface.get(),
                           resource_provider.get());
 
   gfx::Rect viewport_rect(1, 1);
   AddRenderPass(&render_passes_in_draw_order_,
                 RenderPassId(1, 0),
                 viewport_rect,
                 gfx::Transform());
@@ skipping 38 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;
+  FakeDirectRendererClient renderer_client;
   FakeRendererGL renderer(&renderer_client,
                           &settings,
                           output_surface.get(),
                           resource_provider.get());
 
   // 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),
@@ skipping 63 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;
+  FakeDirectRendererClient renderer_client;
   FakeRendererGL renderer(&renderer_client,
                           &settings,
                           output_surface.get(),
                           resource_provider.get());
 
   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,
@@ skipping 64 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;
+  FakeDirectRendererClient renderer_client;
   FakeRendererGL renderer(&renderer_client,
                           &settings,
                           output_surface.get(),
                           resource_provider.get());
   EXPECT_FALSE(renderer.Capabilities().using_partial_swap);
 
   gfx::Rect viewport_rect(1, 1);
 
   gfx::Rect grand_child_rect(25, 25);
   RenderPassId grand_child_pass_id(3, 0);
@@ skipping 70 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;
+  FakeDirectRendererClient renderer_client;
   FakeRendererGL renderer(&renderer_client,
                           &settings,
                           output_surface.get(),
                           resource_provider.get());
   EXPECT_TRUE(renderer.Capabilities().using_partial_swap);
 
   gfx::Rect viewport_rect(100, 100);
   gfx::Rect clip_rect(100, 100);
 
   {
@@ skipping 113 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;
+  FakeDirectRendererClient renderer_client;
   FakeRendererGL renderer(&renderer_client,
                           &settings,
                           output_surface.get(),
                           resource_provider.get());
   EXPECT_FALSE(renderer.Capabilities().using_partial_swap);
 
   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);
 
@@ skipping 18 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;
+  FakeDirectRendererClient renderer_client;
   FakeRendererGL renderer(&renderer_client, &settings, output_surface.get(),
                           resource_provider.get());
   EXPECT_FALSE(renderer.Capabilities().using_partial_swap);
 
   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 408 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_;
+  FakeDirectRendererClient renderer_client_;
   std::unique_ptr<FakeRendererGL> renderer_;
 };
 
 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());
 }
@@ skipping 83 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;
+  FakeDirectRendererClient renderer_client;
   FakeRendererGL renderer(&renderer_client, &settings, output_surface.get(),
                           resource_provider.get(), mailbox_deleter.get());
 
   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;
+  FakeDirectRendererClient renderer_client;
   FakeRendererGL renderer(&renderer_client, &settings, output_surface.get(),
                           resource_provider.get(), mailbox_deleter.get());
 
   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;
+    FakeDirectRendererClient renderer_client;
     FakeRendererGL renderer(&renderer_client, &settings, output_surface.get(),
                             resource_provider.get());
     EXPECT_EQ(partial_swap, renderer.Capabilities().using_partial_swap);
 
     gfx::Rect viewport_rect(100, 100);
     gfx::Rect clip_rect(100, 100);
 
     {
       RenderPassId root_pass_id(1, 0);
       RenderPass* root_pass =
@@ skipping 37 matching lines @@
 TEST_F(GLRendererPartialSwapTest, PartialSwap) {
   RunTest(true);
 }
 
 TEST_F(GLRendererPartialSwapTest, NoPartialSwap) {
   RunTest(false);
 }
 
 }  // namespace
 }  // namespace cc