cc: Delete the Renderer base class.

cc/output/direct_renderer.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/direct_renderer.h"
 
 #include <stddef.h>
 
 #include <unordered_map>
 #include <utility>
 #include <vector>
 
 #include "base/metrics/histogram.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/trace_event/trace_event.h"
 #include "cc/base/math_util.h"
 #include "cc/output/bsp_tree.h"
 #include "cc/output/bsp_walk_action.h"
 #include "cc/output/copy_output_request.h"
+#include "cc/output/renderer_settings.h"
 #include "cc/quads/draw_quad.h"
+#include "cc/resources/scoped_resource.h"
 #include "ui/gfx/geometry/quad_f.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/transform.h"
 
 static gfx::Transform OrthoProjectionMatrix(float left,
                                             float right,
                                             float bottom,
                                             float top) {
   // Use the standard formula to map the clipping frustum to the cube from
   // [-1, -1, -1] to [1, 1, 1].
@@ skipping 23 matching lines @@
 
   // Map from ([-1, -1] to [1, 1]) -> ([0, 0] to [1, 1])
   canvas.Translate3d(0.5, 0.5, 0.5);
   canvas.Scale3d(0.5, 0.5, 0.5);
 
   return canvas;
 }
 
 namespace cc {
 
-DirectRenderer::DrawingFrame::DrawingFrame()
-    : root_render_pass(NULL), current_render_pass(NULL), current_texture(NULL) {
+DirectRenderer::DrawingFrame::DrawingFrame() = default;
+DirectRenderer::DrawingFrame::~DrawingFrame() = default;
+
+DirectRenderer::DirectRenderer(const RendererSettings* settings,
+                               OutputSurface* output_surface,
+                               ResourceProvider* resource_provider)
+    : settings_(settings),
+      output_surface_(output_surface),
+      resource_provider_(resource_provider),
+      overlay_processor_(new OverlayProcessor(output_surface)) {
+  // TODO(danakj): This should not be happening in the constructor.
+  overlay_processor_->Initialize();
 }
 
-DirectRenderer::DrawingFrame::~DrawingFrame() {}
+DirectRenderer::~DirectRenderer() = default;
 
-//
 // static
 gfx::RectF DirectRenderer::QuadVertexRect() {
   return gfx::RectF(-0.5f, -0.5f, 1.f, 1.f);
 }
 
 // static
 void DirectRenderer::QuadRectTransform(gfx::Transform* quad_rect_transform,
                                        const gfx::Transform& quad_transform,
                                        const gfx::RectF& quad_rect) {
   *quad_rect_transform = quad_transform;
@@ skipping 40 matching lines @@
     const DrawingFrame* frame,
     const gfx::Rect& draw_rect) const {
   gfx::Rect window_rect = draw_rect;
   window_rect -= current_draw_rect_.OffsetFromOrigin();
   window_rect += current_viewport_rect_.OffsetFromOrigin();
   if (FlippedFramebuffer(frame))
     window_rect.set_y(current_surface_size_.height() - window_rect.bottom());
   return window_rect;
 }
 
-DirectRenderer::DirectRenderer(const RendererSettings* settings,
-                               OutputSurface* output_surface,
-                               ResourceProvider* resource_provider)
-    : Renderer(settings),
-      output_surface_(output_surface),
-      resource_provider_(resource_provider),
-      overlay_processor_(new OverlayProcessor(output_surface)) {
-  overlay_processor_->Initialize();
-}
-
-DirectRenderer::~DirectRenderer() {}
-
 const TileDrawQuad* DirectRenderer::CanPassBeDrawnDirectly(
     const RenderPass* pass) {
   return nullptr;
 }
 
+void DirectRenderer::SetVisible(bool visible) {
+  if (visible_ == visible)
+    return;
+  visible_ = visible;
+  DidChangeVisibility();
+}
+
 void DirectRenderer::DecideRenderPassAllocationsForFrame(
     const RenderPassList& render_passes_in_draw_order) {
   render_pass_bypass_quads_.clear();
 
   std::unordered_map<RenderPassId, gfx::Size, RenderPassIdHash>
       render_passes_in_frame;
   RenderPass* root_render_pass = render_passes_in_draw_order.back().get();
   for (size_t i = 0; i < render_passes_in_draw_order.size(); ++i) {
     RenderPass* pass = render_passes_in_draw_order[i].get();
     if (pass != root_render_pass) {
@@ skipping 35 matching lines @@
     if (!resource)
       resource = ScopedResource::Create(resource_provider_);
   }
 }
 
 void DirectRenderer::DrawFrame(RenderPassList* render_passes_in_draw_order,
                                float device_scale_factor,
                                const gfx::ColorSpace& device_color_space,
                                const gfx::Rect& device_viewport_rect,
                                const gfx::Rect& device_clip_rect) {
-  DCHECK(visible());
+  DCHECK(visible_);
   TRACE_EVENT0("cc", "DirectRenderer::DrawFrame");
   UMA_HISTOGRAM_COUNTS(
       "Renderer4.renderPassCount",
       base::saturated_cast<int>(render_passes_in_draw_order->size()));
 
   RenderPass* root_render_pass = render_passes_in_draw_order->back().get();
   DCHECK(root_render_pass);
 
   DrawingFrame frame;
   frame.render_passes_in_draw_order = render_passes_in_draw_order;
@@ skipping 151 matching lines @@
 }
 
 void DirectRenderer::SetScissorTestRectInDrawSpace(
     const DrawingFrame* frame,
     const gfx::Rect& draw_space_rect) {
   gfx::Rect window_space_rect =
       MoveFromDrawToWindowSpace(frame, draw_space_rect);
   SetScissorTestRect(window_space_rect);
 }
 
-void DirectRenderer::FinishDrawingQuadList() {}
-
 void DirectRenderer::DoDrawPolygon(const DrawPolygon& poly,
                                    DrawingFrame* frame,
                                    const gfx::Rect& render_pass_scissor,
                                    bool use_render_pass_scissor) {
   SetScissorStateForQuad(frame, *poly.original_ref(), render_pass_scissor,
                          use_render_pass_scissor);
 
   // If the poly has not been split, then it is just a normal DrawQuad,
   // and we should save any extra processing that would have to be done.
   if (!poly.is_split()) {
@@ skipping 182 matching lines @@
   auto iter = render_pass_textures_.find(id);
   return iter != render_pass_textures_.end() && iter->second->id();
 }
 
 // static
 gfx::Size DirectRenderer::RenderPassTextureSize(const RenderPass* render_pass) {
   return render_pass->output_rect.size();
 }
 
 }  // namespace cc