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

Convert various helper traits from &JSRef to JSRef

Browse source 
I converted them all with a few exceptions:

- Methods that were used by trait objects, since trait objects don't
  work with `self` methods.
- Methods that take an &'b JSRef<'a, T> and return an &'b. In reality,
  many (all?) could return an &'a instead, but this isn't allowed by the
  Deref trait.
- Methods that internally rely on the same issue with Deref.
- I left out the traits involved in layout entirely, even though not all
  of their methods suffer from one of the above problems.

There will probably be solutions to all of these problems in the future.
This commit is contained in:
Cameron Zwarich 2014-09-19 19:57:50 -07:00
parent 2c8d51a37c
commit d768ee77ad
17 changed files with 196 additions and 196 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -147,14 +147,14 @@ impl<'a> AttrMethods for JSRef<'a, Attr> {
}
pub trait AttrHelpers {
fn set_value(&self, set_type: AttrSettingType, value: AttrValue);
fn set_value(self, set_type: AttrSettingType, value: AttrValue);
fn value<'a>(&'a self) -> Ref<'a, AttrValue>;
fn local_name<'a>(&'a self) -> &'a Atom;
fn summarize(&self) -> AttrInfo;
fn summarize(self) -> AttrInfo;
}
impl<'a> AttrHelpers for JSRef<'a, Attr> {
fn set_value(&self, set_type: AttrSettingType, value: AttrValue) {
fn set_value(self, set_type: AttrSettingType, value: AttrValue) {
let owner = self.owner.root();
let node: JSRef<Node> = NodeCast::from_ref(*owner);
let namespace_is_null = self.namespace == namespace::Null;
@ -187,7 +187,7 @@ impl<'a> AttrHelpers for JSRef<'a, Attr> {
&self.local_name
}
fn summarize(&self) -> AttrInfo {
fn summarize(self) -> AttrInfo {
AttrInfo {
namespace: self.namespace.to_str().to_string(),
name: self.Name(),

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

@ -175,11 +175,11 @@ impl<'a> DedicatedWorkerGlobalScopeMethods for JSRef<'a, DedicatedWorkerGlobalSc
}
trait PrivateDedicatedWorkerGlobalScopeHelpers {
fn delayed_release_worker(&self);
fn delayed_release_worker(self);
}
impl<'a> PrivateDedicatedWorkerGlobalScopeHelpers for JSRef<'a, DedicatedWorkerGlobalScope> {
fn delayed_release_worker(&self) {
fn delayed_release_worker(self) {
let ScriptChan(ref sender) = self.parent_sender;
sender.send(WorkerRelease(*self.worker));
}

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

@ -150,16 +150,16 @@ impl CollectionFilter for AppletsFilter {
pub trait DocumentHelpers {
fn url<'a>(&'a self) -> &'a Url;
fn quirks_mode(&self) -> QuirksMode;
fn set_quirks_mode(&self, mode: QuirksMode);
fn set_last_modified(&self, value: DOMString);
fn set_encoding_name(&self, name: DOMString);
fn content_changed(&self);
fn damage_and_reflow(&self, damage: DocumentDamageLevel);
fn wait_until_safe_to_modify_dom(&self);
fn unregister_named_element(&self, to_unregister: JSRef<Element>, id: DOMString);
fn register_named_element(&self, element: JSRef<Element>, id: DOMString);
fn load_anchor_href(&self, href: DOMString);
fn quirks_mode(self) -> QuirksMode;
fn set_quirks_mode(self, mode: QuirksMode);
fn set_last_modified(self, value: DOMString);
fn set_encoding_name(self, name: DOMString);
fn content_changed(self);
fn damage_and_reflow(self, damage: DocumentDamageLevel);
fn wait_until_safe_to_modify_dom(self);
fn unregister_named_element(self, to_unregister: JSRef<Element>, id: DOMString);
fn register_named_element(self, element: JSRef<Element>, id: DOMString);
fn load_anchor_href(self, href: DOMString);
}
impl<'a> DocumentHelpers for JSRef<'a, Document> {
@ -167,37 +167,37 @@ impl<'a> DocumentHelpers for JSRef<'a, Document> {
&*self.url
}
fn quirks_mode(&self) -> QuirksMode {
fn quirks_mode(self) -> QuirksMode {
self.quirks_mode.deref().get()
}
fn set_quirks_mode(&self, mode: QuirksMode) {
fn set_quirks_mode(self, mode: QuirksMode) {
self.quirks_mode.deref().set(mode);
}
fn set_last_modified(&self, value: DOMString) {
fn set_last_modified(self, value: DOMString) {
*self.last_modified.deref().borrow_mut() = Some(value);
}
fn set_encoding_name(&self, name: DOMString) {
fn set_encoding_name(self, name: DOMString) {
*self.encoding_name.deref().borrow_mut() = name;
}
fn content_changed(&self) {
fn content_changed(self) {
self.damage_and_reflow(ContentChangedDocumentDamage);
}
fn damage_and_reflow(&self, damage: DocumentDamageLevel) {
fn damage_and_reflow(self, damage: DocumentDamageLevel) {
self.window.root().damage_and_reflow(damage);
}
fn wait_until_safe_to_modify_dom(&self) {
fn wait_until_safe_to_modify_dom(self) {
self.window.root().wait_until_safe_to_modify_dom();
}
/// Remove any existing association between the provided id and any elements in this document.
fn unregister_named_element(&self,
fn unregister_named_element(self,
to_unregister: JSRef<Element>,
id: DOMString) {
let mut idmap = self.idmap.deref().borrow_mut();
@ -218,7 +218,7 @@ impl<'a> DocumentHelpers for JSRef<'a, Document> {
}
/// Associate an element present in this document with the provided id.
fn register_named_element(&self,
fn register_named_element(self,
element: JSRef<Element>,
id: DOMString) {
assert!({
@ -261,7 +261,7 @@ impl<'a> DocumentHelpers for JSRef<'a, Document> {
idmap.insert(id, elements);
}
fn load_anchor_href(&self, href: DOMString) {
fn load_anchor_href(self, href: DOMString) {
let window = self.window.root();
window.load_url(href);
}
@ -329,12 +329,12 @@ impl Reflectable for Document {
}
trait PrivateDocumentHelpers {
fn createNodeList(&self, callback: |node: JSRef<Node>| -> bool) -> Temporary<NodeList>;
fn get_html_element(&self) -> Option<Temporary<HTMLHtmlElement>>;
fn createNodeList(self, callback: |node: JSRef<Node>| -> bool) -> Temporary<NodeList>;
fn get_html_element(self) -> Option<Temporary<HTMLHtmlElement>>;
}
impl<'a> PrivateDocumentHelpers for JSRef<'a, Document> {
fn createNodeList(&self, callback: |node: JSRef<Node>| -> bool) -> Temporary<NodeList> {
fn createNodeList(self, callback: |node: JSRef<Node>| -> bool) -> Temporary<NodeList> {
let window = self.window.root();
match self.GetDocumentElement().root() {
@ -355,7 +355,7 @@ impl<'a> PrivateDocumentHelpers for JSRef<'a, Document> {
}
fn get_html_element(&self) -> Option<Temporary<HTMLHtmlElement>> {
fn get_html_element(self) -> Option<Temporary<HTMLHtmlElement>> {
self.GetDocumentElement().root().filtered(|root| {
let root: JSRef<Node> = NodeCast::from_ref(**root);
root.type_id() == ElementNodeTypeId(HTMLHtmlElementTypeId)

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

@ -49,17 +49,17 @@ impl Reflectable for DOMTokenList {
}
trait PrivateDOMTokenListHelpers {
fn attribute(&self) -> Option<Temporary<Attr>>;
fn check_token_exceptions<'a>(&self, token: &'a str) -> Fallible<&'a str>;
fn attribute(self) -> Option<Temporary<Attr>>;
fn check_token_exceptions<'a>(self, token: &'a str) -> Fallible<&'a str>;
}
impl<'a> PrivateDOMTokenListHelpers for JSRef<'a, DOMTokenList> {
fn attribute(&self) -> Option<Temporary<Attr>> {
fn attribute(self) -> Option<Temporary<Attr>> {
let element = self.element.root();
element.deref().get_attribute(Null, self.local_name)
}
fn check_token_exceptions<'a>(&self, token: &'a str) -> Fallible<&'a str> {
fn check_token_exceptions<'a>(self, token: &'a str) -> Fallible<&'a str> {
match token {
"" => Err(Syntax),
token if token.find(HTML_SPACE_CHARACTERS).is_some() => Err(InvalidCharacter),

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

@ -241,8 +241,8 @@ pub trait ElementHelpers {
fn html_element_in_html_document(&self) -> bool;
fn get_local_name<'a>(&'a self) -> &'a Atom;
fn get_namespace<'a>(&'a self) -> &'a Namespace;
fn summarize(&self) -> Vec<AttrInfo>;
fn is_void(&self) -> bool;
fn summarize(self) -> Vec<AttrInfo>;
fn is_void(self) -> bool;
}
impl<'a> ElementHelpers for JSRef<'a, Element> {
@ -259,7 +259,7 @@ impl<'a> ElementHelpers for JSRef<'a, Element> {
&self.deref().namespace
}
fn summarize(&self) -> Vec<AttrInfo> {
fn summarize(self) -> Vec<AttrInfo> {
let attrs = self.Attributes().root();
let mut i = 0;
let mut summarized = vec!();
@ -289,45 +289,45 @@ impl<'a> ElementHelpers for JSRef<'a, Element> {
pub trait AttributeHandlers {
/// Returns the attribute with given namespace and case-sensitive local
/// name, if any.
fn get_attribute(&self, namespace: Namespace, local_name: &str)
fn get_attribute(self, namespace: Namespace, local_name: &str)
-> Option<Temporary<Attr>>;
fn set_attribute_from_parser(&self, local_name: Atom,
fn set_attribute_from_parser(self, local_name: Atom,
value: DOMString, namespace: Namespace,
prefix: Option<DOMString>);
fn set_attribute(&self, name: &str, value: AttrValue);
fn do_set_attribute(&self, local_name: Atom, value: AttrValue,
fn set_attribute(self, name: &str, value: AttrValue);
fn do_set_attribute(self, local_name: Atom, value: AttrValue,
name: Atom, namespace: Namespace,
prefix: Option<DOMString>, cb: |JSRef<Attr>| -> bool);
fn parse_attribute(&self, namespace: &Namespace, local_name: &Atom,
fn parse_attribute(self, namespace: &Namespace, local_name: &Atom,
value: DOMString) -> AttrValue;
fn remove_attribute(&self, namespace: Namespace, name: &str);
fn notify_attribute_changed(&self, local_name: &Atom);
fn remove_attribute(self, namespace: Namespace, name: &str);
fn notify_attribute_changed(self, local_name: &Atom);
fn has_class(&self, name: &str) -> bool;
fn set_atomic_attribute(&self, name: &str, value: DOMString);
fn set_atomic_attribute(self, name: &str, value: DOMString);
// http://www.whatwg.org/html/#reflecting-content-attributes-in-idl-attributes
fn has_attribute(&self, name: &str) -> bool;
fn set_bool_attribute(&self, name: &str, value: bool);
fn get_url_attribute(&self, name: &str) -> DOMString;
fn set_url_attribute(&self, name: &str, value: DOMString);
fn get_string_attribute(&self, name: &str) -> DOMString;
fn set_string_attribute(&self, name: &str, value: DOMString);
fn set_tokenlist_attribute(&self, name: &str, value: DOMString);
fn get_uint_attribute(&self, name: &str) -> u32;
fn set_uint_attribute(&self, name: &str, value: u32);
fn has_attribute(self, name: &str) -> bool;
fn set_bool_attribute(self, name: &str, value: bool);
fn get_url_attribute(self, name: &str) -> DOMString;
fn set_url_attribute(self, name: &str, value: DOMString);
fn get_string_attribute(self, name: &str) -> DOMString;
fn set_string_attribute(self, name: &str, value: DOMString);
fn set_tokenlist_attribute(self, name: &str, value: DOMString);
fn get_uint_attribute(self, name: &str) -> u32;
fn set_uint_attribute(self, name: &str, value: u32);
}
impl<'a> AttributeHandlers for JSRef<'a, Element> {
fn get_attribute(&self, namespace: Namespace, local_name: &str) -> Option<Temporary<Attr>> {
fn get_attribute(self, namespace: Namespace, local_name: &str) -> Option<Temporary<Attr>> {
let local_name = Atom::from_slice(local_name);
self.attrs.borrow().iter().map(|attr| attr.root()).find(|attr| {
*attr.local_name() == local_name && attr.namespace == namespace
}).map(|x| Temporary::from_rooted(*x))
}
fn set_attribute_from_parser(&self, local_name: Atom,
fn set_attribute_from_parser(self, local_name: Atom,
value: DOMString, namespace: Namespace,
prefix: Option<DOMString>) {
let name = match prefix {
@ -341,11 +341,11 @@ impl<'a> AttributeHandlers for JSRef<'a, Element> {
self.do_set_attribute(local_name, value, name, namespace, prefix, |_| false)
}
fn set_attribute(&self, name: &str, value: AttrValue) {
fn set_attribute(self, name: &str, value: AttrValue) {
assert!(name == name.to_ascii_lower().as_slice());
assert!(!name.contains(":"));
let node: JSRef<Node> = NodeCast::from_ref(*self);
let node: JSRef<Node> = NodeCast::from_ref(self);
node.wait_until_safe_to_modify_dom();
let name = Atom::from_slice(name);
@ -353,7 +353,7 @@ impl<'a> AttributeHandlers for JSRef<'a, Element> {
namespace::Null, None, |attr| *attr.local_name() == name);
}
fn do_set_attribute(&self, local_name: Atom, value: AttrValue,
fn do_set_attribute(self, local_name: Atom, value: AttrValue,
name: Atom, namespace: Namespace,
prefix: Option<DOMString>, cb: |JSRef<Attr>| -> bool) {
let idx = self.deref().attrs.borrow().iter()
@ -362,9 +362,9 @@ impl<'a> AttributeHandlers for JSRef<'a, Element> {
let (idx, set_type) = match idx {
Some(idx) => (idx, ReplacedAttr),
None => {
let window = window_from_node(*self).root();
let window = window_from_node(self).root();
let attr = Attr::new(*window, local_name, value.clone(),
name, namespace.clone(), prefix, *self);
name, namespace.clone(), prefix, self);
self.deref().attrs.borrow_mut().push_unrooted(&attr);
(self.deref().attrs.borrow().len() - 1, FirstSetAttr)
}
@ -373,17 +373,17 @@ impl<'a> AttributeHandlers for JSRef<'a, Element> {
(*self.deref().attrs.borrow())[idx].root().set_value(set_type, value);
}
fn parse_attribute(&self, namespace: &Namespace, local_name: &Atom,
fn parse_attribute(self, namespace: &Namespace, local_name: &Atom,
value: DOMString) -> AttrValue {
if *namespace == namespace::Null {
vtable_for(&NodeCast::from_ref(*self))
vtable_for(&NodeCast::from_ref(self))
.parse_plain_attribute(local_name.as_slice(), value)
} else {
StringAttrValue(value)
}
}
fn remove_attribute(&self, namespace: Namespace, name: &str) {
fn remove_attribute(self, namespace: Namespace, name: &str) {
let (_, local_name) = get_attribute_parts(name);
let local_name = Atom::from_slice(local_name);
@ -395,13 +395,13 @@ impl<'a> AttributeHandlers for JSRef<'a, Element> {
None => (),
Some(idx) => {
{
let node: JSRef<Node> = NodeCast::from_ref(*self);
let node: JSRef<Node> = NodeCast::from_ref(self);
node.wait_until_safe_to_modify_dom();
}
if namespace == namespace::Null {
let removed_raw_value = (*self.deref().attrs.borrow())[idx].root().Value();
vtable_for(&NodeCast::from_ref(*self))
vtable_for(&NodeCast::from_ref(self))
.before_remove_attr(&local_name,
removed_raw_value);
}
@ -411,8 +411,8 @@ impl<'a> AttributeHandlers for JSRef<'a, Element> {
};
}
fn notify_attribute_changed(&self, local_name: &Atom) {
let node: JSRef<Node> = NodeCast::from_ref(*self);
fn notify_attribute_changed(self, local_name: &Atom) {
let node: JSRef<Node> = NodeCast::from_ref(self);
if node.is_in_doc() {
let damage = match local_name.as_slice() {
"style" | "id" | "class" => MatchSelectorsDocumentDamage,
@ -431,13 +431,13 @@ impl<'a> AttributeHandlers for JSRef<'a, Element> {
}).unwrap_or(false)
}
fn set_atomic_attribute(&self, name: &str, value: DOMString) {
fn set_atomic_attribute(self, name: &str, value: DOMString) {
assert!(name == name.to_ascii_lower().as_slice());
let value = AttrValue::from_atomic(value);
self.set_attribute(name, value);
}
fn has_attribute(&self, name: &str) -> bool {
fn has_attribute(self, name: &str) -> bool {
let name = match self.html_element_in_html_document() {
true => Atom::from_slice(name.to_ascii_lower().as_slice()),
false => Atom::from_slice(name)
@ -447,7 +447,7 @@ impl<'a> AttributeHandlers for JSRef<'a, Element> {
})
}
fn set_bool_attribute(&self, name: &str, value: bool) {
fn set_bool_attribute(self, name: &str, value: bool) {
if self.has_attribute(name) == value { return; }
if value {
self.set_string_attribute(name, String::new());
@ -456,16 +456,16 @@ impl<'a> AttributeHandlers for JSRef<'a, Element> {
}
}
fn get_url_attribute(&self, name: &str) -> DOMString {
fn get_url_attribute(self, name: &str) -> DOMString {
assert!(name == name.to_ascii_lower().as_slice());
// XXX Resolve URL.
self.get_string_attribute(name)
}
fn set_url_attribute(&self, name: &str, value: DOMString) {
fn set_url_attribute(self, name: &str, value: DOMString) {
self.set_string_attribute(name, value);
}
fn get_string_attribute(&self, name: &str) -> DOMString {
fn get_string_attribute(self, name: &str) -> DOMString {
assert!(name == name.to_ascii_lower().as_slice());
match self.get_attribute(Null, name) {
Some(x) => {
@ -475,17 +475,17 @@ impl<'a> AttributeHandlers for JSRef<'a, Element> {
None => "".to_string()
}
}
fn set_string_attribute(&self, name: &str, value: DOMString) {
fn set_string_attribute(self, name: &str, value: DOMString) {
assert!(name == name.to_ascii_lower().as_slice());
self.set_attribute(name, StringAttrValue(value));
}
fn set_tokenlist_attribute(&self, name: &str, value: DOMString) {
fn set_tokenlist_attribute(self, name: &str, value: DOMString) {
assert!(name == name.to_ascii_lower().as_slice());
self.set_attribute(name, AttrValue::from_tokenlist(value));
}
fn get_uint_attribute(&self, name: &str) -> u32 {
fn get_uint_attribute(self, name: &str) -> u32 {
assert!(name == name.to_ascii_lower().as_slice());
let attribute = self.get_attribute(Null, name).root();
match attribute {
@ -498,7 +498,7 @@ impl<'a> AttributeHandlers for JSRef<'a, Element> {
None => 0,
}
}
fn set_uint_attribute(&self, name: &str, value: u32) {
fn set_uint_attribute(self, name: &str, value: u32) {
assert!(name == name.to_ascii_lower().as_slice());
self.set_attribute(name, UIntAttrValue(value.to_string(), value));
}

34
components/script/dom/eventtarget.rs
View file

@ -94,37 +94,37 @@ impl EventTarget {
}
pub trait EventTargetHelpers {
fn dispatch_event_with_target<'a>(&self,
target: Option<JSRef<'a, EventTarget>>,
fn dispatch_event_with_target(self,
target: Option<JSRef<EventTarget>>,
event: JSRef<Event>) -> Fallible<bool>;
fn set_inline_event_listener(&self,
fn set_inline_event_listener(self,
ty: DOMString,
listener: Option<EventListener>);
fn get_inline_event_listener(&self, ty: DOMString) -> Option<EventListener>;
fn set_event_handler_uncompiled(&self,
fn get_inline_event_listener(self, ty: DOMString) -> Option<EventListener>;
fn set_event_handler_uncompiled(self,
cx: *mut JSContext,
url: Url,
scope: *mut JSObject,
ty: &str,
source: DOMString);
fn set_event_handler_common<T: CallbackContainer>(&self, ty: &str,
fn set_event_handler_common<T: CallbackContainer>(self, ty: &str,
listener: Option<T>);
fn get_event_handler_common<T: CallbackContainer>(&self, ty: &str) -> Option<T>;
fn get_event_handler_common<T: CallbackContainer>(self, ty: &str) -> Option<T>;
fn has_handlers(&self) -> bool;
fn has_handlers(self) -> bool;
}
impl<'a> EventTargetHelpers for JSRef<'a, EventTarget> {
fn dispatch_event_with_target<'b>(&self,
target: Option<JSRef<'b, EventTarget>>,
fn dispatch_event_with_target(self,
target: Option<JSRef<EventTarget>>,
event: JSRef<Event>) -> Fallible<bool> {
if event.deref().dispatching.deref().get() || !event.deref().initialized.deref().get() {
return Err(InvalidState);
}
Ok(dispatch_event(*self, target, event))
Ok(dispatch_event(self, target, event))
}
fn set_inline_event_listener(&self,
fn set_inline_event_listener(self,
ty: DOMString,
listener: Option<EventListener>) {
let mut handlers = self.handlers.deref().borrow_mut();
@ -156,7 +156,7 @@ impl<'a> EventTargetHelpers for JSRef<'a, EventTarget> {
}
}
fn get_inline_event_listener(&self, ty: DOMString) -> Option<EventListener> {
fn get_inline_event_listener(self, ty: DOMString) -> Option<EventListener> {
let handlers = self.handlers.deref().borrow();
let entries = handlers.find(&ty);
entries.and_then(|entries| entries.iter().find(|entry| {
@ -167,7 +167,7 @@ impl<'a> EventTargetHelpers for JSRef<'a, EventTarget> {
}).map(|entry| entry.listener.get_listener()))
}
fn set_event_handler_uncompiled(&self,
fn set_event_handler_uncompiled(self,
cx: *mut JSContext,
url: Url,
scope: *mut JSObject,
@ -207,19 +207,19 @@ impl<'a> EventTargetHelpers for JSRef<'a, EventTarget> {
}
fn set_event_handler_common<T: CallbackContainer>(
&self, ty: &str, listener: Option<T>)
self, ty: &str, listener: Option<T>)
{
let event_listener = listener.map(|listener|
EventListener::new(listener.callback()));
self.set_inline_event_listener(ty.to_string(), event_listener);
}
fn get_event_handler_common<T: CallbackContainer>(&self, ty: &str) -> Option<T> {
fn get_event_handler_common<T: CallbackContainer>(self, ty: &str) -> Option<T> {
let listener = self.get_inline_event_listener(ty.to_string());
listener.map(|listener| CallbackContainer::new(listener.parent.callback()))
}
fn has_handlers(&self) -> bool {
fn has_handlers(self) -> bool {
!self.handlers.deref().borrow().is_empty()
}
}

8
components/script/dom/htmlanchorelement.rs
View file

@ -50,19 +50,19 @@ impl HTMLAnchorElement {
}
trait PrivateHTMLAnchorElementHelpers {
fn handle_event_impl(&self, event: JSRef<Event>);
fn handle_event_impl(self, event: JSRef<Event>);
}
impl<'a> PrivateHTMLAnchorElementHelpers for JSRef<'a, HTMLAnchorElement> {
fn handle_event_impl(&self, event: JSRef<Event>) {
fn handle_event_impl(self, event: JSRef<Event>) {
if "click" == event.Type().as_slice() && !event.DefaultPrevented() {
let element: JSRef<Element> = ElementCast::from_ref(*self);
let element: JSRef<Element> = ElementCast::from_ref(self);
let attr = element.get_attribute(Null, "href").root();
match attr {
Some(ref href) => {
let value = href.Value();
debug!("clicked on link to {:s}", value);
let node: JSRef<Node> = NodeCast::from_ref(*self);
let node: JSRef<Node> = NodeCast::from_ref(self);
let doc = node.owner_doc().root();
doc.load_anchor_href(value);
}

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

@ -52,12 +52,12 @@ impl HTMLElement {
}
trait PrivateHTMLElementHelpers {
fn is_body_or_frameset(&self) -> bool;
fn is_body_or_frameset(self) -> bool;
}
impl<'a> PrivateHTMLElementHelpers for JSRef<'a, HTMLElement> {
fn is_body_or_frameset(&self) -> bool {
let eventtarget: JSRef<EventTarget> = EventTargetCast::from_ref(*self);
fn is_body_or_frameset(self) -> bool {
let eventtarget: JSRef<EventTarget> = EventTargetCast::from_ref(self);
eventtarget.is_htmlbodyelement() || eventtarget.is_htmlframesetelement()
}
}

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

@ -62,32 +62,32 @@ pub struct IFrameSize {
}
pub trait HTMLIFrameElementHelpers {
fn is_sandboxed(&self) -> bool;
fn get_url(&self) -> Option<Url>;
fn is_sandboxed(self) -> bool;
fn get_url(self) -> Option<Url>;
/// http://www.whatwg.org/html/#process-the-iframe-attributes
fn process_the_iframe_attributes(&self);
fn process_the_iframe_attributes(self);
}
impl<'a> HTMLIFrameElementHelpers for JSRef<'a, HTMLIFrameElement> {
fn is_sandboxed(&self) -> bool {
fn is_sandboxed(self) -> bool {
self.sandbox.deref().get().is_some()
}
fn get_url(&self) -> Option<Url> {
let element: JSRef<Element> = ElementCast::from_ref(*self);
fn get_url(self) -> Option<Url> {
let element: JSRef<Element> = ElementCast::from_ref(self);
element.get_attribute(Null, "src").root().and_then(|src| {
let url = src.deref().value();
if url.as_slice().is_empty() {
None
} else {
let window = window_from_node(*self).root();
let window = window_from_node(self).root();
UrlParser::new().base_url(&window.deref().page().get_url())
.parse(url.as_slice()).ok()
}
})
}
fn process_the_iframe_attributes(&self) {
fn process_the_iframe_attributes(self) {
let url = match self.get_url() {
Some(url) => url.clone(),
None => Url::parse("about:blank").unwrap(),
@ -100,7 +100,7 @@ impl<'a> HTMLIFrameElementHelpers for JSRef<'a, HTMLIFrameElement> {
};
// Subpage Id
let window = window_from_node(*self).root();
let window = window_from_node(self).root();
let page = window.deref().page();
let subpage_id = page.get_next_subpage_id();

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

@ -39,14 +39,14 @@ impl HTMLImageElementDerived for EventTarget {
}
trait PrivateHTMLImageElementHelpers {
fn update_image(&self, value: Option<(DOMString, &Url)>);
fn update_image(self, value: Option<(DOMString, &Url)>);
}
impl<'a> PrivateHTMLImageElementHelpers for JSRef<'a, HTMLImageElement> {
/// Makes the local `image` member match the status of the `src` attribute and starts
/// prefetching the image. This method must be called after `src` is changed.
fn update_image(&self, value: Option<(DOMString, &Url)>) {
let node: JSRef<Node> = NodeCast::from_ref(*self);
fn update_image(self, value: Option<(DOMString, &Url)>) {
let node: JSRef<Node> = NodeCast::from_ref(self);
let document = node.owner_doc().root();
let window = document.deref().window.root();
let image_cache = &window.image_cache_task;

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

@ -114,12 +114,12 @@ impl<'a> VirtualMethods for JSRef<'a, HTMLLinkElement> {
}
trait PrivateHTMLLinkElementHelpers {
fn handle_stylesheet_url(&self, href: &str);
fn handle_stylesheet_url(self, href: &str);
}
impl<'a> PrivateHTMLLinkElementHelpers for JSRef<'a, HTMLLinkElement> {
fn handle_stylesheet_url(&self, href: &str) {
let window = window_from_node(*self).root();
fn handle_stylesheet_url(self, href: &str) {
let window = window_from_node(self).root();
match UrlParser::new().base_url(&window.deref().page().get_url()).parse(href) {
Ok(url) => {
let LayoutChan(ref layout_chan) = *window.deref().page().layout_chan;

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

@ -48,7 +48,7 @@ impl HTMLScriptElement {
pub trait HTMLScriptElementHelpers {
/// Prepare a script (<http://www.whatwg.org/html/#prepare-a-script>),
/// steps 6 and 7.
fn is_javascript(&self) -> bool;
fn is_javascript(self) -> bool;
}
/// Supported script types as defined by
@ -73,8 +73,8 @@ static SCRIPT_JS_MIMES: StaticStringVec = &[
];
impl<'a> HTMLScriptElementHelpers for JSRef<'a, HTMLScriptElement> {
fn is_javascript(&self) -> bool {
let element: JSRef<Element> = ElementCast::from_ref(*self);
fn is_javascript(self) -> bool {
let element: JSRef<Element> = ElementCast::from_ref(self);
match element.get_attribute(Null, "type").root().map(|s| s.Value()) {
Some(ref s) if s.is_empty() => {
// type attr exists, but empty means js

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

@ -44,12 +44,12 @@ impl HTMLStyleElement {
}
pub trait StyleElementHelpers {
fn parse_own_css(&self);
fn parse_own_css(self);
}
impl<'a> StyleElementHelpers for JSRef<'a, HTMLStyleElement> {
fn parse_own_css(&self) {
let node: JSRef<Node> = NodeCast::from_ref(*self);
fn parse_own_css(self) {
let node: JSRef<Node> = NodeCast::from_ref(self);
assert!(node.is_in_doc());
let win = window_from_node(node).root();

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

@ -43,11 +43,11 @@ impl<'a> PerformanceTimingMethods for JSRef<'a, PerformanceTiming> {
}
pub trait PerformanceTimingHelpers {
fn NavigationStartPrecise(&self) -> f64;
fn NavigationStartPrecise(self) -> f64;
}
impl<'a> PerformanceTimingHelpers for JSRef<'a, PerformanceTiming> {
fn NavigationStartPrecise(&self) -> f64 {
fn NavigationStartPrecise(self) -> f64 {
self.navigationStartPrecise
}
}

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

@ -133,24 +133,24 @@ impl Reflectable for TreeWalker {
type NodeAdvancer<'a, 'b> = |node: JSRef<'a, Node>|: 'b -> Option<Temporary<Node>>;
trait PrivateTreeWalkerHelpers<'a, 'b> {
fn traverse_children(&self,
fn traverse_children(self,
next_child: NodeAdvancer<'a, 'b>,
next_sibling: NodeAdvancer<'a, 'b>)
-> Fallible<Option<Temporary<Node>>>;
fn traverse_siblings(&self,
fn traverse_siblings(self,
next_child: NodeAdvancer<'a, 'b>,
next_sibling: NodeAdvancer<'a, 'b>)
-> Fallible<Option<Temporary<Node>>>;
fn is_root_node(&self, node: JSRef<'a, Node>) -> bool;
fn is_current_node(&self, node: JSRef<'a, Node>) -> bool;
fn first_following_node_not_following_root(&self, node: JSRef<'a, Node>)
fn is_root_node(self, node: JSRef<'a, Node>) -> bool;
fn is_current_node(self, node: JSRef<'a, Node>) -> bool;
fn first_following_node_not_following_root(self, node: JSRef<'a, Node>)
-> Option<Temporary<Node>>;
fn accept_node(&self, node: JSRef<'a, Node>) -> Fallible<u16>;
fn accept_node(self, node: JSRef<'a, Node>) -> Fallible<u16>;
}
impl<'a, 'b> PrivateTreeWalkerHelpers<'a, 'b> for JSRef<'a, TreeWalker> {
// http://dom.spec.whatwg.org/#concept-traverse-children
fn traverse_children(&self,
fn traverse_children(self,
next_child: NodeAdvancer<'a, 'b>,
next_sibling: NodeAdvancer<'a, 'b>)
-> Fallible<Option<Temporary<Node>>> {
@ -229,7 +229,7 @@ impl<'a, 'b> PrivateTreeWalkerHelpers<'a, 'b> for JSRef<'a, TreeWalker> {
}
// http://dom.spec.whatwg.org/#concept-traverse-siblings
fn traverse_siblings(&self,
fn traverse_siblings(self,
next_child: NodeAdvancer<'a, 'b>,
next_sibling: NodeAdvancer<'a, 'b>)
-> Fallible<Option<Temporary<Node>>> {
@ -293,7 +293,7 @@ impl<'a, 'b> PrivateTreeWalkerHelpers<'a, 'b> for JSRef<'a, TreeWalker> {
}
// http://dom.spec.whatwg.org/#concept-tree-following
fn first_following_node_not_following_root(&self, node: JSRef<'a, Node>)
fn first_following_node_not_following_root(self, node: JSRef<'a, Node>)
-> Option<Temporary<Node>> {
// "An object A is following an object B if A and B are in the same tree
// and A comes after B in tree order."
@ -320,7 +320,7 @@ impl<'a, 'b> PrivateTreeWalkerHelpers<'a, 'b> for JSRef<'a, TreeWalker> {
}
// http://dom.spec.whatwg.org/#concept-node-filter
fn accept_node(&self, node: JSRef<'a, Node>) -> Fallible<u16> {
fn accept_node(self, node: JSRef<'a, Node>) -> Fallible<u16> {
// "To filter node run these steps:"
// "1. Let n be node's nodeType attribute value minus 1."
let n: uint = node.NodeType() as uint - 1;
@ -336,32 +336,32 @@ impl<'a, 'b> PrivateTreeWalkerHelpers<'a, 'b> for JSRef<'a, TreeWalker> {
match self.filter {
FilterNone => Ok(NodeFilterConstants::FILTER_ACCEPT),
FilterNative(f) => Ok((*f)(node)),
FilterJS(callback) => callback.AcceptNode_(*self, node, RethrowExceptions)
FilterJS(callback) => callback.AcceptNode_(self, node, RethrowExceptions)
}
}
fn is_root_node(&self, node: JSRef<'a, Node>) -> bool {
fn is_root_node(self, node: JSRef<'a, Node>) -> bool {
JS::from_rooted(node) == self.root_node
}
fn is_current_node(&self, node: JSRef<'a, Node>) -> bool {
fn is_current_node(self, node: JSRef<'a, Node>) -> bool {
JS::from_rooted(node) == self.current_node.get()
}
}
pub trait TreeWalkerHelpers<'a> {
fn parent_node(&self) -> Fallible<Option<Temporary<Node>>>;
fn first_child(&self) -> Fallible<Option<Temporary<Node>>>;
fn last_child(&self) -> Fallible<Option<Temporary<Node>>>;
fn next_sibling(&self) -> Fallible<Option<Temporary<Node>>>;
fn prev_sibling(&self) -> Fallible<Option<Temporary<Node>>>;
fn next_node(&self) -> Fallible<Option<Temporary<Node>>>;
fn prev_node(&self) -> Fallible<Option<Temporary<Node>>>;
fn parent_node(self) -> Fallible<Option<Temporary<Node>>>;
fn first_child(self) -> Fallible<Option<Temporary<Node>>>;
fn last_child(self) -> Fallible<Option<Temporary<Node>>>;
fn next_sibling(self) -> Fallible<Option<Temporary<Node>>>;
fn prev_sibling(self) -> Fallible<Option<Temporary<Node>>>;
fn next_node(self) -> Fallible<Option<Temporary<Node>>>;
fn prev_node(self) -> Fallible<Option<Temporary<Node>>>;
}
impl<'a> TreeWalkerHelpers<'a> for JSRef<'a, TreeWalker> {
// http://dom.spec.whatwg.org/#dom-treewalker-parentnode
fn parent_node(&self) -> Fallible<Option<Temporary<Node>>> {
fn parent_node(self) -> Fallible<Option<Temporary<Node>>> {
// "1. Let node be the value of the currentNode attribute."
let mut node = self.current_node.get().root().clone();
// "2. While node is not null and is not root, run these substeps:"
@ -389,35 +389,35 @@ impl<'a> TreeWalkerHelpers<'a> for JSRef<'a, TreeWalker> {
}
// http://dom.spec.whatwg.org/#dom-treewalker-firstchild
fn first_child(&self) -> Fallible<Option<Temporary<Node>>> {
fn first_child(self) -> Fallible<Option<Temporary<Node>>> {
// "The firstChild() method must traverse children of type first."
self.traverse_children(|node| node.first_child(),
|node| node.next_sibling())
}
// http://dom.spec.whatwg.org/#dom-treewalker-lastchild
fn last_child(&self) -> Fallible<Option<Temporary<Node>>> {
fn last_child(self) -> Fallible<Option<Temporary<Node>>> {
// "The lastChild() method must traverse children of type last."
self.traverse_children(|node| node.last_child(),
|node| node.prev_sibling())
}
// http://dom.spec.whatwg.org/#dom-treewalker-nextsibling
fn next_sibling(&self) -> Fallible<Option<Temporary<Node>>> {
fn next_sibling(self) -> Fallible<Option<Temporary<Node>>> {
// "The nextSibling() method must traverse siblings of type next."
self.traverse_siblings(|node| node.first_child(),
|node| node.next_sibling())
}
// http://dom.spec.whatwg.org/#dom-treewalker-previoussibling
fn prev_sibling(&self) -> Fallible<Option<Temporary<Node>>> {
fn prev_sibling(self) -> Fallible<Option<Temporary<Node>>> {
// "The previousSibling() method must traverse siblings of type previous."
self.traverse_siblings(|node| node.last_child(),
|node| node.prev_sibling())
}
// http://dom.spec.whatwg.org/#dom-treewalker-previousnode
fn prev_node(&self) -> Fallible<Option<Temporary<Node>>> {
fn prev_node(self) -> Fallible<Option<Temporary<Node>>> {
// "1. Let node be the value of the currentNode attribute."
let mut node = self.current_node.get().root().clone();
// "2. While node is not root, run these substeps:"
@ -478,7 +478,7 @@ impl<'a> TreeWalkerHelpers<'a> for JSRef<'a, TreeWalker> {
}
// http://dom.spec.whatwg.org/#dom-treewalker-nextnode
fn next_node(&self) -> Fallible<Option<Temporary<Node>>> {
fn next_node(self) -> Fallible<Option<Temporary<Node>>> {
// "1. Let node be the value of the currentNode attribute."
let mut node = self.current_node.get().root().clone();
// "2. Let result be FILTER_ACCEPT."

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

@ -364,21 +364,21 @@ impl Reflectable for Window {
}
pub trait WindowHelpers {
fn damage_and_reflow(&self, damage: DocumentDamageLevel);
fn flush_layout(&self, goal: ReflowGoal);
fn wait_until_safe_to_modify_dom(&self);
fn init_browser_context(&self, doc: JSRef<Document>);
fn load_url(&self, href: DOMString);
fn handle_fire_timer(&self, timer_id: TimerId, cx: *mut JSContext);
fn evaluate_js_with_result(&self, code: &str) -> JSVal;
fn damage_and_reflow(self, damage: DocumentDamageLevel);
fn flush_layout(self, goal: ReflowGoal);
fn wait_until_safe_to_modify_dom(self);
fn init_browser_context(self, doc: JSRef<Document>);
fn load_url(self, href: DOMString);
fn handle_fire_timer(self, timer_id: TimerId, cx: *mut JSContext);
fn evaluate_js_with_result(self, code: &str) -> JSVal;
}
trait PrivateWindowHelpers {
fn set_timeout_or_interval(&self, callback: JSVal, timeout: i32, is_interval: bool) -> i32;
fn set_timeout_or_interval(self, callback: JSVal, timeout: i32, is_interval: bool) -> i32;
}
impl<'a> WindowHelpers for JSRef<'a, Window> {
fn evaluate_js_with_result(&self, code: &str) -> JSVal {
fn evaluate_js_with_result(self, code: &str) -> JSVal {
let global = self.reflector().get_jsobject();
let code: Vec<u16> = code.as_slice().utf16_units().collect();
let mut rval = UndefinedValue();
@ -397,27 +397,27 @@ impl<'a> WindowHelpers for JSRef<'a, Window> {
})
}
fn damage_and_reflow(&self, damage: DocumentDamageLevel) {
fn damage_and_reflow(self, damage: DocumentDamageLevel) {
self.page().damage(damage);
self.page().avoided_reflows.set(self.page().avoided_reflows.get() + 1);
}
fn flush_layout(&self, goal: ReflowGoal) {
fn flush_layout(self, goal: ReflowGoal) {
self.page().flush_layout(goal);
}
fn wait_until_safe_to_modify_dom(&self) {
fn wait_until_safe_to_modify_dom(self) {
// FIXME: This disables concurrent layout while we are modifying the DOM, since
// our current architecture is entirely unsafe in the presence of races.
self.page().join_layout();
}
fn init_browser_context(&self, doc: JSRef<Document>) {
fn init_browser_context(self, doc: JSRef<Document>) {
*self.browser_context.deref().borrow_mut() = Some(BrowserContext::new(doc));
}
/// Commence a new URL load which will either replace this window or scroll to a fragment.
fn load_url(&self, href: DOMString) {
fn load_url(self, href: DOMString) {
let base_url = self.page().get_url();
debug!("current page url is {:?}", base_url);
let url = UrlParser::new().base_url(&base_url).parse(href.as_slice());
@ -431,7 +431,7 @@ impl<'a> WindowHelpers for JSRef<'a, Window> {
}
}
fn handle_fire_timer(&self, timer_id: TimerId, cx: *mut JSContext) {
fn handle_fire_timer(self, timer_id: TimerId, cx: *mut JSContext) {
let this_value = self.reflector().get_jsobject();
let data = match self.active_timers.deref().borrow().find(&timer_id) {
@ -455,7 +455,7 @@ impl<'a> WindowHelpers for JSRef<'a, Window> {
}
impl<'a> PrivateWindowHelpers for JSRef<'a, Window> {
fn set_timeout_or_interval(&self, callback: JSVal, timeout: i32, is_interval: bool) -> i32 {
fn set_timeout_or_interval(self, callback: JSVal, timeout: i32, is_interval: bool) -> i32 {
let timeout = cmp::max(0, timeout) as u64;
let handle = self.next_timer_handle.deref().get();
self.next_timer_handle.deref().set(handle + 1);

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

@ -692,23 +692,23 @@ impl TrustedXHRAddress {
trait PrivateXMLHttpRequestHelpers {
unsafe fn to_trusted(&self) -> TrustedXHRAddress;
fn release_once(&self);
fn change_ready_state(&self, XMLHttpRequestState);
fn process_partial_response(&self, progress: XHRProgress);
fn insert_trusted_header(&self, name: String, value: String);
fn dispatch_progress_event(&self, upload: bool, type_: DOMString, loaded: u64, total: Option<u64>);
fn dispatch_upload_progress_event(&self, type_: DOMString, partial_load: Option<u64>);
fn dispatch_response_progress_event(&self, type_: DOMString);
fn text_response(&self) -> DOMString;
fn set_timeout(&self, timeout:u32);
fn cancel_timeout(&self);
fn filter_response_headers(&self) -> ResponseHeaderCollection;
unsafe fn to_trusted(self) -> TrustedXHRAddress;
fn release_once(self);
fn change_ready_state(self, XMLHttpRequestState);
fn process_partial_response(self, progress: XHRProgress);
fn insert_trusted_header(self, name: String, value: String);
fn dispatch_progress_event(self, upload: bool, type_: DOMString, loaded: u64, total: Option<u64>);
fn dispatch_upload_progress_event(self, type_: DOMString, partial_load: Option<u64>);
fn dispatch_response_progress_event(self, type_: DOMString);
fn text_response(self) -> DOMString;
fn set_timeout(self, timeout:u32);
fn cancel_timeout(self);
fn filter_response_headers(self) -> ResponseHeaderCollection;
}
impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
// Creates a trusted address to the object, and roots it. Always pair this with a release()
unsafe fn to_trusted(&self) -> TrustedXHRAddress {
unsafe fn to_trusted(self) -> TrustedXHRAddress {
if self.pinned_count.deref().get() == 0 {
JS_AddObjectRoot(self.global.root().root_ref().get_cx(), self.reflector().rootable());
}
@ -717,7 +717,7 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
TrustedXHRAddress(self.deref() as *const XMLHttpRequest as *const libc::c_void)
}
fn release_once(&self) {
fn release_once(self) {
if self.sync.deref().get() {
// Lets us call this at various termination cases without having to
// check self.sync every time, since the pinning mechanism only is
@ -734,18 +734,18 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
}
}
fn change_ready_state(&self, rs: XMLHttpRequestState) {
fn change_ready_state(self, rs: XMLHttpRequestState) {
assert!(self.ready_state.deref().get() != rs)
self.ready_state.deref().set(rs);
let global = self.global.root();
let event = Event::new(&global.root_ref(),
"readystatechange".to_string(),
false, true).root();
let target: JSRef<EventTarget> = EventTargetCast::from_ref(*self);
let target: JSRef<EventTarget> = EventTargetCast::from_ref(self);
target.dispatch_event_with_target(None, *event).ok();
}
fn process_partial_response(&self, progress: XHRProgress) {
fn process_partial_response(self, progress: XHRProgress) {
match progress {
HeadersReceivedMsg(headers, status) => {
// For synchronous requests, this should not fire any events, and just store data
@ -845,7 +845,7 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
}
}
fn insert_trusted_header(&self, name: String, value: String) {
fn insert_trusted_header(self, name: String, value: String) {
// Insert a header without checking spec-compliance
// Use for hardcoded headers
let mut collection = self.request_headers.deref().borrow_mut();
@ -857,7 +857,7 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
collection.insert(maybe_header.unwrap());
}
fn dispatch_progress_event(&self, upload: bool, type_: DOMString, loaded: u64, total: Option<u64>) {
fn dispatch_progress_event(self, upload: bool, type_: DOMString, loaded: u64, total: Option<u64>) {
let global = self.global.root();
let upload_target = *self.upload.root();
let progressevent = ProgressEvent::new(&global.root_ref(),
@ -867,25 +867,25 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
let target: JSRef<EventTarget> = if upload {
EventTargetCast::from_ref(upload_target)
} else {
EventTargetCast::from_ref(*self)
EventTargetCast::from_ref(self)
};
let event: JSRef<Event> = EventCast::from_ref(*progressevent);
target.dispatch_event_with_target(None, event).ok();
}
fn dispatch_upload_progress_event(&self, type_: DOMString, partial_load: Option<u64>) {
fn dispatch_upload_progress_event(self, type_: DOMString, partial_load: Option<u64>) {
// If partial_load is None, loading has completed and we can just use the value from the request body
let total = self.request_body_len.get() as u64;
self.dispatch_progress_event(true, type_, partial_load.unwrap_or(total), Some(total));
}
fn dispatch_response_progress_event(&self, type_: DOMString) {
fn dispatch_response_progress_event(self, type_: DOMString) {
let len = self.response.deref().borrow().len() as u64;
let total = self.response_headers.deref().borrow().content_length.map(|x| {x as u64});
self.dispatch_progress_event(false, type_, len, total);
}
fn set_timeout(&self, timeout: u32) {
fn set_timeout(self, timeout: u32) {
// Sets up the object to timeout in a given number of milliseconds
// This will cancel all previous timeouts
let oneshot = self.timer.deref().borrow_mut().oneshot(timeout as u64);
@ -916,7 +916,7 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
}
);
}
fn cancel_timeout(&self) {
fn cancel_timeout(self) {
// Cancels timeouts on the object, if any
if self.timeout_pinned.deref().get() {
self.timeout_pinned.deref().set(false);
@ -925,7 +925,7 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
// oneshot() closes the previous channel, canceling the timeout
self.timer.deref().borrow_mut().oneshot(0);
}
fn text_response(&self) -> DOMString {
fn text_response(self) -> DOMString {
let mut encoding = UTF_8 as EncodingRef;
match self.response_headers.deref().borrow().content_type {
Some(ref x) => {
@ -941,7 +941,7 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
// the result should be fine. XXXManishearth have a closer look at this later
encoding.decode(self.response.deref().borrow().as_slice(), DecodeReplace).unwrap().to_string()
}
fn filter_response_headers(&self) -> ResponseHeaderCollection {
fn filter_response_headers(self) -> ResponseHeaderCollection {
// http://fetch.spec.whatwg.org/#concept-response-header-list
let mut headers = ResponseHeaderCollection::new();
for header in self.response_headers.deref().borrow().iter() {