Implement transform/clip support for Android WebView.

Transforms are applied above the root-layer.  I fixed LTHCommon to forward
root-layer transforms to sublayers, as the RenderSurface-based logic was previously
clearing transforms and copying over only the scale portion.

The clip rect is treated as the viewport for the purposes of DrawQuads and Renderer
(this is required to avoid awful performance when the WebView is much larger than
the screen).  Because y-flipping the clip rect depends on knowledge of the true
surface size, I also needed to add a new OutputSurface::SurfaceSize() getter and refactored
viewport size throughout the Renderers to separate render-pass draw rect, glViewport rect,
and surface size.

Scale and translate transforms work with this patch, but rotation is still broken.

New tests: LayerTreeHostCommonTest.TransformAboveRootLayer,
GLRendererTest2.ScissorAndViewportWithinNonreshapableSurface,
RendererPixelTest/2* and 3*

NOTRY=true
BUG=230463

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

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

15 files changed, 280 insertions, 148 deletions

diff --git a/cc/output/direct_renderer.cc b/cc/output/direct_renderer.cc
index e2c17b8..76c5426 100644
--- a/cc/output/direct_renderer.cc
+++ b/cc/output/direct_renderer.cc
@@ -79,10 +79,15 @@ void DirectRenderer::QuadRectTransform(gfx::Transform* quad_rect_transform,
   quad_rect_transform->Scale(quad_rect.width(), quad_rect.height());
 }
 
-// static
-void DirectRenderer::InitializeMatrices(DrawingFrame* frame,
+void DirectRenderer::InitializeViewport(DrawingFrame* frame,
                                         gfx::Rect draw_rect,
+                                        gfx::Rect viewport_rect,
+                                        gfx::Size surface_size,
                                         bool flip_y) {
+  DCHECK_GE(viewport_rect.x(), 0);
+  DCHECK_GE(viewport_rect.y(), 0);
+  DCHECK_LE(viewport_rect.right(), surface_size.width());
+  DCHECK_LE(viewport_rect.bottom(), surface_size.height());
   if (flip_y) {
     frame->projection_matrix = OrthoProjectionMatrix(draw_rect.x(),
                                                      draw_rect.right(),
@@ -94,35 +99,38 @@ void DirectRenderer::InitializeMatrices(DrawingFrame* frame,
                                                      draw_rect.y(),
                                                      draw_rect.bottom());
   }
-  frame->window_matrix =
-      window_matrix(0, 0, draw_rect.width(), draw_rect.height());
+
+  gfx::Rect window_rect = viewport_rect;
+  if (flip_y)
+    window_rect.set_y(surface_size.height() - viewport_rect.bottom());
+  frame->window_matrix = window_matrix(window_rect.x(),
+                                       window_rect.y(),
+                                       window_rect.width(),
+                                       window_rect.height());
+  SetDrawViewport(window_rect);
+
   frame->flipped_y = flip_y;
+
+  current_draw_rect_ = draw_rect;
+  current_viewport_rect_ = viewport_rect;
+  current_surface_size_ = surface_size;
 }
 
-// static
-gfx::Rect DirectRenderer::MoveScissorToWindowSpace(
-    const DrawingFrame* frame, const gfx::RectF& scissor_rect) {
-  gfx::Rect scissor_rect_in_canvas_space = gfx::ToEnclosingRect(scissor_rect);
-  // The scissor coordinates must be supplied in viewport space so we need to
-  // offset by the relative position of the top left corner of the current
-  // render pass.
-  gfx::Rect framebuffer_output_rect = frame->current_render_pass->output_rect;
-  scissor_rect_in_canvas_space.set_x(
-      scissor_rect_in_canvas_space.x() - framebuffer_output_rect.x());
-  if (frame->flipped_y && !frame->current_texture) {
-    scissor_rect_in_canvas_space.set_y(
-        framebuffer_output_rect.height() -
-        (scissor_rect_in_canvas_space.bottom() - framebuffer_output_rect.y()));
-  } else {
-    scissor_rect_in_canvas_space.set_y(
-        scissor_rect_in_canvas_space.y() - framebuffer_output_rect.y());
-  }
-  return scissor_rect_in_canvas_space;
+gfx::Rect DirectRenderer::MoveFromDrawToWindowSpace(
+    const gfx::RectF& draw_rect, bool flip_y) const {
+  gfx::Rect window_rect = gfx::ToEnclosingRect(draw_rect);
+  window_rect -= current_draw_rect_.OffsetFromOrigin();
+  window_rect += current_viewport_rect_.OffsetFromOrigin();
+  if (flip_y)
+    window_rect.set_y(current_surface_size_.height() - window_rect.bottom());
+  return window_rect;
 }
 
 DirectRenderer::DirectRenderer(RendererClient* client,
+                               OutputSurface* output_surface,
                                ResourceProvider* resource_provider)
     : Renderer(client),
+      output_surface_(output_surface),
       resource_provider_(resource_provider) {}
 
 DirectRenderer::~DirectRenderer() {}
@@ -197,7 +205,13 @@ void DirectRenderer::DrawFrame(RenderPassList* render_passes_in_draw_order) {
   frame.root_damage_rect =
       Capabilities().using_partial_swap && client_->AllowPartialSwap() ?
       root_render_pass->damage_rect : root_render_pass->output_rect;
-  frame.root_damage_rect.Intersect(gfx::Rect(ViewportSize()));
+  frame.root_damage_rect.Intersect(gfx::Rect(client_->DeviceViewport().size()));
+
+  // Only reshape when we know we are going to draw. Otherwise, the reshape
+  // can leave the window at the wrong size if we never draw and the proper
+  // viewport size is never set.
+  output_surface_->Reshape(client_->DeviceViewport().size(),
+                           client_->DeviceScaleFactor());
 
   BeginDrawingFrame(&frame);
   for (size_t i = 0; i < render_passes_in_draw_order->size(); ++i) {
@@ -245,7 +259,8 @@ void DirectRenderer::SetScissorStateForQuad(const DrawingFrame* frame,
                                             const DrawQuad& quad) {
   if (quad.isClipped()) {
     gfx::RectF quad_scissor_rect = quad.clipRect();
-    SetScissorTestRect(MoveScissorToWindowSpace(frame, quad_scissor_rect));
+    SetScissorTestRect(
+        MoveFromDrawToWindowSpace(quad_scissor_rect, frame->flipped_y));
   } else {
     EnsureScissorTestDisabled();
   }
@@ -267,7 +282,8 @@ void DirectRenderer::SetScissorStateForQuadWithRenderPassScissor(
   }
 
   *should_skip_quad = false;
-  SetScissorTestRect(MoveScissorToWindowSpace(frame, quad_scissor_rect));
+  SetScissorTestRect(
+      MoveFromDrawToWindowSpace(quad_scissor_rect, frame->flipped_y));
 }
 
 void DirectRenderer::FinishDrawingQuadList() {}
@@ -284,7 +300,8 @@ void DirectRenderer::DrawRenderPass(DrawingFrame* frame,
 
   if (using_scissor_as_optimization) {
     render_pass_scissor = ComputeScissorRectForRenderPass(frame);
-    SetScissorTestRect(MoveScissorToWindowSpace(frame, render_pass_scissor));
+    SetScissorTestRect(
+        MoveFromDrawToWindowSpace(render_pass_scissor, frame->flipped_y));
   }
 
   if (frame->current_render_pass != frame->root_render_pass ||
@@ -327,8 +344,11 @@ bool DirectRenderer::UseRenderPass(DrawingFrame* frame,
 
   if (render_pass == frame->root_render_pass) {
     BindFramebufferToOutputSurface(frame);
-    InitializeMatrices(frame, render_pass->output_rect, FlippedFramebuffer());
-    SetDrawViewportSize(render_pass->output_rect.size());
+    InitializeViewport(frame,
+                       render_pass->output_rect,
+                       client_->DeviceViewport(),
+                       output_surface_->SurfaceSize(),
+                       FlippedFramebuffer());
     return true;
   }
 
diff --git a/cc/output/direct_renderer.h b/cc/output/direct_renderer.h
index 4baadee..864ce91 100644
--- a/cc/output/direct_renderer.h
+++ b/cc/output/direct_renderer.h
@@ -50,7 +50,9 @@ class CC_EXPORT DirectRenderer : public Renderer {
   void SetEnlargePassTextureAmountForTesting(gfx::Vector2d amount);
 
  protected:
-  DirectRenderer(RendererClient* client, ResourceProvider* resource_provider);
+  DirectRenderer(RendererClient* client,
+                 OutputSurface* output_surface,
+                 ResourceProvider* resource_provider);
 
   class CachedResource : public ScopedResource {
    public:
@@ -78,11 +80,14 @@ class CC_EXPORT DirectRenderer : public Renderer {
   static void QuadRectTransform(gfx::Transform* quad_rect_transform,
                                 const gfx::Transform& quad_transform,
                                 const gfx::RectF& quad_rect);
-  static void InitializeMatrices(DrawingFrame* frame,
-                                 gfx::Rect draw_rect,
-                                 bool flip_y);
-  static gfx::Rect MoveScissorToWindowSpace(const DrawingFrame* frame,
-                                            const gfx::RectF& scissor_rect);
+  void InitializeViewport(DrawingFrame* frame,
+                          gfx::Rect draw_rect,
+                          gfx::Rect viewport_rect,
+                          gfx::Size surface_size,
+                          bool flip_y);
+  gfx::Rect MoveFromDrawToWindowSpace(const gfx::RectF& draw_rect,
+                                      bool flip_y) const;
+
   static gfx::RectF ComputeScissorRectForRenderPass(const DrawingFrame* frame);
   void SetScissorStateForQuad(const DrawingFrame* frame, const DrawQuad& quad);
   void SetScissorStateForQuadWithRenderPassScissor(
@@ -100,8 +105,8 @@ class CC_EXPORT DirectRenderer : public Renderer {
   virtual void BindFramebufferToOutputSurface(DrawingFrame* frame) = 0;
   virtual bool BindFramebufferToTexture(DrawingFrame* frame,
                                         const ScopedResource* resource,
-                                        gfx::Rect framebuffer_rect) = 0;
-  virtual void SetDrawViewportSize(gfx::Size viewport_size) = 0;
+                                        gfx::Rect target_rect) = 0;
+  virtual void SetDrawViewport(gfx::Rect window_space_viewport) = 0;
   virtual void SetScissorTestRect(gfx::Rect scissor_rect) = 0;
   virtual void ClearFramebuffer(DrawingFrame* frame) = 0;
   virtual void DoDrawQuad(DrawingFrame* frame, const DrawQuad* quad) = 0;
@@ -117,8 +122,18 @@ class CC_EXPORT DirectRenderer : public Renderer {
       scoped_ptr<CopyOutputRequest> request) = 0;
 
   ScopedPtrHashMap<RenderPass::Id, CachedResource> render_pass_textures_;
+  OutputSurface* output_surface_;
   ResourceProvider* resource_provider_;
 
+  // For use in coordinate conversion, this stores the output rect, viewport
+  // rect (= unflipped version of glViewport rect), and the size of target
+  // framebuffer. During a draw, this stores the values for the current render
+  // pass; in between draws, they retain the values for the root render pass of
+  // the last draw.
+  gfx::Rect current_draw_rect_;
+  gfx::Rect current_viewport_rect_;
+  gfx::Size current_surface_size_;
+
  private:
   gfx::Vector2d enlarge_pass_texture_amount_;
 
diff --git a/cc/output/gl_renderer.cc b/cc/output/gl_renderer.cc
index 4da3aab..4519af3 100644
--- a/cc/output/gl_renderer.cc
+++ b/cc/output/gl_renderer.cc
@@ -125,12 +125,10 @@ GLRenderer::GLRenderer(RendererClient* client,
                        OutputSurface* output_surface,
                        ResourceProvider* resource_provider,
                        int highp_threshold_min)
-    : DirectRenderer(client, resource_provider),
+    : DirectRenderer(client, output_surface, resource_provider),
       offscreen_framebuffer_id_(0),
       shared_geometry_quad_(gfx::RectF(-0.5f, -0.5f, 1.0f, 1.0f)),
-      output_surface_(output_surface),
       context_(output_surface->context3d()),
-      is_viewport_changed_(false),
       is_backbuffer_discarded_(false),
       discard_backbuffer_when_not_visible_(false),
       is_using_bind_uniform_(false),
@@ -275,7 +273,6 @@ void GLRenderer::SendManagedMemoryStats(size_t bytes_visible,
 void GLRenderer::ReleaseRenderPassTextures() { render_pass_textures_.clear(); }
 
 void GLRenderer::ViewportChanged() {
-  is_viewport_changed_ = true;
   ReinitializeGrCanvas();
 }
 
@@ -305,18 +302,10 @@ void GLRenderer::BeginDrawingFrame(DrawingFrame* frame) {
   // FIXME: Remove this once backbuffer is automatically recreated on first use
   EnsureBackbuffer();
 
-  if (ViewportSize().IsEmpty())
+  if (client_->DeviceViewport().IsEmpty())
     return;
 
   TRACE_EVENT0("cc", "GLRenderer::DrawLayers");
-  if (is_viewport_changed_) {
-    // Only reshape when we know we are going to draw. Otherwise, the reshape
-    // can leave the window at the wrong size if we never draw and the proper
-    // viewport size is never set.
-    is_viewport_changed_ = false;
-    output_surface_->Reshape(gfx::Size(ViewportWidth(), ViewportHeight()),
-                             DeviceScaleFactor());
-  }
 
   MakeContextCurrent();
 
@@ -1503,7 +1492,7 @@ void GLRenderer::DrawPictureQuadDirectToBackbuffer(
     sk_canvas_->clipRect(gfx::RectToSkRect(scissor_rect_),
                          SkRegion::kReplace_Op);
   } else {
-    sk_canvas_->clipRect(gfx::RectToSkRect(gfx::Rect(ViewportSize())),
+    sk_canvas_->clipRect(gfx::RectToSkRect(client_->DeviceViewport()),
                          SkRegion::kReplace_Op);
   }
 
@@ -1970,9 +1959,10 @@ void GLRenderer::SwapBuffers(const ui::LatencyInfo& latency_info) {
   if (capabilities_.using_partial_swap && client_->AllowPartialSwap()) {
     // If supported, we can save significant bandwidth by only swapping the
     // damaged/scissored region (clamped to the viewport)
-    swap_buffer_rect_.Intersect(gfx::Rect(ViewportSize()));
+    swap_buffer_rect_.Intersect(client_->DeviceViewport());
     int flipped_y_pos_of_rect_bottom =
-        ViewportHeight() - swap_buffer_rect_.y() - swap_buffer_rect_.height();
+        client_->DeviceViewport().height() - swap_buffer_rect_.y() -
+        swap_buffer_rect_.height();
     output_surface_->PostSubBuffer(gfx::Rect(swap_buffer_rect_.x(),
                                              flipped_y_pos_of_rect_bottom,
                                              swap_buffer_rect_.width(),
@@ -2126,8 +2116,9 @@ void GLRenderer::DoGetFramebufferPixels(
     gfx::Rect rect,
     bool flipped_y,
     const AsyncGetFramebufferPixelsCleanupCallback& cleanup_callback) {
-  DCHECK(rect.right() <= ViewportWidth());
-  DCHECK(rect.bottom() <= ViewportHeight());
+  gfx::Rect window_rect = MoveFromDrawToWindowSpace(rect, flipped_y);
+  DCHECK_LE(window_rect.right(), current_surface_size_.width());
+  DCHECK_LE(window_rect.bottom(), current_surface_size_.height());
 
   bool is_async = !cleanup_callback.is_null();
 
@@ -2167,8 +2158,8 @@ void GLRenderer::DoGetFramebufferPixels(
                                  GL_RGBA,
                                  0,
                                  0,
-                                 current_framebuffer_size_.width(),
-                                 current_framebuffer_size_.height(),
+                                 current_surface_size_.width(),
+                                 current_surface_size_.height(),
                                  0));
     temporary_fbo = context_->createFramebuffer();
     // Attach this texture to an FBO, and perform the readback from that FBO.
@@ -2193,10 +2184,10 @@ void GLRenderer::DoGetFramebufferPixels(
                                      GL_STREAM_READ));
 
   GLC(context_,
-      context_->readPixels(rect.x(),
-                           current_framebuffer_size_.height() - rect.bottom(),
-                           rect.width(),
-                           rect.height(),
+      context_->readPixels(window_rect.x(),
+                           window_rect.y(),
+                           window_rect.width(),
+                           window_rect.height(),
                            GL_RGBA,
                            GL_UNSIGNED_BYTE,
                            NULL));
@@ -2348,7 +2339,7 @@ void GLRenderer::BindFramebufferToOutputSurface(DrawingFrame* frame) {
 
 bool GLRenderer::BindFramebufferToTexture(DrawingFrame* frame,
                                           const ScopedResource* texture,
-                                          gfx::Rect framebuffer_rect) {
+                                          gfx::Rect target_rect) {
   DCHECK(texture->id());
 
   current_framebuffer_lock_.reset();
@@ -2366,9 +2357,11 @@ bool GLRenderer::BindFramebufferToTexture(DrawingFrame* frame,
   DCHECK(context_->checkFramebufferStatus(GL_FRAMEBUFFER) ==
          GL_FRAMEBUFFER_COMPLETE || IsContextLost());
 
-  InitializeMatrices(frame, framebuffer_rect, false);
-  SetDrawViewportSize(framebuffer_rect.size());
-
+  InitializeViewport(frame,
+                     target_rect,
+                     gfx::Rect(target_rect.size()),
+                     target_rect.size(),
+                     false);
   return true;
 }
 
@@ -2389,10 +2382,11 @@ void GLRenderer::SetScissorTestRect(gfx::Rect scissor_rect) {
                         scissor_rect.height()));
 }
 
-void GLRenderer::SetDrawViewportSize(gfx::Size viewport_size) {
-  current_framebuffer_size_ = viewport_size;
-  GLC(context_,
-      context_->viewport(0, 0, viewport_size.width(), viewport_size.height()));
+void GLRenderer::SetDrawViewport(gfx::Rect window_space_viewport) {
+  GLC(context_, context_->viewport(window_space_viewport.x(),
+                                   window_space_viewport.y(),
+                                   window_space_viewport.width(),
+                                   window_space_viewport.height()));
 }
 
 bool GLRenderer::MakeContextCurrent() { return context_->makeContextCurrent(); }
@@ -2866,8 +2860,8 @@ void GLRenderer::ReinitializeGrCanvas() {
     return;
 
   GrBackendRenderTargetDesc desc;
-  desc.fWidth = ViewportWidth();
-  desc.fHeight = ViewportHeight();
+  desc.fWidth = client_->DeviceViewport().width();
+  desc.fHeight = client_->DeviceViewport().height();
   desc.fConfig = kRGBA_8888_GrPixelConfig;
   desc.fOrigin = kTopLeft_GrSurfaceOrigin;
   desc.fSampleCnt = 1;
diff --git a/cc/output/gl_renderer.h b/cc/output/gl_renderer.h
index 1c30d34..a45af22 100644
--- a/cc/output/gl_renderer.h
+++ b/cc/output/gl_renderer.h
@@ -104,8 +104,8 @@ class CC_EXPORT GLRenderer
   virtual void BindFramebufferToOutputSurface(DrawingFrame* frame) OVERRIDE;
   virtual bool BindFramebufferToTexture(DrawingFrame* frame,
                                         const ScopedResource* resource,
-                                        gfx::Rect framebuffer_rect) OVERRIDE;
-  virtual void SetDrawViewportSize(gfx::Size viewport_size) OVERRIDE;
+                                        gfx::Rect target_rect) OVERRIDE;
+  virtual void SetDrawViewport(gfx::Rect window_space_viewport) OVERRIDE;
   virtual void SetScissorTestRect(gfx::Rect scissor_rect) OVERRIDE;
   virtual void ClearFramebuffer(DrawingFrame* frame) OVERRIDE;
   virtual void DoDrawQuad(DrawingFrame* frame, const class DrawQuad*) OVERRIDE;
@@ -399,7 +399,6 @@ class CC_EXPORT GLRenderer
   scoped_ptr<SolidColorProgram> solid_color_program_;
   scoped_ptr<SolidColorProgramAA> solid_color_program_aa_;
 
-  OutputSurface* output_surface_;
   WebKit::WebGraphicsContext3D* context_;
 
   skia::RefPtr<GrContext> gr_context_;
@@ -407,7 +406,6 @@ class CC_EXPORT GLRenderer
 
   gfx::Rect swap_buffer_rect_;
   gfx::Rect scissor_rect_;
-  bool is_viewport_changed_;
   bool is_backbuffer_discarded_;
   bool discard_backbuffer_when_not_visible_;
   bool is_using_bind_uniform_;
@@ -423,7 +421,6 @@ class CC_EXPORT GLRenderer
   ScopedPtrVector<PendingAsyncReadPixels> pending_async_read_pixels_;
 
   scoped_ptr<ResourceProvider::ScopedWriteLockGL> current_framebuffer_lock_;
-  gfx::Size current_framebuffer_size_;
 
   scoped_refptr<ResourceProvider::Fence> last_swap_fence_;
 
diff --git a/cc/output/gl_renderer_unittest.cc b/cc/output/gl_renderer_unittest.cc
index 48a5951..0f901c5 100644
--- a/cc/output/gl_renderer_unittest.cc
+++ b/cc/output/gl_renderer_unittest.cc
@@ -153,8 +153,7 @@ class FakeRendererClient : public RendererClient {
         memory_allocation_limit_bytes_(
             PrioritizedResourceManager::DefaultMemoryAllocationLimit()),
         viewport_size_(gfx::Size(1, 1)),
-        scale_factor_(1.f),
-        is_viewport_changed_(true) {
+        scale_factor_(1.f) {
     root_layer_->CreateRenderSurface();
     RenderPass::Id render_pass_id =
         root_layer_->render_surface()->RenderPassId();
@@ -165,9 +164,9 @@ class FakeRendererClient : public RendererClient {
   }
 
   // RendererClient methods.
-  virtual gfx::Size DeviceViewportSize() const OVERRIDE {
+  virtual gfx::Rect DeviceViewport() const OVERRIDE {
     static gfx::Size fake_size(1, 1);
-    return fake_size;
+    return gfx::Rect(fake_size);
   }
   virtual float DeviceScaleFactor() const OVERRIDE {
     return scale_factor_;
@@ -209,10 +208,7 @@ class FakeRendererClient : public RendererClient {
       gfx::Size viewport_size, float scale_factor) {
     viewport_size_ = viewport_size;
     scale_factor_ = scale_factor;
-    is_viewport_changed_ = true;
   }
-  bool is_viewport_changed() const { return is_viewport_changed_; }
-  void clear_viewport_changed() { is_viewport_changed_ = false; }
 
   RenderPass* root_render_pass() { return render_passes_in_draw_order_.back(); }
   RenderPassList* render_passes_in_draw_order() {
@@ -233,7 +229,6 @@ class FakeRendererClient : public RendererClient {
   size_t memory_allocation_limit_bytes_;
   gfx::Size viewport_size_;
   float scale_factor_;
-  bool is_viewport_changed_;
 };
 
 class FakeRendererGL : public GLRenderer {
@@ -1004,7 +999,7 @@ TEST(GLRendererTest2, ShouldClearRootRenderPass) {
       &mock_client, output_surface.get(), resource_provider.get());
   EXPECT_TRUE(renderer.Initialize());
 
-  gfx::Rect viewport_rect(mock_client.DeviceViewportSize());
+  gfx::Rect viewport_rect(mock_client.DeviceViewport());
   ScopedPtrVector<RenderPass>& render_passes =
       *mock_client.render_passes_in_draw_order();
   render_passes.clear();
@@ -1075,7 +1070,7 @@ TEST(GLRendererTest2, ScissorTestWhenClearing) {
   EXPECT_TRUE(renderer.Initialize());
   EXPECT_FALSE(renderer.Capabilities().using_partial_swap);
 
-  gfx::Rect viewport_rect(mock_client.DeviceViewportSize());
+  gfx::Rect viewport_rect(mock_client.DeviceViewport());
   ScopedPtrVector<RenderPass>& render_passes =
       *mock_client.render_passes_in_draw_order();
   render_passes.clear();
@@ -1105,12 +1100,89 @@ TEST(GLRendererTest2, ScissorTestWhenClearing) {
   renderer.DrawFrame(mock_client.render_passes_in_draw_order());
 }
 
+class NonReshapableOutputSurface : public FakeOutputSurface {
+ public:
+  explicit NonReshapableOutputSurface(
+      scoped_ptr<WebKit::WebGraphicsContext3D> context3d)
+      : FakeOutputSurface(context3d.Pass(), false) {}
+  virtual gfx::Size SurfaceSize() const OVERRIDE { return gfx::Size(500, 500); }
+};
+
+class OffsetViewportRendererClient : public FakeRendererClient {
+ public:
+  virtual gfx::Rect DeviceViewport() const OVERRIDE {
+    return gfx::Rect(10, 10, 100, 100);
+  }
+};
+
+class FlippedScissorAndViewportContext : public TestWebGraphicsContext3D {
+ public:
+  FlippedScissorAndViewportContext()
+      : did_call_viewport_(false), did_call_scissor_(false) {}
+  virtual ~FlippedScissorAndViewportContext() {
+    EXPECT_TRUE(did_call_viewport_);
+    EXPECT_TRUE(did_call_scissor_);
+  }
+
+  virtual void viewport(GLint x, GLint y, GLsizei width, GLsizei height) {
+    EXPECT_EQ(10, x);
+    EXPECT_EQ(390, y);
+    EXPECT_EQ(100, width);
+    EXPECT_EQ(100, height);
+    did_call_viewport_ = true;
+  }
+
+  virtual void scissor(GLint x, GLint y, GLsizei width, GLsizei height) {
+    EXPECT_EQ(30, x);
+    EXPECT_EQ(450, y);
+    EXPECT_EQ(20, width);
+    EXPECT_EQ(20, height);
+    did_call_scissor_ = true;
+  }
+
+ private:
+  bool did_call_viewport_;
+  bool did_call_scissor_;
+};
+
+TEST(GLRendererTest2, ScissorAndViewportWithinNonreshapableSurface) {
+  // In Android WebView, the OutputSurface is unable to respect reshape() calls
+  // and maintains a fixed size. This test verifies that glViewport and
+  // glScissor's Y coordinate is flipped correctly in this environment, and that
+  // the glViewport can be at a nonzero origin within the surface.
+  OffsetViewportRendererClient mock_client;
+  scoped_ptr<OutputSurface> output_surface(make_scoped_ptr(
+      new NonReshapableOutputSurface(scoped_ptr<WebKit::WebGraphicsContext3D>(
+          new FlippedScissorAndViewportContext))));
+  scoped_ptr<ResourceProvider> resource_provider(
+      ResourceProvider::Create(output_surface.get(), 0));
+  FakeRendererGL renderer(
+      &mock_client, output_surface.get(), resource_provider.get());
+  EXPECT_TRUE(renderer.Initialize());
+  EXPECT_FALSE(renderer.Capabilities().using_partial_swap);
+
+  gfx::Rect viewport_rect(mock_client.DeviceViewport().size());
+  gfx::Rect quad_rect = gfx::Rect(20, 20, 20, 20);
+  ScopedPtrVector<RenderPass>& render_passes =
+      *mock_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(
+      *mock_client.render_passes_in_draw_order());
+  renderer.DrawFrame(mock_client.render_passes_in_draw_order());
+}
+
 // This test was never actually working as intended. Before adding
 // ShaderCreatorMockGraphicsContext, all shader programs received the same
 // program identifier from the TestWebGraphicsContext3D, so it always passed
 // when checking which shader was used.
 TEST_F(GLRendererShaderTest, DISABLED_DrawRenderPassQuadShaderPermutations) {
-  gfx::Rect viewport_rect(mock_client_.DeviceViewportSize());
+  gfx::Rect viewport_rect(mock_client_.DeviceViewport());
   ScopedPtrVector<RenderPass>* render_passes =
       mock_client_.render_passes_in_draw_order();
 
@@ -1372,7 +1444,7 @@ TEST_F(GLRendererShaderTest, DrawRenderPassQuadSkipsAAForClippingTransform) {
   RenderPass::Id child_pass_id(2, 0);
   TestRenderPass* child_pass;
 
-  gfx::Rect viewport_rect(mock_client_.DeviceViewportSize());
+  gfx::Rect viewport_rect(mock_client_.DeviceViewport());
   RenderPass::Id root_pass_id(1, 0);
   TestRenderPass* root_pass;
 
@@ -1417,7 +1489,7 @@ TEST_F(GLRendererShaderTest, DrawRenderPassQuadSkipsAAForClippingTransform) {
 }
 
 TEST_F(GLRendererShaderTest, DrawSolidColorShader) {
-  gfx::Rect viewport_rect(mock_client_.DeviceViewportSize());
+  gfx::Rect viewport_rect(mock_client_.DeviceViewport());
   ScopedPtrVector<RenderPass>* render_passes =
       mock_client_.render_passes_in_draw_order();
 
@@ -1474,7 +1546,9 @@ class MockOutputSurface : public OutputSurface {
  public:
   MockOutputSurface()
       : OutputSurface(scoped_ptr<WebKit::WebGraphicsContext3D>(
-            new StrictMock<OutputSurfaceMockContext>)) {}
+            new StrictMock<OutputSurfaceMockContext>)) {
+    surface_size_ = gfx::Size(100, 100);
+  }
   virtual ~MockOutputSurface() {}
 
   MOCK_METHOD1(SendFrameToParentCompositor, void(CompositorFrame* frame));
@@ -1497,7 +1571,7 @@ class MockOutputSurfaceTest : public testing::Test, public FakeRendererClient {
   void SwapBuffers() { renderer_.SwapBuffers(ui::LatencyInfo()); }
 
   void DrawFrame() {
-    gfx::Rect viewport_rect(DeviceViewportSize());
+    gfx::Rect viewport_rect(DeviceViewport());
     ScopedPtrVector<RenderPass>* render_passes = render_passes_in_draw_order();
     render_passes->clear();
 
@@ -1508,11 +1582,8 @@ class MockOutputSurfaceTest : public testing::Test, public FakeRendererClient {
 
     EXPECT_CALL(output_surface_, EnsureBackbuffer()).WillRepeatedly(Return());
 
-    if (is_viewport_changed()) {
-      EXPECT_CALL(output_surface_,
-                  Reshape(DeviceViewportSize(), DeviceScaleFactor())).Times(1);
-      clear_viewport_changed();
-    }
+    EXPECT_CALL(output_surface_,
+                Reshape(DeviceViewport().size(), DeviceScaleFactor())).Times(1);
 
     EXPECT_CALL(output_surface_, BindFramebuffer()).Times(1);
 
diff --git a/cc/output/output_surface.cc b/cc/output/output_surface.cc
index fe2b074..1be41892 100644
--- a/cc/output/output_surface.cc
+++ b/cc/output/output_surface.cc
@@ -46,14 +46,16 @@ OutputSurface::OutputSurface(
     scoped_ptr<WebKit::WebGraphicsContext3D> context3d)
     : client_(NULL),
       context3d_(context3d.Pass()),
-      has_gl_discard_backbuffer_(false) {
+      has_gl_discard_backbuffer_(false),
+      device_scale_factor_(-1) {
 }
 
 OutputSurface::OutputSurface(
     scoped_ptr<cc::SoftwareOutputDevice> software_device)
     : client_(NULL),
       software_device_(software_device.Pass()),
-      has_gl_discard_backbuffer_(false) {
+      has_gl_discard_backbuffer_(false),
+      device_scale_factor_(-1) {
 }
 
 OutputSurface::OutputSurface(
@@ -62,7 +64,8 @@ OutputSurface::OutputSurface(
     : client_(NULL),
       context3d_(context3d.Pass()),
       software_device_(software_device.Pass()),
-      has_gl_discard_backbuffer_(false) {
+      has_gl_discard_backbuffer_(false),
+      device_scale_factor_(-1) {
 }
 
 OutputSurface::~OutputSurface() {
@@ -112,8 +115,19 @@ void OutputSurface::DiscardBackbuffer() {
 }
 
 void OutputSurface::Reshape(gfx::Size size, float scale_factor) {
-  DCHECK(context3d_);
-  context3d_->reshapeWithScaleFactor(size.width(), size.height(), scale_factor);
+  if (size == surface_size_ && scale_factor == device_scale_factor_)
+    return;
+
+  surface_size_ = size;
+  device_scale_factor_ = scale_factor;
+  if (context3d_) {
+    context3d_->reshapeWithScaleFactor(
+        size.width(), size.height(), scale_factor);
+  }
+}
+
+gfx::Size OutputSurface::SurfaceSize() const {
+  return surface_size_;
 }
 
 void OutputSurface::BindFramebuffer() {
diff --git a/cc/output/output_surface.h b/cc/output/output_surface.h
index d6f4b82..00877de 100644
--- a/cc/output/output_surface.h
+++ b/cc/output/output_surface.h
@@ -89,6 +89,7 @@ class CC_EXPORT OutputSurface {
   virtual void DiscardBackbuffer();
 
   virtual void Reshape(gfx::Size size, float scale_factor);
+  virtual gfx::Size SurfaceSize() const;
 
   virtual void BindFramebuffer();
 
@@ -110,6 +111,8 @@ class CC_EXPORT OutputSurface {
   scoped_ptr<WebKit::WebGraphicsContext3D> context3d_;
   scoped_ptr<cc::SoftwareOutputDevice> software_device_;
   bool has_gl_discard_backbuffer_;
+  gfx::Size surface_size_;
+  float device_scale_factor_;
 
   scoped_ptr<OutputSurfaceCallbacks> callbacks_;
 
diff --git a/cc/output/output_surface_client.h b/cc/output/output_surface_client.h
index cbb3b8c..26edec8 100644
--- a/cc/output/output_surface_client.h
+++ b/cc/output/output_surface_client.h
@@ -9,6 +9,10 @@
 #include "cc/base/cc_export.h"
 #include "ui/gfx/rect.h"
 
+namespace gfx {
+class Transform;
+}
+
 namespace cc {
 
 class CompositorFrameAck;
@@ -23,6 +27,8 @@ class CC_EXPORT OutputSurfaceClient {
       const CompositorFrameAck& ack) = 0;
   virtual void OnSwapBuffersComplete() = 0;
   virtual void DidLoseOutputSurface() = 0;
+  virtual void SetExternalDrawConstraints(const gfx::Transform& transform,
+                                          gfx::Rect viewport) = 0;
 
  protected:
   virtual ~OutputSurfaceClient() {}
diff --git a/cc/output/output_surface_unittest.cc b/cc/output/output_surface_unittest.cc
index a23ba93..d54afe2 100644
--- a/cc/output/output_surface_unittest.cc
+++ b/cc/output/output_surface_unittest.cc
@@ -36,6 +36,8 @@ class FakeOutputSurfaceClient : public OutputSurfaceClient {
       OVERRIDE {}
   virtual void OnSwapBuffersComplete() OVERRIDE {}
   virtual void DidLoseOutputSurface() OVERRIDE {}
+  virtual void SetExternalDrawConstraints(const gfx::Transform& transform,
+                                          gfx::Rect viewport) OVERRIDE {}
 };
 
 TEST(OutputSurfaceTest, ClientPointerIndicatesBindToClientSuccess) {
diff --git a/cc/output/renderer.h b/cc/output/renderer.h
index aaf9fd7..a905d4c 100644
--- a/cc/output/renderer.h
+++ b/cc/output/renderer.h
@@ -20,7 +20,11 @@ class ScopedResource;
 
 class CC_EXPORT RendererClient {
  public:
-  virtual gfx::Size DeviceViewportSize() const = 0;
+  // Draw viewport in non-y-flipped window space. Note that while a draw is in
+  // progress, this is guaranteed to be contained within the output surface
+  // size.
+  virtual gfx::Rect DeviceViewport() const = 0;
+
   virtual float DeviceScaleFactor() const = 0;
   virtual const LayerTreeSettings& Settings() const = 0;
   virtual void SetFullRootLayerDamage() = 0;
@@ -44,12 +48,6 @@ class CC_EXPORT Renderer {
 
   const LayerTreeSettings& Settings() const { return client_->Settings(); }
 
-  gfx::Size ViewportSize() const { return client_->DeviceViewportSize(); }
-  int ViewportWidth() const { return ViewportSize().width(); }
-  int ViewportHeight() const { return ViewportSize().height(); }
-
-  float DeviceScaleFactor() const { return client_->DeviceScaleFactor(); }
-
   virtual void ViewportChanged() {}
   virtual void ReceiveCompositorFrameAck(const CompositorFrameAck& ack) {}
 
diff --git a/cc/output/renderer_pixeltest.cc b/cc/output/renderer_pixeltest.cc
index d479e5f..2faa0d0 100644
--- a/cc/output/renderer_pixeltest.cc
+++ b/cc/output/renderer_pixeltest.cc
@@ -94,7 +94,10 @@ scoped_ptr<DrawQuad> CreateTestRenderPassDrawQuad(
   return quad.PassAs<DrawQuad>();
 }
 
-typedef ::testing::Types<GLRenderer, SoftwareRenderer> RendererTypes;
+typedef ::testing::Types<GLRenderer,
+                         SoftwareRenderer,
+                         GLRendererWithExpandedViewport,
+                         SoftwareRendererWithExpandedViewport> RendererTypes;
 TYPED_TEST_CASE(RendererPixelTest, RendererTypes);
 
 typedef ::testing::Types<GLRenderer,
@@ -135,6 +138,14 @@ bool FuzzyForSoftwareOnlyPixelComparator<SoftwareRenderer>::Compare(
   return fuzzy_.Compare(actual_bmp, expected_bmp);
 }
 
+template <>
+bool FuzzyForSoftwareOnlyPixelComparator<
+    SoftwareRendererWithExpandedViewport>::Compare(
+    const SkBitmap& actual_bmp,
+    const SkBitmap& expected_bmp) const {
+  return fuzzy_.Compare(actual_bmp, expected_bmp);
+}
+
 template<typename RendererType>
 bool FuzzyForSoftwareOnlyPixelComparator<RendererType>::Compare(
     const SkBitmap& actual_bmp,
diff --git a/cc/output/software_output_device.cc b/cc/output/software_output_device.cc
index 956ee6c..719eeed 100644
--- a/cc/output/software_output_device.cc
+++ b/cc/output/software_output_device.cc
@@ -8,6 +8,7 @@
 #include "cc/output/software_frame_data.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkDevice.h"
+#include "ui/gfx/skia_util.h"
 
 namespace cc {
 
@@ -43,11 +44,8 @@ void SoftwareOutputDevice::EndPaint(SoftwareFrameData* frame_data) {
 void SoftwareOutputDevice::CopyToBitmap(
     gfx::Rect rect, SkBitmap* output) {
   DCHECK(device_);
-  SkIRect invert_rect = SkIRect::MakeXYWH(
-      rect.x(), viewport_size_.height() - rect.bottom(),
-      rect.width(), rect.height());
   const SkBitmap& bitmap = device_->accessBitmap(false);
-  bitmap.extractSubset(output, invert_rect);
+  bitmap.extractSubset(output, gfx::RectToSkIRect(rect));
 }
 
 void SoftwareOutputDevice::Scroll(
diff --git a/cc/output/software_renderer.cc b/cc/output/software_renderer.cc
index b555b57..c53e0c7 100644
--- a/cc/output/software_renderer.cc
+++ b/cc/output/software_renderer.cc
@@ -53,11 +53,10 @@ scoped_ptr<SoftwareRenderer> SoftwareRenderer::Create(
 SoftwareRenderer::SoftwareRenderer(RendererClient* client,
                                    OutputSurface* output_surface,
                                    ResourceProvider* resource_provider)
-  : DirectRenderer(client, resource_provider),
+  : DirectRenderer(client, output_surface, resource_provider),
     visible_(true),
     is_scissor_enabled_(false),
     is_viewport_changed_(true),
-    output_surface_(output_surface),
     output_device_(output_surface->software_device()),
     current_canvas_(NULL) {
   if (resource_provider_) {
@@ -88,7 +87,7 @@ void SoftwareRenderer::BeginDrawingFrame(DrawingFrame* frame) {
   TRACE_EVENT0("cc", "SoftwareRenderer::BeginDrawingFrame");
   if (is_viewport_changed_) {
     is_viewport_changed_ = false;
-    output_device_->Resize(ViewportSize());
+    output_device_->Resize(client_->DeviceViewport().size());
   }
   root_canvas_ = output_device_->BeginPaint(
       gfx::ToEnclosingRect(frame->root_damage_rect));
@@ -146,15 +145,17 @@ void SoftwareRenderer::BindFramebufferToOutputSurface(DrawingFrame* frame) {
 bool SoftwareRenderer::BindFramebufferToTexture(
     DrawingFrame* frame,
     const ScopedResource* texture,
-    gfx::Rect framebuffer_rect) {
+    gfx::Rect target_rect) {
   current_framebuffer_lock_.reset();
   current_framebuffer_lock_ = make_scoped_ptr(
       new ResourceProvider::ScopedWriteLockSoftware(
           resource_provider_, texture->id()));
   current_canvas_ = current_framebuffer_lock_->sk_canvas();
-  InitializeMatrices(frame, framebuffer_rect, false);
-  SetDrawViewportSize(framebuffer_rect.size());
-
+  InitializeViewport(frame,
+                     target_rect,
+                     gfx::Rect(target_rect.size()),
+                     target_rect.size(),
+                     false);
   return true;
 }
 
@@ -193,7 +194,7 @@ void SoftwareRenderer::ClearFramebuffer(DrawingFrame* frame) {
   }
 }
 
-void SoftwareRenderer::SetDrawViewportSize(gfx::Size viewport_size) {}
+void SoftwareRenderer::SetDrawViewport(gfx::Rect window_space_viewport) {}
 
 bool SoftwareRenderer::IsSoftwareResource(
     ResourceProvider::ResourceId resource_id) const {
@@ -437,13 +438,12 @@ void SoftwareRenderer::DrawUnsupportedQuad(const DrawingFrame* frame,
 void SoftwareRenderer::CopyCurrentRenderPassToBitmap(
     DrawingFrame* frame,
     scoped_ptr<CopyOutputRequest> request) {
-  gfx::Size render_pass_size = frame->current_render_pass->output_rect.size();
-
   scoped_ptr<SkBitmap> bitmap(new SkBitmap);
   bitmap->setConfig(SkBitmap::kARGB_8888_Config,
-                    render_pass_size.width(),
-                    render_pass_size.height());
-  current_canvas_->readPixels(bitmap.get(), 0, 0);
+                    current_viewport_rect_.width(),
+                    current_viewport_rect_.height());
+  current_canvas_->readPixels(
+      bitmap.get(), current_viewport_rect_.x(), current_viewport_rect_.y());
 
   request->SendBitmapResult(bitmap.Pass());
 }
@@ -451,6 +451,7 @@ void SoftwareRenderer::CopyCurrentRenderPassToBitmap(
 void SoftwareRenderer::GetFramebufferPixels(void* pixels, gfx::Rect rect) {
   TRACE_EVENT0("cc", "SoftwareRenderer::GetFramebufferPixels");
   SkBitmap subset_bitmap;
+  rect += current_viewport_rect_.OffsetFromOrigin();
   output_device_->CopyToBitmap(rect, &subset_bitmap);
   subset_bitmap.copyPixelsTo(pixels,
                              4 * rect.width() * rect.height(),
diff --git a/cc/output/software_renderer.h b/cc/output/software_renderer.h
index cbaf1d3..8eb9c0e 100644
--- a/cc/output/software_renderer.h
+++ b/cc/output/software_renderer.h
@@ -50,8 +50,8 @@ class CC_EXPORT SoftwareRenderer : public DirectRenderer {
   virtual bool BindFramebufferToTexture(
       DrawingFrame* frame,
       const ScopedResource* texture,
-      gfx::Rect framebuffer_rect) OVERRIDE;
-  virtual void SetDrawViewportSize(gfx::Size viewport_size) OVERRIDE;
+      gfx::Rect target_rect) OVERRIDE;
+  virtual void SetDrawViewport(gfx::Rect window_space_viewport) OVERRIDE;
   virtual void SetScissorTestRect(gfx::Rect scissor_rect) OVERRIDE;
   virtual void ClearFramebuffer(DrawingFrame* frame) OVERRIDE;
   virtual void DoDrawQuad(DrawingFrame* frame, const DrawQuad* quad) OVERRIDE;
@@ -64,12 +64,12 @@ class CC_EXPORT SoftwareRenderer : public DirectRenderer {
       DrawingFrame* frame,
       scoped_ptr<CopyOutputRequest> request) OVERRIDE;
 
- private:
   SoftwareRenderer(
       RendererClient* client,
       OutputSurface* output_surface,
       ResourceProvider* resource_provider);
 
+ private:
   void ClearCanvas(SkColor color);
   void SetClipRect(gfx::Rect rect);
   bool IsSoftwareResource(ResourceProvider::ResourceId resource_id) const;
@@ -95,7 +95,6 @@ class CC_EXPORT SoftwareRenderer : public DirectRenderer {
   bool is_viewport_changed_;
   gfx::Rect scissor_rect_;
 
-  OutputSurface* output_surface_;
   SoftwareOutputDevice* output_device_;
   SkCanvas* root_canvas_;
   SkCanvas* current_canvas_;
diff --git a/cc/output/software_renderer_unittest.cc b/cc/output/software_renderer_unittest.cc
index af4d7d1..b4e91fc 100644
--- a/cc/output/software_renderer_unittest.cc
+++ b/cc/output/software_renderer_unittest.cc
@@ -18,6 +18,8 @@
 #include "cc/test/render_pass_test_utils.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/skia/include/core/SkCanvas.h"
+#include "third_party/skia/include/core/SkDevice.h"
 
 namespace cc {
 namespace {
@@ -26,9 +28,10 @@ class SoftwareRendererTest : public testing::Test, public RendererClient {
  public:
   SoftwareRendererTest() : should_clear_root_render_pass_(true) {}
 
-  void InitializeRenderer() {
+  void InitializeRenderer(
+      scoped_ptr<SoftwareOutputDevice> software_output_device) {
     output_surface_ = FakeOutputSurface::CreateSoftware(
-        make_scoped_ptr(new SoftwareOutputDevice));
+        software_output_device.Pass());
     resource_provider_ = ResourceProvider::Create(output_surface_.get(), 0);
     renderer_ = SoftwareRenderer::Create(
         this, output_surface_.get(), resource_provider());
@@ -40,8 +43,8 @@ class SoftwareRendererTest : public testing::Test, public RendererClient {
 
   SoftwareRenderer* renderer() const { return renderer_.get(); }
 
-  void set_viewport_size(gfx::Size viewport_size) {
-    viewport_size_ = viewport_size;
+  void set_viewport(gfx::Rect viewport) {
+    viewport_ = viewport;
   }
 
   void set_should_clear_root_render_pass(bool clear_root_render_pass) {
@@ -49,8 +52,8 @@ class SoftwareRendererTest : public testing::Test, public RendererClient {
   }
 
   // RendererClient implementation.
-  virtual gfx::Size DeviceViewportSize() const OVERRIDE {
-    return viewport_size_;
+  virtual gfx::Rect DeviceViewport() const OVERRIDE {
+    return viewport_;
   }
   virtual float DeviceScaleFactor() const OVERRIDE {
     return 1.f;
@@ -78,7 +81,7 @@ class SoftwareRendererTest : public testing::Test, public RendererClient {
   scoped_ptr<FakeOutputSurface> output_surface_;
   scoped_ptr<ResourceProvider> resource_provider_;
   scoped_ptr<SoftwareRenderer> renderer_;
-  gfx::Size viewport_size_;
+  gfx::Rect viewport_;
   LayerTreeSettings settings_;
   bool should_clear_root_render_pass_;
 };
@@ -88,9 +91,9 @@ TEST_F(SoftwareRendererTest, SolidColorQuad) {
   gfx::Size inner_size(98, 98);
   gfx::Rect outer_rect(outer_size);
   gfx::Rect inner_rect(gfx::Point(1, 1), inner_size);
-  set_viewport_size(outer_size);
+  set_viewport(gfx::Rect(outer_size));
 
-  InitializeRenderer();
+  InitializeRenderer(make_scoped_ptr(new SoftwareOutputDevice));
 
   scoped_ptr<SharedQuadState> shared_quad_state = SharedQuadState::Create();
   shared_quad_state->SetAll(
@@ -113,8 +116,8 @@ TEST_F(SoftwareRendererTest, SolidColorQuad) {
 
   SkBitmap output;
   output.setConfig(SkBitmap::kARGB_8888_Config,
-                   DeviceViewportSize().width(),
-                   DeviceViewportSize().height());
+                   DeviceViewport().width(),
+                   DeviceViewport().height());
   output.allocPixels();
   renderer()->GetFramebufferPixels(output.getPixels(), outer_rect);
 
@@ -131,8 +134,8 @@ TEST_F(SoftwareRendererTest, TileQuad) {
   gfx::Size inner_size(98, 98);
   gfx::Rect outer_rect(outer_size);
   gfx::Rect inner_rect(gfx::Point(1, 1), inner_size);
-  set_viewport_size(outer_size);
-  InitializeRenderer();
+  set_viewport(gfx::Rect(outer_size));
+  InitializeRenderer(make_scoped_ptr(new SoftwareOutputDevice));
 
   ResourceProvider::ResourceId resource_yellow =
       resource_provider()->CreateResource(
@@ -165,7 +168,7 @@ TEST_F(SoftwareRendererTest, TileQuad) {
                                  gfx::Rect(inner_size),
                                  gfx::Vector2d());
 
-  gfx::Rect root_rect = gfx::Rect(DeviceViewportSize());
+  gfx::Rect root_rect = DeviceViewport();
 
   scoped_ptr<SharedQuadState> shared_quad_state = SharedQuadState::Create();
   shared_quad_state->SetAll(
@@ -199,8 +202,8 @@ TEST_F(SoftwareRendererTest, TileQuad) {
 
   SkBitmap output;
   output.setConfig(SkBitmap::kARGB_8888_Config,
-                   DeviceViewportSize().width(),
-                   DeviceViewportSize().height());
+                   DeviceViewport().width(),
+                   DeviceViewport().height());
   output.allocPixels();
   renderer()->GetFramebufferPixels(output.getPixels(), outer_rect);
 
@@ -214,9 +217,9 @@ TEST_F(SoftwareRendererTest, TileQuad) {
 
 TEST_F(SoftwareRendererTest, ShouldClearRootRenderPass) {
   gfx::Rect viewport_rect(0, 0, 100, 100);
-  set_viewport_size(viewport_rect.size());
+  set_viewport(viewport_rect);
   set_should_clear_root_render_pass(false);
-  InitializeRenderer();
+  InitializeRenderer(make_scoped_ptr(new SoftwareOutputDevice));
 
   RenderPassList list;