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

cc/TiledLayerChromium.cpp

 // Copyright 2011 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"
 
 #if USE(ACCELERATED_COMPOSITING)
 
 #include "TiledLayerChromium.h"
 
@@ skipping 185 matching lines @@
     LayerChromium::pushPropertiesTo(layer);
 
     CCTiledLayerImpl* tiledLayer = static_cast<CCTiledLayerImpl*>(layer);
 
     tiledLayer->setSkipsDraw(m_skipsDraw);
     tiledLayer->setContentsSwizzled(m_sampledTexelFormat != LayerTextureUpdater::SampledTexelFormatRGBA);
     tiledLayer->setTilingData(*m_tiler);
     Vector<UpdatableTile*> invalidTiles;
 
     for (CCLayerTilingData::TileMap::const_iterator iter = m_tiler->tiles().begin(); iter != m_tiler->tiles().end(); ++iter) {
+#if WTF_NEW_HASHMAP_ITERATORS_INTERFACE
+        int i = iter->key.first;
+        int j = iter->key.second;
+        UpdatableTile* tile = static_cast<UpdatableTile*>(iter->value.get());
+#else
         int i = iter->first.first;
         int j = iter->first.second;
         UpdatableTile* tile = static_cast<UpdatableTile*>(iter->second.get());
+#endif
         // FIXME: This should not ever be null.
         if (!tile)
             continue;
         tile->isInUseOnImpl = false;
         if (!tile->managedTexture()->haveBackingTexture()) {
             invalidTiles.append(tile);
             continue;
         }
         if (!tile->validForFrame)
             continue;
 
         tiledLayer->pushTileProperties(i, j, tile->managedTexture()->resourceId(), tile->opaqueRect());
         tile->isInUseOnImpl = true;
     }
     for (Vector<UpdatableTile*>::const_iterator iter = invalidTiles.begin(); iter != invalidTiles.end(); ++iter)
         m_tiler->takeTile((*iter)->i(), (*iter)->j());
 }
 
 CCPrioritizedTextureManager* TiledLayerChromium::textureManager() const
 {
     if (!layerTreeHost())
         return 0;
     return layerTreeHost()->contentsTextureManager();
 }
 
 void TiledLayerChromium::setLayerTreeHost(CCLayerTreeHost* host)
 {
     if (host && host != layerTreeHost()) {
         for (CCLayerTilingData::TileMap::const_iterator iter = m_tiler->tiles().begin(); iter != m_tiler->tiles().end(); ++iter) {
+#if WTF_NEW_HASHMAP_ITERATORS_INTERFACE
+            UpdatableTile* tile = static_cast<UpdatableTile*>(iter->value.get());
+#else
             UpdatableTile* tile = static_cast<UpdatableTile*>(iter->second.get());
+#endif
             // FIXME: This should not ever be null.
             if (!tile)
                 continue;
             tile->managedTexture()->setTextureManager(host->contentsTextureManager());
         }
     }
     LayerChromium::setLayerTreeHost(host);
 }
 
 UpdatableTile* TiledLayerChromium::tileAt(int i, int j) const
@@ skipping 47 matching lines @@
     setBorderTexelOption(borderTexelOption);
 }
 
 void TiledLayerChromium::invalidateContentRect(const IntRect& contentRect)
 {
     updateBounds();
     if (m_tiler->isEmpty() || contentRect.isEmpty() || m_skipsDraw)
         return;
 
     for (CCLayerTilingData::TileMap::const_iterator iter = m_tiler->tiles().begin(); iter != m_tiler->tiles().end(); ++iter) {
+#if WTF_NEW_HASHMAP_ITERATORS_INTERFACE
+        UpdatableTile* tile = static_cast<UpdatableTile*>(iter->value.get());
+#else
         UpdatableTile* tile = static_cast<UpdatableTile*>(iter->second.get());
+#endif
         ASSERT(tile);
         // FIXME: This should not ever be null.
         if (!tile)
             continue;
         IntRect bound = m_tiler->tileRect(tile);
         bound.intersect(contentRect);
         tile->dirtyRect.unite(bound);
     }
 }
 
@@ skipping 308 matching lines @@
                                                                                         backBuffer->texture()->format());
                 // Swap backBuffer into frontBuffer and add it to delete after commit queue.
                 backBuffer->swapTextureWith(frontBuffer);
                 layerTreeHost()->deleteTextureAfterCommit(frontBuffer.release());
             }
         }
     }
 
     // Now update priorities on all tiles we have in the layer, no matter where they are.
     for (CCLayerTilingData::TileMap::const_iterator iter = m_tiler->tiles().begin(); iter != m_tiler->tiles().end(); ++iter) {
+#if WTF_NEW_HASHMAP_ITERATORS_INTERFACE
+        UpdatableTile* tile = static_cast<UpdatableTile*>(iter->value.get());
+#else
         UpdatableTile* tile = static_cast<UpdatableTile*>(iter->second.get());
+#endif
         // FIXME: This should not ever be null.
         if (!tile)
             continue;
         IntRect tileRect = m_tiler->tileRect(tile);
         setPriorityForTexture(visibleContentRect(), tileRect, drawsToRoot, smallAnimatedLayer, tile->managedTexture());
     }
 }
 
 Region TiledLayerChromium::visibleContentOpaqueRegion() const
 {
     if (m_skipsDraw)
         return Region();
     if (opaque())
         return visibleContentRect();
     return m_tiler->opaqueRegionInContentRect(visibleContentRect());
 }
 
 void TiledLayerChromium::resetUpdateState()
 {
     m_skipsDraw = false;
     m_failedUpdate = false;
 
     CCLayerTilingData::TileMap::const_iterator end = m_tiler->tiles().end();
     for (CCLayerTilingData::TileMap::const_iterator iter = m_tiler->tiles().begin(); iter != end; ++iter) {
+#if WTF_NEW_HASHMAP_ITERATORS_INTERFACE
+        UpdatableTile* tile = static_cast<UpdatableTile*>(iter->value.get());
+#else
         UpdatableTile* tile = static_cast<UpdatableTile*>(iter->second.get());
+#endif
         // FIXME: This should not ever be null.
         if (!tile)
             continue;
         tile->resetUpdateState();
     }
 }
 
 void TiledLayerChromium::update(CCTextureUpdateQueue& queue, const CCOcclusionTracker* occlusion, CCRenderingStats& stats)
 {
     ASSERT(!m_skipsDraw && !m_failedUpdate); // Did resetUpdateState get skipped?
@@ skipping 109 matching lines @@
     prepaintRect.inflateX(m_tiler->tileSize().width());
     prepaintRect.inflateY(m_tiler->tileSize().height() * 2);
     IntRect contentRect(IntPoint::zero(), contentBounds());
     prepaintRect.intersect(contentRect);
 
     return prepaintRect;
 }
 
 }
 #endif // USE(ACCELERATED_COMPOSITING)