diff --git a/servo/components/selectors/parser.rs b/servo/components/selectors/parser.rs
--- a/servo/components/selectors/parser.rs
+++ b/servo/components/selectors/parser.rs
@@ -1706,34 +1706,25 @@ where

         AttrSelectorOperator::Includes => value.is_empty() || value.contains(SELECTOR_WHITESPACE),

         AttrSelectorOperator::Prefix |
         AttrSelectorOperator::Substring |
         AttrSelectorOperator::Suffix => value.is_empty(),
     };

-    let mut case_sensitivity = parse_attribute_flags(input)?;
+    let mut attribute_flags = parse_attribute_flags(input)?;

     let value = value.as_ref().into();
     let local_name_lower;
     let local_name_is_ascii_lowercase;
+    let case_sensitivity;
     {
         let local_name_lower_cow = to_ascii_lowercase(&local_name);
-        if let ParsedCaseSensitivity::CaseSensitive = case_sensitivity {
-            if namespace.is_none() && include!(concat!(
-                env!("OUT_DIR"),
-                "/ascii_case_insensitive_html_attributes.rs"
-            ))
-            .contains(&*local_name_lower_cow)
-            {
-                case_sensitivity =
-                    ParsedCaseSensitivity::AsciiCaseInsensitiveIfInHtmlElementInHtmlDocument
-            }
-        }
+        case_sensitivity = attribute_flags.to_case_sensitivity(local_name_lower_cow.as_ref(), &namespace);
         local_name_lower = local_name_lower_cow.as_ref().into();
         local_name_is_ascii_lowercase = matches!(local_name_lower_cow, Cow::Borrowed(..));
     }
     let local_name = local_name.as_ref().into();
     if namespace.is_some() || !local_name_is_ascii_lowercase {
         Ok(Component::AttributeOther(Box::new(
             AttrSelectorWithOptionalNamespace {
                 namespace,
@@ -1753,27 +1744,71 @@ where
             operator: operator,
             value: value,
             case_sensitivity: case_sensitivity,
             never_matches: never_matches,
         })
     }
 }

+/// An attribute selector can have 's' or 'i' as flags, or no flags at all.
+enum AttributeFlags {
+    // Matching should be case-sensitive ('s' flag).
+    CaseSensitive,
+    // Matching should be case-insensitive ('i' flag).
+    AsciiCaseInsensitive,
+    // No flags.  Matching behavior depends on the name of the attribute.
+    DependsOnName
+}
+
+impl AttributeFlags {
+    fn to_case_sensitivity<Impl>(
+        self,
+        local_name: &str,
+        namespace: &Option<NamespaceConstraint<(Impl::NamespacePrefix,
+                                                Impl::NamespaceUrl)>>
+    ) -> ParsedCaseSensitivity
+        where Impl: SelectorImpl
+    {
+        match self {
+            AttributeFlags::CaseSensitive =>
+                ParsedCaseSensitivity::CaseSensitive,
+            AttributeFlags::AsciiCaseInsensitive =>
+                ParsedCaseSensitivity::AsciiCaseInsensitive,
+            DependsOnName => {
+                if namespace.is_none() && include!(concat!(
+                    env!("OUT_DIR"),
+                    "/ascii_case_insensitive_html_attributes.rs"
+                ))
+                    .contains(local_name)
+                {
+                    ParsedCaseSensitivity::AsciiCaseInsensitiveIfInHtmlElementInHtmlDocument
+                } else {
+                    ParsedCaseSensitivity::CaseSensitive
+                }
+            }
+        }
+    }
+}
+
 fn parse_attribute_flags<'i, 't>(
     input: &mut CssParser<'i, 't>,
-) -> Result<ParsedCaseSensitivity, BasicParseError<'i>> {
+) -> Result<AttributeFlags, BasicParseError<'i>> {
     let location = input.current_source_location();
     match input.next() {
         Err(_) => {
-            // Selectors spec says language-defined, but HTML says sensitive.
-            Ok(ParsedCaseSensitivity::CaseSensitive)
+            // Selectors spec says language-defined; HTML says it depends on the
+            // exact attribute name.
+            Ok(AttributeFlags::DependsOnName)
         },
         Ok(&Token::Ident(ref value)) if value.eq_ignore_ascii_case("i") => {
-            Ok(ParsedCaseSensitivity::AsciiCaseInsensitive)
+            Ok(AttributeFlags::AsciiCaseInsensitive)
+        },
+        Ok(&Token::Ident(ref value)) if value.eq_ignore_ascii_case("s") => {
+            Ok(AttributeFlags::CaseSensitive)
         },
         Ok(t) => Err(location.new_basic_unexpected_token_error(t.clone())),
     }
 }

 /// Level 3: Parse **one** simple_selector.  (Though we might insert a second
 /// implied "<defaultns>|*" type selector.)
 fn parse_negation<'i, 't, P, Impl>(