cc: Emulate BeginFrame in OutputSurfaces that don't support it natively

cc/scheduler/scheduler.h

 // 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.
 
 #ifndef CC_SCHEDULER_SCHEDULER_H_
 #define CC_SCHEDULER_SCHEDULER_H_
 
 #include <string>
 
 #include "base/basictypes.h"
@@ skipping 15 matching lines @@
         did_swap(false) {}
   ScheduledActionDrawAndSwapResult(bool did_draw, bool did_swap)
       : did_draw(did_draw),
         did_swap(did_swap) {}
   bool did_draw;
   bool did_swap;
 };
 
 class SchedulerClient {
  public:
+  virtual void SetNeedsBeginFrameOnImplThread(bool enable) = 0;
   virtual void ScheduledActionSendBeginFrameToMainThread() = 0;
   virtual ScheduledActionDrawAndSwapResult
   ScheduledActionDrawAndSwapIfPossible() = 0;
   virtual ScheduledActionDrawAndSwapResult
   ScheduledActionDrawAndSwapForced() = 0;
   virtual void ScheduledActionCommit() = 0;
   virtual void ScheduledActionCheckForCompletedTileUploads() = 0;
   virtual void ScheduledActionActivatePendingTreeIfNeeded() = 0;
   virtual void ScheduledActionBeginOutputSurfaceCreation() = 0;
   virtual void ScheduledActionAcquireLayerTexturesForMainThread() = 0;
   virtual void DidAnticipatedDrawTimeChange(base::TimeTicks time) = 0;
 
  protected:
   virtual ~SchedulerClient() {}
 };
 
-class CC_EXPORT Scheduler : FrameRateControllerClient {
+class CC_EXPORT Scheduler {
  public:
   static scoped_ptr<Scheduler> Create(
       SchedulerClient* client,
-      scoped_ptr<FrameRateController> frame_rate_controller,
-      const SchedulerSettings& scheduler_settings) {
-    return make_scoped_ptr(new Scheduler(
-        client, frame_rate_controller.Pass(), scheduler_settings));
+      const SchedulerSettings& scheduler_settings,
+      Thread* thread) {
+    return make_scoped_ptr(new Scheduler(client,  scheduler_settings, thread));
   }
 
   virtual ~Scheduler();
 
   void SetCanStart();
 
   void SetVisible(bool visible);
   void SetCanDraw(bool can_draw);
   void SetHasPendingTree(bool has_pending_tree);
 
   void SetNeedsCommit();
 
   // Like SetNeedsCommit(), but ensures a commit will definitely happen even if
   // we are not visible.
   void SetNeedsForcedCommit();
 
   void SetNeedsRedraw();
 
   void SetMainThreadNeedsLayerTextures();
 
   // Like SetNeedsRedraw(), but ensures the draw will definitely happen even if
   // we are not visible.
   void SetNeedsForcedRedraw();
 
   void DidSwapUseIncompleteTile();
 
   void FinishCommit();
   void BeginFrameAbortedByMainThread();
 
-  void SetMaxFramesPending(int max);
-  int MaxFramesPending() const;
-  int NumFramesPendingForTesting() const;
-
-  void SetSwapBuffersCompleteSupported(bool supported);
-  void DidSwapBuffersComplete();
-
   void DidLoseOutputSurface();
   void DidCreateAndInitializeOutputSurface();
   bool HasInitializedOutputSurface() const {
     return state_machine_.HasInitializedOutputSurface();
   }
 
   bool CommitPending() const { return state_machine_.CommitPending(); }
   bool RedrawPending() const { return state_machine_.RedrawPending(); }
 
   bool WillDrawIfNeeded() const;
 
-  void SetTimebaseAndInterval(base::TimeTicks timebase,
-                              base::TimeDelta interval);
-
   base::TimeTicks AnticipatedDrawTime();
 
   base::TimeTicks LastBeginFrameOnImplThreadTime();
 
-  // FrameRateControllerClient implementation
-  virtual void BeginFrame(bool throttled) OVERRIDE;
+  void BeginFrame(base::TimeTicks frame_time);
+  void BeginFrameRetry();
 
   std::string StateAsStringForTesting() { return state_machine_.ToString(); }
 
  private:
   Scheduler(SchedulerClient* client,
-            scoped_ptr<FrameRateController> frame_rate_controller,
-            const SchedulerSettings& scheduler_settings);
+            const SchedulerSettings& scheduler_settings,
+            Thread* thread);
 
+  void DidSwapBuffers();
+  void SetNeedsBeginFrameIfNeeded();
   void ProcessScheduledActions();
 
   const SchedulerSettings settings_;
   SchedulerClient* client_;
-  scoped_ptr<FrameRateController> frame_rate_controller_;
+
+  base::WeakPtrFactory<Scheduler> weak_factory_;

[brianderson, 2013/06/01 04:30:29]

I'll probably move these into the StateMachine so it's aware of all state.

+  Thread* thread_;
+  bool last_set_needs_begin_frame_;
+  int pending_begin_frames_;

[Sami, 2013/06/03 17:30:33]

Does it ever make sense to have more than one of these?

[brianderson, 2013/06/03 18:51:40]

Currently, it does not make sense: one BeginFrame will correspond to one Impl
frame. The compositor should be fast enough that we don't need to pipeline the
Impl thread.

When we get to phase II and potentially pipeline commit and raster, I think
being able to have 2 BeginFrames will help.

+  base::TimeTicks last_begin_frame_time_;
+  base::TimeDelta interval_;
+
   SchedulerStateMachine state_machine_;
   bool inside_process_scheduled_actions_;
 
   DISALLOW_COPY_AND_ASSIGN(Scheduler);
 };
 
 }  // namespace cc
 
 #endif  // CC_SCHEDULER_SCHEDULER_H_