cancel stream

components/script/dom/readablestream.rs

@@ -3,17 +3,22 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use crate::dom::bindings::codegen::Bindings::FunctionBinding::Function;
-use crate::dom::bindings::codegen::Bindings::ReadableStreamBinding::Wrap;
+use crate::dom::bindings::codegen::Bindings::ReadableStreamBinding::{ReadableStreamMethods, Wrap};
+use crate::dom::bindings::error::{Error, Fallible};
 use crate::dom::bindings::num::Finite;
-use crate::dom::bindings::reflector::{reflect_dom_object, Reflector};
+use crate::dom::bindings::reflector::{reflect_dom_object, DomObject, Reflector};
 use crate::dom::bindings::root::DomRoot;
+use crate::dom::bindings::str::DOMString;
 use crate::dom::globalscope::GlobalScope;
+use crate::dom::promise::Promise;
 use crate::js::conversions::ToJSValConvertible;
 use crate::script_runtime::JSContext as SafeJSContext;
 use dom_struct::dom_struct;
-use js::jsapi::{Heap, JSFunction, JSObject, JS_ValueToFunction};
-use js::jsapi::{IsReadableStream, NewReadableDefaultStreamObject};
-use js::jsval::UndefinedValue;
+use js::jsapi::{HandleObject, Heap, JSFunction, JSObject, JS_ValueToFunction};
+use js::jsapi::{
+    IsReadableStream, NewReadableDefaultStreamObject, ReadableStreamCancel, ReadableStreamIsLocked,
+};
+use js::jsval::{BooleanValue, UndefinedValue};
 use js::rust::{Handle, IntoHandle};
 use std::ptr;
 use std::rc::Rc;
@@ -25,6 +30,36 @@ pub struct ReadableStream {
     stream: Heap<*mut JSObject>,
 }
 
+impl ReadableStream {
+    /// <https://streams.spec.whatwg.org/#rs-class>
+    #[allow(non_snake_case)]
+    pub fn Constructor(
+        cx: SafeJSContext,
+        global: &GlobalScope,
+        underlying_source: *mut JSObject,
+        size: Rc<Function>,
+        high_watermark: Finite<f64>,
+        proto: *mut JSObject,
+    ) -> DomRoot<ReadableStream> {
+        let stream =
+            construct_default_readablestream(cx, underlying_source, size, high_watermark, proto);
+
+        reflect_dom_object(
+            Box::new(ReadableStream {
+                reflector_: Reflector::new(),
+                stream,
+            }),
+            global,
+            Wrap,
+        )
+    }
+
+    pub fn Cancel(&self, reason: DOMString) -> Fallible<Rc<Promise>> {
+        let cx = self.global().get_cx();
+        cancel_readablestream(cx, &self.stream, reason)
+    }
+}
+
 #[allow(unsafe_code)]
 fn construct_default_readablestream(
     cx: SafeJSContext,
@@ -62,27 +97,35 @@ fn construct_default_readablestream(
     heap
 }
 
-impl ReadableStream {
-    /// <https://html.spec.whatwg.org/multipage/#dom-messagechannel>
-    #[allow(non_snake_case)]
-    pub fn Constructor(
-        cx: SafeJSContext,
-        global: &GlobalScope,
-        underlying_source: *mut JSObject,
-        size: Rc<Function>,
-        high_watermark: Finite<f64>,
-        proto: *mut JSObject,
-    ) -> DomRoot<ReadableStream> {
-        let stream =
-            construct_default_readablestream(cx, underlying_source, size, high_watermark, proto);
+#[allow(unsafe_code)]
+fn cancel_readablestream(
+    cx: SafeJSContext,
+    stream: &Heap<*mut JSObject>,
+    reason: DOMString,
+) -> Fallible<Rc<Promise>> {
+    unsafe {
+        let stream = stream.handle();
 
-        reflect_dom_object(
-            Box::new(ReadableStream {
-                reflector_: Reflector::new(),
-                stream,
-            }),
-            global,
-            Wrap,
-        )
+        let mut is_locked = false;
+        let is_locked_ptr = &mut is_locked as *mut _;
+        ReadableStreamIsLocked(*cx, stream, is_locked_ptr);
+
+        let is_stream = IsReadableStream(stream.get());
+
+        if !is_stream || is_locked {
+            return Err(Error::Type(
+                "The stream you are trying to cancel is not a ReadableStream, or it is locked."
+                    .to_string(),
+            ));
+        }
+
+        rooted!(in(*cx) let mut reason_val = UndefinedValue());
+        (*reason).to_jsval(*cx, reason_val.handle_mut());
+
+        rooted!(in(*cx) let raw_cancel_promise = ReadableStreamCancel(*cx, stream, reason_val.handle().into_handle()));
+
+        let cancel_promise = Promise::new_with_js_promise(raw_cancel_promise.handle(), cx);
+
+        Ok(cancel_promise)
     }
 }

components/script/dom/webidls/ReadableStream.webidl

@@ -8,6 +8,7 @@
 [Exposed=(Window,Worker)]
 interface ReadableStream {
   constructor(object underlyingSource, Function size, HighWatermark highWaterMark, object proto);
+  [Throws] Promise<DOMString> cancel(DOMString reason);
 };
 
 typedef double HighWatermark;