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

native_client_sdk/src/libraries/nacl_io/fusefs/fuse_fs.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/fusefs/fuse_fs.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <string.h>
 
@@ skipping 11 matching lines @@
   FillDirInfo(GetDentsHelper* getdents, size_t num_bytes)
       : getdents(getdents), num_bytes(num_bytes), wrote_offset(false) {}
 
   GetDentsHelper* getdents;
   size_t num_bytes;
   bool wrote_offset;
 };
 
 }  // namespace
 
-FuseFs::FuseFs() : fuse_ops_(NULL), fuse_user_data_(NULL) {}
+FuseFs::FuseFs() : fuse_ops_(NULL), fuse_user_data_(NULL) {
+}
 
 Error FuseFs::Init(const FsInitArgs& args) {
   Error error = Filesystem::Init(args);
   if (error)
     return error;
 
   fuse_ops_ = args.fuse_ops;
   if (fuse_ops_ == NULL)
     return EINVAL;
 
@@ skipping 154 matching lines @@
   if (result < 0)
     return -result;
 
   return 0;
 }
 
 FuseFsNode::FuseFsNode(Filesystem* filesystem,
                        struct fuse_operations* fuse_ops,
                        struct fuse_file_info& info,
                        const std::string& path)
-    : Node(filesystem), fuse_ops_(fuse_ops), info_(info), path_(path) {}
+    : Node(filesystem), fuse_ops_(fuse_ops), info_(info), path_(path) {
+}
 
 bool FuseFsNode::CanOpen(int open_flags) {
   struct stat statbuf;
   Error error = GetStat(&statbuf);
   if (error)
     return false;
 
   // GetStat cached the mode in stat_.st_mode. Forward to Node::CanOpen,
   // which will check this mode against open_flags.
   return Node::CanOpen(open_flags);
@@ skipping 46 matching lines @@
     return error;
 
   *out_size = stat_.st_size;
   return 0;
 }
 
 FileFuseFsNode::FileFuseFsNode(Filesystem* filesystem,
                                struct fuse_operations* fuse_ops,
                                struct fuse_file_info& info,
                                const std::string& path)
-    : FuseFsNode(filesystem, fuse_ops, info, path) {}
+    : FuseFsNode(filesystem, fuse_ops, info, path) {
+}
 
 void FileFuseFsNode::Destroy() {
   if (!fuse_ops_->release)
     return;
   fuse_ops_->release(path_.c_str(), &info_);
 }
 
 Error FileFuseFsNode::FSync() {
   if (!fuse_ops_->fsync)
     return ENOSYS;
@@ skipping 55 matching lines @@
   // TODO(binji): What should we do if the user breaks this contract? Warn?
   // TODO(binji): support the direct_io flag
   *out_bytes = result;
   return 0;
 }
 
 DirFuseFsNode::DirFuseFsNode(Filesystem* filesystem,
                              struct fuse_operations* fuse_ops,
                              struct fuse_file_info& info,
                              const std::string& path)
-    : FuseFsNode(filesystem, fuse_ops, info, path) {}
+    : FuseFsNode(filesystem, fuse_ops, info, path) {
+}
 
 void DirFuseFsNode::Destroy() {
   if (!fuse_ops_->releasedir)
     return;
   fuse_ops_->releasedir(path_.c_str(), &info_);
 }
 
 Error DirFuseFsNode::FSync() {
   if (!fuse_ops_->fsyncdir)
     return ENOSYS;
@@ skipping 81 matching lines @@
   } else {
     fill_info->getdents->AddDirent(ino, name, strlen(name));
     fill_info->num_bytes -= sizeof(dirent);
     // According to the docs, we can never return 1 (buffer full) when the
     // offset is zero (the user is probably ignoring the result anyway).
     return 0;
   }
 }
 
 }  // namespace nacl_io