cc: Emulate BeginFrame in OutputSurfaces that don't support it natively

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 1020 matching lines @@
   }
 
   if (needs_commit)
     client_->SetNeedsCommitOnImplThread();
 }
 
 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::BeginFrame(base::TimeTicks frame_time) {
   client_->BeginFrameOnImplThread(frame_time);
 }
 
 void LayerTreeHostImpl::OnSendFrameToParentCompositorAck(
     const CompositorFrameAck& ack) {
   if (!renderer_)
     return;
 
   // TODO(piman): We may need to do some validation on this ack before
@@ skipping 404 matching lines @@
                                           settings_.num_raster_threads,
                                           settings_.use_color_estimator,
                                           rendering_stats_instrumentation_,
                                           using_map_image);
       UpdateTileManagerMemoryPolicy(ActualManagedMemoryPolicy());
     }
 
     resource_provider_ = resource_provider.Pass();
   }
 
+  // Setup BeginFrameEmulation if it's not supported natively
+  if (!settings_.begin_frame_scheduling_enabled) {
+    const base::TimeDelta display_refresh_interval =
+      base::TimeDelta::FromMicroseconds(
+          base::Time::kMicrosecondsPerSecond /
+          settings_.refresh_rate);
+
+    int max_frames_pending =
+        output_surface->capabilities().max_frames_pending;
+    if (max_frames_pending <= 0)
+      max_frames_pending = FrameRateController::DEFAULT_MAX_FRAMES_PENDING;
+    if (output_surface->capabilities().has_parent_compositor)
+      max_frames_pending = 1;
+
+    output_surface->InitializeBeginFrameEmulation(
+        proxy_->ImplThread(),
+        settings_.throttle_frame_production,
+        display_refresh_interval,
+        max_frames_pending,
+        GetRendererCapabilities().using_swap_complete_callback);
+  }
+
   output_surface_ = output_surface.Pass();
 
   if (!visible_)
     renderer_->SetVisible(visible_);
 
   client_->OnCanDrawStateChanged(CanDraw());
 
   // See note in LayerTreeImpl::UpdateDrawProperties.  Renderer needs
   // to be initialized to get max texture size.
   active_tree_->set_needs_update_draw_properties();
@@ skipping 762 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