Update from https://crrev.com/316786

net/quic/crypto/strike_register.cc

 // 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.
 
 #include "net/quic/crypto/strike_register.h"
 
 #include <limits>
 
 #include "base/logging.h"
 
-using std::make_pair;
 using std::max;
 using std::min;
 using std::pair;
 using std::set;
 using std::vector;
 
 namespace net {
 
 namespace {
 
@@ skipping 295 matching lines @@
   return static_cast<uint32>(d[0]) << 24 |
          static_cast<uint32>(d[1]) << 16 |
          static_cast<uint32>(d[2]) << 8 |
          static_cast<uint32>(d[3]);
 }
 
 pair<uint32, uint32> StrikeRegister::GetValidRange(
     uint32 current_time_internal) const {
   if (current_time_internal < horizon_) {
     // Empty valid range.
-    return make_pair(std::numeric_limits<uint32>::max(), 0);
+    return std::make_pair(std::numeric_limits<uint32>::max(), 0);
   }
 
   uint32 lower_bound;
   if (current_time_internal >= window_secs_) {
     lower_bound = max(horizon_, current_time_internal - window_secs_);
   } else {
     lower_bound = horizon_;
   }
 
   // Also limit the upper range based on horizon_.  This makes the
   // strike register reject inserts that are far in the future and
   // would consume strike register resources for a long time.  This
   // allows the strike server to degrade optimally in cases where the
   // insert rate exceeds |max_entries_ / (2 * window_secs_)| entries
   // per second.
   uint32 upper_bound =
       current_time_internal + min(current_time_internal - horizon_,
                                   window_secs_);
 
-  return make_pair(lower_bound, upper_bound);
+  return std::make_pair(lower_bound, upper_bound);
 }
 
 uint32 StrikeRegister::ExternalTimeToInternal(uint32 external_time) const {
   return external_time - internal_epoch_;
 }
 
 uint32 StrikeRegister::BestMatch(const uint8 v[24]) const {
   if (internal_node_head_ == kNil) {
     return kNil;
   }
@@ skipping 154 matching lines @@
       CHECK_EQ(free_internal_nodes.count(inter), 0u);
       CHECK_EQ(used_internal_nodes->count(inter), 0u);
       used_internal_nodes->insert(inter);
       ValidateTree(inter, bit, bits, free_internal_nodes, free_external_nodes,
                    used_internal_nodes, used_external_nodes);
     }
   }
 }
 
 }  // namespace net