Remove the pools from the ResourceProvider.

Pools were used in the past and were planned to be used to
call deleteOwnedResources. We have moved the responsibility
of deleting resources to the structure that created them
(for example, the PrioritizedResourceManager now deletes
contents textures, instead of calling deleteOwnedResources).

BUG=164947

Review URL: https://codereview.chromium.org/11578019

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@173212 0039d316-1c4b-4281-b951-d872f2087c98

cc/direct_renderer.cc

@@ -277,7 +277,7 @@ bool DirectRenderer::useRenderPass(DrawingFrame& frame, const RenderPass* render
 
     gfx::Size size = renderPassTextureSize(renderPass);
     size.Enlarge(m_enlargePassTextureAmount.x(), m_enlargePassTextureAmount.y());
-    if (!texture->id() && !texture->Allocate(Renderer::ImplPool, size, renderPassTextureFormat(renderPass), ResourceProvider::TextureUsageFramebuffer))
+    if (!texture->id() && !texture->Allocate(size, renderPassTextureFormat(renderPass), ResourceProvider::TextureUsageFramebuffer))
         return false;
 
     return bindFramebufferToTexture(frame, texture, renderPass->output_rect);

cc/gl_renderer.cc

@@ -484,7 +484,7 @@ scoped_ptr<ScopedResource> GLRenderer::drawBackgroundFilters(
     int filteredDeviceBackgroundTextureId = texture->getTextureHandle();
 
     scoped_ptr<ScopedResource> backgroundTexture = ScopedResource::create(m_resourceProvider);
-    if (!backgroundTexture->Allocate(Renderer::ImplPool, quad->rect.size(), GL_RGBA, ResourceProvider::TextureUsageFramebuffer))
+    if (!backgroundTexture->Allocate(quad->rect.size(), GL_RGBA, ResourceProvider::TextureUsageFramebuffer))
         return scoped_ptr<ScopedResource>();
 
     const RenderPass* targetRenderPass = frame.currentRenderPass;
@@ -1455,7 +1455,7 @@ bool GLRenderer::getFramebufferTexture(ScopedResource* texture, const gfx::Rect&
 {
     DCHECK(!texture->id() || (texture->size() == deviceRect.size() && texture->format() == GL_RGB));
 
-    if (!texture->id() && !texture->Allocate(Renderer::ImplPool, deviceRect.size(), GL_RGB, ResourceProvider::TextureUsageAny))
+    if (!texture->id() && !texture->Allocate(deviceRect.size(), GL_RGB, ResourceProvider::TextureUsageAny))
         return false;
 
     ResourceProvider::ScopedWriteLockGL lock(m_resourceProvider, texture->id());

cc/heads_up_display_layer_impl.cc

@@ -77,7 +77,7 @@ void HeadsUpDisplayLayerImpl::willDraw(ResourceProvider* resourceProvider)
         m_hudTexture->Free();
 
     if (!m_hudTexture->id())
-        m_hudTexture->Allocate(Renderer::ImplPool, bounds(), GL_RGBA, ResourceProvider::TextureUsageAny);
+        m_hudTexture->Allocate(bounds(), GL_RGBA, ResourceProvider::TextureUsageAny);
 }
 
 void HeadsUpDisplayLayerImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& appendQuadsData)

cc/layer_tree_host.cc

@@ -153,7 +153,7 @@ void LayerTreeHost::initializeRenderer()
         maxPartialTextureUpdates = min(m_settings.maxPartialTextureUpdates, m_proxy->maxPartialTextureUpdates());
     m_settings.maxPartialTextureUpdates = maxPartialTextureUpdates;
 
-    m_contentsTextureManager = PrioritizedResourceManager::create(Renderer::ContentPool, m_proxy.get());
+    m_contentsTextureManager = PrioritizedResourceManager::create(m_proxy.get());
     m_surfaceMemoryPlaceholder = m_contentsTextureManager->createTexture(gfx::Size(), GL_RGBA);
 
     m_rendererInitialized = true;

cc/layer_tree_host_impl_unittest.cc

@@ -1051,7 +1051,7 @@ private:
         setTilingData(*tilingData.get());
         setSkipsDraw(skipsDraw);
         if (!tileMissing) {
-            ResourceProvider::ResourceId resource = resourceProvider->createResource(Renderer::ContentPool, gfx::Size(), GL_RGBA, ResourceProvider::TextureUsageAny);
+            ResourceProvider::ResourceId resource = resourceProvider->createResource(gfx::Size(), GL_RGBA, ResourceProvider::TextureUsageAny);
             pushTileProperties(0, 0, resource, gfx::Rect(), false);
         }
         if (animating)
@@ -1675,7 +1675,7 @@ private:
         , m_quadsAppended(false)
         , m_quadRect(5, 5, 5, 5)
         , m_quadVisibleRect(5, 5, 5, 5)
-        , m_resourceId(resourceProvider->createResource(Renderer::ContentPool, gfx::Size(1, 1), GL_RGBA, ResourceProvider::TextureUsageAny))
+        , m_resourceId(resourceProvider->createResource(gfx::Size(1, 1), GL_RGBA, ResourceProvider::TextureUsageAny))
     {
         setAnchorPoint(gfx::PointF(0, 0));
         setBounds(gfx::Size(10, 10));
@@ -2750,15 +2750,14 @@ public:
     void createResources(ResourceProvider* provider)
     {
         DCHECK(provider);
-        int pool = 0;
         gfx::Size size(10, 10);
         GLenum format = GL_RGBA;
         ResourceProvider::TextureUsageHint hint = ResourceProvider::TextureUsageAny;
         setScrollbarGeometry(ScrollbarGeometryFixedThumb::create(FakeWebScrollbarThemeGeometryNonEmpty::create()));
 
-        setBackTrackResourceId(provider->createResource(pool, size, format, hint));
-        setForeTrackResourceId(provider->createResource(pool, size, format, hint));
-        setThumbResourceId(provider->createResource(pool, size, format, hint));
+        setBackTrackResourceId(provider->createResource(size, format, hint));
+        setForeTrackResourceId(provider->createResource(size, format, hint));
+        setThumbResourceId(provider->createResource(size, format, hint));
     }
 
 protected:
@@ -2770,7 +2769,7 @@ protected:
 
 static inline scoped_ptr<RenderPass> createRenderPassWithResource(ResourceProvider* provider)
 {
-    ResourceProvider::ResourceId resourceId = provider->createResource(0, gfx::Size(1, 1), GL_RGBA, ResourceProvider::TextureUsageAny);
+    ResourceProvider::ResourceId resourceId = provider->createResource(gfx::Size(1, 1), GL_RGBA, ResourceProvider::TextureUsageAny);
 
     scoped_ptr<TestRenderPass> pass = TestRenderPass::Create();
     pass->SetNew(RenderPass::Id(1, 1), gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1), gfx::Transform());

cc/prioritized_resource_manager.cc

@@ -15,14 +15,13 @@ using namespace std;
 
 namespace cc {
 
-PrioritizedResourceManager::PrioritizedResourceManager(int pool, const Proxy* proxy)
+PrioritizedResourceManager::PrioritizedResourceManager(const Proxy* proxy)
     : m_proxy(proxy)
     , m_maxMemoryLimitBytes(defaultMemoryAllocationLimit())
     , m_externalPriorityCutoff(PriorityCalculator::allowEverythingCutoff())
     , m_memoryUseBytes(0)
     , m_memoryAboveCutoffBytes(0)
     , m_memoryAvailableBytes(0)
-    , m_pool(pool)
     , m_backingsTailNotSorted(false)
     , m_memoryVisibleBytes(0)
     , m_memoryVisibleAndNearbyBytes(0)
@@ -396,7 +395,7 @@ PrioritizedResource::Backing* PrioritizedResourceManager::createBacking(gfx::Siz
 {
     DCHECK(m_proxy->isImplThread() && m_proxy->isMainThreadBlocked());
     DCHECK(resourceProvider);
-    ResourceProvider::ResourceId resourceId = resourceProvider->createResource(m_pool, size, format, ResourceProvider::TextureUsageAny);
+    ResourceProvider::ResourceId resourceId = resourceProvider->createResource(size, format, ResourceProvider::TextureUsageAny);
     PrioritizedResource::Backing* backing = new PrioritizedResource::Backing(resourceId, resourceProvider, size, format);
     m_memoryUseBytes += backing->bytes();
     return backing;

cc/prioritized_resource_manager.h

@@ -38,9 +38,9 @@ class Proxy;
 
 class CC_EXPORT PrioritizedResourceManager {
 public:
-    static scoped_ptr<PrioritizedResourceManager> create(int pool, const Proxy* proxy)
+    static scoped_ptr<PrioritizedResourceManager> create(const Proxy* proxy)
     {
-        return make_scoped_ptr(new PrioritizedResourceManager(pool, proxy));
+        return make_scoped_ptr(new PrioritizedResourceManager(proxy));
     }
     scoped_ptr<PrioritizedResource> createTexture(gfx::Size size, GLenum format)
     {
@@ -152,7 +152,7 @@ private:
         return a < b;
     }
 
-    PrioritizedResourceManager(int pool, const Proxy* proxy);
+    PrioritizedResourceManager(const Proxy* proxy);
 
     bool evictBackingsToReduceMemory(size_t limitBytes,
                                      int priorityCutoff,
@@ -176,7 +176,6 @@ private:
     size_t m_memoryUseBytes;
     size_t m_memoryAboveCutoffBytes;
     size_t m_memoryAvailableBytes;
-    int m_pool;
 
     typedef base::hash_set<PrioritizedResource*> TextureSet;
     typedef std::vector<PrioritizedResource*> TextureVector;

cc/prioritized_resource_unittest.cc

@@ -39,7 +39,7 @@ public:
 
     scoped_ptr<PrioritizedResourceManager> createManager(size_t maxTextures)
     {
-        scoped_ptr<PrioritizedResourceManager> manager = PrioritizedResourceManager::create(0, &m_proxy);
+        scoped_ptr<PrioritizedResourceManager> manager = PrioritizedResourceManager::create(&m_proxy);
         manager->setMaxMemoryLimitBytes(texturesMemorySize(maxTextures));
         return manager.Pass();
     }

cc/renderer.h

@@ -32,13 +32,6 @@ protected:
 
 class CC_EXPORT Renderer {
 public:
-    // This enum defines the various resource pools for the ResourceProvider
-    // where textures get allocated.
-    enum ResourcePool {
-      ImplPool = 1, // This pool is for textures that get allocated on the impl thread (e.g. RenderSurfaces).
-      ContentPool // This pool is for textures that get allocated on the main thread (e.g. tiles).
-    };
-
     virtual ~Renderer() { }
 
     virtual const RendererCapabilities& capabilities() const = 0;

cc/resource_pool.cc

@@ -9,11 +9,9 @@
 namespace cc {
 
 ResourcePool::Resource::Resource(cc::ResourceProvider* resource_provider,
-                                 cc::Renderer::ResourcePool pool_id,
                                  const gfx::Size& size,
                                  GLenum format)
     : cc::Resource(resource_provider->createResource(
-                       pool_id,
                        size,
                        format,
                        ResourceProvider::TextureUsageAny),
@@ -29,10 +27,8 @@ ResourcePool::Resource::~Resource() {
   resource_provider_->deleteResource(id());
 }
 
-ResourcePool::ResourcePool(ResourceProvider* resource_provider,
-                           Renderer::ResourcePool pool_id)
+ResourcePool::ResourcePool(ResourceProvider* resource_provider)
     : resource_provider_(resource_provider),
-      pool_id_(pool_id),
       max_memory_usage_bytes_(0),
       memory_usage_bytes_(0) {
 }
@@ -58,7 +54,7 @@ scoped_ptr<ResourcePool::Resource> ResourcePool::AcquireResource(
 
   // Create new resource.
   Resource* resource = new Resource(
-      resource_provider_, pool_id_, size, format);
+      resource_provider_, size, format);
   memory_usage_bytes_ += resource->bytes();
   return make_scoped_ptr(resource);
 }

cc/resource_pool.h

@@ -19,7 +19,6 @@ class ResourcePool {
   class Resource : public cc::Resource {
    public:
     Resource(ResourceProvider* resource_provider,
-             Renderer::ResourcePool pool_id,
              const gfx::Size& size,
              GLenum format);
     ~Resource();
@@ -30,9 +29,8 @@ class ResourcePool {
     DISALLOW_COPY_AND_ASSIGN(Resource);
   };
 
-  static scoped_ptr<ResourcePool> Create(ResourceProvider* resource_provider,
-                                         Renderer::ResourcePool pool_id) {
-    return make_scoped_ptr(new ResourcePool(resource_provider, pool_id));
+  static scoped_ptr<ResourcePool> Create(ResourceProvider* resource_provider) {
+    return make_scoped_ptr(new ResourcePool(resource_provider));
   }
 
   virtual ~ResourcePool();
@@ -46,12 +44,10 @@ class ResourcePool {
   void SetMaxMemoryUsageBytes(size_t max_memory_usage_bytes);
 
  protected:
-  ResourcePool(ResourceProvider* resource_provider,
-               Renderer::ResourcePool pool_id);
+  ResourcePool(ResourceProvider* resource_provider);
 
  private:
   ResourceProvider* resource_provider_;
-  Renderer::ResourcePool pool_id_;
   size_t max_memory_usage_bytes_;
   size_t memory_usage_bytes_;
 

cc/resource_provider.cc

@@ -54,7 +54,6 @@ ResourceProvider::Resource::Resource()
     , glUploadQueryId(0)
     , pixels(0)
     , pixelBuffer(0)
-    , pool(0)
     , lockForReadCount(0)
     , lockedForWrite(false)
     , external(false)
@@ -68,13 +67,12 @@ ResourceProvider::Resource::Resource()
 {
 }
 
-ResourceProvider::Resource::Resource(unsigned textureId, int pool, const gfx::Size& size, GLenum format, GLenum filter)
+ResourceProvider::Resource::Resource(unsigned textureId, const gfx::Size& size, GLenum format, GLenum filter)
     : glId(textureId)
     , glPixelBufferId(0)
     , glUploadQueryId(0)
     , pixels(0)
     , pixelBuffer(0)
-    , pool(pool)
     , lockForReadCount(0)
     , lockedForWrite(false)
     , external(false)
@@ -88,13 +86,12 @@ ResourceProvider::Resource::Resource(unsigned textureId, int pool, const gfx::Si
 {
 }
 
-ResourceProvider::Resource::Resource(uint8_t* pixels, int pool, const gfx::Size& size, GLenum format, GLenum filter)
+ResourceProvider::Resource::Resource(uint8_t* pixels, const gfx::Size& size, GLenum format, GLenum filter)
     : glId(0)
     , glPixelBufferId(0)
     , glUploadQueryId(0)
     , pixels(pixels)
     , pixelBuffer(0)
-    , pool(pool)
     , lockForReadCount(0)
     , lockedForWrite(false)
     , external(false)
@@ -148,21 +145,21 @@ bool ResourceProvider::inUseByConsumer(ResourceId id)
     return !!resource->lockForReadCount || resource->exported;
 }
 
-ResourceProvider::ResourceId ResourceProvider::createResource(int pool, const gfx::Size& size, GLenum format, TextureUsageHint hint)
+ResourceProvider::ResourceId ResourceProvider::createResource(const gfx::Size& size, GLenum format, TextureUsageHint hint)
 {
     switch (m_defaultResourceType) {
     case GLTexture:
-        return createGLTexture(pool, size, format, hint);
+        return createGLTexture(size, format, hint);
     case Bitmap:
         DCHECK(format == GL_RGBA);
-        return createBitmap(pool, size);
+        return createBitmap(size);
     }
 
     LOG(FATAL) << "Invalid default resource type.";
     return 0;
 }
 
-ResourceProvider::ResourceId ResourceProvider::createGLTexture(int pool, const gfx::Size& size, GLenum format, TextureUsageHint hint)
+ResourceProvider::ResourceId ResourceProvider::createGLTexture(const gfx::Size& size, GLenum format, TextureUsageHint hint)
 {
     DCHECK_LE(size.width(), m_maxTextureSize);
     DCHECK_LE(size.height(), m_maxTextureSize);
@@ -187,19 +184,19 @@ ResourceProvider::ResourceId ResourceProvider::createGLTexture(int pool, const g
         GLC(context3d, context3d->texImage2D(GL_TEXTURE_2D, 0, format, size.width(), size.height(), 0, format, GL_UNSIGNED_BYTE, 0));
 
     ResourceId id = m_nextId++;
-    Resource resource(textureId, pool, size, format, GL_LINEAR);
+    Resource resource(textureId, size, format, GL_LINEAR);
     m_resources[id] = resource;
     return id;
 }
 
-ResourceProvider::ResourceId ResourceProvider::createBitmap(int pool, const gfx::Size& size)
+ResourceProvider::ResourceId ResourceProvider::createBitmap(const gfx::Size& size)
 {
     DCHECK(m_threadChecker.CalledOnValidThread());
 
     uint8_t* pixels = new uint8_t[size.width() * size.height() * 4];
 
     ResourceId id = m_nextId++;
-    Resource resource(pixels, pool, size, GL_RGBA, GL_LINEAR);
+    Resource resource(pixels, size, GL_RGBA, GL_LINEAR);
     m_resources[id] = resource;
     return id;
 }
@@ -217,7 +214,7 @@ ResourceProvider::ResourceId ResourceProvider::createResourceFromExternalTexture
     GLC(context3d, context3d->texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE));
 
     ResourceId id = m_nextId++;
-    Resource resource(textureId, 0, gfx::Size(), 0, GL_LINEAR);
+    Resource resource(textureId, gfx::Size(), 0, GL_LINEAR);
     resource.external = true;
     m_resources[id] = resource;
     return id;
@@ -266,18 +263,6 @@ void ResourceProvider::deleteResourceInternal(ResourceMap::iterator it)
     m_resources.erase(it);
 }
 
-void ResourceProvider::deleteOwnedResources(int pool)
-{
-    DCHECK(m_threadChecker.CalledOnValidThread());
-    ResourceIdArray toDelete;
-    for (ResourceMap::iterator it = m_resources.begin(); it != m_resources.end(); ++it) {
-        if (it->second.pool == pool && !it->second.external && !it->second.markedForDeletion)
-            toDelete.push_back(it->first);
-    }
-    for (ResourceIdArray::iterator it = toDelete.begin(); it != toDelete.end(); ++it)
-        deleteResource(*it);
-}
-
 ResourceProvider::ResourceType ResourceProvider::resourceType(ResourceId id)
 {
     ResourceMap::iterator it = m_resources.find(id);
@@ -545,22 +530,23 @@ bool ResourceProvider::initialize()
     return true;
 }
 
-int ResourceProvider::createChild(int pool)
+int ResourceProvider::createChild()
 {
     DCHECK(m_threadChecker.CalledOnValidThread());
     Child childInfo;
-    childInfo.pool = pool;
     int child = m_nextChild++;
     m_children[child] = childInfo;
     return child;
 }
 
-void ResourceProvider::destroyChild(int child)
+void ResourceProvider::destroyChild(int child_id)
 {
     DCHECK(m_threadChecker.CalledOnValidThread());
-    ChildMap::iterator it = m_children.find(child);
+    ChildMap::iterator it = m_children.find(child_id);
     DCHECK(it != m_children.end());
-    deleteOwnedResources(it->second.pool);
+    Child& child = it->second;
+    for (ResourceIdMap::iterator child_it = child.childToParentMap.begin(); child_it != child.childToParentMap.end(); ++child_it)
+        deleteResource(child_it->second);
     m_children.erase(it);
 }
 
@@ -643,7 +629,7 @@ void ResourceProvider::receiveFromChild(int child, const TransferableResourceLis
         GLC(context3d, context3d->bindTexture(GL_TEXTURE_2D, textureId));
         GLC(context3d, context3d->consumeTextureCHROMIUM(GL_TEXTURE_2D, it->mailbox.name));
         ResourceId id = m_nextId++;
-        Resource resource(textureId, childInfo.pool, it->size, it->format, it->filter);
+        Resource resource(textureId, it->size, it->format, it->filter);
         resource.mailbox.setName(it->mailbox.name);
         m_resources[id] = resource;
         childInfo.parentToChildMap[id] = it->id;

cc/resource_provider.h

@@ -40,7 +40,10 @@ 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,
@@ -67,19 +70,16 @@ public:
     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);
 
@@ -97,11 +97,10 @@ public:
     // 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.
@@ -230,8 +229,8 @@ public:
 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.
@@ -241,7 +240,6 @@ private:
         Mailbox mailbox;
         uint8_t* pixels;
         uint8_t* pixelBuffer;
-        int pool;
         int lockForReadCount;
         bool lockedForWrite;
         bool external;
@@ -259,7 +257,6 @@ private:
         Child();
         ~Child();
 
-        int pool;
         ResourceIdMap childToParentMap;
         ResourceIdMap parentToChildMap;
     };

cc/resource_provider_unittest.cc

@@ -310,11 +310,10 @@ TEST_P(ResourceProviderTest, Basic)
 {
     gfx::Size size(1, 1);
     WGC3Denum format = GL_RGBA;
-    int pool = 1;
     size_t pixelSize = textureSize(size, format);
     ASSERT_EQ(4U, pixelSize);
 
-    ResourceProvider::ResourceId id = m_resourceProvider->createResource(pool, size, format, ResourceProvider::TextureUsageAny);
+    ResourceProvider::ResourceId id = m_resourceProvider->createResource(size, format, ResourceProvider::TextureUsageAny);
     expectNumResources(1);
 
     uint8_t data[4] = {1, 2, 3, 4};
@@ -329,33 +328,14 @@ TEST_P(ResourceProviderTest, Basic)
     expectNumResources(0);
 }
 
-TEST_P(ResourceProviderTest, DeleteOwnedResources)
-{
-    gfx::Size size(1, 1);
-    WGC3Denum format = GL_RGBA;
-    int pool = 1;
-
-    const int count = 3;
-    for (int i = 0; i < count; ++i)
-        m_resourceProvider->createResource(pool, size, format, ResourceProvider::TextureUsageAny);
-    expectNumResources(3);
-
-    m_resourceProvider->deleteOwnedResources(pool+1);
-    expectNumResources(3);
-
-    m_resourceProvider->deleteOwnedResources(pool);
-    expectNumResources(0);
-}
-
 TEST_P(ResourceProviderTest, Upload)
 {
     gfx::Size size(2, 2);
     WGC3Denum format = GL_RGBA;
-    int pool = 1;
     size_t pixelSize = textureSize(size, format);
     ASSERT_EQ(16U, pixelSize);
 
-    ResourceProvider::ResourceId id = m_resourceProvider->createResource(pool, size, format, ResourceProvider::TextureUsageAny);
+    ResourceProvider::ResourceId id = m_resourceProvider->createResource(size, format, ResourceProvider::TextureUsageAny);
 
     uint8_t image[16] = {0};
     gfx::Rect imageRect(gfx::Point(), size);
@@ -422,21 +402,19 @@ TEST_P(ResourceProviderTest, TransferResources)
 
     gfx::Size size(1, 1);
     WGC3Denum format = GL_RGBA;
-    int pool = 1;
     size_t pixelSize = textureSize(size, format);
     ASSERT_EQ(4U, pixelSize);
 
-    ResourceProvider::ResourceId id1 = childResourceProvider->createResource(pool, size, format, ResourceProvider::TextureUsageAny);
+    ResourceProvider::ResourceId id1 = childResourceProvider->createResource(size, format, ResourceProvider::TextureUsageAny);
     uint8_t data1[4] = {1, 2, 3, 4};
     gfx::Rect rect(gfx::Point(), size);
     childResourceProvider->setPixels(id1, data1, rect, rect, gfx::Vector2d());
 
-    ResourceProvider::ResourceId id2 = childResourceProvider->createResource(pool, size, format, ResourceProvider::TextureUsageAny);
+    ResourceProvider::ResourceId id2 = childResourceProvider->createResource(size, format, ResourceProvider::TextureUsageAny);
     uint8_t data2[4] = {5, 5, 5, 5};
     childResourceProvider->setPixels(id2, data2, rect, rect, gfx::Vector2d());
 
-    int childPool = 2;
-    int childId = m_resourceProvider->createChild(childPool);
+    int childId = m_resourceProvider->createChild();
 
     {
         // Transfer some resources to the parent.
@@ -539,17 +517,15 @@ TEST_P(ResourceProviderTest, DeleteTransferredResources)
 
     gfx::Size size(1, 1);
     WGC3Denum format = GL_RGBA;
-    int pool = 1;
     size_t pixelSize = textureSize(size, format);
     ASSERT_EQ(4U, pixelSize);
 
-    ResourceProvider::ResourceId id = childResourceProvider->createResource(pool, size, format, ResourceProvider::TextureUsageAny);
+    ResourceProvider::ResourceId id = childResourceProvider->createResource(size, format, ResourceProvider::TextureUsageAny);
     uint8_t data[4] = {1, 2, 3, 4};
     gfx::Rect rect(gfx::Point(), size);
     childResourceProvider->setPixels(id, data, rect, rect, gfx::Vector2d());
 
-    int childPool = 2;
-    int childId = m_resourceProvider->createChild(childPool);
+    int childId = m_resourceProvider->createChild();
 
     {
         // Transfer some resource to the parent.
@@ -601,7 +577,6 @@ TEST_P(ResourceProviderTest, ScopedSampler)
 
     gfx::Size size(1, 1);
     WGC3Denum format = GL_RGBA;
-    int pool = 1;
     int textureId = 1;
 
     // Check that the texture gets created with the right sampler settings.
@@ -610,7 +585,7 @@ TEST_P(ResourceProviderTest, ScopedSampler)
     EXPECT_CALL(*context, texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
     EXPECT_CALL(*context, texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE));
     EXPECT_CALL(*context, texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE));
-    ResourceProvider::ResourceId id = resourceProvider->createResource(pool, size, format, ResourceProvider::TextureUsageAny);
+    ResourceProvider::ResourceId id = resourceProvider->createResource(size, format, ResourceProvider::TextureUsageAny);
 
     // Creating a sampler with the default filter should not change any texture
     // parameters.

cc/resource_update_controller_unittest.cc

@@ -65,7 +65,7 @@ public:
     ResourceUpdateControllerTest()
         : m_proxy(scoped_ptr<Thread>(NULL))
         , m_queue(make_scoped_ptr(new ResourceUpdateQueue))
-        , m_resourceManager(PrioritizedResourceManager::create(Renderer::ContentPool, &m_proxy))
+        , m_resourceManager(PrioritizedResourceManager::create(&m_proxy))
         , m_fullUploadCountExpected(0)
         , m_partialCountExpected(0)
         , m_totalUploadCountExpected(0)

cc/scoped_resource.cc

@@ -15,13 +15,13 @@ ScopedResource::~ScopedResource() {
   Free();
 }
 
-bool ScopedResource::Allocate(int pool, const gfx::Size& size, GLenum format,
+bool ScopedResource::Allocate(const gfx::Size& size, GLenum format,
                               ResourceProvider::TextureUsageHint hint) {
   DCHECK(!id());
   DCHECK(!size.IsEmpty());
 
   set_dimensions(size, format);
-  set_id(resource_provider_->createResource(pool, size, format, hint));
+  set_id(resource_provider_->createResource(size, format, hint));
 
 #ifndef NDEBUG
   allocate_thread_id_ = base::PlatformThread::CurrentId();

cc/scoped_resource.h

@@ -25,7 +25,7 @@ class CC_EXPORT ScopedResource : public Resource {
   }
   virtual ~ScopedResource();
 
-  bool Allocate(int pool, const gfx::Size&, GLenum format,
+  bool Allocate(const gfx::Size&, GLenum format,
                 ResourceProvider::TextureUsageHint);
   void Free();
   void Leak();

cc/scoped_resource_unittest.cc

@@ -34,7 +34,7 @@ TEST(ScopedResourceTest, CreateScopedResource)
     scoped_ptr<OutputSurface> context(createFakeOutputSurface());
     scoped_ptr<ResourceProvider> resourceProvider(ResourceProvider::create(context.get()));
     scoped_ptr<ScopedResource> texture = ScopedResource::create(resourceProvider.get());
-    texture->Allocate(Renderer::ImplPool, gfx::Size(30, 30), GL_RGBA, ResourceProvider::TextureUsageAny);
+    texture->Allocate(gfx::Size(30, 30), GL_RGBA, ResourceProvider::TextureUsageAny);
 
     // The texture has an allocated byte-size now.
     size_t expectedBytes = 30 * 30 * 4;
@@ -54,7 +54,7 @@ TEST(ScopedResourceTest, ScopedResourceIsDeleted)
         scoped_ptr<ScopedResource> texture = ScopedResource::create(resourceProvider.get());
 
         EXPECT_EQ(0u, resourceProvider->numResources());
-        texture->Allocate(Renderer::ImplPool, gfx::Size(30, 30), GL_RGBA, ResourceProvider::TextureUsageAny);
+        texture->Allocate(gfx::Size(30, 30), GL_RGBA, ResourceProvider::TextureUsageAny);
         EXPECT_LT(0u, texture->id());
         EXPECT_EQ(1u, resourceProvider->numResources());
     }
@@ -64,7 +64,7 @@ TEST(ScopedResourceTest, ScopedResourceIsDeleted)
     {
         scoped_ptr<ScopedResource> texture = ScopedResource::create(resourceProvider.get());
         EXPECT_EQ(0u, resourceProvider->numResources());
-        texture->Allocate(Renderer::ImplPool, gfx::Size(30, 30), GL_RGBA, ResourceProvider::TextureUsageAny);
+        texture->Allocate(gfx::Size(30, 30), GL_RGBA, ResourceProvider::TextureUsageAny);
         EXPECT_LT(0u, texture->id());
         EXPECT_EQ(1u, resourceProvider->numResources());
         texture->Free();
@@ -81,7 +81,7 @@ TEST(ScopedResourceTest, LeakScopedResource)
         scoped_ptr<ScopedResource> texture = ScopedResource::create(resourceProvider.get());
 
         EXPECT_EQ(0u, resourceProvider->numResources());
-        texture->Allocate(Renderer::ImplPool, gfx::Size(30, 30), GL_RGBA, ResourceProvider::TextureUsageAny);
+        texture->Allocate(gfx::Size(30, 30), GL_RGBA, ResourceProvider::TextureUsageAny);
         EXPECT_LT(0u, texture->id());
         EXPECT_EQ(1u, resourceProvider->numResources());
 

cc/software_renderer_unittest.cc

@@ -110,8 +110,8 @@ TEST_F(SoftwareRendererTest, tileQuad)
     setViewportSize(outerSize);
     initializeRenderer();
 
-    ResourceProvider::ResourceId resourceYellow = resourceProvider()->createResource(1, outerSize, GL_RGBA, ResourceProvider::TextureUsageAny);
-    ResourceProvider::ResourceId resourceCyan = resourceProvider()->createResource(1, innerSize, GL_RGBA, ResourceProvider::TextureUsageAny);
+    ResourceProvider::ResourceId resourceYellow = resourceProvider()->createResource(outerSize, GL_RGBA, ResourceProvider::TextureUsageAny);
+    ResourceProvider::ResourceId resourceCyan = resourceProvider()->createResource(innerSize, GL_RGBA, ResourceProvider::TextureUsageAny);
 
     SkColor yellow = SK_ColorYELLOW;
     SkColor cyan = SK_ColorCYAN;

cc/tile_manager.cc

@@ -136,8 +136,7 @@ TileManager::TileManager(
     ResourceProvider* resource_provider,
     size_t num_raster_threads)
     : client_(client),
-      resource_pool_(ResourcePool::Create(resource_provider,
-                                          Renderer::ImplPool)),
+      resource_pool_(ResourcePool::Create(resource_provider)),
       manage_tiles_pending_(false),
       manage_tiles_call_count_(0),
       check_for_completed_set_pixels_pending_(false) {

cc/tiled_layer_unittest.cc

@@ -59,7 +59,7 @@ public:
     {
         m_layerTreeHost = LayerTreeHost::create(&m_fakeLayerImplTreeHostClient, m_settings, scoped_ptr<Thread>(NULL));
         m_proxy = m_layerTreeHost->proxy();
-        m_resourceManager = PrioritizedResourceManager::create(Renderer::ContentPool, m_proxy);
+        m_resourceManager = PrioritizedResourceManager::create(m_proxy);
         m_layerTreeHost->initializeRendererIfNeeded();
         DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked(m_proxy);
         m_resourceProvider = ResourceProvider::create(m_outputSurface.get());

cc/video_layer_impl.cc

@@ -316,7 +316,7 @@ bool VideoLayerImpl::FramePlane::allocateData(
     if (resourceId)
         return true;
 
-    resourceId = resourceProvider->createResource(Renderer::ImplPool, size, format, ResourceProvider::TextureUsageAny);
+    resourceId = resourceProvider->createResource(size, format, ResourceProvider::TextureUsageAny);
     return resourceId;
 }