From 41f444fa78c6fbd99d25d844f789c5798cd8f307 Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Tue, 11 Feb 2025 08:40:02 -0800
Subject: [PATCH] src: improve error handling in string_bytes/decoder

PR-URL: https://github.com/nodejs/node/pull/56978
Reviewed-By: Yagiz Nizipli <yagiz@nizipli.com>
Reviewed-By: Chengzhong Wu <legendecas@gmail.com>
---
 src/string_bytes.cc   | 34 ++++++++++++++++------------------
 src/string_decoder.cc | 16 +++++++++-------
 2 files changed, 25 insertions(+), 25 deletions(-)

diff --git a/src/string_bytes.cc b/src/string_bytes.cc
index 8a94d0eb63245c..4324ed52d7cd6a 100644
--- a/src/string_bytes.cc
+++ b/src/string_bytes.cc
@@ -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
diff --git a/src/string_decoder.cc b/src/string_decoder.cc
index 5493bc1d9cc871..c7a6f5e8e58d24 100644
--- a/src/string_decoder.cc
+++ b/src/string_decoder.cc
@@ -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,