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

cc/resources/prioritized_resource.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_PRIORITIZED_RESOURCE_H_
 #define CC_RESOURCES_PRIORITIZED_RESOURCE_H_
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "cc/base/cc_export.h"
 #include "cc/resources/priority_calculator.h"
 #include "cc/resources/resource.h"
 #include "cc/resources/resource_provider.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/size.h"
 #include "ui/gfx/vector2d.h"
 
 namespace cc {
 
 class PrioritizedResourceManager;
 class Proxy;
 
 class CC_EXPORT PrioritizedResource {
  public:
   static scoped_ptr<PrioritizedResource> Create(
       PrioritizedResourceManager* manager,
-      const gfx::Size& size,
+      gfx::Size size,
       ResourceFormat format) {
     return make_scoped_ptr(new PrioritizedResource(manager, size, format));
   }
   static scoped_ptr<PrioritizedResource> Create(
       PrioritizedResourceManager* manager) {
     return make_scoped_ptr(
         new PrioritizedResource(manager, gfx::Size(), RGBA_8888));
   }
   ~PrioritizedResource();
 
   // Texture properties. Changing these causes the backing texture to be lost.
   // Setting these to the same value is a no-op.
   void SetTextureManager(PrioritizedResourceManager* manager);
   PrioritizedResourceManager* resource_manager() { return manager_; }
-  void SetDimensions(const gfx::Size& size, ResourceFormat format);
+  void SetDimensions(gfx::Size size, ResourceFormat format);
   ResourceFormat format() const { return format_; }
   gfx::Size size() const { return size_; }
   size_t bytes() const { return bytes_; }
   bool contents_swizzled() const { return contents_swizzled_; }
 
   // Set priority for the requested texture.
   void set_request_priority(int priority) { priority_ = priority; }
   int request_priority() const { return priority_; }
 
   // After PrioritizedResource::PrioritizeTextures() is called, this returns
@@ skipping 46 matching lines @@
   void ReturnBackingTexture();
 
  private:
   friend class PrioritizedResourceManager;
   friend class PrioritizedResourceTest;
 
   class Backing : public Resource {
    public:
     Backing(unsigned id,
             ResourceProvider* resource_provider,
-            const gfx::Size& size,
+            gfx::Size size,
             ResourceFormat format);
     ~Backing();
     void UpdatePriority();
     void UpdateState(ResourceProvider* resource_provider);
 
     PrioritizedResource* owner() { return owner_; }
     bool CanBeRecycledIfNotInExternalUse() const;
     int request_priority_at_last_priority_update() const {
       return priority_at_last_priority_update_;
     }
@@ skipping 22 matching lines @@
 
     bool resource_has_been_deleted_;
 
 #ifndef NDEBUG
     ResourceProvider* resource_provider_;
 #endif
     DISALLOW_COPY_AND_ASSIGN(Backing);
   };
 
   PrioritizedResource(PrioritizedResourceManager* resource_manager,
-                      const gfx::Size& size,
+                      gfx::Size size,
                       ResourceFormat format);
 
   bool is_above_priority_cutoff() { return is_above_priority_cutoff_; }
   void set_above_priority_cutoff(bool is_above_priority_cutoff) {
     is_above_priority_cutoff_ = is_above_priority_cutoff;
   }
   void set_manager_internal(PrioritizedResourceManager* manager) {
     manager_ = manager;
   }
 
@@ skipping 12 matching lines @@
 
   Backing* backing_;
   PrioritizedResourceManager* manager_;
 
   DISALLOW_COPY_AND_ASSIGN(PrioritizedResource);
 };
 
 }  // namespace cc
 
 #endif  // CC_RESOURCES_PRIORITIZED_RESOURCE_H_