Clang format slam.

net/socket/tcp_socket_win.cc

 // Copyright 2013 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/socket/tcp_socket_win.h"
 
 #include <mstcpip.h>
 
 #include "base/callback_helpers.h"
 #include "base/logging.h"
@@ skipping 11 matching lines @@
 #include "net/socket/socket_descriptor.h"
 #include "net/socket/socket_net_log_params.h"
 
 namespace net {
 
 namespace {
 
 const int kTCPKeepAliveSeconds = 45;
 
 int SetSocketReceiveBufferSize(SOCKET socket, int32 size) {
-  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 net_error = (rv == 0) ? OK : MapSystemError(WSAGetLastError());
   DCHECK(!rv) << "Could not set socket receive buffer size: " << net_error;
   return net_error;
 }
 
 int SetSocketSendBufferSize(SOCKET socket, int32 size) {
-  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 net_error = (rv == 0) ? OK : MapSystemError(WSAGetLastError());
   DCHECK(!rv) << "Could not set socket send buffer size: " << net_error;
   return net_error;
 }
 
 // Disable Nagle.
 // The Nagle implementation on windows is governed by RFC 896.  The idea
 // behind Nagle is to reduce small packets on the network.  When Nagle is
 // enabled, if a partial packet has been sent, the TCP stack will disallow
 // further *partial* packets until an ACK has been received from the other
 // side.  Good applications should always strive to send as much data as
 // possible and avoid partial-packet sends.  However, in most real world
 // applications, there are edge cases where this does not happen, and two
 // partial packets may be sent back to back.  For a browser, it is NEVER
 // a benefit to delay for an RTT before the second packet is sent.
 //
 // As a practical example in Chromium today, consider the case of a small
 // POST.  I have verified this:
 //     Client writes 649 bytes of header  (partial packet #1)
 //     Client writes 50 bytes of POST data (partial packet #2)
 // In the above example, with Nagle, a RTT delay is inserted between these
 // two sends due to nagle.  RTTs can easily be 100ms or more.  The best
 // fix is to make sure that for POSTing data, we write as much data as
 // possible and minimize partial packets.  We will fix that.  But disabling
 // Nagle also ensure we don't run into this delay in other edge cases.
 // See also:
 //    http://technet.microsoft.com/en-us/library/bb726981.aspx
 bool DisableNagle(SOCKET socket, bool disable) {
   BOOL val = disable ? TRUE : FALSE;
-  int rv = setsockopt(socket, IPPROTO_TCP, TCP_NODELAY,
+  int rv = setsockopt(socket,
+                      IPPROTO_TCP,
+                      TCP_NODELAY,
                       reinterpret_cast<const char*>(&val),
                       sizeof(val));
   DCHECK(!rv) << "Could not disable nagle";
   return rv == 0;
 }
 
 // Enable TCP Keep-Alive to prevent NAT routers from timing out TCP
 // connections. See http://crbug.com/27400 for details.
 bool SetTCPKeepAlive(SOCKET socket, BOOL enable, int delay_secs) {
   int delay = delay_secs * 1000;
   struct tcp_keepalive keepalive_vals = {
-    enable ? 1 : 0,  // TCP keep-alive on.
-    delay,  // Delay seconds before sending first TCP keep-alive packet.
-    delay,  // Delay seconds between sending TCP keep-alive packets.
+      enable ? 1 : 0,  // TCP keep-alive on.
+      delay,  // Delay seconds before sending first TCP keep-alive packet.
+      delay,  // Delay seconds between sending TCP keep-alive packets.
   };
   DWORD bytes_returned = 0xABAB;
-  int rv = WSAIoctl(socket, SIO_KEEPALIVE_VALS, &keepalive_vals,
-                    sizeof(keepalive_vals), NULL, 0,
-                    &bytes_returned, NULL, NULL);
+  int rv = WSAIoctl(socket,
+                    SIO_KEEPALIVE_VALS,
+                    &keepalive_vals,
+                    sizeof(keepalive_vals),
+                    NULL,
+                    0,
+                    &bytes_returned,
+                    NULL,
+                    NULL);
   DCHECK(!rv) << "Could not enable TCP Keep-Alive for socket: " << socket
               << " [error: " << WSAGetLastError() << "].";
 
   // Disregard any failure in disabling nagle or enabling TCP Keep-Alive.
   return rv == 0;
 }
 
 int MapConnectError(int os_error) {
   switch (os_error) {
     // connect fails with WSAEACCES when Windows Firewall blocks the
@@ skipping 141 matching lines @@
   if (core_->socket_) {
     if (core_->socket_->waiting_connect_)
       core_->socket_->DidCompleteConnect();
     else
       core_->socket_->DidSignalRead();
   }
 
   core_->Release();
 }
 
-void TCPSocketWin::Core::WriteDelegate::OnObjectSignaled(
-    HANDLE object) {
+void TCPSocketWin::Core::WriteDelegate::OnObjectSignaled(HANDLE object) {
   DCHECK_EQ(object, core_->write_overlapped_.hEvent);
   if (core_->socket_)
     core_->socket_->DidCompleteWrite();
 
   core_->Release();
 }
 
 //-----------------------------------------------------------------------------
 
 TCPSocketWin::TCPSocketWin(net::NetLog* net_log,
@@ skipping 15 matching lines @@
 
 TCPSocketWin::~TCPSocketWin() {
   Close();
   net_log_.EndEvent(NetLog::TYPE_SOCKET_ALIVE);
 }
 
 int TCPSocketWin::Open(AddressFamily family) {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(socket_, INVALID_SOCKET);
 
-  socket_ = CreatePlatformSocket(ConvertAddressFamily(family), SOCK_STREAM,
-                                 IPPROTO_TCP);
+  socket_ = CreatePlatformSocket(
+      ConvertAddressFamily(family), SOCK_STREAM, IPPROTO_TCP);
   if (socket_ == INVALID_SOCKET) {
     PLOG(ERROR) << "CreatePlatformSocket() returned an error";
     return MapSystemError(WSAGetLastError());
   }
 
   if (SetNonBlocking(socket_)) {
     int result = MapSystemError(WSAGetLastError());
     Close();
     return result;
   }
@@ skipping 203 matching lines @@
   base::StatsCounter writes("tcp.writes");
   writes.Increment();
 
   WSABUF write_buffer;
   write_buffer.len = buf_len;
   write_buffer.buf = buf->data();
 
   // TODO(wtc): Remove the assertion after enough testing.
   AssertEventNotSignaled(core_->write_overlapped_.hEvent);
   DWORD num;
-  int rv = WSASend(socket_, &write_buffer, 1, &num, 0,
-                   &core_->write_overlapped_, NULL);
+  int rv = WSASend(
+      socket_, &write_buffer, 1, &num, 0, &core_->write_overlapped_, NULL);
   if (rv == 0) {
     if (ResetEventIfSignaled(core_->write_overlapped_.hEvent)) {
       rv = static_cast<int>(num);
       if (rv > buf_len || rv < 0) {
         // It seems that some winsock interceptors report that more was written
         // than was available. Treat this as an error.  http://crbug.com/27870
         LOG(ERROR) << "Detected broken LSP: Asked to write " << buf_len
                    << " bytes, but " << rv << " bytes reported.";
         return ERR_WINSOCK_UNEXPECTED_WRITTEN_BYTES;
       }
       base::StatsCounter write_bytes("tcp.write_bytes");
       write_bytes.Add(rv);
-      net_log_.AddByteTransferEvent(NetLog::TYPE_SOCKET_BYTES_SENT, rv,
-                                    buf->data());
+      net_log_.AddByteTransferEvent(
+          NetLog::TYPE_SOCKET_BYTES_SENT, rv, buf->data());
       return rv;
     }
   } else {
     int os_error = WSAGetLastError();
     if (os_error != WSA_IO_PENDING) {
       int net_error = MapSystemError(os_error);
       net_log_.AddEvent(NetLog::TYPE_SOCKET_WRITE_ERROR,
                         CreateNetLogSocketErrorCallback(net_error, os_error));
       return net_error;
     }
@@ skipping 64 matching lines @@
   //
   // Unlike on *nix, on Windows a TCP server socket can always bind to an end
   // point in TIME_WAIT state without setting SO_REUSEADDR, therefore it is not
   // needed here.
   //
   // SO_EXCLUSIVEADDRUSE will prevent a TCP client socket from binding to an end
   // point in TIME_WAIT status. It does not have this effect for a TCP server
   // socket.
 
   BOOL true_value = 1;
-  int rv = setsockopt(socket_, SOL_SOCKET, SO_EXCLUSIVEADDRUSE,
+  int rv = setsockopt(socket_,
+                      SOL_SOCKET,
+                      SO_EXCLUSIVEADDRUSE,
                       reinterpret_cast<const char*>(&true_value),
                       sizeof(true_value));
   if (rv < 0)
     return MapSystemError(errno);
   return OK;
 }
 
 int TCPSocketWin::SetReceiveBufferSize(int32 size) {
   DCHECK(CalledOnValidThread());
   return SetSocketReceiveBufferSize(socket_, size);
@@ skipping 103 matching lines @@
 
   IPEndPoint ip_end_point;
   if (!ip_end_point.FromSockAddr(storage.addr, storage.addr_len)) {
     NOTREACHED();
     if (closesocket(new_socket) < 0)
       PLOG(ERROR) << "closesocket";
     int net_error = ERR_ADDRESS_INVALID;
     net_log_.EndEventWithNetErrorCode(NetLog::TYPE_TCP_ACCEPT, net_error);
     return net_error;
   }
-  scoped_ptr<TCPSocketWin> tcp_socket(new TCPSocketWin(
-      net_log_.net_log(), net_log_.source()));
+  scoped_ptr<TCPSocketWin> tcp_socket(
+      new TCPSocketWin(net_log_.net_log(), net_log_.source()));
   int adopt_result = tcp_socket->AdoptConnectedSocket(new_socket, ip_end_point);
   if (adopt_result != OK) {
     net_log_.EndEventWithNetErrorCode(NetLog::TYPE_TCP_ACCEPT, adopt_result);
     return adopt_result;
   }
   *socket = tcp_socket.Pass();
   *address = ip_end_point;
   net_log_.EndEvent(NetLog::TYPE_TCP_ACCEPT,
                     CreateNetLogIPEndPointCallback(&ip_end_point));
   return OK;
@@ skipping 113 matching lines @@
     return;
   }
 
   net_log_.EndEvent(
       NetLog::TYPE_TCP_CONNECT,
       CreateNetLogSourceAddressCallback(
           reinterpret_cast<const struct sockaddr*>(&source_address),
           sizeof(source_address)));
 }
 
-int TCPSocketWin::DoRead(IOBuffer* buf, int buf_len,
+int TCPSocketWin::DoRead(IOBuffer* buf,
+                         int buf_len,
                          const CompletionCallback& callback) {
   if (!core_->non_blocking_reads_initialized_) {
-    WSAEventSelect(socket_, core_->read_overlapped_.hEvent,
-                   FD_READ | FD_CLOSE);
+    WSAEventSelect(socket_, core_->read_overlapped_.hEvent, FD_READ | FD_CLOSE);
     core_->non_blocking_reads_initialized_ = true;
   }
   int rv = recv(socket_, buf->data(), buf_len, 0);
   if (rv == SOCKET_ERROR) {
     int os_error = WSAGetLastError();
     if (os_error != WSAEWOULDBLOCK) {
       int net_error = MapSystemError(os_error);
-      net_log_.AddEvent(
-          NetLog::TYPE_SOCKET_READ_ERROR,
-          CreateNetLogSocketErrorCallback(net_error, os_error));
+      net_log_.AddEvent(NetLog::TYPE_SOCKET_READ_ERROR,
+                        CreateNetLogSocketErrorCallback(net_error, os_error));
       return net_error;
     }
   } else {
     base::StatsCounter read_bytes("tcp.read_bytes");
     if (rv > 0)
       read_bytes.Add(rv);
-    net_log_.AddByteTransferEvent(NetLog::TYPE_SOCKET_BYTES_RECEIVED, rv,
-                                  buf->data());
+    net_log_.AddByteTransferEvent(
+        NetLog::TYPE_SOCKET_BYTES_RECEIVED, rv, buf->data());
     return rv;
   }
 
   waiting_read_ = true;
   read_callback_ = callback;
   core_->read_iobuffer_ = buf;
   core_->read_buffer_length_ = buf_len;
   core_->WatchForRead();
   return ERR_IO_PENDING;
 }
 
 void TCPSocketWin::DidCompleteConnect() {
   DCHECK(waiting_connect_);
   DCHECK(!read_callback_.is_null());
   int result;
 
   WSANETWORKEVENTS events;
-  int rv = WSAEnumNetworkEvents(socket_, core_->read_overlapped_.hEvent,
-                                &events);
+  int rv =
+      WSAEnumNetworkEvents(socket_, core_->read_overlapped_.hEvent, &events);
   int os_error = 0;
   if (rv == SOCKET_ERROR) {
     NOTREACHED();
     os_error = WSAGetLastError();
     result = MapSystemError(os_error);
   } else if (events.lNetworkEvents & FD_CONNECT) {
     os_error = events.iErrorCode[FD_CONNECT_BIT];
     result = MapConnectError(os_error);
   } else {
     NOTREACHED();
     result = ERR_UNEXPECTED;
   }
 
   connect_os_error_ = os_error;
   DoConnectComplete(result);
   waiting_connect_ = false;
 
   DCHECK_NE(result, ERR_IO_PENDING);
   base::ResetAndReturn(&read_callback_).Run(result);
 }
 
 void TCPSocketWin::DidCompleteWrite() {
   DCHECK(waiting_write_);
   DCHECK(!write_callback_.is_null());
 
   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);
   waiting_write_ = false;
   int rv;
   if (!ok) {
     int os_error = WSAGetLastError();
     rv = MapSystemError(os_error);
     net_log_.AddEvent(NetLog::TYPE_SOCKET_WRITE_ERROR,
                       CreateNetLogSocketErrorCallback(rv, os_error));
   } else {
     rv = static_cast<int>(num_bytes);
     if (rv > core_->write_buffer_length_ || rv < 0) {
       // It seems that some winsock interceptors report that more was written
       // than was available. Treat this as an error.  http://crbug.com/27870
       LOG(ERROR) << "Detected broken LSP: Asked to write "
                  << core_->write_buffer_length_ << " bytes, but " << rv
                  << " bytes reported.";
       rv = ERR_WINSOCK_UNEXPECTED_WRITTEN_BYTES;
     } else {
       base::StatsCounter write_bytes("tcp.write_bytes");
       write_bytes.Add(num_bytes);
-      net_log_.AddByteTransferEvent(NetLog::TYPE_SOCKET_BYTES_SENT, num_bytes,
+      net_log_.AddByteTransferEvent(NetLog::TYPE_SOCKET_BYTES_SENT,
+                                    num_bytes,
                                     core_->write_iobuffer_->data());
     }
   }
 
   core_->write_iobuffer_ = NULL;
 
   DCHECK_NE(rv, ERR_IO_PENDING);
   base::ResetAndReturn(&write_callback_).Run(rv);
 }
 
 void TCPSocketWin::DidSignalRead() {
   DCHECK(waiting_read_);
   DCHECK(!read_callback_.is_null());
 
   int os_error = 0;
   WSANETWORKEVENTS network_events;
-  int rv = WSAEnumNetworkEvents(socket_, core_->read_overlapped_.hEvent,
-                                &network_events);
+  int rv = WSAEnumNetworkEvents(
+      socket_, core_->read_overlapped_.hEvent, &network_events);
   if (rv == SOCKET_ERROR) {
     os_error = WSAGetLastError();
     rv = MapSystemError(os_error);
   } else if (network_events.lNetworkEvents) {
     DCHECK_EQ(network_events.lNetworkEvents & ~(FD_READ | FD_CLOSE), 0);
     // If network_events.lNetworkEvents is FD_CLOSE and
     // network_events.iErrorCode[FD_CLOSE_BIT] is 0, it is a graceful
     // connection closure. It is tempting to directly set rv to 0 in
     // this case, but the MSDN pages for WSAEventSelect and
     // WSAAsyncSelect recommend we still call DoRead():
     //   FD_CLOSE should only be posted after all data is read from a
     //   socket, but an application should check for remaining data upon
     //   receipt of FD_CLOSE to avoid any possibility of losing data.
     //
     // If network_events.iErrorCode[FD_READ_BIT] or
     // network_events.iErrorCode[FD_CLOSE_BIT] is nonzero, still call
     // DoRead() because recv() reports a more accurate error code
     // (WSAECONNRESET vs. WSAECONNABORTED) when the connection was
     // reset.
-    rv = DoRead(core_->read_iobuffer_, core_->read_buffer_length_,
-                read_callback_);
+    rv = DoRead(
+        core_->read_iobuffer_, core_->read_buffer_length_, read_callback_);
     if (rv == ERR_IO_PENDING)
       return;
   } else {
     // This may happen because Read() may succeed synchronously and
     // consume all the received data without resetting the event object.
     core_->WatchForRead();
     return;
   }
 
   waiting_read_ = false;
   core_->read_iobuffer_ = NULL;
   core_->read_buffer_length_ = 0;
 
   DCHECK_NE(rv, ERR_IO_PENDING);
   base::ResetAndReturn(&read_callback_).Run(rv);
 }
 
 }  // namespace net
-