aboutsummaryrefslogtreecommitdiffstats
path: root/components/script/dom
diff options
context:
space:
mode:
Diffstat (limited to 'components/script/dom')
-rw-r--r--components/script/dom/bindings/structuredclone.rs27
-rw-r--r--components/script/dom/globalscope.rs6
-rw-r--r--components/script/dom/imagebitmap.rs133
3 files changed, 153 insertions, 13 deletions
diff --git a/components/script/dom/bindings/structuredclone.rs b/components/script/dom/bindings/structuredclone.rs
index c23156817cb..73974abe714 100644
--- a/components/script/dom/bindings/structuredclone.rs
+++ b/components/script/dom/bindings/structuredclone.rs
@@ -10,11 +10,13 @@ use std::os::raw;
use std::ptr;
use base::id::{
- BlobId, DomExceptionId, DomPointId, Index, MessagePortId, NamespaceIndex, PipelineNamespaceId,
+ BlobId, DomExceptionId, DomPointId, ImageBitmapId, Index, MessagePortId, NamespaceIndex,
+ PipelineNamespaceId,
};
use constellation_traits::{
BlobImpl, DomException, DomPoint, MessagePortImpl, Serializable as SerializableInterface,
- StructuredSerializedData, Transferrable as TransferrableInterface, TransformStreamData,
+ SerializableImageBitmap, StructuredSerializedData, Transferrable as TransferrableInterface,
+ TransformStreamData,
};
use js::gc::RootedVec;
use js::glue::{
@@ -42,6 +44,7 @@ use crate::dom::blob::Blob;
use crate::dom::dompoint::DOMPoint;
use crate::dom::dompointreadonly::DOMPointReadOnly;
use crate::dom::globalscope::GlobalScope;
+use crate::dom::imagebitmap::ImageBitmap;
use crate::dom::messageport::MessagePort;
use crate::dom::readablestream::ReadableStream;
use crate::dom::types::{DOMException, TransformStream};
@@ -66,6 +69,7 @@ pub(super) enum StructuredCloneTags {
DomException = 0xFFFF8007,
WritableStream = 0xFFFF8008,
TransformStream = 0xFFFF8009,
+ ImageBitmap = 0xFFFF800A,
Max = 0xFFFFFFFF,
}
@@ -76,6 +80,7 @@ impl From<SerializableInterface> for StructuredCloneTags {
SerializableInterface::DomPointReadOnly => StructuredCloneTags::DomPointReadOnly,
SerializableInterface::DomPoint => StructuredCloneTags::DomPoint,
SerializableInterface::DomException => StructuredCloneTags::DomException,
+ SerializableInterface::ImageBitmap => StructuredCloneTags::ImageBitmap,
}
}
}
@@ -83,6 +88,7 @@ impl From<SerializableInterface> for StructuredCloneTags {
impl From<TransferrableInterface> for StructuredCloneTags {
fn from(v: TransferrableInterface) -> Self {
match v {
+ TransferrableInterface::ImageBitmap => StructuredCloneTags::ImageBitmap,
TransferrableInterface::MessagePort => StructuredCloneTags::MessagePort,
TransferrableInterface::ReadableStream => StructuredCloneTags::ReadableStream,
TransferrableInterface::WritableStream => StructuredCloneTags::WritableStream,
@@ -104,6 +110,7 @@ fn reader_for_type(
SerializableInterface::DomPointReadOnly => read_object::<DOMPointReadOnly>,
SerializableInterface::DomPoint => read_object::<DOMPoint>,
SerializableInterface::DomException => read_object::<DOMException>,
+ SerializableInterface::ImageBitmap => read_object::<ImageBitmap>,
}
}
@@ -237,6 +244,7 @@ fn serialize_for_type(val: SerializableInterface) -> SerializeOperation {
SerializableInterface::DomPointReadOnly => try_serialize::<DOMPointReadOnly>,
SerializableInterface::DomPoint => try_serialize::<DOMPoint>,
SerializableInterface::DomException => try_serialize::<DOMException>,
+ SerializableInterface::ImageBitmap => try_serialize::<ImageBitmap>,
}
}
@@ -264,6 +272,7 @@ fn receiver_for_type(
) -> fn(&GlobalScope, &mut StructuredDataReader<'_>, u64, RawMutableHandleObject) -> Result<(), ()>
{
match val {
+ TransferrableInterface::ImageBitmap => receive_object::<ImageBitmap>,
TransferrableInterface::MessagePort => receive_object::<MessagePort>,
TransferrableInterface::ReadableStream => receive_object::<ReadableStream>,
TransferrableInterface::WritableStream => receive_object::<WritableStream>,
@@ -390,6 +399,7 @@ type TransferOperation = unsafe fn(
fn transfer_for_type(val: TransferrableInterface) -> TransferOperation {
match val {
+ TransferrableInterface::ImageBitmap => try_transfer::<ImageBitmap>,
TransferrableInterface::MessagePort => try_transfer::<MessagePort>,
TransferrableInterface::ReadableStream => try_transfer::<ReadableStream>,
TransferrableInterface::WritableStream => try_transfer::<WritableStream>,
@@ -439,6 +449,7 @@ unsafe fn can_transfer_for_type(
root_from_object::<T>(*obj, cx).map(|o| Transferable::can_transfer(&*o))
}
match transferable {
+ TransferrableInterface::ImageBitmap => can_transfer::<ImageBitmap>(obj, cx),
TransferrableInterface::MessagePort => can_transfer::<MessagePort>(obj, cx),
TransferrableInterface::ReadableStream => can_transfer::<ReadableStream>(obj, cx),
TransferrableInterface::WritableStream => can_transfer::<WritableStream>(obj, cx),
@@ -527,6 +538,10 @@ pub(crate) struct StructuredDataReader<'a> {
pub(crate) points: Option<HashMap<DomPointId, DomPoint>>,
/// A map of serialized exceptions.
pub(crate) exceptions: Option<HashMap<DomExceptionId, DomException>>,
+ // A map of serialized image bitmaps.
+ pub(crate) image_bitmaps: Option<HashMap<ImageBitmapId, SerializableImageBitmap>>,
+ /// A map of transferred image bitmaps.
+ pub(crate) transferred_image_bitmaps: Option<HashMap<ImageBitmapId, SerializableImageBitmap>>,
}
/// A data holder for transferred and serialized objects.
@@ -545,6 +560,10 @@ pub(crate) struct StructuredDataWriter {
pub(crate) exceptions: Option<HashMap<DomExceptionId, DomException>>,
/// Serialized blobs.
pub(crate) blobs: Option<HashMap<BlobId, BlobImpl>>,
+ /// Serialized image bitmaps.
+ pub(crate) image_bitmaps: Option<HashMap<ImageBitmapId, SerializableImageBitmap>>,
+ /// Transferred image bitmaps.
+ pub(crate) transferred_image_bitmaps: Option<HashMap<ImageBitmapId, SerializableImageBitmap>>,
}
/// Writes a structured clone. Returns a `DataClone` error if that fails.
@@ -599,6 +618,8 @@ pub(crate) fn write(
points: sc_writer.points.take(),
exceptions: sc_writer.exceptions.take(),
blobs: sc_writer.blobs.take(),
+ image_bitmaps: sc_writer.image_bitmaps.take(),
+ transferred_image_bitmaps: sc_writer.transferred_image_bitmaps.take(),
};
Ok(data)
@@ -623,6 +644,8 @@ pub(crate) fn read(
points: data.points.take(),
exceptions: data.exceptions.take(),
errors: DOMErrorRecord { message: None },
+ image_bitmaps: data.image_bitmaps.take(),
+ transferred_image_bitmaps: data.transferred_image_bitmaps.take(),
};
let sc_reader_ptr = &mut sc_reader as *mut _;
unsafe {
diff --git a/components/script/dom/globalscope.rs b/components/script/dom/globalscope.rs
index 55db2e4d248..ec2ed70dd15 100644
--- a/components/script/dom/globalscope.rs
+++ b/components/script/dom/globalscope.rs
@@ -2992,8 +2992,7 @@ impl GlobalScope {
if let Some(snapshot) = canvas.get_image_data() {
let size = snapshot.size().cast();
- let image_bitmap =
- ImageBitmap::new(self, size.width, size.height, can_gc).unwrap();
+ let image_bitmap = ImageBitmap::new(self, size.width, size.height, can_gc);
image_bitmap.set_bitmap_data(snapshot.to_vec());
image_bitmap.set_origin_clean(canvas.origin_is_clean());
p.resolve_native(&(image_bitmap), can_gc);
@@ -3009,8 +3008,7 @@ impl GlobalScope {
if let Some(snapshot) = canvas.get_image_data() {
let size = snapshot.size().cast();
- let image_bitmap =
- ImageBitmap::new(self, size.width, size.height, can_gc).unwrap();
+ let image_bitmap = ImageBitmap::new(self, size.width, size.height, can_gc);
image_bitmap.set_bitmap_data(snapshot.to_vec());
image_bitmap.set_origin_clean(canvas.origin_is_clean());
p.resolve_native(&(image_bitmap), can_gc);
diff --git a/components/script/dom/imagebitmap.rs b/components/script/dom/imagebitmap.rs
index ef6538e7451..97a1a54bba7 100644
--- a/components/script/dom/imagebitmap.rs
+++ b/components/script/dom/imagebitmap.rs
@@ -3,15 +3,20 @@
* file, You can obtain one at https://mozilla.org/MPL/2.0/. */
use std::cell::Cell;
+use std::collections::HashMap;
use std::vec::Vec;
+use base::id::{ImageBitmapId, ImageBitmapIndex};
+use constellation_traits::SerializableImageBitmap;
use dom_struct::dom_struct;
use crate::dom::bindings::cell::DomRefCell;
use crate::dom::bindings::codegen::Bindings::ImageBitmapBinding::ImageBitmapMethods;
-use crate::dom::bindings::error::Fallible;
use crate::dom::bindings::reflector::{Reflector, reflect_dom_object};
use crate::dom::bindings::root::DomRoot;
+use crate::dom::bindings::serializable::Serializable;
+use crate::dom::bindings::structuredclone::StructuredData;
+use crate::dom::bindings::transferable::Transferable;
use crate::dom::globalscope::GlobalScope;
use crate::script_runtime::CanGc;
@@ -29,33 +34,36 @@ pub(crate) struct ImageBitmap {
}
impl ImageBitmap {
- fn new_inherited(width_arg: u32, height_arg: u32) -> ImageBitmap {
+ fn new_inherited(width: u32, height: u32) -> ImageBitmap {
ImageBitmap {
reflector_: Reflector::new(),
- width: width_arg,
- height: height_arg,
+ width,
+ height,
bitmap_data: DomRefCell::new(Some(vec![])),
origin_clean: Cell::new(true),
}
}
- #[allow(dead_code)]
pub(crate) fn new(
global: &GlobalScope,
width: u32,
height: u32,
can_gc: CanGc,
- ) -> Fallible<DomRoot<ImageBitmap>> {
+ ) -> DomRoot<ImageBitmap> {
//assigning to a variable the return object of new_inherited
let imagebitmap = Box::new(ImageBitmap::new_inherited(width, height));
- Ok(reflect_dom_object(imagebitmap, global, can_gc))
+ reflect_dom_object(imagebitmap, global, can_gc)
}
pub(crate) fn set_bitmap_data(&self, data: Vec<u8>) {
*self.bitmap_data.borrow_mut() = Some(data);
}
+ pub(crate) fn origin_is_clean(&self) -> bool {
+ self.origin_clean.get()
+ }
+
pub(crate) fn set_origin_clean(&self, origin_is_clean: bool) {
self.origin_clean.set(origin_is_clean);
}
@@ -67,6 +75,117 @@ impl ImageBitmap {
}
}
+impl Serializable for ImageBitmap {
+ type Index = ImageBitmapIndex;
+ type Data = SerializableImageBitmap;
+
+ /// <https://html.spec.whatwg.org/multipage/#the-imagebitmap-interface:serialization-steps>
+ fn serialize(&self) -> Result<(ImageBitmapId, Self::Data), ()> {
+ // Step 1. If value's origin-clean flag is not set, then throw a "DataCloneError" DOMException.
+ if !self.origin_is_clean() {
+ return Err(());
+ }
+
+ // If value has a [[Detached]] internal slot whose value is true,
+ // then throw a "DataCloneError" DOMException.
+ if self.is_detached() {
+ return Err(());
+ }
+
+ // Step 2. Set serialized.[[BitmapData]] to a copy of value's bitmap data.
+ let serialized = SerializableImageBitmap {
+ width: self.width,
+ height: self.height,
+ bitmap_data: self.bitmap_data.borrow().clone().unwrap(),
+ };
+
+ Ok((ImageBitmapId::new(), serialized))
+ }
+
+ /// <https://html.spec.whatwg.org/multipage/#the-imagebitmap-interface:deserialization-steps>
+ fn deserialize(
+ owner: &GlobalScope,
+ serialized: Self::Data,
+ can_gc: CanGc,
+ ) -> Result<DomRoot<Self>, ()> {
+ let image_bitmap = ImageBitmap::new(owner, serialized.width, serialized.height, can_gc);
+
+ // Step 1. Set value's bitmap data to serialized.[[BitmapData]].
+ image_bitmap.set_bitmap_data(serialized.bitmap_data);
+
+ Ok(image_bitmap)
+ }
+
+ fn serialized_storage<'a>(
+ reader: StructuredData<'a, '_>,
+ ) -> &'a mut Option<HashMap<ImageBitmapId, Self::Data>> {
+ match reader {
+ StructuredData::Reader(r) => &mut r.image_bitmaps,
+ StructuredData::Writer(w) => &mut w.image_bitmaps,
+ }
+ }
+}
+
+impl Transferable for ImageBitmap {
+ type Index = ImageBitmapIndex;
+ type Data = SerializableImageBitmap;
+
+ fn can_transfer(&self) -> bool {
+ if !self.origin_is_clean() || self.is_detached() {
+ return false;
+ }
+ true
+ }
+
+ /// <https://html.spec.whatwg.org/multipage/#the-imagebitmap-interface:transfer-steps>
+ fn transfer(&self) -> Result<(ImageBitmapId, SerializableImageBitmap), ()> {
+ // Step 1. If value's origin-clean flag is not set, then throw a "DataCloneError" DOMException.
+ if !self.origin_is_clean() {
+ return Err(());
+ }
+
+ // If value has a [[Detached]] internal slot whose value is true,
+ // then throw a "DataCloneError" DOMException.
+ if self.is_detached() {
+ return Err(());
+ }
+
+ // Step 2. Set dataHolder.[[BitmapData]] to value's bitmap data.
+ // Step 3. Unset value's bitmap data.
+ let serialized = SerializableImageBitmap {
+ width: self.width,
+ height: self.height,
+ bitmap_data: self.bitmap_data.borrow_mut().take().unwrap(),
+ };
+
+ Ok((ImageBitmapId::new(), serialized))
+ }
+
+ /// <https://html.spec.whatwg.org/multipage/#the-imagebitmap-interface:transfer-receiving-steps>
+ fn transfer_receive(
+ owner: &GlobalScope,
+ _: ImageBitmapId,
+ serialized: SerializableImageBitmap,
+ ) -> Result<DomRoot<Self>, ()> {
+ let image_bitmap =
+ ImageBitmap::new(owner, serialized.width, serialized.height, CanGc::note());
+
+ // Step 1. Set value's bitmap data to serialized.[[BitmapData]].
+ image_bitmap.set_bitmap_data(serialized.bitmap_data);
+
+ Ok(image_bitmap)
+ }
+
+ fn serialized_storage<'a>(
+ data: StructuredData<'a, '_>,
+ ) -> &'a mut Option<HashMap<ImageBitmapId, Self::Data>> {
+ match data {
+ StructuredData::Reader(r) => &mut r.transferred_image_bitmaps,
+ StructuredData::Writer(w) => &mut w.transferred_image_bitmaps,
+ }
+ }
+}
+
impl ImageBitmapMethods<crate::DomTypeHolder> for ImageBitmap {
/// <https://html.spec.whatwg.org/multipage/#dom-imagebitmap-height>
fn Height(&self) -> u32 {
generated by cgit v1.2.3 (git 2.25.1) at 2025-05-24 10:36:37 +0000