src/cc/scheduler/scheduler.h

   1 // Copyright 2011 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef CC_SCHEDULER_SCHEDULER_H_
   6 #define CC_SCHEDULER_SCHEDULER_H_
   7
   8 #include <deque>
   9 #include <string>
  10
  11 #include "base/basictypes.h"
  12 #include "base/cancelable_callback.h"
  13 #include "base/memory/scoped_ptr.h"
  14 #include "base/time/time.h"
  15 #include "cc/base/cc_export.h"
  16 #include "cc/output/begin_frame_args.h"
  17 #include "cc/scheduler/delay_based_time_source.h"
  18 #include "cc/scheduler/draw_result.h"
  19 #include "cc/scheduler/scheduler_settings.h"
  20 #include "cc/scheduler/scheduler_state_machine.h"
  21
  22 namespace base {
  23 namespace debug {
  24 class ConvertableToTraceFormat;
  25 }
  26 class SingleThreadTaskRunner;
  27 }
  28
  29 namespace cc {
  30
  31 class SchedulerClient {
  32  public:
  33   virtual void SetNeedsBeginFrame(bool enable) = 0;
  34   virtual void WillBeginImplFrame(const BeginFrameArgs& args) = 0;
  35   virtual void ScheduledActionSendBeginMainFrame() = 0;
  36   virtual DrawResult ScheduledActionDrawAndSwapIfPossible() = 0;
  37   virtual DrawResult ScheduledActionDrawAndSwapForced() = 0;
  38   virtual void ScheduledActionAnimate() = 0;
  39   virtual void ScheduledActionCommit() = 0;
  40   virtual void ScheduledActionUpdateVisibleTiles() = 0;
  41   virtual void ScheduledActionActivateSyncTree() = 0;
  42   virtual void ScheduledActionBeginOutputSurfaceCreation() = 0;
  43   virtual void ScheduledActionManageTiles() = 0;
  44   virtual void DidAnticipatedDrawTimeChange(base::TimeTicks time) = 0;
  45   virtual base::TimeDelta DrawDurationEstimate() = 0;
  46   virtual base::TimeDelta BeginMainFrameToCommitDurationEstimate() = 0;
  47   virtual base::TimeDelta CommitToActivateDurationEstimate() = 0;
  48   virtual void DidBeginImplFrameDeadline() = 0;
  49
  50  protected:
  51   virtual ~SchedulerClient() {}
  52 };
  53
  54 class CC_EXPORT Scheduler {
  55  public:
  56   static scoped_ptr<Scheduler> Create(
  57       SchedulerClient* client,
  58       const SchedulerSettings& scheduler_settings,
  59       int layer_tree_host_id,
  60       const scoped_refptr<base::SingleThreadTaskRunner>& task_runner) {
  61     return make_scoped_ptr(new Scheduler(
  62         client, scheduler_settings, layer_tree_host_id, task_runner));
  63   }
  64
  65   virtual ~Scheduler();
  66
  67   const SchedulerSettings& settings() const { return settings_; }
  68
  69   void CommitVSyncParameters(base::TimeTicks timebase,
  70                              base::TimeDelta interval);
  71   void SetEstimatedParentDrawTime(base::TimeDelta draw_time);
  72
  73   void SetCanStart();
  74
  75   void SetVisible(bool visible);
  76   void SetCanDraw(bool can_draw);
  77   void NotifyReadyToActivate();
  78
  79   void SetNeedsCommit();
  80
  81   void SetNeedsRedraw();
  82
  83   void SetNeedsAnimate();
  84
  85   void SetNeedsManageTiles();
  86
  87   void SetMaxSwapsPending(int max);
  88   void DidSwapBuffers();
  89   void SetSwapUsedIncompleteTile(bool used_incomplete_tile);
  90   void DidSwapBuffersComplete();
  91
  92   void SetImplLatencyTakesPriority(bool impl_latency_takes_priority);
  93
  94   void NotifyReadyToCommit();
  95   void BeginMainFrameAborted(bool did_handle);
  96
  97   void DidManageTiles();
  98   void DidLoseOutputSurface();
  99   void DidCreateAndInitializeOutputSurface();
 100
 101   // Tests do not want to shut down until all possible BeginMainFrames have
 102   // occured to prevent flakiness.
 103   bool MainFrameForTestingWillHappen() const {
 104     return state_machine_.CommitPending() ||
 105            state_machine_.CouldSendBeginMainFrame();
 106   }
 107
 108   bool CommitPending() const { return state_machine_.CommitPending(); }
 109   bool RedrawPending() const { return state_machine_.RedrawPending(); }
 110   bool ManageTilesPending() const {
 111     return state_machine_.ManageTilesPending();
 112   }
 113   bool MainThreadIsInHighLatencyMode() const {
 114     return state_machine_.MainThreadIsInHighLatencyMode();
 115   }
 116   bool BeginImplFrameDeadlinePending() const {
 117     return !begin_impl_frame_deadline_task_.IsCancelled();
 118   }
 119
 120   bool WillDrawIfNeeded() const;
 121
 122   base::TimeTicks AnticipatedDrawTime() const;
 123
 124   void NotifyBeginMainFrameStarted();
 125
 126   base::TimeTicks LastBeginImplFrameTime();
 127
 128   void BeginFrame(const BeginFrameArgs& args);
 129
 130   scoped_refptr<base::debug::ConvertableToTraceFormat> AsValue() const;
 131   void AsValueInto(base::debug::TracedValue* state) const;
 132
 133   void SetContinuousPainting(bool continuous_painting) {
 134     state_machine_.SetContinuousPainting(continuous_painting);
 135   }
 136
 137  protected:
 138   class CC_EXPORT SyntheticBeginFrameSource : public TimeSourceClient {
 139    public:
 140     SyntheticBeginFrameSource(Scheduler* scheduler,
 141                               scoped_refptr<DelayBasedTimeSource> time_source);
 142     virtual ~SyntheticBeginFrameSource();
 143
 144     // Updates the phase and frequency of the timer.
 145     void CommitVSyncParameters(base::TimeTicks timebase,
 146                                base::TimeDelta interval);
 147
 148     // Activates future BeginFrames and, if activating, pushes the most
 149     // recently missed BeginFrame to the back of a retroactive queue.
 150     void SetNeedsBeginFrame(bool needs_begin_frame,
 151                             std::deque<BeginFrameArgs>* begin_retro_frame_args);
 152
 153     bool IsActive() const;
 154
 155     // TimeSourceClient implementation of OnTimerTick triggers a BeginFrame.
 156     virtual void OnTimerTick() OVERRIDE;
 157
 158     void AsValueInto(base::debug::TracedValue* dict) const;
 159
 160    private:
 161     BeginFrameArgs CreateSyntheticBeginFrameArgs(base::TimeTicks frame_time);
 162
 163     Scheduler* scheduler_;
 164     scoped_refptr<DelayBasedTimeSource> time_source_;
 165   };
 166
 167   Scheduler(SchedulerClient* client,
 168             const SchedulerSettings& scheduler_settings,
 169             int layer_tree_host_id,
 170             const scoped_refptr<base::SingleThreadTaskRunner>& task_runner);
 171
 172   virtual base::TimeTicks Now() const;
 173
 174   const SchedulerSettings settings_;
 175   SchedulerClient* client_;
 176   int layer_tree_host_id_;
 177   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 178
 179   base::TimeDelta vsync_interval_;
 180   base::TimeDelta estimated_parent_draw_time_;
 181
 182   bool last_set_needs_begin_frame_;
 183   bool begin_unthrottled_frame_posted_;
 184   bool begin_retro_frame_posted_;
 185   std::deque<BeginFrameArgs> begin_retro_frame_args_;
 186   BeginFrameArgs begin_impl_frame_args_;
 187
 188   scoped_ptr<SyntheticBeginFrameSource> synthetic_begin_frame_source_;
 189
 190   base::Closure begin_retro_frame_closure_;
 191   base::Closure begin_unthrottled_frame_closure_;
 192
 193   base::Closure begin_impl_frame_deadline_closure_;
 194   base::Closure poll_for_draw_triggers_closure_;
 195   base::Closure advance_commit_state_closure_;
 196   base::CancelableClosure begin_impl_frame_deadline_task_;
 197   base::CancelableClosure poll_for_draw_triggers_task_;
 198   base::CancelableClosure advance_commit_state_task_;
 199
 200   SchedulerStateMachine state_machine_;
 201   bool inside_process_scheduled_actions_;
 202   SchedulerStateMachine::Action inside_action_;
 203
 204   base::TimeDelta VSyncInterval() { return vsync_interval_; }
 205
 206  private:
 207   base::TimeTicks AdjustedBeginImplFrameDeadline(
 208       const BeginFrameArgs& args,
 209       base::TimeDelta draw_duration_estimate) const;
 210   void ScheduleBeginImplFrameDeadline(base::TimeTicks deadline);
 211   void SetupNextBeginFrameIfNeeded();
 212   void PostBeginRetroFrameIfNeeded();
 213   void SetupNextBeginFrameWhenVSyncThrottlingEnabled(bool needs_begin_frame);
 214   void SetupNextBeginFrameWhenVSyncThrottlingDisabled(bool needs_begin_frame);
 215   void SetupPollingMechanisms(bool needs_begin_frame);
 216   void DrawAndSwapIfPossible();
 217   void ProcessScheduledActions();
 218   bool CanCommitAndActivateBeforeDeadline() const;
 219   void AdvanceCommitStateIfPossible();
 220   bool IsBeginMainFrameSentOrStarted() const;
 221   void SetupSyntheticBeginFrames();
 222   void BeginRetroFrame();
 223   void BeginUnthrottledFrame();
 224   void BeginImplFrame(const BeginFrameArgs& args);
 225   void OnBeginImplFrameDeadline();
 226   void PollForAnticipatedDrawTriggers();
 227   void PollToAdvanceCommitState();
 228
 229   base::TimeDelta EstimatedParentDrawTime() {
 230     return estimated_parent_draw_time_;
 231   }
 232
 233   bool IsInsideAction(SchedulerStateMachine::Action action) {
 234     return inside_action_ == action;
 235   }
 236
 237   base::WeakPtrFactory<Scheduler> weak_factory_;
 238
 239   DISALLOW_COPY_AND_ASSIGN(Scheduler);
 240 };
 241
 242 }  // namespace cc
 243
 244 #endif  // CC_SCHEDULER_SCHEDULER_H_