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

native_client_sdk/src/libraries/nacl_io/kernel_object.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_object.h"
 
 #include <assert.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <pthread.h>
 
 #include <algorithm>
 #include <map>
 #include <string>
 #include <vector>
 
 #include "nacl_io/filesystem.h"
 #include "nacl_io/kernel_handle.h"
 #include "nacl_io/node.h"
 
 #include "sdk_util/auto_lock.h"
 #include "sdk_util/ref_object.h"
 #include "sdk_util/scoped_ref.h"
 
 namespace nacl_io {
 
-KernelObject::KernelObject() { cwd_ = "/"; }
+KernelObject::KernelObject() {
+  cwd_ = "/";
+}
 
 KernelObject::~KernelObject() {};
 
 Error KernelObject::AttachFsAtPath(const ScopedFilesystem& fs,
                                    const std::string& path) {
   std::string abs_path = GetAbsParts(path).Join();
 
   AUTO_LOCK(fs_lock_);
   if (filesystems_.find(abs_path) != filesystems_.end())
     return EBUSY;
@@ skipping 138 matching lines @@
     return EBADF;
 
   Descriptor_t& desc = handle_map_[fd];
   if (!desc.handle)
     return EBADF;
 
   *out_handle = desc.handle;
   return 0;
 }
 
-Error KernelObject::AcquireHandleAndPath(int fd, ScopedKernelHandle* out_handle,
-                                         std::string* out_path){
+Error KernelObject::AcquireHandleAndPath(int fd,
+                                         ScopedKernelHandle* out_handle,
+                                         std::string* out_path) {
   out_handle->reset(NULL);
 
   AUTO_LOCK(handle_lock_);
   if (fd < 0 || fd >= static_cast<int>(handle_map_.size()))
     return EBADF;
 
   Descriptor_t& desc = handle_map_[fd];
   if (!desc.handle)
     return EBADF;
 
@@ skipping 18 matching lines @@
     free_fds_.pop_back();
     handle_map_[id] = descriptor;
   } else {
     id = handle_map_.size();
     handle_map_.push_back(descriptor);
   }
 
   return id;
 }
 
-void KernelObject::FreeAndReassignFD(int fd, const ScopedKernelHandle& handle,
+void KernelObject::FreeAndReassignFD(int fd,
+                                     const ScopedKernelHandle& handle,
                                      const std::string& path) {
   if (NULL == handle) {
     FreeFD(fd);
   } else {
     AUTO_LOCK(handle_lock_);
 
     // If the required FD is larger than the current set, grow the set
     if (fd >= (int)handle_map_.size())
       handle_map_.resize(fd + 1);
 
     // This path will be from an existing handle, and absolute.
     handle_map_[fd] = Descriptor_t(handle, path);
   }
 }
 
 void KernelObject::FreeFD(int fd) {
   AUTO_LOCK(handle_lock_);
 
   handle_map_[fd].handle.reset(NULL);
   free_fds_.push_back(fd);
 
   // Force lower numbered FD to be available first.
   std::push_heap(free_fds_.begin(), free_fds_.end(), std::greater<int>());
 }
 
 }  // namespace nacl_io