cc: Remove most methods from RendererClient.

cc/trees/layer_tree_host_impl.cc

 // Copyright 2011 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/trees/layer_tree_host_impl.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/containers/hash_tables.h"
@@ skipping 1094 matching lines @@
   new_state.memory_limit_policy =
       ManagedMemoryPolicy::PriorityCutoffToTileMemoryLimitPolicy(
           visible_ ?
           policy.priority_cutoff_when_visible :
           policy.priority_cutoff_when_not_visible);
   new_state.num_resources_limit = policy.num_resources_limit;
   tile_manager_->SetGlobalState(new_state);
   manage_tiles_needed_ = true;
 }
 
-bool LayerTreeHostImpl::HasImplThread() const {
-  return proxy_->HasImplThread();
-}
-
 void LayerTreeHostImpl::DidInitializeVisibleTile() {
   // TODO(reveman): Determine tiles that changed and only damage
   // what's necessary.
   SetFullRootLayerDamage();
   if (client_)
     client_->DidInitializeVisibleTileOnImplThread();
 }
 
 void LayerTreeHostImpl::NotifyReadyToActivate() {
   client_->NotifyReadyToActivate();
 }
 
-bool LayerTreeHostImpl::ShouldClearRootRenderPass() const {
-  return settings_.should_clear_root_render_pass;
-}
-
 void LayerTreeHostImpl::SetMemoryPolicy(const ManagedMemoryPolicy& policy) {
   SetManagedMemoryPolicy(policy, zero_budget_);
 }
 
 void LayerTreeHostImpl::SetDiscardBackBufferWhenNotVisible(bool discard) {
   DCHECK(renderer_);
   renderer_->SetDiscardBackBufferWhenNotVisible(discard);
 }
 
 void LayerTreeHostImpl::SetTreeActivationCallback(
@@ skipping 48 matching lines @@
     const gfx::Transform& transform,
     gfx::Rect viewport,
     gfx::Rect clip,
     bool valid_for_tile_management) {
   external_transform_ = transform;
   external_viewport_ = viewport;
   external_clip_ = clip;
   device_viewport_valid_for_tile_management_ = valid_for_tile_management;
 }
 
-void LayerTreeHostImpl::SetExternalStencilTest(bool enabled) {
-  external_stencil_test_enabled_ = enabled;
-}
-
 void LayerTreeHostImpl::SetNeedsRedrawRect(gfx::Rect damage_rect) {
   client_->SetNeedsRedrawRectOnImplThread(damage_rect);
 }
 
 void LayerTreeHostImpl::BeginFrame(const BeginFrameArgs& args) {
   client_->BeginFrameOnImplThread(args);
 }
 
 void LayerTreeHostImpl::OnSwapBuffersComplete(
     const CompositorFrameAck* ack) {
@@ skipping 27 matching lines @@
   }
 
   if (!RootScrollLayer())
     return metadata;
 
   metadata.root_scroll_offset = RootScrollLayer()->TotalScrollOffset();
 
   return metadata;
 }
 
-bool LayerTreeHostImpl::AllowPartialSwap() const {
-  // We don't track damage on the HUD layer (it interacts with damage tracking
-  // visualizations), so disable partial swaps to make the HUD layer display
-  // properly.
-  return !debug_state_.ShowHudRects();
-}
-
-bool LayerTreeHostImpl::ExternalStencilTestEnabled() const {
-  return external_stencil_test_enabled_;
-}
-
 static void LayerTreeHostImplDidBeginTracingCallback(LayerImpl* layer) {
   layer->DidBeginTracing();
 }
 
 void LayerTreeHostImpl::DrawLayers(FrameData* frame,
                                    base::TimeTicks frame_begin_time) {
   TRACE_EVENT0("cc", "LayerTreeHostImpl::DrawLayers");
   DCHECK(CanDraw());
 
   if (frame->has_no_damage) {
@@ skipping 53 matching lines @@
       TRACE_DISABLED_BY_DEFAULT("cc.debug.quads"), "cc::LayerTreeHostImpl",
       this, TracedValue::FromValue(AsValueWithFrame(frame).release()));
 
   // Because the contents of the HUD depend on everything else in the frame, the
   // contents of its texture are updated as the last thing before the frame is
   // drawn.
   if (active_tree_->hud_layer())
     active_tree_->hud_layer()->UpdateHudTexture(resource_provider_.get());
 
   if (output_surface_->ForcedDrawToSoftwareDevice()) {
+    bool allow_partial_swap = false;
+
     scoped_ptr<SoftwareRenderer> temp_software_renderer =
-        SoftwareRenderer::Create(this, output_surface_.get(), NULL);
-    temp_software_renderer->DrawFrame(&frame->render_passes, NULL);
+        SoftwareRenderer::Create(this, &settings_, output_surface_.get(), NULL);
+    temp_software_renderer->DrawFrame(
+        &frame->render_passes, NULL, device_scale_factor_, allow_partial_swap);
   } else {
+    // We don't track damage on the HUD layer (it interacts with damage tracking
+    // visualizations), so disable partial swaps to make the HUD layer display
+    // properly.
+    bool allow_partial_swap = !debug_state_.ShowHudRects();
+
     renderer_->DrawFrame(&frame->render_passes,
-                         offscreen_context_provider_.get());
+                         offscreen_context_provider_.get(),
+                         device_scale_factor_,
+                         allow_partial_swap);
   }
   // The render passes should be consumed by the renderer.
   DCHECK(frame->render_passes.empty());
   frame->render_passes_by_id.clear();
 
   // The next frame should start by assuming nothing has changed, and changes
   // are noted as they occur.
+  // TODO(boliu): If we did a temporary software renderer frame, propogate the
+  // damage forward to the next frame.
   for (size_t i = 0; i < frame->render_surface_layer_list->size(); i++) {
     (*frame->render_surface_layer_list)[i]->render_surface()->damage_tracker()->
         DidDrawDamagedArea();
   }
   active_tree_->root_layer()->ResetAllChangeTrackingForSubtree();
 
   rendering_stats_instrumentation_->IssueTraceEventForImplThreadStats();
   rendering_stats_instrumentation_->AccumulateAndClearImplThreadStats();
 }
 
@@ skipping 26 matching lines @@
   renderer_->SwapBuffers();
   active_tree_->ClearLatencyInfo();
   return true;
 }
 
 void LayerTreeHostImpl::SetNeedsBeginFrame(bool enable) {
   if (output_surface_)
     output_surface_->SetNeedsBeginFrame(enable);
 }
 
-float LayerTreeHostImpl::DeviceScaleFactor() const {
-  return device_scale_factor_;
-}
-
 gfx::SizeF LayerTreeHostImpl::UnscaledScrollableViewportSize() const {
   // The container layer bounds should be used if non-overlay scrollbars may
   // exist since it adjusts for them.
   LayerImpl* container_layer = active_tree_->RootContainerLayer();
-  if (!Settings().solid_color_scrollbars && container_layer) {
+  if (!settings_.solid_color_scrollbars && container_layer) {
     DCHECK(!top_controls_manager_);
     DCHECK_EQ(0, overdraw_bottom_height_);
     return container_layer->bounds();
   }
 
   gfx::SizeF dip_size =
       gfx::ScaleSize(device_viewport_size_, 1.f / device_scale_factor());
 
   float top_offset =
       top_controls_manager_ ? top_controls_manager_->content_top_offset() : 0.f;
   return gfx::SizeF(dip_size.width(),
                     dip_size.height() - top_offset - overdraw_bottom_height_);
 }
 
-const LayerTreeSettings& LayerTreeHostImpl::Settings() const {
-  return settings();
-}
-
 void LayerTreeHostImpl::DidLoseOutputSurface() {
   // TODO(jamesr): The renderer_ check is needed to make some of the
   // LayerTreeHostContextTest tests pass, but shouldn't be necessary (or
   // important) in production. We should adjust the test to not need this.
   if (renderer_)
     client_->DidLoseOutputSurfaceOnImplThread();
 }
 
 void LayerTreeHostImpl::Readback(void* pixels,
                                  gfx::Rect rect_in_device_viewport) {
@@ skipping 166 matching lines @@
 
   DeleteAllUIResources();
 }
 
 void LayerTreeHostImpl::CreateAndSetRenderer(
     OutputSurface* output_surface,
     ResourceProvider* resource_provider,
     bool skip_gl_renderer) {
   DCHECK(!renderer_);
   if (output_surface->capabilities().delegated_rendering) {
-    renderer_ =
-        DelegatingRenderer::Create(this, output_surface, resource_provider);
+    renderer_ = DelegatingRenderer::Create(
+        this, &settings_, output_surface, resource_provider);
   } else if (output_surface->context_provider() && !skip_gl_renderer) {
     renderer_ = GLRenderer::Create(this,
+                                   &settings_,
                                    output_surface,
                                    resource_provider,
                                    settings_.highp_threshold_min,
                                    settings_.force_direct_layer_drawing);
   } else if (output_surface->software_device()) {
-    renderer_ =
-        SoftwareRenderer::Create(this, output_surface, resource_provider);
+    renderer_ = SoftwareRenderer::Create(
+        this, &settings_, output_surface, resource_provider);
   }
 
   if (renderer_) {
     renderer_->SetVisible(visible_);
     SetFullRootLayerDamage();
   }
 }
 
 void LayerTreeHostImpl::CreateAndSetTileManager(
     ResourceProvider* resource_provider,
@@ skipping 1018 matching lines @@
 
 ResourceProvider::ResourceId LayerTreeHostImpl::ResourceIdForUIResource(
     UIResourceId uid) const {
   UIResourceMap::const_iterator iter = ui_resource_map_.find(uid);
   if (iter != ui_resource_map_.end())
     return iter->second;
   return 0;
 }
 
 }  // namespace cc