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 <string>
   9
  10 #include "base/basictypes.h"
  11 #include "base/cancelable_callback.h"
  12 #include "base/memory/scoped_ptr.h"
  13 #include "base/time/time.h"
  14 #include "cc/base/cc_export.h"
  15 #include "cc/output/begin_frame_args.h"
  16 #include "cc/scheduler/draw_swap_readback_result.h"
  17 #include "cc/scheduler/scheduler_settings.h"
  18 #include "cc/scheduler/scheduler_state_machine.h"
  19 #include "cc/trees/layer_tree_host.h"
  20
  21 namespace cc {
  22
  23 class Thread;
  24
  25 class SchedulerClient {
  26  public:
  27   virtual void SetNeedsBeginImplFrame(bool enable) = 0;
  28   virtual void ScheduledActionSendBeginMainFrame() = 0;
  29   virtual DrawSwapReadbackResult ScheduledActionDrawAndSwapIfPossible() = 0;
  30   virtual DrawSwapReadbackResult ScheduledActionDrawAndSwapForced() = 0;
  31   virtual DrawSwapReadbackResult ScheduledActionDrawAndReadback() = 0;
  32   virtual void ScheduledActionCommit() = 0;
  33   virtual void ScheduledActionUpdateVisibleTiles() = 0;
  34   virtual void ScheduledActionActivatePendingTree() = 0;
  35   virtual void ScheduledActionBeginOutputSurfaceCreation() = 0;
  36   virtual void ScheduledActionAcquireLayerTexturesForMainThread() = 0;
  37   virtual void ScheduledActionManageTiles() = 0;
  38   virtual void DidAnticipatedDrawTimeChange(base::TimeTicks time) = 0;
  39   virtual base::TimeDelta DrawDurationEstimate() = 0;
  40   virtual base::TimeDelta BeginMainFrameToCommitDurationEstimate() = 0;
  41   virtual base::TimeDelta CommitToActivateDurationEstimate() = 0;
  42   virtual void PostBeginImplFrameDeadline(const base::Closure& closure,
  43                                           base::TimeTicks deadline) = 0;
  44   virtual void DidBeginImplFrameDeadline() = 0;
  45
  46  protected:
  47   virtual ~SchedulerClient() {}
  48 };
  49
  50 class CC_EXPORT Scheduler {
  51  public:
  52   static scoped_ptr<Scheduler> Create(
  53       SchedulerClient* client,
  54       const SchedulerSettings& scheduler_settings,
  55       int layer_tree_host_id) {
  56     return make_scoped_ptr(
  57         new Scheduler(client, scheduler_settings, layer_tree_host_id));
  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 SetMainThreadNeedsLayerTextures();
  79
  80   void SetSwapUsedIncompleteTile(bool used_incomplete_tile);
  81
  82   void SetSmoothnessTakesPriority(bool smoothness_takes_priority);
  83
  84   void FinishCommit();
  85   void BeginMainFrameAborted(bool did_handle);
  86
  87   void DidManageTiles();
  88   void DidLoseOutputSurface();
  89   void DidCreateAndInitializeOutputSurface();
  90   bool HasInitializedOutputSurface() const {
  91     return state_machine_.HasInitializedOutputSurface();
  92   }
  93
  94   bool CommitPending() const { return state_machine_.CommitPending(); }
  95   bool RedrawPending() const { return state_machine_.RedrawPending(); }
  96   bool ManageTilesPending() const {
  97     return state_machine_.ManageTilesPending();
  98   }
  99   bool MainThreadIsInHighLatencyMode() const {
 100     return state_machine_.MainThreadIsInHighLatencyMode();
 101   }
 102
 103   bool WillDrawIfNeeded() const;
 104
 105   base::TimeTicks AnticipatedDrawTime();
 106
 107   base::TimeTicks LastBeginImplFrameTime();
 108
 109   void BeginImplFrame(const BeginFrameArgs& args);
 110   void OnBeginImplFrameDeadline();
 111   void PollForAnticipatedDrawTriggers();
 112
 113   scoped_ptr<base::Value> StateAsValue() {
 114     return state_machine_.AsValue().Pass();
 115   }
 116
 117   bool IsInsideAction(SchedulerStateMachine::Action action) {
 118     return inside_action_ == action;
 119   }
 120
 121  private:
 122   Scheduler(SchedulerClient* client,
 123             const SchedulerSettings& scheduler_settings,
 124             int layer_tree_host_id);
 125
 126   void PostBeginImplFrameDeadline(base::TimeTicks deadline);
 127   void SetupNextBeginImplFrameIfNeeded();
 128   void ActivatePendingTree();
 129   void DrawAndSwapIfPossible();
 130   void DrawAndSwapForced();
 131   void DrawAndReadback();
 132   void ProcessScheduledActions();
 133
 134   bool CanCommitAndActivateBeforeDeadline() const;
 135   void AdvanceCommitStateIfPossible();
 136
 137   const SchedulerSettings settings_;
 138   SchedulerClient* client_;
 139   int layer_tree_host_id_;
 140
 141   bool last_set_needs_begin_impl_frame_;
 142   BeginFrameArgs last_begin_impl_frame_args_;
 143   base::CancelableClosure begin_impl_frame_deadline_closure_;
 144   base::CancelableClosure poll_for_draw_triggers_closure_;
 145   base::RepeatingTimer<Scheduler> advance_commit_state_timer_;
 146
 147   SchedulerStateMachine state_machine_;
 148   bool inside_process_scheduled_actions_;
 149   SchedulerStateMachine::Action inside_action_;
 150
 151   base::WeakPtrFactory<Scheduler> weak_factory_;
 152
 153   DISALLOW_COPY_AND_ASSIGN(Scheduler);
 154 };
 155
 156 }  // namespace cc
 157
 158 #endif  // CC_SCHEDULER_SCHEDULER_H_