cc: Remove most methods from RendererClient.

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 <utility>
 #include <vector>
 
 #include "base/containers/hash_tables.h"
@@ skipping 109 matching lines @@
     const gfx::RectF& draw_rect) const {
   gfx::Rect window_rect = gfx::ToEnclosingRect(draw_rect);
   window_rect -= current_draw_rect_.OffsetFromOrigin();
   window_rect += current_viewport_rect_.OffsetFromOrigin();
   if (FlippedFramebuffer())
     window_rect.set_y(current_surface_size_.height() - window_rect.bottom());
   return window_rect;
 }
 
 DirectRenderer::DirectRenderer(RendererClient* client,
+                               const LayerTreeSettings* settings,
                                OutputSurface* output_surface,
                                ResourceProvider* resource_provider)
-    : Renderer(client),
+    : Renderer(client, settings),
       output_surface_(output_surface),
       resource_provider_(resource_provider) {}
 
 DirectRenderer::~DirectRenderer() {}
 
 bool DirectRenderer::CanReadPixels() const { return true; }
 
 void DirectRenderer::SetEnlargePassTextureAmountForTesting(
     gfx::Vector2d amount) {
   enlarge_pass_texture_amount_ = amount;
@@ skipping 44 matching lines @@
     if (!render_pass_textures_.contains(render_passes_in_draw_order[i]->id)) {
       scoped_ptr<CachedResource> texture =
           CachedResource::Create(resource_provider_);
       render_pass_textures_.set(render_passes_in_draw_order[i]->id,
                               texture.Pass());
     }
   }
 }
 
 void DirectRenderer::DrawFrame(RenderPassList* render_passes_in_draw_order,
-                               ContextProvider* offscreen_context_provider) {
+                               ContextProvider* offscreen_context_provider,
+                               float device_scale_factor,
+                               bool allow_partial_swap) {
   TRACE_EVENT0("cc", "DirectRenderer::DrawFrame");
   UMA_HISTOGRAM_COUNTS("Renderer4.renderPassCount",
                        render_passes_in_draw_order->size());
 
   const RenderPass* root_render_pass = render_passes_in_draw_order->back();
   DCHECK(root_render_pass);
 
   DrawingFrame frame;
   frame.root_render_pass = root_render_pass;
   frame.root_damage_rect =
-      Capabilities().using_partial_swap && client_->AllowPartialSwap() ?
-      root_render_pass->damage_rect : root_render_pass->output_rect;
+      Capabilities().using_partial_swap && allow_partial_swap
+          ? root_render_pass->damage_rect
+          : root_render_pass->output_rect;
   frame.root_damage_rect.Intersect(gfx::Rect(client_->DeviceViewport().size()));
   frame.offscreen_context_provider = offscreen_context_provider;
 
   EnsureBackbuffer();
 
   // Only reshape when we know we are going to draw. Otherwise, the reshape
   // can leave the window at the wrong size if we never draw and the proper
   // viewport size is never set.
   output_surface_->Reshape(client_->DeviceViewport().size(),
-                           client_->DeviceScaleFactor());
+                           device_scale_factor);
 
   BeginDrawingFrame(&frame);
   for (size_t i = 0; i < render_passes_in_draw_order->size(); ++i) {
     RenderPass* pass = render_passes_in_draw_order->at(i);
-    DrawRenderPass(&frame, pass);
+    DrawRenderPass(&frame, pass, allow_partial_swap);
 
     for (ScopedPtrVector<CopyOutputRequest>::iterator it =
              pass->copy_requests.begin();
          it != pass->copy_requests.end();
          ++it) {
       if (i > 0) {
         // Doing a readback is destructive of our state on Mac, so make sure
         // we restore the state between readbacks. http://crbug.com/99393.
         UseRenderPass(&frame, pass);
       }
@@ skipping 77 matching lines @@
                                                    gfx::RectF draw_space_rect) {
   gfx::Rect window_space_rect = MoveFromDrawToWindowSpace(draw_space_rect);
   if (NeedDeviceClip(frame))
     window_space_rect.Intersect(DeviceClipRect(frame));
   SetScissorTestRect(window_space_rect);
 }
 
 void DirectRenderer::FinishDrawingQuadList() {}
 
 void DirectRenderer::DrawRenderPass(DrawingFrame* frame,
-                                    const RenderPass* render_pass) {
+                                    const RenderPass* render_pass,
+                                    bool allow_partial_swap) {
   TRACE_EVENT0("cc", "DirectRenderer::DrawRenderPass");
   if (!UseRenderPass(frame, render_pass))
     return;
 
   bool using_scissor_as_optimization =
-      Capabilities().using_partial_swap && client_->AllowPartialSwap();
+      Capabilities().using_partial_swap && allow_partial_swap;
   gfx::RectF render_pass_scissor;
 
   if (using_scissor_as_optimization) {
     render_pass_scissor = ComputeScissorRectForRenderPass(frame);
     SetScissorTestRectInDrawSpace(frame, render_pass_scissor);
   }
 
   if (frame->current_render_pass != frame->root_render_pass ||
-      client_->ShouldClearRootRenderPass()) {
+      settings_->should_clear_root_render_pass) {
     if (NeedDeviceClip(frame))
       SetScissorTestRect(DeviceClipRect(frame));
     else if (!using_scissor_as_optimization)
       EnsureScissorTestDisabled();
     ClearFramebuffer(frame);
   }
 
   const QuadList& quad_list = render_pass->quad_list;
   for (QuadList::ConstBackToFrontIterator it = quad_list.BackToFrontBegin();
        it != quad_list.BackToFrontEnd();
@@ skipping 47 matching lines @@
       !texture->Allocate(size,
                          RenderPassTextureFormat(render_pass),
                          ResourceProvider::TextureUsageFramebuffer))
     return false;
 
   return BindFramebufferToTexture(frame, texture, render_pass->output_rect);
 }
 
 bool DirectRenderer::HaveCachedResourcesForRenderPassId(RenderPass::Id id)
     const {
-  if (!Settings().cache_render_pass_contents)
+  if (!settings_->cache_render_pass_contents)
     return false;
 
   CachedResource* texture = render_pass_textures_.get(id);
   return texture && texture->id() && texture->is_complete();
 }
 
 // static
 gfx::Size DirectRenderer::RenderPassTextureSize(const RenderPass* render_pass) {
   return render_pass->output_rect.size();
 }
 
 // static
 GLenum DirectRenderer::RenderPassTextureFormat(const RenderPass* render_pass) {
   return GL_RGBA;
 }
 
 }  // namespace cc