Clang format slam.

net/socket/tcp_socket_libevent.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.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <netdb.h>
 #include <netinet/in.h>
@@ skipping 93 matching lines @@
       }
       return net_error;
     }
   }
 }
 
 }  // namespace
 
 //-----------------------------------------------------------------------------
 
-TCPSocketLibevent::Watcher::Watcher(
-    const base::Closure& read_ready_callback,
-    const base::Closure& write_ready_callback)
+TCPSocketLibevent::Watcher::Watcher(const base::Closure& read_ready_callback,
+                                    const base::Closure& write_ready_callback)
     : read_ready_callback_(read_ready_callback),
       write_ready_callback_(write_ready_callback) {
 }
 
 TCPSocketLibevent::Watcher::~Watcher() {
 }
 
 void TCPSocketLibevent::Watcher::OnFileCanReadWithoutBlocking(int /* fd */) {
   if (!read_ready_callback_.is_null())
     read_ready_callback_.Run();
@@ skipping 32 matching lines @@
       logging_multiple_connect_attempts_(false),
       net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_SOCKET)) {
   net_log_.BeginEvent(NetLog::TYPE_SOCKET_ALIVE,
                       source.ToEventParametersCallback());
 }
 
 TCPSocketLibevent::~TCPSocketLibevent() {
   net_log_.EndEvent(NetLog::TYPE_SOCKET_ALIVE);
   if (tcp_fastopen_connected_) {
     UMA_HISTOGRAM_ENUMERATION("Net.TcpFastOpenSocketConnection",
-                              fast_open_status_, FAST_OPEN_MAX_VALUE);
+                              fast_open_status_,
+                              FAST_OPEN_MAX_VALUE);
   }
   Close();
 }
 
 int TCPSocketLibevent::Open(AddressFamily family) {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(socket_, kInvalidSocket);
 
-  socket_ = CreatePlatformSocket(ConvertAddressFamily(family), SOCK_STREAM,
-                                 IPPROTO_TCP);
+  socket_ = CreatePlatformSocket(
+      ConvertAddressFamily(family), SOCK_STREAM, IPPROTO_TCP);
   if (socket_ < 0) {
     PLOG(ERROR) << "CreatePlatformSocket() returned an error";
     return MapSystemError(errno);
   }
 
   if (SetNonBlocking(socket_)) {
     int result = MapSystemError(errno);
     Close();
     return result;
   }
@@ skipping 58 matching lines @@
   DCHECK(address);
   DCHECK(!callback.is_null());
   DCHECK(accept_callback_.is_null());
 
   net_log_.BeginEvent(NetLog::TYPE_TCP_ACCEPT);
 
   int result = AcceptInternal(socket, address);
 
   if (result == ERR_IO_PENDING) {
     if (!base::MessageLoopForIO::current()->WatchFileDescriptor(
-            socket_, true, base::MessageLoopForIO::WATCH_READ,
-            &accept_socket_watcher_, &accept_watcher_)) {
+            socket_,
+            true,
+            base::MessageLoopForIO::WATCH_READ,
+            &accept_socket_watcher_,
+            &accept_watcher_)) {
       PLOG(ERROR) << "WatchFileDescriptor failed on read";
       return MapSystemError(errno);
     }
 
     accept_socket_ = socket;
     accept_address_ = address;
     accept_callback_ = callback;
   }
 
   return result;
@@ skipping 84 matching lines @@
   DCHECK(!waiting_connect_);
   DCHECK(read_callback_.is_null());
   // Synchronous operation not supported
   DCHECK(!callback.is_null());
   DCHECK_GT(buf_len, 0);
 
   int nread = HANDLE_EINTR(read(socket_, buf->data(), buf_len));
   if (nread >= 0) {
     base::StatsCounter read_bytes("tcp.read_bytes");
     read_bytes.Add(nread);
-    net_log_.AddByteTransferEvent(NetLog::TYPE_SOCKET_BYTES_RECEIVED, nread,
-                                  buf->data());
+    net_log_.AddByteTransferEvent(
+        NetLog::TYPE_SOCKET_BYTES_RECEIVED, nread, buf->data());
     RecordFastOpenStatus();
     return nread;
   }
   if (errno != EAGAIN && errno != EWOULDBLOCK) {
     int net_error = MapSystemError(errno);
     net_log_.AddEvent(NetLog::TYPE_SOCKET_READ_ERROR,
                       CreateNetLogSocketErrorCallback(net_error, errno));
     return net_error;
   }
 
   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_)) {
     DVLOG(1) << "WatchFileDescriptor failed on read, errno " << errno;
     return MapSystemError(errno);
   }
 
   read_buf_ = buf;
   read_buf_len_ = buf_len;
   read_callback_ = callback;
   return ERR_IO_PENDING;
 }
 
 int TCPSocketLibevent::Write(IOBuffer* buf,
                              int buf_len,
                              const CompletionCallback& callback) {
   DCHECK(CalledOnValidThread());
   DCHECK_NE(kInvalidSocket, socket_);
   DCHECK(!waiting_connect_);
   DCHECK(write_callback_.is_null());
   // Synchronous operation not supported
   DCHECK(!callback.is_null());
   DCHECK_GT(buf_len, 0);
 
   int nwrite = InternalWrite(buf, buf_len);
   if (nwrite >= 0) {
     base::StatsCounter write_bytes("tcp.write_bytes");
     write_bytes.Add(nwrite);
-    net_log_.AddByteTransferEvent(NetLog::TYPE_SOCKET_BYTES_SENT, nwrite,
-                                  buf->data());
+    net_log_.AddByteTransferEvent(
+        NetLog::TYPE_SOCKET_BYTES_SENT, nwrite, buf->data());
     return nwrite;
   }
   if (errno != EAGAIN && errno != EWOULDBLOCK) {
     int net_error = MapSystemError(errno);
     net_log_.AddEvent(NetLog::TYPE_SOCKET_WRITE_ERROR,
                       CreateNetLogSocketErrorCallback(net_error, errno));
     return net_error;
   }
 
   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;
     return MapSystemError(errno);
   }
 
   write_buf_ = buf;
   write_buf_len_ = buf_len;
   write_callback_ = callback;
   return ERR_IO_PENDING;
 }
 
@@ skipping 24 matching lines @@
   return SetAddressReuse(true);
 }
 
 void TCPSocketLibevent::SetDefaultOptionsForClient() {
   DCHECK(CalledOnValidThread());
 
   // This mirrors the behaviour on Windows. See the comment in
   // tcp_socket_win.cc after searching for "NODELAY".
   SetTCPNoDelay(socket_, true);  // If SetTCPNoDelay fails, we don't care.
 
-  // TCP keep alive wakes up the radio, which is expensive on mobile. Do not
-  // enable it there. It's useful to prevent TCP middleboxes from timing out
-  // connection mappings. Packets for timed out connection mappings at
-  // middleboxes will either lead to:
-  // a) Middleboxes sending TCP RSTs. It's up to higher layers to check for this
-  // and retry. The HTTP network transaction code does this.
-  // b) Middleboxes just drop the unrecognized TCP packet. This leads to the TCP
-  // stack retransmitting packets per TCP stack retransmission timeouts, which
-  // are very high (on the order of seconds). Given the number of
-  // retransmissions required before killing the connection, this can lead to
-  // tens of seconds or even minutes of delay, depending on OS.
+// TCP keep alive wakes up the radio, which is expensive on mobile. Do not
+// enable it there. It's useful to prevent TCP middleboxes from timing out
+// connection mappings. Packets for timed out connection mappings at
+// middleboxes will either lead to:
+// a) Middleboxes sending TCP RSTs. It's up to higher layers to check for this
+// and retry. The HTTP network transaction code does this.
+// b) Middleboxes just drop the unrecognized TCP packet. This leads to the TCP
+// stack retransmitting packets per TCP stack retransmission timeouts, which
+// are very high (on the order of seconds). Given the number of
+// retransmissions required before killing the connection, this can lead to
+// tens of seconds or even minutes of delay, depending on OS.
 #if !defined(OS_ANDROID) && !defined(OS_IOS)
   const int kTCPKeepAliveSeconds = 45;
 
   SetTCPKeepAlive(socket_, true, kTCPKeepAliveSeconds);
 #endif
 }
 
 int TCPSocketLibevent::SetAddressReuse(bool allow) {
   DCHECK(CalledOnValidThread());
 
   // SO_REUSEADDR is useful for server sockets to bind to a recently unbound
   // port. When a socket is closed, the end point changes its state to TIME_WAIT
   // and wait for 2 MSL (maximum segment lifetime) to ensure the remote peer
   // acknowledges its closure. For server sockets, it is usually safe to
   // bind to a TIME_WAIT end point immediately, which is a widely adopted
   // behavior.
   //
   // Note that on *nix, SO_REUSEADDR does not enable the TCP socket to bind to
   // an end point that is already bound by another socket. To do that one must
   // set SO_REUSEPORT instead. This option is not provided on Linux prior
   // to 3.9.
   //
   // SO_REUSEPORT is provided in MacOS X and iOS.
   int boolean_value = allow ? 1 : 0;
-  int rv = setsockopt(socket_, SOL_SOCKET, SO_REUSEADDR, &boolean_value,
-                      sizeof(boolean_value));
+  int rv = setsockopt(
+      socket_, SOL_SOCKET, SO_REUSEADDR, &boolean_value, sizeof(boolean_value));
   if (rv < 0)
     return MapSystemError(errno);
   return OK;
 }
 
 int TCPSocketLibevent::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));
   return (rv == 0) ? OK : MapSystemError(errno);
 }
 
 int TCPSocketLibevent::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));
   return (rv == 0) ? OK : MapSystemError(errno);
 }
 
 bool TCPSocketLibevent::SetKeepAlive(bool enable, int delay) {
   DCHECK(CalledOnValidThread());
   return SetTCPKeepAlive(socket_, enable, delay);
 }
 
 bool TCPSocketLibevent::SetNoDelay(bool no_delay) {
   DCHECK(CalledOnValidThread());
@@ skipping 60 matching lines @@
     LogConnectEnd(net_error);
     logging_multiple_connect_attempts_ = false;
   } else {
     NOTREACHED();
   }
 }
 
 int TCPSocketLibevent::AcceptInternal(scoped_ptr<TCPSocketLibevent>* socket,
                                       IPEndPoint* address) {
   SockaddrStorage storage;
-  int new_socket = HANDLE_EINTR(accept(socket_,
-                                       storage.addr,
-                                       &storage.addr_len));
+  int new_socket =
+      HANDLE_EINTR(accept(socket_, storage.addr, &storage.addr_len));
   if (new_socket < 0) {
     int net_error = MapAcceptError(errno);
     if (net_error != ERR_IO_PENDING)
       net_log_.EndEventWithNetErrorCode(NetLog::TYPE_TCP_ACCEPT, net_error);
     return net_error;
   }
 
   IPEndPoint ip_end_point;
   if (!ip_end_point.FromSockAddr(storage.addr, storage.addr_len)) {
     NOTREACHED();
     if (IGNORE_EINTR(close(new_socket)) < 0)
       PLOG(ERROR) << "close";
     int net_error = ERR_ADDRESS_INVALID;
     net_log_.EndEventWithNetErrorCode(NetLog::TYPE_TCP_ACCEPT, net_error);
     return net_error;
   }
-  scoped_ptr<TCPSocketLibevent> tcp_socket(new TCPSocketLibevent(
-      net_log_.net_log(), net_log_.source()));
+  scoped_ptr<TCPSocketLibevent> tcp_socket(
+      new TCPSocketLibevent(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 22 matching lines @@
   }
 
   // Check if the connect() failed synchronously.
   connect_os_error_ = errno;
   if (connect_os_error_ != EINPROGRESS)
     return MapConnectError(connect_os_error_);
 
   // Otherwise the connect() is going to complete asynchronously, so watch
   // for its completion.
   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_)) {
     connect_os_error_ = errno;
     DVLOG(1) << "WatchFileDescriptor failed: " << connect_os_error_;
     return MapSystemError(connect_os_error_);
   }
 
   return ERR_IO_PENDING;
 }
 
 void TCPSocketLibevent::DoConnectComplete(int result) {
   // Log the end of this attempt (and any OS error it threw).
@@ skipping 29 matching lines @@
 
   SockaddrStorage storage;
   int rv = getsockname(socket_, storage.addr, &storage.addr_len);
   if (rv != 0) {
     PLOG(ERROR) << "getsockname() [rv: " << rv << "] error: ";
     NOTREACHED();
     net_log_.EndEventWithNetErrorCode(NetLog::TYPE_TCP_CONNECT, rv);
     return;
   }
 
-  net_log_.EndEvent(NetLog::TYPE_TCP_CONNECT,
-                    CreateNetLogSourceAddressCallback(storage.addr,
-                                                      storage.addr_len));
+  net_log_.EndEvent(
+      NetLog::TYPE_TCP_CONNECT,
+      CreateNetLogSourceAddressCallback(storage.addr, storage.addr_len));
 }
 
 void TCPSocketLibevent::DidCompleteRead() {
   RecordFastOpenStatus();
   if (read_callback_.is_null())
     return;
 
   int bytes_transferred;
-  bytes_transferred = HANDLE_EINTR(read(socket_, read_buf_->data(),
-                                        read_buf_len_));
+  bytes_transferred =
+      HANDLE_EINTR(read(socket_, read_buf_->data(), read_buf_len_));
 
   int result;
   if (bytes_transferred >= 0) {
     result = bytes_transferred;
     base::StatsCounter read_bytes("tcp.read_bytes");
     read_bytes.Add(bytes_transferred);
-    net_log_.AddByteTransferEvent(NetLog::TYPE_SOCKET_BYTES_RECEIVED, result,
-                                  read_buf_->data());
+    net_log_.AddByteTransferEvent(
+        NetLog::TYPE_SOCKET_BYTES_RECEIVED, result, read_buf_->data());
   } else {
     result = MapSystemError(errno);
     if (result != ERR_IO_PENDING) {
       net_log_.AddEvent(NetLog::TYPE_SOCKET_READ_ERROR,
                         CreateNetLogSocketErrorCallback(result, errno));
     }
   }
 
   if (result != ERR_IO_PENDING) {
     read_buf_ = NULL;
     read_buf_len_ = 0;
     bool ok = read_socket_watcher_.StopWatchingFileDescriptor();
     DCHECK(ok);
     base::ResetAndReturn(&read_callback_).Run(result);
   }
 }
 
 void TCPSocketLibevent::DidCompleteWrite() {
   if (write_callback_.is_null())
     return;
 
   int bytes_transferred;
-  bytes_transferred = HANDLE_EINTR(write(socket_, write_buf_->data(),
-                                         write_buf_len_));
+  bytes_transferred =
+      HANDLE_EINTR(write(socket_, write_buf_->data(), write_buf_len_));
 
   int result;
   if (bytes_transferred >= 0) {
     result = bytes_transferred;
     base::StatsCounter write_bytes("tcp.write_bytes");
     write_bytes.Add(bytes_transferred);
-    net_log_.AddByteTransferEvent(NetLog::TYPE_SOCKET_BYTES_SENT, result,
-                                  write_buf_->data());
+    net_log_.AddByteTransferEvent(
+        NetLog::TYPE_SOCKET_BYTES_SENT, result, write_buf_->data());
   } else {
     result = MapSystemError(errno);
     if (result != ERR_IO_PENDING) {
       net_log_.AddEvent(NetLog::TYPE_SOCKET_WRITE_ERROR,
                         CreateNetLogSocketErrorCallback(result, errno));
     }
   }
 
   if (result != ERR_IO_PENDING) {
     write_buf_ = NULL;
@@ skipping 48 matching lines @@
   int nwrite;
   if (use_tcp_fastopen_ && !tcp_fastopen_connected_) {
     SockaddrStorage storage;
     if (!peer_address_->ToSockAddr(storage.addr, &storage.addr_len)) {
       // Set errno to EADDRNOTAVAIL so that MapSystemError will map it to
       // ERR_ADDRESS_INVALID later.
       errno = EADDRNOTAVAIL;
       return -1;
     }
 
-    int flags = 0x20000000; // Magic flag to enable TCP_FASTOPEN.
+    int flags = 0x20000000;  // Magic flag to enable TCP_FASTOPEN.
 #if defined(OS_LINUX)
     // sendto() will fail with EPIPE when the system doesn't support TCP Fast
     // Open. Theoretically that shouldn't happen since the caller should check
     // for system support on startup, but users may dynamically disable TCP Fast
     // Open via sysctl.
     flags |= MSG_NOSIGNAL;
-#endif // defined(OS_LINUX)
-    nwrite = HANDLE_EINTR(sendto(socket_,
-                                 buf->data(),
-                                 buf_len,
-                                 flags,
-                                 storage.addr,
-                                 storage.addr_len));
+#endif  // defined(OS_LINUX)
+    nwrite = HANDLE_EINTR(sendto(
+        socket_, buf->data(), buf_len, flags, storage.addr, storage.addr_len));
     tcp_fastopen_connected_ = true;
 
     if (nwrite < 0) {
       DCHECK_NE(EPIPE, errno);
 
       // If errno == EINPROGRESS, that means the kernel didn't have a cookie
       // and would block. The kernel is internally doing a connect() though.
       // Remap EINPROGRESS to EAGAIN so we treat this the same as our other
       // asynchronous cases. Note that the user buffer has not been copied to
       // kernel space.
@@ skipping 19 matching lines @@
     DCHECK_NE(FAST_OPEN_STATUS_UNKNOWN, fast_open_status_);
     bool getsockopt_success(false);
     bool server_acked_data(false);
 #if defined(TCP_INFO)
     // Probe to see the if the socket used TCP Fast Open.
     tcp_info info;
     socklen_t info_len = sizeof(tcp_info);
     getsockopt_success =
         getsockopt(socket_, IPPROTO_TCP, TCP_INFO, &info, &info_len) == 0 &&
         info_len == sizeof(tcp_info);
-    server_acked_data = getsockopt_success &&
-        (info.tcpi_options & TCPI_OPT_SYN_DATA);
+    server_acked_data =
+        getsockopt_success && (info.tcpi_options & TCPI_OPT_SYN_DATA);
 #endif
     if (getsockopt_success) {
       if (fast_open_status_ == FAST_OPEN_FAST_CONNECT_RETURN) {
-        fast_open_status_ = (server_acked_data ? FAST_OPEN_SYN_DATA_ACK :
-                             FAST_OPEN_SYN_DATA_NACK);
+        fast_open_status_ = (server_acked_data ? FAST_OPEN_SYN_DATA_ACK
+                                               : FAST_OPEN_SYN_DATA_NACK);
       } else {
-        fast_open_status_ = (server_acked_data ? FAST_OPEN_NO_SYN_DATA_ACK :
-                             FAST_OPEN_NO_SYN_DATA_NACK);
+        fast_open_status_ = (server_acked_data ? FAST_OPEN_NO_SYN_DATA_ACK
+                                               : FAST_OPEN_NO_SYN_DATA_NACK);
       }
     } else {
-      fast_open_status_ = (fast_open_status_ == FAST_OPEN_FAST_CONNECT_RETURN ?
-                           FAST_OPEN_SYN_DATA_FAILED :
-                           FAST_OPEN_NO_SYN_DATA_FAILED);
+      fast_open_status_ = (fast_open_status_ == FAST_OPEN_FAST_CONNECT_RETURN
+                               ? FAST_OPEN_SYN_DATA_FAILED
+                               : FAST_OPEN_NO_SYN_DATA_FAILED);
     }
   }
 }
 
 }  // namespace net