Switch to standard integer types in net/.

net/dns/dns_transaction.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 <deque>
 #include <string>
 #include <vector>
 
 #include "base/big_endian.h"
 #include "base/bind.h"
 #include "base/location.h"
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/rand_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_piece.h"
 #include "base/thread_task_runner_handle.h"
@@ skipping 30 matching lines @@
   return count;
 }
 
 bool IsIPLiteral(const std::string& hostname) {
   IPAddressNumber ip;
   return ParseIPLiteralToNumber(hostname, &ip);
 }
 
 scoped_ptr<base::Value> NetLogStartCallback(
     const std::string* hostname,
-    uint16 qtype,
+    uint16_t qtype,
     NetLogCaptureMode /* capture_mode */) {
   scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   dict->SetString("hostname", *hostname);
   dict->SetInteger("query_type", qtype);
   return dict.Pass();
 };
 
 // ----------------------------------------------------------------------------
 
 // A single asynchronous DNS exchange, which consists of sending out a
@@ skipping 222 matching lines @@
 
 class DnsTCPAttempt : public DnsAttempt {
  public:
   DnsTCPAttempt(unsigned server_index,
                 scoped_ptr<StreamSocket> socket,
                 scoped_ptr<DnsQuery> query)
       : DnsAttempt(server_index),
         next_state_(STATE_NONE),
         socket_(socket.Pass()),
         query_(query.Pass()),
-        length_buffer_(new IOBufferWithSize(sizeof(uint16))),
+        length_buffer_(new IOBufferWithSize(sizeof(uint16_t))),
         response_length_(0) {}
 
   // DnsAttempt:
   int Start(const CompletionCallback& callback) override {
     DCHECK_EQ(STATE_NONE, next_state_);
     callback_ = callback;
     start_time_ = base::TimeTicks::Now();
     next_state_ = STATE_CONNECT_COMPLETE;
     int rv = socket_->Connect(base::Bind(&DnsTCPAttempt::OnIOComplete,
                                          base::Unretained(this)));
@@ skipping 76 matching lines @@
   int DoConnectComplete(int rv) {
     // TODO(rvargas): Remove ScopedTracker below once crbug.com/462784 is fixed.
     tracked_objects::ScopedTracker tracking_profile(
         FROM_HERE_WITH_EXPLICIT_FUNCTION(
             "462784 DnsTCPAttempt::DoConnectComplete"));
 
     DCHECK_NE(ERR_IO_PENDING, rv);
     if (rv < 0)
       return rv;
 
-    uint16 query_size = static_cast<uint16>(query_->io_buffer()->size());
+    uint16_t query_size = static_cast<uint16_t>(query_->io_buffer()->size());
     if (static_cast<int>(query_size) != query_->io_buffer()->size())
       return ERR_FAILED;
-    base::WriteBigEndian<uint16>(length_buffer_->data(), query_size);
+    base::WriteBigEndian<uint16_t>(length_buffer_->data(), query_size);
     buffer_ =
         new DrainableIOBuffer(length_buffer_.get(), length_buffer_->size());
     next_state_ = STATE_SEND_LENGTH;
     return OK;
   }
 
   int DoSendLength(int rv) {
     DCHECK_NE(ERR_IO_PENDING, rv);
     if (rv < 0)
       return rv;
@@ skipping 44 matching lines @@
       return rv;
     if (rv == 0)
       return ERR_CONNECTION_CLOSED;
 
     buffer_->DidConsume(rv);
     if (buffer_->BytesRemaining() > 0) {
       next_state_ = STATE_READ_LENGTH;
       return OK;
     }
 
-    base::ReadBigEndian<uint16>(length_buffer_->data(), &response_length_);
+    base::ReadBigEndian<uint16_t>(length_buffer_->data(), &response_length_);
     // Check if advertised response is too short. (Optimization only.)
     if (response_length_ < query_->io_buffer()->size())
       return ERR_DNS_MALFORMED_RESPONSE;
     // Allocate more space so that DnsResponse::InitParse sanity check passes.
     response_.reset(new DnsResponse(response_length_ + 1));
     buffer_ = new DrainableIOBuffer(response_->io_buffer(), response_length_);
     next_state_ = STATE_READ_RESPONSE;
     return OK;
   }
 
@@ skipping 44 matching lines @@
   }
 
   State next_state_;
   base::TimeTicks start_time_;
 
   scoped_ptr<StreamSocket> socket_;
   scoped_ptr<DnsQuery> query_;
   scoped_refptr<IOBufferWithSize> length_buffer_;
   scoped_refptr<DrainableIOBuffer> buffer_;
 
-  uint16 response_length_;
+  uint16_t response_length_;
   scoped_ptr<DnsResponse> response_;
 
   CompletionCallback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(DnsTCPAttempt);
 };
 
 // ----------------------------------------------------------------------------
 
 // Implements DnsTransaction. Configuration is supplied by DnsSession.
 // The suffix list is built according to the DnsConfig from the session.
 // The timeout for each DnsUDPAttempt is given by DnsSession::NextTimeout.
 // The first server to attempt on each query is given by
 // DnsSession::NextFirstServerIndex, and the order is round-robin afterwards.
 // Each server is attempted DnsConfig::attempts times.
 class DnsTransactionImpl : public DnsTransaction,
                            public base::NonThreadSafe,
                            public base::SupportsWeakPtr<DnsTransactionImpl> {
  public:
   DnsTransactionImpl(DnsSession* session,
                      const std::string& hostname,
-                     uint16 qtype,
+                     uint16_t qtype,
                      const DnsTransactionFactory::CallbackType& callback,
                      const BoundNetLog& net_log)
-    : session_(session),
-      hostname_(hostname),
-      qtype_(qtype),
-      callback_(callback),
-      net_log_(net_log),
-      qnames_initial_size_(0),
-      attempts_count_(0),
-      had_tcp_attempt_(false),
-      first_server_index_(0) {
+      : session_(session),
+        hostname_(hostname),
+        qtype_(qtype),
+        callback_(callback),
+        net_log_(net_log),
+        qnames_initial_size_(0),
+        attempts_count_(0),
+        had_tcp_attempt_(false),
+        first_server_index_(0) {
     DCHECK(session_.get());
     DCHECK(!hostname_.empty());
     DCHECK(!callback_.is_null());
     DCHECK(!IsIPLiteral(hostname_));
   }
 
   ~DnsTransactionImpl() override {
     if (!callback_.is_null()) {
       net_log_.EndEventWithNetErrorCode(NetLog::TYPE_DNS_TRANSACTION,
                                         ERR_ABORTED);
     }  // otherwise logged in DoCallback or Start
   }
 
   const std::string& GetHostname() const override {
     DCHECK(CalledOnValidThread());
     return hostname_;
   }
 
-  uint16 GetType() const override {
+  uint16_t GetType() const override {
     DCHECK(CalledOnValidThread());
     return qtype_;
   }
 
   void Start() override {
     DCHECK(!callback_.is_null());
     DCHECK(attempts_.empty());
     net_log_.BeginEvent(NetLog::TYPE_DNS_TRANSACTION,
                         base::Bind(&NetLogStartCallback, &hostname_, qtype_));
     AttemptResult result(PrepareSearch(), NULL);
@@ skipping 95 matching lines @@
 
     net_log_.EndEventWithNetErrorCode(NetLog::TYPE_DNS_TRANSACTION, result.rv);
     callback.Run(this, result.rv, response);
   }
 
   // Makes another attempt at the current name, |qnames_.front()|, using the
   // next nameserver.
   AttemptResult MakeAttempt() {
     unsigned attempt_number = attempts_.size();
 
-    uint16 id = session_->NextQueryId();
+    uint16_t id = session_->NextQueryId();
     scoped_ptr<DnsQuery> query;
     if (attempts_.empty()) {
       query.reset(new DnsQuery(id, qnames_.front(), qtype_));
     } else {
       query = attempts_[0]->GetQuery()->CloneWithNewId(id);
     }
 
     const DnsConfig& config = session_->config();
 
     unsigned server_index =
@@ skipping 34 matching lines @@
   AttemptResult MakeTCPAttempt(const DnsAttempt* previous_attempt) {
     DCHECK(previous_attempt);
     DCHECK(!had_tcp_attempt_);
 
     unsigned server_index = previous_attempt->server_index();
 
     scoped_ptr<StreamSocket> socket(
         session_->CreateTCPSocket(server_index, net_log_.source()));
 
     // TODO(szym): Reuse the same id to help the server?
-    uint16 id = session_->NextQueryId();
+    uint16_t id = session_->NextQueryId();
     scoped_ptr<DnsQuery> query =
         previous_attempt->GetQuery()->CloneWithNewId(id);
 
     RecordLostPacketsIfAny();
     // Cancel all other attempts, no point waiting on them.
     attempts_.clear();
 
     unsigned attempt_number = attempts_.size();
 
     DnsTCPAttempt* attempt = new DnsTCPAttempt(server_index, socket.Pass(),
@@ skipping 163 matching lines @@
       return;
     DCHECK(!attempts_.empty());
     AttemptResult result = ProcessAttemptResult(
         AttemptResult(ERR_DNS_TIMED_OUT, attempts_.back().get()));
     if (result.rv != ERR_IO_PENDING)
       DoCallback(result);
   }
 
   scoped_refptr<DnsSession> session_;
   std::string hostname_;
-  uint16 qtype_;
+  uint16_t qtype_;
   // Cleared in DoCallback.
   DnsTransactionFactory::CallbackType callback_;
 
   BoundNetLog net_log_;
 
   // Search list of fully-qualified DNS names to query next (in DNS format).
   std::deque<std::string> qnames_;
   size_t qnames_initial_size_;
 
   // List of attempts for the current name.
@@ skipping 15 matching lines @@
 // Implementation of DnsTransactionFactory that returns instances of
 // DnsTransactionImpl.
 class DnsTransactionFactoryImpl : public DnsTransactionFactory {
  public:
   explicit DnsTransactionFactoryImpl(DnsSession* session) {
     session_ = session;
   }
 
   scoped_ptr<DnsTransaction> CreateTransaction(
       const std::string& hostname,
-      uint16 qtype,
+      uint16_t qtype,
       const CallbackType& callback,
       const BoundNetLog& net_log) override {
     return scoped_ptr<DnsTransaction>(new DnsTransactionImpl(
         session_.get(), hostname, qtype, callback, net_log));
   }
 
  private:
   scoped_refptr<DnsSession> session_;
 };
 
 }  // namespace
 
 // static
 scoped_ptr<DnsTransactionFactory> DnsTransactionFactory::CreateFactory(
     DnsSession* session) {
   return scoped_ptr<DnsTransactionFactory>(
       new DnsTransactionFactoryImpl(session));
 }
 
 }  // namespace net