Read compositor VSync information from platform, when possible

ui/compositor/compositor.cc

 // Copyright (c) 2012 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 "ui/compositor/compositor.h"
 
 #include <algorithm>
 #include <deque>
 
 #include "base/bind.h"
@@ skipping 412 matching lines @@
 
 void Compositor::RemoveObserver(CompositorObserver* observer) {
   observer_list_.RemoveObserver(observer);
 }
 
 bool Compositor::HasObserver(CompositorObserver* observer) {
   return observer_list_.HasObserver(observer);
 }
 
 void Compositor::OnUpdateVSyncParameters(base::TimeTicks timebase,
-                                         base::TimeDelta interval) {
-  FOR_EACH_OBSERVER(CompositorObserver,
-                    observer_list_,
-                    OnUpdateVSyncParameters(this, timebase, interval));
+                                         base::TimeDelta interval,
+                                         bool interval_is_authoritative) {
+  if (interval_is_authoritative) {
+    authoritative_vsync_interval_ = interval;
+  } else {
+    if (authoritative_vsync_interval_ != base::TimeDelta())
+      interval = authoritative_vsync_interval_;
+  }

[brianderson, 2014/02/03 22:56:04]

The if/else above means that we always set overwrite interval to the last
authoritative interval, even if interval is a valid value.

Is that what you intended? Why?

[sheu, 2014/02/03 23:02:40]

Yes this is intentional.  The idea is that we can keep feeding the compositor
timebase values, but it will use the authoritative one instead if there is one. 
In the particular case I'm considering, the EGL context supplies us with the
timebase and an interval that may be inaccurate; so if the window manager can
supply a better interval, we'd rather use that.

[brianderson, 2014/02/04 01:39:51]

How is the interval inaccurate? Is there a way to test for inaccuracy?

+
+  if (!timebase.is_null()) {

[brianderson, 2014/02/03 22:56:04]

Is this check actually needed?

On Windows, we currently always set the timebase to 0, which means we'll never
tell the Renderers of an updated vsync interval.

Some background on why: Windows provides the vsync timebase in a high-res
timebase, but scheduling is done in a low-res timebase. To avoid
inconsistencies, we are using a timebase of 0 until scheduling is also high-res.

[sheu, 2014/02/03 23:02:40]

Would it make more sense to add to the ui::Compositor different entry points for
OnUpdateVSyncParameters() and, say, a SetAuthoritativeInterval() or some such? 
It seems a little odd to have this carried in the compositor, so I'm not sure
where the proper place would be to put it.

+    FOR_EACH_OBSERVER(CompositorObserver,
+                      observer_list_,
+                      OnUpdateVSyncParameters(this, timebase, interval));
+  }
 }
 
 void Compositor::Layout() {
   // We're sending damage that will be addressed during this composite
   // cycle, so we don't need to schedule another composite to address it.
   disable_schedule_composite_ = true;
   if (root_layer_)
     root_layer_->SendDamagedRects();
   disable_schedule_composite_ = false;
 }
@@ skipping 110 matching lines @@
     // CompositorObservers to be notified before starting another
     // draw cycle.
     ScheduleDraw();
   }
   FOR_EACH_OBSERVER(CompositorObserver,
                     observer_list_,
                     OnCompositingEnded(this));
 }
 
 }  // namespace ui