Adds std:: to stl types (#049)

net/quic/core/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/core/crypto/strike_register.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/logging.h"
 
-using std::pair;
-using std::set;
-using std::vector;
-
 namespace net {
 
 namespace {
 
 uint32_t GetInitialHorizon(uint32_t current_time_internal,
                            uint32_t window_secs,
                            StrikeRegister::StartupType startup) {
   if (startup == StrikeRegister::DENY_REQUESTS_AT_STARTUP) {
     // The horizon is initially set |window_secs| into the future because, if
     // we just crashed, then we may have accepted nonces in the span
@@ skipping 117 matching lines @@
   const uint32_t current_time = ExternalTimeToInternal(current_time_external);
 
   // Check to see if the orbit is correct.
   if (memcmp(nonce + sizeof(current_time), orbit_, sizeof(orbit_))) {
     return NONCE_INVALID_ORBIT_FAILURE;
   }
 
   const uint32_t nonce_time = ExternalTimeToInternal(TimeFromBytes(nonce));
 
   // Check that the timestamp is in the valid range.
-  pair<uint32_t, uint32_t> valid_range =
+  std::pair<uint32_t, uint32_t> valid_range =
       StrikeRegister::GetValidRange(current_time);
   if (nonce_time < valid_range.first || nonce_time > valid_range.second) {
     return NONCE_INVALID_TIME_FAILURE;
   }
 
   // We strip the orbit out of the nonce.
   uint8_t value[24];
   memcpy(value, nonce, sizeof(nonce_time));
   memcpy(value + sizeof(nonce_time),
          nonce + sizeof(nonce_time) + sizeof(orbit_),
@@ skipping 105 matching lines @@
   return NONCE_OK;
 }
 
 const uint8_t* StrikeRegister::orbit() const {
   return orbit_;
 }
 
 uint32_t StrikeRegister::GetCurrentValidWindowSecs(
     uint32_t current_time_external) const {
   uint32_t current_time = ExternalTimeToInternal(current_time_external);
-  pair<uint32_t, uint32_t> valid_range =
+  std::pair<uint32_t, uint32_t> valid_range =
       StrikeRegister::GetValidRange(current_time);
   if (valid_range.second >= valid_range.first) {
     return valid_range.second - current_time + 1;
   } else {
     return 0;
   }
 }
 
 void StrikeRegister::Validate() {
-  set<uint32_t> free_internal_nodes;
+  std::set<uint32_t> free_internal_nodes;
   for (uint32_t i = internal_node_free_head_; i != kNil;
        i = internal_nodes_[i].next()) {
     CHECK_LT(i, max_entries_);
     CHECK_EQ(free_internal_nodes.count(i), 0u);
     free_internal_nodes.insert(i);
   }
 
-  set<uint32_t> free_external_nodes;
+  std::set<uint32_t> free_external_nodes;
   for (uint32_t i = external_node_free_head_; i != kNil;
        i = external_node_next_ptr(i)) {
     CHECK_LT(i, max_entries_);
     CHECK_EQ(free_external_nodes.count(i), 0u);
     free_external_nodes.insert(i);
   }
 
-  set<uint32_t> used_external_nodes;
-  set<uint32_t> used_internal_nodes;
+  std::set<uint32_t> used_external_nodes;
+  std::set<uint32_t> used_internal_nodes;
 
   if (internal_node_head_ != kNil &&
       ((internal_node_head_ >> 8) & kExternalFlag) == 0) {
-    vector<pair<unsigned, bool>> bits;
+    std::vector<std::pair<unsigned, bool>> bits;
     ValidateTree(internal_node_head_ >> 8, -1, bits, free_internal_nodes,
                  free_external_nodes, &used_internal_nodes,
                  &used_external_nodes);
   }
 }
 
 // static
 uint32_t StrikeRegister::TimeFromBytes(const uint8_t d[4]) {
   return static_cast<uint32_t>(d[0]) << 24 | static_cast<uint32_t>(d[1]) << 16 |
          static_cast<uint32_t>(d[2]) << 8 | static_cast<uint32_t>(d[3]);
 }
 
-pair<uint32_t, uint32_t> StrikeRegister::GetValidRange(
+std::pair<uint32_t, uint32_t> StrikeRegister::GetValidRange(
     uint32_t current_time_internal) const {
   if (current_time_internal < horizon_) {
     // Empty valid range.
     return std::make_pair(std::numeric_limits<uint32_t>::max(), 0);
   }
 
   uint32_t lower_bound;
   if (current_time_internal >= window_secs_) {
     lower_bound = std::max(horizon_, current_time_internal - window_secs_);
   } else {
@@ skipping 101 matching lines @@
 void StrikeRegister::FreeExternalNode(uint32_t index) {
   external_node_next_ptr(index) = external_node_free_head_;
   external_node_free_head_ = index;
 }
 
 void StrikeRegister::FreeInternalNode(uint32_t index) {
   internal_nodes_[index].SetNextPtr(internal_node_free_head_);
   internal_node_free_head_ = index;
 }
 
-void StrikeRegister::ValidateTree(uint32_t internal_node,
-                                  int last_bit,
-                                  const vector<pair<unsigned, bool>>& bits,
-                                  const set<uint32_t>& free_internal_nodes,
-                                  const set<uint32_t>& free_external_nodes,
-                                  set<uint32_t>* used_internal_nodes,
-                                  set<uint32_t>* used_external_nodes) {
+void StrikeRegister::ValidateTree(
+    uint32_t internal_node,
+    int last_bit,
+    const std::vector<std::pair<unsigned, bool>>& bits,
+    const std::set<uint32_t>& free_internal_nodes,
+    const std::set<uint32_t>& free_external_nodes,
+    std::set<uint32_t>* used_internal_nodes,
+    std::set<uint32_t>* used_external_nodes) {
   CHECK_LT(internal_node, max_entries_);
   const InternalNode* i = &internal_nodes_[internal_node];
   unsigned bit = 0;
   switch (i->otherbits()) {
     case 0xff & ~(1 << 7):
       bit = 0;
       break;
     case 0xff & ~(1 << 6):
       bit = 1;
       break;
@@ skipping 26 matching lines @@
 
   CHECK_EQ(free_internal_nodes.count(internal_node), 0u);
 
   for (unsigned child = 0; child < 2; child++) {
     if (i->child(child) & kExternalFlag) {
       uint32_t ext = i->child(child) & ~kExternalFlag;
       CHECK_EQ(free_external_nodes.count(ext), 0u);
       CHECK_EQ(used_external_nodes->count(ext), 0u);
       used_external_nodes->insert(ext);
       const uint8_t* bytes = external_node(ext);
-      for (const pair<unsigned, bool>& pair : bits) {
+      for (const std::pair<unsigned, bool>& pair : bits) {
         unsigned byte = pair.first / 8;
         DCHECK_LE(byte, 0xffu);
         unsigned bit_new = pair.first % 8;
         static const uint8_t kMasks[8] = {0x80, 0x40, 0x20, 0x10,
                                           0x08, 0x04, 0x02, 0x01};
         CHECK_EQ((bytes[byte] & kMasks[bit_new]) != 0, pair.second);
       }
     } else {
       uint32_t inter = i->child(child);
-      vector<pair<unsigned, bool>> new_bits(bits);
-      new_bits.push_back(pair<unsigned, bool>(bit, child != 0));
+      std::vector<std::pair<unsigned, bool>> new_bits(bits);
+      new_bits.push_back(std::pair<unsigned, bool>(bit, child != 0));
       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