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

cc/trees/layer_tree_host_impl_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_impl.h"
 
 #include <cmath>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 186 matching lines @@
     for (size_t i = 0; i < scroll_info.scrolls.size(); ++i) {
       if (scroll_info.scrolls[i].layer_id != id)
         continue;
       times_encountered++;
     }
 
     ASSERT_EQ(0, times_encountered);
   }
 
   LayerImpl* CreateScrollAndContentsLayers(LayerTreeImpl* layer_tree_impl,
-                                           const gfx::Size& content_size) {
+                                           gfx::Size content_size) {
     scoped_ptr<LayerImpl> root =
         LayerImpl::Create(layer_tree_impl, 1);
     root->SetBounds(content_size);
     root->SetContentBounds(content_size);
     root->SetPosition(gfx::PointF());
     root->SetAnchorPoint(gfx::PointF());
 
     scoped_ptr<LayerImpl> scroll =
         LayerImpl::Create(layer_tree_impl, 2);
     LayerImpl* scroll_layer = scroll.get();
@@ skipping 14 matching lines @@
     contents->SetPosition(gfx::PointF());
     contents->SetAnchorPoint(gfx::PointF());
 
     scroll->AddChild(contents.Pass());
     root->AddChild(scroll.Pass());
 
     layer_tree_impl->SetRootLayer(root.Pass());
     return scroll_layer;
   }
 
-  LayerImpl* SetupScrollAndContentsLayers(const gfx::Size& content_size) {
+  LayerImpl* SetupScrollAndContentsLayers(gfx::Size content_size) {
     LayerImpl* scroll_layer = CreateScrollAndContentsLayers(
         host_impl_->active_tree(), content_size);
     host_impl_->active_tree()->DidBecomeActive();
     return scroll_layer;
   }
 
-  scoped_ptr<LayerImpl> CreateScrollableLayer(int id, const gfx::Size& size) {
+  scoped_ptr<LayerImpl> CreateScrollableLayer(int id, gfx::Size size) {
     scoped_ptr<LayerImpl> layer =
         LayerImpl::Create(host_impl_->active_tree(), id);
     layer->SetScrollable(true);
     layer->SetDrawsContent(true);
     layer->SetBounds(size);
     layer->SetContentBounds(size);
     layer->SetMaxScrollOffset(gfx::Vector2d(size.width() * 2,
                                             size.height() * 2));
     return layer.Pass();
   }
@@ skipping 2902 matching lines @@
     host_impl_->DidDrawAllLayers(frame);
   }
 
   virtual void DidActivatePendingTree() OVERRIDE {
     did_activate_pending_tree_ = true;
   }
 
   void set_gutter_quad_material(DrawQuad::Material material) {
     gutter_quad_material_ = material;
   }
-  void set_gutter_texture_size(const gfx::Size& gutter_texture_size) {
+  void set_gutter_texture_size(gfx::Size gutter_texture_size) {
     gutter_texture_size_ = gutter_texture_size;
   }
 
  protected:
   size_t CountGutterQuads(const QuadList& quad_list) {
     size_t num_gutter_quads = 0;
     for (size_t i = 0; i < quad_list.size(); ++i) {
       num_gutter_quads += (quad_list[i]->material ==
                            gutter_quad_material_) ? 1 : 0;
     }
@@ skipping 17 matching lines @@
                 quad->rect.x() / gutter_texture_size_pixels.width());
       EXPECT_EQ(quad->uv_top_left.y(),
                 quad->rect.y() / gutter_texture_size_pixels.height());
       EXPECT_EQ(quad->uv_bottom_right.x(),
                 quad->rect.right() / gutter_texture_size_pixels.width());
       EXPECT_EQ(quad->uv_bottom_right.y(),
                 quad->rect.bottom() / gutter_texture_size_pixels.height());
     }
   }
 
-  gfx::Size DipSizeToPixelSize(const gfx::Size& size) {
+  gfx::Size DipSizeToPixelSize(gfx::Size size) {
     return gfx::ToRoundedSize(
         gfx::ScaleSize(size, host_impl_->device_scale_factor()));
   }
 
   DrawQuad::Material gutter_quad_material_;
   gfx::Size gutter_texture_size_;
   gfx::Size viewport_size_;
   BlendStateCheckLayer* child_;
   bool did_activate_pending_tree_;
 };
@@ skipping 2232 matching lines @@
                                      &set_needs_redraw_count));
     // Empty damage rect won't signal the monitor.
     host_impl_->SetNeedsRedrawRect(gfx::Rect());
     EXPECT_EQ(0, set_needs_commit_count);
     EXPECT_EQ(2, set_needs_redraw_count);
   }
 }
 
 }  // namespace
 }  // namespace cc