cc: Add asynchronous setPixel interface.

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 32 matching lines @@
 }
 
 static bool isTextureFormatSupportedForStorage(GLenum format)
 {
     return (format == GL_RGBA || format == GL_BGRA_EXT);
 }
 
 ResourceProvider::Resource::Resource()
     : glId(0)
     , glPixelBufferId(0)
+    , glUploadQueryId(0)
     , pixels(0)
     , pixelBuffer(0)
     , pool(0)
     , lockForReadCount(0)
     , lockedForWrite(false)
     , external(false)
     , exported(false)
     , markedForDeletion(false)
+    , pendingSetPixels(false)
     , size()
     , format(0)
     , filter(0)
     , type(static_cast<ResourceType>(0))
 {
 }
 
 ResourceProvider::Resource::Resource(unsigned textureId, int pool, 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)
     , exported(false)
     , markedForDeletion(false)
+    , pendingSetPixels(false)
     , size(size)
     , format(format)
     , filter(filter)
     , type(GLTexture)
 {
 }
 
 ResourceProvider::Resource::Resource(uint8_t* pixels, int pool, 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)
     , exported(false)
     , markedForDeletion(false)
+    , pendingSetPixels(false)
     , size(size)
     , format(format)
     , filter(filter)
     , type(Bitmap)
 {
 }
 
 ResourceProvider::Child::Child()
 {
 }
@@ skipping 127 matching lines @@
 }
 
 void ResourceProvider::deleteResourceInternal(ResourceMap::iterator it)
 {
     Resource* resource = &it->second;
     if (resource->glId && !resource->external) {
         WebGraphicsContext3D* context3d = m_outputSurface->context3D();
         DCHECK(context3d);
         GLC(context3d, context3d->deleteTexture(resource->glId));
     }
+    if (resource->glUploadQueryId) {
+        WebGraphicsContext3D* context3d = m_outputSurface->context3D();
+        DCHECK(context3d);
+        GLC(context3d, context3d->deleteQueryEXT(resource->glUploadQueryId));
+    }
     if (resource->glPixelBufferId) {
         WebGraphicsContext3D* context3d = m_outputSurface->context3D();
         DCHECK(context3d);
         GLC(context3d, context3d->deleteBuffer(resource->glPixelBufferId));
     }
     if (resource->pixels)
         delete[] resource->pixels;
     if (resource->pixelBuffer)
         delete[] resource->pixelBuffer;
 
@@ skipping 607 matching lines @@
     DCHECK(!resource->lockedForWrite);
 
     GLC(context3d, context3d->bindTexture(target, resource->glId));
     if (filter != resource->filter) {
         GLC(context3d, context3d->texParameteri(target, GL_TEXTURE_MIN_FILTER, filter));
         GLC(context3d, context3d->texParameteri(target, GL_TEXTURE_MAG_FILTER, filter));
         resource->filter = filter;
     }
 }
 
+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);
+
+    lockForWrite(id);
+
+    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);
+        if (!resource->glUploadQueryId)
+            resource->glUploadQueryId = context3d->createQueryEXT();
+        context3d->beginQueryEXT(
+            GL_ASYNC_PIXEL_TRANSFERS_COMPLETED_CHROMIUM,
+            resource->glUploadQueryId);
+        context3d->asyncTexSubImage2DCHROMIUM(GL_TEXTURE_2D,
+                                              0, /* level */
+                                              0, /* x */
+                                              0, /* y */
+                                              resource->size.width(),
+                                              resource->size.height(),
+                                              resource->format,
+                                              GL_UNSIGNED_BYTE,
+                                              NULL);
+        context3d->endQueryEXT(GL_ASYNC_PIXEL_TRANSFERS_COMPLETED_CHROMIUM);
+        context3d->bindBuffer(GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM, 0);
+    }
+
+    if (resource->pixels)
+      setPixelsFromBuffer(id);
+
+    resource->pendingSetPixels = true;
+}
+
+bool ResourceProvider::didSetPixelsComplete(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->pendingSetPixels);
+
+    if (resource->glId) {
+        WebGraphicsContext3D* context3d = m_outputSurface->context3D();
+        DCHECK(context3d);
+        DCHECK(resource->glUploadQueryId);
+        unsigned complete = 1;
+        context3d->getQueryObjectuivEXT(
+            resource->glUploadQueryId,
+            GL_QUERY_RESULT_AVAILABLE_EXT,
+            &complete);
+        if (!complete)
+            return false;
+    }
+
+    resource->pendingSetPixels = false;
+    unlockForWrite(id);
+
+    return true;
+}
+
 }  // namespace cc