Return an optional span from value_to_buffer

Author: elliottt

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

@@ -74,25 +74,24 @@ bool deflate_chunk(JSContext *cx, JS::HandleObject self, JS::HandleValue chunk,
   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, "CompressionStream transform: chunks", &length);
-    if (!data) {
+    auto data = value_to_buffer(cx, chunk, "CompressionStream transform: chunks");
+    if (!data.has_value()) {
       return false;
     }
 
-    if (length == 0) {
+    if (data->size() == 0) {
       return true;
     }
 
     // 2.  Let _buffer_ be the result of compressing _chunk_ with _cs_'s format
     // and context. This just sets up step 2. The actual compression happen in
     // the `do` loop below.
-    zstream->avail_in = length;
+    zstream->avail_in = data->size();
 
     // `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;
+    zstream->next_in = data->data();
   } else {
     // Step 1 of flush:
     // 1.  Let _buffer_ be the result of compressing an empty input with _cs_'s

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

@@ -69,25 +69,24 @@ bool inflate_chunk(JSContext *cx, JS::HandleObject self, JS::HandleValue chunk,
   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) {
+    auto data = value_to_buffer(cx, chunk, "DecompressionStream transform: chunks");
+    if (!data.has_value()) {
       return false;
     }
 
-    if (length == 0) {
+    if (data->size() == 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;
+    zstream->avail_in = data->size();
 
     // `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;
+    zstream->next_in = data->data();
   } else {
     // Step 1 of flush:
     // 1.  Let _buffer_ be the result of decompressing an empty input with _ds_'s

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

@@ -291,9 +291,8 @@ bool SubtleCrypto::digest(JSContext *cx, unsigned argc, JS::Value *vp) {
 
   // 2 . Let data be the result of getting a copy of the bytes held by the data parameter
   // passed to the digest() method.
-  size_t length;
-  uint8_t *data = value_to_buffer(cx, args.get(1), "SubtleCrypto#digest: data", &length);
-  if (!data) {
+  auto data = value_to_buffer(cx, args.get(1), "SubtleCrypto#digest: data");
+  if (!data.has_value()) {
     return false;
   }
 
@@ -367,7 +366,7 @@ bool SubtleCrypto::digest(JSContext *cx, unsigned argc, JS::Value *vp) {
     JS_ReportOutOfMemory(cx);
     return false;
   }
-  if (!EVP_Digest(data, length, buf, &size, alg, NULL)) {
+  if (!EVP_Digest(data->data(), data->size(), buf, &size, alg, NULL)) {
     JS_ReportErrorUTF8(cx, "SubtleCrypto.digest: failed to create digest");
     return RejectPromiseWithPendingError(cx, promise);
   }

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

@@ -164,25 +164,27 @@ SpecString encode(JSContext *cx, HandleValue val) {
   return slice;
 }
 
-uint8_t *value_to_buffer(JSContext *cx, HandleValue val, const char *val_desc, size_t *len) {
+std::optional<std::span<uint8_t>> value_to_buffer(JSContext *cx, HandleValue val,
+                                                  const char *val_desc) {
   if (!val.isObject() ||
       !(JS_IsArrayBufferViewObject(&val.toObject()) || JS::IsArrayBufferObject(&val.toObject()))) {
     JS_ReportErrorNumberUTF8(cx, GetErrorMessage, nullptr, JSMSG_INVALID_BUFFER_ARG, val_desc,
                              val.type());
-    return nullptr;
+    return std::nullopt;
   }
 
   RootedObject input(cx, &val.toObject());
   uint8_t *data;
   bool is_shared;
+  size_t len = 0;
 
   if (JS_IsArrayBufferViewObject(input)) {
-    js::GetArrayBufferViewLengthAndData(input, len, &is_shared, &data);
+    js::GetArrayBufferViewLengthAndData(input, &len, &is_shared, &data);
   } else {
-    JS::GetArrayBufferLengthAndData(input, len, &is_shared, &data);
+    JS::GetArrayBufferLengthAndData(input, &len, &is_shared, &data);
   }
 
-  return data;
+  return std::span(data, len);
 }
 
 bool RejectPromiseWithPendingError(JSContext *cx, HandleObject promise) {
@@ -2855,13 +2857,13 @@ bool decode(JSContext *cx, unsigned argc, Value *vp) {
     return true;
   }
 
-  size_t length;
-  uint8_t *data = value_to_buffer(cx, args[0], "TextDecoder#decode: input", &length);
-  if (!data) {
+  auto data = value_to_buffer(cx, args[0], "TextDecoder#decode: input");
+  if (!data.has_value()) {
     return false;
   }
 
-  RootedString str(cx, JS_NewStringCopyUTF8N(cx, JS::UTF8Chars((char *)data, length)));
+  RootedString str(cx,
+                   JS_NewStringCopyUTF8N(cx, JS::UTF8Chars((char *)data->data(), data->size())));
   if (!str)
     return false;
 

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

@@ -1,6 +1,9 @@
 #ifndef fastly_sys_h
 #define fastly_sys_h
 
+#include <optional>
+#include <span>
+
 // TODO: remove these once the warnings are fixed
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Winvalid-offsetof"
@@ -46,7 +49,8 @@ inline bool ReturnPromiseRejectedWithPendingError(JSContext *cx, const JS::CallA
   return true;
 }
 
-uint8_t *value_to_buffer(JSContext *cx, JS::HandleValue val, const char *val_desc, size_t *len);
+std::optional<std::span<uint8_t>> value_to_buffer(JSContext *cx, JS::HandleValue val,
+                                                  const char *val_desc);
 
 typedef bool InternalMethod(JSContext *cx, JS::HandleObject receiver, JS::HandleValue extra,
                             JS::CallArgs args);