cc: Optimize the tile map key hash for 4-byte size_t.

cc/tiles/picture_layer_tiling.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/tiles/picture_layer_tiling.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 #include <set>
@@ skipping 103 matching lines @@
   tile->set_tiling_index(i, j);
   tiles_.add(key, tile.Pass());
   return raw_ptr;
 }
 
 void PictureLayerTiling::CreateMissingTilesInLiveTilesRect() {
   bool include_borders = false;
   for (TilingData::Iterator iter(&tiling_data_, live_tiles_rect_,
                                  include_borders);
        iter; ++iter) {
-    TileMapKey key = iter.index();
+    TileMapKey key(iter.index());
     TileMap::iterator find = tiles_.find(key);
     if (find != tiles_.end())
       continue;
 
-    if (ShouldCreateTileAt(key.first, key.second))
-      CreateTile(key.first, key.second);
+    if (ShouldCreateTileAt(key.index_x, key.index_y))
+      CreateTile(key.index_x, key.index_y);
   }
   VerifyLiveTilesRect(false);
 }
 
 void PictureLayerTiling::TakeTilesAndPropertiesFrom(
     PictureLayerTiling* pending_twin,
     const Region& layer_invalidation) {
   TRACE_EVENT0("cc", "TakeTilesAndPropertiesFrom");
   SetRasterSourceAndResize(pending_twin->raster_source_);
 
@@ skipping 138 matching lines @@
     if (content_rect.IsEmpty())
       continue;
     // Since the content_rect includes border pixels already, don't include
     // borders when iterating to avoid double counting them.
     bool include_borders = false;
     for (
         TilingData::Iterator iter(&tiling_data_, content_rect, include_borders);
         iter; ++iter) {
       if (RemoveTileAt(iter.index_x(), iter.index_y())) {
         if (recreate_tiles)
-          new_tile_keys.push_back(iter.index());
+          new_tile_keys.push_back(TileMapKey(iter.index()));
       }
     }
   }
 
   for (const auto& key : new_tile_keys)
-    CreateTile(key.first, key.second);
+    CreateTile(key.index_x, key.index_y);
 }
 
 bool PictureLayerTiling::ShouldCreateTileAt(int i, int j) const {
   // Active tree should always create a tile. The reason for this is that active
   // tree represents content that we draw on screen, which means that whenever
   // we check whether a tile should exist somewhere, the answer is yes. This
   // doesn't mean it will actually be created (if raster source doesn't cover
   // the tile for instance). Pending tree, on the other hand, should only be
   // creating tiles that are different from the current active tree, which is
   // represented by the logic in the rest of the function.
@@ skipping 345 matching lines @@
                                            new_live_tiles_rect);
        iter; ++iter) {
     RemoveTileAt(iter.index_x(), iter.index_y());
   }
 
   // Iterate to allocate new tiles for all regions with newly exposed area.
   for (TilingData::DifferenceIterator iter(&tiling_data_, new_live_tiles_rect,
                                            live_tiles_rect_);
        iter; ++iter) {
     TileMapKey key(iter.index());
-    if (ShouldCreateTileAt(key.first, key.second))
-      CreateTile(key.first, key.second);
+    if (ShouldCreateTileAt(key.index_x, key.index_y))
+      CreateTile(key.index_x, key.index_y);
   }
 
   live_tiles_rect_ = new_live_tiles_rect;
   VerifyLiveTilesRect(false);
 }
 
 void PictureLayerTiling::VerifyLiveTilesRect(bool is_on_recycle_tree) const {
 #if DCHECK_IS_ON()
   for (auto it = tiles_.begin(); it != tiles_.end(); ++it) {
     if (!it->second)
       continue;
-    DCHECK(it->first.first < tiling_data_.num_tiles_x())
-        << this << " " << it->first.first << "," << it->first.second
-        << " num_tiles_x " << tiling_data_.num_tiles_x() << " live_tiles_rect "
+    TileMapKey key = it->first;
+    DCHECK(key.index_x < tiling_data_.num_tiles_x())
+        << this << " " << key.index_x << "," << key.index_y << " num_tiles_x "
+        << tiling_data_.num_tiles_x() << " live_tiles_rect "
         << live_tiles_rect_.ToString();
-    DCHECK(it->first.second < tiling_data_.num_tiles_y())
-        << this << " " << it->first.first << "," << it->first.second
-        << " num_tiles_y " << tiling_data_.num_tiles_y() << " live_tiles_rect "
+    DCHECK(key.index_y < tiling_data_.num_tiles_y())
+        << this << " " << key.index_x << "," << key.index_y << " num_tiles_y "
+        << tiling_data_.num_tiles_y() << " live_tiles_rect "
         << live_tiles_rect_.ToString();
-    DCHECK(tiling_data_.TileBounds(it->first.first, it->first.second)
+    DCHECK(tiling_data_.TileBounds(key.index_x, key.index_y)
                .Intersects(live_tiles_rect_))
-        << this << " " << it->first.first << "," << it->first.second
-        << " tile bounds "
-        << tiling_data_.TileBounds(it->first.first, it->first.second).ToString()
+        << this << " " << key.index_x << "," << key.index_y << " tile bounds "
+        << tiling_data_.TileBounds(key.index_x, key.index_y).ToString()
         << " live_tiles_rect " << live_tiles_rect_.ToString();
   }
 #endif
 }
 
 bool PictureLayerTiling::IsTileOccluded(const Tile* tile) const {
   // If this tile is not occluded on this tree, then it is not occluded.
   if (!IsTileOccludedOnCurrentTree(tile))
     return false;
 
@@ skipping 374 matching lines @@
       break;
   }
 
   gfx::Rect result(origin_x, origin_y, width, height);
   if (cache)
     cache->previous_result = result;
   return result;
 }
 
 }  // namespace cc