cc: Make BackToBackBeginFrameSource a SyntheticBeginFrameSource.

cc/scheduler/begin_frame_source.h

 // Copyright 2014 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.
 
 #ifndef CC_SCHEDULER_BEGIN_FRAME_SOURCE_H_
 #define CC_SCHEDULER_BEGIN_FRAME_SOURCE_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <set>
 #include <string>
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/trace_event/trace_event.h"
 #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
 // objects.
 class CC_EXPORT BeginFrameObserver {
  public:
   virtual ~BeginFrameObserver() {}
 
   // The |args| given to OnBeginFrame is guaranteed to have
   // |args|.IsValid()==true and have |args|.frame_time
@@ skipping 77 matching lines @@
   // is pending at a time.
   virtual void DidFinishFrame(BeginFrameObserver* obs,
                               size_t remaining_frames) = 0;
 
   // Add/Remove an observer from the source. When no observers are added the BFS
   // should shut down its timers, disable vsync, etc.
   virtual void AddObserver(BeginFrameObserver* obs) = 0;
   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;
+  ~SyntheticBeginFrameSource() 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_;
-
- 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
+  // SyntheticBeginFrameSource implementation.
+  void OnUpdateVSyncParameters(base::TimeTicks timebase,
+                               base::TimeDelta interval) override {}
+  void SetAuthoritativeVSyncInterval(base::TimeDelta interval) override {}
 
-  base::SingleThreadTaskRunner* task_runner_;
-  base::CancelableClosure begin_frame_task_;
-  std::set<BeginFrameObserver*> pending_begin_frame_observers_;
-
-  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);
 };
 
 // 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;
+  ~DelayBasedBeginFrameSource() override;
 
+  // BeginFrameSource implementation.
+  void AddObserver(BeginFrameObserver* obs) 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);
-  // This overrides any past or future interval from updating vsync parameters.
-  void SetAuthoritativeVSyncInterval(base::TimeDelta interval);
+                               base::TimeDelta interval) override;
+  void SetAuthoritativeVSyncInterval(base::TimeDelta interval) override;
 
-  // BeginFrameSourceBase
-  void AddObserver(BeginFrameObserver* obs) override;
-  void OnNeedsBeginFramesChanged(bool needs_begin_frames) 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
 
 #endif  // CC_SCHEDULER_BEGIN_FRAME_SOURCE_H_