Clang format slam.

net/udp/udp_socket_win.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_win.h"
 
 #include <mstcpip.h>
 
 #include "base/callback.h"
 #include "base/logging.h"
@@ skipping 88 matching lines @@
 
   // |read_watcher_| watches for events from Read().
   base::win::ObjectWatcher read_watcher_;
   // |write_watcher_| watches for events from Write();
   base::win::ObjectWatcher write_watcher_;
 
   DISALLOW_COPY_AND_ASSIGN(Core);
 };
 
 UDPSocketWin::Core::Core(UDPSocketWin* socket)
-    : socket_(socket),
-      reader_(this),
-      writer_(this) {
+    : socket_(socket), reader_(this), writer_(this) {
   memset(&read_overlapped_, 0, sizeof(read_overlapped_));
   memset(&write_overlapped_, 0, sizeof(write_overlapped_));
 
   read_overlapped_.hEvent = WSACreateEvent();
   write_overlapped_.hEvent = WSACreateEvent();
 }
 
 UDPSocketWin::Core::~Core() {
   // Make sure the message loop is not watching this object anymore.
   read_watcher_.StopWatching();
@@ skipping 261 matching lines @@
   addr_family_ = addr_family;
   socket_ = CreatePlatformSocket(addr_family_, SOCK_DGRAM, IPPROTO_UDP);
   if (socket_ == INVALID_SOCKET)
     return MapSystemError(WSAGetLastError());
   core_ = new Core(this);
   return OK;
 }
 
 int UDPSocketWin::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));
   if (rv != 0)
     return MapSystemError(WSAGetLastError());
 
   // According to documentation, setsockopt may succeed, but we need to check
   // the results via getsockopt to be sure it works on Windows.
   int32 actual_size = 0;
   int option_size = sizeof(actual_size);
-  rv = getsockopt(socket_, SOL_SOCKET, SO_RCVBUF,
-                  reinterpret_cast<char*>(&actual_size), &option_size);
+  rv = getsockopt(socket_,
+                  SOL_SOCKET,
+                  SO_RCVBUF,
+                  reinterpret_cast<char*>(&actual_size),
+                  &option_size);
   if (rv != 0)
     return MapSystemError(WSAGetLastError());
   if (actual_size >= size)
     return OK;
-  UMA_HISTOGRAM_CUSTOM_COUNTS("Net.SocketUnchangeableReceiveBuffer",
-                              actual_size, 1000, 1000000, 50);
+  UMA_HISTOGRAM_CUSTOM_COUNTS(
+      "Net.SocketUnchangeableReceiveBuffer", actual_size, 1000, 1000000, 50);
   return ERR_SOCKET_RECEIVE_BUFFER_SIZE_UNCHANGEABLE;
 }
 
 int UDPSocketWin::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));
   if (rv != 0)
     return MapSystemError(WSAGetLastError());
   // According to documentation, setsockopt may succeed, but we need to check
   // the results via getsockopt to be sure it works on Windows.
   int32 actual_size = 0;
   int option_size = sizeof(actual_size);
-  rv = getsockopt(socket_, SOL_SOCKET, SO_SNDBUF,
-                  reinterpret_cast<char*>(&actual_size), &option_size);
+  rv = getsockopt(socket_,
+                  SOL_SOCKET,
+                  SO_SNDBUF,
+                  reinterpret_cast<char*>(&actual_size),
+                  &option_size);
   if (rv != 0)
     return MapSystemError(WSAGetLastError());
   if (actual_size >= size)
     return OK;
-  UMA_HISTOGRAM_CUSTOM_COUNTS("Net.SocketUnchangeableSendBuffer",
-                              actual_size, 1000, 1000000, 50);
+  UMA_HISTOGRAM_CUSTOM_COUNTS(
+      "Net.SocketUnchangeableSendBuffer", actual_size, 1000, 1000000, 50);
   return ERR_SOCKET_SEND_BUFFER_SIZE_UNCHANGEABLE;
 }
 
 void UDPSocketWin::AllowAddressReuse() {
   DCHECK(CalledOnValidThread());
   DCHECK(!is_connected());
 
   socket_options_ |= SOCKET_OPTION_REUSE_ADDRESS;
 }
 
@@ skipping 19 matching lines @@
   DCHECK(!write_callback_.is_null());
 
   // since Run may result in Write being called, clear write_callback_ up front.
   CompletionCallback c = write_callback_;
   write_callback_.Reset();
   c.Run(rv);
 }
 
 void UDPSocketWin::DidCompleteRead() {
   DWORD num_bytes, flags;
-  BOOL ok = WSAGetOverlappedResult(socket_, &core_->read_overlapped_,
-                                   &num_bytes, FALSE, &flags);
+  BOOL ok = WSAGetOverlappedResult(
+      socket_, &core_->read_overlapped_, &num_bytes, FALSE, &flags);
   WSAResetEvent(core_->read_overlapped_.hEvent);
   int result = ok ? num_bytes : MapSystemError(WSAGetLastError());
   // Convert address.
   if (recv_from_address_ && result >= 0) {
     if (!ReceiveAddressToIPEndpoint(recv_from_address_))
       result = ERR_ADDRESS_INVALID;
   }
   LogRead(result, core_->read_iobuffer_->data());
   core_->read_iobuffer_ = NULL;
   recv_from_address_ = NULL;
   DoReadCallback(result);
 }
 
 void UDPSocketWin::LogRead(int result, const char* bytes) const {
   if (result < 0) {
     net_log_.AddEventWithNetErrorCode(NetLog::TYPE_UDP_RECEIVE_ERROR, result);
     return;
   }
 
   if (net_log_.IsLogging()) {
     // Get address for logging, if |address| is NULL.
     IPEndPoint address;
     bool is_address_valid = ReceiveAddressToIPEndpoint(&address);
-    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);
 }
 
 void UDPSocketWin::DidCompleteWrite() {
   DWORD num_bytes, flags;
-  BOOL ok = WSAGetOverlappedResult(socket_, &core_->write_overlapped_,
-                                   &num_bytes, FALSE, &flags);
+  BOOL ok = WSAGetOverlappedResult(
+      socket_, &core_->write_overlapped_, &num_bytes, FALSE, &flags);
   WSAResetEvent(core_->write_overlapped_.hEvent);
   int result = ok ? num_bytes : MapSystemError(WSAGetLastError());
   LogWrite(result, core_->write_iobuffer_->data(), send_to_address_.get());
 
   send_to_address_.reset();
   core_->write_iobuffer_ = NULL;
   DoWriteCallback(result);
 }
 
 void UDPSocketWin::LogWrite(int result,
                             const char* bytes,
                             const IPEndPoint* address) const {
   if (result < 0) {
     net_log_.AddEventWithNetErrorCode(NetLog::TYPE_UDP_SEND_ERROR, result);
     return;
   }
 
   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 UDPSocketWin::InternalRecvFrom(IOBuffer* buf, int buf_len,
+int UDPSocketWin::InternalRecvFrom(IOBuffer* buf,
+                                   int buf_len,
                                    IPEndPoint* address) {
   DCHECK(!core_->read_iobuffer_);
   SockaddrStorage& storage = core_->recv_addr_storage_;
   storage.addr_len = sizeof(storage.addr_storage);
 
   WSABUF read_buffer;
   read_buffer.buf = buf->data();
   read_buffer.len = buf_len;
 
   DWORD flags = 0;
   DWORD num;
   CHECK_NE(INVALID_SOCKET, socket_);
   AssertEventNotSignaled(core_->read_overlapped_.hEvent);
-  int rv = WSARecvFrom(socket_, &read_buffer, 1, &num, &flags, storage.addr,
-                       &storage.addr_len, &core_->read_overlapped_, NULL);
+  int rv = WSARecvFrom(socket_,
+                       &read_buffer,
+                       1,
+                       &num,
+                       &flags,
+                       storage.addr,
+                       &storage.addr_len,
+                       &core_->read_overlapped_,
+                       NULL);
   if (rv == 0) {
     if (ResetEventIfSignaled(core_->read_overlapped_.hEvent)) {
       int result = num;
       // Convert address.
       if (address && result >= 0) {
         if (!ReceiveAddressToIPEndpoint(address))
           result = ERR_ADDRESS_INVALID;
       }
       LogRead(result, buf->data());
       return result;
     }
   } else {
     int os_error = WSAGetLastError();
     if (os_error != WSA_IO_PENDING) {
       int result = MapSystemError(os_error);
       LogRead(result, NULL);
       return result;
     }
   }
   core_->WatchForRead();
   core_->read_iobuffer_ = buf;
   return ERR_IO_PENDING;
 }
 
-int UDPSocketWin::InternalSendTo(IOBuffer* buf, int buf_len,
+int UDPSocketWin::InternalSendTo(IOBuffer* buf,
+                                 int buf_len,
                                  const IPEndPoint* address) {
   DCHECK(!core_->write_iobuffer_);
   SockaddrStorage storage;
   struct sockaddr* addr = storage.addr;
   // Convert address.
   if (!address) {
     addr = NULL;
     storage.addr_len = 0;
   } else {
     if (!address->ToSockAddr(addr, &storage.addr_len)) {
       int result = ERR_ADDRESS_INVALID;
       LogWrite(result, NULL, NULL);
       return result;
     }
   }
 
   WSABUF write_buffer;
   write_buffer.buf = buf->data();
   write_buffer.len = buf_len;
 
   DWORD flags = 0;
   DWORD num;
   AssertEventNotSignaled(core_->write_overlapped_.hEvent);
-  int rv = WSASendTo(socket_, &write_buffer, 1, &num, flags,
-                     addr, storage.addr_len, &core_->write_overlapped_, NULL);
+  int rv = WSASendTo(socket_,
+                     &write_buffer,
+                     1,
+                     &num,
+                     flags,
+                     addr,
+                     storage.addr_len,
+                     &core_->write_overlapped_,
+                     NULL);
   if (rv == 0) {
     if (ResetEventIfSignaled(core_->write_overlapped_.hEvent)) {
       int result = num;
       LogWrite(result, buf->data(), address);
       return result;
     }
   } else {
     int os_error = WSAGetLastError();
     if (os_error != WSA_IO_PENDING) {
       int result = MapSystemError(os_error);
       LogWrite(result, NULL, NULL);
       return result;
     }
   }
 
   core_->WatchForWrite();
   core_->write_iobuffer_ = buf;
   return ERR_IO_PENDING;
 }
 
 int UDPSocketWin::SetSocketOptions() {
   BOOL true_value = 1;
   if (socket_options_ & SOCKET_OPTION_REUSE_ADDRESS) {
-    int rv = setsockopt(socket_, SOL_SOCKET, SO_REUSEADDR,
+    int rv = setsockopt(socket_,
+                        SOL_SOCKET,
+                        SO_REUSEADDR,
                         reinterpret_cast<const char*>(&true_value),
                         sizeof(true_value));
     if (rv < 0)
       return MapSystemError(WSAGetLastError());
   }
   if (socket_options_ & SOCKET_OPTION_BROADCAST) {
-    int rv = setsockopt(socket_, SOL_SOCKET, SO_BROADCAST,
+    int rv = setsockopt(socket_,
+                        SOL_SOCKET,
+                        SO_BROADCAST,
                         reinterpret_cast<const char*>(&true_value),
                         sizeof(true_value));
     if (rv < 0)
       return MapSystemError(WSAGetLastError());
   }
   if (!(socket_options_ & SOCKET_OPTION_MULTICAST_LOOP)) {
     DWORD loop = 0;
-    int protocol_level =
-        addr_family_ == AF_INET ? IPPROTO_IP : IPPROTO_IPV6;
+    int protocol_level = addr_family_ == AF_INET ? IPPROTO_IP : IPPROTO_IPV6;
     int option =
-        addr_family_ == AF_INET ? IP_MULTICAST_LOOP: IPV6_MULTICAST_LOOP;
-    int rv = setsockopt(socket_, protocol_level, option,
-                        reinterpret_cast<const char*>(&loop), sizeof(loop));
+        addr_family_ == AF_INET ? IP_MULTICAST_LOOP : IPV6_MULTICAST_LOOP;
+    int rv = setsockopt(socket_,
+                        protocol_level,
+                        option,
+                        reinterpret_cast<const char*>(&loop),
+                        sizeof(loop));
     if (rv < 0)
       return MapSystemError(WSAGetLastError());
   }
   if (multicast_time_to_live_ != 1) {
     DWORD hops = multicast_time_to_live_;
-    int protocol_level =
-        addr_family_ == AF_INET ? IPPROTO_IP : IPPROTO_IPV6;
+    int protocol_level = addr_family_ == AF_INET ? IPPROTO_IP : IPPROTO_IPV6;
     int option =
-        addr_family_ == AF_INET ? IP_MULTICAST_TTL: IPV6_MULTICAST_HOPS;
-    int rv = setsockopt(socket_, protocol_level, option,
-                        reinterpret_cast<const char*>(&hops), sizeof(hops));
+        addr_family_ == AF_INET ? IP_MULTICAST_TTL : IPV6_MULTICAST_HOPS;
+    int rv = setsockopt(socket_,
+                        protocol_level,
+                        option,
+                        reinterpret_cast<const char*>(&hops),
+                        sizeof(hops));
     if (rv < 0)
       return MapSystemError(WSAGetLastError());
   }
   if (multicast_interface_ != 0) {
     switch (addr_family_) {
       case AF_INET: {
         in_addr address;
         address.s_addr = htonl(multicast_interface_);
-        int rv = setsockopt(socket_, IPPROTO_IP, IP_MULTICAST_IF,
+        int rv = setsockopt(socket_,
+                            IPPROTO_IP,
+                            IP_MULTICAST_IF,
                             reinterpret_cast<const char*>(&address),
                             sizeof(address));
         if (rv)
           return MapSystemError(WSAGetLastError());
         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(WSAGetLastError());
         break;
       }
       default:
         NOTREACHED() << "Invalid address family";
         return ERR_ADDRESS_INVALID;
     }
@@ skipping 18 matching lines @@
   //   page "Using SO_REUSEADDR and SO_EXCLUSIVEADDRUSE" for the gory details.
   if (last_error == WSAEACCES || last_error == WSAEADDRNOTAVAIL)
     return ERR_ADDRESS_IN_USE;
   return MapSystemError(last_error);
 }
 
 int UDPSocketWin::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));
 }
 
 bool UDPSocketWin::ReceiveAddressToIPEndpoint(IPEndPoint* address) const {
   SockaddrStorage& storage = core_->recv_addr_storage_;
   return address->FromSockAddr(storage.addr, storage.addr_len);
 }
 
-int UDPSocketWin::JoinGroup(
-    const IPAddressNumber& group_address) const {
+int UDPSocketWin::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;
       ip_mreq mreq;
       mreq.imr_interface.s_addr = htonl(multicast_interface_);
       memcpy(&mreq.imr_multiaddr, &group_address[0], kIPv4AddressSize);
-      int rv = setsockopt(socket_, IPPROTO_IP, IP_ADD_MEMBERSHIP,
+      int rv = setsockopt(socket_,
+                          IPPROTO_IP,
+                          IP_ADD_MEMBERSHIP,
                           reinterpret_cast<const char*>(&mreq),
                           sizeof(mreq));
       if (rv)
         return MapSystemError(WSAGetLastError());
       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_ADD_MEMBERSHIP,
+      int rv = setsockopt(socket_,
+                          IPPROTO_IPV6,
+                          IPV6_ADD_MEMBERSHIP,
                           reinterpret_cast<const char*>(&mreq),
                           sizeof(mreq));
       if (rv)
         return MapSystemError(WSAGetLastError());
       return OK;
     }
     default:
       NOTREACHED() << "Invalid address family";
       return ERR_ADDRESS_INVALID;
   }
 }
 
-int UDPSocketWin::LeaveGroup(
-    const IPAddressNumber& group_address) const {
+int UDPSocketWin::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 = htonl(multicast_interface_);
       memcpy(&mreq.imr_multiaddr, &group_address[0], kIPv4AddressSize);
-      int rv = setsockopt(socket_, IPPROTO_IP, IP_DROP_MEMBERSHIP,
-                          reinterpret_cast<const char*>(&mreq), sizeof(mreq));
+      int rv = setsockopt(socket_,
+                          IPPROTO_IP,
+                          IP_DROP_MEMBERSHIP,
+                          reinterpret_cast<const char*>(&mreq),
+                          sizeof(mreq));
       if (rv)
         return MapSystemError(WSAGetLastError());
       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, IP_DROP_MEMBERSHIP,
-                          reinterpret_cast<const char*>(&mreq), sizeof(mreq));
+      int rv = setsockopt(socket_,
+                          IPPROTO_IPV6,
+                          IP_DROP_MEMBERSHIP,
+                          reinterpret_cast<const char*>(&mreq),
+                          sizeof(mreq));
       if (rv)
         return MapSystemError(WSAGetLastError());
       return OK;
     }
     default:
       NOTREACHED() << "Invalid address family";
       return ERR_ADDRESS_INVALID;
   }
 }
 
@@ skipping 32 matching lines @@
 // Note: setsockopt(IP_TOS) does not work on windows XP and later.
 int UDPSocketWin::SetDiffServCodePoint(DiffServCodePoint dscp) {
   return ERR_NOT_IMPLEMENTED;
 }
 
 void UDPSocketWin::DetachFromThread() {
   base::NonThreadSafe::DetachFromThread();
 }
 
 }  // namespace net