From c95fc0c9237714e76b5e969b73a6440b205cbe27 Mon Sep 17 00:00:00 2001 From: Ms2ger Date: Fri, 1 May 2015 21:16:20 +0200 Subject: [PATCH 01/12] Stop using IndexMut on HashMap. This feature was removed in https://github.com/rust-lang/rust/pull/23559. --- components/gfx/buffer_map.rs | 2 +- components/gfx/font_cache_task.rs | 8 ++++---- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/components/gfx/buffer_map.rs b/components/gfx/buffer_map.rs index 69b798b4e19..cba6fa82b59 100644 --- a/components/gfx/buffer_map.rs +++ b/components/gfx/buffer_map.rs @@ -109,7 +109,7 @@ impl BufferMap { } }; if { - let list = &mut self.map[old_key].buffers; + let list = &mut self.map.get_mut(&old_key).unwrap().buffers; let condemned_buffer = list.pop().take().unwrap(); self.mem -= condemned_buffer.get_mem(); condemned_buffer.destroy(graphics_context); diff --git a/components/gfx/font_cache_task.rs b/components/gfx/font_cache_task.rs index 24e36ba3163..250eb484a55 100644 --- a/components/gfx/font_cache_task.rs +++ b/components/gfx/font_cache_task.rs @@ -139,7 +139,7 @@ impl FontCache { let maybe_resource = load_whole_resource(&self.resource_task, url.clone()); match maybe_resource { Ok((_, bytes)) => { - let family = &mut self.web_families[family_name]; + let family = &mut self.web_families.get_mut(&family_name).unwrap(); family.add_template(&url.to_string(), Some(bytes)); }, Err(_) => { @@ -148,7 +148,7 @@ impl FontCache { } } Source::Local(ref local_family_name) => { - let family = &mut self.web_families[family_name]; + let family = &mut self.web_families.get_mut(&family_name).unwrap(); get_variations_for_family(&local_family_name, |path| { family.add_template(&path, None); }); @@ -188,7 +188,7 @@ impl FontCache { // look up canonical name if self.local_families.contains_key(family_name) { debug!("FontList: Found font family with name={}", &**family_name); - let s = &mut self.local_families[*family_name]; + let s = self.local_families.get_mut(family_name).unwrap(); if s.templates.len() == 0 { get_variations_for_family(&family_name, |path| { @@ -213,7 +213,7 @@ impl FontCache { fn find_font_in_web_family<'a>(&'a mut self, family_name: &LowercaseString, desc: &FontTemplateDescriptor) -> Option> { if self.web_families.contains_key(family_name) { - let family = &mut self.web_families[*family_name]; + let family = self.web_families.get_mut(family_name).unwrap(); let maybe_font = family.find_font_for_style(desc, &self.font_context); maybe_font } else { From ad4996b5458f7df256d3e59be2b5a820215cea84 Mon Sep 17 00:00:00 2001 From: Ms2ger Date: Fri, 1 May 2015 21:16:43 +0200 Subject: [PATCH 02/12] Remove a range() call. --- components/layout/table_rowgroup.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/components/layout/table_rowgroup.rs b/components/layout/table_rowgroup.rs index 8990b127da4..034597965bc 100644 --- a/components/layout/table_rowgroup.rs +++ b/components/layout/table_rowgroup.rs @@ -88,7 +88,7 @@ impl TableRowGroupFlow { self.collapsed_inline_direction_border_widths_for_table .extend(collapsed_inline_direction_border_widths_for_table.into_iter().map(|x| *x)); - for _ in range(0, self.block_flow.base.children.len()) { + for _ in 0..self.block_flow.base.children.len() { if let Some(collapsed_block_direction_border_width_for_table) = collapsed_block_direction_border_widths_for_table.next() { self.collapsed_block_direction_border_widths_for_table From 0a5ffc4bb04304c4bdd1e6cebcadb7823e1bff1f Mon Sep 17 00:00:00 2001 From: Ms2ger Date: Fri, 1 May 2015 21:17:14 +0200 Subject: [PATCH 03/12] Remove an as_slice() call. --- components/layout/table_wrapper.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/components/layout/table_wrapper.rs b/components/layout/table_wrapper.rs index 7369acbbf4c..720f80566cc 100644 --- a/components/layout/table_wrapper.rs +++ b/components/layout/table_wrapper.rs @@ -305,7 +305,7 @@ impl Flow for TableWrapperFlow { self.compute_used_inline_size(layout_context, containing_block_inline_size, - intermediate_column_inline_sizes.as_slice()); + &intermediate_column_inline_sizes); if let TableLayout::Auto = self.table_layout { self.calculate_table_column_sizes_for_automatic_layout( From 84b1b5268217d2be6fc729282cd4a921c93ccc5b Mon Sep 17 00:00:00 2001 From: Ms2ger Date: Fri, 1 May 2015 21:19:11 +0200 Subject: [PATCH 04/12] Replace ByteString::as_slice() by a Deref implementation. --- components/script/dom/bindings/conversions.rs | 5 ++--- components/script/dom/bindings/str.rs | 14 ++++++++------ components/script/dom/xmlhttprequest.rs | 8 ++++---- 3 files changed, 14 insertions(+), 13 deletions(-) diff --git a/components/script/dom/bindings/conversions.rs b/components/script/dom/bindings/conversions.rs index aa509ad5927..5055921bb3a 100644 --- a/components/script/dom/bindings/conversions.rs +++ b/components/script/dom/bindings/conversions.rs @@ -400,9 +400,8 @@ impl FromJSValConvertible for USVString { impl ToJSValConvertible for ByteString { fn to_jsval(&self, cx: *mut JSContext) -> JSVal { unsafe { - let slice = self.as_slice(); - let jsstr = JS_NewStringCopyN(cx, slice.as_ptr() as *const libc::c_char, - slice.len() as libc::size_t); + let jsstr = JS_NewStringCopyN(cx, self.as_ptr() as *const libc::c_char, + self.len() as libc::size_t); if jsstr.is_null() { panic!("JS_NewStringCopyN failed"); } diff --git a/components/script/dom/bindings/str.rs b/components/script/dom/bindings/str.rs index fff381e98f8..4b275baa934 100644 --- a/components/script/dom/bindings/str.rs +++ b/components/script/dom/bindings/str.rs @@ -6,6 +6,7 @@ use std::borrow::ToOwned; use std::hash::{Hash, Hasher}; +use std::ops; use std::str; use std::str::FromStr; @@ -27,12 +28,6 @@ impl ByteString { str::from_utf8(&vec).ok() } - /// Returns the underlying vector as a slice. - pub fn as_slice<'a>(&'a self) -> &'a [u8] { - let ByteString(ref vector) = *self; - vector - } - /// Returns the length. pub fn len(&self) -> usize { let ByteString(ref vector) = *self; @@ -158,6 +153,13 @@ impl FromStr for ByteString { } } +impl ops::Deref for ByteString { + type Target = [u8]; + fn deref(&self) -> &[u8] { + &self.0 + } +} + /// A string that is constructed from a UCS-2 buffer by replacing invalid code /// points with the replacement character. pub struct USVString(pub String); diff --git a/components/script/dom/xmlhttprequest.rs b/components/script/dom/xmlhttprequest.rs index 73748b27f14..d9e0f57ad8d 100644 --- a/components/script/dom/xmlhttprequest.rs +++ b/components/script/dom/xmlhttprequest.rs @@ -399,14 +399,14 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> { debug!("SetRequestHeader: old value = {:?}", raw[0]); let mut buf = raw[0].clone(); buf.push_all(b", "); - buf.push_all(value.as_slice()); + buf.push_all(&value); debug!("SetRequestHeader: new value = {:?}", buf); value = ByteString::new(buf); }, None => {} } - headers.set_raw(name_str.to_owned(), vec![value.as_slice().to_vec()]); + headers.set_raw(name_str.to_owned(), vec![value.to_vec()]); Ok(()) } @@ -678,7 +678,7 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> { }, _ if self.ready_state.get() != XMLHttpRequestState::Done => NullValue(), Json => { - let decoded = UTF_8.decode(self.response.borrow().as_slice(), DecoderTrap::Replace).unwrap().to_owned(); + let decoded = UTF_8.decode(&self.response.borrow(), DecoderTrap::Replace).unwrap().to_owned(); let decoded: Vec = decoded.utf16_units().collect(); let mut vp = UndefinedValue(); unsafe { @@ -1028,7 +1028,7 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> { let response = self.response.borrow(); // 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(response.as_slice(), DecoderTrap::Replace).unwrap().to_owned() + encoding.decode(&response, DecoderTrap::Replace).unwrap().to_owned() } fn filter_response_headers(self) -> Headers { // https://fetch.spec.whatwg.org/#concept-response-header-list From b59f54ce81e06c416e039119e1df70e5cbde41f8 Mon Sep 17 00:00:00 2001 From: Ms2ger Date: Fri, 1 May 2015 21:19:37 +0200 Subject: [PATCH 05/12] Add a Reflectable bound to Root's type parameter. --- components/script/dom/bindings/js.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/components/script/dom/bindings/js.rs b/components/script/dom/bindings/js.rs index c80aa48b4ac..70dd88c1842 100644 --- a/components/script/dom/bindings/js.rs +++ b/components/script/dom/bindings/js.rs @@ -593,7 +593,7 @@ impl RootCollection { /// `RootCollection` object. Attempts to transfer ownership of a `Root` via /// moving will trigger dynamic unrooting failures due to incorrect ordering. #[no_move] -pub struct Root { +pub struct Root { /// List that ensures correct dynamic root ordering root_list: &'static RootCollection, /// Reference to rooted value that must not outlive this container From 5f6b791e626b1a012665b917cb9173ceaf5f4bcc Mon Sep 17 00:00:00 2001 From: Ms2ger Date: Fri, 1 May 2015 21:19:46 +0200 Subject: [PATCH 06/12] Add a Reflectable bound to Trusted's type parameter. --- components/script/dom/bindings/refcounted.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/components/script/dom/bindings/refcounted.rs b/components/script/dom/bindings/refcounted.rs index 8a626ac6b67..204ef93e023 100644 --- a/components/script/dom/bindings/refcounted.rs +++ b/components/script/dom/bindings/refcounted.rs @@ -47,7 +47,7 @@ unsafe impl Send for TrustedReference {} /// shared among tasks for use in asynchronous operations. The underlying /// DOM object is guaranteed to live at least as long as the last outstanding /// `Trusted` instance. -pub struct Trusted { +pub struct Trusted { /// A pointer to the Rust DOM object of type T, but void to allow /// sending `Trusted` between tasks, regardless of T's sendability. ptr: *const libc::c_void, From bd77acfbb87a7ac8e987e38c14f26441fb0de64f Mon Sep 17 00:00:00 2001 From: Ms2ger Date: Fri, 1 May 2015 21:20:16 +0200 Subject: [PATCH 07/12] Use AsciiExt in ByteString implementations. --- components/script/dom/bindings/str.rs | 13 +++---------- 1 file changed, 3 insertions(+), 10 deletions(-) diff --git a/components/script/dom/bindings/str.rs b/components/script/dom/bindings/str.rs index 4b275baa934..b8c0af0caa6 100644 --- a/components/script/dom/bindings/str.rs +++ b/components/script/dom/bindings/str.rs @@ -4,6 +4,7 @@ //! The `ByteString` struct. +use std::ascii::AsciiExt; use std::borrow::ToOwned; use std::hash::{Hash, Hasher}; use std::ops; @@ -36,20 +37,12 @@ impl ByteString { /// Compare `self` to `other`, matching A–Z and a–z as equal. pub fn eq_ignore_case(&self, other: &ByteString) -> bool { - // XXXManishearth make this more efficient - self.to_lower() == other.to_lower() + self.0.eq_ignore_ascii_case(&other.0) } /// Returns `self` with A–Z replaced by a–z. pub fn to_lower(&self) -> ByteString { - let ByteString(ref vec) = *self; - ByteString::new(vec.iter().map(|&x| { - if x > 'A' as u8 && x < 'Z' as u8 { - x + ('a' as u8) - ('A' as u8) - } else { - x - } - }).collect()) + ByteString::new(self.0.to_ascii_lowercase()) } /// Returns whether `self` is a `token`, as defined by From 568b7f3a53f298ffc627bfaab033ee14fb51e739 Mon Sep 17 00:00:00 2001 From: Ms2ger Date: Fri, 1 May 2015 21:20:34 +0200 Subject: [PATCH 08/12] Replace -1 by !0 for unsigned integers. --- components/script/dom/bindings/trace.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/components/script/dom/bindings/trace.rs b/components/script/dom/bindings/trace.rs index c25b0addc47..d7d0cc51e9c 100644 --- a/components/script/dom/bindings/trace.rs +++ b/components/script/dom/bindings/trace.rs @@ -99,7 +99,7 @@ pub fn trace_jsval(tracer: *mut JSTracer, description: &str, val: JSVal) { unsafe { let name = CString::new(description).unwrap(); (*tracer).debugPrinter = None; - (*tracer).debugPrintIndex = -1; + (*tracer).debugPrintIndex = !0; (*tracer).debugPrintArg = name.as_ptr() as *const libc::c_void; debug!("tracing value {}", description); JS_CallTracer(tracer, val.to_gcthing(), val.trace_kind()); @@ -117,7 +117,7 @@ pub fn trace_object(tracer: *mut JSTracer, description: &str, obj: *mut JSObject unsafe { let name = CString::new(description).unwrap(); (*tracer).debugPrinter = None; - (*tracer).debugPrintIndex = -1; + (*tracer).debugPrintIndex = !0; (*tracer).debugPrintArg = name.as_ptr() as *const libc::c_void; debug!("tracing {}", description); JS_CallTracer(tracer, obj as *mut libc::c_void, JSGCTraceKind::JSTRACE_OBJECT); From 9a97a7e30c715979afe28df5d8b23a4807a1a046 Mon Sep 17 00:00:00 2001 From: Ms2ger Date: Fri, 1 May 2015 21:21:26 +0200 Subject: [PATCH 09/12] Add a VecRootableType bound to RootedVec's type parameter. --- components/script/dom/bindings/trace.rs | 38 ++++++++++++++++++------- 1 file changed, 27 insertions(+), 11 deletions(-) diff --git a/components/script/dom/bindings/trace.rs b/components/script/dom/bindings/trace.rs index d7d0cc51e9c..14d23920ab9 100644 --- a/components/script/dom/bindings/trace.rs +++ b/components/script/dom/bindings/trace.rs @@ -318,16 +318,20 @@ impl JSTraceable for () { /// Holds a set of vectors that need to be rooted pub struct RootedCollectionSet { - set: Vec>> + set: Vec>> } /// TLV Holds a set of vectors that need to be rooted thread_local!(pub static ROOTED_COLLECTIONS: Rc> = Rc::new(RefCell::new(RootedCollectionSet::new()))); -enum CollectionType { +/// Type of `RootedVec` +pub enum CollectionType { + /// DOM objects DOMObjects, + /// `JSVal`s JSVals, + /// `*mut JSObject`s JSObjects, } @@ -356,10 +360,12 @@ impl RootedCollectionSet { } unsafe fn trace(&self, tracer: *mut JSTracer) { - fn trace_collection_type(tracer: *mut JSTracer, - collections: &HashSet<*const RootedVec<()>>) { + fn trace_collection_type(tracer: *mut JSTracer, + collections: &HashSet<*const RootedVec>) + where T: JSTraceable + VecRootableType + { for collection in collections { - let collection: *const RootedVec<()> = *collection; + let collection: *const RootedVec = *collection; let collection = collection as *const RootedVec; unsafe { let _ = (*collection).trace(tracer); @@ -367,10 +373,10 @@ impl RootedCollectionSet { } } - let dom_collections = &self.set[CollectionType::DOMObjects as usize] as *const _ as *const HashSet<*const RootedVec<*const Reflector>>; + let dom_collections = &self.set[CollectionType::DOMObjects as usize] as *const _ as *const HashSet<*const RootedVec>>; for dom_collection in (*dom_collections).iter() { for reflector in (**dom_collection).iter() { - trace_reflector(tracer, "", &**reflector); + trace_reflector(tracer, "", reflector.reflector()); } } @@ -381,7 +387,7 @@ impl RootedCollectionSet { /// Trait implemented by all types that can be used with RootedVec -trait VecRootableType { +pub trait VecRootableType { /// Return the type tag used to determine how to trace RootedVec fn tag(_a: Option) -> CollectionType; } @@ -398,11 +404,21 @@ impl VecRootableType for *mut JSObject { fn tag(_a: Option<*mut JSObject>) -> CollectionType { CollectionType::JSObjects } } +enum Void {} + +impl VecRootableType for Void { + fn tag(_a: Option) -> CollectionType { unreachable!() } +} + +impl Reflectable for Void { + fn reflector<'a>(&'a self) -> &'a Reflector { unreachable!() } +} + /// A vector of items that are rooted for the lifetime /// of this struct #[allow(unrooted_must_root)] #[no_move] -pub struct RootedVec { +pub struct RootedVec { v: Vec } @@ -435,14 +451,14 @@ impl Drop for RootedVec { } } -impl Deref for RootedVec { +impl Deref for RootedVec { type Target = Vec; fn deref(&self) -> &Vec { &self.v } } -impl DerefMut for RootedVec { +impl DerefMut for RootedVec { fn deref_mut(&mut self) -> &mut Vec { &mut self.v } From a3adf6ab750c1548fb89dc935d7da744d5aea17a Mon Sep 17 00:00:00 2001 From: Ms2ger Date: Fri, 1 May 2015 21:21:50 +0200 Subject: [PATCH 10/12] Stop using MemWriter in Element::serialize. --- components/script/dom/element.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/components/script/dom/element.rs b/components/script/dom/element.rs index a936e783ad4..deb2df56b84 100644 --- a/components/script/dom/element.rs +++ b/components/script/dom/element.rs @@ -83,7 +83,7 @@ use std::borrow::{IntoCow, ToOwned}; use std::cell::{Ref, RefMut}; use std::default::Default; use std::mem; -use std::old_io::{MemWriter, Writer}; +use std::old_io::Writer; use std::sync::Arc; #[dom_struct] @@ -571,13 +571,13 @@ impl<'a> ElementHelpers<'a> for JSRef<'a, Element> { fn serialize(self, traversal_scope: TraversalScope) -> Fallible { let node: JSRef = NodeCast::from_ref(self); - let mut writer = MemWriter::new(); + let mut writer = vec![]; match serialize(&mut writer, &node, SerializeOpts { traversal_scope: traversal_scope, .. Default::default() }) { - Ok(()) => Ok(String::from_utf8(writer.into_inner()).unwrap()), + Ok(()) => Ok(String::from_utf8(writer).unwrap()), Err(_) => panic!("Cannot serialize element"), } } From e282b71596af0bf2dd453c405db55cc1f80f339c Mon Sep 17 00:00:00 2001 From: Ms2ger Date: Fri, 1 May 2015 21:22:16 +0200 Subject: [PATCH 11/12] Simplify the implementation of make_url_or_base_getter. --- components/script/dom/macros.rs | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-) diff --git a/components/script/dom/macros.rs b/components/script/dom/macros.rs index 76157789e71..b3dda8730e0 100644 --- a/components/script/dom/macros.rs +++ b/components/script/dom/macros.rs @@ -85,12 +85,11 @@ macro_rules! make_url_or_base_getter( use std::ascii::AsciiExt; let element: JSRef = ElementCast::from_ref(self); let url = element.get_url_attribute(&Atom::from_slice($htmlname)); - match &*url { - "" => { - let window = window_from_node(self).root(); - window.r().get_url().serialize() - }, - _ => url + if url.is_empty() { + let window = window_from_node(self).root(); + window.r().get_url().serialize() + } else { + url } } ); From 99d6f83b663fb40c70357cd0389e7f705e95ee8e Mon Sep 17 00:00:00 2001 From: Ms2ger Date: Fri, 1 May 2015 21:22:35 +0200 Subject: [PATCH 12/12] Use a better name in TextEncoder::Encode. --- components/script/dom/textencoder.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/components/script/dom/textencoder.rs b/components/script/dom/textencoder.rs index 91a02257d71..75d2badd9e6 100644 --- a/components/script/dom/textencoder.rs +++ b/components/script/dom/textencoder.rs @@ -80,12 +80,12 @@ impl<'a> TextEncoderMethods for JSRef<'a, TextEncoder> { #[allow(unsafe_code)] fn Encode(self, cx: *mut JSContext, input: USVString) -> *mut JSObject { unsafe { - let output = self.encoder.encode(&input.0, EncoderTrap::Strict).unwrap(); - let length = output.len() as u32; + let encoded = self.encoder.encode(&input.0, EncoderTrap::Strict).unwrap(); + let length = encoded.len() as u32; let js_object: *mut JSObject = JS_NewUint8Array(cx, length); let js_object_data: *mut uint8_t = JS_GetUint8ArrayData(js_object, cx); - ptr::copy_nonoverlapping(js_object_data, output.as_ptr(), length as usize); + ptr::copy_nonoverlapping(js_object_data, encoded.as_ptr(), length as usize); return js_object; } }