Land Recent QUIC changes.

net/base/linked_hash_map.h

 // Copyright (c) 2013 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.
 //
 // This is a simplistic insertion-ordered map.  It behaves similarly to an STL
 // map, but only implements a small subset of the map's methods.  Internally, we
 // just keep a map and a list going in parallel.
 //
 // This class provides no thread safety guarantees, beyond what you would
 // normally see with std::list.
@@ skipping 128 matching lines @@
     }
     return found->second;
   }
 
   // Returns the bounds of a range that includes all the elements in the
   // container with a key that compares equal to x.
   std::pair<iterator, iterator> equal_range(const key_type& key) {
     std::pair<typename MapType::iterator, typename MapType::iterator> eq_range =
         map_.equal_range(key);
 
-    return make_pair(eq_range.first->second, eq_range.second->second);
+    return std::make_pair(eq_range.first->second, eq_range.second->second);
   }
 
   std::pair<const_iterator, const_iterator> equal_range(
       const key_type& key) const {
     std::pair<typename MapType::const_iterator,
         typename MapType::const_iterator> eq_range =
         map_.equal_range(key);
     const const_iterator& start_iter = eq_range.first != map_.end() ?
         eq_range.first->second : end();
     const const_iterator& end_iter = eq_range.second != map_.end() ?
         eq_range.second->second : end();
 
-    return make_pair(start_iter, end_iter);
+    return std::make_pair(start_iter, end_iter);
   }
 
   // Returns the value mapped to key, or an inserted iterator to that position
   // in the map.
   Value& operator[](const key_type& key) {
-    return (*((this->insert(make_pair(key, Value()))).first)).second;
+    return (*((this->insert(std::make_pair(key, Value()))).first)).second;
   }
 
   // Inserts an element into the map
   std::pair<iterator, bool> insert(const std::pair<Key, Value>& pair) {
     // First make sure the map doesn't have a key with this value.  If it does,
     // return a pair with an iterator to it, and false indicating that we
     // didn't insert anything.
     typename MapType::iterator found = map_.find(pair.first);
-    if (found != map_.end()) return make_pair(found->second, false);
+    if (found != map_.end()) return std::make_pair(found->second, false);
 
     // Otherwise, insert into the list first.
     list_.push_back(pair);
 
     // Obtain an iterator to the newly added element.  We do -- instead of -
     // since list::iterator doesn't implement operator-().
     typename ListType::iterator last = list_.end();
     --last;
 
-    CHECK(map_.insert(make_pair(pair.first, last)).second)
+    CHECK(map_.insert(std::make_pair(pair.first, last)).second)
         << "Map and list are inconsistent";
 
-    return make_pair(last, true);
+    return std::make_pair(last, true);
   }
 
   size_type size() const {
     return list_.size();
   }
 
   void swap(linked_hash_map& other) {
     map_.swap(other.map_);
     list_.swap(other.list_);
   }
 
  private:
   // The map component, used for speedy lookups
   MapType map_;
 
   // The list component, used for maintaining insertion order
   ListType list_;
 };
 
 #endif  // UTIL_GTL_LINKED_HASH_MAP_H_