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

native_client_sdk/src/libraries/nacl_io/httpfs/http_fs_node.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/httpfs/http_fs_node.h"
 
 #include <assert.h>
 #include <errno.h>
 #include <stdio.h>
 #include <string.h>
@@ skipping 210 matching lines @@
 
   *out_size = stat_.st_size;
   return 0;
 }
 
 HttpFsNode::HttpFsNode(Filesystem* filesystem,
                        const std::string& url,
                        bool cache_content)
     : Node(filesystem),
       url_(url),
+      buffer_(NULL),
+      buffer_len_(0),
       cache_content_(cache_content),
       has_cached_size_(false) {
 }
 
 void HttpFsNode::SetMode(int mode) {
   stat_.st_mode = mode;
 }
 
 Error HttpFsNode::GetStat_Locked(struct stat* stat) {
   // Assume we need to 'HEAD' if we do not know the size, otherwise, assume
@@ skipping 309 matching lines @@
   }
 
   return ReadEntireResponseToTemp(loader, out_bytes);
 }
 
 Error HttpFsNode::ReadEntireResponseToTemp(const ScopedResource& loader,
                                            off_t* out_bytes) {
   *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;
 
     *out_bytes += bytes_read;
 
     if (bytes_read < kBytesToRead)
       return 0;
   }
 }
 
@@ skipping 21 matching lines @@
       return 0;
     }
   }
 }
 
 Error HttpFsNode::ReadResponseToTemp(const ScopedResource& loader,
                                      int count,
                                      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;
 
     if (bytes_read == 0)
       return 0;
 
     bytes_left -= bytes_read;
     *out_bytes += bytes_read;
   }
 
@@ skipping 31 matching lines @@
     assert(bytes_read <= bytes_to_read);
     bytes_to_read -= bytes_read;
     out_buffer += bytes_read;
   }
 
   *out_bytes = count;
   return 0;
 }
 
 }  // namespace nacl_io