Clang format slam.

net/socket/unix_domain_socket_posix.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/unix_domain_socket_posix.h"
 
 #include <cstring>
 #include <string>
 
 #include <errno.h>
@@ skipping 69 matching lines @@
 }
 
 #if defined(SOCKET_ABSTRACT_NAMESPACE_SUPPORTED)
 // static
 scoped_ptr<UnixDomainSocket>
 UnixDomainSocket::CreateAndListenWithAbstractNamespace(
     const std::string& path,
     const std::string& fallback_path,
     StreamListenSocket::Delegate* del,
     const AuthCallback& auth_callback) {
-  return
-      CreateAndListenInternal(path, fallback_path, del, auth_callback, true);
+  return CreateAndListenInternal(path, fallback_path, del, auth_callback, true);
 }
 #endif
 
-UnixDomainSocket::UnixDomainSocket(
-    SocketDescriptor s,
-    StreamListenSocket::Delegate* del,
-    const AuthCallback& auth_callback)
-    : StreamListenSocket(s, del),
-      auth_callback_(auth_callback) {}
+UnixDomainSocket::UnixDomainSocket(SocketDescriptor s,
+                                   StreamListenSocket::Delegate* del,
+                                   const AuthCallback& auth_callback)
+    : StreamListenSocket(s, del), auth_callback_(auth_callback) {
+}
 
-UnixDomainSocket::~UnixDomainSocket() {}
+UnixDomainSocket::~UnixDomainSocket() {
+}
 
 // static
 SocketDescriptor UnixDomainSocket::CreateAndBind(const std::string& path,
                                                  bool use_abstract_namespace) {
   sockaddr_un addr;
   static const size_t kPathMax = sizeof(addr.sun_path);
   if (use_abstract_namespace + path.size() + 1 /* '\0' */ > kPathMax)
     return kInvalidSocket;
   const SocketDescriptor s = CreatePlatformSocket(PF_UNIX, SOCK_STREAM, 0);
   if (s == kInvalidSocket)
@@ skipping 39 matching lines @@
   scoped_ptr<UnixDomainSocket> sock(
       new UnixDomainSocket(conn, socket_delegate_, auth_callback_));
   // It's up to the delegate to AddRef if it wants to keep it around.
   sock->WatchSocket(WAITING_READ);
   socket_delegate_->DidAccept(this, sock.PassAs<StreamListenSocket>());
 }
 
 UnixDomainSocketFactory::UnixDomainSocketFactory(
     const std::string& path,
     const UnixDomainSocket::AuthCallback& auth_callback)
-    : path_(path),
-      auth_callback_(auth_callback) {}
+    : path_(path), auth_callback_(auth_callback) {
+}
 
-UnixDomainSocketFactory::~UnixDomainSocketFactory() {}
+UnixDomainSocketFactory::~UnixDomainSocketFactory() {
+}
 
 scoped_ptr<StreamListenSocket> UnixDomainSocketFactory::CreateAndListen(
     StreamListenSocket::Delegate* delegate) const {
-  return UnixDomainSocket::CreateAndListen(
-      path_, delegate, auth_callback_).PassAs<StreamListenSocket>();
+  return UnixDomainSocket::CreateAndListen(path_, delegate, auth_callback_)
+      .PassAs<StreamListenSocket>();
 }
 
 #if defined(SOCKET_ABSTRACT_NAMESPACE_SUPPORTED)
 
 UnixDomainSocketWithAbstractNamespaceFactory::
-UnixDomainSocketWithAbstractNamespaceFactory(
-    const std::string& path,
-    const std::string& fallback_path,
-    const UnixDomainSocket::AuthCallback& auth_callback)
+    UnixDomainSocketWithAbstractNamespaceFactory(
+        const std::string& path,
+        const std::string& fallback_path,
+        const UnixDomainSocket::AuthCallback& auth_callback)
     : UnixDomainSocketFactory(path, auth_callback),
-      fallback_path_(fallback_path) {}
+      fallback_path_(fallback_path) {
+}
 
 UnixDomainSocketWithAbstractNamespaceFactory::
-~UnixDomainSocketWithAbstractNamespaceFactory() {}
+    ~UnixDomainSocketWithAbstractNamespaceFactory() {
+}
 
 scoped_ptr<StreamListenSocket>
 UnixDomainSocketWithAbstractNamespaceFactory::CreateAndListen(
     StreamListenSocket::Delegate* delegate) const {
   return UnixDomainSocket::CreateAndListenWithAbstractNamespace(
              path_, fallback_path_, delegate, auth_callback_)
-         .PassAs<StreamListenSocket>();
+      .PassAs<StreamListenSocket>();
 }
 
 #endif
 
 }  // namespace net