Changing animate to beginFrame and use struct rather than naked double to allow extension.

public/platform/WebFrameTime.h

 /*
  * Copyright (C) 2014 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 10 matching lines @@
  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef WebWaitableEvent_h
-#define WebWaitableEvent_h
+#ifndef WebFrameTime_h
+#define WebFrameTime_h
 
 #include "WebCommon.h"
 
 namespace blink {
 
-// Provides a thread synchronization that can be used to allow one thread to
-// wait until another thread to finish some work.
-class WebWaitableEvent {
-public:
-    virtual ~WebWaitableEvent() { }
+struct WebFrameTime {

[Sami, 2014/07/02 13:24:38]

Any reason not just to call this WebBeginFrameArgs and pass in the same data as
we get through BeginFrame? Right now this is almost exactly the same except we
have just one predicted frame time instead of an interval.

To be clear I'm not opposed to calling this WebFrameTime, but let's make it
compatible with BeginFrameArgs.

+    WebFrameTime(double lastFrameTime, double renderDeadline, double displayFrameTime, double predictedNextDisplayFrameTime)
+        : lastFrameTime(lastFrameTime)
+        , renderDeadline(renderDeadline)
+        , displayFrameTime(displayFrameTime)
+        , predictedNextDisplayFrameTime(predictedNextDisplayFrameTime)
+    { }
 
-    // Waits indefinitely for the event to be signaled.
-    virtual void wait() = 0;
+    // FIXME(mithro): Upgrade the time in CLOCK_MONOTONIC values to use a
+    // TimeTick like class rather than a bare double.
 
-    // Puts the event in the signaled state. Causing any thread blocked on Wait
-    // to be woken up. The event state is reset to non-signaled after
-    // a waiting thread has been released.
-    virtual void signal() = 0;
+    // Time in CLOCK_MONOTONIC that is the most recent vsync time.
+    double lastFrameTime;
+
+    // Time in CLOCK_MONOTONIC by which rendering must be finished by to not
+    // stall the pipeline.
+    double renderDeadline;
+
+    // Time in CLOCK_MONOTONIC that the frame will hit the glass of the display
+    // if rendered within the deadline. This time may be identical to
+    // lastFrameTime.
+    double displayFrameTime;
+
+    // Time in CLOCK_MONOTONIC that is the predicated next value for
+    // displayFrameTime. The next displayFrameTime should be this value or
+    // greater.
+    double predictedNextDisplayFrameTime;
 };
 
 } // namespace blink
 
-#endif // WebWaitableEvent_h
+#endif