Bug 1336646 - Apply selector flags during traversal. r=emilio

components/style/context.rs

@@ -9,12 +9,13 @@ use animation::Animation;
 use app_units::Au;
 use bloom::StyleBloom;
 use data::ElementData;
-use dom::{OpaqueNode, TNode, TElement};
+use dom::{OpaqueNode, TNode, TElement, SendElement};
 use error_reporting::ParseErrorReporter;
 use euclid::Size2D;
 use matching::StyleSharingCandidateCache;
 use parking_lot::RwLock;
 use properties::ComputedValues;
+use selectors::matching::ElementSelectorFlags;
 use servo_config::opts;
 use std::collections::HashMap;
 use std::env;
@@ -23,6 +24,7 @@ use std::ops::Add;
 use std::sync::{Arc, Mutex};
 use std::sync::mpsc::Sender;
 use stylist::Stylist;
+use thread_state;
 use timer::Timer;
 
 /// This structure is used to create a local style context from a shared one.
@@ -165,6 +167,34 @@ impl TraversalStatistics {
     }
 }
 
+/// A task to be run in sequential mode on the parent (non-worker) thread. This
+/// is used by the style system to queue up work which is not safe to do during
+/// the parallel traversal.
+pub enum SequentialTask<E: TElement> {
+    /// Sets selector flags. This is used when we need to set flags on an
+    /// element that we don't have exclusive access to (i.e. the parent).
+    SetSelectorFlags(SendElement<E>, ElementSelectorFlags),
+}
+
+impl<E: TElement> SequentialTask<E> {
+    /// Executes this task.
+    pub fn execute(self) {
+        use self::SequentialTask::*;
+        debug_assert!(thread_state::get() == thread_state::LAYOUT);
+        match self {
+            SetSelectorFlags(el, flags) => {
+                unsafe { el.set_selector_flags(flags) };
+            }
+        }
+    }
+
+    /// Creates a task to set the selector flags on an element.
+    pub fn set_selector_flags(el: E, flags: ElementSelectorFlags) -> Self {
+        use self::SequentialTask::*;
+        SetSelectorFlags(unsafe { SendElement::new(el) }, flags)
+    }
+}
+
 /// A thread-local style context.
 ///
 /// This context contains data that needs to be used during restyling, but is
@@ -178,6 +208,10 @@ pub struct ThreadLocalStyleContext<E: TElement> {
     /// A channel on which new animations that have been triggered by style
     /// recalculation can be sent.
     pub new_animations_sender: Sender<Animation>,
+    /// A set of tasks to be run (on the parent thread) in sequential mode after
+    /// the rest of the styling is complete. This is useful for infrequently-needed
+    /// non-threadsafe operations.
+    pub tasks: Vec<SequentialTask<E>>,
     /// Statistics about the traversal.
     pub statistics: TraversalStatistics,
     /// Information related to the current element, non-None during processing.
@@ -191,6 +225,7 @@ impl<E: TElement> ThreadLocalStyleContext<E> {
             style_sharing_candidate_cache: StyleSharingCandidateCache::new(),
             bloom_filter: StyleBloom::new(),
             new_animations_sender: shared.local_context_creation_data.lock().unwrap().new_animations_sender.clone(),
+            tasks: Vec::new(),
             statistics: TraversalStatistics::default(),
             current_element_info: None,
         }
@@ -222,10 +257,15 @@ impl<E: TElement> ThreadLocalStyleContext<E> {
     }
 }
 
-#[cfg(debug_assertions)]
 impl<E: TElement> Drop for ThreadLocalStyleContext<E> {
     fn drop(&mut self) {
         debug_assert!(self.current_element_info.is_none());
+
+        // Execute any enqueued sequential tasks.
+        debug_assert!(thread_state::get() == thread_state::LAYOUT);
+        for task in self.tasks.drain(..) {
+            task.execute();
+        }
     }
 }