cc: Make BackToBackBeginFrameSource a SyntheticBeginFrameSource.

cc/scheduler/begin_frame_source.h

Index: cc/scheduler/begin_frame_source.h
diff --git a/cc/scheduler/begin_frame_source.h b/cc/scheduler/begin_frame_source.h
index 575ab06beb450555065d2801b7f388c3b4180bdc..8a3034cc702bdd4415105c9c902d31f704ad6d46 100644
--- a/cc/scheduler/begin_frame_source.h
+++ b/cc/scheduler/begin_frame_source.h
@@ -17,14 +17,6 @@
 #include "cc/output/begin_frame_args.h"
 #include "cc/scheduler/delay_based_time_source.h"
 
-#ifdef NDEBUG
-#define DEBUG_FRAMES(...)
-#else
-#define DEBUG_FRAMES(name, arg1_name, arg1_val, arg2_name, arg2_val)         \
-  TRACE_EVENT2(TRACE_DISABLED_BY_DEFAULT("cc.debug.scheduler.frames"), name, \
-               arg1_name, arg1_val, arg2_name, arg2_val);
-#endif
-
 namespace cc {
 
 // (Pure) Interface for observing BeginFrame messages from BeginFrameSource
@@ -122,67 +114,44 @@ class CC_EXPORT BeginFrameSource {
   virtual void RemoveObserver(BeginFrameObserver* obs) = 0;
 };
 
-// Simple base class which implements a BeginFrameSource.
-// Implementation classes should:
-//  - Implement the pure virtual (Set)NeedsBeginFrames methods from
-//    BeginFrameSource.
-//  - Use the CallOnBeginFrame method to call to the observer(s).
-class CC_EXPORT BeginFrameSourceBase : public BeginFrameSource {
+// A frame source which ticks itself independently.
+class CC_EXPORT SyntheticBeginFrameSource : public BeginFrameSource {
  public:
-  ~BeginFrameSourceBase() override;
-
-  // BeginFrameSource
-  void DidFinishFrame(BeginFrameObserver* obs,
-                      size_t remaining_frames) override {}
-  void AddObserver(BeginFrameObserver* obs) override;
-  void RemoveObserver(BeginFrameObserver* obs) override;
-
- protected:
-  BeginFrameSourceBase();
-
-  // These methods should be used by subclasses to make the call to the
-  // observers.
-  void CallOnBeginFrame(const BeginFrameArgs& args);
-  void SetBeginFrameSourcePaused(bool paused);
-
-  // This notifies that the subclass that it must turn on or off its mechnanism
-  // for producing BeginFrames.
-  virtual void OnNeedsBeginFramesChanged(bool needs_begin_frames) {}
-
-  bool needs_begin_frames() const { return !observers_.empty(); }
-
-  std::set<BeginFrameObserver*> observers_;
-  bool paused_;
+  ~SyntheticBeginFrameSource() override;
 
- private:
-  DISALLOW_COPY_AND_ASSIGN(BeginFrameSourceBase);
+  virtual void OnUpdateVSyncParameters(base::TimeTicks timebase,
+                                       base::TimeDelta interval) = 0;
+  // This overrides any past or future interval from updating vsync parameters.
+  virtual void SetAuthoritativeVSyncInterval(base::TimeDelta interval) = 0;
 };
 
 // A frame source which calls BeginFrame (at the next possible time) as soon as
 // remaining frames reaches zero.
-class CC_EXPORT BackToBackBeginFrameSource : public BeginFrameSourceBase {
+class CC_EXPORT BackToBackBeginFrameSource : public SyntheticBeginFrameSource,
+                                             public DelayBasedTimeSourceClient {
  public:
   explicit BackToBackBeginFrameSource(
-      base::SingleThreadTaskRunner* task_runner);
+      std::unique_ptr<DelayBasedTimeSource> time_source);
   ~BackToBackBeginFrameSource() override;
 
-  // BeginFrameSource
+  // BeginFrameSource implementation.
   void AddObserver(BeginFrameObserver* obs) override;
   void RemoveObserver(BeginFrameObserver* obs) override;
   void DidFinishFrame(BeginFrameObserver* obs,
                       size_t remaining_frames) override;
 
- protected:
-  virtual base::TimeTicks Now();  // Now overridable for testing
-
-  base::SingleThreadTaskRunner* task_runner_;
-  base::CancelableClosure begin_frame_task_;
-  std::set<BeginFrameObserver*> pending_begin_frame_observers_;
+  // SyntheticBeginFrameSource implementation.
+  void OnUpdateVSyncParameters(base::TimeTicks timebase,
+                               base::TimeDelta interval) override {}
+  void SetAuthoritativeVSyncInterval(base::TimeDelta interval) override {}
 
-  void PostPendingBeginFramesTask();
-  void SendPendingBeginFrames();
+  // DelayBasedTimeSourceClient implementation.
+  void OnTimerTick() override;
 
  private:
+  std::unique_ptr<DelayBasedTimeSource> time_source_;
+  std::unordered_set<BeginFrameObserver*> observers_;
+  std::unordered_set<BeginFrameObserver*> pending_begin_frame_observers_;
   base::WeakPtrFactory<BackToBackBeginFrameSource> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(BackToBackBeginFrameSource);
@@ -190,37 +159,37 @@ class CC_EXPORT BackToBackBeginFrameSource : public BeginFrameSourceBase {
 
 // A frame source which is locked to an external parameters provides from a
 // vsync source and generates BeginFrameArgs for it.
-class CC_EXPORT SyntheticBeginFrameSource : public BeginFrameSourceBase,
-                                            public DelayBasedTimeSourceClient {
+class CC_EXPORT DelayBasedBeginFrameSource : public SyntheticBeginFrameSource,
+                                             public DelayBasedTimeSourceClient {
  public:
-  explicit SyntheticBeginFrameSource(base::SingleThreadTaskRunner* task_runner,
-                                     base::TimeDelta initial_vsync_interval);
-  explicit SyntheticBeginFrameSource(
+  explicit DelayBasedBeginFrameSource(
       std::unique_ptr<DelayBasedTimeSource> time_source);
-  ~SyntheticBeginFrameSource() override;
-
-  void OnUpdateVSyncParameters(base::TimeTicks timebase,
-                               base::TimeDelta interval);
-  // This overrides any past or future interval from updating vsync parameters.
-  void SetAuthoritativeVSyncInterval(base::TimeDelta interval);
+  ~DelayBasedBeginFrameSource() override;
 
-  // BeginFrameSourceBase
+  // BeginFrameSource implementation.
   void AddObserver(BeginFrameObserver* obs) override;
-  void OnNeedsBeginFramesChanged(bool needs_begin_frames) override;
+  void RemoveObserver(BeginFrameObserver* obs) override;
+  void DidFinishFrame(BeginFrameObserver* obs,
+                      size_t remaining_frames) override {}
+
+  // SyntheticBeginFrameSource implementation.
+  void OnUpdateVSyncParameters(base::TimeTicks timebase,
+                               base::TimeDelta interval) override;
+  void SetAuthoritativeVSyncInterval(base::TimeDelta interval) override;
 
-  // DelayBasedTimeSourceClient
+  // DelayBasedTimeSourceClient implementation.
   void OnTimerTick() override;
 
- protected:
+ private:
   BeginFrameArgs CreateBeginFrameArgs(base::TimeTicks frame_time,
                                       BeginFrameArgs::BeginFrameArgsType type);
 
   std::unique_ptr<DelayBasedTimeSource> time_source_;
+  std::unordered_set<BeginFrameObserver*> observers_;
   base::TimeTicks last_timebase_;
   base::TimeDelta authoritative_interval_;
 
- private:
-  DISALLOW_COPY_AND_ASSIGN(SyntheticBeginFrameSource);
+  DISALLOW_COPY_AND_ASSIGN(DelayBasedBeginFrameSource);
 };
 
 }  // namespace cc