cc: Move scheduling logic out of OutputSurface

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 <deque>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/cancelable_callback.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/time/time.h"
 #include "cc/base/cc_export.h"
 #include "cc/output/begin_frame_args.h"
 #include "cc/scheduler/draw_swap_readback_result.h"
 #include "cc/scheduler/scheduler_settings.h"
 #include "cc/scheduler/scheduler_state_machine.h"
+#include "cc/scheduler/time_source.h"
 #include "cc/trees/layer_tree_host.h"
 
 namespace cc {
 
 class Thread;
 
 class SchedulerClient {
  public:
   virtual void SetNeedsBeginFrame(bool enable) = 0;
   virtual void WillBeginImplFrame(const BeginFrameArgs& args) = 0;
@@ skipping 10 matching lines @@
   virtual void DidAnticipatedDrawTimeChange(base::TimeTicks time) = 0;
   virtual base::TimeDelta DrawDurationEstimate() = 0;
   virtual base::TimeDelta BeginMainFrameToCommitDurationEstimate() = 0;
   virtual base::TimeDelta CommitToActivateDurationEstimate() = 0;
   virtual void DidBeginImplFrameDeadline() = 0;
 
  protected:
   virtual ~SchedulerClient() {}
 };
 
-class CC_EXPORT Scheduler {
+class CC_EXPORT Scheduler : public TimeSourceClient {
  public:
   static scoped_ptr<Scheduler> Create(
       SchedulerClient* client,
       const SchedulerSettings& scheduler_settings,
       int layer_tree_host_id,
-      const scoped_refptr<base::SequencedTaskRunner>& impl_task_runner) {
+      const scoped_refptr<base::SingleThreadTaskRunner>& impl_task_runner) {
     return make_scoped_ptr(new Scheduler(
         client, scheduler_settings, layer_tree_host_id, impl_task_runner));
   }
 
   virtual ~Scheduler();
 
+  // TimeSourceClient implementation
+  virtual void OnTimerTick() OVERRIDE;
+
+  void CommitVSyncParameters(base::TimeTicks timebase,
+                             base::TimeDelta interval);
+  void SetEstimatedParentDrawTime(base::TimeDelta draw_time);

[Sami, 2014/04/08 13:46:01]

Since DrawDurationEstimate() is already in SchedulerClient seems like 
SetEstimatedParentDrawTime would fit there too. WDYT?

[brianderson, 2014/04/09 02:52:05]

SetEstimatedParentDrawTime is likely to be an async message sent from the
Browser eventually, so I think it makes sense to keep it as a method into the
scheduler.

I was also hoping to move the other estimation logic into the scheduler
eventually, so it's all in one place; at which point, the estimated times won't
be a client call.

+
   void SetCanStart();
 
   void SetVisible(bool visible);
   void SetCanDraw(bool can_draw);
   void NotifyReadyToActivate();
 
   void SetNeedsCommit();
 
   // Like SetNeedsCommit(), but ensures a commit will definitely happen even if
   // we are not visible. Will eventually result in a forced draw internally.
@@ skipping 36 matching lines @@
 
   bool WillDrawIfNeeded() const;
 
   base::TimeTicks AnticipatedDrawTime() const;
 
   void NotifyBeginMainFrameStarted();
 
   base::TimeTicks LastBeginImplFrameTime();
 
   void BeginFrame(const BeginFrameArgs& args);
+  void PostBeginRetroFrame();
   void BeginRetroFrame();
   void BeginImplFrame(const BeginFrameArgs& args);
   void OnBeginImplFrameDeadline();
   void PollForAnticipatedDrawTriggers();
   void PollToAdvanceCommitState();
 
   scoped_ptr<base::Value> StateAsValue() const;
 
   bool IsInsideAction(SchedulerStateMachine::Action action) {
     return inside_action_ == action;
   }
 
   bool IsBeginMainFrameSent() const;
   void SetContinuousPainting(bool continuous_painting) {
     state_machine_.SetContinuousPainting(continuous_painting);
   }
 
  private:
-  Scheduler(SchedulerClient* client,
-            const SchedulerSettings& scheduler_settings,
-            int layer_tree_host_id,
-            const scoped_refptr<base::SequencedTaskRunner>& impl_task_runner);
+  Scheduler(
+      SchedulerClient* client,
+      const SchedulerSettings& scheduler_settings,
+      int layer_tree_host_id,
+      const scoped_refptr<base::SingleThreadTaskRunner>& impl_task_runner);
 
   base::TimeTicks AdjustedBeginImplFrameDeadline(
       const BeginFrameArgs& args,
       base::TimeDelta draw_duration_estimate) const;
   void ScheduleBeginImplFrameDeadline(base::TimeTicks deadline);
   void SetupNextBeginFrameIfNeeded();
   void PostBeginRetroFrameIfNeeded();
+  void SetupNextBeginFrameWhenVSyncEnabled(bool needs_begin_frame);
+  void SetupNextBeginFrameWhenVSyncDisabled(bool needs_begin_frame);
+  void SetupPollingMechanisms(bool needs_begin_frame);
   void ActivatePendingTree();
   void DrawAndSwapIfPossible();
   void DrawAndSwapForced();
   void DrawAndReadback();
   void ProcessScheduledActions();
 
   bool CanCommitAndActivateBeforeDeadline() const;
   void AdvanceCommitStateIfPossible();
 
   bool IsBeginMainFrameSentOrStarted() const;
 
   const SchedulerSettings settings_;
   SchedulerClient* client_;
   int layer_tree_host_id_;
-  scoped_refptr<base::SequencedTaskRunner> impl_task_runner_;
+  scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner_;
+
+  base::TimeDelta vsync_interval_;
+  base::TimeDelta estimated_parent_draw_time_;
 
   bool last_set_needs_begin_frame_;
   bool begin_retro_frame_posted_;
-
   std::deque<BeginFrameArgs> begin_retro_frame_args_;
   BeginFrameArgs begin_impl_frame_args_;
 
+  scoped_refptr<TimeSource> time_source_for_synthetic_begin_frames_;

[Sami, 2014/04/08 13:46:01]

Is there a way we could isolate the synthetic BeginFrame logic to an
inner/implementation-side class? Eventually we want to get rid of it, so it
would be convenient to have it all in one place. Also, it feels weird to have
Scheduler derive from TimeSourceClient since it's more of an implementation
detail than public scheduler interface.

[brianderson, 2014/04/09 02:52:05]

The goal was to get rid of it before, but I'm not sure if that's feasible
anymore since we'll need it for scheduling the Browser compositor.

To remove the inheritance, I could create an adaptor class or register a
callback rather than a client with the TimeSource.

[brianderson, 2014/04/10 23:45:58]

I ended up using an inner class like you originally suggested.

+  void SetupSyntheticBeginFrames();
+  BeginFrameArgs CreateSyntheticBeginFrameArgs(base::TimeTicks frame_time);
+
   base::Closure begin_retro_frame_closure_;
   base::Closure begin_impl_frame_deadline_closure_;
   base::Closure poll_for_draw_triggers_closure_;
   base::Closure advance_commit_state_closure_;
   base::CancelableClosure begin_impl_frame_deadline_task_;
   base::CancelableClosure poll_for_draw_triggers_task_;
   base::CancelableClosure advance_commit_state_task_;
 
   SchedulerStateMachine state_machine_;
   bool inside_process_scheduled_actions_;
   SchedulerStateMachine::Action inside_action_;
 
   base::WeakPtrFactory<Scheduler> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(Scheduler);
 };
 
 }  // namespace cc
 
 #endif  // CC_SCHEDULER_SCHEDULER_H_