src: add V8 Fast API for URL.revokeObjectURL

co-authored-by: Nicholas Paun <npaun@cloudflare.com>

Author: dario-piotrowicz

src/node_blob.cc

@@ -5,13 +5,16 @@
 #include "env-inl.h"
 #include "memory_tracker-inl.h"
 #include "node_bob-inl.h"
+#include "node_debug.h"
 #include "node_errors.h"
 #include "node_external_reference.h"
 #include "node_file.h"
 #include "path.h"
 #include "permission/permission.h"
 #include "util.h"
+#include "v8-value.h"
 #include "v8.h"
+#include "v8-fast-api-calls.h"
 
 #include <algorithm>
 
@@ -39,6 +42,8 @@ using v8::String;
 using v8::Uint32;
 using v8::Undefined;
 using v8::Value;
+using v8::CFunction;
+using v8::FastApiCallbackOptions;
 
 namespace {
 
@@ -130,7 +135,7 @@ void Blob::CreatePerIsolateProperties(IsolateData* isolate_data,
   SetMethod(isolate, target, "createBlob", New);
   SetMethod(isolate, target, "storeDataObject", StoreDataObject);
   SetMethod(isolate, target, "getDataObject", GetDataObject);
-  SetMethod(isolate, target, "revokeObjectURL", RevokeObjectURL);
+  SetFastMethod(isolate, target, "revokeObjectURL", RevokeObjectURL, &fast_revoke_object_url_method);
   SetMethod(isolate, target, "concat", Concat);
   SetMethod(isolate, target, "createBlobFromFilePath", BlobFromFilePath);
 }
@@ -450,7 +455,6 @@ void Blob::StoreDataObject(const FunctionCallbackInfo<Value>& args) {
         std::string(*type, type.length())));
 }
 
-// TODO(@anonrig): Add V8 Fast API to the following function
 void Blob::RevokeObjectURL(const FunctionCallbackInfo<Value>& args) {
   CHECK_GE(args.Length(), 1);
   CHECK(args[0]->IsString());
@@ -477,6 +481,38 @@ void Blob::RevokeObjectURL(const FunctionCallbackInfo<Value>& args) {
   }
 }
 
+void Blob::FastRevokeObjectURL(
+  Local<Value> receiver,
+  Local<Value> raw_input, FastApiCallbackOptions& options) {
+  TRACK_V8_FAST_API_CALL("blob.revokeObjectURL");
+  CHECK(raw_input->IsString());
+
+  auto isolate = options.isolate;
+  HandleScope handleScope(isolate);
+  Realm* realm = Realm::GetCurrent(isolate->GetCurrentContext());
+  BlobBindingData* binding_data = realm->GetBindingData<BlobBindingData>();
+
+  Utf8Value input(isolate, raw_input.As<String>());
+  auto out = ada::parse<ada::url_aggregator>(input.ToStringView());
+
+  if (!out) {
+    return;
+  }
+
+  auto pathname = out->get_pathname();
+  auto start_index = pathname.find(':');
+
+  if (start_index != std::string_view::npos && start_index != pathname.size()) {
+    auto end_index = pathname.find(':', start_index + 1);
+    if (end_index == std::string_view::npos) {
+      auto id = std::string(pathname.substr(start_index + 1));
+      binding_data->revoke_data_object(id);
+    }
+  }
+}
+
+CFunction Blob::fast_revoke_object_url_method = CFunction::Make(Blob::FastRevokeObjectURL);
+
 void Blob::GetDataObject(const FunctionCallbackInfo<Value>& args) {
   CHECK(args[0]->IsString());
   Realm* realm = Realm::GetCurrent(args);
@@ -584,9 +620,11 @@ void Blob::RegisterExternalReferences(ExternalReferenceRegistry* registry) {
   registry->Register(Blob::StoreDataObject);
   registry->Register(Blob::GetDataObject);
   registry->Register(Blob::RevokeObjectURL);
+  registry->Register(Blob::FastRevokeObjectURL);
   registry->Register(Blob::Reader::Pull);
   registry->Register(Concat);
   registry->Register(BlobFromFilePath);
+  registry->Register(fast_revoke_object_url_method.GetTypeInfo());
 }
 
 }  // namespace node

src/node_blob.h

@@ -14,7 +14,7 @@
 #include "node_snapshotable.h"
 #include "node_worker.h"
 #include "v8.h"
-
+#include "v8-fast-api-calls.h"
 #include <string>
 #include <unordered_map>
 #include <vector>
@@ -39,6 +39,9 @@ class Blob : public BaseObject {
   static void StoreDataObject(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void GetDataObject(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void RevokeObjectURL(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void FastRevokeObjectURL(v8::Local<v8::Value> receiver, v8::Local<v8::Value> raw_input, v8::FastApiCallbackOptions& options);
+
+  static v8::CFunction fast_revoke_object_url_method;
 
   static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(
       Environment* env);

src/node_external_reference.h

@@ -46,6 +46,11 @@ using CFunctionCallbackWithInt64 = void (*)(v8::Local<v8::Object> unused,
 using CFunctionCallbackWithBool = void (*)(v8::Local<v8::Object> unused,
                                            v8::Local<v8::Object> receiver,
                                            bool);
+
+using CFunctionCallbackWithValue = void (*)(v8::Local<v8::Value>,
+                                            v8::Local<v8::Value>,
+                                            v8::FastApiCallbackOptions&);
+
 using CFunctionCallbackWithString =
     bool (*)(v8::Local<v8::Value>, const v8::FastOneByteString& input);
 using CFunctionCallbackWithStrings =
@@ -116,6 +121,7 @@ class ExternalReferenceRegistry {
   V(CFunctionCallbackWithBool)                                                 \
   V(CFunctionCallbackWithString)                                               \
   V(CFunctionCallbackWithStrings)                                              \
+  V(CFunctionCallbackWithValue)                                                \
   V(CFunctionCallbackWithTwoUint8Arrays)                                       \
   V(CFunctionCallbackWithUint8ArrayUint32Int64Bool)                            \
   V(CFunctionWithUint32)                                                       \

test/parallel/test-url-revokeobjecturl-fast.js

@@ -0,0 +1,26 @@
+// Flags: --expose-internals --allow-natives-syntax
+'use strict';
+const common = require('../common');
+const assert = require('node:assert');
+
+const { internalBinding } = require('internal/test/binding');
+
+const blob = new Blob([JSON.stringify({ hello: "world" }, null, 2)], {
+  type: "application/json",
+});
+
+function testFastPath() {
+  const objURL = URL.createObjectURL(blob);
+  URL.revokeObjectURL(objURL);
+}
+
+eval('%PrepareFunctionForOptimization(URL.revokeObjectURL)');
+testFastPath();
+
+eval('%OptimizeFunctionOnNextCall(URL.revokeObjectURL)');
+testFastPath();
+
+if (common.isDebug) {
+  const { getV8FastApiCallCount } = internalBinding('debug');
+  assert.strictEqual(getV8FastApiCallCount('blob.revokeObjectURL'), 1);
+}