Use input events to improve vsync scheduling

cc/vsync_time_source.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/vsync_time_source.h"
 
 namespace cc {
 
 scoped_refptr<VSyncTimeSource> VSyncTimeSource::create(
     VSyncProvider* vsync_provider) {
   return make_scoped_refptr(new VSyncTimeSource(vsync_provider));
 }
 
 VSyncTimeSource::VSyncTimeSource(VSyncProvider* vsync_provider)
   : vsync_provider_(vsync_provider)
   , client_(0)
   , active_(false)
-  , notification_requested_(false) {}
+  , notification_requested_(false)
+  , did_synthesize_last_vsync_(false) {}
 
 VSyncTimeSource::~VSyncTimeSource() {}
 
 void VSyncTimeSource::setClient(TimeSourceClient* client) {
   client_ = client;
 }
 
 void VSyncTimeSource::setActive(bool active) {
   if (active_ == active)
     return;
@@ skipping 18 matching lines @@
 base::TimeTicks VSyncTimeSource::nextTickTime() {
   return active() ? last_tick_time_ + interval_ : base::TimeTicks();
 }
 
 void VSyncTimeSource::setTimebaseAndInterval(base::TimeTicks,
                                              base::TimeDelta interval) {
   interval_ = interval;
 }
 
 void VSyncTimeSource::DidVSync(base::TimeTicks frame_time) {
+  // We can use input events to synthesize vsync events, but we must be careful

[jamesr, 2013/01/16 04:13:26]

this logic seems really fishy to me.  I think you need to decide if the smarts
for vsync are going to be in the renderer or not and stick to that - we
shouldn't have one process second-guessing the other

[Sami, 2013/01/16 10:49:15]

I suppose you're right. Doing this in the browser seems better because it has
global visibility across all renderers and all the funky input event queuing
happens there anyway. I'll give this another go to move the logic there.

+  // to avoid ticking multiple times during a single frame. To do that we keep
+  // track of when the last synthesized vsync happened and ignore any real vsync
+  // notifications during the first half of the same frame.
+  double intervals_since_last_tick =
+      (frame_time - last_tick_time_).InSecondsF() / interval_.InSecondsF();
   last_tick_time_ = frame_time;
+  if (did_synthesize_last_vsync_) {
+    did_synthesize_last_vsync_ = false;
+    if (intervals_since_last_tick < .5)
+        return;

[jamesr, 2013/01/16 04:13:26]

we should trace this early-out

+  }
   if (!active_) {
     if (notification_requested_) {
       notification_requested_ = false;
       vsync_provider_->RequestVSyncNotification(NULL);
     }
     return;
   }
   if (client_)
     client_->onTimerTick();
 }
 
+base::TimeTicks VSyncTimeSource::Now() const
+{
+  return base::TimeTicks::Now();
+}
+
+void VSyncTimeSource::DidReceiveLastInputEventForVSync() {
+  if (!active_ || interval_ == base::TimeDelta())
+    return;
+
+  // Since input events currently aren't timestamped, we need to estimate the
+  // current frame time.
+  double intervals_since_last_tick =
+      (Now() - last_tick_time_).InSecondsF() / interval_.InSecondsF();
+  last_tick_time_ += interval_ * std::max(1., floor(intervals_since_last_tick));
+  did_synthesize_last_vsync_ = true;
+
+  if (client_)
+    client_->onTimerTick();
+}
+
 }  // namespace cc