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 "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");

[asanka, 2015/12/04 15:12:34]

Why not numeric_limits? Isn't it required to be constexpr in C++11, or is this
something that's not allowed yet? I don't see anything calling out the
constexprness of limits in chromium-cpp though.

[Avi (use Gerrit), 2015/12/04 15:19:28]

There was some rumbling about whether we can rely on the constexprness of max(),
so I used the old-school contant here. I can switch if you want.

 
 // 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,
+  // 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, StringToInt64 will
-  // return false with i set to kint64max, so this case is detected
+  // For values too large to be stored in an int64_t, StringToInt64 will
+  // return false with i set to INT64_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 != kint64max)
+  if (!base::StringToInt64(s, &i) && i != INT64_MAX)

[asanka, 2015/12/04 15:12:34]

Why INT64_MAX instead of numeric_limits?

This doesn't need constexpr. Also StringToInt64 is documented to return the
"maximum value supported by the data type" upon overflow.

[Avi (use Gerrit), 2015/12/04 15:19:28]

Consistency with above. I'll switch if you want.
This is a mechanical-ish change. I want to switch out the integer types and
upgrade the max constants. I don't want to make any real code changes, no matter
how correct they are.

[asanka, 2015/12/04 15:41:43]

I'd prefer if we switch this instance and keep the above as-is if constexprness
is contentious. Otherwise the presence of an old-school constant would prevent
us from migrating the remainder of the code.
Yup. I was remarking that the API isn't specific about a named constant, just
that it's the maximum value for the numeric type.

[Avi (use Gerrit), 2015/12/04 15:48:16]

Done.

     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