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

cc/resources/resource_provider_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/resource_provider.h"
 
 #include <algorithm>
 #include <map>
 
 #include "base/bind.h"
@@ skipping 46 matching lines @@
     unsigned* release_sync_point,
     bool* lost_resource_result,
     unsigned sync_point,
     bool lost_resource) {
   *release_called = true;
   *release_sync_point = sync_point;
   *lost_resource_result = lost_resource;
 }
 
 static scoped_ptr<base::SharedMemory> CreateAndFillSharedMemory(
-    const gfx::Size& size,
+    gfx::Size size,
     uint32_t value) {
   scoped_ptr<base::SharedMemory> shared_memory(new base::SharedMemory);
   CHECK(shared_memory->CreateAndMapAnonymous(4 * size.GetArea()));
   uint32_t* pixels = reinterpret_cast<uint32_t*>(shared_memory->memory());
   CHECK(pixels);
   std::fill_n(pixels, size.GetArea(), value);
   return shared_memory.Pass();
 }
 
 class TextureStateTrackingContext : public TestWebGraphicsContext3D {
@@ skipping 179 matching lines @@
 
   virtual void consumeTextureCHROMIUM(GLenum target,
                                       const GLbyte* mailbox) OVERRIDE {
     CheckTextureIsBound(target);
     base::AutoLock lock_for_texture_access(namespace_->lock);
     scoped_refptr<TestTexture> texture =
         shared_data_->ConsumeTexture(mailbox, last_waited_sync_point_);
     namespace_->textures.Replace(BoundTextureId(target), texture);
   }
 
-  void GetPixels(const gfx::Size& size,
-                 ResourceFormat format,
-                 uint8_t* pixels) {
+  void GetPixels(gfx::Size size, ResourceFormat format, uint8_t* pixels) {
     CheckTextureIsBound(GL_TEXTURE_2D);
     base::AutoLock lock_for_texture_access(namespace_->lock);
     scoped_refptr<TestTexture> texture = BoundTexture(GL_TEXTURE_2D);
     ASSERT_EQ(texture->size, size);
     ASSERT_EQ(texture->format, format);
     memcpy(pixels, texture->data.get(), TextureSizeBytes(size, format));
   }
 
  protected:
   explicit ResourceProviderContext(ContextSharedData* shared_data)
       : shared_data_(shared_data),
         last_waited_sync_point_(0) {}
 
  private:
-  void AllocateTexture(const gfx::Size& size, GLenum format) {
+  void AllocateTexture(gfx::Size size, GLenum format) {
     CheckTextureIsBound(GL_TEXTURE_2D);
     ResourceFormat texture_format = RGBA_8888;
     switch (format) {
       case GL_RGBA:
         texture_format = RGBA_8888;
         break;
       case GL_BGRA_EXT:
         texture_format = BGRA_8888;
         break;
     }
@@ skipping 40 matching lines @@
   delete shared_bitmap->memory();
 }
 
 void IgnoreSharedBitmap(SharedBitmap* shared_bitmap) {}
 
 class TestSharedBitmapManager : public SharedBitmapManager {
  public:
   TestSharedBitmapManager() : count_(0) {}
   virtual ~TestSharedBitmapManager() {}
 
-  virtual scoped_ptr<SharedBitmap> AllocateSharedBitmap(const gfx::Size& size)
+  virtual scoped_ptr<SharedBitmap> AllocateSharedBitmap(gfx::Size size)
       OVERRIDE {
     scoped_ptr<base::SharedMemory> memory(new base::SharedMemory);
     memory->CreateAndMapAnonymous(size.GetArea() * 4);
     int8 name[64] = { 0 };
     name[0] = count_++;
     SharedBitmapId id;
     id.SetName(name);
     bitmap_map_[id] = memory.get();
     return scoped_ptr<SharedBitmap>(
         new SharedBitmap(memory.release(), id, base::Bind(&FreeSharedBitmap)));
   }
 
   virtual scoped_ptr<SharedBitmap> GetSharedBitmapFromId(
-      const gfx::Size&,
+      gfx::Size,
       const SharedBitmapId& id) OVERRIDE {
     if (bitmap_map_.find(id) == bitmap_map_.end())
       return scoped_ptr<SharedBitmap>();
     return scoped_ptr<SharedBitmap>(
         new SharedBitmap(bitmap_map_[id], id, base::Bind(&IgnoreSharedBitmap)));
   }
 
   virtual scoped_ptr<SharedBitmap> GetBitmapForSharedMemory(
       base::SharedMemory* memory) OVERRIDE {
     int8 name[64] = { 0 };
     name[0] = count_++;
     SharedBitmapId id;
     id.SetName(name);
     bitmap_map_[id] = memory;
     return scoped_ptr<SharedBitmap>(
         new SharedBitmap(memory, id, base::Bind(&IgnoreSharedBitmap)));
   }
 
  private:
   int count_;
   std::map<SharedBitmapId, base::SharedMemory*> bitmap_map_;
 };
 
 void GetResourcePixels(ResourceProvider* resource_provider,
                        ResourceProviderContext* context,
                        ResourceProvider::ResourceId id,
-                       const gfx::Size& size,
+                       gfx::Size size,
                        ResourceFormat format,
                        uint8_t* pixels) {
   switch (resource_provider->default_resource_type()) {
     case ResourceProvider::GLTexture: {
       ResourceProvider::ScopedReadLockGL lock_gl(resource_provider, id);
       ASSERT_NE(0U, lock_gl.texture_id());
       context->bindTexture(GL_TEXTURE_2D, lock_gl.texture_id());
       context->GetPixels(size, format, pixels);
       break;
     }
@@ skipping 2764 matching lines @@
     resource_provider->AllocateForTesting(id);
     Mock::VerifyAndClearExpectations(context);
 
     DCHECK_EQ(10u, context->PeekTextureId());
     resource_provider->DeleteResource(id);
   }
 }
 
 }  // namespace
 }  // namespace cc