Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-06-06 16:45:39 +00: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::node::{LayoutDataRef, Node, NodeTypeId};
use script::dom::element::ElementTypeId;
use script::layout_interface::{AddStylesheetMsg, ContentBoxResponse, ContentBoxesResponse};
use script::layout_interface::{ContentBoxesQuery, ContentBoxQuery, ExitNowMsg, GetRPCMsg};
use script::layout_interface::{HitTestResponse, LayoutChan, LayoutRPC, LoadStylesheetMsg};
use script::layout_interface::{MouseOverResponse, Msg, NoQuery, PrepareToExitMsg};
use script::layout_interface::{ReapLayoutDataMsg, Reflow, ReflowForDisplay, ReflowMsg};
use script::layout_interface::{ReflowForScriptQuery, ScriptLayoutChan, SetQuirksModeMsg};
use script::layout_interface::{TrustedNodeAddress};
use script::layout_interface::{ContentBoxResponse, ContentBoxesResponse};
use script::layout_interface::{ContentBoxesQuery, ContentBoxQuery};
use script::layout_interface::{HitTestResponse, LayoutChan, LayoutRPC};
use script::layout_interface::{MouseOverResponse, Msg, NoQuery};
use script::layout_interface::{Reflow, ReflowGoal, ScriptLayoutChan, TrustedNodeAddress};
use script_traits::{SendEventMsg, ReflowEvent, ReflowCompleteMsg, OpaqueScriptLayoutChannel};
use script_traits::{ScriptControlChan, UntrustedNodeAddress};
use servo_msg::compositor_msg::Scrollable;
@ -346,7 +344,7 @@ impl LayoutTask {
PortToRead::Pipeline => {
match self.pipeline_port.recv() {
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>>)
-> bool {
match request {
AddStylesheetMsg(sheet) => self.handle_add_stylesheet(sheet, possibly_locked_rw_data),
LoadStylesheetMsg(url) => self.handle_load_stylesheet(url, possibly_locked_rw_data),
SetQuirksModeMsg => self.handle_set_quirks_mode(possibly_locked_rw_data),
GetRPCMsg(response_chan) => {
Msg::AddStylesheet(sheet) => self.handle_add_stylesheet(sheet, possibly_locked_rw_data),
Msg::LoadStylesheet(url) => self.handle_load_stylesheet(url, possibly_locked_rw_data),
Msg::SetQuirksMode => self.handle_set_quirks_mode(possibly_locked_rw_data),
Msg::GetRPC(response_chan) => {
response_chan.send(box LayoutRPCImpl(self.rw_data.clone()) as
Box<LayoutRPC + Send>);
},
ReflowMsg(data) => {
Msg::Reflow(data) => {
profile(time::LayoutPerformCategory,
self.profiler_metadata(&*data),
self.time_profiler_chan.clone(),
|| self.handle_reflow(&*data, possibly_locked_rw_data));
},
ReapLayoutDataMsg(dead_layout_data) => {
Msg::ReapLayoutData(dead_layout_data) => {
unsafe {
LayoutTask::handle_reap_layout_data(dead_layout_data)
}
},
PrepareToExitMsg(response_chan) => {
Msg::PrepareToExit(response_chan) => {
debug!("layout: PrepareToExitMsg received");
self.prepare_to_exit(response_chan, possibly_locked_rw_data);
return false
},
ExitNowMsg => {
Msg::ExitNow => {
debug!("layout: ExitNowMsg received");
self.exit_now(possibly_locked_rw_data);
return false
@ -423,7 +421,7 @@ impl LayoutTask {
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
/// response channel.
fn prepare_to_exit<'a>(&'a self,
@ -432,12 +430,12 @@ impl LayoutTask {
response_chan.send(());
loop {
match self.port.recv() {
ReapLayoutDataMsg(dead_layout_data) => {
Msg::ReapLayoutData(dead_layout_data) => {
unsafe {
LayoutTask::handle_reap_layout_data(dead_layout_data)
}
}
ExitNowMsg => {
Msg::ExitNow => {
debug!("layout task is exiting...");
self.exit_now(possibly_locked_rw_data);
break
@ -830,14 +828,14 @@ impl LayoutTask {
// Build the display list if necessary, and send it to the painter.
match data.goal {
ReflowForDisplay => {
ReflowGoal::ForDisplay => {
self.build_display_list_for_reflow(data,
node,
&mut layout_root,
&mut shared_layout_context,
&mut rw_data);
}
ReflowForScriptQuery => {}
ReflowGoal::ForScriptQuery => {}
}
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::AttrMethods;
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::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::element::{Element, AttributeHandlers};
@ -110,7 +110,7 @@ impl Attr {
name: Atom, namespace: Namespace,
prefix: Option<DOMString>, owner: Option<JSRef<Element>>) -> Temporary<Attr> {
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]

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

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

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

@ -29,7 +29,7 @@ use dom::htmlformelement::HTMLFormElement;
use dom::htmlframeelement::HTMLFrameElement;
use dom::htmlframesetelement::HTMLFrameSetElement;
use dom::htmlheadelement::HTMLHeadElement;
use dom::htmlheadingelement::HeadingLevel::*;
use dom::htmlheadingelement::HeadingLevel;
use dom::htmlheadingelement::HTMLHeadingElement;
use dom::htmlhrelement::HTMLHRElement;
use dom::htmlhtmlelement::HTMLHtmlElement;
@ -142,12 +142,12 @@ pub fn create_element(name: QualName, prefix: Option<DOMString>,
atom!("form") => make!(HTMLFormElement),
atom!("frame") => make!(HTMLFrameElement),
atom!("frameset") => make!(HTMLFrameSetElement),
atom!("h1") => make!(HTMLHeadingElement, Heading1),
atom!("h2") => make!(HTMLHeadingElement, Heading2),
atom!("h3") => make!(HTMLHeadingElement, Heading3),
atom!("h4") => make!(HTMLHeadingElement, Heading4),
atom!("h5") => make!(HTMLHeadingElement, Heading5),
atom!("h6") => make!(HTMLHeadingElement, Heading6),
atom!("h1") => make!(HTMLHeadingElement, HeadingLevel::Heading1),
atom!("h2") => make!(HTMLHeadingElement, HeadingLevel::Heading2),
atom!("h3") => make!(HTMLHeadingElement, HeadingLevel::Heading3),
atom!("h4") => make!(HTMLHeadingElement, HeadingLevel::Heading4),
atom!("h5") => make!(HTMLHeadingElement, HeadingLevel::Heading5),
atom!("h6") => make!(HTMLHeadingElement, HeadingLevel::Heading6),
atom!("head") => make!(HTMLHeadElement),
atom!("header") => 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::InheritTypes::{NodeCast, ElementCast};
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::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::document::DocumentHelpers;
@ -62,7 +62,7 @@ impl CSSStyleDeclaration {
pub fn new(global: JSRef<Window>, owner: JSRef<HTMLElement>) -> Temporary<CSSStyleDeclaration> {
reflect_dom_object(box CSSStyleDeclaration::new_inherited(owner),
global::Window(global),
GlobalRef::Window(global),
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::error::ErrorResult;
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::utils::{Reflectable, Reflector};
use dom::eventtarget::{EventTarget, EventTargetHelpers, EventTargetTypeId};
@ -19,8 +19,6 @@ use dom::workerglobalscope::{WorkerGlobalScope, WorkerGlobalScopeHelpers};
use dom::workerglobalscope::WorkerGlobalScopeTypeId;
use dom::xmlhttprequest::XMLHttpRequest;
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 servo_net::resource_task::{ResourceTask, load_whole_resource};
@ -121,7 +119,7 @@ impl DedicatedWorkerGlobalScope {
EventTargetCast::from_ref(*global);
loop {
match global.receiver.recv_opt() {
Ok(DOMMessage(data, nbytes)) => {
Ok(ScriptMsg::DOMMessage(data, nbytes)) => {
let mut message = UndefinedValue();
unsafe {
assert!(JS_ReadStructuredClone(
@ -130,22 +128,22 @@ impl DedicatedWorkerGlobalScope {
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();
},
Ok(XHRProgressMsg(addr, progress)) => {
Ok(ScriptMsg::XHRProgress(addr, progress)) => {
XMLHttpRequest::handle_progress(addr, progress)
},
Ok(XHRReleaseMsg(addr)) => {
Ok(ScriptMsg::XHRRelease(addr)) => {
XMLHttpRequest::handle_release(addr)
},
Ok(WorkerPostMessage(addr, data, nbytes)) => {
Ok(ScriptMsg::WorkerPostMessage(addr, data, nbytes)) => {
Worker::handle_message(addr, data, nbytes);
},
Ok(WorkerRelease(addr)) => {
Ok(ScriptMsg::WorkerRelease(addr)) => {
Worker::handle_release(addr)
},
Ok(FireTimerMsg(TimerSource::FromWorker, timer_id)) => {
Ok(ScriptMsg::FireTimer(TimerSource::FromWorker, timer_id)) => {
scope.handle_fire_timer(timer_id);
}
Ok(_) => panic!("Unexpected message"),
@ -170,7 +168,7 @@ impl<'a> DedicatedWorkerGlobalScopeMethods for JSRef<'a, DedicatedWorkerGlobalSc
}
let ScriptChan(ref sender) = self.parent_sender;
sender.send(WorkerPostMessage(self.worker, data, nbytes));
sender.send(ScriptMsg::WorkerPostMessage(self.worker, data, nbytes));
Ok(())
}
@ -184,7 +182,7 @@ trait PrivateDedicatedWorkerGlobalScopeHelpers {
impl<'a> PrivateDedicatedWorkerGlobalScopeHelpers for JSRef<'a, DedicatedWorkerGlobalScope> {
fn delayed_release_worker(self) {
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::{HierarchyRequest, NamespaceError};
use dom::bindings::global::GlobalRef;
use dom::bindings::global;
use dom::bindings::js::{MutNullableJS, JS, JSRef, Temporary, OptionalSettable, TemporaryPushable};
use dom::bindings::js::OptionalRootable;
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 html5ever::tree_builder::{QuirksMode, NoQuirks, LimitedQuirks, Quirks};
use layout_interface::{LayoutChan, SetQuirksModeMsg};
use layout_interface::{LayoutChan, Msg};
use string_cache::{Atom, QualName};
use url::Url;
@ -222,7 +221,7 @@ impl<'a> DocumentHelpers<'a> for JSRef<'a, Document> {
Quirks => {
let window = self.window.root();
let LayoutChan(ref layout_chan) = window.page().layout_chan;
layout_chan.send(SetQuirksModeMsg);
layout_chan.send(Msg::SetQuirksMode);
}
NoQuirks | LimitedQuirks => {}
}
@ -339,7 +338,7 @@ impl<'a> DocumentHelpers<'a> for JSRef<'a, Document> {
self.ready_state.set(state);
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,
EventCancelable::NotCancelable).root();
let target: JSRef<EventTarget> = EventTargetCast::from_ref(self);
@ -464,7 +463,7 @@ impl Document {
source: DocumentSource) -> Temporary<Document> {
let document = reflect_dom_object(box Document::new_inherited(window, url, doctype,
content_type, source),
global::Window(window),
GlobalRef::Window(window),
DocumentBinding::Wrap).root();
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(
MouseEvent::new_uninitialized(*window))),
"customevent" => Ok(EventCast::from_temporary(
CustomEvent::new_uninitialized(global::Window(*window)))),
CustomEvent::new_uninitialized(GlobalRef::Window(*window)))),
"htmlevents" | "events" | "event" => Ok(Event::new_uninitialized(
global::Window(*window))),
GlobalRef::Window(*window))),
"keyboardevent" | "keyevents" => Ok(EventCast::from_temporary(
KeyboardEvent::new_uninitialized(*window))),
"messageevent" => Ok(EventCast::from_temporary(
MessageEvent::new_uninitialized(global::Window(*window)))),
MessageEvent::new_uninitialized(GlobalRef::Window(*window)))),
_ => 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::error::Fallible;
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::utils::{Reflector, Reflectable, reflect_dom_object};
use dom::bindings::utils::xml_name_type;
@ -42,7 +42,7 @@ impl DOMImplementation {
pub fn new(document: JSRef<Document>) -> Temporary<DOMImplementation> {
let window = document.window().root();
reflect_dom_object(box DOMImplementation::new_inherited(document),
Window(*window),
GlobalRef::Window(*window),
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::Error::FailureUnknown;
use dom::bindings::global::GlobalRef;
use dom::bindings::global;
use dom::bindings::js::{JS, JSRef, Temporary};
use dom::bindings::utils::{Reflector, Reflectable, reflect_dom_object};
use dom::document::{Document, DocumentHelpers, IsHTMLDocument};
@ -33,7 +32,7 @@ impl 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)
}

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

@ -4,7 +4,7 @@
use dom::bindings::codegen::Bindings::DOMRectBinding;
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::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::window::Window;
@ -36,7 +36,7 @@ impl DOMRect {
top: Au, bottom: Au,
left: Au, right: Au) -> Temporary<DOMRect> {
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::DOMRectListMethods;
use dom::bindings::global;
use dom::bindings::global::GlobalRef;
use dom::bindings::js::{JS, JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::domrect::DOMRect;
@ -31,7 +31,7 @@ impl DOMRectList {
pub fn new(window: JSRef<Window>,
rects: Vec<JSRef<DOMRect>>) -> Temporary<DOMRectList> {
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::error::Fallible;
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::utils::{Reflector, Reflectable, reflect_dom_object};
use dom::element::{Element, AttributeHandlers};
@ -35,7 +35,7 @@ impl DOMTokenList {
pub fn new(element: JSRef<Element>, local_name: &Atom) -> Temporary<DOMTokenList> {
let window = window_from_node(element).root();
reflect_dom_object(box DOMTokenList::new_inherited(element, local_name.clone()),
Window(*window),
GlobalRef::Window(*window),
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::InheritTypes::HTMLCanvasElementDerived;
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::utils::{Reflectable, Reflector};
use dom::canvasrenderingcontext2d::CanvasRenderingContext2D;
@ -87,7 +87,7 @@ impl<'a> HTMLCanvasElementMethods for JSRef<'a, HTMLCanvasElement> {
if self.context.get().is_none() {
let window = window_from_node(self).root();
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.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::HTMLCollectionMethods;
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::trace::JSTraceable;
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> {
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::InheritTypes::{EventTargetCast, HTMLFormElementDerived, NodeCast};
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::utils::{Reflectable, Reflector};
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 servo_msg::constellation_msg::LoadData;
use servo_util::str::DOMString;
use script_task::ScriptChan;
use script_task::ScriptMsg::TriggerLoadMsg;
use script_task::{ScriptChan, ScriptMsg};
use std::ascii::OwnedAsciiExt;
use url::UrlParser;
use url::form_urlencoded::serialize;
@ -157,7 +156,7 @@ impl<'a> HTMLFormElementHelpers for JSRef<'a, HTMLFormElement> {
let base = doc.url();
// TODO: Handle browsing contexts
// TODO: Handle validation
let event = Event::new(Window(*win),
let event = Event::new(GlobalRef::Window(*win),
"submit".to_string(),
EventBubbles::Bubbles,
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
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> {
@ -345,7 +344,7 @@ impl<'a> HTMLFormElementHelpers for JSRef<'a, HTMLFormElement> {
}
let win = window_from_node(self).root();
let event = Event::new(Window(*win),
let event = Event::new(GlobalRef::Window(*win),
"reset".to_string(),
EventBubbles::Bubbles,
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::{HTMLInputElementDerived, HTMLFieldSetElementDerived, EventTargetCast};
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::{ResultRootable, RootedReference, MutNullableJS};
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
if self.mutable() {
let win = window_from_node(*self).root();
let event = Event::new(Window(*win),
let event = Event::new(GlobalRef::Window(*win),
"input".to_string(),
EventBubbles::Bubbles,
EventCancelable::NotCancelable).root();
@ -750,7 +750,7 @@ impl<'a> Activatable for JSRef<'a, HTMLInputElement> {
let target: JSRef<EventTarget> = EventTargetCast::from_ref(*self);
target.DispatchEvent(*event).ok();
let event = Event::new(Window(*win),
let event = Event::new(GlobalRef::Window(*win),
"change".to_string(),
EventBubbles::Bubbles,
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::node::{Node, NodeHelpers, NodeTypeId, window_from_node};
use dom::virtualmethods::VirtualMethods;
use layout_interface::{LayoutChan, LoadStylesheetMsg};
use layout_interface::{LayoutChan, Msg};
use servo_util::str::{DOMString, HTML_SPACE_CHARACTERS};
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) {
Ok(url) => {
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)
}

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

@ -13,7 +13,7 @@ use dom::eventtarget::{EventTarget, EventTargetTypeId};
use dom::htmlelement::HTMLElement;
use dom::node::{Node, NodeHelpers, NodeTypeId, window_from_node};
use dom::virtualmethods::VirtualMethods;
use layout_interface::{AddStylesheetMsg, LayoutChan};
use layout_interface::{LayoutChan, Msg};
use servo_util::str::DOMString;
use style::{StylesheetOrigin, Stylesheet};
@ -58,7 +58,7 @@ impl<'a> StyleElementHelpers for JSRef<'a, HTMLStyleElement> {
let sheet = Stylesheet::from_str(data.as_slice(), url,
StylesheetOrigin::Author);
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::error::Fallible;
use dom::bindings::global::GlobalRef;
use dom::bindings::global;
use dom::bindings::js::{JSRef, Temporary, RootedReference};
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::event::{Event, EventTypeId};
@ -61,7 +60,7 @@ impl KeyboardEvent {
pub fn new_uninitialized(window: JSRef<Window>) -> Temporary<KeyboardEvent> {
reflect_dom_object(box KeyboardEvent::new_inherited(),
global::Window(window),
GlobalRef::Window(window),
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::LocationMethods;
use dom::bindings::global;
use dom::bindings::global::GlobalRef;
use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::urlhelper::UrlHelper;
@ -31,7 +31,7 @@ impl Location {
pub fn new(window: JSRef<Window>, page: Rc<Page>) -> Temporary<Location> {
reflect_dom_object(box Location::new_inherited(page),
global::Window(window),
GlobalRef::Window(window),
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::error::Fallible;
use dom::bindings::global::GlobalRef;
use dom::bindings::global;
use dom::bindings::js::{MutNullableJS, JSRef, RootedReference, Temporary, OptionalSettable};
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::event::{Event, EventTypeId};
@ -59,7 +58,7 @@ impl MouseEvent {
pub fn new_uninitialized(window: JSRef<Window>) -> Temporary<MouseEvent> {
reflect_dom_object(box MouseEvent::new_inherited(),
global::Window(window),
GlobalRef::Window(window),
MouseEventBinding::Wrap)
}

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

@ -5,7 +5,7 @@
use dom::attr::Attr;
use dom::bindings::codegen::Bindings::NamedNodeMapBinding;
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::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::element::{Element, ElementHelpers};
@ -27,7 +27,7 @@ impl NamedNodeMap {
pub fn new(window: JSRef<Window>, elem: JSRef<Element>) -> Temporary<NamedNodeMap> {
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::NavigatorMethods;
use dom::bindings::global;
use dom::bindings::global::GlobalRef;
use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::navigatorinfo::NavigatorInfo;
@ -25,7 +25,7 @@ impl Navigator {
pub fn new(window: JSRef<Window>) -> Temporary<Navigator> {
reflect_dom_object(box Navigator::new_inherited(),
global::Window(window),
GlobalRef::Window(window),
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::Error::{NotFound, HierarchyRequest, Syntax};
use dom::bindings::global::GlobalRef;
use dom::bindings::global;
use dom::bindings::js::{JS, JSRef, RootedReference, Temporary, Root};
use dom::bindings::js::{OptionalSettable, TemporaryPushable, OptionalRootedRootable};
use dom::bindings::js::{ResultRootable, OptionalRootable, MutNullableJS};
@ -43,7 +42,7 @@ use dom::text::Text;
use dom::virtualmethods::{VirtualMethods, vtable_for};
use dom::window::Window;
use geom::rect::Rect;
use layout_interface::{LayoutChan, ReapLayoutDataMsg};
use layout_interface::{LayoutChan, Msg};
use devtools_traits::NodeInfo;
use script_traits::UntrustedNodeAddress;
use servo_util::geometry::Au;
@ -1161,7 +1160,7 @@ impl Node {
wrap_fn: extern "Rust" fn(*mut JSContext, &GlobalRef, Box<N>) -> Temporary<N>)
-> Temporary<N> {
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 {
@ -1625,7 +1624,7 @@ impl Node {
None => {}
Some(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::NodeListMethods;
use dom::bindings::global;
use dom::bindings::global::GlobalRef;
use dom::bindings::js::{JS, JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::node::{Node, NodeHelpers};
@ -34,7 +34,7 @@ impl NodeList {
pub fn new(window: JSRef<Window>,
list_type: NodeListType) -> Temporary<NodeList> {
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> {

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

@ -4,7 +4,7 @@
use dom::bindings::codegen::Bindings::PerformanceBinding;
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::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::performancetiming::{PerformanceTiming, PerformanceTimingHelpers};
@ -37,7 +37,7 @@ impl Performance {
reflect_dom_object(box Performance::new_inherited(window,
navigation_start,
navigation_start_precise),
global::Window(window),
GlobalRef::Window(window),
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::PerformanceTimingMethods;
use dom::bindings::global;
use dom::bindings::global::GlobalRef;
use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::window::Window;
@ -33,7 +33,7 @@ impl PerformanceTiming {
-> Temporary<PerformanceTiming> {
let timing = PerformanceTiming::new_inherited(navigation_start,
navigation_start_precise);
reflect_dom_object(box timing, global::Window(window),
reflect_dom_object(box timing, GlobalRef::Window(window),
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::WindowBinding::WindowMethods;
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::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::document::{Document, DocumentHelpers};
@ -26,7 +26,7 @@ impl Range {
pub fn new(document: JSRef<Document>) -> Temporary<Range> {
let window = document.window().root();
reflect_dom_object(box Range::new_inherited(),
Window(*window),
GlobalRef::Window(*window),
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::ScreenMethods;
use dom::bindings::global;
use dom::bindings::global::GlobalRef;
use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::window::Window;
@ -23,7 +23,7 @@ impl Screen {
pub fn new(window: JSRef<Window>) -> Temporary<Screen> {
reflect_dom_object(box Screen::new_inherited(),
global::Window(window),
GlobalRef::Window(window),
ScreenBinding::Wrap)
}
}

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

@ -7,7 +7,7 @@
use dom::bindings::cell::DOMRefCell;
use dom::bindings::codegen::Bindings::ServoHTMLParserBinding;
use dom::bindings::global;
use dom::bindings::global::GlobalRef;
use dom::bindings::trace::JSTraceable;
use dom::bindings::js::{JS, JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
@ -72,7 +72,7 @@ impl ServoHTMLParser {
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]

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.
// use dom::bindings::codegen::Bindings::NodeFilterBinding::NodeFilterConstants;
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::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::document::{Document, DocumentHelpers};
@ -49,7 +49,7 @@ impl TreeWalker {
filter: Filter) -> Temporary<TreeWalker> {
let window = document.window().root();
reflect_dom_object(box TreeWalker::new_inherited(root_node, what_to_show, filter),
Window(*window),
GlobalRef::Window(*window),
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::error::Fallible;
use dom::bindings::global::GlobalRef;
use dom::bindings::global;
use dom::bindings::js::{MutNullableJS, JSRef, RootedReference, Temporary, OptionalSettable};
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
@ -43,7 +42,7 @@ impl UIEvent {
pub fn new_uninitialized(window: JSRef<Window>) -> Temporary<UIEvent> {
reflect_dom_object(box UIEvent::new_inherited(EventTypeId::UIEvent),
global::Window(window),
GlobalRef::Window(window),
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/. */
use dom::bindings::codegen::Bindings::ValidityStateBinding;
use dom::bindings::global;
use dom::bindings::global::GlobalRef;
use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::window::Window;
@ -24,7 +24,7 @@ impl ValidityState {
pub fn new(window: JSRef<Window>) -> Temporary<ValidityState> {
reflect_dom_object(box ValidityState::new_inherited(),
global::Window(window),
GlobalRef::Window(window),
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::error::Fallible;
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::utils::{Reflectable, Reflector};
use dom::browsercontext::BrowserContext;
@ -22,10 +22,10 @@ use dom::navigator::Navigator;
use dom::performance::Performance;
use dom::screen::Screen;
use dom::storage::Storage;
use layout_interface::{NoQuery, ReflowForDisplay, ReflowGoal, ReflowQueryType};
use layout_interface::{ReflowGoal, ReflowQueryType};
use page::Page;
use script_task::{TimerSource, ScriptChan};
use script_task::ScriptMsg::{ExitWindowMsg, TriggerLoadMsg, TriggerFragmentMsg};
use script_task::ScriptMsg;
use script_traits::ScriptControlChan;
use timers::{IsInterval, TimerId, TimerManager};
@ -191,7 +191,7 @@ impl<'a> WindowMethods for JSRef<'a, Window> {
fn Close(self) {
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> {
@ -204,11 +204,11 @@ impl<'a> WindowMethods for JSRef<'a, Window> {
}
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> {
self.console.or_init(|| Console::new(global::Window(self)))
self.console.or_init(|| Console::new(GlobalRef::Window(self)))
}
fn Navigator(self) -> Temporary<Navigator> {
@ -350,15 +350,15 @@ impl<'a> WindowHelpers for JSRef<'a, Window> {
let url = url.unwrap();
let ScriptChan(ref script_chan) = self.script_chan;
if href.as_slice().starts_with("#") {
script_chan.send(TriggerFragmentMsg(self.page.id, url));
script_chan.send(ScriptMsg::TriggerFragment(self.page.id, url));
} 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) {
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::eventtarget::{EventTarget, EventTargetHelpers, EventTargetTypeId};
use dom::messageevent::MessageEvent;
use script_task::ScriptChan;
use script_task::ScriptMsg::DOMMessage;
use script_task::{ScriptChan, ScriptMsg};
use servo_util::str::DOMString;
@ -147,7 +146,7 @@ impl<'a> WorkerMethods for JSRef<'a, Worker> {
self.addref();
let ScriptChan(ref sender) = self.sender;
sender.send(DOMMessage(data, nbytes));
sender.send(ScriptMsg::DOMMessage(data, nbytes));
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::error::{ErrorResult, Fallible};
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::utils::{Reflectable, Reflector};
use dom::console::Console;
@ -136,7 +136,7 @@ impl<'a> WorkerGlobalScopeMethods for JSRef<'a, WorkerGlobalScope> {
}
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> {

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

@ -5,7 +5,7 @@
use dom::bindings::codegen::Bindings::WorkerLocationBinding;
use dom::bindings::codegen::Bindings::WorkerLocationBinding::WorkerLocationMethods;
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::urlhelper::UrlHelper;
use dom::workerglobalscope::WorkerGlobalScope;
@ -30,7 +30,7 @@ impl WorkerLocation {
pub fn new(global: JSRef<WorkerGlobalScope>, url: Url) -> Temporary<WorkerLocation> {
reflect_dom_object(box WorkerLocation::new_inherited(url),
Worker(global),
GlobalRef::Worker(global),
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::WorkerNavigatorMethods;
use dom::bindings::global::Worker;
use dom::bindings::global::GlobalRef;
use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::navigatorinfo::NavigatorInfo;
@ -25,7 +25,7 @@ impl WorkerNavigator {
pub fn new(global: JSRef<WorkerGlobalScope>) -> Temporary<WorkerNavigator> {
reflect_dom_object(box WorkerNavigator::new_inherited(),
Worker(global),
GlobalRef::Worker(global),
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
* 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::codegen::Bindings::EventHandlerBinding::EventHandlerNonNull;
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::{InvalidState, InvalidAccess};
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::str::ByteString;
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
@ -30,8 +25,7 @@ use dom::urlsearchparams::URLSearchParamsHelpers;
use dom::xmlhttprequesteventtarget::XMLHttpRequestEventTarget;
use dom::xmlhttprequesteventtarget::XMLHttpRequestEventTargetTypeId;
use dom::xmlhttprequestupload::XMLHttpRequestUpload;
use script_task::ScriptChan;
use script_task::ScriptMsg::{XHRProgressMsg, XHRReleaseMsg};
use script_task::{ScriptChan, ScriptMsg};
use encoding::all::UTF_8;
use encoding::label::encoding_from_whatwg_label;
@ -85,22 +79,22 @@ pub struct GenerationId(uint);
pub enum XHRProgress {
/// 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
LoadingMsg(GenerationId, ByteString),
Loading(GenerationId, ByteString),
/// Loading is done
DoneMsg(GenerationId),
Done(GenerationId),
/// There was an error (only Abort, Timeout or Network is used)
ErroredMsg(GenerationId, Error),
Errored(GenerationId, Error),
}
impl XHRProgress {
fn generation_id(&self) -> GenerationId {
match *self {
HeadersReceivedMsg(id, _, _) |
LoadingMsg(id, _) |
DoneMsg(id) |
ErroredMsg(id, _) => id
XHRProgress::HeadersReceived(id, _, _) |
XHRProgress::Loading(id, _) |
XHRProgress::Done(id) |
XHRProgress::Errored(id, _) => id
}
}
}
@ -152,7 +146,7 @@ impl XMLHttpRequest {
fn new_inherited(global: &GlobalRef) -> XMLHttpRequest {
XMLHttpRequest {
eventtarget: XMLHttpRequestEventTarget::new_inherited(XMLHttpRequestEventTargetTypeId::XMLHttpRequest),
ready_state: Cell::new(Unsent),
ready_state: Cell::new(XMLHttpRequestState::Unsent),
timeout: Cell::new(0u32),
with_credentials: Cell::new(false),
upload: JS::from_rooted(XMLHttpRequestUpload::new(*global)),
@ -209,12 +203,12 @@ impl XMLHttpRequest {
fn notify_partial_progress(fetch_type: &SyncOrAsync, msg: XHRProgress) {
match *fetch_type {
Sync(xhr) => {
SyncOrAsync::Sync(xhr) => {
xhr.process_partial_response(msg);
},
Async(addr, script_chan) => {
SyncOrAsync::Async(addr, 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(
($err:expr) => ({
notify_partial_progress(fetch_type, ErroredMsg(gen_id, $err));
notify_partial_progress(fetch_type, XHRProgress::Errored(gen_id, $err));
return Err($err)
});
)
@ -230,10 +224,10 @@ impl XMLHttpRequest {
macro_rules! terminate(
($reason:expr) => (
match $reason {
AbortedOrReopened => {
TerminateReason::AbortedOrReopened => {
return Err(Abort)
}
TimedOut => {
TerminateReason::TimedOut => {
notify_error_and_return!(Timeout);
}
}
@ -292,7 +286,7 @@ impl XMLHttpRequest {
_ => {}
};
// 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()));
progress_port = response.progress_port;
@ -318,10 +312,10 @@ impl XMLHttpRequest {
Payload(data) => {
buf.push_all(data.as_slice());
notify_partial_progress(fetch_type,
LoadingMsg(gen_id, ByteString::new(buf.clone())));
XHRProgress::Loading(gen_id, ByteString::new(buf.clone())));
},
Done(Ok(())) => {
notify_partial_progress(fetch_type, DoneMsg(gen_id));
notify_partial_progress(fetch_type, XHRProgress::Done(gen_id));
return Ok(());
},
Done(Err(_)) => {
@ -390,8 +384,8 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> {
self.status.set(0);
// Step 13
if self.ready_state.get() != Opened {
self.change_ready_state(Opened);
if self.ready_state.get() != XMLHttpRequestState::Opened {
self.change_ready_state(XMLHttpRequestState::Opened);
}
Ok(())
},
@ -406,7 +400,7 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> {
self.Open(method, url)
}
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
}
if !name.is_token() || !value.is_field_value() {
@ -488,7 +482,7 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> {
Temporary::new(self.upload)
}
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
}
@ -609,13 +603,13 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> {
let gen_id = self.generation_id.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);
} else {
self.fetch_time.set(time::now().to_timespec().sec);
let script_chan = global.root_ref().script_chan().clone();
// 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
// as long as there are (possibly cancelled) inflight events queued up
// in the script task's port
@ -623,7 +617,7 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> {
self.to_trusted()
};
spawn_named("XHRTask", proc() {
let _ = XMLHttpRequest::fetch(&mut Async(addr, &script_chan),
let _ = XMLHttpRequest::fetch(&mut SyncOrAsync::Async(addr, &script_chan),
resource_task,
load_data,
terminate_receiver,
@ -631,7 +625,7 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> {
gen_id,
start_port);
let ScriptChan(ref chan) = script_chan;
chan.send(XHRReleaseMsg(addr));
chan.send(ScriptMsg::XHRRelease(addr));
});
let timeout = self.timeout.get();
if timeout > 0 {
@ -643,18 +637,18 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> {
fn Abort(self) {
self.terminate_ongoing_fetch();
let state = self.ready_state.get();
if (state == Opened && self.send_flag.get()) ||
state == HeadersReceived ||
state == Loading {
if (state == XMLHttpRequestState::Opened && self.send_flag.get()) ||
state == XMLHttpRequestState::HeadersReceived ||
state == XMLHttpRequestState::Loading {
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
// above call then we should terminate the abort sequence
if self.generation_id.get() != gen_id {
return
}
}
self.ready_state.set(Unsent);
self.ready_state.set(XMLHttpRequestState::Unsent);
}
fn ResponseURL(self) -> DOMString {
self.response_url.clone()
@ -680,12 +674,12 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> {
}
fn SetResponseType(self, response_type: XMLHttpRequestResponseType) -> ErrorResult {
match self.global.root() {
WorkerRoot(_) if response_type == XMLHttpRequestResponseType::Document
GlobalRoot::Worker(_) if response_type == XMLHttpRequestResponseType::Document
=> return Ok(()),
_ => {}
}
match self.ready_state.get() {
Loading | XHRDone => Err(InvalidState),
XMLHttpRequestState::Loading | XMLHttpRequestState::XHRDone => Err(InvalidState),
_ if self.sync.get() => Err(InvalidAccess),
_ => {
self.response_type.set(response_type);
@ -697,13 +691,13 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> {
match self.response_type.get() {
_empty | Text => {
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)
} else {
"".to_string().to_jsval(cx)
}
},
_ if self.ready_state.get() != XHRDone => NullValue(),
_ if self.ready_state.get() != XMLHttpRequestState::XHRDone => NullValue(),
Json => {
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();
@ -726,7 +720,7 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> {
match self.response_type.get() {
_empty | Text => {
match self.ready_state.get() {
Loading | XHRDone => Ok(self.text_response()),
XMLHttpRequestState::Loading | XMLHttpRequestState::XHRDone => Ok(self.text_response()),
_ => Ok("".to_string())
}
},
@ -837,8 +831,8 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
return_if_fetch_was_terminated!();
match progress {
HeadersReceivedMsg(_, headers, status) => {
assert!(self.ready_state.get() == Opened);
XHRProgress::HeadersReceived(_, headers, status) => {
assert!(self.ready_state.get() == XMLHttpRequestState::Opened);
// 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)
@ -865,26 +859,26 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
// Substep 3
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
// Part of step 11, send() (processing response body)
// XXXManishearth handle errors, if any (substep 2)
*self.response.borrow_mut() = partial_response;
if !self.sync.get() {
if self.ready_state.get() == HeadersReceived {
self.change_ready_state(Loading);
if self.ready_state.get() == XMLHttpRequestState::HeadersReceived {
self.change_ready_state(XMLHttpRequestState::Loading);
return_if_fetch_was_terminated!();
}
self.dispatch_response_progress_event("progress".to_string());
}
},
DoneMsg(_) => {
assert!(self.ready_state.get() == HeadersReceived ||
self.ready_state.get() == Loading ||
XHRProgress::Done(_) => {
assert!(self.ready_state.get() == XMLHttpRequestState::HeadersReceived ||
self.ready_state.get() == XMLHttpRequestState::Loading ||
self.sync.get());
// Part of step 11, send() (processing response end of file)
@ -892,7 +886,7 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
// Subsubsteps 5-7
self.send_flag.set(false);
self.change_ready_state(XHRDone);
self.change_ready_state(XMLHttpRequestState::XHRDone);
return_if_fetch_was_terminated!();
// Subsubsteps 10-12
self.dispatch_response_progress_event("progress".to_string());
@ -901,10 +895,10 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
return_if_fetch_was_terminated!();
self.dispatch_response_progress_event("loadend".to_string());
},
ErroredMsg(_, e) => {
XHRProgress::Errored(_, e) => {
self.send_flag.set(false);
// XXXManishearth set response to NetworkError
self.change_ready_state(XHRDone);
self.change_ready_state(XMLHttpRequestState::XHRDone);
return_if_fetch_was_terminated!();
let errormsg = match e {
@ -935,7 +929,7 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
fn terminate_ongoing_fetch(self) {
let GenerationId(prev_id) = self.generation_id.get();
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) {
@ -981,7 +975,7 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
spawn_named("XHR:Timer", proc () {
match oneshot.recv_opt() {
Ok(_) => {
terminate_sender.map(|s| s.send_opt(TimedOut));
terminate_sender.map(|s| s.send_opt(TerminateReason::TimedOut));
},
Err(_) => {
// 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
/// from layout.
pub use self::Msg::*;
pub use self::ReflowGoal::*;
pub use self::ReflowQueryType::*;
use dom::node::LayoutDataRef;
use geom::point::Point2D;
@ -28,33 +24,33 @@ pub use dom::node::TrustedNodeAddress;
/// Asynchronous messages that script can send to layout.
pub enum Msg {
/// Adds the given stylesheet to the document.
AddStylesheetMsg(Stylesheet),
AddStylesheet(Stylesheet),
/// 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.
SetQuirksModeMsg,
SetQuirksMode,
/// Requests a reflow.
ReflowMsg(Box<Reflow>),
Reflow(Box<Reflow>),
/// Get an RPC interface.
GetRPCMsg(Sender<Box<LayoutRPC + Send>>),
GetRPC(Sender<Box<LayoutRPC + Send>>),
/// Destroys layout data associated with a DOM node.
///
/// 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
/// accepted except `ExitMsg`. A response message will be sent on the supplied channel when
/// this happens.
PrepareToExitMsg(Sender<()>),
PrepareToExit(Sender<()>),
/// Requests that the layout task immediately shut down. There must be no more nodes left after
/// this, or layout will crash.
ExitNowMsg,
ExitNow,
}
/// Synchronous messages that script can send to layout.
@ -84,9 +80,9 @@ pub struct MouseOverResponse(pub Vec<UntrustedNodeAddress>);
#[deriving(PartialEq, Show)]
pub enum ReflowGoal {
/// 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.
ReflowForScriptQuery,
ForScriptQuery,
}
/// 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::window::Window;
use layout_interface::{
ContentBoxQuery, ContentBoxResponse, ContentBoxesQuery, ContentBoxesResponse,
GetRPCMsg, HitTestResponse, LayoutChan, LayoutRPC, MouseOverResponse, Reflow,
ReflowForScriptQuery, ReflowGoal, ReflowMsg, ReflowQueryType,
ContentBoxResponse, ContentBoxesResponse,
HitTestResponse, LayoutChan, LayoutRPC, MouseOverResponse, Msg, Reflow,
ReflowGoal, ReflowQueryType,
TrustedNodeAddress
};
use script_traits::{UntrustedNodeAddress, ScriptControlChan};
@ -138,7 +138,7 @@ impl Page {
let layout_rpc: Box<LayoutRPC> = {
let (rpc_send, rpc_recv) = channel();
let LayoutChan(ref lchan) = layout_chan;
lchan.send(GetRPCMsg(rpc_send));
lchan.send(Msg::GetRPC(rpc_send));
rpc_recv.recv()
};
Page {
@ -174,14 +174,14 @@ impl Page {
}
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?
let ContentBoxResponse(rect) = self.layout_rpc.content_box();
rect
}
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?
let ContentBoxesResponse(rects) = self.layout_rpc.content_boxes();
rects
@ -391,7 +391,7 @@ impl Page {
};
let LayoutChan(ref chan) = self.layout_chan;
chan.send(ReflowMsg(reflow));
chan.send(Msg::Reflow(reflow));
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
//! and layout tasks.
use self::ScriptMsg::*;
use dom::bindings::cell::DOMRefCell;
use dom::bindings::codegen::Bindings::DocumentBinding::{DocumentMethods, DocumentReadyState};
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::conversions::FromJSValConvertible;
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::trace::JSTraceable;
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::xmlhttprequest::{TrustedXHRAddress, XMLHttpRequest, XHRProgress};
use parse::html::{HTMLInput, parse_html};
use layout_interface::{ScriptLayoutChan, LayoutChan, NoQuery, ReflowForDisplay};
use layout_interface::{ScriptLayoutChan, LayoutChan, ReflowGoal, ReflowQueryType};
use layout_interface;
use page::{Page, IterablePage, Frame};
use timers::TimerId;
@ -93,24 +91,24 @@ pub enum TimerSource {
pub enum ScriptMsg {
/// Acts on a fragment URL load on the specified pipeline (only dispatched
/// to ScriptTask).
TriggerFragmentMsg(PipelineId, Url),
TriggerFragment(PipelineId, Url),
/// Begins a content-initiated load on the specified pipeline (only
/// dispatched to ScriptTask).
TriggerLoadMsg(PipelineId, LoadData),
TriggerLoad(PipelineId, LoadData),
/// Instructs the script task to send a navigate message to
/// the constellation (only dispatched to ScriptTask).
NavigateMsg(NavigationDirection),
Navigate(NavigationDirection),
/// Fires a JavaScript timeout
/// TimerSource must be FromWindow when dispatched to ScriptTask and
/// 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
/// should be closed (only dispatched to ScriptTask).
ExitWindowMsg(PipelineId),
ExitWindow(PipelineId),
/// 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).
XHRReleaseMsg(TrustedXHRAddress),
XHRRelease(TrustedXHRAddress),
/// Message sent through Worker.postMessage (only dispatched to
/// DedicatedWorkerGlobalScope).
DOMMessage(*mut u64, size_t),
@ -561,27 +559,27 @@ impl ScriptTask {
fn handle_msg_from_script(&self, msg: ScriptMsg) {
match msg {
TriggerLoadMsg(id, load_data) =>
ScriptMsg::TriggerLoad(id, load_data) =>
self.trigger_load(id, load_data),
TriggerFragmentMsg(id, url) =>
ScriptMsg::TriggerFragment(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),
FireTimerMsg(TimerSource::FromWorker, _) =>
ScriptMsg::FireTimer(TimerSource::FromWorker, _) =>
panic!("Worker timeouts must not be sent to script task"),
NavigateMsg(direction) =>
ScriptMsg::Navigate(direction) =>
self.handle_navigate_msg(direction),
ExitWindowMsg(id) =>
ScriptMsg::ExitWindow(id) =>
self.handle_exit_window_msg(id),
XHRProgressMsg(addr, progress) =>
ScriptMsg::XHRProgress(addr, progress) =>
XMLHttpRequest::handle_progress(addr, progress),
XHRReleaseMsg(addr) =>
ScriptMsg::XHRRelease(addr) =>
XMLHttpRequest::handle_release(addr),
DOMMessage(..) =>
ScriptMsg::DOMMessage(..) =>
panic!("unexpected message"),
WorkerPostMessage(addr, data, nbytes) =>
ScriptMsg::WorkerPostMessage(addr, data, nbytes) =>
Worker::handle_message(addr, data, nbytes),
WorkerRelease(addr) =>
ScriptMsg::WorkerRelease(addr) =>
Worker::handle_release(addr),
}
}
@ -826,7 +824,7 @@ impl ScriptTask {
let document_as_node = NodeCast::from_ref(document_js_ref);
document.content_changed(document_as_node, NodeDamage::OtherNodeDamage);
}
window.flush_layout(ReflowForDisplay, NoQuery);
window.flush_layout(ReflowGoal::ForDisplay, ReflowQueryType::NoQuery);
{
// No more reflow required
@ -835,7 +833,7 @@ impl ScriptTask {
}
// 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,
EventCancelable::NotCancelable).root();
let doctarget: JSRef<EventTarget> = EventTargetCast::from_ref(*document);
@ -848,7 +846,7 @@ impl ScriptTask {
// https://html.spec.whatwg.org/multipage/#the-end step 7
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,
EventCancelable::NotCancelable).root();
let wintarget: JSRef<EventTarget> = EventTargetCast::from_ref(*window);
@ -888,10 +886,10 @@ impl ScriptTask {
/// Reflows non-incrementally.
fn force_reflow(&self, page: &Page) {
page.dirty_all_nodes();
page.reflow(ReflowForDisplay,
page.reflow(ReflowGoal::ForDisplay,
self.control_chan.clone(),
&mut **self.compositor.borrow_mut(),
NoQuery);
ReflowQueryType::NoQuery);
}
/// 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
@ -1121,7 +1119,7 @@ impl ScriptTask {
doc.begin_focus_transaction();
let event =
Event::new(global::Window(*window),
Event::new(GlobalRef::Window(*window),
"click".to_string(),
EventBubbles::Bubbles,
EventCancelable::Cancelable).root();
@ -1132,7 +1130,7 @@ impl ScriptTask {
el.authentic_click_activation(*event);
doc.commit_focus_transaction();
window.flush_layout(ReflowForDisplay, NoQuery);
window.flush_layout(ReflowGoal::ForDisplay, ReflowQueryType::NoQuery);
}
None => {}
}
@ -1213,7 +1211,7 @@ fn shut_down_layout(page_tree: &Rc<Page>, rt: *mut JSRuntime) {
// processed this message.
let (response_chan, response_port) = channel();
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();
}
@ -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.
for page in page_tree.iter() {
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::utils::Reflectable;
use script_task::{ScriptChan, TimerSource};
use script_task::ScriptMsg::FireTimerMsg;
use script_task::{ScriptChan, ScriptMsg, TimerSource};
use servo_util::task::spawn_named;
@ -107,7 +106,7 @@ impl TimerManager {
let handle = self.next_timer_handle.get();
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.
let tm = Timer::new().unwrap();
let (cancel_chan, cancel_port) = channel();
@ -138,7 +137,7 @@ impl TimerManager {
if id == timeout_handle.id() {
timeout_port.recv();
let ScriptChan(ref chan) = script_chan;
chan.send(FireTimerMsg(source, TimerId(handle)));
chan.send(ScriptMsg::FireTimer(source, TimerId(handle)));
if is_interval == IsInterval::NonInterval {
break;
}