style: Remove the Mutex from new_animations_sender by moving it to the local StyleContext.

As a follow-up, we could move all the data living under a mutex in the
SharedLayoutContext only in order to create the local context to the same place.

This should increase animation performance when there are multiple animations in
one page that happen to be on different threads.

components/layout/context.rs

@@ -25,15 +25,14 @@ use std::hash::BuildHasherDefault;
 use std::rc::Rc;
 use std::sync::{Arc, Mutex, RwLock};
 use style::context::{LocalStyleContext, StyleContext};
-use style::matching::{ApplicableDeclarationsCache, StyleSharingCandidateCache};
-use style::properties::ServoComputedValues;
 use style::selector_impl::ServoSelectorImpl;
 use style::servo::SharedStyleContext;
 use url::Url;
 use util::opts;
 
 struct LocalLayoutContext {
-    style_context: LocalStyleContext<ServoComputedValues>,
+    style_context: LocalStyleContext<ServoSelectorImpl>,
+
     font_context: RefCell<FontContext>,
 }
 
@@ -64,11 +63,10 @@ fn create_or_get_local_context(shared_layout_context: &SharedLayoutContext)
             context
         } else {
             let font_cache_thread = shared_layout_context.font_cache_thread.lock().unwrap().clone();
+            let local_style_data = shared_layout_context.style_context.local_context_creation_data.lock().unwrap();
+
             let context = Rc::new(LocalLayoutContext {
-                style_context: LocalStyleContext {
+                style_context: LocalStyleContext::new(&local_style_data),
-                    applicable_declarations_cache: RefCell::new(ApplicableDeclarationsCache::new()),
-                    style_sharing_candidate_cache: RefCell::new(StyleSharingCandidateCache::new()),
-                },
                 font_context: RefCell::new(FontContext::new(font_cache_thread)),
             });
             *r = Some(context.clone());
@@ -110,7 +108,7 @@ impl<'a> StyleContext<'a, ServoSelectorImpl> for LayoutContext<'a> {
         &self.shared.style_context
     }
 
-    fn local_context(&self) -> &LocalStyleContext<ServoComputedValues> {
+    fn local_context(&self) -> &LocalStyleContext<ServoSelectorImpl> {
         &self.cached_local_layout_context.style_context
     }
 }

components/layout_thread/lib.rs

@@ -108,7 +108,7 @@ use style::parallel::WorkQueueData;
 use style::properties::ComputedValues;
 use style::refcell::RefCell;
 use style::selector_matching::USER_OR_USER_AGENT_STYLESHEETS;
-use style::servo::{Animation, SharedStyleContext, Stylesheet, Stylist};
+use style::servo::{Animation, LocalStyleContextCreationInfo, SharedStyleContext, Stylesheet, Stylist};
 use style::stylesheets::CSSRuleIteratorExt;
 use url::Url;
 use util::geometry::MAX_RECT;
@@ -488,6 +488,8 @@ impl LayoutThread {
                                    screen_size_changed: bool,
                                    goal: ReflowGoal)
                                    -> SharedLayoutContext {
+        let local_style_context_creation_data = LocalStyleContextCreationInfo::new(self.new_animations_sender.clone());
+
         SharedLayoutContext {
             style_context: SharedStyleContext {
                 viewport_size: self.viewport_size.clone(),
@@ -495,10 +497,10 @@ impl LayoutThread {
                 stylist: rw_data.stylist.clone(),
                 generation: self.generation,
                 goal: goal,
-                new_animations_sender: Mutex::new(self.new_animations_sender.clone()),
                 running_animations: self.running_animations.clone(),
                 expired_animations: self.expired_animations.clone(),
                 error_reporter: self.error_reporter.clone(),
+                local_context_creation_data: Mutex::new(local_style_context_creation_data),
             },
             image_cache_thread: self.image_cache_thread.clone(),
             image_cache_sender: Mutex::new(self.image_cache_sender.clone()),

components/style/animation.rs

@@ -19,8 +19,8 @@ use properties::style_struct_traits::Box;
 use properties::{self, ComputedValues};
 use selector_impl::SelectorImplExt;
 use selectors::matching::DeclarationBlock;
+use std::sync::Arc;
 use std::sync::mpsc::Sender;
-use std::sync::{Arc, Mutex};
 use string_cache::Atom;
 use time;
 use values::computed::Time;
@@ -356,7 +356,7 @@ impl<T> GetMod for Vec<T> {
 //
 // TODO(emilio): Take rid of this mutex splitting SharedLayoutContex into a
 // cloneable part and a non-cloneable part..
-pub fn start_transitions_if_applicable<Impl: SelectorImplExt>(new_animations_sender: &Mutex<Sender<Animation<Impl>>>,
+pub fn start_transitions_if_applicable<Impl: SelectorImplExt>(new_animations_sender: &Sender<Animation<Impl>>,
                                                               node: OpaqueNode,
                                                               old_style: &Impl::ComputedValues,
                                                               new_style: &mut Arc<Impl::ComputedValues>)
@@ -377,7 +377,6 @@ pub fn start_transitions_if_applicable<Impl: SelectorImplExt>(new_animations_sen
             let start_time =
                 now + (box_style.transition_delay.0.get_mod(i).seconds() as f64);
             new_animations_sender
-                .lock().unwrap()
                 .send(Animation::Transition(node, start_time, AnimationFrame {
                     duration: box_style.transition_duration.0.get_mod(i).seconds() as f64,
                     property_animation: property_animation,
@@ -417,6 +416,7 @@ fn compute_style_for_animation_step<Impl: SelectorImplExt>(context: &SharedStyle
 }
 
 pub fn maybe_start_animations<Impl: SelectorImplExt>(context: &SharedStyleContext<Impl>,
+                                                     new_animations_sender: &Sender<Animation<Impl>>,
                                                      node: OpaqueNode,
                                                      new_style: &Arc<Impl::ComputedValues>) -> bool
 {
@@ -465,19 +465,18 @@ pub fn maybe_start_animations<Impl: SelectorImplExt>(context: &SharedStyleContex
             };
 
 
-            context.new_animations_sender
+            new_animations_sender
-                   .lock().unwrap()
+                .send(Animation::Keyframes(node, name.clone(), KeyframesAnimationState {
-                   .send(Animation::Keyframes(node, name.clone(), KeyframesAnimationState {
+                    started_at: animation_start,
-                       started_at: animation_start,
+                    duration: duration as f64,
-                       duration: duration as f64,
+                    delay: delay as f64,
-                       delay: delay as f64,
+                    iteration_state: iteration_state,
-                       iteration_state: iteration_state,
+                    running_state: running_state,
-                       running_state: running_state,
+                    direction: animation_direction,
-                       direction: animation_direction,
+                    current_direction: initial_direction,
-                       current_direction: initial_direction,
+                    expired: false,
-                       expired: false,
+                    cascade_style: new_style.clone(),
-                       cascade_style: new_style.clone(),
+                })).unwrap();
-                   })).unwrap();
             had_animations = true;
         }
     }

components/style/context.rs

@@ -10,7 +10,6 @@ use dom::OpaqueNode;
 use error_reporting::ParseErrorReporter;
 use euclid::Size2D;
 use matching::{ApplicableDeclarationsCache, StyleSharingCandidateCache};
-use properties::ComputedValues;
 use selector_impl::SelectorImplExt;
 use selector_matching::Stylist;
 use std::cell::RefCell;
@@ -18,6 +17,19 @@ use std::collections::HashMap;
 use std::sync::mpsc::Sender;
 use std::sync::{Arc, Mutex, RwLock};
 
+/// This structure is used to create a local style context from a shared one.
+pub struct LocalStyleContextCreationInfo<Impl: SelectorImplExt> {
+    new_animations_sender: Sender<Animation<Impl>>,
+}
+
+impl<Impl: SelectorImplExt> LocalStyleContextCreationInfo<Impl> {
+    pub fn new(animations_sender: Sender<Animation<Impl>>) -> Self {
+        LocalStyleContextCreationInfo {
+            new_animations_sender: animations_sender,
+        }
+    }
+}
+
 pub struct SharedStyleContext<Impl: SelectorImplExt> {
     /// The current viewport size.
     pub viewport_size: Size2D<Au>,
@@ -32,10 +44,6 @@ pub struct SharedStyleContext<Impl: SelectorImplExt> {
     /// This can be used to easily check for invalid stale data.
     pub generation: u32,
 
-    /// A channel on which new animations that have been triggered by style recalculation can be
-    /// sent.
-    pub new_animations_sender: Mutex<Sender<Animation<Impl>>>,
-
     /// Why is this reflow occurring
     pub goal: ReflowGoal,
 
@@ -47,16 +55,32 @@ pub struct SharedStyleContext<Impl: SelectorImplExt> {
 
     ///The CSS error reporter for all CSS loaded in this layout thread
     pub error_reporter: Box<ParseErrorReporter + Sync>,
+
+    /// Data needed to create the local style context from the shared one.
+    pub local_context_creation_data: Mutex<LocalStyleContextCreationInfo<Impl>>,
 }
 
-pub struct LocalStyleContext<C: ComputedValues> {
+pub struct LocalStyleContext<Impl: SelectorImplExt> {
-    pub applicable_declarations_cache: RefCell<ApplicableDeclarationsCache<C>>,
+    pub applicable_declarations_cache: RefCell<ApplicableDeclarationsCache<Impl::ComputedValues>>,
-    pub style_sharing_candidate_cache: RefCell<StyleSharingCandidateCache<C>>,
+    pub style_sharing_candidate_cache: RefCell<StyleSharingCandidateCache<Impl::ComputedValues>>,
+    /// A channel on which new animations that have been triggered by style
+    /// recalculation can be sent.
+    pub new_animations_sender: Sender<Animation<Impl>>,
+}
+
+impl<Impl: SelectorImplExt> LocalStyleContext<Impl> {
+    pub fn new(local_context_creation_data: &LocalStyleContextCreationInfo<Impl>) -> Self {
+        LocalStyleContext {
+            applicable_declarations_cache: RefCell::new(ApplicableDeclarationsCache::new()),
+            style_sharing_candidate_cache: RefCell::new(StyleSharingCandidateCache::new()),
+            new_animations_sender: local_context_creation_data.new_animations_sender.clone(),
+        }
+    }
 }
 
 pub trait StyleContext<'a, Impl: SelectorImplExt> {
     fn shared_context(&self) -> &'a SharedStyleContext<Impl>;
-    fn local_context(&self) -> &LocalStyleContext<Impl::ComputedValues>;
+    fn local_context(&self) -> &LocalStyleContext<Impl>;
 }
 
 /// Why we're doing reflow.

components/style/matching.rs

@@ -7,7 +7,7 @@
 #![allow(unsafe_code)]
 
 use animation::{self, Animation};
-use context::{SharedStyleContext, LocalStyleContext};
+use context::{StyleContext, SharedStyleContext};
 use data::PrivateStyleData;
 use dom::{TElement, TNode, TRestyleDamage};
 use properties::{ComputedValues, PropertyDeclaration, cascade};
@@ -371,19 +371,22 @@ trait PrivateMatchMethods: TNode
     ///
     /// Note that animations only apply to nodes or ::before or ::after
     /// pseudo-elements.
-    fn cascade_node_pseudo_element(&self,
+    fn cascade_node_pseudo_element<'a, Ctx>(&self,
-                                   context: &SharedStyleContext<<Self::ConcreteElement as Element>::Impl>,
+                                            context: &Ctx,
-                                   parent_style: Option<&Arc<Self::ConcreteComputedValues>>,
+                                            parent_style: Option<&Arc<Self::ConcreteComputedValues>>,
-                                   applicable_declarations: &[DeclarationBlock],
+                                            applicable_declarations: &[DeclarationBlock],
-                                   mut style: Option<&mut Arc<Self::ConcreteComputedValues>>,
+                                            mut style: Option<&mut Arc<Self::ConcreteComputedValues>>,
-                                   applicable_declarations_cache:
+                                            applicable_declarations_cache:
-                                    &mut ApplicableDeclarationsCache<Self::ConcreteComputedValues>,
+                                             &mut ApplicableDeclarationsCache<Self::ConcreteComputedValues>,
-                                   shareable: bool,
+                                            shareable: bool,
-                                   animate_properties: bool)
+                                            animate_properties: bool)
-                                   -> (Self::ConcreteRestyleDamage, Arc<Self::ConcreteComputedValues>) {
+                                            -> (Self::ConcreteRestyleDamage, Arc<Self::ConcreteComputedValues>)
+    where Ctx: StyleContext<'a, <Self::ConcreteElement as Element>::Impl> {
         let mut cacheable = true;
+        let shared_context = context.shared_context();
         if animate_properties {
-            cacheable = !self.update_animations_for_cascade(context, &mut style) && cacheable;
+            cacheable = !self.update_animations_for_cascade(shared_context,
+                                                            &mut style) && cacheable;
         }
 
         let this_style;
@@ -395,22 +398,22 @@ trait PrivateMatchMethods: TNode
                     None => None,
                 };
 
-                let (the_style, is_cacheable) = cascade(context.viewport_size,
+                let (the_style, is_cacheable) = cascade(shared_context.viewport_size,
                                                         applicable_declarations,
                                                         shareable,
                                                         Some(&***parent_style),
                                                         cached_computed_values,
-                                                        context.error_reporter.clone());
+                                                        shared_context.error_reporter.clone());
                 cacheable = cacheable && is_cacheable;
                 this_style = the_style
             }
             None => {
-                let (the_style, is_cacheable) = cascade(context.viewport_size,
+                let (the_style, is_cacheable) = cascade(shared_context.viewport_size,
                                                         applicable_declarations,
                                                         shareable,
                                                         None,
                                                         None,
-                                                        context.error_reporter.clone());
+                                                        shared_context.error_reporter.clone());
                 cacheable = cacheable && is_cacheable;
                 this_style = the_style
             }
@@ -419,10 +422,12 @@ trait PrivateMatchMethods: TNode
         let mut this_style = Arc::new(this_style);
 
         if animate_properties {
+            let new_animations_sender = &context.local_context().new_animations_sender;
             let this_opaque = self.opaque();
             // Trigger any present animations if necessary.
             let mut animations_started = animation::maybe_start_animations::<<Self::ConcreteElement as Element>::Impl>(
-                &context,
+                &shared_context,
+                new_animations_sender,
                 this_opaque,
                 &this_style);
 
@@ -431,7 +436,7 @@ trait PrivateMatchMethods: TNode
             if let Some(ref style) = style {
                 animations_started |=
                     animation::start_transitions_if_applicable::<<Self::ConcreteElement as Element>::Impl>(
-                        &context.new_animations_sender,
+                        new_animations_sender,
                         this_opaque,
                         &**style,
                         &mut this_style);
@@ -658,12 +663,13 @@ pub trait MatchMethods : TNode {
         }
     }
 
-    unsafe fn cascade_node(&self,
+    unsafe fn cascade_node<'a, Ctx>(&self,
-                           context: &SharedStyleContext<<Self::ConcreteElement as Element>::Impl>,
+                                    context: &Ctx,
-                           local_context: &LocalStyleContext<Self::ConcreteComputedValues>,
+                                    parent: Option<Self>,
-                           parent: Option<Self>,
+                                    applicable_declarations:
-                           applicable_declarations: &ApplicableDeclarations<<Self::ConcreteElement as Element>::Impl>)
+                                     &ApplicableDeclarations<<Self::ConcreteElement as Element>::Impl>)
-    where <Self::ConcreteElement as Element>::Impl: SelectorImplExt<ComputedValues = Self::ConcreteComputedValues>
+    where <Self::ConcreteElement as Element>::Impl: SelectorImplExt<ComputedValues = Self::ConcreteComputedValues>,
+          Ctx: StyleContext<'a, <Self::ConcreteElement as Element>::Impl>
     {
         // Get our parent's style. This must be unsafe so that we don't touch the parent's
         // borrow flags.
@@ -679,7 +685,7 @@ pub trait MatchMethods : TNode {
         };
 
         let mut applicable_declarations_cache =
-            local_context.applicable_declarations_cache.borrow_mut();
+            context.local_context().applicable_declarations_cache.borrow_mut();
 
         let damage;
         if self.is_text_node() {

components/style/parallel.rs

@@ -45,7 +45,7 @@ pub fn traverse_dom<N, C>(root: N,
                           where N: TNode, C: DomTraversalContext<N> {
     run_queue_with_custom_work_data_type(queue, |queue| {
         queue.push(WorkUnit {
-            fun:  top_down_dom::<N, C>,
+            fun: top_down_dom::<N, C>,
             data: (Box::new(vec![root.to_unsafe()]), root.opaque()),
         });
     }, queue_data);

components/style/selector_impl.rs

@@ -65,7 +65,7 @@ pub trait ElementExt: Element {
 
 // NB: The `Clone` trait is here for convenience due to:
 // https://github.com/rust-lang/rust/issues/26925
-pub trait SelectorImplExt : SelectorImpl + Clone + Debug + Sized {
+pub trait SelectorImplExt : SelectorImpl + Clone + Debug + Sized + 'static {
     type ComputedValues: properties::ComputedValues;
 
     fn pseudo_element_cascade_type(pseudo: &Self::PseudoElement) -> PseudoElementCascadeType;

components/style/servo.rs

@@ -15,4 +15,5 @@ pub type Stylesheet = stylesheets::Stylesheet<ServoSelectorImpl>;
 pub type PrivateStyleData = data::PrivateStyleData<ServoSelectorImpl, ServoComputedValues>;
 pub type Stylist = selector_matching::Stylist<ServoSelectorImpl>;
 pub type SharedStyleContext = context::SharedStyleContext<ServoSelectorImpl>;
+pub type LocalStyleContextCreationInfo = context::LocalStyleContextCreationInfo<ServoSelectorImpl>;
 pub type Animation = animation::Animation<ServoSelectorImpl>;

components/style/traversal.rs

@@ -218,8 +218,7 @@ pub fn recalc_style_at<'a, N, C>(context: &'a C,
 
                 // Perform the CSS cascade.
                 unsafe {
-                    node.cascade_node(&context.shared_context(),
+                    node.cascade_node(context,
-                                      &context.local_context(),
                                       parent_opt,
                                       &applicable_declarations);
                 }

ports/geckolib/context.rs

@@ -0,0 +1,53 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+use selector_impl::{GeckoSelectorImpl, SharedStyleContext};
+use std::cell::RefCell;
+use std::rc::Rc;
+use style::context::{LocalStyleContext, StyleContext};
+
+thread_local!(static LOCAL_CONTEXT_KEY:
+                RefCell<Option<Rc<LocalStyleContext<GeckoSelectorImpl>>>> = RefCell::new(None));
+
+// Keep this implementation in sync with the one in components/layout/context.rs.
+fn create_or_get_local_context(shared: &SharedStyleContext)
+                               -> Rc<LocalStyleContext<GeckoSelectorImpl>> {
+    LOCAL_CONTEXT_KEY.with(|r| {
+        let mut r = r.borrow_mut();
+        if let Some(context) = r.clone() {
+            if shared.screen_size_changed {
+                context.applicable_declarations_cache.borrow_mut().evict_all();
+            }
+            context
+        } else {
+            let context = Rc::new(LocalStyleContext::new(&shared.local_context_creation_data.lock().unwrap()));
+            *r = Some(context.clone());
+            context
+        }
+    })
+}
+
+pub struct StandaloneStyleContext<'a> {
+    pub shared: &'a SharedStyleContext,
+    cached_local_context: Rc<LocalStyleContext<GeckoSelectorImpl>>,
+}
+
+impl<'a> StandaloneStyleContext<'a> {
+    pub fn new(shared: &'a SharedStyleContext) -> Self {
+        let local_context = create_or_get_local_context(shared);
+        StandaloneStyleContext {
+            shared: shared,
+            cached_local_context: local_context,
+        }
+    }
+}
+
+impl<'a> StyleContext<'a, GeckoSelectorImpl> for StandaloneStyleContext<'a> {
+    fn shared_context(&self) -> &'a SharedStyleContext {
+        &self.shared
+    }
+
+    fn local_context(&self) -> &LocalStyleContext<GeckoSelectorImpl> {
+        &self.cached_local_context
+    }
+}

ports/geckolib/data.rs

@@ -6,7 +6,7 @@ use euclid::Size2D;
 use euclid::size::TypedSize2D;
 use gecko_bindings::bindings::RawServoStyleSet;
 use num_cpus;
-use selector_impl::{GeckoSelectorImpl, Stylist, Stylesheet, SharedStyleContext};
+use selector_impl::{Animation, SharedStyleContext, Stylist, Stylesheet};
 use std::cmp;
 use std::collections::HashMap;
 use std::sync::mpsc::{channel, Receiver, Sender};
@@ -18,8 +18,6 @@ use util::geometry::ViewportPx;
 use util::thread_state;
 use util::workqueue::WorkQueue;
 
-pub type Animation = ::style::animation::Animation<GeckoSelectorImpl>;
-
 pub struct PerDocumentStyleData {
     /// Rule processor.
     pub stylist: Arc<Stylist>,

ports/geckolib/glue.rs

@@ -22,7 +22,7 @@ use std::ptr;
 use std::slice;
 use std::str::from_utf8_unchecked;
 use std::sync::{Arc, Mutex};
-use style::context::ReflowGoal;
+use style::context::{LocalStyleContextCreationInfo, ReflowGoal};
 use style::dom::{TDocument, TElement, TNode};
 use style::error_reporting::StdoutErrorReporter;
 use style::parallel;
@@ -77,7 +77,7 @@ pub extern "C" fn Servo_Initialize() -> () {
 fn restyle_subtree(node: GeckoNode, raw_data: *mut RawServoStyleSet) {
     debug_assert!(node.is_element() || node.is_text_node());
 
-    let data = unsafe { &mut *(raw_data as *mut PerDocumentStyleData) };
+    let per_doc_data = unsafe { &mut *(raw_data as *mut PerDocumentStyleData) };
 
     // Force the creation of our lazily-constructed initial computed values on
     // the main thread, since it's not safe to call elsewhere.
@@ -88,24 +88,28 @@ fn restyle_subtree(node: GeckoNode, raw_data: *mut RawServoStyleSet) {
     // along in startup than the sensible place to call Servo_Initialize.
     GeckoComputedValues::initial_values();
 
-    let _needs_dirtying = Arc::get_mut(&mut data.stylist).unwrap()
+    let _needs_dirtying = Arc::get_mut(&mut per_doc_data.stylist).unwrap()
-                              .update(&data.stylesheets, data.stylesheets_changed);
+                              .update(&per_doc_data.stylesheets,
-    data.stylesheets_changed = false;
+                                      per_doc_data.stylesheets_changed);
+    per_doc_data.stylesheets_changed = false;
+
+    let local_context_data =
+        LocalStyleContextCreationInfo::new(per_doc_data.new_animations_sender.clone());
 
     let shared_style_context = SharedStyleContext {
         viewport_size: Size2D::new(Au(0), Au(0)),
         screen_size_changed: false,
         generation: 0,
         goal: ReflowGoal::ForScriptQuery,
-        stylist: data.stylist.clone(),
+        stylist: per_doc_data.stylist.clone(),
-        new_animations_sender: Mutex::new(data.new_animations_sender.clone()),
+        running_animations: per_doc_data.running_animations.clone(),
-        running_animations: data.running_animations.clone(),
+        expired_animations: per_doc_data.expired_animations.clone(),
-        expired_animations: data.expired_animations.clone(),
         error_reporter: Box::new(StdoutErrorReporter),
+        local_context_creation_data: Mutex::new(local_context_data),
     };
 
     if node.is_dirty() || node.has_dirty_descendants() {
-        parallel::traverse_dom::<GeckoNode, RecalcStyleOnly>(node, &shared_style_context, &mut data.work_queue);
+        parallel::traverse_dom::<GeckoNode, RecalcStyleOnly>(node, &shared_style_context, &mut per_doc_data.work_queue);
     }
 }
 

ports/geckolib/lib.rs

@@ -24,6 +24,7 @@ extern crate style_traits;
 extern crate url;
 extern crate util;
 
+mod context;
 mod data;
 #[allow(non_snake_case)]
 pub mod glue;

ports/geckolib/selector_impl.rs

@@ -12,6 +12,7 @@ pub type Stylist = style::selector_matching::Stylist<GeckoSelectorImpl>;
 pub type Stylesheet = style::stylesheets::Stylesheet<GeckoSelectorImpl>;
 pub type SharedStyleContext = style::context::SharedStyleContext<GeckoSelectorImpl>;
 pub type PrivateStyleData = style::data::PrivateStyleData<GeckoSelectorImpl, GeckoComputedValues>;
+pub type Animation = style::animation::Animation<GeckoSelectorImpl>;
 
 #[cfg(feature = "servo_features")]
 known_heap_size!(0, GeckoSelectorImpl, PseudoElement, NonTSPseudoClass);

ports/geckolib/traversal.rs

@@ -2,66 +2,13 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-use properties::GeckoComputedValues;
+use context::StandaloneStyleContext;
-use selector_impl::{GeckoSelectorImpl, SharedStyleContext};
+use selector_impl::SharedStyleContext;
-use std::cell::RefCell;
 use std::mem;
-use std::rc::Rc;
-use style::context::{LocalStyleContext, StyleContext};
 use style::dom::OpaqueNode;
-use style::matching::{ApplicableDeclarationsCache, StyleSharingCandidateCache};
 use style::traversal::{DomTraversalContext, recalc_style_at};
 use wrapper::GeckoNode;
 
-thread_local!(static LOCAL_CONTEXT_KEY:
-                RefCell<Option<Rc<LocalStyleContext<GeckoComputedValues>>>> = RefCell::new(None));
-
-// Keep this implementation in sync with the one in components/layout/context.rs.
-fn create_or_get_local_context(shared: &SharedStyleContext)
-                               -> Rc<LocalStyleContext<GeckoComputedValues>> {
-    LOCAL_CONTEXT_KEY.with(|r| {
-        let mut r = r.borrow_mut();
-        if let Some(context) = r.clone() {
-            if shared.screen_size_changed {
-                context.applicable_declarations_cache.borrow_mut().evict_all();
-            }
-            context
-        } else {
-            let context = Rc::new(LocalStyleContext {
-                applicable_declarations_cache: RefCell::new(ApplicableDeclarationsCache::new()),
-                style_sharing_candidate_cache: RefCell::new(StyleSharingCandidateCache::new()),
-            });
-            *r = Some(context.clone());
-            context
-        }
-    })
-}
-
-pub struct StandaloneStyleContext<'a> {
-    pub shared: &'a SharedStyleContext,
-    cached_local_context: Rc<LocalStyleContext<GeckoComputedValues>>,
-}
-
-impl<'a> StandaloneStyleContext<'a> {
-    pub fn new(shared: &'a SharedStyleContext) -> Self {
-        let local_context = create_or_get_local_context(shared);
-        StandaloneStyleContext {
-            shared: shared,
-            cached_local_context: local_context,
-        }
-    }
-}
-
-impl<'a> StyleContext<'a, GeckoSelectorImpl> for StandaloneStyleContext<'a> {
-    fn shared_context(&self) -> &'a SharedStyleContext {
-        &self.shared
-    }
-
-    fn local_context(&self) -> &LocalStyleContext<GeckoComputedValues> {
-        &self.cached_local_context
-    }
-}
-
 pub struct RecalcStyleOnly<'lc> {
     context: StandaloneStyleContext<'lc>,
     root: OpaqueNode,
@@ -73,7 +20,7 @@ impl<'lc, 'ln> DomTraversalContext<GeckoNode<'ln>> for RecalcStyleOnly<'lc> {
     fn new<'a>(shared: &'a Self::SharedContext, root: OpaqueNode) -> Self {
         // See the comment in RecalcStyleAndConstructFlows::new for an explanation of why this is
         // necessary.
-        let shared_lc: &'lc SharedStyleContext = unsafe { mem::transmute(shared) };
+        let shared_lc: &'lc Self::SharedContext = unsafe { mem::transmute(shared) };
         RecalcStyleOnly {
             context: StandaloneStyleContext::new(shared_lc),
             root: root,
@@ -90,4 +37,3 @@ impl<'lc, 'ln> DomTraversalContext<GeckoNode<'ln>> for RecalcStyleOnly<'lc> {
 
     fn process_postorder(&self, _: GeckoNode<'ln>) {}
 }
-