cc: Make BackToBackBeginFrameSource a SyntheticBeginFrameSource.

cc/trees/single_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/single_thread_proxy.h"
 
 #include "base/auto_reset.h"
 #include "base/memory/ptr_util.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/trace_event/trace_event.h"
 #include "cc/animation/animation_events.h"
 #include "cc/debug/benchmark_instrumentation.h"
 #include "cc/debug/devtools_instrumentation.h"
 #include "cc/output/context_provider.h"
 #include "cc/output/output_surface.h"
 #include "cc/quads/draw_quad.h"
 #include "cc/scheduler/commit_earlyout_reason.h"
 #include "cc/scheduler/compositor_timing_history.h"
+#include "cc/scheduler/delay_based_time_source.h"
 #include "cc/scheduler/scheduler.h"
 #include "cc/trees/layer_tree_host.h"
 #include "cc/trees/layer_tree_host_common.h"
 #include "cc/trees/layer_tree_host_single_thread_client.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/scoped_abort_remaining_swap_promises.h"
 
 namespace cc {
 
 std::unique_ptr<Proxy> SingleThreadProxy::Create(
@@ skipping 43 matching lines @@
             scheduler_settings.using_synchronous_renderer_compositor,
             CompositorTimingHistory::BROWSER_UMA,
             layer_tree_host_->rendering_stats_instrumentation()));
 
     BeginFrameSource* frame_source = nullptr;
     if (!layer_tree_host_->settings().use_output_surface_begin_frame_source) {
       frame_source = external_begin_frame_source_.get();
       if (!scheduler_settings.throttle_frame_production) {
         // Unthrottled source takes precedence over external sources.
         unthrottled_begin_frame_source_.reset(new BackToBackBeginFrameSource(
-            task_runner_provider_->MainThreadTaskRunner()));
+            base::MakeUnique<DelayBasedTimeSource>(
+                task_runner_provider_->MainThreadTaskRunner())));
         frame_source = unthrottled_begin_frame_source_.get();
       }
       if (!frame_source) {
-        synthetic_begin_frame_source_.reset(new SyntheticBeginFrameSource(
-            task_runner_provider_->MainThreadTaskRunner(),
-            BeginFrameArgs::DefaultInterval()));
+        synthetic_begin_frame_source_.reset(new DelayBasedBeginFrameSource(
+            base::MakeUnique<DelayBasedTimeSource>(
+                task_runner_provider_->MainThreadTaskRunner())));
         frame_source = synthetic_begin_frame_source_.get();
       }
     }
 
     scheduler_on_impl_thread_ =
         Scheduler::Create(this, scheduler_settings, layer_tree_host_->id(),
                           task_runner_provider_->MainThreadTaskRunner(),
                           frame_source, std::move(compositor_timing_history));
   }
 
@@ skipping 386 matching lines @@
     // the output surface if already in BEGIN_IMPL_FRAME_STATE_IDLE.
     layer_tree_host_->DidLoseOutputSurface();
   }
   client_->DidAbortSwapBuffers();
   if (scheduler_on_impl_thread_)
     scheduler_on_impl_thread_->DidLoseOutputSurface();
 }
 
 void SingleThreadProxy::CommitVSyncParameters(base::TimeTicks timebase,
                                               base::TimeDelta interval) {
-  if (interval.is_zero()) {
-    // TODO(brianderson): We should not be receiving 0 intervals.
-    interval = BeginFrameArgs::DefaultInterval();
-  }
-
   if (synthetic_begin_frame_source_)
     synthetic_begin_frame_source_->OnUpdateVSyncParameters(timebase, interval);
 }
 
 void SingleThreadProxy::SetBeginFrameSource(BeginFrameSource* source) {
   DCHECK(layer_tree_host_->settings().single_thread_proxy_scheduler);
   // TODO(enne): this overrides any preexisting begin frame source.  Those
   // other sources will eventually be removed and this will be the only path.
   if (!layer_tree_host_->settings().use_output_surface_begin_frame_source)
     return;
@@ skipping 379 matching lines @@
 void SingleThreadProxy::DidFinishImplFrame() {
   layer_tree_host_impl_->DidFinishImplFrame();
 #if DCHECK_IS_ON()
   DCHECK(inside_impl_frame_)
       << "DidFinishImplFrame called while not inside an impl frame!";
   inside_impl_frame_ = false;
 #endif
 }
 
 }  // namespace cc