Replace RwLock<StyleRule> with Locked<StyleRule>

tests/unit/style/Cargo.toml

@@ -17,7 +17,6 @@ app_units = "0.4"
 cssparser = "0.12"
 euclid = "0.11"
 html5ever-atoms = "0.2"
-owning_ref = "0.2.2"
 parking_lot = "0.3"
 rayon = "0.6"
 rustc-serialize = "0.3"

tests/unit/style/lib.rs

@@ -9,7 +9,6 @@ extern crate app_units;
 extern crate cssparser;
 extern crate euclid;
 #[macro_use] extern crate html5ever_atoms;
-extern crate owning_ref;
 extern crate parking_lot;
 extern crate rayon;
 extern crate rustc_serialize;
@@ -26,7 +25,6 @@ mod attr;
 mod keyframes;
 mod logical_geometry;
 mod media_queries;
-mod owning_handle;
 mod parsing;
 mod properties;
 mod rule_tree;

tests/unit/style/owning_handle.rs

@@ -1,34 +0,0 @@
-/* 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 owning_ref::RcRef;
-use std::cell::RefCell;
-use std::rc::Rc;
-use std::sync::{Arc, RwLock};
-use style::owning_handle::OwningHandle;
-
-#[test]
-fn owning_handle() {
-    use std::cell::RefCell;
-    let cell = Rc::new(RefCell::new(2));
-    let cell_ref = RcRef::new(cell);
-    let mut handle = OwningHandle::new(cell_ref, |x| unsafe { x.as_ref() }.unwrap().borrow_mut());
-    assert_eq!(*handle, 2);
-    *handle = 3;
-    assert_eq!(*handle, 3);
-}
-
-#[test]
-fn nested() {
-    let result = {
-        let complex = Rc::new(RefCell::new(Arc::new(RwLock::new("someString"))));
-        let curr = RcRef::new(complex);
-        let curr = OwningHandle::new(curr, |x| unsafe { x.as_ref() }.unwrap().borrow_mut());
-        let mut curr = OwningHandle::new(curr, |x| unsafe { x.as_ref() }.unwrap().try_write().unwrap());
-        assert_eq!(*curr, "someString");
-        *curr = "someOtherString";
-        curr
-    };
-    assert_eq!(*result, "someOtherString");
-}

tests/unit/style/stylesheets.rs

@@ -81,7 +81,7 @@ fn test_parse_stylesheet() {
                 prefix: None,
                 url: NsAtom::from("http://www.w3.org/1999/xhtml")
             }))),
-            CssRule::Style(Arc::new(RwLock::new(StyleRule {
+            CssRule::Style(Arc::new(stylesheet.shared_lock.wrap(StyleRule {
                 selectors: SelectorList(vec![
                     Selector {
                         complex_selector: Arc::new(ComplexSelector {
@@ -117,7 +117,7 @@ fn test_parse_stylesheet() {
                      Importance::Important),
                 ]))),
             }))),
-            CssRule::Style(Arc::new(RwLock::new(StyleRule {
+            CssRule::Style(Arc::new(stylesheet.shared_lock.wrap(StyleRule {
                 selectors: SelectorList(vec![
                     Selector {
                         complex_selector: Arc::new(ComplexSelector {
@@ -159,7 +159,7 @@ fn test_parse_stylesheet() {
                      Importance::Normal),
                 ]))),
             }))),
-            CssRule::Style(Arc::new(RwLock::new(StyleRule {
+            CssRule::Style(Arc::new(stylesheet.shared_lock.wrap(StyleRule {
                 selectors: SelectorList(vec![
                     Selector {
                         complex_selector: Arc::new(ComplexSelector {

tests/unit/style/stylist.rs

@@ -11,17 +11,19 @@ use style::properties::{PropertyDeclarationBlock, PropertyDeclaration};
 use style::properties::{longhands, Importance};
 use style::rule_tree::CascadeLevel;
 use style::selector_parser::SelectorParser;
+use style::shared_lock::SharedRwLock;
 use style::stylesheets::StyleRule;
 use style::stylist::{Rule, SelectorMap};
 use style::thread_state;
 
 /// Helper method to get some Rules from selector strings.
 /// Each sublist of the result contains the Rules for one StyleRule.
-fn get_mock_rules(css_selectors: &[&str]) -> Vec<Vec<Rule>> {
-    css_selectors.iter().enumerate().map(|(i, selectors)| {
+fn get_mock_rules(css_selectors: &[&str]) -> (Vec<Vec<Rule>>, SharedRwLock) {
+    let shared_lock = SharedRwLock::new();
+    (css_selectors.iter().enumerate().map(|(i, selectors)| {
         let selectors = SelectorParser::parse_author_origin_no_namespace(selectors).unwrap();
 
-        let rule = Arc::new(RwLock::new(StyleRule {
+        let locked = Arc::new(shared_lock.wrap(StyleRule {
             selectors: selectors,
             block: Arc::new(RwLock::new(PropertyDeclarationBlock::with_one(
                 PropertyDeclaration::Display(
@@ -30,21 +32,22 @@ fn get_mock_rules(css_selectors: &[&str]) -> Vec<Vec<Rule>> {
             ))),
         }));
 
-        let guard = rule.read();
-        guard.selectors.0.iter().map(|s| {
+        let guard = shared_lock.read();
+        let rule = locked.read_with(&guard);
+        rule.selectors.0.iter().map(|s| {
             Rule {
                 selector: s.complex_selector.clone(),
-                style_rule: rule.clone(),
+                style_rule: locked.clone(),
                 specificity: s.specificity,
                 source_order: i,
             }
         }).collect()
-    }).collect()
+    }).collect(), shared_lock)
 }
 
-fn get_mock_map(selectors: &[&str]) -> SelectorMap {
+fn get_mock_map(selectors: &[&str]) -> (SelectorMap, SharedRwLock) {
     let mut map = SelectorMap::new();
-    let selector_rules = get_mock_rules(selectors);
+    let (selector_rules, shared_lock) = get_mock_rules(selectors);
 
     for rules in selector_rules.into_iter() {
         for rule in rules.into_iter() {
@@ -52,12 +55,12 @@ fn get_mock_map(selectors: &[&str]) -> SelectorMap {
         }
     }
 
-    map
+    (map, shared_lock)
 }
 
 #[test]
 fn test_rule_ordering_same_specificity() {
-    let rules_list = get_mock_rules(&["a.intro", "img.sidebar"]);
+    let (rules_list, _) = get_mock_rules(&["a.intro", "img.sidebar"]);
     let a = &rules_list[0][0];
     let b = &rules_list[1][0];
     assert!((a.specificity, a.source_order) < ((b.specificity, b.source_order)),
@@ -67,21 +70,21 @@ fn test_rule_ordering_same_specificity() {
 
 #[test]
 fn test_get_id_name() {
-    let rules_list = get_mock_rules(&[".intro", "#top"]);
+    let (rules_list, _) = get_mock_rules(&[".intro", "#top"]);
     assert_eq!(SelectorMap::get_id_name(&rules_list[0][0]), None);
     assert_eq!(SelectorMap::get_id_name(&rules_list[1][0]), Some(Atom::from("top")));
 }
 
 #[test]
 fn test_get_class_name() {
-    let rules_list = get_mock_rules(&[".intro.foo", "#top"]);
+    let (rules_list, _) = get_mock_rules(&[".intro.foo", "#top"]);
     assert_eq!(SelectorMap::get_class_name(&rules_list[0][0]), Some(Atom::from("intro")));
     assert_eq!(SelectorMap::get_class_name(&rules_list[1][0]), None);
 }
 
 #[test]
 fn test_get_local_name() {
-    let rules_list = get_mock_rules(&["img.foo", "#top", "IMG", "ImG"]);
+    let (rules_list, _) = get_mock_rules(&["img.foo", "#top", "IMG", "ImG"]);
     let check = |i: usize, names: Option<(&str, &str)>| {
         assert!(SelectorMap::get_local_name(&rules_list[i][0])
                 == names.map(|(name, lower_name)| LocalNameSelector {
@@ -96,7 +99,7 @@ fn test_get_local_name() {
 
 #[test]
 fn test_insert() {
-    let rules_list = get_mock_rules(&[".intro.foo", "#top"]);
+    let (rules_list, _) = get_mock_rules(&[".intro.foo", "#top"]);
     let mut selector_map = SelectorMap::new();
     selector_map.insert(rules_list[1][0].clone());
     assert_eq!(1, selector_map.id_hash.get(&Atom::from("top")).unwrap()[0].source_order);
@@ -108,10 +111,11 @@ fn test_insert() {
 #[test]
 fn test_get_universal_rules() {
     thread_state::initialize(thread_state::LAYOUT);
-    let map = get_mock_map(&["*|*", "#foo > *|*", ".klass", "#id"]);
+    let (map, shared_lock) = get_mock_map(&["*|*", "#foo > *|*", ".klass", "#id"]);
 
-    let decls = map.get_universal_rules(CascadeLevel::UserNormal,
-                                        CascadeLevel::UserImportant);
+    let guard = shared_lock.read();
+    let decls = map.get_universal_rules(
+        &guard, CascadeLevel::UserNormal, CascadeLevel::UserImportant);
 
     assert_eq!(decls.len(), 1);
 }