Move all PropertyDeclarationBlock from RwLock<_> to Locked<_>

components/style/gecko/arc_types.rs

@@ -48,7 +48,7 @@ impl_arc_ffi!(Stylesheet => RawServoStyleSheet
 impl_arc_ffi!(ComputedValues => ServoComputedValues
               [Servo_ComputedValues_AddRef, Servo_ComputedValues_Release]);
 
-impl_arc_ffi!(RwLock<PropertyDeclarationBlock> => RawServoDeclarationBlock
+impl_arc_ffi!(Locked<PropertyDeclarationBlock> => RawServoDeclarationBlock
               [Servo_DeclarationBlock_AddRef, Servo_DeclarationBlock_Release]);
 
 impl_arc_ffi!(Locked<StyleRule> => RawServoStyleRule

components/style/gecko/global_style_data.rs

@@ -0,0 +1,50 @@
+/* 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/. */
+
+//! Global style data
+
+use num_cpus;
+use rayon;
+use shared_lock::SharedRwLock;
+use std::cmp;
+use std::env;
+
+/// Global style data
+pub struct GlobalStyleData {
+    /// How many threads parallel styling can use.
+    pub num_threads: usize,
+
+    /// The parallel styling thread pool.
+    pub style_thread_pool: Option<rayon::ThreadPool>,
+
+    /// Shared RWLock for CSSOM objects
+    pub shared_lock: SharedRwLock,
+}
+
+lazy_static! {
+    /// Global style data
+    pub static ref GLOBAL_STYLE_DATA: GlobalStyleData = {
+        let stylo_threads = env::var("STYLO_THREADS")
+            .map(|s| s.parse::<usize>().expect("invalid STYLO_THREADS value"));
+        let num_threads = match stylo_threads {
+            Ok(num) => num,
+            _ => cmp::max(num_cpus::get() * 3 / 4, 1),
+        };
+
+        let pool = if num_threads <= 1 {
+            None
+        } else {
+            let configuration =
+                rayon::Configuration::new().set_num_threads(num_threads);
+            let pool = rayon::ThreadPool::new(configuration).ok();
+            pool
+        };
+
+        GlobalStyleData {
+            num_threads: num_threads,
+            style_thread_pool: pool,
+            shared_lock: SharedRwLock::new(),
+        }
+    };
+}

components/style/gecko/mod.rs

@@ -10,6 +10,7 @@ mod non_ts_pseudo_class_list;
 pub mod arc_types;
 pub mod conversions;
 pub mod data;
+pub mod global_style_data;
 pub mod media_queries;
 pub mod restyle_damage;
 pub mod selector_parser;

components/style/gecko/wrapper.rs

@@ -20,6 +20,7 @@ use dom::{AnimationRules, LayoutIterator, NodeInfo, TElement, TNode, UnsafeNode}
 use dom::{OpaqueNode, PresentationalHintsSynthetizer};
 use element_state::ElementState;
 use error_reporting::StdoutErrorReporter;
+use gecko::global_style_data::GLOBAL_STYLE_DATA;
 use gecko::selector_parser::{SelectorImpl, NonTSPseudoClass, PseudoElement};
 use gecko::snapshot_helpers;
 use gecko_bindings::bindings;
@@ -53,6 +54,7 @@ use selectors::Element;
 use selectors::matching::{ElementSelectorFlags, StyleRelations, matches_complex_selector};
 use selectors::parser::{AttrSelector, NamespaceConstraint};
 use servo_url::ServoUrl;
+use shared_lock::Locked;
 use sink::Push;
 use std::fmt;
 use std::ptr;
@@ -407,12 +409,14 @@ fn selector_flags_to_node_flags(flags: ElementSelectorFlags) -> u32 {
 fn get_animation_rule(element: &GeckoElement,
                       pseudo: Option<&PseudoElement>,
                       cascade_level: CascadeLevel)
-                      -> Option<Arc<RwLock<PropertyDeclarationBlock>>> {
+                      -> Option<Arc<Locked<PropertyDeclarationBlock>>> {
     let atom_ptr = PseudoElement::ns_atom_or_null_from_opt(pseudo);
     let animation_values = Arc::new(RwLock::new(AnimationValueMap::new()));
     if unsafe { Gecko_GetAnimationRule(element.0, atom_ptr, cascade_level,
                                        HasArcFFI::arc_as_borrowed(&animation_values)) } {
-        Some(Arc::new(RwLock::new(PropertyDeclarationBlock::from_animation_value_map(&animation_values.read()))))
+        let shared_lock = &GLOBAL_STYLE_DATA.shared_lock;
+        Some(Arc::new(shared_lock.wrap(
+            PropertyDeclarationBlock::from_animation_value_map(&animation_values.read()))))
     } else {
         None
     }
@@ -425,7 +429,7 @@ impl<'le> TElement for GeckoElement<'le> {
         unsafe { GeckoNode(&*(self.0 as *const _ as *const RawGeckoNode)) }
     }
 
-    fn style_attribute(&self) -> Option<&Arc<RwLock<PropertyDeclarationBlock>>> {
+    fn style_attribute(&self) -> Option<&Arc<Locked<PropertyDeclarationBlock>>> {
         let declarations = unsafe { Gecko_GetStyleAttrDeclarationBlock(self.0) };
         declarations.map(|s| s.as_arc_opt()).unwrap_or(None)
     }
@@ -436,12 +440,12 @@ impl<'le> TElement for GeckoElement<'le> {
     }
 
     fn get_animation_rule(&self, pseudo: Option<&PseudoElement>)
-                          -> Option<Arc<RwLock<PropertyDeclarationBlock>>> {
+                          -> Option<Arc<Locked<PropertyDeclarationBlock>>> {
         get_animation_rule(self, pseudo, CascadeLevel::Animations)
     }
 
     fn get_transition_rule(&self, pseudo: Option<&PseudoElement>)
-                           -> Option<Arc<RwLock<PropertyDeclarationBlock>>> {
+                           -> Option<Arc<Locked<PropertyDeclarationBlock>>> {
         get_animation_rule(self, pseudo, CascadeLevel::Transitions)
     }