[NaCl SDK] nacl_io: Remove use of new/delete for data buffers.

This is the first step in the transition of nacl_io
from C++ to C.

Also, remove an unused method (Packet::Take).

BUG=400779
R=binji@chromium.org

Review URL: https://codereview.chromium.org/443693002

Cr-Commit-Position: refs/heads/master@{#288314}
git-svn-id: svn://svn.chromium.org/chrome/trunk/src@288314 0039d316-1c4b-4281-b951-d872f2087c98

native_client_sdk/src/libraries/nacl_io/fifo_char.cc

@@ -4,6 +4,7 @@
 
 #include "nacl_io/fifo_char.h"
 
+#include <assert.h>
 #include <stdlib.h>
 #include <string.h>
 
@@ -13,12 +14,14 @@ namespace nacl_io {
 
 FIFOChar::FIFOChar(size_t size)
     : buffer_(NULL), size_(size), avail_(0), tail_(0) {
-  if (size)
-    buffer_ = new char[size];
+  if (size) {
+    buffer_ = (char*)malloc(size);
+    assert(buffer_ != NULL);
+  }
 }
 
 FIFOChar::~FIFOChar() {
-  delete[] buffer_;
+  free(buffer_);
 }
 
 bool FIFOChar::IsEmpty() {
@@ -34,13 +37,11 @@ bool FIFOChar::Resize(size_t len) {
   if (len < avail_)
     return false;
 
-  // Read current data into new buffer
-  char* data = new char[len];
-  avail_ = Read(data, avail_);
-
-  // Replace buffer
-  delete[] buffer_;
-  buffer_ = data;
+  // Resize buffer
+  buffer_ = (char*)realloc(buffer_, len);
+  assert(buffer_ != NULL);
+  if (buffer_ == NULL)
+    return false;
   size_ = len;
   return true;
 }

native_client_sdk/src/libraries/nacl_io/httpfs/http_fs.cc

@@ -226,11 +226,11 @@ Error HttpFs::Init(const FsInitArgs& args) {
 
       error = ParseManifest(text);
       if (error) {
-        delete[] text;
+        free(text);
         return error;
       }
 
-      delete[] text;
+      free(text);
     } else if (iter->first == "allow_cross_origin_requests") {
       allow_cors_ = iter->second == "true";
     } else if (iter->first == "allow_credentials") {
@@ -396,7 +396,10 @@ Error HttpFs::LoadManifest(const std::string& manifest_name,
   if (error)
     return error;
 
-  char* text = new char[size + 1];
+  char* text = (char*)malloc(size + 1);
+  assert(text != NULL);
+  if (text == NULL)
+    return ENOMEM;
   int len;
   error = manifest_node->Read(HandleAttr(), text, size, &len);
   if (error)

native_client_sdk/src/libraries/nacl_io/httpfs/http_fs_node.cc

@@ -228,6 +228,8 @@ HttpFsNode::HttpFsNode(Filesystem* filesystem,
                        bool cache_content)
     : Node(filesystem),
       url_(url),
+      buffer_(NULL),
+      buffer_len_(0),
       cache_content_(cache_content),
       has_cached_size_(false) {
 }
@@ -557,12 +559,18 @@ Error HttpFsNode::ReadEntireResponseToTemp(const ScopedResource& loader,
   *out_bytes = 0;
 
   const int kBytesToRead = MAX_READ_BUFFER_SIZE;
-  buffer_.resize(kBytesToRead);
+  buffer_ = (char*)realloc(buffer_, kBytesToRead);
+  assert(buffer_);
+  if (!buffer_) {
+    buffer_len_ = 0;
+    return ENOMEM;
+  }
+  buffer_len_ = kBytesToRead;
 
   while (true) {
     int bytes_read;
     Error error =
-        ReadResponseToBuffer(loader, buffer_.data(), kBytesToRead, &bytes_read);
+        ReadResponseToBuffer(loader, buffer_, kBytesToRead, &bytes_read);
     if (error)
       return error;
 
@@ -604,16 +612,23 @@ Error HttpFsNode::ReadResponseToTemp(const ScopedResource& loader,
                                      int* out_bytes) {
   *out_bytes = 0;
 
-  if (buffer_.size() < static_cast<size_t>(count))
-    buffer_.resize(std::min(count, MAX_READ_BUFFER_SIZE));
+  if (buffer_len_ < count) {
+    int new_len = std::min(count, MAX_READ_BUFFER_SIZE);
+    buffer_ = (char*)realloc(buffer_, new_len);
+    assert(buffer_);
+    if (!buffer_) {
+      buffer_len_ = 0;
+      return ENOMEM;
+    }
+    buffer_len_ = new_len;
+  }
 
   int bytes_left = count;
   while (bytes_left > 0) {
-    int bytes_to_read =
-        std::min(static_cast<size_t>(bytes_left), buffer_.size());
+    int bytes_to_read = std::min(bytes_left, buffer_len_);
     int bytes_read;
     Error error = ReadResponseToBuffer(
-        loader, buffer_.data(), bytes_to_read, &bytes_read);
+        loader, buffer_, bytes_to_read, &bytes_read);
     if (error)
       return error;
 

native_client_sdk/src/libraries/nacl_io/httpfs/http_fs_node.h

@@ -86,7 +86,8 @@ class HttpFsNode : public Node {
                              int* out_bytes);
 
   std::string url_;
-  std::vector<char> buffer_;
+  char* buffer_;
+  int buffer_len_;
 
   bool cache_content_;
   bool has_cached_size_;

native_client_sdk/src/libraries/nacl_io/memfs/mem_fs_node.cc

@@ -2,14 +2,20 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#ifndef __STDC_LIMIT_MACROS
+#define __STDC_LIMIT_MACROS
+#endif
+
 #include "nacl_io/memfs/mem_fs_node.h"
 
+#include <assert.h>
 #include <errno.h>
 #include <string.h>
 
 #include <algorithm>
 
 #include "nacl_io/kernel_handle.h"
+#include "nacl_io/osinttypes.h"
 #include "nacl_io/osstat.h"
 #include "sdk_util/auto_lock.h"
 
@@ -23,7 +29,10 @@ const size_t kMaxResizeIncrement = 16 * 1024 * 1024;
 
 }  // namespace
 
-MemFsNode::MemFsNode(Filesystem* filesystem) : Node(filesystem) {
+MemFsNode::MemFsNode(Filesystem* filesystem)
+  : Node(filesystem),
+    data_(NULL),
+    data_capacity_(0) {
   SetType(S_IFREG);
 }
 
@@ -46,7 +55,7 @@ Error MemFsNode::Read(const HandleAttr& attr,
     count = size - attr.offs;
   }
 
-  memcpy(buf, &data_[attr.offs], count);
+  memcpy(buf, data_ + attr.offs, count);
   *out_bytes = static_cast<int>(count);
   return 0;
 }
@@ -56,40 +65,56 @@ Error MemFsNode::Write(const HandleAttr& attr,
                        size_t count,
                        int* out_bytes) {
   *out_bytes = 0;
-  AUTO_LOCK(node_lock_);
 
   if (count == 0)
     return 0;
 
-  if (count + attr.offs > static_cast<size_t>(stat_.st_size)) {
-    Resize(count + attr.offs);
-    count = stat_.st_size - attr.offs;
+  AUTO_LOCK(node_lock_);
+  off_t new_size = attr.offs + count;
+  if (new_size > stat_.st_size) {
+    Error error = Resize(new_size);
+    if (error) {
+      LOG_ERROR("memfs: resize (%" PRIoff ") failed: %s", new_size,
+          strerror(error));
+      return error;
+    }
   }
 
-  memcpy(&data_[attr.offs], buf, count);
+  memcpy(data_ + attr.offs, buf, count);
   *out_bytes = static_cast<int>(count);
   return 0;
 }
 
 Error MemFsNode::FTruncate(off_t new_size) {
   AUTO_LOCK(node_lock_);
-  Resize(new_size);
-  return 0;
+  return Resize(new_size);
 }
 
-void MemFsNode::Resize(off_t new_size) {
-  if (new_size > static_cast<off_t>(data_.capacity())) {
+Error MemFsNode::Resize(off_t new_length) {
+  if (new_length < 0)
+    return EINVAL;
+  size_t new_size = static_cast<size_t>(new_length);
+
+  if (new_size > data_capacity_) {
     // While the node size is small, grow exponentially. When it starts to get
     // larger, grow linearly.
-    size_t extra = std::min<size_t>(new_size, kMaxResizeIncrement);
-    data_.reserve(new_size + extra);
-  } else if (new_size < stat_.st_size) {
-    // Shrink to fit. std::vector usually doesn't reduce allocation size, so
-    // use the swap trick.
-    std::vector<char>(data_).swap(data_);
+    size_t extra = std::min(new_size, kMaxResizeIncrement);
+    data_capacity_ = new_size + extra;
+  } else {
+    data_capacity_ = new_size;
+  }
+
+  data_ = (char*)realloc(data_, data_capacity_);
+  if (data_capacity_ != 0) {
+    assert(data_ != NULL);
+    if (data_ == NULL)
+      return ENOMEM;
+    if (new_length > stat_.st_size)
+      memset(data_ + stat_.st_size, 0, new_length - stat_.st_size);
   }
-  data_.resize(new_size);
-  stat_.st_size = new_size;
+
+  stat_.st_size = new_length;
+  return 0;
 }
 
 }  // namespace nacl_io

native_client_sdk/src/libraries/nacl_io/memfs/mem_fs_node.h

@@ -7,8 +7,6 @@
 
 #include "nacl_io/node.h"
 
-#include <vector>
-
 namespace nacl_io {
 
 class MemFsNode : public Node {
@@ -31,9 +29,10 @@ class MemFsNode : public Node {
   virtual Error FTruncate(off_t size);
 
  private:
-  void Resize(off_t size);
+  Error Resize(off_t size);
 
-  std::vector<char> data_;
+  char* data_;
+  size_t data_capacity_;
   friend class MemFs;
 };
 

native_client_sdk/src/libraries/nacl_io/osinttypes.h

@@ -34,4 +34,10 @@
 
 #endif
 
+#if !defined(__native_client__)
+#define PRIoff "ld"
+#else
+#define PRIoff "lld"
+#endif
+
 #endif  /* NACL_IO_OSINTTYPES_H_ */

native_client_sdk/src/libraries/nacl_io/socket/fifo_packet.h

@@ -8,7 +8,6 @@
 #include <string.h>
 
 #include <list>
-#include <vector>
 
 #include "nacl_io/fifo_interface.h"
 #include "ppapi/c/pp_resource.h"

native_client_sdk/src/libraries/nacl_io/socket/packet.cc

@@ -4,6 +4,7 @@
 
 #include "nacl_io/socket/packet.h"
 
+#include <assert.h>
 #include <string.h>
 
 #include "nacl_io/pepper_interface.h"
@@ -17,19 +18,14 @@ Packet::Packet(PepperInterface* ppapi)
 Packet::~Packet() {
   if ((NULL != ppapi_) && addr_)
     ppapi_->ReleaseResource(addr_);
-  delete[] buffer_;
-}
-
-void Packet::Take(const void* buffer, size_t len, PP_Resource addr) {
-  addr_ = addr;
-  len_ = len;
-  buffer_ = static_cast<char*>(const_cast<void*>(buffer));
+  free(buffer_);
 }
 
 void Packet::Copy(const void* buffer, size_t len, PP_Resource addr) {
   addr_ = addr;
   len_ = len;
-  buffer_ = new char[len];
+  buffer_ = (char*)malloc(len);
+  assert(buffer_);
 
   memcpy(buffer_, buffer, len);
   if (addr && (NULL != ppapi_))

native_client_sdk/src/libraries/nacl_io/socket/packet.h

@@ -14,8 +14,7 @@ namespace nacl_io {
 
 class PepperInterface;
 
-// NOTE: The Packet class always owns the buffer and address, either by 'Copy'
-// or by 'Take' ownership.
+// NOTE: The Packet class always owns the buffer and address.
 class Packet {
  public:
   explicit Packet(PepperInterface* ppapi);
@@ -24,9 +23,6 @@ class Packet {
   // Copy the buffer, and address reference
   void Copy(const void* buffer, size_t len, PP_Resource addr);
 
-  // Take ownership the buffer, and address reference
-  void Take(const void* buffer, size_t len, PP_Resource addr);
-
   char* buffer() { return buffer_; }
   PP_Resource addr() { return addr_; }
   size_t len() { return len_; }

native_client_sdk/src/libraries/nacl_io/socket/tcp_node.cc

@@ -30,7 +30,9 @@ class TcpWork : public StreamFs::Work {
         emitter_(emitter),
         data_(NULL) {}
 
-  ~TcpWork() { delete[] data_; }
+  ~TcpWork() {
+    free(data_);
+  }
 
   TCPSocketInterface* TCPInterface() {
     return filesystem()->ppapi()->GetTCPSocketInterface();
@@ -63,7 +65,10 @@ class TcpSendWork : public TcpWork {
     if (capped_len == 0)
       return false;
 
-    data_ = new char[capped_len];
+    data_ = (char*)malloc(capped_len);
+    assert(data_);
+    if (data_ == NULL)
+      return false;
     emitter_->ReadOut_Locked(data_, capped_len);
 
     int err = TCPInterface()->Write(node_->socket_resource(),
@@ -126,7 +131,10 @@ class TcpRecvWork : public TcpWork {
     if (capped_len == 0)
       return false;
 
-    data_ = new char[capped_len];
+    data_ = (char*)malloc(capped_len);
+    assert(data_);
+    if (data_ == NULL)
+      return false;
     int err = TCPInterface()->Read(stream->socket_resource(),
                                    data_,
                                    capped_len,

native_client_sdk/src/libraries/nacl_io/socket/udp_node.cc

@@ -96,11 +96,8 @@ class UdpRecvWork : public UdpWork {
  public:
   explicit UdpRecvWork(const ScopedUdpEventEmitter& emitter)
       : UdpWork(emitter) {
-    data_ = new char[kMaxPacketSize];
   }
 
-  ~UdpRecvWork() { delete[] data_; }
-
   virtual bool Start(int32_t val) {
     AUTO_LOCK(emitter_->GetLock());
     UdpNode* stream = static_cast<UdpNode*>(emitter_->stream());
@@ -146,7 +143,7 @@ class UdpRecvWork : public UdpWork {
   }
 
  private:
-  char* data_;
+  char data_[kMaxPacketSize];
   PP_Resource addr_;
 };