Clang format slam.

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>
 
@@ skipping 23 matching lines @@
 #include "net/dns/dns_session.h"
 #include "net/socket/stream_socket.h"
 #include "net/udp/datagram_client_socket.h"
 
 namespace net {
 
 namespace {
 
 // Provide a common macro to simplify code and readability. We must use a
 // macro as the underlying HISTOGRAM macro creates static variables.
-#define DNS_HISTOGRAM(name, time) UMA_HISTOGRAM_CUSTOM_TIMES(name, time, \
-    base::TimeDelta::FromMilliseconds(1), base::TimeDelta::FromHours(1), 100)
+#define DNS_HISTOGRAM(name, time)                                  \
+  UMA_HISTOGRAM_CUSTOM_TIMES(name,                                 \
+                             time,                                 \
+                             base::TimeDelta::FromMilliseconds(1), \
+                             base::TimeDelta::FromHours(1),        \
+                             100)
 
 // Count labels in the fully-qualified name in DNS format.
 int CountLabels(const std::string& name) {
   size_t count = 0;
   for (size_t i = 0; i < name.size() && name[i]; i += name[i] + 1)
     ++count;
   return count;
 }
 
 bool IsIPLiteral(const std::string& hostname) {
   IPAddressNumber ip;
   return ParseIPLiteralToNumber(hostname, &ip);
 }
 
 base::Value* NetLogStartCallback(const std::string* hostname,
-                           uint16 qtype,
-                           NetLog::LogLevel /* log_level */) {
+                                 uint16 qtype,
+                                 NetLog::LogLevel /* log_level */) {
   base::DictionaryValue* dict = new base::DictionaryValue();
   dict->SetString("hostname", *hostname);
   dict->SetInteger("query_type", qtype);
   return dict;
 };
 
 // ----------------------------------------------------------------------------
 
 // A single asynchronous DNS exchange, which consists of sending out a
 // DNS query, waiting for a response, and returning the response that it
@@ skipping 27 matching lines @@
   base::Value* NetLogResponseCallback(NetLog::LogLevel log_level) const {
     DCHECK(GetResponse()->IsValid());
 
     base::DictionaryValue* dict = new base::DictionaryValue();
     dict->SetInteger("rcode", GetResponse()->rcode());
     dict->SetInteger("answer_count", GetResponse()->answer_count());
     GetSocketNetLog().source().AddToEventParameters(dict);
     return dict;
   }
 
-  void set_result(int result) {
-    result_ = result;
-  }
+  void set_result(int result) { result_ = result; }
 
   // True if current attempt is pending (waiting for server response).
-  bool is_pending() const {
-    return result_ == ERR_IO_PENDING;
-  }
+  bool is_pending() const { return result_ == ERR_IO_PENDING; }
 
   // True if attempt is completed (received server response).
   bool is_completed() const {
     return (result_ == OK) || (result_ == ERR_NAME_NOT_RESOLVED) ||
-        (result_ == ERR_DNS_SERVER_REQUIRES_TCP);
+           (result_ == ERR_DNS_SERVER_REQUIRES_TCP);
   }
 
  private:
   // Result of last operation.
   int result_;
 
   const unsigned server_index_;
 };
 
 class DnsUDPAttempt : public DnsAttempt {
  public:
   DnsUDPAttempt(unsigned server_index,
                 scoped_ptr<DnsSession::SocketLease> socket_lease,
                 scoped_ptr<DnsQuery> query)
       : DnsAttempt(server_index),
         next_state_(STATE_NONE),
         received_malformed_response_(false),
         socket_lease_(socket_lease.Pass()),
         query_(query.Pass()) {}
 
   // DnsAttempt:
   virtual int Start(const CompletionCallback& callback) OVERRIDE {
     DCHECK_EQ(STATE_NONE, next_state_);
     callback_ = callback;
     start_time_ = base::TimeTicks::Now();
     next_state_ = STATE_SEND_QUERY;
     return DoLoop(OK);
   }
 
-  virtual const DnsQuery* GetQuery() const OVERRIDE {
-    return query_.get();
-  }
+  virtual const DnsQuery* GetQuery() const OVERRIDE { return query_.get(); }
 
   virtual const DnsResponse* GetResponse() const OVERRIDE {
     const DnsResponse* resp = response_.get();
     return (resp != NULL && resp->IsValid()) ? resp : NULL;
   }
 
   virtual const BoundNetLog& GetSocketNetLog() const OVERRIDE {
     return socket_lease_->socket()->NetLog();
   }
 
  private:
   enum State {
     STATE_SEND_QUERY,
     STATE_SEND_QUERY_COMPLETE,
     STATE_READ_RESPONSE,
     STATE_READ_RESPONSE_COMPLETE,
     STATE_NONE,
   };
 
-  DatagramClientSocket* socket() {
-    return socket_lease_->socket();
-  }
+  DatagramClientSocket* socket() { return socket_lease_->socket(); }
 
   int DoLoop(int result) {
     CHECK_NE(STATE_NONE, next_state_);
     int rv = result;
     do {
       State state = next_state_;
       next_state_ = STATE_NONE;
       switch (state) {
         case STATE_SEND_QUERY:
           rv = DoSendQuery();
@@ skipping 24 matching lines @@
                     base::TimeTicks::Now() - start_time_);
     } else if (rv != ERR_IO_PENDING) {
       DNS_HISTOGRAM("AsyncDNS.UDPAttemptFail",
                     base::TimeTicks::Now() - start_time_);
     }
     return rv;
   }
 
   int DoSendQuery() {
     next_state_ = STATE_SEND_QUERY_COMPLETE;
-    return socket()->Write(query_->io_buffer(),
-                           query_->io_buffer()->size(),
-                           base::Bind(&DnsUDPAttempt::OnIOComplete,
-                                      base::Unretained(this)));
+    return socket()->Write(
+        query_->io_buffer(),
+        query_->io_buffer()->size(),
+        base::Bind(&DnsUDPAttempt::OnIOComplete, base::Unretained(this)));
   }
 
   int DoSendQueryComplete(int rv) {
     DCHECK_NE(ERR_IO_PENDING, rv);
     if (rv < 0)
       return rv;
 
     // Writing to UDP should not result in a partial datagram.
     if (rv != query_->io_buffer()->size())
       return ERR_MSG_TOO_BIG;
 
     next_state_ = STATE_READ_RESPONSE;
     return OK;
   }
 
   int DoReadResponse() {
     next_state_ = STATE_READ_RESPONSE_COMPLETE;
     response_.reset(new DnsResponse());
-    return socket()->Read(response_->io_buffer(),
-                          response_->io_buffer()->size(),
-                          base::Bind(&DnsUDPAttempt::OnIOComplete,
-                                     base::Unretained(this)));
+    return socket()->Read(
+        response_->io_buffer(),
+        response_->io_buffer()->size(),
+        base::Bind(&DnsUDPAttempt::OnIOComplete, base::Unretained(this)));
   }
 
   int DoReadResponseComplete(int rv) {
     DCHECK_NE(ERR_IO_PENDING, rv);
     if (rv < 0)
       return rv;
 
     DCHECK(rv);
     if (!response_->InitParse(rv, *query_)) {
       // Other implementations simply ignore mismatched responses. Since each
@@ skipping 47 matching lines @@
         query_(query.Pass()),
         length_buffer_(new IOBufferWithSize(sizeof(uint16))),
         response_length_(0) {}
 
   // DnsAttempt:
   virtual 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)));
+    int rv = socket_->Connect(
+        base::Bind(&DnsTCPAttempt::OnIOComplete, base::Unretained(this)));
     if (rv == ERR_IO_PENDING) {
       set_result(rv);
       return rv;
     }
     return DoLoop(rv);
   }
 
-  virtual const DnsQuery* GetQuery() const OVERRIDE {
-    return query_.get();
-  }
+  virtual const DnsQuery* GetQuery() const OVERRIDE { return query_.get(); }
 
   virtual const DnsResponse* GetResponse() const OVERRIDE {
     const DnsResponse* resp = response_.get();
     return (resp != NULL && resp->IsValid()) ? resp : NULL;
   }
 
   virtual const BoundNetLog& GetSocketNetLog() const OVERRIDE {
     return socket_->NetLog();
   }
 
@@ skipping 66 matching lines @@
       return rv;
 
     buffer_->DidConsume(rv);
     if (buffer_->BytesRemaining() > 0) {
       next_state_ = STATE_SEND_LENGTH;
       return socket_->Write(
           buffer_.get(),
           buffer_->BytesRemaining(),
           base::Bind(&DnsTCPAttempt::OnIOComplete, base::Unretained(this)));
     }
-    buffer_ = new DrainableIOBuffer(query_->io_buffer(),
-                                    query_->io_buffer()->size());
+    buffer_ =
+        new DrainableIOBuffer(query_->io_buffer(), query_->io_buffer()->size());
     next_state_ = STATE_SEND_QUERY;
     return OK;
   }
 
   int DoSendQuery(int rv) {
     DCHECK_NE(ERR_IO_PENDING, rv);
     if (rv < 0)
       return rv;
 
     buffer_->DidConsume(rv);
@@ skipping 92 matching lines @@
 // 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,
                      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_));
   }
 
   virtual ~DnsTransactionImpl() {
     if (!callback_.is_null()) {
       net_log_.EndEventWithNetErrorCode(NetLog::TYPE_DNS_TRANSACTION,
                                         ERR_ABORTED);
@@ skipping 85 matching lines @@
 
     if (ndots > 0 && !had_hostname)
       qnames_.push_back(labeled_hostname);
 
     return qnames_.empty() ? ERR_DNS_SEARCH_EMPTY : OK;
   }
 
   void DoCallback(AttemptResult result) {
     DCHECK(!callback_.is_null());
     DCHECK_NE(ERR_IO_PENDING, result.rv);
-    const DnsResponse* response = result.attempt ?
-        result.attempt->GetResponse() : NULL;
+    const DnsResponse* response =
+        result.attempt ? result.attempt->GetResponse() : NULL;
     CHECK(result.rv != OK || response != NULL);
 
     timer_.Stop();
     RecordLostPacketsIfAny();
     if (result.rv == OK)
       UMA_HISTOGRAM_COUNTS("AsyncDNS.AttemptCountSuccess", attempts_count_);
     else
       UMA_HISTOGRAM_COUNTS("AsyncDNS.AttemptCountFail", attempts_count_);
 
     if (response && qtype_ == dns_protocol::kTypeA) {
@@ skipping 40 matching lines @@
     attempts_.push_back(attempt);
     ++attempts_count_;
 
     if (!got_socket)
       return AttemptResult(ERR_CONNECTION_REFUSED, NULL);
 
     net_log_.AddEvent(
         NetLog::TYPE_DNS_TRANSACTION_ATTEMPT,
         attempt->GetSocketNetLog().source().ToEventParametersCallback());
 
-    int rv = attempt->Start(
-        base::Bind(&DnsTransactionImpl::OnUdpAttemptComplete,
-                   base::Unretained(this), attempt_number,
-                   base::TimeTicks::Now()));
+    int rv =
+        attempt->Start(base::Bind(&DnsTransactionImpl::OnUdpAttemptComplete,
+                                  base::Unretained(this),
+                                  attempt_number,
+                                  base::TimeTicks::Now()));
     if (rv == ERR_IO_PENDING) {
-      base::TimeDelta timeout = session_->NextTimeout(server_index,
-                                                      attempt_number);
+      base::TimeDelta timeout =
+          session_->NextTimeout(server_index, attempt_number);
       timer_.Start(FROM_HERE, timeout, this, &DnsTransactionImpl::OnTimeout);
     }
     return AttemptResult(rv, attempt);
   }
 
   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();
     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(),
-                                               query.Pass());
+    DnsTCPAttempt* attempt =
+        new DnsTCPAttempt(server_index, socket.Pass(), query.Pass());
 
     attempts_.push_back(attempt);
     ++attempts_count_;
     had_tcp_attempt_ = true;
 
     net_log_.AddEvent(
         NetLog::TYPE_DNS_TRANSACTION_TCP_ATTEMPT,
         attempt->GetSocketNetLog().source().ToEventParametersCallback());
 
     int rv = attempt->Start(base::Bind(&DnsTransactionImpl::OnAttemptComplete,
@@ skipping 40 matching lines @@
     AttemptResult result = ProcessAttemptResult(AttemptResult(rv, attempt));
     if (result.rv != ERR_IO_PENDING)
       DoCallback(result);
   }
 
   // Record packet loss for any incomplete attempts.
   void RecordLostPacketsIfAny() {
     // Loop through attempts until we find first that is completed
     size_t first_completed = 0;
     for (first_completed = 0; first_completed < attempts_.size();
-        ++first_completed) {
+         ++first_completed) {
       if (attempts_[first_completed]->is_completed())
         break;
     }
     // If there were no completed attempts, then we must be offline, so don't
     // record any attempts as lost packets.
     if (first_completed == attempts_.size())
       return;
 
     size_t num_servers = session_->config().nameservers.size();
     std::vector<int> server_attempts(num_servers);
     for (size_t i = 0; i < first_completed; ++i) {
       unsigned server_index = attempts_[i]->server_index();
       int server_attempt = server_attempts[server_index]++;
       // Don't record lost packet unless attempt is in pending state.
       if (!attempts_[i]->is_pending())
         continue;
       session_->RecordLostPacket(server_index, server_attempt);
     }
   }
 
   void LogResponse(const DnsAttempt* attempt) {
     if (attempt && attempt->GetResponse()) {
-      net_log_.AddEvent(
-          NetLog::TYPE_DNS_TRANSACTION_RESPONSE,
-          base::Bind(&DnsAttempt::NetLogResponseCallback,
-                     base::Unretained(attempt)));
+      net_log_.AddEvent(NetLog::TYPE_DNS_TRANSACTION_RESPONSE,
+                        base::Bind(&DnsAttempt::NetLogResponseCallback,
+                                   base::Unretained(attempt)));
     }
   }
 
   bool MoreAttemptsAllowed() const {
     if (had_tcp_attempt_)
       return false;
     const DnsConfig& config = session_->config();
     return attempts_.size() < config.attempts * config.nameservers.size();
   }
 
@@ skipping 78 matching lines @@
 
   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.
   ScopedVector<DnsAttempt> attempts_;
   // Count of attempts, not reset when |attempts_| vector is cleared.
-  int  attempts_count_;
+  int attempts_count_;
   bool had_tcp_attempt_;
 
   // Index of the first server to try on each search query.
   int first_server_index_;
 
   base::OneShotTimer<DnsTransactionImpl> timer_;
 
   DISALLOW_COPY_AND_ASSIGN(DnsTransactionImpl);
 };
 
@@ skipping 23 matching lines @@
 }  // namespace
 
 // static
 scoped_ptr<DnsTransactionFactory> DnsTransactionFactory::CreateFactory(
     DnsSession* session) {
   return scoped_ptr<DnsTransactionFactory>(
       new DnsTransactionFactoryImpl(session));
 }
 
 }  // namespace net