cc: Rename VSync to BeginFrame

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"
@@ skipping 40 matching lines @@
       in_composite_and_readback_(false),
       manage_tiles_pending_(false),
       weak_factory_on_impl_thread_(this),
       weak_factory_(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),
-      synchronously_disable_vsync_(
-          layer_tree_host->settings().synchronously_disable_vsync),
+      throttle_frame_production_(
+          layer_tree_host->settings().throttle_frame_production),
+      render_begin_frame_notification_enabled_(
+          layer_tree_host->settings().render_begin_frame_notification_enabled),
+      using_synchronous_renderer_compositor_(
+          layer_tree_host->settings().using_synchronous_renderer_compositor),
       vsync_client_(NULL),
       inside_draw_(false),
       defer_commits_(false),
       renew_tree_priority_on_impl_thread_pending_(false) {
   TRACE_EVENT0("cc", "ThreadProxy::ThreadProxy");
   DCHECK(IsMainThread());
   DCHECK(layer_tree_host_);
 }
 
 ThreadProxy::~ThreadProxy() {
@@ skipping 243 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) {
+void ThreadProxy::DidBeginFrame(base::TimeTicks frame_time) {
   DCHECK(IsImplThread());
-  TRACE_EVENT0("cc", "ThreadProxy::DidVSync");
+  TRACE_EVENT0("cc", "ThreadProxy::DidBeginFrame");
   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);
+  layer_tree_host_impl_->EnableBeginFrameNotification(!!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);
   layer_tree_host_impl_->UpdateBackgroundAnimateTicking(
       !scheduler_on_impl_thread_->WillDrawIfNeeded());
 }
@@ skipping 582 matching lines @@
     if (layer_tree_host_impl_->PrepareToDraw(&frame, readback_rect) ||
         forced_draw)
       draw_frame = true;
     else
       start_ready_animations = false;
   }
 
   if (draw_frame) {
     layer_tree_host_impl_->DrawLayers(
         &frame,
-        scheduler_on_impl_thread_->LastVSyncTime());
+        scheduler_on_impl_thread_->LastBeginFrameTime());
     result.did_draw = true;
   }
   layer_tree_host_impl_->DidDrawAllLayers(frame);
 
   layer_tree_host_impl_->UpdateAnimationState(start_ready_animations);
 
   // Check for a pending CompositeAndReadback.
   if (readback_request_on_impl_thread_) {
     readback_request_on_impl_thread_->success = false;
     if (draw_frame) {
@@ skipping 148 matching lines @@
     CompletionEvent* completion,
     InputHandlerClient* input_handler_client) {
   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 /
           layer_tree_host_->settings().refresh_rate);
   scoped_ptr<FrameRateController> frame_rate_controller;
-  if (render_vsync_enabled_) {
-    if (render_vsync_notification_enabled_) {
+  if (throttle_frame_production_) {
+    if (render_begin_frame_notification_enabled_) {
       frame_rate_controller.reset(
           new FrameRateController(VSyncTimeSource::Create(
               this,
-              synchronously_disable_vsync_ ?
+              using_synchronous_renderer_compositor_ ?
                   VSyncTimeSource::DISABLE_SYNCHRONOUSLY :
                   VSyncTimeSource::DISABLE_ON_NEXT_TICK)));
     } else {
       frame_rate_controller.reset(
           new FrameRateController(DelayBasedTimeSource::Create(
               display_refresh_interval, Proxy::ImplThread())));
     }
   } else {
     frame_rate_controller.reset(new FrameRateController(Proxy::ImplThread()));
   }
@@ skipping 70 matching lines @@
   if (layer_tree_host_impl_->resource_provider())
     layer_tree_host_impl_->resource_provider()->Finish();
   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);
+  layer_tree_host_impl_->EnableBeginFrameNotification(false);
   input_handler_client_on_impl_thread_.reset();
   scheduler_on_impl_thread_.reset();
   layer_tree_host_impl_.reset();
   weak_factory_on_impl_thread_.InvalidateWeakPtrs();
   vsync_client_ = NULL;
   completion->Signal();
 }
 
 size_t ThreadProxy::MaxPartialTextureUpdates() const {
   return ResourceUpdateController::MaxPartialTextureUpdates();
@@ skipping 141 matching lines @@
       base::Bind(&ThreadProxy::StartScrollbarAnimationOnImplThread,
                  impl_thread_weak_ptr_),
       delay);
 }
 
 void ThreadProxy::StartScrollbarAnimationOnImplThread() {
   layer_tree_host_impl_->StartScrollbarAnimation(
       layer_tree_host_impl_->CurrentFrameTimeTicks());
 }
 
-void ThreadProxy::DidReceiveLastInputEventForVSync(
+void ThreadProxy::DidReceiveLastInputEventForBeginFrame(
     base::TimeTicks frame_time) {
-  if (render_vsync_notification_enabled_) {
-    TRACE_EVENT0("cc", "ThreadProxy::DidReceiveLastInputEventForVSync");
-    DidVSync(frame_time);
+  if (render_begin_frame_notification_enabled_) {
+    TRACE_EVENT0("cc", "ThreadProxy::DidReceiveLastInputEventForBeginFrame");
+    DidBeginFrame(frame_time);
   }
 }
 
 void ThreadProxy::DidActivatePendingTree() {
   DCHECK(IsImplThread());
   TRACE_EVENT0("cc", "ThreadProxy::DidActivatePendingTreeOnImplThread");
 
   if (completion_event_for_commit_held_on_tree_activation_ &&
       !layer_tree_host_impl_->pending_tree()) {
     TRACE_EVENT_INSTANT0("cc", "ReleaseCommitbyActivation",
                          TRACE_EVENT_SCOPE_THREAD);
     DCHECK(layer_tree_host_impl_->settings().impl_side_painting);
     completion_event_for_commit_held_on_tree_activation_->Signal();
     completion_event_for_commit_held_on_tree_activation_ = NULL;
   }
 }
 
 }  // namespace cc