cc: Remove most methods from RendererClient.

cc/output/gl_renderer_unittest.cc

 // Copyright 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/output/gl_renderer.h"
 
 #include <set>
 
 #include "cc/base/math_util.h"
 #include "cc/debug/test_web_graphics_context_3d.h"
@@ skipping 123 matching lines @@
  private:
   int frame_;
 };
 
 class FakeRendererClient : public RendererClient {
  public:
   FakeRendererClient()
       : 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();
     scoped_ptr<RenderPass> root_render_pass = RenderPass::Create();
     root_render_pass->SetNew(
         render_pass_id, gfx::Rect(), gfx::Rect(), gfx::Transform());
     render_passes_in_draw_order_.push_back(root_render_pass.Pass());
   }
 
   // RendererClient methods.
   virtual gfx::Rect DeviceViewport() const OVERRIDE {
     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() {
     return &render_passes_in_draw_order_;
   }
 
  private:
   FakeImplProxy proxy_;
   FakeLayerTreeHostImpl host_impl_;
   int set_full_root_layer_damage_count_;
   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.
 
   // Changing visibility to public.
   using GLRenderer::Initialize;
   using GLRenderer::IsBackbufferDiscarded;
   using GLRenderer::DoDrawQuad;
   using GLRenderer::BeginDrawingFrame;
   using GLRenderer::FinishDrawingQuadList;
   using GLRenderer::stencil_enabled;
 };
 
 class GLRendererTest : public testing::Test {
  protected:
   GLRendererTest() {
     scoped_ptr<FrameCountingContext> context3d(new FrameCountingContext);
     context3d_ = context3d.get();
 
     output_surface_ = FakeOutputSurface::Create3d(
         context3d.PassAs<TestWebGraphicsContext3D>()).Pass();
     CHECK(output_surface_->BindToClient(&output_surface_client_));
 
     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_;
   FakeRendererClient renderer_client_;
   scoped_ptr<ResourceProvider> resource_provider_;
   scoped_ptr<FakeRendererGL> renderer_;
 };
 
 // Closing the namespace here so that GLRendererShaderTest can take advantage
 // of the friend relationship with GLRenderer and all of the mock classes
@@ skipping 62 matching lines @@
  protected:
   GLRendererShaderTest() {
     output_surface_ = FakeOutputSurface::Create3d(
         scoped_ptr<TestWebGraphicsContext3D>(
             new ShaderCreatorMockGraphicsContext())).Pass();
     CHECK(output_surface_->BindToClient(&output_surface_client_));
 
     resource_provider_ = ResourceProvider::Create(output_surface_.get(),
                                                   0).Pass();
     renderer_.reset(new FakeRendererGL(&renderer_client_,
+                                       &settings_,
                                        output_surface_.get(),
                                        resource_provider_.get()));
     renderer_->Initialize();
   }
 
   void TestRenderPassProgram() {
     EXPECT_PROGRAM_VALID(renderer_->render_pass_program_);
     EXPECT_EQ(renderer_->render_pass_program_->program(),
               renderer_->program_shadow_);
   }
@@ skipping 39 matching lines @@
     EXPECT_EQ(renderer_->render_pass_mask_color_matrix_program_aa_->program(),
               renderer_->program_shadow_);
   }
 
   void TestSolidColorProgramAA() {
     EXPECT_PROGRAM_VALID(renderer_->solid_color_program_aa_);
     EXPECT_EQ(renderer_->solid_color_program_aa_->program(),
               renderer_->program_shadow_);
   }
 
+  LayerTreeSettings settings_;
   FakeOutputSurfaceClient output_surface_client_;
   scoped_ptr<FakeOutputSurface> output_surface_;
   FakeRendererClient renderer_client_;
   scoped_ptr<ResourceProvider> resource_provider_;
   scoped_ptr<FakeRendererGL> renderer_;
 };
 
 namespace {
 
 // Test GLRenderer discardBackbuffer functionality:
@@ skipping 48 matching lines @@
 // Test GLRenderer DiscardBackbuffer functionality:
 // Begin drawing a frame while a framebuffer is discarded.
 // Expected: will recreate framebuffer.
 TEST_F(GLRendererTest, DiscardedBackbufferIsRecreatedForScopeDuration) {
   renderer_->SetVisible(false);
   renderer_->SetDiscardBackBufferWhenNotVisible(true);
   EXPECT_TRUE(renderer_->IsBackbufferDiscarded());
   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();
   EXPECT_EQ(1, context3d_->frame_count());
 }
 
 TEST_F(GLRendererTest, FramebufferDiscardedAfterReadbackWhenNotVisible) {
   renderer_->SetVisible(false);
   renderer_->SetDiscardBackBufferWhenNotVisible(true);
   EXPECT_TRUE(renderer_->IsBackbufferDiscarded());
   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));
   EXPECT_TRUE(renderer_->IsBackbufferDiscarded());
   EXPECT_EQ(2, renderer_client_.set_full_root_layer_damage_count());
 }
 
 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());
 }
 
 class ForbidSynchronousCallContext : public TestWebGraphicsContext3D {
  public:
   ForbidSynchronousCallContext() {}
 
   virtual bool getActiveAttrib(WebGLId program,
                                WGC3Duint index,
                                ActiveInfo& info) {
@@ skipping 140 matching lines @@
 // TEST() and TEST_F() with the same name, Hence LRC2.
 TEST(GLRendererTest2, InitializationDoesNotMakeSynchronousCalls) {
   FakeOutputSurfaceClient output_surface_client;
   scoped_ptr<OutputSurface> output_surface(FakeOutputSurface::Create3d(
       scoped_ptr<TestWebGraphicsContext3D>(new ForbidSynchronousCallContext)));
   CHECK(output_surface->BindToClient(&output_surface_client));
 
   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());
 }
 
 class LoseContextOnFirstGetContext : public TestWebGraphicsContext3D {
  public:
   LoseContextOnFirstGetContext() : context_lost_(false) {}
 
   virtual bool makeContextCurrent() OVERRIDE { return !context_lost_; }
 
@@ skipping 19 matching lines @@
 
 TEST(GLRendererTest2, InitializationWithQuicklyLostContextDoesNotAssert) {
   FakeOutputSurfaceClient output_surface_client;
   scoped_ptr<OutputSurface> output_surface(FakeOutputSurface::Create3d(
       scoped_ptr<TestWebGraphicsContext3D>(new LoseContextOnFirstGetContext)));
   CHECK(output_surface->BindToClient(&output_surface_client));
 
   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();
 }
 
 class ClearCountingContext : public TestWebGraphicsContext3D {
  public:
   ClearCountingContext() {
     test_capabilities_.discard_framebuffer = true;
   }
 
   MOCK_METHOD3(discardFramebufferEXT,
                void(WGC3Denum target,
                     WGC3Dsizei numAttachments,
                     const WGC3Denum* attachments));
   MOCK_METHOD1(clear, void(WGC3Dbitfield mask));
 };
 
 TEST(GLRendererTest2, OpaqueBackground) {
   scoped_ptr<ClearCountingContext> context_owned(new ClearCountingContext);
   ClearCountingContext* context = context_owned.get();
 
   FakeOutputSurfaceClient output_surface_client;
   scoped_ptr<OutputSurface> output_surface(FakeOutputSurface::Create3d(
       context_owned.PassAs<TestWebGraphicsContext3D>()));
   CHECK(output_surface->BindToClient(&output_surface_client));
 
   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
   EXPECT_CALL(*context, clear(_)).Times(0);
 #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);
 }
 
 TEST(GLRendererTest2, TransparentBackground) {
   scoped_ptr<ClearCountingContext> context_owned(new ClearCountingContext);
   ClearCountingContext* context = context_owned.get();
 
   FakeOutputSurfaceClient output_surface_client;
   scoped_ptr<OutputSurface> output_surface(FakeOutputSurface::Create3d(
       context_owned.PassAs<TestWebGraphicsContext3D>()));
   CHECK(output_surface->BindToClient(&output_surface_client));
 
   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;
 
   EXPECT_TRUE(renderer.Initialize());
 
   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);
 }
 
 class VisibilityChangeIsLastCallTrackingContext
     : public TestWebGraphicsContext3D {
  public:
   VisibilityChangeIsLastCallTrackingContext()
       : last_call_was_set_visibility_(false) {
     test_capabilities_.set_visibility = true;
@@ skipping 42 matching lines @@
   VisibilityChangeIsLastCallTrackingContext* context = context_owned.get();
 
   FakeOutputSurfaceClient output_surface_client;
   scoped_ptr<OutputSurface> output_surface(FakeOutputSurface::Create3d(
       context_owned.PassAs<TestWebGraphicsContext3D>()));
   CHECK(output_surface->BindToClient(&output_surface_client));
 
   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());
 
   // Ensure that the call to setVisibilityCHROMIUM is the last call issue to the
   // GPU process, after glFlush is called, and after the RendererClient's
   // SetManagedMemoryPolicy is called. Plumb this tracking between both the
   // 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());
 }
 
 class TextureStateTrackingContext : public TestWebGraphicsContext3D {
  public:
   TextureStateTrackingContext()
       : active_texture_(GL_INVALID_ENUM) {
     test_capabilities_.egl_image_external = true;
   }
@@ skipping 23 matching lines @@
   TextureStateTrackingContext* context = context_owned.get();
 
   FakeOutputSurfaceClient output_surface_client;
   scoped_ptr<OutputSurface> output_surface(FakeOutputSurface::Create3d(
       context_owned.PassAs<TestWebGraphicsContext3D>()));
   CHECK(output_surface->BindToClient(&output_surface_client));
 
   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());
   EXPECT_TRUE(renderer.Initialize());
 
   cc::RenderPass::Id id(1, 1);
   scoped_ptr<TestRenderPass> pass = TestRenderPass::Create();
   pass->SetNew(id,
                gfx::Rect(0, 0, 100, 100),
                gfx::Rect(0, 0, 100, 100),
@@ skipping 38 matching lines @@
            it = pass->quad_list.BackToFrontBegin();
        it != pass->quad_list.BackToFrontEnd();
        ++it) {
     renderer.DoDrawQuad(&drawing_frame, *it);
   }
   renderer.FinishDrawingQuadList();
   EXPECT_EQ(static_cast<unsigned>(GL_TEXTURE0), context->active_texture());
   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));
   MOCK_METHOD4(drawElements,
                void(WGC3Denum mode,
                     WGC3Dsizei count,
                     WGC3Denum type,
                     WGC3Dintptr offset));
 };
 
 TEST(GLRendererTest2, ShouldClearRootRenderPass) {
   scoped_ptr<NoClearRootRenderPassMockContext> mock_context_owned(
       new NoClearRootRenderPassMockContext);
   NoClearRootRenderPassMockContext* mock_context = mock_context_owned.get();
 
   FakeOutputSurfaceClient output_surface_client;
   scoped_ptr<OutputSurface> output_surface(FakeOutputSurface::Create3d(
           mock_context_owned.PassAs<TestWebGraphicsContext3D>()));
   CHECK(output_surface->BindToClient(&output_surface_client));
 
   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());
   ScopedPtrVector<RenderPass>& render_passes =
       *renderer_client.render_passes_in_draw_order();
   render_passes.clear();
 
   RenderPass::Id root_pass_id(1, 0);
   TestRenderPass* root_pass = AddRenderPass(
       &render_passes, root_pass_id, viewport_rect, gfx::Transform());
@@ skipping 20 matching lines @@
 
   // The second render pass is the root one, clearing should be prevented.
   EXPECT_CALL(*mock_context, clear(clear_bits)).Times(0)
       .After(first_render_pass);
 
   EXPECT_CALL(*mock_context, drawElements(_, _, _, _)).Times(AnyNumber())
       .After(first_render_pass);
 
   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.
   Mock::VerifyAndClearExpectations(&mock_context);
 }
 
 class ScissorTestOnClearCheckingContext : public TestWebGraphicsContext3D {
  public:
   ScissorTestOnClearCheckingContext() : scissor_enabled_(false) {}
 
@@ skipping 18 matching lines @@
       new ScissorTestOnClearCheckingContext);
 
   FakeOutputSurfaceClient output_surface_client;
   scoped_ptr<OutputSurface> output_surface(FakeOutputSurface::Create3d(
       context_owned.PassAs<TestWebGraphicsContext3D>()));
   CHECK(output_surface->BindToClient(&output_surface_client));
 
   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);
 
   gfx::Rect viewport_rect(renderer_client.DeviceViewport());
   ScopedPtrVector<RenderPass>& render_passes =
       *renderer_client.render_passes_in_draw_order();
   render_passes.clear();
 
   gfx::Rect grand_child_rect(25, 25);
   RenderPass::Id grand_child_pass_id(3, 0);
@@ skipping 10 matching lines @@
   RenderPass::Id root_pass_id(1, 0);
   TestRenderPass* root_pass = AddRenderPass(
       &render_passes, root_pass_id, viewport_rect, gfx::Transform());
   AddQuad(root_pass, viewport_rect, SK_ColorGREEN);
 
   AddRenderPassQuad(root_pass, child_pass);
   AddRenderPassQuad(child_pass, grand_child_pass);
 
   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 {
  public:
   explicit NonReshapableOutputSurface(
       scoped_ptr<TestWebGraphicsContext3D> context3d)
       : FakeOutputSurface(
           TestContextProvider::Create(context3d.Pass()),
           false) {}
   virtual gfx::Size SurfaceSize() const OVERRIDE { return gfx::Size(500, 500); }
@@ skipping 45 matching lines @@
       new FlippedScissorAndViewportContext);
 
   FakeOutputSurfaceClient output_surface_client;
   scoped_ptr<OutputSurface> output_surface(new NonReshapableOutputSurface(
       context_owned.PassAs<TestWebGraphicsContext3D>()));
   CHECK(output_surface->BindToClient(&output_surface_client));
 
   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);
 
   gfx::Rect viewport_rect(renderer_client.DeviceViewport().size());
   gfx::Rect quad_rect = gfx::Rect(20, 20, 20, 20);
   ScopedPtrVector<RenderPass>& render_passes =
       *renderer_client.render_passes_in_draw_order();
   render_passes.clear();
 
   RenderPass::Id root_pass_id(1, 0);
   TestRenderPass* root_pass = AddRenderPass(
       &render_passes, root_pass_id, viewport_rect, gfx::Transform());
   AddClippedQuad(root_pass, quad_rect, SK_ColorGREEN);
 
   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) {
   gfx::Rect viewport_rect(renderer_client_.DeviceViewport());
   ScopedPtrVector<RenderPass>* render_passes =
       renderer_client_.render_passes_in_draw_order();
 
   gfx::Rect child_rect(50, 50);
   RenderPass::Id child_pass_id(2, 0);
   TestRenderPass* child_pass;
@@ skipping 42 matching lines @@
       render_passes, root_pass_id, viewport_rect, gfx::Transform());
 
   AddRenderPassQuad(root_pass,
                     child_pass,
                     0,
                     skia::RefPtr<SkImageFilter>(),
                     gfx::Transform());
 
   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
   render_passes->clear();
 
   child_pass = AddRenderPass(
       render_passes, child_pass_id, child_rect, transform_causing_aa);
 
   root_pass = AddRenderPass(
       render_passes, root_pass_id, viewport_rect, gfx::Transform());
 
   AddRenderPassQuad(root_pass, child_pass, 0, filter, gfx::Transform());
 
   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
   render_passes->clear();
 
   child_pass = AddRenderPass(
       render_passes, child_pass_id, child_rect, gfx::Transform());
 
   root_pass = AddRenderPass(
       render_passes, root_pass_id, viewport_rect, gfx::Transform());
 
   AddRenderPassQuad(root_pass,
                     child_pass,
                     mask,
                     skia::RefPtr<SkImageFilter>(),
                     gfx::Transform());
 
   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
   render_passes->clear();
 
   child_pass = AddRenderPass(
       render_passes, child_pass_id, child_rect, gfx::Transform());
 
   root_pass = AddRenderPass(
       render_passes, root_pass_id, viewport_rect, gfx::Transform());
 
   AddRenderPassQuad(root_pass, child_pass, mask, filter, gfx::Transform());
 
   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
   render_passes->clear();
 
   child_pass = AddRenderPass(
       render_passes, child_pass_id, child_rect, transform_causing_aa);
 
   root_pass = AddRenderPass(
       render_passes, root_pass_id, viewport_rect, gfx::Transform());
 
   AddRenderPassQuad(root_pass,
                     child_pass,
                     0,
                     skia::RefPtr<SkImageFilter>(),
                     transform_causing_aa);
 
   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
   render_passes->clear();
 
   child_pass = AddRenderPass(
       render_passes, child_pass_id, child_rect, transform_causing_aa);
 
   root_pass = AddRenderPass(
       render_passes, root_pass_id, viewport_rect, gfx::Transform());
 
   AddRenderPassQuad(root_pass, child_pass, 0, filter, transform_causing_aa);
 
   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
   render_passes->clear();
 
   child_pass = AddRenderPass(render_passes, child_pass_id, child_rect,
       transform_causing_aa);
 
   root_pass = AddRenderPass(render_passes, root_pass_id, viewport_rect,
       gfx::Transform());
 
   AddRenderPassQuad(root_pass, child_pass, mask, skia::RefPtr<SkImageFilter>(),
       transform_causing_aa);
 
   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
   render_passes->clear();
 
   child_pass = AddRenderPass(render_passes, child_pass_id, child_rect,
       transform_causing_aa);
 
   root_pass = AddRenderPass(render_passes, root_pass_id, viewport_rect,
       transform_causing_aa);
 
   AddRenderPassQuad(root_pass, child_pass, mask, filter, transform_causing_aa);
 
   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();
 }
 
 // At this time, the AA code path cannot be taken if the surface's rect would
 // project incorrectly by the given transform, because of w<0 clipping.
 TEST_F(GLRendererShaderTest, DrawRenderPassQuadSkipsAAForClippingTransform) {
   gfx::Rect child_rect(50, 50);
   RenderPass::Id child_pass_id(2, 0);
   TestRenderPass* child_pass;
 
@@ skipping 27 matching lines @@
       render_passes, root_pass_id, viewport_rect, gfx::Transform());
 
   AddRenderPassQuad(root_pass,
                     child_pass,
                     0,
                     skia::RefPtr<SkImageFilter>(),
                     transform_preventing_aa);
 
   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.
   TestRenderPassProgram();
 }
 
 TEST_F(GLRendererShaderTest, DrawSolidColorShader) {
   gfx::Rect viewport_rect(renderer_client_.DeviceViewport());
   ScopedPtrVector<RenderPass>* render_passes =
       renderer_client_.render_passes_in_draw_order();
 
   RenderPass::Id root_pass_id(1, 0);
   TestRenderPass* root_pass;
 
   gfx::Transform pixel_aligned_transform_causing_aa;
   pixel_aligned_transform_causing_aa.Translate(25.5f, 25.5f);
   pixel_aligned_transform_causing_aa.Scale(0.5f, 0.5f);
 
   render_passes->clear();
 
   root_pass = AddRenderPass(
       render_passes, root_pass_id, viewport_rect, gfx::Transform());
   AddTransformedQuad(root_pass,
                      viewport_rect,
                      SK_ColorYELLOW,
                      pixel_aligned_transform_causing_aa);
 
   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();
 }
 
 class OutputSurfaceMockContext : public TestWebGraphicsContext3D {
  public:
   OutputSurfaceMockContext() {
     test_capabilities_.discard_backbuffer = true;
     test_capabilities_.post_sub_buffer = true;
   }
@@ skipping 33 matching lines @@
 };
 
 class MockOutputSurfaceTest : public testing::Test, public FakeRendererClient {
  protected:
   virtual void SetUp() {
     FakeOutputSurfaceClient output_surface_client_;
     CHECK(output_surface_.BindToClient(&output_surface_client_));
 
     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();
 
     RenderPass::Id render_pass_id(1, 0);
     TestRenderPass* render_pass = AddRenderPass(
         render_passes, render_pass_id, viewport_rect, gfx::Transform());
     AddQuad(render_pass, viewport_rect, SK_ColorGREEN);
 
     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);
 
     EXPECT_CALL(*Context(), drawElements(_, _, _, _)).Times(1);
 
     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() {
     return static_cast<OutputSurfaceMockContext*>(
         output_surface_.context_provider()->Context3d());
   }
 
+  LayerTreeSettings settings_;
   FakeOutputSurfaceClient output_surface_client_;
   StrictMock<MockOutputSurface> output_surface_;
   scoped_ptr<ResourceProvider> resource_provider_;
   scoped_ptr<FakeRendererGL> renderer_;
 };
 
 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();
 }
 
 class GLRendererTestSyncPoint : public GLRendererPixelTest {
  protected:
   static void SyncPointCallback(int* callback_count) {
     ++(*callback_count);
     base::MessageLoop::current()->QuitWhenIdle();
   }
@@ skipping 58 matching lines @@
   base::MessageLoop::current()->Run();
 
   // The sync point should have happened.
   EXPECT_EQ(1, sync_point_callback_count);
   EXPECT_EQ(1, other_callback_count);
 }
 #endif  // OS_ANDROID
 
 }  // namespace
 }  // namespace cc