Commit e93710a4 authored by sbc@chromium.org's avatar sbc@chromium.org

[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
parent 04f968ff
......@@ -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;
}
......
......@@ -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)
......
......@@ -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;
......
......@@ -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_;
......
......@@ -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_.resize(new_size);
stat_.st_size = 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);
}
stat_.st_size = new_length;
return 0;
}
} // namespace nacl_io
......@@ -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;
};
......
......@@ -34,4 +34,10 @@
#endif
#if !defined(__native_client__)
#define PRIoff "ld"
#else
#define PRIoff "lld"
#endif
#endif /* NACL_IO_OSINTTYPES_H_ */
......@@ -8,7 +8,6 @@
#include <string.h>
#include <list>
#include <vector>
#include "nacl_io/fifo_interface.h"
#include "ppapi/c/pp_resource.h"
......
......@@ -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_))
......
......@@ -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_; }
......
......@@ -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,
......
......@@ -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_;
};
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment