--- a/servo/components/style/invalidation/element/invalidator.rs
+++ b/servo/components/style/invalidation/element/invalidator.rs
@@ -312,17 +312,17 @@ where
         }
 
         any_invalidated
     }
 
     fn invalidate_pseudo_element_or_nac(
         &mut self,
         child: E,
-        invalidations: &InvalidationVector<'b>,
+        invalidations: &[Invalidation<'b>],
     ) -> bool {
         let mut sibling_invalidations = InvalidationVector::new();
 
         let result = self.invalidate_child(
             child,
             invalidations,
             &mut sibling_invalidations
         );
@@ -337,17 +337,17 @@ where
         result
     }
 
     /// Invalidate a child and recurse down invalidating its descendants if
     /// needed.
     fn invalidate_child(
         &mut self,
         child: E,
-        invalidations: &InvalidationVector<'b>,
+        invalidations: &[Invalidation<'b>],
         sibling_invalidations: &mut InvalidationVector<'b>,
     ) -> bool {
         let mut invalidations_for_descendants = InvalidationVector::new();
 
         let mut invalidated_child = false;
         let invalidated_descendants = {
             let mut child_invalidator = TreeStyleInvalidator::new(
                 child,
@@ -384,17 +384,17 @@ where
             self.processor.invalidated_descendants(self.element, child);
         }
 
         invalidated_child || invalidated_descendants
     }
 
     fn invalidate_nac(
         &mut self,
-        invalidations: &InvalidationVector<'b>,
+        invalidations: &[Invalidation<'b>],
     ) -> bool {
         let mut any_nac_root = false;
 
         let element = self.element;
         element.each_anonymous_content_child(|nac| {
             any_nac_root |=
                 self.invalidate_pseudo_element_or_nac(nac, invalidations);
         });
@@ -402,17 +402,17 @@ where
         any_nac_root
     }
 
     // NB: It's important that this operates on DOM children, which is what
     // selector-matching operates on.
     fn invalidate_dom_descendants_of(
         &mut self,
         parent: E::ConcreteNode,
-        invalidations: &InvalidationVector<'b>,
+        invalidations: &[Invalidation<'b>],
     ) -> bool {
         let mut any_descendant = false;
 
         let mut sibling_invalidations = InvalidationVector::new();
         for child in parent.dom_children() {
             // TODO(emilio): We handle <xbl:children> fine, because they appear
             // in selector-matching (note bug 1374247, though).
             //
@@ -436,17 +436,17 @@ where
 
         any_descendant
     }
 
     /// Given a descendant invalidation list, go through the current element's
     /// descendants, and invalidate style on them.
     fn invalidate_descendants(
         &mut self,
-        invalidations: &InvalidationVector<'b>,
+        invalidations: &[Invalidation<'b>],
     ) -> bool {
         if invalidations.is_empty() {
             return false;
         }
 
         debug!("StyleTreeInvalidator::invalidate_descendants({:?})",
                self.element);
         debug!(" > {:?}", invalidations);
@@ -541,17 +541,17 @@ where
 
     /// Process a given invalidation list coming from our parent,
     /// adding to `descendant_invalidations` and `sibling_invalidations` as
     /// needed.
     ///
     /// Returns whether our style was invalidated as a result.
     fn process_descendant_invalidations(
         &mut self,
-        invalidations: &InvalidationVector<'b>,
+        invalidations: &[Invalidation<'b>],
         descendant_invalidations: &mut InvalidationVector<'b>,
         sibling_invalidations: &mut InvalidationVector<'b>,
     ) -> bool {
         let mut invalidated = false;
 
         for invalidation in invalidations {
             let result = self.process_invalidation(
                 invalidation,