Fully qualify std::* names being exported internally by using

net/quic/quic_received_packet_manager.cc

 // Copyright 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/quic_received_packet_manager.h"
 
 #include <limits>
 #include <utility>
 
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "net/base/linked_hash_map.h"
 #include "net/quic/crypto/crypto_protocol.h"
 #include "net/quic/quic_connection_stats.h"
 
-using std::make_pair;
 using std::max;
 using std::min;
 using std::numeric_limits;
 
 namespace net {
 
 namespace {
 
 // The maximum number of packets to ack immediately after a missing packet for
 // fast retransmission to kick in at the sender.  This limit is created to
@@ skipping 47 matching lines @@
 
   // Optimize the typical case of no gaps.
   if (sequence_number == largest_observed_ + 1 && packets_entropy_.empty()) {
     ++first_gap_;
     largest_observed_ = sequence_number;
     return;
   }
   if (sequence_number > largest_observed_) {
     for (QuicPacketSequenceNumber i = 0;
          i < (sequence_number - largest_observed_ - 1); ++i) {
-      packets_entropy_.push_back(make_pair(0, false));
+      packets_entropy_.push_back(std::make_pair(0, false));
     }
-    packets_entropy_.push_back(make_pair(entropy_hash, true));
+    packets_entropy_.push_back(std::make_pair(entropy_hash, true));
     largest_observed_ = sequence_number;
   } else {
     packets_entropy_[sequence_number - first_gap_] =
-        make_pair(entropy_hash, true);
+        std::make_pair(entropy_hash, true);
     AdvanceFirstGapAndGarbageCollectEntropyMap();
   }
 
   DVLOG(2) << "setting cumulative received entropy hash to: "
            << static_cast<int>(packets_entropy_hash_)
            << " updated with sequence number " << sequence_number
            << " entropy hash: " << static_cast<int>(entropy_hash);
 }
 
 void QuicReceivedPacketManager::EntropyTracker::SetCumulativeEntropyUpTo(
@@ skipping 177 matching lines @@
   return !ack_frame_.missing_packets.empty() &&
       (ack_frame_.largest_observed -
        *ack_frame_.missing_packets.rbegin()) <= kMaxPacketsAfterNewMissing;
 }
 
 size_t QuicReceivedPacketManager::NumTrackedPackets() const {
   return entropy_tracker_.size();
 }
 
 }  // namespace net