Switch cc to std::unordered_*.

cc/resources/resource_provider.h

 // 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.
 
 #ifndef CC_RESOURCES_RESOURCE_PROVIDER_H_
 #define CC_RESOURCES_RESOURCE_PROVIDER_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <deque>
 #include <set>
 #include <string>
+#include <unordered_map>
+#include <unordered_set>
 #include <utility>
 #include <vector>
 
 #include "base/callback.h"
-#include "base/containers/hash_tables.h"
 #include "base/macros.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/threading/thread_checker.h"
 #include "base/trace_event/memory_allocator_dump.h"
 #include "base/trace_event/memory_dump_provider.h"
 #include "cc/base/cc_export.h"
 #include "cc/base/resource_id.h"
 #include "cc/output/context_provider.h"
 #include "cc/output/output_surface.h"
@@ skipping 32 matching lines @@
 class SharedBitmapManager;
 
 // This class is not thread-safe and can only be called from the thread it was
 // created on (in practice, the impl thread).
 class CC_EXPORT ResourceProvider
     : public base::trace_event::MemoryDumpProvider {
  private:
   struct Resource;
 
  public:
-  typedef std::vector<ResourceId> ResourceIdArray;
-  typedef base::hash_set<ResourceId> ResourceIdSet;
-  typedef base::hash_map<ResourceId, ResourceId> ResourceIdMap;
+  using ResourceIdArray = std::vector<ResourceId>;
+  using ResourceIdSet = std::unordered_set<ResourceId>;
+  using ResourceIdMap = std::unordered_map<ResourceId, ResourceId>;
   enum TextureHint {
     TEXTURE_HINT_DEFAULT = 0x0,
     TEXTURE_HINT_IMMUTABLE = 0x1,
     TEXTURE_HINT_FRAMEBUFFER = 0x2,
     TEXTURE_HINT_IMMUTABLE_FRAMEBUFFER =
         TEXTURE_HINT_IMMUTABLE | TEXTURE_HINT_FRAMEBUFFER
   };
   enum ResourceType {
     RESOURCE_TYPE_GPU_MEMORY_BUFFER,
     RESOURCE_TYPE_GL_TEXTURE,
@@ skipping 410 matching lines @@
     GLenum filter;
     unsigned image_id;
     unsigned bound_image_id;
     TextureHint hint;
     ResourceType type;
     ResourceFormat format;
     SharedBitmapId shared_bitmap_id;
     SharedBitmap* shared_bitmap;
     gfx::GpuMemoryBuffer* gpu_memory_buffer;
   };
-  typedef base::hash_map<ResourceId, Resource> ResourceMap;
+  using ResourceMap = std::unordered_map<ResourceId, Resource>;
 
   struct Child {
     Child();
     ~Child();
 
     ResourceIdMap child_to_parent_map;
     ResourceIdMap parent_to_child_map;
     ReturnCallback return_callback;
     bool marked_for_deletion;
     bool needs_sync_tokens;
   };
-  typedef base::hash_map<int, Child> ChildMap;
+  using ChildMap = std::unordered_map<int, Child>;
 
   bool ReadLockFenceHasPassed(const Resource* resource) {
     return !resource->read_lock_fence.get() ||
            resource->read_lock_fence->HasPassed();
   }
 
   ResourceId CreateGLTexture(const gfx::Size& size,
                              TextureHint hint,
                              ResourceType type,
                              ResourceFormat format);
@@ skipping 70 matching lines @@
   // A process-unique ID used for disambiguating memory dumps from different
   // resource providers.
   int tracing_id_;
 
   DISALLOW_COPY_AND_ASSIGN(ResourceProvider);
 };
 
 }  // namespace cc
 
 #endif  // CC_RESOURCES_RESOURCE_PROVIDER_H_