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 176 matching lines @@
       posted_swaps_(new PostedSwapQueue()),
       device_scale_factor_(0.0f),
       last_started_frame_(0),
       last_ended_frame_(0),
       next_draw_is_resize_(false),
       disable_schedule_composite_(false),
       compositor_lock_(NULL),
       defer_draw_scheduling_(false),
       waiting_on_compositing_end_(false),
       draw_on_compositing_end_(false),
       schedule_draw_factory_(this) {

[oshima, 2014/01/29 19:00:35]

initialize authoritative_vsync_interval_

[sheu, 2014/01/29 22:43:36]

The default constructor initializes to a 0 internal value already.  Should this
still be necessary?

[oshima, 2014/01/29 22:45:32]

Ah, it's TimeDelta. nvm.

   DCHECK(g_compositor_initialized)
       << "Compositor::Initialize must be called before creating a Compositor.";
 
   root_web_layer_ = cc::Layer::Create();
   root_web_layer_->SetAnchorPoint(gfx::PointF(0.f, 0.f));
 
   CommandLine* command_line = CommandLine::ForCurrentProcess();
 
   cc::LayerTreeSettings settings;
   settings.refresh_rate =
@@ skipping 231 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_;
+  }
+
+  if (!timebase.is_null()) {
+    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