--- a/dom/animation/ComputedTimingFunction.h
+++ b/dom/animation/ComputedTimingFunction.h
@@ -31,16 +31,21 @@ public:
   nsTimingFunction::Type GetType() const { return mType; }
   bool HasSpline() const { return nsTimingFunction::IsSplineType(mType); }
   uint32_t GetSteps() const
   {
     MOZ_ASSERT(mType == nsTimingFunction::Type::StepStart ||
                mType == nsTimingFunction::Type::StepEnd);
     return mStepsOrFrames;
   }
+  uint32_t GetFrames() const
+  {
+    MOZ_ASSERT(mType == nsTimingFunction::Type::Frames);
+    return mStepsOrFrames;
+  }
   bool operator==(const ComputedTimingFunction& aOther) const
   {
     return mType == aOther.mType &&
            (HasSpline() ?
             mTimingFunction == aOther.mTimingFunction :
             mStepsOrFrames == aOther.mStepsOrFrames);
   }
   bool operator!=(const ComputedTimingFunction& aOther) const

--- a/gfx/layers/ipc/LayerAnimationUtils.cpp
+++ b/gfx/layers/ipc/LayerAnimationUtils.cpp
@@ -28,18 +28,25 @@ AnimationUtils::TimingFunctionToComputed
       StepFunction sf = aTimingFunction.get_StepFunction();
       nsTimingFunction::Type type = sf.type() == 1 ?
         nsTimingFunction::Type::StepStart :
         nsTimingFunction::Type::StepEnd;
       ComputedTimingFunction result;
       result.Init(nsTimingFunction(type, sf.steps()));
       return Some(result);
     }
+    case TimingFunction::TFramesFunction: {
+      FramesFunction ff = aTimingFunction.get_FramesFunction();
+      ComputedTimingFunction result;
+      result.Init(nsTimingFunction(nsTimingFunction::Type::Frames,
+                                   ff.frames()));
+      return Some(result);
+    }
     default:
       MOZ_ASSERT_UNREACHABLE(
-        "Function must be null, bezier or step");
+        "Function must be null, bezier, step or frames");
       break;
   }
   return Nothing();
 }
 
 } // namespace layers
 } // namespace mozilla

--- a/gfx/layers/ipc/LayersMessages.ipdlh
+++ b/gfx/layers/ipc/LayersMessages.ipdlh
@@ -97,20 +97,25 @@ struct CubicBezierFunction {
 };
 
 struct StepFunction {
   int steps;
   // 1 = nsTimingFunction::StepStart, 2 = nsTimingFunction::StepEnd
   int type;
 };
 
+struct FramesFunction {
+  int frames;
+};
+
 union TimingFunction {
   null_t;
   CubicBezierFunction;
   StepFunction;
+  FramesFunction;
 };
 
 // Send the angle with units rather than sending all angles in radians
 // to avoid having floating point error introduced by unit switching.
 struct CSSAngle {
   float value;
   int unit; // an nsCSSUnit that is valid for angles
 };

--- a/layout/painting/nsDisplayList.cpp
+++ b/layout/painting/nsDisplayList.cpp
@@ -428,16 +428,20 @@ ToTimingFunction(const Maybe<ComputedTim
   }
 
   if (aCTF->HasSpline()) {
     const nsSMILKeySpline* spline = aCTF->GetFunction();
     return TimingFunction(CubicBezierFunction(spline->X1(), spline->Y1(),
                                               spline->X2(), spline->Y2()));
   }
 
+  if (aCTF->GetType() == nsTimingFunction::Type::Frames) {
+    return TimingFunction(FramesFunction(aCTF->GetFrames()));
+  }
+
   uint32_t type = aCTF->GetType() == nsTimingFunction::Type::StepStart ? 1 : 2;
   return TimingFunction(StepFunction(aCTF->GetSteps(), type));
 }
 
 static void
 SetAnimatable(nsCSSPropertyID aProperty,
               const AnimationValue& aAnimationValue,
               nsIFrame* aFrame,