Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-07-22 23:03:42 +01:00
Code Issues Projects Releases Packages Wiki Activity

script: Remove glob imports added in #4405

Browse source
This commit is contained in:
Tetsuharu OHZEKI 2014-12-19 02:37:20 +09:00
parent 824788649c
commit a7bb436177
43 changed files with 243 additions and 272 deletions
Download patch file Download diff file Expand all files Collapse all files

40
components/layout/layout_task.rs
View file

@ -34,13 +34,11 @@ use log;
use script::dom::bindings::js::JS; use script::dom::bindings::js::JS;
use script::dom::node::{LayoutDataRef, Node, NodeTypeId}; use script::dom::node::{LayoutDataRef, Node, NodeTypeId};
use script::dom::element::ElementTypeId; use script::dom::element::ElementTypeId;
use script::layout_interface::{AddStylesheetMsg, ContentBoxResponse, ContentBoxesResponse}; use script::layout_interface::{ContentBoxResponse, ContentBoxesResponse};
use script::layout_interface::{ContentBoxesQuery, ContentBoxQuery, ExitNowMsg, GetRPCMsg}; use script::layout_interface::{ContentBoxesQuery, ContentBoxQuery};
use script::layout_interface::{HitTestResponse, LayoutChan, LayoutRPC, LoadStylesheetMsg}; use script::layout_interface::{HitTestResponse, LayoutChan, LayoutRPC};
use script::layout_interface::{MouseOverResponse, Msg, NoQuery, PrepareToExitMsg}; use script::layout_interface::{MouseOverResponse, Msg, NoQuery};
use script::layout_interface::{ReapLayoutDataMsg, Reflow, ReflowForDisplay, ReflowMsg}; use script::layout_interface::{Reflow, ReflowGoal, ScriptLayoutChan, TrustedNodeAddress};
use script::layout_interface::{ReflowForScriptQuery, ScriptLayoutChan, SetQuirksModeMsg};
use script::layout_interface::{TrustedNodeAddress};
use script_traits::{SendEventMsg, ReflowEvent, ReflowCompleteMsg, OpaqueScriptLayoutChannel}; use script_traits::{SendEventMsg, ReflowEvent, ReflowCompleteMsg, OpaqueScriptLayoutChannel};
use script_traits::{ScriptControlChan, UntrustedNodeAddress}; use script_traits::{ScriptControlChan, UntrustedNodeAddress};
use servo_msg::compositor_msg::Scrollable; use servo_msg::compositor_msg::Scrollable;
@ -346,7 +344,7 @@ impl LayoutTask {
PortToRead::Pipeline => { PortToRead::Pipeline => {
match self.pipeline_port.recv() { match self.pipeline_port.recv() {
layout_traits::ExitNowMsg => { layout_traits::ExitNowMsg => {
self.handle_script_request(ExitNowMsg, possibly_locked_rw_data) self.handle_script_request(Msg::ExitNow, possibly_locked_rw_data)
} }
} }
}, },
@ -390,30 +388,30 @@ impl LayoutTask {
LayoutTaskData>>) LayoutTaskData>>)
-> bool { -> bool {
match request { match request {
AddStylesheetMsg(sheet) => self.handle_add_stylesheet(sheet, possibly_locked_rw_data), Msg::AddStylesheet(sheet) => self.handle_add_stylesheet(sheet, possibly_locked_rw_data),
LoadStylesheetMsg(url) => self.handle_load_stylesheet(url, possibly_locked_rw_data), Msg::LoadStylesheet(url) => self.handle_load_stylesheet(url, possibly_locked_rw_data),
SetQuirksModeMsg => self.handle_set_quirks_mode(possibly_locked_rw_data), Msg::SetQuirksMode => self.handle_set_quirks_mode(possibly_locked_rw_data),
GetRPCMsg(response_chan) => { Msg::GetRPC(response_chan) => {
response_chan.send(box LayoutRPCImpl(self.rw_data.clone()) as response_chan.send(box LayoutRPCImpl(self.rw_data.clone()) as
Box<LayoutRPC + Send>); Box<LayoutRPC + Send>);
}, },
ReflowMsg(data) => { Msg::Reflow(data) => {
profile(time::LayoutPerformCategory, profile(time::LayoutPerformCategory,
self.profiler_metadata(&*data), self.profiler_metadata(&*data),
self.time_profiler_chan.clone(), self.time_profiler_chan.clone(),
|| self.handle_reflow(&*data, possibly_locked_rw_data)); || self.handle_reflow(&*data, possibly_locked_rw_data));
}, },
ReapLayoutDataMsg(dead_layout_data) => { Msg::ReapLayoutData(dead_layout_data) => {
unsafe { unsafe {
LayoutTask::handle_reap_layout_data(dead_layout_data) LayoutTask::handle_reap_layout_data(dead_layout_data)
} }
}, },
PrepareToExitMsg(response_chan) => { Msg::PrepareToExit(response_chan) => {
debug!("layout: PrepareToExitMsg received"); debug!("layout: PrepareToExitMsg received");
self.prepare_to_exit(response_chan, possibly_locked_rw_data); self.prepare_to_exit(response_chan, possibly_locked_rw_data);
return false return false
}, },
ExitNowMsg => { Msg::ExitNow => {
debug!("layout: ExitNowMsg received"); debug!("layout: ExitNowMsg received");
self.exit_now(possibly_locked_rw_data); self.exit_now(possibly_locked_rw_data);
return false return false
@ -423,7 +421,7 @@ impl LayoutTask {
true true
} }
/// Enters a quiescent state in which no new messages except for `ReapLayoutDataMsg` will be /// Enters a quiescent state in which no new messages except for `layout_interface::Msg::ReapLayoutData` will be
/// processed until an `ExitNowMsg` is received. A pong is immediately sent on the given /// processed until an `ExitNowMsg` is received. A pong is immediately sent on the given
/// response channel. /// response channel.
fn prepare_to_exit<'a>(&'a self, fn prepare_to_exit<'a>(&'a self,
@ -432,12 +430,12 @@ impl LayoutTask {
response_chan.send(()); response_chan.send(());
loop { loop {
match self.port.recv() { match self.port.recv() {
ReapLayoutDataMsg(dead_layout_data) => { Msg::ReapLayoutData(dead_layout_data) => {
unsafe { unsafe {
LayoutTask::handle_reap_layout_data(dead_layout_data) LayoutTask::handle_reap_layout_data(dead_layout_data)
} }
} }
ExitNowMsg => { Msg::ExitNow => {
debug!("layout task is exiting..."); debug!("layout task is exiting...");
self.exit_now(possibly_locked_rw_data); self.exit_now(possibly_locked_rw_data);
break break
@ -830,14 +828,14 @@ impl LayoutTask {
// Build the display list if necessary, and send it to the painter. // Build the display list if necessary, and send it to the painter.
match data.goal { match data.goal {
ReflowForDisplay => { ReflowGoal::ForDisplay => {
self.build_display_list_for_reflow(data, self.build_display_list_for_reflow(data,
node, node,
&mut layout_root, &mut layout_root,
&mut shared_layout_context, &mut shared_layout_context,
&mut rw_data); &mut rw_data);
} }
ReflowForScriptQuery => {} ReflowGoal::ForScriptQuery => {}
} }
match data.query_type { match data.query_type {

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

@ -6,7 +6,7 @@ use dom::bindings::cell::DOMRefCell;
use dom::bindings::codegen::Bindings::AttrBinding; use dom::bindings::codegen::Bindings::AttrBinding;
use dom::bindings::codegen::Bindings::AttrBinding::AttrMethods; use dom::bindings::codegen::Bindings::AttrBinding::AttrMethods;
use dom::bindings::codegen::InheritTypes::NodeCast; use dom::bindings::codegen::InheritTypes::NodeCast;
use dom::bindings::global; use dom::bindings::global::GlobalRef;
use dom::bindings::js::{JS, JSRef, Temporary}; use dom::bindings::js::{JS, JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object}; use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::element::{Element, AttributeHandlers}; use dom::element::{Element, AttributeHandlers};
@ -110,7 +110,7 @@ impl Attr {
name: Atom, namespace: Namespace, name: Atom, namespace: Namespace,
prefix: Option<DOMString>, owner: Option<JSRef<Element>>) -> Temporary<Attr> { prefix: Option<DOMString>, owner: Option<JSRef<Element>>) -> Temporary<Attr> {
reflect_dom_object(box Attr::new_inherited(local_name, value, name, namespace, prefix, owner), reflect_dom_object(box Attr::new_inherited(local_name, value, name, namespace, prefix, owner),
global::Window(window), AttrBinding::Wrap) GlobalRef::Window(window), AttrBinding::Wrap)
} }
#[inline] #[inline]

52
components/script/dom/bindings/global.rs
View file

@ -7,10 +7,6 @@
//! This module contains smart pointers to global scopes, to simplify writing //! This module contains smart pointers to global scopes, to simplify writing
//! code that works in workers as well as window scopes. //! code that works in workers as well as window scopes.
pub use self::GlobalRef::*;
pub use self::GlobalRoot::*;
pub use self::GlobalField::*;
use dom::bindings::conversions::FromJSValConvertible; use dom::bindings::conversions::FromJSValConvertible;
use dom::bindings::js::{JS, JSRef, Root}; use dom::bindings::js::{JS, JSRef, Root};
use dom::bindings::utils::{Reflectable, Reflector}; use dom::bindings::utils::{Reflectable, Reflector};
@ -37,8 +33,8 @@ pub enum GlobalRef<'a> {
/// A stack-based rooted reference to a global object. /// A stack-based rooted reference to a global object.
pub enum GlobalRoot<'a, 'b> { pub enum GlobalRoot<'a, 'b> {
WindowRoot(Root<'a, 'b, window::Window>), Window(Root<'a, 'b, window::Window>),
WorkerRoot(Root<'a, 'b, WorkerGlobalScope>), Worker(Root<'a, 'b, WorkerGlobalScope>),
} }
/// A traced reference to a global object, for use in fields of traced Rust /// A traced reference to a global object, for use in fields of traced Rust
@ -46,8 +42,8 @@ pub enum GlobalRoot<'a, 'b> {
#[jstraceable] #[jstraceable]
#[must_root] #[must_root]
pub enum GlobalField { pub enum GlobalField {
WindowField(JS<window::Window>), Window(JS<window::Window>),
WorkerField(JS<WorkerGlobalScope>), Worker(JS<WorkerGlobalScope>),
} }
impl<'a> GlobalRef<'a> { impl<'a> GlobalRef<'a> {
@ -55,8 +51,8 @@ impl<'a> GlobalRef<'a> {
/// this global object is on. /// this global object is on.
pub fn get_cx(&self) -> *mut JSContext { pub fn get_cx(&self) -> *mut JSContext {
match *self { match *self {
Window(ref window) => window.get_cx(), GlobalRef::Window(ref window) => window.get_cx(),
Worker(ref worker) => worker.get_cx(), GlobalRef::Worker(ref worker) => worker.get_cx(),
} }
} }
@ -64,22 +60,22 @@ impl<'a> GlobalRef<'a> {
/// a `Window`. /// a `Window`.
pub fn as_window<'b>(&'b self) -> JSRef<'b, window::Window> { pub fn as_window<'b>(&'b self) -> JSRef<'b, window::Window> {
match *self { match *self {
Window(window) => window, GlobalRef::Window(window) => window,
Worker(_) => panic!("expected a Window scope"), GlobalRef::Worker(_) => panic!("expected a Window scope"),
} }
} }
pub fn resource_task(&self) -> ResourceTask { pub fn resource_task(&self) -> ResourceTask {
match *self { match *self {
Window(ref window) => window.page().resource_task.clone(), GlobalRef::Window(ref window) => window.page().resource_task.clone(),
Worker(ref worker) => worker.resource_task().clone(), GlobalRef::Worker(ref worker) => worker.resource_task().clone(),
} }
} }
pub fn get_url(&self) -> Url { pub fn get_url(&self) -> Url {
match *self { match *self {
Window(ref window) => window.get_url(), GlobalRef::Window(ref window) => window.get_url(),
Worker(ref worker) => worker.get_url().clone(), GlobalRef::Worker(ref worker) => worker.get_url().clone(),
} }
} }
@ -87,8 +83,8 @@ impl<'a> GlobalRef<'a> {
/// thread. /// thread.
pub fn script_chan<'b>(&'b self) -> &'b ScriptChan { pub fn script_chan<'b>(&'b self) -> &'b ScriptChan {
match *self { match *self {
Window(ref window) => window.script_chan(), GlobalRef::Window(ref window) => window.script_chan(),
Worker(ref worker) => worker.script_chan(), GlobalRef::Worker(ref worker) => worker.script_chan(),
} }
} }
} }
@ -96,8 +92,8 @@ impl<'a> GlobalRef<'a> {
impl<'a> Reflectable for GlobalRef<'a> { impl<'a> Reflectable for GlobalRef<'a> {
fn reflector<'b>(&'b self) -> &'b Reflector { fn reflector<'b>(&'b self) -> &'b Reflector {
match *self { match *self {
Window(ref window) => window.reflector(), GlobalRef::Window(ref window) => window.reflector(),
Worker(ref worker) => worker.reflector(), GlobalRef::Worker(ref worker) => worker.reflector(),
} }
} }
} }
@ -107,8 +103,8 @@ impl<'a, 'b> GlobalRoot<'a, 'b> {
/// lifetime of this root. /// lifetime of this root.
pub fn root_ref<'c>(&'c self) -> GlobalRef<'c> { pub fn root_ref<'c>(&'c self) -> GlobalRef<'c> {
match *self { match *self {
WindowRoot(ref window) => Window(window.root_ref()), GlobalRoot::Window(ref window) => GlobalRef::Window(window.root_ref()),
WorkerRoot(ref worker) => Worker(worker.root_ref()), GlobalRoot::Worker(ref worker) => GlobalRef::Worker(worker.root_ref()),
} }
} }
} }
@ -117,16 +113,16 @@ impl GlobalField {
/// Create a new `GlobalField` from a rooted reference. /// Create a new `GlobalField` from a rooted reference.
pub fn from_rooted(global: &GlobalRef) -> GlobalField { pub fn from_rooted(global: &GlobalRef) -> GlobalField {
match *global { match *global {
Window(window) => WindowField(JS::from_rooted(window)), GlobalRef::Window(window) => GlobalField::Window(JS::from_rooted(window)),
Worker(worker) => WorkerField(JS::from_rooted(worker)), GlobalRef::Worker(worker) => GlobalField::Worker(JS::from_rooted(worker)),
} }
} }
/// Create a stack-bounded root for this reference. /// Create a stack-bounded root for this reference.
pub fn root(&self) -> GlobalRoot { pub fn root(&self) -> GlobalRoot {
match *self { match *self {
WindowField(ref window) => WindowRoot(window.root()), GlobalField::Window(ref window) => GlobalRoot::Window(window.root()),
WorkerField(ref worker) => WorkerRoot(worker.root()), GlobalField::Worker(ref worker) => GlobalRoot::Worker(worker.root()),
} }
} }
} }
@ -139,12 +135,12 @@ pub fn global_object_for_js_object(obj: *mut JSObject) -> GlobalField {
let clasp = JS_GetClass(global); let clasp = JS_GetClass(global);
assert!(((*clasp).flags & (JSCLASS_IS_DOMJSCLASS | JSCLASS_IS_GLOBAL)) != 0); assert!(((*clasp).flags & (JSCLASS_IS_DOMJSCLASS | JSCLASS_IS_GLOBAL)) != 0);
match FromJSValConvertible::from_jsval(ptr::null_mut(), ObjectOrNullValue(global), ()) { match FromJSValConvertible::from_jsval(ptr::null_mut(), ObjectOrNullValue(global), ()) {
Ok(window) => return WindowField(window), Ok(window) => return GlobalField::Window(window),
Err(_) => (), Err(_) => (),
} }
match FromJSValConvertible::from_jsval(ptr::null_mut(), ObjectOrNullValue(global), ()) { match FromJSValConvertible::from_jsval(ptr::null_mut(), ObjectOrNullValue(global), ()) {
Ok(worker) => return WorkerField(worker), Ok(worker) => return GlobalField::Worker(worker),
Err(_) => (), Err(_) => (),
} }

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

@ -29,7 +29,7 @@ use dom::htmlformelement::HTMLFormElement;
use dom::htmlframeelement::HTMLFrameElement; use dom::htmlframeelement::HTMLFrameElement;
use dom::htmlframesetelement::HTMLFrameSetElement; use dom::htmlframesetelement::HTMLFrameSetElement;
use dom::htmlheadelement::HTMLHeadElement; use dom::htmlheadelement::HTMLHeadElement;
use dom::htmlheadingelement::HeadingLevel::*; use dom::htmlheadingelement::HeadingLevel;
use dom::htmlheadingelement::HTMLHeadingElement; use dom::htmlheadingelement::HTMLHeadingElement;
use dom::htmlhrelement::HTMLHRElement; use dom::htmlhrelement::HTMLHRElement;
use dom::htmlhtmlelement::HTMLHtmlElement; use dom::htmlhtmlelement::HTMLHtmlElement;
@ -142,12 +142,12 @@ pub fn create_element(name: QualName, prefix: Option<DOMString>,
atom!("form") => make!(HTMLFormElement), atom!("form") => make!(HTMLFormElement),
atom!("frame") => make!(HTMLFrameElement), atom!("frame") => make!(HTMLFrameElement),
atom!("frameset") => make!(HTMLFrameSetElement), atom!("frameset") => make!(HTMLFrameSetElement),
atom!("h1") => make!(HTMLHeadingElement, Heading1), atom!("h1") => make!(HTMLHeadingElement, HeadingLevel::Heading1),
atom!("h2") => make!(HTMLHeadingElement, Heading2), atom!("h2") => make!(HTMLHeadingElement, HeadingLevel::Heading2),
atom!("h3") => make!(HTMLHeadingElement, Heading3), atom!("h3") => make!(HTMLHeadingElement, HeadingLevel::Heading3),
atom!("h4") => make!(HTMLHeadingElement, Heading4), atom!("h4") => make!(HTMLHeadingElement, HeadingLevel::Heading4),
atom!("h5") => make!(HTMLHeadingElement, Heading5), atom!("h5") => make!(HTMLHeadingElement, HeadingLevel::Heading5),
atom!("h6") => make!(HTMLHeadingElement, Heading6), atom!("h6") => make!(HTMLHeadingElement, HeadingLevel::Heading6),
atom!("head") => make!(HTMLHeadElement), atom!("head") => make!(HTMLHeadElement),
atom!("header") => make!(HTMLElement), atom!("header") => make!(HTMLElement),
atom!("hgroup") => make!(HTMLElement), atom!("hgroup") => make!(HTMLElement),

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

@ -5,7 +5,7 @@
use dom::bindings::codegen::Bindings::CSSStyleDeclarationBinding::{mod, CSSStyleDeclarationMethods}; use dom::bindings::codegen::Bindings::CSSStyleDeclarationBinding::{mod, CSSStyleDeclarationMethods};
use dom::bindings::codegen::InheritTypes::{NodeCast, ElementCast}; use dom::bindings::codegen::InheritTypes::{NodeCast, ElementCast};
use dom::bindings::error::ErrorResult; use dom::bindings::error::ErrorResult;
use dom::bindings::global; use dom::bindings::global::GlobalRef;
use dom::bindings::js::{JS, JSRef, OptionalRootedRootable, Temporary}; use dom::bindings::js::{JS, JSRef, OptionalRootedRootable, Temporary};
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object}; use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::document::DocumentHelpers; use dom::document::DocumentHelpers;
@ -62,7 +62,7 @@ impl CSSStyleDeclaration {
pub fn new(global: JSRef<Window>, owner: JSRef<HTMLElement>) -> Temporary<CSSStyleDeclaration> { pub fn new(global: JSRef<Window>, owner: JSRef<HTMLElement>) -> Temporary<CSSStyleDeclaration> {
reflect_dom_object(box CSSStyleDeclaration::new_inherited(owner), reflect_dom_object(box CSSStyleDeclaration::new_inherited(owner),
global::Window(global), GlobalRef::Window(global),
CSSStyleDeclarationBinding::Wrap) CSSStyleDeclarationBinding::Wrap)
} }
} }

22
components/script/dom/dedicatedworkerglobalscope.rs
View file

@ -9,7 +9,7 @@ use dom::bindings::codegen::InheritTypes::DedicatedWorkerGlobalScopeDerived;
use dom::bindings::codegen::InheritTypes::{EventTargetCast, WorkerGlobalScopeCast}; use dom::bindings::codegen::InheritTypes::{EventTargetCast, WorkerGlobalScopeCast};
use dom::bindings::error::ErrorResult; use dom::bindings::error::ErrorResult;
use dom::bindings::error::Error::DataClone; use dom::bindings::error::Error::DataClone;
use dom::bindings::global; use dom::bindings::global::GlobalRef;
use dom::bindings::js::{JSRef, Temporary, RootCollection}; use dom::bindings::js::{JSRef, Temporary, RootCollection};
use dom::bindings::utils::{Reflectable, Reflector}; use dom::bindings::utils::{Reflectable, Reflector};
use dom::eventtarget::{EventTarget, EventTargetHelpers, EventTargetTypeId}; use dom::eventtarget::{EventTarget, EventTargetHelpers, EventTargetTypeId};
@ -19,8 +19,6 @@ use dom::workerglobalscope::{WorkerGlobalScope, WorkerGlobalScopeHelpers};
use dom::workerglobalscope::WorkerGlobalScopeTypeId; use dom::workerglobalscope::WorkerGlobalScopeTypeId;
use dom::xmlhttprequest::XMLHttpRequest; use dom::xmlhttprequest::XMLHttpRequest;
use script_task::{ScriptTask, ScriptChan, ScriptMsg, TimerSource}; use script_task::{ScriptTask, ScriptChan, ScriptMsg, TimerSource};
use script_task::ScriptMsg::{DOMMessage, FireTimerMsg, XHRProgressMsg};
use script_task::ScriptMsg::{XHRReleaseMsg, WorkerRelease, WorkerPostMessage};
use script_task::StackRootTLS; use script_task::StackRootTLS;
use servo_net::resource_task::{ResourceTask, load_whole_resource}; use servo_net::resource_task::{ResourceTask, load_whole_resource};
@ -121,7 +119,7 @@ impl DedicatedWorkerGlobalScope {
EventTargetCast::from_ref(*global); EventTargetCast::from_ref(*global);
loop { loop {
match global.receiver.recv_opt() { match global.receiver.recv_opt() {
Ok(DOMMessage(data, nbytes)) => { Ok(ScriptMsg::DOMMessage(data, nbytes)) => {
let mut message = UndefinedValue(); let mut message = UndefinedValue();
unsafe { unsafe {
assert!(JS_ReadStructuredClone( assert!(JS_ReadStructuredClone(
@ -130,22 +128,22 @@ impl DedicatedWorkerGlobalScope {
ptr::null(), ptr::null_mut()) != 0); ptr::null(), ptr::null_mut()) != 0);
} }
MessageEvent::dispatch_jsval(target, global::Worker(scope), message); MessageEvent::dispatch_jsval(target, GlobalRef::Worker(scope), message);
global.delayed_release_worker(); global.delayed_release_worker();
}, },
Ok(XHRProgressMsg(addr, progress)) => { Ok(ScriptMsg::XHRProgress(addr, progress)) => {
XMLHttpRequest::handle_progress(addr, progress) XMLHttpRequest::handle_progress(addr, progress)
}, },
Ok(XHRReleaseMsg(addr)) => { Ok(ScriptMsg::XHRRelease(addr)) => {
XMLHttpRequest::handle_release(addr) XMLHttpRequest::handle_release(addr)
}, },
Ok(WorkerPostMessage(addr, data, nbytes)) => { Ok(ScriptMsg::WorkerPostMessage(addr, data, nbytes)) => {
Worker::handle_message(addr, data, nbytes); Worker::handle_message(addr, data, nbytes);
}, },
Ok(WorkerRelease(addr)) => { Ok(ScriptMsg::WorkerRelease(addr)) => {
Worker::handle_release(addr) Worker::handle_release(addr)
}, },
Ok(FireTimerMsg(TimerSource::FromWorker, timer_id)) => { Ok(ScriptMsg::FireTimer(TimerSource::FromWorker, timer_id)) => {
scope.handle_fire_timer(timer_id); scope.handle_fire_timer(timer_id);
} }
Ok(_) => panic!("Unexpected message"), Ok(_) => panic!("Unexpected message"),
@ -170,7 +168,7 @@ impl<'a> DedicatedWorkerGlobalScopeMethods for JSRef<'a, DedicatedWorkerGlobalSc
} }
let ScriptChan(ref sender) = self.parent_sender; let ScriptChan(ref sender) = self.parent_sender;
sender.send(WorkerPostMessage(self.worker, data, nbytes)); sender.send(ScriptMsg::WorkerPostMessage(self.worker, data, nbytes));
Ok(()) Ok(())
} }
@ -184,7 +182,7 @@ trait PrivateDedicatedWorkerGlobalScopeHelpers {
impl<'a> PrivateDedicatedWorkerGlobalScopeHelpers for JSRef<'a, DedicatedWorkerGlobalScope> { impl<'a> PrivateDedicatedWorkerGlobalScopeHelpers for JSRef<'a, DedicatedWorkerGlobalScope> {
fn delayed_release_worker(self) { fn delayed_release_worker(self) {
let ScriptChan(ref sender) = self.parent_sender; let ScriptChan(ref sender) = self.parent_sender;
sender.send(WorkerRelease(self.worker)); sender.send(ScriptMsg::WorkerRelease(self.worker));
} }
} }

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

@ -23,7 +23,6 @@ use dom::bindings::error::{ErrorResult, Fallible};
use dom::bindings::error::Error::{NotSupported, InvalidCharacter}; use dom::bindings::error::Error::{NotSupported, InvalidCharacter};
use dom::bindings::error::Error::{HierarchyRequest, NamespaceError}; use dom::bindings::error::Error::{HierarchyRequest, NamespaceError};
use dom::bindings::global::GlobalRef; use dom::bindings::global::GlobalRef;
use dom::bindings::global;
use dom::bindings::js::{MutNullableJS, JS, JSRef, Temporary, OptionalSettable, TemporaryPushable}; use dom::bindings::js::{MutNullableJS, JS, JSRef, Temporary, OptionalSettable, TemporaryPushable};
use dom::bindings::js::OptionalRootable; use dom::bindings::js::OptionalRootable;
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object}; use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
@ -60,7 +59,7 @@ use servo_util::namespace;
use servo_util::str::{DOMString, split_html_space_chars}; use servo_util::str::{DOMString, split_html_space_chars};
use html5ever::tree_builder::{QuirksMode, NoQuirks, LimitedQuirks, Quirks}; use html5ever::tree_builder::{QuirksMode, NoQuirks, LimitedQuirks, Quirks};
use layout_interface::{LayoutChan, SetQuirksModeMsg}; use layout_interface::{LayoutChan, Msg};
use string_cache::{Atom, QualName}; use string_cache::{Atom, QualName};
use url::Url; use url::Url;
@ -222,7 +221,7 @@ impl<'a> DocumentHelpers<'a> for JSRef<'a, Document> {
Quirks => { Quirks => {
let window = self.window.root(); let window = self.window.root();
let LayoutChan(ref layout_chan) = window.page().layout_chan; let LayoutChan(ref layout_chan) = window.page().layout_chan;
layout_chan.send(SetQuirksModeMsg); layout_chan.send(Msg::SetQuirksMode);
} }
NoQuirks | LimitedQuirks => {} NoQuirks | LimitedQuirks => {}
} }
@ -339,7 +338,7 @@ impl<'a> DocumentHelpers<'a> for JSRef<'a, Document> {
self.ready_state.set(state); self.ready_state.set(state);
let window = self.window.root(); let window = self.window.root();
let event = Event::new(global::Window(*window), "readystatechange".to_string(), let event = Event::new(GlobalRef::Window(*window), "readystatechange".to_string(),
EventBubbles::DoesNotBubble, EventBubbles::DoesNotBubble,
EventCancelable::NotCancelable).root(); EventCancelable::NotCancelable).root();
let target: JSRef<EventTarget> = EventTargetCast::from_ref(self); let target: JSRef<EventTarget> = EventTargetCast::from_ref(self);
@ -464,7 +463,7 @@ impl Document {
source: DocumentSource) -> Temporary<Document> { source: DocumentSource) -> Temporary<Document> {
let document = reflect_dom_object(box Document::new_inherited(window, url, doctype, let document = reflect_dom_object(box Document::new_inherited(window, url, doctype,
content_type, source), content_type, source),
global::Window(window), GlobalRef::Window(window),
DocumentBinding::Wrap).root(); DocumentBinding::Wrap).root();
let node: JSRef<Node> = NodeCast::from_ref(*document); let node: JSRef<Node> = NodeCast::from_ref(*document);
@ -735,13 +734,13 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
"mouseevents" | "mouseevent" => Ok(EventCast::from_temporary( "mouseevents" | "mouseevent" => Ok(EventCast::from_temporary(
MouseEvent::new_uninitialized(*window))), MouseEvent::new_uninitialized(*window))),
"customevent" => Ok(EventCast::from_temporary( "customevent" => Ok(EventCast::from_temporary(
CustomEvent::new_uninitialized(global::Window(*window)))), CustomEvent::new_uninitialized(GlobalRef::Window(*window)))),
"htmlevents" | "events" | "event" => Ok(Event::new_uninitialized( "htmlevents" | "events" | "event" => Ok(Event::new_uninitialized(
global::Window(*window))), GlobalRef::Window(*window))),
"keyboardevent" | "keyevents" => Ok(EventCast::from_temporary( "keyboardevent" | "keyevents" => Ok(EventCast::from_temporary(
KeyboardEvent::new_uninitialized(*window))), KeyboardEvent::new_uninitialized(*window))),
"messageevent" => Ok(EventCast::from_temporary( "messageevent" => Ok(EventCast::from_temporary(
MessageEvent::new_uninitialized(global::Window(*window)))), MessageEvent::new_uninitialized(GlobalRef::Window(*window)))),
_ => Err(NotSupported) _ => Err(NotSupported)
} }
} }

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

@ -9,7 +9,7 @@ use dom::bindings::codegen::Bindings::NodeBinding::NodeMethods;
use dom::bindings::codegen::InheritTypes::NodeCast; use dom::bindings::codegen::InheritTypes::NodeCast;
use dom::bindings::error::Fallible; use dom::bindings::error::Fallible;
use dom::bindings::error::Error::{InvalidCharacter, NamespaceError}; use dom::bindings::error::Error::{InvalidCharacter, NamespaceError};
use dom::bindings::global::Window; use dom::bindings::global::GlobalRef;
use dom::bindings::js::{JS, JSRef, Root, Temporary, OptionalRootable}; use dom::bindings::js::{JS, JSRef, Root, Temporary, OptionalRootable};
use dom::bindings::utils::{Reflector, Reflectable, reflect_dom_object}; use dom::bindings::utils::{Reflector, Reflectable, reflect_dom_object};
use dom::bindings::utils::xml_name_type; use dom::bindings::utils::xml_name_type;
@ -42,7 +42,7 @@ impl DOMImplementation {
pub fn new(document: JSRef<Document>) -> Temporary<DOMImplementation> { pub fn new(document: JSRef<Document>) -> Temporary<DOMImplementation> {
let window = document.window().root(); let window = document.window().root();
reflect_dom_object(box DOMImplementation::new_inherited(document), reflect_dom_object(box DOMImplementation::new_inherited(document),
Window(*window), GlobalRef::Window(*window),
DOMImplementationBinding::Wrap) DOMImplementationBinding::Wrap)
} }
} }

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

@ -9,7 +9,6 @@ use dom::bindings::codegen::Bindings::DOMParserBinding::SupportedType::{Text_htm
use dom::bindings::error::Fallible; use dom::bindings::error::Fallible;
use dom::bindings::error::Error::FailureUnknown; use dom::bindings::error::Error::FailureUnknown;
use dom::bindings::global::GlobalRef; use dom::bindings::global::GlobalRef;
use dom::bindings::global;
use dom::bindings::js::{JS, JSRef, Temporary}; use dom::bindings::js::{JS, JSRef, Temporary};
use dom::bindings::utils::{Reflector, Reflectable, reflect_dom_object}; use dom::bindings::utils::{Reflector, Reflectable, reflect_dom_object};
use dom::document::{Document, DocumentHelpers, IsHTMLDocument}; use dom::document::{Document, DocumentHelpers, IsHTMLDocument};
@ -33,7 +32,7 @@ impl DOMParser {
} }
pub fn new(window: JSRef<Window>) -> Temporary<DOMParser> { pub fn new(window: JSRef<Window>) -> Temporary<DOMParser> {
reflect_dom_object(box DOMParser::new_inherited(window), global::Window(window), reflect_dom_object(box DOMParser::new_inherited(window), GlobalRef::Window(window),
DOMParserBinding::Wrap) DOMParserBinding::Wrap)
} }

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

@ -4,7 +4,7 @@
use dom::bindings::codegen::Bindings::DOMRectBinding; use dom::bindings::codegen::Bindings::DOMRectBinding;
use dom::bindings::codegen::Bindings::DOMRectBinding::DOMRectMethods; use dom::bindings::codegen::Bindings::DOMRectBinding::DOMRectMethods;
use dom::bindings::global; use dom::bindings::global::GlobalRef;
use dom::bindings::js::{JSRef, Temporary}; use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object}; use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::window::Window; use dom::window::Window;
@ -36,7 +36,7 @@ impl DOMRect {
top: Au, bottom: Au, top: Au, bottom: Au,
left: Au, right: Au) -> Temporary<DOMRect> { left: Au, right: Au) -> Temporary<DOMRect> {
reflect_dom_object(box DOMRect::new_inherited(top, bottom, left, right), reflect_dom_object(box DOMRect::new_inherited(top, bottom, left, right),
global::Window(window), DOMRectBinding::Wrap) GlobalRef::Window(window), DOMRectBinding::Wrap)
} }
} }

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

@ -4,7 +4,7 @@
use dom::bindings::codegen::Bindings::DOMRectListBinding; use dom::bindings::codegen::Bindings::DOMRectListBinding;
use dom::bindings::codegen::Bindings::DOMRectListBinding::DOMRectListMethods; use dom::bindings::codegen::Bindings::DOMRectListBinding::DOMRectListMethods;
use dom::bindings::global; use dom::bindings::global::GlobalRef;
use dom::bindings::js::{JS, JSRef, Temporary}; use dom::bindings::js::{JS, JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object}; use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::domrect::DOMRect; use dom::domrect::DOMRect;
@ -31,7 +31,7 @@ impl DOMRectList {
pub fn new(window: JSRef<Window>, pub fn new(window: JSRef<Window>,
rects: Vec<JSRef<DOMRect>>) -> Temporary<DOMRectList> { rects: Vec<JSRef<DOMRect>>) -> Temporary<DOMRectList> {
reflect_dom_object(box DOMRectList::new_inherited(window, rects), reflect_dom_object(box DOMRectList::new_inherited(window, rects),
global::Window(window), DOMRectListBinding::Wrap) GlobalRef::Window(window), DOMRectListBinding::Wrap)
} }
} }

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

@ -7,7 +7,7 @@ use dom::bindings::codegen::Bindings::DOMTokenListBinding;
use dom::bindings::codegen::Bindings::DOMTokenListBinding::DOMTokenListMethods; use dom::bindings::codegen::Bindings::DOMTokenListBinding::DOMTokenListMethods;
use dom::bindings::error::Fallible; use dom::bindings::error::Fallible;
use dom::bindings::error::Error::{InvalidCharacter, Syntax}; use dom::bindings::error::Error::{InvalidCharacter, Syntax};
use dom::bindings::global::Window; use dom::bindings::global::GlobalRef;
use dom::bindings::js::{JS, JSRef, Temporary, OptionalRootable}; use dom::bindings::js::{JS, JSRef, Temporary, OptionalRootable};
use dom::bindings::utils::{Reflector, Reflectable, reflect_dom_object}; use dom::bindings::utils::{Reflector, Reflectable, reflect_dom_object};
use dom::element::{Element, AttributeHandlers}; use dom::element::{Element, AttributeHandlers};
@ -35,7 +35,7 @@ impl DOMTokenList {
pub fn new(element: JSRef<Element>, local_name: &Atom) -> Temporary<DOMTokenList> { pub fn new(element: JSRef<Element>, local_name: &Atom) -> Temporary<DOMTokenList> {
let window = window_from_node(element).root(); let window = window_from_node(element).root();
reflect_dom_object(box DOMTokenList::new_inherited(element, local_name.clone()), reflect_dom_object(box DOMTokenList::new_inherited(element, local_name.clone()),
Window(*window), GlobalRef::Window(*window),
DOMTokenListBinding::Wrap) DOMTokenListBinding::Wrap)
} }
} }

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

@ -8,7 +8,7 @@ use dom::bindings::codegen::Bindings::HTMLCanvasElementBinding;
use dom::bindings::codegen::Bindings::HTMLCanvasElementBinding::HTMLCanvasElementMethods; use dom::bindings::codegen::Bindings::HTMLCanvasElementBinding::HTMLCanvasElementMethods;
use dom::bindings::codegen::InheritTypes::HTMLCanvasElementDerived; use dom::bindings::codegen::InheritTypes::HTMLCanvasElementDerived;
use dom::bindings::codegen::InheritTypes::{ElementCast, HTMLElementCast}; use dom::bindings::codegen::InheritTypes::{ElementCast, HTMLElementCast};
use dom::bindings::global::Window; use dom::bindings::global::GlobalRef;
use dom::bindings::js::{MutNullableJS, JSRef, Temporary, OptionalSettable}; use dom::bindings::js::{MutNullableJS, JSRef, Temporary, OptionalSettable};
use dom::bindings::utils::{Reflectable, Reflector}; use dom::bindings::utils::{Reflectable, Reflector};
use dom::canvasrenderingcontext2d::CanvasRenderingContext2D; use dom::canvasrenderingcontext2d::CanvasRenderingContext2D;
@ -87,7 +87,7 @@ impl<'a> HTMLCanvasElementMethods for JSRef<'a, HTMLCanvasElement> {
if self.context.get().is_none() { if self.context.get().is_none() {
let window = window_from_node(self).root(); let window = window_from_node(self).root();
let (w, h) = (self.width.get() as i32, self.height.get() as i32); let (w, h) = (self.width.get() as i32, self.height.get() as i32);
let context = CanvasRenderingContext2D::new(&Window(*window), self, Size2D(w, h)); let context = CanvasRenderingContext2D::new(&GlobalRef::Window(*window), self, Size2D(w, h));
self.context.assign(Some(context)); self.context.assign(Some(context));
} }
self.context.get() self.context.get()

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

@ -5,7 +5,7 @@
use dom::bindings::codegen::Bindings::HTMLCollectionBinding; use dom::bindings::codegen::Bindings::HTMLCollectionBinding;
use dom::bindings::codegen::Bindings::HTMLCollectionBinding::HTMLCollectionMethods; use dom::bindings::codegen::Bindings::HTMLCollectionBinding::HTMLCollectionMethods;
use dom::bindings::codegen::InheritTypes::{ElementCast, NodeCast}; use dom::bindings::codegen::InheritTypes::{ElementCast, NodeCast};
use dom::bindings::global; use dom::bindings::global::GlobalRef;
use dom::bindings::js::{JS, JSRef, Temporary}; use dom::bindings::js::{JS, JSRef, Temporary};
use dom::bindings::trace::JSTraceable; use dom::bindings::trace::JSTraceable;
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object}; use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
@ -46,7 +46,7 @@ impl HTMLCollection {
pub fn new(window: JSRef<Window>, collection: CollectionTypeId) -> Temporary<HTMLCollection> { pub fn new(window: JSRef<Window>, collection: CollectionTypeId) -> Temporary<HTMLCollection> {
reflect_dom_object(box HTMLCollection::new_inherited(collection), reflect_dom_object(box HTMLCollection::new_inherited(collection),
global::Window(window), HTMLCollectionBinding::Wrap) GlobalRef::Window(window), HTMLCollectionBinding::Wrap)
} }
} }

11
components/script/dom/htmlformelement.rs
View file

@ -10,7 +10,7 @@ use dom::bindings::codegen::Bindings::HTMLFormElementBinding::HTMLFormElementMet
use dom::bindings::codegen::Bindings::HTMLInputElementBinding::HTMLInputElementMethods; use dom::bindings::codegen::Bindings::HTMLInputElementBinding::HTMLInputElementMethods;
use dom::bindings::codegen::InheritTypes::{EventTargetCast, HTMLFormElementDerived, NodeCast}; use dom::bindings::codegen::InheritTypes::{EventTargetCast, HTMLFormElementDerived, NodeCast};
use dom::bindings::codegen::InheritTypes::{HTMLInputElementCast, HTMLTextAreaElementCast, HTMLFormElementCast}; use dom::bindings::codegen::InheritTypes::{HTMLInputElementCast, HTMLTextAreaElementCast, HTMLFormElementCast};
use dom::bindings::global::Window; use dom::bindings::global::GlobalRef;
use dom::bindings::js::{JSRef, Temporary, OptionalRootable}; use dom::bindings::js::{JSRef, Temporary, OptionalRootable};
use dom::bindings::utils::{Reflectable, Reflector}; use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::{Document, DocumentHelpers}; use dom::document::{Document, DocumentHelpers};
@ -24,8 +24,7 @@ use dom::node::{Node, NodeHelpers, NodeTypeId, document_from_node, window_from_n
use hyper::method::Post; use hyper::method::Post;
use servo_msg::constellation_msg::LoadData; use servo_msg::constellation_msg::LoadData;
use servo_util::str::DOMString; use servo_util::str::DOMString;
use script_task::ScriptChan; use script_task::{ScriptChan, ScriptMsg};
use script_task::ScriptMsg::TriggerLoadMsg;
use std::ascii::OwnedAsciiExt; use std::ascii::OwnedAsciiExt;
use url::UrlParser; use url::UrlParser;
use url::form_urlencoded::serialize; use url::form_urlencoded::serialize;
@ -157,7 +156,7 @@ impl<'a> HTMLFormElementHelpers for JSRef<'a, HTMLFormElement> {
let base = doc.url(); let base = doc.url();
// TODO: Handle browsing contexts // TODO: Handle browsing contexts
// TODO: Handle validation // TODO: Handle validation
let event = Event::new(Window(*win), let event = Event::new(GlobalRef::Window(*win),
"submit".to_string(), "submit".to_string(),
EventBubbles::Bubbles, EventBubbles::Bubbles,
EventCancelable::Cancelable).root(); EventCancelable::Cancelable).root();
@ -207,7 +206,7 @@ impl<'a> HTMLFormElementHelpers for JSRef<'a, HTMLFormElement> {
// This is wrong. https://html.spec.whatwg.org/multipage/forms.html#planned-navigation // This is wrong. https://html.spec.whatwg.org/multipage/forms.html#planned-navigation
let ScriptChan(ref script_chan) = *win.script_chan(); let ScriptChan(ref script_chan) = *win.script_chan();
script_chan.send(TriggerLoadMsg(win.page().id, load_data)); script_chan.send(ScriptMsg::TriggerLoad(win.page().id, load_data));
} }
fn get_form_dataset<'b>(self, submitter: Option<FormSubmitter<'b>>) -> Vec<FormDatum> { fn get_form_dataset<'b>(self, submitter: Option<FormSubmitter<'b>>) -> Vec<FormDatum> {
@ -345,7 +344,7 @@ impl<'a> HTMLFormElementHelpers for JSRef<'a, HTMLFormElement> {
} }
let win = window_from_node(self).root(); let win = window_from_node(self).root();
let event = Event::new(Window(*win), let event = Event::new(GlobalRef::Window(*win),
"reset".to_string(), "reset".to_string(),
EventBubbles::Bubbles, EventBubbles::Bubbles,
EventCancelable::Cancelable).root(); EventCancelable::Cancelable).root();

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

@ -14,7 +14,7 @@ use dom::bindings::codegen::Bindings::HTMLInputElementBinding::HTMLInputElementM
use dom::bindings::codegen::InheritTypes::{ElementCast, HTMLElementCast, HTMLInputElementCast, NodeCast}; use dom::bindings::codegen::InheritTypes::{ElementCast, HTMLElementCast, HTMLInputElementCast, NodeCast};
use dom::bindings::codegen::InheritTypes::{HTMLInputElementDerived, HTMLFieldSetElementDerived, EventTargetCast}; use dom::bindings::codegen::InheritTypes::{HTMLInputElementDerived, HTMLFieldSetElementDerived, EventTargetCast};
use dom::bindings::codegen::InheritTypes::KeyboardEventCast; use dom::bindings::codegen::InheritTypes::KeyboardEventCast;
use dom::bindings::global::Window; use dom::bindings::global::GlobalRef;
use dom::bindings::js::{Comparable, JS, JSRef, Root, Temporary, OptionalRootable}; use dom::bindings::js::{Comparable, JS, JSRef, Root, Temporary, OptionalRootable};
use dom::bindings::js::{ResultRootable, RootedReference, MutNullableJS}; use dom::bindings::js::{ResultRootable, RootedReference, MutNullableJS};
use dom::bindings::utils::{Reflectable, Reflector}; use dom::bindings::utils::{Reflectable, Reflector};
@ -742,7 +742,7 @@ impl<'a> Activatable for JSRef<'a, HTMLInputElement> {
// https://html.spec.whatwg.org/multipage/forms.html#radio-button-state-(type=radio):activation-behavior // https://html.spec.whatwg.org/multipage/forms.html#radio-button-state-(type=radio):activation-behavior
if self.mutable() { if self.mutable() {
let win = window_from_node(*self).root(); let win = window_from_node(*self).root();
let event = Event::new(Window(*win), let event = Event::new(GlobalRef::Window(*win),
"input".to_string(), "input".to_string(),
EventBubbles::Bubbles, EventBubbles::Bubbles,
EventCancelable::NotCancelable).root(); EventCancelable::NotCancelable).root();
@ -750,7 +750,7 @@ impl<'a> Activatable for JSRef<'a, HTMLInputElement> {
let target: JSRef<EventTarget> = EventTargetCast::from_ref(*self); let target: JSRef<EventTarget> = EventTargetCast::from_ref(*self);
target.DispatchEvent(*event).ok(); target.DispatchEvent(*event).ok();
let event = Event::new(Window(*win), let event = Event::new(GlobalRef::Window(*win),
"change".to_string(), "change".to_string(),
EventBubbles::Bubbles, EventBubbles::Bubbles,
EventCancelable::NotCancelable).root(); EventCancelable::NotCancelable).root();

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

@ -17,7 +17,7 @@ use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::{Node, NodeHelpers, NodeTypeId, window_from_node}; use dom::node::{Node, NodeHelpers, NodeTypeId, window_from_node};
use dom::virtualmethods::VirtualMethods; use dom::virtualmethods::VirtualMethods;
use layout_interface::{LayoutChan, LoadStylesheetMsg}; use layout_interface::{LayoutChan, Msg};
use servo_util::str::{DOMString, HTML_SPACE_CHARACTERS}; use servo_util::str::{DOMString, HTML_SPACE_CHARACTERS};
use std::ascii::AsciiExt; use std::ascii::AsciiExt;
@ -131,7 +131,7 @@ impl<'a> PrivateHTMLLinkElementHelpers for JSRef<'a, HTMLLinkElement> {
match UrlParser::new().base_url(&window.page().get_url()).parse(href) { match UrlParser::new().base_url(&window.page().get_url()).parse(href) {
Ok(url) => { Ok(url) => {
let LayoutChan(ref layout_chan) = window.page().layout_chan; let LayoutChan(ref layout_chan) = window.page().layout_chan;
layout_chan.send(LoadStylesheetMsg(url)); layout_chan.send(Msg::LoadStylesheet(url));
} }
Err(e) => debug!("Parsing url {:s} failed: {}", href, e) Err(e) => debug!("Parsing url {:s} failed: {}", href, e)
} }

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

@ -13,7 +13,7 @@ use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlelement::HTMLElement; use dom::htmlelement::HTMLElement;
use dom::node::{Node, NodeHelpers, NodeTypeId, window_from_node}; use dom::node::{Node, NodeHelpers, NodeTypeId, window_from_node};
use dom::virtualmethods::VirtualMethods; use dom::virtualmethods::VirtualMethods;
use layout_interface::{AddStylesheetMsg, LayoutChan}; use layout_interface::{LayoutChan, Msg};
use servo_util::str::DOMString; use servo_util::str::DOMString;
use style::{StylesheetOrigin, Stylesheet}; use style::{StylesheetOrigin, Stylesheet};
@ -58,7 +58,7 @@ impl<'a> StyleElementHelpers for JSRef<'a, HTMLStyleElement> {
let sheet = Stylesheet::from_str(data.as_slice(), url, let sheet = Stylesheet::from_str(data.as_slice(), url,
StylesheetOrigin::Author); StylesheetOrigin::Author);
let LayoutChan(ref layout_chan) = win.page().layout_chan; let LayoutChan(ref layout_chan) = win.page().layout_chan;
layout_chan.send(AddStylesheetMsg(sheet)); layout_chan.send(Msg::AddStylesheet(sheet));
} }
} }

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

@ -8,7 +8,6 @@ use dom::bindings::codegen::Bindings::UIEventBinding::UIEventMethods;
use dom::bindings::codegen::InheritTypes::{EventCast, UIEventCast, KeyboardEventDerived}; use dom::bindings::codegen::InheritTypes::{EventCast, UIEventCast, KeyboardEventDerived};
use dom::bindings::error::Fallible; use dom::bindings::error::Fallible;
use dom::bindings::global::GlobalRef; use dom::bindings::global::GlobalRef;
use dom::bindings::global;
use dom::bindings::js::{JSRef, Temporary, RootedReference}; use dom::bindings::js::{JSRef, Temporary, RootedReference};
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object}; use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::event::{Event, EventTypeId}; use dom::event::{Event, EventTypeId};
@ -61,7 +60,7 @@ impl KeyboardEvent {
pub fn new_uninitialized(window: JSRef<Window>) -> Temporary<KeyboardEvent> { pub fn new_uninitialized(window: JSRef<Window>) -> Temporary<KeyboardEvent> {
reflect_dom_object(box KeyboardEvent::new_inherited(), reflect_dom_object(box KeyboardEvent::new_inherited(),
global::Window(window), GlobalRef::Window(window),
KeyboardEventBinding::Wrap) KeyboardEventBinding::Wrap)
} }

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

@ -4,7 +4,7 @@
use dom::bindings::codegen::Bindings::LocationBinding; use dom::bindings::codegen::Bindings::LocationBinding;
use dom::bindings::codegen::Bindings::LocationBinding::LocationMethods; use dom::bindings::codegen::Bindings::LocationBinding::LocationMethods;
use dom::bindings::global; use dom::bindings::global::GlobalRef;
use dom::bindings::js::{JSRef, Temporary}; use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object}; use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::urlhelper::UrlHelper; use dom::urlhelper::UrlHelper;
@ -31,7 +31,7 @@ impl Location {
pub fn new(window: JSRef<Window>, page: Rc<Page>) -> Temporary<Location> { pub fn new(window: JSRef<Window>, page: Rc<Page>) -> Temporary<Location> {
reflect_dom_object(box Location::new_inherited(page), reflect_dom_object(box Location::new_inherited(page),
global::Window(window), GlobalRef::Window(window),
LocationBinding::Wrap) LocationBinding::Wrap)
} }
} }

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

@ -8,7 +8,6 @@ use dom::bindings::codegen::Bindings::UIEventBinding::UIEventMethods;
use dom::bindings::codegen::InheritTypes::{EventCast, UIEventCast, MouseEventDerived}; use dom::bindings::codegen::InheritTypes::{EventCast, UIEventCast, MouseEventDerived};
use dom::bindings::error::Fallible; use dom::bindings::error::Fallible;
use dom::bindings::global::GlobalRef; use dom::bindings::global::GlobalRef;
use dom::bindings::global;
use dom::bindings::js::{MutNullableJS, JSRef, RootedReference, Temporary, OptionalSettable}; use dom::bindings::js::{MutNullableJS, JSRef, RootedReference, Temporary, OptionalSettable};
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object}; use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::event::{Event, EventTypeId}; use dom::event::{Event, EventTypeId};
@ -59,7 +58,7 @@ impl MouseEvent {
pub fn new_uninitialized(window: JSRef<Window>) -> Temporary<MouseEvent> { pub fn new_uninitialized(window: JSRef<Window>) -> Temporary<MouseEvent> {
reflect_dom_object(box MouseEvent::new_inherited(), reflect_dom_object(box MouseEvent::new_inherited(),
global::Window(window), GlobalRef::Window(window),
MouseEventBinding::Wrap) MouseEventBinding::Wrap)
} }

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

@ -5,7 +5,7 @@
use dom::attr::Attr; use dom::attr::Attr;
use dom::bindings::codegen::Bindings::NamedNodeMapBinding; use dom::bindings::codegen::Bindings::NamedNodeMapBinding;
use dom::bindings::codegen::Bindings::NamedNodeMapBinding::NamedNodeMapMethods; use dom::bindings::codegen::Bindings::NamedNodeMapBinding::NamedNodeMapMethods;
use dom::bindings::global; use dom::bindings::global::GlobalRef;
use dom::bindings::js::{JS, JSRef, Temporary}; use dom::bindings::js::{JS, JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object}; use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::element::{Element, ElementHelpers}; use dom::element::{Element, ElementHelpers};
@ -27,7 +27,7 @@ impl NamedNodeMap {
pub fn new(window: JSRef<Window>, elem: JSRef<Element>) -> Temporary<NamedNodeMap> { pub fn new(window: JSRef<Window>, elem: JSRef<Element>) -> Temporary<NamedNodeMap> {
reflect_dom_object(box NamedNodeMap::new_inherited(elem), reflect_dom_object(box NamedNodeMap::new_inherited(elem),
global::Window(window), NamedNodeMapBinding::Wrap) GlobalRef::Window(window), NamedNodeMapBinding::Wrap)
} }
} }

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

@ -4,7 +4,7 @@
use dom::bindings::codegen::Bindings::NavigatorBinding; use dom::bindings::codegen::Bindings::NavigatorBinding;
use dom::bindings::codegen::Bindings::NavigatorBinding::NavigatorMethods; use dom::bindings::codegen::Bindings::NavigatorBinding::NavigatorMethods;
use dom::bindings::global; use dom::bindings::global::GlobalRef;
use dom::bindings::js::{JSRef, Temporary}; use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object}; use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::navigatorinfo::NavigatorInfo; use dom::navigatorinfo::NavigatorInfo;
@ -25,7 +25,7 @@ impl Navigator {
pub fn new(window: JSRef<Window>) -> Temporary<Navigator> { pub fn new(window: JSRef<Window>) -> Temporary<Navigator> {
reflect_dom_object(box Navigator::new_inherited(), reflect_dom_object(box Navigator::new_inherited(),
global::Window(window), GlobalRef::Window(window),
NavigatorBinding::Wrap) NavigatorBinding::Wrap)
} }
} }

7
components/script/dom/node.rs
View file

@ -22,7 +22,6 @@ use dom::bindings::codegen::InheritTypes::HTMLOptGroupElementDerived;
use dom::bindings::error::Fallible; use dom::bindings::error::Fallible;
use dom::bindings::error::Error::{NotFound, HierarchyRequest, Syntax}; use dom::bindings::error::Error::{NotFound, HierarchyRequest, Syntax};
use dom::bindings::global::GlobalRef; use dom::bindings::global::GlobalRef;
use dom::bindings::global;
use dom::bindings::js::{JS, JSRef, RootedReference, Temporary, Root}; use dom::bindings::js::{JS, JSRef, RootedReference, Temporary, Root};
use dom::bindings::js::{OptionalSettable, TemporaryPushable, OptionalRootedRootable}; use dom::bindings::js::{OptionalSettable, TemporaryPushable, OptionalRootedRootable};
use dom::bindings::js::{ResultRootable, OptionalRootable, MutNullableJS}; use dom::bindings::js::{ResultRootable, OptionalRootable, MutNullableJS};
@ -43,7 +42,7 @@ use dom::text::Text;
use dom::virtualmethods::{VirtualMethods, vtable_for}; use dom::virtualmethods::{VirtualMethods, vtable_for};
use dom::window::Window; use dom::window::Window;
use geom::rect::Rect; use geom::rect::Rect;
use layout_interface::{LayoutChan, ReapLayoutDataMsg}; use layout_interface::{LayoutChan, Msg};
use devtools_traits::NodeInfo; use devtools_traits::NodeInfo;
use script_traits::UntrustedNodeAddress; use script_traits::UntrustedNodeAddress;
use servo_util::geometry::Au; use servo_util::geometry::Au;
@ -1161,7 +1160,7 @@ impl Node {
wrap_fn: extern "Rust" fn(*mut JSContext, &GlobalRef, Box<N>) -> Temporary<N>) wrap_fn: extern "Rust" fn(*mut JSContext, &GlobalRef, Box<N>) -> Temporary<N>)
-> Temporary<N> { -> Temporary<N> {
let window = document.window().root(); let window = document.window().root();
reflect_dom_object(node, global::Window(*window), wrap_fn) reflect_dom_object(node, GlobalRef::Window(*window), wrap_fn)
} }
pub fn new_inherited(type_id: NodeTypeId, doc: JSRef<Document>) -> Node { pub fn new_inherited(type_id: NodeTypeId, doc: JSRef<Document>) -> Node {
@ -1625,7 +1624,7 @@ impl Node {
None => {} None => {}
Some(chan) => { Some(chan) => {
let LayoutChan(chan) = chan; let LayoutChan(chan) = chan;
chan.send(ReapLayoutDataMsg(layout_data)) chan.send(Msg::ReapLayoutData(layout_data))
}, },
} }
} }

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

@ -4,7 +4,7 @@
use dom::bindings::codegen::Bindings::NodeListBinding; use dom::bindings::codegen::Bindings::NodeListBinding;
use dom::bindings::codegen::Bindings::NodeListBinding::NodeListMethods; use dom::bindings::codegen::Bindings::NodeListBinding::NodeListMethods;
use dom::bindings::global; use dom::bindings::global::GlobalRef;
use dom::bindings::js::{JS, JSRef, Temporary}; use dom::bindings::js::{JS, JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object}; use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::node::{Node, NodeHelpers}; use dom::node::{Node, NodeHelpers};
@ -34,7 +34,7 @@ impl NodeList {
pub fn new(window: JSRef<Window>, pub fn new(window: JSRef<Window>,
list_type: NodeListType) -> Temporary<NodeList> { list_type: NodeListType) -> Temporary<NodeList> {
reflect_dom_object(box NodeList::new_inherited(list_type), reflect_dom_object(box NodeList::new_inherited(list_type),
global::Window(window), NodeListBinding::Wrap) GlobalRef::Window(window), NodeListBinding::Wrap)
} }
pub fn new_simple_list(window: JSRef<Window>, elements: Vec<JSRef<Node>>) -> Temporary<NodeList> { pub fn new_simple_list(window: JSRef<Window>, elements: Vec<JSRef<Node>>) -> Temporary<NodeList> {

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

@ -4,7 +4,7 @@
use dom::bindings::codegen::Bindings::PerformanceBinding; use dom::bindings::codegen::Bindings::PerformanceBinding;
use dom::bindings::codegen::Bindings::PerformanceBinding::PerformanceMethods; use dom::bindings::codegen::Bindings::PerformanceBinding::PerformanceMethods;
use dom::bindings::global; use dom::bindings::global::GlobalRef;
use dom::bindings::js::{JS, JSRef, Temporary}; use dom::bindings::js::{JS, JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object}; use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::performancetiming::{PerformanceTiming, PerformanceTimingHelpers}; use dom::performancetiming::{PerformanceTiming, PerformanceTimingHelpers};
@ -37,7 +37,7 @@ impl Performance {
reflect_dom_object(box Performance::new_inherited(window, reflect_dom_object(box Performance::new_inherited(window,
navigation_start, navigation_start,
navigation_start_precise), navigation_start_precise),
global::Window(window), GlobalRef::Window(window),
PerformanceBinding::Wrap) PerformanceBinding::Wrap)
} }
} }

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

@ -4,7 +4,7 @@
use dom::bindings::codegen::Bindings::PerformanceTimingBinding; use dom::bindings::codegen::Bindings::PerformanceTimingBinding;
use dom::bindings::codegen::Bindings::PerformanceTimingBinding::PerformanceTimingMethods; use dom::bindings::codegen::Bindings::PerformanceTimingBinding::PerformanceTimingMethods;
use dom::bindings::global; use dom::bindings::global::GlobalRef;
use dom::bindings::js::{JSRef, Temporary}; use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object}; use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::window::Window; use dom::window::Window;
@ -33,7 +33,7 @@ impl PerformanceTiming {
-> Temporary<PerformanceTiming> { -> Temporary<PerformanceTiming> {
let timing = PerformanceTiming::new_inherited(navigation_start, let timing = PerformanceTiming::new_inherited(navigation_start,
navigation_start_precise); navigation_start_precise);
reflect_dom_object(box timing, global::Window(window), reflect_dom_object(box timing, GlobalRef::Window(window),
PerformanceTimingBinding::Wrap) PerformanceTimingBinding::Wrap)
} }
} }

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

@ -6,7 +6,7 @@ use dom::bindings::codegen::Bindings::RangeBinding;
use dom::bindings::codegen::Bindings::RangeBinding::RangeMethods; use dom::bindings::codegen::Bindings::RangeBinding::RangeMethods;
use dom::bindings::codegen::Bindings::WindowBinding::WindowMethods; use dom::bindings::codegen::Bindings::WindowBinding::WindowMethods;
use dom::bindings::error::Fallible; use dom::bindings::error::Fallible;
use dom::bindings::global::{GlobalRef, Window}; use dom::bindings::global::GlobalRef;
use dom::bindings::js::{JSRef, Temporary}; use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object}; use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::document::{Document, DocumentHelpers}; use dom::document::{Document, DocumentHelpers};
@ -26,7 +26,7 @@ impl Range {
pub fn new(document: JSRef<Document>) -> Temporary<Range> { pub fn new(document: JSRef<Document>) -> Temporary<Range> {
let window = document.window().root(); let window = document.window().root();
reflect_dom_object(box Range::new_inherited(), reflect_dom_object(box Range::new_inherited(),
Window(*window), GlobalRef::Window(*window),
RangeBinding::Wrap) RangeBinding::Wrap)
} }

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

@ -4,7 +4,7 @@
use dom::bindings::codegen::Bindings::ScreenBinding; use dom::bindings::codegen::Bindings::ScreenBinding;
use dom::bindings::codegen::Bindings::ScreenBinding::ScreenMethods; use dom::bindings::codegen::Bindings::ScreenBinding::ScreenMethods;
use dom::bindings::global; use dom::bindings::global::GlobalRef;
use dom::bindings::js::{JSRef, Temporary}; use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object}; use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::window::Window; use dom::window::Window;
@ -23,7 +23,7 @@ impl Screen {
pub fn new(window: JSRef<Window>) -> Temporary<Screen> { pub fn new(window: JSRef<Window>) -> Temporary<Screen> {
reflect_dom_object(box Screen::new_inherited(), reflect_dom_object(box Screen::new_inherited(),
global::Window(window), GlobalRef::Window(window),
ScreenBinding::Wrap) ScreenBinding::Wrap)
} }
} }

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

@ -7,7 +7,7 @@
use dom::bindings::cell::DOMRefCell; use dom::bindings::cell::DOMRefCell;
use dom::bindings::codegen::Bindings::ServoHTMLParserBinding; use dom::bindings::codegen::Bindings::ServoHTMLParserBinding;
use dom::bindings::global; use dom::bindings::global::GlobalRef;
use dom::bindings::trace::JSTraceable; use dom::bindings::trace::JSTraceable;
use dom::bindings::js::{JS, JSRef, Temporary}; use dom::bindings::js::{JS, JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object}; use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
@ -72,7 +72,7 @@ impl ServoHTMLParser {
tokenizer: DOMRefCell::new(tok), tokenizer: DOMRefCell::new(tok),
}; };
reflect_dom_object(box parser, global::Window(*window), ServoHTMLParserBinding::Wrap) reflect_dom_object(box parser, GlobalRef::Window(*window), ServoHTMLParserBinding::Wrap)
} }
#[inline] #[inline]

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

@ -12,7 +12,7 @@ use dom::bindings::codegen::Bindings::NodeFilterBinding::NodeFilter;
// For now, it is defined in this file. // For now, it is defined in this file.
// use dom::bindings::codegen::Bindings::NodeFilterBinding::NodeFilterConstants; // use dom::bindings::codegen::Bindings::NodeFilterBinding::NodeFilterConstants;
use dom::bindings::error::{ErrorResult, Fallible}; use dom::bindings::error::{ErrorResult, Fallible};
use dom::bindings::global::Window; use dom::bindings::global::GlobalRef;
use dom::bindings::js::{JS, JSRef, OptionalRootable, Temporary}; use dom::bindings::js::{JS, JSRef, OptionalRootable, Temporary};
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object}; use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::document::{Document, DocumentHelpers}; use dom::document::{Document, DocumentHelpers};
@ -49,7 +49,7 @@ impl TreeWalker {
filter: Filter) -> Temporary<TreeWalker> { filter: Filter) -> Temporary<TreeWalker> {
let window = document.window().root(); let window = document.window().root();
reflect_dom_object(box TreeWalker::new_inherited(root_node, what_to_show, filter), reflect_dom_object(box TreeWalker::new_inherited(root_node, what_to_show, filter),
Window(*window), GlobalRef::Window(*window),
TreeWalkerBinding::Wrap) TreeWalkerBinding::Wrap)
} }

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

@ -8,7 +8,6 @@ use dom::bindings::codegen::Bindings::UIEventBinding::UIEventMethods;
use dom::bindings::codegen::InheritTypes::{EventCast, UIEventDerived}; use dom::bindings::codegen::InheritTypes::{EventCast, UIEventDerived};
use dom::bindings::error::Fallible; use dom::bindings::error::Fallible;
use dom::bindings::global::GlobalRef; use dom::bindings::global::GlobalRef;
use dom::bindings::global;
use dom::bindings::js::{MutNullableJS, JSRef, RootedReference, Temporary, OptionalSettable}; use dom::bindings::js::{MutNullableJS, JSRef, RootedReference, Temporary, OptionalSettable};
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object}; use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
@ -43,7 +42,7 @@ impl UIEvent {
pub fn new_uninitialized(window: JSRef<Window>) -> Temporary<UIEvent> { pub fn new_uninitialized(window: JSRef<Window>) -> Temporary<UIEvent> {
reflect_dom_object(box UIEvent::new_inherited(EventTypeId::UIEvent), reflect_dom_object(box UIEvent::new_inherited(EventTypeId::UIEvent),
global::Window(window), GlobalRef::Window(window),
UIEventBinding::Wrap) UIEventBinding::Wrap)
} }

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

@ -3,7 +3,7 @@
* 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::codegen::Bindings::ValidityStateBinding; use dom::bindings::codegen::Bindings::ValidityStateBinding;
use dom::bindings::global; use dom::bindings::global::GlobalRef;
use dom::bindings::js::{JSRef, Temporary}; use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object}; use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::window::Window; use dom::window::Window;
@ -24,7 +24,7 @@ impl ValidityState {
pub fn new(window: JSRef<Window>) -> Temporary<ValidityState> { pub fn new(window: JSRef<Window>) -> Temporary<ValidityState> {
reflect_dom_object(box ValidityState::new_inherited(), reflect_dom_object(box ValidityState::new_inherited(),
global::Window(window), GlobalRef::Window(window),
ValidityStateBinding::Wrap) ValidityStateBinding::Wrap)
} }
} }

18
components/script/dom/window.rs
View file

@ -10,7 +10,7 @@ use dom::bindings::codegen::Bindings::WindowBinding::WindowMethods;
use dom::bindings::codegen::InheritTypes::EventTargetCast; use dom::bindings::codegen::InheritTypes::EventTargetCast;
use dom::bindings::error::Fallible; use dom::bindings::error::Fallible;
use dom::bindings::error::Error::InvalidCharacter; use dom::bindings::error::Error::InvalidCharacter;
use dom::bindings::global; use dom::bindings::global::GlobalRef;
use dom::bindings::js::{MutNullableJS, JSRef, Temporary}; use dom::bindings::js::{MutNullableJS, JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector}; use dom::bindings::utils::{Reflectable, Reflector};
use dom::browsercontext::BrowserContext; use dom::browsercontext::BrowserContext;
@ -22,10 +22,10 @@ use dom::navigator::Navigator;
use dom::performance::Performance; use dom::performance::Performance;
use dom::screen::Screen; use dom::screen::Screen;
use dom::storage::Storage; use dom::storage::Storage;
use layout_interface::{NoQuery, ReflowForDisplay, ReflowGoal, ReflowQueryType}; use layout_interface::{ReflowGoal, ReflowQueryType};
use page::Page; use page::Page;
use script_task::{TimerSource, ScriptChan}; use script_task::{TimerSource, ScriptChan};
use script_task::ScriptMsg::{ExitWindowMsg, TriggerLoadMsg, TriggerFragmentMsg}; use script_task::ScriptMsg;
use script_traits::ScriptControlChan; use script_traits::ScriptControlChan;
use timers::{IsInterval, TimerId, TimerManager}; use timers::{IsInterval, TimerId, TimerManager};
@ -191,7 +191,7 @@ impl<'a> WindowMethods for JSRef<'a, Window> {
fn Close(self) { fn Close(self) {
let ScriptChan(ref chan) = self.script_chan; let ScriptChan(ref chan) = self.script_chan;
chan.send(ExitWindowMsg(self.page.id.clone())); chan.send(ScriptMsg::ExitWindow(self.page.id.clone()));
} }
fn Document(self) -> Temporary<Document> { fn Document(self) -> Temporary<Document> {
@ -204,11 +204,11 @@ impl<'a> WindowMethods for JSRef<'a, Window> {
} }
fn SessionStorage(self) -> Temporary<Storage> { fn SessionStorage(self) -> Temporary<Storage> {
self.session_storage.or_init(|| Storage::new(&global::Window(self))) self.session_storage.or_init(|| Storage::new(&GlobalRef::Window(self)))
} }
fn Console(self) -> Temporary<Console> { fn Console(self) -> Temporary<Console> {
self.console.or_init(|| Console::new(global::Window(self))) self.console.or_init(|| Console::new(GlobalRef::Window(self)))
} }
fn Navigator(self) -> Temporary<Navigator> { fn Navigator(self) -> Temporary<Navigator> {
@ -350,15 +350,15 @@ impl<'a> WindowHelpers for JSRef<'a, Window> {
let url = url.unwrap(); let url = url.unwrap();
let ScriptChan(ref script_chan) = self.script_chan; let ScriptChan(ref script_chan) = self.script_chan;
if href.as_slice().starts_with("#") { if href.as_slice().starts_with("#") {
script_chan.send(TriggerFragmentMsg(self.page.id, url)); script_chan.send(ScriptMsg::TriggerFragment(self.page.id, url));
} else { } else {
script_chan.send(TriggerLoadMsg(self.page.id, LoadData::new(url))); script_chan.send(ScriptMsg::TriggerLoad(self.page.id, LoadData::new(url)));
} }
} }
fn handle_fire_timer(self, timer_id: TimerId) { fn handle_fire_timer(self, timer_id: TimerId) {
self.timers.fire_timer(timer_id, self); self.timers.fire_timer(timer_id, self);
self.flush_layout(ReflowForDisplay, NoQuery); self.flush_layout(ReflowGoal::ForDisplay, ReflowQueryType::NoQuery);
} }
} }

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

@ -15,8 +15,7 @@ use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::dedicatedworkerglobalscope::DedicatedWorkerGlobalScope; use dom::dedicatedworkerglobalscope::DedicatedWorkerGlobalScope;
use dom::eventtarget::{EventTarget, EventTargetHelpers, EventTargetTypeId}; use dom::eventtarget::{EventTarget, EventTargetHelpers, EventTargetTypeId};
use dom::messageevent::MessageEvent; use dom::messageevent::MessageEvent;
use script_task::ScriptChan; use script_task::{ScriptChan, ScriptMsg};
use script_task::ScriptMsg::DOMMessage;
use servo_util::str::DOMString; use servo_util::str::DOMString;
@ -147,7 +146,7 @@ impl<'a> WorkerMethods for JSRef<'a, Worker> {
self.addref(); self.addref();
let ScriptChan(ref sender) = self.sender; let ScriptChan(ref sender) = self.sender;
sender.send(DOMMessage(data, nbytes)); sender.send(ScriptMsg::DOMMessage(data, nbytes));
Ok(()) Ok(())
} }

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

@ -6,7 +6,7 @@ use dom::bindings::codegen::Bindings::WorkerGlobalScopeBinding::WorkerGlobalScop
use dom::bindings::codegen::Bindings::FunctionBinding::Function; use dom::bindings::codegen::Bindings::FunctionBinding::Function;
use dom::bindings::error::{ErrorResult, Fallible}; use dom::bindings::error::{ErrorResult, Fallible};
use dom::bindings::error::Error::{Syntax, Network, FailureUnknown}; use dom::bindings::error::Error::{Syntax, Network, FailureUnknown};
use dom::bindings::global; use dom::bindings::global::GlobalRef;
use dom::bindings::js::{MutNullableJS, JSRef, Temporary}; use dom::bindings::js::{MutNullableJS, JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector}; use dom::bindings::utils::{Reflectable, Reflector};
use dom::console::Console; use dom::console::Console;
@ -136,7 +136,7 @@ impl<'a> WorkerGlobalScopeMethods for JSRef<'a, WorkerGlobalScope> {
} }
fn Console(self) -> Temporary<Console> { fn Console(self) -> Temporary<Console> {
self.console.or_init(|| Console::new(global::Worker(self))) self.console.or_init(|| Console::new(GlobalRef::Worker(self)))
} }
fn Btoa(self, btoa: DOMString) -> Fallible<DOMString> { fn Btoa(self, btoa: DOMString) -> Fallible<DOMString> {

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

@ -5,7 +5,7 @@
use dom::bindings::codegen::Bindings::WorkerLocationBinding; use dom::bindings::codegen::Bindings::WorkerLocationBinding;
use dom::bindings::codegen::Bindings::WorkerLocationBinding::WorkerLocationMethods; use dom::bindings::codegen::Bindings::WorkerLocationBinding::WorkerLocationMethods;
use dom::bindings::js::{JSRef, Temporary}; use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::global::Worker; use dom::bindings::global::GlobalRef;
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object}; use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::urlhelper::UrlHelper; use dom::urlhelper::UrlHelper;
use dom::workerglobalscope::WorkerGlobalScope; use dom::workerglobalscope::WorkerGlobalScope;
@ -30,7 +30,7 @@ impl WorkerLocation {
pub fn new(global: JSRef<WorkerGlobalScope>, url: Url) -> Temporary<WorkerLocation> { pub fn new(global: JSRef<WorkerGlobalScope>, url: Url) -> Temporary<WorkerLocation> {
reflect_dom_object(box WorkerLocation::new_inherited(url), reflect_dom_object(box WorkerLocation::new_inherited(url),
Worker(global), GlobalRef::Worker(global),
WorkerLocationBinding::Wrap) WorkerLocationBinding::Wrap)
} }
} }

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

@ -4,7 +4,7 @@
use dom::bindings::codegen::Bindings::WorkerNavigatorBinding; use dom::bindings::codegen::Bindings::WorkerNavigatorBinding;
use dom::bindings::codegen::Bindings::WorkerNavigatorBinding::WorkerNavigatorMethods; use dom::bindings::codegen::Bindings::WorkerNavigatorBinding::WorkerNavigatorMethods;
use dom::bindings::global::Worker; use dom::bindings::global::GlobalRef;
use dom::bindings::js::{JSRef, Temporary}; use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object}; use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::navigatorinfo::NavigatorInfo; use dom::navigatorinfo::NavigatorInfo;
@ -25,7 +25,7 @@ impl WorkerNavigator {
pub fn new(global: JSRef<WorkerGlobalScope>) -> Temporary<WorkerNavigator> { pub fn new(global: JSRef<WorkerGlobalScope>) -> Temporary<WorkerNavigator> {
reflect_dom_object(box WorkerNavigator::new_inherited(), reflect_dom_object(box WorkerNavigator::new_inherited(),
Worker(global), GlobalRef::Worker(global),
WorkerNavigatorBinding::Wrap) WorkerNavigatorBinding::Wrap)
} }
} }

110
components/script/dom/xmlhttprequest.rs
View file

@ -2,11 +2,6 @@
* 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 self::SyncOrAsync::*;
use self::TerminateReason::*;
use self::XHRProgress::*;
use self::XMLHttpRequestState::*;
use dom::bindings::cell::DOMRefCell; use dom::bindings::cell::DOMRefCell;
use dom::bindings::codegen::Bindings::EventHandlerBinding::EventHandlerNonNull; use dom::bindings::codegen::Bindings::EventHandlerBinding::EventHandlerNonNull;
use dom::bindings::codegen::Bindings::XMLHttpRequestBinding; use dom::bindings::codegen::Bindings::XMLHttpRequestBinding;
@ -18,7 +13,7 @@ use dom::bindings::conversions::ToJSValConvertible;
use dom::bindings::error::{Error, ErrorResult, Fallible}; use dom::bindings::error::{Error, ErrorResult, Fallible};
use dom::bindings::error::Error::{InvalidState, InvalidAccess}; use dom::bindings::error::Error::{InvalidState, InvalidAccess};
use dom::bindings::error::Error::{Network, Syntax, Security, Abort, Timeout}; use dom::bindings::error::Error::{Network, Syntax, Security, Abort, Timeout};
use dom::bindings::global::{GlobalField, GlobalRef, WorkerRoot}; use dom::bindings::global::{GlobalField, GlobalRef, GlobalRoot};
use dom::bindings::js::{MutNullableJS, JS, JSRef, Temporary, OptionalRootedRootable}; use dom::bindings::js::{MutNullableJS, JS, JSRef, Temporary, OptionalRootedRootable};
use dom::bindings::str::ByteString; use dom::bindings::str::ByteString;
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object}; use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
@ -30,8 +25,7 @@ use dom::urlsearchparams::URLSearchParamsHelpers;
use dom::xmlhttprequesteventtarget::XMLHttpRequestEventTarget; use dom::xmlhttprequesteventtarget::XMLHttpRequestEventTarget;
use dom::xmlhttprequesteventtarget::XMLHttpRequestEventTargetTypeId; use dom::xmlhttprequesteventtarget::XMLHttpRequestEventTargetTypeId;
use dom::xmlhttprequestupload::XMLHttpRequestUpload; use dom::xmlhttprequestupload::XMLHttpRequestUpload;
use script_task::ScriptChan; use script_task::{ScriptChan, ScriptMsg};
use script_task::ScriptMsg::{XHRProgressMsg, XHRReleaseMsg};
use encoding::all::UTF_8; use encoding::all::UTF_8;
use encoding::label::encoding_from_whatwg_label; use encoding::label::encoding_from_whatwg_label;
@ -85,22 +79,22 @@ pub struct GenerationId(uint);
pub enum XHRProgress { pub enum XHRProgress {
/// Notify that headers have been received /// Notify that headers have been received
HeadersReceivedMsg(GenerationId, Option<Headers>, Option<RawStatus>), HeadersReceived(GenerationId, Option<Headers>, Option<RawStatus>),
/// Partial progress (after receiving headers), containing portion of the response /// Partial progress (after receiving headers), containing portion of the response
LoadingMsg(GenerationId, ByteString), Loading(GenerationId, ByteString),
/// Loading is done /// Loading is done
DoneMsg(GenerationId), Done(GenerationId),
/// There was an error (only Abort, Timeout or Network is used) /// There was an error (only Abort, Timeout or Network is used)
ErroredMsg(GenerationId, Error), Errored(GenerationId, Error),
} }
impl XHRProgress { impl XHRProgress {
fn generation_id(&self) -> GenerationId { fn generation_id(&self) -> GenerationId {
match *self { match *self {
HeadersReceivedMsg(id, _, _) | XHRProgress::HeadersReceived(id, _, _) |
LoadingMsg(id, _) | XHRProgress::Loading(id, _) |
DoneMsg(id) | XHRProgress::Done(id) |
ErroredMsg(id, _) => id XHRProgress::Errored(id, _) => id
} }
} }
} }
@ -152,7 +146,7 @@ impl XMLHttpRequest {
fn new_inherited(global: &GlobalRef) -> XMLHttpRequest { fn new_inherited(global: &GlobalRef) -> XMLHttpRequest {
XMLHttpRequest { XMLHttpRequest {
eventtarget: XMLHttpRequestEventTarget::new_inherited(XMLHttpRequestEventTargetTypeId::XMLHttpRequest), eventtarget: XMLHttpRequestEventTarget::new_inherited(XMLHttpRequestEventTargetTypeId::XMLHttpRequest),
ready_state: Cell::new(Unsent), ready_state: Cell::new(XMLHttpRequestState::Unsent),
timeout: Cell::new(0u32), timeout: Cell::new(0u32),
with_credentials: Cell::new(false), with_credentials: Cell::new(false),
upload: JS::from_rooted(XMLHttpRequestUpload::new(*global)), upload: JS::from_rooted(XMLHttpRequestUpload::new(*global)),
@ -209,12 +203,12 @@ impl XMLHttpRequest {
fn notify_partial_progress(fetch_type: &SyncOrAsync, msg: XHRProgress) { fn notify_partial_progress(fetch_type: &SyncOrAsync, msg: XHRProgress) {
match *fetch_type { match *fetch_type {
Sync(xhr) => { SyncOrAsync::Sync(xhr) => {
xhr.process_partial_response(msg); xhr.process_partial_response(msg);
}, },
Async(addr, script_chan) => { SyncOrAsync::Async(addr, script_chan) => {
let ScriptChan(ref chan) = *script_chan; let ScriptChan(ref chan) = *script_chan;
chan.send(XHRProgressMsg(addr, msg)); chan.send(ScriptMsg::XHRProgress(addr, msg));
} }
} }
} }
@ -222,7 +216,7 @@ impl XMLHttpRequest {
macro_rules! notify_error_and_return( macro_rules! notify_error_and_return(
($err:expr) => ({ ($err:expr) => ({
notify_partial_progress(fetch_type, ErroredMsg(gen_id, $err)); notify_partial_progress(fetch_type, XHRProgress::Errored(gen_id, $err));
return Err($err) return Err($err)
}); });
) )
@ -230,10 +224,10 @@ impl XMLHttpRequest {
macro_rules! terminate( macro_rules! terminate(
($reason:expr) => ( ($reason:expr) => (
match $reason { match $reason {
AbortedOrReopened => { TerminateReason::AbortedOrReopened => {
return Err(Abort) return Err(Abort)
} }
TimedOut => { TerminateReason::TimedOut => {
notify_error_and_return!(Timeout); notify_error_and_return!(Timeout);
} }
} }
@ -292,7 +286,7 @@ impl XMLHttpRequest {
_ => {} _ => {}
}; };
// XXXManishearth Clear cache entries in case of a network error // XXXManishearth Clear cache entries in case of a network error
notify_partial_progress(fetch_type, HeadersReceivedMsg(gen_id, notify_partial_progress(fetch_type, XHRProgress::HeadersReceived(gen_id,
response.metadata.headers.clone(), response.metadata.status.clone())); response.metadata.headers.clone(), response.metadata.status.clone()));
progress_port = response.progress_port; progress_port = response.progress_port;
@ -318,10 +312,10 @@ impl XMLHttpRequest {
Payload(data) => { Payload(data) => {
buf.push_all(data.as_slice()); buf.push_all(data.as_slice());
notify_partial_progress(fetch_type, notify_partial_progress(fetch_type,
LoadingMsg(gen_id, ByteString::new(buf.clone()))); XHRProgress::Loading(gen_id, ByteString::new(buf.clone())));
}, },
Done(Ok(())) => { Done(Ok(())) => {
notify_partial_progress(fetch_type, DoneMsg(gen_id)); notify_partial_progress(fetch_type, XHRProgress::Done(gen_id));
return Ok(()); return Ok(());
}, },
Done(Err(_)) => { Done(Err(_)) => {
@ -390,8 +384,8 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> {
self.status.set(0); self.status.set(0);
// Step 13 // Step 13
if self.ready_state.get() != Opened { if self.ready_state.get() != XMLHttpRequestState::Opened {
self.change_ready_state(Opened); self.change_ready_state(XMLHttpRequestState::Opened);
} }
Ok(()) Ok(())
}, },
@ -406,7 +400,7 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> {
self.Open(method, url) self.Open(method, url)
} }
fn SetRequestHeader(self, name: ByteString, mut value: ByteString) -> ErrorResult { fn SetRequestHeader(self, name: ByteString, mut value: ByteString) -> ErrorResult {
if self.ready_state.get() != Opened || self.send_flag.get() { if self.ready_state.get() != XMLHttpRequestState::Opened || self.send_flag.get() {
return Err(InvalidState); // Step 1, 2 return Err(InvalidState); // Step 1, 2
} }
if !name.is_token() || !value.is_field_value() { if !name.is_token() || !value.is_field_value() {
@ -488,7 +482,7 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> {
Temporary::new(self.upload) Temporary::new(self.upload)
} }
fn Send(self, data: Option<SendParam>) -> ErrorResult { fn Send(self, data: Option<SendParam>) -> ErrorResult {
if self.ready_state.get() != Opened || self.send_flag.get() { if self.ready_state.get() != XMLHttpRequestState::Opened || self.send_flag.get() {
return Err(InvalidState); // Step 1, 2 return Err(InvalidState); // Step 1, 2
} }
@ -609,13 +603,13 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> {
let gen_id = self.generation_id.get(); let gen_id = self.generation_id.get();
if self.sync.get() { if self.sync.get() {
return XMLHttpRequest::fetch(&mut Sync(self), resource_task, load_data, return XMLHttpRequest::fetch(&mut SyncOrAsync::Sync(self), resource_task, load_data,
terminate_receiver, cors_request, gen_id, start_port); terminate_receiver, cors_request, gen_id, start_port);
} else { } else {
self.fetch_time.set(time::now().to_timespec().sec); self.fetch_time.set(time::now().to_timespec().sec);
let script_chan = global.root_ref().script_chan().clone(); let script_chan = global.root_ref().script_chan().clone();
// Pin the object before launching the fetch task. // Pin the object before launching the fetch task.
// The XHRReleaseMsg sent when the fetch task completes will // The `ScriptMsg::XHRRelease` sent when the fetch task completes will
// unpin it. This is to ensure that the object will stay alive // unpin it. This is to ensure that the object will stay alive
// as long as there are (possibly cancelled) inflight events queued up // as long as there are (possibly cancelled) inflight events queued up
// in the script task's port // in the script task's port
@ -623,7 +617,7 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> {
self.to_trusted() self.to_trusted()
}; };
spawn_named("XHRTask", proc() { spawn_named("XHRTask", proc() {
let _ = XMLHttpRequest::fetch(&mut Async(addr, &script_chan), let _ = XMLHttpRequest::fetch(&mut SyncOrAsync::Async(addr, &script_chan),
resource_task, resource_task,
load_data, load_data,
terminate_receiver, terminate_receiver,
@ -631,7 +625,7 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> {
gen_id, gen_id,
start_port); start_port);
let ScriptChan(ref chan) = script_chan; let ScriptChan(ref chan) = script_chan;
chan.send(XHRReleaseMsg(addr)); chan.send(ScriptMsg::XHRRelease(addr));
}); });
let timeout = self.timeout.get(); let timeout = self.timeout.get();
if timeout > 0 { if timeout > 0 {
@ -643,18 +637,18 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> {
fn Abort(self) { fn Abort(self) {
self.terminate_ongoing_fetch(); self.terminate_ongoing_fetch();
let state = self.ready_state.get(); let state = self.ready_state.get();
if (state == Opened && self.send_flag.get()) || if (state == XMLHttpRequestState::Opened && self.send_flag.get()) ||
state == HeadersReceived || state == XMLHttpRequestState::HeadersReceived ||
state == Loading { state == XMLHttpRequestState::Loading {
let gen_id = self.generation_id.get(); let gen_id = self.generation_id.get();
self.process_partial_response(ErroredMsg(gen_id, Abort)); self.process_partial_response(XHRProgress::Errored(gen_id, Abort));
// If open was called in one of the handlers invoked by the // If open was called in one of the handlers invoked by the
// above call then we should terminate the abort sequence // above call then we should terminate the abort sequence
if self.generation_id.get() != gen_id { if self.generation_id.get() != gen_id {
return return
} }
} }
self.ready_state.set(Unsent); self.ready_state.set(XMLHttpRequestState::Unsent);
} }
fn ResponseURL(self) -> DOMString { fn ResponseURL(self) -> DOMString {
self.response_url.clone() self.response_url.clone()
@ -680,12 +674,12 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> {
} }
fn SetResponseType(self, response_type: XMLHttpRequestResponseType) -> ErrorResult { fn SetResponseType(self, response_type: XMLHttpRequestResponseType) -> ErrorResult {
match self.global.root() { match self.global.root() {
WorkerRoot(_) if response_type == XMLHttpRequestResponseType::Document GlobalRoot::Worker(_) if response_type == XMLHttpRequestResponseType::Document
=> return Ok(()), => return Ok(()),
_ => {} _ => {}
} }
match self.ready_state.get() { match self.ready_state.get() {
Loading | XHRDone => Err(InvalidState), XMLHttpRequestState::Loading | XMLHttpRequestState::XHRDone => Err(InvalidState),
_ if self.sync.get() => Err(InvalidAccess), _ if self.sync.get() => Err(InvalidAccess),
_ => { _ => {
self.response_type.set(response_type); self.response_type.set(response_type);
@ -697,13 +691,13 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> {
match self.response_type.get() { match self.response_type.get() {
_empty | Text => { _empty | Text => {
let ready_state = self.ready_state.get(); let ready_state = self.ready_state.get();
if ready_state == XHRDone || ready_state == Loading { if ready_state == XMLHttpRequestState::XHRDone || ready_state == XMLHttpRequestState::Loading {
self.text_response().to_jsval(cx) self.text_response().to_jsval(cx)
} else { } else {
"".to_string().to_jsval(cx) "".to_string().to_jsval(cx)
} }
}, },
_ if self.ready_state.get() != XHRDone => NullValue(), _ if self.ready_state.get() != XMLHttpRequestState::XHRDone => NullValue(),
Json => { Json => {
let decoded = UTF_8.decode(self.response.borrow().as_slice(), DecoderTrap::Replace).unwrap().to_string(); let decoded = UTF_8.decode(self.response.borrow().as_slice(), DecoderTrap::Replace).unwrap().to_string();
let decoded: Vec<u16> = decoded.as_slice().utf16_units().collect(); let decoded: Vec<u16> = decoded.as_slice().utf16_units().collect();
@ -726,7 +720,7 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> {
match self.response_type.get() { match self.response_type.get() {
_empty | Text => { _empty | Text => {
match self.ready_state.get() { match self.ready_state.get() {
Loading | XHRDone => Ok(self.text_response()), XMLHttpRequestState::Loading | XMLHttpRequestState::XHRDone => Ok(self.text_response()),
_ => Ok("".to_string()) _ => Ok("".to_string())
} }
}, },
@ -837,8 +831,8 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
return_if_fetch_was_terminated!(); return_if_fetch_was_terminated!();
match progress { match progress {
HeadersReceivedMsg(_, headers, status) => { XHRProgress::HeadersReceived(_, headers, status) => {
assert!(self.ready_state.get() == Opened); assert!(self.ready_state.get() == XMLHttpRequestState::Opened);
// For synchronous requests, this should not fire any events, and just store data // For synchronous requests, this should not fire any events, and just store data
// XXXManishearth Find a way to track partial progress of the send (onprogresss for XHRUpload) // XXXManishearth Find a way to track partial progress of the send (onprogresss for XHRUpload)
@ -865,26 +859,26 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
// Substep 3 // Substep 3
if !self.sync.get() { if !self.sync.get() {
self.change_ready_state(HeadersReceived); self.change_ready_state(XMLHttpRequestState::HeadersReceived);
} }
}, },
LoadingMsg(_, partial_response) => { XHRProgress::Loading(_, partial_response) => {
// For synchronous requests, this should not fire any events, and just store data // For synchronous requests, this should not fire any events, and just store data
// Part of step 11, send() (processing response body) // Part of step 11, send() (processing response body)
// XXXManishearth handle errors, if any (substep 2) // XXXManishearth handle errors, if any (substep 2)
*self.response.borrow_mut() = partial_response; *self.response.borrow_mut() = partial_response;
if !self.sync.get() { if !self.sync.get() {
if self.ready_state.get() == HeadersReceived { if self.ready_state.get() == XMLHttpRequestState::HeadersReceived {
self.change_ready_state(Loading); self.change_ready_state(XMLHttpRequestState::Loading);
return_if_fetch_was_terminated!(); return_if_fetch_was_terminated!();
} }
self.dispatch_response_progress_event("progress".to_string()); self.dispatch_response_progress_event("progress".to_string());
} }
}, },
DoneMsg(_) => { XHRProgress::Done(_) => {
assert!(self.ready_state.get() == HeadersReceived || assert!(self.ready_state.get() == XMLHttpRequestState::HeadersReceived ||
self.ready_state.get() == Loading || self.ready_state.get() == XMLHttpRequestState::Loading ||
self.sync.get()); self.sync.get());
// Part of step 11, send() (processing response end of file) // Part of step 11, send() (processing response end of file)
@ -892,7 +886,7 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
// Subsubsteps 5-7 // Subsubsteps 5-7
self.send_flag.set(false); self.send_flag.set(false);
self.change_ready_state(XHRDone); self.change_ready_state(XMLHttpRequestState::XHRDone);
return_if_fetch_was_terminated!(); return_if_fetch_was_terminated!();
// Subsubsteps 10-12 // Subsubsteps 10-12
self.dispatch_response_progress_event("progress".to_string()); self.dispatch_response_progress_event("progress".to_string());
@ -901,10 +895,10 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
return_if_fetch_was_terminated!(); return_if_fetch_was_terminated!();
self.dispatch_response_progress_event("loadend".to_string()); self.dispatch_response_progress_event("loadend".to_string());
}, },
ErroredMsg(_, e) => { XHRProgress::Errored(_, e) => {
self.send_flag.set(false); self.send_flag.set(false);
// XXXManishearth set response to NetworkError // XXXManishearth set response to NetworkError
self.change_ready_state(XHRDone); self.change_ready_state(XMLHttpRequestState::XHRDone);
return_if_fetch_was_terminated!(); return_if_fetch_was_terminated!();
let errormsg = match e { let errormsg = match e {
@ -935,7 +929,7 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
fn terminate_ongoing_fetch(self) { fn terminate_ongoing_fetch(self) {
let GenerationId(prev_id) = self.generation_id.get(); let GenerationId(prev_id) = self.generation_id.get();
self.generation_id.set(GenerationId(prev_id + 1)); self.generation_id.set(GenerationId(prev_id + 1));
self.terminate_sender.borrow().as_ref().map(|s| s.send_opt(AbortedOrReopened)); self.terminate_sender.borrow().as_ref().map(|s| s.send_opt(TerminateReason::AbortedOrReopened));
} }
fn insert_trusted_header(self, name: String, value: String) { fn insert_trusted_header(self, name: String, value: String) {
@ -981,7 +975,7 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
spawn_named("XHR:Timer", proc () { spawn_named("XHR:Timer", proc () {
match oneshot.recv_opt() { match oneshot.recv_opt() {
Ok(_) => { Ok(_) => {
terminate_sender.map(|s| s.send_opt(TimedOut)); terminate_sender.map(|s| s.send_opt(TerminateReason::TimedOut));
}, },
Err(_) => { Err(_) => {
// This occurs if xhr.timeout (the sender) goes out of scope (i.e, xhr went out of scope) // This occurs if xhr.timeout (the sender) goes out of scope (i.e, xhr went out of scope)

24
components/script/layout_interface.rs
View file

@ -6,10 +6,6 @@
/// coupling between these two components, and enables the DOM to be placed in a separate crate /// coupling between these two components, and enables the DOM to be placed in a separate crate
/// from layout. /// from layout.
pub use self::Msg::*;
pub use self::ReflowGoal::*;
pub use self::ReflowQueryType::*;
use dom::node::LayoutDataRef; use dom::node::LayoutDataRef;
use geom::point::Point2D; use geom::point::Point2D;
@ -28,33 +24,33 @@ pub use dom::node::TrustedNodeAddress;
/// Asynchronous messages that script can send to layout. /// Asynchronous messages that script can send to layout.
pub enum Msg { pub enum Msg {
/// Adds the given stylesheet to the document. /// Adds the given stylesheet to the document.
AddStylesheetMsg(Stylesheet), AddStylesheet(Stylesheet),
/// Adds the given stylesheet to the document. /// Adds the given stylesheet to the document.
LoadStylesheetMsg(Url), LoadStylesheet(Url),
/// Puts a document into quirks mode, causing the quirks mode stylesheet to be loaded. /// Puts a document into quirks mode, causing the quirks mode stylesheet to be loaded.
SetQuirksModeMsg, SetQuirksMode,
/// Requests a reflow. /// Requests a reflow.
ReflowMsg(Box<Reflow>), Reflow(Box<Reflow>),
/// Get an RPC interface. /// Get an RPC interface.
GetRPCMsg(Sender<Box<LayoutRPC + Send>>), GetRPC(Sender<Box<LayoutRPC + Send>>),
/// Destroys layout data associated with a DOM node. /// Destroys layout data associated with a DOM node.
/// ///
/// TODO(pcwalton): Maybe think about batching to avoid message traffic. /// TODO(pcwalton): Maybe think about batching to avoid message traffic.
ReapLayoutDataMsg(LayoutDataRef), ReapLayoutData(LayoutDataRef),
/// Requests that the layout task enter a quiescent state in which no more messages are /// Requests that the layout task enter a quiescent state in which no more messages are
/// accepted except `ExitMsg`. A response message will be sent on the supplied channel when /// accepted except `ExitMsg`. A response message will be sent on the supplied channel when
/// this happens. /// this happens.
PrepareToExitMsg(Sender<()>), PrepareToExit(Sender<()>),
/// Requests that the layout task immediately shut down. There must be no more nodes left after /// Requests that the layout task immediately shut down. There must be no more nodes left after
/// this, or layout will crash. /// this, or layout will crash.
ExitNowMsg, ExitNow,
} }
/// Synchronous messages that script can send to layout. /// Synchronous messages that script can send to layout.
@ -84,9 +80,9 @@ pub struct MouseOverResponse(pub Vec<UntrustedNodeAddress>);
#[deriving(PartialEq, Show)] #[deriving(PartialEq, Show)]
pub enum ReflowGoal { pub enum ReflowGoal {
/// We're reflowing in order to send a display list to the screen. /// We're reflowing in order to send a display list to the screen.
ReflowForDisplay, ForDisplay,
/// We're reflowing in order to satisfy a script query. No display list will be created. /// We're reflowing in order to satisfy a script query. No display list will be created.
ReflowForScriptQuery, ForScriptQuery,
} }
/// Any query to perform with this reflow. /// Any query to perform with this reflow.

14
components/script/page.rs
View file

@ -12,9 +12,9 @@ use dom::element::Element;
use dom::node::{Node, NodeHelpers}; use dom::node::{Node, NodeHelpers};
use dom::window::Window; use dom::window::Window;
use layout_interface::{ use layout_interface::{
ContentBoxQuery, ContentBoxResponse, ContentBoxesQuery, ContentBoxesResponse, ContentBoxResponse, ContentBoxesResponse,
GetRPCMsg, HitTestResponse, LayoutChan, LayoutRPC, MouseOverResponse, Reflow, HitTestResponse, LayoutChan, LayoutRPC, MouseOverResponse, Msg, Reflow,
ReflowForScriptQuery, ReflowGoal, ReflowMsg, ReflowQueryType, ReflowGoal, ReflowQueryType,
TrustedNodeAddress TrustedNodeAddress
}; };
use script_traits::{UntrustedNodeAddress, ScriptControlChan}; use script_traits::{UntrustedNodeAddress, ScriptControlChan};
@ -138,7 +138,7 @@ impl Page {
let layout_rpc: Box<LayoutRPC> = { let layout_rpc: Box<LayoutRPC> = {
let (rpc_send, rpc_recv) = channel(); let (rpc_send, rpc_recv) = channel();
let LayoutChan(ref lchan) = layout_chan; let LayoutChan(ref lchan) = layout_chan;
lchan.send(GetRPCMsg(rpc_send)); lchan.send(Msg::GetRPC(rpc_send));
rpc_recv.recv() rpc_recv.recv()
}; };
Page { Page {
@ -174,14 +174,14 @@ impl Page {
} }
pub fn content_box_query(&self, content_box_request: TrustedNodeAddress) -> Rect<Au> { pub fn content_box_query(&self, content_box_request: TrustedNodeAddress) -> Rect<Au> {
self.flush_layout(ReflowForScriptQuery, ContentBoxQuery(content_box_request)); self.flush_layout(ReflowGoal::ForScriptQuery, ReflowQueryType::ContentBoxQuery(content_box_request));
self.join_layout(); //FIXME: is this necessary, or is layout_rpc's mutex good enough? self.join_layout(); //FIXME: is this necessary, or is layout_rpc's mutex good enough?
let ContentBoxResponse(rect) = self.layout_rpc.content_box(); let ContentBoxResponse(rect) = self.layout_rpc.content_box();
rect rect
} }
pub fn content_boxes_query(&self, content_boxes_request: TrustedNodeAddress) -> Vec<Rect<Au>> { pub fn content_boxes_query(&self, content_boxes_request: TrustedNodeAddress) -> Vec<Rect<Au>> {
self.flush_layout(ReflowForScriptQuery, ContentBoxesQuery(content_boxes_request)); self.flush_layout(ReflowGoal::ForScriptQuery, ReflowQueryType::ContentBoxesQuery(content_boxes_request));
self.join_layout(); //FIXME: is this necessary, or is layout_rpc's mutex good enough? self.join_layout(); //FIXME: is this necessary, or is layout_rpc's mutex good enough?
let ContentBoxesResponse(rects) = self.layout_rpc.content_boxes(); let ContentBoxesResponse(rects) = self.layout_rpc.content_boxes();
rects rects
@ -391,7 +391,7 @@ impl Page {
}; };
let LayoutChan(ref chan) = self.layout_chan; let LayoutChan(ref chan) = self.layout_chan;
chan.send(ReflowMsg(reflow)); chan.send(Msg::Reflow(reflow));
debug!("script: layout forked"); debug!("script: layout forked");

62
components/script/script_task.rs
View file

@ -5,8 +5,6 @@
//! The script task is the task that owns the DOM in memory, runs JavaScript, and spawns parsing //! The script task is the task that owns the DOM in memory, runs JavaScript, and spawns parsing
//! and layout tasks. //! and layout tasks.
use self::ScriptMsg::*;
use dom::bindings::cell::DOMRefCell; use dom::bindings::cell::DOMRefCell;
use dom::bindings::codegen::Bindings::DocumentBinding::{DocumentMethods, DocumentReadyState}; use dom::bindings::codegen::Bindings::DocumentBinding::{DocumentMethods, DocumentReadyState};
use dom::bindings::codegen::Bindings::EventBinding::EventMethods; use dom::bindings::codegen::Bindings::EventBinding::EventMethods;
@ -15,7 +13,7 @@ use dom::bindings::codegen::Bindings::WindowBinding::WindowMethods;
use dom::bindings::codegen::InheritTypes::{ElementCast, EventTargetCast, NodeCast, EventCast}; use dom::bindings::codegen::InheritTypes::{ElementCast, EventTargetCast, NodeCast, EventCast};
use dom::bindings::conversions::FromJSValConvertible; use dom::bindings::conversions::FromJSValConvertible;
use dom::bindings::conversions::StringificationBehavior; use dom::bindings::conversions::StringificationBehavior;
use dom::bindings::global; use dom::bindings::global::GlobalRef;
use dom::bindings::js::{JS, JSRef, RootCollection, Temporary, OptionalRootable}; use dom::bindings::js::{JS, JSRef, RootCollection, Temporary, OptionalRootable};
use dom::bindings::trace::JSTraceable; use dom::bindings::trace::JSTraceable;
use dom::bindings::utils::{wrap_for_same_compartment, pre_wrap}; use dom::bindings::utils::{wrap_for_same_compartment, pre_wrap};
@ -30,7 +28,7 @@ use dom::window::{Window, WindowHelpers};
use dom::worker::{Worker, TrustedWorkerAddress}; use dom::worker::{Worker, TrustedWorkerAddress};
use dom::xmlhttprequest::{TrustedXHRAddress, XMLHttpRequest, XHRProgress}; use dom::xmlhttprequest::{TrustedXHRAddress, XMLHttpRequest, XHRProgress};
use parse::html::{HTMLInput, parse_html}; use parse::html::{HTMLInput, parse_html};
use layout_interface::{ScriptLayoutChan, LayoutChan, NoQuery, ReflowForDisplay}; use layout_interface::{ScriptLayoutChan, LayoutChan, ReflowGoal, ReflowQueryType};
use layout_interface; use layout_interface;
use page::{Page, IterablePage, Frame}; use page::{Page, IterablePage, Frame};
use timers::TimerId; use timers::TimerId;
@ -93,24 +91,24 @@ pub enum TimerSource {
pub enum ScriptMsg { pub enum ScriptMsg {
/// Acts on a fragment URL load on the specified pipeline (only dispatched /// Acts on a fragment URL load on the specified pipeline (only dispatched
/// to ScriptTask). /// to ScriptTask).
TriggerFragmentMsg(PipelineId, Url), TriggerFragment(PipelineId, Url),
/// Begins a content-initiated load on the specified pipeline (only /// Begins a content-initiated load on the specified pipeline (only
/// dispatched to ScriptTask). /// dispatched to ScriptTask).
TriggerLoadMsg(PipelineId, LoadData), TriggerLoad(PipelineId, LoadData),
/// Instructs the script task to send a navigate message to /// Instructs the script task to send a navigate message to
/// the constellation (only dispatched to ScriptTask). /// the constellation (only dispatched to ScriptTask).
NavigateMsg(NavigationDirection), Navigate(NavigationDirection),
/// Fires a JavaScript timeout /// Fires a JavaScript timeout
/// TimerSource must be FromWindow when dispatched to ScriptTask and /// TimerSource must be FromWindow when dispatched to ScriptTask and
/// must be FromWorker when dispatched to a DedicatedGlobalWorkerScope /// must be FromWorker when dispatched to a DedicatedGlobalWorkerScope
FireTimerMsg(TimerSource, TimerId), FireTimer(TimerSource, TimerId),
/// Notifies the script that a window associated with a particular pipeline /// Notifies the script that a window associated with a particular pipeline
/// should be closed (only dispatched to ScriptTask). /// should be closed (only dispatched to ScriptTask).
ExitWindowMsg(PipelineId), ExitWindow(PipelineId),
/// Notifies the script of progress on a fetch (dispatched to all tasks). /// Notifies the script of progress on a fetch (dispatched to all tasks).
XHRProgressMsg(TrustedXHRAddress, XHRProgress), XHRProgress(TrustedXHRAddress, XHRProgress),
/// Releases one reference to the XHR object (dispatched to all tasks). /// Releases one reference to the XHR object (dispatched to all tasks).
XHRReleaseMsg(TrustedXHRAddress), XHRRelease(TrustedXHRAddress),
/// Message sent through Worker.postMessage (only dispatched to /// Message sent through Worker.postMessage (only dispatched to
/// DedicatedWorkerGlobalScope). /// DedicatedWorkerGlobalScope).
DOMMessage(*mut u64, size_t), DOMMessage(*mut u64, size_t),
@ -561,27 +559,27 @@ impl ScriptTask {
fn handle_msg_from_script(&self, msg: ScriptMsg) { fn handle_msg_from_script(&self, msg: ScriptMsg) {
match msg { match msg {
TriggerLoadMsg(id, load_data) => ScriptMsg::TriggerLoad(id, load_data) =>
self.trigger_load(id, load_data), self.trigger_load(id, load_data),
TriggerFragmentMsg(id, url) => ScriptMsg::TriggerFragment(id, url) =>
self.trigger_fragment(id, url), self.trigger_fragment(id, url),
FireTimerMsg(TimerSource::FromWindow(id), timer_id) => ScriptMsg::FireTimer(TimerSource::FromWindow(id), timer_id) =>
self.handle_fire_timer_msg(id, timer_id), self.handle_fire_timer_msg(id, timer_id),
FireTimerMsg(TimerSource::FromWorker, _) => ScriptMsg::FireTimer(TimerSource::FromWorker, _) =>
panic!("Worker timeouts must not be sent to script task"), panic!("Worker timeouts must not be sent to script task"),
NavigateMsg(direction) => ScriptMsg::Navigate(direction) =>
self.handle_navigate_msg(direction), self.handle_navigate_msg(direction),
ExitWindowMsg(id) => ScriptMsg::ExitWindow(id) =>
self.handle_exit_window_msg(id), self.handle_exit_window_msg(id),
XHRProgressMsg(addr, progress) => ScriptMsg::XHRProgress(addr, progress) =>
XMLHttpRequest::handle_progress(addr, progress), XMLHttpRequest::handle_progress(addr, progress),
XHRReleaseMsg(addr) => ScriptMsg::XHRRelease(addr) =>
XMLHttpRequest::handle_release(addr), XMLHttpRequest::handle_release(addr),
DOMMessage(..) => ScriptMsg::DOMMessage(..) =>
panic!("unexpected message"), panic!("unexpected message"),
WorkerPostMessage(addr, data, nbytes) => ScriptMsg::WorkerPostMessage(addr, data, nbytes) =>
Worker::handle_message(addr, data, nbytes), Worker::handle_message(addr, data, nbytes),
WorkerRelease(addr) => ScriptMsg::WorkerRelease(addr) =>
Worker::handle_release(addr), Worker::handle_release(addr),
} }
} }
@ -826,7 +824,7 @@ impl ScriptTask {
let document_as_node = NodeCast::from_ref(document_js_ref); let document_as_node = NodeCast::from_ref(document_js_ref);
document.content_changed(document_as_node, NodeDamage::OtherNodeDamage); document.content_changed(document_as_node, NodeDamage::OtherNodeDamage);
} }
window.flush_layout(ReflowForDisplay, NoQuery); window.flush_layout(ReflowGoal::ForDisplay, ReflowQueryType::NoQuery);
{ {
// No more reflow required // No more reflow required
@ -835,7 +833,7 @@ impl ScriptTask {
} }
// https://html.spec.whatwg.org/multipage/#the-end step 4 // https://html.spec.whatwg.org/multipage/#the-end step 4
let event = Event::new(global::Window(*window), "DOMContentLoaded".to_string(), let event = Event::new(GlobalRef::Window(*window), "DOMContentLoaded".to_string(),
EventBubbles::DoesNotBubble, EventBubbles::DoesNotBubble,
EventCancelable::NotCancelable).root(); EventCancelable::NotCancelable).root();
let doctarget: JSRef<EventTarget> = EventTargetCast::from_ref(*document); let doctarget: JSRef<EventTarget> = EventTargetCast::from_ref(*document);
@ -848,7 +846,7 @@ impl ScriptTask {
// https://html.spec.whatwg.org/multipage/#the-end step 7 // https://html.spec.whatwg.org/multipage/#the-end step 7
document.set_ready_state(DocumentReadyState::Complete); document.set_ready_state(DocumentReadyState::Complete);
let event = Event::new(global::Window(*window), "load".to_string(), let event = Event::new(GlobalRef::Window(*window), "load".to_string(),
EventBubbles::DoesNotBubble, EventBubbles::DoesNotBubble,
EventCancelable::NotCancelable).root(); EventCancelable::NotCancelable).root();
let wintarget: JSRef<EventTarget> = EventTargetCast::from_ref(*window); let wintarget: JSRef<EventTarget> = EventTargetCast::from_ref(*window);
@ -888,10 +886,10 @@ impl ScriptTask {
/// Reflows non-incrementally. /// Reflows non-incrementally.
fn force_reflow(&self, page: &Page) { fn force_reflow(&self, page: &Page) {
page.dirty_all_nodes(); page.dirty_all_nodes();
page.reflow(ReflowForDisplay, page.reflow(ReflowGoal::ForDisplay,
self.control_chan.clone(), self.control_chan.clone(),
&mut **self.compositor.borrow_mut(), &mut **self.compositor.borrow_mut(),
NoQuery); ReflowQueryType::NoQuery);
} }
/// This is the main entry point for receiving and dispatching DOM events. /// This is the main entry point for receiving and dispatching DOM events.
@ -1019,7 +1017,7 @@ impl ScriptTask {
_ => () _ => ()
} }
window.flush_layout(ReflowForDisplay, NoQuery); window.flush_layout(ReflowGoal::ForDisplay, ReflowQueryType::NoQuery);
} }
/// The entry point for content to notify that a new load has been requested /// The entry point for content to notify that a new load has been requested
@ -1121,7 +1119,7 @@ impl ScriptTask {
doc.begin_focus_transaction(); doc.begin_focus_transaction();
let event = let event =
Event::new(global::Window(*window), Event::new(GlobalRef::Window(*window),
"click".to_string(), "click".to_string(),
EventBubbles::Bubbles, EventBubbles::Bubbles,
EventCancelable::Cancelable).root(); EventCancelable::Cancelable).root();
@ -1132,7 +1130,7 @@ impl ScriptTask {
el.authentic_click_activation(*event); el.authentic_click_activation(*event);
doc.commit_focus_transaction(); doc.commit_focus_transaction();
window.flush_layout(ReflowForDisplay, NoQuery); window.flush_layout(ReflowGoal::ForDisplay, ReflowQueryType::NoQuery);
} }
None => {} None => {}
} }
@ -1213,7 +1211,7 @@ fn shut_down_layout(page_tree: &Rc<Page>, rt: *mut JSRuntime) {
// processed this message. // processed this message.
let (response_chan, response_port) = channel(); let (response_chan, response_port) = channel();
let LayoutChan(ref chan) = page.layout_chan; let LayoutChan(ref chan) = page.layout_chan;
chan.send(layout_interface::PrepareToExitMsg(response_chan)); chan.send(layout_interface::Msg::PrepareToExit(response_chan));
response_port.recv(); response_port.recv();
} }
@ -1236,7 +1234,7 @@ fn shut_down_layout(page_tree: &Rc<Page>, rt: *mut JSRuntime) {
// Destroy the layout task. If there were node leaks, layout will now crash safely. // Destroy the layout task. If there were node leaks, layout will now crash safely.
for page in page_tree.iter() { for page in page_tree.iter() {
let LayoutChan(ref chan) = page.layout_chan; let LayoutChan(ref chan) = page.layout_chan;
chan.send(layout_interface::ExitNowMsg); chan.send(layout_interface::Msg::ExitNow);
} }
} }

7
components/script/timers.rs
View file

@ -8,8 +8,7 @@ use dom::bindings::codegen::Bindings::FunctionBinding::Function;
use dom::bindings::js::JSRef; use dom::bindings::js::JSRef;
use dom::bindings::utils::Reflectable; use dom::bindings::utils::Reflectable;
use script_task::{ScriptChan, TimerSource}; use script_task::{ScriptChan, ScriptMsg, TimerSource};
use script_task::ScriptMsg::FireTimerMsg;
use servo_util::task::spawn_named; use servo_util::task::spawn_named;
@ -107,7 +106,7 @@ impl TimerManager {
let handle = self.next_timer_handle.get(); let handle = self.next_timer_handle.get();
self.next_timer_handle.set(handle + 1); self.next_timer_handle.set(handle + 1);
// Spawn a new timer task; it will dispatch the FireTimerMsg // Spawn a new timer task; it will dispatch the `ScriptMsg::FireTimer`
// to the relevant script handler that will deal with it. // to the relevant script handler that will deal with it.
let tm = Timer::new().unwrap(); let tm = Timer::new().unwrap();
let (cancel_chan, cancel_port) = channel(); let (cancel_chan, cancel_port) = channel();
@ -138,7 +137,7 @@ impl TimerManager {
if id == timeout_handle.id() { if id == timeout_handle.id() {
timeout_port.recv(); timeout_port.recv();
let ScriptChan(ref chan) = script_chan; let ScriptChan(ref chan) = script_chan;
chan.send(FireTimerMsg(source, TimerId(handle))); chan.send(ScriptMsg::FireTimer(source, TimerId(handle)));
if is_interval == IsInterval::NonInterval { if is_interval == IsInterval::NonInterval {
break; break;
} }