feat: implement AbortController and AbortSignal (#240)

* Implement AbortConrtoller and AbortSignal

* Add Response aborter algorithm

* Replace glitch.me with fastly.dev

* Reject bodyAll promise on abort

* Add more spec references to AbortSignal

* Fix indentation

* Check if request's abort signal is instance of AbortSignal

* Spec subtleties

* More spec subtleties

* Fix AbortSignal protype chain

* Missing spec ref

Author: andreiltd

builtins/web/abort/abort-controller.cpp

@@ -0,0 +1,70 @@
+#include "abort-controller.h"
+#include "abort-signal.h"
+
+namespace builtins {
+namespace web {
+namespace abort {
+
+const JSFunctionSpec AbortController::static_methods[] = {
+    JS_FS_END,
+};
+
+const JSPropertySpec AbortController::static_properties[] = {
+    JS_PS_END,
+};
+
+const JSFunctionSpec AbortController::methods[] = {
+    JS_FN("abort", abort, 0, JSPROP_ENUMERATE),
+    JS_FS_END,
+};
+
+const JSPropertySpec AbortController::properties[] = {
+    JS_PSG("signal", signal_get, JSPROP_ENUMERATE),
+    JS_PS_END,
+};
+
+bool AbortController::signal_get(JSContext *cx, unsigned argc, JS::Value *vp) {
+  METHOD_HEADER(0);
+
+  args.rval().set(JS::GetReservedSlot(self, Slots::Signal));
+  return true;
+}
+
+bool AbortController::abort(JSContext *cx, unsigned argc, JS::Value *vp) {
+  METHOD_HEADER(0);
+
+  RootedValue reason(cx, args.get(0));
+  RootedObject signal(cx, JS::GetReservedSlot(self, Slots::Signal).toObjectOrNull());
+  if (!signal) {
+    return false;
+  }
+
+  return AbortSignal::abort(cx, signal, reason);
+}
+
+bool AbortController::constructor(JSContext *cx, unsigned argc, JS::Value *vp) {
+  CTOR_HEADER("AbortController", 0);
+
+  RootedObject self(cx, JS_NewObjectForConstructor(cx, &class_, args));
+  if (!self) {
+    return false;
+  }
+
+  RootedObject signal(cx, AbortSignal::create(cx));
+  if (!signal) {
+    return false;
+  }
+
+  SetReservedSlot(self, Slots::Signal, JS::ObjectValue(*signal));
+
+  args.rval().setObject(*self);
+  return true;
+}
+
+bool AbortController::init_class(JSContext *cx, JS::HandleObject global) {
+  return init_class_impl(cx, global);
+}
+
+}  // namespace abort
+}  // namespace web
+}  // namespace builtins

builtins/web/abort/abort-controller.h

@@ -0,0 +1,37 @@
+#ifndef WEB_BUILTINS_ABORT_CONTROLLER_H
+#define WEB_BUILTINS_ABORT_CONTROLLER_H
+
+#include "builtin.h"
+
+namespace builtins {
+namespace web {
+namespace abort {
+
+class AbortController : public BuiltinImpl<AbortController> {
+  static bool signal_get(JSContext *cx, unsigned argc, JS::Value *vp);
+  static bool abort(JSContext *cx, unsigned argc, JS::Value *vp);
+
+  static JSObject *create(JSContext *cx);
+
+public:
+  static constexpr const char *class_name = "AbortController";
+  static constexpr unsigned ctor_length = 0;
+
+  enum Slots { Signal = 0, Count };
+
+  static const JSFunctionSpec static_methods[];
+  static const JSPropertySpec static_properties[];
+  static const JSFunctionSpec methods[];
+  static const JSPropertySpec properties[];
+
+  static bool init_class(JSContext *cx, HandleObject global);
+  static bool constructor(JSContext *cx, unsigned argc, Value *vp);
+};
+
+} // namespace abort
+} // namespace web
+} // namespace builtins
+
+
+
+#endif // WEB_BUILTINS_ABORT_CONTROLLER_H