Clang format slam.

net/socket/socket_test_util.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/socket_test_util.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 47 matching lines @@
 void DumpData(const char* data, int data_len) {
   if (logging::LOG_INFO < logging::GetMinLogLevel())
     return;
   DVLOG(1) << "Length:  " << data_len;
   const char* pfx = "Data:    ";
   if (!data || (data_len <= 0)) {
     DVLOG(1) << pfx << "<None>";
   } else {
     int i;
     for (i = 0; i <= (data_len - 4); i += 4) {
-      DVLOG(1) << pfx
-               << AsciifyHigh(data[i + 0]) << AsciifyLow(data[i + 0])
+      DVLOG(1) << pfx << AsciifyHigh(data[i + 0]) << AsciifyLow(data[i + 0])
                << AsciifyHigh(data[i + 1]) << AsciifyLow(data[i + 1])
                << AsciifyHigh(data[i + 2]) << AsciifyLow(data[i + 2])
-               << AsciifyHigh(data[i + 3]) << AsciifyLow(data[i + 3])
-               << "  '"
-               << Asciify(data[i + 0])
-               << Asciify(data[i + 1])
-               << Asciify(data[i + 2])
-               << Asciify(data[i + 3])
-               << "'";
+               << AsciifyHigh(data[i + 3]) << AsciifyLow(data[i + 3]) << "  '"
+               << Asciify(data[i + 0]) << Asciify(data[i + 1])
+               << Asciify(data[i + 2]) << Asciify(data[i + 3]) << "'";
       pfx = "         ";
     }
     // Take care of any 'trailing' bytes, if data_len was not a multiple of 4.
     switch (data_len - i) {
       case 3:
-        DVLOG(1) << pfx
-                 << AsciifyHigh(data[i + 0]) << AsciifyLow(data[i + 0])
+        DVLOG(1) << pfx << AsciifyHigh(data[i + 0]) << AsciifyLow(data[i + 0])
                  << AsciifyHigh(data[i + 1]) << AsciifyLow(data[i + 1])
                  << AsciifyHigh(data[i + 2]) << AsciifyLow(data[i + 2])
-                 << "    '"
-                 << Asciify(data[i + 0])
-                 << Asciify(data[i + 1])
-                 << Asciify(data[i + 2])
-                 << " '";
+                 << "    '" << Asciify(data[i + 0]) << Asciify(data[i + 1])
+                 << Asciify(data[i + 2]) << " '";
         break;
       case 2:
-        DVLOG(1) << pfx
-                 << AsciifyHigh(data[i + 0]) << AsciifyLow(data[i + 0])
+        DVLOG(1) << pfx << AsciifyHigh(data[i + 0]) << AsciifyLow(data[i + 0])
                  << AsciifyHigh(data[i + 1]) << AsciifyLow(data[i + 1])
-                 << "      '"
-                 << Asciify(data[i + 0])
-                 << Asciify(data[i + 1])
+                 << "      '" << Asciify(data[i + 0]) << Asciify(data[i + 1])
                  << "  '";
         break;
       case 1:
-        DVLOG(1) << pfx
-                 << AsciifyHigh(data[i + 0]) << AsciifyLow(data[i + 0])
-                 << "        '"
-                 << Asciify(data[i + 0])
-                 << "   '";
+        DVLOG(1) << pfx << AsciifyHigh(data[i + 0]) << AsciifyLow(data[i + 0])
+                 << "        '" << Asciify(data[i + 0]) << "   '";
         break;
     }
   }
 }
 
 template <MockReadWriteType type>
 void DumpMockReadWrite(const MockReadWrite<type>& r) {
   if (logging::LOG_INFO < logging::GetMinLogLevel())
     return;
-  DVLOG(1) << "Async:   " << (r.mode == ASYNC)
-           << "\nResult:  " << r.result;
+  DVLOG(1) << "Async:   " << (r.mode == ASYNC) << "\nResult:  " << r.result;
   DumpData(r.data, r.data_len);
   const char* stop = (r.sequence_number & MockRead::STOPLOOP) ? " (STOP)" : "";
   DVLOG(1) << "Stage:   " << (r.sequence_number & ~MockRead::STOPLOOP) << stop
            << "\nTime:    " << r.time_stamp.ToInternalValue();
 }
 
 }  // namespace
 
 MockConnect::MockConnect() : mode(ASYNC), result(OK) {
   IPAddressNumber ip;
   CHECK(ParseIPLiteralToNumber("192.0.2.33", &ip));
   peer_addr = IPEndPoint(ip, 0);
 }
 
 MockConnect::MockConnect(IoMode io_mode, int r) : mode(io_mode), result(r) {
   IPAddressNumber ip;
   CHECK(ParseIPLiteralToNumber("192.0.2.33", &ip));
   peer_addr = IPEndPoint(ip, 0);
 }
 
-MockConnect::MockConnect(IoMode io_mode, int r, IPEndPoint addr) :
-    mode(io_mode),
-    result(r),
-    peer_addr(addr) {
+MockConnect::MockConnect(IoMode io_mode, int r, IPEndPoint addr)
+    : mode(io_mode), result(r), peer_addr(addr) {
 }
 
-MockConnect::~MockConnect() {}
+MockConnect::~MockConnect() {
+}
 
 StaticSocketDataProvider::StaticSocketDataProvider()
     : reads_(NULL),
       read_index_(0),
       read_count_(0),
       writes_(NULL),
       write_index_(0),
       write_count_(0) {
 }
 
 StaticSocketDataProvider::StaticSocketDataProvider(MockRead* reads,
                                                    size_t reads_count,
                                                    MockWrite* writes,
                                                    size_t writes_count)
     : reads_(reads),
       read_index_(0),
       read_count_(reads_count),
       writes_(writes),
       write_index_(0),
       write_count_(writes_count) {
 }
 
-StaticSocketDataProvider::~StaticSocketDataProvider() {}
+StaticSocketDataProvider::~StaticSocketDataProvider() {
+}
 
 const MockRead& StaticSocketDataProvider::PeekRead() const {
   CHECK(!at_read_eof());
   return reads_[read_index_];
 }
 
 const MockWrite& StaticSocketDataProvider::PeekWrite() const {
   CHECK(!at_write_eof());
   return writes_[write_index_];
 }
@@ skipping 49 matching lines @@
   }
   return MockWriteResult(w->mode, result);
 }
 
 void StaticSocketDataProvider::Reset() {
   read_index_ = 0;
   write_index_ = 0;
 }
 
 DynamicSocketDataProvider::DynamicSocketDataProvider()
-    : short_read_limit_(0),
-      allow_unconsumed_reads_(false) {
+    : short_read_limit_(0), allow_unconsumed_reads_(false) {
 }
 
-DynamicSocketDataProvider::~DynamicSocketDataProvider() {}
+DynamicSocketDataProvider::~DynamicSocketDataProvider() {
+}
 
 MockRead DynamicSocketDataProvider::GetNextRead() {
   if (reads_.empty())
     return MockRead(SYNCHRONOUS, ERR_UNEXPECTED);
   MockRead result = reads_.front();
   if (short_read_limit_ == 0 || result.data_len <= short_read_limit_) {
     reads_.pop_front();
   } else {
     result.data_len = short_read_limit_;
     reads_.front().data += result.data_len;
@@ skipping 27 matching lines @@
 SSLSocketDataProvider::~SSLSocketDataProvider() {
 }
 
 void SSLSocketDataProvider::SetNextProto(NextProto proto) {
   was_npn_negotiated = true;
   next_proto_status = SSLClientSocket::kNextProtoNegotiated;
   protocol_negotiated = proto;
   next_proto = SSLClientSocket::NextProtoToString(proto);
 }
 
-DelayedSocketData::DelayedSocketData(
-    int write_delay, MockRead* reads, size_t reads_count,
-    MockWrite* writes, size_t writes_count)
+DelayedSocketData::DelayedSocketData(int write_delay,
+                                     MockRead* reads,
+                                     size_t reads_count,
+                                     MockWrite* writes,
+                                     size_t writes_count)
     : StaticSocketDataProvider(reads, reads_count, writes, writes_count),
       write_delay_(write_delay),
       read_in_progress_(false),
       weak_factory_(this) {
   DCHECK_GE(write_delay_, 0);
 }
 
-DelayedSocketData::DelayedSocketData(
-    const MockConnect& connect, int write_delay, MockRead* reads,
-    size_t reads_count, MockWrite* writes, size_t writes_count)
+DelayedSocketData::DelayedSocketData(const MockConnect& connect,
+                                     int write_delay,
+                                     MockRead* reads,
+                                     size_t reads_count,
+                                     MockWrite* writes,
+                                     size_t writes_count)
     : StaticSocketDataProvider(reads, reads_count, writes, writes_count),
       write_delay_(write_delay),
       read_in_progress_(false),
       weak_factory_(this) {
   DCHECK_GE(write_delay_, 0);
   set_connect_data(connect);
 }
 
 DelayedSocketData::~DelayedSocketData() {
 }
@@ skipping 29 matching lines @@
   read_in_progress_ = false;
   weak_factory_.InvalidateWeakPtrs();
   StaticSocketDataProvider::Reset();
 }
 
 void DelayedSocketData::CompleteRead() {
   if (socket() && read_in_progress_)
     socket()->OnReadComplete(GetNextRead());
 }
 
-OrderedSocketData::OrderedSocketData(
-    MockRead* reads, size_t reads_count, MockWrite* writes, size_t writes_count)
+OrderedSocketData::OrderedSocketData(MockRead* reads,
+                                     size_t reads_count,
+                                     MockWrite* writes,
+                                     size_t writes_count)
     : StaticSocketDataProvider(reads, reads_count, writes, writes_count),
-      sequence_number_(0), loop_stop_stage_(0),
-      blocked_(false), weak_factory_(this) {
+      sequence_number_(0),
+      loop_stop_stage_(0),
+      blocked_(false),
+      weak_factory_(this) {
 }
 
-OrderedSocketData::OrderedSocketData(
-    const MockConnect& connect,
-    MockRead* reads, size_t reads_count,
-    MockWrite* writes, size_t writes_count)
+OrderedSocketData::OrderedSocketData(const MockConnect& connect,
+                                     MockRead* reads,
+                                     size_t reads_count,
+                                     MockWrite* writes,
+                                     size_t writes_count)
     : StaticSocketDataProvider(reads, reads_count, writes, writes_count),
-      sequence_number_(0), loop_stop_stage_(0),
-      blocked_(false), weak_factory_(this) {
+      sequence_number_(0),
+      loop_stop_stage_(0),
+      blocked_(false),
+      weak_factory_(this) {
   set_connect_data(connect);
 }
 
 void OrderedSocketData::EndLoop() {
   // If we've already stopped the loop, don't do it again until we've advanced
   // to the next sequence_number.
   NET_TRACE(INFO, "  *** ") << "Stage " << sequence_number_ << ": EndLoop()";
   if (loop_stop_stage_ > 0) {
     const MockRead& next_read = StaticSocketDataProvider::PeekRead();
-    if ((next_read.sequence_number & ~MockRead::STOPLOOP) >
-        loop_stop_stage_) {
+    if ((next_read.sequence_number & ~MockRead::STOPLOOP) > loop_stop_stage_) {
       NET_TRACE(INFO, "  *** ") << "Stage " << sequence_number_
                                 << ": Clearing stop index";
       loop_stop_stage_ = 0;
     } else {
       return;
     }
   }
   // Record the sequence_number at which we stopped the loop.
   NET_TRACE(INFO, "  *** ") << "Stage " << sequence_number_
                             << ": Posting Quit at read " << read_index();
   loop_stop_stage_ = sequence_number_;
 }
 
 MockRead OrderedSocketData::GetNextRead() {
   weak_factory_.InvalidateWeakPtrs();
   blocked_ = false;
   const MockRead& next_read = StaticSocketDataProvider::PeekRead();
   if (next_read.sequence_number & MockRead::STOPLOOP)
     EndLoop();
-  if ((next_read.sequence_number & ~MockRead::STOPLOOP) <=
-      sequence_number_++) {
-    NET_TRACE(INFO, "  *** ") << "Stage " << sequence_number_ - 1
-                              << ": Read " << read_index();
+  if ((next_read.sequence_number & ~MockRead::STOPLOOP) <= sequence_number_++) {
+    NET_TRACE(INFO, "  *** ") << "Stage " << sequence_number_ - 1 << ": Read "
+                              << read_index();
     DumpMockReadWrite(next_read);
     blocked_ = (next_read.result == ERR_IO_PENDING);
     return StaticSocketDataProvider::GetNextRead();
   }
   NET_TRACE(INFO, "  *** ") << "Stage " << sequence_number_ - 1
                             << ": I/O Pending";
   MockRead result = MockRead(ASYNC, ERR_IO_PENDING);
   DumpMockReadWrite(result);
   blocked_ = true;
   return result;
 }
 
 MockWriteResult OrderedSocketData::OnWrite(const std::string& data) {
-  NET_TRACE(INFO, "  *** ") << "Stage " << sequence_number_
-                            << ": Write " << write_index();
+  NET_TRACE(INFO, "  *** ") << "Stage " << sequence_number_ << ": Write "
+                            << write_index();
   DumpMockReadWrite(PeekWrite());
   ++sequence_number_;
   if (blocked_) {
     // TODO(willchan): This 100ms delay seems to work around some weirdness.  We
     // should probably fix the weirdness.  One example is in SpdyStream,
     // DoSendRequest() will return ERR_IO_PENDING, and there's a race.  If the
     // SYN_REPLY causes OnResponseReceived() to get called before
     // SpdyStream::ReadResponseHeaders() is called, we hit a NOTREACHED().
     base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&OrderedSocketData::CompleteRead,
                    weak_factory_.GetWeakPtr()),
         base::TimeDelta::FromMilliseconds(100));
   }
   return StaticSocketDataProvider::OnWrite(data);
 }
 
 void OrderedSocketData::Reset() {
-  NET_TRACE(INFO, "  *** ") << "Stage "
-                            << sequence_number_ << ": Reset()";
+  NET_TRACE(INFO, "  *** ") << "Stage " << sequence_number_ << ": Reset()";
   sequence_number_ = 0;
   loop_stop_stage_ = 0;
   set_socket(NULL);
   weak_factory_.InvalidateWeakPtrs();
   StaticSocketDataProvider::Reset();
 }
 
 void OrderedSocketData::CompleteRead() {
   if (socket() && blocked_) {
     NET_TRACE(INFO, "  *** ") << "Stage " << sequence_number_;
     socket()->OnReadComplete(GetNextRead());
   }
 }
 
-OrderedSocketData::~OrderedSocketData() {}
+OrderedSocketData::~OrderedSocketData() {
+}
 
 DeterministicSocketData::DeterministicSocketData(MockRead* reads,
-    size_t reads_count, MockWrite* writes, size_t writes_count)
+                                                 size_t reads_count,
+                                                 MockWrite* writes,
+                                                 size_t writes_count)
     : StaticSocketDataProvider(reads, reads_count, writes, writes_count),
       sequence_number_(0),
       current_read_(),
       current_write_(),
       stopping_sequence_number_(0),
       stopped_(false),
       print_debug_(false),
       is_running_(false) {
   VerifyCorrectSequenceNumbers(reads, reads_count, writes, writes_count);
 }
 
-DeterministicSocketData::~DeterministicSocketData() {}
+DeterministicSocketData::~DeterministicSocketData() {
+}
 
 void DeterministicSocketData::Run() {
   DCHECK(!is_running_);
   is_running_ = true;
 
   SetStopped(false);
   int counter = 0;
   // Continue to consume data until all data has run out, or the stopped_ flag
   // has been set. Consuming data requires two separate operations -- running
   // the tasks in the message loop, and explicitly invoking the read/write
@@ skipping 43 matching lines @@
     return MockRead(SYNCHRONOUS, ERR_UNEXPECTED);
   }
 
   // Async read which will be called back in a future step.
   if (sequence_number_ < current_read_.sequence_number) {
     NET_TRACE(INFO, "  *** ") << "Stage " << sequence_number_
                               << ": I/O Pending";
     MockRead result = MockRead(SYNCHRONOUS, ERR_IO_PENDING);
     if (current_read_.mode == SYNCHRONOUS) {
       LOG(ERROR) << "Unable to perform synchronous read: "
-          << current_read_.sequence_number
-          << " at stage: " << sequence_number_;
+                 << current_read_.sequence_number
+                 << " at stage: " << sequence_number_;
       result = MockRead(SYNCHRONOUS, ERR_UNEXPECTED);
     }
     if (print_debug_)
       DumpMockReadWrite(result);
     return result;
   }
 
-  NET_TRACE(INFO, "  *** ") << "Stage " << sequence_number_
-                            << ": Read " << read_index();
+  NET_TRACE(INFO, "  *** ") << "Stage " << sequence_number_ << ": Read "
+                            << read_index();
   if (print_debug_)
     DumpMockReadWrite(current_read_);
 
   // Increment the sequence number if IO is complete
   if (current_read_.mode == SYNCHRONOUS)
     NextStep();
 
   DCHECK_NE(ERR_IO_PENDING, current_read_.result);
   StaticSocketDataProvider::GetNextRead();
 
   return current_read_;
 }
 
 MockWriteResult DeterministicSocketData::OnWrite(const std::string& data) {
   const MockWrite& next_write = StaticSocketDataProvider::PeekWrite();
   current_write_ = next_write;
 
   // Synchronous write while stopped is an error
   if (stopped() && next_write.mode == SYNCHRONOUS) {
     LOG(ERROR) << "Unable to perform synchronous IO while stopped";
     return MockWriteResult(SYNCHRONOUS, ERR_UNEXPECTED);
   }
 
   // Async write which will be called back in a future step.
   if (sequence_number_ < next_write.sequence_number) {
     NET_TRACE(INFO, "  *** ") << "Stage " << sequence_number_
                               << ": I/O Pending";
     if (next_write.mode == SYNCHRONOUS) {
       LOG(ERROR) << "Unable to perform synchronous write: "
-          << next_write.sequence_number << " at stage: " << sequence_number_;
+                 << next_write.sequence_number
+                 << " at stage: " << sequence_number_;
       return MockWriteResult(SYNCHRONOUS, ERR_UNEXPECTED);
     }
   } else {
-    NET_TRACE(INFO, "  *** ") << "Stage " << sequence_number_
-                              << ": Write " << write_index();
+    NET_TRACE(INFO, "  *** ") << "Stage " << sequence_number_ << ": Write "
+                              << write_index();
   }
 
   if (print_debug_)
     DumpMockReadWrite(next_write);
 
   // Move to the next step if I/O is synchronous, since the operation will
   // complete when this method returns.
   if (next_write.mode == SYNCHRONOUS)
     NextStep();
 
   // This is either a sync write for this step, or an async write.
   return StaticSocketDataProvider::OnWrite(data);
 }
 
 void DeterministicSocketData::Reset() {
-  NET_TRACE(INFO, "  *** ") << "Stage "
-                            << sequence_number_ << ": Reset()";
+  NET_TRACE(INFO, "  *** ") << "Stage " << sequence_number_ << ": Reset()";
   sequence_number_ = 0;
   StaticSocketDataProvider::Reset();
   NOTREACHED();
 }
 
 void DeterministicSocketData::InvokeCallbacks() {
   if (delegate_.get() && delegate_->WritePending() &&
       (current_write().sequence_number == sequence_number())) {
     NextStep();
     delegate_->CompleteWrite();
     return;
   }
   if (delegate_.get() && delegate_->ReadPending() &&
       (current_read().sequence_number == sequence_number())) {
     NextStep();
     delegate_->CompleteRead();
     return;
   }
 }
 
 void DeterministicSocketData::NextStep() {
   // Invariant: Can never move *past* the stopping step.
   DCHECK_LT(sequence_number_, stopping_sequence_number_);
   sequence_number_++;
   if (sequence_number_ == stopping_sequence_number_)
     SetStopped(true);
 }
 
 void DeterministicSocketData::VerifyCorrectSequenceNumbers(
-    MockRead* reads, size_t reads_count,
-    MockWrite* writes, size_t writes_count) {
+    MockRead* reads,
+    size_t reads_count,
+    MockWrite* writes,
+    size_t writes_count) {
   size_t read = 0;
   size_t write = 0;
   int expected = 0;
   while (read < reads_count || write < writes_count) {
     // Check to see that we have a read or write at the expected
     // state.
-    if (read < reads_count  && reads[read].sequence_number == expected) {
+    if (read < reads_count && reads[read].sequence_number == expected) {
       ++read;
       ++expected;
       continue;
     }
     if (write < writes_count && writes[write].sequence_number == expected) {
       ++write;
       ++expected;
       continue;
     }
     NOTREACHED() << "Missing sequence number: " << expected;
     return;
   }
   DCHECK_EQ(read, reads_count);
   DCHECK_EQ(write, writes_count);
 }
 
-MockClientSocketFactory::MockClientSocketFactory() {}
+MockClientSocketFactory::MockClientSocketFactory() {
+}
 
-MockClientSocketFactory::~MockClientSocketFactory() {}
+MockClientSocketFactory::~MockClientSocketFactory() {
+}
 
-void MockClientSocketFactory::AddSocketDataProvider(
-    SocketDataProvider* data) {
+void MockClientSocketFactory::AddSocketDataProvider(SocketDataProvider* data) {
   mock_data_.Add(data);
 }
 
 void MockClientSocketFactory::AddSSLSocketDataProvider(
     SSLSocketDataProvider* data) {
   mock_ssl_data_.Add(data);
 }
 
 void MockClientSocketFactory::ResetNextMockIndexes() {
   mock_data_.ResetNextIndex();
@@ skipping 26 matching lines @@
   return socket.PassAs<StreamSocket>();
 }
 
 scoped_ptr<SSLClientSocket> MockClientSocketFactory::CreateSSLClientSocket(
     scoped_ptr<ClientSocketHandle> transport_socket,
     const HostPortPair& host_and_port,
     const SSLConfig& ssl_config,
     const SSLClientSocketContext& context) {
   return scoped_ptr<SSLClientSocket>(
       new MockSSLClientSocket(transport_socket.Pass(),
-                              host_and_port, ssl_config,
+                              host_and_port,
+                              ssl_config,
                               mock_ssl_data_.GetNext()));
 }
 
 void MockClientSocketFactory::ClearSSLSessionCache() {
 }
 
 const char MockClientSocket::kTlsUnique[] = "MOCK_TLSUNIQ";
 
 MockClientSocket::MockClientSocket(const BoundNetLog& net_log)
-    : connected_(false),
-      net_log_(net_log),
-      weak_factory_(this) {
+    : connected_(false), net_log_(net_log), weak_factory_(this) {
   IPAddressNumber ip;
   CHECK(ParseIPLiteralToNumber("192.0.2.33", &ip));
   peer_addr_ = IPEndPoint(ip, 0);
 }
 
 int MockClientSocket::SetReceiveBufferSize(int32 size) {
   return OK;
 }
 
 int MockClientSocket::SetSendBufferSize(int32 size) {
@@ skipping 25 matching lines @@
   CHECK(rv);
   *address = IPEndPoint(ip, 123);
   return OK;
 }
 
 const BoundNetLog& MockClientSocket::NetLog() const {
   return net_log_;
 }
 
 void MockClientSocket::GetSSLCertRequestInfo(
-  SSLCertRequestInfo* cert_request_info) {
+    SSLCertRequestInfo* cert_request_info) {
 }
 
 int MockClientSocket::ExportKeyingMaterial(const base::StringPiece& label,
                                            bool has_context,
                                            const base::StringPiece& context,
                                            unsigned char* out,
                                            unsigned int outlen) {
   memset(out, 'A', outlen);
   return OK;
 }
 
 int MockClientSocket::GetTLSUniqueChannelBinding(std::string* out) {
   out->assign(MockClientSocket::kTlsUnique);
   return OK;
 }
 
 ServerBoundCertService* MockClientSocket::GetServerBoundCertService() const {
   NOTREACHED();
   return NULL;
 }
 
-SSLClientSocket::NextProtoStatus
-MockClientSocket::GetNextProto(std::string* proto, std::string* server_protos) {
+SSLClientSocket::NextProtoStatus MockClientSocket::GetNextProto(
+    std::string* proto,
+    std::string* server_protos) {
   proto->clear();
   server_protos->clear();
   return SSLClientSocket::kNextProtoUnsupported;
 }
 
 scoped_refptr<X509Certificate>
 MockClientSocket::GetUnverifiedServerCertificateChain() const {
   NOTREACHED();
   return NULL;
 }
 
-MockClientSocket::~MockClientSocket() {}
+MockClientSocket::~MockClientSocket() {
+}
 
 void MockClientSocket::RunCallbackAsync(const CompletionCallback& callback,
                                         int result) {
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&MockClientSocket::RunCallback,
                  weak_factory_.GetWeakPtr(),
                  callback,
                  result));
 }
@@ skipping 15 matching lines @@
       need_read_data_(true),
       peer_closed_connection_(false),
       pending_buf_(NULL),
       pending_buf_len_(0),
       was_used_to_convey_data_(false) {
   DCHECK(data_);
   peer_addr_ = data->connect_data().peer_addr;
   data_->Reset();
 }
 
-MockTCPClientSocket::~MockTCPClientSocket() {}
+MockTCPClientSocket::~MockTCPClientSocket() {
+}
 
-int MockTCPClientSocket::Read(IOBuffer* buf, int buf_len,
+int MockTCPClientSocket::Read(IOBuffer* buf,
+                              int buf_len,
                               const CompletionCallback& callback) {
   if (!connected_)
     return ERR_UNEXPECTED;
 
   // If the buffer is already in use, a read is already in progress!
   DCHECK(pending_buf_ == NULL);
 
   // Store our async IO data.
   pending_buf_ = buf;
   pending_buf_len_ = buf_len;
@@ skipping 18 matching lines @@
       // We need to be using async IO in this case.
       DCHECK(!callback.is_null());
       return ERR_IO_PENDING;
     }
     need_read_data_ = false;
   }
 
   return CompleteRead();
 }
 
-int MockTCPClientSocket::Write(IOBuffer* buf, int buf_len,
+int MockTCPClientSocket::Write(IOBuffer* buf,
+                               int buf_len,
                                const CompletionCallback& callback) {
   DCHECK(buf);
   DCHECK_GT(buf_len, 0);
 
   if (!connected_)
     return ERR_UNEXPECTED;
 
   std::string data(buf->data(), buf_len);
   MockWriteResult write_result = data_->OnWrite(data);
 
@@ skipping 131 matching lines @@
       read_data_(),
       read_buf_(NULL),
       read_buf_len_(0),
       read_pending_(false),
       data_(data),
       was_used_to_convey_data_(false),
       peer_closed_connection_(false),
       net_log_(BoundNetLog::Make(net_log, net::NetLog::SOURCE_NONE)) {
 }
 
-DeterministicSocketHelper::~DeterministicSocketHelper() {}
+DeterministicSocketHelper::~DeterministicSocketHelper() {
+}
 
 void DeterministicSocketHelper::CompleteWrite() {
   was_used_to_convey_data_ = true;
   write_pending_ = false;
   write_callback_.Run(write_result_);
 }
 
 int DeterministicSocketHelper::CompleteRead() {
   DCHECK_GT(read_buf_len_, 0);
   DCHECK_LE(read_data_.data_len, read_buf_len_);
@@ skipping 15 matching lines @@
   }
 
   if (read_pending_) {
     read_pending_ = false;
     read_callback_.Run(result);
   }
 
   return result;
 }
 
-int DeterministicSocketHelper::Write(
-    IOBuffer* buf, int buf_len, const CompletionCallback& callback) {
+int DeterministicSocketHelper::Write(IOBuffer* buf,
+                                     int buf_len,
+                                     const CompletionCallback& callback) {
   DCHECK(buf);
   DCHECK_GT(buf_len, 0);
 
   std::string data(buf->data(), buf_len);
   MockWriteResult write_result = data_->OnWrite(data);
 
   if (write_result.mode == ASYNC) {
     write_callback_ = callback;
     write_result_ = write_result.result;
     DCHECK(!write_callback_.is_null());
     write_pending_ = true;
     return ERR_IO_PENDING;
   }
 
   was_used_to_convey_data_ = true;
   write_pending_ = false;
   return write_result.result;
 }
 
-int DeterministicSocketHelper::Read(
-    IOBuffer* buf, int buf_len, const CompletionCallback& callback) {
-
+int DeterministicSocketHelper::Read(IOBuffer* buf,
+                                    int buf_len,
+                                    const CompletionCallback& callback) {
   read_data_ = data_->GetNextRead();
   // The buffer should always be big enough to contain all the MockRead data. To
   // use small buffers, split the data into multiple MockReads.
   DCHECK_LE(read_data_.data_len, buf_len);
 
   if (read_data_.result == ERR_CONNECTION_CLOSED) {
     // This MockRead is just a marker to instruct us to set
     // peer_closed_connection_.
     peer_closed_connection_ = true;
   }
@@ skipping 14 matching lines @@
     return ERR_IO_PENDING;
   }
 
   was_used_to_convey_data_ = true;
   return CompleteRead();
 }
 
 DeterministicMockUDPClientSocket::DeterministicMockUDPClientSocket(
     net::NetLog* net_log,
     DeterministicSocketData* data)
-    : connected_(false),
-      helper_(net_log, data),
-      source_port_(123) {
+    : connected_(false), helper_(net_log, data), source_port_(123) {
 }
 
-DeterministicMockUDPClientSocket::~DeterministicMockUDPClientSocket() {}
+DeterministicMockUDPClientSocket::~DeterministicMockUDPClientSocket() {
+}
 
 bool DeterministicMockUDPClientSocket::WritePending() const {
   return helper_.write_pending();
 }
 
 bool DeterministicMockUDPClientSocket::ReadPending() const {
   return helper_.read_pending();
 }
 
 void DeterministicMockUDPClientSocket::CompleteWrite() {
@@ skipping 15 matching lines @@
 int DeterministicMockUDPClientSocket::Write(
     IOBuffer* buf,
     int buf_len,
     const CompletionCallback& callback) {
   if (!connected_)
     return ERR_UNEXPECTED;
 
   return helper_.Write(buf, buf_len, callback);
 }
 
-int DeterministicMockUDPClientSocket::Read(
-    IOBuffer* buf,
-    int buf_len,
-    const CompletionCallback& callback) {
+int DeterministicMockUDPClientSocket::Read(IOBuffer* buf,
+                                           int buf_len,
+                                           const CompletionCallback& callback) {
   if (!connected_)
     return ERR_UNEXPECTED;
 
   return helper_.Read(buf, buf_len, callback);
 }
 
 int DeterministicMockUDPClientSocket::SetReceiveBufferSize(int32 size) {
   return OK;
 }
 
@@ skipping 17 matching lines @@
   bool rv = ParseIPLiteralToNumber("192.0.2.33", &ip);
   CHECK(rv);
   *address = IPEndPoint(ip, source_port_);
   return OK;
 }
 
 const BoundNetLog& DeterministicMockUDPClientSocket::NetLog() const {
   return helper_.net_log();
 }
 
-void DeterministicMockUDPClientSocket::OnReadComplete(const MockRead& data) {}
+void DeterministicMockUDPClientSocket::OnReadComplete(const MockRead& data) {
+}
 
 void DeterministicMockUDPClientSocket::OnConnectComplete(
     const MockConnect& data) {
   NOTIMPLEMENTED();
 }
 
 DeterministicMockTCPClientSocket::DeterministicMockTCPClientSocket(
     net::NetLog* net_log,
     DeterministicSocketData* data)
     : MockClientSocket(BoundNetLog::Make(net_log, net::NetLog::SOURCE_NONE)),
       helper_(net_log, data) {
   peer_addr_ = data->connect_data().peer_addr;
 }
 
-DeterministicMockTCPClientSocket::~DeterministicMockTCPClientSocket() {}
+DeterministicMockTCPClientSocket::~DeterministicMockTCPClientSocket() {
+}
 
 bool DeterministicMockTCPClientSocket::WritePending() const {
   return helper_.write_pending();
 }
 
 bool DeterministicMockTCPClientSocket::ReadPending() const {
   return helper_.read_pending();
 }
 
 void DeterministicMockTCPClientSocket::CompleteWrite() {
   helper_.CompleteWrite();
 }
 
 int DeterministicMockTCPClientSocket::CompleteRead() {
   return helper_.CompleteRead();
 }
 
 int DeterministicMockTCPClientSocket::Write(
     IOBuffer* buf,
     int buf_len,
     const CompletionCallback& callback) {
   if (!connected_)
     return ERR_UNEXPECTED;
 
   return helper_.Write(buf, buf_len, callback);
 }
 
-int DeterministicMockTCPClientSocket::Read(
-    IOBuffer* buf,
-    int buf_len,
-    const CompletionCallback& callback) {
+int DeterministicMockTCPClientSocket::Read(IOBuffer* buf,
+                                           int buf_len,
+                                           const CompletionCallback& callback) {
   if (!connected_)
     return ERR_UNEXPECTED;
 
   return helper_.Read(buf, buf_len, callback);
 }
 
 // TODO(erikchen): Support connect sequencing.
 int DeterministicMockTCPClientSocket::Connect(
     const CompletionCallback& callback) {
   if (connected_)
@@ skipping 27 matching lines @@
 }
 
 bool DeterministicMockTCPClientSocket::WasNpnNegotiated() const {
   return false;
 }
 
 bool DeterministicMockTCPClientSocket::GetSSLInfo(SSLInfo* ssl_info) {
   return false;
 }
 
-void DeterministicMockTCPClientSocket::OnReadComplete(const MockRead& data) {}
+void DeterministicMockTCPClientSocket::OnReadComplete(const MockRead& data) {
+}
 
 void DeterministicMockTCPClientSocket::OnConnectComplete(
-    const MockConnect& data) {}
+    const MockConnect& data) {
+}
 
 // static
 void MockSSLClientSocket::ConnectCallback(
     MockSSLClientSocket* ssl_client_socket,
     const CompletionCallback& callback,
     int rv) {
   if (rv == OK)
     ssl_client_socket->connected_ = true;
   callback.Run(rv);
 }
 
 MockSSLClientSocket::MockSSLClientSocket(
     scoped_ptr<ClientSocketHandle> transport_socket,
     const HostPortPair& host_port_pair,
     const SSLConfig& ssl_config,
     SSLSocketDataProvider* data)
     : MockClientSocket(
-         // Have to use the right BoundNetLog for LoadTimingInfo regression
-         // tests.
-         transport_socket->socket()->NetLog()),
+          // Have to use the right BoundNetLog for LoadTimingInfo regression
+          // tests.
+          transport_socket->socket()->NetLog()),
       transport_(transport_socket.Pass()),
       data_(data),
       is_npn_state_set_(false),
       new_npn_value_(false),
       is_protocol_negotiated_set_(false),
       protocol_negotiated_(kProtoUnknown) {
   DCHECK(data_);
   peer_addr_ = data->connect.peer_addr;
 }
 
 MockSSLClientSocket::~MockSSLClientSocket() {
   Disconnect();
 }
 
-int MockSSLClientSocket::Read(IOBuffer* buf, int buf_len,
+int MockSSLClientSocket::Read(IOBuffer* buf,
+                              int buf_len,
                               const CompletionCallback& callback) {
   return transport_->socket()->Read(buf, buf_len, callback);
 }
 
-int MockSSLClientSocket::Write(IOBuffer* buf, int buf_len,
+int MockSSLClientSocket::Write(IOBuffer* buf,
+                               int buf_len,
                                const CompletionCallback& callback) {
   return transport_->socket()->Write(buf, buf_len, callback);
 }
 
 int MockSSLClientSocket::Connect(const CompletionCallback& callback) {
   int rv = transport_->socket()->Connect(
       base::Bind(&ConnectCallback, base::Unretained(this), callback));
   if (rv == OK) {
     if (data_->connect.result == OK)
       connected_ = true;
@@ skipping 33 matching lines @@
   ssl_info->cert = data_->cert;
   ssl_info->client_cert_sent = data_->client_cert_sent;
   ssl_info->channel_id_sent = data_->channel_id_sent;
   return true;
 }
 
 void MockSSLClientSocket::GetSSLCertRequestInfo(
     SSLCertRequestInfo* cert_request_info) {
   DCHECK(cert_request_info);
   if (data_->cert_request_info) {
-    cert_request_info->host_and_port =
-        data_->cert_request_info->host_and_port;
+    cert_request_info->host_and_port = data_->cert_request_info->host_and_port;
     cert_request_info->client_certs = data_->cert_request_info->client_certs;
   } else {
     cert_request_info->Reset();
   }
 }
 
 SSLClientSocket::NextProtoStatus MockSSLClientSocket::GetNextProto(
-    std::string* proto, std::string* server_protos) {
+    std::string* proto,
+    std::string* server_protos) {
   *proto = data_->next_proto;
   *server_protos = data_->server_protos;
   return data_->next_proto_status;
 }
 
 bool MockSSLClientSocket::set_was_npn_negotiated(bool negotiated) {
   is_npn_state_set_ = true;
   return new_npn_value_ = negotiated;
 }
 
@@ skipping 45 matching lines @@
       source_port_(123),
       pending_buf_(NULL),
       pending_buf_len_(0),
       net_log_(BoundNetLog::Make(net_log, net::NetLog::SOURCE_NONE)),
       weak_factory_(this) {
   DCHECK(data_);
   data_->Reset();
   peer_addr_ = data->connect_data().peer_addr;
 }
 
-MockUDPClientSocket::~MockUDPClientSocket() {}
+MockUDPClientSocket::~MockUDPClientSocket() {
+}
 
 int MockUDPClientSocket::Read(IOBuffer* buf,
                               int buf_len,
                               const CompletionCallback& callback) {
   if (!connected_)
     return ERR_UNEXPECTED;
 
   // If the buffer is already in use, a read is already in progress!
   DCHECK(pending_buf_ == NULL);
 
@@ skipping 10 matching lines @@
       // We need to be using async IO in this case.
       DCHECK(!callback.is_null());
       return ERR_IO_PENDING;
     }
     need_read_data_ = false;
   }
 
   return CompleteRead();
 }
 
-int MockUDPClientSocket::Write(IOBuffer* buf, int buf_len,
+int MockUDPClientSocket::Write(IOBuffer* buf,
+                               int buf_len,
                                const CompletionCallback& callback) {
   DCHECK(buf);
   DCHECK_GT(buf_len, 0);
 
   if (!connected_)
     return ERR_UNEXPECTED;
 
   std::string data(buf->data(), buf_len);
   MockWriteResult write_result = data_->OnWrite(data);
 
@@ skipping 110 matching lines @@
                  result));
 }
 
 void MockUDPClientSocket::RunCallback(const CompletionCallback& callback,
                                       int result) {
   if (!callback.is_null())
     callback.Run(result);
 }
 
 TestSocketRequest::TestSocketRequest(
-    std::vector<TestSocketRequest*>* request_order, size_t* completion_count)
+    std::vector<TestSocketRequest*>* request_order,
+    size_t* completion_count)
     : request_order_(request_order),
       completion_count_(completion_count),
-      callback_(base::Bind(&TestSocketRequest::OnComplete,
-                           base::Unretained(this))) {
+      callback_(
+          base::Bind(&TestSocketRequest::OnComplete, base::Unretained(this))) {
   DCHECK(request_order);
   DCHECK(completion_count);
 }
 
 TestSocketRequest::~TestSocketRequest() {
 }
 
 void TestSocketRequest::OnComplete(int result) {
   SetResult(result);
   (*completion_count_)++;
   request_order_->push_back(this);
 }
 
 // static
 const int ClientSocketPoolTest::kIndexOutOfBounds = -1;
 
 // static
 const int ClientSocketPoolTest::kRequestNotFound = -2;
 
-ClientSocketPoolTest::ClientSocketPoolTest() : completion_count_(0) {}
-ClientSocketPoolTest::~ClientSocketPoolTest() {}
+ClientSocketPoolTest::ClientSocketPoolTest() : completion_count_(0) {
+}
+ClientSocketPoolTest::~ClientSocketPoolTest() {
+}
 
 int ClientSocketPoolTest::GetOrderOfRequest(size_t index) const {
   index--;
   if (index >= requests_.size())
     return kIndexOutOfBounds;
 
   for (size_t i = 0; i < request_order_.size(); i++)
     if (requests_[index] == request_order_[i])
       return i + 1;
 
@@ skipping 18 matching lines @@
   bool released_one;
   do {
     released_one = ReleaseOneConnection(keep_alive);
   } while (released_one);
 }
 
 MockTransportClientSocketPool::MockConnectJob::MockConnectJob(
     scoped_ptr<StreamSocket> socket,
     ClientSocketHandle* handle,
     const CompletionCallback& callback)
-    : socket_(socket.Pass()),
-      handle_(handle),
-      user_callback_(callback) {
+    : socket_(socket.Pass()), handle_(handle), user_callback_(callback) {
 }
 
-MockTransportClientSocketPool::MockConnectJob::~MockConnectJob() {}
+MockTransportClientSocketPool::MockConnectJob::~MockConnectJob() {
+}
 
 int MockTransportClientSocketPool::MockConnectJob::Connect() {
-  int rv = socket_->Connect(base::Bind(&MockConnectJob::OnConnect,
-                                       base::Unretained(this)));
+  int rv = socket_->Connect(
+      base::Bind(&MockConnectJob::OnConnect, base::Unretained(this)));
   if (rv == OK) {
     user_callback_.Reset();
     OnConnect(OK);
   }
   return rv;
 }
 
 bool MockTransportClientSocketPool::MockConnectJob::CancelHandle(
     const ClientSocketHandle* handle) {
   if (handle != handle_)
@@ skipping 30 matching lines @@
     user_callback_.Reset();
     callback.Run(rv);
   }
 }
 
 MockTransportClientSocketPool::MockTransportClientSocketPool(
     int max_sockets,
     int max_sockets_per_group,
     ClientSocketPoolHistograms* histograms,
     ClientSocketFactory* socket_factory)
-    : TransportClientSocketPool(max_sockets, max_sockets_per_group, histograms,
-                                NULL, NULL, NULL),
+    : TransportClientSocketPool(max_sockets,
+                                max_sockets_per_group,
+                                histograms,
+                                NULL,
+                                NULL,
+                                NULL),
       client_socket_factory_(socket_factory),
       last_request_priority_(DEFAULT_PRIORITY),
       release_count_(0),
       cancel_count_(0) {
 }
 
-MockTransportClientSocketPool::~MockTransportClientSocketPool() {}
+MockTransportClientSocketPool::~MockTransportClientSocketPool() {
+}
 
 int MockTransportClientSocketPool::RequestSocket(
-    const std::string& group_name, const void* socket_params,
-    RequestPriority priority, ClientSocketHandle* handle,
-    const CompletionCallback& callback, const BoundNetLog& net_log) {
+    const std::string& group_name,
+    const void* socket_params,
+    RequestPriority priority,
+    ClientSocketHandle* handle,
+    const CompletionCallback& callback,
+    const BoundNetLog& net_log) {
   last_request_priority_ = priority;
   scoped_ptr<StreamSocket> socket =
       client_socket_factory_->CreateTransportClientSocket(
           AddressList(), net_log.net_log(), net::NetLog::Source());
   MockConnectJob* job = new MockConnectJob(socket.Pass(), handle, callback);
   job_list_.push_back(job);
   handle->set_pool_id(1);
   return job->Connect();
 }
 
 void MockTransportClientSocketPool::CancelRequest(const std::string& group_name,
                                                   ClientSocketHandle* handle) {
   std::vector<MockConnectJob*>::iterator i;
   for (i = job_list_.begin(); i != job_list_.end(); ++i) {
     if ((*i)->CancelHandle(handle)) {
       cancel_count_++;
       break;
     }
   }
 }
 
 void MockTransportClientSocketPool::ReleaseSocket(
     const std::string& group_name,
     scoped_ptr<StreamSocket> socket,
     int id) {
   EXPECT_EQ(1, id);
   release_count_++;
 }
 
-DeterministicMockClientSocketFactory::DeterministicMockClientSocketFactory() {}
+DeterministicMockClientSocketFactory::DeterministicMockClientSocketFactory() {
+}
 
-DeterministicMockClientSocketFactory::~DeterministicMockClientSocketFactory() {}
+DeterministicMockClientSocketFactory::~DeterministicMockClientSocketFactory() {
+}
 
 void DeterministicMockClientSocketFactory::AddSocketDataProvider(
     DeterministicSocketData* data) {
   mock_data_.Add(data);
 }
 
 void DeterministicMockClientSocketFactory::AddSSLSocketDataProvider(
     SSLSocketDataProvider* data) {
   mock_ssl_data_.Add(data);
 }
 
 void DeterministicMockClientSocketFactory::ResetNextMockIndexes() {
   mock_data_.ResetNextIndex();
   mock_ssl_data_.ResetNextIndex();
 }
 
-MockSSLClientSocket* DeterministicMockClientSocketFactory::
-    GetMockSSLClientSocket(size_t index) const {
+MockSSLClientSocket*
+DeterministicMockClientSocketFactory::GetMockSSLClientSocket(
+    size_t index) const {
   DCHECK_LT(index, ssl_client_sockets_.size());
   return ssl_client_sockets_[index];
 }
 
 scoped_ptr<DatagramClientSocket>
 DeterministicMockClientSocketFactory::CreateDatagramClientSocket(
     DatagramSocket::BindType bind_type,
     const RandIntCallback& rand_int_cb,
     net::NetLog* net_log,
     const NetLog::Source& source) {
@@ skipping 21 matching lines @@
 }
 
 scoped_ptr<SSLClientSocket>
 DeterministicMockClientSocketFactory::CreateSSLClientSocket(
     scoped_ptr<ClientSocketHandle> transport_socket,
     const HostPortPair& host_and_port,
     const SSLConfig& ssl_config,
     const SSLClientSocketContext& context) {
   scoped_ptr<MockSSLClientSocket> socket(
       new MockSSLClientSocket(transport_socket.Pass(),
-                              host_and_port, ssl_config,
+                              host_and_port,
+                              ssl_config,
                               mock_ssl_data_.GetNext()));
   ssl_client_sockets_.push_back(socket.get());
   return socket.PassAs<SSLClientSocket>();
 }
 
 void DeterministicMockClientSocketFactory::ClearSSLSessionCache() {
 }
 
 MockSOCKSClientSocketPool::MockSOCKSClientSocketPool(
     int max_sockets,
     int max_sockets_per_group,
     ClientSocketPoolHistograms* histograms,
     TransportClientSocketPool* transport_pool)
-    : SOCKSClientSocketPool(max_sockets, max_sockets_per_group, histograms,
-                            NULL, transport_pool, NULL),
+    : SOCKSClientSocketPool(max_sockets,
+                            max_sockets_per_group,
+                            histograms,
+                            NULL,
+                            transport_pool,
+                            NULL),
       transport_pool_(transport_pool) {
 }
 
-MockSOCKSClientSocketPool::~MockSOCKSClientSocketPool() {}
+MockSOCKSClientSocketPool::~MockSOCKSClientSocketPool() {
+}
 
-int MockSOCKSClientSocketPool::RequestSocket(
-    const std::string& group_name, const void* socket_params,
-    RequestPriority priority, ClientSocketHandle* handle,
-    const CompletionCallback& callback, const BoundNetLog& net_log) {
+int MockSOCKSClientSocketPool::RequestSocket(const std::string& group_name,
+                                             const void* socket_params,
+                                             RequestPriority priority,
+                                             ClientSocketHandle* handle,
+                                             const CompletionCallback& callback,
+                                             const BoundNetLog& net_log) {
   return transport_pool_->RequestSocket(
       group_name, socket_params, priority, handle, callback, net_log);
 }
 
-void MockSOCKSClientSocketPool::CancelRequest(
-    const std::string& group_name,
-    ClientSocketHandle* handle) {
+void MockSOCKSClientSocketPool::CancelRequest(const std::string& group_name,
+                                              ClientSocketHandle* handle) {
   return transport_pool_->CancelRequest(group_name, handle);
 }
 
 void MockSOCKSClientSocketPool::ReleaseSocket(const std::string& group_name,
                                               scoped_ptr<StreamSocket> socket,
                                               int id) {
   return transport_pool_->ReleaseSocket(group_name, socket.Pass(), id);
 }
 
-const char kSOCKS5GreetRequest[] = { 0x05, 0x01, 0x00 };
+const char kSOCKS5GreetRequest[] = {0x05, 0x01, 0x00};
 const int kSOCKS5GreetRequestLength = arraysize(kSOCKS5GreetRequest);
 
-const char kSOCKS5GreetResponse[] = { 0x05, 0x00 };
+const char kSOCKS5GreetResponse[] = {0x05, 0x00};
 const int kSOCKS5GreetResponseLength = arraysize(kSOCKS5GreetResponse);
 
-const char kSOCKS5OkRequest[] =
-    { 0x05, 0x01, 0x00, 0x03, 0x04, 'h', 'o', 's', 't', 0x00, 0x50 };
+const char kSOCKS5OkRequest[] = {0x05, 0x01, 0x00, 0x03, 0x04, 'h',
+                                 'o',  's',  't',  0x00, 0x50};
 const int kSOCKS5OkRequestLength = arraysize(kSOCKS5OkRequest);
 
-const char kSOCKS5OkResponse[] =
-    { 0x05, 0x00, 0x00, 0x01, 127, 0, 0, 1, 0x00, 0x50 };
+const char kSOCKS5OkResponse[] = {0x05, 0x00, 0x00, 0x01, 127,
+                                  0,    0,    1,    0x00, 0x50};
 const int kSOCKS5OkResponseLength = arraysize(kSOCKS5OkResponse);
 
 }  // namespace net