Plumb timeToNextEffect through players and animation

Source/core/animation/TimedItem.h

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 56 matching lines @@
         virtual ~EventDelegate() { };
         virtual void onEventCondition(const TimedItem*, bool isFirstSample, Phase previousPhase, double previousIteration) = 0;
     };
 
     virtual ~TimedItem() { }
 
     Phase phase() const { return ensureCalculated().phase; }
     bool isCurrent() const { return ensureCalculated().isCurrent; }
     bool isInEffect() const { return ensureCalculated().isInEffect; }
     bool isInPlay() const { return ensureCalculated().isInPlay; }
+    double timeToEffectChange() const { return ensureCalculated().timeToEffectChange; }
 
     double startTime() const { return m_startTime; }
 
     double currentIteration() const { return ensureCalculated().currentIteration; }
     double activeDuration() const { return ensureCalculated().activeDuration; }
     double timeFraction() const { return ensureCalculated().timeFraction; }
     const Player* player() const { return m_player; }
 
     const Timing& specified() const { return m_specified; }
 
 protected:
     TimedItem(const Timing&, PassOwnPtr<EventDelegate> = nullptr);
 
     // When TimedItem receives a new inherited time via updateInheritedTime
     // it will (if necessary) recalculate timings and (if necessary) call
     // updateChildrenAndEffects.
     void updateInheritedTime(double inheritedTime) const;
     virtual void updateChildrenAndEffects(bool wasInEffect) const = 0;
     virtual double intrinsicIterationDuration() const { return 0; };
     virtual void willDetach() = 0;
+    virtual double calculateTimeToEffectChange(double inheritedTime, double activeTime, Phase) const = 0;

[Timothy Loh, 2013/10/18 06:01:27]

Can we make this private? I think protected-virtual is for virtual functions
where you want to be able to explicitly call your ancestors' functions, while
private-virtual disallows this.

[shans, 2013/10/21 00:37:57]

private-virtual disallows *any* access to the ancestor version of the function,
so it's impossible to e.g. define a single version at the top of an inheritance
subtree - every class needs to have its own implementation (or be abstract).

calculateTimeToEffectChange can probably be made private for now
(updateChildrenAndEffects and willDetach too), but we'll likely run into this
issue at some point in the future. In constract, we already can't make
intrinsicIterationDuration private because we have a default implementation in
TimedItem.

I think I'd rather keep all of these functions at the same level of access
(they're all part of the same process and will evolve together as we support the
rest of the model), but I don't feel particularly strongly about it.

 
 private:
     void attach(Player* player) { m_player = player; };
     void detach()
     {
         ASSERT(m_player);
         willDetach();
         m_player = 0;
     };
 
     // FIXME: m_parent and m_startTime are placeholders, they depend on timing groups.
     TimedItem* const m_parent;
     const double m_startTime;
     Player* m_player;
     Timing m_specified;
     OwnPtr<EventDelegate> m_eventDelegate;
 
     // FIXME: Should be versioned by monotonic value on player.
     mutable struct CalculatedTiming {
         double activeDuration;
         Phase phase;
         double currentIteration;
         double timeFraction;
         bool isCurrent;
         bool isInEffect;
         bool isInPlay;
+        double timeToEffectChange;
     } m_calculated;
     mutable bool m_isFirstSample;
 
     // FIXME: Should check the version and reinherit time if inconsistent.
     const CalculatedTiming& ensureCalculated() const { return m_calculated; }
 };
 
 } // namespace WebCore
 
 #endif