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/draw_swap_readback_result.h"
  18 #include "cc/scheduler/scheduler_settings.h"
  19 #include "cc/scheduler/scheduler_state_machine.h"
  20 #include "cc/trees/layer_tree_host.h"
  21
  22 namespace cc {
  23
  24 class Thread;
  25
  26 class SchedulerClient {
  27  public:
  28   virtual void SetNeedsBeginFrame(bool enable) = 0;
  29   virtual void WillBeginImplFrame(const BeginFrameArgs& args) = 0;
  30   virtual void ScheduledActionSendBeginMainFrame() = 0;
  31   virtual DrawSwapReadbackResult ScheduledActionDrawAndSwapIfPossible() = 0;
  32   virtual DrawSwapReadbackResult ScheduledActionDrawAndSwapForced() = 0;
  33   virtual DrawSwapReadbackResult ScheduledActionDrawAndReadback() = 0;
  34   virtual void ScheduledActionCommit() = 0;
  35   virtual void ScheduledActionUpdateVisibleTiles() = 0;
  36   virtual void ScheduledActionActivatePendingTree() = 0;
  37   virtual void ScheduledActionBeginOutputSurfaceCreation() = 0;
  38   virtual void ScheduledActionManageTiles() = 0;
  39   virtual void DidAnticipatedDrawTimeChange(base::TimeTicks time) = 0;
  40   virtual base::TimeDelta DrawDurationEstimate() = 0;
  41   virtual base::TimeDelta BeginMainFrameToCommitDurationEstimate() = 0;
  42   virtual base::TimeDelta CommitToActivateDurationEstimate() = 0;
  43   virtual void DidBeginImplFrameDeadline() = 0;
  44
  45  protected:
  46   virtual ~SchedulerClient() {}
  47 };
  48
  49 class CC_EXPORT Scheduler {
  50  public:
  51   static scoped_ptr<Scheduler> Create(
  52       SchedulerClient* client,
  53       const SchedulerSettings& scheduler_settings,
  54       int layer_tree_host_id,
  55       const scoped_refptr<base::SequencedTaskRunner>& impl_task_runner) {
  56     return make_scoped_ptr(new Scheduler(
  57         client, scheduler_settings, layer_tree_host_id, impl_task_runner));
  58   }
  59
  60   virtual ~Scheduler();
  61
  62   void SetCanStart();
  63
  64   void SetVisible(bool visible);
  65   void SetCanDraw(bool can_draw);
  66   void NotifyReadyToActivate();
  67
  68   void SetNeedsCommit();
  69
  70   // Like SetNeedsCommit(), but ensures a commit will definitely happen even if
  71   // we are not visible. Will eventually result in a forced draw internally.
  72   void SetNeedsForcedCommitForReadback();
  73
  74   void SetNeedsRedraw();
  75
  76   void SetNeedsManageTiles();
  77
  78   void SetSwapUsedIncompleteTile(bool used_incomplete_tile);
  79
  80   void SetSmoothnessTakesPriority(bool smoothness_takes_priority);
  81
  82   void NotifyReadyToCommit();
  83   void BeginMainFrameAborted(bool did_handle);
  84
  85   void DidManageTiles();
  86   void DidLoseOutputSurface();
  87   void DidCreateAndInitializeOutputSurface();
  88   bool HasInitializedOutputSurface() const {
  89     return state_machine_.HasInitializedOutputSurface();
  90   }
  91
  92   bool CommitPending() const { return state_machine_.CommitPending(); }
  93   bool RedrawPending() const { return state_machine_.RedrawPending(); }
  94   bool ManageTilesPending() const {
  95     return state_machine_.ManageTilesPending();
  96   }
  97   bool MainThreadIsInHighLatencyMode() const {
  98     return state_machine_.MainThreadIsInHighLatencyMode();
  99   }
 100   bool BeginImplFrameDeadlinePending() const {
 101     return !begin_impl_frame_deadline_task_.IsCancelled();
 102   }
 103
 104   bool WillDrawIfNeeded() const;
 105
 106   base::TimeTicks AnticipatedDrawTime() const;
 107
 108   void NotifyBeginMainFrameStarted();
 109
 110   base::TimeTicks LastBeginImplFrameTime();
 111
 112   void BeginFrame(const BeginFrameArgs& args);
 113   void BeginRetroFrame();
 114   void BeginImplFrame(const BeginFrameArgs& args);
 115   void OnBeginImplFrameDeadline();
 116   void PollForAnticipatedDrawTriggers();
 117   void PollToAdvanceCommitState();
 118
 119   scoped_ptr<base::Value> StateAsValue() const;
 120
 121   bool IsInsideAction(SchedulerStateMachine::Action action) {
 122     return inside_action_ == action;
 123   }
 124
 125   bool IsBeginMainFrameSent() const;
 126   void SetContinuousPainting(bool continuous_painting) {
 127     state_machine_.SetContinuousPainting(continuous_painting);
 128   }
 129
 130  private:
 131   Scheduler(SchedulerClient* client,
 132             const SchedulerSettings& scheduler_settings,
 133             int layer_tree_host_id,
 134             const scoped_refptr<base::SequencedTaskRunner>& impl_task_runner);
 135
 136   base::TimeTicks AdjustedBeginImplFrameDeadline(
 137       const BeginFrameArgs& args,
 138       base::TimeDelta draw_duration_estimate) const;
 139   void ScheduleBeginImplFrameDeadline(base::TimeTicks deadline);
 140   void SetupNextBeginFrameIfNeeded();
 141   void PostBeginRetroFrameIfNeeded();
 142   void ActivatePendingTree();
 143   void DrawAndSwapIfPossible();
 144   void DrawAndSwapForced();
 145   void DrawAndReadback();
 146   void ProcessScheduledActions();
 147
 148   bool CanCommitAndActivateBeforeDeadline() const;
 149   void AdvanceCommitStateIfPossible();
 150
 151   bool IsBeginMainFrameSentOrStarted() const;
 152
 153   const SchedulerSettings settings_;
 154   SchedulerClient* client_;
 155   int layer_tree_host_id_;
 156   scoped_refptr<base::SequencedTaskRunner> impl_task_runner_;
 157
 158   bool last_set_needs_begin_frame_;
 159   bool begin_retro_frame_posted_;
 160
 161   std::deque<BeginFrameArgs> begin_retro_frame_args_;
 162   BeginFrameArgs begin_impl_frame_args_;
 163
 164   base::Closure begin_retro_frame_closure_;
 165   base::Closure begin_impl_frame_deadline_closure_;
 166   base::Closure poll_for_draw_triggers_closure_;
 167   base::Closure advance_commit_state_closure_;
 168   base::CancelableClosure begin_impl_frame_deadline_task_;
 169   base::CancelableClosure poll_for_draw_triggers_task_;
 170   base::CancelableClosure advance_commit_state_task_;
 171
 172   SchedulerStateMachine state_machine_;
 173   bool inside_process_scheduled_actions_;
 174   SchedulerStateMachine::Action inside_action_;
 175
 176   base::WeakPtrFactory<Scheduler> weak_factory_;
 177
 178   DISALLOW_COPY_AND_ASSIGN(Scheduler);
 179 };
 180
 181 }  // namespace cc
 182
 183 #endif  // CC_SCHEDULER_SCHEDULER_H_