cc: Rename VSync to BeginFrame

cc/trees/layer_tree_host_impl.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/layer_tree_host_impl.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/json/json_writer.h"
@@ skipping 350 matching lines @@
   // region that the given point hits.
   for (; layer_impl; layer_impl = layer_impl->parent()) {
     if (LayerTreeHostCommon::LayerHasTouchEventHandlersAt(device_viewport_point,
                                                           layer_impl))
       return true;
   }
 
   return false;
 }
 
-void LayerTreeHostImpl::DidReceiveLastInputEventForVSync(
+void LayerTreeHostImpl::DidReceiveLastInputEventForBeginFrame(
     base::TimeTicks frame_time) {
-  client_->DidReceiveLastInputEventForVSync(frame_time);
+  client_->DidReceiveLastInputEventForBeginFrame(frame_time);
 }
 
 void LayerTreeHostImpl::TrackDamageForAllSurfaces(
     LayerImpl* root_draw_layer,
     const LayerImplList& render_surface_layer_list) {
   // For now, we use damage tracking to compute a global scissor. To do this, we
   // must compute all damage tracking before drawing anything, so that we know
   // the root damage rect. The root damage rect is then used to scissor each
   // surface.
 
@@ skipping 622 matching lines @@
 
 void LayerTreeHostImpl::SetNeedsRedrawRect(gfx::Rect damage_rect) {
   client_->SetNeedsRedrawRectOnImplThread(damage_rect);
 }
 
 void LayerTreeHostImpl::OnVSyncParametersChanged(base::TimeTicks timebase,
                                                  base::TimeDelta interval) {
   client_->OnVSyncParametersChanged(timebase, interval);
 }
 
-void LayerTreeHostImpl::DidVSync(base::TimeTicks frame_time) {
-  client_->DidVSync(frame_time);
+void LayerTreeHostImpl::BeginFrame(base::TimeTicks frame_time) {
+  client_->DidBeginFrame(frame_time);
 }
 
 void LayerTreeHostImpl::OnSendFrameToParentCompositorAck(
     const CompositorFrameAck& ack) {
   if (!renderer_)
     return;
 
   // TODO(piman): We may need to do some validation on this ack before
   // processing it.
   renderer_->ReceiveCompositorFrameAck(ack);
@@ skipping 131 matching lines @@
 }
 
 bool LayerTreeHostImpl::SwapBuffers(const LayerTreeHostImpl::FrameData& frame) {
   if (frame.has_no_damage)
     return false;
   renderer_->SwapBuffers(frame.latency_info);
   active_tree_->ClearLatencyInfo();
   return true;
 }
 
-void LayerTreeHostImpl::EnableVSyncNotification(bool enable) {
+void LayerTreeHostImpl::EnableBeginFrameNotification(bool enable) {
   if (output_surface_)
-    output_surface_->EnableVSyncNotification(enable);
+    output_surface_->EnableBeginFrameNotification(enable);
 }
 
 gfx::Size LayerTreeHostImpl::DeviceViewportSize() const {
   return device_viewport_size();
 }
 
 gfx::SizeF LayerTreeHostImpl::VisibleViewportSize() const {
   gfx::SizeF dip_size =
       gfx::ScaleSize(DeviceViewportSize(), 1.f / device_scale_factor());
 
@@ skipping 981 matching lines @@
 }
 
 void LayerTreeHostImpl::SetDebugState(const LayerTreeDebugState& debug_state) {
   if (debug_state_.continuous_painting != debug_state.continuous_painting)
     paint_time_counter_->ClearHistory();
 
   debug_state_ = debug_state;
 }
 
 }  // namespace cc