Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-10-09 04:59:23 +01:00
Code Issues Projects Releases Packages Wiki Activity

auto merge of #2633 : Ms2ger/servo/derefmut, r=jdm

Browse source 
Part of #1854.
This commit is contained in:
bors-servo 2014-06-11 13:59:01 -04:00
commit cc23f3c436
22 changed files with 417 additions and 406 deletions
Download patch file Download diff file Expand all files Collapse all files

8
src/components/main/layout/wrapper.rs
View file

@ -112,7 +112,7 @@ pub trait TLayoutNode {
fail!("not an iframe element!") fail!("not an iframe element!")
} }
let iframe_element: JS<HTMLIFrameElement> = self.get_jsmanaged().transmute_copy(); let iframe_element: JS<HTMLIFrameElement> = self.get_jsmanaged().transmute_copy();
let size = (*iframe_element.unsafe_get()).size.unwrap(); let size = (*iframe_element.unsafe_get()).size.deref().get().unwrap();
(size.pipeline_id, size.subpage_id) (size.pipeline_id, size.subpage_id)
} }
} }
@ -188,7 +188,7 @@ impl<'ln> TLayoutNode for LayoutNode<'ln> {
fail!("not text!") fail!("not text!")
} }
let text: JS<Text> = self.get_jsmanaged().transmute_copy(); let text: JS<Text> = self.get_jsmanaged().transmute_copy();
(*text.unsafe_get()).characterdata.data.to_str() (*text.unsafe_get()).characterdata.data.deref().borrow().clone()
} }
} }
} }
@ -494,7 +494,7 @@ impl<'ln> TLayoutNode for ThreadSafeLayoutNode<'ln> {
fail!("not text!") fail!("not text!")
} }
let text: JS<Text> = self.get_jsmanaged().transmute_copy(); let text: JS<Text> = self.get_jsmanaged().transmute_copy();
(*text.unsafe_get()).characterdata.data.to_str() (*text.unsafe_get()).characterdata.data.deref().borrow().clone()
} }
} }
} }
@ -636,7 +636,7 @@ impl<'ln> ThreadSafeLayoutNode<'ln> {
Some(TextNodeTypeId) => { Some(TextNodeTypeId) => {
unsafe { unsafe {
let text: JS<Text> = self.get_jsmanaged().transmute_copy(); let text: JS<Text> = self.get_jsmanaged().transmute_copy();
if !is_whitespace((*text.unsafe_get()).characterdata.data.as_slice()) { if !is_whitespace((*text.unsafe_get()).characterdata.data.deref().borrow().as_slice()) {
return false return false
} }

2
src/components/script/dom/bindings/utils.rs
View file

@ -606,7 +606,7 @@ pub extern fn outerize_global(_cx: *mut JSContext, obj: JSHandleObject) -> *mut
IDLInterface::get_prototype_depth(None::<window::Window>)) IDLInterface::get_prototype_depth(None::<window::Window>))
.unwrap() .unwrap()
.root(); .root();
win.deref().browser_context.get_ref().window_proxy() win.deref().browser_context.deref().borrow().get_ref().window_proxy()
} }
} }

47
src/components/script/dom/characterdata.rs
View file

@ -5,18 +5,21 @@
//! DOM bindings for `CharacterData`. //! DOM bindings for `CharacterData`.
use dom::bindings::codegen::InheritTypes::{CharacterDataDerived, NodeCast}; use dom::bindings::codegen::InheritTypes::{CharacterDataDerived, NodeCast};
use dom::bindings::js::JSRef;
use dom::bindings::error::{Fallible, ErrorResult, IndexSize}; use dom::bindings::error::{Fallible, ErrorResult, IndexSize};
use dom::bindings::js::JSRef;
use dom::bindings::trace::Untraceable;
use dom::bindings::utils::{Reflectable, Reflector}; use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::Document; use dom::document::Document;
use dom::eventtarget::{EventTarget, NodeTargetTypeId}; use dom::eventtarget::{EventTarget, NodeTargetTypeId};
use dom::node::{CommentNodeTypeId, Node, NodeTypeId, TextNodeTypeId, ProcessingInstructionNodeTypeId, NodeHelpers}; use dom::node::{CommentNodeTypeId, Node, NodeTypeId, TextNodeTypeId, ProcessingInstructionNodeTypeId, NodeHelpers};
use servo_util::str::DOMString; use servo_util::str::DOMString;
use std::cell::RefCell;
#[deriving(Encodable)] #[deriving(Encodable)]
pub struct CharacterData { pub struct CharacterData {
pub node: Node, pub node: Node,
pub data: DOMString, pub data: Untraceable<RefCell<DOMString>>,
} }
impl CharacterDataDerived for EventTarget { impl CharacterDataDerived for EventTarget {
@ -34,56 +37,56 @@ impl CharacterData {
pub fn new_inherited(id: NodeTypeId, data: DOMString, document: &JSRef<Document>) -> CharacterData { pub fn new_inherited(id: NodeTypeId, data: DOMString, document: &JSRef<Document>) -> CharacterData {
CharacterData { CharacterData {
node: Node::new_inherited(id, document), node: Node::new_inherited(id, document),
data: data data: Untraceable::new(RefCell::new(data)),
} }
} }
} }
pub trait CharacterDataMethods { pub trait CharacterDataMethods {
fn Data(&self) -> DOMString; fn Data(&self) -> DOMString;
fn SetData(&mut self, arg: DOMString) -> ErrorResult; fn SetData(&self, arg: DOMString) -> ErrorResult;
fn Length(&self) -> u32; fn Length(&self) -> u32;
fn SubstringData(&self, offset: u32, count: u32) -> Fallible<DOMString>; fn SubstringData(&self, offset: u32, count: u32) -> Fallible<DOMString>;
fn AppendData(&mut self, arg: DOMString) -> ErrorResult; fn AppendData(&self, arg: DOMString) -> ErrorResult;
fn InsertData(&mut self, _offset: u32, _arg: DOMString) -> ErrorResult; fn InsertData(&self, _offset: u32, _arg: DOMString) -> ErrorResult;
fn DeleteData(&mut self, _offset: u32, _count: u32) -> ErrorResult; fn DeleteData(&self, _offset: u32, _count: u32) -> ErrorResult;
fn ReplaceData(&mut self, _offset: u32, _count: u32, _arg: DOMString) -> ErrorResult; fn ReplaceData(&self, _offset: u32, _count: u32, _arg: DOMString) -> ErrorResult;
fn Remove(&self); fn Remove(&self);
} }
impl<'a> CharacterDataMethods for JSRef<'a, CharacterData> { impl<'a> CharacterDataMethods for JSRef<'a, CharacterData> {
fn Data(&self) -> DOMString { fn Data(&self) -> DOMString {
self.data.clone() self.data.deref().borrow().clone()
} }
fn SetData(&mut self, arg: DOMString) -> ErrorResult { fn SetData(&self, arg: DOMString) -> ErrorResult {
self.data = arg; *self.data.deref().borrow_mut() = arg;
Ok(()) Ok(())
} }
fn Length(&self) -> u32 { fn Length(&self) -> u32 {
self.data.len() as u32 self.data.deref().borrow().len() as u32
} }
fn SubstringData(&self, offset: u32, count: u32) -> Fallible<DOMString> { fn SubstringData(&self, offset: u32, count: u32) -> Fallible<DOMString> {
Ok(self.data.as_slice().slice(offset as uint, count as uint).to_str()) Ok(self.data.deref().borrow().as_slice().slice(offset as uint, count as uint).to_string())
} }
fn AppendData(&mut self, arg: DOMString) -> ErrorResult { fn AppendData(&self, arg: DOMString) -> ErrorResult {
self.data.push_str(arg.as_slice()); self.data.deref().borrow_mut().push_str(arg.as_slice());
Ok(()) Ok(())
} }
fn InsertData(&mut self, offset: u32, arg: DOMString) -> ErrorResult { fn InsertData(&self, offset: u32, arg: DOMString) -> ErrorResult {
self.ReplaceData(offset, 0, arg) self.ReplaceData(offset, 0, arg)
} }
fn DeleteData(&mut self, offset: u32, count: u32) -> ErrorResult { fn DeleteData(&self, offset: u32, count: u32) -> ErrorResult {
self.ReplaceData(offset, count, "".to_string()) self.ReplaceData(offset, count, "".to_string())
} }
fn ReplaceData(&mut self, offset: u32, count: u32, arg: DOMString) -> ErrorResult { fn ReplaceData(&self, offset: u32, count: u32, arg: DOMString) -> ErrorResult {
let length = self.data.len() as u32; let length = self.data.deref().borrow().len() as u32;
if offset > length { if offset > length {
return Err(IndexSize); return Err(IndexSize);
} }
@ -92,10 +95,10 @@ impl<'a> CharacterDataMethods for JSRef<'a, CharacterData> {
} else { } else {
count count
}; };
let mut data = self.data.as_slice().slice(0, offset as uint).to_string(); let mut data = self.data.deref().borrow().as_slice().slice(0, offset as uint).to_string();
data.push_str(arg.as_slice()); data.push_str(arg.as_slice());
data.push_str(self.data.as_slice().slice((offset + count) as uint, length as uint)); data.push_str(self.data.deref().borrow().as_slice().slice((offset + count) as uint, length as uint));
self.data = data.into_owned(); *self.data.deref().borrow_mut() = data.into_owned();
// FIXME: Once we have `Range`, we should implement step7 to step11 // FIXME: Once we have `Range`, we should implement step7 to step11
Ok(()) Ok(())
} }

20
src/components/script/dom/customevent.rs
View file

@ -14,10 +14,12 @@ use js::jsapi::JSContext;
use js::jsval::{JSVal, NullValue}; use js::jsval::{JSVal, NullValue};
use servo_util::str::DOMString; use servo_util::str::DOMString;
use std::cell::Cell;
#[deriving(Encodable)] #[deriving(Encodable)]
pub struct CustomEvent { pub struct CustomEvent {
event: Event, event: Event,
detail: Traceable<JSVal> detail: Traceable<Cell<Traceable<JSVal>>>,
} }
impl CustomEventDerived for Event { impl CustomEventDerived for Event {
@ -28,7 +30,7 @@ impl CustomEventDerived for Event {
pub trait CustomEventMethods { pub trait CustomEventMethods {
fn Detail(&self, _cx: *mut JSContext) -> JSVal; fn Detail(&self, _cx: *mut JSContext) -> JSVal;
fn InitCustomEvent(&mut self, _cx: *mut JSContext, fn InitCustomEvent(&self, _cx: *mut JSContext,
type_: DOMString, can_bubble: bool, type_: DOMString, can_bubble: bool,
cancelable: bool, detail: JSVal); cancelable: bool, detail: JSVal);
} }
@ -37,7 +39,7 @@ impl CustomEvent {
pub fn new_inherited(type_id: EventTypeId) -> CustomEvent { pub fn new_inherited(type_id: EventTypeId) -> CustomEvent {
CustomEvent { CustomEvent {
event: Event::new_inherited(type_id), event: Event::new_inherited(type_id),
detail: Traceable::new(NullValue()) detail: Traceable::new(Cell::new(Traceable::new(NullValue()))),
} }
} }
@ -47,8 +49,8 @@ impl CustomEvent {
CustomEventBinding::Wrap) CustomEventBinding::Wrap)
} }
pub fn new(window: &JSRef<Window>, type_: DOMString, bubbles: bool, cancelable: bool, detail: JSVal) -> Temporary<CustomEvent> { pub fn new(window: &JSRef<Window>, type_: DOMString, bubbles: bool, cancelable: bool, detail: JSVal) -> Temporary<CustomEvent> {
let mut ev = CustomEvent::new_uninitialized(window).root(); let ev = CustomEvent::new_uninitialized(window).root();
ev.InitCustomEvent(window.deref().get_cx(), type_, bubbles, cancelable, detail); ev.deref().InitCustomEvent(window.deref().get_cx(), type_, bubbles, cancelable, detail);
Temporary::from_rooted(&*ev) Temporary::from_rooted(&*ev)
} }
pub fn Constructor(owner: &JSRef<Window>, pub fn Constructor(owner: &JSRef<Window>,
@ -60,17 +62,17 @@ impl CustomEvent {
impl<'a> CustomEventMethods for JSRef<'a, CustomEvent> { impl<'a> CustomEventMethods for JSRef<'a, CustomEvent> {
fn Detail(&self, _cx: *mut JSContext) -> JSVal { fn Detail(&self, _cx: *mut JSContext) -> JSVal {
self.detail.deref().clone() *self.detail.deref().get()
} }
fn InitCustomEvent(&mut self, fn InitCustomEvent(&self,
_cx: *mut JSContext, _cx: *mut JSContext,
type_: DOMString, type_: DOMString,
can_bubble: bool, can_bubble: bool,
cancelable: bool, cancelable: bool,
detail: JSVal) { detail: JSVal) {
self.detail = Traceable::new(detail); self.detail.deref().set(Traceable::new(detail));
let event: &mut JSRef<Event> = EventCast::from_mut_ref(self); let event: &JSRef<Event> = EventCast::from_ref(self);
event.InitEvent(type_, can_bubble, cancelable); event.InitEvent(type_, can_bubble, cancelable);
} }
} }

46
src/components/script/dom/document.rs
View file

@ -49,7 +49,7 @@ use servo_util::str::{DOMString, null_str_as_empty_ref};
use collections::hashmap::HashMap; use collections::hashmap::HashMap;
use js::jsapi::JSContext; use js::jsapi::JSContext;
use std::ascii::StrAsciiExt; use std::ascii::StrAsciiExt;
use std::cell::Cell; use std::cell::{Cell, RefCell};
use url::{Url, from_str}; use url::{Url, from_str};
#[deriving(Eq,Encodable)] #[deriving(Eq,Encodable)]
@ -66,10 +66,10 @@ pub struct Document {
pub idmap: HashMap<DOMString, Vec<JS<Element>>>, pub idmap: HashMap<DOMString, Vec<JS<Element>>>,
pub implementation: Cell<Option<JS<DOMImplementation>>>, pub implementation: Cell<Option<JS<DOMImplementation>>>,
pub content_type: DOMString, pub content_type: DOMString,
pub encoding_name: DOMString, pub encoding_name: Untraceable<RefCell<DOMString>>,
pub is_html_document: bool, pub is_html_document: bool,
pub url: Untraceable<Url>, pub url: Untraceable<Url>,
pub quirks_mode: Untraceable<QuirksMode>, pub quirks_mode: Untraceable<Cell<QuirksMode>>,
} }
impl DocumentDerived for EventTarget { impl DocumentDerived for EventTarget {
@ -81,8 +81,8 @@ impl DocumentDerived for EventTarget {
pub trait DocumentHelpers { pub trait DocumentHelpers {
fn url<'a>(&'a self) -> &'a Url; fn url<'a>(&'a self) -> &'a Url;
fn quirks_mode(&self) -> QuirksMode; fn quirks_mode(&self) -> QuirksMode;
fn set_quirks_mode(&mut self, mode: QuirksMode); fn set_quirks_mode(&self, mode: QuirksMode);
fn set_encoding_name(&mut self, name: DOMString); fn set_encoding_name(&self, name: DOMString);
fn content_changed(&self); fn content_changed(&self);
fn damage_and_reflow(&self, damage: DocumentDamageLevel); fn damage_and_reflow(&self, damage: DocumentDamageLevel);
fn wait_until_safe_to_modify_dom(&self); fn wait_until_safe_to_modify_dom(&self);
@ -97,15 +97,15 @@ impl<'a> DocumentHelpers for JSRef<'a, Document> {
} }
fn quirks_mode(&self) -> QuirksMode { fn quirks_mode(&self) -> QuirksMode {
*self.quirks_mode self.quirks_mode.deref().get()
} }
fn set_quirks_mode(&mut self, mode: QuirksMode) { fn set_quirks_mode(&self, mode: QuirksMode) {
*self.quirks_mode = mode; self.quirks_mode.deref().set(mode);
} }
fn set_encoding_name(&mut self, name: DOMString) { fn set_encoding_name(&self, name: DOMString) {
self.encoding_name = name; *self.encoding_name.deref().borrow_mut() = name;
} }
fn content_changed(&self) { fn content_changed(&self) {
@ -227,9 +227,9 @@ impl Document {
}, },
url: Untraceable::new(url), url: Untraceable::new(url),
// http://dom.spec.whatwg.org/#concept-document-quirks // http://dom.spec.whatwg.org/#concept-document-quirks
quirks_mode: Untraceable::new(NoQuirks), quirks_mode: Untraceable::new(Cell::new(NoQuirks)),
// http://dom.spec.whatwg.org/#concept-document-encoding // http://dom.spec.whatwg.org/#concept-document-encoding
encoding_name: "utf-8".to_string(), encoding_name: Untraceable::new(RefCell::new("utf-8".to_string())),
is_html_document: is_html_document == HTMLDocument, is_html_document: is_html_document == HTMLDocument,
} }
} }
@ -331,9 +331,9 @@ pub trait DocumentMethods {
fn Children(&self) -> Temporary<HTMLCollection>; fn Children(&self) -> Temporary<HTMLCollection>;
fn QuerySelector(&self, selectors: DOMString) -> Fallible<Option<Temporary<Element>>>; fn QuerySelector(&self, selectors: DOMString) -> Fallible<Option<Temporary<Element>>>;
fn GetOnclick(&self) -> Option<EventHandlerNonNull>; fn GetOnclick(&self) -> Option<EventHandlerNonNull>;
fn SetOnclick(&mut self, listener: Option<EventHandlerNonNull>); fn SetOnclick(&self, listener: Option<EventHandlerNonNull>);
fn GetOnload(&self) -> Option<EventHandlerNonNull>; fn GetOnload(&self) -> Option<EventHandlerNonNull>;
fn SetOnload(&mut self, listener: Option<EventHandlerNonNull>); fn SetOnload(&self, listener: Option<EventHandlerNonNull>);
} }
impl<'a> DocumentMethods for JSRef<'a, Document> { impl<'a> DocumentMethods for JSRef<'a, Document> {
@ -358,7 +358,7 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
// http://dom.spec.whatwg.org/#dom-document-compatmode // http://dom.spec.whatwg.org/#dom-document-compatmode
fn CompatMode(&self) -> DOMString { fn CompatMode(&self) -> DOMString {
match *self.quirks_mode { match self.quirks_mode.deref().get() {
NoQuirks => "CSS1Compat".to_string(), NoQuirks => "CSS1Compat".to_string(),
LimitedQuirks | FullQuirks => "BackCompat".to_string() LimitedQuirks | FullQuirks => "BackCompat".to_string()
} }
@ -366,7 +366,7 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
// http://dom.spec.whatwg.org/#dom-document-characterset // http://dom.spec.whatwg.org/#dom-document-characterset
fn CharacterSet(&self) -> DOMString { fn CharacterSet(&self) -> DOMString {
self.encoding_name.as_slice().to_ascii_lower() self.encoding_name.deref().borrow().as_slice().to_ascii_lower()
} }
// http://dom.spec.whatwg.org/#dom-document-content_type // http://dom.spec.whatwg.org/#dom-document-content_type
@ -430,7 +430,7 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
return Err(InvalidCharacter); return Err(InvalidCharacter);
} }
let local_name = local_name.as_slice().to_ascii_lower(); let local_name = local_name.as_slice().to_ascii_lower();
Ok(build_element_from_tag(local_name, self)) Ok(build_element_from_tag(local_name, namespace::HTML, self))
} }
// http://dom.spec.whatwg.org/#dom-document-createelementns // http://dom.spec.whatwg.org/#dom-document-createelementns
@ -473,7 +473,7 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
} }
if ns == namespace::HTML { if ns == namespace::HTML {
Ok(build_element_from_tag(local_name_from_qname, self)) Ok(build_element_from_tag(local_name_from_qname, ns, self))
} else { } else {
Ok(Element::new(local_name_from_qname, ns, prefix_from_qname, self)) Ok(Element::new(local_name_from_qname, ns, prefix_from_qname, self))
} }
@ -567,7 +567,7 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
for child in title_elem.children() { for child in title_elem.children() {
if child.is_text() { if child.is_text() {
let text: &JSRef<Text> = TextCast::to_ref(&child).unwrap(); let text: &JSRef<Text> = TextCast::to_ref(&child).unwrap();
title.push_str(text.deref().characterdata.data.as_slice()); title.push_str(text.deref().characterdata.data.deref().borrow().as_slice());
} }
} }
}); });
@ -826,8 +826,8 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
eventtarget.get_event_handler_common("click") eventtarget.get_event_handler_common("click")
} }
fn SetOnclick(&mut self, listener: Option<EventHandlerNonNull>) { fn SetOnclick(&self, listener: Option<EventHandlerNonNull>) {
let eventtarget: &mut JSRef<EventTarget> = EventTargetCast::from_mut_ref(self); let eventtarget: &JSRef<EventTarget> = EventTargetCast::from_ref(self);
eventtarget.set_event_handler_common("click", listener) eventtarget.set_event_handler_common("click", listener)
} }
@ -836,8 +836,8 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
eventtarget.get_event_handler_common("load") eventtarget.get_event_handler_common("load")
} }
fn SetOnload(&mut self, listener: Option<EventHandlerNonNull>) { fn SetOnload(&self, listener: Option<EventHandlerNonNull>) {
let eventtarget: &mut JSRef<EventTarget> = EventTargetCast::from_mut_ref(self); let eventtarget: &JSRef<EventTarget> = EventTargetCast::from_ref(self);
eventtarget.set_event_handler_common("load", listener) eventtarget.set_event_handler_common("load", listener)
} }
} }

107
src/components/script/dom/event.rs
View file

@ -4,14 +4,15 @@
use dom::bindings::codegen::Bindings::EventBinding; use dom::bindings::codegen::Bindings::EventBinding;
use dom::bindings::codegen::Bindings::EventBinding::EventConstants; use dom::bindings::codegen::Bindings::EventBinding::EventConstants;
use dom::bindings::js::{JS, JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::bindings::error::Fallible; use dom::bindings::error::Fallible;
use dom::bindings::js::{JS, JSRef, Temporary};
use dom::bindings::trace::Untraceable;
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::eventtarget::EventTarget; use dom::eventtarget::EventTarget;
use dom::window::Window; use dom::window::Window;
use servo_util::str::DOMString; use servo_util::str::DOMString;
use servo_util::geometry::PagePx; use servo_util::geometry::PagePx;
use std::cell::Cell; use std::cell::{Cell, RefCell};
use geom::point::Point2D; use geom::point::Point2D;
use geom::size::TypedSize2D; use geom::size::TypedSize2D;
@ -51,16 +52,16 @@ pub struct Event {
pub reflector_: Reflector, pub reflector_: Reflector,
pub current_target: Cell<Option<JS<EventTarget>>>, pub current_target: Cell<Option<JS<EventTarget>>>,
pub target: Cell<Option<JS<EventTarget>>>, pub target: Cell<Option<JS<EventTarget>>>,
pub type_: DOMString, type_: Untraceable<RefCell<DOMString>>,
pub phase: EventPhase, pub phase: Untraceable<Cell<EventPhase>>,
pub canceled: bool, pub canceled: Untraceable<Cell<bool>>,
pub stop_propagation: bool, pub stop_propagation: Untraceable<Cell<bool>>,
pub stop_immediate: bool, pub stop_immediate: Untraceable<Cell<bool>>,
pub cancelable: bool, pub cancelable: Untraceable<Cell<bool>>,
pub bubbles: bool, pub bubbles: Untraceable<Cell<bool>>,
pub trusted: bool, pub trusted: Untraceable<Cell<bool>>,
pub dispatching: bool, pub dispatching: Untraceable<Cell<bool>>,
pub initialized: bool, pub initialized: Untraceable<Cell<bool>>,
pub timestamp: u64, pub timestamp: u64,
} }
@ -71,16 +72,16 @@ impl Event {
reflector_: Reflector::new(), reflector_: Reflector::new(),
current_target: Cell::new(None), current_target: Cell::new(None),
target: Cell::new(None), target: Cell::new(None),
phase: PhaseNone, phase: Untraceable::new(Cell::new(PhaseNone)),
type_: "".to_string(), type_: Untraceable::new(RefCell::new("".to_string())),
canceled: false, canceled: Untraceable::new(Cell::new(false)),
cancelable: true, cancelable: Untraceable::new(Cell::new(true)),
bubbles: false, bubbles: Untraceable::new(Cell::new(false)),
trusted: false, trusted: Untraceable::new(Cell::new(false)),
dispatching: false, dispatching: Untraceable::new(Cell::new(false)),
stop_propagation: false, stop_propagation: Untraceable::new(Cell::new(false)),
stop_immediate: false, stop_immediate: Untraceable::new(Cell::new(false)),
initialized: false, initialized: Untraceable::new(Cell::new(false)),
timestamp: time::get_time().sec as u64, timestamp: time::get_time().sec as u64,
} }
} }
@ -95,8 +96,8 @@ impl Event {
type_: DOMString, type_: DOMString,
can_bubble: bool, can_bubble: bool,
cancelable: bool) -> Temporary<Event> { cancelable: bool) -> Temporary<Event> {
let mut event = Event::new_uninitialized(window).root(); let event = Event::new_uninitialized(window).root();
event.InitEvent(type_, can_bubble, cancelable); event.deref().InitEvent(type_, can_bubble, cancelable);
Temporary::from_rooted(&*event) Temporary::from_rooted(&*event)
} }
@ -113,23 +114,23 @@ pub trait EventMethods {
fn GetTarget(&self) -> Option<Temporary<EventTarget>>; fn GetTarget(&self) -> Option<Temporary<EventTarget>>;
fn GetCurrentTarget(&self) -> Option<Temporary<EventTarget>>; fn GetCurrentTarget(&self) -> Option<Temporary<EventTarget>>;
fn DefaultPrevented(&self) -> bool; fn DefaultPrevented(&self) -> bool;
fn PreventDefault(&mut self); fn PreventDefault(&self);
fn StopPropagation(&mut self); fn StopPropagation(&self);
fn StopImmediatePropagation(&mut self); fn StopImmediatePropagation(&self);
fn Bubbles(&self) -> bool; fn Bubbles(&self) -> bool;
fn Cancelable(&self) -> bool; fn Cancelable(&self) -> bool;
fn TimeStamp(&self) -> u64; fn TimeStamp(&self) -> u64;
fn InitEvent(&mut self, type_: DOMString, bubbles: bool, cancelable: bool); fn InitEvent(&self, type_: DOMString, bubbles: bool, cancelable: bool);
fn IsTrusted(&self) -> bool; fn IsTrusted(&self) -> bool;
} }
impl<'a> EventMethods for JSRef<'a, Event> { impl<'a> EventMethods for JSRef<'a, Event> {
fn EventPhase(&self) -> u16 { fn EventPhase(&self) -> u16 {
self.phase as u16 self.phase.deref().get() as u16
} }
fn Type(&self) -> DOMString { fn Type(&self) -> DOMString {
self.type_.clone() self.type_.deref().borrow().clone()
} }
fn GetTarget(&self) -> Option<Temporary<EventTarget>> { fn GetTarget(&self) -> Option<Temporary<EventTarget>> {
@ -141,56 +142,56 @@ impl<'a> EventMethods for JSRef<'a, Event> {
} }
fn DefaultPrevented(&self) -> bool { fn DefaultPrevented(&self) -> bool {
self.canceled self.canceled.deref().get()
} }
fn PreventDefault(&mut self) { fn PreventDefault(&self) {
if self.cancelable { if self.cancelable.deref().get() {
self.canceled = true self.canceled.deref().set(true)
} }
} }
fn StopPropagation(&mut self) { fn StopPropagation(&self) {
self.stop_propagation = true; self.stop_propagation.deref().set(true);
} }
fn StopImmediatePropagation(&mut self) { fn StopImmediatePropagation(&self) {
self.stop_immediate = true; self.stop_immediate.deref().set(true);
self.stop_propagation = true; self.stop_propagation.deref().set(true);
} }
fn Bubbles(&self) -> bool { fn Bubbles(&self) -> bool {
self.bubbles self.bubbles.deref().get()
} }
fn Cancelable(&self) -> bool { fn Cancelable(&self) -> bool {
self.cancelable self.cancelable.deref().get()
} }
fn TimeStamp(&self) -> u64 { fn TimeStamp(&self) -> u64 {
self.timestamp self.timestamp
} }
fn InitEvent(&mut self, fn InitEvent(&self,
type_: DOMString, type_: DOMString,
bubbles: bool, bubbles: bool,
cancelable: bool) { cancelable: bool) {
self.initialized = true; self.initialized.deref().set(true);
if self.dispatching { if self.dispatching.deref().get() {
return; return;
} }
self.stop_propagation = false; self.stop_propagation.deref().set(false);
self.stop_immediate = false; self.stop_immediate.deref().set(false);
self.canceled = false; self.canceled.deref().set(false);
self.trusted = false; self.trusted.deref().set(false);
self.target.set(None); self.target.set(None);
self.type_ = type_; *self.type_.deref().borrow_mut() = type_;
self.bubbles = bubbles; self.bubbles.deref().set(bubbles);
self.cancelable = cancelable; self.cancelable.deref().set(cancelable);
} }
fn IsTrusted(&self) -> bool { fn IsTrusted(&self) -> bool {
self.trusted self.trusted.deref().get()
} }
} }

40
src/components/script/dom/eventdispatcher.rs
View file

@ -13,19 +13,16 @@ use dom::virtualmethods::vtable_for;
// See http://dom.spec.whatwg.org/#concept-event-dispatch for the full dispatch algorithm // See http://dom.spec.whatwg.org/#concept-event-dispatch for the full dispatch algorithm
pub fn dispatch_event<'a, 'b>(target: &JSRef<'a, EventTarget>, pub fn dispatch_event<'a, 'b>(target: &JSRef<'a, EventTarget>,
pseudo_target: Option<JSRef<'b, EventTarget>>, pseudo_target: Option<JSRef<'b, EventTarget>>,
event: &mut JSRef<Event>) -> bool { event: &JSRef<Event>) -> bool {
assert!(!event.deref().dispatching); assert!(!event.deref().dispatching.deref().get());
{
let event = event.deref_mut();
event.target.assign(Some(match pseudo_target { event.target.assign(Some(match pseudo_target {
Some(pseudo_target) => pseudo_target, Some(pseudo_target) => pseudo_target,
None => target.clone(), None => target.clone(),
})); }));
event.dispatching = true; event.dispatching.deref().set(true);
}
let type_ = event.deref().type_.clone(); let type_ = event.Type();
//TODO: no chain if not participating in a tree //TODO: no chain if not participating in a tree
let mut chain: Vec<Root<EventTarget>> = if target.deref().is_node() { let mut chain: Vec<Root<EventTarget>> = if target.deref().is_node() {
@ -38,7 +35,7 @@ pub fn dispatch_event<'a, 'b>(target: &JSRef<'a, EventTarget>,
vec!() vec!()
}; };
event.deref_mut().phase = PhaseCapturing; event.deref().phase.deref().set(PhaseCapturing);
//FIXME: The "callback this value" should be currentTarget //FIXME: The "callback this value" should be currentTarget
@ -51,12 +48,12 @@ pub fn dispatch_event<'a, 'b>(target: &JSRef<'a, EventTarget>,
// Explicitly drop any exception on the floor. // Explicitly drop any exception on the floor.
let _ = listener.HandleEvent_(&**cur_target, event, ReportExceptions); let _ = listener.HandleEvent_(&**cur_target, event, ReportExceptions);
if event.deref().stop_immediate { if event.deref().stop_immediate.deref().get() {
break; break;
} }
} }
event.deref().stop_propagation event.deref().stop_propagation.deref().get()
} }
None => false None => false
}; };
@ -67,12 +64,9 @@ pub fn dispatch_event<'a, 'b>(target: &JSRef<'a, EventTarget>,
} }
/* at target */ /* at target */
if !event.deref().stop_propagation { if !event.deref().stop_propagation.deref().get() {
{ event.phase.deref().set(PhaseAtTarget);
let event = event.deref_mut();
event.phase = PhaseAtTarget;
event.current_target.assign(Some(target.clone())); event.current_target.assign(Some(target.clone()));
}
let opt_listeners = target.deref().get_listeners(type_.as_slice()); let opt_listeners = target.deref().get_listeners(type_.as_slice());
for listeners in opt_listeners.iter() { for listeners in opt_listeners.iter() {
@ -80,7 +74,7 @@ pub fn dispatch_event<'a, 'b>(target: &JSRef<'a, EventTarget>,
// Explicitly drop any exception on the floor. // Explicitly drop any exception on the floor.
let _ = listener.HandleEvent_(target, event, ReportExceptions); let _ = listener.HandleEvent_(target, event, ReportExceptions);
if event.deref().stop_immediate { if event.deref().stop_immediate.deref().get() {
break; break;
} }
} }
@ -88,23 +82,23 @@ pub fn dispatch_event<'a, 'b>(target: &JSRef<'a, EventTarget>,
} }
/* bubbling */ /* bubbling */
if event.deref().bubbles && !event.deref().stop_propagation { if event.deref().bubbles.deref().get() && !event.deref().stop_propagation.deref().get() {
event.deref_mut().phase = PhaseBubbling; event.deref().phase.deref().set(PhaseBubbling);
for cur_target in chain.iter() { for cur_target in chain.iter() {
let stopped = match cur_target.deref().get_listeners_for(type_.as_slice(), Bubbling) { let stopped = match cur_target.deref().get_listeners_for(type_.as_slice(), Bubbling) {
Some(listeners) => { Some(listeners) => {
event.deref_mut().current_target.assign(Some(cur_target.deref().clone())); event.deref().current_target.assign(Some(cur_target.deref().clone()));
for listener in listeners.iter() { for listener in listeners.iter() {
// Explicitly drop any exception on the floor. // Explicitly drop any exception on the floor.
let _ = listener.HandleEvent_(&**cur_target, event, ReportExceptions); let _ = listener.HandleEvent_(&**cur_target, event, ReportExceptions);
if event.deref().stop_immediate { if event.deref().stop_immediate.deref().get() {
break; break;
} }
} }
event.deref().stop_propagation event.deref().stop_propagation.deref().get()
} }
None => false None => false
}; };
@ -136,8 +130,8 @@ pub fn dispatch_event<'a, 'b>(target: &JSRef<'a, EventTarget>,
let _ = chain.pop(); let _ = chain.pop();
} }
event.dispatching = false; event.dispatching.deref().set(false);
event.phase = PhaseNone; event.phase.deref().set(PhaseNone);
event.current_target.set(None); event.current_target.set(None);
!event.DefaultPrevented() !event.DefaultPrevented()

68
src/components/script/dom/eventtarget.rs
View file

@ -7,6 +7,7 @@ use dom::bindings::codegen::Bindings::EventHandlerBinding::EventHandlerNonNull;
use dom::bindings::codegen::Bindings::EventListenerBinding::EventListener; use dom::bindings::codegen::Bindings::EventListenerBinding::EventListener;
use dom::bindings::error::{Fallible, InvalidState}; use dom::bindings::error::{Fallible, InvalidState};
use dom::bindings::js::JSRef; use dom::bindings::js::JSRef;
use dom::bindings::trace::Traceable;
use dom::bindings::utils::{Reflectable, Reflector}; use dom::bindings::utils::{Reflectable, Reflector};
use dom::event::Event; use dom::event::Event;
use dom::eventdispatcher::dispatch_event; use dom::eventdispatcher::dispatch_event;
@ -17,6 +18,7 @@ use js::jsapi::{JS_CompileUCFunction, JS_GetFunctionObject, JS_CloneFunctionObje
use js::jsapi::{JSContext, JSObject}; use js::jsapi::{JSContext, JSObject};
use servo_util::str::DOMString; use servo_util::str::DOMString;
use libc::{c_char, size_t}; use libc::{c_char, size_t};
use std::cell::RefCell;
use std::ptr; use std::ptr;
use url::Url; use url::Url;
@ -59,7 +61,7 @@ pub struct EventListenerEntry {
pub struct EventTarget { pub struct EventTarget {
pub type_id: EventTargetTypeId, pub type_id: EventTargetTypeId,
pub reflector_: Reflector, pub reflector_: Reflector,
pub handlers: HashMap<DOMString, Vec<EventListenerEntry>>, handlers: Traceable<RefCell<HashMap<DOMString, Vec<EventListenerEntry>>>>,
} }
impl EventTarget { impl EventTarget {
@ -67,19 +69,19 @@ impl EventTarget {
EventTarget { EventTarget {
type_id: type_id, type_id: type_id,
reflector_: Reflector::new(), reflector_: Reflector::new(),
handlers: HashMap::new(), handlers: Traceable::new(RefCell::new(HashMap::new())),
} }
} }
pub fn get_listeners(&self, type_: &str) -> Option<Vec<EventListener>> { pub fn get_listeners(&self, type_: &str) -> Option<Vec<EventListener>> {
self.handlers.find_equiv(&type_).map(|listeners| { self.handlers.deref().borrow().find_equiv(&type_).map(|listeners| {
listeners.iter().map(|entry| entry.listener.get_listener()).collect() listeners.iter().map(|entry| entry.listener.get_listener()).collect()
}) })
} }
pub fn get_listeners_for(&self, type_: &str, desired_phase: ListenerPhase) pub fn get_listeners_for(&self, type_: &str, desired_phase: ListenerPhase)
-> Option<Vec<EventListener>> { -> Option<Vec<EventListener>> {
self.handlers.find_equiv(&type_).map(|listeners| { self.handlers.deref().borrow().find_equiv(&type_).map(|listeners| {
let filtered = listeners.iter().filter(|entry| entry.phase == desired_phase); let filtered = listeners.iter().filter(|entry| entry.phase == desired_phase);
filtered.map(|entry| entry.listener.get_listener()).collect() filtered.map(|entry| entry.listener.get_listener()).collect()
}) })
@ -89,36 +91,39 @@ impl EventTarget {
pub trait EventTargetHelpers { pub trait EventTargetHelpers {
fn dispatch_event_with_target<'a>(&self, fn dispatch_event_with_target<'a>(&self,
target: Option<JSRef<'a, EventTarget>>, target: Option<JSRef<'a, EventTarget>>,
event: &mut JSRef<Event>) -> Fallible<bool>; event: &JSRef<Event>) -> Fallible<bool>;
fn set_inline_event_listener(&mut self, fn set_inline_event_listener(&self,
ty: DOMString, ty: DOMString,
listener: Option<EventListener>); listener: Option<EventListener>);
fn get_inline_event_listener(&self, ty: DOMString) -> Option<EventListener>; fn get_inline_event_listener(&self, ty: DOMString) -> Option<EventListener>;
fn set_event_handler_uncompiled(&mut self, fn set_event_handler_uncompiled(&self,
cx: *mut JSContext, cx: *mut JSContext,
url: Url, url: Url,
scope: *mut JSObject, scope: *mut JSObject,
ty: &str, ty: &str,
source: DOMString); source: DOMString);
fn set_event_handler_common<T: CallbackContainer>(&mut self, ty: &str, fn set_event_handler_common<T: CallbackContainer>(&self, ty: &str,
listener: Option<T>); listener: Option<T>);
fn get_event_handler_common<T: CallbackContainer>(&self, ty: &str) -> Option<T>; fn get_event_handler_common<T: CallbackContainer>(&self, ty: &str) -> Option<T>;
fn has_handlers(&self) -> bool;
} }
impl<'a> EventTargetHelpers for JSRef<'a, EventTarget> { impl<'a> EventTargetHelpers for JSRef<'a, EventTarget> {
fn dispatch_event_with_target<'b>(&self, fn dispatch_event_with_target<'b>(&self,
target: Option<JSRef<'b, EventTarget>>, target: Option<JSRef<'b, EventTarget>>,
event: &mut JSRef<Event>) -> Fallible<bool> { event: &JSRef<Event>) -> Fallible<bool> {
if event.deref().dispatching || !event.deref().initialized { if event.deref().dispatching.deref().get() || !event.deref().initialized.deref().get() {
return Err(InvalidState); return Err(InvalidState);
} }
Ok(dispatch_event(self, target, event)) Ok(dispatch_event(self, target, event))
} }
fn set_inline_event_listener(&mut self, fn set_inline_event_listener(&self,
ty: DOMString, ty: DOMString,
listener: Option<EventListener>) { listener: Option<EventListener>) {
let entries = self.handlers.find_or_insert_with(ty, |_| vec!()); let mut handlers = self.handlers.deref().borrow_mut();
let entries = handlers.find_or_insert_with(ty, |_| vec!());
let idx = entries.iter().position(|&entry| { let idx = entries.iter().position(|&entry| {
match entry.listener { match entry.listener {
Inline(_) => true, Inline(_) => true,
@ -147,7 +152,8 @@ impl<'a> EventTargetHelpers for JSRef<'a, EventTarget> {
} }
fn get_inline_event_listener(&self, ty: DOMString) -> Option<EventListener> { fn get_inline_event_listener(&self, ty: DOMString) -> Option<EventListener> {
let entries = self.handlers.find(&ty); let handlers = self.handlers.deref().borrow();
let entries = handlers.find(&ty);
entries.and_then(|entries| entries.iter().find(|entry| { entries.and_then(|entries| entries.iter().find(|entry| {
match entry.listener { match entry.listener {
Inline(_) => true, Inline(_) => true,
@ -156,7 +162,7 @@ impl<'a> EventTargetHelpers for JSRef<'a, EventTarget> {
}).map(|entry| entry.listener.get_listener())) }).map(|entry| entry.listener.get_listener()))
} }
fn set_event_handler_uncompiled(&mut self, fn set_event_handler_uncompiled(&self,
cx: *mut JSContext, cx: *mut JSContext,
url: Url, url: Url,
scope: *mut JSObject, scope: *mut JSObject,
@ -188,7 +194,7 @@ impl<'a> EventTargetHelpers for JSRef<'a, EventTarget> {
} }
fn set_event_handler_common<T: CallbackContainer>( fn set_event_handler_common<T: CallbackContainer>(
&mut self, ty: &str, listener: Option<T>) &self, ty: &str, listener: Option<T>)
{ {
let event_listener = listener.map(|listener| let event_listener = listener.map(|listener|
EventListener::new(listener.callback())); EventListener::new(listener.callback()));
@ -199,27 +205,33 @@ impl<'a> EventTargetHelpers for JSRef<'a, EventTarget> {
let listener = self.get_inline_event_listener(ty.to_string()); let listener = self.get_inline_event_listener(ty.to_string());
listener.map(|listener| CallbackContainer::new(listener.parent.callback())) listener.map(|listener| CallbackContainer::new(listener.parent.callback()))
} }
fn has_handlers(&self) -> bool {
!self.handlers.deref().borrow().is_empty()
}
} }
pub trait EventTargetMethods { pub trait EventTargetMethods {
fn AddEventListener(&mut self, fn AddEventListener(&self,
ty: DOMString, ty: DOMString,
listener: Option<EventListener>, listener: Option<EventListener>,
capture: bool); capture: bool);
fn RemoveEventListener(&mut self, fn RemoveEventListener(&self,
ty: DOMString, ty: DOMString,
listener: Option<EventListener>, listener: Option<EventListener>,
capture: bool); capture: bool);
fn DispatchEvent(&self, event: &mut JSRef<Event>) -> Fallible<bool>; fn DispatchEvent(&self, event: &JSRef<Event>) -> Fallible<bool>;
} }
impl<'a> EventTargetMethods for JSRef<'a, EventTarget> { impl<'a> EventTargetMethods for JSRef<'a, EventTarget> {
fn AddEventListener(&mut self, fn AddEventListener(&self,
ty: DOMString, ty: DOMString,
listener: Option<EventListener>, listener: Option<EventListener>,
capture: bool) { capture: bool) {
for &listener in listener.iter() { match listener {
let entry = self.handlers.find_or_insert_with(ty.clone(), |_| vec!()); Some(listener) => {
let mut handlers = self.handlers.deref().borrow_mut();
let entry = handlers.find_or_insert_with(ty, |_| vec!());
let phase = if capture { Capturing } else { Bubbling }; let phase = if capture { Capturing } else { Bubbling };
let new_entry = EventListenerEntry { let new_entry = EventListenerEntry {
phase: phase, phase: phase,
@ -228,15 +240,19 @@ impl<'a> EventTargetMethods for JSRef<'a, EventTarget> {
if entry.as_slice().position_elem(&new_entry).is_none() { if entry.as_slice().position_elem(&new_entry).is_none() {
entry.push(new_entry); entry.push(new_entry);
} }
},
_ => (),
} }
} }
fn RemoveEventListener(&mut self, fn RemoveEventListener(&self,
ty: DOMString, ty: DOMString,
listener: Option<EventListener>, listener: Option<EventListener>,
capture: bool) { capture: bool) {
for &listener in listener.iter() { match listener {
let mut entry = self.handlers.find_mut(&ty); Some(listener) => {
let mut handlers = self.handlers.deref().borrow_mut();
let mut entry = handlers.find_mut(&ty);
for entry in entry.mut_iter() { for entry in entry.mut_iter() {
let phase = if capture { Capturing } else { Bubbling }; let phase = if capture { Capturing } else { Bubbling };
let old_entry = EventListenerEntry { let old_entry = EventListenerEntry {
@ -248,10 +264,12 @@ impl<'a> EventTargetMethods for JSRef<'a, EventTarget> {
entry.remove(position); entry.remove(position);
} }
} }
},
_ => (),
} }
} }
fn DispatchEvent(&self, event: &mut JSRef<Event>) -> Fallible<bool> { fn DispatchEvent(&self, event: &JSRef<Event>) -> Fallible<bool> {
self.dispatch_event_with_target(None, event) self.dispatch_event_with_target(None, event)
} }
} }

22
src/components/script/dom/formdata.rs
View file

@ -2,15 +2,17 @@
* License, v. 2.0. If a copy of the MPL was not distributed with this * 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/. */ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::bindings::error::{Fallible};
use dom::bindings::codegen::Bindings::FormDataBinding; use dom::bindings::codegen::Bindings::FormDataBinding;
use dom::bindings::error::{Fallible};
use dom::bindings::js::{JS, JSRef, Temporary, OptionalUnrootable}; use dom::bindings::js::{JS, JSRef, Temporary, OptionalUnrootable};
use dom::bindings::trace::Traceable;
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::blob::Blob; use dom::blob::Blob;
use dom::htmlformelement::HTMLFormElement; use dom::htmlformelement::HTMLFormElement;
use dom::window::Window; use dom::window::Window;
use servo_util::str::DOMString; use servo_util::str::DOMString;
use collections::hashmap::HashMap; use collections::hashmap::HashMap;
use std::cell::RefCell;
#[deriving(Encodable)] #[deriving(Encodable)]
pub enum FormDatum { pub enum FormDatum {
@ -20,7 +22,7 @@ pub enum FormDatum {
#[deriving(Encodable)] #[deriving(Encodable)]
pub struct FormData { pub struct FormData {
pub data: HashMap<DOMString, FormDatum>, pub data: Traceable<RefCell<HashMap<DOMString, FormDatum>>>,
pub reflector_: Reflector, pub reflector_: Reflector,
pub window: JS<Window>, pub window: JS<Window>,
pub form: Option<JS<HTMLFormElement>> pub form: Option<JS<HTMLFormElement>>
@ -29,7 +31,7 @@ pub struct FormData {
impl FormData { impl FormData {
pub fn new_inherited(form: Option<JSRef<HTMLFormElement>>, window: &JSRef<Window>) -> FormData { pub fn new_inherited(form: Option<JSRef<HTMLFormElement>>, window: &JSRef<Window>) -> FormData {
FormData { FormData {
data: HashMap::new(), data: Traceable::new(RefCell::new(HashMap::new())),
reflector_: Reflector::new(), reflector_: Reflector::new(),
window: window.unrooted(), window: window.unrooted(),
form: form.unrooted(), form: form.unrooted(),
@ -46,21 +48,21 @@ impl FormData {
} }
pub trait FormDataMethods { pub trait FormDataMethods {
fn Append(&mut self, name: DOMString, value: &JSRef<Blob>, filename: Option<DOMString>); fn Append(&self, name: DOMString, value: &JSRef<Blob>, filename: Option<DOMString>);
fn Append_(&mut self, name: DOMString, value: DOMString); fn Append_(&self, name: DOMString, value: DOMString);
} }
impl<'a> FormDataMethods for JSRef<'a, FormData> { impl<'a> FormDataMethods for JSRef<'a, FormData> {
fn Append(&mut self, name: DOMString, value: &JSRef<Blob>, filename: Option<DOMString>) { fn Append(&self, name: DOMString, value: &JSRef<Blob>, filename: Option<DOMString>) {
let blob = BlobData { let blob = BlobData {
blob: value.unrooted(), blob: value.unrooted(),
name: filename.unwrap_or("default".to_string()) name: filename.unwrap_or("default".to_string())
}; };
self.data.insert(name.clone(), blob); self.data.deref().borrow_mut().insert(name.clone(), blob);
} }
fn Append_(&mut self, name: DOMString, value: DOMString) { fn Append_(&self, name: DOMString, value: DOMString) {
self.data.insert(name, StringData(value)); self.data.deref().borrow_mut().insert(name, StringData(value));
} }
} }

7
src/components/script/dom/htmlbodyelement.rs
View file

@ -80,12 +80,11 @@ impl<'a> VirtualMethods for JSRef<'a, HTMLBodyElement> {
let (cx, url, reflector) = (window.get_cx(), let (cx, url, reflector) = (window.get_cx(),
window.get_url(), window.get_url(),
window.reflector().get_jsobject()); window.reflector().get_jsobject());
let mut self_alias = self.clone(); let evtarget: &JSRef<EventTarget> =
let evtarget: &mut JSRef<EventTarget> =
if forwarded_events.iter().any(|&event| name.as_slice() == event) { if forwarded_events.iter().any(|&event| name.as_slice() == event) {
EventTargetCast::from_mut_ref(&mut *window) EventTargetCast::from_ref(&*window)
} else { } else {
EventTargetCast::from_mut_ref(&mut self_alias) EventTargetCast::from_ref(self)
}; };
evtarget.set_event_handler_uncompiled(cx, url, reflector, evtarget.set_event_handler_uncompiled(cx, url, reflector,
name.as_slice().slice_from(2), name.as_slice().slice_from(2),

18
src/components/script/dom/htmlelement.rs
View file

@ -59,9 +59,9 @@ impl<'a> PrivateHTMLElementHelpers for JSRef<'a, HTMLElement> {
pub trait HTMLElementMethods { pub trait HTMLElementMethods {
fn GetOnclick(&self) -> Option<EventHandlerNonNull>; fn GetOnclick(&self) -> Option<EventHandlerNonNull>;
fn SetOnclick(&mut self, listener: Option<EventHandlerNonNull>); fn SetOnclick(&self, listener: Option<EventHandlerNonNull>);
fn GetOnload(&self) -> Option<EventHandlerNonNull>; fn GetOnload(&self) -> Option<EventHandlerNonNull>;
fn SetOnload(&mut self, listener: Option<EventHandlerNonNull>); fn SetOnload(&self, listener: Option<EventHandlerNonNull>);
} }
impl<'a> HTMLElementMethods for JSRef<'a, HTMLElement> { impl<'a> HTMLElementMethods for JSRef<'a, HTMLElement> {
@ -70,8 +70,8 @@ impl<'a> HTMLElementMethods for JSRef<'a, HTMLElement> {
eventtarget.get_event_handler_common("click") eventtarget.get_event_handler_common("click")
} }
fn SetOnclick(&mut self, listener: Option<EventHandlerNonNull>) { fn SetOnclick(&self, listener: Option<EventHandlerNonNull>) {
let eventtarget: &mut JSRef<EventTarget> = EventTargetCast::from_mut_ref(self); let eventtarget: &JSRef<EventTarget> = EventTargetCast::from_ref(self);
eventtarget.set_event_handler_common("click", listener) eventtarget.set_event_handler_common("click", listener)
} }
@ -84,10 +84,10 @@ impl<'a> HTMLElementMethods for JSRef<'a, HTMLElement> {
} }
} }
fn SetOnload(&mut self, listener: Option<EventHandlerNonNull>) { fn SetOnload(&self, listener: Option<EventHandlerNonNull>) {
if self.is_body_or_frameset() { if self.is_body_or_frameset() {
let mut win = window_from_node(self).root(); let win = window_from_node(self).root();
win.SetOnload(listener) win.deref().SetOnload(listener)
} }
} }
} }
@ -109,9 +109,7 @@ impl<'a> VirtualMethods for JSRef<'a, HTMLElement> {
let (cx, url, reflector) = (window.get_cx(), let (cx, url, reflector) = (window.get_cx(),
window.get_url(), window.get_url(),
window.reflector().get_jsobject()); window.reflector().get_jsobject());
let mut self_alias = self.clone(); let evtarget: &JSRef<EventTarget> = EventTargetCast::from_ref(self);
let evtarget: &mut JSRef<EventTarget> =
EventTargetCast::from_mut_ref(&mut self_alias);
evtarget.set_event_handler_uncompiled(cx, url, reflector, evtarget.set_event_handler_uncompiled(cx, url, reflector,
name.as_slice().slice_from(2), name.as_slice().slice_from(2),
value); value);

11
src/components/script/dom/htmliframeelement.rs
View file

@ -39,7 +39,7 @@ enum SandboxAllowance {
#[deriving(Encodable)] #[deriving(Encodable)]
pub struct HTMLIFrameElement { pub struct HTMLIFrameElement {
pub htmlelement: HTMLElement, pub htmlelement: HTMLElement,
pub size: Option<IFrameSize>, pub size: Traceable<Cell<Option<IFrameSize>>>,
pub sandbox: Traceable<Cell<Option<u8>>>, pub sandbox: Traceable<Cell<Option<u8>>>,
} }
@ -79,7 +79,7 @@ impl HTMLIFrameElement {
pub fn new_inherited(localName: DOMString, document: &JSRef<Document>) -> HTMLIFrameElement { pub fn new_inherited(localName: DOMString, document: &JSRef<Document>) -> HTMLIFrameElement {
HTMLIFrameElement { HTMLIFrameElement {
htmlelement: HTMLElement::new_inherited(HTMLIFrameElementTypeId, localName, document), htmlelement: HTMLElement::new_inherited(HTMLIFrameElementTypeId, localName, document),
size: None, size: Traceable::new(Cell::new(None)),
sandbox: Traceable::new(Cell::new(None)), sandbox: Traceable::new(Cell::new(None)),
} }
} }
@ -120,7 +120,7 @@ impl<'a> HTMLIFrameElementMethods for JSRef<'a, HTMLIFrameElement> {
} }
fn GetContentWindow(&self) -> Option<Temporary<Window>> { fn GetContentWindow(&self) -> Option<Temporary<Window>> {
self.size.and_then(|size| { self.size.deref().get().and_then(|size| {
let window = window_from_node(self).root(); let window = window_from_node(self).root();
let children = &*window.deref().page.children.deref().borrow(); let children = &*window.deref().page.children.deref().borrow();
let child = children.iter().find(|child| { let child = children.iter().find(|child| {
@ -194,11 +194,10 @@ impl<'a> VirtualMethods for JSRef<'a, HTMLIFrameElement> {
let page = window.deref().page(); let page = window.deref().page();
let subpage_id = page.get_next_subpage_id(); let subpage_id = page.get_next_subpage_id();
let mut self_alias = self.clone(); self.deref().size.deref().set(Some(IFrameSize {
self_alias.deref_mut().size = Some(IFrameSize {
pipeline_id: page.id, pipeline_id: page.id,
subpage_id: subpage_id, subpage_id: subpage_id,
}); }));
let ConstellationChan(ref chan) = *page.constellation_chan.deref(); let ConstellationChan(ref chan) = *page.constellation_chan.deref();
chan.send(LoadIframeUrlMsg(url, page.id, subpage_id, sandboxed)); chan.send(LoadIframeUrlMsg(url, page.id, subpage_id, sandboxed));

30
src/components/script/dom/htmlimageelement.rs
View file

@ -17,12 +17,13 @@ use servo_util::geometry::to_px;
use servo_net::image_cache_task; use servo_net::image_cache_task;
use servo_util::url::parse_url; use servo_util::url::parse_url;
use servo_util::str::DOMString; use servo_util::str::DOMString;
use std::cell::RefCell;
use url::Url; use url::Url;
#[deriving(Encodable)] #[deriving(Encodable)]
pub struct HTMLImageElement { pub struct HTMLImageElement {
pub htmlelement: HTMLElement, pub htmlelement: HTMLElement,
image: Untraceable<Option<Url>>, image: Untraceable<RefCell<Option<Url>>>,
} }
impl HTMLImageElementDerived for EventTarget { impl HTMLImageElementDerived for EventTarget {
@ -32,25 +33,24 @@ impl HTMLImageElementDerived for EventTarget {
} }
trait PrivateHTMLImageElementHelpers { trait PrivateHTMLImageElementHelpers {
fn update_image(&mut self, value: Option<DOMString>, url: Option<Url>); fn update_image(&self, value: Option<DOMString>, url: Option<Url>);
} }
impl<'a> PrivateHTMLImageElementHelpers for JSRef<'a, HTMLImageElement> { impl<'a> PrivateHTMLImageElementHelpers for JSRef<'a, HTMLImageElement> {
/// Makes the local `image` member match the status of the `src` attribute and starts /// Makes the local `image` member match the status of the `src` attribute and starts
/// prefetching the image. This method must be called after `src` is changed. /// prefetching the image. This method must be called after `src` is changed.
fn update_image(&mut self, value: Option<DOMString>, url: Option<Url>) { fn update_image(&self, value: Option<DOMString>, url: Option<Url>) {
let self_alias = self.clone(); let node: &JSRef<Node> = NodeCast::from_ref(self);
let node_alias: &JSRef<Node> = NodeCast::from_ref(&self_alias); let document = node.owner_doc().root();
let document = node_alias.owner_doc().root();
let window = document.deref().window.root(); let window = document.deref().window.root();
let image_cache = &window.image_cache_task; let image_cache = &window.image_cache_task;
match value { match value {
None => { None => {
*self.image = None; *self.image.deref().borrow_mut() = None;
} }
Some(src) => { Some(src) => {
let img_url = parse_url(src.as_slice(), url); let img_url = parse_url(src.as_slice(), url);
*self.image = Some(img_url.clone()); *self.image.deref().borrow_mut() = Some(img_url.clone());
// inform the image cache to load this, but don't store a // inform the image cache to load this, but don't store a
// handle. // handle.
@ -67,7 +67,7 @@ impl HTMLImageElement {
pub fn new_inherited(localName: DOMString, document: &JSRef<Document>) -> HTMLImageElement { pub fn new_inherited(localName: DOMString, document: &JSRef<Document>) -> HTMLImageElement {
HTMLImageElement { HTMLImageElement {
htmlelement: HTMLElement::new_inherited(HTMLImageElementTypeId, localName, document), htmlelement: HTMLElement::new_inherited(HTMLImageElementTypeId, localName, document),
image: Untraceable::new(None), image: Untraceable::new(RefCell::new(None)),
} }
} }
@ -78,12 +78,12 @@ impl HTMLImageElement {
} }
pub trait LayoutHTMLImageElementHelpers { pub trait LayoutHTMLImageElementHelpers {
unsafe fn image<'a>(&'a self) -> &'a Option<Url>; unsafe fn image(&self) -> Option<Url>;
} }
impl LayoutHTMLImageElementHelpers for JS<HTMLImageElement> { impl LayoutHTMLImageElementHelpers for JS<HTMLImageElement> {
unsafe fn image<'a>(&'a self) -> &'a Option<Url> { unsafe fn image(&self) -> Option<Url> {
&*(*self.unsafe_get()).image (*self.unsafe_get()).image.borrow().clone()
} }
} }
@ -253,8 +253,7 @@ impl<'a> VirtualMethods for JSRef<'a, HTMLImageElement> {
if "src" == name.as_slice() { if "src" == name.as_slice() {
let window = window_from_node(self).root(); let window = window_from_node(self).root();
let url = Some(window.deref().get_url()); let url = Some(window.deref().get_url());
let mut self_alias = self.clone(); self.update_image(Some(value), url);
self_alias.update_image(Some(value), url);
} }
} }
@ -265,8 +264,7 @@ impl<'a> VirtualMethods for JSRef<'a, HTMLImageElement> {
} }
if "src" == name.as_slice() { if "src" == name.as_slice() {
let mut self_alias = self.clone(); self.update_image(None, None);
self_alias.update_image(None, None);
} }
} }
} }

12
src/components/script/dom/htmlserializer.rs
View file

@ -67,7 +67,7 @@ pub fn serialize(iterator: &mut NodeIterator) -> String {
fn serialize_comment(comment: &JSRef<Comment>, html: &mut String) { fn serialize_comment(comment: &JSRef<Comment>, html: &mut String) {
html.push_str("<!--"); html.push_str("<!--");
html.push_str(comment.deref().characterdata.data.as_slice()); html.push_str(comment.deref().characterdata.data.deref().borrow().as_slice());
html.push_str("-->"); html.push_str("-->");
} }
@ -80,11 +80,11 @@ fn serialize_text(text: &JSRef<Text>, html: &mut String) {
"style" | "script" | "xmp" | "iframe" | "style" | "script" | "xmp" | "iframe" |
"noembed" | "noframes" | "plaintext" | "noembed" | "noframes" | "plaintext" |
"noscript" if elem.deref().namespace == namespace::HTML "noscript" if elem.deref().namespace == namespace::HTML
=> html.push_str(text.deref().characterdata.data.as_slice()), => html.push_str(text.deref().characterdata.data.deref().borrow().as_slice()),
_ => escape(text.deref().characterdata.data.as_slice(), false, html) _ => escape(text.deref().characterdata.data.deref().borrow().as_slice(), false, html)
} }
} }
_ => escape(text.deref().characterdata.data.as_slice(), false, html) _ => escape(text.deref().characterdata.data.deref().borrow().as_slice(), false, html)
} }
} }
@ -93,7 +93,7 @@ fn serialize_processing_instruction(processing_instruction: &JSRef<ProcessingIns
html.push_str("<?"); html.push_str("<?");
html.push_str(processing_instruction.deref().target.as_slice()); html.push_str(processing_instruction.deref().target.as_slice());
html.push_char(' '); html.push_char(' ');
html.push_str(processing_instruction.deref().characterdata.data.as_slice()); html.push_str(processing_instruction.deref().characterdata.data.deref().borrow().as_slice());
html.push_str("?>"); html.push_str("?>");
} }
@ -118,7 +118,7 @@ fn serialize_elem(elem: &JSRef<Element>, open_elements: &mut Vec<String>, html:
match node.first_child().map(|child| child.root()) { match node.first_child().map(|child| child.root()) {
Some(ref child) if child.is_text() => { Some(ref child) if child.is_text() => {
let text: &JSRef<CharacterData> = CharacterDataCast::to_ref(&**child).unwrap(); let text: &JSRef<CharacterData> = CharacterDataCast::to_ref(&**child).unwrap();
if text.deref().data.len() > 0 && text.deref().data.as_slice().char_at(0) == '\n' { if text.deref().data.deref().borrow().len() > 0 && text.deref().data.deref().borrow().as_slice().char_at(0) == '\n' {
html.push_char('\x0A'); html.push_char('\x0A');
} }
}, },

70
src/components/script/dom/node.rs
View file

@ -11,12 +11,13 @@ use dom::bindings::codegen::InheritTypes::{ElementCast, TextCast, NodeCast, Elem
use dom::bindings::codegen::InheritTypes::{CharacterDataCast, NodeBase, NodeDerived}; use dom::bindings::codegen::InheritTypes::{CharacterDataCast, NodeBase, NodeDerived};
use dom::bindings::codegen::InheritTypes::{ProcessingInstructionCast, EventTargetCast}; use dom::bindings::codegen::InheritTypes::{ProcessingInstructionCast, EventTargetCast};
use dom::bindings::codegen::Bindings::NodeBinding::NodeConstants; use dom::bindings::codegen::Bindings::NodeBinding::NodeConstants;
use dom::bindings::error::{ErrorResult, Fallible, NotFound, HierarchyRequest, Syntax};
use dom::bindings::js::{JS, JSRef, RootedReference, Temporary, Root, OptionalUnrootable}; use dom::bindings::js::{JS, JSRef, RootedReference, Temporary, Root, OptionalUnrootable};
use dom::bindings::js::{OptionalSettable, TemporaryPushable, OptionalRootedRootable}; use dom::bindings::js::{OptionalSettable, TemporaryPushable, OptionalRootedRootable};
use dom::bindings::js::{ResultRootable, OptionalRootable}; use dom::bindings::js::{ResultRootable, OptionalRootable};
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object}; use dom::bindings::trace::Untraceable;
use dom::bindings::error::{ErrorResult, Fallible, NotFound, HierarchyRequest, Syntax};
use dom::bindings::utils; use dom::bindings::utils;
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::characterdata::{CharacterData, CharacterDataMethods}; use dom::characterdata::{CharacterData, CharacterDataMethods};
use dom::comment::Comment; use dom::comment::Comment;
use dom::document::{Document, DocumentMethods, DocumentHelpers, HTMLDocument, NonHTMLDocument}; use dom::document::{Document, DocumentMethods, DocumentHelpers, HTMLDocument, NonHTMLDocument};
@ -86,7 +87,7 @@ pub struct Node {
pub child_list: Cell<Option<JS<NodeList>>>, pub child_list: Cell<Option<JS<NodeList>>>,
/// A bitfield of flags for node items. /// A bitfield of flags for node items.
flags: NodeFlags, flags: Untraceable<RefCell<NodeFlags>>,
/// Layout information. Only the layout task may touch this data. /// Layout information. Only the layout task may touch this data.
/// ///
@ -382,7 +383,7 @@ pub trait NodeHelpers {
fn is_anchor_element(&self) -> bool; fn is_anchor_element(&self) -> bool;
fn get_hover_state(&self) -> bool; fn get_hover_state(&self) -> bool;
fn set_hover_state(&mut self, state: bool); fn set_hover_state(&self, state: bool);
fn dump(&self); fn dump(&self);
fn dump_indent(&self, indent: uint); fn dump_indent(&self, indent: uint);
@ -430,7 +431,7 @@ impl<'a> NodeHelpers for JSRef<'a, Node> {
} }
fn is_in_doc(&self) -> bool { fn is_in_doc(&self) -> bool {
self.deref().flags.contains(IsInDoc) self.deref().flags.deref().borrow().contains(IsInDoc)
} }
/// Returns the type ID of this node. Fails if this node is borrowed mutably. /// Returns the type ID of this node. Fails if this node is borrowed mutably.
@ -489,14 +490,14 @@ impl<'a> NodeHelpers for JSRef<'a, Node> {
} }
fn get_hover_state(&self) -> bool { fn get_hover_state(&self) -> bool {
self.flags.contains(InHoverState) self.flags.deref().borrow().contains(InHoverState)
} }
fn set_hover_state(&mut self, state: bool) { fn set_hover_state(&self, state: bool) {
if state { if state {
self.flags.insert(InHoverState); self.flags.deref().borrow_mut().insert(InHoverState);
} else { } else {
self.flags.remove(InHoverState); self.flags.deref().borrow_mut().remove(InHoverState);
} }
} }
@ -706,7 +707,7 @@ pub trait RawLayoutNodeHelpers {
impl RawLayoutNodeHelpers for Node { impl RawLayoutNodeHelpers for Node {
unsafe fn get_hover_state_for_layout(&self) -> bool { unsafe fn get_hover_state_for_layout(&self) -> bool {
self.flags.contains(InHoverState) self.flags.deref().borrow().contains(InHoverState)
} }
} }
@ -916,7 +917,7 @@ impl Node {
owner_doc: Cell::new(doc.unrooted()), owner_doc: Cell::new(doc.unrooted()),
child_list: Cell::new(None), child_list: Cell::new(None),
flags: NodeFlags::new(type_id), flags: Untraceable::new(RefCell::new(NodeFlags::new(type_id))),
layout_data: LayoutDataRef::new(), layout_data: LayoutDataRef::new(),
} }
@ -1110,9 +1111,9 @@ impl Node {
for node in nodes.mut_iter() { for node in nodes.mut_iter() {
parent.add_child(node, child); parent.add_child(node, child);
if parent.is_in_doc() { if parent.is_in_doc() {
node.flags.insert(IsInDoc); node.flags.deref().borrow_mut().insert(IsInDoc);
} else { } else {
node.flags.remove(IsInDoc); node.flags.deref().borrow_mut().remove(IsInDoc);
} }
} }
@ -1197,9 +1198,7 @@ impl Node {
// Step 8. // Step 8.
parent.remove_child(node); parent.remove_child(node);
// FIXME(2513): remove this `node_alias` when in fix mozilla#2513 node.deref().flags.deref().borrow_mut().remove(IsInDoc);
let mut node_alias = node.clone();
node_alias.deref_mut().flags.remove(IsInDoc);
// Step 9. // Step 9.
match suppress_observers { match suppress_observers {
@ -1236,7 +1235,7 @@ impl Node {
CommentNodeTypeId => { CommentNodeTypeId => {
let comment: &JSRef<Comment> = CommentCast::to_ref(node).unwrap(); let comment: &JSRef<Comment> = CommentCast::to_ref(node).unwrap();
let comment = comment.deref(); let comment = comment.deref();
let comment = Comment::new(comment.characterdata.data.clone(), &*document); let comment = Comment::new(comment.characterdata.data.deref().borrow().clone(), &*document);
NodeCast::from_temporary(comment) NodeCast::from_temporary(comment)
}, },
DocumentNodeTypeId => { DocumentNodeTypeId => {
@ -1253,20 +1252,21 @@ impl Node {
ElementNodeTypeId(..) => { ElementNodeTypeId(..) => {
let element: &JSRef<Element> = ElementCast::to_ref(node).unwrap(); let element: &JSRef<Element> = ElementCast::to_ref(node).unwrap();
let element = element.deref(); let element = element.deref();
let element = build_element_from_tag(element.local_name.clone(), &*document); let element = build_element_from_tag(element.local_name.clone(),
element.namespace.clone(), &*document);
NodeCast::from_temporary(element) NodeCast::from_temporary(element)
}, },
TextNodeTypeId => { TextNodeTypeId => {
let text: &JSRef<Text> = TextCast::to_ref(node).unwrap(); let text: &JSRef<Text> = TextCast::to_ref(node).unwrap();
let text = text.deref(); let text = text.deref();
let text = Text::new(text.characterdata.data.clone(), &*document); let text = Text::new(text.characterdata.data.deref().borrow().clone(), &*document);
NodeCast::from_temporary(text) NodeCast::from_temporary(text)
}, },
ProcessingInstructionNodeTypeId => { ProcessingInstructionNodeTypeId => {
let pi: &JSRef<ProcessingInstruction> = ProcessingInstructionCast::to_ref(node).unwrap(); let pi: &JSRef<ProcessingInstruction> = ProcessingInstructionCast::to_ref(node).unwrap();
let pi = pi.deref(); let pi = pi.deref();
let pi = ProcessingInstruction::new(pi.target.clone(), let pi = ProcessingInstruction::new(pi.target.clone(),
pi.characterdata.data.clone(), &*document); pi.characterdata.data.deref().borrow().clone(), &*document);
NodeCast::from_temporary(pi) NodeCast::from_temporary(pi)
}, },
}.root(); }.root();
@ -1284,28 +1284,22 @@ impl Node {
match node.type_id() { match node.type_id() {
DocumentNodeTypeId => { DocumentNodeTypeId => {
let node_doc: &JSRef<Document> = DocumentCast::to_ref(node).unwrap(); let node_doc: &JSRef<Document> = DocumentCast::to_ref(node).unwrap();
let copy_doc: &mut JSRef<Document> = DocumentCast::to_mut_ref(&mut *copy).unwrap(); let copy_doc: &JSRef<Document> = DocumentCast::to_ref(&*copy).unwrap();
copy_doc.set_encoding_name(node_doc.encoding_name.clone()); copy_doc.set_encoding_name(node_doc.encoding_name.deref().borrow().clone());
copy_doc.set_quirks_mode(node_doc.quirks_mode()); copy_doc.set_quirks_mode(node_doc.quirks_mode());
}, },
ElementNodeTypeId(..) => { ElementNodeTypeId(..) => {
let node_elem: &JSRef<Element> = ElementCast::to_ref(node).unwrap(); let node_elem: &JSRef<Element> = ElementCast::to_ref(node).unwrap();
let node_elem = node_elem.deref(); let copy_elem: &JSRef<Element> = ElementCast::to_ref(&*copy).unwrap();
let copy_elem: &mut JSRef<Element> = ElementCast::to_mut_ref(&mut *copy).unwrap();
// XXX: to avoid double borrowing compile error. we might be able to fix this after #1854
let copy_elem_alias = copy_elem.clone();
let copy_elem = copy_elem.deref_mut();
// FIXME: https://github.com/mozilla/servo/issues/1737 // FIXME: https://github.com/mozilla/servo/issues/1737
copy_elem.namespace = node_elem.namespace.clone();
let window = document.deref().window.root(); let window = document.deref().window.root();
for attr in node_elem.attrs.borrow().iter().map(|attr| attr.root()) { for attr in node_elem.deref().attrs.borrow().iter().map(|attr| attr.root()) {
copy_elem.attrs.borrow_mut().push_unrooted( copy_elem.deref().attrs.borrow_mut().push_unrooted(
&Attr::new(&*window, &Attr::new(&*window,
attr.deref().local_name.clone(), attr.deref().value.clone(), attr.deref().local_name.clone(), attr.deref().value.clone(),
attr.deref().name.clone(), attr.deref().namespace.clone(), attr.deref().name.clone(), attr.deref().namespace.clone(),
attr.deref().prefix.clone(), &copy_elem_alias)); attr.deref().prefix.clone(), copy_elem));
} }
}, },
_ => () _ => ()
@ -1520,7 +1514,7 @@ impl<'a> NodeMethods for JSRef<'a, Node> {
for node in self.traverse_preorder() { for node in self.traverse_preorder() {
if node.is_text() { if node.is_text() {
let text: &JSRef<Text> = TextCast::to_ref(&node).unwrap(); let text: &JSRef<Text> = TextCast::to_ref(&node).unwrap();
content.push_str(text.deref().characterdata.data.as_slice()); content.push_str(text.deref().characterdata.data.deref().borrow().as_slice());
} }
} }
Some(content.into_owned()) Some(content.into_owned())
@ -1561,10 +1555,8 @@ impl<'a> NodeMethods for JSRef<'a, Node> {
ProcessingInstructionNodeTypeId => { ProcessingInstructionNodeTypeId => {
self.wait_until_safe_to_modify_dom(); self.wait_until_safe_to_modify_dom();
{ let characterdata: &JSRef<CharacterData> = CharacterDataCast::to_ref(self).unwrap();
let characterdata: &mut JSRef<CharacterData> = CharacterDataCast::to_mut_ref(self).unwrap(); *characterdata.data.deref().borrow_mut() = value;
characterdata.deref_mut().data = value;
}
// Notify the document that the content of this node is different // Notify the document that the content of this node is different
let document = self.owner_doc().root(); let document = self.owner_doc().root();
@ -1778,12 +1770,12 @@ impl<'a> NodeMethods for JSRef<'a, Node> {
let pi: &JSRef<ProcessingInstruction> = ProcessingInstructionCast::to_ref(node).unwrap(); let pi: &JSRef<ProcessingInstruction> = ProcessingInstructionCast::to_ref(node).unwrap();
let other_pi: &JSRef<ProcessingInstruction> = ProcessingInstructionCast::to_ref(other).unwrap(); let other_pi: &JSRef<ProcessingInstruction> = ProcessingInstructionCast::to_ref(other).unwrap();
(pi.deref().target == other_pi.deref().target) && (pi.deref().target == other_pi.deref().target) &&
(pi.deref().characterdata.data == other_pi.deref().characterdata.data) (*pi.deref().characterdata.data.deref().borrow() == *other_pi.deref().characterdata.data.deref().borrow())
} }
fn is_equal_characterdata(node: &JSRef<Node>, other: &JSRef<Node>) -> bool { fn is_equal_characterdata(node: &JSRef<Node>, other: &JSRef<Node>) -> bool {
let characterdata: &JSRef<CharacterData> = CharacterDataCast::to_ref(node).unwrap(); let characterdata: &JSRef<CharacterData> = CharacterDataCast::to_ref(node).unwrap();
let other_characterdata: &JSRef<CharacterData> = CharacterDataCast::to_ref(other).unwrap(); let other_characterdata: &JSRef<CharacterData> = CharacterDataCast::to_ref(other).unwrap();
characterdata.deref().data == other_characterdata.deref().data *characterdata.deref().data.deref().borrow() == *other_characterdata.deref().data.deref().borrow()
} }
fn is_equal_element_attrs(node: &JSRef<Node>, other: &JSRef<Node>) -> bool { fn is_equal_element_attrs(node: &JSRef<Node>, other: &JSRef<Node>) -> bool {
let element: &JSRef<Element> = ElementCast::to_ref(node).unwrap(); let element: &JSRef<Element> = ElementCast::to_ref(node).unwrap();

6
src/components/script/dom/progressevent.rs
View file

@ -37,13 +37,11 @@ impl ProgressEvent {
pub fn new(window: &JSRef<Window>, type_: DOMString, pub fn new(window: &JSRef<Window>, type_: DOMString,
can_bubble: bool, cancelable: bool, can_bubble: bool, cancelable: bool,
length_computable: bool, loaded: u64, total: u64) -> Temporary<ProgressEvent> { length_computable: bool, loaded: u64, total: u64) -> Temporary<ProgressEvent> {
let mut ev = reflect_dom_object(box ProgressEvent::new_inherited(length_computable, loaded, total), let ev = reflect_dom_object(box ProgressEvent::new_inherited(length_computable, loaded, total),
window, window,
ProgressEventBinding::Wrap).root(); ProgressEventBinding::Wrap).root();
{ let event: &JSRef<Event> = EventCast::from_ref(&*ev);
let event: &mut JSRef<Event> = EventCast::from_mut_ref(&mut *ev);
event.InitEvent(type_, can_bubble, cancelable); event.InitEvent(type_, can_bubble, cancelable);
}
Temporary::from_rooted(&*ev) Temporary::from_rooted(&*ev)
} }
pub fn Constructor(owner: &JSRef<Window>, pub fn Constructor(owner: &JSRef<Window>,

23
src/components/script/dom/uievent.rs
View file

@ -4,8 +4,9 @@
use dom::bindings::codegen::Bindings::UIEventBinding; use dom::bindings::codegen::Bindings::UIEventBinding;
use dom::bindings::codegen::InheritTypes::{EventCast, UIEventDerived}; use dom::bindings::codegen::InheritTypes::{EventCast, UIEventDerived};
use dom::bindings::js::{JS, JSRef, RootedReference, Temporary, OptionalSettable};
use dom::bindings::error::Fallible; use dom::bindings::error::Fallible;
use dom::bindings::js::{JS, JSRef, RootedReference, Temporary, OptionalSettable};
use dom::bindings::trace::Untraceable;
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object}; use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::event::{Event, EventMethods, EventTypeId, UIEventTypeId}; use dom::event::{Event, EventMethods, EventTypeId, UIEventTypeId};
use dom::window::Window; use dom::window::Window;
@ -18,7 +19,7 @@ use std::cell::Cell;
pub struct UIEvent { pub struct UIEvent {
pub event: Event, pub event: Event,
pub view: Cell<Option<JS<Window>>>, pub view: Cell<Option<JS<Window>>>,
pub detail: i32 pub detail: Untraceable<Cell<i32>>
} }
impl UIEventDerived for Event { impl UIEventDerived for Event {
@ -32,7 +33,7 @@ impl UIEvent {
UIEvent { UIEvent {
event: Event::new_inherited(type_id), event: Event::new_inherited(type_id),
view: Cell::new(None), view: Cell::new(None),
detail: 0 detail: Untraceable::new(Cell::new(0)),
} }
} }
@ -48,8 +49,8 @@ impl UIEvent {
cancelable: bool, cancelable: bool,
view: Option<JSRef<Window>>, view: Option<JSRef<Window>>,
detail: i32) -> Temporary<UIEvent> { detail: i32) -> Temporary<UIEvent> {
let mut ev = UIEvent::new_uninitialized(window).root(); let ev = UIEvent::new_uninitialized(window).root();
ev.InitUIEvent(type_, can_bubble, cancelable, view, detail); ev.deref().InitUIEvent(type_, can_bubble, cancelable, view, detail);
Temporary::from_rooted(&*ev) Temporary::from_rooted(&*ev)
} }
@ -66,7 +67,7 @@ impl UIEvent {
pub trait UIEventMethods { pub trait UIEventMethods {
fn GetView(&self) -> Option<Temporary<Window>>; fn GetView(&self) -> Option<Temporary<Window>>;
fn Detail(&self) -> i32; fn Detail(&self) -> i32;
fn InitUIEvent(&mut self, fn InitUIEvent(&self,
type_: DOMString, type_: DOMString,
can_bubble: bool, can_bubble: bool,
cancelable: bool, cancelable: bool,
@ -80,21 +81,19 @@ impl<'a> UIEventMethods for JSRef<'a, UIEvent> {
} }
fn Detail(&self) -> i32 { fn Detail(&self) -> i32 {
self.detail self.detail.deref().get()
} }
fn InitUIEvent(&mut self, fn InitUIEvent(&self,
type_: DOMString, type_: DOMString,
can_bubble: bool, can_bubble: bool,
cancelable: bool, cancelable: bool,
view: Option<JSRef<Window>>, view: Option<JSRef<Window>>,
detail: i32) { detail: i32) {
{ let event: &JSRef<Event> = EventCast::from_ref(self);
let event: &mut JSRef<Event> = EventCast::from_mut_ref(self);
event.InitEvent(type_, can_bubble, cancelable); event.InitEvent(type_, can_bubble, cancelable);
}
self.view.assign(view); self.view.assign(view);
self.detail = detail; self.detail.deref().set(detail);
} }
} }

77
src/components/script/dom/window.rs
View file

@ -29,7 +29,7 @@ use js::jsapi::{JS_GC, JS_GetRuntime};
use js::jsval::JSVal; use js::jsval::JSVal;
use collections::hashmap::HashMap; use collections::hashmap::HashMap;
use std::cell::Cell; use std::cell::{Cell, RefCell};
use std::cmp; use std::cmp;
use std::comm::{channel, Sender}; use std::comm::{channel, Sender};
use std::comm::Select; use std::comm::Select;
@ -73,10 +73,10 @@ pub struct Window {
pub location: Cell<Option<JS<Location>>>, pub location: Cell<Option<JS<Location>>>,
pub navigator: Cell<Option<JS<Navigator>>>, pub navigator: Cell<Option<JS<Navigator>>>,
pub image_cache_task: ImageCacheTask, pub image_cache_task: ImageCacheTask,
pub active_timers: Box<HashMap<TimerId, TimerHandle>>, pub active_timers: Traceable<RefCell<HashMap<TimerId, TimerHandle>>>,
pub next_timer_handle: i32, pub next_timer_handle: Untraceable<Cell<i32>>,
pub compositor: Untraceable<Box<ScriptListener>>, pub compositor: Untraceable<Box<ScriptListener>>,
pub browser_context: Option<BrowserContext>, pub browser_context: Traceable<RefCell<Option<BrowserContext>>>,
pub page: Rc<Page>, pub page: Rc<Page>,
pub performance: Cell<Option<JS<Performance>>>, pub performance: Cell<Option<JS<Performance>>>,
pub navigationStart: u64, pub navigationStart: u64,
@ -100,7 +100,7 @@ impl Window {
#[unsafe_destructor] #[unsafe_destructor]
impl Drop for Window { impl Drop for Window {
fn drop(&mut self) { fn drop(&mut self) {
for (_, timer_handle) in self.active_timers.mut_iter() { for (_, timer_handle) in self.active_timers.borrow_mut().mut_iter() {
timer_handle.cancel(); timer_handle.cancel();
} }
} }
@ -122,21 +122,21 @@ pub trait WindowMethods {
fn Location(&self) -> Temporary<Location>; fn Location(&self) -> Temporary<Location>;
fn Console(&self) -> Temporary<Console>; fn Console(&self) -> Temporary<Console>;
fn Navigator(&self) -> Temporary<Navigator>; fn Navigator(&self) -> Temporary<Navigator>;
fn SetTimeout(&mut self, _cx: *mut JSContext, callback: JSVal, timeout: i32) -> i32; fn SetTimeout(&self, _cx: *mut JSContext, callback: JSVal, timeout: i32) -> i32;
fn ClearTimeout(&mut self, handle: i32); fn ClearTimeout(&self, handle: i32);
fn SetInterval(&mut self, _cx: *mut JSContext, callback: JSVal, timeout: i32) -> i32; fn SetInterval(&self, _cx: *mut JSContext, callback: JSVal, timeout: i32) -> i32;
fn ClearInterval(&mut self, handle: i32); fn ClearInterval(&self, handle: i32);
fn Window(&self) -> Temporary<Window>; fn Window(&self) -> Temporary<Window>;
fn Self(&self) -> Temporary<Window>; fn Self(&self) -> Temporary<Window>;
fn Performance(&self) -> Temporary<Performance>; fn Performance(&self) -> Temporary<Performance>;
fn GetOnclick(&self) -> Option<EventHandlerNonNull>; fn GetOnclick(&self) -> Option<EventHandlerNonNull>;
fn SetOnclick(&mut self, listener: Option<EventHandlerNonNull>); fn SetOnclick(&self, listener: Option<EventHandlerNonNull>);
fn GetOnload(&self) -> Option<EventHandlerNonNull>; fn GetOnload(&self) -> Option<EventHandlerNonNull>;
fn SetOnload(&mut self, listener: Option<EventHandlerNonNull>); fn SetOnload(&self, listener: Option<EventHandlerNonNull>);
fn GetOnunload(&self) -> Option<EventHandlerNonNull>; fn GetOnunload(&self) -> Option<EventHandlerNonNull>;
fn SetOnunload(&mut self, listener: Option<EventHandlerNonNull>); fn SetOnunload(&self, listener: Option<EventHandlerNonNull>);
fn GetOnerror(&self) -> Option<OnErrorEventHandlerNonNull>; fn GetOnerror(&self) -> Option<OnErrorEventHandlerNonNull>;
fn SetOnerror(&mut self, listener: Option<OnErrorEventHandlerNonNull>); fn SetOnerror(&self, listener: Option<OnErrorEventHandlerNonNull>);
fn Debug(&self, message: DOMString); fn Debug(&self, message: DOMString);
fn Gc(&self); fn Gc(&self);
} }
@ -182,24 +182,25 @@ impl<'a> WindowMethods for JSRef<'a, Window> {
Temporary::new(self.navigator.get().get_ref().clone()) Temporary::new(self.navigator.get().get_ref().clone())
} }
fn SetTimeout(&mut self, _cx: *mut JSContext, callback: JSVal, timeout: i32) -> i32 { fn SetTimeout(&self, _cx: *mut JSContext, callback: JSVal, timeout: i32) -> i32 {
self.set_timeout_or_interval(callback, timeout, false) self.set_timeout_or_interval(callback, timeout, false)
} }
fn ClearTimeout(&mut self, handle: i32) { fn ClearTimeout(&self, handle: i32) {
let mut timer_handle = self.active_timers.pop(&TimerId(handle)); let mut timers = self.active_timers.deref().borrow_mut();
let mut timer_handle = timers.pop(&TimerId(handle));
match timer_handle { match timer_handle {
Some(ref mut handle) => handle.cancel(), Some(ref mut handle) => handle.cancel(),
None => { } None => { }
} }
self.active_timers.remove(&TimerId(handle)); timers.remove(&TimerId(handle));
} }
fn SetInterval(&mut self, _cx: *mut JSContext, callback: JSVal, timeout: i32) -> i32 { fn SetInterval(&self, _cx: *mut JSContext, callback: JSVal, timeout: i32) -> i32 {
self.set_timeout_or_interval(callback, timeout, true) self.set_timeout_or_interval(callback, timeout, true)
} }
fn ClearInterval(&mut self, handle: i32) { fn ClearInterval(&self, handle: i32) {
self.ClearTimeout(handle); self.ClearTimeout(handle);
} }
@ -224,8 +225,8 @@ impl<'a> WindowMethods for JSRef<'a, Window> {
eventtarget.get_event_handler_common("click") eventtarget.get_event_handler_common("click")
} }
fn SetOnclick(&mut self, listener: Option<EventHandlerNonNull>) { fn SetOnclick(&self, listener: Option<EventHandlerNonNull>) {
let eventtarget: &mut JSRef<EventTarget> = EventTargetCast::from_mut_ref(self); let eventtarget: &JSRef<EventTarget> = EventTargetCast::from_ref(self);
eventtarget.set_event_handler_common("click", listener) eventtarget.set_event_handler_common("click", listener)
} }
@ -234,8 +235,8 @@ impl<'a> WindowMethods for JSRef<'a, Window> {
eventtarget.get_event_handler_common("load") eventtarget.get_event_handler_common("load")
} }
fn SetOnload(&mut self, listener: Option<EventHandlerNonNull>) { fn SetOnload(&self, listener: Option<EventHandlerNonNull>) {
let eventtarget: &mut JSRef<EventTarget> = EventTargetCast::from_mut_ref(self); let eventtarget: &JSRef<EventTarget> = EventTargetCast::from_ref(self);
eventtarget.set_event_handler_common("load", listener) eventtarget.set_event_handler_common("load", listener)
} }
@ -244,8 +245,8 @@ impl<'a> WindowMethods for JSRef<'a, Window> {
eventtarget.get_event_handler_common("unload") eventtarget.get_event_handler_common("unload")
} }
fn SetOnunload(&mut self, listener: Option<EventHandlerNonNull>) { fn SetOnunload(&self, listener: Option<EventHandlerNonNull>) {
let eventtarget: &mut JSRef<EventTarget> = EventTargetCast::from_mut_ref(self); let eventtarget: &JSRef<EventTarget> = EventTargetCast::from_ref(self);
eventtarget.set_event_handler_common("unload", listener) eventtarget.set_event_handler_common("unload", listener)
} }
@ -254,8 +255,8 @@ impl<'a> WindowMethods for JSRef<'a, Window> {
eventtarget.get_event_handler_common("error") eventtarget.get_event_handler_common("error")
} }
fn SetOnerror(&mut self, listener: Option<OnErrorEventHandlerNonNull>) { fn SetOnerror(&self, listener: Option<OnErrorEventHandlerNonNull>) {
let eventtarget: &mut JSRef<EventTarget> = EventTargetCast::from_mut_ref(self); let eventtarget: &JSRef<EventTarget> = EventTargetCast::from_ref(self);
eventtarget.set_event_handler_common("error", listener) eventtarget.set_event_handler_common("error", listener)
} }
@ -283,12 +284,12 @@ impl Reflectable for Window {
pub trait WindowHelpers { pub trait WindowHelpers {
fn damage_and_reflow(&self, damage: DocumentDamageLevel); fn damage_and_reflow(&self, damage: DocumentDamageLevel);
fn wait_until_safe_to_modify_dom(&self); fn wait_until_safe_to_modify_dom(&self);
fn init_browser_context(&mut self, doc: &JSRef<Document>); fn init_browser_context(&self, doc: &JSRef<Document>);
fn load_url(&self, href: DOMString); fn load_url(&self, href: DOMString);
} }
trait PrivateWindowHelpers { trait PrivateWindowHelpers {
fn set_timeout_or_interval(&mut self, callback: JSVal, timeout: i32, is_interval: bool) -> i32; fn set_timeout_or_interval(&self, callback: JSVal, timeout: i32, is_interval: bool) -> i32;
} }
impl<'a> WindowHelpers for JSRef<'a, Window> { impl<'a> WindowHelpers for JSRef<'a, Window> {
@ -306,8 +307,8 @@ impl<'a> WindowHelpers for JSRef<'a, Window> {
self.page().join_layout(); self.page().join_layout();
} }
fn init_browser_context(&mut self, doc: &JSRef<Document>) { fn init_browser_context(&self, doc: &JSRef<Document>) {
self.browser_context = Some(BrowserContext::new(doc)); *self.browser_context.deref().borrow_mut() = Some(BrowserContext::new(doc));
} }
/// Commence a new URL load which will either replace this window or scroll to a fragment. /// Commence a new URL load which will either replace this window or scroll to a fragment.
@ -325,10 +326,10 @@ impl<'a> WindowHelpers for JSRef<'a, Window> {
} }
impl<'a> PrivateWindowHelpers for JSRef<'a, Window> { impl<'a> PrivateWindowHelpers for JSRef<'a, Window> {
fn set_timeout_or_interval(&mut self, callback: JSVal, timeout: i32, is_interval: bool) -> i32 { fn set_timeout_or_interval(&self, callback: JSVal, timeout: i32, is_interval: bool) -> i32 {
let timeout = cmp::max(0, timeout) as u64; let timeout = cmp::max(0, timeout) as u64;
let handle = self.next_timer_handle; let handle = self.next_timer_handle.deref().get();
self.next_timer_handle += 1; self.next_timer_handle.deref().set(handle + 1);
// Post a delayed message to the per-window timer task; it will dispatch it // Post a delayed message to the per-window timer task; it will dispatch it
// to the relevant script handler that will deal with it. // to the relevant script handler that will deal with it.
@ -379,7 +380,7 @@ impl<'a> PrivateWindowHelpers for JSRef<'a, Window> {
funval: Traceable::new(callback), funval: Traceable::new(callback),
} }
}; };
self.active_timers.insert(timer_id, timer); self.active_timers.deref().borrow_mut().insert(timer_id, timer);
handle handle
} }
} }
@ -400,9 +401,9 @@ impl Window {
location: Cell::new(None), location: Cell::new(None),
navigator: Cell::new(None), navigator: Cell::new(None),
image_cache_task: image_cache_task, image_cache_task: image_cache_task,
active_timers: box HashMap::new(), active_timers: Traceable::new(RefCell::new(HashMap::new())),
next_timer_handle: 0, next_timer_handle: Untraceable::new(Cell::new(0)),
browser_context: None, browser_context: Traceable::new(RefCell::new(None)),
performance: Cell::new(None), performance: Cell::new(None),
navigationStart: time::get_time().sec as u64, navigationStart: time::get_time().sec as u64,
navigationStartPrecise: time::precise_time_s(), navigationStartPrecise: time::precise_time_s(),

18
src/components/script/dom/xmlhttprequest.rs
View file

@ -225,7 +225,7 @@ impl XMLHttpRequest {
pub trait XMLHttpRequestMethods<'a> { pub trait XMLHttpRequestMethods<'a> {
fn GetOnreadystatechange(&self) -> Option<EventHandlerNonNull>; fn GetOnreadystatechange(&self) -> Option<EventHandlerNonNull>;
fn SetOnreadystatechange(&mut self, listener: Option<EventHandlerNonNull>); fn SetOnreadystatechange(&self, listener: Option<EventHandlerNonNull>);
fn ReadyState(&self) -> u16; fn ReadyState(&self) -> u16;
fn Open(&mut self, _method: ByteString, _url: DOMString) -> ErrorResult; fn Open(&mut self, _method: ByteString, _url: DOMString) -> ErrorResult;
fn Open_(&mut self, _method: ByteString, _url: DOMString, _async: bool, fn Open_(&mut self, _method: ByteString, _url: DOMString, _async: bool,
@ -257,8 +257,8 @@ impl<'a> XMLHttpRequestMethods<'a> for JSRef<'a, XMLHttpRequest> {
eventtarget.get_event_handler_common("readystatechange") eventtarget.get_event_handler_common("readystatechange")
} }
fn SetOnreadystatechange(&mut self, listener: Option<EventHandlerNonNull>) { fn SetOnreadystatechange(&self, listener: Option<EventHandlerNonNull>) {
let eventtarget: &mut JSRef<EventTarget> = EventTargetCast::from_mut_ref(self); let eventtarget: &JSRef<EventTarget> = EventTargetCast::from_ref(self);
eventtarget.set_event_handler_common("readystatechange", listener) eventtarget.set_event_handler_common("readystatechange", listener)
} }
@ -431,7 +431,7 @@ impl<'a> XMLHttpRequestMethods<'a> for JSRef<'a, XMLHttpRequest> {
// Step 8 // Step 8
let upload_target = &*self.upload.get().root().unwrap(); let upload_target = &*self.upload.get().root().unwrap();
let event_target: &JSRef<EventTarget> = EventTargetCast::from_ref(upload_target); let event_target: &JSRef<EventTarget> = EventTargetCast::from_ref(upload_target);
if event_target.handlers.iter().len() > 0 { if event_target.has_handlers() {
self.upload_events = true; self.upload_events = true;
} }
@ -638,10 +638,10 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
assert!(self.ready_state != rs) assert!(self.ready_state != rs)
self.ready_state = rs; self.ready_state = rs;
let win = &*self.global.root(); let win = &*self.global.root();
let mut event = let event =
Event::new(win, "readystatechange".to_string(), false, true).root(); Event::new(win, "readystatechange".to_string(), false, true).root();
let target: &JSRef<EventTarget> = EventTargetCast::from_ref(self); let target: &JSRef<EventTarget> = EventTargetCast::from_ref(self);
target.dispatch_event_with_target(None, &mut *event).ok(); target.dispatch_event_with_target(None, &*event).ok();
} }
fn process_partial_response(&mut self, progress: XHRProgress) { fn process_partial_response(&mut self, progress: XHRProgress) {
@ -739,7 +739,7 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
fn dispatch_progress_event(&self, upload: bool, type_: DOMString, loaded: u64, total: Option<u64>) { fn dispatch_progress_event(&self, upload: bool, type_: DOMString, loaded: u64, total: Option<u64>) {
let win = &*self.global.root(); let win = &*self.global.root();
let upload_target = &*self.upload.get().root().unwrap(); let upload_target = &*self.upload.get().root().unwrap();
let mut progressevent = ProgressEvent::new(win, type_, false, false, let progressevent = ProgressEvent::new(win, type_, false, false,
total.is_some(), loaded, total.is_some(), loaded,
total.unwrap_or(0)).root(); total.unwrap_or(0)).root();
let target: &JSRef<EventTarget> = if upload { let target: &JSRef<EventTarget> = if upload {
@ -747,8 +747,8 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
} else { } else {
EventTargetCast::from_ref(self) EventTargetCast::from_ref(self)
}; };
let event: &mut JSRef<Event> = EventCast::from_mut_ref(&mut *progressevent); let event: &JSRef<Event> = EventCast::from_ref(&*progressevent);
target.dispatch_event_with_target(None, &mut *event).ok(); target.dispatch_event_with_target(None, event).ok();
} }
fn dispatch_upload_progress_event(&self, type_: DOMString, partial_load: Option<u64>) { fn dispatch_upload_progress_event(&self, type_: DOMString, partial_load: Option<u64>) {

42
src/components/script/dom/xmlhttprequesteventtarget.rs
View file

@ -44,19 +44,19 @@ impl Reflectable for XMLHttpRequestEventTarget {
pub trait XMLHttpRequestEventTargetMethods { pub trait XMLHttpRequestEventTargetMethods {
fn GetOnloadstart(&self) -> Option<EventHandlerNonNull>; fn GetOnloadstart(&self) -> Option<EventHandlerNonNull>;
fn SetOnloadstart(&mut self, listener: Option<EventHandlerNonNull>); fn SetOnloadstart(&self, listener: Option<EventHandlerNonNull>);
fn GetOnprogress(&self) -> Option<EventHandlerNonNull>; fn GetOnprogress(&self) -> Option<EventHandlerNonNull>;
fn SetOnprogress(&mut self, listener: Option<EventHandlerNonNull>); fn SetOnprogress(&self, listener: Option<EventHandlerNonNull>);
fn GetOnabort(&self) -> Option<EventHandlerNonNull>; fn GetOnabort(&self) -> Option<EventHandlerNonNull>;
fn SetOnabort(&mut self, listener: Option<EventHandlerNonNull>); fn SetOnabort(&self, listener: Option<EventHandlerNonNull>);
fn GetOnerror(&self) -> Option<EventHandlerNonNull>; fn GetOnerror(&self) -> Option<EventHandlerNonNull>;
fn SetOnerror(&mut self, listener: Option<EventHandlerNonNull>); fn SetOnerror(&self, listener: Option<EventHandlerNonNull>);
fn GetOnload(&self) -> Option<EventHandlerNonNull>; fn GetOnload(&self) -> Option<EventHandlerNonNull>;
fn SetOnload(&mut self, listener: Option<EventHandlerNonNull>); fn SetOnload(&self, listener: Option<EventHandlerNonNull>);
fn GetOntimeout(&self) -> Option<EventHandlerNonNull>; fn GetOntimeout(&self) -> Option<EventHandlerNonNull>;
fn SetOntimeout(&mut self, listener: Option<EventHandlerNonNull>); fn SetOntimeout(&self, listener: Option<EventHandlerNonNull>);
fn GetOnloadend(&self) -> Option<EventHandlerNonNull>; fn GetOnloadend(&self) -> Option<EventHandlerNonNull>;
fn SetOnloadend(&mut self, listener: Option<EventHandlerNonNull>); fn SetOnloadend(&self, listener: Option<EventHandlerNonNull>);
} }
impl<'a> XMLHttpRequestEventTargetMethods for JSRef<'a, XMLHttpRequestEventTarget> { impl<'a> XMLHttpRequestEventTargetMethods for JSRef<'a, XMLHttpRequestEventTarget> {
@ -65,8 +65,8 @@ impl<'a> XMLHttpRequestEventTargetMethods for JSRef<'a, XMLHttpRequestEventTarge
eventtarget.get_event_handler_common("loadstart") eventtarget.get_event_handler_common("loadstart")
} }
fn SetOnloadstart(&mut self, listener: Option<EventHandlerNonNull>) { fn SetOnloadstart(&self, listener: Option<EventHandlerNonNull>) {
let eventtarget: &mut JSRef<EventTarget> = EventTargetCast::from_mut_ref(self); let eventtarget: &JSRef<EventTarget> = EventTargetCast::from_ref(self);
eventtarget.set_event_handler_common("loadstart", listener) eventtarget.set_event_handler_common("loadstart", listener)
} }
@ -75,8 +75,8 @@ impl<'a> XMLHttpRequestEventTargetMethods for JSRef<'a, XMLHttpRequestEventTarge
eventtarget.get_event_handler_common("progress") eventtarget.get_event_handler_common("progress")
} }
fn SetOnprogress(&mut self, listener: Option<EventHandlerNonNull>) { fn SetOnprogress(&self, listener: Option<EventHandlerNonNull>) {
let eventtarget: &mut JSRef<EventTarget> = EventTargetCast::from_mut_ref(self); let eventtarget: &JSRef<EventTarget> = EventTargetCast::from_ref(self);
eventtarget.set_event_handler_common("progress", listener) eventtarget.set_event_handler_common("progress", listener)
} }
@ -85,8 +85,8 @@ impl<'a> XMLHttpRequestEventTargetMethods for JSRef<'a, XMLHttpRequestEventTarge
eventtarget.get_event_handler_common("abort") eventtarget.get_event_handler_common("abort")
} }
fn SetOnabort(&mut self, listener: Option<EventHandlerNonNull>) { fn SetOnabort(&self, listener: Option<EventHandlerNonNull>) {
let eventtarget: &mut JSRef<EventTarget> = EventTargetCast::from_mut_ref(self); let eventtarget: &JSRef<EventTarget> = EventTargetCast::from_ref(self);
eventtarget.set_event_handler_common("abort", listener) eventtarget.set_event_handler_common("abort", listener)
} }
@ -95,8 +95,8 @@ impl<'a> XMLHttpRequestEventTargetMethods for JSRef<'a, XMLHttpRequestEventTarge
eventtarget.get_event_handler_common("error") eventtarget.get_event_handler_common("error")
} }
fn SetOnerror(&mut self, listener: Option<EventHandlerNonNull>) { fn SetOnerror(&self, listener: Option<EventHandlerNonNull>) {
let eventtarget: &mut JSRef<EventTarget> = EventTargetCast::from_mut_ref(self); let eventtarget: &JSRef<EventTarget> = EventTargetCast::from_ref(self);
eventtarget.set_event_handler_common("error", listener) eventtarget.set_event_handler_common("error", listener)
} }
@ -105,8 +105,8 @@ impl<'a> XMLHttpRequestEventTargetMethods for JSRef<'a, XMLHttpRequestEventTarge
eventtarget.get_event_handler_common("load") eventtarget.get_event_handler_common("load")
} }
fn SetOnload(&mut self, listener: Option<EventHandlerNonNull>) { fn SetOnload(&self, listener: Option<EventHandlerNonNull>) {
let eventtarget: &mut JSRef<EventTarget> = EventTargetCast::from_mut_ref(self); let eventtarget: &JSRef<EventTarget> = EventTargetCast::from_ref(self);
eventtarget.set_event_handler_common("load", listener) eventtarget.set_event_handler_common("load", listener)
} }
@ -115,8 +115,8 @@ impl<'a> XMLHttpRequestEventTargetMethods for JSRef<'a, XMLHttpRequestEventTarge
eventtarget.get_event_handler_common("timeout") eventtarget.get_event_handler_common("timeout")
} }
fn SetOntimeout(&mut self, listener: Option<EventHandlerNonNull>) { fn SetOntimeout(&self, listener: Option<EventHandlerNonNull>) {
let eventtarget: &mut JSRef<EventTarget> = EventTargetCast::from_mut_ref(self); let eventtarget: &JSRef<EventTarget> = EventTargetCast::from_ref(self);
eventtarget.set_event_handler_common("timeout", listener) eventtarget.set_event_handler_common("timeout", listener)
} }
@ -125,8 +125,8 @@ impl<'a> XMLHttpRequestEventTargetMethods for JSRef<'a, XMLHttpRequestEventTarge
eventtarget.get_event_handler_common("loadend") eventtarget.get_event_handler_common("loadend")
} }
fn SetOnloadend(&mut self, listener: Option<EventHandlerNonNull>) { fn SetOnloadend(&self, listener: Option<EventHandlerNonNull>) {
let eventtarget: &mut JSRef<EventTarget> = EventTargetCast::from_mut_ref(self); let eventtarget: &JSRef<EventTarget> = EventTargetCast::from_ref(self);
eventtarget.set_event_handler_common("loadend", listener) eventtarget.set_event_handler_common("loadend", listener)
} }
} }

24
src/components/script/html/hubbub_html_parser.rs
View file

@ -17,10 +17,10 @@ use html::cssparse::{StylesheetProvenance, UrlProvenance, spawn_css_parser};
use script_task::Page; use script_task::Page;
use hubbub::hubbub; use hubbub::hubbub;
use hubbub::hubbub::{NullNs, XLinkNs, XmlNs, XmlNsNs}; use hubbub::hubbub::{NullNs, HtmlNs, MathMlNs, SvgNs, XLinkNs, XmlNs, XmlNsNs};
use servo_net::resource_task::{Load, LoadData, Payload, Done, ResourceTask, load_whole_resource}; use servo_net::resource_task::{Load, LoadData, Payload, Done, ResourceTask, load_whole_resource};
use servo_util::namespace; use servo_util::namespace;
use servo_util::namespace::Null; use servo_util::namespace::{Namespace, Null};
use servo_util::str::{DOMString, HTML_SPACE_CHARACTERS}; use servo_util::str::{DOMString, HTML_SPACE_CHARACTERS};
use servo_util::task::spawn_named; use servo_util::task::spawn_named;
use servo_util::url::parse_url; use servo_util::url::parse_url;
@ -158,7 +158,11 @@ fn js_script_listener(to_parent: Sender<HtmlDiscoveryMessage>,
// Silly macros to handle constructing DOM nodes. This produces bad code and should be optimized // Silly macros to handle constructing DOM nodes. This produces bad code and should be optimized
// via atomization (issue #85). // via atomization (issue #85).
pub fn build_element_from_tag(tag: DOMString, document: &JSRef<Document>) -> Temporary<Element> { pub fn build_element_from_tag(tag: DOMString, ns: Namespace, document: &JSRef<Document>) -> Temporary<Element> {
if ns != namespace::HTML {
return Element::new(tag, ns, None, document);
}
// TODO (Issue #85): use atoms // TODO (Issue #85): use atoms
handle_element!(document, tag, "a", HTMLAnchorElement); handle_element!(document, tag, "a", HTMLAnchorElement);
handle_element!(document, tag, "abbr", HTMLElement); handle_element!(document, tag, "abbr", HTMLElement);
@ -369,7 +373,13 @@ pub fn parse_html(page: &Page,
// NOTE: tmp vars are workaround for lifetime issues. Both required. // NOTE: tmp vars are workaround for lifetime issues. Both required.
let tmp_borrow = doc_cell.borrow(); let tmp_borrow = doc_cell.borrow();
let tmp = &*tmp_borrow; let tmp = &*tmp_borrow;
let mut element: Root<Element> = build_element_from_tag(tag.name.clone(), *tmp).root(); let namespace = match tag.ns {
HtmlNs => namespace::HTML,
MathMlNs => namespace::MathML,
SvgNs => namespace::SVG,
ns => fail!("Not expecting namespace {:?}", ns),
};
let mut element: Root<Element> = build_element_from_tag(tag.name.clone(), namespace, *tmp).root();
debug!("-- attach attrs"); debug!("-- attach attrs");
for attr in tag.attributes.iter() { for attr in tag.attributes.iter() {
@ -496,17 +506,17 @@ pub fn parse_html(page: &Page,
js_chan2.send(JSTaskNewFile(new_url)); js_chan2.send(JSTaskNewFile(new_url));
} }
None => { None => {
let mut data = vec!(); let mut data = String::new();
let scriptnode: &JSRef<Node> = NodeCast::from_ref(script); let scriptnode: &JSRef<Node> = NodeCast::from_ref(script);
debug!("iterating over children {:?}", scriptnode.first_child()); debug!("iterating over children {:?}", scriptnode.first_child());
for child in scriptnode.children() { for child in scriptnode.children() {
debug!("child = {:?}", child); debug!("child = {:?}", child);
let text: &JSRef<Text> = TextCast::to_ref(&child).unwrap(); let text: &JSRef<Text> = TextCast::to_ref(&child).unwrap();
data.push(text.deref().characterdata.data.to_str()); // FIXME: Bad copy. data.push_str(text.deref().characterdata.data.deref().borrow().as_slice());
} }
debug!("script data = {:?}", data); debug!("script data = {:?}", data);
js_chan2.send(JSTaskNewInlineScript(data.concat(), url3.clone())); js_chan2.send(JSTaskNewInlineScript(data, url3.clone()));
} }
} }
} }

49
src/components/script/script_task.rs
View file

@ -817,31 +817,27 @@ impl ScriptTask {
let page = page.find(id).expect("ScriptTask: received fire timer msg for a let page = page.find(id).expect("ScriptTask: received fire timer msg for a
pipeline ID not associated with this script task. This is a bug."); pipeline ID not associated with this script task. This is a bug.");
let frame = page.frame(); let frame = page.frame();
let mut window = frame.get_ref().window.root(); let window = frame.get_ref().window.root();
let this_value = window.deref().reflector().get_jsobject(); let this_value = window.deref().reflector().get_jsobject();
let is_interval; let data = match window.deref().active_timers.deref().borrow().find(&timer_id) {
match window.deref().active_timers.find(&timer_id) {
None => return, None => return,
Some(timer_handle) => { Some(timer_handle) => timer_handle.data,
};
// TODO: Support extra arguments. This requires passing a `*JSVal` array as `argv`. // TODO: Support extra arguments. This requires passing a `*JSVal` array as `argv`.
let cx = self.get_cx(); let cx = self.get_cx();
with_compartment(cx, this_value, || { with_compartment(cx, this_value, || {
let mut rval = NullValue(); let mut rval = NullValue();
unsafe { unsafe {
JS_CallFunctionValue(cx, this_value, JS_CallFunctionValue(cx, this_value, *data.funval,
*timer_handle.data.funval,
0, ptr::mut_null(), &mut rval); 0, ptr::mut_null(), &mut rval);
} }
}); });
is_interval = timer_handle.data.is_interval; if !data.is_interval {
} window.deref().active_timers.deref().borrow_mut().remove(&timer_id);
}
if !is_interval {
window.deref_mut().active_timers.remove(&timer_id);
} }
} }
@ -952,7 +948,7 @@ impl ScriptTask {
self.compositor.dup(), self.compositor.dup(),
self.image_cache_task.clone()).root(); self.image_cache_task.clone()).root();
let mut document = Document::new(&*window, Some(url.clone()), HTMLDocument, None).root(); let mut document = Document::new(&*window, Some(url.clone()), HTMLDocument, None).root();
window.deref_mut().init_browser_context(&*document); window.deref().init_browser_context(&*document);
with_compartment((**cx).ptr, window.reflector().get_jsobject(), || { with_compartment((**cx).ptr, window.reflector().get_jsobject(), || {
let mut js_info = page.mut_js_info(); let mut js_info = page.mut_js_info();
@ -1033,12 +1029,11 @@ impl ScriptTask {
// We have no concept of a document loader right now, so just dispatch the // We have no concept of a document loader right now, so just dispatch the
// "load" event as soon as we've finished executing all scripts parsed during // "load" event as soon as we've finished executing all scripts parsed during
// the initial load. // the initial load.
let mut event = let event = Event::new(&*window, "load".to_string(), false, false).root();
Event::new(&*window, "load".to_string(), false, false).root();
let doctarget: &JSRef<EventTarget> = EventTargetCast::from_ref(&*document); let doctarget: &JSRef<EventTarget> = EventTargetCast::from_ref(&*document);
let wintarget: &JSRef<EventTarget> = EventTargetCast::from_ref(&*window); let wintarget: &JSRef<EventTarget> = EventTargetCast::from_ref(&*window);
let _ = wintarget.dispatch_event_with_target(Some((*doctarget).clone()), let _ = wintarget.dispatch_event_with_target(Some((*doctarget).clone()),
&mut *event); &*event);
page.fragment_node.assign(fragment.map_or(None, |fragid| page.find_fragment_node(fragid))); page.fragment_node.assign(fragment.map_or(None, |fragid| page.find_fragment_node(fragid)));
@ -1089,12 +1084,14 @@ impl ScriptTask {
Some(mut window) => { Some(mut window) => {
// http://dev.w3.org/csswg/cssom-view/#resizing-viewports // http://dev.w3.org/csswg/cssom-view/#resizing-viewports
// https://dvcs.w3.org/hg/dom3events/raw-file/tip/html/DOM3-Events.html#event-type-resize // https://dvcs.w3.org/hg/dom3events/raw-file/tip/html/DOM3-Events.html#event-type-resize
let mut uievent = UIEvent::new(&window.clone(), "resize".to_string(), false, false, let uievent = UIEvent::new(&window.clone(),
Some((*window).clone()), 0i32).root(); "resize".to_string(), false,
let event: &mut JSRef<Event> = EventCast::from_mut_ref(&mut *uievent); false, Some(window.clone()),
0i32).root();
let event: &JSRef<Event> = EventCast::from_ref(&*uievent);
let wintarget: &mut JSRef<EventTarget> = EventTargetCast::from_mut_ref(&mut *window); let wintarget: &JSRef<EventTarget> = EventTargetCast::from_ref(&*window);
let _ = wintarget.dispatch_event_with_target(None, &mut *event); let _ = wintarget.dispatch_event_with_target(None, event);
} }
None => () None => ()
} }
@ -1129,12 +1126,12 @@ impl ScriptTask {
match *page.frame() { match *page.frame() {
Some(ref frame) => { Some(ref frame) => {
let window = frame.window.root(); let window = frame.window.root();
let mut event = let event =
Event::new(&*window, Event::new(&*window,
"click".to_string(), "click".to_string(),
true, true).root(); true, true).root();
let eventtarget: &JSRef<EventTarget> = EventTargetCast::from_ref(&node); let eventtarget: &JSRef<EventTarget> = EventTargetCast::from_ref(&node);
let _ = eventtarget.dispatch_event_with_target(None, &mut *event); let _ = eventtarget.dispatch_event_with_target(None, &*event);
} }
None => {} None => {}
} }
@ -1160,8 +1157,8 @@ impl ScriptTask {
match *mouse_over_targets { match *mouse_over_targets {
Some(ref mut mouse_over_targets) => { Some(ref mut mouse_over_targets) => {
for node in mouse_over_targets.mut_iter() { for node in mouse_over_targets.mut_iter() {
let mut node = node.root(); let node = node.root();
node.set_hover_state(false); node.deref().set_hover_state(false);
} }
} }
None => {} None => {}
@ -1175,7 +1172,7 @@ impl ScriptTask {
let maybe_node = temp_node.root().ancestors().find(|node| node.is_element()); let maybe_node = temp_node.root().ancestors().find(|node| node.is_element());
match maybe_node { match maybe_node {
Some(mut node) => { Some(node) => {
node.set_hover_state(true); node.set_hover_state(true);
match *mouse_over_targets { match *mouse_over_targets {