cc: Remove wtf hashmap from damage tracker

cc/damage_tracker.cc

 // 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 "CCDamageTracker.h"
 
@@ skipping 133 matching lines @@
     m_currentDamageRect.uniteIfNonZero(damageRectForThisUpdate);
 
     // The next history map becomes the current map for the next frame. Note this must
     // happen every frame to correctly track changes, even if damage accumulates over
     // multiple frames before actually being drawn.
     swap(m_currentRectHistory, m_nextRectHistory);
 }
 
 FloatRect CCDamageTracker::removeRectFromCurrentFrame(int layerID, bool& layerIsNew)
 {
-    layerIsNew = !m_currentRectHistory->contains(layerID);
+    RectMap::iterator iter = m_currentRectHistory->find(layerID);
+    layerIsNew = iter == m_currentRectHistory->end();
+    if (layerIsNew)
+        return FloatRect();
 
-    // take() will remove the entry from the map, or if not found, return a default (empty) rect.
-    return m_currentRectHistory->take(layerID);
+    FloatRect ret = iter->second;
+    m_currentRectHistory->erase(iter);
+    return ret;
 }
 
 void CCDamageTracker::saveRectForNextFrame(int layerID, const FloatRect& targetSpaceRect)
 {
     // This layer should not yet exist in next frame's history.
     ASSERT(layerID > 0);
     ASSERT(m_nextRectHistory->find(layerID) == m_nextRectHistory->end());
-    m_nextRectHistory->set(layerID, targetSpaceRect);
+    (*m_nextRectHistory)[layerID] = targetSpaceRect;
 }
 
 FloatRect CCDamageTracker::trackDamageFromActiveLayers(const std::vector<CCLayerImpl*>& layerList, int targetSurfaceLayerID)
 {
     FloatRect damageRect = FloatRect();
 
     for (unsigned layerIndex = 0; layerIndex < layerList.size(); ++layerIndex) {
         // Visit layers in back-to-front order.
         CCLayerImpl* layer = layerList[layerIndex];
 
@@ skipping 24 matching lines @@
 
 FloatRect CCDamageTracker::trackDamageFromLeftoverRects()
 {
     // After computing damage for all active layers, any leftover items in the current
     // rect history correspond to layers/surfaces that no longer exist. So, these regions
     // are now exposed on the target surface.
 
     FloatRect damageRect = FloatRect();
 
     for (RectMap::iterator it = m_currentRectHistory->begin(); it != m_currentRectHistory->end(); ++it)
-#if WTF_NEW_HASHMAP_ITERATORS_INTERFACE
-        damageRect.unite(it->value);
-#else
         damageRect.unite(it->second);
-#endif
 
     m_currentRectHistory->clear();
 
     return damageRect;
 }
 
 static bool layerNeedsToRedrawOntoItsTargetSurface(CCLayerImpl* layer)
 {
     // If the layer does NOT own a surface but has SurfacePropertyChanged,
     // this means that its target surface is affected and needs to be redrawn.
@@ skipping 115 matching lines @@
     // at or below this layer. We expand the damage from this layer too, as we need to readback those pixels from the surface with only
     // the contents of layers below this one in them. This means we need to redraw any pixels in the surface being used for the blur in
     // this layer this frame.
     if (layer->backgroundFilters().hasFilterThatMovesPixels())
         expandDamageRectInsideRectWithFilters(targetDamageRect, surfaceRectInTargetSpace, layer->backgroundFilters());
 }
 
 }  // namespace cc
 
 #endif // USE(ACCELERATED_COMPOSITING)