Cosmetic cleanup to texture_layer mailboxes.

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 223 matching lines @@
     GLC(context3d, context3d->texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE));
 
     ResourceId id = m_nextId++;
     Resource resource(textureId, gfx::Size(), 0, GL_LINEAR);
     resource.external = true;
     resource.allocated = true;
     m_resources[id] = resource;
     return id;
 }
 
-ResourceProvider::ResourceId ResourceProvider::createResourceFromTextureMailbox(const std::string& mailbox, const base::Callback<void(unsigned)>& releaseCallback)
+ResourceProvider::ResourceId ResourceProvider::createResourceFromTextureMailbox(const TextureMailbox& mailbox)
 {
     DCHECK(m_threadChecker.CalledOnValidThread());
     // Just store the information. Mailbox will be consumed in lockForRead().
     ResourceId id = m_nextId++;
     unsigned textureId = 0;
     Resource resource(textureId, gfx::Size(), 0, GL_LINEAR);
     resource.external = true;
     resource.allocated = true;
-    resource.mailbox.setName(reinterpret_cast<const int8*>(mailbox.data()));
-    resource.mailboxReleaseCallback = releaseCallback;
+    resource.mailbox = mailbox;
     m_resources[id] = resource;
     return id;
 }
 
 void ResourceProvider::deleteResource(ResourceId id)
 {
     DCHECK(m_threadChecker.CalledOnValidThread());
     ResourceMap::iterator it = m_resources.find(id);
     CHECK(it != m_resources.end());
     Resource* resource = &it->second;
@@ skipping 19 matching lines @@
     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->mailbox.isZero() && resource->external) {
+    if (!resource->mailbox.IsEmpty() && resource->external) {
         WebGraphicsContext3D* context3d = m_outputSurface->Context3D();
         DCHECK(context3d);
         unsigned syncPoint = 0;
         if (resource->glId) {
             GLC(context3d, context3d->bindTexture(GL_TEXTURE_2D, resource->glId));
-            GLC(context3d, context3d->produceTextureCHROMIUM(GL_TEXTURE_2D, resource->mailbox.name));
+            GLC(context3d, context3d->produceTextureCHROMIUM(GL_TEXTURE_2D, resource->mailbox.data()));
             GLC(context3d, context3d->deleteTexture(resource->glId));
             syncPoint = context3d->insertSyncPoint();
         }
-        if (!resource->mailboxReleaseCallback.is_null())
-            resource->mailboxReleaseCallback.Run(syncPoint);
+        resource->mailbox.RunReleaseCallback(syncPoint);
     }
     if (resource->pixels)
         delete[] resource->pixels;
     if (resource->pixelBuffer)
         delete[] resource->pixelBuffer;
 
     m_resources.erase(it);
 }
 
 ResourceProvider::ResourceType ResourceProvider::resourceType(ResourceId id)
@@ skipping 101 matching lines @@
 const ResourceProvider::Resource* ResourceProvider::lockForRead(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->allocated); // Uninitialized! Call setPixels or lockForWrite first.
 
-    if (!resource->glId && resource->external && !resource->mailbox.isZero()) {
+    if (!resource->glId && resource->external && !resource->mailbox.IsEmpty()) {
         WebGraphicsContext3D* context3d = m_outputSurface->Context3D();
         DCHECK(context3d);
         resource->glId = context3d->createTexture();
         GLC(context3d, context3d->bindTexture(GL_TEXTURE_2D, resource->glId));
-        GLC(context3d, context3d->consumeTextureCHROMIUM(GL_TEXTURE_2D, resource->mailbox.name));
+        GLC(context3d, context3d->consumeTextureCHROMIUM(GL_TEXTURE_2D, resource->mailbox.data()));
     }
 
     resource->lockForReadCount++;
     return resource;
 }
 
 void ResourceProvider::unlockForRead(ResourceId id)
 {
     DCHECK(m_threadChecker.CalledOnValidThread());
     ResourceMap::iterator it = m_resources.find(id);
@@ skipping 244 matching lines @@
         GLC(context3d, context3d->waitSyncPoint(resources.sync_point));
     }
     Child& childInfo = m_children.find(child)->second;
     for (TransferableResourceArray::const_iterator it = resources.resources.begin(); it != resources.resources.end(); ++it) {
         unsigned textureId;
         GLC(context3d, textureId = context3d->createTexture());
         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, it->size, it->format, it->filter);
-        resource.mailbox.setName(it->mailbox.name);
+        resource.mailbox.SetName(it->mailbox.name);
         // Don't allocate a texture for a child.
         resource.allocated = true;
         m_resources[id] = resource;
         childInfo.parentToChildMap[id] = it->id;
         childInfo.childToParentMap[it->id] = id;
     }
 }
 
 void ResourceProvider::receiveFromParent(const TransferableResourceList& resources)
 {
     DCHECK(m_threadChecker.CalledOnValidThread());
     WebGraphicsContext3D* context3d = m_outputSurface->Context3D();
     if (!context3d || !context3d->makeContextCurrent()) {
         // FIXME: Implement this path for software compositing.
         return;
     }
     if (resources.sync_point)
         GLC(context3d, context3d->waitSyncPoint(resources.sync_point));
     for (TransferableResourceArray::const_iterator it = resources.resources.begin(); it != resources.resources.end(); ++it) {
         ResourceMap::iterator mapIterator = m_resources.find(it->id);
         DCHECK(mapIterator != m_resources.end());
         Resource* resource = &mapIterator->second;
         DCHECK(resource->exported);
         resource->exported = false;
-        resource->mailbox.setName(it->mailbox.name);
+        resource->mailbox.SetName(it->mailbox.name);
         GLC(context3d, context3d->bindTexture(GL_TEXTURE_2D, resource->glId));
         GLC(context3d, context3d->consumeTextureCHROMIUM(GL_TEXTURE_2D, it->mailbox.name));
         if (resource->markedForDeletion)
             deleteResourceInternal(mapIterator);
     }
 }
 
 bool ResourceProvider::transferResource(WebGraphicsContext3D* context, ResourceId id, TransferableResource* resource)
 {
     DCHECK(m_threadChecker.CalledOnValidThread());
     WebGraphicsContext3D* context3d = m_outputSurface->Context3D();
     ResourceMap::iterator it = m_resources.find(id);
     CHECK(it != m_resources.end());
     Resource* source = &it->second;
     DCHECK(!source->lockedForWrite);
     DCHECK(!source->lockForReadCount);
-    DCHECK(!source->external || (source->external && !source->mailbox.isZero()));
+    DCHECK(!source->external || (source->external && !source->mailbox.IsEmpty()));
     DCHECK(source->allocated);
     if (source->exported)
         return false;
     resource->id = id;
     resource->format = source->format;
     resource->filter = source->filter;
     resource->size = source->size;
 
-    if (source->mailbox.isZero()) {
+    if (source->mailbox.IsEmpty()) {
       GLbyte name[GL_MAILBOX_SIZE_CHROMIUM];
       GLC(context3d, context3d->genMailboxCHROMIUM(name));
-      source->mailbox.setName(name);
+      source->mailbox.SetName(name);
     }
 
-    resource->mailbox = source->mailbox;
+    resource->mailbox = source->mailbox.name();
     GLC(context, context->bindTexture(GL_TEXTURE_2D, source->glId));
     GLC(context, context->produceTextureCHROMIUM(GL_TEXTURE_2D, resource->mailbox.name));
     return true;
 }
 
 void ResourceProvider::acquirePixelBuffer(ResourceId id)
 {
     DCHECK(m_threadChecker.CalledOnValidThread());
     ResourceMap::iterator it = m_resources.find(id);
     CHECK(it != m_resources.end());
@@ skipping 280 matching lines @@
     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));
 }
 
 
 }  // namespace cc