diff --git a/layout/painting/nsCSSRenderingBorders.cpp b/layout/painting/nsCSSRenderingBorders.cpp index 4cef49606185..4ac2d676099f 100644 --- a/layout/painting/nsCSSRenderingBorders.cpp +++ b/layout/painting/nsCSSRenderingBorders.cpp @@ -3707,7 +3707,7 @@ ImgDrawResult nsCSSBorderImageRenderer::CreateWebRenderCommands( renderer.BuildWebRenderParameters(1.0, extendMode, stops, lineStart, lineEnd, gradientRadius); - if (gradient.IsLinear()) { + if (gradient.kind.IsLinear()) { LayoutDevicePoint startPoint = LayoutDevicePoint(dest.origin.x, dest.origin.y) + lineStart; LayoutDevicePoint endPoint = diff --git a/layout/painting/nsCSSRenderingGradients.cpp b/layout/painting/nsCSSRenderingGradients.cpp index 8b289706b6c7..cc258050f2e2 100644 --- a/layout/painting/nsCSSRenderingGradients.cpp +++ b/layout/painting/nsCSSRenderingGradients.cpp @@ -66,9 +66,9 @@ static Tuple ComputeLinearGradientLine( using X = StyleHorizontalPositionKeyword; using Y = StyleVerticalPositionKeyword; - const StyleLineDirection& direction = aGradient.AsLinear().direction; + const StyleLineDirection& direction = aGradient.kind.AsLinear(); const bool isModern = - aGradient.AsLinear().compat_mode == StyleGradientCompatMode::Modern; + aGradient.compat_mode == StyleGradientCompatMode::Modern; CSSPoint center(aBoxSize.width / 2, aBoxSize.height / 2); switch (direction.tag) { @@ -154,9 +154,9 @@ static RadialGradientRadii ComputeRadialGradientRadii(const EndingShape& aShape, // ellipse to use. static Tuple ComputeRadialGradientLine( const StyleGradient& aGradient, const CSSSize& aBoxSize) { - const auto& radial = aGradient.AsRadial(); - const EndingShape& endingShape = radial.shape; - const Position& position = radial.position; + const auto& radial = aGradient.kind.AsRadial(); + const EndingShape& endingShape = radial._0; + const Position& position = radial._1; CSSPoint start = ResolvePosition(position, aBoxSize); // Compute gradient shape: the x and y radii of an ellipse. @@ -566,19 +566,17 @@ static Maybe GetSpecifiedGradientPosition( static nsTArray ComputeColorStops(ComputedStyle* aComputedStyle, const StyleGradient& aGradient, CSSCoord aLineLength) { - auto items = aGradient.IsLinear() ? aGradient.AsLinear().items.AsSpan() - : aGradient.AsRadial().items.AsSpan(); - - MOZ_ASSERT(items.Length() >= 2, + MOZ_ASSERT(aGradient.items.Length() >= 2, "The parser should reject gradients with less than two stops"); - nsTArray stops(items.Length()); + nsTArray stops(aGradient.items.Length()); // If there is a run of stops before stop i that did not have specified // positions, then this is the index of the first stop in that run. Maybe firstUnsetPosition; - for (size_t i = 0; i < items.Length(); ++i) { - const auto& stop = items[i]; + auto span = aGradient.items.AsSpan(); + for (size_t i = 0; i < aGradient.items.Length(); ++i) { + const auto& stop = span[i]; double position; Maybe specifiedPosition = @@ -589,7 +587,7 @@ static nsTArray ComputeColorStops(ComputedStyle* aComputedStyle, } else if (i == 0) { // First stop defaults to position 0.0 position = 0.0; - } else if (i == items.Length() - 1) { + } else if (i == aGradient.items.Length() - 1) { // Last stop defaults to position 1.0 position = 1.0; } else { @@ -643,7 +641,7 @@ nsCSSGradientRenderer nsCSSGradientRenderer::Create( // the gradient. CSSPoint lineStart, lineEnd; CSSCoord radiusX = 0, radiusY = 0; // for radial gradients only - if (aGradient.IsLinear()) { + if (aGradient.kind.IsLinear()) { Tie(lineStart, lineEnd) = ComputeLinearGradientLine(aPresContext, aGradient, srcSize); } else { @@ -701,10 +699,10 @@ void nsCSSGradientRenderer::Paint(gfxContext& aContext, const nsRect& aDest, // between tiles, we can optimise away most of the work by converting to a // repeating linear gradient and filling the whole destination rect at once. bool forceRepeatToCoverTiles = - mGradient->IsLinear() && + mGradient->kind.IsLinear() && (mLineStart.x == mLineEnd.x) != (mLineStart.y == mLineEnd.y) && aRepeatSize.width == aDest.width && aRepeatSize.height == aDest.height && - !mGradient->AsLinear().repeating && !aSrc.IsEmpty() && !cellContainsFill; + !mGradient->repeating && !aSrc.IsEmpty() && !cellContainsFill; gfxMatrix matrix; if (forceRepeatToCoverTiles) { @@ -753,8 +751,8 @@ void nsCSSGradientRenderer::Paint(gfxContext& aContext, const nsRect& aDest, // Eliminate negative-position stops if the gradient is radial. double firstStop = mStops[0].mPosition; - if (mGradient->IsRadial() && firstStop < 0.0) { - if (mGradient->AsRadial().repeating) { + if (!mGradient->kind.IsLinear() && firstStop < 0.0) { + if (mGradient->repeating) { // Choose an instance of the repeated pattern that gives us all positive // stop-offsets. double lastStop = mStops[mStops.Length() - 1].mPosition; @@ -807,7 +805,7 @@ void nsCSSGradientRenderer::Paint(gfxContext& aContext, const nsRect& aDest, MOZ_ASSERT(firstStop >= 0.0, "Failed to fix stop offsets"); } - if (mGradient->IsRadial() && !mGradient->AsRadial().repeating) { + if (!mGradient->kind.IsLinear() && !mGradient->repeating) { // Direct2D can only handle a particular class of radial gradients because // of the way the it specifies gradients. Setting firstStop to 0, when we // can, will help us stay on the fast path. Currently we don't do this @@ -825,13 +823,13 @@ void nsCSSGradientRenderer::Paint(gfxContext& aContext, const nsRect& aDest, double stopEnd = lastStop; double stopDelta = lastStop - firstStop; bool zeroRadius = - mGradient->IsRadial() && (mRadiusX < 1e-6 || mRadiusY < 1e-6); + !mGradient->kind.IsLinear() && (mRadiusX < 1e-6 || mRadiusY < 1e-6); if (stopDelta < 1e-6 || lineLength < 1e-6 || zeroRadius) { // Stops are all at the same place. Map all stops to 0.0. // For repeating radial gradients, or for any radial gradients with // a zero radius, we need to fill with the last stop color, so just set // both radii to 0. - if (mGradient->Repeating() || zeroRadius) { + if (mGradient->repeating || zeroRadius) { mRadiusX = mRadiusY = 0.0; } stopDelta = 0.0; @@ -841,7 +839,7 @@ void nsCSSGradientRenderer::Paint(gfxContext& aContext, const nsRect& aDest, // This keeps the gradient line as large as the box and doesn't // lets us avoiding having to get padding correct for stops // at 0 and 1 - if (!mGradient->Repeating() || stopDelta == 0.0) { + if (!mGradient->repeating || stopDelta == 0.0) { stopOrigin = std::min(stopOrigin, 0.0); stopEnd = std::max(stopEnd, 1.0); } @@ -851,7 +849,7 @@ void nsCSSGradientRenderer::Paint(gfxContext& aContext, const nsRect& aDest, RefPtr gradientPattern; gfxPoint gradientStart; gfxPoint gradientEnd; - if (mGradient->IsLinear()) { + if (mGradient->kind.IsLinear()) { // Compute the actual gradient line ends we need to pass to cairo after // stops have been normalized. gradientStart = mLineStart + (mLineEnd - mLineStart) * stopOrigin; @@ -870,7 +868,6 @@ void nsCSSGradientRenderer::Paint(gfxContext& aContext, const nsRect& aDest, gradientPattern = new gfxPattern(gradientStart.x, gradientStart.y, gradientEnd.x, gradientEnd.y); } else { - MOZ_ASSERT(mGradient->IsRadial()); NS_ASSERTION(firstStop >= 0.0, "Negative stops not allowed for radial gradients"); @@ -915,7 +912,7 @@ void nsCSSGradientRenderer::Paint(gfxContext& aContext, const nsRect& aDest, Color lastColor(mStops.LastElement().mColor); mStops.Clear(); - if (!mGradient->Repeating() && !zeroRadius) { + if (!mGradient->repeating && !zeroRadius) { mStops.AppendElement(ColorStop(firstStop, false, firstColor)); } mStops.AppendElement(ColorStop(firstStop, false, lastColor)); @@ -923,7 +920,7 @@ void nsCSSGradientRenderer::Paint(gfxContext& aContext, const nsRect& aDest, ResolvePremultipliedAlpha(mStops); - bool isRepeat = mGradient->Repeating() || forceRepeatToCoverTiles; + bool isRepeat = mGradient->repeating || forceRepeatToCoverTiles; // Now set normalized color stops in pattern. // Offscreen gradient surface cache (not a tile): @@ -1017,7 +1014,7 @@ void nsCSSGradientRenderer::Paint(gfxContext& aContext, const nsRect& aDest, gfxRect dirtyFillRect = fillRect.Intersect(dirtyAreaToFill); gfxRect fillRectRelativeToTile = dirtyFillRect - tileRect.TopLeft(); Color edgeColor; - if (mGradient->IsLinear() && !isRepeat && + if (mGradient->kind.IsLinear() && !isRepeat && RectIsBeyondLinearGradientEdge(fillRectRelativeToTile, matrix, mStops, gradientStart, gradientEnd, &edgeColor)) { @@ -1121,8 +1118,7 @@ void nsCSSGradientRenderer::BuildWebRenderParameters( float aOpacity, wr::ExtendMode& aMode, nsTArray& aStops, LayoutDevicePoint& aLineStart, LayoutDevicePoint& aLineEnd, LayoutDeviceSize& aGradientRadius) { - aMode = - mGradient->Repeating() ? wr::ExtendMode::Repeat : wr::ExtendMode::Clamp; + aMode = mGradient->repeating ? wr::ExtendMode::Repeat : wr::ExtendMode::Clamp; aStops.SetLength(mStops.Length()); for (uint32_t i = 0; i < mStops.Length(); i++) { @@ -1188,7 +1184,7 @@ void nsCSSGradientRenderer::BuildWebRenderDisplayItems( lineStart.x = (lineStart.x - srcTransform.x) * srcTransform.width; lineStart.y = (lineStart.y - srcTransform.y) * srcTransform.height; - if (mGradient->IsLinear()) { + if (mGradient->kind.IsLinear()) { lineEnd.x = (lineEnd.x - srcTransform.x) * srcTransform.width; lineEnd.y = (lineEnd.y - srcTransform.y) * srcTransform.height; @@ -1200,7 +1196,6 @@ void nsCSSGradientRenderer::BuildWebRenderDisplayItems( mozilla::wr::ToLayoutSize(firstTileBounds.Size()), mozilla::wr::ToLayoutSize(tileSpacing)); } else { - MOZ_ASSERT(mGradient->IsRadial()); gradientRadius.width *= srcTransform.width; gradientRadius.height *= srcTransform.height; diff --git a/layout/style/ServoStyleConstsInlines.h b/layout/style/ServoStyleConstsInlines.h index 615a8530b623..92da66a44de6 100644 --- a/layout/style/ServoStyleConstsInlines.h +++ b/layout/style/ServoStyleConstsInlines.h @@ -439,11 +439,6 @@ inline imgRequestProxy* StyleComputedImageUrl::GetImage() const { return LoadData().resolved_image; } -template <> -bool StyleGradient::Repeating() const { - return IsLinear() ? AsLinear().repeating : AsRadial().repeating; -} - template <> bool StyleGradient::IsOpaque() const; diff --git a/layout/style/nsStyleStruct.cpp b/layout/style/nsStyleStruct.cpp index ac9487d01213..107a7f95b2e6 100644 --- a/layout/style/nsStyleStruct.cpp +++ b/layout/style/nsStyleStruct.cpp @@ -1404,9 +1404,7 @@ nsChangeHint nsStyleTableBorder::CalcDifference( template <> bool StyleGradient::IsOpaque() const { - auto items = - IsLinear() ? AsLinear().items.AsSpan() : AsRadial().items.AsSpan(); - for (auto& stop : items) { + for (auto& stop : items.AsSpan()) { if (stop.IsInterpolationHint()) { continue; } diff --git a/servo/components/style/values/generics/image.rs b/servo/components/style/values/generics/image.rs index 56e3d183d83b..f6206a9fb25d 100644 --- a/servo/components/style/values/generics/image.rs +++ b/servo/components/style/values/generics/image.rs @@ -51,7 +51,7 @@ pub use self::GenericImage as Image; /// #[derive(Clone, Debug, MallocSizeOf, PartialEq, ToComputedValue, ToResolvedValue, ToShmem)] #[repr(C)] -pub enum GenericGradient< +pub struct GenericGradient< LineDirection, LengthPercentage, NonNegativeLength, @@ -59,30 +59,19 @@ pub enum GenericGradient< Position, Color, > { - /// A linear gradient. - Linear { - /// Line direction - direction: LineDirection, - /// The color stops and interpolation hints. - items: crate::OwnedSlice>, - /// True if this is a repeating gradient. - repeating: bool, - /// Compatibility mode. - compat_mode: GradientCompatMode, - }, - /// A radial gradient. - Radial { - /// Shape of gradient - shape: GenericEndingShape, - /// Center of gradient - position: Position, - /// The color stops and interpolation hints. - items: crate::OwnedSlice>, - /// True if this is a repeating gradient. - repeating: bool, - /// Compatibility mode. - compat_mode: GradientCompatMode, - }, + /// Gradients can be linear or radial. + pub kind: GenericGradientKind< + LineDirection, + NonNegativeLength, + NonNegativeLengthPercentage, + Position, + >, + /// The color stops and interpolation hints. + pub items: crate::OwnedSlice>, + /// True if this is a repeating gradient. + pub repeating: bool, + /// Compatibility mode. + pub compat_mode: GradientCompatMode, } pub use self::GenericGradient as Gradient; @@ -99,6 +88,26 @@ pub enum GradientCompatMode { Moz, } +/// A gradient kind. +#[derive(Clone, Copy, Debug, MallocSizeOf, PartialEq, ToComputedValue, ToResolvedValue, ToShmem)] +#[repr(C, u8)] +pub enum GenericGradientKind< + LineDirection, + NonNegativeLength, + NonNegativeLengthPercentage, + Position, +> { + /// A linear gradient. + Linear(LineDirection), + /// A radial gradient. + Radial( + GenericEndingShape, + Position, + ), +} + +pub use self::GenericGradientKind as GradientKind; + /// A radial gradient's ending shape. #[derive( Clone, Copy, Debug, MallocSizeOf, PartialEq, ToComputedValue, ToCss, ToResolvedValue, ToShmem, @@ -321,39 +330,32 @@ where where W: Write, { - let (compat_mode, repeating) = match *self { - Gradient::Linear { compat_mode, repeating, .. } => (compat_mode, repeating), - Gradient::Radial { compat_mode, repeating, .. } => (compat_mode, repeating), - }; - - match compat_mode { + match self.compat_mode { GradientCompatMode::WebKit => dest.write_str("-webkit-")?, GradientCompatMode::Moz => dest.write_str("-moz-")?, _ => {}, } - if repeating { + if self.repeating { dest.write_str("repeating-")?; } - - let (items, mut skip_comma) = match *self { - Gradient::Linear { ref direction, compat_mode, ref items, .. } => { - dest.write_str("linear-gradient(")?; - if !direction.points_downwards(compat_mode) { - direction.to_css(dest, compat_mode)?; - (items, false) - } else { - (items, true) - } + dest.write_str(self.kind.label())?; + dest.write_str("-gradient(")?; + let mut skip_comma = match self.kind { + GradientKind::Linear(ref direction) if direction.points_downwards(self.compat_mode) => { + true }, - Gradient::Radial { ref shape, ref position, compat_mode, ref items, .. } => { - dest.write_str("radial-gradient(")?; + GradientKind::Linear(ref direction) => { + direction.to_css(dest, self.compat_mode)?; + false + }, + GradientKind::Radial(ref shape, ref position) => { let omit_shape = match *shape { EndingShape::Ellipse(Ellipse::Extent(ShapeExtent::Cover)) | EndingShape::Ellipse(Ellipse::Extent(ShapeExtent::FarthestCorner)) => true, _ => false, }; - if compat_mode == GradientCompatMode::Modern { + if self.compat_mode == GradientCompatMode::Modern { if !omit_shape { shape.to_css(dest)?; dest.write_str(" ")?; @@ -367,10 +369,10 @@ where shape.to_css(dest)?; } } - (items, false) + false }, }; - for item in &**items { + for item in &*self.items { if !skip_comma { dest.write_str(", ")?; } @@ -381,6 +383,15 @@ where } } +impl GradientKind { + fn label(&self) -> &str { + match *self { + GradientKind::Linear(..) => "linear", + GradientKind::Radial(..) => "radial", + } + } +} + /// The direction of a linear gradient. pub trait LineDirection { /// Whether this direction points towards, and thus can be omitted. diff --git a/servo/components/style/values/specified/image.rs b/servo/components/style/values/specified/image.rs index 50400fbc7a0e..13e06d44c575 100644 --- a/servo/components/style/values/specified/image.rs +++ b/servo/components/style/values/specified/image.rs @@ -70,6 +70,10 @@ impl SpecifiedValueInfo for Gradient { } } +/// A specified gradient kind. +pub type GradientKind = + generic::GradientKind; + /// A specified gradient line direction. /// /// FIXME(emilio): This should be generic over Angle. @@ -241,12 +245,25 @@ impl Parse for Gradient { } }; - Ok(input.parse_nested_block(|i| { - Ok(match shape { - Shape::Linear => Self::parse_linear(context, i, repeating, compat_mode)?, - Shape::Radial => Self::parse_radial(context, i, repeating, compat_mode)?, - }) - })?) + let (kind, items) = input.parse_nested_block(|i| { + let shape = match shape { + Shape::Linear => GradientKind::parse_linear(context, i, &mut compat_mode)?, + Shape::Radial => GradientKind::parse_radial(context, i, &mut compat_mode)?, + }; + let items = generic::GradientItem::parse_comma_separated(context, i)?; + Ok((shape, items)) + })?; + + if items.len() < 2 { + return Err(input.new_custom_error(StyleParseErrorKind::UnspecifiedError)); + } + + Ok(Gradient { + items, + repeating, + kind, + compat_mode, + }) } } @@ -366,21 +383,16 @@ impl Gradient { let ident = input.expect_ident_cloned()?; input.expect_comma()?; - Ok(match_ignore_ascii_case! { &ident, + let (kind, reverse_stops) = match_ignore_ascii_case! { &ident, "linear" => { let first = Point::parse(context, input)?; input.expect_comma()?; let second = Point::parse(context, input)?; let direction = LineDirection::from_points(first, second); - let items = Gradient::parse_webkit_gradient_stops(context, input, false)?; + let kind = generic::GradientKind::Linear(direction); - generic::Gradient::Linear { - direction, - items, - repeating: false, - compat_mode: GradientCompatMode::Modern, - } + (kind, false) }, "radial" => { let first_point = Point::parse(context, input)?; @@ -400,28 +412,16 @@ impl Gradient { let rad = Circle::Radius(NonNegative(Length::from_px(radius.value))); let shape = generic::EndingShape::Circle(rad); let position: Position = point.into(); - let items = Gradient::parse_webkit_gradient_stops(context, input, reverse_stops)?; - generic::Gradient::Radial { - shape, - position, - items, - repeating: false, - compat_mode: GradientCompatMode::Modern, - } + let kind = generic::GradientKind::Radial(shape, position); + (kind, reverse_stops) }, _ => { let e = SelectorParseErrorKind::UnexpectedIdent(ident.clone()); return Err(input.new_custom_error(e)); }, - }) - } + }; - fn parse_webkit_gradient_stops<'i, 't>( - context: &ParserContext, - input: &mut Parser<'i, 't>, - reverse_stops: bool, - ) -> Result>, ParseError<'i>> { let mut items = input .try(|i| { i.expect_comma()?; @@ -500,63 +500,46 @@ impl Gradient { } }) } - Ok(items.into()) - } - - /// Not used for -webkit-gradient syntax. - fn parse_stops<'i, 't>( - context: &ParserContext, - input: &mut Parser<'i, 't>, - ) -> Result>, ParseError<'i>> { - let items = generic::GradientItem::parse_comma_separated(context, input)?; - - if items.len() < 2 { - return Err(input.new_custom_error(StyleParseErrorKind::UnspecifiedError)); - } - - Ok(items) + + Ok(generic::Gradient { + kind, + items: items.into(), + repeating: false, + compat_mode: GradientCompatMode::Modern, + }) } +} +impl GradientKind { /// Parses a linear gradient. /// GradientCompatMode can change during `-moz-` prefixed gradient parsing if it come across a `to` keyword. fn parse_linear<'i, 't>( context: &ParserContext, input: &mut Parser<'i, 't>, - repeating: bool, - mut compat_mode: GradientCompatMode, + compat_mode: &mut GradientCompatMode, ) -> Result> { let direction = if let Ok(d) = input.try(|i| LineDirection::parse(context, i, compat_mode)) { input.expect_comma()?; d } else { - match compat_mode { + match *compat_mode { GradientCompatMode::Modern => { LineDirection::Vertical(VerticalPositionKeyword::Bottom) }, _ => LineDirection::Vertical(VerticalPositionKeyword::Top), } }; - let items = Gradient::parse_stops(context, input)?; - - Ok(Gradient::Linear { - direction, - items, - repeating, - compat_mode, - }) + Ok(generic::GradientKind::Linear(direction)) } - - /// Parses a radial gradient. fn parse_radial<'i, 't>( context: &ParserContext, input: &mut Parser<'i, 't>, - repeating: bool, - compat_mode: GradientCompatMode, + compat_mode: &mut GradientCompatMode, ) -> Result> { - let (shape, position) = match compat_mode { + let (shape, position) = match *compat_mode { GradientCompatMode::Modern => { - let shape = input.try(|i| EndingShape::parse(context, i, compat_mode)); + let shape = input.try(|i| EndingShape::parse(context, i, *compat_mode)); let position = input.try(|i| { i.expect_ident_matching("at")?; Position::parse(context, i) @@ -569,7 +552,7 @@ impl Gradient { if position.is_ok() { i.expect_comma()?; } - EndingShape::parse(context, i, compat_mode) + EndingShape::parse(context, i, *compat_mode) }); (shape, position.ok()) }, @@ -584,16 +567,7 @@ impl Gradient { }); let position = position.unwrap_or(Position::center()); - - let items = Gradient::parse_stops(context, input)?; - - Ok(Gradient::Radial { - shape, - position, - items, - repeating, - compat_mode, - }) + Ok(generic::GradientKind::Radial(shape, position)) } } @@ -645,7 +619,7 @@ impl LineDirection { fn parse<'i, 't>( context: &ParserContext, input: &mut Parser<'i, 't>, - mut compat_mode: GradientCompatMode, + compat_mode: &mut GradientCompatMode, ) -> Result> { // Gradients allow unitless zero angles as an exception, see: // https://github.com/w3c/csswg-drafts/issues/1162 @@ -655,14 +629,14 @@ impl LineDirection { input.try(|i| { let to_ident = i.try(|i| i.expect_ident_matching("to")); - match compat_mode { + match *compat_mode { // `to` keyword is mandatory in modern syntax. GradientCompatMode::Modern => to_ident?, // Fall back to Modern compatibility mode in case there is a `to` keyword. // According to Gecko, `-moz-linear-gradient(to ...)` should serialize like // `linear-gradient(to ...)`. GradientCompatMode::Moz if to_ident.is_ok() => { - compat_mode = GradientCompatMode::Modern + *compat_mode = GradientCompatMode::Modern }, // There is no `to` keyword in webkit prefixed syntax. If it's consumed, // parsing should throw an error. diff --git a/servo/components/style/values/specified/length.rs b/servo/components/style/values/specified/length.rs index 16b9bf003e66..f7d7023a51a0 100644 --- a/servo/components/style/values/specified/length.rs +++ b/servo/components/style/values/specified/length.rs @@ -29,7 +29,7 @@ use style_traits::values::specified::AllowedNumericType; use style_traits::{ParseError, SpecifiedValueInfo, StyleParseErrorKind}; pub use super::image::{EndingShape as GradientEndingShape, Gradient}; -pub use super::image::Image; +pub use super::image::{GradientKind, Image}; pub use crate::values::specified::calc::CalcLengthPercentage; /// Number of app units per pixel diff --git a/servo/components/style/values/specified/mod.rs b/servo/components/style/values/specified/mod.rs index 84e2b7472345..aa8bda5c227e 100644 --- a/servo/components/style/values/specified/mod.rs +++ b/servo/components/style/values/specified/mod.rs @@ -56,7 +56,7 @@ pub use self::font::{FontVariantAlternates, FontWeight}; pub use self::font::{FontVariantEastAsian, FontVariationSettings}; pub use self::font::{MozScriptLevel, MozScriptMinSize, MozScriptSizeMultiplier, XLang, XTextZoom}; pub use self::image::{EndingShape as GradientEndingShape, Gradient}; -pub use self::image::{Image, MozImageRect}; +pub use self::image::{GradientKind, Image, MozImageRect}; pub use self::length::{AbsoluteLength, CalcLengthPercentage, CharacterWidth}; pub use self::length::{FontRelativeLength, Length, LengthOrNumber, NonNegativeLengthOrNumber}; pub use self::length::{LengthOrAuto, LengthPercentage, LengthPercentageOrAuto}; diff --git a/servo/ports/geckolib/cbindgen.toml b/servo/ports/geckolib/cbindgen.toml index 69457aa8dfcf..e31f38f344a6 100644 --- a/servo/ports/geckolib/cbindgen.toml +++ b/servo/ports/geckolib/cbindgen.toml @@ -671,7 +671,6 @@ renaming_overrides_prefixing = true """ "GenericGradient" = """ - bool Repeating() const; bool IsOpaque() const; """