Switch to standard integer types in net/.

net/dns/mdns_client_impl.cc

 // Copyright 2013 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/mdns_client_impl.h"
 
 #include <algorithm>
 #include <queue>
 
 #include "base/bind.h"
@@ skipping 197 matching lines @@
 }
 
 MDnsClientImpl::Core::~Core() {
   STLDeleteValues(&listeners_);
 }
 
 bool MDnsClientImpl::Core::Init(MDnsSocketFactory* socket_factory) {
   return connection_->Init(socket_factory);
 }
 
-bool MDnsClientImpl::Core::SendQuery(uint16 rrtype, const std::string& name) {
+bool MDnsClientImpl::Core::SendQuery(uint16_t rrtype, const std::string& name) {
   std::string name_dns;
   if (!DNSDomainFromDot(name, &name_dns))
     return false;
 
   DnsQuery query(0, name_dns, rrtype);
   query.set_flags(0);  // Remove the RD flag from the query. It is unneeded.
 
   connection_->Send(query.io_buffer(), query.io_buffer()->size());
   return true;
 }
@@ skipping 185 matching lines @@
   ScheduleCleanup(cache_.next_expiration());
 }
 
 void MDnsClientImpl::Core::OnRecordRemoved(
     const RecordParsed* record) {
   AlertListeners(MDnsCache::RecordRemoved,
                  ListenerKey(record->name(), record->type()), record);
 }
 
 void MDnsClientImpl::Core::QueryCache(
-    uint16 rrtype, const std::string& name,
+    uint16_t rrtype,
+    const std::string& name,
     std::vector<const RecordParsed*>* records) const {
   cache_.FindDnsRecords(rrtype, name, records, clock_->Now());
 }
 
 MDnsClientImpl::MDnsClientImpl()
     : clock_(new base::DefaultClock),
       cleanup_timer_(new base::Timer(false, false)) {
 }
 
 MDnsClientImpl::MDnsClientImpl(scoped_ptr<base::Clock> clock,
@@ skipping 16 matching lines @@
 
 void MDnsClientImpl::StopListening() {
   core_.reset();
 }
 
 bool MDnsClientImpl::IsListening() const {
   return core_.get() != NULL;
 }
 
 scoped_ptr<MDnsListener> MDnsClientImpl::CreateListener(
-    uint16 rrtype,
+    uint16_t rrtype,
     const std::string& name,
     MDnsListener::Delegate* delegate) {
   return scoped_ptr<MDnsListener>(
       new MDnsListenerImpl(rrtype, name, clock_.get(), delegate, this));
 }
 
 scoped_ptr<MDnsTransaction> MDnsClientImpl::CreateTransaction(
-    uint16 rrtype,
+    uint16_t rrtype,
     const std::string& name,
     int flags,
     const MDnsTransaction::ResultCallback& callback) {
   return scoped_ptr<MDnsTransaction>(
       new MDnsTransactionImpl(rrtype, name, flags, callback, this));
 }
 
-MDnsListenerImpl::MDnsListenerImpl(uint16 rrtype,
+MDnsListenerImpl::MDnsListenerImpl(uint16_t rrtype,
                                    const std::string& name,
                                    base::Clock* clock,
                                    MDnsListener::Delegate* delegate,
                                    MDnsClientImpl* client)
     : rrtype_(rrtype),
       name_(name),
       clock_(clock),
       client_(client),
       delegate_(delegate),
       started_(false),
-      active_refresh_(false) {
-}
+      active_refresh_(false) {}
 
 MDnsListenerImpl::~MDnsListenerImpl() {
   if (started_) {
     DCHECK(client_->core());
     client_->core()->RemoveListener(this);
   }
 }
 
 bool MDnsListenerImpl::Start() {
   DCHECK(!started_);
@@ skipping 15 matching lines @@
     } else if (last_update_ != base::Time()) {
       ScheduleNextRefresh();
     }
   }
 }
 
 const std::string& MDnsListenerImpl::GetName() const {
   return name_;
 }
 
-uint16 MDnsListenerImpl::GetType() const {
+uint16_t MDnsListenerImpl::GetType() const {
   return rrtype_;
 }
 
 void MDnsListenerImpl::HandleRecordUpdate(MDnsCache::UpdateType update_type,
                                           const RecordParsed* record) {
   DCHECK(started_);
 
   if (update_type != MDnsCache::RecordRemoved) {
     ttl_ = record->ttl();
     last_update_ = record->time_created();
@@ skipping 62 matching lines @@
 
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE, next_refresh_.callback(), next_refresh2 - clock_->Now());
 }
 
 void MDnsListenerImpl::DoRefresh() {
   client_->core()->SendQuery(rrtype_, name_);
 }
 
 MDnsTransactionImpl::MDnsTransactionImpl(
-    uint16 rrtype,
+    uint16_t rrtype,
     const std::string& name,
     int flags,
     const MDnsTransaction::ResultCallback& callback,
     MDnsClientImpl* client)
-    : rrtype_(rrtype), name_(name), callback_(callback), client_(client),
-      started_(false), flags_(flags) {
+    : rrtype_(rrtype),
+      name_(name),
+      callback_(callback),
+      client_(client),
+      started_(false),
+      flags_(flags) {
   DCHECK((flags_ & MDnsTransaction::FLAG_MASK) == flags_);
   DCHECK(flags_ & MDnsTransaction::QUERY_CACHE ||
          flags_ & MDnsTransaction::QUERY_NETWORK);
 }
 
 MDnsTransactionImpl::~MDnsTransactionImpl() {
   timeout_.Cancel();
 }
 
 bool MDnsTransactionImpl::Start() {
@@ skipping 14 matching lines @@
   // If this is a cache only query, signal that the transaction is over
   // immediately.
   SignalTransactionOver();
   return true;
 }
 
 const std::string& MDnsTransactionImpl::GetName() const {
   return name_;
 }
 
-uint16 MDnsTransactionImpl::GetType() const {
+uint16_t MDnsTransactionImpl::GetType() const {
   return rrtype_;
 }
 
 void MDnsTransactionImpl::CacheRecordFound(const RecordParsed* record) {
   DCHECK(started_);
   OnRecordUpdate(MDnsListener::RECORD_ADDED, record);
 }
 
 void MDnsTransactionImpl::TriggerCallback(MDnsTransaction::Result result,
                                           const RecordParsed* record) {
@@ skipping 84 matching lines @@
 
 void MDnsTransactionImpl::OnNsecRecord(const std::string& name, unsigned type) {
   TriggerCallback(RESULT_NSEC, NULL);
 }
 
 void MDnsTransactionImpl::OnCachePurged() {
   // TODO(noamsml): Cache purge situations not yet implemented
 }
 
 }  // namespace net