anchor.diff:          painter: new _CircularProgressIndicatorPainter(
             valueColor: _getValueColor(context),
             value: value,
  -          animationValue: animationValue
  +          headValue: headValue,
  +          tailValue: tailValue,
  +          stepValue: stepValue,
  +          rotationValue: rotationValue
           )
         )
       );
     }
   }
  +// TODO(jestelle) This should probably go somewhere else?  And maybe be more
  +// general?
  +class RepeatingCurveTween extends Animatable<double> {
  +  RepeatingCurveTween({ this.curve, this.repeats });
  +
  +  Curve curve;
  +  int repeats;
  +
  +  double evaluate(Animation<double> animation) {
  +    double t = animation.value;
  +    t *= repeats;
  +    t -= t.truncateToDouble();
  +    if (t == 0.0 || t == 1.0) {
  +      assert(curve.transform(t).round() == t);
  +      return t;
  +    }
  +    return curve.transform(t);
  +  }
  +}
  +
  +// TODO(jestelle) This should probably go somewhere else?  And maybe be more
  +// general?  Or maybe the IntTween should actually work this way?
  +class StepTween extends Tween<int> {
  +  StepTween({ int begin, int end }) : super(begin: begin, end: end);
  +
  +  // The inherited lerp() function doesn't work with ints because it multiplies
  +  // the begin and end types by a double, and int * double returns a double.
  +  int lerp(double t) => (begin + (end - begin) * t).floor();
  +}
  +
  +// Tweens used by circular progress indicator
  +final RepeatingCurveTween _kStrokeHeadTween =
  +    new RepeatingCurveTween(
  +        curve:new Interval(0.0, 0.5, curve: Curves.fastOutSlowIn),
  +        repeats:5);
  +
  +final RepeatingCurveTween _kStrokeTailTween =
  +    new RepeatingCurveTween(
  +        curve:new Interval(0.5, 1.0, curve: Curves.fastOutSlowIn),
  +        repeats:5);
  +
  +final StepTween _kStepTween = new StepTween(begin:0, end:5);
  +
  +final RepeatingCurveTween _kRotationTween =
  +    new RepeatingCurveTween(curve:Curves.linear, repeats:5);
  +
  +class _CircularProgressIndicatorState extends State<CircularProgressIndicator> {
  +  Animation<double> _animation;
  +  AnimationController _controller;
  +
  +  void initState() {
  +    super.initState();
  +    _controller = new AnimationController(
  +      duration: const Duration(milliseconds: 6666)
  +    )..repeat();
  +    _animation = new CurvedAnimation(parent: _controller, curve: Curves.linear);
  +  }
  +
  +  Widget build(BuildContext context) {
  +    if (config.value != null)
  +      return config._buildIndicator(context, 0.0, 0.0, 0, 0.0);
  +
  +    return new AnimatedBuilder(
  +      animation: _animation,
  +      builder: (BuildContext context, Widget child) {
  +        return config._buildIndicator(context,
  +            _kStrokeHeadTween.evaluate(_animation),
  +            _kStrokeTailTween.evaluate(_animation),
  +            _kStepTween.evaluate(_animation),
  +            _kRotationTween.evaluate(_animation));
  +      }
  +    );
  +  }
  +}
  
positive.code:     double value
    }) : super(key: key, value: value);
  
    Widget _buildIndicator(BuildContext context, double animationValue) {
      return new Container(
        constraints: new BoxConstraints(
          minWidth: _kMinCircularProgressIndicatorSize,
  
negative.code:   void paint(Canvas canvas, Size size) {
      Paint paint = new Paint()
        ..color = backgroundColor
        ..style = ui.PaintingStyle.fill;
      canvas.drawRect(Point.origin & size, paint);
  
      paint.color = valueColor;
  