refactor native-stream-sink to extend from BuiltinNoConstructor class

Author: Jake Champion

c-dependencies/js-compute-runtime/builtins/native-stream-sink.cpp

@@ -12,68 +12,57 @@
 
 // A JS class to use as the underlying sink for native writable streams, used
 // for TransformStream.
-namespace NativeStreamSink {
-namespace Slots {
-enum {
-  Owner,          // TransformStream.
-  Controller,     // The WritableStreamDefaultController.
-  InternalWriter, // Only used to lock the stream if it's consumed internally.
-  StartPromise,   // Used as the return value of `start`, can be undefined.
-                  // Needed to properly implement TransformStream.
-  WriteAlgorithm,
-  AbortAlgorithm,
-  CloseAlgorithm,
-  // AbortAlgorithm, TODO: implement
-  Count
-};
-};
-
-JSObject *owner(JSObject *self) { return &JS::GetReservedSlot(self, Slots::Owner).toObject(); }
-
-JS::Value startPromise(JSObject *self) { return JS::GetReservedSlot(self, Slots::StartPromise); }
-
-WriteAlgorithm *writeAlgorithm(JSObject *self) {
-  return (WriteAlgorithm *)JS::GetReservedSlot(self, Slots::WriteAlgorithm).toPrivate();
+namespace builtins {
+
+JSObject *NativeStreamSink::owner(JSObject *self) {
+  return &JS::GetReservedSlot(self, Slots::Owner).toObject();
+}
+
+JS::Value NativeStreamSink::startPromise(JSObject *self) {
+  return JS::GetReservedSlot(self, Slots::StartPromise);
+}
+
+NativeStreamSink::WriteAlgorithmImplementation *NativeStreamSink::writeAlgorithm(JSObject *self) {
+  return (WriteAlgorithmImplementation *)JS::GetReservedSlot(self, Slots::WriteAlgorithm)
+      .toPrivate();
 }
 
-AbortAlgorithm *abortAlgorithm(JSObject *self) {
-  return (AbortAlgorithm *)JS::GetReservedSlot(self, Slots::AbortAlgorithm).toPrivate();
+NativeStreamSink::AbortAlgorithmImplementation *NativeStreamSink::abortAlgorithm(JSObject *self) {
+  return (AbortAlgorithmImplementation *)JS::GetReservedSlot(self, Slots::AbortAlgorithm)
+      .toPrivate();
 }
 
-CloseAlgorithm *closeAlgorithm(JSObject *self) {
-  return (CloseAlgorithm *)JS::GetReservedSlot(self, Slots::CloseAlgorithm).toPrivate();
+NativeStreamSink::CloseAlgorithmImplementation *NativeStreamSink::closeAlgorithm(JSObject *self) {
+  return (CloseAlgorithmImplementation *)JS::GetReservedSlot(self, Slots::CloseAlgorithm)
+      .toPrivate();
 }
 
-JSObject *controller(JSObject *self) {
+JSObject *NativeStreamSink::controller(JSObject *self) {
   return &JS::GetReservedSlot(self, Slots::Controller).toObject();
 }
 
 /**
  * Returns the underlying sink for the given controller iff it's an object,
  * nullptr otherwise.
  */
-static JSObject *get_controller_sink(JSContext *cx, JS::HandleObject controller) {
+JSObject *NativeStreamSink::get_controller_sink(JSContext *cx, JS::HandleObject controller) {
   JS::RootedValue sink(cx, JS::WritableStreamControllerGetUnderlyingSink(cx, controller));
   return sink.isObject() ? &sink.toObject() : nullptr;
 }
 
-JSObject *get_stream_sink(JSContext *cx, JS::HandleObject stream) {
+JSObject *NativeStreamSink::get_stream_sink(JSContext *cx, JS::HandleObject stream) {
   JS::RootedObject controller(cx, JS::WritableStreamGetController(cx, stream));
   return get_controller_sink(cx, controller);
 }
 
-bool stream_has_native_sink(JSContext *cx, JS::HandleObject stream) {
+bool NativeStreamSink::stream_has_native_sink(JSContext *cx, JS::HandleObject stream) {
   MOZ_RELEASE_ASSERT(JS::IsWritableStream(stream));
 
   JSObject *sink = get_stream_sink(cx, stream);
   return is_instance(sink);
 }
 
-const unsigned ctor_length = 0;
-
-bool check_receiver(JSContext *cx, JS::HandleValue receiver, const char *method_name);
-
-bool start(JSContext *cx, unsigned argc, JS::Value *vp) {
+bool NativeStreamSink::start(JSContext *cx, unsigned argc, JS::Value *vp) {
   METHOD_HEADER(1)
 
   MOZ_ASSERT(args[0].isObject());
@@ -93,45 +82,46 @@ bool start(JSContext *cx, unsigned argc, JS::Value *vp) {
   return true;
 }
 
-bool write(JSContext *cx, unsigned argc, JS::Value *vp) {
+bool NativeStreamSink::write(JSContext *cx, unsigned argc, JS::Value *vp) {
   METHOD_HEADER(1)
 
   JS::RootedObject owner(cx, NativeStreamSink::owner(self));
   JS::HandleValue chunk(args[0]);
 
-  WriteAlgorithm *write = writeAlgorithm(self);
+  WriteAlgorithmImplementation *write = writeAlgorithm(self);
   return write(cx, args, self, owner, chunk);
 }
 
-bool abort(JSContext *cx, unsigned argc, JS::Value *vp) {
+bool NativeStreamSink::abort(JSContext *cx, unsigned argc, JS::Value *vp) {
   METHOD_HEADER(1)
 
   JS::RootedObject owner(cx, NativeStreamSink::owner(self));
   JS::HandleValue reason(args[0]);
 
-  AbortAlgorithm *abort = abortAlgorithm(self);
+  AbortAlgorithmImplementation *abort = abortAlgorithm(self);
   return abort(cx, args, self, owner, reason);
 }
 
-bool close(JSContext *cx, unsigned argc, JS::Value *vp) {
+bool NativeStreamSink::close(JSContext *cx, unsigned argc, JS::Value *vp) {
   METHOD_HEADER(0)
 
   JS::RootedObject owner(cx, NativeStreamSink::owner(self));
 
-  CloseAlgorithm *close = closeAlgorithm(self);
+  CloseAlgorithmImplementation *close = closeAlgorithm(self);
   return close(cx, args, self, owner);
 }
 
-const JSFunctionSpec methods[] = {JS_FN("start", start, 1, 0), JS_FN("write", write, 2, 0),
-                                  JS_FN("abort", abort, 2, 0), JS_FN("close", close, 1, 0),
-                                  JS_FS_END};
-
-const JSPropertySpec properties[] = {JS_PS_END};
+const JSFunctionSpec NativeStreamSink::methods[] = {
+    JS_FN("start", start, 1, 0), JS_FN("write", write, 2, 0), JS_FN("abort", abort, 2, 0),
+    JS_FN("close", close, 1, 0), JS_FS_END};
 
-CLASS_BOILERPLATE_NO_CTOR(NativeStreamSink)
+const JSPropertySpec NativeStreamSink::properties[] = {JS_PS_END};
 
-JSObject *create(JSContext *cx, JS::HandleObject owner, JS::HandleValue startPromise,
-                 WriteAlgorithm *write, CloseAlgorithm *close, AbortAlgorithm *abort) {
+JSObject *NativeStreamSink::create(JSContext *cx, JS::HandleObject owner,
+                                   JS::HandleValue startPromise,
+                                   WriteAlgorithmImplementation *write,
+                                   CloseAlgorithmImplementation *close,
+                                   AbortAlgorithmImplementation *abort) {
   JS::RootedObject sink(cx, JS_NewObjectWithGivenProto(cx, &class_, proto_obj));
   if (!sink)
     return nullptr;
@@ -143,4 +133,4 @@ JSObject *create(JSContext *cx, JS::HandleObject owner, JS::HandleValue startPro
   JS::SetReservedSlot(sink, Slots::CloseAlgorithm, JS::PrivateValue((void *)close));
   return sink;
 }
-} // namespace NativeStreamSink
+} // namespace builtins

c-dependencies/js-compute-runtime/builtins/native-stream-sink.h

@@ -1,20 +1,61 @@
 #ifndef JS_COMPUTE_RUNTIME_NATIVE_STREAM_SINK_H
 #define JS_COMPUTE_RUNTIME_NATIVE_STREAM_SINK_H
+#include "builtin.h"
 
-namespace NativeStreamSink {
-typedef bool WriteAlgorithm(JSContext *cx, JS::CallArgs args, JS::HandleObject stream,
-                            JS::HandleObject owner, JS::HandleValue chunk);
-typedef bool AbortAlgorithm(JSContext *cx, JS::CallArgs args, JS::HandleObject stream,
-                            JS::HandleObject owner, JS::HandleValue reason);
-typedef bool CloseAlgorithm(JSContext *cx, JS::CallArgs args, JS::HandleObject stream,
-                            JS::HandleObject owner);
-bool is_instance(JSObject *obj);
-// Register the class.
-bool init_class(JSContext *cx, JS::HandleObject global);
-JSObject *create(JSContext *cx, JS::HandleObject owner, JS::HandleValue startPromise,
-                 WriteAlgorithm *write, CloseAlgorithm *close, AbortAlgorithm *abort);
-JSObject *get_stream_sink(JSContext *cx, JS::HandleObject stream);
-JSObject *owner(JSObject *self);
-
-} // namespace NativeStreamSink
+namespace builtins {
+
+class NativeStreamSink : public BuiltinNoConstructor<NativeStreamSink> {
+private:
+public:
+  static constexpr const char *class_name = "NativeStreamSink";
+
+  enum Slots {
+    Owner,          // TransformStream.
+    Controller,     // The WritableStreamDefaultController.
+    InternalWriter, // Only used to lock the stream if it's consumed internally.
+    StartPromise,   // Used as the return value of `start`, can be undefined.
+                    // Needed to properly implement TransformStream.
+    WriteAlgorithm,
+    AbortAlgorithm,
+    CloseAlgorithm,
+    // AbortAlgorithm, TODO: implement
+    Count
+  };
+
+  typedef bool WriteAlgorithmImplementation(JSContext *cx, JS::CallArgs args,
+                                            JS::HandleObject stream, JS::HandleObject owner,
+                                            JS::HandleValue chunk);
+  typedef bool AbortAlgorithmImplementation(JSContext *cx, JS::CallArgs args,
+                                            JS::HandleObject stream, JS::HandleObject owner,
+                                            JS::HandleValue reason);
+  typedef bool CloseAlgorithmImplementation(JSContext *cx, JS::CallArgs args,
+                                            JS::HandleObject stream, JS::HandleObject owner);
+
+  static const JSFunctionSpec methods[];
+  static const JSPropertySpec properties[];
+
+  static JSObject *owner(JSObject *self);
+  static JS::Value startPromise(JSObject *self);
+  static WriteAlgorithmImplementation *writeAlgorithm(JSObject *self);
+  static AbortAlgorithmImplementation *abortAlgorithm(JSObject *self);
+  static CloseAlgorithmImplementation *closeAlgorithm(JSObject *self);
+  static JSObject *controller(JSObject *self);
+
+  /**
+   * Returns the underlying sink for the given controller iff it's an object,
+   * nullptr otherwise.
+   */
+  static JSObject *get_controller_sink(JSContext *cx, JS::HandleObject controller);
+  static JSObject *get_stream_sink(JSContext *cx, JS::HandleObject stream);
+  static bool stream_has_native_sink(JSContext *cx, JS::HandleObject stream);
+  static bool start(JSContext *cx, unsigned argc, JS::Value *vp);
+  static bool write(JSContext *cx, unsigned argc, JS::Value *vp);
+  static bool abort(JSContext *cx, unsigned argc, JS::Value *vp);
+  static bool close(JSContext *cx, unsigned argc, JS::Value *vp);
+  static JSObject *create(JSContext *cx, JS::HandleObject owner, JS::HandleValue startPromise,
+                          WriteAlgorithmImplementation *write, CloseAlgorithmImplementation *close,
+                          AbortAlgorithmImplementation *abort);
+};
+
+} // namespace builtins
 #endif

c-dependencies/js-compute-runtime/builtins/transform-stream.cpp

@@ -321,11 +321,11 @@ JSObject *writable(JSObject *self) {
 }
 
 bool is_ts_writable(JSContext *cx, JS::HandleObject writable) {
-  JSObject *sink = NativeStreamSink::get_stream_sink(cx, writable);
-  if (!sink || !NativeStreamSink::is_instance(sink)) {
+  JSObject *sink = builtins::NativeStreamSink::get_stream_sink(cx, writable);
+  if (!sink || !builtins::NativeStreamSink::is_instance(sink)) {
     return false;
   }
-  JSObject *stream_owner = NativeStreamSink::owner(sink);
+  JSObject *stream_owner = builtins::NativeStreamSink::owner(sink);
   return stream_owner ? is_instance(stream_owner) : false;
 }
 
@@ -794,8 +794,8 @@ bool Initialize(JSContext *cx, JS::HandleObject stream, JS::HandleObject startPr
   // writableSizeAlgorithm).
   JS::RootedValue startPromiseVal(cx, JS::ObjectValue(*startPromise));
   JS::RootedObject sink(
-      cx, NativeStreamSink::create(cx, stream, startPromiseVal, DefaultSinkWriteAlgorithm,
-                                   DefaultSinkCloseAlgorithm, DefaultSinkAbortAlgorithm));
+      cx, builtins::NativeStreamSink::create(cx, stream, startPromiseVal, DefaultSinkWriteAlgorithm,
+                                             DefaultSinkCloseAlgorithm, DefaultSinkAbortAlgorithm));
   if (!sink)
     return false;
 

c-dependencies/js-compute-runtime/js-compute-builtins.cpp

@@ -4894,7 +4894,7 @@ bool define_fastly_sys(JSContext *cx, HandleObject global) {
 
   if (!builtins::NativeStreamSource::init_class(cx, global))
     return false;
-  if (!NativeStreamSink::init_class(cx, global))
+  if (!builtins::NativeStreamSink::init_class(cx, global))
     return false;
   if (!TransformStreamDefaultController::init_class(cx, global))
     return false;