Delete layout_viewport_size.

cc/trees/layer_tree_host_impl_unittest.cc

 // Copyright 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/trees/layer_tree_host_impl.h"
 
 #include <cmath>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 65 matching lines @@
 
   virtual void SetUp() OVERRIDE {
     LayerTreeSettings settings;
     settings.minimum_occlusion_tracking_size = gfx::Size();
 
     host_impl_ = LayerTreeHostImpl::Create(settings,
                                            this,
                                            &proxy_,
                                            &stats_instrumentation_);
     host_impl_->InitializeRenderer(CreateOutputSurface());
-    host_impl_->SetViewportSize(gfx::Size(10, 10), gfx::Size(10, 10));
+    host_impl_->SetViewportSize(gfx::Size(10, 10));
   }
 
   virtual void TearDown() OVERRIDE {}
 
   virtual void DidLoseOutputSurfaceOnImplThread() OVERRIDE {}
   virtual void OnSwapBuffersCompleteOnImplThread() OVERRIDE {}
   virtual void OnVSyncParametersChanged(base::TimeTicks timebase,
                                         base::TimeDelta interval) OVERRIDE {}
   virtual void DidVSync(base::TimeTicks frame_time) OVERRIDE {}
   virtual void OnCanDrawStateChanged(bool can_draw) OVERRIDE {
@@ skipping 35 matching lines @@
     LayerTreeSettings settings;
     settings.minimum_occlusion_tracking_size = gfx::Size();
     settings.partial_swap_enabled = partial_swap;
 
     host_impl_ = LayerTreeHostImpl::Create(settings,
                                            this,
                                            &proxy_,
                                            &stats_instrumentation_);
 
     host_impl_->InitializeRenderer(output_surface.Pass());
-    host_impl_->SetViewportSize(gfx::Size(10, 10), gfx::Size(10, 10));
+    host_impl_->SetViewportSize(gfx::Size(10, 10));
   }
 
   void SetupRootLayerImpl(scoped_ptr<LayerImpl> root) {
     root->SetAnchorPoint(gfx::PointF());
     root->SetPosition(gfx::PointF());
     root->SetBounds(gfx::Size(10, 10));
     root->SetContentBounds(gfx::Size(10, 10));
     root->SetDrawsContent(true);
     root->draw_properties().visible_content_rect = gfx::Rect(0, 0, 10, 10);
     host_impl_->active_tree()->SetRootLayer(root.Pass());
@@ skipping 130 matching lines @@
   EXPECT_FALSE(host_impl_->CanDraw());
   EXPECT_TRUE(on_can_draw_state_changed_called_);
   on_can_draw_state_changed_called_ = false;
 
   SetupScrollAndContentsLayers(gfx::Size(100, 100));
   EXPECT_TRUE(host_impl_->CanDraw());
   EXPECT_TRUE(on_can_draw_state_changed_called_);
   on_can_draw_state_changed_called_ = false;
 
   // Toggle the device viewport size to make sure it toggles can_draw.
-  host_impl_->SetViewportSize(gfx::Size(100, 100), gfx::Size());
+  host_impl_->SetViewportSize(gfx::Size());
   EXPECT_FALSE(host_impl_->CanDraw());
   EXPECT_TRUE(on_can_draw_state_changed_called_);
   on_can_draw_state_changed_called_ = false;
 
-  host_impl_->SetViewportSize(gfx::Size(100, 100), gfx::Size(100, 100));
+  host_impl_->SetViewportSize(gfx::Size(100, 100));
   EXPECT_TRUE(host_impl_->CanDraw());
   EXPECT_TRUE(on_can_draw_state_changed_called_);
   on_can_draw_state_changed_called_ = false;
 
   // Toggle contents textures purged without causing any evictions,
   // and make sure that it does not change can_draw.
   set_reduce_memory_result(false);
   host_impl_->SetManagedMemoryPolicy(ManagedMemoryPolicy(
       host_impl_->memory_allocation_limit_bytes() - 1));
   EXPECT_TRUE(host_impl_->CanDraw());
@@ skipping 78 matching lines @@
   EXPECT_VECTOR_EQ(root->sent_scroll_delta(), scroll_delta + scroll_delta2);
   ExpectContains(*scroll_info, root->id(), scroll_delta + scroll_delta2);
 
   root->ScrollBy(gfx::Vector2d());
   scroll_info = host_impl_->ProcessScrollDeltas();
   EXPECT_EQ(root->sent_scroll_delta(), scroll_delta + scroll_delta2);
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollRootCallsCommitAndRedraw) {
   SetupScrollAndContentsLayers(gfx::Size(100, 100));
-  host_impl_->SetViewportSize(gfx::Size(50, 50), gfx::Size(50, 50));
+  host_impl_->SetViewportSize(gfx::Size(50, 50));
   InitializeRendererAndDrawFrame();
 
   EXPECT_EQ(InputHandlerClient::ScrollStarted,
             host_impl_->ScrollBegin(gfx::Point(), InputHandlerClient::Wheel));
   host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, 10));
   host_impl_->ScrollEnd();
   EXPECT_TRUE(did_request_redraw_);
   EXPECT_TRUE(did_request_commit_);
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollWithoutRootLayer) {
   // We should not crash when trying to scroll an empty layer tree.
   EXPECT_EQ(InputHandlerClient::ScrollIgnored,
             host_impl_->ScrollBegin(gfx::Point(), InputHandlerClient::Wheel));
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollWithoutRenderer) {
   LayerTreeSettings settings;
   host_impl_ = LayerTreeHostImpl::Create(settings,
                                          this,
                                          &proxy_,
                                          &stats_instrumentation_);
 
   // Initialization will fail here.
   host_impl_->InitializeRenderer(FakeOutputSurface::Create3d(
       scoped_ptr<WebKit::WebGraphicsContext3D>(
           new TestWebGraphicsContext3DMakeCurrentFails))
       .PassAs<OutputSurface>());
-  host_impl_->SetViewportSize(gfx::Size(10, 10), gfx::Size(10, 10));
+  host_impl_->SetViewportSize(gfx::Size(10, 10));
 
   SetupScrollAndContentsLayers(gfx::Size(100, 100));
 
   // We should not crash when trying to scroll after the renderer initialization
   // fails.
   EXPECT_EQ(InputHandlerClient::ScrollIgnored,
             host_impl_->ScrollBegin(gfx::Point(), InputHandlerClient::Wheel));
 }
 
 TEST_F(LayerTreeHostImplTest, ReplaceTreeWhileScrolling) {
   int scroll_layer_id = 1;
 
   SetupScrollAndContentsLayers(gfx::Size(100, 100));
-  host_impl_->SetViewportSize(gfx::Size(50, 50), gfx::Size(50, 50));
+  host_impl_->SetViewportSize(gfx::Size(50, 50));
   InitializeRendererAndDrawFrame();
 
   // We should not crash if the tree is replaced while we are scrolling.
   EXPECT_EQ(InputHandlerClient::ScrollStarted,
             host_impl_->ScrollBegin(gfx::Point(), InputHandlerClient::Wheel));
   host_impl_->active_tree()->DetachLayerTree();
 
   SetupScrollAndContentsLayers(gfx::Size(100, 100));
 
   // We should still be scrolling, because the scrolled layer also exists in the
   // new tree.
   gfx::Vector2d scroll_delta(0, 10);
   host_impl_->ScrollBy(gfx::Point(), scroll_delta);
   host_impl_->ScrollEnd();
   scoped_ptr<ScrollAndScaleSet> scroll_info = host_impl_->ProcessScrollDeltas();
   ExpectContains(*scroll_info, scroll_layer_id, scroll_delta);
 }
 
 TEST_F(LayerTreeHostImplTest, ClearRootRenderSurfaceAndScroll) {
   SetupScrollAndContentsLayers(gfx::Size(100, 100));
-  host_impl_->SetViewportSize(gfx::Size(50, 50), gfx::Size(50, 50));
+  host_impl_->SetViewportSize(gfx::Size(50, 50));
   InitializeRendererAndDrawFrame();
 
   // We should be able to scroll even if the root layer loses its render surface
   // after the most recent render.
   host_impl_->active_tree()->root_layer()->ClearRenderSurface();
   host_impl_->active_tree()->set_needs_update_draw_properties();
 
   EXPECT_EQ(InputHandlerClient::ScrollStarted,
             host_impl_->ScrollBegin(gfx::Point(), InputHandlerClient::Wheel));
 }
 
 TEST_F(LayerTreeHostImplTest, WheelEventHandlers) {
   SetupScrollAndContentsLayers(gfx::Size(100, 100));
-  host_impl_->SetViewportSize(gfx::Size(50, 50), gfx::Size(50, 50));
+  host_impl_->SetViewportSize(gfx::Size(50, 50));
   InitializeRendererAndDrawFrame();
   LayerImpl* root = host_impl_->active_tree()->root_layer();
 
   root->SetHaveWheelEventHandlers(true);
 
   // With registered event handlers, wheel scrolls have to go to the main
   // thread.
   EXPECT_EQ(InputHandlerClient::ScrollOnMainThread,
             host_impl_->ScrollBegin(gfx::Point(), InputHandlerClient::Wheel));
 
   // But gesture scrolls can still be handled.
   EXPECT_EQ(InputHandlerClient::ScrollStarted,
             host_impl_->ScrollBegin(gfx::Point(), InputHandlerClient::Gesture));
 }
 
 TEST_F(LayerTreeHostImplTest, ShouldScrollOnMainThread) {
   SetupScrollAndContentsLayers(gfx::Size(100, 100));
-  host_impl_->SetViewportSize(gfx::Size(50, 50), gfx::Size(50, 50));
+  host_impl_->SetViewportSize(gfx::Size(50, 50));
   InitializeRendererAndDrawFrame();
   LayerImpl* root = host_impl_->active_tree()->root_layer();
 
   root->SetShouldScrollOnMainThread(true);
 
   EXPECT_EQ(InputHandlerClient::ScrollOnMainThread,
             host_impl_->ScrollBegin(gfx::Point(), InputHandlerClient::Wheel));
   EXPECT_EQ(InputHandlerClient::ScrollOnMainThread,
             host_impl_->ScrollBegin(gfx::Point(), InputHandlerClient::Gesture));
 }
 
 TEST_F(LayerTreeHostImplTest, NonFastScrollableRegionBasic) {
   SetupScrollAndContentsLayers(gfx::Size(200, 200));
-  host_impl_->SetViewportSize(gfx::Size(100, 100), gfx::Size(100, 100));
+  host_impl_->SetViewportSize(gfx::Size(100, 100));
 
   LayerImpl* root = host_impl_->active_tree()->root_layer();
   root->SetContentsScale(2.f, 2.f);
   root->SetNonFastScrollableRegion(gfx::Rect(0, 0, 50, 50));
 
   InitializeRendererAndDrawFrame();
 
   // All scroll types inside the non-fast scrollable region should fail.
   EXPECT_EQ(InputHandlerClient::ScrollOnMainThread,
             host_impl_->ScrollBegin(gfx::Point(25, 25),
@@ skipping 10 matching lines @@
   host_impl_->ScrollEnd();
   EXPECT_EQ(InputHandlerClient::ScrollStarted,
             host_impl_->ScrollBegin(gfx::Point(75, 75),
                                     InputHandlerClient::Gesture));
   host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, 10));
   host_impl_->ScrollEnd();
 }
 
 TEST_F(LayerTreeHostImplTest, NonFastScrollableRegionWithOffset) {
   SetupScrollAndContentsLayers(gfx::Size(200, 200));
-  host_impl_->SetViewportSize(gfx::Size(100, 100), gfx::Size(100, 100));
+  host_impl_->SetViewportSize(gfx::Size(100, 100));
 
   LayerImpl* root = host_impl_->active_tree()->root_layer();
   root->SetContentsScale(2.f, 2.f);
   root->SetNonFastScrollableRegion(gfx::Rect(0, 0, 50, 50));
   root->SetPosition(gfx::PointF(-25.f, 0.f));
 
   InitializeRendererAndDrawFrame();
 
   // This point would fall into the non-fast scrollable region except that we've
   // moved the layer down by 25 pixels.
   EXPECT_EQ(InputHandlerClient::ScrollStarted,
             host_impl_->ScrollBegin(gfx::Point(40, 10),
                                     InputHandlerClient::Wheel));
   host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, 1));
   host_impl_->ScrollEnd();
 
   // This point is still inside the non-fast region.
   EXPECT_EQ(InputHandlerClient::ScrollOnMainThread,
             host_impl_->ScrollBegin(gfx::Point(10, 10),
                                     InputHandlerClient::Wheel));
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollByReturnsCorrectValue) {
   SetupScrollAndContentsLayers(gfx::Size(200, 200));
-  host_impl_->SetViewportSize(gfx::Size(100, 100), gfx::Size(100, 100));
+  host_impl_->SetViewportSize(gfx::Size(100, 100));
 
   InitializeRendererAndDrawFrame();
 
   EXPECT_EQ(InputHandlerClient::ScrollStarted,
             host_impl_->ScrollBegin(gfx::Point(), InputHandlerClient::Gesture));
 
   // Trying to scroll to the left/top will not succeed.
   EXPECT_FALSE(host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(-10, 0)));
   EXPECT_FALSE(host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, -10)));
   EXPECT_FALSE(host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(-10, -10)));
@@ skipping 12 matching lines @@
   EXPECT_TRUE(host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(10, -10)));
   EXPECT_TRUE(host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(-10, 0)));
   EXPECT_TRUE(host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(-10, 10)));
 
   // Trying to scroll more than the available space will also succeed.
   EXPECT_TRUE(host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(5000, 5000)));
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollVerticallyByPageReturnsCorrectValue) {
   SetupScrollAndContentsLayers(gfx::Size(200, 2000));
-  host_impl_->SetViewportSize(gfx::Size(100, 1000), gfx::Size(100, 1000));
+  host_impl_->SetViewportSize(gfx::Size(100, 1000));
 
   InitializeRendererAndDrawFrame();
 
   EXPECT_EQ(InputHandlerClient::ScrollStarted,
             host_impl_->ScrollBegin(gfx::Point(),
                                     InputHandlerClient::Wheel));
 
   // Trying to scroll without a vertical scrollbar will fail.
   EXPECT_FALSE(host_impl_->ScrollVerticallyByPage(
       gfx::Point(), WebKit::WebScrollbar::ScrollForward));
@@ skipping 13 matching lines @@
   EXPECT_TRUE(host_impl_->ScrollVerticallyByPage(
       gfx::Point(), WebKit::WebScrollbar::ScrollForward));
   EXPECT_FLOAT_EQ(875.f, host_impl_->RootScrollLayer()->scroll_delta().y());
   EXPECT_TRUE(host_impl_->ScrollVerticallyByPage(
       gfx::Point(), WebKit::WebScrollbar::ScrollBackward));
 }
 
 TEST_F(LayerTreeHostImplTest,
        ClearRootRenderSurfaceAndHitTestTouchHandlerRegion) {
   SetupScrollAndContentsLayers(gfx::Size(100, 100));
-  host_impl_->SetViewportSize(gfx::Size(50, 50), gfx::Size(50, 50));
+  host_impl_->SetViewportSize(gfx::Size(50, 50));
   InitializeRendererAndDrawFrame();
 
   // We should be able to hit test for touch event handlers even if the root
   // layer loses its render surface after the most recent render.
   host_impl_->active_tree()->root_layer()->ClearRenderSurface();
   host_impl_->active_tree()->set_needs_update_draw_properties();
 
   EXPECT_EQ(host_impl_->HaveTouchEventHandlersAt(gfx::Point()), false);
 }
 
 TEST_F(LayerTreeHostImplTest, ImplPinchZoom) {
   SetupScrollAndContentsLayers(gfx::Size(100, 100));
-  host_impl_->SetViewportSize(gfx::Size(50, 50), gfx::Size(50, 50));
+  host_impl_->SetViewportSize(gfx::Size(50, 50));
   InitializeRendererAndDrawFrame();
 
   LayerImpl* scroll_layer = host_impl_->RootScrollLayer();
   DCHECK(scroll_layer);
 
   float min_page_scale = 1.f, max_page_scale = 4.f;
   gfx::Transform identity_scale_transform;
 
   // The impl-based pinch zoom should adjust the max scroll position.
   {
@@ skipping 44 matching lines @@
     scoped_ptr<ScrollAndScaleSet> scroll_info =
         host_impl_->ProcessScrollDeltas();
     ExpectContains(*scroll_info.get(),
                    host_impl_->active_tree()->root_layer()->id(),
                    scroll_delta);
   }
 }
 
 TEST_F(LayerTreeHostImplTest, PinchGesture) {
   SetupScrollAndContentsLayers(gfx::Size(100, 100));
-  host_impl_->SetViewportSize(gfx::Size(50, 50), gfx::Size(50, 50));
+  host_impl_->SetViewportSize(gfx::Size(50, 50));
   InitializeRendererAndDrawFrame();
 
   LayerImpl* scroll_layer = host_impl_->RootScrollLayer();
   DCHECK(scroll_layer);
 
   float min_page_scale = 1.f;
   float max_page_scale = 4.f;
   gfx::Transform identity_scale_transform;
 
   // Basic pinch zoom in gesture
@@ skipping 96 matching lines @@
 
     scoped_ptr<ScrollAndScaleSet> scroll_info =
         host_impl_->ProcessScrollDeltas();
     EXPECT_EQ(scroll_info->page_scale_delta, page_scale_delta);
     ExpectContains(*scroll_info, scroll_layer->id(), gfx::Vector2d(-10, -10));
   }
 }
 
 TEST_F(LayerTreeHostImplTest, PageScaleAnimation) {
   SetupScrollAndContentsLayers(gfx::Size(100, 100));
-  host_impl_->SetViewportSize(gfx::Size(50, 50), gfx::Size(50, 50));
+  host_impl_->SetViewportSize(gfx::Size(50, 50));
   InitializeRendererAndDrawFrame();
 
   LayerImpl* scroll_layer = host_impl_->RootScrollLayer();
   DCHECK(scroll_layer);
 
   float min_page_scale = 0.5f;
   float max_page_scale = 4.f;
   base::TimeTicks start_time = base::TimeTicks() +
                                base::TimeDelta::FromSeconds(1);
   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(100);
@@ skipping 44 matching lines @@
     scoped_ptr<ScrollAndScaleSet> scroll_info =
         host_impl_->ProcessScrollDeltas();
     EXPECT_EQ(scroll_info->page_scale_delta, min_page_scale);
     // Pushed to (0,0) via clamping against contents layer size.
     ExpectContains(*scroll_info, scroll_layer->id(), gfx::Vector2d(-50, -50));
   }
 }
 
 TEST_F(LayerTreeHostImplTest, PageScaleAnimationNoOp) {
   SetupScrollAndContentsLayers(gfx::Size(100, 100));
-  host_impl_->SetViewportSize(gfx::Size(50, 50), gfx::Size(50, 50));
+  host_impl_->SetViewportSize(gfx::Size(50, 50));
   InitializeRendererAndDrawFrame();
 
   LayerImpl* scroll_layer = host_impl_->RootScrollLayer();
   DCHECK(scroll_layer);
 
   float min_page_scale = 0.5f;
   float max_page_scale = 4.f;
   base::TimeTicks start_time = base::TimeTicks() +
                                base::TimeDelta::FromSeconds(1);
   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(100);
@@ skipping 21 matching lines @@
 
     scoped_ptr<ScrollAndScaleSet> scroll_info =
         host_impl_->ProcessScrollDeltas();
     EXPECT_EQ(scroll_info->page_scale_delta, 1);
     ExpectNone(*scroll_info, scroll_layer->id());
   }
 }
 
 TEST_F(LayerTreeHostImplTest, CompositorFrameMetadata) {
   SetupScrollAndContentsLayers(gfx::Size(100, 100));
-  host_impl_->SetViewportSize(gfx::Size(50, 50), gfx::Size(50, 50));
+  host_impl_->SetViewportSize(gfx::Size(50, 50));
   host_impl_->active_tree()->SetPageScaleFactorAndLimits(1.f, 0.5f, 4.f);
   InitializeRendererAndDrawFrame();
   {
     CompositorFrameMetadata metadata =
         host_impl_->MakeCompositorFrameMetadata();
     EXPECT_EQ(gfx::Vector2dF(), metadata.root_scroll_offset);
     EXPECT_EQ(1.f, metadata.page_scale_factor);
     EXPECT_EQ(gfx::SizeF(50.f, 50.f), metadata.viewport_size);
     EXPECT_EQ(gfx::SizeF(100.f, 100.f), metadata.root_layer_size);
     EXPECT_EQ(0.5f, metadata.min_page_scale_factor);
@@ skipping 135 matching lines @@
   host_impl_->DidDrawAllLayers(frame);
 
   EXPECT_TRUE(layer->will_draw_called());
   EXPECT_TRUE(layer->did_draw_called());
 
   EXPECT_FALSE(layer->visible_content_rect().IsEmpty());
 }
 
 TEST_F(LayerTreeHostImplTest, WillDrawNotCalledOnOccludedLayer) {
   gfx::Size big_size(1000, 1000);
-  host_impl_->SetViewportSize(big_size, big_size);
+  host_impl_->SetViewportSize(big_size);
 
   host_impl_->active_tree()->SetRootLayer(
       DidDrawCheckLayer::Create(host_impl_->active_tree(), 1));
   DidDrawCheckLayer* root =
       static_cast<DidDrawCheckLayer*>(host_impl_->active_tree()->root_layer());
 
   root->AddChild(DidDrawCheckLayer::Create(host_impl_->active_tree(), 2));
   DidDrawCheckLayer* occluded_layer =
       static_cast<DidDrawCheckLayer*>(root->children()[0]);
 
@@ skipping 191 matching lines @@
 TEST_F(LayerTreeHostImplTest, ScrollNonScrollableRootWithTopControls) {
   LayerTreeSettings settings;
   settings.calculate_top_controls_position = true;
   settings.top_controls_height = 50;
 
   host_impl_ = LayerTreeHostImpl::Create(settings,
                                          this,
                                          &proxy_,
                                          &stats_instrumentation_);
   host_impl_->InitializeRenderer(CreateOutputSurface());
-  host_impl_->SetViewportSize(gfx::Size(10, 10), gfx::Size(10, 10));
+  host_impl_->SetViewportSize(gfx::Size(10, 10));
 
   gfx::Size layer_size(5, 5);
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl_->active_tree(), 1);
   root->SetScrollable(true);
   root->SetMaxScrollOffset(gfx::Vector2d(layer_size.width(),
                                          layer_size.height()));
   root->SetBounds(layer_size);
   root->SetContentBounds(layer_size);
   root->SetPosition(gfx::PointF());
   root->SetAnchorPoint(gfx::PointF());
@@ skipping 35 matching lines @@
   scroll_layer->SetScrollable(true);
   scroll_layer->SetMaxScrollOffset(gfx::Vector2d(surface_size.width(),
                                                  surface_size.height()));
   scroll_layer->SetBounds(surface_size);
   scroll_layer->SetContentBounds(surface_size);
   scroll_layer->SetPosition(gfx::PointF());
   scroll_layer->SetAnchorPoint(gfx::PointF());
   scroll_layer->AddChild(content_layer.Pass());
 
   host_impl_->active_tree()->SetRootLayer(scroll_layer.Pass());
-  host_impl_->SetViewportSize(surface_size, surface_size);
+  host_impl_->SetViewportSize(surface_size);
   InitializeRendererAndDrawFrame();
 
   EXPECT_EQ(InputHandlerClient::ScrollStarted,
             host_impl_->ScrollBegin(gfx::Point(5, 5),
                                     InputHandlerClient::Wheel));
   host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, 10));
   host_impl_->ScrollEnd();
   EXPECT_TRUE(did_request_redraw_);
   EXPECT_TRUE(did_request_commit_);
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollChildCallsCommitAndRedraw) {
   gfx::Size surface_size(10, 10);
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl_->active_tree(), 1);
   root->SetBounds(surface_size);
   root->SetContentBounds(surface_size);
   root->AddChild(CreateScrollableLayer(2, surface_size));
   host_impl_->active_tree()->SetRootLayer(root.Pass());
-  host_impl_->SetViewportSize(surface_size, surface_size);
+  host_impl_->SetViewportSize(surface_size);
   InitializeRendererAndDrawFrame();
 
   EXPECT_EQ(InputHandlerClient::ScrollStarted,
             host_impl_->ScrollBegin(gfx::Point(5, 5),
                                     InputHandlerClient::Wheel));
   host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, 10));
   host_impl_->ScrollEnd();
   EXPECT_TRUE(did_request_redraw_);
   EXPECT_TRUE(did_request_commit_);
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollMissesChild) {
   gfx::Size surface_size(10, 10);
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl_->active_tree(), 1);
   root->AddChild(CreateScrollableLayer(2, surface_size));
   host_impl_->active_tree()->SetRootLayer(root.Pass());
-  host_impl_->SetViewportSize(surface_size, surface_size);
+  host_impl_->SetViewportSize(surface_size);
   InitializeRendererAndDrawFrame();
 
   // Scroll event is ignored because the input coordinate is outside the layer
   // boundaries.
   EXPECT_EQ(InputHandlerClient::ScrollIgnored,
             host_impl_->ScrollBegin(gfx::Point(15, 5),
                                     InputHandlerClient::Wheel));
   EXPECT_FALSE(did_request_redraw_);
   EXPECT_FALSE(did_request_commit_);
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollMissesBackfacingChild) {
   gfx::Size surface_size(10, 10);
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl_->active_tree(), 1);
   scoped_ptr<LayerImpl> child = CreateScrollableLayer(2, surface_size);
-  host_impl_->SetViewportSize(surface_size, surface_size);
+  host_impl_->SetViewportSize(surface_size);
 
   gfx::Transform matrix;
   matrix.RotateAboutXAxis(180.0);
   child->SetTransform(matrix);
   child->SetDoubleSided(false);
 
   root->AddChild(child.Pass());
   host_impl_->active_tree()->SetRootLayer(root.Pass());
   InitializeRendererAndDrawFrame();
 
   // Scroll event is ignored because the scrollable layer is not facing the
   // viewer and there is nothing scrollable behind it.
   EXPECT_EQ(InputHandlerClient::ScrollIgnored,
             host_impl_->ScrollBegin(gfx::Point(5, 5),
                                     InputHandlerClient::Wheel));
   EXPECT_FALSE(did_request_redraw_);
   EXPECT_FALSE(did_request_commit_);
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollBlockedByContentLayer) {
   gfx::Size surface_size(10, 10);
   scoped_ptr<LayerImpl> content_layer = CreateScrollableLayer(1, surface_size);
   content_layer->SetShouldScrollOnMainThread(true);
   content_layer->SetScrollable(false);
 
   scoped_ptr<LayerImpl> scroll_layer = CreateScrollableLayer(2, surface_size);
   scroll_layer->AddChild(content_layer.Pass());
 
   host_impl_->active_tree()->SetRootLayer(scroll_layer.Pass());
-  host_impl_->SetViewportSize(surface_size, surface_size);
+  host_impl_->SetViewportSize(surface_size);
   InitializeRendererAndDrawFrame();
 
   // Scrolling fails because the content layer is asking to be scrolled on the
   // main thread.
   EXPECT_EQ(InputHandlerClient::ScrollOnMainThread,
             host_impl_->ScrollBegin(gfx::Point(5, 5),
                                     InputHandlerClient::Wheel));
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollRootAndChangePageScaleOnMainThread) {
   gfx::Size surface_size(10, 10);
   float page_scale = 2.f;
   scoped_ptr<LayerImpl> root = CreateScrollableLayer(1, surface_size);
   host_impl_->active_tree()->SetRootLayer(root.Pass());
   host_impl_->active_tree()->DidBecomeActive();
-  host_impl_->SetViewportSize(surface_size, surface_size);
+  host_impl_->SetViewportSize(surface_size);
   InitializeRendererAndDrawFrame();
 
   gfx::Vector2d scroll_delta(0, 10);
   gfx::Vector2d expected_scroll_delta = scroll_delta;
   gfx::Vector2d expected_max_scroll =
       host_impl_->active_tree()->root_layer()->max_scroll_offset();
   EXPECT_EQ(InputHandlerClient::ScrollStarted,
             host_impl_->ScrollBegin(gfx::Point(5, 5),
                                     InputHandlerClient::Wheel));
   host_impl_->ScrollBy(gfx::Point(), scroll_delta);
@@ skipping 68 matching lines @@
             host_impl_->active_tree()->root_layer()->
                 impl_transform().matrix().getDouble(3, 3));
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollRootAndChangePageScaleOnImplThread) {
   gfx::Size surface_size(10, 10);
   float page_scale = 2.f;
   scoped_ptr<LayerImpl> root = CreateScrollableLayer(1, surface_size);
   host_impl_->active_tree()->SetRootLayer(root.Pass());
   host_impl_->active_tree()->DidBecomeActive();
-  host_impl_->SetViewportSize(surface_size, surface_size);
+  host_impl_->SetViewportSize(surface_size);
   host_impl_->active_tree()->SetPageScaleFactorAndLimits(1.f, 1.f, page_scale);
   InitializeRendererAndDrawFrame();
 
   gfx::Vector2d scroll_delta(0, 10);
   gfx::Vector2d expected_scroll_delta = scroll_delta;
   gfx::Vector2d expected_max_scroll =
       host_impl_->active_tree()->root_layer()->max_scroll_offset();
   EXPECT_EQ(InputHandlerClient::ScrollStarted,
             host_impl_->ScrollBegin(gfx::Point(5, 5),
                                     InputHandlerClient::Wheel));
@@ skipping 75 matching lines @@
   gfx::Size surface_size(10, 10);
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl_->active_tree(), 1);
   root->SetBounds(surface_size);
   root->SetContentBounds(surface_size);
   // Also mark the root scrollable so it becomes the root scroll layer.
   root->SetScrollable(true);
   int scroll_layer_id = 2;
   root->AddChild(CreateScrollableLayer(scroll_layer_id, surface_size));
   host_impl_->active_tree()->SetRootLayer(root.Pass());
   host_impl_->active_tree()->DidBecomeActive();
-  host_impl_->SetViewportSize(surface_size, surface_size);
+  host_impl_->SetViewportSize(surface_size);
   InitializeRendererAndDrawFrame();
 
   LayerImpl* child = host_impl_->active_tree()->root_layer()->children()[0];
 
   gfx::Vector2d scroll_delta(0, 10);
   gfx::Vector2d expected_scroll_delta(scroll_delta);
   gfx::Vector2d expected_max_scroll(child->max_scroll_offset());
   EXPECT_EQ(InputHandlerClient::ScrollStarted,
             host_impl_->ScrollBegin(gfx::Point(5, 5),
                                     InputHandlerClient::Wheel));
@@ skipping 29 matching lines @@
   scoped_ptr<LayerImpl> grand_child = CreateScrollableLayer(3, surface_size);
   grand_child->SetScrollOffset(gfx::Vector2d(0, 5));
 
   scoped_ptr<LayerImpl> child = CreateScrollableLayer(2, surface_size);
   child->SetScrollOffset(gfx::Vector2d(3, 0));
   child->AddChild(grand_child.Pass());
 
   root->AddChild(child.Pass());
   host_impl_->active_tree()->SetRootLayer(root.Pass());
   host_impl_->active_tree()->DidBecomeActive();
-  host_impl_->SetViewportSize(surface_size, surface_size);
+  host_impl_->SetViewportSize(surface_size);
   InitializeRendererAndDrawFrame();
   {
     gfx::Vector2d scroll_delta(-8, -7);
     EXPECT_EQ(InputHandlerClient::ScrollStarted,
               host_impl_->ScrollBegin(gfx::Point(5, 5),
                                       InputHandlerClient::Wheel));
     host_impl_->ScrollBy(gfx::Point(), scroll_delta);
     host_impl_->ScrollEnd();
 
     scoped_ptr<ScrollAndScaleSet> scroll_info =
@@ skipping 18 matching lines @@
   scoped_ptr<LayerImpl> grand_child = CreateScrollableLayer(3, surface_size);
   grand_child->SetScrollOffset(gfx::Vector2d(0, 2));
 
   scoped_ptr<LayerImpl> child = CreateScrollableLayer(2, surface_size);
   child->SetScrollOffset(gfx::Vector2d(0, 3));
   child->AddChild(grand_child.Pass());
 
   root->AddChild(child.Pass());
   host_impl_->active_tree()->SetRootLayer(root.Pass());
   host_impl_->active_tree()->DidBecomeActive();
-  host_impl_->SetViewportSize(surface_size, surface_size);
+  host_impl_->SetViewportSize(surface_size);
   InitializeRendererAndDrawFrame();
   {
     gfx::Vector2d scroll_delta(0, -10);
     EXPECT_EQ(InputHandlerClient::ScrollStarted,
               host_impl_->ScrollBegin(gfx::Point(5, 5),
                                       InputHandlerClient::NonBubblingGesture));
     host_impl_->ScrollBy(gfx::Point(), scroll_delta);
     host_impl_->ScrollEnd();
 
     scoped_ptr<ScrollAndScaleSet> scroll_info =
@@ skipping 71 matching lines @@
   // When we try to scroll a non-scrollable child layer, the scroll delta
   // should be applied to one of its ancestors if possible.
   gfx::Size surface_size(10, 10);
   gfx::Size content_size(20, 20);
   scoped_ptr<LayerImpl> root = CreateScrollableLayer(1, content_size);
   scoped_ptr<LayerImpl> child = CreateScrollableLayer(2, content_size);
 
   child->SetScrollable(false);
   root->AddChild(child.Pass());
 
-  host_impl_->SetViewportSize(surface_size, surface_size);
+  host_impl_->SetViewportSize(surface_size);
   host_impl_->active_tree()->SetRootLayer(root.Pass());
   host_impl_->active_tree()->DidBecomeActive();
   InitializeRendererAndDrawFrame();
   {
     gfx::Vector2d scroll_delta(0, 4);
     EXPECT_EQ(InputHandlerClient::ScrollStarted,
               host_impl_->ScrollBegin(gfx::Point(5, 5),
                                       InputHandlerClient::Wheel));
     host_impl_->ScrollBy(gfx::Point(), scroll_delta);
     host_impl_->ScrollEnd();
 
     scoped_ptr<ScrollAndScaleSet> scroll_info =
         host_impl_->ProcessScrollDeltas();
 
     // Only the root should have scrolled.
     ASSERT_EQ(scroll_info->scrolls.size(), 1u);
     ExpectContains(*scroll_info.get(),
                    host_impl_->active_tree()->root_layer()->id(),
                    scroll_delta);
   }
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollBeforeRedraw) {
   gfx::Size surface_size(10, 10);
   host_impl_->active_tree()->SetRootLayer(
       CreateScrollableLayer(1, surface_size));
   host_impl_->active_tree()->DidBecomeActive();
-  host_impl_->SetViewportSize(surface_size, surface_size);
+  host_impl_->SetViewportSize(surface_size);
 
   // Draw one frame and then immediately rebuild the layer tree to mimic a tree
   // synchronization.
   InitializeRendererAndDrawFrame();
   host_impl_->active_tree()->DetachLayerTree();
   host_impl_->active_tree()->SetRootLayer(
       CreateScrollableLayer(2, surface_size));
   host_impl_->active_tree()->DidBecomeActive();
 
   // Scrolling should still work even though we did not draw yet.
   EXPECT_EQ(InputHandlerClient::ScrollStarted,
             host_impl_->ScrollBegin(gfx::Point(5, 5),
                                     InputHandlerClient::Wheel));
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollAxisAlignedRotatedLayer) {
   SetupScrollAndContentsLayers(gfx::Size(100, 100));
 
   // Rotate the root layer 90 degrees counter-clockwise about its center.
   gfx::Transform rotate_transform;
   rotate_transform.Rotate(-90.0);
   host_impl_->active_tree()->root_layer()->SetTransform(rotate_transform);
 
   gfx::Size surface_size(50, 50);
-  host_impl_->SetViewportSize(surface_size, surface_size);
+  host_impl_->SetViewportSize(surface_size);
   InitializeRendererAndDrawFrame();
 
   // Scroll to the right in screen coordinates with a gesture.
   gfx::Vector2d gesture_scroll_delta(10, 0);
   EXPECT_EQ(InputHandlerClient::ScrollStarted,
             host_impl_->ScrollBegin(gfx::Point(),
                                     InputHandlerClient::Gesture));
   host_impl_->ScrollBy(gfx::Point(), gesture_scroll_delta);
   host_impl_->ScrollEnd();
 
@@ skipping 32 matching lines @@
   rotate_transform.Translate(-50.0, -50.0);
   rotate_transform.Rotate(child_layer_angle);
   rotate_transform.Translate(50.0, 50.0);
   child->SetTransform(rotate_transform);
 
   // Only allow vertical scrolling.
   child->SetMaxScrollOffset(gfx::Vector2d(0, child->content_bounds().height()));
   host_impl_->active_tree()->root_layer()->AddChild(child.Pass());
 
   gfx::Size surface_size(50, 50);
-  host_impl_->SetViewportSize(surface_size, surface_size);
+  host_impl_->SetViewportSize(surface_size);
   InitializeRendererAndDrawFrame();
   {
     // Scroll down in screen coordinates with a gesture.
     gfx::Vector2d gesture_scroll_delta(0, 10);
     EXPECT_EQ(InputHandlerClient::ScrollStarted,
               host_impl_->ScrollBegin(gfx::Point(),
                                       InputHandlerClient::Gesture));
     host_impl_->ScrollBy(gfx::Point(), gesture_scroll_delta);
     host_impl_->ScrollEnd();
 
@@ skipping 47 matching lines @@
 TEST_F(LayerTreeHostImplTest, ScrollScaledLayer) {
   SetupScrollAndContentsLayers(gfx::Size(100, 100));
 
   // Scale the layer to twice its normal size.
   int scale = 2;
   gfx::Transform scale_transform;
   scale_transform.Scale(scale, scale);
   host_impl_->active_tree()->root_layer()->SetTransform(scale_transform);
 
   gfx::Size surface_size(50, 50);
-  host_impl_->SetViewportSize(surface_size, surface_size);
+  host_impl_->SetViewportSize(surface_size);
   InitializeRendererAndDrawFrame();
 
   // Scroll down in screen coordinates with a gesture.
   gfx::Vector2d scroll_delta(0, 10);
   EXPECT_EQ(InputHandlerClient::ScrollStarted,
             host_impl_->ScrollBegin(gfx::Point(), InputHandlerClient::Gesture));
   host_impl_->ScrollBy(gfx::Point(), scroll_delta);
   host_impl_->ScrollEnd();
 
   // The layer should have scrolled down in its local coordinates, but half the
@@ skipping 339 matching lines @@
   host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
   EXPECT_TRUE(layer1->quads_appended());
   host_impl_->DidDrawAllLayers(frame);
 }
 
 TEST_F(LayerTreeHostImplTest, ViewportCovered) {
   host_impl_->InitializeRenderer(CreateOutputSurface());
   host_impl_->active_tree()->set_background_color(SK_ColorGRAY);
 
   gfx::Size viewport_size(1000, 1000);
-  host_impl_->SetViewportSize(viewport_size, viewport_size);
+  host_impl_->SetViewportSize(viewport_size);
 
   host_impl_->active_tree()->SetRootLayer(
       LayerImpl::Create(host_impl_->active_tree(), 1));
   host_impl_->active_tree()->root_layer()->AddChild(
       BlendStateCheckLayer::Create(host_impl_->active_tree(),
                                    2,
                                    host_impl_->resource_provider()));
   BlendStateCheckLayer* child = static_cast<BlendStateCheckLayer*>(
       host_impl_->active_tree()->root_layer()->children()[0]);
   child->SetExpectation(false, false);
@@ skipping 161 matching lines @@
   // This test creates its own LayerTreeHostImpl, so
   // that we can force partial swap enabled.
   LayerTreeSettings settings;
   settings.partial_swap_enabled = true;
   scoped_ptr<LayerTreeHostImpl> layer_tree_host_impl =
       LayerTreeHostImpl::Create(settings,
                                 this,
                                 &proxy_,
                                 &stats_instrumentation_);
   layer_tree_host_impl->InitializeRenderer(output_surface.Pass());
-  layer_tree_host_impl->SetViewportSize(gfx::Size(500, 500),
-                                        gfx::Size(500, 500));
+  layer_tree_host_impl->SetViewportSize(gfx::Size(500, 500));
 
   scoped_ptr<LayerImpl> root =
       FakeDrawableLayerImpl::Create(layer_tree_host_impl->active_tree(), 1);
   scoped_ptr<LayerImpl> child =
       FakeDrawableLayerImpl::Create(layer_tree_host_impl->active_tree(), 2);
   child->SetPosition(gfx::PointF(12.f, 13.f));
   child->SetAnchorPoint(gfx::PointF());
   child->SetBounds(gfx::Size(14, 15));
   child->SetContentBounds(gfx::Size(14, 15));
   child->SetDrawsContent(true);
@@ skipping 31 matching lines @@
   actual_swap_rect = partial_swap_tracker->partial_swap_rect();
   expected_swap_rect = gfx::Rect(0, 500-28, 26, 28);
   EXPECT_EQ(expected_swap_rect.x(), actual_swap_rect.x());
   EXPECT_EQ(expected_swap_rect.y(), actual_swap_rect.y());
   EXPECT_EQ(expected_swap_rect.width(), actual_swap_rect.width());
   EXPECT_EQ(expected_swap_rect.height(), actual_swap_rect.height());
 
   // Make sure that partial swap is constrained to the viewport dimensions
   // expected damage rect: gfx::Rect(500, 500);
   // expected swap rect: flipped damage rect, but also clamped to viewport
-  layer_tree_host_impl->SetViewportSize(gfx::Size(10, 10), gfx::Size(10, 10));
+  layer_tree_host_impl->SetViewportSize(gfx::Size(10, 10));
   // This will damage everything.
   layer_tree_host_impl->active_tree()->root_layer()->SetOpacity(0.7f);
   EXPECT_TRUE(layer_tree_host_impl->PrepareToDraw(&frame, gfx::Rect()));
   layer_tree_host_impl->DrawLayers(&frame, base::TimeTicks::Now());
   host_impl_->DidDrawAllLayers(frame);
   layer_tree_host_impl->SwapBuffers(frame);
   actual_swap_rect = partial_swap_tracker->partial_swap_rect();
   expected_swap_rect = gfx::Rect(10, 10);
   EXPECT_EQ(expected_swap_rect.x(), actual_swap_rect.x());
   EXPECT_EQ(expected_swap_rect.y(), actual_swap_rect.y());
@@ skipping 252 matching lines @@
     RenderingStatsInstrumentation* stats_instrumentation) {
   scoped_ptr<OutputSurface> output_surface =
       FakeOutputSurface::Create3d(scoped_ptr<WebKit::WebGraphicsContext3D>(
           new PartialSwapContext)).PassAs<OutputSurface>();
 
   LayerTreeSettings settings;
   settings.partial_swap_enabled = partial_swap;
   scoped_ptr<LayerTreeHostImpl> my_host_impl =
       LayerTreeHostImpl::Create(settings, client, proxy, stats_instrumentation);
   my_host_impl->InitializeRenderer(output_surface.Pass());
-  my_host_impl->SetViewportSize(gfx::Size(100, 100), gfx::Size(100, 100));
+  my_host_impl->SetViewportSize(gfx::Size(100, 100));
 
   /*
     Layers are created as follows:
 
     +--------------------+
     |                  1 |
     |  +-----------+     |
     |  |         2 |     |
     |  | +-------------------+
     |  | |   3               |
@@ skipping 250 matching lines @@
     LayerImpl*& root_ptr,
     LayerImpl*& intermediate_layer_ptr,
     LayerImpl*& surface_layer_ptr,
     LayerImpl*& child_ptr,
     gfx::Size root_size) {
   scoped_ptr<OutputSurface> output_surface =
       FakeOutputSurface::Create3d(scoped_ptr<WebKit::WebGraphicsContext3D>(
           new PartialSwapContext)).PassAs<OutputSurface>();
 
   layer_tree_host_impl->InitializeRenderer(output_surface.Pass());
-  layer_tree_host_impl->SetViewportSize(root_size, root_size);
+  layer_tree_host_impl->SetViewportSize(root_size);
 
   scoped_ptr<LayerImpl> root =
       LayerImpl::Create(layer_tree_host_impl->active_tree(), 1);
   root_ptr = root.get();
 
   root->SetAnchorPoint(gfx::PointF());
   root->SetPosition(gfx::PointF());
   root->SetBounds(root_size);
   root->SetContentBounds(root_size);
   root->SetDrawsContent(true);
@@ skipping 60 matching lines @@
   LayerImpl* layer_s1_ptr;
   LayerImpl* layer_s2_ptr;
 
   scoped_ptr<OutputSurface> output_surface =
       FakeOutputSurface::Create3d(scoped_ptr<WebKit::WebGraphicsContext3D>(
           new PartialSwapContext)).PassAs<OutputSurface>();
 
   gfx::Size root_size(1000, 1000);
 
   my_host_impl->InitializeRenderer(output_surface.Pass());
-  my_host_impl->SetViewportSize(root_size, root_size);
+  my_host_impl->SetViewportSize(root_size);
 
   scoped_ptr<LayerImpl> root =
       LayerImpl::Create(my_host_impl->active_tree(), 1);
   root_ptr = root.get();
 
   root->SetAnchorPoint(gfx::PointF());
   root->SetPosition(gfx::PointF());
   root->SetBounds(root_size);
   root->SetContentBounds(root_size);
   root->SetDrawsContent(true);
@@ skipping 98 matching lines @@
   LayerImpl* layer_s1_ptr;
   LayerImpl* layer_s2_ptr;
 
   scoped_ptr<OutputSurface> output_surface =
       FakeOutputSurface::Create3d(scoped_ptr<WebKit::WebGraphicsContext3D>(
           new PartialSwapContext)).PassAs<OutputSurface>();
 
   gfx::Size root_size(1000, 1000);
 
   my_host_impl->InitializeRenderer(output_surface.Pass());
-  my_host_impl->SetViewportSize(root_size, root_size);
+  my_host_impl->SetViewportSize(root_size);
 
   scoped_ptr<LayerImpl> root =
       LayerImpl::Create(my_host_impl->active_tree(), 1);
   root_ptr = root.get();
 
   root->SetAnchorPoint(gfx::PointF());
   root->SetPosition(gfx::PointF());
   root->SetBounds(root_size);
   root->SetContentBounds(root_size);
   root->SetDrawsContent(true);
@@ skipping 100 matching lines @@
   LayerImpl* layer_s1_ptr;
   LayerImpl* layer_s2_ptr;
 
   scoped_ptr<OutputSurface> output_surface =
       FakeOutputSurface::Create3d(scoped_ptr<WebKit::WebGraphicsContext3D>(
           new PartialSwapContext)).PassAs<OutputSurface>();
 
   gfx::Size root_size(1000, 1000);
 
   my_host_impl->InitializeRenderer(output_surface.Pass());
-  my_host_impl->SetViewportSize(root_size, root_size);
+  my_host_impl->SetViewportSize(root_size);
 
   scoped_ptr<LayerImpl> root =
       LayerImpl::Create(my_host_impl->active_tree(), 1);
   root_ptr = root.get();
 
   root->SetAnchorPoint(gfx::PointF());
   root->SetPosition(gfx::PointF());
   root->SetBounds(root_size);
   root->SetContentBounds(root_size);
   root->SetDrawsContent(true);
@@ skipping 69 matching lines @@
   LayerImpl* root_ptr;
   LayerImpl* layer_s1_ptr;
 
   scoped_ptr<OutputSurface> output_surface =
       FakeOutputSurface::Create3d(scoped_ptr<WebKit::WebGraphicsContext3D>(
           new PartialSwapContext)).PassAs<OutputSurface>();
 
   gfx::Size root_size(1000, 1000);
 
   my_host_impl->InitializeRenderer(output_surface.Pass());
-  my_host_impl->SetViewportSize(root_size, root_size);
+  my_host_impl->SetViewportSize(root_size);
 
   scoped_ptr<LayerImpl> root =
       LayerImpl::Create(my_host_impl->active_tree(), 1);
   root_ptr = root.get();
 
   root->SetAnchorPoint(gfx::PointF());
   root->SetPosition(gfx::PointF());
   root->SetBounds(root_size);
   root->SetContentBounds(root_size);
   root->SetDrawsContent(true);
@@ skipping 70 matching lines @@
   LayerImpl* layer_s1_ptr;
   LayerImpl* layer_s2_ptr;
 
   scoped_ptr<OutputSurface> output_surface =
       FakeOutputSurface::Create3d(scoped_ptr<WebKit::WebGraphicsContext3D>(
           new PartialSwapContext)).PassAs<OutputSurface>();
 
   gfx::Size root_size(1000, 1000);
 
   my_host_impl->InitializeRenderer(output_surface.Pass());
-  my_host_impl->SetViewportSize(root_size, root_size);
+  my_host_impl->SetViewportSize(root_size);
 
   scoped_ptr<LayerImpl> root =
       LayerImpl::Create(my_host_impl->active_tree(), 1);
   root_ptr = root.get();
 
   root->SetAnchorPoint(gfx::PointF());
   root->SetPosition(gfx::PointF());
   root->SetBounds(root_size);
   root->SetContentBounds(root_size);
   root->SetDrawsContent(true);
@@ skipping 141 matching lines @@
   grand_child->SetBounds(grand_child_rect.size());
   grand_child->SetContentBounds(grand_child->bounds());
   grand_child->SetDrawsContent(true);
 
   TiledLayerImpl* child_ptr = child.get();
   RenderPass::Id child_pass_id(child_ptr->id(), 0);
 
   child->AddChild(grand_child.Pass());
   root->AddChild(child.PassAs<LayerImpl>());
   my_host_impl->active_tree()->SetRootLayer(root.Pass());
-  my_host_impl->SetViewportSize(root_rect.size(), root_rect.size());
+  my_host_impl->SetViewportSize(root_rect.size());
 
   EXPECT_FALSE(my_host_impl->renderer()->HaveCachedResourcesForRenderPassId(
       child_pass_id));
   {
     LayerTreeHostImpl::FrameData frame;
     host_impl_->SetFullRootLayerDamage();
     EXPECT_TRUE(my_host_impl->PrepareToDraw(&frame, gfx::Rect()));
     my_host_impl->DrawLayers(&frame, base::TimeTicks::Now());
     my_host_impl->DidDrawAllLayers(frame);
   }
@@ skipping 1006 matching lines @@
   mask_layer->SetBounds(scaling_layer_size);
   mask_layer->SetContentBounds(scaling_layer_size);
   mask_layer->SetPosition(gfx::PointF());
   mask_layer->SetAnchorPoint(gfx::PointF());
   mask_layer->SetDrawsContent(true);
 
 
   // Check that the tree scaling is correctly taken into account for the mask,
   // that should fully map onto the quad.
   float device_scale_factor = 1.f;
-  host_impl_->SetViewportSize(root_size, root_size);
+  host_impl_->SetViewportSize(root_size);
   host_impl_->SetDeviceScaleFactor(device_scale_factor);
   {
     LayerTreeHostImpl::FrameData frame;
     EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
 
     ASSERT_EQ(1u, frame.render_passes.size());
     ASSERT_EQ(1u, frame.render_passes[0]->quad_list.size());
     ASSERT_EQ(DrawQuad::RENDER_PASS,
               frame.render_passes[0]->quad_list[0]->material);
     const RenderPassDrawQuad* render_pass_quad =
         RenderPassDrawQuad::MaterialCast(frame.render_passes[0]->quad_list[0]);
     EXPECT_EQ(gfx::Rect(0, 0, 100, 100).ToString(),
               render_pass_quad->rect.ToString());
     EXPECT_EQ(gfx::RectF(0.f, 0.f, 1.f, 1.f).ToString(),
               render_pass_quad->mask_uv_rect.ToString());
 
     host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
     host_impl_->DidDrawAllLayers(frame);
   }
 
 
   // Applying a DSF should change the render surface size, but won't affect
   // which part of the mask is used.
   device_scale_factor = 2.f;
   gfx::Size device_viewport =
       gfx::ToFlooredSize(gfx::ScaleSize(root_size, device_scale_factor));
-  host_impl_->SetViewportSize(root_size, device_viewport);
+  host_impl_->SetViewportSize(device_viewport);
   host_impl_->SetDeviceScaleFactor(device_scale_factor);
   host_impl_->active_tree()->set_needs_update_draw_properties();
   {
     LayerTreeHostImpl::FrameData frame;
     EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
 
     ASSERT_EQ(1u, frame.render_passes.size());
     ASSERT_EQ(1u, frame.render_passes[0]->quad_list.size());
     ASSERT_EQ(DrawQuad::RENDER_PASS,
               frame.render_passes[0]->quad_list[0]->material);
@@ skipping 74 matching lines @@
   gfx::Size mask_size(100, 100);
   mask_layer->SetBounds(mask_size);
   mask_layer->SetContentBounds(mask_size);
   mask_layer->SetPosition(gfx::PointF());
   mask_layer->SetAnchorPoint(gfx::PointF());
   mask_layer->SetDrawsContent(true);
 
 
   // Check that the mask fills the surface.
   float device_scale_factor = 1.f;
-  host_impl_->SetViewportSize(root_size, root_size);
+  host_impl_->SetViewportSize(root_size);
   host_impl_->SetDeviceScaleFactor(device_scale_factor);
   {
     LayerTreeHostImpl::FrameData frame;
     EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
 
     ASSERT_EQ(1u, frame.render_passes.size());
     ASSERT_EQ(1u, frame.render_passes[0]->quad_list.size());
     ASSERT_EQ(DrawQuad::RENDER_PASS,
               frame.render_passes[0]->quad_list[0]->material);
     const RenderPassDrawQuad* render_pass_quad =
         RenderPassDrawQuad::MaterialCast(frame.render_passes[0]->quad_list[0]);
     EXPECT_EQ(gfx::Rect(0, 0, 50, 50).ToString(),
               render_pass_quad->rect.ToString());
     EXPECT_EQ(gfx::RectF(0.f, 0.f, 1.f, 1.f).ToString(),
               render_pass_quad->mask_uv_rect.ToString());
 
     host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
     host_impl_->DidDrawAllLayers(frame);
   }
 
 
   // Applying a DSF should change the render surface size, but won't affect
   // which part of the mask is used.
   device_scale_factor = 2.f;
   gfx::Size device_viewport =
       gfx::ToFlooredSize(gfx::ScaleSize(root_size, device_scale_factor));
-  host_impl_->SetViewportSize(root_size, device_viewport);
+  host_impl_->SetViewportSize(device_viewport);
   host_impl_->SetDeviceScaleFactor(device_scale_factor);
   host_impl_->active_tree()->set_needs_update_draw_properties();
   {
     LayerTreeHostImpl::FrameData frame;
     EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
 
     ASSERT_EQ(1u, frame.render_passes.size());
     ASSERT_EQ(1u, frame.render_passes[0]->quad_list.size());
     ASSERT_EQ(DrawQuad::RENDER_PASS,
               frame.render_passes[0]->quad_list[0]->material);
@@ skipping 59 matching lines @@
     EXPECT_EQ(gfx::RectF(0.f, 0.f, 1.f, 1.f).ToString(),
               render_pass_quad->mask_uv_rect.ToString());
 
     host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
     host_impl_->DidDrawAllLayers(frame);
   }
 }
 
 }  // namespace
 }  // namespace cc