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

Upgrade to rustc d2b30f7d3 2014-09-23

Browse source
This commit is contained in:
Simon Sapin 2014-09-25 16:01:21 +01:00
parent a58324f25b
commit b3245fa407
51 changed files with 227 additions and 197 deletions
Download patch file Download diff file Expand all files Collapse all files

3
components/script/Cargo.toml
View file

@ -57,3 +57,6 @@ git = "https://github.com/servo/rust-mozjs"
[dependencies.url]
git = "https://github.com/servo/rust-url"
[dependencies.uuid]
git = "https://github.com/rust-lang/uuid"

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

@ -5,7 +5,7 @@
use dom::bindings::codegen::Bindings::AttrBinding;
use dom::bindings::codegen::Bindings::AttrBinding::AttrMethods;
use dom::bindings::codegen::InheritTypes::NodeCast;
use dom::bindings::global::Window;
use dom::bindings::global;
use dom::bindings::js::{JS, JSRef, Temporary};
use dom::bindings::trace::Traceable;
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
@ -112,7 +112,7 @@ impl Attr {
name: Atom, namespace: Namespace,
prefix: Option<DOMString>, owner: JSRef<Element>) -> Temporary<Attr> {
reflect_dom_object(box Attr::new_inherited(local_name, value, name, namespace, prefix, owner),
&Window(window), AttrBinding::Wrap)
&global::Window(window), AttrBinding::Wrap)
}
}

12
components/script/dom/bindings/conversions.rs
View file

@ -23,7 +23,7 @@ use js::jsval::{UndefinedValue, NullValue, BooleanValue, Int32Value, UInt32Value
use js::jsval::{StringValue, ObjectValue, ObjectOrNullValue};
use js::glue::RUST_JS_NumberValue;
use libc;
use std::default::Default;
use std::default;
use std::slice;
use dom::bindings::codegen::PrototypeList;
@ -67,10 +67,10 @@ impl ToJSValConvertible for JSVal {
}
}
unsafe fn convert_from_jsval<T: Default>(
unsafe fn convert_from_jsval<T: default::Default>(
cx: *mut JSContext, value: JSVal,
convert_fn: unsafe extern "C" fn(*mut JSContext, JSVal, *mut T) -> JSBool) -> Result<T, ()> {
let mut ret = Default::default();
let mut ret = default::Default::default();
if convert_fn(cx, value, &mut ret) == 0 {
Err(())
} else {
@ -246,7 +246,7 @@ pub enum StringificationBehavior {
Empty,
}
impl Default for StringificationBehavior {
impl default::Default for StringificationBehavior {
fn default() -> StringificationBehavior {
Default
}
@ -355,12 +355,12 @@ impl<T: ToJSValConvertible> ToJSValConvertible for Option<T> {
}
}
impl<X: Default, T: FromJSValConvertible<X>> FromJSValConvertible<()> for Option<T> {
impl<X: default::Default, T: FromJSValConvertible<X>> FromJSValConvertible<()> for Option<T> {
fn from_jsval(cx: *mut JSContext, value: JSVal, _: ()) -> Result<Option<T>, ()> {
if value.is_null_or_undefined() {
Ok(None)
} else {
let option: X = Default::default();
let option: X = default::Default::default();
let result: Result<T, ()> = FromJSValConvertible::from_jsval(cx, value, option);
result.map(Some)
}

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

@ -11,7 +11,7 @@ use dom::bindings::conversions::FromJSValConvertible;
use dom::bindings::js::{JS, JSRef, Root};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::workerglobalscope::WorkerGlobalScope;
use dom::window::Window;
use dom::window;
use script_task::ScriptChan;
use servo_net::resource_task::ResourceTask;
@ -27,13 +27,13 @@ use std::ptr;
/// A freely-copyable reference to a rooted global object.
pub enum GlobalRef<'a> {
Window(JSRef<'a, Window>),
Window(JSRef<'a, window::Window>),
Worker(JSRef<'a, WorkerGlobalScope>),
}
/// A stack-based rooted reference to a global object.
pub enum GlobalRoot<'a, 'b> {
WindowRoot(Root<'a, 'b, Window>),
WindowRoot(Root<'a, 'b, window::Window>),
WorkerRoot(Root<'a, 'b, WorkerGlobalScope>),
}
@ -42,7 +42,7 @@ pub enum GlobalRoot<'a, 'b> {
#[jstraceable]
#[must_root]
pub enum GlobalField {
WindowField(JS<Window>),
WindowField(JS<window::Window>),
WorkerField(JS<WorkerGlobalScope>),
}
@ -58,7 +58,7 @@ impl<'a> GlobalRef<'a> {
/// Extract a `Window`, causing task failure if the global object is not
/// a `Window`.
pub fn as_window<'b>(&'b self) -> JSRef<'b, Window> {
pub fn as_window<'b>(&'b self) -> JSRef<'b, window::Window> {
match *self {
Window(window) => window,
Worker(_) => fail!("expected a Window scope"),

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

@ -7,7 +7,7 @@ use dom::bindings::codegen::Bindings::DedicatedWorkerGlobalScopeBinding::Dedicat
use dom::bindings::codegen::Bindings::EventHandlerBinding::EventHandlerNonNull;
use dom::bindings::codegen::InheritTypes::DedicatedWorkerGlobalScopeDerived;
use dom::bindings::codegen::InheritTypes::{EventTargetCast, WorkerGlobalScopeCast};
use dom::bindings::global::Worker;
use dom::bindings::global;
use dom::bindings::js::{JSRef, Temporary, RootCollection};
use dom::bindings::trace::Untraceable;
use dom::bindings::utils::{Reflectable, Reflector};
@ -130,7 +130,7 @@ impl DedicatedWorkerGlobalScope {
ptr::null(), ptr::null_mut()) != 0);
}
MessageEvent::dispatch_jsval(target, &Worker(scope), message);
MessageEvent::dispatch_jsval(target, &global::Worker(scope), message);
global.delayed_release_worker();
},
Ok(XHRProgressMsg(addr, progress)) => {

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

@ -19,7 +19,8 @@ use dom::bindings::codegen::InheritTypes::{HTMLFormElementDerived, HTMLImageElem
use dom::bindings::codegen::InheritTypes::{HTMLScriptElementDerived};
use dom::bindings::error::{ErrorResult, Fallible, NotSupported, InvalidCharacter};
use dom::bindings::error::{HierarchyRequest, NamespaceError};
use dom::bindings::global::{GlobalRef, Window};
use dom::bindings::global::GlobalRef;
use dom::bindings::global;
use dom::bindings::js::{JS, JSRef, Temporary, OptionalSettable, TemporaryPushable};
use dom::bindings::js::OptionalRootable;
use dom::bindings::trace::{Traceable, Untraceable};
@ -322,7 +323,7 @@ impl Document {
pub fn new(window: JSRef<Window>, url: Option<Url>, doctype: IsHTMLDocument, content_type: Option<DOMString>) -> Temporary<Document> {
let document = reflect_dom_object(box Document::new_inherited(window, url, doctype, content_type),
&Window(window),
&global::Window(window),
DocumentBinding::Wrap).root();
let node: JSRef<Node> = NodeCast::from_ref(*document);
@ -584,10 +585,14 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
let window = self.window.root();
match interface.as_slice().to_ascii_lower().as_slice() {
"uievents" | "uievent" => Ok(EventCast::from_temporary(UIEvent::new_uninitialized(*window))),
"mouseevents" | "mouseevent" => Ok(EventCast::from_temporary(MouseEvent::new_uninitialized(*window))),
"customevent" => Ok(EventCast::from_temporary(CustomEvent::new_uninitialized(&Window(*window)))),
"htmlevents" | "events" | "event" => Ok(Event::new_uninitialized(&Window(*window))),
"uievents" | "uievent" => Ok(EventCast::from_temporary(
UIEvent::new_uninitialized(*window))),
"mouseevents" | "mouseevent" => Ok(EventCast::from_temporary(
MouseEvent::new_uninitialized(*window))),
"customevent" => Ok(EventCast::from_temporary(
CustomEvent::new_uninitialized(&global::Window(*window)))),
"htmlevents" | "events" | "event" => Ok(Event::new_uninitialized(
&global::Window(*window))),
_ => Err(NotSupported)
}
}

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

@ -6,7 +6,8 @@ use dom::bindings::codegen::Bindings::DOMParserBinding;
use dom::bindings::codegen::Bindings::DOMParserBinding::DOMParserMethods;
use dom::bindings::codegen::Bindings::DOMParserBinding::SupportedTypeValues::{Text_html, Text_xml};
use dom::bindings::error::{Fallible, FailureUnknown};
use dom::bindings::global::{GlobalRef, Window};
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, HTMLDocument, NonHTMLDocument};
@ -29,7 +30,7 @@ impl DOMParser {
}
pub fn new(window: JSRef<Window>) -> Temporary<DOMParser> {
reflect_dom_object(box DOMParser::new_inherited(window), &Window(window),
reflect_dom_object(box DOMParser::new_inherited(window), &global::Window(window),
DOMParserBinding::Wrap)
}

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

@ -4,7 +4,7 @@
use dom::bindings::codegen::Bindings::DOMRectBinding;
use dom::bindings::codegen::Bindings::DOMRectBinding::DOMRectMethods;
use dom::bindings::global::Window;
use dom::bindings::global;
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),
&Window(window), DOMRectBinding::Wrap)
&global::Window(window), DOMRectBinding::Wrap)
}
}

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

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

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

@ -142,7 +142,7 @@ pub enum ElementTypeId {
HTMLVideoElementTypeId,
HTMLUnknownElementTypeId,
ElementTypeId,
ElementTypeId_,
}
//
@ -164,7 +164,7 @@ impl Element {
}
pub fn new(local_name: DOMString, namespace: Namespace, prefix: Option<DOMString>, document: JSRef<Document>) -> Temporary<Element> {
Node::reflect_node(box Element::new_inherited(ElementTypeId, local_name, namespace, prefix, document),
Node::reflect_node(box Element::new_inherited(ElementTypeId_, local_name, namespace, prefix, document),
document, ElementBinding::Wrap)
}
}

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

@ -5,7 +5,7 @@
use dom::bindings::codegen::Bindings::HTMLCollectionBinding;
use dom::bindings::codegen::Bindings::HTMLCollectionBinding::HTMLCollectionMethods;
use dom::bindings::codegen::InheritTypes::{ElementCast, NodeCast};
use dom::bindings::global::Window;
use dom::bindings::global;
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),
&Window(window), HTMLCollectionBinding::Wrap)
&global::Window(window), HTMLCollectionBinding::Wrap)
}
}
@ -191,8 +191,10 @@ impl<'a> HTMLCollectionMethods for JSRef<'a, HTMLCollection> {
root.deref().traverse_preorder()
.filter_map(|node| {
let elem: Option<JSRef<Element>> = ElementCast::to_ref(node);
elem.filtered(|&elem| filter.filter(elem, *root))
.map(|elem| elem.clone())
match elem {
Some(ref elem) if filter.filter(*elem, *root) => Some(elem.clone()),
_ => None
}
})
.nth(index as uint)
.clone()
@ -221,8 +223,10 @@ impl<'a> HTMLCollectionMethods for JSRef<'a, HTMLCollection> {
root.deref().traverse_preorder()
.filter_map(|node| {
let elem: Option<JSRef<Element>> = ElementCast::to_ref(node);
elem.filtered(|&elem| filter.filter(elem, *root))
.map(|elem| elem.clone())
match elem {
Some(ref elem) if filter.filter(*elem, *root) => Some(elem.clone()),
_ => None
}
})
.find(|elem| {
elem.get_string_attribute("name") == key ||

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

@ -12,7 +12,7 @@ use dom::bindings::codegen::InheritTypes::{HTMLElementDerived, HTMLBodyElementDe
use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector};
use dom::document::Document;
use dom::element::{Element, ElementTypeId, HTMLElementTypeId};
use dom::element::{Element, ElementTypeId, ElementTypeId_, HTMLElementTypeId};
use dom::eventtarget::{EventTarget, EventTargetHelpers, NodeTargetTypeId};
use dom::node::{Node, ElementNodeTypeId, window_from_node};
use dom::virtualmethods::VirtualMethods;
@ -30,7 +30,7 @@ pub struct HTMLElement {
impl HTMLElementDerived for EventTarget {
fn is_htmlelement(&self) -> bool {
match self.type_id {
NodeTargetTypeId(ElementNodeTypeId(ElementTypeId)) => false,
NodeTargetTypeId(ElementNodeTypeId(ElementTypeId_)) => false,
NodeTargetTypeId(ElementNodeTypeId(_)) => true,
_ => false
}

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

@ -94,7 +94,7 @@ impl<'a> HTMLScriptElementHelpers for JSRef<'a, HTMLScriptElement> {
},
Some(ref s) => {
debug!("script language={:s}", *s);
SCRIPT_JS_MIMES.contains(&"text/".to_string().append(s.as_slice()).as_slice())
SCRIPT_JS_MIMES.contains(&format!("text/{}", s).as_slice())
},
None => {
debug!("no script type or language, inferring js");

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

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

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

@ -7,7 +7,8 @@ use dom::bindings::codegen::Bindings::MouseEventBinding::MouseEventMethods;
use dom::bindings::codegen::Bindings::UIEventBinding::UIEventMethods;
use dom::bindings::codegen::InheritTypes::{UIEventCast, MouseEventDerived};
use dom::bindings::error::Fallible;
use dom::bindings::global::{GlobalRef, Window};
use dom::bindings::global::GlobalRef;
use dom::bindings::global;
use dom::bindings::js::{JS, JSRef, RootedReference, Temporary, OptionalSettable};
use dom::bindings::trace::Traceable;
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
@ -59,7 +60,7 @@ impl MouseEvent {
pub fn new_uninitialized(window: JSRef<Window>) -> Temporary<MouseEvent> {
reflect_dom_object(box MouseEvent::new_inherited(),
&Window(window),
&global::Window(window),
MouseEventBinding::Wrap)
}

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

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

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

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

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

@ -20,7 +20,8 @@ use dom::bindings::codegen::InheritTypes::{ProcessingInstructionCast, EventTarge
use dom::bindings::codegen::InheritTypes::{HTMLLegendElementDerived, HTMLFieldSetElementDerived};
use dom::bindings::codegen::InheritTypes::HTMLOptGroupElementDerived;
use dom::bindings::error::{Fallible, NotFound, HierarchyRequest, Syntax};
use dom::bindings::global::{GlobalRef, Window};
use dom::bindings::global::GlobalRef;
use dom::bindings::global;
use dom::bindings::js::{JS, JSRef, RootedReference, Temporary, Root, OptionalUnrootable};
use dom::bindings::js::{OptionalSettable, TemporaryPushable, OptionalRootedRootable};
use dom::bindings::js::{ResultRootable, OptionalRootable};
@ -203,9 +204,9 @@ impl LayoutDataRef {
/// Take the chan out of the layout data if it is present.
pub fn take_chan(&self) -> Option<LayoutChan> {
let mut layout_data = self.data_cell.borrow_mut();
match *layout_data {
None => None,
Some(..) => Some(layout_data.get_mut_ref().chan.take_unwrap()),
match &mut *layout_data {
&None => None,
&Some(ref mut layout_data) => Some(layout_data.chan.take().unwrap()),
}
}
@ -697,7 +698,7 @@ impl<'m, 'n> NodeHelpers<'m, 'n> for JSRef<'n, Node> {
fn summarize(&self) -> NodeInfo {
if self.unique_id.borrow().is_empty() {
let mut unique_id = self.unique_id.borrow_mut();
*unique_id = uuid::Uuid::new_v4().to_simple_str();
*unique_id = uuid::Uuid::new_v4().to_simple_string();
}
NodeInfo {
@ -1008,7 +1009,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, &Window(*window), wrap_fn)
reflect_dom_object(node, &global::Window(*window), wrap_fn)
}
pub fn new_inherited(type_id: NodeTypeId, doc: JSRef<Document>) -> Node {

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

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

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

@ -4,7 +4,7 @@
use dom::bindings::codegen::Bindings::PerformanceBinding;
use dom::bindings::codegen::Bindings::PerformanceBinding::PerformanceMethods;
use dom::bindings::global::Window;
use dom::bindings::global;
use dom::bindings::js::{JS, JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::performancetiming::{PerformanceTiming, PerformanceTimingHelpers};
@ -30,7 +30,7 @@ impl Performance {
pub fn new(window: JSRef<Window>) -> Temporary<Performance> {
reflect_dom_object(box Performance::new_inherited(window),
&Window(window),
&global::Window(window),
PerformanceBinding::Wrap)
}
}

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

@ -4,7 +4,7 @@
use dom::bindings::codegen::Bindings::PerformanceTimingBinding;
use dom::bindings::codegen::Bindings::PerformanceTimingBinding::PerformanceTimingMethods;
use dom::bindings::global::Window;
use dom::bindings::global;
use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::window::Window;
@ -31,7 +31,7 @@ impl PerformanceTiming {
pub fn new(window: JSRef<Window>) -> Temporary<PerformanceTiming> {
let timing = PerformanceTiming::new_inherited(window.navigationStart,
window.navigationStartPrecise);
reflect_dom_object(box timing, &Window(window),
reflect_dom_object(box timing, &global::Window(window),
PerformanceTimingBinding::Wrap)
}
}

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

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

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

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

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

@ -16,7 +16,7 @@ impl UrlHelper {
match url.query {
None => "".to_string(),
Some(ref query) if query.as_slice() == "" => "".to_string(),
Some(ref query) => "?".to_string().append(query.as_slice())
Some(ref query) => format!("?{}", query)
}
}
@ -24,7 +24,7 @@ impl UrlHelper {
match url.fragment {
None => "".to_string(),
Some(ref hash) if hash.as_slice() == "" => "".to_string(),
Some(ref hash) => "#".to_string().append(hash.as_slice())
Some(ref hash) => format!("#{}", hash)
}
}
}

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

@ -3,7 +3,7 @@
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
use dom::bindings::codegen::Bindings::ValidityStateBinding;
use dom::bindings::global::Window;
use dom::bindings::global;
use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::window::Window;
@ -25,7 +25,7 @@ impl ValidityState {
pub fn new(window: JSRef<Window>) -> Temporary<ValidityState> {
reflect_dom_object(box ValidityState::new_inherited(),
&Window(window),
&global::Window(window),
ValidityStateBinding::Wrap)
}
}

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

@ -23,7 +23,7 @@ use dom::bindings::codegen::InheritTypes::HTMLStyleElementCast;
use dom::bindings::codegen::InheritTypes::HTMLTextAreaElementCast;
use dom::bindings::js::JSRef;
use dom::element::Element;
use dom::element::ElementTypeId;
use dom::element::ElementTypeId_;
use dom::element::HTMLAnchorElementTypeId;
use dom::element::HTMLAreaElementTypeId;
use dom::element::HTMLBodyElementTypeId;
@ -204,7 +204,7 @@ pub fn vtable_for<'a>(node: &'a JSRef<'a, Node>) -> &'a VirtualMethods + 'a {
let element: &'a JSRef<'a, HTMLTextAreaElement> = HTMLTextAreaElementCast::to_borrowed_ref(node).unwrap();
element as &'a VirtualMethods + 'a
}
ElementNodeTypeId(ElementTypeId) => {
ElementNodeTypeId(ElementTypeId_) => {
let element: &'a JSRef<'a, Element> = ElementCast::to_borrowed_ref(node).unwrap();
element as &'a VirtualMethods + 'a
}

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

@ -6,7 +6,8 @@ use dom::bindings::codegen::Bindings::EventHandlerBinding::EventHandlerNonNull;
use dom::bindings::codegen::Bindings::XMLHttpRequestBinding;
use dom::bindings::codegen::Bindings::XMLHttpRequestBinding::XMLHttpRequestMethods;
use dom::bindings::codegen::Bindings::XMLHttpRequestBinding::XMLHttpRequestResponseType;
use dom::bindings::codegen::Bindings::XMLHttpRequestBinding::XMLHttpRequestResponseTypeValues::{_empty, Document, Json, Text};
use dom::bindings::codegen::Bindings::XMLHttpRequestBinding::XMLHttpRequestResponseTypeValues;
use dom::bindings::codegen::Bindings::XMLHttpRequestBinding::XMLHttpRequestResponseTypeValues::{_empty, Json, Text};
use dom::bindings::codegen::InheritTypes::{EventCast, EventTargetCast, XMLHttpRequestDerived};
use dom::bindings::conversions::ToJSValConvertible;
use dom::bindings::error::{Error, ErrorResult, Fallible, InvalidState, InvalidAccess};
@ -384,8 +385,8 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> {
// So this unsafe block should never fail
let mut buf = h.header_value();
buf.push_bytes(&[0x2C, 0x20]);
buf.push_bytes(value.as_slice());
buf.as_mut_vec().push_all(&[0x2C, 0x20]);
buf.as_mut_vec().push_all(value.as_slice());
value = ByteString::new(buf.container_into_owned_bytes());
}
@ -612,7 +613,8 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> {
}
fn SetResponseType(self, response_type: XMLHttpRequestResponseType) -> ErrorResult {
match self.global {
WorkerField(_) if response_type == Document => return Ok(()),
WorkerField(_) if response_type == XMLHttpRequestResponseTypeValues::Document
=> return Ok(()),
_ => {}
}
match self.ready_state.deref().get() {

16
components/script/script_task.rs
View file

@ -11,7 +11,7 @@ use dom::bindings::codegen::Bindings::ElementBinding::ElementMethods;
use dom::bindings::codegen::InheritTypes::{EventTargetCast, NodeCast, EventCast, ElementCast};
use dom::bindings::conversions;
use dom::bindings::conversions::{FromJSValConvertible, Empty};
use dom::bindings::global::Window;
use dom::bindings::global;
use dom::bindings::js::{JS, JSRef, RootCollection, Temporary, OptionalSettable};
use dom::bindings::js::OptionalRootable;
use dom::bindings::trace::JSTraceable;
@ -514,7 +514,7 @@ impl ScriptTask {
fn handle_evaluate_js(&self, pipeline: PipelineId, eval: String, reply: Sender<EvaluateJSReply>) {
let page = get_page(&*self.page.borrow(), pipeline);
let frame = page.frame();
let window = frame.get_ref().window.root();
let window = frame.as_ref().unwrap().window.root();
let cx = window.get_cx();
let rval = window.evaluate_js_with_result(eval.as_slice());
@ -537,7 +537,7 @@ impl ScriptTask {
fn handle_get_root_node(&self, pipeline: PipelineId, reply: Sender<NodeInfo>) {
let page = get_page(&*self.page.borrow(), pipeline);
let frame = page.frame();
let document = frame.get_ref().document.root();
let document = frame.as_ref().unwrap().document.root();
let node: JSRef<Node> = NodeCast::from_ref(*document);
reply.send(node.summarize());
@ -546,7 +546,7 @@ impl ScriptTask {
fn handle_get_document_element(&self, pipeline: PipelineId, reply: Sender<NodeInfo>) {
let page = get_page(&*self.page.borrow(), pipeline);
let frame = page.frame();
let document = frame.get_ref().document.root();
let document = frame.as_ref().unwrap().document.root();
let document_element = document.GetDocumentElement().root().unwrap();
let node: JSRef<Node> = NodeCast::from_ref(*document_element);
@ -556,7 +556,7 @@ impl ScriptTask {
fn find_node_by_unique_id(&self, pipeline: PipelineId, node_id: String) -> Temporary<Node> {
let page = get_page(&*self.page.borrow(), pipeline);
let frame = page.frame();
let document = frame.get_ref().document.root();
let document = frame.as_ref().unwrap().document.root();
let node: JSRef<Node> = NodeCast::from_ref(*document);
for candidate in node.traverse_preorder() {
@ -810,7 +810,7 @@ impl ScriptTask {
// Receive the JavaScript scripts.
assert!(js_scripts.is_some());
let js_scripts = js_scripts.take_unwrap();
let js_scripts = js_scripts.take().unwrap();
debug!("js_scripts: {:?}", js_scripts);
with_compartment((**cx).ptr, window.reflector().get_jsobject(), || {
@ -836,7 +836,7 @@ impl ScriptTask {
// We have no concept of a document loader right now, so just dispatch the
// "load" event as soon as we've finished executing all scripts parsed during
// the initial load.
let event = Event::new(&Window(*window), "load".to_string(), false, false).root();
let event = Event::new(&global::Window(*window), "load".to_string(), false, false).root();
let doctarget: JSRef<EventTarget> = EventTargetCast::from_ref(*document);
let wintarget: JSRef<EventTarget> = EventTargetCast::from_ref(*window);
let _ = wintarget.dispatch_event_with_target(Some(doctarget), *event);
@ -940,7 +940,7 @@ impl ScriptTask {
Some(ref frame) => {
let window = frame.window.root();
let event =
Event::new(&Window(*window),
Event::new(&global::Window(*window),
"click".to_string(),
true, true).root();
let eventtarget: JSRef<EventTarget> = EventTargetCast::from_ref(node);