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

native_client_sdk/src/libraries/nacl_io/node.cc

 // Copyright 2013 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/node.h"
 
 #include <assert.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <poll.h>
@@ skipping 21 matching lines @@
   stat_.st_mode = S_IRALL | S_IWALL;
 
   // Filesystem should normally never be NULL, but may be null in tests.
   // If NULL, at least set the inode to a valid (nonzero) value.
   if (filesystem_)
     filesystem_->OnNodeCreated(this);
   else
     stat_.st_ino = 1;
 }
 
-Node::~Node() {}
+Node::~Node() {
+}
 
-Error Node::Init(int open_flags) { return 0; }
+Error Node::Init(int open_flags) {
+  return 0;
+}
 
 void Node::Destroy() {
   if (filesystem_) {
     filesystem_->OnNodeDestroyed(this);
   }
 }
 
-EventEmitter* Node::GetEventEmitter() { return NULL; }
+EventEmitter* Node::GetEventEmitter() {
+  return NULL;
+}
 
 uint32_t Node::GetEventStatus() {
   if (GetEventEmitter())
     return GetEventEmitter()->GetEventStatus();
 
   return POLLIN | POLLOUT;
 }
 
 bool Node::CanOpen(int open_flags) {
   switch (open_flags & 3) {
     case O_RDONLY:
       return (stat_.st_mode & S_IRALL) != 0;
     case O_WRONLY:
       return (stat_.st_mode & S_IWALL) != 0;
     case O_RDWR:
       return (stat_.st_mode & S_IRALL) != 0 && (stat_.st_mode & S_IWALL) != 0;
   }
 
   return false;
 }
 
-Error Node::FSync() { return 0; }
+Error Node::FSync() {
+  return 0;
+}
 
-Error Node::FTruncate(off_t length) { return EINVAL; }
+Error Node::FTruncate(off_t length) {
+  return EINVAL;
+}
 
 Error Node::GetDents(size_t offs,
                      struct dirent* pdir,
                      size_t count,
                      int* out_bytes) {
   *out_bytes = 0;
   return ENOTDIR;
 }
 
 Error Node::GetStat(struct stat* pstat) {
   AUTO_LOCK(node_lock_);
   memcpy(pstat, &stat_, sizeof(stat_));
   return 0;
 }
 
 Error Node::Ioctl(int request, ...) {
   va_list ap;
   va_start(ap, request);
   Error rtn = VIoctl(request, ap);
   va_end(ap);
   return rtn;
 }
 
-Error Node::VIoctl(int request, va_list args) { return EINVAL; }
+Error Node::VIoctl(int request, va_list args) {
+  return EINVAL;
+}
 
 Error Node::Read(const HandleAttr& attr,
                  void* buf,
                  size_t count,
                  int* out_bytes) {
   *out_bytes = 0;
   return EINVAL;
 }
 
 Error Node::Write(const HandleAttr& attr,
@@ skipping 35 matching lines @@
   Error read_error = Read(data, new_addr, length, &bytes_read);
   if (read_error) {
     _real_munmap(new_addr, length);
     return read_error;
   }
 
   *out_addr = new_addr;
   return 0;
 }
 
-Error Node::Tcflush(int queue_selector) { return EINVAL; }
+Error Node::Tcflush(int queue_selector) {
+  return EINVAL;
+}
 
-Error Node::Tcgetattr(struct termios* termios_p) { return EINVAL; }
+Error Node::Tcgetattr(struct termios* termios_p) {
+  return EINVAL;
+}
 
 Error Node::Tcsetattr(int optional_actions, const struct termios* termios_p) {
   return EINVAL;
 }
 
-int Node::GetLinks() { return stat_.st_nlink; }
+int Node::GetLinks() {
+  return stat_.st_nlink;
+}
 
-int Node::GetMode() { return stat_.st_mode & ~S_IFMT; }
+int Node::GetMode() {
+  return stat_.st_mode & ~S_IFMT;
+}
 
 Error Node::GetSize(off_t* out_size) {
   *out_size = stat_.st_size;
   return 0;
 }
 
-int Node::GetType() { return stat_.st_mode & S_IFMT; }
+int Node::GetType() {
+  return stat_.st_mode & S_IFMT;
+}
 
 void Node::SetType(int type) {
   assert((type & ~S_IFMT) == 0);
   stat_.st_mode &= ~S_IFMT;
   stat_.st_mode |= type;
 }
 
-bool Node::IsaDir() { return (stat_.st_mode & S_IFDIR) != 0; }
+bool Node::IsaDir() {
+  return (stat_.st_mode & S_IFDIR) != 0;
+}
 
-bool Node::IsaFile() { return (stat_.st_mode & S_IFREG) != 0; }
+bool Node::IsaFile() {
+  return (stat_.st_mode & S_IFREG) != 0;
+}
 
-bool Node::IsaSock() { return (stat_.st_mode & S_IFSOCK) != 0; }
+bool Node::IsaSock() {
+  return (stat_.st_mode & S_IFSOCK) != 0;
+}
 
 Error Node::Isatty() {
   return ENOTTY;
 }
 
 Error Node::AddChild(const std::string& name, const ScopedNode& node) {
   return ENOTDIR;
 }
 
-Error Node::RemoveChild(const std::string& name) { return ENOTDIR; }
+Error Node::RemoveChild(const std::string& name) {
+  return ENOTDIR;
+}
 
 Error Node::FindChild(const std::string& name, ScopedNode* out_node) {
   out_node->reset(NULL);
   return ENOTDIR;
 }
 
-int Node::ChildCount() { return 0; }
+int Node::ChildCount() {
+  return 0;
+}
 
-void Node::Link() { stat_.st_nlink++; }
+void Node::Link() {
+  stat_.st_nlink++;
+}
 
-void Node::Unlink() { stat_.st_nlink--; }
+void Node::Unlink() {
+  stat_.st_nlink--;
+}
 
 }  // namespace nacl_io