Clang format slam.

net/socket/unix_domain_socket_posix_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 <errno.h>
 #include <fcntl.h>
 #include <poll.h>
 #include <sys/socket.h>
 #include <sys/stat.h>
 #include <sys/time.h>
@@ skipping 105 matching lines @@
       DCHECK(len);
       data_.assign(data, len - 1);
     }
     Notify(EVENT_READ);
   }
 
   virtual void DidClose(StreamListenSocket* sock) OVERRIDE {
     Notify(EVENT_CLOSE);
   }
 
-  void OnListenCompleted() {
-    Notify(EVENT_LISTEN);
-  }
+  void OnListenCompleted() { Notify(EVENT_LISTEN); }
 
   string ReceivedData() {
     base::AutoLock lock(mutex_);
     return data_;
   }
 
  private:
-  void Notify(EventType event) {
-    event_manager_->Notify(event);
-  }
+  void Notify(EventType event) { event_manager_->Notify(event); }
 
   const scoped_refptr<EventManager> event_manager_;
   scoped_ptr<StreamListenSocket> connection_;
   base::Lock mutex_;
   string data_;
 };
 
-bool UserCanConnectCallback(
-    bool allow_user, const scoped_refptr<EventManager>& event_manager,
-    uid_t, gid_t) {
-  event_manager->Notify(
-      allow_user ? EVENT_AUTH_GRANTED : EVENT_AUTH_DENIED);
+bool UserCanConnectCallback(bool allow_user,
+                            const scoped_refptr<EventManager>& event_manager,
+                            uid_t,
+                            gid_t) {
+  event_manager->Notify(allow_user ? EVENT_AUTH_GRANTED : EVENT_AUTH_DENIED);
   return allow_user;
 }
 
 class UnixDomainSocketTestHelper : public testing::Test {
  public:
   void CreateAndListen() {
     socket_ = UnixDomainSocket::CreateAndListen(
         file_path_.value(), socket_delegate_.get(), MakeAuthCallback());
     socket_delegate_->OnListenCompleted();
   }
 
  protected:
   UnixDomainSocketTestHelper(const string& path, bool allow_user)
-      : file_path_(path),
-        allow_user_(allow_user) {}
+      : file_path_(path), allow_user_(allow_user) {}
 
   virtual void SetUp() OVERRIDE {
     event_manager_ = new EventManager();
     socket_delegate_.reset(new TestListenSocketDelegate(event_manager_));
     DeleteSocketFile();
   }
 
   virtual void TearDown() OVERRIDE {
     DeleteSocketFile();
     socket_.reset();
@@ skipping 86 matching lines @@
       file_path_.value(), "", socket_delegate_.get(), MakeAuthCallback());
   EXPECT_FALSE(socket_.get() == NULL);
 }
 
 TEST_F(UnixDomainSocketTest, TestFallbackName) {
   scoped_ptr<UnixDomainSocket> existing_socket =
       UnixDomainSocket::CreateAndListenWithAbstractNamespace(
           file_path_.value(), "", socket_delegate_.get(), MakeAuthCallback());
   EXPECT_FALSE(existing_socket.get() == NULL);
   // First, try to bind socket with the same name with no fallback name.
-  socket_ =
-      UnixDomainSocket::CreateAndListenWithAbstractNamespace(
-          file_path_.value(), "", socket_delegate_.get(), MakeAuthCallback());
+  socket_ = UnixDomainSocket::CreateAndListenWithAbstractNamespace(
+      file_path_.value(), "", socket_delegate_.get(), MakeAuthCallback());
   EXPECT_TRUE(socket_.get() == NULL);
   // Now with a fallback name.
   const char kFallbackSocketName[] = "unix_domain_socket_for_testing_2";
   socket_ = UnixDomainSocket::CreateAndListenWithAbstractNamespace(
       file_path_.value(),
       MakeSocketPath(kFallbackSocketName),
       socket_delegate_.get(),
       MakeAuthCallback());
   EXPECT_FALSE(socket_.get() == NULL);
 }
@@ skipping 44 matching lines @@
 
   // Send() must fail.
   ssize_t ret = HANDLE_EINTR(send(sock, kMsg, sizeof(kMsg), 0));
   ASSERT_EQ(-1, ret);
   ASSERT_EQ(EPIPE, errno);
   ASSERT_FALSE(event_manager_->HasPendingEvent());
 }
 
 }  // namespace
 }  // namespace net