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

components/style/keyframes.rs

@@ -8,14 +8,13 @@
 
 use cssparser::{AtRuleParser, Parser, QualifiedRuleParser, RuleListParser};
 use cssparser::{DeclarationListParser, DeclarationParser, parse_one_rule};
-use parking_lot::RwLock;
 use parser::{ParserContext, ParserContextExtraData, log_css_error};
 use properties::{Importance, PropertyDeclaration, PropertyDeclarationBlock, PropertyId};
 use properties::{PropertyDeclarationId, LonghandId, ParsedDeclaration};
 use properties::LonghandIdSet;
 use properties::animated_properties::TransitionProperty;
 use properties::longhands::transition_timing_function::single_value::SpecifiedValue as SpecifiedTimingFunction;
-use shared_lock::{SharedRwLock, SharedRwLockReadGuard, Locked};
+use shared_lock::{SharedRwLock, SharedRwLockReadGuard, Locked, ToCssWithGuard};
 use std::fmt;
 use std::sync::Arc;
 use style_traits::ToCss;
@@ -102,11 +101,12 @@ pub struct Keyframe {
     ///
     /// Note that `!important` rules in keyframes don't apply, but we keep this
     /// `Arc` just for convenience.
-    pub block: Arc<RwLock<PropertyDeclarationBlock>>,
+    pub block: Arc<Locked<PropertyDeclarationBlock>>,
 }
 
-impl ToCss for Keyframe {
-    fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
+impl ToCssWithGuard for Keyframe {
+    fn to_css<W>(&self, guard: &SharedRwLockReadGuard, dest: &mut W) -> fmt::Result
+    where W: fmt::Write {
         let mut iter = self.selector.percentages().iter();
         try!(iter.next().unwrap().to_css(dest));
         for percentage in iter {
@@ -114,7 +114,7 @@ impl ToCss for Keyframe {
             try!(percentage.to_css(dest));
         }
         try!(dest.write_str(" { "));
-        try!(self.block.read().to_css(dest));
+        try!(self.block.read_with(guard).to_css(dest));
         try!(dest.write_str(" }"));
         Ok(())
     }
@@ -154,7 +154,7 @@ pub enum KeyframesStepValue {
     Declarations {
         /// The declaration block per se.
         #[cfg_attr(feature = "servo", ignore_heap_size_of = "Arc")]
-        block: Arc<RwLock<PropertyDeclarationBlock>>
+        block: Arc<Locked<PropertyDeclarationBlock>>
     },
     /// A synthetic step computed from the current computed values at the time
     /// of the animation.
@@ -180,10 +180,11 @@ pub struct KeyframesStep {
 impl KeyframesStep {
     #[inline]
     fn new(percentage: KeyframePercentage,
-           value: KeyframesStepValue) -> Self {
+           value: KeyframesStepValue,
+           guard: &SharedRwLockReadGuard) -> Self {
         let declared_timing_function = match value {
             KeyframesStepValue::Declarations { ref block } => {
-                block.read().declarations().iter().any(|&(ref prop_decl, _)| {
+                block.read_with(guard).declarations().iter().any(|&(ref prop_decl, _)| {
                     match *prop_decl {
                         PropertyDeclaration::AnimationTimingFunction(..) => true,
                         _ => false,
@@ -201,13 +202,14 @@ impl KeyframesStep {
     }
 
     /// Return specified TransitionTimingFunction if this KeyframesSteps has 'animation-timing-function'.
-    pub fn get_animation_timing_function(&self) -> Option<SpecifiedTimingFunction> {
+    pub fn get_animation_timing_function(&self, guard: &SharedRwLockReadGuard)
+                                         -> Option<SpecifiedTimingFunction> {
         if !self.declared_timing_function {
             return None;
         }
         match self.value {
             KeyframesStepValue::Declarations { ref block } => {
-                let guard = block.read();
+                let guard = block.read_with(guard);
                 let &(ref declaration, _) =
                     guard.get(PropertyDeclarationId::Longhand(LonghandId::AnimationTimingFunction)).unwrap();
                 match *declaration {
@@ -249,7 +251,8 @@ fn get_animated_properties(keyframes: &[Arc<Locked<Keyframe>>], guard: &SharedRw
     // it here.
     for keyframe in keyframes {
         let keyframe = keyframe.read_with(&guard);
-        for &(ref declaration, importance) in keyframe.block.read().declarations().iter() {
+        let block = keyframe.block.read_with(guard);
+        for &(ref declaration, importance) in block.declarations().iter() {
             assert!(!importance.important());
 
             if let Some(property) = TransitionProperty::from_declaration(declaration) {
@@ -294,7 +297,7 @@ impl KeyframesAnimation {
             for percentage in keyframe.selector.0.iter() {
                 result.steps.push(KeyframesStep::new(*percentage, KeyframesStepValue::Declarations {
                     block: keyframe.block.clone(),
-                }));
+                }, guard));
             }
         }
 
@@ -304,12 +307,14 @@ impl KeyframesAnimation {
         // Prepend autogenerated keyframes if appropriate.
         if result.steps[0].start_percentage.0 != 0. {
             result.steps.insert(0, KeyframesStep::new(KeyframePercentage::new(0.),
-                                                      KeyframesStepValue::ComputedValues));
+                                                      KeyframesStepValue::ComputedValues,
+                                                      guard));
         }
 
         if result.steps.last().unwrap().start_percentage.0 != 1. {
             result.steps.push(KeyframesStep::new(KeyframePercentage::new(1.),
-                                                 KeyframesStepValue::ComputedValues));
+                                                 KeyframesStepValue::ComputedValues,
+                                                 guard));
         }
 
         result
@@ -381,7 +386,7 @@ impl<'a> QualifiedRuleParser for KeyframeListParser<'a> {
         }
         Ok(Arc::new(self.shared_lock.wrap(Keyframe {
             selector: prelude,
-            block: Arc::new(RwLock::new(block)),
+            block: Arc::new(self.shared_lock.wrap(block)),
         })))
     }
 }