src: rename EncodeKnownValidUTF8 to EncodeValidUtf8

Author: araujogui

src/encoding_binding.cc

@@ -459,21 +459,14 @@ 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::EncodeKnownValidUTF8(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 =
-      StringBytes::Encode(env->isolate(), data, length, UTF8);
+      has_fatal ? StringBytes::EncodeValidUtf8(env->isolate(), data, length)
+                : StringBytes::Encode(env->isolate(), data, length, UTF8);
   if (encoded.ToLocal(&ret)) {
     args.GetReturnValue().Set(ret);
   }

src/string_bytes.cc

@@ -539,9 +539,9 @@ Maybe<size_t> StringBytes::Size(Isolate* isolate,
 
 // Converts known-valid 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) {
+static MaybeLocal<Value> EncodeValidNonAsciiUtf8(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));
@@ -555,18 +555,6 @@ static MaybeLocal<Value> EncodeKnownValidNonAsciiUTF8(Isolate* isolate,
       });
 }
 
-MaybeLocal<Value> StringBytes::EncodeKnownValidUTF8(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,
@@ -616,7 +604,7 @@ MaybeLocal<Value> StringBytes::Encode(Isolate* isolate,
         // We know that we are non-ASCII (and are unlikely Latin1), use 2-byte
         // In the most likely case of valid UTF-8, we can use this fast impl
         // For very short input, it is slower, so we limit min size
-        return EncodeKnownValidNonAsciiUTF8(isolate, buf, buflen);
+        return EncodeValidNonAsciiUtf8(isolate, buf, buflen);
       }
 
       val =
@@ -719,4 +707,19 @@ MaybeLocal<Value> StringBytes::Encode(Isolate* isolate,
   return Encode(isolate, buf, len, encoding);
 }
 
+MaybeLocal<Value> StringBytes::EncodeValidUtf8(Isolate* isolate,
+                                               const char* buf,
+                                               size_t buflen) {
+  buflen = keep_buflen_in_range(buflen);
+  if (!simdutf::validate_ascii_with_errors(buf, buflen).error) {
+    return ExternOneByteString::NewFromCopy(isolate, buf, buflen);
+  }
+  if (buflen >= 32) return EncodeValidNonAsciiUtf8(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;
+}
+
 }  // namespace node

src/string_bytes.h

@@ -85,9 +85,9 @@ class StringBytes {
 
   // Like Encode(..., UTF8) but skips UTF-8 validation. Caller must guarantee
   // that buf contains valid UTF-8.
-  static v8::MaybeLocal<v8::Value> EncodeKnownValidUTF8(v8::Isolate* isolate,
-                                                        const char* buf,
-                                                        size_t buflen);
+  static v8::MaybeLocal<v8::Value> EncodeValidUtf8(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.