Auto merge of #20838 - emilio:gecko-sync, r=emilio

style: Sync changes from mozilla-central.

See each individual commit for details.

components/style/gecko/conversions.rs

@@ -426,10 +426,10 @@ impl nsStyleImage {
         }
     }
 
-    unsafe fn get_image_url(self: &nsStyleImage) -> ComputedImageUrl {
+    unsafe fn get_image_url(&self) -> ComputedImageUrl {
-        let url_value = bindings::Gecko_GetURLValue(self);
+        let image_request = bindings::Gecko_GetImageRequest(self)
-        ComputedImageUrl::from_url_value_data(url_value.as_ref().unwrap())
+            .as_ref().expect("Null image request?");
-            .expect("Could not convert to ComputedUrl")
+        ComputedImageUrl::from_image_request(image_request)
     }
 
     unsafe fn get_gradient(self: &nsStyleImage) -> Box<Gradient> {
@@ -634,6 +634,7 @@ pub mod basic_shape {
     use gecko_bindings::structs::{StyleGeometryBox, StyleShapeSource, StyleShapeSourceType};
     use gecko_bindings::structs::{nsStyleCoord, nsStyleCorners};
     use gecko_bindings::sugar::ns_style_coord::{CoordDataMut, CoordDataValue};
+    use gecko_bindings::sugar::refptr::RefPtr;
     use std::borrow::Borrow;
     use values::computed::basic_shape::{BasicShape, ClippingShape, FloatAreaShape, ShapeRadius};
     use values::computed::border::{BorderCornerRadius, BorderRadius};
@@ -678,8 +679,8 @@ pub mod basic_shape {
             match other.mType {
                 StyleShapeSourceType::URL => unsafe {
                     let shape_image = &*other.mShapeImage.mPtr;
-                    let other_url = &(**shape_image.__bindgen_anon_1.mURLValue.as_ref());
+                    let other_url = RefPtr::new(*shape_image.__bindgen_anon_1.mURLValue.as_ref());
-                    let url = ComputedUrl::from_url_value_data(&other_url._base).unwrap();
+                    let url = ComputedUrl::from_url_value(other_url);
                     ShapeSource::ImageOrUrl(url)
                 },
                 StyleShapeSourceType::Image => {

components/style/gecko/url.rs

@@ -38,16 +38,11 @@ pub struct CssUrl {
 impl CssUrl {
     /// Try to parse a URL from a string value that is a valid CSS token for a
     /// URL.
-    ///
+    pub fn parse_from_string(url: String, context: &ParserContext) -> Self {
-    /// Returns `Err` in the case that extra_data is incomplete.
+        CssUrl {
-    pub fn parse_from_string<'a>(
-        url: String,
-        context: &ParserContext,
-    ) -> Result<Self, ParseError<'a>> {
-        Ok(CssUrl {
             serialization: Arc::new(url),
             extra_data: context.url_data.clone(),
-        })
+        }
     }
 
     /// Returns true if the URL is definitely invalid. We don't eagerly resolve
@@ -58,13 +53,13 @@ impl CssUrl {
     }
 
     /// Convert from URLValueData to SpecifiedUrl.
-    unsafe fn from_url_value_data(url: &URLValueData) -> Result<Self, ()> {
+    unsafe fn from_url_value_data(url: &URLValueData) -> Self {
         let arc_type =
             &url.mString as *const _ as *const RawOffsetArc<String>;
-        Ok(CssUrl {
+        CssUrl {
             serialization: Arc::from_raw_offset((*arc_type).clone()),
             extra_data: url.mExtraData.to_safe(),
-        })
+        }
     }
 
     /// Returns true if this URL looks like a fragment.
@@ -104,7 +99,7 @@ impl Parse for CssUrl {
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
         let url = input.expect_url()?;
-        Self::parse_from_string(url.as_ref().to_owned(), context)
+        Ok(Self::parse_from_string(url.as_ref().to_owned(), context))
     }
 }
 
@@ -188,11 +183,8 @@ pub struct SpecifiedImageUrl {
 
 impl SpecifiedImageUrl {
     /// Parse a URL from a string value. See SpecifiedUrl::parse_from_string.
-    pub fn parse_from_string<'a>(
+    pub fn parse_from_string(url: String, context: &ParserContext) -> Self {
-        url: String,
+        Self::from_css_url(CssUrl::parse_from_string(url, context))
-        context: &ParserContext,
-    ) -> Result<Self, ParseError<'a>> {
-        CssUrl::parse_from_string(url, context).map(Self::from_css_url)
     }
 
     fn from_css_url(url: CssUrl) -> Self {
@@ -295,11 +287,10 @@ impl ToCss for ComputedUrl {
 }
 
 impl ComputedUrl {
-    /// Convert from URLValueData to ComputedUrl.
+    /// Convert from RefPtr<URLValue> to ComputedUrl.
-    pub unsafe fn from_url_value_data(url: &URLValueData) -> Result<Self, ()> {
+    pub unsafe fn from_url_value(url_value: RefPtr<URLValue>) -> Self {
-        Ok(ComputedUrl(
+        let url = CssUrl::from_url_value_data(&url_value._base);
-            SpecifiedUrl::from_css_url(CssUrl::from_url_value_data(url)?)
+        ComputedUrl(SpecifiedUrl { url, url_value })
-        ))
     }
 }
 
@@ -317,21 +308,10 @@ impl ToCss for ComputedImageUrl {
 }
 
 impl ComputedImageUrl {
-    /// Convert from URLValueData to SpecifiedUrl.
-    pub unsafe fn from_url_value_data(url: &URLValueData) -> Result<Self, ()> {
-        Ok(ComputedImageUrl(
-            SpecifiedImageUrl::from_css_url(CssUrl::from_url_value_data(url)?)
-        ))
-    }
-
     /// Convert from nsStyleImageReques to ComputedImageUrl.
-    pub unsafe fn from_image_request(image_request: &nsStyleImageRequest) -> Result<Self, ()> {
+    pub unsafe fn from_image_request(image_request: &nsStyleImageRequest) -> Self {
-        if image_request.mImageValue.mRawPtr.is_null() {
+        let image_value = image_request.mImageValue.to_safe();
-            return Err(());
+        let url = CssUrl::from_url_value_data(&image_value._base);
-        }
+        ComputedImageUrl(SpecifiedImageUrl { url, image_value })
-
-        let image_value = image_request.mImageValue.mRawPtr.as_ref().unwrap();
-        let url_value_data = &image_value._base;
-        Self::from_url_value_data(url_value_data)
     }
 }

components/style/properties/gecko.mako.rs

@@ -43,6 +43,7 @@ use gecko_bindings::structs::mozilla::CSSPseudoElementType;
 use gecko_bindings::structs::mozilla::CSSPseudoElementType_InheritingAnonBox;
 use gecko_bindings::structs::root::NS_STYLE_CONTEXT_TYPE_SHIFT;
 use gecko_bindings::sugar::ns_style_coord::{CoordDataValue, CoordData, CoordDataMut};
+use gecko_bindings::sugar::refptr::RefPtr;
 use gecko::values::convert_nscolor_to_rgba;
 use gecko::values::convert_rgba_to_nscolor;
 use gecko::values::GeckoStyleCoordConvertible;
@@ -758,13 +759,10 @@ def set_gecko_property(ffi_name, expr):
             nsStyleSVGPaintType::eStyleSVGPaintType_ContextFill => SVGPaintKind::ContextFill,
             nsStyleSVGPaintType::eStyleSVGPaintType_ContextStroke => SVGPaintKind::ContextStroke,
             nsStyleSVGPaintType::eStyleSVGPaintType_Server => {
-                unsafe {
+                SVGPaintKind::PaintServer(unsafe {
-                    SVGPaintKind::PaintServer(
+                    let url = RefPtr::new(*paint.mPaint.mPaintServer.as_ref());
-                        ComputedUrl::from_url_value_data(
+                    ComputedUrl::from_url_value(url)
-                            &(**paint.mPaint.mPaintServer.as_ref())._base
+                })
-                        ).unwrap()
-                    )
-                }
             }
             nsStyleSVGPaintType::eStyleSVGPaintType_Color => {
                 unsafe { SVGPaintKind::Color(convert_nscolor_to_rgba(*paint.mPaint.mColor.as_ref())) }
@@ -967,13 +965,9 @@ def set_gecko_property(ffi_name, expr):
             return UrlOrNone::none()
         }
 
-        unsafe {
+        UrlOrNone::Url(unsafe {
-            let gecko_url_value = &*self.gecko.${gecko_ffi_name}.mRawPtr;
+            ComputedUrl::from_url_value(self.gecko.${gecko_ffi_name}.to_safe())
-            UrlOrNone::Url(
+        })
-                ComputedUrl::from_url_value_data(&gecko_url_value._base)
-                    .expect("${gecko_ffi_name} could not convert to ComputedUrl")
-            )
-        }
     }
 </%def>
 
@@ -2613,10 +2607,16 @@ fn static_assert() {
     }
 
     pub fn set_font_stretch(&mut self, v: longhands::font_stretch::computed_value::T) {
-        unsafe { bindings::Gecko_FontStretch_SetFloat(&mut self.gecko.mFont.stretch, (v.0).0) };
+        unsafe {
+            bindings::Gecko_FontStretch_SetFloat(
+                &mut self.gecko.mFont.stretch,
+                v.value(),
+            )
+        };
     }
     ${impl_simple_copy('font_stretch', 'mFont.stretch')}
     pub fn clone_font_stretch(&self) -> longhands::font_stretch::computed_value::T {
+        use values::computed::font::FontStretch;
         use values::computed::Percentage;
         use values::generics::NonNegative;
 
@@ -2624,7 +2624,7 @@ fn static_assert() {
             unsafe { bindings::Gecko_FontStretch_ToFloat(self.gecko.mFont.stretch) };
         debug_assert!(stretch >= 0.);
 
-        NonNegative(Percentage(stretch))
+        FontStretch(NonNegative(Percentage(stretch)))
     }
 
     pub fn set_font_style(&mut self, v: longhands::font_style::computed_value::T) {
@@ -4146,9 +4146,7 @@ fn static_assert() {
 
         unsafe {
             let ref gecko_image_request = *self.gecko.mListStyleImage.mRawPtr;
-            UrlOrNone::Url(ComputedImageUrl::from_image_request(
+            UrlOrNone::Url(ComputedImageUrl::from_image_request(gecko_image_request))
-                gecko_image_request
-            ).expect("mListStyleImage could not convert to ComputedImageUrl"))
         }
     }
 
@@ -4553,11 +4551,10 @@ fn static_assert() {
                     });
                 },
                 NS_STYLE_FILTER_URL => {
-                    filters.push(unsafe {
+                    filters.push(Filter::Url(unsafe {
-                        Filter::Url(
+                        let url = RefPtr::new(*filter.__bindgen_anon_1.mURL.as_ref());
-                            ComputedUrl::from_url_value_data(&(**filter.__bindgen_anon_1.mURL.as_ref())._base).unwrap()
+                        ComputedUrl::from_url_value(url)
-                        )
+                    }));
-                    });
                 }
                 _ => {},
             }
@@ -5438,7 +5435,6 @@ clip-path
             let url = unsafe {
                 let gecko_image_request = gecko_cursor_image.mImage.mRawPtr.as_ref().unwrap();
                 ComputedImageUrl::from_image_request(&gecko_image_request)
-                    .expect("mCursorImages.mImage could not convert to ComputedImageUrl")
             };
 
             let hotspot =
@@ -5714,7 +5710,6 @@ clip-path
                                 &**gecko_content.mContent.mImage.as_ref();
                             ContentItem::Url(
                                 ComputedImageUrl::from_image_request(gecko_image_request)
-                                    .expect("mContent could not convert to ComputedImageUrl")
                             )
                         }
                     },

components/style/properties/longhand/font.mako.rs

@@ -335,7 +335,7 @@ ${helpers.predefined_type("-x-text-zoom",
                 use gecko_bindings::structs::{LookAndFeel_FontID, nsFont};
                 use std::mem;
                 use values::computed::Percentage;
-                use values::computed::font::{FontSize, FontStyle, FontFamilyList};
+                use values::computed::font::{FontSize, FontStretch, FontStyle, FontFamilyList};
                 use values::generics::NonNegative;
 
                 let id = match *self {
@@ -356,9 +356,9 @@ ${helpers.predefined_type("-x-text-zoom",
                     )
                 }
                 let font_weight = longhands::font_weight::computed_value::T::from_gecko_weight(system.weight);
-                let font_stretch = NonNegative(Percentage(unsafe {
+                let font_stretch = FontStretch(NonNegative(Percentage(unsafe {
                     bindings::Gecko_FontStretch_ToFloat(system.stretch)
-                }));
+                })));
                 let font_style = FontStyle::from_gecko(system.style);
                 let ret = ComputedSystemFont {
                     font_family: longhands::font_family::computed_value::T(

components/style/servo/url.rs

@@ -40,18 +40,14 @@ pub struct CssUrl {
 
 impl CssUrl {
     /// Try to parse a URL from a string value that is a valid CSS token for a
-    /// URL. Never fails - the API is only fallible to be compatible with the
+    /// URL.
-    /// gecko version.
+    pub fn parse_from_string(url: String, context: &ParserContext) -> Self {
-    pub fn parse_from_string<'a>(
-        url: String,
-        context: &ParserContext,
-    ) -> Result<Self, ParseError<'a>> {
         let serialization = Arc::new(url);
         let resolved = context.url_data.join(&serialization).ok();
-        Ok(CssUrl {
+        CssUrl {
             original: Some(serialization),
             resolved: resolved,
-        })
+        }
     }
 
     /// Returns true if the URL is definitely invalid. For Servo URLs, we can
@@ -110,7 +106,7 @@ impl Parse for CssUrl {
         input: &mut Parser<'i, 't>,
     ) -> Result<Self, ParseError<'i>> {
         let url = input.expect_url()?;
-        Self::parse_from_string(url.as_ref().to_owned(), context)
+        Ok(Self::parse_from_string(url.as_ref().to_owned(), context))
     }
 }
 

components/style/stylesheets/rule_parser.rs

@@ -158,7 +158,7 @@ impl<'a, 'i, R: ParseErrorReporter> AtRuleParser<'i> for TopLevelRuleParser<'a,
                 }
 
                 let url_string = input.expect_url_or_string()?.as_ref().to_owned();
-                let url = CssUrl::parse_from_string(url_string, &self.context)?;
+                let url = CssUrl::parse_from_string(url_string, &self.context);
 
                 let media = parse_media_query_list(&self.context, input,
                                                    self.error_context.error_reporter);

components/style/values/specified/box.rs

@@ -212,6 +212,8 @@ impl Display {
             Display::Table => Display::InlineTable,
             Display::Flex => Display::InlineFlex,
             Display::Grid => Display::InlineGrid,
+            // XXX bug 1105868 this should probably be InlineListItem:
+            Display::ListItem => Display::Inline,
             Display::MozBox => Display::MozInlineBox,
             Display::MozStack => Display::MozInlineStack,
             Display::WebkitBox => Display::WebkitInlineBox,

components/style/values/specified/image.rs

@@ -990,7 +990,7 @@ impl Parse for MozImageRect {
         input.try(|i| i.expect_function_matching("-moz-image-rect"))?;
         input.parse_nested_block(|i| {
             let string = i.expect_url_or_string()?;
-            let url = SpecifiedImageUrl::parse_from_string(string.as_ref().to_owned(), context)?;
+            let url = SpecifiedImageUrl::parse_from_string(string.as_ref().to_owned(), context);
             i.expect_comma()?;
             let top = NumberOrPercentage::parse_non_negative(context, i)?;
             i.expect_comma()?;