Switch cc to std::unordered_*.

cc/tiles/image_decode_controller.h

 // Copyright 2015 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.
 
 #ifndef CC_TILES_IMAGE_DECODE_CONTROLLER_H_
 #define CC_TILES_IMAGE_DECODE_CONTROLLER_H_
 
 #include <stdint.h>
 
-#include "base/containers/hash_tables.h"
+#include <unordered_map>
+#include <unordered_set>
+
 #include "base/hash.h"
 #include "base/memory/discardable_memory_allocator.h"
 #include "base/memory/ref_counted.h"
 #include "base/numerics/safe_math.h"
 #include "base/threading/thread_checker.h"
 #include "cc/base/cc_export.h"
 #include "cc/playback/decoded_draw_image.h"
 #include "cc/playback/draw_image.h"
 #include "cc/raster/tile_task_runner.h"
 #include "skia/ext/refptr.h"
-
 #include "ui/gfx/transform.h"
 
 namespace cc {
 
 // ImageDecodeControllerKey is a class that gets a cache key out of a given draw
 // image. That is, this key uniquely identifies an image in the cache. Note that
 // it's insufficient to use SkImage's unique id, since the same image can appear
 // in the cache multiple times at different scales and filter qualities.
 class CC_EXPORT ImageDecodeControllerKey {
  public:
@@ skipping 31 matching lines @@
                            const gfx::Rect& src_rect,
                            const gfx::Size& size,
                            SkFilterQuality filter_quality);
 
   uint32_t image_id_;
   gfx::Rect src_rect_;
   gfx::Size target_size_;
   SkFilterQuality filter_quality_;
 };
 
-}  // namespace cc
-
 // Hash function for the above ImageDecodeControllerKey.
-namespace BASE_HASH_NAMESPACE {
-template <>
-struct hash<cc::ImageDecodeControllerKey> {
-  size_t operator()(const cc::ImageDecodeControllerKey& key) const {
+struct ImageDecodeControllerKeyHash {
+  size_t operator()(const ImageDecodeControllerKey& key) const {
     // TODO(vmpstr): This is a mess. Maybe it's faster to just search the vector
     // always (forwards or backwards to account for LRU).
     uint64_t src_rect_hash =
         base::HashInts(static_cast<uint64_t>(base::HashInts(
                            key.src_rect().x(), key.src_rect().y())),
                        static_cast<uint64_t>(base::HashInts(
                            key.src_rect().width(), key.src_rect().height())));
 
     uint64_t target_size_hash =
         base::HashInts(key.target_size().width(), key.target_size().height());
 
     return base::HashInts(base::HashInts(src_rect_hash, target_size_hash),
                           base::HashInts(key.image_id(), key.filter_quality()));
   }
 };
-}  // namespace BASE_HASH_NAMESPACE
-
-namespace cc {
 
 // ImageDecodeController is responsible for generating decode tasks, decoding
 // images, storing images in cache, and being able to return the decoded images
 // when requested.
 
 // ImageDecodeController is responsible for the following things:
 // 1. Given a DrawImage, it can return an ImageDecodeTask which when run will
 //    decode and cache the resulting image. If the image does not need a task to
 //    be decoded, then nullptr will be returned. The return value of the
 //    function indicates whether the image was or is going to be locked, so an
 //    unlock will be required.
 // 2. Given a cache key and a DrawImage, it can decode the image and store it in
 //    the cache. Note that it is important that this function is only accessed
 //    via an image decode task.
 // 3. Given a DrawImage, it can return a DecodedDrawImage, which represented the
 //    decoded version of the image. Note that if the image is not in the cache
 //    and it needs to be scaled/decoded, then this decode will happen as part of
 //    getting the image. As such, this should only be accessed from a raster
 //    thread.
 class CC_EXPORT ImageDecodeController {
  public:
   using ImageKey = ImageDecodeControllerKey;
+  using ImageKeyHash = ImageDecodeControllerKeyHash;
 
   ImageDecodeController();
   ~ImageDecodeController();
 
   // Fill in an ImageDecodeTask which will decode the given image when run. In
   // case the image is already cached, fills in nullptr. Returns true if the
   // image needs to be unreffed when the caller is finished with it.
   //
   // This is called by the tile manager (on the compositor thread) when creating
   // a raster task.
@@ skipping 99 matching lines @@
   // These functions indicate whether the images can be handled and cached by
   // ImageDecodeController or whether they will fall through to Skia (with
   // exception of possibly prerolling them). Over time these should return
   // "false" in less cases, as the ImageDecodeController should start handling
   // more of them.
   bool CanHandleImage(const ImageKey& key, const DrawImage& image);
   bool CanHandleFilterQuality(SkFilterQuality filter_quality);
 
   bool is_using_gpu_rasterization_;
 
-  base::hash_map<ImageKey, scoped_refptr<ImageDecodeTask>> pending_image_tasks_;
+  std::unordered_map<ImageKey, scoped_refptr<ImageDecodeTask>, ImageKeyHash>
+      pending_image_tasks_;
 
   // The members below this comment can only be accessed if the lock is held to
   // ensure that they are safe to access on multiple threads.
   base::Lock lock_;
 
   std::deque<AnnotatedDecodedImage> decoded_images_;
-  base::hash_map<ImageKey, int> decoded_images_ref_counts_;
+  std::unordered_map<ImageKey, int, ImageKeyHash> decoded_images_ref_counts_;
   std::deque<AnnotatedDecodedImage> at_raster_decoded_images_;
-  base::hash_map<ImageKey, int> at_raster_decoded_images_ref_counts_;
+  std::unordered_map<ImageKey, int, ImageKeyHash>
+      at_raster_decoded_images_ref_counts_;
   MemoryBudget locked_images_budget_;
 
   // Note that this is used for cases where the only thing we do is preroll the
   // image the first time we see it. This mimics the previous behavior and
   // should over time change as the compositor starts to handle more cases.
-  base::hash_set<uint32_t> prerolled_images_;
+  std::unordered_set<uint32_t> prerolled_images_;
 };
 
 }  // namespace cc
 
 #endif  // CC_TILES_IMAGE_DECODE_CONTROLLER_H_