buffer: switch API to return MaybeLocal<T>

Instead of aborting in case of internal failure, return an empty
Local<Object>. Using the MaybeLocal<T> API, users must check their
return values.

PR-URL: https://github.com/nodejs/io.js/pull/1825
Reviewed-By: Ben Noordhuis <info@bnoordhuis.nl>

src/js_stream.cc

@@ -88,8 +88,11 @@ int JSStream::DoWrite(WriteWrap* w,
   HandleScope scope(env()->isolate());
 
   Local<Array> bufs_arr = Array::New(env()->isolate(), count);
-  for (size_t i = 0; i < count; i++)
+  Local<Object> buf;
-    bufs_arr->Set(i, Buffer::New(env(), bufs[i].base, bufs[i].len));
+  for (size_t i = 0; i < count; i++) {
+    buf = Buffer::New(env(), bufs[i].base, bufs[i].len).ToLocalChecked();
+    bufs_arr->Set(i, buf);
+  }
 
   Local<Value> argv[] = {
     w->object(),
@@ -134,11 +137,13 @@ void JSStream::DoAlloc(const FunctionCallbackInfo<Value>& args) {
 
   uv_buf_t buf;
   wrap->OnAlloc(args[0]->Int32Value(), &buf);
-  args.GetReturnValue().Set(Buffer::New(wrap->env(),
+  Local<Object> vbuf = Buffer::New(
-                                        buf.base,
+      wrap->env(),
-                                        buf.len,
+      buf.base,
-                                        FreeCallback,
+      buf.len,
-                                        nullptr));
+      FreeCallback,
+      nullptr).ToLocalChecked();
+  return args.GetReturnValue().Set(vbuf);
 }
 
 

src/node_buffer.cc

@@ -74,6 +74,7 @@ using v8::HandleScope;
 using v8::Isolate;
 using v8::Local;
 using v8::Maybe;
+using v8::MaybeLocal;
 using v8::Number;
 using v8::Object;
 using v8::Persistent;
@@ -234,7 +235,9 @@ size_t Length(Handle<Object> obj) {
 }
 
 
-Local<Object> New(Isolate* isolate, Handle<String> string, enum encoding enc) {
+MaybeLocal<Object> New(Isolate* isolate,
+                       Local<String> string,
+                       enum encoding enc) {
   EscapableHandleScope scope(isolate);
 
   size_t length = StringBytes::Size(isolate, string, enc);
@@ -251,19 +254,26 @@ Local<Object> New(Isolate* isolate, Handle<String> string, enum encoding enc) {
     CHECK_NE(data, nullptr);
   }
 
-  Local<Object> buf = Use(isolate, data, actual);
+  Local<Object> buf;
-  return scope.Escape(buf);
+  if (Use(isolate, data, actual).ToLocal(&buf))
+    return scope.Escape(buf);
+
+  // Object failed to be created. Clean up resources.
+  free(data);
+  return Local<Object>();
 }
 
 
-Local<Object> New(Isolate* isolate, size_t length) {
+MaybeLocal<Object> New(Isolate* isolate, size_t length) {
   EscapableHandleScope handle_scope(isolate);
-  Local<Object> obj = Buffer::New(Environment::GetCurrent(isolate), length);
+  Local<Object> obj;
-  return handle_scope.Escape(obj);
+  if (Buffer::New(Environment::GetCurrent(isolate), length).ToLocal(&obj))
+    return handle_scope.Escape(obj);
+  return Local<Object>();
 }
 
 
-Local<Object> New(Environment* env, size_t length) {
+MaybeLocal<Object> New(Environment* env, size_t length) {
   EscapableHandleScope scope(env->isolate());
 
   if (using_old_buffer) {
@@ -286,13 +296,12 @@ Local<Object> New(Environment* env, size_t length) {
   void* data;
   if (length > 0) {
     data = malloc(length);
-    // NOTE: API change. Must check .IsEmpty() on the return object to see if
-    // the data was able to be allocated.
     if (data == nullptr)
       return Local<Object>();
   } else {
     data = nullptr;
   }
+
   Local<ArrayBuffer> ab =
     ArrayBuffer::New(env->isolate(),
         data,
@@ -301,25 +310,27 @@ Local<Object> New(Environment* env, size_t length) {
   Local<Uint8Array> ui = Uint8Array::New(ab, 0, length);
   Maybe<bool> mb =
       ui->SetPrototype(env->context(), env->buffer_prototype_object());
-  if (!mb.FromMaybe(false)) {
+  if (mb.FromMaybe(false))
-    FatalError("node::Buffer::New(Environment*, size_t)",
+    return scope.Escape(ui);
-               "Could not set Object prototype");
+
-    UNREACHABLE();
+  // Object failed to be created. Clean up resources.
-  }
+  free(data);
-  return scope.Escape(ui);
+  return Local<Object>();
 }
 
 
-Local<Object> New(Isolate* isolate, const char* data, size_t length) {
+MaybeLocal<Object> New(Isolate* isolate, const char* data, size_t length) {
   Environment* env = Environment::GetCurrent(isolate);
   EscapableHandleScope handle_scope(env->isolate());
-  Local<Object> obj = Buffer::New(env, data, length);
+  Local<Object> obj;
-  return handle_scope.Escape(obj);
+  if (Buffer::New(env, data, length).ToLocal(&obj))
+    return handle_scope.Escape(obj);
+  return Local<Object>();
 }
 
 
 // Make a copy of "data". Why this isn't called "Copy", we'll never know.
-Local<Object> New(Environment* env, const char* data, size_t length) {
+MaybeLocal<Object> New(Environment* env, const char* data, size_t length) {
   EscapableHandleScope scope(env->isolate());
 
   if (using_old_buffer) {
@@ -353,8 +364,6 @@ Local<Object> New(Environment* env, const char* data, size_t length) {
   if (length > 0) {
     CHECK_NE(data, nullptr);
     new_data = malloc(length);
-    // NOTE: API change. Must check .IsEmpty() on the return object to see if
-    // the data was able to be allocated.
     if (new_data == nullptr)
       return Local<Object>();
     memcpy(new_data, data, length);
@@ -370,33 +379,34 @@ Local<Object> New(Environment* env, const char* data, size_t length) {
   Local<Uint8Array> ui = Uint8Array::New(ab, 0, length);
   Maybe<bool> mb =
       ui->SetPrototype(env->context(), env->buffer_prototype_object());
-  if (!mb.FromMaybe(false)) {
+  if (mb.FromMaybe(false))
-    FatalError("node::Buffer::New(Environment*, char*, size_t)",
+    return scope.Escape(ui);
-               "Could not set Object prototype");
-    UNREACHABLE();
-  }
 
-  return scope.Escape(ui);
+  // Object failed to be created. Clean up resources.
+  free(new_data);
+  return Local<Object>();
 }
 
 
-Local<Object> New(Isolate* isolate,
+MaybeLocal<Object> New(Isolate* isolate,
-                  char* data,
+                       char* data,
-                  size_t length,
+                       size_t length,
-                  FreeCallback callback,
+                       FreeCallback callback,
-                  void* hint) {
+                       void* hint) {
   Environment* env = Environment::GetCurrent(isolate);
   EscapableHandleScope handle_scope(env->isolate());
-  Local<Object> obj = Buffer::New(env, data, length, callback, hint);
+  Local<Object> obj;
-  return handle_scope.Escape(obj);
+  if (Buffer::New(env, data, length, callback, hint).ToLocal(&obj))
+    return handle_scope.Escape(obj);
+  return Local<Object>();
 }
 
 
-Local<Object> New(Environment* env,
+MaybeLocal<Object> New(Environment* env,
-                  char* data,
+                       char* data,
-                  size_t length,
+                       size_t length,
-                  FreeCallback callback,
+                       FreeCallback callback,
-                  void* hint) {
+                       void* hint) {
   EscapableHandleScope scope(env->isolate());
 
   if (using_old_buffer) {
@@ -416,26 +426,26 @@ Local<Object> New(Environment* env,
   Local<Uint8Array> ui = Uint8Array::New(ab, 0, length);
   Maybe<bool> mb =
       ui->SetPrototype(env->context(), env->buffer_prototype_object());
-  if (!mb.FromMaybe(false)) {
+
-    FatalError("node::Buffer::New(Environment*, char*, size_t,"
+  if (!mb.FromMaybe(false))
-               " FreeCallback, void*)",
+    return Local<Object>();
-               "Could not set Object prototype");
+
-    UNREACHABLE();
-  }
   CallbackInfo::New(env->isolate(), ui, callback, hint);
   return scope.Escape(ui);
 }
 
 
-Local<Object> Use(Isolate* isolate, char* data, size_t length) {
+MaybeLocal<Object> Use(Isolate* isolate, char* data, size_t length) {
   Environment* env = Environment::GetCurrent(isolate);
   EscapableHandleScope handle_scope(env->isolate());
-  Local<Object> obj = Buffer::Use(env, data, length);
+  Local<Object> obj;
-  return handle_scope.Escape(obj);
+  if (Buffer::Use(env, data, length).ToLocal(&obj))
+    return handle_scope.Escape(obj);
+  return Local<Object>();
 }
 
 
-Local<Object> Use(Environment* env, char* data, size_t length) {
+MaybeLocal<Object> Use(Environment* env, char* data, size_t length) {
   EscapableHandleScope scope(env->isolate());
 
   if (using_old_buffer) {
@@ -463,12 +473,9 @@ Local<Object> Use(Environment* env, char* data, size_t length) {
   Local<Uint8Array> ui = Uint8Array::New(ab, 0, length);
   Maybe<bool> mb =
       ui->SetPrototype(env->context(), env->buffer_prototype_object());
-  if (!mb.FromMaybe(false)) {
+  if (mb.FromMaybe(false))
-    FatalError("node::Buffer::Use(Environment*, char*, size_t)",
+    return scope.Escape(ui);
-               "Could not set Object prototype");
+  return Local<Object>();
-    UNREACHABLE();
-  }
-  return scope.Escape(ui);
 }
 
 
@@ -501,8 +508,9 @@ void Create(const FunctionCallbackInfo<Value>& args) {
   Local<Uint8Array> ui = Uint8Array::New(ab, 0, length);
   Maybe<bool> mb =
       ui->SetPrototype(env->context(), env->buffer_prototype_object());
-  if (mb.FromMaybe(false))
+  if (!mb.FromMaybe(false))
-    args.GetReturnValue().Set(ui);
+    return env->ThrowError("Unable to set Object prototype");
+  args.GetReturnValue().Set(ui);
 }
 
 
@@ -513,8 +521,9 @@ void CreateFromString(const FunctionCallbackInfo<Value>& args) {
   enum encoding enc = ParseEncoding(args.GetIsolate(),
                                     args[1].As<String>(),
                                     UTF8);
-  Local<Object> buf = New(args.GetIsolate(), args[0].As<String>(), enc);
+  Local<Object> buf;
-  args.GetReturnValue().Set(buf);
+  if (New(args.GetIsolate(), args[0].As<String>(), enc).ToLocal(&buf))
+    args.GetReturnValue().Set(buf);
 }
 
 
@@ -535,8 +544,9 @@ void Slice(const FunctionCallbackInfo<Value>& args) {
   Local<Uint8Array> ui = Uint8Array::New(ab, start, size);
   Maybe<bool> mb =
       ui->SetPrototype(env->context(), env->buffer_prototype_object());
-  if (mb.FromMaybe(false))
+  if (!mb.FromMaybe(false))
-    args.GetReturnValue().Set(ui);
+    env->ThrowError("Unable to set Object prototype");
+  args.GetReturnValue().Set(ui);
 }
 
 

src/node_buffer.h

@@ -24,50 +24,52 @@ NODE_EXTERN size_t Length(v8::Handle<v8::Value> val);
 NODE_EXTERN size_t Length(v8::Handle<v8::Object> val);
 
 // public constructor
-NODE_EXTERN v8::Local<v8::Object> New(v8::Isolate* isolate, size_t length);
+NODE_EXTERN v8::MaybeLocal<v8::Object> New(v8::Isolate* isolate, size_t length);
 NODE_DEPRECATED("Use New(isolate, ...)",
-                inline v8::Local<v8::Object> New(size_t length) {
+                inline v8::MaybeLocal<v8::Object> New(size_t length) {
   return New(v8::Isolate::GetCurrent(), length);
 })
 // public constructor from string
-NODE_EXTERN v8::Local<v8::Object> New(v8::Isolate* isolate,
+NODE_EXTERN v8::MaybeLocal<v8::Object> New(v8::Isolate* isolate,
-                                      v8::Handle<v8::String> string,
+                                           v8::Handle<v8::String> string,
-                                      enum encoding enc = UTF8);
+                                           enum encoding enc = UTF8);
 NODE_DEPRECATED("Use New(isolate, ...)",
-                inline v8::Local<v8::Object> New(v8::Handle<v8::String> string,
+                inline v8::MaybeLocal<v8::Object> New(
-                                                 enum encoding enc = UTF8) {
+                    v8::Handle<v8::String> string,
+                    enum encoding enc = UTF8) {
   return New(v8::Isolate::GetCurrent(), string, enc);
 })
 // public constructor - data is copied
 // TODO(trevnorris): should be something like Copy()
-NODE_EXTERN v8::Local<v8::Object> New(v8::Isolate* isolate,
+NODE_EXTERN v8::MaybeLocal<v8::Object> New(v8::Isolate* isolate,
-                                      const char* data,
+                                           const char* data,
-                                      size_t len);
+                                           size_t len);
 NODE_DEPRECATED("Use New(isolate, ...)",
-                inline v8::Local<v8::Object> New(const char* data, size_t len) {
+                inline v8::MaybeLocal<v8::Object> New(const char* data,
+                                                      size_t len) {
   return New(v8::Isolate::GetCurrent(), data, len);
 })
 // public constructor - data is used, callback is passed data on object gc
-NODE_EXTERN v8::Local<v8::Object> New(v8::Isolate* isolate,
+NODE_EXTERN v8::MaybeLocal<v8::Object> New(v8::Isolate* isolate,
-                                      char* data,
+                                           char* data,
-                                      size_t length,
+                                           size_t length,
-                                      FreeCallback callback,
+                                           FreeCallback callback,
-                                      void* hint);
+                                           void* hint);
 NODE_DEPRECATED("Use New(isolate, ...)",
-                inline v8::Local<v8::Object> New(char* data,
+                inline v8::MaybeLocal<v8::Object> New(char* data,
-                                                 size_t length,
+                                                      size_t length,
-                                                 FreeCallback callback,
+                                                      FreeCallback callback,
-                                                 void* hint) {
+                                                      void* hint) {
   return New(v8::Isolate::GetCurrent(), data, length, callback, hint);
 })
 
 // public constructor - data is used.
 // TODO(trevnorris): should be New() for consistency
-NODE_EXTERN v8::Local<v8::Object> Use(v8::Isolate* isolate,
+NODE_EXTERN v8::MaybeLocal<v8::Object> Use(v8::Isolate* isolate,
-                                      char* data,
+                                           char* data,
-                                      size_t len);
+                                           size_t len);
 NODE_DEPRECATED("Use Use(isolate, ...)",
-                inline v8::Local<v8::Object> Use(char* data, size_t len) {
+                inline v8::MaybeLocal<v8::Object> Use(char* data, size_t len) {
   return Use(v8::Isolate::GetCurrent(), data, len);
 })
 
@@ -90,14 +92,14 @@ static inline bool IsWithinBounds(size_t off, size_t len, size_t max) {
 // src/node_internals.h due to a circular dependency issue with
 // the smalloc.h and node_internals.h headers.
 #if defined(NODE_WANT_INTERNALS)
-v8::Local<v8::Object> New(Environment* env, size_t size);
+v8::MaybeLocal<v8::Object> New(Environment* env, size_t size);
-v8::Local<v8::Object> New(Environment* env, const char* data, size_t len);
+v8::MaybeLocal<v8::Object> New(Environment* env, const char* data, size_t len);
-v8::Local<v8::Object> New(Environment* env,
+v8::MaybeLocal<v8::Object> New(Environment* env,
-                          char* data,
+                               char* data,
-                          size_t length,
+                               size_t length,
-                          FreeCallback callback,
+                               FreeCallback callback,
-                          void* hint);
+                               void* hint);
-v8::Local<v8::Object> Use(Environment* env, char* data, size_t length);
+v8::MaybeLocal<v8::Object> Use(Environment* env, char* data, size_t length);
 #endif  // defined(NODE_WANT_INTERNALS)
 
 }  // namespace Buffer

src/node_crypto.cc

@@ -942,7 +942,7 @@ void SecureContext::GetTicketKeys(const FunctionCallbackInfo<Value>& args) {
 
   SecureContext* wrap = Unwrap<SecureContext>(args.Holder());
 
-  Local<Object> buff = Buffer::New(wrap->env(), 48);
+  Local<Object> buff = Buffer::New(wrap->env(), 48).ToLocalChecked();
   if (SSL_CTX_get_tlsext_ticket_keys(wrap->ctx_,
                                      Buffer::Data(buff),
                                      Buffer::Length(buff)) != 1) {
@@ -1006,7 +1006,7 @@ void SecureContext::GetCertificate(const FunctionCallbackInfo<Value>& args) {
     return args.GetReturnValue().Set(Null(env->isolate()));
 
   int size = i2d_X509(cert, nullptr);
-  Local<Object> buff = Buffer::New(env, size);
+  Local<Object> buff = Buffer::New(env, size).ToLocalChecked();
   unsigned char* serialized = reinterpret_cast<unsigned char*>(
       Buffer::Data(buff));
   i2d_X509(cert, &serialized);
@@ -1109,15 +1109,16 @@ int SSLWrap<Base>::NewSessionCallback(SSL* s, SSL_SESSION* sess) {
     return 0;
 
   // Serialize session
-  Local<Object> buff = Buffer::New(env, size);
+  Local<Object> buff = Buffer::New(env, size).ToLocalChecked();
   unsigned char* serialized = reinterpret_cast<unsigned char*>(
       Buffer::Data(buff));
   memset(serialized, 0, size);
   i2d_SSL_SESSION(sess, &serialized);
 
-  Local<Object> session = Buffer::New(env,
+  Local<Object> session = Buffer::New(
-                                      reinterpret_cast<char*>(sess->session_id),
+      env,
-                                      sess->session_id_length);
+      reinterpret_cast<char*>(sess->session_id),
+      sess->session_id_length).ToLocalChecked();
   Local<Value> argv[] = { session, buff };
   w->new_session_wait_ = true;
   w->MakeCallback(env->onnewsession_string(), ARRAY_SIZE(argv), argv);
@@ -1138,7 +1139,7 @@ void SSLWrap<Base>::OnClientHello(void* arg,
   Local<Object> buff = Buffer::New(
       env,
       reinterpret_cast<const char*>(hello.session_id()),
-      hello.session_size());
+      hello.session_size()).ToLocalChecked();
   hello_obj->Set(env->session_id_string(), buff);
   if (hello.servername() == nullptr) {
     hello_obj->Set(env->servername_string(), String::Empty(env->isolate()));
@@ -1349,7 +1350,7 @@ static Local<Object> X509ToObject(Environment* env, X509* cert) {
 
   // Raw DER certificate
   int size = i2d_X509(cert, nullptr);
-  Local<Object> buff = Buffer::New(env, size);
+  Local<Object> buff = Buffer::New(env, size).ToLocalChecked();
   unsigned char* serialized = reinterpret_cast<unsigned char*>(
       Buffer::Data(buff));
   i2d_X509(cert, &serialized);
@@ -1596,11 +1597,12 @@ void SSLWrap<Base>::GetTLSTicket(const FunctionCallbackInfo<Value>& args) {
   if (sess == nullptr || sess->tlsext_tick == nullptr)
     return;
 
-  Local<Object> buf = Buffer::New(env,
+  Local<Object> buff = Buffer::New(
-                                  reinterpret_cast<char*>(sess->tlsext_tick),
+      env,
-                                  sess->tlsext_ticklen);
+      reinterpret_cast<char*>(sess->tlsext_tick),
+      sess->tlsext_ticklen).ToLocalChecked();
 
-  args.GetReturnValue().Set(buf);
+  args.GetReturnValue().Set(buff);
 }
 
 
@@ -1880,7 +1882,7 @@ int SSLWrap<Base>::TLSExtStatusCallback(SSL* s, void* arg) {
       arg = Buffer::New(
           env,
           reinterpret_cast<char*>(const_cast<unsigned char*>(resp)),
-          len);
+          len).ToLocalChecked();
     }
 
     w->MakeCallback(env->onocspresponse_string(), 1, &arg);
@@ -2897,7 +2899,7 @@ void CipherBase::GetAuthTag(const FunctionCallbackInfo<Value>& args) {
   unsigned int out_len = 0;
 
   if (cipher->GetAuthTag(&out, &out_len)) {
-    Local<Object> buf = Buffer::Use(env, out, out_len);
+    Local<Object> buf = Buffer::Use(env, out, out_len).ToLocalChecked();
     args.GetReturnValue().Set(buf);
   } else {
     env->ThrowError("Attempting to get auth tag in unsupported state");
@@ -3014,7 +3016,8 @@ void CipherBase::Update(const FunctionCallbackInfo<Value>& args) {
                             "Trying to add data in unsupported state");
   }
 
-  Local<Object> buf = Buffer::New(env, reinterpret_cast<char*>(out), out_len);
+  Local<Object> buf =
+      Buffer::New(env, reinterpret_cast<char*>(out), out_len).ToLocalChecked();
   if (out)
     delete[] out;
 
@@ -3089,8 +3092,11 @@ void CipherBase::Final(const FunctionCallbackInfo<Value>& args) {
     }
   }
 
-  args.GetReturnValue().Set(
+  Local<Object> buf = Buffer::New(
-      Buffer::New(env, reinterpret_cast<char*>(out_value), out_len));
+      env,
+      reinterpret_cast<char*>(out_value),
+      out_len).ToLocalChecked();
+  args.GetReturnValue().Set(buf);
   delete[] out_value;
 }
 
@@ -3868,8 +3874,11 @@ void PublicKeyCipher::Cipher(const FunctionCallbackInfo<Value>& args) {
     }
   }
 
-  args.GetReturnValue().Set(
+  Local<Object> vbuf = Buffer::New(
-      Buffer::New(env, reinterpret_cast<char*>(out_value), out_len));
+      env,
+      reinterpret_cast<char*>(out_value),
+      out_len).ToLocalChecked();
+  args.GetReturnValue().Set(vbuf);
   delete[] out_value;
 }
 
@@ -4364,7 +4373,8 @@ void ECDH::ComputeSecret(const FunctionCallbackInfo<Value>& args) {
     return env->ThrowError("Failed to compute ECDH key");
   }
 
-  args.GetReturnValue().Set(Buffer::Use(env, out, out_len));
+  Local<Object> buf = Buffer::Use(env, out, out_len).ToLocalChecked();
+  args.GetReturnValue().Set(buf);
 }
 
 
@@ -4400,9 +4410,9 @@ void ECDH::GetPublicKey(const FunctionCallbackInfo<Value>& args) {
     return env->ThrowError("Failed to get public key");
   }
 
-  args.GetReturnValue().Set(Buffer::Use(env,
+  Local<Object> buf =
-                                        reinterpret_cast<char*>(out),
+      Buffer::Use(env, reinterpret_cast<char*>(out), size).ToLocalChecked();
-                                        size));
+  args.GetReturnValue().Set(buf);
 }
 
 
@@ -4427,9 +4437,9 @@ void ECDH::GetPrivateKey(const FunctionCallbackInfo<Value>& args) {
     return env->ThrowError("Failed to convert ECDH private key to Buffer");
   }
 
-  args.GetReturnValue().Set(Buffer::Use(env,
+  Local<Object> buf =
-                                        reinterpret_cast<char*>(out),
+      Buffer::Use(env, reinterpret_cast<char*>(out), size).ToLocalChecked();
-                                        size));
+  args.GetReturnValue().Set(buf);
 }
 
 
@@ -4831,7 +4841,7 @@ void RandomBytesCheck(RandomBytesRequest* req, Local<Value> argv[2]) {
     size_t size;
     req->return_memory(&data, &size);
     argv[0] = Null(req->env()->isolate());
-    argv[1] = Buffer::Use(req->env()->isolate(), data, size);
+    argv[1] = Buffer::Use(req->env(), data, size).ToLocalChecked();
   }
 }
 

src/spawn_sync.cc

@@ -167,7 +167,7 @@ void SyncProcessStdioPipe::Close() {
 
 Local<Object> SyncProcessStdioPipe::GetOutputAsBuffer(Environment* env) const {
   size_t length = OutputLength();
-  Local<Object> js_buffer = Buffer::New(env, length);
+  Local<Object> js_buffer = Buffer::New(env, length).ToLocalChecked();
   CopyOutput(Buffer::Data(js_buffer));
   return js_buffer;
 }

src/stream_wrap.cc

@@ -223,7 +223,8 @@ void StreamWrap::OnReadImpl(ssize_t nread,
     CHECK_EQ(pending, UV_UNKNOWN_HANDLE);
   }
 
-  wrap->EmitData(nread, Buffer::Use(env, base, nread), pending_obj);
+  Local<Object> obj = Buffer::Use(env, base, nread).ToLocalChecked();
+  wrap->EmitData(nread, obj, pending_obj);
 }
 
 

src/string_bytes.cc

@@ -19,6 +19,7 @@ using v8::Handle;
 using v8::HandleScope;
 using v8::Isolate;
 using v8::Local;
+using v8::Object;
 using v8::String;
 using v8::Value;
 
@@ -702,7 +703,10 @@ Local<Value> StringBytes::Encode(Isolate* isolate,
   Local<String> val;
   switch (encoding) {
     case BUFFER:
-      return scope.Escape(Buffer::New(isolate, buf, buflen));
+      {
+        Local<Object> vbuf = Buffer::New(isolate, buf, buflen).ToLocalChecked();
+        return scope.Escape(vbuf);
+      }
 
     case ASCII:
       if (contains_non_ascii(buf, buflen)) {

src/tls_wrap.cc

@@ -660,7 +660,7 @@ void TLSWrap::OnReadSelf(ssize_t nread,
   TLSWrap* wrap = static_cast<TLSWrap*>(ctx);
   Local<Object> buf_obj;
   if (buf != nullptr)
-    buf_obj = Buffer::Use(wrap->env(), buf->base, buf->len);
+    buf_obj = Buffer::Use(wrap->env(), buf->base, buf->len).ToLocalChecked();
   wrap->EmitData(nread, buf_obj, Local<Object>());
 }
 

src/udp_wrap.cc

@@ -408,7 +408,7 @@ void UDPWrap::OnRecv(uv_udp_t* handle,
   }
 
   char* base = static_cast<char*>(realloc(buf->base, nread));
-  argv[2] = Buffer::Use(env, base, nread);
+  argv[2] = Buffer::Use(env, base, nread).ToLocalChecked();
   argv[3] = AddressToJS(env, addr);
   wrap->MakeCallback(env->onmessage_string(), ARRAY_SIZE(argv), argv);
 }