mozilla
/
gecko-dev
зеркало из https://github.com/mozilla/gecko-dev.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

servo: Merge #2658 - Use internal mutability for XMLHttpRequest (from saneyuki:xhr) 

Source-Repo: https://github.com/servo/servo
Source-Revision: 2c0b6e4962367f5e69300e4c66b4f4f097bf6335
This commit is contained in:
Tetsuharu OHZEKI 2014-06-20 12:47:43 +01:00
Родитель ac5b16c824
Коммит db28990469
1 изменённых файлов: 182 добавлений и 179 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

361
servo/src/components/script/dom/xmlhttprequest.rs
Просмотреть файл

@ -12,7 +12,7 @@ use dom::bindings::error::{Error, ErrorResult, Fallible, InvalidState, InvalidAc
use dom::bindings::error::{Network, Syntax, Security, Abort, Timeout}; use dom::bindings::error::{Network, Syntax, Security, Abort, Timeout};
use dom::bindings::js::{JS, JSRef, Temporary, OptionalRootedRootable}; use dom::bindings::js::{JS, JSRef, Temporary, OptionalRootedRootable};
use dom::bindings::str::ByteString; use dom::bindings::str::ByteString;
use dom::bindings::trace::Untraceable; 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;
@ -47,7 +47,7 @@ use servo_util::task::spawn_named;
use servo_util::url::{parse_url, try_parse_url}; use servo_util::url::{parse_url, try_parse_url};
use std::ascii::StrAsciiExt; use std::ascii::StrAsciiExt;
use std::cell::Cell; use std::cell::{Cell, RefCell};
use std::comm::{Sender, Receiver, channel}; use std::comm::{Sender, Receiver, channel};
use std::io::{BufReader, MemWriter, Timer}; use std::io::{BufReader, MemWriter, Timer};
use std::from_str::FromStr; use std::from_str::FromStr;
@ -90,7 +90,7 @@ pub enum XHRProgress {
} }
enum SyncOrAsync<'a, 'b> { enum SyncOrAsync<'a, 'b> {
Sync(&'b mut JSRef<'a, XMLHttpRequest>), Sync(&'b JSRef<'a, XMLHttpRequest>),
Async(TrustedXHRAddress, ScriptChan) Async(TrustedXHRAddress, ScriptChan)
} }
@ -98,68 +98,68 @@ enum SyncOrAsync<'a, 'b> {
#[deriving(Encodable)] #[deriving(Encodable)]
pub struct XMLHttpRequest { pub struct XMLHttpRequest {
eventtarget: XMLHttpRequestEventTarget, eventtarget: XMLHttpRequestEventTarget,
ready_state: XMLHttpRequestState, ready_state: Traceable<Cell<XMLHttpRequestState>>,
timeout: u32, timeout: Traceable<Cell<u32>>,
with_credentials: bool, with_credentials: Traceable<Cell<bool>>,
upload: Cell<JS<XMLHttpRequestUpload>>, upload: Cell<JS<XMLHttpRequestUpload>>,
response_url: DOMString, response_url: DOMString,
status: u16, status: Traceable<Cell<u16>>,
status_text: ByteString, status_text: Traceable<RefCell<ByteString>>,
response: ByteString, response: Traceable<RefCell<ByteString>>,
response_type: XMLHttpRequestResponseType, response_type: Traceable<Cell<XMLHttpRequestResponseType>>,
response_xml: Cell<Option<JS<Document>>>, response_xml: Cell<Option<JS<Document>>>,
response_headers: Untraceable<ResponseHeaderCollection>, response_headers: Untraceable<RefCell<ResponseHeaderCollection>>,
// Associated concepts // Associated concepts
request_method: Untraceable<Method>, request_method: Untraceable<RefCell<Method>>,
request_url: Untraceable<Url>, request_url: Untraceable<RefCell<Url>>,
request_headers: Untraceable<RequestHeaderCollection>, request_headers: Untraceable<RefCell<RequestHeaderCollection>>,
request_body: SendParam, request_body: SendParam,
sync: bool, sync: Traceable<Cell<bool>>,
upload_complete: bool, upload_complete: Traceable<Cell<bool>>,
upload_events: bool, upload_events: Traceable<Cell<bool>>,
send_flag: bool, send_flag: Traceable<Cell<bool>>,
global: JS<Window>, global: JS<Window>,
pinned_count: uint, pinned_count: Traceable<Cell<uint>>,
timer: Untraceable<Timer>, timer: Untraceable<RefCell<Timer>>,
fetch_time: i64, fetch_time: Traceable<Cell<i64>>,
timeout_pinned: bool, timeout_pinned: Traceable<Cell<bool>>,
terminate_sender: Untraceable<Option<Sender<Error>>>, terminate_sender: Untraceable<RefCell<Option<Sender<Error>>>>,
} }
impl XMLHttpRequest { impl XMLHttpRequest {
pub fn new_inherited(owner: &JSRef<Window>) -> XMLHttpRequest { pub fn new_inherited(owner: &JSRef<Window>) -> XMLHttpRequest {
let xhr = XMLHttpRequest { let xhr = XMLHttpRequest {
eventtarget: XMLHttpRequestEventTarget::new_inherited(XMLHttpRequestTypeId), eventtarget: XMLHttpRequestEventTarget::new_inherited(XMLHttpRequestTypeId),
ready_state: Unsent, ready_state: Traceable::new(Cell::new(Unsent)),
timeout: 0u32, timeout: Traceable::new(Cell::new(0u32)),
with_credentials: false, with_credentials: Traceable::new(Cell::new(false)),
upload: Cell::new(JS::from_rooted(&XMLHttpRequestUpload::new(owner))), upload: Cell::new(JS::from_rooted(&XMLHttpRequestUpload::new(owner))),
response_url: "".to_string(), response_url: "".to_string(),
status: 0, status: Traceable::new(Cell::new(0)),
status_text: ByteString::new(vec!()), status_text: Traceable::new(RefCell::new(ByteString::new(vec!()))),
response: ByteString::new(vec!()), response: Traceable::new(RefCell::new(ByteString::new(vec!()))),
response_type: _empty, response_type: Traceable::new(Cell::new(_empty)),
response_xml: Cell::new(None), response_xml: Cell::new(None),
response_headers: Untraceable::new(ResponseHeaderCollection::new()), response_headers: Untraceable::new(RefCell::new(ResponseHeaderCollection::new())),
request_method: Untraceable::new(Get), request_method: Untraceable::new(RefCell::new(Get)),
request_url: Untraceable::new(parse_url("", None)), request_url: Untraceable::new(RefCell::new(parse_url("", None))),
request_headers: Untraceable::new(RequestHeaderCollection::new()), request_headers: Untraceable::new(RefCell::new(RequestHeaderCollection::new())),
request_body: "".to_string(), request_body: "".to_string(),
sync: false, sync: Traceable::new(Cell::new(false)),
send_flag: false, send_flag: Traceable::new(Cell::new(false)),
upload_complete: false, upload_complete: Traceable::new(Cell::new(false)),
upload_events: false, upload_events: Traceable::new(Cell::new(false)),
global: JS::from_rooted(owner), global: JS::from_rooted(owner),
pinned_count: 0, pinned_count: Traceable::new(Cell::new(0)),
timer: Untraceable::new(Timer::new().unwrap()), timer: Untraceable::new(RefCell::new(Timer::new().unwrap())),
fetch_time: 0, fetch_time: Traceable::new(Cell::new(0)),
timeout_pinned: false, timeout_pinned: Traceable::new(Cell::new(false)),
terminate_sender: Untraceable::new(None), terminate_sender: Untraceable::new(RefCell::new(None)),
}; };
xhr xhr
} }
@ -174,17 +174,16 @@ impl XMLHttpRequest {
pub fn handle_xhr_progress(addr: TrustedXHRAddress, progress: XHRProgress) { pub fn handle_xhr_progress(addr: TrustedXHRAddress, progress: XHRProgress) {
unsafe { unsafe {
let mut xhr = JS::from_trusted_xhr_address(addr).root(); let xhr = JS::from_trusted_xhr_address(addr).root();
xhr.process_partial_response(progress); xhr.deref().process_partial_response(progress);
} }
} }
fn fetch(fetch_type: &mut SyncOrAsync, resource_task: ResourceTask, fn fetch(fetch_type: &SyncOrAsync, resource_task: ResourceTask,
load_data: LoadData, terminate_receiver: Receiver<Error>) -> ErrorResult { load_data: LoadData, terminate_receiver: Receiver<Error>) -> ErrorResult {
fn notify_partial_progress(fetch_type: &SyncOrAsync, msg: XHRProgress) {
fn notify_partial_progress(fetch_type: &mut SyncOrAsync, msg: XHRProgress) {
match *fetch_type { match *fetch_type {
Sync(ref mut xhr) => { Sync(ref xhr) => {
xhr.process_partial_response(msg); xhr.process_partial_response(msg);
}, },
Async(addr, ref script_chan) => { Async(addr, ref script_chan) => {
@ -233,17 +232,17 @@ pub trait XMLHttpRequestMethods<'a> {
fn GetOnreadystatechange(&self) -> Option<EventHandlerNonNull>; fn GetOnreadystatechange(&self) -> Option<EventHandlerNonNull>;
fn SetOnreadystatechange(&self, listener: Option<EventHandlerNonNull>); fn SetOnreadystatechange(&self, listener: Option<EventHandlerNonNull>);
fn ReadyState(&self) -> u16; fn ReadyState(&self) -> u16;
fn Open(&mut self, _method: ByteString, _url: DOMString) -> ErrorResult; fn Open(&self, _method: ByteString, _url: DOMString) -> ErrorResult;
fn Open_(&mut 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;
fn SetRequestHeader(&mut self, name: ByteString, mut value: ByteString) -> ErrorResult; fn SetRequestHeader(&self, name: ByteString, mut value: ByteString) -> ErrorResult;
fn Timeout(&self) -> u32; fn Timeout(&self) -> u32;
fn SetTimeout(&mut self, timeout: u32) -> ErrorResult; fn SetTimeout(&self, timeout: u32) -> ErrorResult;
fn WithCredentials(&self) -> bool; fn WithCredentials(&self) -> bool;
fn SetWithCredentials(&mut self, with_credentials: bool); fn SetWithCredentials(&self, with_credentials: bool);
fn Upload(&self) -> Temporary<XMLHttpRequestUpload>; fn Upload(&self) -> Temporary<XMLHttpRequestUpload>;
fn Send(&mut self, _data: Option<SendParam>) -> ErrorResult; fn Send(&self, _data: Option<SendParam>) -> ErrorResult;
fn Abort(&mut self); fn Abort(&self);
fn ResponseURL(&self) -> DOMString; fn ResponseURL(&self) -> DOMString;
fn Status(&self) -> u16; fn Status(&self) -> u16;
fn StatusText(&self) -> ByteString; fn StatusText(&self) -> ByteString;
@ -251,7 +250,7 @@ pub trait XMLHttpRequestMethods<'a> {
fn GetAllResponseHeaders(&self) -> ByteString; fn GetAllResponseHeaders(&self) -> ByteString;
fn OverrideMimeType(&self, _mime: DOMString); fn OverrideMimeType(&self, _mime: DOMString);
fn ResponseType(&self) -> XMLHttpRequestResponseType; fn ResponseType(&self) -> XMLHttpRequestResponseType;
fn SetResponseType(&mut self, response_type: XMLHttpRequestResponseType) -> ErrorResult; fn SetResponseType(&self, response_type: XMLHttpRequestResponseType) -> ErrorResult;
fn Response(&self, _cx: *mut JSContext) -> JSVal; fn Response(&self, _cx: *mut JSContext) -> JSVal;
fn GetResponseText(&self) -> Fallible<DOMString>; fn GetResponseText(&self) -> Fallible<DOMString>;
fn GetResponseXML(&self) -> Option<Temporary<Document>>; fn GetResponseXML(&self) -> Option<Temporary<Document>>;
@ -269,13 +268,12 @@ impl<'a> XMLHttpRequestMethods<'a> for JSRef<'a, XMLHttpRequest> {
} }
fn ReadyState(&self) -> u16 { fn ReadyState(&self) -> u16 {
self.ready_state as u16 self.ready_state.deref().get() as u16
} }
fn Open(&mut self, method: ByteString, url: DOMString) -> ErrorResult { fn Open(&self, method: ByteString, url: DOMString) -> ErrorResult {
// Clean up from previous requests, if any: // Clean up from previous requests, if any:
self.cancel_timeout(); self.cancel_timeout();
let uppercase_method = method.as_str().map(|s| { let uppercase_method = method.as_str().map(|s| {
let upper = s.to_ascii_upper(); let upper = s.to_ascii_upper();
match upper.as_slice() { match upper.as_slice() {
@ -301,7 +299,7 @@ impl<'a> XMLHttpRequestMethods<'a> 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 = maybe_method.unwrap(); *self.request_method.deref().borrow_mut() = maybe_method.unwrap();
// Step 6 // Step 6
let parsed_url = match try_parse_url(url.as_slice(), base) { let parsed_url = match try_parse_url(url.as_slice(), base) {
@ -309,22 +307,22 @@ impl<'a> XMLHttpRequestMethods<'a> 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 { if self.sync.deref().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 != 0 || self.with_credentials || self.response_type != _empty { if self.timeout.deref().get() != 0 || self.with_credentials.deref().get() || self.response_type.deref().get() != _empty {
return Err(InvalidAccess) return Err(InvalidAccess)
} }
} }
// XXXManishearth abort existing requests // XXXManishearth abort existing requests
// Step 12 // Step 12
*self.request_url = parsed_url; *self.request_url.deref().borrow_mut() = parsed_url;
*self.request_headers = RequestHeaderCollection::new(); *self.request_headers.deref().borrow_mut() = RequestHeaderCollection::new();
self.send_flag = false; self.send_flag.deref().set(false);
self.status_text = ByteString::new(vec!()); *self.status_text.deref().borrow_mut() = ByteString::new(vec!());
self.status = 0; self.status.deref().set(0);
// Step 13 // Step 13
if self.ready_state != Opened { if self.ready_state.deref().get() != Opened {
self.change_ready_state(Opened); self.change_ready_state(Opened);
} }
Ok(()) Ok(())
@ -334,13 +332,13 @@ impl<'a> XMLHttpRequestMethods<'a> for JSRef<'a, XMLHttpRequest> {
_ => Err(Syntax), // Step 3 _ => Err(Syntax), // Step 3
} }
} }
fn Open_(&mut 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 = !async; self.sync.deref().set(!async);
self.Open(method, url) self.Open(method, url)
} }
fn SetRequestHeader(&mut self, name: ByteString, mut value: ByteString) -> ErrorResult { fn SetRequestHeader(&self, name: ByteString, mut value: ByteString) -> ErrorResult {
if self.ready_state != Opened || self.send_flag { if self.ready_state.deref().get() != Opened || self.send_flag.deref().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() {
@ -365,7 +363,7 @@ impl<'a> XMLHttpRequestMethods<'a> for JSRef<'a, XMLHttpRequest> {
}, },
None => return Err(Syntax) None => return Err(Syntax)
}; };
let collection = self.request_headers.deref_mut(); let mut collection = self.request_headers.deref().borrow_mut();
// Steps 6,7 // Steps 6,7
@ -404,20 +402,20 @@ impl<'a> XMLHttpRequestMethods<'a> for JSRef<'a, XMLHttpRequest> {
} }
} }
fn Timeout(&self) -> u32 { fn Timeout(&self) -> u32 {
self.timeout self.timeout.deref().get()
} }
fn SetTimeout(&mut self, timeout: u32) -> ErrorResult { fn SetTimeout(&self, timeout: u32) -> ErrorResult {
if self.sync { if self.sync.deref().get() {
// FIXME: Not valid for a worker environment // FIXME: Not valid for a worker environment
Err(InvalidState) Err(InvalidState)
} else { } else {
self.timeout = timeout; self.timeout.deref().set(timeout);
if self.send_flag { if self.send_flag.deref().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; let progress = time::now().to_timespec().sec - self.fetch_time.deref().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 {
@ -429,34 +427,34 @@ impl<'a> XMLHttpRequestMethods<'a> for JSRef<'a, XMLHttpRequest> {
} }
} }
fn WithCredentials(&self) -> bool { fn WithCredentials(&self) -> bool {
self.with_credentials self.with_credentials.deref().get()
} }
fn SetWithCredentials(&mut self, with_credentials: bool) { fn SetWithCredentials(&self, with_credentials: bool) {
self.with_credentials = with_credentials self.with_credentials.deref().set(with_credentials);
} }
fn Upload(&self) -> Temporary<XMLHttpRequestUpload> { fn Upload(&self) -> Temporary<XMLHttpRequestUpload> {
Temporary::new(self.upload.get()) Temporary::new(self.upload.get())
} }
fn Send(&mut self, data: Option<DOMString>) -> ErrorResult { fn Send(&self, data: Option<DOMString>) -> ErrorResult {
if self.ready_state != Opened || self.send_flag { if self.ready_state.deref().get() != Opened || self.send_flag.deref().get() {
return Err(InvalidState); // Step 1, 2 return Err(InvalidState); // Step 1, 2
} }
let data = match *self.request_method { let data = match *self.request_method.deref().borrow() {
Get | Head => None, // Step 3 Get | Head => None, // Step 3
_ => data _ => data
}; };
// Step 6 // Step 6
self.upload_events = false; self.upload_events.deref().set(false);
// Step 7 // Step 7
self.upload_complete = match data { self.upload_complete.deref().set(match data {
None => true, None => true,
Some (ref s) if s.len() == 0 => true, Some (ref s) if s.len() == 0 => true,
_ => false _ => false
}; });
let mut addr = None; let mut addr = None;
if !self.sync { if !self.sync.deref().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
@ -468,39 +466,39 @@ impl<'a> XMLHttpRequestMethods<'a> for JSRef<'a, XMLHttpRequest> {
let upload_target = &*self.upload.get().root(); let upload_target = &*self.upload.get().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 = true; self.upload_events.deref().set(true);
} }
// Step 9 // Step 9
self.send_flag = true; self.send_flag.deref().set(true);
self.dispatch_response_progress_event("loadstart".to_string()); self.dispatch_response_progress_event("loadstart".to_string());
if !self.upload_complete { if !self.upload_complete.deref().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 == Unsent { if self.ready_state.deref().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.deref().page().resource_task.deref().clone(); let resource_task = global.deref().page().resource_task.deref().clone();
let mut load_data = LoadData::new((*self.request_url).clone()); let mut load_data = LoadData::new(self.request_url.deref().borrow().clone());
load_data.data = data; load_data.data = data;
// Default headers // Default headers
let request_headers = self.request_headers.deref();
if self.request_headers.content_type.is_none() { if request_headers.borrow().content_type.is_none() {
self.request_headers.content_type = Some(MediaType { request_headers.borrow_mut().content_type = Some(MediaType {
type_: String::from_str("text"), type_: String::from_str("text"),
subtype: String::from_str("plain"), subtype: String::from_str("plain"),
parameters: vec!((String::from_str("charset"), String::from_str("UTF-8"))) parameters: vec!((String::from_str("charset"), String::from_str("UTF-8")))
}); });
} }
if self.request_headers.accept.is_none() { if request_headers.borrow().accept.is_none() {
self.request_headers.accept = Some(String::from_str("*/*")) request_headers.borrow_mut().accept = Some(String::from_str("*/*"))
} }
// XXXManishearth this is to be replaced with Origin for CORS (with no path) // XXXManishearth this is to be replaced with Origin for CORS (with no path)
@ -514,48 +512,48 @@ impl<'a> XMLHttpRequestMethods<'a> for JSRef<'a, XMLHttpRequest> {
buf.push_str(p.as_slice()); buf.push_str(p.as_slice());
}); });
buf.push_str(referer_url.path.as_slice()); buf.push_str(referer_url.path.as_slice());
self.request_headers.referer = Some(buf); self.request_headers.deref().borrow_mut().referer = Some(buf);
load_data.headers = (*self.request_headers).clone(); load_data.headers = (*self.request_headers.deref().borrow()).clone();
load_data.method = (*self.request_method).clone(); load_data.method = (*self.request_method.deref().borrow()).clone();
let (terminate_sender, terminate_receiver) = channel(); let (terminate_sender, terminate_receiver) = channel();
*self.terminate_sender = Some(terminate_sender); *self.terminate_sender.deref().borrow_mut() = Some(terminate_sender);
if self.sync { if self.sync.deref().get() {
return XMLHttpRequest::fetch(&mut Sync(self), resource_task, load_data, terminate_receiver); return XMLHttpRequest::fetch(&mut Sync(self), resource_task, load_data, terminate_receiver);
} else { } else {
let builder = TaskBuilder::new().named("XHRTask"); let builder = TaskBuilder::new().named("XHRTask");
self.fetch_time = time::now().to_timespec().sec; self.fetch_time.deref().set(time::now().to_timespec().sec);
let script_chan = global.deref().script_chan.clone(); let script_chan = global.deref().script_chan.clone();
builder.spawn(proc() { builder.spawn(proc() {
let _ = XMLHttpRequest::fetch(&mut Async(addr.unwrap(), script_chan), resource_task, load_data, terminate_receiver); let _ = XMLHttpRequest::fetch(&mut Async(addr.unwrap(), script_chan), resource_task, load_data, terminate_receiver);
}); });
let timeout = self.timeout; let timeout = self.timeout.deref().get();
if timeout > 0 { if timeout > 0 {
self.set_timeout(timeout); self.set_timeout(timeout);
} }
} }
Ok(()) Ok(())
} }
fn Abort(&mut self) { fn Abort(&self) {
self.terminate_sender.as_ref().map(|s| s.send_opt(Abort)); self.terminate_sender.deref().borrow().as_ref().map(|s| s.send_opt(Abort));
match self.ready_state { match self.ready_state.deref().get() {
Opened if self.send_flag => self.process_partial_response(ErroredMsg(Some(Abort))), Opened if self.send_flag.deref().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 = Unsent; self.ready_state.deref().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 self.status.deref().get()
} }
fn StatusText(&self) -> ByteString { fn StatusText(&self) -> ByteString {
self.status_text.clone() self.status_text.deref().borrow().clone()
} }
fn GetResponseHeader(&self, name: ByteString) -> Option<ByteString> { fn GetResponseHeader(&self, name: ByteString) -> Option<ByteString> {
self.response_headers.deref().iter().find(|h| { self.response_headers.deref().borrow().iter().find(|h| {
name.eq_ignore_case(&FromStr::from_str(h.header_name().as_slice()).unwrap()) name.eq_ignore_case(&FromStr::from_str(h.header_name().as_slice()).unwrap())
}).map(|h| { }).map(|h| {
FromStr::from_str(h.header_value().as_slice()).unwrap() FromStr::from_str(h.header_value().as_slice()).unwrap()
@ -563,7 +561,7 @@ impl<'a> XMLHttpRequestMethods<'a> for JSRef<'a, XMLHttpRequest> {
} }
fn GetAllResponseHeaders(&self) -> ByteString { fn GetAllResponseHeaders(&self) -> ByteString {
let mut writer = MemWriter::new(); let mut writer = MemWriter::new();
self.response_headers.deref().write_all(&mut writer).ok().expect("Writing response headers failed"); self.response_headers.deref().borrow().write_all(&mut writer).ok().expect("Writing response headers failed");
let mut vec = writer.unwrap(); let mut vec = writer.unwrap();
// rust-http appends an extra "\r\n" when using write_all // rust-http appends an extra "\r\n" when using write_all
@ -576,34 +574,35 @@ impl<'a> XMLHttpRequestMethods<'a> for JSRef<'a, XMLHttpRequest> {
} }
fn ResponseType(&self) -> XMLHttpRequestResponseType { fn ResponseType(&self) -> XMLHttpRequestResponseType {
self.response_type self.response_type.deref().get()
} }
fn SetResponseType(&mut self, response_type: XMLHttpRequestResponseType) -> ErrorResult { fn SetResponseType(&self, response_type: XMLHttpRequestResponseType) -> ErrorResult {
if self.sync { if self.sync.deref().get() {
// FIXME: When Workers are implemented, there should be // FIXME: When Workers are implemented, there should be
// an additional check that this is a document environment // an additional check that this is a document environment
return Err(InvalidState); return Err(InvalidState);
} }
match self.ready_state { match self.ready_state.deref().get() {
Loading | XHRDone => Err(InvalidState), Loading | XHRDone => Err(InvalidState),
_ => { _ => {
self.response_type = response_type; self.response_type.deref().set(response_type);
Ok(()) Ok(())
} }
} }
} }
fn Response(&self, cx: *mut JSContext) -> JSVal { fn Response(&self, cx: *mut JSContext) -> JSVal {
match self.response_type { match self.response_type.deref().get() {
_empty | Text => { _empty | Text => {
if self.ready_state == XHRDone || self.ready_state == Loading { let ready_state = self.ready_state.deref().get();
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 != XHRDone => NullValue(), _ if self.ready_state.deref().get() != XHRDone => NullValue(),
Json => { Json => {
let decoded = UTF_8.decode(self.response.as_slice(), DecodeReplace).unwrap().to_string().to_utf16(); let decoded = UTF_8.decode(self.response.deref().borrow().as_slice(), DecodeReplace).unwrap().to_string().to_utf16();
let mut vp = UndefinedValue(); let mut vp = UndefinedValue();
unsafe { unsafe {
JS_ParseJSON(cx, decoded.as_ptr(), decoded.len() as u32, &mut vp); JS_ParseJSON(cx, decoded.as_ptr(), decoded.len() as u32, &mut vp);
@ -612,14 +611,14 @@ impl<'a> XMLHttpRequestMethods<'a> for JSRef<'a, XMLHttpRequest> {
} }
_ => { _ => {
// XXXManishearth handle other response types // XXXManishearth handle other response types
self.response.to_jsval(cx) self.response.deref().borrow().to_jsval(cx)
} }
} }
} }
fn GetResponseText(&self) -> Fallible<DOMString> { fn GetResponseText(&self) -> Fallible<DOMString> {
match self.response_type { match self.response_type.deref().get() {
_empty | Text => { _empty | Text => {
match self.ready_state { match self.ready_state.deref().get() {
Loading | XHRDone => Ok(self.text_response()), Loading | XHRDone => Ok(self.text_response()),
_ => Ok("".to_string()) _ => Ok("".to_string())
} }
@ -659,48 +658,50 @@ impl TrustedXHRAddress {
trait PrivateXMLHttpRequestHelpers { trait PrivateXMLHttpRequestHelpers {
unsafe fn to_trusted(&mut self) -> TrustedXHRAddress; unsafe fn to_trusted(&self) -> TrustedXHRAddress;
fn release_once(&mut self); fn release_once(&self);
fn change_ready_state(&mut self, XMLHttpRequestState); fn change_ready_state(&self, XMLHttpRequestState);
fn process_partial_response(&mut self, progress: XHRProgress); fn process_partial_response(&self, progress: XHRProgress);
fn insert_trusted_header(&mut self, name: String, value: String); 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_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_upload_progress_event(&self, type_: DOMString, partial_load: Option<u64>);
fn dispatch_response_progress_event(&self, type_: DOMString); fn dispatch_response_progress_event(&self, type_: DOMString);
fn text_response(&self) -> DOMString; fn text_response(&self) -> DOMString;
fn set_timeout(&mut self, timeout:u32); fn set_timeout(&self, timeout:u32);
fn cancel_timeout(&mut self); fn cancel_timeout(&self);
} }
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(&mut self) -> TrustedXHRAddress { unsafe fn to_trusted(&self) -> TrustedXHRAddress {
if self.pinned_count == 0 { if self.pinned_count.deref().get() == 0 {
JS_AddObjectRoot(self.global.root().get_cx(), self.reflector().rootable()); JS_AddObjectRoot(self.global.root().get_cx(), self.reflector().rootable());
} }
self.pinned_count += 1; let pinned_count = self.pinned_count.deref().get();
self.pinned_count.deref().set(pinned_count + 1);
TrustedXHRAddress(self.deref() as *XMLHttpRequest as *libc::c_void) TrustedXHRAddress(self.deref() as *XMLHttpRequest as *libc::c_void)
} }
fn release_once(&mut self) { fn release_once(&self) {
if self.sync { if self.sync.deref().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 > 0) assert!(self.pinned_count.deref().get() > 0)
self.pinned_count -= 1; let pinned_count = self.pinned_count.deref().get();
if self.pinned_count == 0 { self.pinned_count.deref().set(pinned_count - 1);
if self.pinned_count.deref().get() == 0 {
unsafe { unsafe {
JS_RemoveObjectRoot(self.global.root().get_cx(), self.reflector().rootable()); JS_RemoveObjectRoot(self.global.root().get_cx(), self.reflector().rootable());
} }
} }
} }
fn change_ready_state(&mut self, rs: XMLHttpRequestState) { fn change_ready_state(&self, rs: XMLHttpRequestState) {
assert!(self.ready_state != rs) assert!(self.ready_state.deref().get() != rs)
self.ready_state = rs; self.ready_state.deref().set(rs);
let win = &*self.global.root(); let win = &*self.global.root();
let event = let event =
Event::new(win, "readystatechange".to_string(), false, true).root(); Event::new(win, "readystatechange".to_string(), false, true).root();
@ -708,7 +709,7 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
target.dispatch_event_with_target(None, &*event).ok(); target.dispatch_event_with_target(None, &*event).ok();
} }
fn process_partial_response(&mut self, progress: XHRProgress) { fn process_partial_response(&self, progress: XHRProgress) {
match progress { match progress {
HeadersReceivedMsg(headers, status) => { HeadersReceivedMsg(headers, status) => {
// For synchronous requests, this should not fire any events, and just store data // For synchronous requests, this should not fire any events, and just store data
@ -716,9 +717,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 = true; self.upload_complete.deref().set(true);
// Substeps 2-4 // Substeps 2-4
if !self.sync { if !self.sync.deref().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);
@ -726,14 +727,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 = ByteString::new(status.reason().container_into_owned_bytes()); *self.status_text.deref().borrow_mut() = ByteString::new(status.reason().container_into_owned_bytes());
self.status = status.code(); self.status.deref().set(status.code());
match headers { match headers {
Some(ref h) => *self.response_headers = h.clone(), Some(ref h) => {
*self.response_headers.deref().borrow_mut() = h.clone();
}
None => {} None => {}
}; };
// Substep 3 // Substep 3
if self.ready_state == Opened && !self.sync { if self.ready_state.deref().get() == Opened && !self.sync.deref().get() {
self.change_ready_state(HeadersReceived); self.change_ready_state(HeadersReceived);
} }
}, },
@ -743,13 +746,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 == HeadersReceived && !self.sync { if self.ready_state.deref().get() == HeadersReceived && !self.sync.deref().get() {
self.change_ready_state(Loading); self.change_ready_state(Loading);
} }
// Substep 3 // Substep 3
self.response = partial_response; *self.response.deref().borrow_mut() = partial_response;
// Substep 4 // Substep 4
if !self.sync { if !self.sync.deref().get() {
self.dispatch_response_progress_event("progress".to_string()); self.dispatch_response_progress_event("progress".to_string());
} }
}, },
@ -758,9 +761,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 == Loading || self.sync { if self.ready_state.deref().get() == Loading || self.sync.deref().get() {
// Subsubsteps 2-4 // Subsubsteps 2-4
self.send_flag = false; self.send_flag.deref().set(false);
self.change_ready_state(XHRDone); self.change_ready_state(XHRDone);
// Subsubsteps 5-7 // Subsubsteps 5-7
@ -772,8 +775,7 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
self.release_once(); self.release_once();
}, },
ErroredMsg(e) => { ErroredMsg(e) => {
self.send_flag = false; self.send_flag.deref().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 {
@ -783,8 +785,9 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
_ => unreachable!() _ => unreachable!()
}; };
if !self.upload_complete { let upload_complete: &Cell<bool> = self.upload_complete.deref();
self.upload_complete = true; if !upload_complete.get() {
upload_complete.set(true);
self.dispatch_upload_progress_event("progress".to_string(), None); self.dispatch_upload_progress_event("progress".to_string(), None);
self.dispatch_upload_progress_event(errormsg.to_string(), None); self.dispatch_upload_progress_event(errormsg.to_string(), None);
self.dispatch_upload_progress_event("loadend".to_string(), None); self.dispatch_upload_progress_event("loadend".to_string(), None);
@ -797,8 +800,8 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
self.release_once(); self.release_once();
}, },
TimeoutMsg => { TimeoutMsg => {
match self.ready_state { match self.ready_state.deref().get() {
Opened if self.send_flag => self.process_partial_response(ErroredMsg(Some(Timeout))), Opened if self.send_flag.deref().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()
}; };
@ -806,10 +809,10 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
} }
} }
fn insert_trusted_header(&mut 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 collection = self.request_headers.deref_mut(); let mut collection = self.request_headers.deref().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(
@ -841,25 +844,25 @@ 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.len() as u64; let len = self.response.deref().borrow().len() as u64;
let total = self.response_headers.deref().content_length.map(|x| {x as u64}); let total = self.response_headers.deref().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(&mut 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.oneshot(timeout as u64); let oneshot = self.timer.deref().borrow_mut().oneshot(timeout as u64);
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 { if self.timeout_pinned.deref().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 = true; self.timeout_pinned.deref().set(true);
let global = self.global.root(); let global = self.global.root();
let script_chan = global.deref().script_chan.clone(); let script_chan = global.deref().script_chan.clone();
let terminate_sender = (*self.terminate_sender).clone(); let terminate_sender = (*self.terminate_sender.deref().borrow()).clone();
spawn_named("XHR:Timer", proc () { spawn_named("XHR:Timer", proc () {
match oneshot.recv_opt() { match oneshot.recv_opt() {
Ok(_) => { Ok(_) => {
@ -876,18 +879,18 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
} }
); );
} }
fn cancel_timeout(&mut self) { fn cancel_timeout(&self) {
// Cancels timeouts on the object, if any // Cancels timeouts on the object, if any
if self.timeout_pinned { if self.timeout_pinned.deref().get() {
self.timeout_pinned = false; self.timeout_pinned.deref().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.oneshot(0); self.timer.deref().borrow_mut().oneshot(0);
} }
fn text_response(&self) -> DOMString { fn text_response(&self) -> DOMString {
let mut encoding = UTF_8 as &Encoding:Send; let mut encoding = UTF_8 as &Encoding:Send;
match self.response_headers.content_type { match self.response_headers.deref().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") {
@ -899,6 +902,6 @@ 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.as_slice(), DecodeReplace).unwrap().to_string() encoding.decode(self.response.deref().borrow().as_slice(), DecodeReplace).unwrap().to_string()
} }
} }