Make cc's use of WTF::HashMap robust to key/value change

cc/CCResourceProvider.cpp

 // 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 "config.h"
 
 #include "CCResourceProvider.h"
 #ifdef LOG
 #undef LOG
 #endif
@@ skipping 51 matching lines @@
 {
     ASSERT(CCProxy::isImplThread());
     return m_context->context3D();
 }
 
 bool CCResourceProvider::inUseByConsumer(ResourceId id)
 {
     ASSERT(CCProxy::isImplThread());
     ResourceMap::iterator it = m_resources.find(id);
     ASSERT(it != m_resources.end());
-    return !!it->second.lockForReadCount || it->second.exported;
+#if WTF_NEW_HASHMAP_ITERATORS_INTERFACE
+    Resource* resource = &it->value;
+#else
+    Resource* resource = &it->second;
+#endif
+    return !!resource->lockForReadCount || resource->exported;
 }
 
 CCResourceProvider::ResourceId CCResourceProvider::createResource(int pool, const IntSize& size, GC3Denum format, TextureUsageHint hint)
 {
     switch (m_defaultResourceType) {
     case GLTexture:
         return createGLTexture(pool, size, format, hint);
     case Bitmap:
         ASSERT(format == GraphicsContext3D::RGBA);
         return createBitmap(pool, size);
@@ skipping 50 matching lines @@
     resource.external = true;
     m_resources.add(id, resource);
     return id;
 }
 
 void CCResourceProvider::deleteResource(ResourceId id)
 {
     ASSERT(CCProxy::isImplThread());
     ResourceMap::iterator it = m_resources.find(id);
     ASSERT(it != m_resources.end());
-    ASSERT(!it->second.lockedForWrite);
-    ASSERT(!it->second.lockForReadCount);
+#if WTF_NEW_HASHMAP_ITERATORS_INTERFACE
+    Resource* resource = &it->value;
+#else
+    Resource* resource = &it->second;
+#endif
+    ASSERT(!resource->lockedForWrite);
+    ASSERT(!resource->lockForReadCount);
 
-    if (it->second.glId && !it->second.external) {
+    if (resource->glId && !resource->external) {
         WebGraphicsContext3D* context3d = m_context->context3D();
         ASSERT(context3d);
-        GLC(context3d, context3d->deleteTexture(it->second.glId));
+        GLC(context3d, context3d->deleteTexture(resource->glId));
     }
-    if (it->second.pixels)
-        delete it->second.pixels;
+    if (resource->pixels)
+        delete resource->pixels;
 
     m_resources.remove(it);
 }
 
 void CCResourceProvider::deleteOwnedResources(int pool)
 {
     ASSERT(CCProxy::isImplThread());
     ResourceIdArray toDelete;
     for (ResourceMap::iterator it = m_resources.begin(); it != m_resources.end(); ++it) {
+#if WTF_NEW_HASHMAP_ITERATORS_INTERFACE
+        if (it->value.pool == pool && !it->value.external)
+            toDelete.append(it->key);
+#else
         if (it->second.pool == pool && !it->second.external)
             toDelete.append(it->first);
+#endif
     }
     for (ResourceIdArray::iterator it = toDelete.begin(); it != toDelete.end(); ++it)
         deleteResource(*it);
 }
 
 CCResourceProvider::ResourceType CCResourceProvider::resourceType(ResourceId id)
 {
     ResourceMap::iterator it = m_resources.find(id);
     ASSERT(it != m_resources.end());
-    return it->second.type;
+#if WTF_NEW_HASHMAP_ITERATORS_INTERFACE
+    Resource* resource = &it->value;
+#else
+    Resource* resource = &it->second;
+#endif
+    return resource->type;
 }
 
 void CCResourceProvider::upload(ResourceId id, const uint8_t* image, const IntRect& imageRect, const IntRect& sourceRect, const IntSize& destOffset)
 {
     ASSERT(CCProxy::isImplThread());
     ResourceMap::iterator it = m_resources.find(id);
     ASSERT(it != m_resources.end());
-    ASSERT(!it->second.lockedForWrite);
-    ASSERT(!it->second.lockForReadCount);
-    ASSERT(!it->second.external);
+#if WTF_NEW_HASHMAP_ITERATORS_INTERFACE
+    Resource* resource = &it->value;
+#else
+    Resource* resource = &it->second;
+#endif
+    ASSERT(!resource->lockedForWrite);
+    ASSERT(!resource->lockForReadCount);
+    ASSERT(!resource->external);
 
-    if (it->second.glId) {
+    if (resource->glId) {
         WebGraphicsContext3D* context3d = m_context->context3D();
         ASSERT(context3d);
         ASSERT(m_texSubImage.get());
-        context3d->bindTexture(GraphicsContext3D::TEXTURE_2D, it->second.glId);
-        m_texSubImage->upload(image, imageRect, sourceRect, destOffset, it->second.format, context3d);
+        context3d->bindTexture(GraphicsContext3D::TEXTURE_2D, resource->glId);
+        m_texSubImage->upload(image, imageRect, sourceRect, destOffset, resource->format, context3d);
     }
 
-    if (it->second.pixels) {
+    if (resource->pixels) {
         SkBitmap srcFull;
         srcFull.setConfig(SkBitmap::kARGB_8888_Config, imageRect.width(), imageRect.height());
         srcFull.setPixels(const_cast<uint8_t*>(image));
         SkBitmap srcSubset;
         SkIRect skSourceRect = SkIRect::MakeXYWH(sourceRect.x(), sourceRect.y(), sourceRect.width(), sourceRect.height());
         skSourceRect.offset(-imageRect.x(), -imageRect.y());
         srcFull.extractSubset(&srcSubset, skSourceRect);
 
         ScopedWriteLockSoftware lock(this, id);
         SkCanvas* dest = lock.skCanvas();
@@ skipping 18 matching lines @@
 
     context3d->shallowFlushCHROMIUM();
     return true;
 }
 
 const CCResourceProvider::Resource* CCResourceProvider::lockForRead(ResourceId id)
 {
     ASSERT(CCProxy::isImplThread());
     ResourceMap::iterator it = m_resources.find(id);
     ASSERT(it != m_resources.end());
-    ASSERT(!it->second.lockedForWrite);
-    it->second.lockForReadCount++;
-    return &it->second;
+#if WTF_NEW_HASHMAP_ITERATORS_INTERFACE
+    Resource* resource = &it->value;
+#else
+    Resource* resource = &it->second;
+#endif
+    ASSERT(!resource->lockedForWrite);
+    resource->lockForReadCount++;
+    return resource;
 }
 
 void CCResourceProvider::unlockForRead(ResourceId id)
 {
     ASSERT(CCProxy::isImplThread());
     ResourceMap::iterator it = m_resources.find(id);
     ASSERT(it != m_resources.end());
-    ASSERT(it->second.lockForReadCount > 0);
-    it->second.lockForReadCount--;
+#if WTF_NEW_HASHMAP_ITERATORS_INTERFACE
+    Resource* resource = &it->value;
+#else
+    Resource* resource = &it->second;
+#endif
+    ASSERT(resource->lockForReadCount > 0);
+    resource->lockForReadCount--;
 }
 
 const CCResourceProvider::Resource* CCResourceProvider::lockForWrite(ResourceId id)
 {
     ASSERT(CCProxy::isImplThread());
     ResourceMap::iterator it = m_resources.find(id);
     ASSERT(it != m_resources.end());
-    ASSERT(!it->second.lockedForWrite);
-    ASSERT(!it->second.lockForReadCount);
-    ASSERT(!it->second.external);
-    it->second.lockedForWrite = true;
-    return &it->second;
+#if WTF_NEW_HASHMAP_ITERATORS_INTERFACE
+    Resource* resource = &it->value;
+#else
+    Resource* resource = &it->second;
+#endif
+    ASSERT(!resource->lockedForWrite);
+    ASSERT(!resource->lockForReadCount);
+    ASSERT(!resource->external);
+    resource->lockedForWrite = true;
+    return resource;
 }
 
 void CCResourceProvider::unlockForWrite(ResourceId id)
 {
     ASSERT(CCProxy::isImplThread());
     ResourceMap::iterator it = m_resources.find(id);
     ASSERT(it != m_resources.end());
-    ASSERT(it->second.lockedForWrite);
-    ASSERT(!it->second.external);
-    it->second.lockedForWrite = false;
+#if WTF_NEW_HASHMAP_ITERATORS_INTERFACE
+    Resource* resource = &it->value;
+#else
+    Resource* resource = &it->second;
+#endif
+    ASSERT(resource->lockedForWrite);
+    ASSERT(!resource->external);
+    resource->lockedForWrite = false;
 }
 
 CCResourceProvider::ScopedReadLockGL::ScopedReadLockGL(CCResourceProvider* resourceProvider, CCResourceProvider::ResourceId resourceId)
     : m_resourceProvider(resourceProvider)
     , m_resourceId(resourceId)
     , m_textureId(resourceProvider->lockForRead(resourceId)->glId)
 {
     ASSERT(m_textureId);
 }
 
@@ skipping 101 matching lines @@
     int child = m_nextChild++;
     m_children.add(child, childInfo);
     return child;
 }
 
 void CCResourceProvider::destroyChild(int child)
 {
     ASSERT(CCProxy::isImplThread());
     ChildMap::iterator it = m_children.find(child);
     ASSERT(it != m_children.end());
+#if WTF_NEW_HASHMAP_ITERATORS_INTERFACE
+    deleteOwnedResources(it->value.pool);
+#else
     deleteOwnedResources(it->second.pool);
+#endif
     m_children.remove(it);
     trimMailboxDeque();
 }
 
 const CCResourceProvider::ResourceIdMap& CCResourceProvider::getChildToParentMap(int child) const
 {
     ASSERT(CCProxy::isImplThread());
     ChildMap::const_iterator it = m_children.find(child);
     ASSERT(it != m_children.end());
+#if WTF_NEW_HASHMAP_ITERATORS_INTERFACE
+    return it->value.childToParentMap;
+#else
     return it->second.childToParentMap;
+#endif
 }
 
 CCResourceProvider::TransferableResourceList CCResourceProvider::prepareSendToParent(const ResourceIdArray& resources)
 {
     ASSERT(CCProxy::isImplThread());
     TransferableResourceList list;
     list.syncPoint = 0;
     WebGraphicsContext3D* context3d = m_context->context3D();
     if (!context3d || !context3d->makeContextCurrent()) {
         // FIXME: Implement this path for software compositing.
         return list;
     }
     for (ResourceIdArray::const_iterator it = resources.begin(); it != resources.end(); ++it) {
         TransferableResource resource;
         if (transferResource(context3d, *it, &resource)) {
+#if WTF_NEW_HASHMAP_ITERATORS_INTERFACE
+            m_resources.find(*it)->value.exported = true;
+#else
             m_resources.find(*it)->second.exported = true;
+#endif
             list.resources.append(resource);
         }
     }
     if (list.resources.size())
         list.syncPoint = context3d->insertSyncPoint();
     return list;
 }
 
 CCResourceProvider::TransferableResourceList CCResourceProvider::prepareSendToChild(int child, const ResourceIdArray& resources)
 {
     ASSERT(CCProxy::isImplThread());
     TransferableResourceList list;
     list.syncPoint = 0;
     WebGraphicsContext3D* context3d = m_context->context3D();
     if (!context3d || !context3d->makeContextCurrent()) {
         // FIXME: Implement this path for software compositing.
         return list;
     }
+#if WTF_NEW_HASHMAP_ITERATORS_INTERFACE
+    Child& childInfo = m_children.find(child)->value;
+#else
     Child& childInfo = m_children.find(child)->second;
+#endif
     for (ResourceIdArray::const_iterator it = resources.begin(); it != resources.end(); ++it) {
         TransferableResource resource;
         if (!transferResource(context3d, *it, &resource))
             ASSERT_NOT_REACHED();
         resource.id = childInfo.parentToChildMap.get(*it);
         childInfo.parentToChildMap.remove(*it);
         childInfo.childToParentMap.remove(resource.id);
         list.resources.append(resource);
         deleteResource(*it);
     }
@@ skipping 12 matching lines @@
     }
     if (resources.syncPoint) {
         // NOTE: If the parent is a browser and the child a renderer, the parent
         // is not supposed to have its context wait, because that could induce
         // deadlocks and/or security issues. The caller is responsible for
         // waiting asynchronously, and resetting syncPoint before calling this.
         // However if the parent is a renderer (e.g. browser tag), it may be ok
         // (and is simpler) to wait.
         GLC(context3d, context3d->waitSyncPoint(resources.syncPoint));
     }
+#if WTF_NEW_HASHMAP_ITERATORS_INTERFACE
+    Child& childInfo = m_children.find(child)->value;
+#else
     Child& childInfo = m_children.find(child)->second;
+#endif
     for (Vector<TransferableResource>::const_iterator it = resources.resources.begin(); it != resources.resources.end(); ++it) {
         unsigned textureId;
         GLC(context3d, textureId = context3d->createTexture());
         GLC(context3d, context3d->bindTexture(GraphicsContext3D::TEXTURE_2D, textureId));
         GLC(context3d, context3d->consumeTextureCHROMIUM(GraphicsContext3D::TEXTURE_2D, it->mailbox.name));
         ResourceId id = m_nextId++;
         Resource resource(textureId, childInfo.pool, it->size, it->format);
         m_resources.add(id, resource);
         m_mailboxes.append(it->mailbox);
         childInfo.parentToChildMap.add(id, it->id);
         childInfo.childToParentMap.add(it->id, id);
     }
 }
 
 void CCResourceProvider::receiveFromParent(const TransferableResourceList& resources)
 {
     ASSERT(CCProxy::isImplThread());
     WebGraphicsContext3D* context3d = m_context->context3D();
     if (!context3d || !context3d->makeContextCurrent()) {
         // FIXME: Implement this path for software compositing.
         return;
     }
     if (resources.syncPoint)
         GLC(context3d, context3d->waitSyncPoint(resources.syncPoint));
     for (Vector<TransferableResource>::const_iterator it = resources.resources.begin(); it != resources.resources.end(); ++it) {
-        Resource& resource = m_resources.find(it->id)->second;
-        ASSERT(resource.exported);
-        resource.exported = false;
-        GLC(context3d, context3d->bindTexture(GraphicsContext3D::TEXTURE_2D, resource.glId));
+#if WTF_NEW_HASHMAP_ITERATORS_INTERFACE
+        Resource* resource = &m_resources.find(it->id)->value;
+#else
+        Resource* resource = &m_resources.find(it->id)->second;
+#endif
+        ASSERT(resource->exported);
+        resource->exported = false;
+        GLC(context3d, context3d->bindTexture(GraphicsContext3D::TEXTURE_2D, resource->glId));
         GLC(context3d, context3d->consumeTextureCHROMIUM(GraphicsContext3D::TEXTURE_2D, it->mailbox.name));
         m_mailboxes.append(it->mailbox);
     }
 }
 
 bool CCResourceProvider::transferResource(WebGraphicsContext3D* context, ResourceId id, TransferableResource* resource)
 {
     ASSERT(CCProxy::isImplThread());
     ResourceMap::const_iterator it = m_resources.find(id);
     ASSERT(it != m_resources.end());
-    ASSERT(!it->second.lockedForWrite);
-    ASSERT(!it->second.lockForReadCount);
-    ASSERT(!it->second.external);
-    if (it->second.exported)
+#if WTF_NEW_HASHMAP_ITERATORS_INTERFACE
+    const Resource* source = &it->value;
+#else
+    const Resource* source = &it->second;
+#endif
+    ASSERT(!source->lockedForWrite);
+    ASSERT(!source->lockForReadCount);
+    ASSERT(!source->external);
+    if (source->exported)
         return false;
     resource->id = id;
-    resource->format = it->second.format;
-    resource->size = it->second.size;
+    resource->format = source->format;
+    resource->size = source->size;
     if (!m_mailboxes.isEmpty())
         resource->mailbox = m_mailboxes.takeFirst();
     else
         GLC(context, context->genMailboxCHROMIUM(resource->mailbox.name));
-    GLC(context, context->bindTexture(GraphicsContext3D::TEXTURE_2D, it->second.glId));
+    GLC(context, context->bindTexture(GraphicsContext3D::TEXTURE_2D, source->glId));
     GLC(context, context->produceTextureCHROMIUM(GraphicsContext3D::TEXTURE_2D, resource->mailbox.name));
     return true;
 }
 
 void CCResourceProvider::trimMailboxDeque()
 {
     // Trim the mailbox deque to the maximum number of resources we may need to
     // send.
     // If we have a parent, any non-external resource not already transfered is
     // eligible to be sent to the parent. Otherwise, all resources belonging to
     // a child might need to be sent back to the child.
     size_t maxMailboxCount = 0;
     if (m_context->capabilities().hasParentCompositor) {
         for (ResourceMap::iterator it = m_resources.begin(); it != m_resources.end(); ++it) {
+#if WTF_NEW_HASHMAP_ITERATORS_INTERFACE
+            if (!it->value.exported && !it->value.external)
+#else
             if (!it->second.exported && !it->second.external)
+#endif
                 ++maxMailboxCount;
         }
     } else {
         HashSet<int> childPoolSet;
         for (ChildMap::iterator it = m_children.begin(); it != m_children.end(); ++it)
+#if WTF_NEW_HASHMAP_ITERATORS_INTERFACE
+            childPoolSet.add(it->value.pool);
+#else
             childPoolSet.add(it->second.pool);
+#endif
         for (ResourceMap::iterator it = m_resources.begin(); it != m_resources.end(); ++it) {
+#if WTF_NEW_HASHMAP_ITERATORS_INTERFACE
+            if (childPoolSet.contains(it->value.pool))
+#else
             if (childPoolSet.contains(it->second.pool))
+#endif
                 ++maxMailboxCount;
         }
     }
     while (m_mailboxes.size() > maxMailboxCount)
         m_mailboxes.removeFirst();
 }
 
 }