Remove the pools from the ResourceProvider.

cc/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_RESOURCE_PROVIDER_H_
 #define CC_RESOURCE_PROVIDER_H_
 
 #include "base/basictypes.h"
 #include "base/hash_tables.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 22 matching lines @@
 
 class TextureUploader;
 
 // This class is not thread-safe and can only be called from the thread it was
 // created on (in practice, the impl thread).
 class CC_EXPORT ResourceProvider {
 public:
     typedef unsigned ResourceId;
     typedef std::vector<ResourceId> ResourceIdArray;
     typedef base::hash_map<ResourceId, ResourceId> ResourceIdMap;
-    enum TextureUsageHint { TextureUsageAny, TextureUsageFramebuffer };
+    enum TextureUsageHint {
+        TextureUsageAny,
+        TextureUsageFramebuffer,
+    };
     enum ResourceType {
         GLTexture = 1,
         Bitmap,
     };
 
     static scoped_ptr<ResourceProvider> create(OutputSurface*);
 
     virtual ~ResourceProvider();
 
     WebKit::WebGraphicsContext3D* graphicsContext3D();
     TextureCopier* textureCopier() const { return m_textureCopier.get(); }
     int maxTextureSize() const { return m_maxTextureSize; }
     GLenum bestTextureFormat() const { return m_bestTextureFormat; }
     unsigned numResources() const { return m_resources.size(); }
 
     // Checks whether a resource is in use by a consumer.
     bool inUseByConsumer(ResourceId);
 
 
     // Producer interface.
 
     void setDefaultResourceType(ResourceType type) { m_defaultResourceType = type; }
     ResourceType defaultResourceType() const { return m_defaultResourceType; }
     ResourceType resourceType(ResourceId);
 
     // Creates a resource of the default resource type.
-    ResourceId createResource(int pool, const gfx::Size&, GLenum format, TextureUsageHint);
+    ResourceId createResource(const gfx::Size&, GLenum format, TextureUsageHint);
 
     // You can also explicitly create a specific resource type.
-    ResourceId createGLTexture(int pool, const gfx::Size&, GLenum format, TextureUsageHint);
-    ResourceId createBitmap(int pool, const gfx::Size&);
+    ResourceId createGLTexture(const gfx::Size&, GLenum format, TextureUsageHint);
+    ResourceId createBitmap(const gfx::Size&);
     // Wraps an external texture into a GL resource.
     ResourceId createResourceFromExternalTexture(unsigned textureId);
 
     void deleteResource(ResourceId);
 
-    // Deletes all resources owned by a given pool.
-    void deleteOwnedResources(int pool);
-
     // Update pixels from image, copying sourceRect (in image) into destRect (in the resource).
     void setPixels(ResourceId, const uint8_t* image, const gfx::Rect& imageRect, const gfx::Rect& sourceRect, const gfx::Vector2d& destOffset);
 
     // Check upload status.
     size_t numBlockingUploads();
     void markPendingUploadsAsNonBlocking();
     double estimatedUploadsPerSecond();
     void flushUploads();
 
     // Flush all context operations, kicking uploads and ensuring ordering with
     // respect to other contexts.
     void flush();
 
     // Only flush the command buffer if supported.
     // Returns true if the shallow flush occurred, false otherwise.
     bool shallowFlushIfSupported();
 
-    // Creates accounting for a child, and associate it with a pool. Resources
-    // transfered from that child will go to that pool. Returns a child ID.
-    int createChild(int pool);
+    // Creates accounting for a child. Returns a child ID.
+    int createChild();
 
-    // Destroys accounting for the child, deleting all resources from that pool.
+    // Destroys accounting for the child, deleting all accounted resources.
     void destroyChild(int child);
 
     // Gets the child->parent resource ID map.
     const ResourceIdMap& getChildToParentMap(int child) const;
 
     // Prepares resources to be transfered to the parent, moving them to
     // mailboxes and serializing meta-data into TransferableResources.
     // Resources are not removed from the ResourceProvider, but are marked as
     // "in use".
     void prepareSendToParent(const ResourceIdArray&, TransferableResourceList*);
@@ skipping 108 matching lines @@
     // Update pixels from acquired pixel buffer.
     void setPixelsFromBuffer(ResourceId id);
 
     // Asynchronously update pixels from acquired pixel buffer.
     void beginSetPixels(ResourceId id);
     bool didSetPixelsComplete(ResourceId id);
 
 private:
     struct Resource {
         Resource();
-        Resource(unsigned textureId, int pool, const gfx::Size& size, GLenum format, GLenum filter);
-        Resource(uint8_t* pixels, int pool, const gfx::Size& size, GLenum format, GLenum filter);
+        Resource(unsigned textureId, const gfx::Size& size, GLenum format, GLenum filter);
+        Resource(uint8_t* pixels, const gfx::Size& size, GLenum format, GLenum filter);
 
         unsigned glId;
         // Pixel buffer used for set pixels without unnecessary copying.
         unsigned glPixelBufferId;
         // Query used to determine when asynchronous set pixels complete.
         unsigned glUploadQueryId;
         Mailbox mailbox;
         uint8_t* pixels;
         uint8_t* pixelBuffer;
-        int pool;
         int lockForReadCount;
         bool lockedForWrite;
         bool external;
         bool exported;
         bool markedForDeletion;
         bool pendingSetPixels;
         gfx::Size size;
         GLenum format;
         // TODO(skyostil): Use a separate sampler object for filter state.
         GLenum filter;
         ResourceType type;
     };
     typedef base::hash_map<ResourceId, Resource> ResourceMap;
     struct Child {
         Child();
         ~Child();
 
-        int pool;
         ResourceIdMap childToParentMap;
         ResourceIdMap parentToChildMap;
     };
     typedef base::hash_map<int, Child> ChildMap;
 
     explicit ResourceProvider(OutputSurface*);
     bool initialize();
 
     const Resource* lockForRead(ResourceId);
     void unlockForRead(ResourceId);
@@ skipping 20 matching lines @@
     GLenum m_bestTextureFormat;
 
     base::ThreadChecker m_threadChecker;
 
     DISALLOW_COPY_AND_ASSIGN(ResourceProvider);
 };
 
 }
 
 #endif  // CC_RESOURCE_PROVIDER_H_