@@ -888,19 +888,18 @@ void NodeAresTask::MemoryInfo(MemoryTracker* tracker) const {
 
 /* Allocates and returns a new NodeAresTask */
 NodeAresTask* NodeAresTask::Create(ChannelWrap* channel, ares_socket_t sock) {
-  auto task = new NodeAresTask();
+  auto task = std::make_unique<NodeAresTask>();
 
   task->channel = channel;
   task->sock = sock;
 
   if (uv_poll_init_socket(channel->env()->event_loop(),
                           &task->poll_watcher, sock) < 0) {
     /* This should never happen. */
-    delete task;
     return nullptr;
   }
 
-  return task;
+  return task.release();
 }
 
 void ChannelWrap::Setup() {
 
@@ -177,28 +177,27 @@ void CompileCacheHandler::ReadCacheFile(CompileCacheEntry* entry) {
   size_t offset = headers_buf.len;
   size_t capacity = 4096;  // Initial buffer capacity
   size_t total_read = 0;
-  uint8_t* buffer = new uint8_t[capacity];
+  auto buffer = std::make_unique<uint8_t[]>(capacity);
 
   while (true) {
     // If there is not enough space to read more data, do a simple
     // realloc here (we don't actually realloc because V8 requires
     // the underlying buffer to be delete[]-able).
     if (total_read == capacity) {
       size_t new_capacity = capacity * 2;
-      auto* new_buffer = new uint8_t[new_capacity];
-      memcpy(new_buffer, buffer, capacity);
-      delete[] buffer;
-      buffer = new_buffer;
+      auto new_buffer = std::make_unique<uint8_t[]>(new_capacity);
+      memcpy(new_buffer.get(), buffer.get(), capacity);
+      buffer = std::move(new_buffer);
       capacity = new_capacity;
     }
 
-    uv_buf_t iov = uv_buf_init(reinterpret_cast<char*>(buffer + total_read),
-                               capacity - total_read);
+    uv_buf_t iov =
+        uv_buf_init(reinterpret_cast<char*>(buffer.get() + total_read),
+                    capacity - total_read);
     int bytes_read =
         uv_fs_read(nullptr, &req, file, &iov, 1, offset + total_read, nullptr);
     if (req.result < 0) {  // Error.
       // req will be cleaned up by scope leave.
-      delete[] buffer;
       Debug(" %s\n", uv_strerror(req.result));
       return;
     }
@@ -216,7 +215,8 @@ void CompileCacheHandler::ReadCacheFile(CompileCacheEntry* entry) {
           total_read);
     return;
   }
-  uint32_t cache_hash = GetHash(reinterpret_cast<char*>(buffer), total_read);
+  uint32_t cache_hash =
+      GetHash(reinterpret_cast<char*>(buffer.get()), total_read);
   if (headers[kCacheHashOffset] != cache_hash) {
     Debug("cache hash mismatch: expected %d, actual %d\n",
           headers[kCacheHashOffset],
@@ -225,7 +225,7 @@ void CompileCacheHandler::ReadCacheFile(CompileCacheEntry* entry) {
   }
 
   entry->cache.reset(new ScriptCompiler::CachedData(
-      buffer, total_read, ScriptCompiler::CachedData::BufferOwned));
+      buffer.release(), total_read, ScriptCompiler::CachedData::BufferOwned));
   Debug(" success, size=%d\n", total_read);
 }
 
 
@@ -99,7 +99,7 @@ int NodeBIO::Read(BIO* bio, char* out, int len) {
 
 char* NodeBIO::Peek(size_t* size) {
   *size = read_head_->write_pos_ - read_head_->read_pos_;
-  return read_head_->data_ + read_head_->read_pos_;
+  return read_head_->data_.get() + read_head_->read_pos_;
 }
 
 
@@ -112,7 +112,7 @@ size_t NodeBIO::PeekMultiple(char** out, size_t* size, size_t* count) {
   for (i = 0; i < max; i++) {
     size[i] = pos->write_pos_ - pos->read_pos_;
     total += size[i];
-    out[i] = pos->data_ + pos->read_pos_;
+    out[i] = pos->data_.get() + pos->read_pos_;
 
     /* Don't get past write head */
     if (pos == write_head_)
@@ -274,7 +274,8 @@ size_t NodeBIO::Read(char* out, size_t size) {
 
     // Copy data
     if (out != nullptr)
-      memcpy(out + offset, read_head_->data_ + read_head_->read_pos_, avail);
+      memcpy(
+          out + offset, read_head_->data_.get() + read_head_->read_pos_, avail);
     read_head_->read_pos_ += avail;
 
     // Move pointers
@@ -330,7 +331,7 @@ size_t NodeBIO::IndexOf(char delim, size_t limit) {
       avail = left;
 
     // Walk through data
-    char* tmp = current->data_ + current->read_pos_;
+    char* tmp = current->data_.get() + current->read_pos_;
     size_t off = 0;
     while (off < avail && *tmp != delim) {
       off++;
@@ -373,7 +374,7 @@ void NodeBIO::Write(const char* data, size_t size) {
       to_write = avail;
 
     // Copy data
-    memcpy(write_head_->data_ + write_head_->write_pos_,
+    memcpy(write_head_->data_.get() + write_head_->write_pos_,
            data + offset,
            to_write);
 
@@ -406,7 +407,7 @@ char* NodeBIO::PeekWritable(size_t* size) {
   if (*size == 0 || available <= *size)
     *size = available;
 
-  return write_head_->data_ + write_head_->write_pos_;
+  return write_head_->data_.get() + write_head_->write_pos_;
 }
 
 
 
@@ -150,19 +150,19 @@ class NodeBIO : public MemoryRetainer {
 
   class Buffer {
    public:
-    Buffer(Environment* env, size_t len) : env_(env),
-                                           read_pos_(0),
-                                           write_pos_(0),
-                                           len_(len),
-                                           next_(nullptr) {
-      data_ = new char[len];
+    Buffer(Environment* env, size_t len)
+        : env_(env),
+          read_pos_(0),
+          write_pos_(0),
+          len_(len),
+          next_(nullptr),
+          data_(new char[len]) {
       if (env_ != nullptr) {
         env_->external_memory_accounter()->Increase(env_->isolate(), len);
       }
     }
 
     ~Buffer() {
-      delete[] data_;
       if (env_ != nullptr) {
         env_->external_memory_accounter()->Decrease(env_->isolate(), len_);
       }
@@ -173,7 +173,7 @@ class NodeBIO : public MemoryRetainer {
     size_t write_pos_;
     size_t len_;
     Buffer* next_;
-    char* data_;
+    std::unique_ptr<char[]> data_;
   };
 
   Environment* env_ = nullptr;