script: Remove glob imports added in #4405

43 files changed, 243 insertions, 272 deletions

diff --git a/components/layout/layout_task.rs b/components/layout/layout_task.rs
index 48941a0d336..94073cd4e09 100644
--- a/components/layout/layout_task.rs
+++ b/components/layout/layout_task.rs
@@ -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 {
diff --git a/components/script/dom/attr.rs b/components/script/dom/attr.rs
index 01074b42ac9..d1b288bd7ad 100644
--- a/components/script/dom/attr.rs
+++ b/components/script/dom/attr.rs
@@ -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]
diff --git a/components/script/dom/bindings/global.rs b/components/script/dom/bindings/global.rs
index 549104856f9..4efeb7aaf67 100644
--- a/components/script/dom/bindings/global.rs
+++ b/components/script/dom/bindings/global.rs
@@ -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(_) => (),
         }
 
diff --git a/components/script/dom/create.rs b/components/script/dom/create.rs
index 1848df54a09..8311a297bdd 100644
--- a/components/script/dom/create.rs
+++ b/components/script/dom/create.rs
@@ -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),
diff --git a/components/script/dom/cssstyledeclaration.rs b/components/script/dom/cssstyledeclaration.rs
index 99cb65c4807..4553f020282 100644
--- a/components/script/dom/cssstyledeclaration.rs
+++ b/components/script/dom/cssstyledeclaration.rs
@@ -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)
     }
 }
diff --git a/components/script/dom/dedicatedworkerglobalscope.rs b/components/script/dom/dedicatedworkerglobalscope.rs
index 04211e9349d..f29691afcf6 100644
--- a/components/script/dom/dedicatedworkerglobalscope.rs
+++ b/components/script/dom/dedicatedworkerglobalscope.rs
@@ -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));
     }
 }
 
diff --git a/components/script/dom/document.rs b/components/script/dom/document.rs
index 8f6dab404f7..697bd011b84 100644
--- a/components/script/dom/document.rs
+++ b/components/script/dom/document.rs
@@ -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)
         }
     }
diff --git a/components/script/dom/domimplementation.rs b/components/script/dom/domimplementation.rs
index 6e84e7a0194..45be86c538a 100644
--- a/components/script/dom/domimplementation.rs
+++ b/components/script/dom/domimplementation.rs
@@ -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)
     }
 }
diff --git a/components/script/dom/domparser.rs b/components/script/dom/domparser.rs
index 601af0493a3..8b4af333995 100644
--- a/components/script/dom/domparser.rs
+++ b/components/script/dom/domparser.rs
@@ -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)
     }
 
diff --git a/components/script/dom/domrect.rs b/components/script/dom/domrect.rs
index 109e263061b..31ddd1d3cee 100644
--- a/components/script/dom/domrect.rs
+++ b/components/script/dom/domrect.rs
@@ -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)
     }
 }
 
diff --git a/components/script/dom/domrectlist.rs b/components/script/dom/domrectlist.rs
index 661177257ab..c4aaa1be09c 100644
--- a/components/script/dom/domrectlist.rs
+++ b/components/script/dom/domrectlist.rs
@@ -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)
     }
 }
 
diff --git a/components/script/dom/domtokenlist.rs b/components/script/dom/domtokenlist.rs
index fecccad8fea..6ba0307b14e 100644
--- a/components/script/dom/domtokenlist.rs
+++ b/components/script/dom/domtokenlist.rs
@@ -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)
     }
 }
diff --git a/components/script/dom/htmlcanvaselement.rs b/components/script/dom/htmlcanvaselement.rs
index 70da494f314..d07080a440a 100644
--- a/components/script/dom/htmlcanvaselement.rs
+++ b/components/script/dom/htmlcanvaselement.rs
@@ -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()
diff --git a/components/script/dom/htmlcollection.rs b/components/script/dom/htmlcollection.rs
index 647b5ee66af..8f2b8bc9e78 100644
--- a/components/script/dom/htmlcollection.rs
+++ b/components/script/dom/htmlcollection.rs
@@ -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)
     }
 }
 
diff --git a/components/script/dom/htmlformelement.rs b/components/script/dom/htmlformelement.rs
index 58a0e0e175b..50c58a22cad 100644
--- a/components/script/dom/htmlformelement.rs
+++ b/components/script/dom/htmlformelement.rs
@@ -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();
diff --git a/components/script/dom/htmlinputelement.rs b/components/script/dom/htmlinputelement.rs
index b051a4f8f43..970396d9e18 100644
--- a/components/script/dom/htmlinputelement.rs
+++ b/components/script/dom/htmlinputelement.rs
@@ -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();
diff --git a/components/script/dom/htmllinkelement.rs b/components/script/dom/htmllinkelement.rs
index 575c9a459d4..f84314b7008 100644
--- a/components/script/dom/htmllinkelement.rs
+++ b/components/script/dom/htmllinkelement.rs
@@ -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)
         }
diff --git a/components/script/dom/htmlstyleelement.rs b/components/script/dom/htmlstyleelement.rs
index c662d39c8e3..d250fda3f54 100644
--- a/components/script/dom/htmlstyleelement.rs
+++ b/components/script/dom/htmlstyleelement.rs
@@ -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));
     }
 }
 
diff --git a/components/script/dom/keyboardevent.rs b/components/script/dom/keyboardevent.rs
index 20f7b1e518e..691c1f787a1 100644
--- a/components/script/dom/keyboardevent.rs
+++ b/components/script/dom/keyboardevent.rs
@@ -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)
     }
 
diff --git a/components/script/dom/location.rs b/components/script/dom/location.rs
index 60acf24617e..9ac0ed67e94 100644
--- a/components/script/dom/location.rs
+++ b/components/script/dom/location.rs
@@ -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)
     }
 }
diff --git a/components/script/dom/mouseevent.rs b/components/script/dom/mouseevent.rs
index 46cc0a6e706..02cbf428437 100644
--- a/components/script/dom/mouseevent.rs
+++ b/components/script/dom/mouseevent.rs
@@ -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)
     }
 
diff --git a/components/script/dom/namednodemap.rs b/components/script/dom/namednodemap.rs
index f7d04f74031..70d27878c0d 100644
--- a/components/script/dom/namednodemap.rs
+++ b/components/script/dom/namednodemap.rs
@@ -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)
     }
 }
 
diff --git a/components/script/dom/navigator.rs b/components/script/dom/navigator.rs
index 721c11efa6a..0e3415f8b48 100644
--- a/components/script/dom/navigator.rs
+++ b/components/script/dom/navigator.rs
@@ -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)
     }
 }
diff --git a/components/script/dom/node.rs b/components/script/dom/node.rs
index 50647862007..e8d6035e856 100644
--- a/components/script/dom/node.rs
+++ b/components/script/dom/node.rs
@@ -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))
                 },
             }
         }
diff --git a/components/script/dom/nodelist.rs b/components/script/dom/nodelist.rs
index e2b09985146..b4c5955a798 100644
--- a/components/script/dom/nodelist.rs
+++ b/components/script/dom/nodelist.rs
@@ -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> {
diff --git a/components/script/dom/performance.rs b/components/script/dom/performance.rs
index 3fc094eeb65..c5882e77b40 100644
--- a/components/script/dom/performance.rs
+++ b/components/script/dom/performance.rs
@@ -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)
     }
 }
diff --git a/components/script/dom/performancetiming.rs b/components/script/dom/performancetiming.rs
index 3dbffabbb3a..e65eed16b8b 100644
--- a/components/script/dom/performancetiming.rs
+++ b/components/script/dom/performancetiming.rs
@@ -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)
     }
 }
diff --git a/components/script/dom/range.rs b/components/script/dom/range.rs
index 1dd10713de8..a66b1fd4683 100644
--- a/components/script/dom/range.rs
+++ b/components/script/dom/range.rs
@@ -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)
     }
 
diff --git a/components/script/dom/screen.rs b/components/script/dom/screen.rs
index 82d67ec05b0..84662b5c4e8 100644
--- a/components/script/dom/screen.rs
+++ b/components/script/dom/screen.rs
@@ -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)
     }
 }
diff --git a/components/script/dom/servohtmlparser.rs b/components/script/dom/servohtmlparser.rs
index 20de9c6b6b5..30807adad02 100644
--- a/components/script/dom/servohtmlparser.rs
+++ b/components/script/dom/servohtmlparser.rs
@@ -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]
diff --git a/components/script/dom/treewalker.rs b/components/script/dom/treewalker.rs
index d9037788c85..1a25c7d9169 100644
--- a/components/script/dom/treewalker.rs
+++ b/components/script/dom/treewalker.rs
@@ -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)
     }
 
diff --git a/components/script/dom/uievent.rs b/components/script/dom/uievent.rs
index eca5ababb22..829561b78c9 100644
--- a/components/script/dom/uievent.rs
+++ b/components/script/dom/uievent.rs
@@ -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)
     }
 
diff --git a/components/script/dom/validitystate.rs b/components/script/dom/validitystate.rs
index 2a1c7458c8b..79a4824252f 100644
--- a/components/script/dom/validitystate.rs
+++ b/components/script/dom/validitystate.rs
@@ -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)
     }
 }
diff --git a/components/script/dom/window.rs b/components/script/dom/window.rs
index 27e852a6aac..c4ac768225f 100644
--- a/components/script/dom/window.rs
+++ b/components/script/dom/window.rs
@@ -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);
     }
 }
 
diff --git a/components/script/dom/worker.rs b/components/script/dom/worker.rs
index ed90118d1fd..6669b496c70 100644
--- a/components/script/dom/worker.rs
+++ b/components/script/dom/worker.rs
@@ -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(())
     }
 
diff --git a/components/script/dom/workerglobalscope.rs b/components/script/dom/workerglobalscope.rs
index 7d1356f0e34..f4827daaa34 100644
--- a/components/script/dom/workerglobalscope.rs
+++ b/components/script/dom/workerglobalscope.rs
@@ -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> {
diff --git a/components/script/dom/workerlocation.rs b/components/script/dom/workerlocation.rs
index a178a8c2e69..d539da9b3b4 100644
--- a/components/script/dom/workerlocation.rs
+++ b/components/script/dom/workerlocation.rs
@@ -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)
     }
 }
diff --git a/components/script/dom/workernavigator.rs b/components/script/dom/workernavigator.rs
index a1fe51b3864..50bad86ca31 100644
--- a/components/script/dom/workernavigator.rs
+++ b/components/script/dom/workernavigator.rs
@@ -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)
     }
 }
diff --git a/components/script/dom/xmlhttprequest.rs b/components/script/dom/xmlhttprequest.rs
index 451c3ab8079..cd6d1850763 100644
--- a/components/script/dom/xmlhttprequest.rs
+++ b/components/script/dom/xmlhttprequest.rs
@@ -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)
diff --git a/components/script/layout_interface.rs b/components/script/layout_interface.rs
index 380289fd091..b19e789a4ed 100644
--- a/components/script/layout_interface.rs
+++ b/components/script/layout_interface.rs
@@ -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.
diff --git a/components/script/page.rs b/components/script/page.rs
index c4c0f741c4c..3c6dcb43f91 100644
--- a/components/script/page.rs
+++ b/components/script/page.rs
@@ -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");
 
diff --git a/components/script/script_task.rs b/components/script/script_task.rs
index dfb4e7d267a..7a9529a2975 100644
--- a/components/script/script_task.rs
+++ b/components/script/script_task.rs
@@ -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);
     }
 }
 
diff --git a/components/script/timers.rs b/components/script/timers.rs
index 1b642a85ca5..082ea626790 100644
--- a/components/script/timers.rs
+++ b/components/script/timers.rs
@@ -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;
                     }