From 5c8a45d74ee3874d39e736a89821ab139e03dc49 Mon Sep 17 00:00:00 2001 From: Manish Goregaokar Date: Mon, 29 Sep 2014 05:39:35 +0530 Subject: [PATCH] Remove Traceable/Untraceable from xmlhttprequest.rs --- components/script/dom/bindings/trace.rs | 23 +- components/script/dom/xmlhttprequest.rs | 273 ++++++++++++------------ 2 files changed, 144 insertions(+), 152 deletions(-) diff --git a/components/script/dom/bindings/trace.rs b/components/script/dom/bindings/trace.rs index c2aff926c080..cfdd8dac40fe 100644 --- a/components/script/dom/bindings/trace.rs +++ b/components/script/dom/bindings/trace.rs @@ -45,6 +45,10 @@ use std::comm::{Receiver, Sender}; use hubbub::hubbub::QuirksMode; use string_cache::{Atom, Namespace}; 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 JSTraceable for JS { fn trace(&self, trc: *mut JSTracer) { @@ -227,14 +231,17 @@ untraceable!(bool, f32, f64, String, Url) untraceable!(uint, u8, u16, u32, u64) untraceable!(int, i8, i16, i32, i64) untraceable!(Untraceable) +untraceable!(Sender) +untraceable!(Receiver) untraceable!(ImageCacheTask, ScriptControlChan) -untraceable!(Atom, Namespace) +untraceable!(Atom, Namespace, Timer) untraceable!(PropertyDeclarationBlock) // These three are interdependent, if you plan to put jsmanaged data // in one of these make sure it is propagated properly to containing structs untraceable!(SubpageId, WindowSizeData, PipelineId) untraceable!(QuirksMode) untraceable!(Cx) +untraceable!(ResponseHeaderCollection, RequestHeaderCollection, Method) impl<'a> JSTraceable for &'a str { #[inline] @@ -243,20 +250,6 @@ impl<'a> JSTraceable for &'a str { } } -impl JSTraceable for Sender { - #[inline] - fn trace(&self, _: *mut JSTracer) { - // Do nothing - } -} - -impl JSTraceable for Receiver { - #[inline] - fn trace(&self, _: *mut JSTracer) { - // Do nothing - } -} - impl JSTraceable for fn(A) -> B { #[inline] fn trace(&self, _: *mut JSTracer) { diff --git a/components/script/dom/xmlhttprequest.rs b/components/script/dom/xmlhttprequest.rs index dd3ababc8cb7..95a3c87192b7 100644 --- a/components/script/dom/xmlhttprequest.rs +++ b/components/script/dom/xmlhttprequest.rs @@ -15,7 +15,6 @@ use dom::bindings::error::{Network, Syntax, Security, Abort, Timeout}; use dom::bindings::global::{GlobalField, GlobalRef, WorkerField}; use dom::bindings::js::{MutNullableJS, JS, JSRef, Temporary, OptionalRootedRootable}; use dom::bindings::str::ByteString; -use dom::bindings::trace::{Traceable, Untraceable}; use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object}; use dom::document::Document; use dom::event::Event; @@ -107,68 +106,68 @@ enum SyncOrAsync<'a> { #[must_root] pub struct XMLHttpRequest { eventtarget: XMLHttpRequestEventTarget, - ready_state: Traceable>, - timeout: Traceable>, - with_credentials: Traceable>, + ready_state: Cell, + timeout: Cell, + with_credentials: Cell, upload: JS, response_url: DOMString, - status: Traceable>, - status_text: Traceable>, - response: Traceable>, - response_type: Traceable>, + status: Cell, + status_text: RefCell, + response: RefCell, + response_type: Cell, response_xml: MutNullableJS, - response_headers: Untraceable>, + response_headers: RefCell, // Associated concepts - request_method: Untraceable>, - request_url: Untraceable>>, - request_headers: Untraceable>, - request_body_len: Traceable>, - sync: Traceable>, - upload_complete: Traceable>, - upload_events: Traceable>, - send_flag: Traceable>, + request_method: RefCell, + request_url: RefCell>, + request_headers: RefCell, + request_body_len: Cell, + sync: Cell, + upload_complete: Cell, + upload_events: Cell, + send_flag: Cell, global: GlobalField, - pinned_count: Traceable>, - timer: Untraceable>, - fetch_time: Traceable>, - timeout_pinned: Traceable>, - terminate_sender: Untraceable>>>, + pinned_count: Cell, + timer: RefCell, + fetch_time: Cell, + timeout_pinned: Cell, + terminate_sender: RefCell>>, } impl XMLHttpRequest { fn new_inherited(global: &GlobalRef) -> XMLHttpRequest { XMLHttpRequest { eventtarget: XMLHttpRequestEventTarget::new_inherited(XMLHttpRequestTypeId), - ready_state: Traceable::new(Cell::new(Unsent)), - timeout: Traceable::new(Cell::new(0u32)), - with_credentials: Traceable::new(Cell::new(false)), + ready_state: Cell::new(Unsent), + timeout: Cell::new(0u32), + with_credentials: Cell::new(false), upload: JS::from_rooted(XMLHttpRequestUpload::new(global)), response_url: "".to_string(), - status: Traceable::new(Cell::new(0)), - status_text: Traceable::new(RefCell::new(ByteString::new(vec!()))), - response: Traceable::new(RefCell::new(ByteString::new(vec!()))), - response_type: Traceable::new(Cell::new(_empty)), + status: Cell::new(0), + status_text: RefCell::new(ByteString::new(vec!())), + response: RefCell::new(ByteString::new(vec!())), + response_type: Cell::new(_empty), 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_url: Untraceable::new(RefCell::new(None)), - request_headers: Untraceable::new(RefCell::new(RequestHeaderCollection::new())), - request_body_len: Traceable::new(Cell::new(0)), - sync: Traceable::new(Cell::new(false)), - send_flag: Traceable::new(Cell::new(false)), + request_method: RefCell::new(Get), + request_url: RefCell::new(None), + request_headers: RefCell::new(RequestHeaderCollection::new()), + request_body_len: Cell::new(0), + sync: Cell::new(false), + send_flag: Cell::new(false), - upload_complete: Traceable::new(Cell::new(false)), - upload_events: Traceable::new(Cell::new(false)), + upload_complete: Cell::new(false), + upload_events: Cell::new(false), global: GlobalField::from_rooted(global), - pinned_count: Traceable::new(Cell::new(0)), - timer: Untraceable::new(RefCell::new(Timer::new().unwrap())), - fetch_time: Traceable::new(Cell::new(0)), - timeout_pinned: Traceable::new(Cell::new(false)), - terminate_sender: Untraceable::new(RefCell::new(None)), + pinned_count: Cell::new(0), + timer: RefCell::new(Timer::new().unwrap()), + fetch_time: Cell::new(0), + timeout_pinned: Cell::new(false), + terminate_sender: RefCell::new(None), } } pub fn new(global: &GlobalRef) -> Temporary { @@ -276,7 +275,7 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> { } 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 { @@ -306,7 +305,7 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> { Some(ExtensionMethod(ref t)) if t.as_slice() == "TRACK" => Err(Security), Some(_) if method.is_token() => { - *self.request_method.deref().borrow_mut() = maybe_method.unwrap(); + *self.request_method.borrow_mut() = maybe_method.unwrap(); // Step 6 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 }; // 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 - 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) } } // XXXManishearth abort existing requests // Step 12 - *self.request_url.deref().borrow_mut() = Some(parsed_url); - *self.request_headers.deref().borrow_mut() = RequestHeaderCollection::new(); - self.send_flag.deref().set(false); - *self.status_text.deref().borrow_mut() = ByteString::new(vec!()); - self.status.deref().set(0); + *self.request_url.borrow_mut() = Some(parsed_url); + *self.request_headers.borrow_mut() = RequestHeaderCollection::new(); + self.send_flag.set(false); + *self.status_text.borrow_mut() = ByteString::new(vec!()); + self.status.set(0); // Step 13 - if self.ready_state.deref().get() != Opened { + if self.ready_state.get() != Opened { self.change_ready_state(Opened); } Ok(()) @@ -342,11 +341,11 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> { } fn Open_(self, method: ByteString, url: DOMString, async: bool, _username: Option, _password: Option) -> ErrorResult { - self.sync.deref().set(!async); + self.sync.set(!async); self.Open(method, url) } 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 } if !name.is_token() || !value.is_field_value() { @@ -371,7 +370,7 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> { }, None => return Err(Syntax) }; - let mut collection = self.request_headers.deref().borrow_mut(); + let mut collection = self.request_headers.borrow_mut(); // Steps 6,7 @@ -410,20 +409,20 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> { } } fn Timeout(self) -> u32 { - self.timeout.deref().get() + self.timeout.get() } fn SetTimeout(self, timeout: u32) -> ErrorResult { - if self.sync.deref().get() { + if self.sync.get() { // FIXME: Not valid for a worker environment Err(InvalidState) } else { - self.timeout.deref().set(timeout); - if self.send_flag.deref().get() { + self.timeout.set(timeout); + if self.send_flag.get() { if timeout == 0 { self.cancel_timeout(); 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 { self.set_timeout(timeout - (progress * 1000) as u32); } else { @@ -435,20 +434,20 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> { } } fn WithCredentials(self) -> bool { - self.with_credentials.deref().get() + self.with_credentials.get() } fn SetWithCredentials(self, with_credentials: bool) { - self.with_credentials.deref().set(with_credentials); + self.with_credentials.set(with_credentials); } fn Upload(self) -> Temporary { Temporary::new(self.upload) } fn Send(self, data: Option) -> 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 } - let data = match *self.request_method.deref().borrow() { + let data = match *self.request_method.borrow() { Get | Head => None, // Step 3 _ => 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)); // Step 6 - self.upload_events.deref().set(false); + self.upload_events.set(false); // Step 7 - self.upload_complete.deref().set(match extracted { + self.upload_complete.set(match extracted { None => true, Some (ref v) if v.len() == 0 => true, _ => false }); let mut addr = None; - if !self.sync.deref().get() { + if !self.sync.get() { // If one of the event handlers below aborts the fetch, // the assertion in release_once() will fail since we haven't pinned it yet. // 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 event_target: JSRef = EventTargetCast::from_ref(upload_target); if event_target.has_handlers() { - self.upload_events.deref().set(true); + self.upload_events.set(true); } // Step 9 - self.send_flag.deref().set(true); + self.send_flag.set(true); 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)); } } - 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. return Ok(()); } let global = self.global.root(); 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; // Default headers - let request_headers = self.request_headers.deref(); + let ref request_headers = self.request_headers; if request_headers.borrow().content_type.is_none() { let parameters = vec!((String::from_str("charset"), String::from_str("UTF-8"))); 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("*/*")) } - load_data.headers = (*self.request_headers.deref().borrow()).clone(); - load_data.method = (*self.request_method.deref().borrow()).clone(); + load_data.headers = (*self.request_headers.borrow()).clone(); + load_data.method = (*self.request_method.borrow()).clone(); 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 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 } else { CORSMode @@ -547,25 +546,25 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> { buf.push_str(format!("{:u}", p).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(), format!("{}", req.origin)), _ => {} } - if self.sync.deref().get() { + if self.sync.get() { return XMLHttpRequest::fetch(&mut Sync(self), resource_task, load_data, terminate_receiver, cors_request); } else { 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(); builder.spawn(proc() { let _ = XMLHttpRequest::fetch(&mut Async(addr.unwrap(), script_chan), resource_task, load_data, terminate_receiver, cors_request); }); - let timeout = self.timeout.deref().get(); + let timeout = self.timeout.get(); if timeout > 0 { self.set_timeout(timeout); } @@ -573,22 +572,22 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> { Ok(()) } fn Abort(self) { - self.terminate_sender.deref().borrow().as_ref().map(|s| s.send_opt(Abort)); - match self.ready_state.deref().get() { - Opened if self.send_flag.deref().get() => self.process_partial_response(ErroredMsg(Some(Abort))), + self.terminate_sender.borrow().as_ref().map(|s| s.send_opt(Abort)); + match self.ready_state.get() { + Opened if self.send_flag.get() => 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 { self.response_url.clone() } fn Status(self) -> u16 { - self.status.deref().get() + self.status.get() } fn StatusText(self) -> ByteString { - self.status_text.deref().borrow().clone() + self.status_text.borrow().clone() } fn GetResponseHeader(self, name: ByteString) -> Option { self.filter_response_headers().iter().find(|h| { @@ -610,7 +609,7 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> { ByteString::new(vec) } fn ResponseType(self) -> XMLHttpRequestResponseType { - self.response_type.deref().get() + self.response_type.get() } fn SetResponseType(self, response_type: XMLHttpRequestResponseType) -> ErrorResult { match self.global { @@ -618,28 +617,28 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> { => return Ok(()), _ => {} } - match self.ready_state.deref().get() { + match self.ready_state.get() { 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(()) } } } fn Response(self, cx: *mut JSContext) -> JSVal { - match self.response_type.deref().get() { + match self.response_type.get() { _empty | Text => { - let ready_state = self.ready_state.deref().get(); + let ready_state = self.ready_state.get(); if ready_state == XHRDone || ready_state == Loading { self.text_response().to_jsval(cx) } else { "".to_string().to_jsval(cx) } }, - _ if self.ready_state.deref().get() != XHRDone => NullValue(), + _ if self.ready_state.get() != XHRDone => NullValue(), 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 = decoded.as_slice().utf16_units().collect(); let mut vp = UndefinedValue(); unsafe { @@ -652,14 +651,14 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> { } _ => { // XXXManishearth handle other response types - self.response.deref().borrow().to_jsval(cx) + self.response.borrow().to_jsval(cx) } } } fn GetResponseText(self) -> Fallible { - match self.response_type.deref().get() { + match self.response_type.get() { _empty | Text => { - match self.ready_state.deref().get() { + match self.ready_state.get() { Loading | XHRDone => Ok(self.text_response()), _ => Ok("".to_string()) } @@ -716,25 +715,25 @@ trait PrivateXMLHttpRequestHelpers { 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 { - 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()); } - let pinned_count = self.pinned_count.deref().get(); - self.pinned_count.deref().set(pinned_count + 1); + let pinned_count = self.pinned_count.get(); + self.pinned_count.set(pinned_count + 1); TrustedXHRAddress(self.deref() as *const XMLHttpRequest as *const libc::c_void) } fn release_once(self) { - if self.sync.deref().get() { + if self.sync.get() { // Lets us call this at various termination cases without having to // check self.sync every time, since the pinning mechanism only is // meaningful during an async fetch return; } - assert!(self.pinned_count.deref().get() > 0) - let pinned_count = self.pinned_count.deref().get(); - self.pinned_count.deref().set(pinned_count - 1); - if self.pinned_count.deref().get() == 0 { + assert!(self.pinned_count.get() > 0) + let pinned_count = self.pinned_count.get(); + self.pinned_count.set(pinned_count - 1); + if self.pinned_count.get() == 0 { unsafe { 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) { - assert!(self.ready_state.deref().get() != rs) - self.ready_state.deref().set(rs); + assert!(self.ready_state.get() != rs) + self.ready_state.set(rs); let global = self.global.root(); let event = Event::new(&global.root_ref(), "readystatechange".to_string(), @@ -760,9 +759,9 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> { // Part of step 13, send() (processing request end of file) // Substep 1 - self.upload_complete.deref().set(true); + self.upload_complete.set(true); // 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("load".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) // XXXManishearth handle errors, if any (substep 1) // Substep 2 - *self.status_text.deref().borrow_mut() = ByteString::new(status.reason().container_into_owned_bytes()); - self.status.deref().set(status.code()); + *self.status_text.borrow_mut() = ByteString::new(status.reason().container_into_owned_bytes()); + self.status.set(status.code()); match headers { Some(ref h) => { - *self.response_headers.deref().borrow_mut() = h.clone(); + *self.response_headers.borrow_mut() = h.clone(); } None => {} }; // 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); } }, @@ -789,13 +788,13 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> { // XXXManishearth handle errors, if any (substep 1) // 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); } // Substep 3 - *self.response.deref().borrow_mut() = partial_response; + *self.response.borrow_mut() = partial_response; // Substep 4 - if !self.sync.deref().get() { + if !self.sync.get() { 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) // 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 - self.send_flag.deref().set(false); + self.send_flag.set(false); self.change_ready_state(XHRDone); // Subsubsteps 5-7 @@ -818,7 +817,7 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> { self.release_once(); }, ErroredMsg(e) => { - self.send_flag.deref().set(false); + self.send_flag.set(false); // XXXManishearth set response to NetworkError self.change_ready_state(XHRDone); let errormsg = match e { @@ -828,7 +827,7 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> { _ => unreachable!() }; - let upload_complete: &Cell = self.upload_complete.deref(); + let upload_complete: &Cell = &self.upload_complete; if !upload_complete.get() { upload_complete.set(true); self.dispatch_upload_progress_event("progress".to_string(), None); @@ -843,8 +842,8 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> { self.release_once(); }, TimeoutMsg => { - match self.ready_state.deref().get() { - Opened if self.send_flag.deref().get() => self.process_partial_response(ErroredMsg(Some(Timeout))), + match self.ready_state.get() { + Opened if self.send_flag.get() => self.process_partial_response(ErroredMsg(Some(Timeout))), Loading | HeadersReceived => self.process_partial_response(ErroredMsg(Some(Timeout))), _ => self.release_once() }; @@ -855,7 +854,7 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> { 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(); + let mut collection = self.request_headers.borrow_mut(); let value_bytes = value.into_bytes(); let mut reader = BufReader::new(value_bytes.as_slice()); let maybe_header: Option
= HeaderEnum::value_from_stream( @@ -888,26 +887,26 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> { } 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}); + let len = self.response.borrow().len() as u64; + let total = self.response_headers.borrow().content_length.map(|x| {x as u64}); self.dispatch_progress_event(false, type_, len, total); } 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() + let oneshot = self.timer.borrow_mut() .oneshot(Duration::milliseconds(timeout as i64)); let addr = unsafe { 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 self.release_once(); } - self.timeout_pinned.deref().set(true); + self.timeout_pinned.set(true); let global = self.global.root(); 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 () { match oneshot.recv_opt() { Ok(_) => { @@ -926,16 +925,16 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> { } fn cancel_timeout(self) { // Cancels timeouts on the object, if any - if self.timeout_pinned.deref().get() { - self.timeout_pinned.deref().set(false); + if self.timeout_pinned.get() { + self.timeout_pinned.set(false); self.release_once(); } // 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 { 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) => { for &(ref name, ref value) in x.parameters.iter() { 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 // 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 { // http://fetch.spec.whatwg.org/#concept-response-header-list 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() { "set-cookie" | "set-cookie2" => {}, // XXXManishearth additional CORS filtering goes here