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

cc/resources/resource_provider.h

 // 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.
 
 #ifndef CC_RESOURCES_RESOURCE_PROVIDER_H_
 #define CC_RESOURCES_RESOURCE_PROVIDER_H_
 
 #include <deque>
 #include <set>
 #include <string>
@@ skipping 79 matching lines @@
   bool InUseByConsumer(ResourceId id);
 
   bool IsLost(ResourceId id);
 
   // Producer interface.
 
   ResourceType default_resource_type() const { return default_resource_type_; }
   ResourceType GetResourceType(ResourceId id);
 
   // Creates a resource of the default resource type.
-  ResourceId CreateResource(gfx::Size size,
+  ResourceId CreateResource(const gfx::Size& size,
                             GLint wrap_mode,
                             TextureUsageHint hint,
                             ResourceFormat format);
 
   // Creates a resource which is tagged as being managed for GPU memory
   // accounting purposes.
-  ResourceId CreateManagedResource(gfx::Size size,
+  ResourceId CreateManagedResource(const gfx::Size& size,
                                    GLenum target,
                                    GLint wrap_mode,
                                    TextureUsageHint hint,
                                    ResourceFormat format);
 
   // You can also explicitly create a specific resource type.
-  ResourceId CreateGLTexture(gfx::Size size,
+  ResourceId CreateGLTexture(const gfx::Size& size,
                              GLenum target,
                              GLenum texture_pool,
                              GLint wrap_mode,
                              TextureUsageHint hint,
                              ResourceFormat format);
 
-  ResourceId CreateBitmap(gfx::Size size, GLint wrap_mode);
+  ResourceId CreateBitmap(const gfx::Size& size, GLint wrap_mode);
   // Wraps an external texture into a GL resource.
   ResourceId CreateResourceFromExternalTexture(
       unsigned texture_target,
       unsigned texture_id);
 
   // Wraps an external texture mailbox into a GL resource.
   ResourceId CreateResourceFromTextureMailbox(
       const TextureMailbox& mailbox,
       scoped_ptr<SingleReleaseCallback> release_callback);
 
@@ skipping 227 matching lines @@
   // Indicates if we can currently lock this resource for write.
   bool CanLockForWrite(ResourceId id);
 
   static GLint GetActiveTextureUnit(gpu::gles2::GLES2Interface* gl);
 
  private:
   struct Resource {
     Resource();
     ~Resource();
     Resource(unsigned texture_id,
-             gfx::Size size,
+             const gfx::Size& size,
              GLenum target,
              GLenum filter,
              GLenum texture_pool,
              GLint wrap_mode,
              TextureUsageHint hint,
              ResourceFormat format);
     Resource(uint8_t* pixels,
              SharedBitmap* bitmap,
-             gfx::Size size,
+             const gfx::Size& size,
              GLenum filter,
              GLint wrap_mode);
 
     int child_id;
     unsigned gl_id;
     // Pixel buffer used for set pixels without unnecessary copying.
     unsigned gl_pixel_buffer_id;
     // Query used to determine when asynchronous set pixels complete.
     unsigned gl_upload_query_id;
     TextureMailbox mailbox;
@@ skipping 168 matching lines @@
   return format_gl_data_format[format];
 }
 
 inline GLenum GLInternalFormat(ResourceFormat format) {
   return GLDataFormat(format);
 }
 
 }  // namespace cc
 
 #endif  // CC_RESOURCES_RESOURCE_PROVIDER_H_