Clang format slam.

net/dns/mdns_client_impl.cc

Index: net/dns/mdns_client_impl.cc
diff --git a/net/dns/mdns_client_impl.cc b/net/dns/mdns_client_impl.cc
index 68cee7a87ec1572b395a964ec6b4de588fedb4b1..1725039522b999c8398e42d91d967c77c78f010d 100644
--- a/net/dns/mdns_client_impl.cc
+++ b/net/dns/mdns_client_impl.cc
@@ -99,17 +99,19 @@ void MDnsConnection::SocketHandler::OnDatagramReceived(int rv) {
 }
 
 int MDnsConnection::SocketHandler::Send(IOBuffer* buffer, unsigned size) {
-  return socket_->SendTo(buffer, size, multicast_addr_,
+  return socket_->SendTo(buffer,
+                         size,
+                         multicast_addr_,
                          base::Bind(&MDnsConnection::SocketHandler::SendDone,
-                                    base::Unretained(this) ));
+                                    base::Unretained(this)));
 }
 
 void MDnsConnection::SocketHandler::SendDone(int rv) {
   // TODO(noamsml): Retry logic.
 }
 
-MDnsConnection::MDnsConnection(MDnsConnection::Delegate* delegate) :
-      delegate_(delegate) {
+MDnsConnection::MDnsConnection(MDnsConnection::Delegate* delegate)
+    : delegate_(delegate) {
 }
 
 MDnsConnection::~MDnsConnection() {
@@ -154,17 +156,15 @@ bool MDnsConnection::Send(IOBuffer* buffer, unsigned size) {
   return success;
 }
 
-void MDnsConnection::OnError(SocketHandler* loop,
-                             int error) {
+void MDnsConnection::OnError(SocketHandler* loop, int error) {
   // TODO(noamsml): Specific handling of intermittent errors that can be handled
   // in the connection.
   delegate_->OnConnectionError(error);
 }
 
-void MDnsConnection::OnDatagramReceived(
-    DnsResponse* response,
-    const IPEndPoint& recv_addr,
-    int bytes_read) {
+void MDnsConnection::OnDatagramReceived(DnsResponse* response,
+                                        const IPEndPoint& recv_addr,
+                                        int bytes_read) {
   // TODO(noamsml): More sophisticated error handling.
   DCHECK_GT(bytes_read, 0);
   delegate_->HandlePacket(response, bytes_read);
@@ -193,8 +193,7 @@ bool MDnsClientImpl::Core::SendQuery(uint16 rrtype, std::string name) {
   return connection_->Send(query.io_buffer(), query.io_buffer()->size());
 }
 
-void MDnsClientImpl::Core::HandlePacket(DnsResponse* response,
-                                        int bytes_read) {
+void MDnsClientImpl::Core::HandlePacket(DnsResponse* response, int bytes_read) {
   unsigned offset;
   // Note: We store cache keys rather than record pointers to avoid
   // erroneous behavior in case a packet contains multiple exclusive
@@ -211,13 +210,13 @@ void MDnsClientImpl::Core::HandlePacket(DnsResponse* response,
     return;  // Message is a query. ignore it.
 
   DnsRecordParser parser = response->Parser();
-  unsigned answer_count = response->answer_count() +
-      response->additional_answer_count();
+  unsigned answer_count =
+      response->answer_count() + response->additional_answer_count();
 
   for (unsigned i = 0; i < answer_count; i++) {
     offset = parser.GetOffset();
-    scoped_ptr<const RecordParsed> record = RecordParsed::CreateFrom(
-        &parser, base::Time::Now());
+    scoped_ptr<const RecordParsed> record =
+        RecordParsed::CreateFrom(&parser, base::Time::Now());
 
     if (!record) {
       DVLOG(1) << "Could not understand an mDNS record.";
@@ -246,7 +245,9 @@ void MDnsClientImpl::Core::HandlePacket(DnsResponse* response,
   }
 
   for (std::map<MDnsCache::Key, MDnsCache::UpdateType>::iterator i =
-           update_keys.begin(); i != update_keys.end(); i++) {
+           update_keys.begin();
+       i != update_keys.end();
+       i++) {
     const RecordParsed* record = cache_.LookupKey(i->first);
     if (!record)
       continue;
@@ -256,8 +257,8 @@ void MDnsClientImpl::Core::HandlePacket(DnsResponse* response,
       NotifyNsecRecord(record);
 #endif
     } else {
-      AlertListeners(i->second, ListenerKey(record->name(), record->type()),
-                     record);
+      AlertListeners(
+          i->second, ListenerKey(record->name(), record->type()), record);
     }
   }
 }
@@ -270,11 +271,12 @@ void MDnsClientImpl::Core::NotifyNsecRecord(const RecordParsed* record) {
   // Remove all cached records matching the nonexistent RR types.
   std::vector<const RecordParsed*> records_to_remove;
 
-  cache_.FindDnsRecords(0, record->name(), &records_to_remove,
-                        base::Time::Now());
+  cache_.FindDnsRecords(
+      0, record->name(), &records_to_remove, base::Time::Now());
 
   for (std::vector<const RecordParsed*>::iterator i = records_to_remove.begin();
-       i != records_to_remove.end(); i++) {
+       i != records_to_remove.end();
+       i++) {
     if ((*i)->type() == dns_protocol::kTypeNSEC)
       continue;
     if (!rdata->GetBit((*i)->type())) {
@@ -298,19 +300,19 @@ void MDnsClientImpl::Core::OnConnectionError(int error) {
   // TODO(noamsml): On connection error, recreate connection and flush cache.
 }
 
-void MDnsClientImpl::Core::AlertListeners(
-    MDnsCache::UpdateType update_type,
-    const ListenerKey& key,
-    const RecordParsed* record) {
+void MDnsClientImpl::Core::AlertListeners(MDnsCache::UpdateType update_type,
+                                          const ListenerKey& key,
+                                          const RecordParsed* record) {
   ListenerMap::iterator listener_map_iterator = listeners_.find(key);
-  if (listener_map_iterator == listeners_.end()) return;
+  if (listener_map_iterator == listeners_.end())
+    return;
 
-  FOR_EACH_OBSERVER(MDnsListenerImpl, *listener_map_iterator->second,
+  FOR_EACH_OBSERVER(MDnsListenerImpl,
+                    *listener_map_iterator->second,
                     HandleRecordUpdate(update_type, record));
 }
 
-void MDnsClientImpl::Core::AddListener(
-    MDnsListenerImpl* listener) {
+void MDnsClientImpl::Core::AddListener(MDnsListenerImpl* listener) {
   ListenerKey key(listener->GetName(), listener->GetType());
   std::pair<ListenerMap::iterator, bool> observer_insert_result =
       listeners_.insert(
@@ -340,7 +342,8 @@ void MDnsClientImpl::Core::RemoveListener(MDnsListenerImpl* listener) {
     // Schedule the actual removal for later in case the listener removal
     // happens while iterating over the observer list.
     base::MessageLoop::current()->PostTask(
-        FROM_HERE, base::Bind(
+        FROM_HERE,
+        base::Bind(
             &MDnsClientImpl::Core::CleanupObserverList, AsWeakPtr(), key));
   }
 }
@@ -355,37 +358,38 @@ void MDnsClientImpl::Core::CleanupObserverList(const ListenerKey& key) {
 
 void MDnsClientImpl::Core::ScheduleCleanup(base::Time cleanup) {
   // Cleanup is already scheduled, no need to do anything.
-  if (cleanup == scheduled_cleanup_) return;
+  if (cleanup == scheduled_cleanup_)
+    return;
   scheduled_cleanup_ = cleanup;
 
   // This cancels the previously scheduled cleanup.
-  cleanup_callback_.Reset(base::Bind(
-      &MDnsClientImpl::Core::DoCleanup, base::Unretained(this)));
+  cleanup_callback_.Reset(
+      base::Bind(&MDnsClientImpl::Core::DoCleanup, base::Unretained(this)));
 
   // If |cleanup| is empty, then no cleanup necessary.
   if (cleanup != base::Time()) {
     base::MessageLoop::current()->PostDelayedTask(
-        FROM_HERE,
-        cleanup_callback_.callback(),
-        cleanup - base::Time::Now());
+        FROM_HERE, cleanup_callback_.callback(), cleanup - base::Time::Now());
   }
 }
 
 void MDnsClientImpl::Core::DoCleanup() {
-  cache_.CleanupRecords(base::Time::Now(), base::Bind(
-      &MDnsClientImpl::Core::OnRecordRemoved, base::Unretained(this)));
+  cache_.CleanupRecords(base::Time::Now(),
+                        base::Bind(&MDnsClientImpl::Core::OnRecordRemoved,
+                                   base::Unretained(this)));
 
   ScheduleCleanup(cache_.next_expiration());
 }
 
-void MDnsClientImpl::Core::OnRecordRemoved(
-    const RecordParsed* record) {
+void MDnsClientImpl::Core::OnRecordRemoved(const RecordParsed* record) {
   AlertListeners(MDnsCache::RecordRemoved,
-                 ListenerKey(record->name(), record->type()), record);
+                 ListenerKey(record->name(), record->type()),
+                 record);
 }
 
 void MDnsClientImpl::Core::QueryCache(
-    uint16 rrtype, const std::string& name,
+    uint16 rrtype,
+    const std::string& name,
     std::vector<const RecordParsed*>* records) const {
   cache_.FindDnsRecords(rrtype, name, records, base::Time::Now());
 }
@@ -431,13 +435,16 @@ scoped_ptr<MDnsTransaction> MDnsClientImpl::CreateTransaction(
       new MDnsTransactionImpl(rrtype, name, flags, callback, this));
 }
 
-MDnsListenerImpl::MDnsListenerImpl(
-    uint16 rrtype,
-    const std::string& name,
-    MDnsListener::Delegate* delegate,
-    MDnsClientImpl* client)
-    : rrtype_(rrtype), name_(name), client_(client), delegate_(delegate),
-      started_(false), active_refresh_(false) {
+MDnsListenerImpl::MDnsListenerImpl(uint16 rrtype,
+                                   const std::string& name,
+                                   MDnsListener::Delegate* delegate,
+                                   MDnsClientImpl* client)
+    : rrtype_(rrtype),
+      name_(name),
+      client_(client),
+      delegate_(delegate),
+      started_(false),
+      active_refresh_(false) {
 }
 
 MDnsListenerImpl::~MDnsListenerImpl() {
@@ -531,29 +538,26 @@ void MDnsListenerImpl::ScheduleNextRefresh() {
     return;
   }
 
-  next_refresh_.Reset(base::Bind(&MDnsListenerImpl::DoRefresh,
-                                 AsWeakPtr()));
+  next_refresh_.Reset(base::Bind(&MDnsListenerImpl::DoRefresh, AsWeakPtr()));
 
   // Schedule refreshes at both 85% and 95% of the original TTL. These will both
   // be canceled and rescheduled if the record's TTL is updated due to a
   // response being received.
-  base::Time next_refresh1 = last_update_ + base::TimeDelta::FromMilliseconds(
-      static_cast<int>(kMillisecondsPerSecond *
-                       kListenerRefreshRatio1 * ttl_));
+  base::Time next_refresh1 =
+      last_update_ +
+      base::TimeDelta::FromMilliseconds(static_cast<int>(
+          kMillisecondsPerSecond * kListenerRefreshRatio1 * ttl_));
 
-  base::Time next_refresh2 = last_update_ + base::TimeDelta::FromMilliseconds(
-      static_cast<int>(kMillisecondsPerSecond *
-                       kListenerRefreshRatio2 * ttl_));
+  base::Time next_refresh2 =
+      last_update_ +
+      base::TimeDelta::FromMilliseconds(static_cast<int>(
+          kMillisecondsPerSecond * kListenerRefreshRatio2 * ttl_));
 
   base::MessageLoop::current()->PostDelayedTask(
-      FROM_HERE,
-      next_refresh_.callback(),
-      next_refresh1 - base::Time::Now());
+      FROM_HERE, next_refresh_.callback(), next_refresh1 - base::Time::Now());
 
   base::MessageLoop::current()->PostDelayedTask(
-      FROM_HERE,
-      next_refresh_.callback(),
-      next_refresh2 - base::Time::Now());
+      FROM_HERE, next_refresh_.callback(), next_refresh2 - base::Time::Now());
 }
 
 void MDnsListenerImpl::DoRefresh() {
@@ -566,8 +570,12 @@ MDnsTransactionImpl::MDnsTransactionImpl(
     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);
@@ -585,7 +593,8 @@ bool MDnsTransactionImpl::Start() {
   if (flags_ & MDnsTransaction::QUERY_CACHE) {
     ServeRecordsFromCache();
 
-    if (!weak_this || !is_active()) return true;
+    if (!weak_this || !is_active())
+      return true;
   }
 
   if (flags_ & MDnsTransaction::QUERY_NETWORK) {
@@ -614,7 +623,8 @@ void MDnsTransactionImpl::CacheRecordFound(const RecordParsed* record) {
 void MDnsTransactionImpl::TriggerCallback(MDnsTransaction::Result result,
                                           const RecordParsed* record) {
   DCHECK(started_);
-  if (!is_active()) return;
+  if (!is_active())
+    return;
 
   // Ensure callback is run after touching all class state, so that
   // the callback can delete the transaction.
@@ -639,7 +649,7 @@ void MDnsTransactionImpl::Reset() {
 void MDnsTransactionImpl::OnRecordUpdate(MDnsListener::UpdateType update,
                                          const RecordParsed* record) {
   DCHECK(started_);
-  if (update ==  MDnsListener::RECORD_ADDED ||
+  if (update == MDnsListener::RECORD_ADDED ||
       update == MDnsListener::RECORD_CHANGED)
     TriggerCallback(MDnsTransaction::RESULT_RECORD, record);
 }
@@ -660,7 +670,8 @@ void MDnsTransactionImpl::ServeRecordsFromCache() {
   if (client_->core()) {
     client_->core()->QueryCache(rrtype_, name_, &records);
     for (std::vector<const RecordParsed*>::iterator i = records.begin();
-         i != records.end() && weak_this; ++i) {
+         i != records.end() && weak_this;
+         ++i) {
       weak_this->TriggerCallback(MDnsTransaction::RESULT_RECORD, *i);
     }
 
@@ -689,8 +700,8 @@ bool MDnsTransactionImpl::QueryAndListen() {
   if (!client_->core()->SendQuery(rrtype_, name_))
     return false;
 
-  timeout_.Reset(base::Bind(&MDnsTransactionImpl::SignalTransactionOver,
-                            AsWeakPtr()));
+  timeout_.Reset(
+      base::Bind(&MDnsTransactionImpl::SignalTransactionOver, AsWeakPtr()));
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       timeout_.callback(),