src: add EncodeValidatedUTF8 to avoid double validation

Signed-off-by: Guilherme Araújo <arauujogui@gmail.com>

Author: araujogui

src/encoding_binding.cc

@@ -471,14 +471,21 @@ void BindingData::DecodeUTF8(const FunctionCallbackInfo<Value>& args) {
       return node::THROW_ERR_ENCODING_INVALID_ENCODED_DATA(
           env->isolate(), "The encoded data was not valid for encoding utf-8");
     }
+
+    Local<Value> ret;
+    // Data is already validated as UTF-8 above; skip redundant re-validation.
+    if (StringBytes::EncodeValidatedUTF8(env->isolate(), data, length)
+            .ToLocal(&ret)) {
+      args.GetReturnValue().Set(ret);
+    }
+    return;
   }
 
   if (length == 0) return args.GetReturnValue().SetEmptyString();
 
   Local<Value> ret;
   v8::MaybeLocal<Value> encoded =
-      has_fatal ? StringBytes::EncodeValidUtf8(env->isolate(), data, length)
-                : StringBytes::Encode(env->isolate(), data, length, UTF8);
+      StringBytes::Encode(env->isolate(), data, length, UTF8);
   if (encoded.ToLocal(&ret)) {
     args.GetReturnValue().Set(ret);
   }

src/string_bytes.cc

@@ -537,6 +537,37 @@ Maybe<size_t> StringBytes::Size(Isolate* isolate,
     }                                                                          \
   } while (0)
 
+// Converts known-valid, known-non-ASCII UTF-8 (buflen >= 32) to a V8 string
+// via the fast UTF-16 path. Callers must ensure buflen is range-checked.
+static MaybeLocal<Value> EncodeKnownValidNonAsciiUTF8(Isolate* isolate,
+                                                       const char* buf,
+                                                       size_t buflen) {
+  size_t u16size = simdutf::utf16_length_from_utf8(buf, buflen);
+  if (u16size > static_cast<size_t>(v8::String::kMaxLength)) {
+    isolate->ThrowException(ERR_STRING_TOO_LONG(isolate));
+    return MaybeLocal<Value>();
+  }
+  return EncodeTwoByteString(
+      isolate, u16size, [buf, buflen, u16size](uint16_t* dst) {
+        size_t written = simdutf::convert_valid_utf8_to_utf16(
+            buf, buflen, reinterpret_cast<char16_t*>(dst));
+        CHECK_EQ(written, u16size);
+      });
+}
+
+MaybeLocal<Value> StringBytes::EncodeValidatedUTF8(Isolate* isolate,
+                                                    const char* buf,
+                                                    size_t buflen) {
+  buflen = keep_buflen_in_range(buflen);
+  if (buflen >= 32)
+    return EncodeKnownValidNonAsciiUTF8(isolate, buf, buflen);
+  Local<String> str;
+  if (!String::NewFromUtf8(isolate, buf, v8::NewStringType::kNormal, buflen)
+           .ToLocal(&str))
+    isolate->ThrowException(node::ERR_STRING_TOO_LONG(isolate));
+  return str;
+}
+
 MaybeLocal<Value> StringBytes::Encode(Isolate* isolate,
                                       const char* buf,
                                       size_t buflen,
@@ -650,17 +681,7 @@ MaybeLocal<Value> StringBytes::Encode(Isolate* isolate,
                                           static_cast<int>(r.count));
           }
         } else if (simdutf::validate_utf8(buf, buflen)) {
-          size_t u16size = simdutf::utf16_length_from_utf8(buf, buflen);
-          if (u16size > static_cast<size_t>(v8::String::kMaxLength)) {
-            isolate->ThrowException(ERR_STRING_TOO_LONG(isolate));
-            return MaybeLocal<Value>();
-          }
-          return EncodeTwoByteString(
-              isolate, u16size, [buf, buflen, u16size](uint16_t* dst) {
-                size_t written = simdutf::convert_valid_utf8_to_utf16(
-                    buf, buflen, reinterpret_cast<char16_t*>(dst));
-                CHECK_EQ(written, u16size);
-              });
+          return EncodeKnownValidNonAsciiUTF8(isolate, buf, buflen);
         }
       }
 
@@ -736,40 +757,6 @@ MaybeLocal<Value> StringBytes::Encode(Isolate* isolate,
   }
 }
 
-MaybeLocal<Value> StringBytes::EncodeValidUtf8(Isolate* isolate,
-                                               const char* buf,
-                                               size_t buflen) {
-  CHECK_BUFLEN_IN_RANGE(buflen);
-  if (!buflen) return String::Empty(isolate);
-  buflen = keep_buflen_in_range(buflen);
-
-  // ASCII fast path
-  if (!simdutf::validate_ascii_with_errors(buf, buflen).error) {
-    return ExternOneByteString::NewFromCopy(isolate, buf, buflen);
-  }
-
-  if (buflen >= 32) {
-    size_t u16size = simdutf::utf16_length_from_utf8(buf, buflen);
-    if (u16size > static_cast<size_t>(v8::String::kMaxLength)) {
-      isolate->ThrowException(ERR_STRING_TOO_LONG(isolate));
-      return MaybeLocal<Value>();
-    }
-    return EncodeTwoByteString(
-        isolate, u16size, [buf, buflen, u16size](uint16_t* dst) {
-          size_t written = simdutf::convert_valid_utf8_to_utf16(
-              buf, buflen, reinterpret_cast<char16_t*>(dst));
-          CHECK_EQ(written, u16size);
-        });
-  }
-
-  Local<String> str;
-  if (!String::NewFromUtf8(isolate, buf, v8::NewStringType::kNormal, buflen)
-           .ToLocal(&str)) {
-    isolate->ThrowException(node::ERR_STRING_TOO_LONG(isolate));
-  }
-  return str;
-}
-
 MaybeLocal<Value> StringBytes::Encode(Isolate* isolate,
                                       const uint16_t* buf,
                                       size_t buflen) {

src/string_bytes.h

@@ -83,10 +83,11 @@ class StringBytes {
                                           size_t buflen,
                                           enum encoding encoding);
 
-  // Like Encode(..., UTF8) but does not re-validate. Input must be valid UTF-8.
-  static v8::MaybeLocal<v8::Value> EncodeValidUtf8(v8::Isolate* isolate,
-                                                   const char* buf,
-                                                   size_t buflen);
+  // Like Encode(..., UTF8) but skips UTF-8 validation. Caller must guarantee
+  // that buf contains valid UTF-8.
+  static v8::MaybeLocal<v8::Value> EncodeValidatedUTF8(v8::Isolate* isolate,
+                                                        const char* buf,
+                                                        size_t buflen);
 
   // Warning: This reverses endianness on BE platforms, even though the
   // signature using uint16_t implies that it should not.