Remove kuint32max.

net/http/http_security_headers.cc

 // Copyright (c) 2012 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 <limits>
+
 #include "base/base64.h"
-#include "base/basictypes.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_tokenizer.h"
 #include "base/strings/string_util.h"
 #include "net/http/http_security_headers.h"
 #include "net/http/http_util.h"
 #include "url/gurl.h"
 
 namespace net {
 
 namespace {
 
 enum MaxAgeParsing { REQUIRE_MAX_AGE, DO_NOT_REQUIRE_MAX_AGE };
 
-static_assert(kMaxHSTSAgeSecs <= kuint32max, "kMaxHSTSAgeSecs too large");
+static_assert(kMaxHSTSAgeSecs <= UINT32_MAX, "kMaxHSTSAgeSecs too large");
 
 // MaxAgeToInt converts a string representation of a "whole number" of
-// seconds into a uint32. The string may contain an arbitrarily large number,
+// seconds into a uint32_t. The string may contain an arbitrarily large number,
 // which will be clipped to kMaxHSTSAgeSecs and which is guaranteed to fit
 // within a 32-bit unsigned integer. False is returned on any parse error.
 bool MaxAgeToInt(std::string::const_iterator begin,
                  std::string::const_iterator end,
-                 uint32* result) {
+                 uint32_t* result) {
   const base::StringPiece s(begin, end);
   if (s.empty())
     return false;
 
-  int64 i = 0;
+  int64_t i = 0;
 
-  // Return false on any StringToInt64 parse errors *except* for
-  // int64 overflow. StringToInt64 is used, rather than StringToUint64,
-  // in order to properly handle and reject negative numbers
-  // (StringToUint64 does not return false on negative numbers).
-  // For values too large to be stored in an int64, StringToInt64 will
-  // return false with i set to kint64max, so this case is detected
-  // by the immediately following if-statement and allowed to fall
-  // through so that i gets clipped to kMaxHSTSAgeSecs.
-  if (!base::StringToInt64(s, &i) && i != kint64max)
+  // Return false on any StringToInt64 parse errors *except* for int64_t
+  // overflow. StringToInt64 is used, rather than StringToUint64, in order to
+  // properly handle and reject negative numbers (StringToUint64 does not return
+  // false on negative numbers). For values too large to be stored in an
+  // int64_t, StringToInt64 will return false with i set to
+  // std::numeric_limits<int64_t>::max(), so this case is detected by the
+  // immediately following if-statement and allowed to fall through so that i
+  // gets clipped to kMaxHSTSAgeSecs.
+  if (!base::StringToInt64(s, &i) && i != std::numeric_limits<int64_t>::max())
     return false;
   if (i < 0)
     return false;
   if (i > kMaxHSTSAgeSecs)
     i = kMaxHSTSAgeSecs;
-  *result = (uint32)i;
+  *result = (uint32_t)i;
   return true;
 }
 
 // Returns true iff there is an item in |pins| which is not present in
 // |from_cert_chain|. Such an SPKI hash is called a "backup pin".
 bool IsBackupPinPresent(const HashValueVector& pins,
                         const HashValueVector& from_cert_chain) {
   for (HashValueVector::const_iterator i = pins.begin(); i != pins.end();
        ++i) {
     HashValueVector::const_iterator j =
@@ skipping 60 matching lines @@
 }
 
 bool ParseHPKPHeaderImpl(const std::string& value,
                          MaxAgeParsing max_age_status,
                          base::TimeDelta* max_age,
                          bool* include_subdomains,
                          HashValueVector* hashes,
                          GURL* report_uri) {
   bool parsed_max_age = false;
   bool include_subdomains_candidate = false;
-  uint32 max_age_candidate = 0;
+  uint32_t max_age_candidate = 0;
   GURL parsed_report_uri;
   HashValueVector pins;
   bool require_max_age = max_age_status == REQUIRE_MAX_AGE;
 
   HttpUtil::NameValuePairsIterator name_value_pairs(
       value.begin(), value.end(), ';',
       HttpUtil::NameValuePairsIterator::VALUES_OPTIONAL);
 
   while (name_value_pairs.GetNext()) {
     if (base::LowerCaseEqualsASCII(
@@ skipping 75 matching lines @@
 //     other header field value data, that does not conform to the
 //     syntax defined in this specification.
 //
 // 5.  If an STS header field contains directive(s) not recognized by
 //     the UA, the UA MUST ignore the unrecognized directives and if the
 //     STS header field otherwise satisfies the above requirements (1
 //     through 4), the UA MUST process the recognized directives.
 bool ParseHSTSHeader(const std::string& value,
                      base::TimeDelta* max_age,
                      bool* include_subdomains) {
-  uint32 max_age_candidate = 0;
+  uint32_t max_age_candidate = 0;
   bool include_subdomains_candidate = false;
 
   // We must see max-age exactly once.
   int max_age_observed = 0;
   // We must see includeSubdomains exactly 0 or 1 times.
   int include_subdomains_observed = 0;
 
   enum ParserState {
     START,
     AFTER_MAX_AGE_LABEL,
@@ skipping 130 matching lines @@
                                bool* include_subdomains,
                                HashValueVector* hashes,
                                GURL* report_uri) {
   // max-age is irrelevant for Report-Only headers.
   base::TimeDelta unused_max_age;
   return ParseHPKPHeaderImpl(value, DO_NOT_REQUIRE_MAX_AGE, &unused_max_age,
                              include_subdomains, hashes, report_uri);
 }
 
 }  // namespace net