Revert of [#7] Pass gfx structs by const ref (gfx::Size)

cc/resources/picture_pile_base.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/resources/picture_pile_base.h"
 
 #include <algorithm>
 #include <set>
 #include <vector>
 
@@ skipping 69 matching lines @@
   for (PictureMap::const_iterator it = other->picture_map_.begin();
        it != other->picture_map_.end();
        ++it) {
     picture_map_[it->first] = it->second.CloneForThread(thread_index);
   }
 }
 
 PicturePileBase::~PicturePileBase() {
 }
 
-void PicturePileBase::Resize(const gfx::Size& new_size) {
+void PicturePileBase::Resize(gfx::Size new_size) {
   if (size() == new_size)
     return;
 
   gfx::Size old_size = size();
   tiling_.SetTotalSize(new_size);
 
   // Find all tiles that contain any pixels outside the new size.
   std::vector<PictureMapKey> to_erase;
   int min_toss_x = tiling_.FirstBorderTileXIndexFromSrcCoord(
       std::min(old_size.width(), new_size.width()));
@@ skipping 28 matching lines @@
   // pixels, since that's the minimum number of pixels to add so that resulting
   // content can be snapped to a four pixel aligned grid.
   int buffer_pixels = static_cast<int>(ceil(1 / min_contents_scale) - 1);
   buffer_pixels = std::max(0, buffer_pixels);
   SetBufferPixels(buffer_pixels);
   min_contents_scale_ = min_contents_scale;
 }
 
 // static
 void PicturePileBase::ComputeTileGridInfo(
-    const gfx::Size& tile_grid_size,
+    gfx::Size tile_grid_size,
     SkTileGridPicture::TileGridInfo* info) {
   DCHECK(info);
   info->fTileInterval.set(tile_grid_size.width() - 2 * kTileGridBorderPixels,
                           tile_grid_size.height() - 2 * kTileGridBorderPixels);
   DCHECK_GT(info->fTileInterval.width(), 0);
   DCHECK_GT(info->fTileInterval.height(), 0);
   info->fMargin.set(kTileGridBorderPixels, kTileGridBorderPixels);
   // Offset the tile grid coordinate space to take into account the fact
   // that the top-most and left-most tiles do not have top and left borders
   // respectively.
   info->fOffset.set(-kTileGridBorderPixels, -kTileGridBorderPixels);
 }
 
-void PicturePileBase::SetTileGridSize(const gfx::Size& tile_grid_size) {
+void PicturePileBase::SetTileGridSize(gfx::Size tile_grid_size) {
   ComputeTileGridInfo(tile_grid_size, &tile_grid_info_);
 }
 
 void PicturePileBase::SetBufferPixels(int new_buffer_pixels) {
   if (new_buffer_pixels == buffer_pixels())
     return;
 
   Clear();
   tiling_.SetBorderTexels(new_buffer_pixels);
 }
@@ skipping 113 matching lines @@
     info.picture_ = picture_->GetCloneForDrawingOnThread(thread_index);
   return info;
 }
 
 float PicturePileBase::PictureInfo::GetInvalidationFrequency() const {
   return invalidation_history_.count() /
          static_cast<float>(INVALIDATION_FRAMES_TRACKED);
 }
 
 }  // namespace cc