Read compositor VSync information from platform, when possible

content/browser/renderer_host/render_widget_host_view_aura.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 "content/browser/renderer_host/render_widget_host_view_aura.h"
 
 #include "base/auto_reset.h"
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback_helpers.h"
@@ skipping 3186 matching lines @@
 void RenderWidgetHostViewAura::OnCompositingLockStateChanged(
     ui::Compositor* compositor) {
   // A compositor lock that is part of a resize lock timed out. We
   // should display a renderer frame.
   if (!compositor->IsLocked() && can_lock_compositor_ == YES_DID_LOCK) {
     can_lock_compositor_ = NO_PENDING_RENDERER_FRAME;
   }
 }
 
 void RenderWidgetHostViewAura::OnUpdateVSyncParameters(
-    ui::Compositor* compositor,
     base::TimeTicks timebase,
     base::TimeDelta interval) {
   if (IsShowing()) {
     if (IsDeadlineSchedulingEnabled()) {
       // The deadline scheduler has logic to stagger the draws of the
       // Renderer and Browser built-in, so send it an accurate timebase.
       host_->UpdateVSyncParameters(timebase, interval);
     } else if (!last_draw_ended_.is_null()) {
       // For the non-deadline scheduler, we send the Renderer an offset
       // vsync timebase to avoid its draws racing the Browser's draws.
@@ skipping 274 matching lines @@
     cursor_client->AddObserver(this);
     NotifyRendererOfCursorVisibilityState(cursor_client->IsCursorVisible());
   }
   if (current_surface_.get())
     UpdateExternalTexture();
   if (HasFocus()) {
     ui::InputMethod* input_method = GetInputMethod();
     if (input_method)
       input_method->SetFocusedTextInputClient(this);
   }
+
+  ui::Compositor* compositor = GetCompositor();
+  if (compositor)
+    compositor->vsync_manager()->AddObserver(this);
 }
 
 void RenderWidgetHostViewAura::RemovingFromRootWindow() {
   aura::client::CursorClient* cursor_client =
       aura::client::GetCursorClient(window_->GetRootWindow());
   if (cursor_client)
     cursor_client->RemoveObserver(this);
 
   DetachFromInputMethod();
 
   window_->GetDispatcher()->RemoveRootWindowObserver(this);
   host_->ParentChanged(0);
   ui::Compositor* compositor = GetCompositor();
   if (current_surface_.get()) {
     // We can't get notification for commits after this point, which would
     // guarantee that the compositor isn't using an old texture any more, so
     // instead we force the layer to stop using any external resources which
     // synchronizes with the compositor thread, and makes it safe to run the
     // callback.
     window_->layer()->SetShowPaintedContent();
   }
   RunOnCommitCallbacks();
   resize_lock_.reset();
   host_->WasResized();
-  if (compositor && compositor->HasObserver(this))
-    compositor->RemoveObserver(this);
+  if (compositor) {
+    if (compositor->HasObserver(this))
+      compositor->RemoveObserver(this);
+    compositor->vsync_manager()->RemoveObserver(this);
+  }
 }
 
 ui::Compositor* RenderWidgetHostViewAura::GetCompositor() const {
   aura::WindowEventDispatcher* dispatcher = window_->GetDispatcher();
   return dispatcher ? dispatcher->host()->compositor() : NULL;
 }
 
 void RenderWidgetHostViewAura::DetachFromInputMethod() {
   ui::InputMethod* input_method = GetInputMethod();
   if (input_method && input_method->GetTextInputClient() == this)
@@ skipping 18 matching lines @@
     RenderWidgetHost* widget) {
   return new RenderWidgetHostViewAura(widget);
 }
 
 // static
 void RenderWidgetHostViewPort::GetDefaultScreenInfo(WebScreenInfo* results) {
   GetScreenInfoForWindow(results, NULL);
 }
 
 }  // namespace content