Clang format slam.

net/socket/transport_client_socket_unittest.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/tcp_client_socket.h"
 
 #include "base/basictypes.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "net/base/address_list.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_log.h"
 #include "net/base/net_log_unittest.h"
 #include "net/base/test_completion_callback.h"
 #include "net/base/winsock_init.h"
 #include "net/dns/mock_host_resolver.h"
 #include "net/socket/client_socket_factory.h"
 #include "net/socket/tcp_listen_socket.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 
 namespace net {
 
 namespace {
 
 const char kServerReply[] = "HTTP/1.1 404 Not Found";
 
-enum ClientSocketTestTypes {
-  TCP,
-  SCTP
-};
+enum ClientSocketTestTypes { TCP, SCTP };
 
 }  // namespace
 
 class TransportClientSocketTest
     : public StreamListenSocket::Delegate,
       public ::testing::TestWithParam<ClientSocketTestTypes> {
  public:
   TransportClientSocketTest()
       : listen_port_(0),
         socket_factory_(ClientSocketFactory::GetDefaultFactory()),
-        close_server_socket_on_next_send_(false) {
-  }
+        close_server_socket_on_next_send_(false) {}
 
-  virtual ~TransportClientSocketTest() {
-  }
+  virtual ~TransportClientSocketTest() {}
 
   // Implement StreamListenSocket::Delegate methods
   virtual void DidAccept(StreamListenSocket* server,
                          scoped_ptr<StreamListenSocket> connection) OVERRIDE {
-    connected_sock_.reset(
-        static_cast<TCPListenSocket*>(connection.release()));
+    connected_sock_.reset(static_cast<TCPListenSocket*>(connection.release()));
   }
   virtual void DidRead(StreamListenSocket*, const char* str, int len) OVERRIDE {
     // TODO(dkegel): this might not be long enough to tickle some bugs.
-    connected_sock_->Send(kServerReply, arraysize(kServerReply) - 1,
+    connected_sock_->Send(kServerReply,
+                          arraysize(kServerReply) - 1,
                           false /* Don't append line feed */);
     if (close_server_socket_on_next_send_)
       CloseServerSocket();
   }
   virtual void DidClose(StreamListenSocket* sock) OVERRIDE {}
 
   // Testcase hooks
   virtual void SetUp();
 
   void CloseServerSocket() {
     // delete the connected_sock_, which will close it.
     connected_sock_.reset();
   }
 
-  void PauseServerReads() {
-    connected_sock_->PauseReads();
-  }
+  void PauseServerReads() { connected_sock_->PauseReads(); }
 
-  void ResumeServerReads() {
-    connected_sock_->ResumeReads();
-  }
+  void ResumeServerReads() { connected_sock_->ResumeReads(); }
 
   int DrainClientSocket(IOBuffer* buf,
                         uint32 buf_len,
                         uint32 bytes_to_read,
                         TestCompletionCallback* callback);
 
   void SendClientRequest();
 
   void set_close_server_socket_on_next_send(bool close) {
     close_server_socket_on_next_send_ = close;
@@ skipping 35 matching lines @@
   AddressList addr;
   // MockHostResolver resolves everything to 127.0.0.1.
   scoped_ptr<HostResolver> resolver(new MockHostResolver());
   HostResolver::RequestInfo info(HostPortPair("localhost", listen_port_));
   TestCompletionCallback callback;
   int rv = resolver->Resolve(
       info, DEFAULT_PRIORITY, &addr, callback.callback(), NULL, BoundNetLog());
   CHECK_EQ(ERR_IO_PENDING, rv);
   rv = callback.WaitForResult();
   CHECK_EQ(rv, OK);
-  sock_ =
-      socket_factory_->CreateTransportClientSocket(addr,
-                                                   &net_log_,
-                                                   NetLog::Source());
+  sock_ = socket_factory_->CreateTransportClientSocket(
+      addr, &net_log_, NetLog::Source());
 }
 
 int TransportClientSocketTest::DrainClientSocket(
-    IOBuffer* buf, uint32 buf_len,
-    uint32 bytes_to_read, TestCompletionCallback* callback) {
+    IOBuffer* buf,
+    uint32 buf_len,
+    uint32 bytes_to_read,
+    TestCompletionCallback* callback) {
   int rv = OK;
   uint32 bytes_read = 0;
 
   while (bytes_read < bytes_to_read) {
     rv = sock_->Read(buf, buf_len, callback->callback());
     EXPECT_TRUE(rv >= 0 || rv == ERR_IO_PENDING);
 
     if (rv == ERR_IO_PENDING)
       rv = callback->WaitForResult();
 
@@ skipping 288 matching lines @@
 
   // It's possible the read is blocked because it's already read all the data.
   // Close the server socket, so there will at least be a 0-byte read.
   CloseServerSocket();
 
   rv = callback.WaitForResult();
   EXPECT_GE(rv, 0);
 }
 
 }  // namespace net