Repository: nodejs/node
Pull request: src: improve error handling in string_bytes/decoder

Replace ToLocalChecked uses

<!--
Before submitting a pull request, please read:

- the CONTRIBUTING guide at https://github.com/nodejs/node/blob/HEAD/CONTRIBUTING.md
- the commit message formatting guidelines at
  https://github.com/nodejs/node/blob/HEAD/doc/contributing/pull-requests.md#commit-message-guidelines

For code changes:
1. Include tests for any bug fixes or new features.
2. Update documentation if relevant.
3. Ensure that `make -j4 test` (UNIX), or `vcbuild test` (Windows) passes.

If you believe this PR should be highlighted in the Node.js CHANGELOG
please add the `notable-change` label.

Developer's Certificate of Origin 1.1

By making a contribution to this project, I certify that:

(a) The contribution was created in whole or in part by me and I
    have the right to submit it under the open source license
    indicated in the file; or

(b) The contribution is based upon previous work that, to the best
    of my knowledge, is covered under an appropriate open source
    license and I have the right under that license to submit that
    work with modifications, whether created in whole or in part
    by me, under the same open source license (unless I am
    permitted to submit under a different license), as indicated
    in the file; or

(c) The contribution was provided directly to me by some other
    person who certified (a), (b) or (c) and I have not modified
    it.

(d) I understand and agree that this project and the contribution
    are public and that a record of the contribution (including all
    personal information I submit with it, including my sign-off) is
    maintained indefinitely and may be redistributed consistent with
    this project or the open source license(s) involved.
-->


Changed files:
filename: src/string_bytes.cc
patch: @@ -112,16 +112,17 @@ class ExternString: public ResourceType {
     ExternString* h_str = new ExternString<ResourceType, TypeName>(isolate,
                                                                    data,
                                                                    length);
-    MaybeLocal<Value> str = NewExternal(isolate, h_str);
-    isolate->AdjustAmountOfExternalAllocatedMemory(h_str->byte_length());
+    Local<Value> str;
 
-    if (str.IsEmpty()) {
+    if (!NewExternal(isolate, h_str).ToLocal(&str)) {
       delete h_str;
       *error = node::ERR_STRING_TOO_LONG(isolate);
       return MaybeLocal<Value>();
     }
 
-    return str.ToLocalChecked();
+    isolate->AdjustAmountOfExternalAllocatedMemory(h_str->byte_length());
+
+    return str;
   }
 
   inline Isolate* isolate() const { return isolate_; }
@@ -168,16 +169,16 @@ MaybeLocal<Value> ExternOneByteString::NewSimpleFromCopy(Isolate* isolate,
                                                          const char* data,
                                                          size_t length,
                                                          Local<Value>* error) {
-  MaybeLocal<String> str =
-      String::NewFromOneByte(isolate,
-                             reinterpret_cast<const uint8_t*>(data),
-                             v8::NewStringType::kNormal,
-                             length);
-  if (str.IsEmpty()) {
+  Local<String> str;
+  if (!String::NewFromOneByte(isolate,
+                              reinterpret_cast<const uint8_t*>(data),
+                              v8::NewStringType::kNormal,
+                              length)
+           .ToLocal(&str)) {
     *error = node::ERR_STRING_TOO_LONG(isolate);
     return MaybeLocal<Value>();
   }
-  return str.ToLocalChecked();
+  return str;
 }
 
 
@@ -186,16 +187,13 @@ MaybeLocal<Value> ExternTwoByteString::NewSimpleFromCopy(Isolate* isolate,
                                                          const uint16_t* data,
                                                          size_t length,
                                                          Local<Value>* error) {
-  MaybeLocal<String> str =
-      String::NewFromTwoByte(isolate,
-                             data,
-                             v8::NewStringType::kNormal,
-                             length);
-  if (str.IsEmpty()) {
+  Local<String> str;
+  if (!String::NewFromTwoByte(isolate, data, v8::NewStringType::kNormal, length)
+           .ToLocal(&str)) {
     *error = node::ERR_STRING_TOO_LONG(isolate);
     return MaybeLocal<Value>();
   }
-  return str.ToLocalChecked();
+  return str;
 }
 
 }  // anonymous namespace

filename: src/string_decoder.cc
patch: @@ -272,19 +272,21 @@ void DecodeData(const FunctionCallbackInfo<Value>& args) {
   ArrayBufferViewContents<char> content(args[1].As<ArrayBufferView>());
   size_t length = content.length();
 
-  MaybeLocal<String> ret =
-      decoder->DecodeData(args.GetIsolate(), content.data(), &length);
-  if (!ret.IsEmpty())
-    args.GetReturnValue().Set(ret.ToLocalChecked());
+  Local<String> ret;
+  if (decoder->DecodeData(args.GetIsolate(), content.data(), &length)
+          .ToLocal(&ret)) {
+    args.GetReturnValue().Set(ret);
+  }
 }
 
 void FlushData(const FunctionCallbackInfo<Value>& args) {
   StringDecoder* decoder =
       reinterpret_cast<StringDecoder*>(Buffer::Data(args[0]));
   CHECK_NOT_NULL(decoder);
-  MaybeLocal<String> ret = decoder->FlushData(args.GetIsolate());
-  if (!ret.IsEmpty())
-    args.GetReturnValue().Set(ret.ToLocalChecked());
+  Local<String> ret;
+  if (decoder->FlushData(args.GetIsolate()).ToLocal(&ret)) {
+    args.GetReturnValue().Set(ret);
+  }
 }
 
 void InitializeStringDecoder(Local<Object> target,