Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-08-06 06:00:15 +01:00
Code Issues Projects Releases Packages Wiki Activity

Auto merge of #14376 - nox:specialized-constructors, r=KiChjang,nox

Browse source 
Make WebIDL static items take a more specific global if possible

<!-- Reviewable:start -->
This change is [<img src="https://reviewable.io/review_button.svg" height="34" align="absmiddle" alt="Reviewable"/>](https://reviewable.io/reviews/servo/servo/14376)
<!-- Reviewable:end -->
This commit is contained in:
bors-servo 2016-11-30 15:43:48 -08:00 • committed by GitHub
commit e315da0731
46 changed files with 151 additions and 134 deletions
Download patch file Download diff file Expand all files Collapse all files

22
components/script/dom/bindings/codegen/CodegenRust.py
View file

@ -3168,7 +3168,7 @@ class CGCallGenerator(CGThing):
if isFallible:
if static:
glob = "&global"
glob = "global.upcast::<GlobalScope>()"
else:
glob = "&this.global()"
@ -3378,12 +3378,13 @@ class CGAbstractStaticBindingMethod(CGAbstractMethod):
Argument('*mut JSVal', 'vp'),
]
CGAbstractMethod.__init__(self, descriptor, name, "bool", args, extern=True)
self.exposureSet = descriptor.interface.exposureSet
def definition_body(self):
preamble = CGGeneric("""\
let global = GlobalScope::from_object(JS_CALLEE(cx, vp).to_object());
""")
return CGList([preamble, self.generate_code()])
preamble = "let global = GlobalScope::from_object(JS_CALLEE(cx, vp).to_object());\n"
if len(self.exposureSet) == 1:
preamble += "let global = Root::downcast::<dom::types::%s>(global).unwrap();\n" % list(self.exposureSet)[0]
return CGList([CGGeneric(preamble), self.generate_code()])
def generate_code(self):
raise NotImplementedError # Override me!
@ -5245,12 +5246,14 @@ class CGClassConstructHook(CGAbstractExternMethod):
assert constructor
CGAbstractExternMethod.__init__(self, descriptor, name, 'bool', args)
self.constructor = constructor
self.exposureSet = descriptor.interface.exposureSet
def definition_body(self):
preamble = CGGeneric("""\
let global = GlobalScope::from_object(JS_CALLEE(cx, vp).to_object());
let args = CallArgs::from_vp(vp, argc);
""")
preamble = """let global = GlobalScope::from_object(JS_CALLEE(cx, vp).to_object());\n"""
if len(self.exposureSet) == 1:
preamble += "let global = Root::downcast::<dom::types::%s>(global).unwrap();\n" % list(self.exposureSet)[0]
preamble += """let args = CallArgs::from_vp(vp, argc);\n"""
preamble = CGGeneric(preamble)
name = self.constructor.identifier.name
nativeName = MakeNativeName(self.descriptor.binaryNameFor(name))
callGenerator = CGMethodCall(["&global"], nativeName, True,
@ -5582,6 +5585,7 @@ def generate_imports(config, cgthings, descriptors, callbacks=None, dictionaries
'dom::bindings::error::throw_dom_exception',
'dom::bindings::guard::Condition',
'dom::bindings::guard::Guard',
'dom::bindings::inheritance::Castable',
'dom::bindings::proxyhandler',
'dom::bindings::proxyhandler::ensure_expando_object',
'dom::bindings::proxyhandler::fill_property_descriptor',

10
components/script/dom/bluetoothuuid.rs
View file

@ -7,7 +7,7 @@ use dom::bindings::error::Error::Syntax;
use dom::bindings::error::Fallible;
use dom::bindings::reflector::Reflector;
use dom::bindings::str::DOMString;
use dom::globalscope::GlobalScope;
use dom::window::Window;
use regex::Regex;
pub type UUID = DOMString;
@ -271,22 +271,22 @@ const VALID_UUID_REGEX: &'static str = "^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-
impl BluetoothUUID {
// https://webbluetoothcg.github.io/web-bluetooth/#dom-bluetoothuuid-canonicaluuid
pub fn CanonicalUUID(_: &GlobalScope, alias: u32) -> UUID {
pub fn CanonicalUUID(_: &Window, alias: u32) -> UUID {
canonical_uuid(alias)
}
// https://webbluetoothcg.github.io/web-bluetooth/#dom-bluetoothuuid-getservice
pub fn GetService(_: &GlobalScope, name: BluetoothServiceUUID) -> Fallible<UUID> {
pub fn GetService(_: &Window, name: BluetoothServiceUUID) -> Fallible<UUID> {
Self::service(name)
}
// https://webbluetoothcg.github.io/web-bluetooth/#dom-bluetoothuuid-getcharacteristic
pub fn GetCharacteristic(_: &GlobalScope, name: BluetoothCharacteristicUUID) -> Fallible<UUID> {
pub fn GetCharacteristic(_: &Window, name: BluetoothCharacteristicUUID) -> Fallible<UUID> {
Self::characteristic(name)
}
// https://webbluetoothcg.github.io/web-bluetooth/#dom-bluetoothuuid-getdescriptor
pub fn GetDescriptor(_: &GlobalScope, name: BluetoothDescriptorUUID) -> Fallible<UUID> {
pub fn GetDescriptor(_: &Window, name: BluetoothDescriptorUUID) -> Fallible<UUID> {
Self::descriptor(name)
}
}

6
components/script/dom/comment.rs
View file

@ -9,8 +9,8 @@ use dom::bindings::js::Root;
use dom::bindings::str::DOMString;
use dom::characterdata::CharacterData;
use dom::document::Document;
use dom::globalscope::GlobalScope;
use dom::node::Node;
use dom::window::Window;
/// An HTML comment.
#[dom_struct]
@ -31,8 +31,8 @@ impl Comment {
CommentBinding::Wrap)
}
pub fn Constructor(global: &GlobalScope, data: DOMString) -> Fallible<Root<Comment>> {
let document = global.as_window().Document();
pub fn Constructor(window: &Window, data: DOMString) -> Fallible<Root<Comment>> {
let document = window.Document();
Ok(Comment::new(data, &document))
}
}

4
components/script/dom/css.rs
View file

@ -6,7 +6,7 @@ use cssparser::serialize_identifier;
use dom::bindings::error::Fallible;
use dom::bindings::reflector::Reflector;
use dom::bindings::str::DOMString;
use dom::globalscope::GlobalScope;
use dom::window::Window;
#[dom_struct]
pub struct CSS {
@ -15,7 +15,7 @@ pub struct CSS {
impl CSS {
// http://dev.w3.org/csswg/cssom/#serialize-an-identifier
pub fn Escape(_: &GlobalScope, ident: DOMString) -> Fallible<DOMString> {
pub fn Escape(_: &Window, ident: DOMString) -> Fallible<DOMString> {
let mut escaped = String::new();
serialize_identifier(&ident, &mut escaped).unwrap();
Ok(DOMString::from(escaped))

9
components/script/dom/document.rs
View file

@ -1884,11 +1884,10 @@ impl Document {
}
// https://dom.spec.whatwg.org/#dom-document
pub fn Constructor(global: &GlobalScope) -> Fallible<Root<Document>> {
let win = global.as_window();
let doc = win.Document();
pub fn Constructor(window: &Window) -> Fallible<Root<Document>> {
let doc = window.Document();
let docloader = DocumentLoader::new(&*doc.loader());
Ok(Document::new(win,
Ok(Document::new(window,
None,
None,
IsHTMLDocument::NonHTMLDocument,
@ -2426,7 +2425,7 @@ impl DocumentMethods for Document {
)
)),
"webglcontextevent" =>
Ok(Root::upcast(WebGLContextEvent::new_uninitialized(self.window.upcast()))),
Ok(Root::upcast(WebGLContextEvent::new_uninitialized(&self.window))),
"storageevent" => {
let USVString(url) = self.URL();
Ok(Root::upcast(StorageEvent::new_uninitialized(&self.window, DOMString::from(url))))

6
components/script/dom/documentfragment.rs
View file

@ -12,10 +12,10 @@ use dom::bindings::js::Root;
use dom::bindings::str::DOMString;
use dom::document::Document;
use dom::element::Element;
use dom::globalscope::GlobalScope;
use dom::htmlcollection::HTMLCollection;
use dom::node::{Node, window_from_node};
use dom::nodelist::NodeList;
use dom::window::Window;
use servo_atoms::Atom;
// https://dom.spec.whatwg.org/#documentfragment
@ -38,8 +38,8 @@ impl DocumentFragment {
DocumentFragmentBinding::Wrap)
}
pub fn Constructor(global: &GlobalScope) -> Fallible<Root<DocumentFragment>> {
let document = global.as_window().Document();
pub fn Constructor(window: &Window) -> Fallible<Root<DocumentFragment>> {
let document = window.Document();
Ok(DocumentFragment::new(&document))
}

5
components/script/dom/domparser.rs
View file

@ -17,7 +17,6 @@ use dom::bindings::reflector::{Reflector, reflect_dom_object};
use dom::bindings::str::DOMString;
use dom::document::{Document, IsHTMLDocument};
use dom::document::DocumentSource;
use dom::globalscope::GlobalScope;
use dom::servoparser::ServoParser;
use dom::window::Window;
@ -41,8 +40,8 @@ impl DOMParser {
DOMParserBinding::Wrap)
}
pub fn Constructor(global: &GlobalScope) -> Fallible<Root<DOMParser>> {
Ok(DOMParser::new(global.as_window()))
pub fn Constructor(window: &Window) -> Fallible<Root<DOMParser>> {
Ok(DOMParser::new(window))
}
}

10
components/script/dom/extendableevent.rs
View file

@ -10,7 +10,7 @@ use dom::bindings::js::Root;
use dom::bindings::reflector::reflect_dom_object;
use dom::bindings::str::DOMString;
use dom::event::Event;
use dom::globalscope::GlobalScope;
use dom::serviceworkerglobalscope::ServiceWorkerGlobalScope;
use js::jsapi::{HandleValue, JSContext};
use servo_atoms::Atom;
@ -28,12 +28,12 @@ impl ExtendableEvent {
extensions_allowed: true
}
}
pub fn new(global: &GlobalScope,
pub fn new(worker: &ServiceWorkerGlobalScope,
type_: Atom,
bubbles: bool,
cancelable: bool)
-> Root<ExtendableEvent> {
let ev = reflect_dom_object(box ExtendableEvent::new_inherited(), global, ExtendableEventBinding::Wrap);
let ev = reflect_dom_object(box ExtendableEvent::new_inherited(), worker, ExtendableEventBinding::Wrap);
{
let event = ev.upcast::<Event>();
event.init_event(type_, bubbles, cancelable);
@ -41,10 +41,10 @@ impl ExtendableEvent {
ev
}
pub fn Constructor(global: &GlobalScope,
pub fn Constructor(worker: &ServiceWorkerGlobalScope,
type_: DOMString,
init: &ExtendableEventBinding::ExtendableEventInit) -> Fallible<Root<ExtendableEvent>> {
Ok(ExtendableEvent::new(global,
Ok(ExtendableEvent::new(worker,
Atom::from(type_),
init.parent.bubbles,
init.parent.cancelable))

4
components/script/dom/extendablemessageevent.rs
View file

@ -13,6 +13,7 @@ use dom::event::Event;
use dom::eventtarget::EventTarget;
use dom::extendableevent::ExtendableEvent;
use dom::globalscope::GlobalScope;
use dom::serviceworkerglobalscope::ServiceWorkerGlobalScope;
use js::jsapi::{HandleValue, Heap, JSContext};
use js::jsval::JSVal;
use servo_atoms::Atom;
@ -46,10 +47,11 @@ impl ExtendableMessageEvent {
ev
}
pub fn Constructor(global: &GlobalScope,
pub fn Constructor(worker: &ServiceWorkerGlobalScope,
type_: DOMString,
init: &ExtendableMessageEventBinding::ExtendableMessageEventInit)
-> Fallible<Root<ExtendableMessageEvent>> {
let global = worker.upcast::<GlobalScope>();
rooted!(in(global.get_cx()) let data = init.data);
let ev = ExtendableMessageEvent::new(global,
Atom::from(type_),

4
components/script/dom/focusevent.rs
View file

@ -53,12 +53,12 @@ impl FocusEvent {
ev
}
pub fn Constructor(global: &GlobalScope,
pub fn Constructor(window: &Window,
type_: DOMString,
init: &FocusEventBinding::FocusEventInit) -> Fallible<Root<FocusEvent>> {
let bubbles = EventBubbles::from(init.parent.parent.bubbles);
let cancelable = EventCancelable::from(init.parent.parent.cancelable);
let event = FocusEvent::new(global.as_window(),
let event = FocusEvent::new(window,
type_,
bubbles,
cancelable,

2
components/script/dom/htmlcanvaselement.rs
View file

@ -177,7 +177,7 @@ impl HTMLCanvasElement {
GLContextAttributes::default()
};
let maybe_ctx = WebGLRenderingContext::new(window.upcast(), self, size, attrs);
let maybe_ctx = WebGLRenderingContext::new(&window, self, size, attrs);
*self.context.borrow_mut() = maybe_ctx.map( |ctx| CanvasContext::WebGL(JS::from_ref(&*ctx)));
}

6
components/script/dom/htmlimageelement.rs
View file

@ -16,11 +16,11 @@ use dom::bindings::str::DOMString;
use dom::document::Document;
use dom::element::{AttributeMutation, Element, RawLayoutElementHelpers};
use dom::eventtarget::EventTarget;
use dom::globalscope::GlobalScope;
use dom::htmlelement::HTMLElement;
use dom::node::{Node, NodeDamage, document_from_node, window_from_node};
use dom::values::UNSIGNED_LONG_MAX;
use dom::virtualmethods::VirtualMethods;
use dom::window::Window;
use html5ever_atoms::LocalName;
use ipc_channel::ipc;
use ipc_channel::router::ROUTER;
@ -220,10 +220,10 @@ impl HTMLImageElement {
HTMLImageElementBinding::Wrap)
}
pub fn Image(global: &GlobalScope,
pub fn Image(window: &Window,
width: Option<u32>,
height: Option<u32>) -> Fallible<Root<HTMLImageElement>> {
let document = global.as_window().Document();
let document = window.Document();
let image = HTMLImageElement::new(local_name!("img"), None, &document);
if let Some(w) = width {
image.SetWidth(w);

5
components/script/dom/keyboardevent.rs
View file

@ -12,7 +12,6 @@ use dom::bindings::js::{Root, RootedReference};
use dom::bindings::reflector::reflect_dom_object;
use dom::bindings::str::DOMString;
use dom::event::Event;
use dom::globalscope::GlobalScope;
use dom::uievent::UIEvent;
use dom::window::Window;
use msg::constellation_msg;
@ -101,10 +100,10 @@ impl KeyboardEvent {
ev
}
pub fn Constructor(global: &GlobalScope,
pub fn Constructor(window: &Window,
type_: DOMString,
init: &KeyboardEventBinding::KeyboardEventInit) -> Fallible<Root<KeyboardEvent>> {
let event = KeyboardEvent::new(global.as_window(),
let event = KeyboardEvent::new(window,
type_,
init.parent.parent.parent.bubbles,
init.parent.parent.parent.cancelable,

5
components/script/dom/mouseevent.rs
View file

@ -12,7 +12,6 @@ use dom::bindings::reflector::reflect_dom_object;
use dom::bindings::str::DOMString;
use dom::event::{Event, EventBubbles, EventCancelable};
use dom::eventtarget::EventTarget;
use dom::globalscope::GlobalScope;
use dom::uievent::UIEvent;
use dom::window::Window;
use std::cell::Cell;
@ -82,12 +81,12 @@ impl MouseEvent {
ev
}
pub fn Constructor(global: &GlobalScope,
pub fn Constructor(window: &Window,
type_: DOMString,
init: &MouseEventBinding::MouseEventInit) -> Fallible<Root<MouseEvent>> {
let bubbles = EventBubbles::from(init.parent.parent.parent.bubbles);
let cancelable = EventCancelable::from(init.parent.parent.parent.cancelable);
let event = MouseEvent::new(global.as_window(),
let event = MouseEvent::new(window,
type_,
bubbles,
cancelable,

6
components/script/dom/range.rs
View file

@ -22,11 +22,11 @@ use dom::characterdata::CharacterData;
use dom::document::Document;
use dom::documentfragment::DocumentFragment;
use dom::element::Element;
use dom::globalscope::GlobalScope;
use dom::htmlbodyelement::HTMLBodyElement;
use dom::htmlscriptelement::HTMLScriptElement;
use dom::node::{Node, UnbindContext};
use dom::text::Text;
use dom::window::Window;
use heapsize::HeapSizeOf;
use js::jsapi::JSTracer;
use std::cell::{Cell, UnsafeCell};
@ -70,8 +70,8 @@ impl Range {
}
// https://dom.spec.whatwg.org/#dom-range
pub fn Constructor(global: &GlobalScope) -> Fallible<Root<Range>> {
let document = global.as_window().Document();
pub fn Constructor(window: &Window) -> Fallible<Root<Range>> {
let document = window.Document();
Ok(Range::new_with_doc(&document))
}

2
components/script/dom/serviceworkerglobalscope.rs
View file

@ -319,7 +319,7 @@ impl ServiceWorkerGlobalScope {
}
fn dispatch_activate(&self) {
let event = ExtendableEvent::new(self.upcast(), atom!("activate"), false, false);
let event = ExtendableEvent::new(self, atom!("activate"), false, false);
let event = (&*event).upcast::<Event>();
self.upcast::<EventTarget>().dispatch_event(event);
}

6
components/script/dom/text.rs
View file

@ -14,8 +14,8 @@ use dom::bindings::js::RootedReference;
use dom::bindings::str::DOMString;
use dom::characterdata::CharacterData;
use dom::document::Document;
use dom::globalscope::GlobalScope;
use dom::node::Node;
use dom::window::Window;
/// An HTML text node.
#[dom_struct]
@ -35,8 +35,8 @@ impl Text {
document, TextBinding::Wrap)
}
pub fn Constructor(global: &GlobalScope, text: DOMString) -> Fallible<Root<Text>> {
let document = global.as_window().Document();
pub fn Constructor(window: &Window, text: DOMString) -> Fallible<Root<Text>> {
let document = window.Document();
Ok(Text::new(text, &document))
}
}

4
components/script/dom/transitionevent.rs
View file

@ -13,6 +13,7 @@ use dom::bindings::reflector::reflect_dom_object;
use dom::bindings::str::DOMString;
use dom::event::Event;
use dom::globalscope::GlobalScope;
use dom::window::Window;
use servo_atoms::Atom;
#[dom_struct]
@ -46,9 +47,10 @@ impl TransitionEvent {
ev
}
pub fn Constructor(global: &GlobalScope,
pub fn Constructor(window: &Window,
type_: DOMString,
init: &TransitionEventInit) -> Fallible<Root<TransitionEvent>> {
let global = window.upcast::<GlobalScope>();
Ok(TransitionEvent::new(global, Atom::from(type_), init))
}
}

5
components/script/dom/uievent.rs
View file

@ -12,7 +12,6 @@ use dom::bindings::js::Root;
use dom::bindings::reflector::reflect_dom_object;
use dom::bindings::str::DOMString;
use dom::event::{Event, EventBubbles, EventCancelable};
use dom::globalscope::GlobalScope;
use dom::window::Window;
use servo_atoms::Atom;
use std::cell::Cell;
@ -52,12 +51,12 @@ impl UIEvent {
ev
}
pub fn Constructor(global: &GlobalScope,
pub fn Constructor(window: &Window,
type_: DOMString,
init: &UIEventBinding::UIEventInit) -> Fallible<Root<UIEvent>> {
let bubbles = EventBubbles::from(init.parent.bubbles);
let cancelable = EventCancelable::from(init.parent.cancelable);
let event = UIEvent::new(global.as_window(),
let event = UIEvent::new(window,
type_,
bubbles, cancelable,
init.view.r(), init.detail);

6
components/script/dom/webglactiveinfo.rs
View file

@ -8,7 +8,7 @@ use dom::bindings::codegen::Bindings::WebGLActiveInfoBinding::WebGLActiveInfoMet
use dom::bindings::js::Root;
use dom::bindings::reflector::{Reflector, reflect_dom_object};
use dom::bindings::str::DOMString;
use dom::globalscope::GlobalScope;
use dom::window::Window;
#[dom_struct]
pub struct WebGLActiveInfo {
@ -29,8 +29,8 @@ impl WebGLActiveInfo {
}
}
pub fn new(global: &GlobalScope, size: i32, ty: u32, name: DOMString) -> Root<WebGLActiveInfo> {
reflect_dom_object(box WebGLActiveInfo::new_inherited(size, ty, name), global, WebGLActiveInfoBinding::Wrap)
pub fn new(window: &Window, size: i32, ty: u32, name: DOMString) -> Root<WebGLActiveInfo> {
reflect_dom_object(box WebGLActiveInfo::new_inherited(size, ty, name), window, WebGLActiveInfoBinding::Wrap)
}
}

10
components/script/dom/webglbuffer.rs
View file

@ -7,8 +7,8 @@ use canvas_traits::CanvasMsg;
use dom::bindings::codegen::Bindings::WebGLBufferBinding;
use dom::bindings::js::Root;
use dom::bindings::reflector::reflect_dom_object;
use dom::globalscope::GlobalScope;
use dom::webglobject::WebGLObject;
use dom::window::Window;
use ipc_channel::ipc::IpcSender;
use std::cell::Cell;
use webrender_traits;
@ -40,21 +40,21 @@ impl WebGLBuffer {
}
}
pub fn maybe_new(global: &GlobalScope, renderer: IpcSender<CanvasMsg>)
pub fn maybe_new(window: &Window, renderer: IpcSender<CanvasMsg>)
-> Option<Root<WebGLBuffer>> {
let (sender, receiver) = webrender_traits::channel::msg_channel().unwrap();
renderer.send(CanvasMsg::WebGL(WebGLCommand::CreateBuffer(sender))).unwrap();
let result = receiver.recv().unwrap();
result.map(|buffer_id| WebGLBuffer::new(global, renderer, buffer_id))
result.map(|buffer_id| WebGLBuffer::new(window, renderer, buffer_id))
}
pub fn new(global: &GlobalScope,
pub fn new(window: &Window,
renderer: IpcSender<CanvasMsg>,
id: WebGLBufferId)
-> Root<WebGLBuffer> {
reflect_dom_object(box WebGLBuffer::new_inherited(renderer, id),
global, WebGLBufferBinding::Wrap)
window, WebGLBufferBinding::Wrap)
}
}

14
components/script/dom/webglcontextevent.rs
View file

@ -12,7 +12,7 @@ use dom::bindings::js::Root;
use dom::bindings::reflector::reflect_dom_object;
use dom::bindings::str::DOMString;
use dom::event::{Event, EventBubbles, EventCancelable};
use dom::globalscope::GlobalScope;
use dom::window::Window;
use servo_atoms::Atom;
#[dom_struct]
@ -41,25 +41,25 @@ impl WebGLContextEvent {
}
}
pub fn new_uninitialized(global_ref: &GlobalScope) -> Root<WebGLContextEvent> {
pub fn new_uninitialized(window: &Window) -> Root<WebGLContextEvent> {
// according to https://www.khronos.org/registry/webgl/specs/1.0/#5.15 this is
// additional information or the empty string if no additional information is
// available.
let status_message = DOMString::new();
reflect_dom_object(
box WebGLContextEvent::new_inherited(status_message),
global_ref,
window,
WebGLContextEventBinding::Wrap)
}
pub fn new(global: &GlobalScope,
pub fn new(window: &Window,
type_: Atom,
bubbles: EventBubbles,
cancelable: EventCancelable,
status_message: DOMString) -> Root<WebGLContextEvent> {
let event = reflect_dom_object(
box WebGLContextEvent::new_inherited(status_message),
global,
window,
WebGLContextEventBinding::Wrap);
{
@ -70,7 +70,7 @@ impl WebGLContextEvent {
event
}
pub fn Constructor(global: &GlobalScope,
pub fn Constructor(window: &Window,
type_: DOMString,
init: &WebGLContextEventInit) -> Fallible<Root<WebGLContextEvent>> {
let status_message = match init.statusMessage.as_ref() {
@ -82,7 +82,7 @@ impl WebGLContextEvent {
let cancelable = EventCancelable::from(init.parent.cancelable);
Ok(WebGLContextEvent::new(global,
Ok(WebGLContextEvent::new(window,
Atom::from(type_),
bubbles,
cancelable,

10
components/script/dom/webglframebuffer.rs
View file

@ -9,10 +9,10 @@ use dom::bindings::codegen::Bindings::WebGLFramebufferBinding;
use dom::bindings::codegen::Bindings::WebGLRenderingContextBinding::WebGLRenderingContextConstants as constants;
use dom::bindings::js::{HeapGCValue, JS, Root};
use dom::bindings::reflector::reflect_dom_object;
use dom::globalscope::GlobalScope;
use dom::webglobject::WebGLObject;
use dom::webglrenderbuffer::WebGLRenderbuffer;
use dom::webgltexture::WebGLTexture;
use dom::window::Window;
use ipc_channel::ipc::IpcSender;
use std::cell::Cell;
use webrender_traits;
@ -66,21 +66,21 @@ impl WebGLFramebuffer {
}
}
pub fn maybe_new(global: &GlobalScope, renderer: IpcSender<CanvasMsg>)
pub fn maybe_new(window: &Window, renderer: IpcSender<CanvasMsg>)
-> Option<Root<WebGLFramebuffer>> {
let (sender, receiver) = webrender_traits::channel::msg_channel().unwrap();
renderer.send(CanvasMsg::WebGL(WebGLCommand::CreateFramebuffer(sender))).unwrap();
let result = receiver.recv().unwrap();
result.map(|fb_id| WebGLFramebuffer::new(global, renderer, fb_id))
result.map(|fb_id| WebGLFramebuffer::new(window, renderer, fb_id))
}
pub fn new(global: &GlobalScope,
pub fn new(window: &Window,
renderer: IpcSender<CanvasMsg>,
id: WebGLFramebufferId)
-> Root<WebGLFramebuffer> {
reflect_dom_object(box WebGLFramebuffer::new_inherited(renderer, id),
global,
window,
WebGLFramebufferBinding::Wrap)
}
}

6
components/script/dom/webglobject.rs
View file

@ -6,7 +6,7 @@
use dom::bindings::codegen::Bindings::WebGLObjectBinding;
use dom::bindings::js::Root;
use dom::bindings::reflector::{Reflector, reflect_dom_object};
use dom::globalscope::GlobalScope;
use dom::window::Window;
#[dom_struct]
pub struct WebGLObject {
@ -20,7 +20,7 @@ impl WebGLObject {
}
}
pub fn new(global: &GlobalScope) -> Root<WebGLObject> {
reflect_dom_object(box WebGLObject::new_inherited(), global, WebGLObjectBinding::Wrap)
pub fn new(window: &Window) -> Root<WebGLObject> {
reflect_dom_object(box WebGLObject::new_inherited(), window, WebGLObjectBinding::Wrap)
}
}

14
components/script/dom/webglprogram.rs
View file

@ -9,11 +9,11 @@ use dom::bindings::codegen::Bindings::WebGLRenderingContextBinding::WebGLRenderi
use dom::bindings::js::{JS, MutNullableHeap, Root};
use dom::bindings::reflector::{Reflectable, reflect_dom_object};
use dom::bindings::str::DOMString;
use dom::globalscope::GlobalScope;
use dom::webglactiveinfo::WebGLActiveInfo;
use dom::webglobject::WebGLObject;
use dom::webglrenderingcontext::MAX_UNIFORM_AND_ATTRIBUTE_LEN;
use dom::webglshader::WebGLShader;
use dom::window::Window;
use ipc_channel::ipc::IpcSender;
use std::cell::Cell;
use webrender_traits;
@ -49,21 +49,21 @@ impl WebGLProgram {
}
}
pub fn maybe_new(global: &GlobalScope, renderer: IpcSender<CanvasMsg>)
pub fn maybe_new(window: &Window, renderer: IpcSender<CanvasMsg>)
-> Option<Root<WebGLProgram>> {
let (sender, receiver) = webrender_traits::channel::msg_channel().unwrap();
renderer.send(CanvasMsg::WebGL(WebGLCommand::CreateProgram(sender))).unwrap();
let result = receiver.recv().unwrap();
result.map(|program_id| WebGLProgram::new(global, renderer, program_id))
result.map(|program_id| WebGLProgram::new(window, renderer, program_id))
}
pub fn new(global: &GlobalScope,
pub fn new(window: &Window,
renderer: IpcSender<CanvasMsg>,
id: WebGLProgramId)
-> Root<WebGLProgram> {
reflect_dom_object(box WebGLProgram::new_inherited(renderer, id),
global,
window,
WebGLProgramBinding::Wrap)
}
}
@ -231,7 +231,7 @@ impl WebGLProgram {
.unwrap();
receiver.recv().unwrap().map(|(size, ty, name)|
WebGLActiveInfo::new(&self.global(), size, ty, DOMString::from(name)))
WebGLActiveInfo::new(self.global().as_window(), size, ty, DOMString::from(name)))
}
/// glGetActiveAttrib
@ -245,7 +245,7 @@ impl WebGLProgram {
.unwrap();
receiver.recv().unwrap().map(|(size, ty, name)|
WebGLActiveInfo::new(&self.global(), size, ty, DOMString::from(name)))
WebGLActiveInfo::new(self.global().as_window(), size, ty, DOMString::from(name)))
}
/// glGetAttribLocation

10
components/script/dom/webglrenderbuffer.rs
View file

@ -8,8 +8,8 @@ use dom::bindings::codegen::Bindings::WebGLRenderbufferBinding;
use dom::bindings::codegen::Bindings::WebGLRenderingContextBinding::WebGLRenderingContextConstants as constants;
use dom::bindings::js::Root;
use dom::bindings::reflector::reflect_dom_object;
use dom::globalscope::GlobalScope;
use dom::webglobject::WebGLObject;
use dom::window::Window;
use ipc_channel::ipc::IpcSender;
use std::cell::Cell;
use webrender_traits;
@ -42,21 +42,21 @@ impl WebGLRenderbuffer {
}
}
pub fn maybe_new(global: &GlobalScope, renderer: IpcSender<CanvasMsg>)
pub fn maybe_new(window: &Window, renderer: IpcSender<CanvasMsg>)
-> Option<Root<WebGLRenderbuffer>> {
let (sender, receiver) = webrender_traits::channel::msg_channel().unwrap();
renderer.send(CanvasMsg::WebGL(WebGLCommand::CreateRenderbuffer(sender))).unwrap();
let result = receiver.recv().unwrap();
result.map(|renderbuffer_id| WebGLRenderbuffer::new(global, renderer, renderbuffer_id))
result.map(|renderbuffer_id| WebGLRenderbuffer::new(window, renderer, renderbuffer_id))
}
pub fn new(global: &GlobalScope,
pub fn new(window: &Window,
renderer: IpcSender<CanvasMsg>,
id: WebGLRenderbufferId)
-> Root<WebGLRenderbuffer> {
reflect_dom_object(box WebGLRenderbuffer::new_inherited(renderer, id),
global,
window,
WebGLRenderbufferBinding::Wrap)
}
}

27
components/script/dom/webglrenderingcontext.rs
View file

@ -34,6 +34,7 @@ use dom::webglrenderbuffer::WebGLRenderbuffer;
use dom::webglshader::WebGLShader;
use dom::webgltexture::{TexParameterValue, WebGLTexture};
use dom::webgluniformlocation::WebGLUniformLocation;
use dom::window::Window;
use euclid::size::Size2D;
use ipc_channel::ipc::{self, IpcSender};
use js::conversions::ConversionBehavior;
@ -135,13 +136,13 @@ pub struct WebGLRenderingContext {
}
impl WebGLRenderingContext {
fn new_inherited(global: &GlobalScope,
fn new_inherited(window: &Window,
canvas: &HTMLCanvasElement,
size: Size2D<i32>,
attrs: GLContextAttributes)
-> Result<WebGLRenderingContext, String> {
let (sender, receiver) = ipc::channel().unwrap();
let constellation_chan = global.constellation_chan();
let constellation_chan = window.upcast::<GlobalScope>().constellation_chan();
constellation_chan.send(ConstellationMsg::CreateWebGLPaintThread(size, attrs, sender))
.unwrap();
let result = receiver.recv().unwrap();
@ -167,13 +168,13 @@ impl WebGLRenderingContext {
}
#[allow(unrooted_must_root)]
pub fn new(global: &GlobalScope, canvas: &HTMLCanvasElement, size: Size2D<i32>, attrs: GLContextAttributes)
pub fn new(window: &Window, canvas: &HTMLCanvasElement, size: Size2D<i32>, attrs: GLContextAttributes)
-> Option<Root<WebGLRenderingContext>> {
match WebGLRenderingContext::new_inherited(global, canvas, size, attrs) {
Ok(ctx) => Some(reflect_dom_object(box ctx, global, WebGLRenderingContextBinding::Wrap)),
match WebGLRenderingContext::new_inherited(window, canvas, size, attrs) {
Ok(ctx) => Some(reflect_dom_object(box ctx, window, WebGLRenderingContextBinding::Wrap)),
Err(msg) => {
error!("Couldn't create WebGLRenderingContext: {}", msg);
let event = WebGLContextEvent::new(global,
let event = WebGLContextEvent::new(window,
atom!("webglcontextcreationerror"),
EventBubbles::DoesNotBubble,
EventCancelable::Cancelable,
@ -1248,27 +1249,27 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
// generated objects, either here or in the webgl thread
// https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.5
fn CreateBuffer(&self) -> Option<Root<WebGLBuffer>> {
WebGLBuffer::maybe_new(&self.global(), self.ipc_renderer.clone())
WebGLBuffer::maybe_new(self.global().as_window(), self.ipc_renderer.clone())
}
// https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.6
fn CreateFramebuffer(&self) -> Option<Root<WebGLFramebuffer>> {
WebGLFramebuffer::maybe_new(&self.global(), self.ipc_renderer.clone())
WebGLFramebuffer::maybe_new(self.global().as_window(), self.ipc_renderer.clone())
}
// https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.7
fn CreateRenderbuffer(&self) -> Option<Root<WebGLRenderbuffer>> {
WebGLRenderbuffer::maybe_new(&self.global(), self.ipc_renderer.clone())
WebGLRenderbuffer::maybe_new(self.global().as_window(), self.ipc_renderer.clone())
}
// https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.8
fn CreateTexture(&self) -> Option<Root<WebGLTexture>> {
WebGLTexture::maybe_new(&self.global(), self.ipc_renderer.clone())
WebGLTexture::maybe_new(self.global().as_window(), self.ipc_renderer.clone())
}
// https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.9
fn CreateProgram(&self) -> Option<Root<WebGLProgram>> {
WebGLProgram::maybe_new(&self.global(), self.ipc_renderer.clone())
WebGLProgram::maybe_new(self.global().as_window(), self.ipc_renderer.clone())
}
// https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.9
@ -1280,7 +1281,7 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
return None;
}
}
WebGLShader::maybe_new(&self.global(), self.ipc_renderer.clone(), shader_type)
WebGLShader::maybe_new(self.global().as_window(), self.ipc_renderer.clone(), shader_type)
}
// https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.5
@ -1612,7 +1613,7 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
name: DOMString) -> Option<Root<WebGLUniformLocation>> {
program.and_then(|p| {
handle_potential_webgl_error!(self, p.get_uniform_location(name), None)
.map(|location| WebGLUniformLocation::new(&self.global(), location, p.id()))
.map(|location| WebGLUniformLocation::new(self.global().as_window(), location, p.id()))
})
}

13
components/script/dom/webglshader.rs
View file

@ -10,8 +10,8 @@ use dom::bindings::codegen::Bindings::WebGLShaderBinding;
use dom::bindings::js::Root;
use dom::bindings::reflector::reflect_dom_object;
use dom::bindings::str::DOMString;
use dom::globalscope::GlobalScope;
use dom::webglobject::WebGLObject;
use dom::window::Window;
use ipc_channel::ipc::IpcSender;
use std::cell::Cell;
use std::sync::{ONCE_INIT, Once};
@ -66,23 +66,24 @@ impl WebGLShader {
}
}
pub fn maybe_new(global: &GlobalScope,
pub fn maybe_new(window: &Window,
renderer: IpcSender<CanvasMsg>,
shader_type: u32) -> Option<Root<WebGLShader>> {
shader_type: u32)
-> Option<Root<WebGLShader>> {
let (sender, receiver) = webrender_traits::channel::msg_channel().unwrap();
renderer.send(CanvasMsg::WebGL(WebGLCommand::CreateShader(shader_type, sender))).unwrap();
let result = receiver.recv().unwrap();
result.map(|shader_id| WebGLShader::new(global, renderer, shader_id, shader_type))
result.map(|shader_id| WebGLShader::new(window, renderer, shader_id, shader_type))
}
pub fn new(global: &GlobalScope,
pub fn new(window: &Window,
renderer: IpcSender<CanvasMsg>,
id: WebGLShaderId,
shader_type: u32)
-> Root<WebGLShader> {
reflect_dom_object(box WebGLShader::new_inherited(renderer, id, shader_type),
global,
window,
WebGLShaderBinding::Wrap)
}
}

6
components/script/dom/webglshaderprecisionformat.rs
View file

@ -7,7 +7,7 @@ use dom::bindings::codegen::Bindings::WebGLShaderPrecisionFormatBinding;
use dom::bindings::codegen::Bindings::WebGLShaderPrecisionFormatBinding::WebGLShaderPrecisionFormatMethods;
use dom::bindings::js::Root;
use dom::bindings::reflector::{Reflector, reflect_dom_object};
use dom::globalscope::GlobalScope;
use dom::window::Window;
#[dom_struct]
pub struct WebGLShaderPrecisionFormat {
@ -27,13 +27,13 @@ impl WebGLShaderPrecisionFormat {
}
}
pub fn new(global: &GlobalScope,
pub fn new(window: &Window,
range_min: i32,
range_max: i32,
precision: i32) -> Root<WebGLShaderPrecisionFormat> {
reflect_dom_object(
box WebGLShaderPrecisionFormat::new_inherited(range_min, range_max, precision),
global,
window,
WebGLShaderPrecisionFormatBinding::Wrap)
}
}

10
components/script/dom/webgltexture.rs
View file

@ -9,9 +9,9 @@ use dom::bindings::codegen::Bindings::WebGLRenderingContextBinding::WebGLRenderi
use dom::bindings::codegen::Bindings::WebGLTextureBinding;
use dom::bindings::js::Root;
use dom::bindings::reflector::reflect_dom_object;
use dom::globalscope::GlobalScope;
use dom::webgl_validations::types::{TexImageTarget, TexFormat, TexDataType};
use dom::webglobject::WebGLObject;
use dom::window::Window;
use ipc_channel::ipc::IpcSender;
use std::cell::Cell;
use std::cmp;
@ -61,21 +61,21 @@ impl WebGLTexture {
}
}
pub fn maybe_new(global: &GlobalScope, renderer: IpcSender<CanvasMsg>)
pub fn maybe_new(window: &Window, renderer: IpcSender<CanvasMsg>)
-> Option<Root<WebGLTexture>> {
let (sender, receiver) = webrender_traits::channel::msg_channel().unwrap();
renderer.send(CanvasMsg::WebGL(WebGLCommand::CreateTexture(sender))).unwrap();
let result = receiver.recv().unwrap();
result.map(|texture_id| WebGLTexture::new(global, renderer, texture_id))
result.map(|texture_id| WebGLTexture::new(window, renderer, texture_id))
}
pub fn new(global: &GlobalScope,
pub fn new(window: &Window,
renderer: IpcSender<CanvasMsg>,
id: WebGLTextureId)
-> Root<WebGLTexture> {
reflect_dom_object(box WebGLTexture::new_inherited(renderer, id),
global,
window,
WebGLTextureBinding::Wrap)
}
}

6
components/script/dom/webgluniformlocation.rs
View file

@ -6,7 +6,7 @@
use dom::bindings::codegen::Bindings::WebGLUniformLocationBinding;
use dom::bindings::js::Root;
use dom::bindings::reflector::{Reflector, reflect_dom_object};
use dom::globalscope::GlobalScope;
use dom::window::Window;
use webrender_traits::WebGLProgramId;
#[dom_struct]
@ -27,12 +27,12 @@ impl WebGLUniformLocation {
}
}
pub fn new(global: &GlobalScope,
pub fn new(window: &Window,
id: i32,
program_id: WebGLProgramId)
-> Root<WebGLUniformLocation> {
reflect_dom_object(box WebGLUniformLocation::new_inherited(id, program_id),
global,
window,
WebGLUniformLocationBinding::Wrap)
}

7
components/script/dom/webidls/DOMMatrix.webidl
View file

@ -11,10 +11,9 @@
*/
[Constructor,
// Constructor(DOMString transformList),
Constructor(sequence<unrestricted double> numberSequence)
// Exposed=(Window,Worker)
]
// Constructor(DOMString transformList),
Constructor(sequence<unrestricted double> numberSequence),
Exposed=(Window,Worker)]
interface DOMMatrix : DOMMatrixReadOnly {
[NewObject, Throws] static DOMMatrix fromMatrix(optional DOMMatrixInit other);

7
components/script/dom/webidls/DOMMatrixReadOnly.webidl
View file

@ -11,10 +11,9 @@
*/
[Constructor,
// Constructor(DOMString transformList)
Constructor(sequence<unrestricted double> numberSequence),
// Exposed=(Window,Worker)
]
// Constructor(DOMString transformList)
Constructor(sequence<unrestricted double> numberSequence),
Exposed=(Window,Worker)]
interface DOMMatrixReadOnly {
[NewObject, Throws] static DOMMatrixReadOnly fromMatrix(optional DOMMatrixInit other);

1
components/script/dom/webidls/WebGLActiveInfo.webidl
View file

@ -6,6 +6,7 @@
// https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.7
//
[Exposed=Window]
interface WebGLActiveInfo {
readonly attribute GLint size;
readonly attribute GLenum type;

1
components/script/dom/webidls/WebGLBuffer.webidl
View file

@ -6,5 +6,6 @@
// https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.4
//
[Exposed=Window]
interface WebGLBuffer : WebGLObject {
};

3
components/script/dom/webidls/WebGLContextEvent.webidl
View file

@ -3,7 +3,8 @@
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
// https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.15
[Constructor(DOMString type, optional WebGLContextEventInit eventInit)]
[Constructor(DOMString type, optional WebGLContextEventInit eventInit),
Exposed=Window]
interface WebGLContextEvent : Event {
readonly attribute DOMString statusMessage;
};

1
components/script/dom/webidls/WebGLFramebuffer.webidl
View file

@ -6,5 +6,6 @@
// https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.7
//
[Exposed=Window]
interface WebGLFramebuffer : WebGLObject {
};

1
components/script/dom/webidls/WebGLObject.webidl
View file

@ -6,5 +6,6 @@
// https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.3
//
[Exposed=Window]
interface WebGLObject {
};

1
components/script/dom/webidls/WebGLProgram.webidl
View file

@ -6,5 +6,6 @@
// https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.6
//
[Exposed=Window]
interface WebGLProgram : WebGLObject {
};

1
components/script/dom/webidls/WebGLRenderbuffer.webidl
View file

@ -6,5 +6,6 @@
// https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.5
//
[Exposed=Window]
interface WebGLRenderbuffer : WebGLObject {
};

3
components/script/dom/webidls/WebGLRenderingContext.webidl
View file

@ -41,7 +41,7 @@ dictionary WebGLContextAttributes {
GLboolean failIfMajorPerformanceCaveat = false;
};
[NoInterfaceObject]
[Exposed=Window, NoInterfaceObject]
interface WebGLRenderingContextBase
{
@ -762,6 +762,7 @@ interface WebGLRenderingContextBase
void viewport(GLint x, GLint y, GLsizei width, GLsizei height);
};
[Exposed=Window]
interface WebGLRenderingContext
{
};

1
components/script/dom/webidls/WebGLShader.webidl
View file

@ -6,5 +6,6 @@
// https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.8
//
[Exposed=Window]
interface WebGLShader : WebGLObject {
};

1
components/script/dom/webidls/WebGLShaderPrecisionFormat.webidl
View file

@ -6,6 +6,7 @@
// https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.7
//
[Exposed=Window]
interface WebGLShaderPrecisionFormat {
readonly attribute GLint rangeMin;
readonly attribute GLint rangeMax;

1
components/script/dom/webidls/WebGLTexture.webidl
View file

@ -6,5 +6,6 @@
// https://www.khronos.org/registry/webgl/specs/latest/#5.9
//
[Exposed=Window]
interface WebGLTexture : WebGLObject {
};

1
components/script/dom/webidls/WebGLUniformLocation.webidl
View file

@ -6,5 +6,6 @@
// https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.10
//
[Exposed=Window]
interface WebGLUniformLocation {
};

2
tests/wpt/mozilla/tests/mozilla/interfaces.worker.js
View file

@ -11,6 +11,8 @@ test_interfaces([
"Blob",
"CloseEvent",
"CSSStyleDeclaration",
"DOMMatrix",
"DOMMatrixReadOnly",
"DOMPoint",
"DOMPointReadOnly",
"DOMQuad",