Clang format slam.

net/socket/socks_client_socket.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/socket/socks_client_socket.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/sys_byteorder.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_log.h"
 #include "net/base/net_util.h"
 #include "net/socket/client_socket_handle.h"
 
 namespace net {
 
 // Every SOCKS server requests a user-id from the client. It is optional
 // and we send an empty string.
 static const char kEmptyUserId[] = "";
 
 // For SOCKS4, the client sends 8 bytes  plus the size of the user-id.
 static const unsigned int kWriteHeaderSize = 8;
 
 // For SOCKS4 the server sends 8 bytes for acknowledgement.
 static const unsigned int kReadHeaderSize = 8;
 
 // Server Response codes for SOCKS.
-static const uint8 kServerResponseOk  = 0x5A;
+static const uint8 kServerResponseOk = 0x5A;
 static const uint8 kServerResponseRejected = 0x5B;
 static const uint8 kServerResponseNotReachable = 0x5C;
 static const uint8 kServerResponseMismatchedUserId = 0x5D;
 
 static const uint8 kSOCKSVersion4 = 0x04;
 static const uint8 kSOCKSStreamRequest = 0x01;
 
 // A struct holding the essential details of the SOCKS4 Server Request.
 // The port in the header is stored in network byte order.
 struct SOCKS4ServerRequest {
@@ skipping 22 matching lines @@
     HostResolver* host_resolver)
     : transport_(transport_socket.Pass()),
       next_state_(STATE_NONE),
       completed_handshake_(false),
       bytes_sent_(0),
       bytes_received_(0),
       was_ever_used_(false),
       host_resolver_(host_resolver),
       host_request_info_(req_info),
       priority_(priority),
-      net_log_(transport_->socket()->NetLog()) {}
+      net_log_(transport_->socket()->NetLog()) {
+}
 
 SOCKSClientSocket::~SOCKSClientSocket() {
   Disconnect();
 }
 
 int SOCKSClientSocket::Connect(const CompletionCallback& callback) {
   DCHECK(transport_.get());
   DCHECK(transport_->socket());
   DCHECK_EQ(STATE_NONE, next_state_);
   DCHECK(user_callback_.is_null());
@@ skipping 81 matching lines @@
   NOTREACHED();
   return kProtoUnknown;
 }
 
 bool SOCKSClientSocket::GetSSLInfo(SSLInfo* ssl_info) {
   if (transport_.get() && transport_->socket()) {
     return transport_->socket()->GetSSLInfo(ssl_info);
   }
   NOTREACHED();
   return false;
-
 }
 
 // Read is called by the transport layer above to read. This can only be done
 // if the SOCKS handshake is complete.
-int SOCKSClientSocket::Read(IOBuffer* buf, int buf_len,
+int SOCKSClientSocket::Read(IOBuffer* buf,
+                            int buf_len,
                             const CompletionCallback& callback) {
   DCHECK(completed_handshake_);
   DCHECK_EQ(STATE_NONE, next_state_);
   DCHECK(user_callback_.is_null());
   DCHECK(!callback.is_null());
 
   int rv = transport_->socket()->Read(
-      buf, buf_len,
+      buf,
+      buf_len,
       base::Bind(&SOCKSClientSocket::OnReadWriteComplete,
-                 base::Unretained(this), callback));
+                 base::Unretained(this),
+                 callback));
   if (rv > 0)
     was_ever_used_ = true;
   return rv;
 }
 
 // Write is called by the transport layer. This can only be done if the
 // SOCKS handshake is complete.
-int SOCKSClientSocket::Write(IOBuffer* buf, int buf_len,
+int SOCKSClientSocket::Write(IOBuffer* buf,
+                             int buf_len,
                              const CompletionCallback& callback) {
   DCHECK(completed_handshake_);
   DCHECK_EQ(STATE_NONE, next_state_);
   DCHECK(user_callback_.is_null());
   DCHECK(!callback.is_null());
 
   int rv = transport_->socket()->Write(
-      buf, buf_len,
+      buf,
+      buf_len,
       base::Bind(&SOCKSClientSocket::OnReadWriteComplete,
-                 base::Unretained(this), callback));
+                 base::Unretained(this),
+                 callback));
   if (rv > 0)
     was_ever_used_ = true;
   return rv;
 }
 
 int SOCKSClientSocket::SetReceiveBufferSize(int32 size) {
   return transport_->socket()->SetReceiveBufferSize(size);
 }
 
 int SOCKSClientSocket::SetSendBufferSize(int32 size) {
@@ skipping 124 matching lines @@
   next_state_ = STATE_HANDSHAKE_WRITE_COMPLETE;
 
   if (buffer_.empty()) {
     buffer_ = BuildHandshakeWriteBuffer();
     bytes_sent_ = 0;
   }
 
   int handshake_buf_len = buffer_.size() - bytes_sent_;
   DCHECK_GT(handshake_buf_len, 0);
   handshake_buf_ = new IOBuffer(handshake_buf_len);
-  memcpy(handshake_buf_->data(), &buffer_[bytes_sent_],
-         handshake_buf_len);
+  memcpy(handshake_buf_->data(), &buffer_[bytes_sent_], handshake_buf_len);
   return transport_->socket()->Write(
       handshake_buf_.get(),
       handshake_buf_len,
       base::Bind(&SOCKSClientSocket::OnIOComplete, base::Unretained(this)));
 }
 
 int SOCKSClientSocket::DoHandshakeWriteComplete(int result) {
   if (result < 0)
     return result;
 
@@ skipping 81 matching lines @@
 
 int SOCKSClientSocket::GetPeerAddress(IPEndPoint* address) const {
   return transport_->socket()->GetPeerAddress(address);
 }
 
 int SOCKSClientSocket::GetLocalAddress(IPEndPoint* address) const {
   return transport_->socket()->GetLocalAddress(address);
 }
 
 }  // namespace net