src: add v8 fast api for url canParse

PR-URL: https://github.com/nodejs/node/pull/47552
Reviewed-By: Yagiz Nizipli <yagiz@nizipli.com>
Reviewed-By: Mohammed Keyvanzadeh <mohammadkeyvanzade94@gmail.com>

src/node_external_reference.h

@@ -19,6 +19,8 @@ using CFunctionCallbackWithInt64 = void (*)(v8::Local<v8::Object> receiver,
                                             int64_t);
 using CFunctionCallbackWithBool = void (*)(v8::Local<v8::Object> receiver,
                                            bool);
+using CFunctionCallbackWithStrings =
+    bool (*)(v8::Local<v8::Value>, const v8::FastOneByteString& input);
 
 // This class manages the external references from the V8 heap
 // to the C++ addresses in Node.js.
@@ -32,6 +34,7 @@ class ExternalReferenceRegistry {
   V(CFunctionCallbackReturnDouble)                                             \
   V(CFunctionCallbackWithInt64)                                                \
   V(CFunctionCallbackWithBool)                                                 \
+  V(CFunctionCallbackWithStrings)                                              \
   V(const v8::CFunctionInfo*)                                                  \
   V(v8::FunctionCallback)                                                      \
   V(v8::AccessorGetterCallback)                                                \

src/node_url.cc

@@ -5,6 +5,7 @@
 #include "node_external_reference.h"
 #include "node_i18n.h"
 #include "util-inl.h"
+#include "v8-fast-api-calls.h"
 #include "v8.h"
 
 #include <cstdint>
@@ -14,7 +15,9 @@
 namespace node {
 namespace url {
 
+using v8::CFunction;
 using v8::Context;
+using v8::FastOneByteString;
 using v8::FunctionCallbackInfo;
 using v8::HandleScope;
 using v8::Isolate;
@@ -113,7 +116,6 @@ void BindingData::DomainToUnicode(const FunctionCallbackInfo<Value>& args) {
                                 .ToLocalChecked());
 }
 
-// TODO(@anonrig): Add V8 Fast API for CanParse method
 void BindingData::CanParse(const FunctionCallbackInfo<Value>& args) {
   CHECK_GE(args.Length(), 1);
   CHECK(args[0]->IsString());  // input
@@ -140,6 +142,17 @@ void BindingData::CanParse(const FunctionCallbackInfo<Value>& args) {
   args.GetReturnValue().Set(out.has_value());
 }
 
+bool BindingData::FastCanParse(Local<Value> receiver,
+                               const FastOneByteString& input) {
+  std::string_view input_view(input.data, input.length);
+
+  auto output = ada::parse<ada::url_aggregator>(input_view);
+
+  return output.has_value();
+}
+
+CFunction BindingData::fast_can_parse_(CFunction::Make(FastCanParse));
+
 void BindingData::Format(const FunctionCallbackInfo<Value>& args) {
   CHECK_GT(args.Length(), 4);
   CHECK(args[0]->IsString());  // url href
@@ -320,20 +333,23 @@ void BindingData::Initialize(Local<Object> target,
 
   SetMethodNoSideEffect(context, target, "domainToASCII", DomainToASCII);
   SetMethodNoSideEffect(context, target, "domainToUnicode", DomainToUnicode);
-  SetMethodNoSideEffect(context, target, "canParse", CanParse);
   SetMethodNoSideEffect(context, target, "format", Format);
   SetMethod(context, target, "parse", Parse);
   SetMethod(context, target, "update", Update);
+  SetFastMethodNoSideEffect(
+      context, target, "canParse", CanParse, &fast_can_parse_);
 }
 
 void BindingData::RegisterExternalReferences(
     ExternalReferenceRegistry* registry) {
   registry->Register(DomainToASCII);
   registry->Register(DomainToUnicode);
-  registry->Register(CanParse);
   registry->Register(Format);
   registry->Register(Parse);
   registry->Register(Update);
+  registry->Register(CanParse);
+  registry->Register(FastCanParse);
+  registry->Register(fast_can_parse_.GetTypeInfo());
 }
 
 std::string FromFilePath(const std::string_view file_path) {

src/node_url.h

@@ -9,6 +9,8 @@
 #include "node.h"
 #include "node_snapshotable.h"
 #include "util.h"
+#include "v8-fast-api-calls.h"
+#include "v8.h"
 
 #include <string>
 
@@ -47,6 +49,9 @@ class BindingData : public SnapshotableObject {
   static void DomainToUnicode(const v8::FunctionCallbackInfo<v8::Value>& args);
 
   static void CanParse(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static bool FastCanParse(v8::Local<v8::Value> receiver,
+                           const v8::FastOneByteString& input);
+
   static void Format(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void Parse(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void Update(const v8::FunctionCallbackInfo<v8::Value>& args);
@@ -63,6 +68,8 @@ class BindingData : public SnapshotableObject {
 
   void UpdateComponents(const ada::url_components& components,
                         const ada::scheme::type type);
+
+  static v8::CFunction fast_can_parse_;
 };
 
 std::string FromFilePath(const std::string_view file_path);

test/parallel/test-url-canParse-whatwg.js

@@ -10,3 +10,10 @@ assert.throws(() => {
   code: 'ERR_MISSING_ARGS',
   name: 'TypeError',
 });
+
+{
+  // This test is to ensure that the v8 fast api works.
+  for (let i = 0; i < 1e5; i++) {
+    assert(URL.canParse('https://www.example.com/path/?query=param#hash'));
+  }
+}