cc: Remove most methods from RendererClient.

This class is being used to pass data to the Renderer, but it's more
clear if we just pass the data directly when we call DrawFrame.

There are also some interesting round trips where OutputSurface sets
data on the OutputSurfaceClient (LayerTreeHostImpl) which just stores
the data. Then the data is accessed through the RendererClient or
on the LTHI directly, but in places that could just query it from the
OutputSurface directly.

This patch unravels one of these loops with HasExternalStencilTest().

The remaining two getters on RendererClient are called in both DrawFrame
and in SwapBuffers, so I'm not sure if we want to pass them directly to
both functions (redundency is error-prone) or we have some other nice
idea to get rid of them.

R=enne
BUG=

Review URL: https://chromiumcodereview.appspot.com/23961003

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@222050 0039d316-1c4b-4281-b951-d872f2087c98

14 files changed, 239 insertions, 220 deletions

diff --git a/cc/output/delegating_renderer.cc b/cc/output/delegating_renderer.cc
index 88c1f6c..d43b0e9 100644
--- a/cc/output/delegating_renderer.cc
+++ b/cc/output/delegating_renderer.cc
@@ -31,20 +31,21 @@ namespace cc {
 
 scoped_ptr<DelegatingRenderer> DelegatingRenderer::Create(
     RendererClient* client,
+    const LayerTreeSettings* settings,
     OutputSurface* output_surface,
     ResourceProvider* resource_provider) {
-  scoped_ptr<DelegatingRenderer> renderer(
-      new DelegatingRenderer(client, output_surface, resource_provider));
+  scoped_ptr<DelegatingRenderer> renderer(new DelegatingRenderer(
+      client, settings, output_surface, resource_provider));
   if (!renderer->Initialize())
     return scoped_ptr<DelegatingRenderer>();
   return renderer.Pass();
 }
 
-DelegatingRenderer::DelegatingRenderer(
-    RendererClient* client,
-    OutputSurface* output_surface,
-    ResourceProvider* resource_provider)
-    : Renderer(client),
+DelegatingRenderer::DelegatingRenderer(RendererClient* client,
+                                       const LayerTreeSettings* settings,
+                                       OutputSurface* output_surface,
+                                       ResourceProvider* resource_provider)
+    : Renderer(client, settings),
       output_surface_(output_surface),
       resource_provider_(resource_provider),
       visible_(true) {
@@ -70,9 +71,7 @@ bool DelegatingRenderer::Initialize() {
     return false;
 
   std::string unique_context_name = base::StringPrintf(
-      "%s-%p",
-      Settings().compositor_name.c_str(),
-      context3d);
+      "%s-%p", settings_->compositor_name.c_str(), context3d);
   context3d->pushGroupMarkerEXT(unique_context_name.c_str());
 
   const ContextProvider::Capabilities& caps =
@@ -82,8 +81,7 @@ bool DelegatingRenderer::Initialize() {
 
   capabilities_.using_set_visibility = caps.set_visibility;
   capabilities_.using_egl_image = caps.egl_image_external;
-  capabilities_.using_map_image =
-      Settings().use_map_image && caps.map_image;
+  capabilities_.using_map_image = settings_->use_map_image && caps.map_image;
 
   return true;
 }
@@ -103,9 +101,10 @@ static ResourceProvider::ResourceId AppendToArray(
   return id;
 }
 
-void DelegatingRenderer::DrawFrame(
-    RenderPassList* render_passes_in_draw_order,
-    ContextProvider* offscreen_context_provider) {
+void DelegatingRenderer::DrawFrame(RenderPassList* render_passes_in_draw_order,
+                                   ContextProvider* offscreen_context_provider,
+                                   float device_scale_factor,
+                                   bool allow_partial_swap) {
   TRACE_EVENT0("cc", "DelegatingRenderer::DrawFrame");
 
   DCHECK(!frame_for_swap_buffers_.delegated_frame_data);
diff --git a/cc/output/delegating_renderer.h b/cc/output/delegating_renderer.h
index 3e900ac..57a2418 100644
--- a/cc/output/delegating_renderer.h
+++ b/cc/output/delegating_renderer.h
@@ -19,6 +19,7 @@ class CC_EXPORT DelegatingRenderer : public Renderer {
  public:
   static scoped_ptr<DelegatingRenderer> Create(
       RendererClient* client,
+      const LayerTreeSettings* settings,
       OutputSurface* output_surface,
       ResourceProvider* resource_provider);
   virtual ~DelegatingRenderer();
@@ -28,7 +29,9 @@ class CC_EXPORT DelegatingRenderer : public Renderer {
   virtual bool CanReadPixels() const OVERRIDE;
 
   virtual void DrawFrame(RenderPassList* render_passes_in_draw_order,
-                         ContextProvider* offscreen_context_provider) OVERRIDE;
+                         ContextProvider* offscreen_context_provider,
+                         float device_scale_factor,
+                         bool allow_partial_swap) OVERRIDE;
 
   virtual void Finish() OVERRIDE {}
 
@@ -49,6 +52,7 @@ class CC_EXPORT DelegatingRenderer : public Renderer {
 
  private:
   DelegatingRenderer(RendererClient* client,
+                     const LayerTreeSettings* settings,
                      OutputSurface* output_surface,
                      ResourceProvider* resource_provider);
   bool Initialize();
diff --git a/cc/output/direct_renderer.cc b/cc/output/direct_renderer.cc
index 15f8501..c3a4d39 100644
--- a/cc/output/direct_renderer.cc
+++ b/cc/output/direct_renderer.cc
@@ -127,9 +127,10 @@ gfx::Rect DirectRenderer::MoveFromDrawToWindowSpace(
 }
 
 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) {}
 
@@ -194,7 +195,9 @@ void DirectRenderer::DecideRenderPassAllocationsForFrame(
 }
 
 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());
@@ -205,8 +208,9 @@ void DirectRenderer::DrawFrame(RenderPassList* render_passes_in_draw_order,
   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;
 
@@ -216,12 +220,12 @@ void DirectRenderer::DrawFrame(RenderPassList* render_passes_in_draw_order,
   // 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();
@@ -319,13 +323,14 @@ void DirectRenderer::SetScissorTestRectInDrawSpace(const DrawingFrame* frame,
 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) {
@@ -334,7 +339,7 @@ void DirectRenderer::DrawRenderPass(DrawingFrame* frame,
   }
 
   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)
@@ -402,7 +407,7 @@ bool DirectRenderer::UseRenderPass(DrawingFrame* frame,
 
 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);
diff --git a/cc/output/direct_renderer.h b/cc/output/direct_renderer.h
index 3937619..94ec9cc 100644
--- a/cc/output/direct_renderer.h
+++ b/cc/output/direct_renderer.h
@@ -32,7 +32,9 @@ class CC_EXPORT DirectRenderer : public Renderer {
   virtual bool HaveCachedResourcesForRenderPassId(RenderPass::Id id) const
       OVERRIDE;
   virtual void DrawFrame(RenderPassList* render_passes_in_draw_order,
-                         ContextProvider* offscreen_context_provider) OVERRIDE;
+                         ContextProvider* offscreen_context_provider,
+                         float device_scale_factor,
+                         bool allow_partial_swap) OVERRIDE;
 
   struct CC_EXPORT DrawingFrame {
     DrawingFrame();
@@ -54,6 +56,7 @@ class CC_EXPORT DirectRenderer : public Renderer {
 
  protected:
   DirectRenderer(RendererClient* client,
+                 const LayerTreeSettings* settings,
                  OutputSurface* output_surface,
                  ResourceProvider* resource_provider);
 
@@ -104,7 +107,9 @@ class CC_EXPORT DirectRenderer : public Renderer {
   static gfx::Size RenderPassTextureSize(const RenderPass* render_pass);
   static GLenum RenderPassTextureFormat(const RenderPass* render_pass);
 
-  void DrawRenderPass(DrawingFrame* frame, const RenderPass* render_pass);
+  void DrawRenderPass(DrawingFrame* frame,
+                      const RenderPass* render_pass,
+                      bool allow_partial_swap);
   bool UseRenderPass(DrawingFrame* frame, const RenderPass* render_pass);
 
   virtual void BindFramebufferToOutputSurface(DrawingFrame* frame) = 0;
diff --git a/cc/output/gl_renderer.cc b/cc/output/gl_renderer.cc
index f19f441..e430ebf 100644
--- a/cc/output/gl_renderer.cc
+++ b/cc/output/gl_renderer.cc
@@ -127,12 +127,16 @@ struct GLRenderer::PendingAsyncReadPixels {
 };
 
 scoped_ptr<GLRenderer> GLRenderer::Create(RendererClient* client,
+                                          const LayerTreeSettings* settings,
                                           OutputSurface* output_surface,
                                           ResourceProvider* resource_provider,
                                           int highp_threshold_min,
                                           bool use_skia_gpu_backend) {
-  scoped_ptr<GLRenderer> renderer(new GLRenderer(
-      client, output_surface, resource_provider, highp_threshold_min));
+  scoped_ptr<GLRenderer> renderer(new GLRenderer(client,
+                                                 settings,
+                                                 output_surface,
+                                                 resource_provider,
+                                                 highp_threshold_min));
   if (!renderer->Initialize())
     return scoped_ptr<GLRenderer>();
   if (use_skia_gpu_backend) {
@@ -145,10 +149,11 @@ scoped_ptr<GLRenderer> GLRenderer::Create(RendererClient* client,
 }
 
 GLRenderer::GLRenderer(RendererClient* client,
+                       const LayerTreeSettings* settings,
                        OutputSurface* output_surface,
                        ResourceProvider* resource_provider,
                        int highp_threshold_min)
-    : DirectRenderer(client, output_surface, resource_provider),
+    : DirectRenderer(client, settings, output_surface, resource_provider),
       offscreen_framebuffer_id_(0),
       shared_geometry_quad_(gfx::RectF(-0.5f, -0.5f, 1.0f, 1.0f)),
       context_(output_surface->context_provider()->Context3d()),
@@ -170,18 +175,15 @@ bool GLRenderer::Initialize() {
   if (!context_->makeContextCurrent())
     return false;
 
-  std::string unique_context_name = base::StringPrintf(
-      "%s-%p",
-      Settings().compositor_name.c_str(),
-      context_);
+  std::string unique_context_name =
+      base::StringPrintf("%s-%p", settings_->compositor_name.c_str(), context_);
   context_->pushGroupMarkerEXT(unique_context_name.c_str());
 
   ContextProvider::Capabilities context_caps =
     output_surface_->context_provider()->ContextCapabilities();
 
   capabilities_.using_partial_swap =
-      Settings().partial_swap_enabled &&
-      context_caps.post_sub_buffer;
+      settings_->partial_swap_enabled && context_caps.post_sub_buffer;
 
   capabilities_.using_set_visibility = context_caps.set_visibility;
 
@@ -202,7 +204,7 @@ bool GLRenderer::Initialize() {
   capabilities_.using_offscreen_context3d = true;
 
   capabilities_.using_map_image =
-      Settings().use_map_image && context_caps.map_image;
+      settings_->use_map_image && context_caps.map_image;
 
   capabilities_.using_discard_framebuffer =
       context_caps.discard_framebuffer;
@@ -290,7 +292,7 @@ void GLRenderer::ViewportChanged() {
 void GLRenderer::ClearFramebuffer(DrawingFrame* frame) {
   // It's unsafe to clear when we have a stencil test because glClear ignores
   // stencil.
-  if (client_->ExternalStencilTestEnabled() &&
+  if (output_surface_->HasExternalStencilTest() &&
       frame->current_render_pass == frame->root_render_pass) {
     DCHECK(!frame->current_render_pass->has_transparent_background);
     return;
@@ -1249,7 +1251,7 @@ void GLRenderer::DrawSolidColorQuad(const DrawingFrame* frame,
   gfx::QuadF local_quad = gfx::QuadF(gfx::RectF(tile_rect));
   float edge[24];
   bool use_aa =
-      Settings().allow_antialiasing && !quad->force_anti_aliasing_off &&
+      settings_->allow_antialiasing && !quad->force_anti_aliasing_off &&
       SetupQuadForAntialiasing(device_transform, quad, &local_quad, edge);
 
   SolidColorProgramUniforms uniforms;
@@ -1388,7 +1390,7 @@ void GLRenderer::DrawContentQuad(const DrawingFrame* frame,
 
   gfx::QuadF local_quad = gfx::QuadF(gfx::RectF(tile_rect));
   float edge[24];
-  bool use_aa = Settings().allow_antialiasing && SetupQuadForAntialiasing(
+  bool use_aa = settings_->allow_antialiasing && SetupQuadForAntialiasing(
       device_transform, quad, &local_quad, edge);
 
   TileProgramUniforms uniforms;
@@ -2098,7 +2100,7 @@ void GLRenderer::SwapBuffers() {
   compositor_frame.metadata = client_->MakeCompositorFrameMetadata();
   compositor_frame.gl_frame_data = make_scoped_ptr(new GLFrameData);
   compositor_frame.gl_frame_data->size = output_surface_->SurfaceSize();
-  if (capabilities_.using_partial_swap && client_->AllowPartialSwap()) {
+  if (capabilities_.using_partial_swap) {
     // If supported, we can save significant bandwidth by only swapping the
     // damaged/scissored region (clamped to the viewport)
     swap_buffer_rect_.Intersect(client_->DeviceViewport());
@@ -2511,7 +2513,7 @@ void GLRenderer::BindFramebufferToOutputSurface(DrawingFrame* frame) {
   current_framebuffer_lock_.reset();
   output_surface_->BindFramebuffer();
 
-  if (client_->ExternalStencilTestEnabled()) {
+  if (output_surface_->HasExternalStencilTest()) {
     SetStencilEnabled(true);
     GLC(context_, context_->stencilFunc(GL_EQUAL, 1, 1));
   } else {
@@ -3159,11 +3161,9 @@ void GLRenderer::LazyLabelOffscreenContext(
     return;
   offscreen_context_labelled_ = true;
   std::string unique_context_name = base::StringPrintf(
-      "%s-Offscreen-%p",
-      Settings().compositor_name.c_str(),
-      context_);
-  offscreen_context_provider->Context3d()->pushGroupMarkerEXT(
-      unique_context_name.c_str());
+      "%s-Offscreen-%p", settings_->compositor_name.c_str(), context_);
+  offscreen_context_provider->Context3d()
+      ->pushGroupMarkerEXT(unique_context_name.c_str());
 }
 
 
diff --git a/cc/output/gl_renderer.h b/cc/output/gl_renderer.h
index 030c863..e4bd650 100644
--- a/cc/output/gl_renderer.h
+++ b/cc/output/gl_renderer.h
@@ -40,6 +40,7 @@ class ScopedEnsureFramebufferAllocation;
 class CC_EXPORT GLRenderer : public DirectRenderer {
  public:
   static scoped_ptr<GLRenderer> Create(RendererClient* client,
+                                       const LayerTreeSettings* settings,
                                        OutputSurface* output_surface,
                                        ResourceProvider* resource_provider,
                                        int highp_threshold_min,
@@ -81,6 +82,7 @@ class CC_EXPORT GLRenderer : public DirectRenderer {
 
  protected:
   GLRenderer(RendererClient* client,
+             const LayerTreeSettings* settings,
              OutputSurface* output_surface,
              ResourceProvider* resource_provider,
              int highp_threshold_min);
diff --git a/cc/output/gl_renderer_unittest.cc b/cc/output/gl_renderer_unittest.cc
index 75b8277..dff29c8 100644
--- a/cc/output/gl_renderer_unittest.cc
+++ b/cc/output/gl_renderer_unittest.cc
@@ -141,9 +141,7 @@ class FakeRendererClient : public RendererClient {
       : host_impl_(&proxy_),
         set_full_root_layer_damage_count_(0),
         root_layer_(LayerImpl::Create(host_impl_.active_tree(), 1)),
-        viewport_size_(gfx::Size(1, 1)),
-        scale_factor_(1.f),
-        external_stencil_test_enabled_(false) {
+        viewport_size_(gfx::Size(1, 1)) {
     root_layer_->CreateRenderSurface();
     RenderPass::Id render_pass_id =
         root_layer_->render_surface()->RenderPassId();
@@ -158,44 +156,19 @@ class FakeRendererClient : public RendererClient {
     static gfx::Size fake_size(1, 1);
     return gfx::Rect(fake_size);
   }
-  virtual gfx::Rect DeviceClip() const OVERRIDE {
-    return DeviceViewport();
-  }
-  virtual float DeviceScaleFactor() const OVERRIDE {
-    return scale_factor_;
-  }
-  virtual const LayerTreeSettings& Settings() const OVERRIDE {
-    static LayerTreeSettings fake_settings;
-    return fake_settings;
-  }
+  virtual gfx::Rect DeviceClip() const OVERRIDE { return DeviceViewport(); }
   virtual void SetFullRootLayerDamage() OVERRIDE {
     set_full_root_layer_damage_count_++;
   }
-  virtual bool HasImplThread() const OVERRIDE { return false; }
-  virtual bool ShouldClearRootRenderPass() const OVERRIDE { return true; }
   virtual CompositorFrameMetadata MakeCompositorFrameMetadata() const OVERRIDE {
     return CompositorFrameMetadata();
   }
-  virtual bool AllowPartialSwap() const OVERRIDE {
-    return true;
-  }
-  virtual bool ExternalStencilTestEnabled() const OVERRIDE {
-    return external_stencil_test_enabled_;
-  }
-
-  void EnableExternalStencilTest() {
-    external_stencil_test_enabled_ = true;
-  }
 
   // Methods added for test.
   int set_full_root_layer_damage_count() const {
     return set_full_root_layer_damage_count_;
   }
-  void set_viewport_and_scale(
-      gfx::Size viewport_size, float scale_factor) {
-    viewport_size_ = viewport_size;
-    scale_factor_ = scale_factor;
-  }
+  void set_viewport(gfx::Size viewport_size) { viewport_size_ = viewport_size; }
 
   RenderPass* root_render_pass() { return render_passes_in_draw_order_.back(); }
   RenderPassList* render_passes_in_draw_order() {
@@ -209,16 +182,15 @@ class FakeRendererClient : public RendererClient {
   scoped_ptr<LayerImpl> root_layer_;
   RenderPassList render_passes_in_draw_order_;
   gfx::Size viewport_size_;
-  float scale_factor_;
-  bool external_stencil_test_enabled_;
 };
 
 class FakeRendererGL : public GLRenderer {
  public:
   FakeRendererGL(RendererClient* client,
+                 const LayerTreeSettings* settings,
                  OutputSurface* output_surface,
                  ResourceProvider* resource_provider)
-      : GLRenderer(client, output_surface, resource_provider, 0) {}
+      : GLRenderer(client, settings, output_surface, resource_provider, 0) {}
 
   // GLRenderer methods.
 
@@ -243,16 +215,17 @@ class GLRendererTest : public testing::Test {
 
     resource_provider_ =
         ResourceProvider::Create(output_surface_.get(), 0).Pass();
-    renderer_ = make_scoped_ptr(new FakeRendererGL(
-        &renderer_client_,
-        output_surface_.get(),
-        resource_provider_.get()));
+    renderer_ = make_scoped_ptr(new FakeRendererGL(&renderer_client_,
+                                                   &settings_,
+                                                   output_surface_.get(),
+                                                   resource_provider_.get()));
   }
 
   virtual void SetUp() { renderer_->Initialize(); }
 
   void SwapBuffers() { renderer_->SwapBuffers(); }
 
+  LayerTreeSettings settings_;
   FrameCountingContext* context3d_;
   FakeOutputSurfaceClient output_surface_client_;
   scoped_ptr<FakeOutputSurface> output_surface_;
@@ -335,6 +308,7 @@ class GLRendererShaderTest : public testing::Test {
     resource_provider_ = ResourceProvider::Create(output_surface_.get(),
                                                   0).Pass();
     renderer_.reset(new FakeRendererGL(&renderer_client_,
+                                       &settings_,
                                        output_surface_.get(),
                                        resource_provider_.get()));
     renderer_->Initialize();
@@ -394,6 +368,7 @@ class GLRendererShaderTest : public testing::Test {
               renderer_->program_shadow_);
   }
 
+  LayerTreeSettings settings_;
   FakeOutputSurfaceClient output_surface_client_;
   scoped_ptr<FakeOutputSurface> output_surface_;
   FakeRendererClient renderer_client_;
@@ -462,7 +437,8 @@ TEST_F(GLRendererTest, DiscardedBackbufferIsRecreatedForScopeDuration) {
   EXPECT_EQ(1, renderer_client_.set_full_root_layer_damage_count());
 
   renderer_->SetVisible(true);
-  renderer_->DrawFrame(renderer_client_.render_passes_in_draw_order(), NULL);
+  renderer_->DrawFrame(
+      renderer_client_.render_passes_in_draw_order(), NULL, 1.f, true);
   EXPECT_FALSE(renderer_->IsBackbufferDiscarded());
 
   SwapBuffers();
@@ -476,7 +452,8 @@ TEST_F(GLRendererTest, FramebufferDiscardedAfterReadbackWhenNotVisible) {
   EXPECT_EQ(1, renderer_client_.set_full_root_layer_damage_count());
 
   char pixels[4];
-  renderer_->DrawFrame(renderer_client_.render_passes_in_draw_order(), NULL);
+  renderer_->DrawFrame(
+      renderer_client_.render_passes_in_draw_order(), NULL, 1.f, true);
   EXPECT_FALSE(renderer_->IsBackbufferDiscarded());
 
   renderer_->GetFramebufferPixels(pixels, gfx::Rect(0, 0, 1, 1));
@@ -487,10 +464,11 @@ TEST_F(GLRendererTest, FramebufferDiscardedAfterReadbackWhenNotVisible) {
 TEST_F(GLRendererTest, ExternalStencil) {
   EXPECT_FALSE(renderer_->stencil_enabled());
 
-  renderer_client_.EnableExternalStencilTest();
+  output_surface_->set_has_external_stencil_test(true);
   renderer_client_.root_render_pass()->has_transparent_background = false;
 
-  renderer_->DrawFrame(renderer_client_.render_passes_in_draw_order(), NULL);
+  renderer_->DrawFrame(
+      renderer_client_.render_passes_in_draw_order(), NULL, 1.f, true);
   EXPECT_TRUE(renderer_->stencil_enabled());
 }
 
@@ -651,9 +629,12 @@ TEST(GLRendererTest2, InitializationDoesNotMakeSynchronousCalls) {
   scoped_ptr<ResourceProvider> resource_provider(
       ResourceProvider::Create(output_surface.get(), 0));
 
+  LayerTreeSettings settings;
   FakeRendererClient renderer_client;
-  FakeRendererGL renderer(
-      &renderer_client, output_surface.get(), resource_provider.get());
+  FakeRendererGL renderer(&renderer_client,
+                          &settings,
+                          output_surface.get(),
+                          resource_provider.get());
 
   EXPECT_TRUE(renderer.Initialize());
 }
@@ -693,9 +674,12 @@ TEST(GLRendererTest2, InitializationWithQuicklyLostContextDoesNotAssert) {
   scoped_ptr<ResourceProvider> resource_provider(
       ResourceProvider::Create(output_surface.get(), 0));
 
+  LayerTreeSettings settings;
   FakeRendererClient renderer_client;
-  FakeRendererGL renderer(
-      &renderer_client, output_surface.get(), resource_provider.get());
+  FakeRendererGL renderer(&renderer_client,
+                          &settings,
+                          output_surface.get(),
+                          resource_provider.get());
 
   renderer.Initialize();
 }
@@ -725,16 +709,19 @@ TEST(GLRendererTest2, OpaqueBackground) {
   scoped_ptr<ResourceProvider> resource_provider(
       ResourceProvider::Create(output_surface.get(), 0));
 
+  LayerTreeSettings settings;
   FakeRendererClient renderer_client;
-  FakeRendererGL renderer(
-      &renderer_client, output_surface.get(), resource_provider.get());
+  FakeRendererGL renderer(&renderer_client,
+                          &settings,
+                          output_surface.get(),
+                          resource_provider.get());
 
   renderer_client.root_render_pass()->has_transparent_background = false;
 
   EXPECT_TRUE(renderer.Initialize());
 
-// On DEBUG builds, render passes with opaque background clear to blue to
-// easily see regions that were not drawn on the screen.
+  // On DEBUG builds, render passes with opaque background clear to blue to
+  // easily see regions that were not drawn on the screen.
   EXPECT_CALL(*context, discardFramebufferEXT(GL_FRAMEBUFFER, 1, _))
       .Times(1);
 #ifdef NDEBUG
@@ -742,7 +729,8 @@ TEST(GLRendererTest2, OpaqueBackground) {
 #else
   EXPECT_CALL(*context, clear(_)).Times(1);
 #endif
-  renderer.DrawFrame(renderer_client.render_passes_in_draw_order(), NULL);
+  renderer.DrawFrame(
+      renderer_client.render_passes_in_draw_order(), NULL, 1.f, true);
   Mock::VerifyAndClearExpectations(context);
 }
 
@@ -758,9 +746,12 @@ TEST(GLRendererTest2, TransparentBackground) {
   scoped_ptr<ResourceProvider> resource_provider(
       ResourceProvider::Create(output_surface.get(), 0));
 
+  LayerTreeSettings settings;
   FakeRendererClient renderer_client;
-  FakeRendererGL renderer(
-      &renderer_client, output_surface.get(), resource_provider.get());
+  FakeRendererGL renderer(&renderer_client,
+                          &settings,
+                          output_surface.get(),
+                          resource_provider.get());
 
   renderer_client.root_render_pass()->has_transparent_background = true;
 
@@ -769,7 +760,8 @@ TEST(GLRendererTest2, TransparentBackground) {
   EXPECT_CALL(*context, discardFramebufferEXT(GL_FRAMEBUFFER, 1, _))
       .Times(1);
   EXPECT_CALL(*context, clear(_)).Times(1);
-  renderer.DrawFrame(renderer_client.render_passes_in_draw_order(), NULL);
+  renderer.DrawFrame(
+      renderer_client.render_passes_in_draw_order(), NULL, 1.f, true);
 
   Mock::VerifyAndClearExpectations(context);
 }
@@ -832,9 +824,12 @@ TEST(GLRendererTest2, VisibilityChangeIsLastCall) {
   scoped_ptr<ResourceProvider> resource_provider(
       ResourceProvider::Create(output_surface.get(), 0));
 
+  LayerTreeSettings settings;
   FakeRendererClient renderer_client;
-  FakeRendererGL renderer(
-      &renderer_client, output_surface.get(), resource_provider.get());
+  FakeRendererGL renderer(&renderer_client,
+                          &settings,
+                          output_surface.get(),
+                          resource_provider.get());
 
   EXPECT_TRUE(renderer.Initialize());
 
@@ -844,7 +839,8 @@ TEST(GLRendererTest2, VisibilityChangeIsLastCall) {
   // RenderClient and the Context by giving them both a pointer to a variable on
   // the stack.
   renderer.SetVisible(true);
-  renderer.DrawFrame(renderer_client.render_passes_in_draw_order(), NULL);
+  renderer.DrawFrame(
+      renderer_client.render_passes_in_draw_order(), NULL, 1.f, true);
   renderer.SetVisible(false);
   EXPECT_TRUE(context->last_call_was_set_visibility());
 }
@@ -888,9 +884,12 @@ TEST(GLRendererTest2, ActiveTextureState) {
   scoped_ptr<ResourceProvider> resource_provider(
       ResourceProvider::Create(output_surface.get(), 0));
 
+  LayerTreeSettings settings;
   FakeRendererClient renderer_client;
-  FakeRendererGL renderer(
-      &renderer_client, output_surface.get(), resource_provider.get());
+  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());
@@ -949,11 +948,6 @@ TEST(GLRendererTest2, ActiveTextureState) {
   Mock::VerifyAndClearExpectations(context);
 }
 
-class NoClearRootRenderPassFakeClient : public FakeRendererClient {
- public:
-  virtual bool ShouldClearRootRenderPass() const OVERRIDE { return false; }
-};
-
 class NoClearRootRenderPassMockContext : public TestWebGraphicsContext3D {
  public:
   MOCK_METHOD1(clear, void(WGC3Dbitfield mask));
@@ -977,9 +971,14 @@ TEST(GLRendererTest2, ShouldClearRootRenderPass) {
   scoped_ptr<ResourceProvider> resource_provider(
       ResourceProvider::Create(output_surface.get(), 0));
 
-  NoClearRootRenderPassFakeClient renderer_client;
-  FakeRendererGL renderer(
-      &renderer_client, output_surface.get(), resource_provider.get());
+  LayerTreeSettings settings;
+  settings.should_clear_root_render_pass = false;
+
+  FakeRendererClient renderer_client;
+  FakeRendererGL renderer(&renderer_client,
+                          &settings,
+                          output_surface.get(),
+                          resource_provider.get());
   EXPECT_TRUE(renderer.Initialize());
 
   gfx::Rect viewport_rect(renderer_client.DeviceViewport());
@@ -1020,7 +1019,8 @@ TEST(GLRendererTest2, ShouldClearRootRenderPass) {
 
   renderer.DecideRenderPassAllocationsForFrame(
       *renderer_client.render_passes_in_draw_order());
-  renderer.DrawFrame(renderer_client.render_passes_in_draw_order(), NULL);
+  renderer.DrawFrame(
+      renderer_client.render_passes_in_draw_order(), NULL, 1.f, true);
 
   // In multiple render passes all but the root pass should clear the
   // framebuffer.
@@ -1059,9 +1059,12 @@ TEST(GLRendererTest2, ScissorTestWhenClearing) {
   scoped_ptr<ResourceProvider> resource_provider(
       ResourceProvider::Create(output_surface.get(), 0));
 
+  LayerTreeSettings settings;
   FakeRendererClient renderer_client;
-  FakeRendererGL renderer(
-      &renderer_client, output_surface.get(), resource_provider.get());
+  FakeRendererGL renderer(&renderer_client,
+                          &settings,
+                          output_surface.get(),
+                          resource_provider.get());
   EXPECT_TRUE(renderer.Initialize());
   EXPECT_FALSE(renderer.Capabilities().using_partial_swap);
 
@@ -1092,7 +1095,8 @@ TEST(GLRendererTest2, ScissorTestWhenClearing) {
 
   renderer.DecideRenderPassAllocationsForFrame(
       *renderer_client.render_passes_in_draw_order());
-  renderer.DrawFrame(renderer_client.render_passes_in_draw_order(), NULL);
+  renderer.DrawFrame(
+      renderer_client.render_passes_in_draw_order(), NULL, 1.f, true);
 }
 
 class NonReshapableOutputSurface : public FakeOutputSurface {
@@ -1158,9 +1162,12 @@ TEST(GLRendererTest2, ScissorAndViewportWithinNonreshapableSurface) {
   scoped_ptr<ResourceProvider> resource_provider(
       ResourceProvider::Create(output_surface.get(), 0));
 
+  LayerTreeSettings settings;
   OffsetViewportRendererClient renderer_client;
-  FakeRendererGL renderer(
-      &renderer_client, output_surface.get(), resource_provider.get());
+  FakeRendererGL renderer(&renderer_client,
+                          &settings,
+                          output_surface.get(),
+                          resource_provider.get());
   EXPECT_TRUE(renderer.Initialize());
   EXPECT_FALSE(renderer.Capabilities().using_partial_swap);
 
@@ -1177,7 +1184,8 @@ TEST(GLRendererTest2, ScissorAndViewportWithinNonreshapableSurface) {
 
   renderer.DecideRenderPassAllocationsForFrame(
       *renderer_client.render_passes_in_draw_order());
-  renderer.DrawFrame(renderer_client.render_passes_in_draw_order(), NULL);
+  renderer.DrawFrame(
+      renderer_client.render_passes_in_draw_order(), NULL, 1.f, true);
 }
 
 TEST_F(GLRendererShaderTest, DrawRenderPassQuadShaderPermutations) {
@@ -1240,7 +1248,8 @@ TEST_F(GLRendererShaderTest, DrawRenderPassQuadShaderPermutations) {
 
   renderer_->DecideRenderPassAllocationsForFrame(
       *renderer_client_.render_passes_in_draw_order());
-  renderer_->DrawFrame(renderer_client_.render_passes_in_draw_order(), NULL);
+  renderer_->DrawFrame(
+      renderer_client_.render_passes_in_draw_order(), NULL, 1.f, true);
   TestRenderPassProgram();
 
   // RenderPassColorMatrixProgram
@@ -1256,7 +1265,8 @@ TEST_F(GLRendererShaderTest, DrawRenderPassQuadShaderPermutations) {
 
   renderer_->DecideRenderPassAllocationsForFrame(
       *renderer_client_.render_passes_in_draw_order());
-  renderer_->DrawFrame(renderer_client_.render_passes_in_draw_order(), NULL);
+  renderer_->DrawFrame(
+      renderer_client_.render_passes_in_draw_order(), NULL, 1.f, true);
   TestRenderPassColorMatrixProgram();
 
   // RenderPassMaskProgram
@@ -1276,7 +1286,8 @@ TEST_F(GLRendererShaderTest, DrawRenderPassQuadShaderPermutations) {
 
   renderer_->DecideRenderPassAllocationsForFrame(
       *renderer_client_.render_passes_in_draw_order());
-  renderer_->DrawFrame(renderer_client_.render_passes_in_draw_order(), NULL);
+  renderer_->DrawFrame(
+      renderer_client_.render_passes_in_draw_order(), NULL, 1.f, true);
   TestRenderPassMaskProgram();
 
   // RenderPassMaskColorMatrixProgram
@@ -1292,7 +1303,8 @@ TEST_F(GLRendererShaderTest, DrawRenderPassQuadShaderPermutations) {
 
   renderer_->DecideRenderPassAllocationsForFrame(
       *renderer_client_.render_passes_in_draw_order());
-  renderer_->DrawFrame(renderer_client_.render_passes_in_draw_order(), NULL);
+  renderer_->DrawFrame(
+      renderer_client_.render_passes_in_draw_order(), NULL, 1.f, true);
   TestRenderPassMaskColorMatrixProgram();
 
   // RenderPassProgramAA
@@ -1312,7 +1324,8 @@ TEST_F(GLRendererShaderTest, DrawRenderPassQuadShaderPermutations) {
 
   renderer_->DecideRenderPassAllocationsForFrame(
       *renderer_client_.render_passes_in_draw_order());
-  renderer_->DrawFrame(renderer_client_.render_passes_in_draw_order(), NULL);
+  renderer_->DrawFrame(
+      renderer_client_.render_passes_in_draw_order(), NULL, 1.f, true);
   TestRenderPassProgramAA();
 
   // RenderPassColorMatrixProgramAA
@@ -1328,7 +1341,8 @@ TEST_F(GLRendererShaderTest, DrawRenderPassQuadShaderPermutations) {
 
   renderer_->DecideRenderPassAllocationsForFrame(
       *renderer_client_.render_passes_in_draw_order());
-  renderer_->DrawFrame(renderer_client_.render_passes_in_draw_order(), NULL);
+  renderer_->DrawFrame(
+      renderer_client_.render_passes_in_draw_order(), NULL, 1.f, true);
   TestRenderPassColorMatrixProgramAA();
 
   // RenderPassMaskProgramAA
@@ -1345,7 +1359,8 @@ TEST_F(GLRendererShaderTest, DrawRenderPassQuadShaderPermutations) {
 
   renderer_->DecideRenderPassAllocationsForFrame(
       *renderer_client_.render_passes_in_draw_order());
-  renderer_->DrawFrame(renderer_client_.render_passes_in_draw_order(), NULL);
+  renderer_->DrawFrame(
+      renderer_client_.render_passes_in_draw_order(), NULL, 1.f, true);
   TestRenderPassMaskProgramAA();
 
   // RenderPassMaskColorMatrixProgramAA
@@ -1361,7 +1376,8 @@ TEST_F(GLRendererShaderTest, DrawRenderPassQuadShaderPermutations) {
 
   renderer_->DecideRenderPassAllocationsForFrame(
       *renderer_client_.render_passes_in_draw_order());
-  renderer_->DrawFrame(renderer_client_.render_passes_in_draw_order(), NULL);
+  renderer_->DrawFrame(
+      renderer_client_.render_passes_in_draw_order(), NULL, 1.f, true);
   TestRenderPassMaskColorMatrixProgramAA();
 }
 
@@ -1409,7 +1425,8 @@ TEST_F(GLRendererShaderTest, DrawRenderPassQuadSkipsAAForClippingTransform) {
 
   renderer_->DecideRenderPassAllocationsForFrame(
       *renderer_client_.render_passes_in_draw_order());
-  renderer_->DrawFrame(renderer_client_.render_passes_in_draw_order(), NULL);
+  renderer_->DrawFrame(
+      renderer_client_.render_passes_in_draw_order(), NULL, 1.f, true);
 
   // If use_aa incorrectly ignores clipping, it will use the
   // RenderPassProgramAA shader instead of the RenderPassProgram.
@@ -1439,7 +1456,8 @@ TEST_F(GLRendererShaderTest, DrawSolidColorShader) {
 
   renderer_->DecideRenderPassAllocationsForFrame(
       *renderer_client_.render_passes_in_draw_order());
-  renderer_->DrawFrame(renderer_client_.render_passes_in_draw_order(), NULL);
+  renderer_->DrawFrame(
+      renderer_client_.render_passes_in_draw_order(), NULL, 1.f, true);
 
   TestSolidColorProgramAA();
 }
@@ -1493,15 +1511,14 @@ class MockOutputSurfaceTest : public testing::Test, public FakeRendererClient {
 
     resource_provider_ = ResourceProvider::Create(&output_surface_, 0).Pass();
 
-    renderer_.reset(new FakeRendererGL(this,
-                                       &output_surface_,
-                                       resource_provider_.get()));
+    renderer_.reset(new FakeRendererGL(
+        this, &settings_, &output_surface_, resource_provider_.get()));
     EXPECT_TRUE(renderer_->Initialize());
   }
 
   void SwapBuffers() { renderer_->SwapBuffers(); }
 
-  void DrawFrame() {
+  void DrawFrame(float device_scale_factor) {
     gfx::Rect viewport_rect(DeviceViewport());
     ScopedPtrVector<RenderPass>* render_passes = render_passes_in_draw_order();
     render_passes->clear();
@@ -1514,7 +1531,7 @@ class MockOutputSurfaceTest : public testing::Test, public FakeRendererClient {
     EXPECT_CALL(output_surface_, EnsureBackbuffer()).WillRepeatedly(Return());
 
     EXPECT_CALL(output_surface_,
-                Reshape(DeviceViewport().size(), DeviceScaleFactor())).Times(1);
+                Reshape(DeviceViewport().size(), device_scale_factor)).Times(1);
 
     EXPECT_CALL(output_surface_, BindFramebuffer()).Times(1);
 
@@ -1522,7 +1539,8 @@ class MockOutputSurfaceTest : public testing::Test, public FakeRendererClient {
 
     renderer_->DecideRenderPassAllocationsForFrame(
         *render_passes_in_draw_order());
-    renderer_->DrawFrame(render_passes_in_draw_order(), NULL);
+    renderer_->DrawFrame(
+        render_passes_in_draw_order(), NULL, device_scale_factor, true);
   }
 
   OutputSurfaceMockContext* Context() {
@@ -1530,6 +1548,7 @@ class MockOutputSurfaceTest : public testing::Test, public FakeRendererClient {
         output_surface_.context_provider()->Context3d());
   }
 
+  LayerTreeSettings settings_;
   FakeOutputSurfaceClient output_surface_client_;
   StrictMock<MockOutputSurface> output_surface_;
   scoped_ptr<ResourceProvider> resource_provider_;
@@ -1537,32 +1556,32 @@ class MockOutputSurfaceTest : public testing::Test, public FakeRendererClient {
 };
 
 TEST_F(MockOutputSurfaceTest, DrawFrameAndSwap) {
-  DrawFrame();
+  DrawFrame(1.f);
 
   EXPECT_CALL(output_surface_, SwapBuffers(_)).Times(1);
   renderer_->SwapBuffers();
 }
 
 TEST_F(MockOutputSurfaceTest, DrawFrameAndResizeAndSwap) {
-  DrawFrame();
+  DrawFrame(1.f);
   EXPECT_CALL(output_surface_, SwapBuffers(_)).Times(1);
   renderer_->SwapBuffers();
 
-  set_viewport_and_scale(gfx::Size(2, 2), 2.f);
+  set_viewport(gfx::Size(2, 2));
   renderer_->ViewportChanged();
 
-  DrawFrame();
+  DrawFrame(2.f);
   EXPECT_CALL(output_surface_, SwapBuffers(_)).Times(1);
   renderer_->SwapBuffers();
 
-  DrawFrame();
+  DrawFrame(2.f);
   EXPECT_CALL(output_surface_, SwapBuffers(_)).Times(1);
   renderer_->SwapBuffers();
 
-  set_viewport_and_scale(gfx::Size(1, 1), 1.f);
+  set_viewport(gfx::Size(1, 1));
   renderer_->ViewportChanged();
 
-  DrawFrame();
+  DrawFrame(1.f);
   EXPECT_CALL(output_surface_, SwapBuffers(_)).Times(1);
   renderer_->SwapBuffers();
 }
diff --git a/cc/output/output_surface.cc b/cc/output/output_surface.cc
index bd2e8c1..2ffcf95 100644
--- a/cc/output/output_surface.cc
+++ b/cc/output/output_surface.cc
@@ -30,8 +30,7 @@ using std::vector;
 
 namespace cc {
 
-OutputSurface::OutputSurface(
-    scoped_refptr<ContextProvider> context_provider)
+OutputSurface::OutputSurface(scoped_refptr<ContextProvider> context_provider)
     : context_provider_(context_provider),
       has_gl_discard_backbuffer_(false),
       has_swap_buffers_complete_callback_(false),
@@ -42,8 +41,8 @@ OutputSurface::OutputSurface(
       needs_begin_frame_(false),
       begin_frame_pending_(false),
       client_(NULL),
-      check_for_retroactive_begin_frame_pending_(false) {
-}
+      check_for_retroactive_begin_frame_pending_(false),
+      external_stencil_test_enabled_(false) {}
 
 OutputSurface::OutputSurface(
     scoped_ptr<cc::SoftwareOutputDevice> software_device)
@@ -57,8 +56,8 @@ OutputSurface::OutputSurface(
       needs_begin_frame_(false),
       begin_frame_pending_(false),
       client_(NULL),
-      check_for_retroactive_begin_frame_pending_(false) {
-}
+      check_for_retroactive_begin_frame_pending_(false),
+      external_stencil_test_enabled_(false) {}
 
 OutputSurface::OutputSurface(
     scoped_refptr<ContextProvider> context_provider,
@@ -74,8 +73,8 @@ OutputSurface::OutputSurface(
       needs_begin_frame_(false),
       begin_frame_pending_(false),
       client_(NULL),
-      check_for_retroactive_begin_frame_pending_(false) {
-}
+      check_for_retroactive_begin_frame_pending_(false),
+      external_stencil_test_enabled_(false) {}
 
 void OutputSurface::InitializeBeginFrameEmulation(
     base::SingleThreadTaskRunner* task_runner,
@@ -220,7 +219,7 @@ void OutputSurface::DidLoseOutputSurface() {
 }
 
 void OutputSurface::SetExternalStencilTest(bool enabled) {
-  client_->SetExternalStencilTest(enabled);
+  external_stencil_test_enabled_ = enabled;
 }
 
 void OutputSurface::SetExternalDrawConstraints(const gfx::Transform& transform,
@@ -237,10 +236,12 @@ OutputSurface::~OutputSurface() {
   ResetContext3d();
 }
 
-bool OutputSurface::ForcedDrawToSoftwareDevice() const {
-  return false;
+bool OutputSurface::HasExternalStencilTest() const {
+  return external_stencil_test_enabled_;
 }
 
+bool OutputSurface::ForcedDrawToSoftwareDevice() const { return false; }
+
 bool OutputSurface::BindToClient(cc::OutputSurfaceClient* client) {
   DCHECK(client);
   client_ = client;
diff --git a/cc/output/output_surface.h b/cc/output/output_surface.h
index 84d128a..c01c768 100644
--- a/cc/output/output_surface.h
+++ b/cc/output/output_surface.h
@@ -73,6 +73,8 @@ class CC_EXPORT OutputSurface : public FrameRateControllerClient {
     return capabilities_;
   }
 
+  virtual bool HasExternalStencilTest() const;
+
   // Obtain the 3d context or the software device associated with this output
   // surface. Either of these may return a null pointer, but not both.
   // In the event of a lost context, the entire output surface should be
@@ -194,6 +196,8 @@ class CC_EXPORT OutputSurface : public FrameRateControllerClient {
   // redundant checks for a retroactive BeginFrame.
   bool check_for_retroactive_begin_frame_pending_;
 
+  bool external_stencil_test_enabled_;
+
   DISALLOW_COPY_AND_ASSIGN(OutputSurface);
 };
 
diff --git a/cc/output/output_surface_client.h b/cc/output/output_surface_client.h
index 7b59513..06e148d 100644
--- a/cc/output/output_surface_client.h
+++ b/cc/output/output_surface_client.h
@@ -34,7 +34,6 @@ class CC_EXPORT OutputSurfaceClient {
   virtual void BeginFrame(const BeginFrameArgs& args) = 0;
   virtual void OnSwapBuffersComplete(const CompositorFrameAck* ack) = 0;
   virtual void DidLoseOutputSurface() = 0;
-  virtual void SetExternalStencilTest(bool enabled) = 0;
   virtual void SetExternalDrawConstraints(const gfx::Transform& transform,
                                           gfx::Rect viewport,
                                           gfx::Rect clip,
diff --git a/cc/output/renderer.h b/cc/output/renderer.h
index 7624a5b..32a109f 100644
--- a/cc/output/renderer.h
+++ b/cc/output/renderer.h
@@ -23,15 +23,8 @@ class CC_EXPORT RendererClient {
   // contained within the output surface size.
   virtual gfx::Rect DeviceViewport() const = 0;
   virtual gfx::Rect DeviceClip() const = 0;
-
-  virtual float DeviceScaleFactor() const = 0;
-  virtual const LayerTreeSettings& Settings() const = 0;
   virtual void SetFullRootLayerDamage() = 0;
-  virtual bool HasImplThread() const = 0;
-  virtual bool ShouldClearRootRenderPass() const = 0;
   virtual CompositorFrameMetadata MakeCompositorFrameMetadata() const = 0;
-  virtual bool AllowPartialSwap() const = 0;
-  virtual bool ExternalStencilTestEnabled() const = 0;
 
  protected:
   virtual ~RendererClient() {}
@@ -43,8 +36,6 @@ class CC_EXPORT Renderer {
 
   virtual const RendererCapabilities& Capabilities() const = 0;
 
-  const LayerTreeSettings& Settings() const { return client_->Settings(); }
-
   virtual void ViewportChanged() {}
 
   virtual bool CanReadPixels() const = 0;
@@ -54,11 +45,12 @@ class CC_EXPORT Renderer {
   virtual bool HaveCachedResourcesForRenderPassId(RenderPass::Id id) const;
 
   // This passes ownership of the render passes to the renderer. It should
-  // consume them, and empty the list.
-  // The |offscreen_context_provider| may change from frame to frame and should
-  // not be cached.
+  // consume them, and empty the list. The parameters here may change from frame
+  // to frame and should not be cached.
   virtual void DrawFrame(RenderPassList* render_passes_in_draw_order,
-                         ContextProvider* offscreen_context_provider) = 0;
+                         ContextProvider* offscreen_context_provider,
+                         float device_scale_factor,
+                         bool allow_partial_swap) = 0;
 
   // Waits for rendering to finish.
   virtual void Finish() = 0;
@@ -82,10 +74,11 @@ class CC_EXPORT Renderer {
   virtual void SetDiscardBackBufferWhenNotVisible(bool discard) = 0;
 
  protected:
-  explicit Renderer(RendererClient* client)
-      : client_(client) {}
+  explicit Renderer(RendererClient* client, const LayerTreeSettings* settings)
+      : client_(client), settings_(settings) {}
 
   RendererClient* client_;
+  const LayerTreeSettings* settings_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(Renderer);
diff --git a/cc/output/software_renderer.cc b/cc/output/software_renderer.cc
index 04f8a8b..7e8f4f8 100644
--- a/cc/output/software_renderer.cc
+++ b/cc/output/software_renderer.cc
@@ -51,21 +51,23 @@ bool IsScaleAndIntegerTranslate(const SkMatrix& matrix) {
 
 scoped_ptr<SoftwareRenderer> SoftwareRenderer::Create(
     RendererClient* client,
+    const LayerTreeSettings* settings,
     OutputSurface* output_surface,
     ResourceProvider* resource_provider) {
-  return make_scoped_ptr(
-      new SoftwareRenderer(client, output_surface, resource_provider));
+  return make_scoped_ptr(new SoftwareRenderer(
+      client, settings, output_surface, resource_provider));
 }
 
 SoftwareRenderer::SoftwareRenderer(RendererClient* client,
+                                   const LayerTreeSettings* settings,
                                    OutputSurface* output_surface,
                                    ResourceProvider* resource_provider)
-  : DirectRenderer(client, output_surface, resource_provider),
-    visible_(true),
-    is_scissor_enabled_(false),
-    is_backbuffer_discarded_(false),
-    output_device_(output_surface->software_device()),
-    current_canvas_(NULL) {
+    : DirectRenderer(client, settings, output_surface, resource_provider),
+      visible_(true),
+      is_scissor_enabled_(false),
+      is_backbuffer_discarded_(false),
+      output_device_(output_surface->software_device()),
+      current_canvas_(NULL) {
   if (resource_provider_) {
     capabilities_.max_texture_size = resource_provider_->max_texture_size();
     capabilities_.best_texture_format =
@@ -76,7 +78,7 @@ SoftwareRenderer::SoftwareRenderer(RendererClient* client,
   capabilities_.allow_partial_texture_updates = true;
   capabilities_.using_partial_swap = true;
 
-  capabilities_.using_map_image = Settings().use_map_image;
+  capabilities_.using_map_image = settings_->use_map_image;
   capabilities_.using_shared_memory_resources = true;
 }
 
@@ -135,7 +137,7 @@ void SoftwareRenderer::EnsureScissorTestDisabled() {
 void SoftwareRenderer::Finish() {}
 
 void SoftwareRenderer::BindFramebufferToOutputSurface(DrawingFrame* frame) {
-  DCHECK(!client_->ExternalStencilTestEnabled());
+  DCHECK(!output_surface_->HasExternalStencilTest());
   current_framebuffer_lock_.reset();
   current_canvas_ = root_canvas_;
 }
@@ -228,8 +230,7 @@ void SoftwareRenderer::DoDrawQuad(DrawingFrame* frame, const DrawQuad* quad) {
                                        quad->IsLeftEdge() &&
                                        quad->IsBottomEdge() &&
                                        quad->IsRightEdge();
-    if (Settings().allow_antialiasing &&
-        all_four_edges_are_exterior)
+    if (settings_->allow_antialiasing && all_four_edges_are_exterior)
       current_paint_.setAntiAlias(true);
     current_paint_.setFilterBitmap(true);
   }
diff --git a/cc/output/software_renderer.h b/cc/output/software_renderer.h
index e07b237..e534f80 100644
--- a/cc/output/software_renderer.h
+++ b/cc/output/software_renderer.h
@@ -29,6 +29,7 @@ class CC_EXPORT SoftwareRenderer : public DirectRenderer {
  public:
   static scoped_ptr<SoftwareRenderer> Create(
       RendererClient* client,
+      const LayerTreeSettings* settings,
       OutputSurface* output_surface,
       ResourceProvider* resource_provider);
 
@@ -67,10 +68,10 @@ class CC_EXPORT SoftwareRenderer : public DirectRenderer {
       DrawingFrame* frame,
       scoped_ptr<CopyOutputRequest> request) OVERRIDE;
 
-  SoftwareRenderer(
-      RendererClient* client,
-      OutputSurface* output_surface,
-      ResourceProvider* resource_provider);
+  SoftwareRenderer(RendererClient* client,
+                   const LayerTreeSettings* settings,
+                   OutputSurface* output_surface,
+                   ResourceProvider* resource_provider);
 
  private:
   void ClearCanvas(SkColor color);
diff --git a/cc/output/software_renderer_unittest.cc b/cc/output/software_renderer_unittest.cc
index b8a5b21..6f61525 100644
--- a/cc/output/software_renderer_unittest.cc
+++ b/cc/output/software_renderer_unittest.cc
@@ -27,8 +27,6 @@ namespace {
 
 class SoftwareRendererTest : public testing::Test, public RendererClient {
  public:
-  SoftwareRendererTest() : should_clear_root_render_pass_(true) {}
-
   void InitializeRenderer(
       scoped_ptr<SoftwareOutputDevice> software_output_device) {
     output_surface_ = FakeOutputSurface::CreateSoftware(
@@ -37,7 +35,7 @@ class SoftwareRendererTest : public testing::Test, public RendererClient {
 
     resource_provider_ = ResourceProvider::Create(output_surface_.get(), 0);
     renderer_ = SoftwareRenderer::Create(
-        this, output_surface_.get(), resource_provider());
+        this, &settings_, output_surface_.get(), resource_provider());
   }
 
   ResourceProvider* resource_provider() const {
@@ -50,44 +48,23 @@ class SoftwareRendererTest : public testing::Test, public RendererClient {
     viewport_ = viewport;
   }
 
-  void set_should_clear_root_render_pass(bool clear_root_render_pass) {
-    should_clear_root_render_pass_ = clear_root_render_pass;
-  }
-
   // RendererClient implementation.
   virtual gfx::Rect DeviceViewport() const OVERRIDE {
     return viewport_;
   }
-  virtual gfx::Rect DeviceClip() const OVERRIDE {
-    return DeviceViewport();
-  }
-  virtual float DeviceScaleFactor() const OVERRIDE {
-    return 1.f;
-  }
-  virtual const LayerTreeSettings& Settings() const OVERRIDE {
-    return settings_;
-  }
+  virtual gfx::Rect DeviceClip() const OVERRIDE { return DeviceViewport(); }
   virtual void SetFullRootLayerDamage() OVERRIDE {}
-  virtual bool HasImplThread() const OVERRIDE { return false; }
-  virtual bool ShouldClearRootRenderPass() const OVERRIDE {
-    return should_clear_root_render_pass_;
-  }
   virtual CompositorFrameMetadata MakeCompositorFrameMetadata() const OVERRIDE {
     return CompositorFrameMetadata();
   }
-  virtual bool AllowPartialSwap() const OVERRIDE {
-    return true;
-  }
-  virtual bool ExternalStencilTestEnabled() const OVERRIDE { return false; }
 
  protected:
+  LayerTreeSettings settings_;
   FakeOutputSurfaceClient output_surface_client_;
   scoped_ptr<FakeOutputSurface> output_surface_;
   scoped_ptr<ResourceProvider> resource_provider_;
   scoped_ptr<SoftwareRenderer> renderer_;
   gfx::Rect viewport_;
-  LayerTreeSettings settings_;
-  bool should_clear_root_render_pass_;
 };
 
 TEST_F(SoftwareRendererTest, SolidColorQuad) {
@@ -118,7 +95,9 @@ TEST_F(SoftwareRendererTest, SolidColorQuad) {
 
   RenderPassList list;
   list.push_back(root_render_pass.PassAs<RenderPass>());
-  renderer()->DrawFrame(&list, NULL);
+
+  float device_scale_factor = 1.f;
+  renderer()->DrawFrame(&list, NULL, device_scale_factor, true);
 
   SkBitmap output;
   output.setConfig(SkBitmap::kARGB_8888_Config,
@@ -207,7 +186,9 @@ TEST_F(SoftwareRendererTest, TileQuad) {
 
   RenderPassList list;
   list.push_back(root_render_pass.PassAs<RenderPass>());
-  renderer()->DrawFrame(&list, NULL);
+
+  float device_scale_factor = 1.f;
+  renderer()->DrawFrame(&list, NULL, device_scale_factor, true);
 
   SkBitmap output;
   output.setConfig(SkBitmap::kARGB_8888_Config,
@@ -275,7 +256,9 @@ TEST_F(SoftwareRendererTest, TileQuadVisibleRect) {
 
   RenderPassList list;
   list.push_back(root_render_pass.PassAs<RenderPass>());
-  renderer()->DrawFrame(&list, NULL);
+
+  float device_scale_factor = 1.f;
+  renderer()->DrawFrame(&list, NULL, device_scale_factor, true);
 
   SkBitmap output;
   output.setConfig(SkBitmap::kARGB_8888_Config,
@@ -305,9 +288,11 @@ TEST_F(SoftwareRendererTest, TileQuadVisibleRect) {
 }
 
 TEST_F(SoftwareRendererTest, ShouldClearRootRenderPass) {
+  float device_scale_factor = 1.f;
   gfx::Rect viewport_rect(0, 0, 100, 100);
   set_viewport(viewport_rect);
-  set_should_clear_root_render_pass(false);
+
+  settings_.should_clear_root_render_pass = false;
   InitializeRenderer(make_scoped_ptr(new SoftwareOutputDevice));
 
   RenderPassList list;
@@ -325,7 +310,7 @@ TEST_F(SoftwareRendererTest, ShouldClearRootRenderPass) {
   AddQuad(root_clear_pass, viewport_rect, SK_ColorGREEN);
 
   renderer()->DecideRenderPassAllocationsForFrame(list);
-  renderer()->DrawFrame(&list, NULL);
+  renderer()->DrawFrame(&list, NULL, device_scale_factor, true);
   renderer()->GetFramebufferPixels(output.getPixels(), viewport_rect);
 
   EXPECT_EQ(SK_ColorGREEN, output.getColor(0, 0));
@@ -344,7 +329,7 @@ TEST_F(SoftwareRendererTest, ShouldClearRootRenderPass) {
   AddQuad(root_smaller_pass, smaller_rect, SK_ColorMAGENTA);
 
   renderer()->DecideRenderPassAllocationsForFrame(list);
-  renderer()->DrawFrame(&list, NULL);
+  renderer()->DrawFrame(&list, NULL, device_scale_factor, true);
   renderer()->GetFramebufferPixels(output.getPixels(), viewport_rect);
 
   // If we didn't clear, the borders should still be green.
@@ -359,6 +344,7 @@ TEST_F(SoftwareRendererTest, ShouldClearRootRenderPass) {
 }
 
 TEST_F(SoftwareRendererTest, RenderPassVisibleRect) {
+  float device_scale_factor = 1.f;
   gfx::Rect viewport_rect(0, 0, 100, 100);
   set_viewport(viewport_rect);
   InitializeRenderer(make_scoped_ptr(new SoftwareOutputDevice));
@@ -390,7 +376,7 @@ TEST_F(SoftwareRendererTest, RenderPassVisibleRect) {
   root_clear_pass->quad_list[0]->visible_rect = interior_visible_rect;
 
   renderer()->DecideRenderPassAllocationsForFrame(list);
-  renderer()->DrawFrame(&list, NULL);
+  renderer()->DrawFrame(&list, NULL, device_scale_factor, true);
   renderer()->GetFramebufferPixels(output.getPixels(), viewport_rect);
 
   EXPECT_EQ(SK_ColorGREEN, output.getColor(0, 0));