Add implementation of DecompressionStream

This is an implementation of the WICG DecompressionStream builtin from https://wicg.github.io/compression/#decompression-stream

We already have CompressionStream, this is the counterpart to that.

An example c@e application which uses the feature would be:
```js
addEventListener("fetch", event => {
    event.respondWith(app(event))
})
/**
 * @param {FetchEvent} event
 * @returns {Response}
 */
async function app(event) {
    const res = await fetch('https://httpbin.org/deflate', {backend: "httpbin"})
        const ds = new DecompressionStream('deflate');
        return new Response(res.body.pipeThrough(ds))
}
```

Author: Jake Champion

.vscode/settings.json

@@ -73,7 +73,8 @@
         "thread": "cpp",
         "typeinfo": "cpp",
         "unordered_map": "cpp",
-        "utility": "cpp"
+        "utility": "cpp",
+        "*.msg": "cpp"
     },
     "git.ignoreLimitWarning": true
 }

c-dependencies/js-compute-runtime/error-numbers.msg

@@ -42,4 +42,6 @@
 MSG_DEF(JSMSG_NOT_AN_ERROR,                    0, JSEXN_ERR, "<Error #0 is reserved>")
 MSG_DEF(JSMSG_BUILTIN_CTOR_NO_NEW,             1, JSEXN_TYPEERR, "calling a builtin {0} constructor without new is forbidden")
 MSG_DEF(JSMSG_INVALID_BUFFER_ARG,              2, JSEXN_TYPEERR, "{0} must be of type ArrayBuffer or ArrayBufferView but got \"{1}\"")
+MSG_DEF(JSMSG_INVALID_COMPRESSION_FORMAT,      1, JSEXN_TYPEERR, "'format' has to be \"deflate\", \"deflate-raw\", or \"gzip\", but got \"{0}\"")
+MSG_DEF(JSMSG_DECOMPRESSING_ERROR,             0, JSEXN_TYPEERR, "DecompressionStream transform: error decompressing chunk")
 //clang-format on

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

@@ -3322,6 +3322,341 @@ JSObject *create_rs_proxy(JSContext *cx, HandleObject input_readable) {
 }
 } // namespace TransformStream
 
+/**
+ * Implementation of the WICG DecompressionStream builtin.
+ *
+ * All algorithm names and steps refer to spec algorithms defined at
+ * https://wicg.github.io/compression/#decompression-stream
+ */
+namespace DecompressionStream {
+namespace Slots {
+enum { Transform, Format, State, Buffer, Count };
+};
+
+enum class Format {
+  GZIP,
+  Deflate,
+  DeflateRaw,
+};
+
+// Using the same fixed encoding buffer size as Chromium, see
+// https://chromium.googlesource.com/chromium/src/+/457f48d3d8635c8bca077232471228d75290cc29/third_party/blink/renderer/modules/compression/deflate_transformer.cc#29
+const size_t BUFFER_SIZE = 16384;
+
+bool is_instance(JSObject *obj);
+
+JSObject *transform(JSObject *self) {
+  MOZ_ASSERT(is_instance(self));
+  return &JS::GetReservedSlot(self, Slots::Transform).toObject();
+}
+
+Format format(JSObject *self) {
+  MOZ_ASSERT(is_instance(self));
+  return (Format)JS::GetReservedSlot(self, Slots::Format).toInt32();
+}
+
+z_stream *state(JSObject *self) {
+  MOZ_ASSERT(is_instance(self));
+  void *ptr = JS::GetReservedSlot(self, Slots::State).toPrivate();
+  MOZ_ASSERT(ptr);
+  return (z_stream *)ptr;
+}
+
+uint8_t *output_buffer(JSObject *self) {
+  MOZ_ASSERT(is_instance(self));
+  void *ptr = JS::GetReservedSlot(self, Slots::Buffer).toPrivate();
+  MOZ_ASSERT(ptr);
+  return (uint8_t *)ptr;
+}
+
+const unsigned ctor_length = 1;
+bool check_receiver(JSContext *cx, HandleValue receiver, const char *method_name);
+
+// Steps 1-5 of the transform algorithm, and 1-5 of the flush algorithm.
+bool inflate_chunk(JSContext *cx, HandleObject self, HandleValue chunk, bool finished) {
+  z_stream *zstream = state(self);
+
+  if (!finished) {
+    // 1.  If _chunk_ is not a `BufferSource` type, then throw a `TypeError`.
+    // Step 2 of transform:
+    size_t length;
+    uint8_t *data = value_to_buffer(cx, chunk, "DecompressionStream transform: chunks", &length);
+    if (!data) {
+      return false;
+    }
+
+    if (length == 0) {
+      return true;
+    }
+
+    // 2.  Let _buffer_ be the result of decompressing _chunk_ with _ds_'s format
+    // and context. This just sets up step 2. The actual decompression happen in
+    // the `do` loop below.
+    zstream->avail_in = length;
+
+    // `data` is a live view into `chunk`. That's ok here because it'll be fully
+    // used in the `do` loop below before any content can execute again and
+    // could potentially invalidate the pointer to `data`.
+    zstream->next_in = data;
+  } else {
+    // Step 1 of flush:
+    // 1.  Let _buffer_ be the result of decompressing an empty input with _ds_'s
+    // format and
+    //     context, with the finish flag.
+
+    // Step 2 of flush:
+    // 2.  If the end of the compressed input has not been reached, then throw a TypeError.
+    if (zstream->avail_in != 0) {
+      JS_ReportErrorNumberUTF8(cx, GetErrorMessage, nullptr, JSMSG_DECOMPRESSING_ERROR);
+      return false;
+    }
+    // This just sets up step 3. The actual decompression happens in the `do` loop
+    // below.
+    zstream->avail_in = 0;
+    zstream->next_in = nullptr;
+  }
+
+  RootedObject controller(cx, TransformStream::controller(transform(self)));
+
+  // Steps 3-5 of transform are identical to steps 3-5 of flush, so numbers
+  // below refer to the former for those. Also, the compression happens in
+  // potentially smaller chunks in the `do` loop below, so the three steps are
+  // reordered and somewhat intertwined with each other.
+
+  uint8_t *buffer = output_buffer(self);
+
+  // Call `inflate` in a loop, enqueuing compressed chunks until the input
+  // buffer has been fully consumed. That is the case when `zstream->avail_out`
+  // is non-zero, i.e. when the last chunk wasn't completely filled. See zlib
+  // docs for details:
+  // https://searchfox.org/mozilla-central/rev/87ecd21d3ca517f8d90e49b32bf042a754ed8f18/modules/zlib/src/zlib.h#319-324
+  do {
+    // 4.  Split _buffer_ into one or more non-empty pieces and convert them
+    // into `Uint8Array`s.
+    // 5.  For each `Uint8Array` _array_, enqueue _array_ in _cds_'s transform.
+    // This loop does the actual decompression, one output-buffer sized chunk at a
+    // time, and then creates and enqueues the Uint8Arrays immediately.
+    zstream->avail_out = BUFFER_SIZE;
+    zstream->next_out = buffer;
+    int err = inflate(zstream, finished ? Z_FINISH : Z_NO_FLUSH);
+    if (err != Z_OK && err != Z_STREAM_END && err != Z_BUF_ERROR) {
+
+      JS_ReportErrorNumberUTF8(cx, GetErrorMessage, nullptr, JSMSG_DECOMPRESSING_ERROR);
+      return false;
+    }
+
+    size_t bytes = BUFFER_SIZE - zstream->avail_out;
+    if (bytes) {
+      RootedObject out_obj(cx, JS_NewUint8Array(cx, bytes));
+      if (!out_obj) {
+        return false;
+      }
+
+      {
+        bool is_shared;
+        JS::AutoCheckCannotGC nogc;
+        uint8_t *out_buffer = JS_GetUint8ArrayData(out_obj, &is_shared, nogc);
+        memcpy(out_buffer, buffer, bytes);
+      }
+
+      RootedValue out_chunk(cx, ObjectValue(*out_obj));
+      if (!TransformStreamDefaultController::Enqueue(cx, controller, out_chunk)) {
+        return false;
+      }
+    }
+
+    // 3.  If _buffer_ is empty, return.
+  } while (zstream->avail_out == 0);
+
+  return true;
+}
+
+// https://wicg.github.io/compression/#decompress-and-enqueue-a-chunk
+// All steps inlined into `inflate_chunk`.
+bool transformAlgorithm(JSContext *cx, unsigned argc, Value *vp) {
+  METHOD_HEADER_WITH_NAME(1, "Decompression stream transform algorithm")
+
+  if (!inflate_chunk(cx, self, args[0], false)) {
+    return false;
+  }
+
+  args.rval().setUndefined();
+  return true;
+}
+
+// https://wicg.github.io/compression/#decompress-flush-and-enqueue
+// All steps inlined into `inflate_chunk`.
+bool flushAlgorithm(JSContext *cx, unsigned argc, Value *vp) {
+  METHOD_HEADER_WITH_NAME(0, "Decompression stream flush algorithm")
+
+  if (!inflate_chunk(cx, self, JS::UndefinedHandleValue, true)) {
+    return false;
+  }
+
+  inflateEnd(state(self));
+  JS_free(cx, output_buffer(self));
+
+// These fields shouldn't ever be accessed again, but we should be able to
+// assert that.
+#ifdef DEBUG
+  JS::SetReservedSlot(self, Slots::State, PrivateValue(nullptr));
+  JS::SetReservedSlot(self, Slots::Buffer, PrivateValue(nullptr));
+#endif
+
+  args.rval().setUndefined();
+  return true;
+}
+
+bool readable_get(JSContext *cx, unsigned argc, Value *vp) {
+  METHOD_HEADER_WITH_NAME(0, "get readable")
+  args.rval().setObject(*TransformStream::readable(transform(self)));
+  return true;
+}
+
+bool writable_get(JSContext *cx, unsigned argc, Value *vp) {
+  METHOD_HEADER_WITH_NAME(0, "get writable")
+  args.rval().setObject(*TransformStream::writable(transform(self)));
+  return true;
+}
+
+const JSFunctionSpec methods[] = {JS_FS_END};
+
+const JSPropertySpec properties[] = {
+    JS_PSG("readable", readable_get, JSPROP_ENUMERATE),
+    JS_PSG("writable", writable_get, JSPROP_ENUMERATE),
+    JS_STRING_SYM_PS(toStringTag, "DecompressionStream", JSPROP_READONLY), JS_PS_END};
+
+bool constructor(JSContext *cx, unsigned argc, Value *vp);
+
+CLASS_BOILERPLATE_CUSTOM_INIT(DecompressionStream)
+
+static PersistentRooted<JSObject *> transformAlgo;
+static PersistentRooted<JSObject *> flushAlgo;
+
+// Steps 2-6 of `new DecompressionStream()`.
+JSObject *create(JSContext *cx, HandleObject stream, Format format) {
+  RootedValue stream_val(cx, ObjectValue(*stream));
+
+  // 2.  Set this's format to _format_.
+  JS::SetReservedSlot(stream, Slots::Format, JS::Int32Value((int32_t)format));
+
+  // 3.  Let _transformAlgorithm_ be an algorithm which takes a _chunk_ argument
+  // and runs the
+  //     `compress and enqueue a chunk algorithm with this and _chunk_.
+  // 4.  Let _flushAlgorithm_ be an algorithm which takes no argument and runs
+  // the
+  //     `compress flush and enqueue` algorithm with this.
+  // (implicit)
+
+  // 5.  Set this's transform to a new `TransformStream`.
+  // 6.  [Set up](https://streams.spec.whatwg.org/#transformstream-set-up)
+  // this's transform with _transformAlgorithm_ set to _transformAlgorithm_ and
+  // _flushAlgorithm_ set to _flushAlgorithm_.
+  RootedObject transform(cx, TransformStream::create(cx, 1, nullptr, 0, nullptr, stream_val,
+                                                     nullptr, transformAlgo, flushAlgo));
+  if (!transform) {
+    return nullptr;
+  }
+
+  TransformStream::set_used_as_mixin(transform);
+  JS::SetReservedSlot(stream, Slots::Transform, ObjectValue(*transform));
+
+  // The remainder of the function deals with setting up the inflate state used
+  // for decompressing chunks.
+
+  z_stream *zstream = (z_stream *)JS_malloc(cx, sizeof(z_stream));
+  if (!zstream) {
+    JS_ReportOutOfMemory(cx);
+    return nullptr;
+  }
+
+  memset(zstream, 0, sizeof(z_stream));
+  JS::SetReservedSlot(stream, Slots::State, PrivateValue(zstream));
+
+  uint8_t *buffer = (uint8_t *)JS_malloc(cx, BUFFER_SIZE);
+  if (!buffer) {
+    JS_ReportOutOfMemory(cx);
+    return nullptr;
+  }
+
+  JS::SetReservedSlot(stream, Slots::Buffer, PrivateValue(buffer));
+
+  // Using the same window bits as Chromium's Compression stream, see
+  // https://chromium.googlesource.com/chromium/src/+/457f48d3d8635c8bca077232471228d75290cc29/third_party/blink/renderer/modules/compression/inflate_transformer.cc#31
+  int window_bits = 15;
+  if (format == Format::GZIP) {
+    window_bits += 16;
+  } else if (format == Format::DeflateRaw) {
+    window_bits = -15;
+  }
+
+  int err = inflateInit2(zstream, window_bits);
+  if (err != Z_OK) {
+    JS_ReportErrorASCII(cx, "Error initializing decompression stream");
+    return nullptr;
+  }
+
+  return stream;
+}
+
+/**
+ * https://wicg.github.io/compression/#dom-compressionstream-compressionstream
+ */
+bool constructor(JSContext *cx, unsigned argc, Value *vp) {
+  // 1.  If _format_ is unsupported in `CompressionStream`, then throw a
+  // `TypeError`.
+  CTOR_HEADER("DecompressionStream", 1);
+
+  size_t format_len;
+  UniqueChars format_chars = encode(cx, args[0], &format_len);
+  if (!format_chars) {
+    return false;
+  }
+
+  Format format;
+  if (!strcmp(format_chars.get(), "deflate-raw")) {
+    format = Format::DeflateRaw;
+  } else if (!strcmp(format_chars.get(), "deflate")) {
+    format = Format::Deflate;
+  } else if (!strcmp(format_chars.get(), "gzip")) {
+    format = Format::GZIP;
+  } else {
+    JS_ReportErrorNumberUTF8(cx, GetErrorMessage, nullptr, JSMSG_INVALID_COMPRESSION_FORMAT,
+                             format_chars.get());
+    return false;
+  }
+
+  RootedObject decompressionStreamInstance(cx, JS_NewObjectForConstructor(cx, &class_, args));
+  // Steps 2-6.
+  RootedObject stream(cx, create(cx, decompressionStreamInstance, format));
+  if (!stream) {
+    return false;
+  }
+
+  args.rval().setObject(*stream);
+  return true;
+}
+
+bool init_class(JSContext *cx, HandleObject global) {
+  if (!init_class_impl(cx, global)) {
+    return false;
+  }
+
+  JSFunction *transformFun = JS_NewFunction(cx, transformAlgorithm, 1, 0, "DS Transform");
+  if (!transformFun)
+    return false;
+  transformAlgo.init(cx, JS_GetFunctionObject(transformFun));
+
+  JSFunction *flushFun = JS_NewFunction(cx, flushAlgorithm, 1, 0, "DS Flush");
+  if (!flushFun)
+    return false;
+  flushAlgo.init(cx, JS_GetFunctionObject(flushFun));
+
+  return true;
+}
+
+} // namespace DecompressionStream
+
 /**
  * Implementation of the WICG CompressionStream builtin.
  *
@@ -3517,8 +3852,10 @@ bool writable_get(JSContext *cx, unsigned argc, Value *vp) {
 
 const JSFunctionSpec methods[] = {JS_FS_END};
 
-const JSPropertySpec properties[] = {JS_PSG("readable", readable_get, JSPROP_ENUMERATE),
-                                     JS_PSG("writable", writable_get, JSPROP_ENUMERATE), JS_PS_END};
+const JSPropertySpec properties[] = {
+    JS_PSG("readable", readable_get, JSPROP_ENUMERATE),
+    JS_PSG("writable", writable_get, JSPROP_ENUMERATE),
+    JS_STRING_SYM_PS(toStringTag, "CompressionStream", JSPROP_READONLY), JS_PS_END};
 
 bool constructor(JSContext *cx, unsigned argc, Value *vp);
 
@@ -7736,6 +8073,8 @@ bool define_fastly_sys(JSContext *cx, HandleObject global) {
     return false;
   if (!CompressionStream::init_class(cx, global))
     return false;
+  if (!DecompressionStream::init_class(cx, global))
+    return false;
   if (!Request::init_class(cx, global))
     return false;
   if (!Response::init_class(cx, global))

tests/wpt-harness/expectations/compression/compression-with-detach.tentative.window.js.json

@@ -0,0 +1,5 @@
+{
+  "data should be correctly compressed even if input is detached partway": {
+    "status": 1
+  }
+}