Clang format slam.

net/socket/socks5_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/socks5_client_socket.h"
 
 #include "base/basictypes.h"
 #include "base/callback_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/debug/trace_event.h"
@@ skipping 126 matching lines @@
   NOTREACHED();
   return kProtoUnknown;
 }
 
 bool SOCKS5ClientSocket::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 SOCKS5ClientSocket::Read(IOBuffer* buf, int buf_len,
+int SOCKS5ClientSocket::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(&SOCKS5ClientSocket::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 SOCKS5ClientSocket::Write(IOBuffer* buf, int buf_len,
+int SOCKS5ClientSocket::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(&SOCKS5ClientSocket::OnReadWriteComplete,
-                 base::Unretained(this), callback));
+                 base::Unretained(this),
+                 callback));
   if (rv > 0)
     was_ever_used_ = true;
   return rv;
 }
 
 int SOCKS5ClientSocket::SetReceiveBufferSize(int32 size) {
   return transport_->socket()->SetReceiveBufferSize(size);
 }
 
 int SOCKS5ClientSocket::SetSendBufferSize(int32 size) {
@@ skipping 53 matching lines @@
         rv = DoGreetReadComplete(rv);
         net_log_.EndEventWithNetErrorCode(NetLog::TYPE_SOCKS5_GREET_READ, rv);
         break;
       case STATE_HANDSHAKE_WRITE:
         DCHECK_EQ(OK, rv);
         net_log_.BeginEvent(NetLog::TYPE_SOCKS5_HANDSHAKE_WRITE);
         rv = DoHandshakeWrite();
         break;
       case STATE_HANDSHAKE_WRITE_COMPLETE:
         rv = DoHandshakeWriteComplete(rv);
-        net_log_.EndEventWithNetErrorCode(
-            NetLog::TYPE_SOCKS5_HANDSHAKE_WRITE, rv);
+        net_log_.EndEventWithNetErrorCode(NetLog::TYPE_SOCKS5_HANDSHAKE_WRITE,
+                                          rv);
         break;
       case STATE_HANDSHAKE_READ:
         DCHECK_EQ(OK, rv);
         net_log_.BeginEvent(NetLog::TYPE_SOCKS5_HANDSHAKE_READ);
         rv = DoHandshakeRead();
         break;
       case STATE_HANDSHAKE_READ_COMPLETE:
         rv = DoHandshakeReadComplete(rv);
-        net_log_.EndEventWithNetErrorCode(
-            NetLog::TYPE_SOCKS5_HANDSHAKE_READ, rv);
+        net_log_.EndEventWithNetErrorCode(NetLog::TYPE_SOCKS5_HANDSHAKE_READ,
+                                          rv);
         break;
       default:
         NOTREACHED() << "bad state";
         rv = ERR_UNEXPECTED;
         break;
     }
   } while (rv != ERR_IO_PENDING && next_state_ != STATE_NONE);
   return rv;
 }
 
-const char kSOCKS5GreetWriteData[] = { 0x05, 0x01, 0x00 };  // no authentication
+const char kSOCKS5GreetWriteData[] = {0x05, 0x01, 0x00};  // no authentication
 
 int SOCKS5ClientSocket::DoGreetWrite() {
   // Since we only have 1 byte to send the hostname length in, if the
   // URL has a hostname longer than 255 characters we can't send it.
   if (0xFF < host_request_info_.hostname().size()) {
     net_log_.AddEvent(NetLog::TYPE_SOCKS_HOSTNAME_TOO_BIG);
     return ERR_SOCKS_CONNECTION_FAILED;
   }
 
   if (buffer_.empty()) {
-    buffer_ = std::string(kSOCKS5GreetWriteData,
-                          arraysize(kSOCKS5GreetWriteData));
+    buffer_ =
+        std::string(kSOCKS5GreetWriteData, arraysize(kSOCKS5GreetWriteData));
     bytes_sent_ = 0;
   }
 
   next_state_ = STATE_GREET_WRITE_COMPLETE;
   size_t handshake_buf_len = buffer_.size() - bytes_sent_;
   handshake_buf_ = new IOBuffer(handshake_buf_len);
-  memcpy(handshake_buf_->data(), &buffer_.data()[bytes_sent_],
-         handshake_buf_len);
-  return transport_->socket()
-      ->Write(handshake_buf_.get(), handshake_buf_len, io_callback_);
+  memcpy(
+      handshake_buf_->data(), &buffer_.data()[bytes_sent_], handshake_buf_len);
+  return transport_->socket()->Write(
+      handshake_buf_.get(), handshake_buf_len, io_callback_);
 }
 
 int SOCKS5ClientSocket::DoGreetWriteComplete(int result) {
   if (result < 0)
     return result;
 
   bytes_sent_ += result;
   if (bytes_sent_ == buffer_.size()) {
     buffer_.clear();
     bytes_received_ = 0;
     next_state_ = STATE_GREET_READ;
   } else {
     next_state_ = STATE_GREET_WRITE;
   }
   return OK;
 }
 
 int SOCKS5ClientSocket::DoGreetRead() {
   next_state_ = STATE_GREET_READ_COMPLETE;
   size_t handshake_buf_len = kGreetReadHeaderSize - bytes_received_;
   handshake_buf_ = new IOBuffer(handshake_buf_len);
-  return transport_->socket()
-      ->Read(handshake_buf_.get(), handshake_buf_len, io_callback_);
+  return transport_->socket()->Read(
+      handshake_buf_.get(), handshake_buf_len, io_callback_);
 }
 
 int SOCKS5ClientSocket::DoGreetReadComplete(int result) {
   if (result < 0)
     return result;
 
   if (result == 0) {
     net_log_.AddEvent(NetLog::TYPE_SOCKS_UNEXPECTEDLY_CLOSED_DURING_GREETING);
     return ERR_SOCKS_CONNECTION_FAILED;
   }
@@ skipping 15 matching lines @@
     net_log_.AddEvent(NetLog::TYPE_SOCKS_UNEXPECTED_AUTH,
                       NetLog::IntegerCallback("method", buffer_[1]));
     return ERR_SOCKS_CONNECTION_FAILED;
   }
 
   buffer_.clear();
   next_state_ = STATE_HANDSHAKE_WRITE;
   return OK;
 }
 
-int SOCKS5ClientSocket::BuildHandshakeWriteBuffer(std::string* handshake)
-    const {
+int SOCKS5ClientSocket::BuildHandshakeWriteBuffer(
+    std::string* handshake) const {
   DCHECK(handshake->empty());
 
   handshake->push_back(kSOCKS5Version);
   handshake->push_back(kTunnelCommand);  // Connect command
-  handshake->push_back(kNullByte);  // Reserved null
+  handshake->push_back(kNullByte);       // Reserved null
 
   handshake->push_back(kEndPointDomain);  // The type of the address.
 
   DCHECK_GE(static_cast<size_t>(0xFF), host_request_info_.hostname().size());
 
   // First add the size of the hostname, followed by the hostname.
-  handshake->push_back(static_cast<unsigned char>(
-      host_request_info_.hostname().size()));
+  handshake->push_back(
+      static_cast<unsigned char>(host_request_info_.hostname().size()));
   handshake->append(host_request_info_.hostname());
 
   uint16 nw_port = base::HostToNet16(host_request_info_.port());
   handshake->append(reinterpret_cast<char*>(&nw_port), sizeof(nw_port));
   return OK;
 }
 
 // Writes the SOCKS handshake data to the underlying socket connection.
 int SOCKS5ClientSocket::DoHandshakeWrite() {
   next_state_ = STATE_HANDSHAKE_WRITE_COMPLETE;
 
   if (buffer_.empty()) {
     int rv = BuildHandshakeWriteBuffer(&buffer_);
     if (rv != OK)
       return rv;
     bytes_sent_ = 0;
   }
 
   int handshake_buf_len = buffer_.size() - bytes_sent_;
   DCHECK_LT(0, handshake_buf_len);
   handshake_buf_ = new IOBuffer(handshake_buf_len);
-  memcpy(handshake_buf_->data(), &buffer_[bytes_sent_],
-         handshake_buf_len);
-  return transport_->socket()
-      ->Write(handshake_buf_.get(), handshake_buf_len, io_callback_);
+  memcpy(handshake_buf_->data(), &buffer_[bytes_sent_], handshake_buf_len);
+  return transport_->socket()->Write(
+      handshake_buf_.get(), handshake_buf_len, io_callback_);
 }
 
 int SOCKS5ClientSocket::DoHandshakeWriteComplete(int result) {
   if (result < 0)
     return result;
 
   // We ignore the case when result is 0, since the underlying Write
   // may return spurious writes while waiting on the socket.
 
   bytes_sent_ += result;
@@ skipping 12 matching lines @@
 int SOCKS5ClientSocket::DoHandshakeRead() {
   next_state_ = STATE_HANDSHAKE_READ_COMPLETE;
 
   if (buffer_.empty()) {
     bytes_received_ = 0;
     read_header_size = kReadHeaderSize;
   }
 
   int handshake_buf_len = read_header_size - bytes_received_;
   handshake_buf_ = new IOBuffer(handshake_buf_len);
-  return transport_->socket()
-      ->Read(handshake_buf_.get(), handshake_buf_len, io_callback_);
+  return transport_->socket()->Read(
+      handshake_buf_.get(), handshake_buf_len, io_callback_);
 }
 
 int SOCKS5ClientSocket::DoHandshakeReadComplete(int result) {
   if (result < 0)
     return result;
 
   // The underlying socket closed unexpectedly.
   if (result == 0) {
     net_log_.AddEvent(NetLog::TYPE_SOCKS_UNEXPECTEDLY_CLOSED_DURING_HANDSHAKE);
     return ERR_SOCKS_CONNECTION_FAILED;
@@ skipping 56 matching lines @@
 
 int SOCKS5ClientSocket::GetPeerAddress(IPEndPoint* address) const {
   return transport_->socket()->GetPeerAddress(address);
 }
 
 int SOCKS5ClientSocket::GetLocalAddress(IPEndPoint* address) const {
   return transport_->socket()->GetLocalAddress(address);
 }
 
 }  // namespace net