Clang format slam.

net/udp/udp_socket_libevent.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/udp/udp_socket_libevent.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <netdb.h>
 #include <net/if.h>
 #include <netinet/in.h>
 #include <sys/ioctl.h>
 #include <sys/socket.h>
 
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/metrics/stats_counters.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/rand_util.h"
 #include "net/base/io_buffer.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_log.h"
 #include "net/base/net_util.h"
 #include "net/socket/socket_descriptor.h"
 #include "net/udp/udp_net_log_parameters.h"
 
-
 namespace net {
 
 namespace {
 
 const int kBindRetries = 10;
 const int kPortStart = 1024;
 const int kPortEnd = 65535;
 
 #if defined(OS_MACOSX)
 
 // Returns IPv4 address in network order.
-int GetIPv4AddressFromIndex(int socket, uint32 index, uint32* address){
+int GetIPv4AddressFromIndex(int socket, uint32 index, uint32* address) {
   if (!index) {
     *address = htonl(INADDR_ANY);
     return OK;
   }
   ifreq ifr;
   ifr.ifr_addr.sa_family = AF_INET;
   if (!if_indextoname(index, ifr.ifr_name))
     return MapSystemError(errno);
   int rv = ioctl(socket, SIOCGIFADDR, &ifr);
   if (rv == -1)
     return MapSystemError(errno);
   *address = reinterpret_cast<sockaddr_in*>(&ifr.ifr_addr)->sin_addr.s_addr;
   return OK;
 }
 
 #endif  // OS_MACOSX
 
 }  // namespace
 
-UDPSocketLibevent::UDPSocketLibevent(
-    DatagramSocket::BindType bind_type,
-    const RandIntCallback& rand_int_cb,
-    net::NetLog* net_log,
-    const net::NetLog::Source& source)
-        : socket_(kInvalidSocket),
-          addr_family_(0),
-          socket_options_(SOCKET_OPTION_MULTICAST_LOOP),
-          multicast_interface_(0),
-          multicast_time_to_live_(1),
-          bind_type_(bind_type),
-          rand_int_cb_(rand_int_cb),
-          read_watcher_(this),
-          write_watcher_(this),
-          read_buf_len_(0),
-          recv_from_address_(NULL),
-          write_buf_len_(0),
-          net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_UDP_SOCKET)) {
+UDPSocketLibevent::UDPSocketLibevent(DatagramSocket::BindType bind_type,
+                                     const RandIntCallback& rand_int_cb,
+                                     net::NetLog* net_log,
+                                     const net::NetLog::Source& source)
+    : socket_(kInvalidSocket),
+      addr_family_(0),
+      socket_options_(SOCKET_OPTION_MULTICAST_LOOP),
+      multicast_interface_(0),
+      multicast_time_to_live_(1),
+      bind_type_(bind_type),
+      rand_int_cb_(rand_int_cb),
+      read_watcher_(this),
+      write_watcher_(this),
+      read_buf_len_(0),
+      recv_from_address_(NULL),
+      write_buf_len_(0),
+      net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_UDP_SOCKET)) {
   net_log_.BeginEvent(NetLog::TYPE_SOCKET_ALIVE,
                       source.ToEventParametersCallback());
   if (bind_type == DatagramSocket::RANDOM_BIND)
     DCHECK(!rand_int_cb.is_null());
 }
 
 UDPSocketLibevent::~UDPSocketLibevent() {
   Close();
   net_log_.EndEvent(NetLog::TYPE_SOCKET_ALIVE);
 }
@@ skipping 83 matching lines @@
   DCHECK(read_callback_.is_null());
   DCHECK(!recv_from_address_);
   DCHECK(!callback.is_null());  // Synchronous operation not supported
   DCHECK_GT(buf_len, 0);
 
   int nread = InternalRecvFrom(buf, buf_len, address);
   if (nread != ERR_IO_PENDING)
     return nread;
 
   if (!base::MessageLoopForIO::current()->WatchFileDescriptor(
-          socket_, true, base::MessageLoopForIO::WATCH_READ,
-          &read_socket_watcher_, &read_watcher_)) {
+          socket_,
+          true,
+          base::MessageLoopForIO::WATCH_READ,
+          &read_socket_watcher_,
+          &read_watcher_)) {
     PLOG(ERROR) << "WatchFileDescriptor failed on read";
     int result = MapSystemError(errno);
     LogRead(result, NULL, 0, NULL);
     return result;
   }
 
   read_buf_ = buf;
   read_buf_len_ = buf_len;
   recv_from_address_ = address;
   read_callback_ = callback;
@@ skipping 21 matching lines @@
   DCHECK_NE(kInvalidSocket, socket_);
   DCHECK(write_callback_.is_null());
   DCHECK(!callback.is_null());  // Synchronous operation not supported
   DCHECK_GT(buf_len, 0);
 
   int result = InternalSendTo(buf, buf_len, address);
   if (result != ERR_IO_PENDING)
     return result;
 
   if (!base::MessageLoopForIO::current()->WatchFileDescriptor(
-          socket_, true, base::MessageLoopForIO::WATCH_WRITE,
-          &write_socket_watcher_, &write_watcher_)) {
+          socket_,
+          true,
+          base::MessageLoopForIO::WATCH_WRITE,
+          &write_socket_watcher_,
+          &write_watcher_)) {
     DVLOG(1) << "WatchFileDescriptor failed on write, errno " << errno;
     int result = MapSystemError(errno);
     LogWrite(result, NULL, NULL);
     return result;
   }
 
   write_buf_ = buf;
   write_buf_len_ = buf_len;
   DCHECK(!send_to_address_.get());
   if (address) {
@@ skipping 72 matching lines @@
   if (rv < 0) {
     Close();
     return rv;
   }
   local_address_.reset();
   return rv;
 }
 
 int UDPSocketLibevent::SetReceiveBufferSize(int32 size) {
   DCHECK(CalledOnValidThread());
-  int rv = setsockopt(socket_, SOL_SOCKET, SO_RCVBUF,
-                      reinterpret_cast<const char*>(&size), sizeof(size));
+  int rv = setsockopt(socket_,
+                      SOL_SOCKET,
+                      SO_RCVBUF,
+                      reinterpret_cast<const char*>(&size),
+                      sizeof(size));
   int last_error = errno;
   DCHECK(!rv) << "Could not set socket receive buffer size: " << last_error;
   return rv == 0 ? OK : MapSystemError(last_error);
 }
 
 int UDPSocketLibevent::SetSendBufferSize(int32 size) {
   DCHECK(CalledOnValidThread());
-  int rv = setsockopt(socket_, SOL_SOCKET, SO_SNDBUF,
-                      reinterpret_cast<const char*>(&size), sizeof(size));
+  int rv = setsockopt(socket_,
+                      SOL_SOCKET,
+                      SO_SNDBUF,
+                      reinterpret_cast<const char*>(&size),
+                      sizeof(size));
   int last_error = errno;
   DCHECK(!rv) << "Could not set socket send buffer size: " << last_error;
   return rv == 0 ? OK : MapSystemError(last_error);
 }
 
 void UDPSocketLibevent::AllowAddressReuse() {
   DCHECK(CalledOnValidThread());
   DCHECK(!is_connected());
 
   socket_options_ |= SOCKET_OPTION_REUSE_ADDRESS;
@@ skipping 57 matching lines @@
     net_log_.AddEventWithNetErrorCode(NetLog::TYPE_UDP_RECEIVE_ERROR, result);
     return;
   }
 
   if (net_log_.IsLogging()) {
     DCHECK(addr_len > 0);
     DCHECK(addr);
 
     IPEndPoint address;
     bool is_address_valid = address.FromSockAddr(addr, addr_len);
-    net_log_.AddEvent(
-        NetLog::TYPE_UDP_BYTES_RECEIVED,
-        CreateNetLogUDPDataTranferCallback(
-            result, bytes,
-            is_address_valid ? &address : NULL));
+    net_log_.AddEvent(NetLog::TYPE_UDP_BYTES_RECEIVED,
+                      CreateNetLogUDPDataTranferCallback(
+                          result, bytes, is_address_valid ? &address : NULL));
   }
 
   base::StatsCounter read_bytes("udp.read_bytes");
   read_bytes.Add(result);
 }
 
 int UDPSocketLibevent::CreateSocket(int addr_family) {
   addr_family_ = addr_family;
   socket_ = CreatePlatformSocket(addr_family_, SOCK_DGRAM, 0);
   if (socket_ == kInvalidSocket)
@@ skipping 30 matching lines @@
   if (net_log_.IsLogging()) {
     net_log_.AddEvent(
         NetLog::TYPE_UDP_BYTES_SENT,
         CreateNetLogUDPDataTranferCallback(result, bytes, address));
   }
 
   base::StatsCounter write_bytes("udp.write_bytes");
   write_bytes.Add(result);
 }
 
-int UDPSocketLibevent::InternalRecvFrom(IOBuffer* buf, int buf_len,
+int UDPSocketLibevent::InternalRecvFrom(IOBuffer* buf,
+                                        int buf_len,
                                         IPEndPoint* address) {
   int bytes_transferred;
   int flags = 0;
 
   SockaddrStorage storage;
 
-  bytes_transferred =
-      HANDLE_EINTR(recvfrom(socket_,
-                            buf->data(),
-                            buf_len,
-                            flags,
-                            storage.addr,
-                            &storage.addr_len));
+  bytes_transferred = HANDLE_EINTR(recvfrom(
+      socket_, buf->data(), buf_len, flags, storage.addr, &storage.addr_len));
   int result;
   if (bytes_transferred >= 0) {
     result = bytes_transferred;
     if (address && !address->FromSockAddr(storage.addr, storage.addr_len))
       result = ERR_ADDRESS_INVALID;
   } else {
     result = MapSystemError(errno);
   }
   if (result != ERR_IO_PENDING)
     LogRead(result, buf->data(), storage.addr_len, storage.addr);
   return result;
 }
 
-int UDPSocketLibevent::InternalSendTo(IOBuffer* buf, int buf_len,
+int UDPSocketLibevent::InternalSendTo(IOBuffer* buf,
+                                      int buf_len,
                                       const IPEndPoint* address) {
   SockaddrStorage storage;
   struct sockaddr* addr = storage.addr;
   if (!address) {
     addr = NULL;
     storage.addr_len = 0;
   } else {
     if (!address->ToSockAddr(storage.addr, &storage.addr_len)) {
       int result = ERR_ADDRESS_INVALID;
       LogWrite(result, NULL, NULL);
       return result;
     }
   }
 
-  int result = HANDLE_EINTR(sendto(socket_,
-                            buf->data(),
-                            buf_len,
-                            0,
-                            addr,
-                            storage.addr_len));
+  int result = HANDLE_EINTR(
+      sendto(socket_, buf->data(), buf_len, 0, addr, storage.addr_len));
   if (result < 0)
     result = MapSystemError(errno);
   if (result != ERR_IO_PENDING)
     LogWrite(result, buf->data(), address);
   return result;
 }
 
 int UDPSocketLibevent::SetSocketOptions() {
   int true_value = 1;
   if (socket_options_ & SOCKET_OPTION_REUSE_ADDRESS) {
-    int rv = setsockopt(socket_, SOL_SOCKET, SO_REUSEADDR, &true_value,
-                        sizeof(true_value));
+    int rv = setsockopt(
+        socket_, SOL_SOCKET, SO_REUSEADDR, &true_value, sizeof(true_value));
     if (rv < 0)
       return MapSystemError(errno);
   }
   if (socket_options_ & SOCKET_OPTION_BROADCAST) {
     int rv;
 #if defined(OS_MACOSX)
     // SO_REUSEPORT on OSX permits multiple processes to each receive
     // UDP multicast or broadcast datagrams destined for the bound
     // port.
-    rv = setsockopt(socket_, SOL_SOCKET, SO_REUSEPORT, &true_value,
-                    sizeof(true_value));
+    rv = setsockopt(
+        socket_, SOL_SOCKET, SO_REUSEPORT, &true_value, sizeof(true_value));
 #else
-    rv = setsockopt(socket_, SOL_SOCKET, SO_BROADCAST, &true_value,
-                    sizeof(true_value));
+    rv = setsockopt(
+        socket_, SOL_SOCKET, SO_BROADCAST, &true_value, sizeof(true_value));
 #endif  // defined(OS_MACOSX)
     if (rv < 0)
       return MapSystemError(errno);
   }
 
   if (!(socket_options_ & SOCKET_OPTION_MULTICAST_LOOP)) {
     int rv;
     if (addr_family_ == AF_INET) {
       u_char loop = 0;
-      rv = setsockopt(socket_, IPPROTO_IP, IP_MULTICAST_LOOP,
-                      &loop, sizeof(loop));
+      rv = setsockopt(
+          socket_, IPPROTO_IP, IP_MULTICAST_LOOP, &loop, sizeof(loop));
     } else {
       u_int loop = 0;
-      rv = setsockopt(socket_, IPPROTO_IPV6, IPV6_MULTICAST_LOOP,
-                      &loop, sizeof(loop));
+      rv = setsockopt(
+          socket_, IPPROTO_IPV6, IPV6_MULTICAST_LOOP, &loop, sizeof(loop));
     }
     if (rv < 0)
       return MapSystemError(errno);
   }
   if (multicast_time_to_live_ != IP_DEFAULT_MULTICAST_TTL) {
     int rv;
     if (addr_family_ == AF_INET) {
       u_char ttl = multicast_time_to_live_;
-      rv = setsockopt(socket_, IPPROTO_IP, IP_MULTICAST_TTL,
-                      &ttl, sizeof(ttl));
+      rv = setsockopt(socket_, IPPROTO_IP, IP_MULTICAST_TTL, &ttl, sizeof(ttl));
     } else {
       // Signed integer. -1 to use route default.
       int ttl = multicast_time_to_live_;
-      rv = setsockopt(socket_, IPPROTO_IPV6, IPV6_MULTICAST_HOPS,
-                      &ttl, sizeof(ttl));
+      rv = setsockopt(
+          socket_, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, &ttl, sizeof(ttl));
     }
     if (rv < 0)
       return MapSystemError(errno);
   }
   if (multicast_interface_ != 0) {
     switch (addr_family_) {
       case AF_INET: {
 #if !defined(OS_MACOSX)
         ip_mreqn mreq;
         mreq.imr_ifindex = multicast_interface_;
         mreq.imr_address.s_addr = htonl(INADDR_ANY);
 #else
         ip_mreq mreq;
-        int error = GetIPv4AddressFromIndex(socket_, multicast_interface_,
-                                            &mreq.imr_interface.s_addr);
+        int error = GetIPv4AddressFromIndex(
+            socket_, multicast_interface_, &mreq.imr_interface.s_addr);
         if (error != OK)
           return error;
 #endif
-        int rv = setsockopt(socket_, IPPROTO_IP, IP_MULTICAST_IF,
-                            reinterpret_cast<const char*>(&mreq), sizeof(mreq));
+        int rv = setsockopt(socket_,
+                            IPPROTO_IP,
+                            IP_MULTICAST_IF,
+                            reinterpret_cast<const char*>(&mreq),
+                            sizeof(mreq));
         if (rv)
           return MapSystemError(errno);
         break;
       }
       case AF_INET6: {
         uint32 interface_index = multicast_interface_;
-        int rv = setsockopt(socket_, IPPROTO_IPV6, IPV6_MULTICAST_IF,
+        int rv = setsockopt(socket_,
+                            IPPROTO_IPV6,
+                            IPV6_MULTICAST_IF,
                             reinterpret_cast<const char*>(&interface_index),
                             sizeof(interface_index));
         if (rv)
           return MapSystemError(errno);
         break;
       }
       default:
         NOTREACHED() << "Invalid address family";
         return ERR_ADDRESS_INVALID;
     }
@@ skipping 17 matching lines @@
   if (last_error == EADDRNOTAVAIL)
     return ERR_ADDRESS_IN_USE;
 #endif
   return MapSystemError(last_error);
 }
 
 int UDPSocketLibevent::RandomBind(const IPAddressNumber& address) {
   DCHECK(bind_type_ == DatagramSocket::RANDOM_BIND && !rand_int_cb_.is_null());
 
   for (int i = 0; i < kBindRetries; ++i) {
-    int rv = DoBind(IPEndPoint(address,
-                               rand_int_cb_.Run(kPortStart, kPortEnd)));
+    int rv =
+        DoBind(IPEndPoint(address, rand_int_cb_.Run(kPortStart, kPortEnd)));
     if (rv == OK || rv != ERR_ADDRESS_IN_USE)
       return rv;
   }
   return DoBind(IPEndPoint(address, 0));
 }
 
 int UDPSocketLibevent::JoinGroup(const IPAddressNumber& group_address) const {
   DCHECK(CalledOnValidThread());
   if (!is_connected())
     return ERR_SOCKET_NOT_CONNECTED;
 
   switch (group_address.size()) {
     case kIPv4AddressSize: {
       if (addr_family_ != AF_INET)
         return ERR_ADDRESS_INVALID;
 
 #if !defined(OS_MACOSX)
       ip_mreqn mreq;
       mreq.imr_ifindex = multicast_interface_;
       mreq.imr_address.s_addr = htonl(INADDR_ANY);
 #else
       ip_mreq mreq;
-      int error = GetIPv4AddressFromIndex(socket_, multicast_interface_,
-                                            &mreq.imr_interface.s_addr);
+      int error = GetIPv4AddressFromIndex(
+          socket_, multicast_interface_, &mreq.imr_interface.s_addr);
       if (error != OK)
         return error;
 #endif
       memcpy(&mreq.imr_multiaddr, &group_address[0], kIPv4AddressSize);
-      int rv = setsockopt(socket_, IPPROTO_IP, IP_ADD_MEMBERSHIP,
-                          &mreq, sizeof(mreq));
+      int rv = setsockopt(
+          socket_, IPPROTO_IP, IP_ADD_MEMBERSHIP, &mreq, sizeof(mreq));
       if (rv < 0)
         return MapSystemError(errno);
       return OK;
     }
     case kIPv6AddressSize: {
       if (addr_family_ != AF_INET6)
         return ERR_ADDRESS_INVALID;
       ipv6_mreq mreq;
       mreq.ipv6mr_interface = multicast_interface_;
       memcpy(&mreq.ipv6mr_multiaddr, &group_address[0], kIPv6AddressSize);
-      int rv = setsockopt(socket_, IPPROTO_IPV6, IPV6_JOIN_GROUP,
-                          &mreq, sizeof(mreq));
+      int rv = setsockopt(
+          socket_, IPPROTO_IPV6, IPV6_JOIN_GROUP, &mreq, sizeof(mreq));
       if (rv < 0)
         return MapSystemError(errno);
       return OK;
     }
     default:
       NOTREACHED() << "Invalid address family";
       return ERR_ADDRESS_INVALID;
   }
 }
 
 int UDPSocketLibevent::LeaveGroup(const IPAddressNumber& group_address) const {
   DCHECK(CalledOnValidThread());
 
   if (!is_connected())
     return ERR_SOCKET_NOT_CONNECTED;
 
   switch (group_address.size()) {
     case kIPv4AddressSize: {
       if (addr_family_ != AF_INET)
         return ERR_ADDRESS_INVALID;
       ip_mreq mreq;
       mreq.imr_interface.s_addr = INADDR_ANY;
       memcpy(&mreq.imr_multiaddr, &group_address[0], kIPv4AddressSize);
-      int rv = setsockopt(socket_, IPPROTO_IP, IP_DROP_MEMBERSHIP,
-                          &mreq, sizeof(mreq));
+      int rv = setsockopt(
+          socket_, IPPROTO_IP, IP_DROP_MEMBERSHIP, &mreq, sizeof(mreq));
       if (rv < 0)
         return MapSystemError(errno);
       return OK;
     }
     case kIPv6AddressSize: {
       if (addr_family_ != AF_INET6)
         return ERR_ADDRESS_INVALID;
       ipv6_mreq mreq;
       mreq.ipv6mr_interface = 0;  // 0 indicates default multicast interface.
       memcpy(&mreq.ipv6mr_multiaddr, &group_address[0], kIPv6AddressSize);
-      int rv = setsockopt(socket_, IPPROTO_IPV6, IPV6_LEAVE_GROUP,
-                          &mreq, sizeof(mreq));
+      int rv = setsockopt(
+          socket_, IPPROTO_IPV6, IPV6_LEAVE_GROUP, &mreq, sizeof(mreq));
       if (rv < 0)
         return MapSystemError(errno);
       return OK;
     }
     default:
       NOTREACHED() << "Invalid address family";
       return ERR_ADDRESS_INVALID;
   }
 }
 
@@ skipping 28 matching lines @@
   return OK;
 }
 
 int UDPSocketLibevent::SetDiffServCodePoint(DiffServCodePoint dscp) {
   if (dscp == DSCP_NO_CHANGE) {
     return OK;
   }
   int rv;
   int dscp_and_ecn = dscp << 2;
   if (addr_family_ == AF_INET) {
-    rv = setsockopt(socket_, IPPROTO_IP, IP_TOS,
-                    &dscp_and_ecn, sizeof(dscp_and_ecn));
+    rv = setsockopt(
+        socket_, IPPROTO_IP, IP_TOS, &dscp_and_ecn, sizeof(dscp_and_ecn));
   } else {
-    rv = setsockopt(socket_, IPPROTO_IPV6, IPV6_TCLASS,
-                    &dscp_and_ecn, sizeof(dscp_and_ecn));
+    rv = setsockopt(socket_,
+                    IPPROTO_IPV6,
+                    IPV6_TCLASS,
+                    &dscp_and_ecn,
+                    sizeof(dscp_and_ecn));
   }
   if (rv < 0)
     return MapSystemError(errno);
 
   return OK;
 }
 
 void UDPSocketLibevent::DetachFromThread() {
   base::NonThreadSafe::DetachFromThread();
 }
 
 }  // namespace net