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

native_client_sdk/src/libraries/nacl_io/mount_node_mem.cc

Index: native_client_sdk/src/libraries/nacl_io/mount_node_mem.cc
diff --git a/native_client_sdk/src/libraries/nacl_io/mount_node_mem.cc b/native_client_sdk/src/libraries/nacl_io/mount_node_mem.cc
index 0fa82baeba30dad2b82c7ab908504d941290f5f7..1e89e4afedbb3767ff0fbd1da6e428bc4fb25997 100644
--- a/native_client_sdk/src/libraries/nacl_io/mount_node_mem.cc
+++ b/native_client_sdk/src/libraries/nacl_io/mount_node_mem.cc
@@ -13,69 +13,83 @@
 #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_); }
+
+Error MountNodeMem::Read(size_t offs, void* buf, size_t count, int* out_bytes) {
+  *out_bytes = 0;
 
-int MountNodeMem::Read(size_t offs, void *buf, size_t count) {
   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 > stat_.st_size) {
+    Error error = FTruncate(count + offs);
+    if (error)
+      return error;
 
-  if (count + offs > GetSize()) {
-    FTruncate(count + offs);
-    count = GetSize() - offs;
+    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;
 }