Remove kuint32max.

net/dns/dns_response.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 "net/dns/dns_response.h"
 
+#include <limits>
+
 #include "base/big_endian.h"
 #include "base/strings/string_util.h"
 #include "base/sys_byteorder.h"
 #include "net/base/address_list.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/dns/dns_protocol.h"
 #include "net/dns/dns_query.h"
 #include "net/dns/dns_util.h"
 
@@ skipping 37 matching lines @@
   if (out) {
     out->clear();
     out->reserve(dns_protocol::kMaxNameLength);
   }
 
   for (;;) {
     // The first two bits of the length give the type of the length. It's
     // either a direct length or a pointer to the remainder of the name.
     switch (*p & dns_protocol::kLabelMask) {
       case dns_protocol::kLabelPointer: {
-        if (p + sizeof(uint16) > end)
+        if (p + sizeof(uint16_t) > end)
           return 0;
         if (consumed == 0) {
-          consumed = p - pos + sizeof(uint16);
+          consumed = p - pos + sizeof(uint16_t);
           if (!out)
             return consumed;  // If name is not stored, that's all we need.
         }
-        seen += sizeof(uint16);
+        seen += sizeof(uint16_t);
         // If seen the whole packet, then we must be in a loop.
         if (seen > length_)
           return 0;
-        uint16 offset;
-        base::ReadBigEndian<uint16>(p, &offset);
+        uint16_t offset;
+        base::ReadBigEndian<uint16_t>(p, &offset);
         offset &= dns_protocol::kOffsetMask;
         p = packet_ + offset;
         if (p >= end)
           return 0;
         break;
       }
       case dns_protocol::kLabelDirect: {
-        uint8 label_len = *p;
+        uint8_t label_len = *p;
         ++p;
         // Note: root domain (".") is NOT included.
         if (label_len == 0) {
           if (consumed == 0) {
             consumed = p - pos;
           }  // else we set |consumed| before first jump
           return consumed;
         }
         if (p + label_len >= end)
           return 0;  // Truncated or missing label.
@@ skipping 13 matching lines @@
   }
 }
 
 bool DnsRecordParser::ReadRecord(DnsResourceRecord* out) {
   DCHECK(packet_);
   size_t consumed = ReadName(cur_, &out->name);
   if (!consumed)
     return false;
   base::BigEndianReader reader(cur_ + consumed,
                                packet_ + length_ - (cur_ + consumed));
-  uint16 rdlen;
+  uint16_t rdlen;
   if (reader.ReadU16(&out->type) &&
       reader.ReadU16(&out->klass) &&
       reader.ReadU32(&out->ttl) &&
       reader.ReadU16(&rdlen) &&
       reader.ReadPiece(&out->rdata, rdlen)) {
     cur_ = reader.ptr();
     return true;
   }
   return false;
 }
 
 bool DnsRecordParser::SkipQuestion() {
   size_t consumed = ReadName(cur_, NULL);
   if (!consumed)
     return false;
 
-  const char* next = cur_ + consumed + 2 * sizeof(uint16);  // QTYPE + QCLASS
+  const char* next = cur_ + consumed + 2 * sizeof(uint16_t);  // QTYPE + QCLASS
   if (next > packet_ + length_)
     return false;
 
   cur_ = next;
 
   return true;
 }
 
 DnsResponse::DnsResponse()
     : io_buffer_(new IOBufferWithSize(dns_protocol::kMaxUDPSize + 1)) {
@@ skipping 63 matching lines @@
     }
   }
 
   return true;
 }
 
 bool DnsResponse::IsValid() const {
   return parser_.IsValid();
 }
 
-uint16 DnsResponse::flags() const {
+uint16_t DnsResponse::flags() const {
   DCHECK(parser_.IsValid());
   return base::NetToHost16(header()->flags) & ~(dns_protocol::kRcodeMask);
 }
 
-uint8 DnsResponse::rcode() const {
+uint8_t DnsResponse::rcode() const {
   DCHECK(parser_.IsValid());
   return base::NetToHost16(header()->flags) & dns_protocol::kRcodeMask;
 }
 
 unsigned DnsResponse::answer_count() const {
   DCHECK(parser_.IsValid());
   return base::NetToHost16(header()->ancount);
 }
 
 unsigned DnsResponse::additional_answer_count() const {
   DCHECK(parser_.IsValid());
   return base::NetToHost16(header()->arcount);
 }
 
 base::StringPiece DnsResponse::qname() const {
   DCHECK(parser_.IsValid());
   // The response is HEADER QNAME QTYPE QCLASS ANSWER.
   // |parser_| is positioned at the beginning of ANSWER, so the end of QNAME is
-  // two uint16s before it.
+  // two uint16_ts before it.
   const size_t hdr_size = sizeof(dns_protocol::Header);
-  const size_t qname_size = parser_.GetOffset() - 2 * sizeof(uint16) - hdr_size;
+  const size_t qname_size =
+      parser_.GetOffset() - 2 * sizeof(uint16_t) - hdr_size;
   return base::StringPiece(io_buffer_->data() + hdr_size, qname_size);
 }
 
-uint16 DnsResponse::qtype() const {
+uint16_t DnsResponse::qtype() const {
   DCHECK(parser_.IsValid());
   // QTYPE starts where QNAME ends.
-  const size_t type_offset = parser_.GetOffset() - 2 * sizeof(uint16);
-  uint16 type;
-  base::ReadBigEndian<uint16>(io_buffer_->data() + type_offset, &type);
+  const size_t type_offset = parser_.GetOffset() - 2 * sizeof(uint16_t);
+  uint16_t type;
+  base::ReadBigEndian<uint16_t>(io_buffer_->data() + type_offset, &type);
   return type;
 }
 
 std::string DnsResponse::GetDottedName() const {
   return DNSDomainToString(qname());
 }
 
 DnsRecordParser DnsResponse::Parser() const {
   DCHECK(parser_.IsValid());
   // Return a copy of the parser.
@@ skipping 10 matching lines @@
   DCHECK(IsValid());
   // DnsTransaction already verified that |response| matches the issued query.
   // We still need to determine if there is a valid chain of CNAMEs from the
   // query name to the RR owner name.
   // We err on the side of caution with the assumption that if we are too picky,
   // we can always fall back to the system getaddrinfo.
 
   // Expected owner of record. No trailing dot.
   std::string expected_name = GetDottedName();
 
-  uint16 expected_type = qtype();
+  uint16_t expected_type = qtype();
   DCHECK(expected_type == dns_protocol::kTypeA ||
          expected_type == dns_protocol::kTypeAAAA);
 
   size_t expected_size = (expected_type == dns_protocol::kTypeAAAA)
       ? kIPv6AddressSize : kIPv4AddressSize;
 
-  uint32 ttl_sec = kuint32max;
+  uint32_t ttl_sec = std::numeric_limits<uint32_t>::max();
   IPAddressList ip_addresses;
   DnsRecordParser parser = Parser();
   DnsResourceRecord record;
   unsigned ancount = answer_count();
   for (unsigned i = 0; i < ancount; ++i) {
     if (!parser.ReadRecord(&record))
       return DNS_MALFORMED_RESPONSE;
 
     if (record.type == dns_protocol::kTypeCNAME) {
       // Following the CNAME chain, only if no addresses seen.
@@ skipping 25 matching lines @@
 
   // getcanonname in eglibc returns the first owner name of an A or AAAA RR.
   // If the response passed all the checks so far, then |expected_name| is it.
   *addr_list = AddressList::CreateFromIPAddressList(ip_addresses,
                                                     expected_name);
   *ttl = base::TimeDelta::FromSeconds(ttl_sec);
   return DNS_PARSE_OK;
 }
 
 }  // namespace net