Clang format slam.

net/dns/dns_socket_pool.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_socket_pool.h"
 
 #include "base/logging.h"
 #include "base/rand_util.h"
 #include "base/stl_util.h"
 #include "net/base/address_list.h"
@@ skipping 18 matching lines @@
 #if defined(OS_WIN)
 const DatagramSocket::BindType kBindType = DatagramSocket::DEFAULT_BIND;
 const unsigned kInitialPoolSize = 256;
 const unsigned kAllocateMinSize = 256;
 #else
 const DatagramSocket::BindType kBindType = DatagramSocket::RANDOM_BIND;
 const unsigned kInitialPoolSize = 0;
 const unsigned kAllocateMinSize = 1;
 #endif
 
-} // namespace
+}  // namespace
 
 DnsSocketPool::DnsSocketPool(ClientSocketFactory* socket_factory)
     : socket_factory_(socket_factory),
       net_log_(NULL),
       nameservers_(NULL),
       initialized_(false) {
 }
 
 void DnsSocketPool::InitializeInternal(
     const std::vector<IPEndPoint>* nameservers,
     NetLog* net_log) {
   DCHECK(nameservers);
   DCHECK(!initialized_);
 
   net_log_ = net_log;
   nameservers_ = nameservers;
   initialized_ = true;
 }
 
 scoped_ptr<StreamSocket> DnsSocketPool::CreateTCPSocket(
     unsigned server_index,
     const NetLog::Source& source) {
   DCHECK_LT(server_index, nameservers_->size());
 
-  return scoped_ptr<StreamSocket>(
-      socket_factory_->CreateTransportClientSocket(
-          AddressList((*nameservers_)[server_index]), net_log_, source));
+  return scoped_ptr<StreamSocket>(socket_factory_->CreateTransportClientSocket(
+      AddressList((*nameservers_)[server_index]), net_log_, source));
 }
 
 scoped_ptr<DatagramClientSocket> DnsSocketPool::CreateConnectedSocket(
     unsigned server_index) {
   DCHECK_LT(server_index, nameservers_->size());
 
   scoped_ptr<DatagramClientSocket> socket;
 
   NetLog::Source no_source;
   socket = socket_factory_->CreateDatagramClientSocket(
       kBindType, base::Bind(&base::RandInt), net_log_, no_source);
 
   if (socket.get()) {
     int rv = socket->Connect((*nameservers_)[server_index]);
     if (rv != OK) {
       VLOG(1) << "Failed to connect socket: " << rv;
       socket.reset();
     }
   } else {
     LOG(WARNING) << "Failed to create socket.";
   }
 
   return socket.Pass();
 }
 
 class NullDnsSocketPool : public DnsSocketPool {
  public:
-  NullDnsSocketPool(ClientSocketFactory* factory)
-     : DnsSocketPool(factory) {
-  }
+  NullDnsSocketPool(ClientSocketFactory* factory) : DnsSocketPool(factory) {}
 
-  virtual void Initialize(
-      const std::vector<IPEndPoint>* nameservers,
-      NetLog* net_log) OVERRIDE {
+  virtual void Initialize(const std::vector<IPEndPoint>* nameservers,
+                          NetLog* net_log) OVERRIDE {
     InitializeInternal(nameservers, net_log);
   }
 
   virtual scoped_ptr<DatagramClientSocket> AllocateSocket(
       unsigned server_index) OVERRIDE {
     return CreateConnectedSocket(server_index);
   }
 
-  virtual void FreeSocket(
-      unsigned server_index,
-      scoped_ptr<DatagramClientSocket> socket) OVERRIDE {
-  }
+  virtual void FreeSocket(unsigned server_index,
+                          scoped_ptr<DatagramClientSocket> socket) OVERRIDE {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(NullDnsSocketPool);
 };
 
 // static
 scoped_ptr<DnsSocketPool> DnsSocketPool::CreateNull(
     ClientSocketFactory* factory) {
   return scoped_ptr<DnsSocketPool>(new NullDnsSocketPool(factory));
 }
 
 class DefaultDnsSocketPool : public DnsSocketPool {
  public:
   DefaultDnsSocketPool(ClientSocketFactory* factory)
-     : DnsSocketPool(factory) {
-  };
+      : DnsSocketPool(factory) {};
 
   virtual ~DefaultDnsSocketPool();
 
-  virtual void Initialize(
-      const std::vector<IPEndPoint>* nameservers,
-      NetLog* net_log) OVERRIDE;
+  virtual void Initialize(const std::vector<IPEndPoint>* nameservers,
+                          NetLog* net_log) OVERRIDE;
 
   virtual scoped_ptr<DatagramClientSocket> AllocateSocket(
       unsigned server_index) OVERRIDE;
 
-  virtual void FreeSocket(
-      unsigned server_index,
-      scoped_ptr<DatagramClientSocket> socket) OVERRIDE;
+  virtual void FreeSocket(unsigned server_index,
+                          scoped_ptr<DatagramClientSocket> socket) OVERRIDE;
 
  private:
   void FillPool(unsigned server_index, unsigned size);
 
   typedef std::vector<DatagramClientSocket*> SocketVector;
 
   std::vector<SocketVector> pools_;
 
   DISALLOW_COPY_AND_ASSIGN(DefaultDnsSocketPool);
 };
@@ skipping 42 matching lines @@
   }
 
   unsigned socket_index = base::RandInt(0, pool.size() - 1);
   DatagramClientSocket* socket = pool[socket_index];
   pool[socket_index] = pool.back();
   pool.pop_back();
 
   return scoped_ptr<DatagramClientSocket>(socket);
 }
 
-void DefaultDnsSocketPool::FreeSocket(
-    unsigned server_index,
-    scoped_ptr<DatagramClientSocket> socket) {
+void DefaultDnsSocketPool::FreeSocket(unsigned server_index,
+                                      scoped_ptr<DatagramClientSocket> socket) {
   DCHECK_LT(server_index, pools_.size());
 }
 
 void DefaultDnsSocketPool::FillPool(unsigned server_index, unsigned size) {
   SocketVector& pool = pools_[server_index];
 
   for (unsigned pool_index = pool.size(); pool_index < size; ++pool_index) {
     DatagramClientSocket* socket =
         CreateConnectedSocket(server_index).release();
     if (!socket)
       break;
     pool.push_back(socket);
   }
 }
 
-} // namespace net
+}  // namespace net