Remove kuint16max.

net/dns/dns_transaction_unittest.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_transaction.h"
 
+#include <stdint.h>
+
+#include <limits>
+
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/rand_util.h"
 #include "base/sys_byteorder.h"
 #include "base/test/test_timeouts.h"
 #include "net/dns/dns_protocol.h"
 #include "net/dns/dns_query.h"
 #include "net/dns/dns_response.h"
 #include "net/dns/dns_session.h"
 #include "net/dns/dns_test_util.h"
 #include "net/dns/dns_util.h"
 #include "net/log/net_log.h"
 #include "net/socket/socket_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
 namespace {
 
 std::string DomainFromDot(const base::StringPiece& dotted) {
   std::string out;
   EXPECT_TRUE(DNSDomainFromDot(dotted, &out));
   return out;
 }
 
 // A SocketDataProvider builder.
 class DnsSocketData {
  public:
   // The ctor takes parameters for the DnsQuery.
-  DnsSocketData(uint16 id,
+  DnsSocketData(uint16_t id,
                 const char* dotted_name,
-                uint16 qtype,
+                uint16_t qtype,
                 IoMode mode,
                 bool use_tcp)
       : query_(new DnsQuery(id, DomainFromDot(dotted_name), qtype)),
         use_tcp_(use_tcp) {
     if (use_tcp_) {
-      scoped_ptr<uint16> length(new uint16);
+      scoped_ptr<uint16_t> length(new uint16_t);
       *length = base::HostToNet16(query_->io_buffer()->size());
       writes_.push_back(MockWrite(mode,
                                   reinterpret_cast<const char*>(length.get()),
-                                  sizeof(uint16), num_reads_and_writes()));
+                                  sizeof(uint16_t), num_reads_and_writes()));
       lengths_.push_back(length.Pass());
     }
     writes_.push_back(MockWrite(mode, query_->io_buffer()->data(),
                                 query_->io_buffer()->size(),
                                 num_reads_and_writes()));
   }
   ~DnsSocketData() {}
 
   // All responses must be added before GetProvider.
 
   // Adds pre-built DnsResponse. |tcp_length| will be used in TCP mode only.
-  void AddResponseWithLength(scoped_ptr<DnsResponse> response, IoMode mode,
-                             uint16 tcp_length) {
+  void AddResponseWithLength(scoped_ptr<DnsResponse> response,
+                             IoMode mode,
+                             uint16_t tcp_length) {
     CHECK(!provider_.get());
     if (use_tcp_) {
-      scoped_ptr<uint16> length(new uint16);
+      scoped_ptr<uint16_t> length(new uint16_t);
       *length = base::HostToNet16(tcp_length);
       reads_.push_back(MockRead(mode,
                                 reinterpret_cast<const char*>(length.get()),
-                                sizeof(uint16), num_reads_and_writes()));
+                                sizeof(uint16_t), num_reads_and_writes()));
       lengths_.push_back(length.Pass());
     }
     reads_.push_back(MockRead(mode, response->io_buffer()->data(),
                               response->io_buffer()->size(),
                               num_reads_and_writes()));
     responses_.push_back(response.Pass());
   }
 
   // Adds pre-built DnsResponse.
   void AddResponse(scoped_ptr<DnsResponse> response, IoMode mode) {
-    uint16 tcp_length = response->io_buffer()->size();
+    uint16_t tcp_length = response->io_buffer()->size();
     AddResponseWithLength(response.Pass(), mode, tcp_length);
   }
 
   // Adds pre-built response from |data| buffer.
-  void AddResponseData(const uint8* data, size_t length, IoMode mode) {
+  void AddResponseData(const uint8_t* data, size_t length, IoMode mode) {
     CHECK(!provider_.get());
     AddResponse(make_scoped_ptr(
         new DnsResponse(reinterpret_cast<const char*>(data), length, 0)), mode);
   }
 
   // Add no-answer (RCODE only) response matching the query.
   void AddRcode(int rcode, IoMode mode) {
     scoped_ptr<DnsResponse> response(
         new DnsResponse(query_->io_buffer()->data(),
                         query_->io_buffer()->size(),
@@ skipping 19 matching lines @@
     reads_.push_back(
         MockRead(ASYNC, ERR_IO_PENDING, writes_.size() + reads_.size()));
     provider_.reset(new SequencedSocketData(&reads_[0], reads_.size(),
                                             &writes_[0], writes_.size()));
     if (use_tcp_) {
       provider_->set_connect_data(MockConnect(reads_[0].mode, OK));
     }
     return provider_.get();
   }
 
-  uint16 query_id() const {
-    return query_->id();
-  }
+  uint16_t query_id() const { return query_->id(); }
 
  private:
   size_t num_reads_and_writes() const { return reads_.size() + writes_.size(); }
 
   scoped_ptr<DnsQuery> query_;
   bool use_tcp_;
-  std::vector<scoped_ptr<uint16>> lengths_;
+  std::vector<scoped_ptr<uint16_t>> lengths_;
   std::vector<scoped_ptr<DnsResponse>> responses_;
   std::vector<MockWrite> writes_;
   std::vector<MockRead> reads_;
   scoped_ptr<SequencedSocketData> provider_;
 
   DISALLOW_COPY_AND_ASSIGN(DnsSocketData);
 };
 
 class TestSocketFactory;
 
@@ skipping 69 matching lines @@
 int TestUDPClientSocket::Connect(const IPEndPoint& endpoint) {
   factory_->OnConnect(endpoint);
   return MockUDPClientSocket::Connect(endpoint);
 }
 
 // Helper class that holds a DnsTransaction and handles OnTransactionComplete.
 class TransactionHelper {
  public:
   // If |expected_answer_count| < 0 then it is the expected net error.
   TransactionHelper(const char* hostname,
-                    uint16 qtype,
+                    uint16_t qtype,
                     int expected_answer_count)
       : hostname_(hostname),
         qtype_(qtype),
         expected_answer_count_(expected_answer_count),
         cancel_in_callback_(false),
         quit_in_callback_(false),
-        completed_(false) {
-  }
+        completed_(false) {}
 
   // Mark that the transaction shall be destroyed immediately upon callback.
   void set_cancel_in_callback() {
     cancel_in_callback_ = true;
   }
 
   // Mark to call MessageLoop::QuitWhenIdle() upon callback.
   void set_quit_in_callback() {
     quit_in_callback_ = true;
   }
@@ skipping 65 matching lines @@
   // Use when some of the responses are timeouts.
   bool RunUntilDone(DnsTransactionFactory* factory) {
     set_quit_in_callback();
     StartTransaction(factory);
     base::MessageLoop::current()->Run();
     return has_completed();
   }
 
  private:
   std::string hostname_;
-  uint16 qtype_;
+  uint16_t qtype_;
   scoped_ptr<DnsTransaction> transaction_;
   int expected_answer_count_;
   bool cancel_in_callback_;
   bool quit_in_callback_;
 
   bool completed_;
 };
 
 class DnsTransactionTest : public testing::Test {
  public:
@@ skipping 29 matching lines @@
   void AddSocketData(scoped_ptr<DnsSocketData> data) {
     CHECK(socket_factory_.get());
     transaction_ids_.push_back(data->query_id());
     socket_factory_->AddSocketDataProvider(data->GetProvider());
     socket_data_.push_back(data.Pass());
   }
 
   // Add expected query for |dotted_name| and |qtype| with |id| and response
   // taken verbatim from |data| of |data_length| bytes. The transaction id in
   // |data| should equal |id|, unless testing mismatched response.
-  void AddQueryAndResponse(uint16 id,
+  void AddQueryAndResponse(uint16_t id,
                            const char* dotted_name,
-                           uint16 qtype,
-                           const uint8* response_data,
+                           uint16_t qtype,
+                           const uint8_t* response_data,
                            size_t response_length,
                            IoMode mode,
                            bool use_tcp) {
     CHECK(socket_factory_.get());
     scoped_ptr<DnsSocketData> data(
         new DnsSocketData(id, dotted_name, qtype, mode, use_tcp));
     data->AddResponseData(response_data, response_length, mode);
     AddSocketData(data.Pass());
   }
 
-  void AddAsyncQueryAndResponse(uint16 id,
+  void AddAsyncQueryAndResponse(uint16_t id,
                                 const char* dotted_name,
-                                uint16 qtype,
-                                const uint8* data,
+                                uint16_t qtype,
+                                const uint8_t* data,
                                 size_t data_length) {
     AddQueryAndResponse(id, dotted_name, qtype, data, data_length, ASYNC,
                         false);
   }
 
-  void AddSyncQueryAndResponse(uint16 id,
+  void AddSyncQueryAndResponse(uint16_t id,
                                const char* dotted_name,
-                               uint16 qtype,
-                               const uint8* data,
+                               uint16_t qtype,
+                               const uint8_t* data,
                                size_t data_length) {
     AddQueryAndResponse(id, dotted_name, qtype, data, data_length, SYNCHRONOUS,
                         false);
   }
 
   // Add expected query of |dotted_name| and |qtype| and no response.
-  void AddQueryAndTimeout(const char* dotted_name, uint16 qtype) {
-    uint16 id = base::RandInt(0, kuint16max);
+  void AddQueryAndTimeout(const char* dotted_name, uint16_t qtype) {
+    uint16_t id = base::RandInt(0, std::numeric_limits<uint16_t>::max());
     scoped_ptr<DnsSocketData> data(
         new DnsSocketData(id, dotted_name, qtype, ASYNC, false));
     AddSocketData(data.Pass());
   }
 
   // Add expected query of |dotted_name| and |qtype| and matching response with
   // no answer and RCODE set to |rcode|. The id will be generated randomly.
   void AddQueryAndRcode(const char* dotted_name,
-                        uint16 qtype,
+                        uint16_t qtype,
                         int rcode,
                         IoMode mode,
                         bool use_tcp) {
     CHECK_NE(dns_protocol::kRcodeNOERROR, rcode);
-    uint16 id = base::RandInt(0, kuint16max);
+    uint16_t id = base::RandInt(0, std::numeric_limits<uint16_t>::max());
     scoped_ptr<DnsSocketData> data(
         new DnsSocketData(id, dotted_name, qtype, mode, use_tcp));
     data->AddRcode(rcode, mode);
     AddSocketData(data.Pass());
   }
 
-  void AddAsyncQueryAndRcode(const char* dotted_name, uint16 qtype, int rcode) {
+  void AddAsyncQueryAndRcode(const char* dotted_name,
+                             uint16_t qtype,
+                             int rcode) {
     AddQueryAndRcode(dotted_name, qtype, rcode, ASYNC, false);
   }
 
-  void AddSyncQueryAndRcode(const char* dotted_name, uint16 qtype, int rcode) {
+  void AddSyncQueryAndRcode(const char* dotted_name,
+                            uint16_t qtype,
+                            int rcode) {
     AddQueryAndRcode(dotted_name, qtype, rcode, SYNCHRONOUS, false);
   }
 
   // Checks if the sockets were connected in the order matching the indices in
   // |servers|.
   void CheckServerOrder(const unsigned* servers, size_t num_attempts) {
     ASSERT_EQ(num_attempts, socket_factory_->remote_endpoints_.size());
     for (size_t i = 0; i < num_attempts; ++i) {
       EXPECT_EQ(socket_factory_->remote_endpoints_[i],
                 session_->config().nameservers[servers[i]]);
@@ skipping 340 matching lines @@
                             ERR_NAME_NOT_RESOLVED);
   EXPECT_TRUE(helper0.Run(transaction_factory_.get()));
 
   TransactionHelper helper1("x.y", dns_protocol::kTypeA, ERR_NAME_NOT_RESOLVED);
   EXPECT_TRUE(helper1.Run(transaction_factory_.get()));
 
   TransactionHelper helper2("x", dns_protocol::kTypeA, ERR_NAME_NOT_RESOLVED);
   EXPECT_TRUE(helper2.Run(transaction_factory_.get()));
 }
 
-const uint8 kResponseNoData[] = {
-  0x00, 0x00, 0x81, 0x80, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
-  // Question
-  0x01,  'x', 0x01,  'y', 0x01,  'z', 0x01,  'b', 0x00, 0x00, 0x01, 0x00, 0x01,
-  // Authority section, SOA record, TTL 0x3E6
-  0x01,  'z', 0x00, 0x00, 0x06, 0x00, 0x01, 0x00, 0x00, 0x03, 0xE6,
-  // Minimal RDATA, 18 bytes
-  0x00, 0x12,
-  0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00,
+const uint8_t kResponseNoData[] = {
+    0x00, 0x00, 0x81, 0x80, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+    // Question
+    0x01, 'x', 0x01, 'y', 0x01, 'z', 0x01, 'b', 0x00, 0x00, 0x01, 0x00, 0x01,
+    // Authority section, SOA record, TTL 0x3E6
+    0x01, 'z', 0x00, 0x00, 0x06, 0x00, 0x01, 0x00, 0x00, 0x03, 0xE6,
+    // Minimal RDATA, 18 bytes
+    0x00, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 };
 
 TEST_F(DnsTransactionTest, SuffixSearchStop) {
   config_.ndots = 2;
   config_.search.push_back("a");
   config_.search.push_back("b");
   config_.search.push_back("c");
   ConfigureFactory();
 
   AddAsyncQueryAndRcode("x.y.z", dns_protocol::kTypeA,
@@ skipping 98 matching lines @@
   scoped_ptr<DnsSocketData> data(
       new DnsSocketData(0 /* id */, kT0HostName, kT0Qtype, ASYNC, true));
   // Valid response but length too short.
   // This must be truncated in the question section. The DnsResponse doesn't
   // examine the answer section until asked to parse it, so truncating it in
   // the answer section would result in the DnsTransaction itself succeeding.
   data->AddResponseWithLength(
       make_scoped_ptr(
           new DnsResponse(reinterpret_cast<const char*>(kT0ResponseDatagram),
                           arraysize(kT0ResponseDatagram), 0)),
-      ASYNC,
-      static_cast<uint16>(kT0QuerySize - 1));
+      ASYNC, static_cast<uint16_t>(kT0QuerySize - 1));
   AddSocketData(data.Pass());
 
   TransactionHelper helper0(kT0HostName, kT0Qtype, ERR_DNS_MALFORMED_RESPONSE);
   EXPECT_TRUE(helper0.Run(transaction_factory_.get()));
 }
 
 TEST_F(DnsTransactionTest, TCPTimeout) {
   config_.timeout = TestTimeouts::tiny_timeout();
   ConfigureFactory();
   AddAsyncQueryAndRcode(kT0HostName, kT0Qtype,
                         dns_protocol::kRcodeNOERROR | dns_protocol::kFlagTC);
   AddSocketData(make_scoped_ptr(
       new DnsSocketData(1 /* id */, kT0HostName, kT0Qtype, ASYNC, true)));
 
   TransactionHelper helper0(kT0HostName, kT0Qtype, ERR_DNS_TIMED_OUT);
   EXPECT_TRUE(helper0.RunUntilDone(transaction_factory_.get()));
 }
 
 TEST_F(DnsTransactionTest, TCPReadReturnsZeroAsync) {
   AddAsyncQueryAndRcode(kT0HostName, kT0Qtype,
                         dns_protocol::kRcodeNOERROR | dns_protocol::kFlagTC);
   scoped_ptr<DnsSocketData> data(
       new DnsSocketData(0 /* id */, kT0HostName, kT0Qtype, ASYNC, true));
   // Return all but the last byte of the response.
   data->AddResponseWithLength(
       make_scoped_ptr(
           new DnsResponse(reinterpret_cast<const char*>(kT0ResponseDatagram),
                           arraysize(kT0ResponseDatagram) - 1, 0)),
-      ASYNC,
-      static_cast<uint16>(arraysize(kT0ResponseDatagram)));
+      ASYNC, static_cast<uint16_t>(arraysize(kT0ResponseDatagram)));
   // Then return a 0-length read.
   data->AddReadError(0, ASYNC);
   AddSocketData(data.Pass());
 
   TransactionHelper helper0(kT0HostName, kT0Qtype, ERR_CONNECTION_CLOSED);
   EXPECT_TRUE(helper0.Run(transaction_factory_.get()));
 }
 
 TEST_F(DnsTransactionTest, TCPReadReturnsZeroSynchronous) {
   AddAsyncQueryAndRcode(kT0HostName, kT0Qtype,
                         dns_protocol::kRcodeNOERROR | dns_protocol::kFlagTC);
   scoped_ptr<DnsSocketData> data(
       new DnsSocketData(0 /* id */, kT0HostName, kT0Qtype, ASYNC, true));
   // Return all but the last byte of the response.
   data->AddResponseWithLength(
       make_scoped_ptr(
           new DnsResponse(reinterpret_cast<const char*>(kT0ResponseDatagram),
                           arraysize(kT0ResponseDatagram) - 1, 0)),
-      SYNCHRONOUS,
-      static_cast<uint16>(arraysize(kT0ResponseDatagram)));
+      SYNCHRONOUS, static_cast<uint16_t>(arraysize(kT0ResponseDatagram)));
   // Then return a 0-length read.
   data->AddReadError(0, SYNCHRONOUS);
   AddSocketData(data.Pass());
 
   TransactionHelper helper0(kT0HostName, kT0Qtype, ERR_CONNECTION_CLOSED);
   EXPECT_TRUE(helper0.Run(transaction_factory_.get()));
 }
 
 TEST_F(DnsTransactionTest, TCPConnectionClosedAsync) {
   AddAsyncQueryAndRcode(kT0HostName, kT0Qtype,
@@ skipping 23 matching lines @@
   config_.timeout = TestTimeouts::tiny_timeout();
   ConfigureFactory();
 
   TransactionHelper helper0(".", dns_protocol::kTypeA, ERR_INVALID_ARGUMENT);
   EXPECT_TRUE(helper0.Run(transaction_factory_.get()));
 }
 
 }  // namespace
 
 }  // namespace net