chromium/cc/scheduler/scheduler.h


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

// 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"
#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/scheduler_settings.h"
#include "cc/scheduler/scheduler_state_machine.h"
#include "cc/trees/layer_tree_host.h"

namespace cc {

class Thread;

struct DrawSwapReadbackResult {
  DrawSwapReadbackResult()
      : did_draw(false), did_swap(false), did_readback(false) {}
  DrawSwapReadbackResult(bool did_draw, bool did_swap, bool did_readback)
      : did_draw(did_draw), did_swap(did_swap), did_readback(did_readback) {}
  bool did_draw;
  bool did_swap;
  bool did_readback;
};

class SchedulerClient {
 public:
  virtual void SetNeedsBeginFrameOnImplThread(bool enable) = 0;
  virtual void ScheduledActionSendBeginFrameToMainThread() = 0;
  virtual DrawSwapReadbackResult ScheduledActionDrawAndSwapIfPossible() = 0;
  virtual DrawSwapReadbackResult ScheduledActionDrawAndSwapForced() = 0;
  virtual DrawSwapReadbackResult ScheduledActionDrawAndReadback() = 0;
  virtual void ScheduledActionCommit() = 0;
  virtual void ScheduledActionUpdateVisibleTiles() = 0;
  virtual void ScheduledActionActivatePendingTree() = 0;
  virtual void ScheduledActionBeginOutputSurfaceCreation() = 0;
  virtual void ScheduledActionAcquireLayerTexturesForMainThread() = 0;
  virtual void ScheduledActionManageTiles() = 0;
  virtual void DidAnticipatedDrawTimeChange(base::TimeTicks time) = 0;
  virtual base::TimeDelta DrawDurationEstimate() = 0;
  virtual base::TimeDelta BeginFrameToCommitDurationEstimate() = 0;
  virtual base::TimeDelta CommitToActivateDurationEstimate() = 0;
  virtual void PostBeginFrameDeadline(const base::Closure& closure,
                                      base::TimeTicks deadline) = 0;
  virtual void DidBeginFrameDeadlineOnImplThread() = 0;

 protected:
  virtual ~SchedulerClient() {}
};

class CC_EXPORT Scheduler {
 public:
  static scoped_ptr<Scheduler> Create(
      SchedulerClient* client,
      const SchedulerSettings& scheduler_settings) {
    return make_scoped_ptr(new Scheduler(client,  scheduler_settings));
  }

  virtual ~Scheduler();

  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.
  void SetNeedsForcedCommitForReadback();

  void SetNeedsRedraw();

  void SetNeedsManageTiles();

  void SetMainThreadNeedsLayerTextures();

  void SetSwapUsedIncompleteTile(bool used_incomplete_tile);

  void SetSmoothnessTakesPriority(bool smoothness_takes_priority);

  void FinishCommit();
  void BeginFrameAbortedByMainThread(bool did_handle);

  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 ManageTilesPending() const {
    return state_machine_.ManageTilesPending();
  }

  bool WillDrawIfNeeded() const;

  base::TimeTicks AnticipatedDrawTime();

  base::TimeTicks LastBeginFrameOnImplThreadTime();

  void BeginFrame(const BeginFrameArgs& args);
  void OnBeginFrameDeadline();
  void PollForAnticipatedDrawTriggers();

  scoped_ptr<base::Value> StateAsValue() {
    return state_machine_.AsValue().Pass();
  }

  bool IsInsideAction(SchedulerStateMachine::Action action) {
    return inside_action_ == action;
  }

 private:
  Scheduler(SchedulerClient* client,
            const SchedulerSettings& scheduler_settings);

  void PostBeginFrameDeadline(base::TimeTicks deadline);
  void SetupNextBeginFrameIfNeeded();
  void ActivatePendingTree();
  void DrawAndSwapIfPossible();
  void DrawAndSwapForced();
  void DrawAndReadback();
  void ProcessScheduledActions();

  const SchedulerSettings settings_;
  SchedulerClient* client_;

  base::WeakPtrFactory<Scheduler> weak_factory_;
  bool last_set_needs_begin_frame_;
  BeginFrameArgs last_begin_frame_args_;
  base::CancelableClosure begin_frame_deadline_closure_;
  base::CancelableClosure poll_for_draw_triggers_closure_;

  SchedulerStateMachine state_machine_;
  bool inside_process_scheduled_actions_;
  SchedulerStateMachine::Action inside_action_;

  DISALLOW_COPY_AND_ASSIGN(Scheduler);
};

}  // namespace cc

#endif  // CC_SCHEDULER_SCHEDULER_H_