Align base::hash_map with C++11.

tools/gn/unique_vector.h

 // Copyright 2014 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 TOOLS_GN_UNIQUE_VECTOR_H_
 #define TOOLS_GN_UNIQUE_VECTOR_H_
 
 #include <algorithm>
 
 #include "base/containers/hash_tables.h"
@@ skipping 45 matching lines @@
         index_(i),
         hash_val_(hash_value) {
   }
 
   const T& value() const { return value_ ? *value_ : (*vect_)[index_]; }
   size_t hash_val() const { return hash_val_; }
   size_t index() const { return index_; }
 
  private:
   void FillHashValue() {
-#if defined(COMPILER_GCC)
     BASE_HASH_NAMESPACE::hash<T> h;
     hash_val_ = h(value());
-#elif defined(COMPILER_MSVC)
-    hash_val_ = BASE_HASH_NAMESPACE::hash_value(value());
-#else
-    #error write me
-#endif  // COMPILER...
   }
 
   // When non-null, points to the object.
   const T* value_;
 
   // When value is null these are used.
   const std::vector<T>* vect_;
   size_t index_;
 
   size_t hash_val_;
 };
 
 template<typename T> inline bool operator==(const UniquifyRef<T>& a,
                                             const UniquifyRef<T>& b) {
   return a.value() == b.value();
 }
 
 template<typename T> inline bool operator<(const UniquifyRef<T>& a,
                                            const UniquifyRef<T>& b) {
   return a.value() < b.value();
 }
 
 }  // namespace internal
 
 namespace BASE_HASH_NAMESPACE {
 
-#if defined(COMPILER_GCC)
 template<typename T> struct hash< internal::UniquifyRef<T> > {
   std::size_t operator()(const internal::UniquifyRef<T>& v) const {
     return v.hash_val();
   }
 };
-#elif defined(COMPILER_MSVC)
-template<typename T>
-inline size_t hash_value(const internal::UniquifyRef<T>& v) {
-  return v.hash_val();
-}
-#endif  // COMPILER...
 
 }  // namespace BASE_HASH_NAMESPACE
 
 // An ordered set optimized for GN's usage. Such sets are used to store lists
 // of configs and libraries, and are appended to but not randomly inserted
 // into.
 template<typename T>
 class UniqueVector {
  public:
   typedef std::vector<T> Vector;
@@ skipping 58 matching lines @@
 
  private:
   typedef internal::UniquifyRef<T> Ref;
   typedef base::hash_set<Ref> HashSet;
 
   HashSet set_;
   Vector vector_;
 };
 
 #endif  // TOOLS_GN_UNIQUE_VECTOR_H_