Don't match native anonymous content to user/author rules.

components/style/gecko/wrapper.rs

@@ -28,6 +28,7 @@ use gecko_bindings::bindings::Gecko_StoreStyleDifference;
 use gecko_bindings::structs;
 use gecko_bindings::structs::{NODE_HAS_DIRTY_DESCENDANTS_FOR_SERVO, NODE_IS_DIRTY_FOR_SERVO};
 use gecko_bindings::structs::{nsIAtom, nsIContent, nsStyleContext};
+use gecko_bindings::structs::NODE_IS_IN_NATIVE_ANONYMOUS_SUBTREE;
 use parking_lot::RwLock;
 use parser::ParserContextExtraData;
 use properties::{ComputedValues, parse_style_attribute};
@@ -624,4 +625,9 @@ impl<'le> ElementExt for GeckoElement<'le> {
     fn is_link(&self) -> bool {
         self.match_non_ts_pseudo_class(NonTSPseudoClass::AnyLink)
     }
+
+    #[inline]
+    fn matches_user_and_author_rules(&self) -> bool {
+        self.flags() & (NODE_IS_IN_NATIVE_ANONYMOUS_SUBTREE as u32) == 0
+    }
 }

components/style/matching.rs

@@ -106,6 +106,7 @@ pub enum CacheMiss {
     LocalName,
     Namespace,
     Link,
+    UserAndAuthorRules,
     State,
     IdAttr,
     StyleAttr,
@@ -143,6 +144,10 @@ fn element_matches_candidate<E: TElement>(element: &E,
         miss!(Link)
     }
 
+    if element.matches_user_and_author_rules() != candidate_element.matches_user_and_author_rules() {
+        miss!(UserAndAuthorRules)
+    }
+
     if element.get_state() != candidate_element.get_state() {
         miss!(State)
     }

components/style/selector_parser.rs

@@ -101,6 +101,8 @@ impl PseudoElementCascadeType {
 
 pub trait ElementExt: Element<Impl=SelectorImpl> {
     fn is_link(&self) -> bool;
+
+    fn matches_user_and_author_rules(&self) -> bool;
 }
 
 impl SelectorImpl {

components/style/servo/selector_parser.rs

@@ -398,4 +398,9 @@ impl<E: Element<Impl=SelectorImpl>> ElementExt for E {
     fn is_link(&self) -> bool {
         self.match_non_ts_pseudo_class(NonTSPseudoClass::AnyLink)
     }
+
+    #[inline]
+    fn matches_user_and_author_rules(&self) -> bool {
+        true
+    }
 }

components/style/stylist.rs

@@ -330,9 +330,9 @@ impl Stylist {
                                                   pseudo: &PseudoElement,
                                                   parent: &Arc<ComputedValues>)
                                                   -> Option<(Arc<ComputedValues>, StrongRuleNode)>
-        where E: Element<Impl=SelectorImpl> +
+        where E: ElementExt +
-              fmt::Debug +
+                 fmt::Debug +
-              PresentationalHintsSynthetizer
+                 PresentationalHintsSynthetizer
     {
         debug_assert!(SelectorImpl::pseudo_element_cascade_type(pseudo).is_lazy());
         if self.pseudos_map.get(pseudo).is_none() {
@@ -418,7 +418,7 @@ impl Stylist {
                                         pseudo_element: Option<&PseudoElement>,
                                         applicable_declarations: &mut V,
                                         reason: MatchingReason) -> StyleRelations
-        where E: Element<Impl=SelectorImpl> +
+        where E: ElementExt +
                  fmt::Debug +
                  PresentationalHintsSynthetizer,
               V: Push<ApplicableDeclarationBlock> + VecLike<ApplicableDeclarationBlock>
@@ -456,66 +456,71 @@ impl Stylist {
         }
         debug!("preshints: {:?}", relations);
 
-        // Step 3: User and author normal rules.
+        if element.matches_user_and_author_rules() {
-        map.user.get_all_matching_rules(element,
+            // Step 3: User and author normal rules.
-                                        parent_bf,
+            map.user.get_all_matching_rules(element,
-                                        applicable_declarations,
+                                            parent_bf,
-                                        &mut relations,
+                                            applicable_declarations,
-                                        reason,
+                                            &mut relations,
-                                        Importance::Normal);
+                                            reason,
-        debug!("user normal: {:?}", relations);
+                                            Importance::Normal);
-        map.author.get_all_matching_rules(element,
+            debug!("user normal: {:?}", relations);
-                                          parent_bf,
+            map.author.get_all_matching_rules(element,
-                                          applicable_declarations,
+                                              parent_bf,
-                                          &mut relations,
+                                              applicable_declarations,
-                                          reason,
+                                              &mut relations,
-                                          Importance::Normal);
+                                              reason,
-        debug!("author normal: {:?}", relations);
+                                              Importance::Normal);
+            debug!("author normal: {:?}", relations);
 
-        // Step 4: Normal style attributes.
+            // Step 4: Normal style attributes.
-        if let Some(sa) = style_attribute {
+            if let Some(sa) = style_attribute {
-            if sa.read().any_normal() {
+                if sa.read().any_normal() {
-                relations |= AFFECTED_BY_STYLE_ATTRIBUTE;
+                    relations |= AFFECTED_BY_STYLE_ATTRIBUTE;
-                Push::push(
+                    Push::push(
-                    applicable_declarations,
+                        applicable_declarations,
-                    ApplicableDeclarationBlock::from_declarations(sa.clone(), Importance::Normal));
+                        ApplicableDeclarationBlock::from_declarations(sa.clone(), Importance::Normal));
+                }
             }
+
+            debug!("style attr: {:?}", relations);
+
+            // Step 5: Author-supplied `!important` rules.
+            map.author.get_all_matching_rules(element,
+                                              parent_bf,
+                                              applicable_declarations,
+                                              &mut relations,
+                                              reason,
+                                              Importance::Important);
+
+            debug!("author important: {:?}", relations);
+
+            // Step 6: `!important` style attributes.
+            if let Some(sa) = style_attribute {
+                if sa.read().any_important() {
+                    relations |= AFFECTED_BY_STYLE_ATTRIBUTE;
+                    Push::push(
+                        applicable_declarations,
+                        ApplicableDeclarationBlock::from_declarations(sa.clone(), Importance::Important));
+                }
+            }
+
+            debug!("style attr important: {:?}", relations);
+
+            // Step 7: User `!important` rules.
+            map.user.get_all_matching_rules(element,
+                                            parent_bf,
+                                            applicable_declarations,
+                                            &mut relations,
+                                            reason,
+                                            Importance::Important);
+
+            debug!("user important: {:?}", relations);
+        } else {
+            debug!("skipping non-agent rules");
         }
 
-        debug!("style attr: {:?}", relations);
+        // Step 8: UA `!important` rules.
-
-        // Step 5: Author-supplied `!important` rules.
-        map.author.get_all_matching_rules(element,
-                                          parent_bf,
-                                          applicable_declarations,
-                                          &mut relations,
-                                          reason,
-                                          Importance::Important);
-
-        debug!("author important: {:?}", relations);
-
-        // Step 6: `!important` style attributes.
-        if let Some(sa) = style_attribute {
-            if sa.read().any_important() {
-                relations |= AFFECTED_BY_STYLE_ATTRIBUTE;
-                Push::push(
-                    applicable_declarations,
-                    ApplicableDeclarationBlock::from_declarations(sa.clone(), Importance::Important));
-            }
-        }
-
-        debug!("style attr important: {:?}", relations);
-
-        // Step 7: User and UA `!important` rules.
-        map.user.get_all_matching_rules(element,
-                                        parent_bf,
-                                        applicable_declarations,
-                                        &mut relations,
-                                        reason,
-                                        Importance::Important);
-
-        debug!("user important: {:?}", relations);
-
         map.user_agent.get_all_matching_rules(element,
                                               parent_bf,
                                               applicable_declarations,