cc: Send all begin frames using a PostTask.

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>
 
@@ skipping 118 matching lines @@
   ~SyntheticBeginFrameSource() override;
 
   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 SyntheticBeginFrameSource,
-                                             public DelayBasedTimeSourceClient {
+class CC_EXPORT BackToBackBeginFrameSource : public SyntheticBeginFrameSource {
  public:
   explicit BackToBackBeginFrameSource(
-      std::unique_ptr<DelayBasedTimeSource> time_source);
+      base::SingleThreadTaskRunner* task_runner);
+  // For testing.

[danakj, 2016/07/13 21:00:59]

Can we avoid reintroducing for-testing constructors?

+  BackToBackBeginFrameSource(base::SingleThreadTaskRunner* task_runner,
+                             base::TickClock* clock);
   ~BackToBackBeginFrameSource() 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) override {}
   void SetAuthoritativeVSyncInterval(base::TimeDelta interval) override {}
 
-  // DelayBasedTimeSourceClient implementation.
-  void OnTimerTick() override;
+ private:
+  void SendBeginFrame();
 
- private:
-  std::unique_ptr<DelayBasedTimeSource> time_source_;
+  base::SingleThreadTaskRunner* task_runner_;
+  base::TickClock* clock_;
+  base::CancelableClosure begin_frame_callback_;
   std::unordered_set<BeginFrameObserver*> observers_;
-  std::unordered_set<BeginFrameObserver*> pending_begin_frame_observers_;
+  std::unordered_set<BeginFrameObserver*> pending_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 DelayBasedBeginFrameSource : public SyntheticBeginFrameSource,
                                              public DelayBasedTimeSourceClient {
  public:
   explicit DelayBasedBeginFrameSource(
-      std::unique_ptr<DelayBasedTimeSource> time_source);
+      base::SingleThreadTaskRunner* task_runner);
+  // For testing.
+  DelayBasedBeginFrameSource(base::SingleThreadTaskRunner* task_runner,
+                             base::TickClock* clock);
   ~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) override;
   void SetAuthoritativeVSyncInterval(base::TimeDelta interval) override;
 
   // DelayBasedTimeSourceClient implementation.
   void OnTimerTick() override;
 
  private:
   BeginFrameArgs CreateBeginFrameArgs(base::TimeTicks frame_time,
                                       BeginFrameArgs::BeginFrameArgsType type);
+  void SendMissedBeginFrame();
 
   std::unique_ptr<DelayBasedTimeSource> time_source_;
+  base::SingleThreadTaskRunner* task_runner_;
+  base::CancelableClosure missed_frame_callback_;
   std::unordered_set<BeginFrameObserver*> observers_;
+  std::unordered_set<BeginFrameObserver*> missed_frame_observers_;
   base::TimeTicks last_timebase_;
   base::TimeDelta authoritative_interval_;
+  base::WeakPtrFactory<DelayBasedBeginFrameSource> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(DelayBasedBeginFrameSource);
 };
 
 }  // namespace cc
 
 #endif  // CC_SCHEDULER_BEGIN_FRAME_SOURCE_H_