cc: Enforce correct recycling in resource pool.

cc/resource_provider.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/resource_provider.h"
 
 #include <limits.h>
 
 #include "base/debug/alias.h"
 #include "base/hash_tables.h"
@@ skipping 43 matching lines @@
     , glUploadQueryId(0)
     , pixels(0)
     , pixelBuffer(0)
     , lockForReadCount(0)
     , lockedForWrite(false)
     , external(false)
     , exported(false)
     , markedForDeletion(false)
     , pendingSetPixels(false)
     , allocated(false)
+    , enableReadLockFences(false)
+    , readLockFence(NULL)
     , size()
     , format(0)
     , filter(0)
     , type(static_cast<ResourceType>(0))
 {
 }
 
 ResourceProvider::Resource::~Resource()
 {
 }
 
 ResourceProvider::Resource::Resource(unsigned textureId, const gfx::Size& size, GLenum format, GLenum filter)
     : glId(textureId)
     , glPixelBufferId(0)
     , glUploadQueryId(0)
     , pixels(0)
     , pixelBuffer(0)
     , lockForReadCount(0)
     , lockedForWrite(false)
     , external(false)
     , exported(false)
     , markedForDeletion(false)
     , pendingSetPixels(false)
     , allocated(false)
+    , enableReadLockFences(false)
+    , readLockFence(NULL)
     , size(size)
     , format(format)
     , filter(filter)
     , type(GLTexture)
 {
 }
 
 ResourceProvider::Resource::Resource(uint8_t* pixels, const gfx::Size& size, GLenum format, GLenum filter)
     : glId(0)
     , glPixelBufferId(0)
     , glUploadQueryId(0)
     , pixels(pixels)
     , pixelBuffer(0)
     , lockForReadCount(0)
     , lockedForWrite(false)
     , external(false)
     , exported(false)
     , markedForDeletion(false)
     , pendingSetPixels(false)
     , allocated(false)
+    , enableReadLockFences(false)
+    , readLockFence(NULL)
     , size(size)
     , format(format)
     , filter(filter)
     , type(Bitmap)
 {
 }
 
 ResourceProvider::Child::Child()
 {
 }
@@ skipping 203 matching lines @@
 void ResourceProvider::setPixels(ResourceId id, const uint8_t* image, const gfx::Rect& imageRect, const gfx::Rect& sourceRect, const gfx::Vector2d& destOffset)
 {
     DCHECK(m_threadChecker.CalledOnValidThread());
     ResourceMap::iterator it = m_resources.find(id);
     CHECK(it != m_resources.end());
     Resource* resource = &it->second;
     DCHECK(!resource->lockedForWrite);
     DCHECK(!resource->lockForReadCount);
     DCHECK(!resource->external);
     DCHECK(!resource->exported);
+    DCHECK(readLockFenceHasPassed(resource));
     lazyAllocate(resource);
 
     if (resource->glId) {
         DCHECK(!resource->pendingSetPixels);
         WebGraphicsContext3D* context3d = m_outputSurface->Context3D();
         DCHECK(context3d);
         DCHECK(m_textureUploader.get());
         context3d->bindTexture(GL_TEXTURE_2D, resource->glId);
         m_textureUploader->upload(image,
                                   imageRect,
@@ skipping 87 matching lines @@
         if (resource->mailbox.sync_point()) {
             GLC(context3d, context3d->waitSyncPoint(resource->mailbox.sync_point()));
             resource->mailbox.ResetSyncPoint();
         }
         resource->glId = context3d->createTexture();
         GLC(context3d, context3d->bindTexture(GL_TEXTURE_2D, resource->glId));
         GLC(context3d, context3d->consumeTextureCHROMIUM(GL_TEXTURE_2D, resource->mailbox.data()));
     }
 
     resource->lockForReadCount++;
+    if (resource->enableReadLockFences)
+        resource->readLockFence = m_currentReadLockFence;
+
     return resource;
 }
 
 void ResourceProvider::unlockForRead(ResourceId id)
 {
     DCHECK(m_threadChecker.CalledOnValidThread());
     ResourceMap::iterator it = m_resources.find(id);
     CHECK(it != m_resources.end());
     Resource* resource = &it->second;
     DCHECK(resource->lockForReadCount > 0);
     DCHECK(!resource->exported);
     resource->lockForReadCount--;
 }
 
 const ResourceProvider::Resource* ResourceProvider::lockForWrite(ResourceId id)
 {
     DCHECK(m_threadChecker.CalledOnValidThread());
     ResourceMap::iterator it = m_resources.find(id);
     CHECK(it != m_resources.end());
     Resource* resource = &it->second;
     DCHECK(!resource->lockedForWrite);
     DCHECK(!resource->lockForReadCount);
     DCHECK(!resource->exported);
     DCHECK(!resource->external);
+    DCHECK(readLockFenceHasPassed(resource));
     lazyAllocate(resource);
 
     resource->lockedForWrite = true;
     return resource;
 }
 
+bool ResourceProvider::canLockForWrite(ResourceId id)
+{
+    DCHECK(m_threadChecker.CalledOnValidThread());
+    ResourceMap::iterator it = m_resources.find(id);
+    CHECK(it != m_resources.end());
+    Resource* resource = &it->second;
+    return !resource->lockedForWrite &&
+           !resource->lockForReadCount &&
+           !resource->exported &&
+           !resource->external &&
+           readLockFenceHasPassed(resource);
+}
+
 void ResourceProvider::unlockForWrite(ResourceId id)
 {
     DCHECK(m_threadChecker.CalledOnValidThread());
     ResourceMap::iterator it = m_resources.find(id);
     CHECK(it != m_resources.end());
     Resource* resource = &it->second;
     DCHECK(resource->lockedForWrite);
     DCHECK(!resource->exported);
     DCHECK(!resource->external);
     resource->lockedForWrite = false;
@@ skipping 401 matching lines @@
 void ResourceProvider::setPixelsFromBuffer(ResourceId id)
 {
     DCHECK(m_threadChecker.CalledOnValidThread());
     ResourceMap::iterator it = m_resources.find(id);
     CHECK(it != m_resources.end());
     Resource* resource = &it->second;
     DCHECK(!resource->lockedForWrite);
     DCHECK(!resource->lockForReadCount);
     DCHECK(!resource->external);
     DCHECK(!resource->exported);
+    DCHECK(readLockFenceHasPassed(resource));
     lazyAllocate(resource);
 
     if (resource->glId) {
         WebGraphicsContext3D* context3d = m_outputSurface->Context3D();
         DCHECK(context3d);
         DCHECK(resource->glPixelBufferId);
         context3d->bindTexture(GL_TEXTURE_2D, resource->glId);
         context3d->bindBuffer(
             GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM,
             resource->glPixelBufferId);
@@ skipping 43 matching lines @@
 }
 
 void ResourceProvider::beginSetPixels(ResourceId id)
 {
     DCHECK(m_threadChecker.CalledOnValidThread());
     ResourceMap::iterator it = m_resources.find(id);
     CHECK(it != m_resources.end());
     Resource* resource = &it->second;
     DCHECK(!resource->pendingSetPixels);
     DCHECK(resource->glId || resource->allocated);
+    DCHECK(readLockFenceHasPassed(resource));
 
     bool allocate = !resource->allocated;
     resource->allocated = true;
     lockForWrite(id);
 
     if (resource->glId) {
         WebGraphicsContext3D* context3d = m_outputSurface->Context3D();
         DCHECK(context3d);
         DCHECK(resource->glPixelBufferId);
         context3d->bindTexture(GL_TEXTURE_2D, resource->glId);
@@ skipping 69 matching lines @@
     Resource* resource = &it->second;
     lazyAllocate(resource);
 }
 
 void ResourceProvider::lazyAllocate(Resource* resource) {
     DCHECK(resource);
     DCHECK(resource->glId || resource->allocated);
 
     if (resource->allocated || !resource->glId)
         return;
-
     resource->allocated = true;
     WebGraphicsContext3D* context3d = m_outputSurface->Context3D();
     gfx::Size& size = resource->size;
     GLenum format = resource->format;
     GLC(context3d, context3d->bindTexture(GL_TEXTURE_2D, resource->glId));
     if (m_useTextureStorageExt && isTextureFormatSupportedForStorage(format)) {
         GLenum storageFormat = textureToStorageFormat(format);
         GLC(context3d, context3d->texStorage2DEXT(GL_TEXTURE_2D, 1, storageFormat, size.width(), size.height()));
     } else
         GLC(context3d, context3d->texImage2D(GL_TEXTURE_2D, 0, format, size.width(), size.height(), 0, format, GL_UNSIGNED_BYTE, 0));
 }
 
+void ResourceProvider::enableReadLockFences(ResourceProvider::ResourceId id, bool enable) {
+    DCHECK(m_threadChecker.CalledOnValidThread());
+    ResourceMap::iterator it = m_resources.find(id);
+    CHECK(it != m_resources.end());
+    Resource* resource = &it->second;
+    resource->enableReadLockFences = enable;
+}
 
 }  // namespace cc