[#2] Pass gfx structs by const ref (gfx::Rect, gfx::RectF)

cc/resources/picture_layer_tiling_unittest.cc

 // Copyright 2012 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/resources/picture_layer_tiling.h"
 
 #include <limits>
 
 #include "cc/base/math_util.h"
 #include "cc/resources/picture_layer_tiling_set.h"
@@ skipping 48 matching lines @@
 
   void Initialize(gfx::Size tile_size,
                   float contents_scale,
                   gfx::Size layer_bounds) {
     client_.SetTileSize(tile_size);
     tiling_ = TestablePictureLayerTiling::Create(contents_scale,
                                                  layer_bounds,
                                                  &client_);
   }
 
-  void SetLiveRectAndVerifyTiles(gfx::Rect live_tiles_rect) {
+  void SetLiveRectAndVerifyTiles(const gfx::Rect& live_tiles_rect) {
     tiling_->SetLiveTilesRect(live_tiles_rect);
 
     std::vector<Tile*> tiles = tiling_->AllTilesForTesting();
     for (std::vector<Tile*>::iterator iter = tiles.begin();
          iter != tiles.end();
          ++iter) {
       EXPECT_TRUE(live_tiles_rect.Intersects((*iter)->content_rect()));
     }
   }
 
   void VerifyTilesExactlyCoverRect(
       float rect_scale,
-      gfx::Rect request_rect,
-      gfx::Rect expect_rect) {
+      const gfx::Rect& request_rect,
+      const gfx::Rect& expect_rect) {
     EXPECT_TRUE(request_rect.Contains(expect_rect));
 
     // Iterators are not valid if this ratio is too large (i.e. the
     // tiling is too high-res for a low-res destination rect.)  This is an
     // artifact of snapping geometry to integer coordinates and then mapping
     // back to floating point texture coordinates.
     float dest_to_contents_scale = tiling_->contents_scale() / rect_scale;
     ASSERT_LE(dest_to_contents_scale, 2.0);
 
     Region remaining = expect_rect;
@@ skipping 14 matching lines @@
       EXPECT_LE(texture_rect.right(), client_.TileSize().width());
       EXPECT_LE(texture_rect.bottom(), client_.TileSize().height());
 
       EXPECT_EQ(iter.texture_size(), client_.TileSize());
     }
 
     // The entire rect must be filled by geometry from the tiling.
     EXPECT_TRUE(remaining.IsEmpty());
   }
 
-  void VerifyTilesExactlyCoverRect(float rect_scale, gfx::Rect rect) {
+  void VerifyTilesExactlyCoverRect(float rect_scale, const gfx::Rect& rect) {
     VerifyTilesExactlyCoverRect(rect_scale, rect, rect);
   }
 
   void VerifyTiles(
       float rect_scale,
-      gfx::Rect rect,
-      base::Callback<void(Tile* tile, gfx::Rect geometry_rect)> callback) {
+      const gfx::Rect& rect,
+      base::Callback<void(Tile* tile,
+                          const gfx::Rect& geometry_rect)> callback) {
     VerifyTiles(tiling_.get(),
                 rect_scale,
                 rect,
                 callback);
   }
 
   void VerifyTiles(
       PictureLayerTiling* tiling,
       float rect_scale,
-      gfx::Rect rect,
-      base::Callback<void(Tile* tile, gfx::Rect geometry_rect)> callback) {
+      const gfx::Rect& rect,
+      base::Callback<void(Tile* tile,
+                          const gfx::Rect& geometry_rect)> callback) {
     Region remaining = rect;
     for (PictureLayerTiling::CoverageIterator iter(tiling, rect_scale, rect);
          iter;
          ++iter) {
       remaining.Subtract(iter.geometry_rect());
       callback.Run(*iter, iter.geometry_rect());
     }
     EXPECT_TRUE(remaining.IsEmpty());
   }
 
-  void VerifyTilesCoverNonContainedRect(float rect_scale, gfx::Rect dest_rect) {
+  void VerifyTilesCoverNonContainedRect(float rect_scale,
+                                        const gfx::Rect& dest_rect) {
     float dest_to_contents_scale = tiling_->contents_scale() / rect_scale;
     gfx::Rect clamped_rect = gfx::ScaleToEnclosingRect(
         tiling_->ContentRect(), 1.f / dest_to_contents_scale);
     clamped_rect.Intersect(dest_rect);
     VerifyTilesExactlyCoverRect(rect_scale, dest_rect, clamped_rect);
   }
 
  protected:
   FakePictureLayerTilingClient client_;
   scoped_ptr<TestablePictureLayerTiling> tiling_;
@@ skipping 314 matching lines @@
   // If a layer has a non-invertible transform, then the starting rect
   // for the layer would be empty.
   gfx::Rect in(40, 40, 0, 0);
   gfx::Rect bounds(0, 0, 10, 10);
   int64 target_area = 400 * 400;
   gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy(
       in, target_area, bounds, NULL);
   EXPECT_TRUE(out.IsEmpty());
 }
 
-static void TileExists(bool exists, Tile* tile, gfx::Rect geometry_rect) {
+static void TileExists(bool exists, Tile* tile,
+                       const gfx::Rect& geometry_rect) {
   EXPECT_EQ(exists, tile != NULL) << geometry_rect.ToString();
 }
 
 TEST_F(PictureLayerTilingIteratorTest, TilesExist) {
   gfx::Size layer_bounds(1099, 801);
   Initialize(gfx::Size(100, 100), 1.f, layer_bounds);
   VerifyTilesExactlyCoverRect(1.f, gfx::Rect(layer_bounds));
   VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, false));
 
   tiling_->UpdateTilePriorities(
@@ skipping 88 matching lines @@
       layer_bounds,  // current layer bounds
       1.f,  // last contents scale
       1.f,  // current contents scale
       gfx::Transform(),  // last screen transform
       gfx::Transform(),  // current screen transform
       1.0,  // current frame time
       10000);  // max tiles in tile manager
   VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, true));
 }
 
-static void TilesIntersectingRectExist(gfx::Rect rect,
+static void TilesIntersectingRectExist(const gfx::Rect& rect,
                                        bool intersect_exists,
                                        Tile* tile,
-                                       gfx::Rect geometry_rect) {
+                                       const gfx::Rect& geometry_rect) {
   bool intersects = rect.Intersects(geometry_rect);
   bool expected_exists = intersect_exists ? intersects : !intersects;
   EXPECT_EQ(expected_exists, tile != NULL)
       << "Rects intersecting " << rect.ToString() << " should exist. "
       << "Current tile rect is " << geometry_rect.ToString();
 }
 
 TEST_F(PictureLayerTilingIteratorTest,
        TilesExistLargeViewportAndLayerWithSmallVisibleArea) {
   gfx::Size layer_bounds(10000, 10000);
@@ skipping 16 matching lines @@
       gfx::Transform(),  // current screen transform
       1.0,  // current frame time
       1);  // max tiles in tile manager
   VerifyTiles(1.f,
               gfx::Rect(layer_bounds),
               base::Bind(&TilesIntersectingRectExist, visible_rect, true));
 }
 
 static void CountExistingTiles(int *count,
                                Tile* tile,
-                               gfx::Rect geometry_rect) {
+                               const gfx::Rect& geometry_rect) {
   if (tile != NULL)
     ++(*count);
 }
 
 TEST_F(PictureLayerTilingIteratorTest,
        TilesExistLargeViewportAndLayerWithLargeVisibleArea) {
   gfx::Size layer_bounds(10000, 10000);
   Initialize(gfx::Size(100, 100), 1.f, layer_bounds);
   VerifyTilesExactlyCoverRect(1.f, gfx::Rect(layer_bounds));
   VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, false));
@@ skipping 762 matching lines @@
   EXPECT_GT(priority.time_to_visible_in_seconds, 0.f);
 
   priority = tiling->TileAt(1, 0)->priority(ACTIVE_TREE);
   EXPECT_GT(priority.distance_to_visible_in_pixels, 0.f);
   EXPECT_FLOAT_EQ(std::numeric_limits<float>::infinity(),
                   priority.time_to_visible_in_seconds);
 }
 
 }  // namespace
 }  // namespace cc