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

cc/layers/delegated_renderer_layer_impl.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/layers/delegated_renderer_layer_impl.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 137 matching lines @@
   gfx::Size frame_size = new_root_pass->output_rect.size();
   gfx::RectF damage_in_layer = MathUtil::MapClippedRect(
       DelegatedFrameToLayerSpaceTransform(frame_size), damage_in_frame);
   SetUpdateRect(gfx::IntersectRects(
       gfx::UnionRects(update_rect(), damage_in_layer), gfx::Rect(bounds())));
 
   SetRenderPasses(&render_pass_list);
   have_render_passes_to_push_ = true;
 }
 
-void DelegatedRendererLayerImpl::SetDisplaySize(const gfx::Size& size) {
+void DelegatedRendererLayerImpl::SetDisplaySize(gfx::Size size) {
   if (display_size_ == size)
     return;
   display_size_ = size;
   NoteLayerPropertyChanged();
 }
 
 void DelegatedRendererLayerImpl::SetRenderPasses(
     ScopedPtrVector<RenderPass>* render_passes_in_draw_order) {
   ClearRenderPasses();
 
@@ skipping 21 matching lines @@
   return DelegatedRendererLayerImpl::Create(
       tree_impl, id()).PassAs<LayerImpl>();
 }
 
 void DelegatedRendererLayerImpl::ReleaseResources() {
   ClearRenderPasses();
   ClearChildId();
 }
 
 gfx::Transform DelegatedRendererLayerImpl::DelegatedFrameToLayerSpaceTransform(
-    const gfx::Size& frame_size) const {
+    gfx::Size frame_size) const {
   gfx::Size display_size = display_size_.IsEmpty() ? bounds() : display_size_;
 
   gfx::Transform delegated_frame_to_layer_space_transform;
   delegated_frame_to_layer_space_transform.Scale(
       static_cast<double>(display_size.width()) / frame_size.width(),
       static_cast<double>(display_size.height()) / frame_size.height());
   return delegated_frame_to_layer_space_transform;
 }
 
 static inline int IndexToId(int index) { return index + 1; }
@@ skipping 176 matching lines @@
           shared_quad_state, right, colors[i % kNumColors], false);
       quad_sink->Append(right_quad.PassAs<DrawQuad>(), append_quads_data);
     }
   }
 }
 
 void DelegatedRendererLayerImpl::AppendRenderPassQuads(
     QuadSink* quad_sink,
     AppendQuadsData* append_quads_data,
     const RenderPass* delegated_render_pass,
-    const gfx::Size& frame_size) const {
+    gfx::Size frame_size) const {
 
   const SharedQuadState* delegated_shared_quad_state = NULL;
   SharedQuadState* output_shared_quad_state = NULL;
 
   for (size_t i = 0; i < delegated_render_pass->quad_list.size(); ++i) {
     const DrawQuad* delegated_quad = delegated_render_pass->quad_list[i];
 
     if (delegated_quad->shared_quad_state != delegated_shared_quad_state) {
       delegated_shared_quad_state = delegated_quad->shared_quad_state;
       output_shared_quad_state = quad_sink->UseSharedQuadState(
@@ skipping 74 matching lines @@
   if (own_child_id_) {
     ResourceProvider* provider = layer_tree_impl()->resource_provider();
     provider->DestroyChild(child_id_);
   }
 
   resources_.clear();
   child_id_ = 0;
 }
 
 }  // namespace cc