Clang format slam.

net/udp/udp_socket_unittest.cc

Index: net/udp/udp_socket_unittest.cc
diff --git a/net/udp/udp_socket_unittest.cc b/net/udp/udp_socket_unittest.cc
index 20e38ee4c118f4e1c986789871e3ad4a7d682c42..8e0907d4c04d45c18e47e37e328e93fd1ab9a90a 100644
--- a/net/udp/udp_socket_unittest.cc
+++ b/net/udp/udp_socket_unittest.cc
@@ -25,9 +25,7 @@ namespace {
 
 class UDPSocketTest : public PlatformTest {
  public:
-  UDPSocketTest()
-      : buffer_(new IOBufferWithSize(kMaxRead)) {
-  }
+  UDPSocketTest() : buffer_(new IOBufferWithSize(kMaxRead)) {}
 
   // Blocks until data is read from the socket.
   std::string RecvFromSocket(UDPServerSocket* socket) {
@@ -175,31 +173,30 @@ TEST_F(UDPSocketTest, Connect) {
   CapturingNetLog::CapturedEntryList server_entries;
   server_log.GetEntries(&server_entries);
   EXPECT_EQ(4u, server_entries.size());
-  EXPECT_TRUE(LogContainsBeginEvent(
-      server_entries, 0, NetLog::TYPE_SOCKET_ALIVE));
+  EXPECT_TRUE(
+      LogContainsBeginEvent(server_entries, 0, NetLog::TYPE_SOCKET_ALIVE));
   EXPECT_TRUE(LogContainsEvent(
       server_entries, 1, NetLog::TYPE_UDP_BYTES_RECEIVED, NetLog::PHASE_NONE));
   EXPECT_TRUE(LogContainsEvent(
       server_entries, 2, NetLog::TYPE_UDP_BYTES_SENT, NetLog::PHASE_NONE));
-  EXPECT_TRUE(LogContainsEndEvent(
-      server_entries, 3, NetLog::TYPE_SOCKET_ALIVE));
+  EXPECT_TRUE(
+      LogContainsEndEvent(server_entries, 3, NetLog::TYPE_SOCKET_ALIVE));
 
   // Check the client's log.
   CapturingNetLog::CapturedEntryList client_entries;
   client_log.GetEntries(&client_entries);
   EXPECT_EQ(6u, client_entries.size());
-  EXPECT_TRUE(LogContainsBeginEvent(
-      client_entries, 0, NetLog::TYPE_SOCKET_ALIVE));
-  EXPECT_TRUE(LogContainsBeginEvent(
-      client_entries, 1, NetLog::TYPE_UDP_CONNECT));
-  EXPECT_TRUE(LogContainsEndEvent(
-      client_entries, 2, NetLog::TYPE_UDP_CONNECT));
+  EXPECT_TRUE(
+      LogContainsBeginEvent(client_entries, 0, NetLog::TYPE_SOCKET_ALIVE));
+  EXPECT_TRUE(
+      LogContainsBeginEvent(client_entries, 1, NetLog::TYPE_UDP_CONNECT));
+  EXPECT_TRUE(LogContainsEndEvent(client_entries, 2, NetLog::TYPE_UDP_CONNECT));
   EXPECT_TRUE(LogContainsEvent(
       client_entries, 3, NetLog::TYPE_UDP_BYTES_SENT, NetLog::PHASE_NONE));
   EXPECT_TRUE(LogContainsEvent(
       client_entries, 4, NetLog::TYPE_UDP_BYTES_RECEIVED, NetLog::PHASE_NONE));
-  EXPECT_TRUE(LogContainsEndEvent(
-      client_entries, 5, NetLog::TYPE_SOCKET_ALIVE));
+  EXPECT_TRUE(
+      LogContainsEndEvent(client_entries, 5, NetLog::TYPE_SOCKET_ALIVE));
 }
 
 #if defined(OS_MACOSX)
@@ -280,6 +277,7 @@ class TestPrng {
     numbers_.pop_front();
     return rv;
   }
+
  private:
   std::deque<int> numbers_;
 
@@ -299,11 +297,10 @@ TEST_F(UDPSocketTest, ConnectRandomBind) {
   // Create and connect sockets and save port numbers.
   std::deque<int> used_ports;
   for (int i = 0; i < kBindRetries; ++i) {
-    UDPClientSocket* socket =
-        new UDPClientSocket(DatagramSocket::DEFAULT_BIND,
-                            RandIntCallback(),
-                            NULL,
-                            NetLog::Source());
+    UDPClientSocket* socket = new UDPClientSocket(DatagramSocket::DEFAULT_BIND,
+                                                  RandIntCallback(),
+                                                  NULL,
+                                                  NetLog::Source());
     sockets.push_back(socket);
     EXPECT_EQ(OK, socket->Connect(peer_address));
 
@@ -321,11 +318,8 @@ TEST_F(UDPSocketTest, ConnectRandomBind) {
       base::Bind(&TestPrng::GetNext, base::Unretained(&test_prng));
 
   // Create a socket with random binding policy and connect.
-  scoped_ptr<UDPClientSocket> test_socket(
-      new UDPClientSocket(DatagramSocket::RANDOM_BIND,
-                          rand_int_cb,
-                          NULL,
-                          NetLog::Source()));
+  scoped_ptr<UDPClientSocket> test_socket(new UDPClientSocket(
+      DatagramSocket::RANDOM_BIND, rand_int_cb, NULL, NetLog::Source()));
   EXPECT_EQ(OK, test_socket->Connect(peer_address));
 
   // Make sure that the last port number in the |used_ports| was used.
@@ -346,11 +340,10 @@ TEST_F(UDPSocketTest, ConnectFail) {
   IPEndPoint peer_address;
   CreateUDPAddress("0.0.0.0", 53, &peer_address);
 
-  scoped_ptr<UDPSocket> socket(
-      new UDPSocket(DatagramSocket::RANDOM_BIND,
-                    base::Bind(&PrivilegedRand),
-                    NULL,
-                    NetLog::Source()));
+  scoped_ptr<UDPSocket> socket(new UDPSocket(DatagramSocket::RANDOM_BIND,
+                                             base::Bind(&PrivilegedRand),
+                                             NULL,
+                                             NetLog::Source()));
   int rv = socket->Connect(peer_address);
   // Connect should have failed since we couldn't bind to that port,
   EXPECT_NE(OK, rv);
@@ -390,10 +383,8 @@ TEST_F(UDPSocketTest, VerifyConnectBindsAddr) {
   // Setup the client, connected to server 1.
   IPEndPoint server_address;
   CreateUDPAddress("127.0.0.1", kPort1, &server_address);
-  UDPClientSocket client(DatagramSocket::DEFAULT_BIND,
-                         RandIntCallback(),
-                         NULL,
-                         NetLog::Source());
+  UDPClientSocket client(
+      DatagramSocket::DEFAULT_BIND, RandIntCallback(), NULL, NetLog::Source());
   rv = client.Connect(server_address);
   EXPECT_EQ(OK, rv);
 
@@ -411,13 +402,11 @@ TEST_F(UDPSocketTest, VerifyConnectBindsAddr) {
   EXPECT_EQ(OK, rv);
 
   // Server2 sends reply.
-  rv = SendToSocket(&server2, foreign_message,
-                    client_address);
+  rv = SendToSocket(&server2, foreign_message, client_address);
   EXPECT_EQ(foreign_message.length(), static_cast<size_t>(rv));
 
   // Server1 sends reply.
-  rv = SendToSocket(&server1, simple_message,
-                    client_address);
+  rv = SendToSocket(&server1, simple_message, client_address);
   EXPECT_EQ(simple_message.length(), static_cast<size_t>(rv));
 
   // Client waits for response.
@@ -431,16 +420,16 @@ TEST_F(UDPSocketTest, ClientGetLocalPeerAddresses) {
     std::string local_address;
     bool may_fail;
   } tests[] = {
-    { "127.0.00.1", "127.0.0.1", false },
-    { "::1", "::1", true },
+    {"127.0.00.1", "127.0.0.1", false},
+    {"::1", "::1", true},
 #if !defined(OS_ANDROID)
     // Addresses below are disabled on Android. See crbug.com/161248
-    { "192.168.1.1", "127.0.0.1", false },
-    { "2001:db8:0::42", "::1", true },
+    {"192.168.1.1", "127.0.0.1", false},
+    {"2001:db8:0::42", "::1", true},
 #endif
   };
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); i++) {
-    SCOPED_TRACE(std::string("Connecting from ") +  tests[i].local_address +
+    SCOPED_TRACE(std::string("Connecting from ") + tests[i].local_address +
                  std::string(" to ") + tests[i].remote_address);
 
     IPAddressNumber ip_number;
@@ -470,7 +459,7 @@ TEST_F(UDPSocketTest, ClientGetLocalPeerAddresses) {
     //                The port is dynamically generated by the udp stack.
     //                The IP is the real IP of the client, not necessarily
     //                loopback.
-    //EXPECT_EQ(local_address.address(), fetched_local_address.address());
+    // EXPECT_EQ(local_address.address(), fetched_local_address.address());
 
     IPEndPoint fetched_remote_address;
     rv = client.GetPeerAddress(&fetched_remote_address);
@@ -544,10 +533,8 @@ TEST_F(UDPSocketTest, MAYBE_JoinMulticastGroup) {
   IPAddressNumber group_ip;
   EXPECT_TRUE(ParseIPLiteralToNumber(kGroup, &group_ip));
 
-  UDPSocket socket(DatagramSocket::DEFAULT_BIND,
-                   RandIntCallback(),
-                   NULL,
-                   NetLog::Source());
+  UDPSocket socket(
+      DatagramSocket::DEFAULT_BIND, RandIntCallback(), NULL, NetLog::Source());
   EXPECT_EQ(OK, socket.Bind(bind_address));
   EXPECT_EQ(OK, socket.JoinGroup(group_ip));
   // Joining group multiple times.
@@ -564,10 +551,8 @@ TEST_F(UDPSocketTest, MulticastOptions) {
   IPEndPoint bind_address;
   CreateUDPAddress("0.0.0.0", kPort, &bind_address);
 
-  UDPSocket socket(DatagramSocket::DEFAULT_BIND,
-                   RandIntCallback(),
-                   NULL,
-                   NetLog::Source());
+  UDPSocket socket(
+      DatagramSocket::DEFAULT_BIND, RandIntCallback(), NULL, NetLog::Source());
   // Before binding.
   EXPECT_EQ(OK, socket.SetMulticastLoopbackMode(false));
   EXPECT_EQ(OK, socket.SetMulticastLoopbackMode(true));