Remove kuint16max.

net/tools/dns_fuzz_stub/dns_fuzz_stub.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 <stdint.h>
+
 #include <algorithm>
+#include <limits>
 #include <sstream>
 #include <string>
 #include <vector>
 
-#include "base/basictypes.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/json/json_reader.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "net/base/address_list.h"
 #include "net/base/io_buffer.h"
 #include "net/base/ip_endpoint.h"
 #include "net/dns/dns_protocol.h"
@@ skipping 11 matching lines @@
   free(p);
 }
 
 void CrashNullPointerDereference(void) {
   // Cause the program to segfault with a NULL pointer dereference
   int *p = NULL;
   *p = 0;
 }
 
 bool FitsUint8(int num) {
-  return (num >= 0) && (num <= kuint8max);
+  return (num >= 0) && (num <= std::numeric_limits<uint8_t>::max());
 }
 
 bool FitsUint16(int num) {
-  return (num >= 0) && (num <= kuint16max);
+  return (num >= 0) && (num <= std::numeric_limits<uint16_t>::max());
 }
 
 bool ReadTestCase(const char* filename,
-                  uint16* id, std::string* qname, uint16* qtype,
+                  uint16_t* id,
+                  std::string* qname,
+                  uint16_t* qtype,
                   std::vector<char>* resp_buf,
                   bool* crash_test) {
   base::FilePath filepath = base::FilePath::FromUTF8Unsafe(filename);
 
   std::string json;
   if (!base::ReadFileToString(filepath, &json)) {
     LOG(ERROR) << filename << ": couldn't read file.";
     return false;
   }
 
@@ skipping 17 matching lines @@
 
   int id_int;
   if (!dict->GetInteger("id", &id_int)) {
     LOG(ERROR) << filename << ": id is missing or not an integer.";
     return false;
   }
   if (!FitsUint16(id_int)) {
     LOG(ERROR) << filename << ": id is out of range.";
     return false;
   }
-  *id = static_cast<uint16>(id_int);
+  *id = static_cast<uint16_t>(id_int);
 
   if (!dict->GetStringASCII("qname", qname)) {
     LOG(ERROR) << filename << ": qname is missing or not a string.";
     return false;
   }
 
   int qtype_int;
   if (!dict->GetInteger("qtype", &qtype_int)) {
     LOG(ERROR) << filename << ": qtype is missing or not an integer.";
     return false;
   }
   if (!FitsUint16(qtype_int)) {
     LOG(ERROR) << filename << ": qtype is out of range.";
     return false;
   }
-  *qtype = static_cast<uint16>(qtype_int);
+  *qtype = static_cast<uint16_t>(qtype_int);
 
   base::ListValue* resp_list;
   if (!dict->GetList("response", &resp_list)) {
     LOG(ERROR) << filename << ": response is missing or not a list.";
     return false;
   }
 
   size_t resp_size = resp_list->GetSize();
   resp_buf->clear();
   resp_buf->reserve(resp_size);
@@ skipping 12 matching lines @@
   DCHECK(resp_buf->size() == resp_size);
 
   LOG(INFO) << "Query: id=" << id_int << ", "
             << "qname=" << *qname << ", "
             << "qtype=" << qtype_int << ", "
             << "resp_size=" << resp_size;
 
   return true;
 }
 
-void RunTestCase(uint16 id, std::string& qname, uint16 qtype,
+void RunTestCase(uint16_t id,
+                 std::string& qname,
+                 uint16_t qtype,
                  std::vector<char>& resp_buf) {
   net::DnsQuery query(id, qname, qtype);
   net::DnsResponse response;
   std::copy(resp_buf.begin(), resp_buf.end(), response.io_buffer()->data());
 
   if (!response.InitParse(resp_buf.size(), query)) {
     LOG(INFO) << "InitParse failed.";
     return;
   }
 
@@ skipping 10 matching lines @@
   std::stringstream result_line;
   result_line << "Response: address_list={ ";
   for (unsigned int i = 0; i < address_list.size(); i++)
     result_line << address_list[i].ToString() << " ";
   result_line << "}, ttl=" << ttl.InSeconds() << "s";
 
   LOG(INFO) << result_line.str();
 }
 
 bool ReadAndRunTestCase(const char* filename) {
-  uint16 id = 0;
+  uint16_t id = 0;
   std::string qname;
-  uint16 qtype = 0;
+  uint16_t qtype = 0;
   std::vector<char> resp_buf;
   bool crash_test = false;
 
   LOG(INFO) << "Test case: " << filename;
 
   // ReadTestCase will print a useful error message if it fails.
   if (!ReadTestCase(filename, &id, &qname, &qtype, &resp_buf, &crash_test))
     return false;
 
   if (crash_test) {
@@ skipping 25 matching lines @@
     if (!ReadAndRunTestCase(argv[i]))
       ret = 2;
 
   // Cluster-Fuzz likes "#EOF" as the last line of output to help distinguish
   // successful runs from crashes.
   printf("#EOF\n");
 
   return ret;
 }