cc: Throttle swaps in Scheduler instead of OutputSurface

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 <limits>
 
 #include "base/basictypes.h"
@@ skipping 1455 matching lines @@
     active_tree()->BreakSwapPromises(SwapPromise::SWAP_FAILS);
     return false;
   }
   CompositorFrameMetadata metadata = MakeCompositorFrameMetadata();
   active_tree()->FinishSwapPromises(&metadata);
   renderer_->SwapBuffers(metadata);
   return true;
 }
 
 void LayerTreeHostImpl::SetNeedsBeginImplFrame(bool enable) {
-  if (output_surface_)
+  if (begin_frame_source_)
+    begin_frame_source_->SetActive(enable);
+  else if (output_surface_)
     output_surface_->SetNeedsBeginImplFrame(enable);
 }
 
 gfx::SizeF LayerTreeHostImpl::ComputeInnerViewportContainerSize() const {
   gfx::SizeF dip_size =
       gfx::ScaleSize(device_viewport_size_, 1.f / device_scale_factor());
 
   float top_offset =
       top_controls_manager_ ? top_controls_manager_->content_top_offset() : 0.f;
 
@@ skipping 28 matching lines @@
 float LayerTreeHostImpl::VerticalAdjust() const {
   if (!active_tree_->InnerViewportContainerLayer())
     return 0;
 
   return active_tree_->InnerViewportContainerLayer()->BoundsDelta().y();
 }
 
 void LayerTreeHostImpl::DidLoseOutputSurface() {
   if (resource_provider_)
     resource_provider_->DidLoseOutputSurface();
+  if (begin_frame_source_)
+    begin_frame_source_->SetActive(false);
   // TODO(jamesr): The renderer_ check is needed to make some of the
   // LayerTreeHostContextTest tests pass, but shouldn't be necessary (or
   // important) in production. We should adjust the test to not need this.
   if (renderer_)
     client_->DidLoseOutputSurfaceOnImplThread();
 #ifndef NDEBUG
   did_lose_called_ = true;
 #endif
 }
 
@@ skipping 293 matching lines @@
     return false;
 
   if (settings_.impl_side_painting) {
     CreateAndSetTileManager(
         resource_provider.get(),
         output_surface->context_provider().get(),
         GetRendererCapabilities().using_map_image,
         GetRendererCapabilities().allow_rasterize_on_demand);
   }
 
-  // Setup BeginImplFrameEmulation if it's not supported natively
-  if (!settings_.begin_impl_frame_scheduling_enabled) {
+  if (!settings_.throttle_frame_production) {
+    // Disable VSync
+    output_surface->SetThrottleFrameProduction(false);

[Sami, 2014/03/14 15:34:58]

Should this also disable the swap limit in the scheduler? Previously we had the
convention that a swap limit of 0 meant no limit, but I'm not sure if that works
anymore because of the DEFAULT_MAX_FRAMES_PENDING adjustment below.

+  } else if (!settings_.begin_impl_frame_scheduling_enabled) {
+    // Setup BeginImplFrameEmulation if it's not supported natively
     const base::TimeDelta display_refresh_interval =
       base::TimeDelta::FromMicroseconds(
           base::Time::kMicrosecondsPerSecond /
           settings_.refresh_rate);
 
-    output_surface->InitializeBeginImplFrameEmulation(
-        proxy_->ImplThreadTaskRunner(),
-        settings_.throttle_frame_production,
-        display_refresh_interval);
+    begin_frame_source_.reset(new BeginFrameSource(
+        display_refresh_interval, proxy_->ImplThreadTaskRunner()));
+
+    begin_frame_source_->SetClient(this);
+    begin_frame_source_->SetDeadlineAdjustment(
+        capabilities_.adjust_deadline_for_parent
+            ? BeginFrameArgs::DefaultDeadlineAdjustment()
+            : base::TimeDelta());
   }
 
   int max_frames_pending =
       output_surface->capabilities().max_frames_pending;
   if (max_frames_pending <= 0)
     max_frames_pending = OutputSurface::DEFAULT_MAX_FRAMES_PENDING;
-  output_surface->SetMaxFramesPending(max_frames_pending);
+  client_->SetMaxSwapsPending(max_frames_pending);
 
   resource_provider_ = resource_provider.Pass();
   output_surface_ = output_surface.Pass();
 
   client_->OnCanDrawStateChanged(CanDraw());
 
   return true;
 }
 
+bool LayerTreeHostImpl::CommitVSyncParameters(base::TimeTicks timebase,
+                                              base::TimeDelta interval) {
+  if (begin_frame_source_)
+    begin_frame_source_->SetTimebaseAndInterval(timebase, interval);
+}
+
 bool LayerTreeHostImpl::DeferredInitialize(
     scoped_refptr<ContextProvider> offscreen_context_provider) {
   DCHECK(output_surface_->capabilities().deferred_gl_initialization);
   DCHECK(settings_.impl_side_painting);
   DCHECK(output_surface_->context_provider());
 
   ReleaseTreeResources();
   renderer_.reset();
 
   bool resource_provider_success = resource_provider_->InitializeGL();
@@ skipping 1143 matching lines @@
   swap_promise_monitor_.erase(monitor);
 }
 
 void LayerTreeHostImpl::NotifySwapPromiseMonitorsOfSetNeedsRedraw() {
   std::set<SwapPromiseMonitor*>::iterator it = swap_promise_monitor_.begin();
   for (; it != swap_promise_monitor_.end(); it++)
     (*it)->OnSetNeedsRedrawOnImpl();
 }
 
 }  // namespace cc