OffscreenCanvas API

components/script/dom/mod.rs

@@ -405,6 +405,8 @@ pub mod nodeiterator;
 pub mod nodelist;
 pub mod offlineaudiocompletionevent;
 pub mod offlineaudiocontext;
+pub mod offscreencanvas;
+pub mod offscreencanvasrenderingcontext2d;
 pub mod oscillatornode;
 pub mod pagetransitionevent;
 pub mod paintrenderingcontext2d;

components/script/dom/offscreencanvas.rs

@@ -0,0 +1,147 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+ use dom::bindings::codegen::Bindings::OffscreenCanvasBinding::{OffscreenCanvasMethods, Wrap as OffscreenCanvasWrap};
+ use dom::bindings::codegen::Bindings::OffscreenCanvasBinding;
+ use dom::bindings::codegen::UnionTypes;
+ use dom::bindings::error::{Error, Fallible};
+ use dom::bindings::reflector::{DomObject, Reflector, reflect_dom_object};
+ use std::ptr;
+ use dom::bindings::root::{DomRoot, Dom};
+ use std::cell::Ref;
+ use dom::bindings::str::DOMString;
+ use dom::globalscope::GlobalScope;
+ use dom::htmlcanvaselement::{CanvasContext, HTMLCanvasElement};
+ use dom_struct::dom_struct;
+ use dom::bindings::cell::DomRefCell;
+ use ref_filter_map;
+ use dom::offscreencanvasrenderingcontext2d::OffscreenCanvasRenderingContext2D;
+ use dom::webglrenderingcontext::WebGLRenderingContext;
+ use dom::webgl2renderingcontext::WebGL2RenderingContext;
+ use js::rust::HandleValue;
+ use js::jsapi::JSContext;
+ use dom::bindings::trace::RootedTraceableBox;
+ use dom::node::{Node, window_from_node};
+ use dom::bindings::codegen::UnionTypes::OffscreenCanvasRenderingContext2DOrWebGLRenderingContextOrWebGL2RenderingContext;
+ use dom::eventtarget::EventTarget;
+
+#[derive(JSTraceable, MallocSizeOf)]
+ pub enum OffscreenRenderingContext {
+     Context2D(Dom<OffscreenCanvasRenderingContext2D>),
+     WebGL(Dom<WebGLRenderingContext>),
+     WebGL2(Dom<WebGL2RenderingContext>),
+ }
+
+ #[dom_struct]
+ pub struct OffscreenCanvas{
+     eventtarget: EventTarget,
+     height: u64,
+     width: u64,
+     context: DomRefCell<Option<OffscreenRenderingContext>>,
+     placeholder: Option<Dom<HTMLCanvasElement>>,
+ }
+
+ impl OffscreenCanvas{
+     pub fn new_inherited(height: u64, width: u64, placeholder: Option<&HTMLCanvasElement>) -> OffscreenCanvas {
+         OffscreenCanvas {
+             eventtarget: EventTarget::new_inherited(),
+             height: height,
+             width: width,
+             context: DomRefCell::new(None),
+             placeholder: placeholder.map(Dom::from_ref),
+         }
+     }
+
+     pub fn new(
+         global: &GlobalScope,
+          height: u64,
+           width: u64,
+            placeholder: Option<&HTMLCanvasElement>
+        ) -> DomRoot<OffscreenCanvas> {
+         reflect_dom_object(Box::new
+             (OffscreenCanvas::new_inherited(height,width,placeholder)), global, OffscreenCanvasWrap)
+     }
+
+     pub fn Constructor (global: &GlobalScope, height: u64, width: u64) -> Fallible<DomRoot<OffscreenCanvas>> {
+         //step 1
+         let offscreencanvas = OffscreenCanvas::new(global,height,width,None);
+         //step 2
+         if offscreencanvas.context.borrow().is_some() {
+             return Err(Error::InvalidState);
+         }
+
+         offscreencanvas.height = height;
+         offscreencanvas.width = width;
+
+         offscreencanvas.placeholder = None;
+
+         //step 3
+         Ok(offscreencanvas)
+     }
+
+     pub fn context(&self) -> Option<Ref<OffscreenRenderingContext>> {
+         ref_filter_map::ref_filter_map(self.context.borrow(), |ctx| ctx.as_ref())
+     }
+
+     fn get_or_init_2d_context(&self) -> Option<DomRoot<OffscreenCanvasRenderingContext2D>> {
+         if let Some(ctx) = self.context() {
+             return match *ctx {
+                 OffscreenRenderingContext::Context2D(ref ctx) => Some(DomRoot::from_ref(ctx)),
+                 _ => None,
+             };
+         }
+         //let window = window_from_node(self);
+         //let size = self.get_size();
+         let context = OffscreenCanvasRenderingContext2D::new(self);
+         *self.context.borrow_mut() = Some(OffscreenRenderingContext::Context2D(Dom::from_ref(&*context)));
+         Some(context)
+     }
+
+ }
+
+
+ impl OffscreenCanvasMethods for OffscreenCanvas{
+     #[allow(unsafe_code)]
+     unsafe fn GetContext(&self,cx: *mut JSContext, contextID: DOMString, options: HandleValue) -> Option<OffscreenCanvasRenderingContext2DOrWebGLRenderingContextOrWebGL2RenderingContext> {
+
+         //let options =
+         /*if !options.is_object() {
+             options = HandleValue::null();
+         }*/
+
+
+
+
+             if contextID == "2d"
+             {
+                 self.get_or_init_2d_context();
+             }
+
+
+        /* match &*contextID {
+             "2d" => self.get_or_init_2d_context(),
+             "webgl" | "experimental-webgl" => self
+                 .map(CanvasRenderingContext::WebGLRenderingContext),
+             "webgl2" | "experimental-webgl2" => self
+                 .map(CanvasRenderingContext::WebGL2RenderingContext)
+             _ => None,
+         } */
+
+     }
+
+
+
+     fn Width(&self) -> u64 {
+         return self.width;
+     }
+     fn SetWidth(&self, value: u64) -> () {
+         self.width = value;
+     }
+     fn Height(&self) -> u64 {
+         return self.height;
+     }
+     fn SetHeight(&self, value: u64) -> () {
+         self.height = value;
+     }
+ }

components/script/dom/offscreencanvasrenderingcontext2d.rs

@@ -0,0 +1,31 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+ use dom_struct::dom_struct;
+ use dom::bindings::codegen::Bindings::OffscreenCanvasRenderingContext2DBinding;
+ use dom::bindings::codegen::Bindings::OffscreenCanvasRenderingContext2DBinding::{Wrap as OffscreenCanvasRenderingContext2DWrap};
+ use dom::offscreencanvas::{OffscreenRenderingContext,OffscreenCanvas};
+ use dom::bindings::root::DomRoot;
+ use dom::globalscope::GlobalScope;
+ use dom::bindings::reflector::{DomObject, Reflector, reflect_dom_object};
+ use dom::bindings::root::Dom;
+
+ #[dom_struct]
+ pub struct OffscreenCanvasRenderingContext2D{
+     reflector_: Reflector,
+     canvas: Option<Dom<OffscreenCanvas>>,
+ }
+
+ impl OffscreenCanvasRenderingContext2D {
+     pub fn new_inherited(canvas: Option<&OffscreenCanvas>) -> OffscreenCanvasRenderingContext2D {
+         OffscreenCanvasRenderingContext2D {
+             reflector_: Reflector::new(),
+             canvas: canvas.map(Dom::from_ref),
+         }
+     }
+
+     pub fn new(canvas: Option<&OffscreenCanvas>) -> DomRoot<OffscreenCanvasRenderingContext2D> {
+         reflect_dom_object(Box::new(OffscreenCanvasRenderingContext2D::new_inherited(canvas)), OffscreenCanvasRenderingContext2DWrap)
+     }
+ }

components/script/dom/webidls/OffscreenCanvas.webidl

@@ -0,0 +1,28 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+
+
+typedef (OffscreenCanvasRenderingContext2D or WebGLRenderingContext or WebGL2RenderingContext) OffscreenRenderingContext;
+
+dictionary ImageEncodeOptions {
+  DOMString type = "image/png";
+  unrestricted double quality = 1.0;
+};
+
+//enum OffscreenRenderingContextId { "2d", "webgl", "webgl2" };
+
+[Constructor([EnforceRange] unsigned long long width, [EnforceRange] unsigned long long height), Exposed=(Window,Worker)/*, Transferable*/, Pref="dom.offscreen_canvas.enabled"]
+interface OffscreenCanvas : EventTarget {
+  attribute /*[EnforceRange]*/ unsigned long long width;
+  attribute /*[EnforceRange]*/ unsigned long long height;
+
+  OffscreenRenderingContext? getContext(DOMString contextId, optional any options = null);
+  //ImageBitmap transferToImageBitmap();
+  //Promise<Blob> convertToBlob(optional ImageEncodeOptions options);
+};
+
+
+
+

components/script/dom/webidls/OffscreenCanvasRenderingContext2d.webidl

@@ -0,0 +1,21 @@
+[Exposed=(Window,Worker), Pref="dom.offscreen_canvas.enabled"]
+interface OffscreenCanvasRenderingContext2D {
+  //void commit();
+  readonly attribute OffscreenCanvas canvas;
+};
+
+//OffscreenCanvasRenderingContext2D includes CanvasState;
+//OffscreenCanvasRenderingContext2D includes CanvasTransform;
+//OffscreenCanvasRenderingContext2D includes CanvasCompositing;
+//OffscreenCanvasRenderingContext2D includes CanvasImageSmoothing;
+//OffscreenCanvasRenderingContext2D includes CanvasFillStrokeStyles;
+//OffscreenCanvasRenderingContext2D includes CanvasShadowStyles;
+//OffscreenCanvasRenderingContext2D includes CanvasFilters;
+//OffscreenCanvasRenderingContext2D includes CanvasRect;
+//OffscreenCanvasRenderingContext2D includes CanvasDrawPath;
+//OffscreenCanvasRenderingContext2D includes CanvasText;
+//OffscreenCanvasRenderingContext2D includes CanvasDrawImage;
+//OffscreenCanvasRenderingContext2D includes CanvasImageData;
+//OffscreenCanvasRenderingContext2D includes CanvasPathDrawingStyles;
+//OffscreenCanvasRenderingContext2D includes CanvasTextDrawingStyles;
+//OffscreenCanvasRenderingContext2D includes CanvasPath;

resources/prefs.json

@@ -1,14 +1,15 @@
 {
   "dom.bluetooth.enabled": false,
   "dom.bluetooth.testing.enabled": false,
-  "dom.canvas-text.enabled": true,
+  "dom.canvas-text.enabled": true, 
   "dom.compositionevent.enabled": false,
   "dom.customelements.enabled": true,
   "dom.forcetouch.enabled": false,
   "dom.gamepad.enabled": false,
   "dom.microdata.testing.enabled": true,
   "dom.mouseevent.which.enabled": false,
   "dom.mutation_observer.enabled": true,
+  "dom.offscreen_canvas.enabled": true,
   "dom.permissions.enabled": false,
   "dom.permissions.testing.allowed_in_nonsecure_contexts": false,
   "dom.serviceworker.timeout_seconds": 60,