cc: Hook vsync time source to output surface

cc/trees/thread_proxy.cc

 // Copyright 2011 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/trees/thread_proxy.h"
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "cc/base/thread.h"
 #include "cc/input/input_handler.h"
 #include "cc/output/context_provider.h"
 #include "cc/output/output_surface.h"
 #include "cc/quads/draw_quad.h"
 #include "cc/resources/prioritized_resource_manager.h"
 #include "cc/scheduler/delay_based_time_source.h"
 #include "cc/scheduler/frame_rate_controller.h"
 #include "cc/scheduler/scheduler.h"
+#include "cc/scheduler/vsync_time_source.h"
 #include "cc/trees/layer_tree_host.h"
 #include "cc/trees/layer_tree_impl.h"
 
 namespace {
 
 // Measured in seconds.
 const double kContextRecreationTickRate = 0.03;
 
 // Measured in seconds.
 const double kSmoothnessTakesPriorityExpirationDelay = 0.25;
@@ skipping 23 matching lines @@
       manage_tiles_pending_(false),
       weak_factory_on_impl_thread_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       begin_frame_completion_event_on_impl_thread_(NULL),
       readback_request_on_impl_thread_(NULL),
       commit_completion_event_on_impl_thread_(NULL),
       completion_event_for_commit_held_on_tree_activation_(NULL),
       texture_acquisition_completion_event_on_impl_thread_(NULL),
       next_frame_is_newly_committed_frame_on_impl_thread_(false),
       render_vsync_enabled_(layer_tree_host->settings().render_vsync_enabled),
+      render_vsync_notification_enabled_(
+          layer_tree_host->settings().render_vsync_notification_enabled),
+      vsync_client_(NULL),
       inside_draw_(false),
       defer_commits_(false),
       renew_tree_priority_on_impl_thread_pending_(false) {
   TRACE_EVENT0("cc", "ThreadProxy::ThreadProxy");
   DCHECK(IsMainThread());
 }
 
 ThreadProxy::~ThreadProxy() {
   TRACE_EVENT0("cc", "ThreadProxy::~ThreadProxy");
   DCHECK(IsMainThread());
@@ skipping 271 matching lines @@
   DCHECK(IsImplThread());
   TRACE_EVENT2("cc",
                "ThreadProxy::OnVSyncParametersChanged",
                "timebase",
                (timebase - base::TimeTicks()).InMilliseconds(),
                "interval",
                interval.InMilliseconds());
   scheduler_on_impl_thread_->SetTimebaseAndInterval(timebase, interval);
 }
 
+void ThreadProxy::DidVSync(base::TimeTicks frame_time) {
+  DCHECK(IsImplThread());
+  TRACE_EVENT0("cc", "ThreadProxy::DidVSync");
+  if (vsync_client_)
+    vsync_client_->DidVSync(frame_time);
+}
+
+void ThreadProxy::RequestVSyncNotification(VSyncClient* client) {
+  DCHECK(IsImplThread());
+  TRACE_EVENT1(
+      "cc", "ThreadProxy::RequestVSyncNotification", "enable", !!client);
+  vsync_client_ = client;
+  layer_tree_host_impl_->EnableVSyncNotification(client);
+}
+
 void ThreadProxy::OnCanDrawStateChanged(bool can_draw) {
   DCHECK(IsImplThread());
   TRACE_EVENT1(
       "cc", "ThreadProxy::OnCanDrawStateChanged", "can_draw", can_draw);
   scheduler_on_impl_thread_->SetCanDraw(can_draw);
 }
 
 void ThreadProxy::OnHasPendingTreeStateChanged(bool has_pending_tree) {
   DCHECK(IsImplThread());
   TRACE_EVENT1("cc",
@@ skipping 695 matching lines @@
 void ThreadProxy::InitializeImplOnImplThread(CompletionEvent* completion,
                                              InputHandler* handler) {
   TRACE_EVENT0("cc", "ThreadProxy::InitializeImplOnImplThread");
   DCHECK(IsImplThread());
   layer_tree_host_impl_ = layer_tree_host_->CreateLayerTreeHostImpl(this);
   const base::TimeDelta display_refresh_interval =
       base::TimeDelta::FromMicroseconds(base::Time::kMicrosecondsPerSecond /
                                         60);
   scoped_ptr<FrameRateController> frame_rate_controller;
   if (render_vsync_enabled_) {
-    frame_rate_controller.reset(
-        new FrameRateController(DelayBasedTimeSource::Create(
-            display_refresh_interval, Proxy::ImplThread())));
+    if (render_vsync_notification_enabled_) {
+      frame_rate_controller.reset(
+          new FrameRateController(VSyncTimeSource::Create(this)));
+    } else {
+      frame_rate_controller.reset(
+          new FrameRateController(DelayBasedTimeSource::Create(
+              display_refresh_interval, Proxy::ImplThread())));
+    }
   } else {
     frame_rate_controller.reset(new FrameRateController(Proxy::ImplThread()));
   }
   SchedulerSettings scheduler_settings;
   scheduler_settings.impl_side_painting =
       layer_tree_host_->settings().impl_side_painting;
   scheduler_on_impl_thread_ = Scheduler::Create(this,
                                                 frame_rate_controller.Pass(),
                                                 scheduler_settings);
   scheduler_on_impl_thread_->SetVisible(layer_tree_host_impl_->visible());
@@ skipping 38 matching lines @@
   }
 
   completion->Signal();
 }
 
 void ThreadProxy::LayerTreeHostClosedOnImplThread(CompletionEvent* completion) {
   TRACE_EVENT0("cc", "ThreadProxy::LayerTreeHostClosedOnImplThread");
   DCHECK(IsImplThread());
   layer_tree_host_->DeleteContentsTexturesOnImplThread(
       layer_tree_host_impl_->resource_provider());
+  layer_tree_host_impl_->EnableVSyncNotification(false);
   input_handler_on_impl_thread_.reset();
   layer_tree_host_impl_.reset();
   scheduler_on_impl_thread_.reset();
   weak_factory_on_impl_thread_.InvalidateWeakPtrs();
+  vsync_client_ = NULL;
   completion->Signal();
 }
 
 void ThreadProxy::SetFullRootLayerDamageOnImplThread() {
   DCHECK(IsImplThread());
   layer_tree_host_impl_->SetFullRootLayerDamage();
 }
 
 size_t ThreadProxy::MaxPartialTextureUpdates() const {
   return ResourceUpdateController::MaxPartialTextureUpdates();
@@ skipping 168 matching lines @@
       base::Bind(&ThreadProxy::StartScrollbarAnimationOnImplThread,
                  impl_thread_weak_ptr_),
       delay);
 }
 
 void ThreadProxy::StartScrollbarAnimationOnImplThread() {
   layer_tree_host_impl_->StartScrollbarAnimation(base::TimeTicks::Now());
 }
 
 }  // namespace cc