--- a/servo/components/style/values/specified/color.rs
+++ b/servo/components/style/values/specified/color.rs
@@ -32,35 +32,35 @@ mod servo {
 #[cfg(feature = "gecko")]
 mod gecko {
     use cssparser::{Color as CSSParserColor, Parser, RGBA};
     use parser::{Parse, ParserContext};
     use properties::longhands::color::SystemColor;
     use std::fmt;
     use style_traits::ToCss;
 
+    define_css_keyword_enum! { SpecialColorKeyword:
+        "-moz-default-color" => MozDefaultColor,
+        "-moz-default-background-color" => MozDefaultBackgroundColor,
+        "-moz-hyperlinktext" => MozHyperlinktext,
+        "-moz-activehyperlinktext" => MozActiveHyperlinktext,
+        "-moz-visitedhyperlinktext" => MozVisitedHyperlinktext,
+    }
+
     /// Color value including non-standard -moz prefixed values.
     #[derive(Clone, Copy, PartialEq, Debug)]
     pub enum Color {
         /// The 'currentColor' keyword
         CurrentColor,
         /// A specific RGBA color
         RGBA(RGBA),
         /// A system color
         System(SystemColor),
-        /// -moz-default-color
-        MozDefaultColor,
-        /// -moz-default-background-color
-        MozDefaultBackgroundColor,
-        /// -moz-hyperlinktext
-        MozHyperlinktext,
-        /// -moz-activehyperlinktext
-        MozActiveHyperlinktext,
-        /// -moz-visitedhyperlinktext
-        MozVisitedHyperlinktext,
+        /// A special color keyword value used in Gecko
+        Special(SpecialColorKeyword),
         /// Quirksmode-only rule for inheriting color from the body
         InheritFromBodyQuirk,
     }
 
     no_viewport_percentage!(Color);
 
     impl From<CSSParserColor> for Color {
         fn from(value: CSSParserColor) -> Self {
@@ -72,44 +72,34 @@ mod gecko {
     }
 
     impl Parse for Color {
         fn parse(_: &ParserContext, input: &mut Parser) -> Result<Self, ()> {
             if let Ok(value) = input.try(CSSParserColor::parse) {
                 Ok(value.into())
             } else if let Ok(system) = input.try(SystemColor::parse) {
                 Ok(Color::System(system))
+            } else if let Ok(special) = input.try(SpecialColorKeyword::parse) {
+                Ok(Color::Special(special))
             } else {
-                let ident = input.expect_ident()?;
-                match_ignore_ascii_case! { &ident,
-                    "-moz-default-color" => Ok(Color::MozDefaultColor),
-                    "-moz-default-background-color" => Ok(Color::MozDefaultBackgroundColor),
-                    "-moz-hyperlinktext" => Ok(Color::MozHyperlinktext),
-                    "-moz-activehyperlinktext" => Ok(Color::MozActiveHyperlinktext),
-                    "-moz-visitedhyperlinktext" => Ok(Color::MozVisitedHyperlinktext),
-                    _ => Err(())
-                }
+                Err(())
             }
         }
     }
 
     impl ToCss for Color {
         fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
             match *self {
                 // Standard values:
                 Color::CurrentColor => CSSParserColor::CurrentColor.to_css(dest),
                 Color::RGBA(rgba) => rgba.to_css(dest),
                 Color::System(system) => system.to_css(dest),
 
                 // Non-standard values:
-                Color::MozDefaultColor => dest.write_str("-moz-default-color"),
-                Color::MozDefaultBackgroundColor => dest.write_str("-moz-default-background-color"),
-                Color::MozHyperlinktext => dest.write_str("-moz-hyperlinktext"),
-                Color::MozActiveHyperlinktext => dest.write_str("-moz-activehyperlinktext"),
-                Color::MozVisitedHyperlinktext => dest.write_str("-moz-visitedhyperlinktext"),
+                Color::Special(special) => special.to_css(dest),
                 Color::InheritFromBodyQuirk => Ok(()),
             }
         }
     }
 }
 
 #[derive(Clone, PartialEq, Debug)]
 #[cfg_attr(feature = "servo", derive(HeapSizeOf))]
@@ -267,21 +257,26 @@ impl ToComputedValue for Color {
     fn to_computed_value(&self, context: &Context) -> RGBA {
         use gecko::values::convert_nscolor_to_rgba as to_rgba;
         // It's safe to access the nsPresContext immutably during style computation.
         let pres_context = unsafe { &*context.device.pres_context };
         match *self {
             Color::RGBA(rgba) => rgba,
             Color::System(system) => to_rgba(system.to_computed_value(context)),
             Color::CurrentColor => context.inherited_style.get_color().clone_color(),
-            Color::MozDefaultColor => to_rgba(pres_context.mDefaultColor),
-            Color::MozDefaultBackgroundColor => to_rgba(pres_context.mBackgroundColor),
-            Color::MozHyperlinktext => to_rgba(pres_context.mLinkColor),
-            Color::MozActiveHyperlinktext => to_rgba(pres_context.mActiveLinkColor),
-            Color::MozVisitedHyperlinktext => to_rgba(pres_context.mVisitedLinkColor),
+            Color::Special(special) => {
+                use self::gecko::SpecialColorKeyword as Keyword;
+                to_rgba(match special {
+                    Keyword::MozDefaultColor => pres_context.mDefaultColor,
+                    Keyword::MozDefaultBackgroundColor => pres_context.mBackgroundColor,
+                    Keyword::MozHyperlinktext => pres_context.mLinkColor,
+                    Keyword::MozActiveHyperlinktext => pres_context.mActiveLinkColor,
+                    Keyword::MozVisitedHyperlinktext => pres_context.mVisitedLinkColor,
+                })
+            }
             Color::InheritFromBodyQuirk => {
                 use dom::TElement;
                 use gecko::wrapper::GeckoElement;
                 use gecko_bindings::bindings::Gecko_GetBody;
                 let body = unsafe {
                     Gecko_GetBody(pres_context)
                 };
                 if let Some(body) = body {