cc: Give TilingData back a Size instead of a Rect.

cc/layers/picture_layer_impl_unittest.cc

 // Copyright 2013 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/picture_layer_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <set>
 #include <utility>
@@ skipping 141 matching lines @@
     layer->draw_properties().maximum_animation_contents_scale =
         maximum_animation_contents_scale;
     layer->draw_properties().screen_space_transform_is_animating =
         animating_transform_to_screen;
     layer->UpdateTiles(NULL);
   }
   static void VerifyAllTilesExistAndHavePile(
       const PictureLayerTiling* tiling,
       PicturePileImpl* pile) {
     for (PictureLayerTiling::CoverageIterator iter(
-             tiling, tiling->contents_scale(), tiling->TilingRect());
+             tiling,
+             tiling->contents_scale(),
+             gfx::Rect(tiling->tiling_size()));
          iter;
          ++iter) {
       EXPECT_TRUE(*iter);
       EXPECT_EQ(pile, iter->picture_pile());
     }
   }
 
   void SetContentsScaleOnBothLayers(float contents_scale,
                                     float device_scale_factor,
                                     float page_scale_factor,
@@ skipping 251 matching lines @@
   AddDefaultTilingsWithInvalidation(invalidation);
 
   const PictureLayerTilingSet* tilings = pending_layer_->tilings();
   EXPECT_GT(tilings->num_tilings(), 0u);
   for (size_t i = 0; i < tilings->num_tilings(); ++i) {
     const PictureLayerTiling* tiling = tilings->tiling_at(i);
     gfx::Rect content_invalidation = gfx::ScaleToEnclosingRect(
         layer_invalidation,
         tiling->contents_scale());
     for (PictureLayerTiling::CoverageIterator iter(
-             tiling, tiling->contents_scale(), tiling->TilingRect());
+             tiling,
+             tiling->contents_scale(),
+             gfx::Rect(tiling->tiling_size()));
          iter;
          ++iter) {
       EXPECT_TRUE(*iter);
       EXPECT_FALSE(iter.geometry_rect().IsEmpty());
       if (iter.geometry_rect().Intersects(content_invalidation))
         EXPECT_EQ(pending_pile, iter->picture_pile());
       else
         EXPECT_EQ(active_pile, iter->picture_pile());
     }
   }
@@ skipping 40 matching lines @@
   AddDefaultTilingsWithInvalidation(invalidation);
 
   const PictureLayerTilingSet* tilings = pending_layer_->tilings();
   EXPECT_GT(tilings->num_tilings(), 0u);
   for (size_t i = 0; i < tilings->num_tilings(); ++i) {
     const PictureLayerTiling* tiling = tilings->tiling_at(i);
     gfx::Rect active_content_bounds = gfx::ScaleToEnclosingRect(
         gfx::Rect(active_layer_bounds),
         tiling->contents_scale());
     for (PictureLayerTiling::CoverageIterator iter(
-             tiling, tiling->contents_scale(), tiling->TilingRect());
+             tiling,
+             tiling->contents_scale(),
+             gfx::Rect(tiling->tiling_size()));
          iter;
          ++iter) {
       EXPECT_TRUE(*iter);
       EXPECT_FALSE(iter.geometry_rect().IsEmpty());
       std::vector<Tile*> active_tiles =
           active_layer_->tilings()->tiling_at(i)->AllTilesForTesting();
       std::vector<Tile*> pending_tiles = tiling->AllTilesForTesting();
       if (iter.geometry_rect().right() >= active_content_bounds.width() ||
           iter.geometry_rect().bottom() >= active_content_bounds.height() ||
           active_tiles[0]->content_rect().size() !=
@@ skipping 33 matching lines @@
   SetupTrees(pending_pile, active_pile);
   Region invalidation;
   AddDefaultTilingsWithInvalidation(invalidation);
 
   const PictureLayerTilingSet* tilings = pending_layer_->tilings();
   EXPECT_GT(tilings->num_tilings(), 0u);
   for (size_t i = 0; i < tilings->num_tilings(); ++i) {
     const PictureLayerTiling* tiling = tilings->tiling_at(i);
 
     for (PictureLayerTiling::CoverageIterator iter(
-             tiling, tiling->contents_scale(), tiling->TilingRect());
+             tiling,
+             tiling->contents_scale(),
+             gfx::Rect(tiling->tiling_size()));
          iter;
          ++iter) {
       EXPECT_FALSE(iter.full_tile_geometry_rect().IsEmpty());
       // Ensure there is a recording for this tile.
       bool in_pending = pending_pile->CanRaster(tiling->contents_scale(),
                                                 iter.full_tile_geometry_rect());
       bool in_active = active_pile->CanRaster(tiling->contents_scale(),
                                               iter.full_tile_geometry_rect());
 
       if (in_pending && !in_active)
@@ skipping 2731 matching lines @@
         // Unshared tiles are occluded on the active tree iff they lie beneath
         // the occluding layer.
         EXPECT_EQ(tile->is_occluded(ACTIVE_TREE),
                   scaled_content_rect.x() >= occluding_layer_position.x());
       }
     }
   }
 }
 }  // namespace
 }  // namespace cc