[NaCl SDK] nacl_io: big refactor to return error value (errno).

native_client_sdk/src/libraries/nacl_io/mount_node_mem.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/mount_node_mem.h"
 
 #include <errno.h>
 #include <string.h>
 
 #include "nacl_io/osstat.h"
 #include "utils/auto_lock.h"
 
 #define BLOCK_SIZE (1 << 16)
 #define BLOCK_MASK (BLOCK_SIZE - 1)
 
-MountNodeMem::MountNodeMem(Mount *mount)
-    : MountNode(mount),
-      data_(NULL),
-      capacity_(0) {
+MountNodeMem::MountNodeMem(Mount* mount)
+    : MountNode(mount), data_(NULL), capacity_(0) {
   stat_.st_mode |= S_IFREG;
 }
 
-MountNodeMem::~MountNodeMem() {
-  free(data_);
-}
+MountNodeMem::~MountNodeMem() { free(data_); }
 
-int MountNodeMem::Read(size_t offs, void *buf, size_t count) {
+Error MountNodeMem::Read(size_t offs, void* buf, size_t count, int* out_bytes) {
+  *out_bytes = 0;
+
   AutoLock lock(&lock_);
-  if (count == 0) return 0;
-  if (offs + count > GetSize()) {
-    count = GetSize() - offs;
+  if (count == 0)
+    return 0;
+
+  size_t size = stat_.st_size;
+
+  if (offs + count > size) {
+    count = size - offs;
   }
 
   memcpy(buf, &data_[offs], count);
-  return static_cast<int>(count);
+  *out_bytes = static_cast<int>(count);
+  return 0;
 }
 
-int MountNodeMem::Write(size_t offs, const void *buf, size_t count) {
+Error MountNodeMem::Write(size_t offs,
+                          const void* buf,
+                          size_t count,
+                          int* out_bytes) {
+  *out_bytes = 0;
+
   AutoLock lock(&lock_);
 
-  if (count == 0) return 0;
+  if (count == 0)
+    return 0;
 
-  if (count + offs > GetSize()) {
-    FTruncate(count + offs);
-    count = GetSize() - offs;
+  if (count + offs > stat_.st_size) {
+    Error error = FTruncate(count + offs);
+    if (error)
+      return error;
+
+    count = stat_.st_size - offs;
   }
 
   memcpy(&data_[offs], buf, count);
-  return static_cast<int>(count);
+  *out_bytes = static_cast<int>(count);
+  return 0;
 }
 
-int MountNodeMem::FTruncate(off_t size) {
-  size_t need = (size + BLOCK_MASK) & ~BLOCK_MASK;
+Error MountNodeMem::FTruncate(off_t new_size) {
+  size_t need = (new_size + BLOCK_MASK) & ~BLOCK_MASK;
+  size_t old_size = stat_.st_size;

[noelallen1, 2013/06/07 21:48:43]

Losing virtual behavior or GetSize, is that what you want to do?

[binji, 2013/06/07 23:23:11]

Fair point, though any derived class (none of which currently exist) will likely
need to override more functions than just GetSize().

GetSize() now potentially returns an error, but that's silly to do for a memory
node, so using the value directly greatly simplifies the code.

 
   // If the current capacity is correct, just adjust and return
   if (need == capacity_) {
-    stat_.st_size = static_cast<off_t>(size);
+    stat_.st_size = static_cast<off_t>(new_size);
     return 0;
   }
 
   // Attempt to realloc the block
-  char *newdata = static_cast<char *>(realloc(data_, need));
+  char* newdata = static_cast<char*>(realloc(data_, need));
   if (newdata != NULL) {
     // Zero out new space.
-    if (size > GetSize())
-      memset(newdata + GetSize(), 0, size - GetSize());
+    if (new_size > old_size)
+      memset(newdata + old_size, 0, new_size - old_size);
 
     data_ = newdata;
     capacity_ = need;
-    stat_.st_size = static_cast<off_t>(size);
+    stat_.st_size = static_cast<off_t>(new_size);
     return 0;
   }
 
   // If we failed, then adjust size according to what we keep
-  if (size > capacity_) size = capacity_;
+  if (new_size > capacity_)
+    new_size = capacity_;
 
   // Update the size and return the new size
-  stat_.st_size = static_cast<off_t>(size);
-  errno = EIO;
-  return -1;
+  stat_.st_size = static_cast<off_t>(new_size);
+  return EIO;
 }