Delete layout_viewport_size.

cc/layers/tiled_layer_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/layers/tiled_layer.h"
 
 #include <limits>
 #include <vector>
 
 #include "cc/debug/overdraw_metrics.h"
@@ skipping 211 matching lines @@
   EXPECT_FALSE(layer_impl->HasResourceIdForTileAt(0, 1));
 }
 
 TEST_F(TiledLayerTest, PushOccludedDirtyTiles) {
   scoped_refptr<FakeTiledLayer> layer =
       make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
   scoped_ptr<FakeTiledLayerImpl> layer_impl =
       make_scoped_ptr(new FakeTiledLayerImpl(host_impl_->active_tree(), 1));
   TestOcclusionTracker occluded;
   occlusion_ = &occluded;
-  layer_tree_host_->SetViewportSize(gfx::Size(1000, 1000),
-                                    gfx::Size(1000, 1000));
+  layer_tree_host_->SetViewportSize(gfx::Size(1000, 1000));
 
   // The tile size is 100x100, so this invalidates and then paints two tiles.
   layer->SetBounds(gfx::Size(100, 200));
   CalcDrawProps(layer);
   UpdateAndPush(layer, layer_impl);
 
   EXPECT_NEAR(occluded.overdraw_metrics()->pixels_uploaded_opaque(), 0, 1);
   EXPECT_NEAR(
       occluded.overdraw_metrics()->pixels_uploaded_translucent(), 20000, 1);
   EXPECT_EQ(0, occluded.overdraw_metrics()->tiles_culled_for_upload());
@@ skipping 328 matching lines @@
   // so the layer is considered small enough.
   bool run_out_of_memory[2] = { false, true };
   for (int i = 0; i < 2; i++) {
     // Create a layer with 5x5 tiles, with 4x4 size viewport.
     int viewport_width = 4 * FakeTiledLayer::tile_size().width();
     int viewport_height = 4 * FakeTiledLayer::tile_size().width();
     int layer_width = 5 * FakeTiledLayer::tile_size().width();
     int layer_height = 5 * FakeTiledLayer::tile_size().height();
     int memory_for_layer = layer_width * layer_height * 4;
     layer_tree_host_->SetViewportSize(
-        gfx::Size(viewport_width, viewport_height),
         gfx::Size(viewport_width, viewport_height));
 
     // Use 10x5 tiles to run out of memory.
     if (run_out_of_memory[i])
       layer_width *= 2;
 
     resource_manager_->SetMaxMemoryLimitBytes(memory_for_layer);
 
     scoped_refptr<FakeTiledLayer> layer =
         make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
@@ skipping 281 matching lines @@
   root_layer->SetBounds(content_bounds);
   root_layer->draw_properties().visible_content_rect = content_rect;
   root_layer->SetPosition(gfx::PointF(0, 0));
   child_layer->SetBounds(content_bounds);
   child_layer->draw_properties().visible_content_rect = content_rect;
   child_layer->SetPosition(gfx::PointF(0, 0));
   root_layer->InvalidateContentRect(content_rect);
   child_layer->InvalidateContentRect(content_rect);
 
   layer_tree_host_->SetRootLayer(root_layer);
-  layer_tree_host_->SetViewportSize(gfx::Size(300, 300), gfx::Size(300, 300));
+  layer_tree_host_->SetViewportSize(gfx::Size(300, 300));
 
   layer_tree_host_->UpdateLayers(queue_.get(), memory_limit);
 
   // We'll skip the root layer.
   EXPECT_TRUE(root_layer->SkipsDraw());
   EXPECT_FALSE(child_layer->SkipsDraw());
 
   layer_tree_host_->CommitComplete();
 
   // Remove the child layer.
@@ skipping 49 matching lines @@
   gfx::Rect content_rect(content_bounds);
 
   scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(
       new FakeTiledLayer(layer_tree_host_->contents_texture_manager()));
   layer->SetBounds(content_bounds);
   layer->SetPosition(gfx::PointF(0, 0));
   layer->draw_properties().visible_content_rect = content_rect;
   layer->InvalidateContentRect(content_rect);
 
   layer_tree_host_->SetRootLayer(layer);
-  layer_tree_host_->SetViewportSize(gfx::Size(300, 200), gfx::Size(300, 200));
+  layer_tree_host_->SetViewportSize(gfx::Size(300, 200));
 
   // Full update of all 6 tiles.
   layer_tree_host_->UpdateLayers(queue_.get(),
                                  std::numeric_limits<size_t>::max());
   {
     scoped_ptr<FakeTiledLayerImpl> layer_impl =
         make_scoped_ptr(new FakeTiledLayerImpl(host_impl_->active_tree(), 1));
     EXPECT_EQ(6u, queue_->FullUploadSize());
     EXPECT_EQ(0u, queue_->PartialUploadSize());
     UpdateTextures();
@@ skipping 101 matching lines @@
 }
 
 TEST_F(TiledLayerTest, TilesPaintedWithOcclusion) {
   scoped_refptr<FakeTiledLayer> layer =
       make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
   TestOcclusionTracker occluded;
   occlusion_ = &occluded;
 
   // The tile size is 100x100.
 
-  layer_tree_host_->SetViewportSize(gfx::Size(600, 600), gfx::Size(600, 600));
+  layer_tree_host_->SetViewportSize(gfx::Size(600, 600));
   layer->SetBounds(gfx::Size(600, 600));
   CalcDrawProps(layer);
 
   occluded.SetOcclusion(gfx::Rect(200, 200, 300, 100));
   layer->draw_properties().drawable_content_rect =
       gfx::Rect(layer->content_bounds());
   layer->draw_properties().visible_content_rect =
       gfx::Rect(layer->content_bounds());
   layer->InvalidateContentRect(gfx::Rect(0, 0, 600, 600));
 
@@ skipping 39 matching lines @@
 }
 
 TEST_F(TiledLayerTest, TilesPaintedWithOcclusionAndVisiblityConstraints) {
   scoped_refptr<FakeTiledLayer> layer =
       make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
   TestOcclusionTracker occluded;
   occlusion_ = &occluded;
 
   // The tile size is 100x100.
 
-  layer_tree_host_->SetViewportSize(gfx::Size(600, 600), gfx::Size(600, 600));
+  layer_tree_host_->SetViewportSize(gfx::Size(600, 600));
   layer->SetBounds(gfx::Size(600, 600));
   CalcDrawProps(layer);
 
   // The partially occluded tiles (by the 150 occlusion height) are visible
   // beyond the occlusion, so not culled.
   occluded.SetOcclusion(gfx::Rect(200, 200, 300, 150));
   layer->draw_properties().drawable_content_rect = gfx::Rect(0, 0, 600, 360);
   layer->draw_properties().visible_content_rect = gfx::Rect(0, 0, 600, 360);
   layer->InvalidateContentRect(gfx::Rect(0, 0, 600, 600));
 
@@ skipping 47 matching lines @@
 }
 
 TEST_F(TiledLayerTest, TilesNotPaintedWithoutInvalidation) {
   scoped_refptr<FakeTiledLayer> layer =
       make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
   TestOcclusionTracker occluded;
   occlusion_ = &occluded;
 
   // The tile size is 100x100.
 
-  layer_tree_host_->SetViewportSize(gfx::Size(600, 600), gfx::Size(600, 600));
+  layer_tree_host_->SetViewportSize(gfx::Size(600, 600));
   layer->SetBounds(gfx::Size(600, 600));
   CalcDrawProps(layer);
 
   occluded.SetOcclusion(gfx::Rect(200, 200, 300, 100));
   layer->draw_properties().drawable_content_rect = gfx::Rect(0, 0, 600, 600);
   layer->draw_properties().visible_content_rect = gfx::Rect(0, 0, 600, 600);
   layer->InvalidateContentRect(gfx::Rect(0, 0, 600, 600));
   layer->SetTexturePriorities(priority_calculator_);
   resource_manager_->PrioritizeTextures();
   layer->Update(queue_.get(), &occluded, NULL);
@@ skipping 23 matching lines @@
 TEST_F(TiledLayerTest, TilesPaintedWithOcclusionAndTransforms) {
   scoped_refptr<FakeTiledLayer> layer =
       make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
   TestOcclusionTracker occluded;
   occlusion_ = &occluded;
 
   // The tile size is 100x100.
 
   // This makes sure the painting works when the occluded region (in screen
   // space) is transformed differently than the layer.
-  layer_tree_host_->SetViewportSize(gfx::Size(600, 600), gfx::Size(600, 600));
+  layer_tree_host_->SetViewportSize(gfx::Size(600, 600));
   layer->SetBounds(gfx::Size(600, 600));
   CalcDrawProps(layer);
   gfx::Transform screen_transform;
   screen_transform.Scale(0.5, 0.5);
   layer->draw_properties().screen_space_transform = screen_transform;
   layer->draw_properties().target_space_transform = screen_transform;
 
   occluded.SetOcclusion(gfx::Rect(100, 100, 150, 50));
   layer->draw_properties().drawable_content_rect =
       gfx::Rect(layer->content_bounds());
@@ skipping 15 matching lines @@
   scoped_refptr<FakeTiledLayer> layer =
       make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
   TestOcclusionTracker occluded;
   occlusion_ = &occluded;
 
   // The tile size is 100x100.
 
   // This makes sure the painting works when the content space is scaled to
   // a different layer space. In this case tiles are scaled to be 200x200
   // pixels, which means none should be occluded.
-  layer_tree_host_->SetViewportSize(gfx::Size(600, 600), gfx::Size(600, 600));
+  layer_tree_host_->SetViewportSize(gfx::Size(600, 600));
   layer->SetBounds(gfx::Size(600, 600));
   layer->SetRasterScale(0.5);
   CalcDrawProps(layer);
   EXPECT_FLOAT_EQ(layer->contents_scale_x(), layer->contents_scale_y());
   gfx::Transform draw_transform;
   double inv_scale_factor = 1 / layer->contents_scale_x();
   draw_transform.Scale(inv_scale_factor, inv_scale_factor);
   layer->draw_properties().target_space_transform = draw_transform;
   layer->draw_properties().screen_space_transform = draw_transform;
 
@@ skipping 64 matching lines @@
               90000 + 80000 + 80000,
               1);
   EXPECT_EQ(1 + 1, occluded.overdraw_metrics()->tiles_culled_for_upload());
 }
 
 TEST_F(TiledLayerTest, VisibleContentOpaqueRegion) {
   scoped_refptr<FakeTiledLayer> layer =
       make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
   TestOcclusionTracker occluded;
   occlusion_ = &occluded;
-  layer_tree_host_->SetViewportSize(gfx::Size(1000, 1000),
-                                    gfx::Size(1000, 1000));
+  layer_tree_host_->SetViewportSize(gfx::Size(1000, 1000));
 
   // The tile size is 100x100, so this invalidates and then paints two tiles in
   // various ways.
 
   gfx::Rect opaque_paint_rect;
   Region opaque_contents;
 
   gfx::Rect content_bounds = gfx::Rect(0, 0, 100, 200);
   gfx::Rect visible_bounds = gfx::Rect(0, 0, 100, 150);
 
@@ skipping 94 matching lines @@
               20000 + 20000 - 17100 + 1 + 1,
               1);
   EXPECT_EQ(0, occluded.overdraw_metrics()->tiles_culled_for_upload());
 }
 
 TEST_F(TiledLayerTest, Pixels_paintedMetrics) {
   scoped_refptr<FakeTiledLayer> layer =
       make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
   TestOcclusionTracker occluded;
   occlusion_ = &occluded;
-  layer_tree_host_->SetViewportSize(gfx::Size(1000, 1000),
-                                    gfx::Size(1000, 1000));
+  layer_tree_host_->SetViewportSize(gfx::Size(1000, 1000));
 
   // The tile size is 100x100, so this invalidates and then paints two tiles in
   // various ways.
 
   gfx::Rect opaque_paint_rect;
   Region opaque_contents;
 
   gfx::Rect content_bounds = gfx::Rect(0, 0, 100, 300);
   layer->SetBounds(content_bounds.size());
   CalcDrawProps(layer);
@@ skipping 71 matching lines @@
   child->draw_properties().visible_content_rect = child_rect;
   child->draw_properties().drawable_content_rect = root_rect;
 
   child2->SetBounds(child2_rect.size());
   child2->SetAnchorPoint(gfx::PointF());
   child2->SetPosition(child2_rect.origin());
   child2->draw_properties().visible_content_rect = child2_rect;
   child2->draw_properties().drawable_content_rect = root_rect;
 
   layer_tree_host_->SetRootLayer(root);
-  layer_tree_host_->SetViewportSize(root_rect.size(), root_rect.size());
+  layer_tree_host_->SetViewportSize(root_rect.size());
 
   // With a huge memory limit, all layers should update and push their textures.
   root->InvalidateContentRect(root_rect);
   child->InvalidateContentRect(child_rect);
   child2->InvalidateContentRect(child2_rect);
   layer_tree_host_->UpdateLayers(queue_.get(),
                                  std::numeric_limits<size_t>::max());
   {
     UpdateTextures();
     EXPECT_EQ(6, root->fake_layer_updater()->update_count());
@@ skipping 210 matching lines @@
   // Invalidate the entire layer in layer space. When painting, the rect given
   // to webkit should match the layer's bounds.
   layer->SetNeedsDisplayRect(layer_rect);
   layer->Update(queue_.get(), 0, NULL);
 
   EXPECT_RECT_EQ(layer_rect, layer->tracking_layer_painter()->PaintedRect());
 }
 
 }  // namespace
 }  // namespace cc