Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-08-04 13:10:20 +01:00
Code Issues Projects Releases Packages Wiki Activity

Remove Traceable/Untraceable from xmlhttprequest.rs

Browse source
This commit is contained in:
Manish Goregaokar 2014-09-29 05:39:35 +05:30
parent 87df84fcf8
commit 5c8a45d74e
2 changed files with 144 additions and 152 deletions
Download patch file Download diff file Expand all files Collapse all files

23
components/script/dom/bindings/trace.rs
View file

@ -45,6 +45,10 @@ use std::comm::{Receiver, Sender};
use hubbub::hubbub::QuirksMode; use hubbub::hubbub::QuirksMode;
use string_cache::{Atom, Namespace}; use string_cache::{Atom, Namespace};
use js::rust::Cx; use js::rust::Cx;
use http::headers::response::HeaderCollection as ResponseHeaderCollection;
use http::headers::request::HeaderCollection as RequestHeaderCollection;
use http::method::Method;
use std::io::timer::Timer;
impl<T: Reflectable> JSTraceable for JS<T> { impl<T: Reflectable> JSTraceable for JS<T> {
fn trace(&self, trc: *mut JSTracer) { fn trace(&self, trc: *mut JSTracer) {
@ -227,14 +231,17 @@ untraceable!(bool, f32, f64, String, Url)
untraceable!(uint, u8, u16, u32, u64) untraceable!(uint, u8, u16, u32, u64)
untraceable!(int, i8, i16, i32, i64) untraceable!(int, i8, i16, i32, i64)
untraceable!(Untraceable<T>) untraceable!(Untraceable<T>)
untraceable!(Sender<T>)
untraceable!(Receiver<T>)
untraceable!(ImageCacheTask, ScriptControlChan) untraceable!(ImageCacheTask, ScriptControlChan)
untraceable!(Atom, Namespace) untraceable!(Atom, Namespace, Timer)
untraceable!(PropertyDeclarationBlock) untraceable!(PropertyDeclarationBlock)
// These three are interdependent, if you plan to put jsmanaged data // These three are interdependent, if you plan to put jsmanaged data
// in one of these make sure it is propagated properly to containing structs // in one of these make sure it is propagated properly to containing structs
untraceable!(SubpageId, WindowSizeData, PipelineId) untraceable!(SubpageId, WindowSizeData, PipelineId)
untraceable!(QuirksMode) untraceable!(QuirksMode)
untraceable!(Cx) untraceable!(Cx)
untraceable!(ResponseHeaderCollection, RequestHeaderCollection, Method)
impl<'a> JSTraceable for &'a str { impl<'a> JSTraceable for &'a str {
#[inline] #[inline]
@ -243,20 +250,6 @@ impl<'a> JSTraceable for &'a str {
} }
} }
impl<T> JSTraceable for Sender<T> {
#[inline]
fn trace(&self, _: *mut JSTracer) {
// Do nothing
}
}
impl<T> JSTraceable for Receiver<T> {
#[inline]
fn trace(&self, _: *mut JSTracer) {
// Do nothing
}
}
impl<A,B> JSTraceable for fn(A) -> B { impl<A,B> JSTraceable for fn(A) -> B {
#[inline] #[inline]
fn trace(&self, _: *mut JSTracer) { fn trace(&self, _: *mut JSTracer) {

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

@ -15,7 +15,6 @@ use dom::bindings::error::{Network, Syntax, Security, Abort, Timeout};
use dom::bindings::global::{GlobalField, GlobalRef, WorkerField}; use dom::bindings::global::{GlobalField, GlobalRef, WorkerField};
use dom::bindings::js::{MutNullableJS, JS, JSRef, Temporary, OptionalRootedRootable}; use dom::bindings::js::{MutNullableJS, JS, JSRef, Temporary, OptionalRootedRootable};
use dom::bindings::str::ByteString; use dom::bindings::str::ByteString;
use dom::bindings::trace::{Traceable, Untraceable};
use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object}; use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
use dom::document::Document; use dom::document::Document;
use dom::event::Event; use dom::event::Event;
@ -107,68 +106,68 @@ enum SyncOrAsync<'a> {
#[must_root] #[must_root]
pub struct XMLHttpRequest { pub struct XMLHttpRequest {
eventtarget: XMLHttpRequestEventTarget, eventtarget: XMLHttpRequestEventTarget,
ready_state: Traceable<Cell<XMLHttpRequestState>>, ready_state: Cell<XMLHttpRequestState>,
timeout: Traceable<Cell<u32>>, timeout: Cell<u32>,
with_credentials: Traceable<Cell<bool>>, with_credentials: Cell<bool>,
upload: JS<XMLHttpRequestUpload>, upload: JS<XMLHttpRequestUpload>,
response_url: DOMString, response_url: DOMString,
status: Traceable<Cell<u16>>, status: Cell<u16>,
status_text: Traceable<RefCell<ByteString>>, status_text: RefCell<ByteString>,
response: Traceable<RefCell<ByteString>>, response: RefCell<ByteString>,
response_type: Traceable<Cell<XMLHttpRequestResponseType>>, response_type: Cell<XMLHttpRequestResponseType>,
response_xml: MutNullableJS<Document>, response_xml: MutNullableJS<Document>,
response_headers: Untraceable<RefCell<ResponseHeaderCollection>>, response_headers: RefCell<ResponseHeaderCollection>,
// Associated concepts // Associated concepts
request_method: Untraceable<RefCell<Method>>, request_method: RefCell<Method>,
request_url: Untraceable<RefCell<Option<Url>>>, request_url: RefCell<Option<Url>>,
request_headers: Untraceable<RefCell<RequestHeaderCollection>>, request_headers: RefCell<RequestHeaderCollection>,
request_body_len: Traceable<Cell<uint>>, request_body_len: Cell<uint>,
sync: Traceable<Cell<bool>>, sync: Cell<bool>,
upload_complete: Traceable<Cell<bool>>, upload_complete: Cell<bool>,
upload_events: Traceable<Cell<bool>>, upload_events: Cell<bool>,
send_flag: Traceable<Cell<bool>>, send_flag: Cell<bool>,
global: GlobalField, global: GlobalField,
pinned_count: Traceable<Cell<uint>>, pinned_count: Cell<uint>,
timer: Untraceable<RefCell<Timer>>, timer: RefCell<Timer>,
fetch_time: Traceable<Cell<i64>>, fetch_time: Cell<i64>,
timeout_pinned: Traceable<Cell<bool>>, timeout_pinned: Cell<bool>,
terminate_sender: Untraceable<RefCell<Option<Sender<Error>>>>, terminate_sender: RefCell<Option<Sender<Error>>>,
} }
impl XMLHttpRequest { impl XMLHttpRequest {
fn new_inherited(global: &GlobalRef) -> XMLHttpRequest { fn new_inherited(global: &GlobalRef) -> XMLHttpRequest {
XMLHttpRequest { XMLHttpRequest {
eventtarget: XMLHttpRequestEventTarget::new_inherited(XMLHttpRequestTypeId), eventtarget: XMLHttpRequestEventTarget::new_inherited(XMLHttpRequestTypeId),
ready_state: Traceable::new(Cell::new(Unsent)), ready_state: Cell::new(Unsent),
timeout: Traceable::new(Cell::new(0u32)), timeout: Cell::new(0u32),
with_credentials: Traceable::new(Cell::new(false)), with_credentials: Cell::new(false),
upload: JS::from_rooted(XMLHttpRequestUpload::new(global)), upload: JS::from_rooted(XMLHttpRequestUpload::new(global)),
response_url: "".to_string(), response_url: "".to_string(),
status: Traceable::new(Cell::new(0)), status: Cell::new(0),
status_text: Traceable::new(RefCell::new(ByteString::new(vec!()))), status_text: RefCell::new(ByteString::new(vec!())),
response: Traceable::new(RefCell::new(ByteString::new(vec!()))), response: RefCell::new(ByteString::new(vec!())),
response_type: Traceable::new(Cell::new(_empty)), response_type: Cell::new(_empty),
response_xml: Default::default(), response_xml: Default::default(),
response_headers: Untraceable::new(RefCell::new(ResponseHeaderCollection::new())), response_headers: RefCell::new(ResponseHeaderCollection::new()),
request_method: Untraceable::new(RefCell::new(Get)), request_method: RefCell::new(Get),
request_url: Untraceable::new(RefCell::new(None)), request_url: RefCell::new(None),
request_headers: Untraceable::new(RefCell::new(RequestHeaderCollection::new())), request_headers: RefCell::new(RequestHeaderCollection::new()),
request_body_len: Traceable::new(Cell::new(0)), request_body_len: Cell::new(0),
sync: Traceable::new(Cell::new(false)), sync: Cell::new(false),
send_flag: Traceable::new(Cell::new(false)), send_flag: Cell::new(false),
upload_complete: Traceable::new(Cell::new(false)), upload_complete: Cell::new(false),
upload_events: Traceable::new(Cell::new(false)), upload_events: Cell::new(false),
global: GlobalField::from_rooted(global), global: GlobalField::from_rooted(global),
pinned_count: Traceable::new(Cell::new(0)), pinned_count: Cell::new(0),
timer: Untraceable::new(RefCell::new(Timer::new().unwrap())), timer: RefCell::new(Timer::new().unwrap()),
fetch_time: Traceable::new(Cell::new(0)), fetch_time: Cell::new(0),
timeout_pinned: Traceable::new(Cell::new(false)), timeout_pinned: Cell::new(false),
terminate_sender: Untraceable::new(RefCell::new(None)), terminate_sender: RefCell::new(None),
} }
} }
pub fn new(global: &GlobalRef) -> Temporary<XMLHttpRequest> { pub fn new(global: &GlobalRef) -> Temporary<XMLHttpRequest> {
@ -276,7 +275,7 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> {
} }
fn ReadyState(self) -> u16 { fn ReadyState(self) -> u16 {
self.ready_state.deref().get() as u16 self.ready_state.get() as u16
} }
fn Open(self, method: ByteString, url: DOMString) -> ErrorResult { fn Open(self, method: ByteString, url: DOMString) -> ErrorResult {
@ -306,7 +305,7 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> {
Some(ExtensionMethod(ref t)) if t.as_slice() == "TRACK" => Err(Security), Some(ExtensionMethod(ref t)) if t.as_slice() == "TRACK" => Err(Security),
Some(_) if method.is_token() => { Some(_) if method.is_token() => {
*self.request_method.deref().borrow_mut() = maybe_method.unwrap(); *self.request_method.borrow_mut() = maybe_method.unwrap();
// Step 6 // Step 6
let base = self.global.root().root_ref().get_url(); let base = self.global.root().root_ref().get_url();
@ -315,22 +314,22 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> {
Err(_) => return Err(Syntax) // Step 7 Err(_) => return Err(Syntax) // Step 7
}; };
// XXXManishearth Do some handling of username/passwords // XXXManishearth Do some handling of username/passwords
if self.sync.deref().get() { if self.sync.get() {
// FIXME: This should only happen if the global environment is a document environment // FIXME: This should only happen if the global environment is a document environment
if self.timeout.deref().get() != 0 || self.with_credentials.deref().get() || self.response_type.deref().get() != _empty { if self.timeout.get() != 0 || self.with_credentials.get() || self.response_type.get() != _empty {
return Err(InvalidAccess) return Err(InvalidAccess)
} }
} }
// XXXManishearth abort existing requests // XXXManishearth abort existing requests
// Step 12 // Step 12
*self.request_url.deref().borrow_mut() = Some(parsed_url); *self.request_url.borrow_mut() = Some(parsed_url);
*self.request_headers.deref().borrow_mut() = RequestHeaderCollection::new(); *self.request_headers.borrow_mut() = RequestHeaderCollection::new();
self.send_flag.deref().set(false); self.send_flag.set(false);
*self.status_text.deref().borrow_mut() = ByteString::new(vec!()); *self.status_text.borrow_mut() = ByteString::new(vec!());
self.status.deref().set(0); self.status.set(0);
// Step 13 // Step 13
if self.ready_state.deref().get() != Opened { if self.ready_state.get() != Opened {
self.change_ready_state(Opened); self.change_ready_state(Opened);
} }
Ok(()) Ok(())
@ -342,11 +341,11 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> {
} }
fn Open_(self, method: ByteString, url: DOMString, async: bool, fn Open_(self, method: ByteString, url: DOMString, async: bool,
_username: Option<DOMString>, _password: Option<DOMString>) -> ErrorResult { _username: Option<DOMString>, _password: Option<DOMString>) -> ErrorResult {
self.sync.deref().set(!async); self.sync.set(!async);
self.Open(method, url) self.Open(method, url)
} }
fn SetRequestHeader(self, name: ByteString, mut value: ByteString) -> ErrorResult { fn SetRequestHeader(self, name: ByteString, mut value: ByteString) -> ErrorResult {
if self.ready_state.deref().get() != Opened || self.send_flag.deref().get() { if self.ready_state.get() != Opened || self.send_flag.get() {
return Err(InvalidState); // Step 1, 2 return Err(InvalidState); // Step 1, 2
} }
if !name.is_token() || !value.is_field_value() { if !name.is_token() || !value.is_field_value() {
@ -371,7 +370,7 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> {
}, },
None => return Err(Syntax) None => return Err(Syntax)
}; };
let mut collection = self.request_headers.deref().borrow_mut(); let mut collection = self.request_headers.borrow_mut();
// Steps 6,7 // Steps 6,7
@ -410,20 +409,20 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> {
} }
} }
fn Timeout(self) -> u32 { fn Timeout(self) -> u32 {
self.timeout.deref().get() self.timeout.get()
} }
fn SetTimeout(self, timeout: u32) -> ErrorResult { fn SetTimeout(self, timeout: u32) -> ErrorResult {
if self.sync.deref().get() { if self.sync.get() {
// FIXME: Not valid for a worker environment // FIXME: Not valid for a worker environment
Err(InvalidState) Err(InvalidState)
} else { } else {
self.timeout.deref().set(timeout); self.timeout.set(timeout);
if self.send_flag.deref().get() { if self.send_flag.get() {
if timeout == 0 { if timeout == 0 {
self.cancel_timeout(); self.cancel_timeout();
return Ok(()); return Ok(());
} }
let progress = time::now().to_timespec().sec - self.fetch_time.deref().get(); let progress = time::now().to_timespec().sec - self.fetch_time.get();
if timeout > (progress * 1000) as u32 { if timeout > (progress * 1000) as u32 {
self.set_timeout(timeout - (progress * 1000) as u32); self.set_timeout(timeout - (progress * 1000) as u32);
} else { } else {
@ -435,20 +434,20 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> {
} }
} }
fn WithCredentials(self) -> bool { fn WithCredentials(self) -> bool {
self.with_credentials.deref().get() self.with_credentials.get()
} }
fn SetWithCredentials(self, with_credentials: bool) { fn SetWithCredentials(self, with_credentials: bool) {
self.with_credentials.deref().set(with_credentials); self.with_credentials.set(with_credentials);
} }
fn Upload(self) -> Temporary<XMLHttpRequestUpload> { fn Upload(self) -> Temporary<XMLHttpRequestUpload> {
Temporary::new(self.upload) Temporary::new(self.upload)
} }
fn Send(self, data: Option<SendParam>) -> ErrorResult { fn Send(self, data: Option<SendParam>) -> ErrorResult {
if self.ready_state.deref().get() != Opened || self.send_flag.deref().get() { if self.ready_state.get() != Opened || self.send_flag.get() {
return Err(InvalidState); // Step 1, 2 return Err(InvalidState); // Step 1, 2
} }
let data = match *self.request_method.deref().borrow() { let data = match *self.request_method.borrow() {
Get | Head => None, // Step 3 Get | Head => None, // Step 3
_ => data _ => data
}; };
@ -456,15 +455,15 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> {
self.request_body_len.set(extracted.as_ref().map(|e| e.len()).unwrap_or(0)); self.request_body_len.set(extracted.as_ref().map(|e| e.len()).unwrap_or(0));
// Step 6 // Step 6
self.upload_events.deref().set(false); self.upload_events.set(false);
// Step 7 // Step 7
self.upload_complete.deref().set(match extracted { self.upload_complete.set(match extracted {
None => true, None => true,
Some (ref v) if v.len() == 0 => true, Some (ref v) if v.len() == 0 => true,
_ => false _ => false
}); });
let mut addr = None; let mut addr = None;
if !self.sync.deref().get() { if !self.sync.get() {
// If one of the event handlers below aborts the fetch, // If one of the event handlers below aborts the fetch,
// the assertion in release_once() will fail since we haven't pinned it yet. // the assertion in release_once() will fail since we haven't pinned it yet.
// Pin early to avoid dealing with this // Pin early to avoid dealing with this
@ -476,29 +475,29 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> {
let upload_target = *self.upload.root(); let upload_target = *self.upload.root();
let event_target: JSRef<EventTarget> = EventTargetCast::from_ref(upload_target); let event_target: JSRef<EventTarget> = EventTargetCast::from_ref(upload_target);
if event_target.has_handlers() { if event_target.has_handlers() {
self.upload_events.deref().set(true); self.upload_events.set(true);
} }
// Step 9 // Step 9
self.send_flag.deref().set(true); self.send_flag.set(true);
self.dispatch_response_progress_event("loadstart".to_string()); self.dispatch_response_progress_event("loadstart".to_string());
if !self.upload_complete.deref().get() { if !self.upload_complete.get() {
self.dispatch_upload_progress_event("loadstart".to_string(), Some(0)); self.dispatch_upload_progress_event("loadstart".to_string(), Some(0));
} }
} }
if self.ready_state.deref().get() == Unsent { if self.ready_state.get() == Unsent {
// The progress events above might have run abort(), in which case we terminate the fetch. // The progress events above might have run abort(), in which case we terminate the fetch.
return Ok(()); return Ok(());
} }
let global = self.global.root(); let global = self.global.root();
let resource_task = global.root_ref().resource_task(); let resource_task = global.root_ref().resource_task();
let mut load_data = LoadData::new(self.request_url.deref().borrow().clone().unwrap()); let mut load_data = LoadData::new(self.request_url.borrow().clone().unwrap());
load_data.data = extracted; load_data.data = extracted;
// Default headers // Default headers
let request_headers = self.request_headers.deref(); let ref request_headers = self.request_headers;
if request_headers.borrow().content_type.is_none() { if request_headers.borrow().content_type.is_none() {
let parameters = vec!((String::from_str("charset"), String::from_str("UTF-8"))); let parameters = vec!((String::from_str("charset"), String::from_str("UTF-8")));
request_headers.borrow_mut().content_type = match data { request_headers.borrow_mut().content_type = match data {
@ -522,14 +521,14 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> {
request_headers.borrow_mut().accept = Some(String::from_str("*/*")) request_headers.borrow_mut().accept = Some(String::from_str("*/*"))
} }
load_data.headers = (*self.request_headers.deref().borrow()).clone(); load_data.headers = (*self.request_headers.borrow()).clone();
load_data.method = (*self.request_method.deref().borrow()).clone(); load_data.method = (*self.request_method.borrow()).clone();
let (terminate_sender, terminate_receiver) = channel(); let (terminate_sender, terminate_receiver) = channel();
*self.terminate_sender.deref().borrow_mut() = Some(terminate_sender); *self.terminate_sender.borrow_mut() = Some(terminate_sender);
// CORS stuff // CORS stuff
let referer_url = self.global.root().root_ref().get_url(); let referer_url = self.global.root().root_ref().get_url();
let mode = if self.upload_events.deref().get() { let mode = if self.upload_events.get() {
ForcedPreflightMode ForcedPreflightMode
} else { } else {
CORSMode CORSMode
@ -547,25 +546,25 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> {
buf.push_str(format!("{:u}", p).as_slice()); buf.push_str(format!("{:u}", p).as_slice());
}); });
referer_url.serialize_path().map(|ref h| buf.push_str(h.as_slice())); referer_url.serialize_path().map(|ref h| buf.push_str(h.as_slice()));
self.request_headers.deref().borrow_mut().referer = Some(buf); self.request_headers.borrow_mut().referer = Some(buf);
}, },
Ok(Some(ref req)) => self.insert_trusted_header("origin".to_string(), Ok(Some(ref req)) => self.insert_trusted_header("origin".to_string(),
format!("{}", req.origin)), format!("{}", req.origin)),
_ => {} _ => {}
} }
if self.sync.deref().get() { if self.sync.get() {
return XMLHttpRequest::fetch(&mut Sync(self), resource_task, load_data, return XMLHttpRequest::fetch(&mut Sync(self), resource_task, load_data,
terminate_receiver, cors_request); terminate_receiver, cors_request);
} else { } else {
let builder = TaskBuilder::new().named("XHRTask"); let builder = TaskBuilder::new().named("XHRTask");
self.fetch_time.deref().set(time::now().to_timespec().sec); self.fetch_time.set(time::now().to_timespec().sec);
let script_chan = global.root_ref().script_chan().clone(); let script_chan = global.root_ref().script_chan().clone();
builder.spawn(proc() { builder.spawn(proc() {
let _ = XMLHttpRequest::fetch(&mut Async(addr.unwrap(), script_chan), let _ = XMLHttpRequest::fetch(&mut Async(addr.unwrap(), script_chan),
resource_task, load_data, terminate_receiver, cors_request); resource_task, load_data, terminate_receiver, cors_request);
}); });
let timeout = self.timeout.deref().get(); let timeout = self.timeout.get();
if timeout > 0 { if timeout > 0 {
self.set_timeout(timeout); self.set_timeout(timeout);
} }
@ -573,22 +572,22 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> {
Ok(()) Ok(())
} }
fn Abort(self) { fn Abort(self) {
self.terminate_sender.deref().borrow().as_ref().map(|s| s.send_opt(Abort)); self.terminate_sender.borrow().as_ref().map(|s| s.send_opt(Abort));
match self.ready_state.deref().get() { match self.ready_state.get() {
Opened if self.send_flag.deref().get() => self.process_partial_response(ErroredMsg(Some(Abort))), Opened if self.send_flag.get() => self.process_partial_response(ErroredMsg(Some(Abort))),
HeadersReceived | Loading => self.process_partial_response(ErroredMsg(Some(Abort))), HeadersReceived | Loading => self.process_partial_response(ErroredMsg(Some(Abort))),
_ => {} _ => {}
}; };
self.ready_state.deref().set(Unsent); self.ready_state.set(Unsent);
} }
fn ResponseURL(self) -> DOMString { fn ResponseURL(self) -> DOMString {
self.response_url.clone() self.response_url.clone()
} }
fn Status(self) -> u16 { fn Status(self) -> u16 {
self.status.deref().get() self.status.get()
} }
fn StatusText(self) -> ByteString { fn StatusText(self) -> ByteString {
self.status_text.deref().borrow().clone() self.status_text.borrow().clone()
} }
fn GetResponseHeader(self, name: ByteString) -> Option<ByteString> { fn GetResponseHeader(self, name: ByteString) -> Option<ByteString> {
self.filter_response_headers().iter().find(|h| { self.filter_response_headers().iter().find(|h| {
@ -610,7 +609,7 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> {
ByteString::new(vec) ByteString::new(vec)
} }
fn ResponseType(self) -> XMLHttpRequestResponseType { fn ResponseType(self) -> XMLHttpRequestResponseType {
self.response_type.deref().get() self.response_type.get()
} }
fn SetResponseType(self, response_type: XMLHttpRequestResponseType) -> ErrorResult { fn SetResponseType(self, response_type: XMLHttpRequestResponseType) -> ErrorResult {
match self.global { match self.global {
@ -618,28 +617,28 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> {
=> return Ok(()), => return Ok(()),
_ => {} _ => {}
} }
match self.ready_state.deref().get() { match self.ready_state.get() {
Loading | XHRDone => Err(InvalidState), Loading | XHRDone => Err(InvalidState),
_ if self.sync.deref().get() => Err(InvalidAccess), _ if self.sync.get() => Err(InvalidAccess),
_ => { _ => {
self.response_type.deref().set(response_type); self.response_type.set(response_type);
Ok(()) Ok(())
} }
} }
} }
fn Response(self, cx: *mut JSContext) -> JSVal { fn Response(self, cx: *mut JSContext) -> JSVal {
match self.response_type.deref().get() { match self.response_type.get() {
_empty | Text => { _empty | Text => {
let ready_state = self.ready_state.deref().get(); let ready_state = self.ready_state.get();
if ready_state == XHRDone || ready_state == Loading { if ready_state == XHRDone || ready_state == Loading {
self.text_response().to_jsval(cx) self.text_response().to_jsval(cx)
} else { } else {
"".to_string().to_jsval(cx) "".to_string().to_jsval(cx)
} }
}, },
_ if self.ready_state.deref().get() != XHRDone => NullValue(), _ if self.ready_state.get() != XHRDone => NullValue(),
Json => { Json => {
let decoded = UTF_8.decode(self.response.deref().borrow().as_slice(), DecodeReplace).unwrap().to_string(); let decoded = UTF_8.decode(self.response.borrow().as_slice(), DecodeReplace).unwrap().to_string();
let decoded: Vec<u16> = decoded.as_slice().utf16_units().collect(); let decoded: Vec<u16> = decoded.as_slice().utf16_units().collect();
let mut vp = UndefinedValue(); let mut vp = UndefinedValue();
unsafe { unsafe {
@ -652,14 +651,14 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> {
} }
_ => { _ => {
// XXXManishearth handle other response types // XXXManishearth handle other response types
self.response.deref().borrow().to_jsval(cx) self.response.borrow().to_jsval(cx)
} }
} }
} }
fn GetResponseText(self) -> Fallible<DOMString> { fn GetResponseText(self) -> Fallible<DOMString> {
match self.response_type.deref().get() { match self.response_type.get() {
_empty | Text => { _empty | Text => {
match self.ready_state.deref().get() { match self.ready_state.get() {
Loading | XHRDone => Ok(self.text_response()), Loading | XHRDone => Ok(self.text_response()),
_ => Ok("".to_string()) _ => Ok("".to_string())
} }
@ -716,25 +715,25 @@ trait PrivateXMLHttpRequestHelpers {
impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> { impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
// Creates a trusted address to the object, and roots it. Always pair this with a release() // 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 { if self.pinned_count.get() == 0 {
JS_AddObjectRoot(self.global.root().root_ref().get_cx(), self.reflector().rootable()); JS_AddObjectRoot(self.global.root().root_ref().get_cx(), self.reflector().rootable());
} }
let pinned_count = self.pinned_count.deref().get(); let pinned_count = self.pinned_count.get();
self.pinned_count.deref().set(pinned_count + 1); self.pinned_count.set(pinned_count + 1);
TrustedXHRAddress(self.deref() as *const XMLHttpRequest as *const libc::c_void) TrustedXHRAddress(self.deref() as *const XMLHttpRequest as *const libc::c_void)
} }
fn release_once(self) { fn release_once(self) {
if self.sync.deref().get() { if self.sync.get() {
// Lets us call this at various termination cases without having to // Lets us call this at various termination cases without having to
// check self.sync every time, since the pinning mechanism only is // check self.sync every time, since the pinning mechanism only is
// meaningful during an async fetch // meaningful during an async fetch
return; return;
} }
assert!(self.pinned_count.deref().get() > 0) assert!(self.pinned_count.get() > 0)
let pinned_count = self.pinned_count.deref().get(); let pinned_count = self.pinned_count.get();
self.pinned_count.deref().set(pinned_count - 1); self.pinned_count.set(pinned_count - 1);
if self.pinned_count.deref().get() == 0 { if self.pinned_count.get() == 0 {
unsafe { unsafe {
JS_RemoveObjectRoot(self.global.root().root_ref().get_cx(), self.reflector().rootable()); JS_RemoveObjectRoot(self.global.root().root_ref().get_cx(), self.reflector().rootable());
} }
@ -742,8 +741,8 @@ 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) assert!(self.ready_state.get() != rs)
self.ready_state.deref().set(rs); self.ready_state.set(rs);
let global = self.global.root(); let global = self.global.root();
let event = Event::new(&global.root_ref(), let event = Event::new(&global.root_ref(),
"readystatechange".to_string(), "readystatechange".to_string(),
@ -760,9 +759,9 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
// Part of step 13, send() (processing request end of file) // Part of step 13, send() (processing request end of file)
// Substep 1 // Substep 1
self.upload_complete.deref().set(true); self.upload_complete.set(true);
// Substeps 2-4 // Substeps 2-4
if !self.sync.deref().get() { if !self.sync.get() {
self.dispatch_upload_progress_event("progress".to_string(), None); self.dispatch_upload_progress_event("progress".to_string(), None);
self.dispatch_upload_progress_event("load".to_string(), None); self.dispatch_upload_progress_event("load".to_string(), None);
self.dispatch_upload_progress_event("loadend".to_string(), None); self.dispatch_upload_progress_event("loadend".to_string(), None);
@ -770,16 +769,16 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
// Part of step 13, send() (processing response) // Part of step 13, send() (processing response)
// XXXManishearth handle errors, if any (substep 1) // XXXManishearth handle errors, if any (substep 1)
// Substep 2 // Substep 2
*self.status_text.deref().borrow_mut() = ByteString::new(status.reason().container_into_owned_bytes()); *self.status_text.borrow_mut() = ByteString::new(status.reason().container_into_owned_bytes());
self.status.deref().set(status.code()); self.status.set(status.code());
match headers { match headers {
Some(ref h) => { Some(ref h) => {
*self.response_headers.deref().borrow_mut() = h.clone(); *self.response_headers.borrow_mut() = h.clone();
} }
None => {} None => {}
}; };
// Substep 3 // Substep 3
if self.ready_state.deref().get() == Opened && !self.sync.deref().get() { if self.ready_state.get() == Opened && !self.sync.get() {
self.change_ready_state(HeadersReceived); self.change_ready_state(HeadersReceived);
} }
}, },
@ -789,13 +788,13 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
// XXXManishearth handle errors, if any (substep 1) // XXXManishearth handle errors, if any (substep 1)
// Substep 2 // Substep 2
if self.ready_state.deref().get() == HeadersReceived && !self.sync.deref().get() { if self.ready_state.get() == HeadersReceived && !self.sync.get() {
self.change_ready_state(Loading); self.change_ready_state(Loading);
} }
// Substep 3 // Substep 3
*self.response.deref().borrow_mut() = partial_response; *self.response.borrow_mut() = partial_response;
// Substep 4 // Substep 4
if !self.sync.deref().get() { if !self.sync.get() {
self.dispatch_response_progress_event("progress".to_string()); self.dispatch_response_progress_event("progress".to_string());
} }
}, },
@ -804,9 +803,9 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
// XXXManishearth handle errors, if any (substep 1) // XXXManishearth handle errors, if any (substep 1)
// Substep 3 // Substep 3
if self.ready_state.deref().get() == Loading || self.sync.deref().get() { if self.ready_state.get() == Loading || self.sync.get() {
// Subsubsteps 2-4 // Subsubsteps 2-4
self.send_flag.deref().set(false); self.send_flag.set(false);
self.change_ready_state(XHRDone); self.change_ready_state(XHRDone);
// Subsubsteps 5-7 // Subsubsteps 5-7
@ -818,7 +817,7 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
self.release_once(); self.release_once();
}, },
ErroredMsg(e) => { ErroredMsg(e) => {
self.send_flag.deref().set(false); self.send_flag.set(false);
// XXXManishearth set response to NetworkError // XXXManishearth set response to NetworkError
self.change_ready_state(XHRDone); self.change_ready_state(XHRDone);
let errormsg = match e { let errormsg = match e {
@ -828,7 +827,7 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
_ => unreachable!() _ => unreachable!()
}; };
let upload_complete: &Cell<bool> = self.upload_complete.deref(); let upload_complete: &Cell<bool> = &self.upload_complete;
if !upload_complete.get() { if !upload_complete.get() {
upload_complete.set(true); upload_complete.set(true);
self.dispatch_upload_progress_event("progress".to_string(), None); self.dispatch_upload_progress_event("progress".to_string(), None);
@ -843,8 +842,8 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
self.release_once(); self.release_once();
}, },
TimeoutMsg => { TimeoutMsg => {
match self.ready_state.deref().get() { match self.ready_state.get() {
Opened if self.send_flag.deref().get() => self.process_partial_response(ErroredMsg(Some(Timeout))), Opened if self.send_flag.get() => self.process_partial_response(ErroredMsg(Some(Timeout))),
Loading | HeadersReceived => self.process_partial_response(ErroredMsg(Some(Timeout))), Loading | HeadersReceived => self.process_partial_response(ErroredMsg(Some(Timeout))),
_ => self.release_once() _ => self.release_once()
}; };
@ -855,7 +854,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 // Insert a header without checking spec-compliance
// Use for hardcoded headers // Use for hardcoded headers
let mut collection = self.request_headers.deref().borrow_mut(); let mut collection = self.request_headers.borrow_mut();
let value_bytes = value.into_bytes(); let value_bytes = value.into_bytes();
let mut reader = BufReader::new(value_bytes.as_slice()); let mut reader = BufReader::new(value_bytes.as_slice());
let maybe_header: Option<Header> = HeaderEnum::value_from_stream( let maybe_header: Option<Header> = HeaderEnum::value_from_stream(
@ -888,26 +887,26 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
} }
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 len = self.response.borrow().len() as u64;
let total = self.response_headers.deref().borrow().content_length.map(|x| {x as u64}); let total = self.response_headers.borrow().content_length.map(|x| {x as u64});
self.dispatch_progress_event(false, type_, len, total); 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 // Sets up the object to timeout in a given number of milliseconds
// This will cancel all previous timeouts // This will cancel all previous timeouts
let oneshot = self.timer.deref().borrow_mut() let oneshot = self.timer.borrow_mut()
.oneshot(Duration::milliseconds(timeout as i64)); .oneshot(Duration::milliseconds(timeout as i64));
let addr = unsafe { let addr = unsafe {
self.to_trusted() // This will increment the pin counter by one self.to_trusted() // This will increment the pin counter by one
}; };
if self.timeout_pinned.deref().get() { if self.timeout_pinned.get() {
// Already pinned due to a timeout, no need to pin it again since the old timeout was cancelled above // Already pinned due to a timeout, no need to pin it again since the old timeout was cancelled above
self.release_once(); self.release_once();
} }
self.timeout_pinned.deref().set(true); self.timeout_pinned.set(true);
let global = self.global.root(); let global = self.global.root();
let script_chan = global.root_ref().script_chan().clone(); let script_chan = global.root_ref().script_chan().clone();
let terminate_sender = (*self.terminate_sender.deref().borrow()).clone(); let terminate_sender = (*self.terminate_sender.borrow()).clone();
spawn_named("XHR:Timer", proc () { spawn_named("XHR:Timer", proc () {
match oneshot.recv_opt() { match oneshot.recv_opt() {
Ok(_) => { Ok(_) => {
@ -926,16 +925,16 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
} }
fn cancel_timeout(self) { fn cancel_timeout(self) {
// Cancels timeouts on the object, if any // Cancels timeouts on the object, if any
if self.timeout_pinned.deref().get() { if self.timeout_pinned.get() {
self.timeout_pinned.deref().set(false); self.timeout_pinned.set(false);
self.release_once(); self.release_once();
} }
// oneshot() closes the previous channel, canceling the timeout // oneshot() closes the previous channel, canceling the timeout
self.timer.deref().borrow_mut().oneshot(Zero::zero()); self.timer.borrow_mut().oneshot(Zero::zero());
} }
fn text_response(self) -> DOMString { fn text_response(self) -> DOMString {
let mut encoding = UTF_8 as EncodingRef; let mut encoding = UTF_8 as EncodingRef;
match self.response_headers.deref().borrow().content_type { match self.response_headers.borrow().content_type {
Some(ref x) => { Some(ref x) => {
for &(ref name, ref value) in x.parameters.iter() { for &(ref name, ref value) in x.parameters.iter() {
if name.as_slice().eq_ignore_ascii_case("charset") { if name.as_slice().eq_ignore_ascii_case("charset") {
@ -947,12 +946,12 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
} }
// According to Simon, decode() should never return an error, so unwrap()ing // According to Simon, decode() should never return an error, so unwrap()ing
// the result should be fine. XXXManishearth have a closer look at this later // 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() encoding.decode(self.response.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 // http://fetch.spec.whatwg.org/#concept-response-header-list
let mut headers = ResponseHeaderCollection::new(); let mut headers = ResponseHeaderCollection::new();
for header in self.response_headers.deref().borrow().iter() { for header in self.response_headers.borrow().iter() {
match header.header_name().as_slice().to_ascii_lower().as_slice() { match header.header_name().as_slice().to_ascii_lower().as_slice() {
"set-cookie" | "set-cookie2" => {}, "set-cookie" | "set-cookie2" => {},
// XXXManishearth additional CORS filtering goes here // XXXManishearth additional CORS filtering goes here