Delete layout_viewport_size.

cc/trees/layer_tree_host_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.h"
 
 #include <algorithm>
 
 #include "base/synchronization/lock.h"
 #include "cc/animation/timing_function.h"
@@ skipping 285 matching lines @@
     if (num_commits_ >= 1) {
       // After the first commit, we should not be able to draw.
       EXPECT_FALSE(impl->CanDraw());
     }
   }
 
   virtual void DidCommit() OVERRIDE {
     num_commits_++;
     if (num_commits_ == 1) {
       // Make the viewport empty so the host says it can't draw.
-      layer_tree_host()->SetViewportSize(gfx::Size(0, 0), gfx::Size(0, 0));
+      layer_tree_host()->SetViewportSize(gfx::Size(0, 0));
     } else if (num_commits_ == 2) {
       char pixels[4];
       layer_tree_host()->CompositeAndReadback(&pixels, gfx::Rect(0, 0, 1, 1));
     } else if (num_commits_ == 3) {
       // Let it draw so we go idle and end the test.
-      layer_tree_host()->SetViewportSize(gfx::Size(1, 1), gfx::Size(1, 1));
+      layer_tree_host()->SetViewportSize(gfx::Size(1, 1));
       done_ = true;
       EndTest();
     }
   }
 
   virtual void AfterTest() OVERRIDE {}
 
  private:
   int num_commits_;
   bool done_;
@@ skipping 119 matching lines @@
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestAbortFrameWhenInvisible);
 
 // This test verifies that properties on the layer tree host are commited
 // to the impl side.
 class LayerTreeHostTestCommit : public LayerTreeHostTest {
  public:
   LayerTreeHostTestCommit() {}
 
   virtual void BeginTest() OVERRIDE {
-    layer_tree_host()->SetViewportSize(gfx::Size(20, 20), gfx::Size(20, 20));
+    layer_tree_host()->SetViewportSize(gfx::Size(20, 20));
     layer_tree_host()->set_background_color(SK_ColorGRAY);
     layer_tree_host()->SetPageScaleFactorAndLimits(5.f, 5.f, 5.f);
 
     PostSetNeedsCommitToMainThread();
   }
 
   virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
-    EXPECT_EQ(gfx::Size(20, 20), impl->layout_viewport_size());
+    EXPECT_EQ(gfx::Size(20, 20), impl->device_viewport_size());
     EXPECT_EQ(SK_ColorGRAY, impl->active_tree()->background_color());
     EXPECT_EQ(5.f, impl->active_tree()->page_scale_factor());
 
     EndTest();
   }
 
   virtual void AfterTest() OVERRIDE {}
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestCommit);
@@ skipping 116 matching lines @@
 class LayerTreeHostTestOpacityChange : public LayerTreeHostTest {
  public:
   LayerTreeHostTestOpacityChange()
       : test_opacity_change_delegate_(),
         update_check_layer_(ContentLayerWithUpdateTracking::Create(
             &test_opacity_change_delegate_)) {
     test_opacity_change_delegate_.SetTestLayer(update_check_layer_.get());
   }
 
   virtual void BeginTest() OVERRIDE {
-    layer_tree_host()->SetViewportSize(gfx::Size(10, 10), gfx::Size(10, 10));
+    layer_tree_host()->SetViewportSize(gfx::Size(10, 10));
     layer_tree_host()->root_layer()->AddChild(update_check_layer_);
 
     PostSetNeedsCommitToMainThread();
   }
 
   virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     EndTest();
   }
 
   virtual void AfterTest() OVERRIDE {
@@ skipping 34 matching lines @@
 };
 
 class LayerTreeHostTestDeviceScaleFactorScalesViewportAndLayers
     : public LayerTreeHostTest {
  public:
   LayerTreeHostTestDeviceScaleFactorScalesViewportAndLayers()
       : root_layer_(NoScaleContentLayer::Create(&client_)),
         child_layer_(ContentLayer::Create(&client_)) {}
 
   virtual void BeginTest() OVERRIDE {
-    layer_tree_host()->SetViewportSize(gfx::Size(40, 40), gfx::Size(60, 60));
+    layer_tree_host()->SetViewportSize(gfx::Size(60, 60));
     layer_tree_host()->SetDeviceScaleFactor(1.5);
-    EXPECT_EQ(gfx::Size(40, 40), layer_tree_host()->layout_viewport_size());
     EXPECT_EQ(gfx::Size(60, 60), layer_tree_host()->device_viewport_size());
 
     root_layer_->AddChild(child_layer_);
 
     root_layer_->SetIsDrawable(true);
     root_layer_->SetBounds(gfx::Size(30, 30));
     root_layer_->SetAnchorPoint(gfx::PointF(0.f, 0.f));
 
     child_layer_->SetIsDrawable(true);
     child_layer_->SetPosition(gfx::Point(2, 2));
@@ skipping 11 matching lines @@
   virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     // Should only do one commit.
     EXPECT_EQ(0, impl->active_tree()->source_frame_number());
     // Device scale factor should come over to impl.
     EXPECT_NEAR(impl->device_scale_factor(), 1.5f, 0.00001f);
 
     // Both layers are on impl.
     ASSERT_EQ(1u, impl->active_tree()->root_layer()->children().size());
 
     // Device viewport is scaled.
-    EXPECT_EQ(gfx::Size(40, 40), impl->layout_viewport_size());
     EXPECT_EQ(gfx::Size(60, 60), impl->device_viewport_size());
 
     LayerImpl* root = impl->active_tree()->root_layer();
     LayerImpl* child = impl->active_tree()->root_layer()->children()[0];
 
     // Positions remain in layout pixels.
     EXPECT_EQ(gfx::Point(0, 0), root->position());
     EXPECT_EQ(gfx::Point(2, 2), child->position());
 
     // Compute all the layer transforms for the frame.
@@ skipping 327 matching lines @@
         child_->SetNeedsDisplayRect(gfx::RectF(0.f, 0.f, 5.f, 5.f));
         scrollbar_with_paints_->SetNeedsDisplayRect(
             gfx::RectF(0.f, 0.f, 5.f, 5.f));
         scrollbar_without_paints_->SetNeedsDisplayRect(
             gfx::RectF(0.f, 0.f, 5.f, 5.f));
         break;
       case 3:
         child_->SetNeedsDisplay();
         scrollbar_with_paints_->SetNeedsDisplay();
         scrollbar_without_paints_->SetNeedsDisplay();
-        layer_tree_host()->SetViewportSize(gfx::Size(10, 10),
-                                           gfx::Size(10, 10));
+        layer_tree_host()->SetViewportSize(gfx::Size(10, 10));
         break;
       case 4:
-        layer_tree_host()->SetViewportSize(gfx::Size(10, 20),
-                                           gfx::Size(10, 20));
+        layer_tree_host()->SetViewportSize(gfx::Size(10, 20));
         break;
       case 5:
         break;
       default:
         NOTREACHED();
         break;
     }
   }
 
   virtual void AfterTest() OVERRIDE {}
@@ skipping 83 matching lines @@
         surface_layer2_(
             FakeContentLayer::Create(&client_)),
         replica_layer2_(
             FakeContentLayer::Create(&client_)) {}
 
   virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
     settings->cache_render_pass_contents = true;
   }
 
   virtual void BeginTest() OVERRIDE {
-    layer_tree_host()->SetViewportSize(gfx::Size(100, 100),
-                                       gfx::Size(100, 100));
+    layer_tree_host()->SetViewportSize(gfx::Size(100, 100));
 
     root_layer_->SetBounds(gfx::Size(100, 100));
     surface_layer1_->SetBounds(gfx::Size(100, 100));
     surface_layer1_->SetForceRenderSurface(true);
     surface_layer1_->SetOpacity(0.5f);
     surface_layer2_->SetBounds(gfx::Size(100, 100));
     surface_layer2_->SetForceRenderSurface(true);
     surface_layer2_->SetOpacity(0.5f);
 
     surface_layer1_->SetReplicaLayer(replica_layer1_.get());
@@ skipping 157 matching lines @@
 
 class LayerTreeHostTestEvictTextures : public LayerTreeHostTest {
  public:
   LayerTreeHostTestEvictTextures()
       : layer_(EvictionTestLayer::Create()),
         impl_for_evict_textures_(0),
         num_commits_(0) {}
 
   virtual void BeginTest() OVERRIDE {
     layer_tree_host()->SetRootLayer(layer_);
-    layer_tree_host()->SetViewportSize(gfx::Size(10, 20), gfx::Size(10, 20));
+    layer_tree_host()->SetViewportSize(gfx::Size(10, 20));
 
     gfx::Transform identity_matrix;
     SetLayerPropertiesForTesting(layer_.get(),
                                  0,
                                  identity_matrix,
                                  gfx::PointF(0.f, 0.f),
                                  gfx::PointF(0.f, 0.f),
                                  gfx::Size(10, 20),
                                  true);
 
@@ skipping 106 matching lines @@
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestEvictTextures);
 
 class LayerTreeHostTestContinuousCommit : public LayerTreeHostTest {
  public:
   LayerTreeHostTestContinuousCommit()
       : num_commit_complete_(0), num_draw_layers_(0) {}
 
   virtual void BeginTest() OVERRIDE {
-    layer_tree_host()->SetViewportSize(gfx::Size(10, 10), gfx::Size(10, 10));
+    layer_tree_host()->SetViewportSize(gfx::Size(10, 10));
     layer_tree_host()->root_layer()->SetBounds(gfx::Size(10, 10));
 
     PostSetNeedsCommitToMainThread();
   }
 
   virtual void DidCommit() OVERRIDE {
     if (num_draw_layers_ == 2)
       return;
     layer_tree_host()->root_layer()->SetNeedsDisplay();
   }
@@ skipping 20 matching lines @@
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestContinuousCommit);
 
 class LayerTreeHostTestContinuousInvalidate : public LayerTreeHostTest {
  public:
   LayerTreeHostTestContinuousInvalidate()
       : num_commit_complete_(0), num_draw_layers_(0) {}
 
   virtual void BeginTest() OVERRIDE {
-    layer_tree_host()->SetViewportSize(gfx::Size(10, 10), gfx::Size(10, 10));
+    layer_tree_host()->SetViewportSize(gfx::Size(10, 10));
     layer_tree_host()->root_layer()->SetBounds(gfx::Size(10, 10));
 
     content_layer_ = ContentLayer::Create(&client_);
     content_layer_->SetBounds(gfx::Size(10, 10));
     content_layer_->SetPosition(gfx::PointF(0.f, 0.f));
     content_layer_->SetAnchorPoint(gfx::PointF(0.f, 0.f));
     content_layer_->SetIsDrawable(true);
     layer_tree_host()->root_layer()->AddChild(content_layer_);
 
     PostSetNeedsCommitToMainThread();
@@ skipping 212 matching lines @@
       canvas->drawRect(rect, paint);
     }
     virtual void DidChangeLayerCanUseLCDText() OVERRIDE {}
   };
 
   virtual void BeginTest() OVERRIDE {
     layer_->SetIsDrawable(true);
     layer_->SetBounds(bounds_);
     // Outside viewport so tiles don't have to be initialized for commit.
     layer_->SetPosition(gfx::Point(100, 100));
-    layer_tree_host()->SetViewportSize(bounds_, bounds_);
+    layer_tree_host()->SetViewportSize(bounds_);
     layer_tree_host()->SetRootLayer(layer_);
 
     EXPECT_TRUE(layer_tree_host()->InitializeRendererIfNeeded());
     PostSetNeedsCommitToMainThread();
   }
 
   virtual void DidCommitAndDrawFrame() OVERRIDE {
     picture_ = layer_tree_host()->CapturePicture();
     EndTest();
   }
@@ skipping 69 matching lines @@
 class LayerTreeHostTestShutdownWithOnlySomeResourcesEvicted
     : public LayerTreeHostTest {
  public:
   LayerTreeHostTestShutdownWithOnlySomeResourcesEvicted()
       : root_layer_(FakeContentLayer::Create(&client_)),
         child_layer1_(FakeContentLayer::Create(&client_)),
         child_layer2_(FakeContentLayer::Create(&client_)),
         num_commits_(0) {}
 
   virtual void BeginTest() OVERRIDE {
-    layer_tree_host()->SetViewportSize(gfx::Size(100, 100),
-                                       gfx::Size(100, 100));
+    layer_tree_host()->SetViewportSize(gfx::Size(100, 100));
     root_layer_->SetBounds(gfx::Size(100, 100));
     child_layer1_->SetBounds(gfx::Size(100, 100));
     child_layer2_->SetBounds(gfx::Size(100, 100));
     root_layer_->AddChild(child_layer1_);
     root_layer_->AddChild(child_layer2_);
     layer_tree_host()->SetRootLayer(root_layer_);
     PostSetNeedsCommitToMainThread();
   }
 
   virtual void DidSetVisibleOnImplTree(LayerTreeHostImpl* host_impl,
@@ skipping 109 matching lines @@
       : root_layer_(ContentLayer::Create(&client_)), num_commits_(0) {}
 
   virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
     settings->use_pinch_zoom_scrollbars = true;
   }
 
   virtual void BeginTest() OVERRIDE {
     root_layer_->SetIsDrawable(true);
     root_layer_->SetBounds(gfx::Size(100, 100));
     layer_tree_host()->SetRootLayer(root_layer_);
-    layer_tree_host()->SetViewportSize(gfx::Size(100, 100),
-                                       gfx::Size(100, 100));
+    layer_tree_host()->SetViewportSize(gfx::Size(100, 100));
     PostSetNeedsCommitToMainThread();
   }
 
   virtual void DidCommit() OVERRIDE {
     num_commits_++;
 
     ScrollbarLayer* layer1 = root_layer_->children()[0]->ToScrollbarLayer();
     ASSERT_TRUE(layer1);
     ScrollbarLayer* layer2 = root_layer_->children()[1]->ToScrollbarLayer();
     ASSERT_TRUE(layer2);
 
     // Get scrollbar thickness from horizontal scrollbar's height.
     int thickness = layer1->bounds().height();
 
     if (!layer1->Orientation() == WebKit::WebScrollbar::Horizontal)
       std::swap(layer1, layer2);
 
-    gfx::Size viewport_size = layer_tree_host()->layout_viewport_size();
+    gfx::Size viewport_size = layer_tree_host()->device_viewport_size();
     EXPECT_EQ(viewport_size.width() - thickness, layer1->bounds().width());
     EXPECT_EQ(viewport_size.height() - thickness, layer2->bounds().height());
 
     switch (num_commits_) {
       case 1:
         // Resizing the viewport should also resize the pinch-zoom scrollbars.
-        layer_tree_host()->SetViewportSize(gfx::Size(120, 150),
-                                           gfx::Size(120, 150));
+        layer_tree_host()->SetViewportSize(gfx::Size(120, 150));
         break;
       default:
         EndTest();
     }
   }
 
   virtual void AfterTest() OVERRIDE {}
 
  private:
   FakeContentLayerClient client_;
@@ skipping 198 matching lines @@
   }
 
  private:
   base::TimeTicks frame_time_;
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestVSyncNotification);
 
 }  // namespace
 }  // namespace cc