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

24 files changed, 340 insertions, 343 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));
diff --git a/cc/test/fake_output_surface.cc b/cc/test/fake_output_surface.cc
index bc94f19..779396e 100644
--- a/cc/test/fake_output_surface.cc
+++ b/cc/test/fake_output_surface.cc
@@ -21,6 +21,7 @@ FakeOutputSurface::FakeOutputSurface(
       num_sent_frames_(0),
       needs_begin_frame_(false),
       forced_draw_to_software_device_(false),
+      has_external_stencil_test_(false),
       fake_weak_ptr_factory_(this) {
   if (delegated_rendering) {
     capabilities_.delegated_rendering = true;
@@ -29,11 +30,13 @@ FakeOutputSurface::FakeOutputSurface(
 }
 
 FakeOutputSurface::FakeOutputSurface(
-    scoped_ptr<SoftwareOutputDevice> software_device, bool delegated_rendering)
+    scoped_ptr<SoftwareOutputDevice> software_device,
+    bool delegated_rendering)
     : OutputSurface(software_device.Pass()),
       client_(NULL),
       num_sent_frames_(0),
       forced_draw_to_software_device_(false),
+      has_external_stencil_test_(false),
       fake_weak_ptr_factory_(this) {
   if (delegated_rendering) {
     capabilities_.delegated_rendering = true;
@@ -49,6 +52,7 @@ FakeOutputSurface::FakeOutputSurface(
       client_(NULL),
       num_sent_frames_(0),
       forced_draw_to_software_device_(false),
+      has_external_stencil_test_(false),
       fake_weak_ptr_factory_(this) {
   if (delegated_rendering) {
     capabilities_.delegated_rendering = true;
@@ -131,4 +135,8 @@ void FakeOutputSurface::ReturnResource(unsigned id, CompositorFrameAck* ack) {
   resources_held_by_parent_.erase(it);
 }
 
+bool FakeOutputSurface::HasExternalStencilTest() const {
+  return has_external_stencil_test_;
+}
+
 }  // namespace cc
diff --git a/cc/test/fake_output_surface.h b/cc/test/fake_output_surface.h
index 3f87bd3..ab91089 100644
--- a/cc/test/fake_output_surface.h
+++ b/cc/test/fake_output_surface.h
@@ -108,6 +108,12 @@ class FakeOutputSurface : public OutputSurface {
 
   void ReturnResource(unsigned id, CompositorFrameAck* ack);
 
+  virtual bool HasExternalStencilTest() const OVERRIDE;
+
+  void set_has_external_stencil_test(bool has_test) {
+    has_external_stencil_test_ = has_test;
+  }
+
  protected:
   FakeOutputSurface(
       scoped_refptr<ContextProvider> context_provider,
@@ -129,6 +135,7 @@ class FakeOutputSurface : public OutputSurface {
   size_t num_sent_frames_;
   bool needs_begin_frame_;
   bool forced_draw_to_software_device_;
+  bool has_external_stencil_test_;
   base::WeakPtrFactory<FakeOutputSurface> fake_weak_ptr_factory_;
   TransferableResourceArray resources_held_by_parent_;
 };
diff --git a/cc/test/fake_output_surface_client.h b/cc/test/fake_output_surface_client.h
index 24c8c74..7a3bcc7 100644
--- a/cc/test/fake_output_surface_client.h
+++ b/cc/test/fake_output_surface_client.h
@@ -32,7 +32,6 @@ class FakeOutputSurfaceClient : public OutputSurfaceClient {
       gfx::Rect viewport,
       gfx::Rect clip,
       bool valid_for_tile_management) OVERRIDE {}
-  virtual void SetExternalStencilTest(bool enable) OVERRIDE {}
   virtual void SetMemoryPolicy(const ManagedMemoryPolicy& policy) OVERRIDE;
   virtual void SetDiscardBackBufferWhenNotVisible(bool discard) OVERRIDE;
   virtual void SetTreeActivationCallback(const base::Closure&) OVERRIDE {}
diff --git a/cc/test/pixel_test.cc b/cc/test/pixel_test.cc
index 8801596..347f81c 100644
--- a/cc/test/pixel_test.cc
+++ b/cc/test/pixel_test.cc
@@ -28,36 +28,18 @@ class PixelTest::PixelTestRendererClient
     : public RendererClient, public OutputSurfaceClient {
  public:
   explicit PixelTestRendererClient(gfx::Rect device_viewport)
-      : device_viewport_(device_viewport),
-        device_clip_(device_viewport),
-        stencil_enabled_(false) {}
+      : device_viewport_(device_viewport), device_clip_(device_viewport) {}
 
   // RendererClient implementation.
   virtual gfx::Rect DeviceViewport() const OVERRIDE {
     return device_viewport_;
   }
-  virtual gfx::Rect DeviceClip() const OVERRIDE {
-    return device_clip_;
-  }
-  virtual float DeviceScaleFactor() const OVERRIDE {
-    return 1.f;
-  }
-  virtual const LayerTreeSettings& Settings() const OVERRIDE {
-    return settings_;
-  }
+  virtual gfx::Rect DeviceClip() const OVERRIDE { return device_clip_; }
   virtual void SetFullRootLayerDamage() OVERRIDE {}
-  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 stencil_enabled_;
-  }
 
   // OutputSurfaceClient implementation.
   virtual bool DeferredInitialize(
@@ -77,9 +59,6 @@ class PixelTest::PixelTestRendererClient
     device_viewport_ = viewport;
     device_clip_ = clip;
   }
-  virtual void SetExternalStencilTest(bool enable) OVERRIDE {
-    stencil_enabled_ = enable;
-  }
   virtual void SetMemoryPolicy(const ManagedMemoryPolicy& policy) OVERRIDE {}
   virtual void SetDiscardBackBufferWhenNotVisible(bool discard) OVERRIDE {}
   virtual void SetTreeActivationCallback(const base::Closure&) OVERRIDE {}
@@ -87,8 +66,6 @@ class PixelTest::PixelTestRendererClient
  private:
   gfx::Rect device_viewport_;
   gfx::Rect device_clip_;
-  bool stencil_enabled_;
-  LayerTreeSettings settings_;
 };
 
 PixelTest::PixelTest()
@@ -133,8 +110,14 @@ bool PixelTest::RunPixelTestWithReadbackTarget(
       break;
   }
 
+  float device_scale_factor = 1.f;
+  bool allow_partial_swap = true;
+
   renderer_->DecideRenderPassAllocationsForFrame(*pass_list);
-  renderer_->DrawFrame(pass_list, offscreen_contexts.get());
+  renderer_->DrawFrame(pass_list,
+                       offscreen_contexts.get(),
+                       device_scale_factor,
+                       allow_partial_swap);
 
   // Wait for the readback to complete.
   resource_provider_->Finish();
@@ -179,6 +162,7 @@ void PixelTest::SetUpGLRenderer(bool use_skia_gpu_backend) {
 
   resource_provider_ = ResourceProvider::Create(output_surface_.get(), 0);
   renderer_ = GLRenderer::Create(fake_client_.get(),
+                                 &settings_,
                                  output_surface_.get(),
                                  resource_provider_.get(),
                                  0,
@@ -204,7 +188,8 @@ void PixelTest::ForceDeviceClip(gfx::Rect clip) {
 }
 
 void PixelTest::EnableExternalStencilTest() {
-  fake_client_->SetExternalStencilTest(true);
+  static_cast<PixelTestOutputSurface*>(output_surface_.get())
+      ->set_has_external_stencil_test(true);
 }
 
 void PixelTest::SetUpSoftwareRenderer() {
@@ -214,10 +199,11 @@ void PixelTest::SetUpSoftwareRenderer() {
   output_surface_.reset(new PixelTestOutputSurface(device.Pass()));
   output_surface_->BindToClient(fake_client_.get());
   resource_provider_ = ResourceProvider::Create(output_surface_.get(), 0);
-  renderer_ = SoftwareRenderer::Create(
-      fake_client_.get(),
-      output_surface_.get(),
-      resource_provider_.get()).PassAs<DirectRenderer>();
+  renderer_ = SoftwareRenderer::Create(fake_client_.get(),
+                                       &settings_,
+                                       output_surface_.get(),
+                                       resource_provider_.get())
+                  .PassAs<DirectRenderer>();
 }
 
 }  // namespace cc
diff --git a/cc/test/pixel_test.h b/cc/test/pixel_test.h
index 86a8112..2d5e8ce 100644
--- a/cc/test/pixel_test.h
+++ b/cc/test/pixel_test.h
@@ -42,6 +42,7 @@ class PixelTest : public testing::Test {
       const base::FilePath& ref_file,
       const PixelComparator& comparator);
 
+  LayerTreeSettings settings_;
   gfx::Size device_viewport_size_;
   class PixelTestRendererClient;
   scoped_ptr<OutputSurface> output_surface_;
@@ -85,10 +86,12 @@ class RendererPixelTest : public PixelTest {
 class GLRendererWithSkiaGPUBackend : public GLRenderer {
  public:
   GLRendererWithSkiaGPUBackend(RendererClient* client,
-                       OutputSurface* output_surface,
-                       ResourceProvider* resource_provider,
-                       int highp_threshold_min)
+                               const LayerTreeSettings* settings,
+                               OutputSurface* output_surface,
+                               ResourceProvider* resource_provider,
+                               int highp_threshold_min)
       : GLRenderer(client,
+                   settings,
                    output_surface,
                    resource_provider,
                    highp_threshold_min) {}
@@ -99,10 +102,12 @@ class GLRendererWithSkiaGPUBackend : public GLRenderer {
 class GLRendererWithExpandedViewport : public GLRenderer {
  public:
   GLRendererWithExpandedViewport(RendererClient* client,
-                       OutputSurface* output_surface,
-                       ResourceProvider* resource_provider,
-                       int highp_threshold_min)
+                                 const LayerTreeSettings* settings,
+                                 OutputSurface* output_surface,
+                                 ResourceProvider* resource_provider,
+                                 int highp_threshold_min)
       : GLRenderer(client,
+                   settings,
                    output_surface,
                    resource_provider,
                    highp_threshold_min) {}
@@ -111,14 +116,12 @@ class GLRendererWithExpandedViewport : public GLRenderer {
 class SoftwareRendererWithExpandedViewport : public SoftwareRenderer {
  public:
   SoftwareRendererWithExpandedViewport(RendererClient* client,
-                       OutputSurface* output_surface,
-                       ResourceProvider* resource_provider)
-      : SoftwareRenderer(client,
-                   output_surface,
-                   resource_provider) {}
+                                       const LayerTreeSettings* settings,
+                                       OutputSurface* output_surface,
+                                       ResourceProvider* resource_provider)
+      : SoftwareRenderer(client, settings, output_surface, resource_provider) {}
 };
 
-
 template<>
 inline void RendererPixelTest<GLRenderer>::SetUp() {
   SetUpGLRenderer(false);
diff --git a/cc/test/pixel_test_output_surface.cc b/cc/test/pixel_test_output_surface.cc
index ffc3d26c..8306cc8 100644
--- a/cc/test/pixel_test_output_surface.cc
+++ b/cc/test/pixel_test_output_surface.cc
@@ -9,6 +9,14 @@
 
 namespace cc {
 
+PixelTestOutputSurface::PixelTestOutputSurface(
+    scoped_refptr<ContextProvider> context_provider)
+    : OutputSurface(context_provider), external_stencil_test_(false) {}
+
+PixelTestOutputSurface::PixelTestOutputSurface(
+    scoped_ptr<cc::SoftwareOutputDevice> software_device)
+    : OutputSurface(software_device.Pass()), external_stencil_test_(false) {}
+
 void PixelTestOutputSurface::Reshape(gfx::Size size, float scale_factor) {
   gfx::Size expanded_size(size.width() + surface_expansion_size_.width(),
                           size.height() + surface_expansion_size_.height());
@@ -22,4 +30,8 @@ void PixelTestOutputSurface::Reshape(gfx::Size size, float scale_factor) {
       gfx::Transform(), offset_viewport, offset_clip, true);
 }
 
+bool PixelTestOutputSurface::HasExternalStencilTest() const {
+  return external_stencil_test_;
+}
+
 }  // namespace cc
diff --git a/cc/test/pixel_test_output_surface.h b/cc/test/pixel_test_output_surface.h
index bb6fdfc..0b58ac26 100644
--- a/cc/test/pixel_test_output_surface.h
+++ b/cc/test/pixel_test_output_surface.h
@@ -12,13 +12,12 @@ namespace cc {
 class PixelTestOutputSurface : public OutputSurface {
  public:
   explicit PixelTestOutputSurface(
-      scoped_refptr<ContextProvider> context_provider)
-      : OutputSurface(context_provider) {}
+      scoped_refptr<ContextProvider> context_provider);
   explicit PixelTestOutputSurface(
-      scoped_ptr<cc::SoftwareOutputDevice> software_device)
-      : OutputSurface(software_device.Pass()) {}
+      scoped_ptr<cc::SoftwareOutputDevice> software_device);
 
   virtual void Reshape(gfx::Size size, float scale_factor) OVERRIDE;
+  virtual bool HasExternalStencilTest() const OVERRIDE;
 
   void set_surface_expansion_size(gfx::Size surface_expansion_size) {
     surface_expansion_size_ = surface_expansion_size;
@@ -29,11 +28,15 @@ class PixelTestOutputSurface : public OutputSurface {
   void set_device_clip(gfx::Rect device_clip) {
     device_clip_ = device_clip;
   }
+  void set_has_external_stencil_test(bool has_test) {
+    external_stencil_test_ = has_test;
+  }
 
  private:
   gfx::Size surface_expansion_size_;
   gfx::Vector2d viewport_offset_;
   gfx::Rect device_clip_;
+  bool external_stencil_test_;
 };
 
 }  // namespace cc
diff --git a/cc/trees/layer_tree_host_impl.cc b/cc/trees/layer_tree_host_impl.cc
index 08e4ac1..816383a 100644
--- a/cc/trees/layer_tree_host_impl.cc
+++ b/cc/trees/layer_tree_host_impl.cc
@@ -1112,10 +1112,6 @@ void LayerTreeHostImpl::UpdateTileManagerMemoryPolicy(
   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.
@@ -1128,10 +1124,6 @@ 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_);
 }
@@ -1200,10 +1192,6 @@ void LayerTreeHostImpl::SetExternalDrawConstraints(
   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);
 }
@@ -1251,17 +1239,6 @@ CompositorFrameMetadata LayerTreeHostImpl::MakeCompositorFrameMetadata() const {
   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();
 }
@@ -1335,12 +1312,22 @@ void LayerTreeHostImpl::DrawLayers(FrameData* frame,
     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());
@@ -1348,6 +1335,8 @@ void LayerTreeHostImpl::DrawLayers(FrameData* frame,
 
   // 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();
@@ -1394,15 +1383,11 @@ void LayerTreeHostImpl::SetNeedsBeginFrame(bool enable) {
     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();
@@ -1417,10 +1402,6 @@ gfx::SizeF LayerTreeHostImpl::UnscaledScrollableViewportSize() const {
                     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
@@ -1607,17 +1588,18 @@ void LayerTreeHostImpl::CreateAndSetRenderer(
     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_) {
diff --git a/cc/trees/layer_tree_host_impl.h b/cc/trees/layer_tree_host_impl.h
index 3f0975f..488cc36 100644
--- a/cc/trees/layer_tree_host_impl.h
+++ b/cc/trees/layer_tree_host_impl.h
@@ -202,16 +202,8 @@ class CC_EXPORT LayerTreeHostImpl
   // and their software-mode equivalents.
   virtual gfx::Rect DeviceViewport() const OVERRIDE;
   virtual gfx::Rect DeviceClip() const OVERRIDE;
- private:
-  virtual float DeviceScaleFactor() const OVERRIDE;
-  virtual const LayerTreeSettings& Settings() const OVERRIDE;
- public:
   virtual void SetFullRootLayerDamage() OVERRIDE;
-  virtual bool HasImplThread() const OVERRIDE;
-  virtual bool ShouldClearRootRenderPass() const OVERRIDE;
   virtual CompositorFrameMetadata MakeCompositorFrameMetadata() const OVERRIDE;
-  virtual bool AllowPartialSwap() const OVERRIDE;
-  virtual bool ExternalStencilTestEnabled() const OVERRIDE;
 
   // TileManagerClient implementation.
   virtual void NotifyReadyToActivate() OVERRIDE;
@@ -227,7 +219,6 @@ class CC_EXPORT LayerTreeHostImpl
       gfx::Rect viewport,
       gfx::Rect clip,
       bool valid_for_tile_management) OVERRIDE;
-  virtual void SetExternalStencilTest(bool enabled) OVERRIDE;
   virtual void DidLoseOutputSurface() OVERRIDE;
   virtual void OnSwapBuffersComplete(const CompositorFrameAck* ack) OVERRIDE;
   virtual void SetMemoryPolicy(const ManagedMemoryPolicy& policy) OVERRIDE;
diff --git a/cc/trees/layer_tree_host_impl_unittest.cc b/cc/trees/layer_tree_host_impl_unittest.cc
index 544bb23..08774f1 100644
--- a/cc/trees/layer_tree_host_impl_unittest.cc
+++ b/cc/trees/layer_tree_host_impl_unittest.cc
@@ -4999,12 +4999,12 @@ struct RenderPassRemovalTestData : public LayerTreeHostImpl::FrameData {
 
 class TestRenderer : public GLRenderer, public RendererClient {
  public:
-  static scoped_ptr<TestRenderer> Create(ResourceProvider* resource_provider,
+  static scoped_ptr<TestRenderer> Create(const LayerTreeSettings* settings,
+                                         ResourceProvider* resource_provider,
                                          OutputSurface* output_surface,
                                          Proxy* proxy) {
-    scoped_ptr<TestRenderer> renderer(new TestRenderer(resource_provider,
-                                                       output_surface,
-                                                       proxy));
+    scoped_ptr<TestRenderer> renderer(
+        new TestRenderer(settings, resource_provider, output_surface, proxy));
     if (!renderer->Initialize())
       return scoped_ptr<TestRenderer>();
 
@@ -5025,30 +5025,18 @@ class TestRenderer : public GLRenderer, public RendererClient {
   virtual gfx::Rect DeviceViewport() const OVERRIDE {
     return gfx::Rect(viewport_size_);
   }
-  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 true; }
-  virtual CompositorFrameMetadata MakeCompositorFrameMetadata() const
-      OVERRIDE { return CompositorFrameMetadata(); }
-  virtual bool AllowPartialSwap() const OVERRIDE {
-    return true;
+  virtual CompositorFrameMetadata MakeCompositorFrameMetadata() const OVERRIDE {
+    return CompositorFrameMetadata();
   }
-  virtual bool ExternalStencilTestEnabled() const OVERRIDE { return false; }
 
  protected:
-  TestRenderer(ResourceProvider* resource_provider,
+  TestRenderer(const LayerTreeSettings* settings,
+               ResourceProvider* resource_provider,
                OutputSurface* output_surface,
                Proxy* proxy)
-      : GLRenderer(this, output_surface, resource_provider, 0) {}
+      : GLRenderer(this, settings, output_surface, resource_provider, 0) {}
 
  private:
   LayerTreeSettings settings_;
@@ -5368,6 +5356,7 @@ static void VerifyRenderPassTestData(
 }
 
 TEST_F(LayerTreeHostImplTest, TestRemoveRenderPasses) {
+  LayerTreeSettings settings;
   FakeOutputSurfaceClient output_surface_client;
   scoped_ptr<OutputSurface> output_surface(CreateOutputSurface());
   ASSERT_TRUE(output_surface->BindToClient(&output_surface_client));
@@ -5376,10 +5365,8 @@ TEST_F(LayerTreeHostImplTest, TestRemoveRenderPasses) {
   scoped_ptr<ResourceProvider> resource_provider =
       ResourceProvider::Create(output_surface.get(), 0);
 
-  scoped_ptr<TestRenderer> renderer =
-      TestRenderer::Create(resource_provider.get(),
-                           output_surface.get(),
-                           &proxy_);
+  scoped_ptr<TestRenderer> renderer = TestRenderer::Create(
+      &settings, resource_provider.get(), output_surface.get(), &proxy_);
 
   int test_case_index = 0;
   while (remove_render_passes_cases[test_case_index].name) {