[NaCl SDK] nacl_io: Run clang-format over nacl_io sources.

native_client_sdk/src/libraries/nacl_io/kernel_handle.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 "nacl_io/kernel_handle.h"
 
 #include <errno.h>
 #include <pthread.h>
 
 #include "nacl_io/filesystem.h"
 #include "nacl_io/node.h"
 #include "nacl_io/osunistd.h"
 #include "nacl_io/socket/socket_node.h"
 
 #include "sdk_util/auto_lock.h"
 
 namespace nacl_io {
 
 // It is only legal to construct a handle while the kernel lock is held.
-KernelHandle::KernelHandle() : filesystem_(NULL), node_(NULL) {}
+KernelHandle::KernelHandle() : filesystem_(NULL), node_(NULL) {
+}
 
 KernelHandle::KernelHandle(const ScopedFilesystem& fs, const ScopedNode& node)
-    : filesystem_(fs), node_(node) {}
+    : filesystem_(fs), node_(node) {
+}
 
 KernelHandle::~KernelHandle() {
   // Force release order for cases where filesystem_ is not ref'd by mounting.
   node_.reset(NULL);
   filesystem_.reset(NULL);
 }
 
 // Returns the SocketNode* if this node is a socket.
 SocketNode* KernelHandle::socket_node() {
   if (node_.get() && node_->IsaSock())
@@ skipping 112 matching lines @@
       const int mutable_flags = O_ASYNC | O_NONBLOCK;
       flags &= mutable_flags;
       handle_attr_.flags &= ~mutable_flags;
       handle_attr_.flags |= flags;
       return 0;
     }
   }
   return ENOSYS;
 }
 
-Error KernelHandle::Accept(PP_Resource* new_sock, struct sockaddr* addr,
+Error KernelHandle::Accept(PP_Resource* new_sock,
+                           struct sockaddr* addr,
                            socklen_t* len) {
   SocketNode* sock = socket_node();
   if (!sock)
     return ENOTSOCK;
 
   AUTO_LOCK(handle_lock_);
   return sock->Accept(handle_attr_, new_sock, addr, len);
 }
 
 Error KernelHandle::Connect(const struct sockaddr* addr, socklen_t len) {
@@ skipping 26 matching lines @@
   if (!sock)
     return ENOTSOCK;
   if (OpenMode() == O_WRONLY)
     return EACCES;
 
   AUTO_LOCK(handle_lock_);
   return sock->RecvFrom(handle_attr_, buf, len, flags, src_addr, addrlen,
                         out_len);
 }
 
-Error KernelHandle::Send(const void* buf,
-                         size_t len,
-                         int flags,
-                         int* out_len) {
+Error KernelHandle::Send(const void* buf, size_t len, int flags, int* out_len) {
   SocketNode* sock = socket_node();
   if (!sock)
     return ENOTSOCK;
   if (OpenMode() == O_RDONLY)
     return EACCES;
 
   AUTO_LOCK(handle_lock_);
   return sock->Send(handle_attr_, buf, len, flags, out_len);
 }
 
 Error KernelHandle::SendTo(const void* buf,
                            size_t len,
                            int flags,
                            const struct sockaddr* dest_addr,
                            socklen_t addrlen,
                            int* out_len) {
   SocketNode* sock = socket_node();
   if (!sock)
     return ENOTSOCK;
   if (OpenMode() == O_RDONLY)
     return EACCES;
 
   AUTO_LOCK(handle_lock_);
   return sock->SendTo(handle_attr_, buf, len, flags, dest_addr, addrlen,
                       out_len);
 }
 
 }  // namespace nacl_io