--- a/servo/components/style/properties/gecko.mako.rs
+++ b/servo/components/style/properties/gecko.mako.rs
@@ -1303,35 +1303,16 @@ fn static_assert() {
 
 <%def name="impl_animation_or_transition_count(type, ident, gecko_ffi_name)">
     #[allow(non_snake_case)]
     pub fn ${type}_${ident}_count(&self) -> usize {
         self.gecko.m${type.capitalize()}${gecko_ffi_name}Count as usize
     }
 </%def>
 
-<%def name="impl_animation_or_transition_timing_function(type)">
-    pub fn set_${type}_timing_function(&mut self, v: longhands::${type}_timing_function::computed_value::T) {
-        debug_assert!(!v.0.is_empty());
-        let input_len = v.0.len();
-        unsafe { self.gecko.m${type.capitalize()}s.ensure_len(input_len) };
-
-        self.gecko.m${type.capitalize()}TimingFunctionCount = input_len as u32;
-        for (i, gecko) in self.gecko.m${type.capitalize()}s.iter_mut().enumerate() {
-            gecko.mTimingFunction = v.0[i % input_len].into();
-        }
-    }
-    ${impl_animation_or_transition_count(type, 'timing_function', 'TimingFunction')}
-    ${impl_copy_animation_or_transition_value(type, 'timing_function', 'TimingFunction')}
-    pub fn ${type}_timing_function_at(&self, index: usize)
-        -> longhands::${type}_timing_function::computed_value::SingleComputedValue {
-        self.gecko.m${type.capitalize()}s[index].mTimingFunction.into()
-    }
-</%def>
-
 <%def name="impl_transition_time_value(ident, gecko_ffi_name)">
     #[allow(non_snake_case)]
     pub fn set_transition_${ident}(&mut self, v: longhands::transition_${ident}::computed_value::T) {
         if !v.0.is_empty() {
             let input_len = v.0.len();
             unsafe { self.gecko.mTransitions.ensure_len(input_len) };
 
             self.gecko.mTransition${gecko_ffi_name}Count = input_len as u32;
@@ -1359,17 +1340,38 @@ fn static_assert() {
     ${impl_animation_or_transition_count('transition', ident, gecko_ffi_name)}
 </%def>
 
 <%def name="impl_copy_animation_value(ident, gecko_ffi_name)">
     ${impl_copy_animation_or_transition_value('animation', ident, gecko_ffi_name)}
 </%def>
 
 <%def name="impl_transition_timing_function()">
-    ${impl_animation_or_transition_timing_function('transition')}
+    pub fn set_transition_timing_function(&mut self, v: longhands::transition_timing_function::computed_value::T) {
+        if !v.0.is_empty() {
+            let input_len = v.0.len();
+            unsafe { self.gecko.mTransitions.ensure_len(input_len) };
+
+            self.gecko.mTransitionTimingFunctionCount = input_len as u32;
+            for (i, gecko) in self.gecko.mTransitions.iter_mut().enumerate() {
+                gecko.mTimingFunction = v.0[i % input_len].into();
+            }
+        } else {
+            // An empty vector means this is a none transition, so we need one item in mTransition
+            // which represents a none transition with initial/unset values.
+            self.gecko.mTransitions[0].mTimingFunction =
+                longhands::transition_timing_function::single_value::get_initial_value().into();
+        }
+    }
+    pub fn transition_timing_function_at(&self, index: usize)
+        -> longhands::transition_timing_function::computed_value::SingleComputedValue {
+        self.gecko.mTransitions[index].mTimingFunction.into()
+    }
+    ${impl_animation_or_transition_count('transition', 'timing_function', 'TimingFunction')}
+    ${impl_copy_animation_or_transition_value('transition', 'timing_function', 'TimingFunction')}
 </%def>
 
 <%def name="impl_animation_count(ident, gecko_ffi_name)">
     ${impl_animation_or_transition_count('animation', ident, gecko_ffi_name)}
 </%def>
 
 <%def name="impl_animation_time_value(ident, gecko_ffi_name)">
     #[allow(non_snake_case)]
@@ -1389,17 +1391,32 @@ fn static_assert() {
         use values::specified::Time;
         Time(self.gecko.mAnimations[index].m${gecko_ffi_name} / 1000.)
     }
     ${impl_animation_or_transition_count('animation', ident, gecko_ffi_name)}
     ${impl_copy_animation_or_transition_value('animation', ident, gecko_ffi_name)}
 </%def>
 
 <%def name="impl_animation_timing_function()">
-    ${impl_animation_or_transition_timing_function('animation')}
+    pub fn set_animation_timing_function(&mut self, v: longhands::animation_timing_function::computed_value::T) {
+        debug_assert!(!v.0.is_empty());
+        let input_len = v.0.len();
+        unsafe { self.gecko.mAnimations.ensure_len(input_len) };
+
+        self.gecko.mAnimationTimingFunctionCount = input_len as u32;
+        for (i, gecko) in self.gecko.mAnimations.iter_mut().enumerate() {
+            gecko.mTimingFunction = v.0[i % input_len].into();
+        }
+    }
+    pub fn animation_timing_function_at(&self, index: usize)
+        -> longhands::animation_timing_function::computed_value::SingleComputedValue {
+        self.gecko.mAnimations[index].mTimingFunction.into()
+    }
+    ${impl_animation_or_transition_count('animation', 'timing_function', 'TimingFunction')}
+    ${impl_copy_animation_or_transition_value('animation', 'timing_function', 'TimingFunction')}
 </%def>
 
 <%def name="impl_animation_keyword(ident, gecko_ffi_name, keyword, cast_type='u8')">
     #[allow(non_snake_case)]
     pub fn set_animation_${ident}(&mut self, v: longhands::animation_${ident}::computed_value::T) {
         use properties::longhands::animation_${ident}::single_value::computed_value::T as Keyword;
         use gecko_bindings::structs;