refactor native-stream-source to extend from BuiltinNoConstructor class

Author: Jake Champion

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

@@ -13,31 +13,35 @@
 
 // A JS class to use as the underlying source for native readable streams, used
 // for Request/Response bodies and TransformStream.
-namespace NativeStreamSource {
+namespace builtins {
 
-JSObject *owner(JSObject *self) {
+JSObject *NativeStreamSource::owner(JSObject *self) {
   MOZ_ASSERT(is_instance(self));
   return &JS::GetReservedSlot(self, Slots::Owner).toObject();
 }
 
-JSObject *stream(JSObject *self) { return RequestOrResponse::body_stream(owner(self)); }
+JSObject *NativeStreamSource::stream(JSObject *self) {
+  return RequestOrResponse::body_stream(owner(self));
+}
 
-JS::Value startPromise(JSObject *self) {
+JS::Value NativeStreamSource::startPromise(JSObject *self) {
   MOZ_ASSERT(is_instance(self));
   return JS::GetReservedSlot(self, Slots::StartPromise);
 }
 
-PullAlgorithm *pullAlgorithm(JSObject *self) {
+NativeStreamSource::PullAlgorithmImplementation *NativeStreamSource::pullAlgorithm(JSObject *self) {
   MOZ_ASSERT(is_instance(self));
-  return (PullAlgorithm *)JS::GetReservedSlot(self, Slots::PullAlgorithm).toPrivate();
+  return (PullAlgorithmImplementation *)JS::GetReservedSlot(self, Slots::PullAlgorithm).toPrivate();
 }
 
-CancelAlgorithm *cancelAlgorithm(JSObject *self) {
+NativeStreamSource::CancelAlgorithmImplementation *
+NativeStreamSource::cancelAlgorithm(JSObject *self) {
   MOZ_ASSERT(is_instance(self));
-  return (CancelAlgorithm *)JS::GetReservedSlot(self, Slots::CancelAlgorithm).toPrivate();
+  return (CancelAlgorithmImplementation *)JS::GetReservedSlot(self, Slots::CancelAlgorithm)
+      .toPrivate();
 }
 
-JSObject *controller(JSObject *self) {
+JSObject *NativeStreamSource::controller(JSObject *self) {
   MOZ_ASSERT(is_instance(self));
   return &JS::GetReservedSlot(self, Slots::Controller).toObject();
 }
@@ -46,33 +50,33 @@ JSObject *controller(JSObject *self) {
  * Returns the underlying source for the given controller iff it's an object,
  * nullptr otherwise.
  */
-static JSObject *get_controller_source(JSContext *cx, JS::HandleObject controller) {
+JSObject *NativeStreamSource::get_controller_source(JSContext *cx, JS::HandleObject controller) {
   JS::RootedValue source(cx);
   bool success __attribute__((unused));
   success = JS::ReadableStreamControllerGetUnderlyingSource(cx, controller, &source);
   MOZ_ASSERT(success);
   return source.isObject() ? &source.toObject() : nullptr;
 }
 
-JSObject *get_stream_source(JSContext *cx, JS::HandleObject stream) {
+JSObject *NativeStreamSource::get_stream_source(JSContext *cx, JS::HandleObject stream) {
   MOZ_ASSERT(JS::IsReadableStream(stream));
   JS::RootedObject controller(cx, JS::ReadableStreamGetController(cx, stream));
   return get_controller_source(cx, controller);
 }
 
-bool stream_has_native_source(JSContext *cx, JS::HandleObject stream) {
+bool NativeStreamSource::stream_has_native_source(JSContext *cx, JS::HandleObject stream) {
   JSObject *source = get_stream_source(cx, stream);
   return is_instance(source);
 }
 
-bool stream_is_body(JSContext *cx, JS::HandleObject stream) {
+bool NativeStreamSource::stream_is_body(JSContext *cx, JS::HandleObject stream) {
   JSObject *stream_source = get_stream_source(cx, stream);
   return NativeStreamSource::is_instance(stream_source) &&
          RequestOrResponse::is_instance(owner(stream_source));
 }
 
-void set_stream_piped_to_ts_writable(JSContext *cx, JS::HandleObject stream,
-                                     JS::HandleObject writable) {
+void NativeStreamSource::set_stream_piped_to_ts_writable(JSContext *cx, JS::HandleObject stream,
+                                                         JS::HandleObject writable) {
   JS::RootedObject source(cx, NativeStreamSource::get_stream_source(cx, stream));
   MOZ_ASSERT(is_instance(source));
   JS::RootedObject sink(cx, NativeStreamSink::get_stream_sink(cx, writable));
@@ -81,12 +85,12 @@ void set_stream_piped_to_ts_writable(JSContext *cx, JS::HandleObject stream,
   JS::SetReservedSlot(source, Slots::PipedToTransformStream, JS::ObjectValue(*transform_stream));
 }
 
-JSObject *piped_to_transform_stream(JSObject *self) {
+JSObject *NativeStreamSource::piped_to_transform_stream(JSObject *self) {
   MOZ_ASSERT(is_instance(self));
   return JS::GetReservedSlot(self, Slots::PipedToTransformStream).toObjectOrNull();
 }
 
-bool lock_stream(JSContext *cx, JS::HandleObject stream) {
+bool NativeStreamSource::lock_stream(JSContext *cx, JS::HandleObject stream) {
   MOZ_ASSERT(JS::IsReadableStream(stream));
 
   bool locked;
@@ -108,11 +112,7 @@ bool lock_stream(JSContext *cx, JS::HandleObject stream) {
   return true;
 }
 
-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 NativeStreamSource::start(JSContext *cx, unsigned argc, JS::Value *vp) {
   METHOD_HEADER(1)
 
   MOZ_ASSERT(args[0].isObject());
@@ -130,37 +130,38 @@ bool start(JSContext *cx, unsigned argc, JS::Value *vp) {
   return true;
 }
 
-bool pull(JSContext *cx, unsigned argc, JS::Value *vp) {
+bool NativeStreamSource::pull(JSContext *cx, unsigned argc, JS::Value *vp) {
   METHOD_HEADER(1)
 
   JS::RootedObject owner(cx, NativeStreamSource::owner(self));
   JS::RootedObject controller(cx, &args[0].toObject());
   MOZ_ASSERT(controller == NativeStreamSource::controller(self));
   MOZ_ASSERT(get_controller_source(cx, controller) == self.get());
 
-  PullAlgorithm *pull = pullAlgorithm(self);
+  PullAlgorithmImplementation *pull = pullAlgorithm(self);
   return pull(cx, args, self, owner, controller);
 }
 
-bool cancel(JSContext *cx, unsigned argc, JS::Value *vp) {
+bool NativeStreamSource::cancel(JSContext *cx, unsigned argc, JS::Value *vp) {
   METHOD_HEADER(0)
 
   JS::RootedObject owner(cx, NativeStreamSource::owner(self));
   JS::HandleValue reason(args.get(0));
 
-  CancelAlgorithm *cancel = cancelAlgorithm(self);
+  CancelAlgorithmImplementation *cancel = cancelAlgorithm(self);
   return cancel(cx, args, self, owner, reason);
 }
 
-const JSFunctionSpec methods[] = {JS_FN("start", start, 1, 0), JS_FN("pull", pull, 1, 0),
-                                  JS_FN("cancel", cancel, 1, 0), JS_FS_END};
-
-const JSPropertySpec properties[] = {JS_PS_END};
+const JSFunctionSpec NativeStreamSource::methods[] = {JS_FN("start", start, 1, 0),
+                                                      JS_FN("pull", pull, 1, 0),
+                                                      JS_FN("cancel", cancel, 1, 0), JS_FS_END};
 
-CLASS_BOILERPLATE_NO_CTOR(NativeStreamSource)
+const JSPropertySpec NativeStreamSource::properties[] = {JS_PS_END};
 
-JSObject *create(JSContext *cx, JS::HandleObject owner, JS::HandleValue startPromise,
-                 PullAlgorithm *pull, CancelAlgorithm *cancel) {
+JSObject *NativeStreamSource::create(JSContext *cx, JS::HandleObject owner,
+                                     JS::HandleValue startPromise,
+                                     PullAlgorithmImplementation *pull,
+                                     CancelAlgorithmImplementation *cancel) {
   JS::RootedObject source(cx, JS_NewObjectWithGivenProto(cx, &class_, proto_obj));
   if (!source)
     return nullptr;
@@ -172,4 +173,4 @@ JSObject *create(JSContext *cx, JS::HandleObject owner, JS::HandleValue startPro
   JS::SetReservedSlot(source, Slots::PipedToTransformStream, JS::NullValue());
   return source;
 }
-} // namespace NativeStreamSource
+} // namespace builtins

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

@@ -1,41 +1,53 @@
 #ifndef JS_COMPUTE_RUNTIME_NATIVE_STREAM_SOURCE_H
 #define JS_COMPUTE_RUNTIME_NATIVE_STREAM_SOURCE_H
 
-namespace NativeStreamSource {
-namespace Slots {
-enum {
-  Owner,          // Request or Response object, or TransformStream.
-  Controller,     // The ReadableStreamDefaultController.
-  InternalReader, // 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.
-  PullAlgorithm,
-  CancelAlgorithm,
-  PipedToTransformStream, // The TransformStream this source's stream is piped
-                          // to, if any. Only applies if the source backs a
-                          // RequestOrResponse's body.
-  Count
-};
-};
-bool is_instance(JSObject *obj);
-// Register the class.
-bool init_class(JSContext *cx, JS::HandleObject global);
-typedef bool PullAlgorithm(JSContext *cx, JS::CallArgs args, JS::HandleObject stream,
-                           JS::HandleObject owner, JS::HandleObject controller);
-typedef bool CancelAlgorithm(JSContext *cx, JS::CallArgs args, JS::HandleObject stream,
-                             JS::HandleObject owner, JS::HandleValue reason);
+#include "builtin.h"
 
-JSObject *create(JSContext *cx, JS::HandleObject owner, JS::HandleValue startPromise,
-                 PullAlgorithm *pull, CancelAlgorithm *cancel);
-JSObject *get_stream_source(JSContext *cx, JS::HandleObject stream);
-JSObject *owner(JSObject *self);
-JSObject *stream(JSObject *self);
-bool stream_has_native_source(JSContext *cx, JS::HandleObject stream);
-bool stream_is_body(JSContext *cx, JS::HandleObject stream);
-bool lock_stream(JSContext *cx, JS::HandleObject stream);
-JSObject *piped_to_transform_stream(JSObject *source);
-JSObject *controller(JSObject *self);
-void set_stream_piped_to_ts_writable(JSContext *cx, JS::HandleObject stream,
-                                     JS::HandleObject writable);
-} // namespace NativeStreamSource
+namespace builtins {
+class NativeStreamSource : public BuiltinNoConstructor<NativeStreamSource> {
+private:
+public:
+  static constexpr const char *class_name = "NativeStreamSource";
+  enum Slots {
+    Owner,          // Request or Response object, or TransformStream.
+    Controller,     // The ReadableStreamDefaultController.
+    InternalReader, // 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.
+    PullAlgorithm,
+    CancelAlgorithm,
+    PipedToTransformStream, // The TransformStream this source's stream is piped
+                            // to, if any. Only applies if the source backs a
+                            // RequestOrResponse's body.
+    Count
+  };
+  static const JSFunctionSpec methods[];
+  static const JSPropertySpec properties[];
+  typedef bool PullAlgorithmImplementation(JSContext *cx, JS::CallArgs args,
+                                           JS::HandleObject stream, JS::HandleObject owner,
+                                           JS::HandleObject controller);
+  typedef bool CancelAlgorithmImplementation(JSContext *cx, JS::CallArgs args,
+                                             JS::HandleObject stream, JS::HandleObject owner,
+                                             JS::HandleValue reason);
+  static JSObject *owner(JSObject *self);
+  static JSObject *stream(JSObject *self);
+  static JS::Value startPromise(JSObject *self);
+  static PullAlgorithmImplementation *pullAlgorithm(JSObject *self);
+  static CancelAlgorithmImplementation *cancelAlgorithm(JSObject *self);
+  static JSObject *controller(JSObject *self);
+  static JSObject *get_controller_source(JSContext *cx, JS::HandleObject controller);
+  static JSObject *get_stream_source(JSContext *cx, JS::HandleObject stream);
+  static bool stream_has_native_source(JSContext *cx, JS::HandleObject stream);
+  static bool stream_is_body(JSContext *cx, JS::HandleObject stream);
+  static void set_stream_piped_to_ts_writable(JSContext *cx, JS::HandleObject stream,
+                                              JS::HandleObject writable);
+  static JSObject *piped_to_transform_stream(JSObject *self);
+  static bool lock_stream(JSContext *cx, JS::HandleObject stream);
+  static bool start(JSContext *cx, unsigned argc, JS::Value *vp);
+  static bool pull(JSContext *cx, unsigned argc, JS::Value *vp);
+  static bool cancel(JSContext *cx, unsigned argc, JS::Value *vp);
+  static JSObject *create(JSContext *cx, JS::HandleObject owner, JS::HandleValue startPromise,
+                          PullAlgorithmImplementation *pull, CancelAlgorithmImplementation *cancel);
+};
+} // namespace builtins
 #endif

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

@@ -38,9 +38,9 @@ bool pipeTo(JSContext *cx, unsigned argc, JS::Value *vp) {
   // writable end of a TransformStream, set the TransformStream as the owner of
   // the receiver's source. This enables us to shortcut operations later on.
   JS::RootedObject target(cx, args[0].isObject() ? &args[0].toObject() : nullptr);
-  if (target && NativeStreamSource::stream_has_native_source(cx, self) &&
+  if (target && builtins::NativeStreamSource::stream_has_native_source(cx, self) &&
       JS::IsWritableStream(target) && TransformStream::is_ts_writable(cx, target)) {
-    NativeStreamSource::set_stream_piped_to_ts_writable(cx, self, target);
+    builtins::NativeStreamSource::set_stream_piped_to_ts_writable(cx, self, target);
   }
 
   return JS::Call(cx, args.thisv(), original_pipeTo, JS::HandleValueArray(args), args.rval());
@@ -279,18 +279,18 @@ JSObject *readable(JSObject *self) {
 }
 
 bool is_ts_readable(JSContext *cx, JS::HandleObject readable) {
-  JSObject *source = NativeStreamSource::get_stream_source(cx, readable);
-  if (!source || !NativeStreamSource::is_instance(source)) {
+  JSObject *source = builtins::NativeStreamSource::get_stream_source(cx, readable);
+  if (!source || !builtins::NativeStreamSource::is_instance(source)) {
     return false;
   }
-  JSObject *stream_owner = NativeStreamSource::owner(source);
+  JSObject *stream_owner = builtins::NativeStreamSource::owner(source);
   return stream_owner ? TransformStream::is_instance(stream_owner) : false;
 }
 
 JSObject *ts_from_readable(JSContext *cx, JS::HandleObject readable) {
   MOZ_ASSERT(is_ts_readable(cx, readable));
-  JSObject *source = NativeStreamSource::get_stream_source(cx, readable);
-  return NativeStreamSource::owner(source);
+  JSObject *source = builtins::NativeStreamSource::get_stream_source(cx, readable);
+  return builtins::NativeStreamSource::owner(source);
 }
 
 bool readable_used_as_body(JSObject *self) {
@@ -817,8 +817,8 @@ bool Initialize(JSContext *cx, JS::HandleObject stream, JS::HandleObject startPr
   // Step 8.  Set stream.[readable] to ! [CreateReadableStream](startAlgorithm,
   // pullAlgorithm, cancelAlgorithm, readableHighWaterMark,
   // readableSizeAlgorithm).
-  JS::RootedObject source(
-      cx, NativeStreamSource::create(cx, stream, startPromiseVal, pullAlgorithm, cancelAlgorithm));
+  JS::RootedObject source(cx, builtins::NativeStreamSource::create(cx, stream, startPromiseVal,
+                                                                   pullAlgorithm, cancelAlgorithm));
   if (!source)
     return false;