Use gfx:: Geometry types for the resource provider and layer updater classes.

cc/prioritized_texture_manager.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 CCPrioritizedTextureManager_h
 #define CCPrioritizedTextureManager_h
 
 #include <list>
 #include <vector>
 
-#include "IntRect.h"
-#include "IntSize.h"
 #include "base/basictypes.h"
 #include "base/hash_tables.h"
 #include "base/memory/scoped_ptr.h"
 #include "cc/prioritized_texture.h"
 #include "cc/priority_calculator.h"
 #include "cc/texture.h"
 #include "third_party/khronos/GLES2/gl2.h"
+#include "ui/gfx/size.h"
 
 #if defined(COMPILER_GCC)
 namespace BASE_HASH_NAMESPACE {
 template<>
 struct hash<cc::PrioritizedTexture*> {
   size_t operator()(cc::PrioritizedTexture* ptr) const {
     return hash<size_t>()(reinterpret_cast<size_t>(ptr));
   }
 };
 } // namespace BASE_HASH_NAMESPACE
 #endif // COMPILER
 
 namespace cc {
 
 class PriorityCalculator;
 
 class PrioritizedTextureManager {
 public:
     static scoped_ptr<PrioritizedTextureManager> create(size_t maxMemoryLimitBytes, int maxTextureSize, int pool)
     {
         return make_scoped_ptr(new PrioritizedTextureManager(maxMemoryLimitBytes, maxTextureSize, pool));
     }
-    scoped_ptr<PrioritizedTexture> createTexture(IntSize size, GLenum format)
+    scoped_ptr<PrioritizedTexture> createTexture(gfx::Size size, GLenum format)
     {
         return make_scoped_ptr(new PrioritizedTexture(this, size, format));
     }
     ~PrioritizedTextureManager();
 
     typedef std::list<PrioritizedTexture::Backing*> BackingList;
 
     // FIXME (http://crbug.com/137094): This 64MB default is a straggler from the
     // old texture manager and is just to give us a default memory allocation before
     // we get a callback from the GPU memory manager. We should probaby either:
@@ skipping 85 matching lines @@
             return PriorityCalculator::priorityIsLower(a->requestPriorityAtLastPriorityUpdate(), b->requestPriorityAtLastPriorityUpdate());
         // Finally sort by being in the impl tree versus being completely unreferenced
         if (a->inDrawingImplTree() != b->inDrawingImplTree())
             return (a->inDrawingImplTree() < b->inDrawingImplTree());
         return a < b;
     }
 
     PrioritizedTextureManager(size_t maxMemoryLimitBytes, int maxTextureSize, int pool);
 
     bool evictBackingsToReduceMemory(size_t limitBytes, int priorityCutoff, EvictionPolicy, ResourceProvider*);
-    PrioritizedTexture::Backing* createBacking(IntSize, GLenum format, ResourceProvider*);
+    PrioritizedTexture::Backing* createBacking(gfx::Size, GLenum format, ResourceProvider*);
     void evictFirstBackingResource(ResourceProvider*);
     void deleteUnlinkedEvictedBackings();
     void sortBackings();
 
     void assertInvariants();
 
     size_t m_maxMemoryLimitBytes;
     // The priority cutoff based on memory pressure. This is not a strict
     // cutoff -- requestLate allows textures with priority equal to this
     // cutoff to be allowed.
@@ skipping 26 matching lines @@
     // Statistics copied at the time of pushTexturePrioritiesToBackings.
     size_t m_memoryVisibleLastPushedBytes;
     size_t m_memoryVisibleAndNearbyLastPushedBytes;
 
     DISALLOW_COPY_AND_ASSIGN(PrioritizedTextureManager);
 };
 
 }  // namespace cc
 
 #endif