OLD | NEW |
| (Empty) |
1 // Copyright 2016 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_TREES_LAYER_TREE_HOST_INTERFACE_H_ | |
6 #define CC_TREES_LAYER_TREE_HOST_INTERFACE_H_ | |
7 | |
8 #include "base/macros.h" | |
9 #include "cc/base/cc_export.h" | |
10 #include "cc/debug/micro_benchmark.h" | |
11 #include "cc/input/top_controls_state.h" | |
12 | |
13 namespace base { | |
14 class TimeTicks; | |
15 } // namespace base | |
16 | |
17 namespace gfx { | |
18 class Rect; | |
19 } // namespace gfx | |
20 | |
21 namespace cc { | |
22 class InputHandler; | |
23 class LayerTree; | |
24 class LayerTreeDebugState; | |
25 class LayerTreeMutator; | |
26 class LayerTreeSettings; | |
27 class CompositorFrameSink; | |
28 class SwapPromiseMonitor; | |
29 class TaskRunnerProvider; | |
30 class UIResourceManager; | |
31 | |
32 // TODO(khushalsagar): Will be renamed to LayerTreeHost. | |
33 class CC_EXPORT LayerTreeHostInterface { | |
34 public: | |
35 virtual ~LayerTreeHostInterface() {} | |
36 | |
37 // Returns the process global unique identifier for this LayerTreeHost. | |
38 virtual int GetId() const = 0; | |
39 | |
40 // The current source frame number. This is incremented for each main frame | |
41 // update(commit) pushed to the compositor thread. | |
42 virtual int SourceFrameNumber() const = 0; | |
43 | |
44 // Returns the LayerTree that holds the main frame state pushed to the | |
45 // LayerTreeImpl on commit. | |
46 virtual LayerTree* GetLayerTree() = 0; | |
47 virtual const LayerTree* GetLayerTree() const = 0; | |
48 | |
49 // Returns the UIResourceManager used to create UIResources for | |
50 // UIResourceLayers pushed to the LayerTree. | |
51 virtual UIResourceManager* GetUIResourceManager() const = 0; | |
52 | |
53 // Returns the TaskRunnerProvider used to access the main and compositor | |
54 // thread task runners. | |
55 virtual TaskRunnerProvider* GetTaskRunnerProvider() const = 0; | |
56 | |
57 // Returns the settings used by this host. | |
58 virtual const LayerTreeSettings& GetSettings() const = 0; | |
59 | |
60 // Sets the client id used to generate the SurfaceId that uniquely identifies | |
61 // the Surfaces produced by this compositor. | |
62 virtual void SetSurfaceClientId(uint32_t client_id) = 0; | |
63 | |
64 // Sets the LayerTreeMutator interface used to directly mutate the compositor | |
65 // state on the compositor thread. (Compositor-Worker) | |
66 virtual void SetLayerTreeMutator( | |
67 std::unique_ptr<LayerTreeMutator> mutator) = 0; | |
68 | |
69 // Call this function when you expect there to be a swap buffer. | |
70 // See swap_promise.h for how to use SwapPromise. | |
71 virtual void QueueSwapPromise(std::unique_ptr<SwapPromise> swap_promise) = 0; | |
72 | |
73 // Returns the SwapPromiseManager used to create SwapPromiseMonitors for this | |
74 // host. | |
75 virtual SwapPromiseManager* GetSwapPromiseManager() = 0; | |
76 | |
77 // Sets whether the content is suitable to use Gpu Rasterization. | |
78 virtual void SetHasGpuRasterizationTrigger(bool has_trigger) = 0; | |
79 | |
80 // Visibility and CompositorFrameSink ------------------------------- | |
81 | |
82 virtual void SetVisible(bool visible) = 0; | |
83 virtual bool IsVisible() const = 0; | |
84 | |
85 // Called in response to an CompositorFrameSink request made to the client | |
86 // using LayerTreeHostClient::RequestNewCompositorFrameSink. The client will | |
87 // be informed of the CompositorFrameSink initialization status using | |
88 // DidInitializaCompositorFrameSink or DidFailToInitializeCompositorFrameSink. | |
89 // The request is completed when the host successfully initializes an | |
90 // CompositorFrameSink. | |
91 virtual void SetCompositorFrameSink( | |
92 std::unique_ptr<CompositorFrameSink> compositor_frame_sink) = 0; | |
93 | |
94 // Forces the host to immediately release all references to the | |
95 // CompositorFrameSink, if any. Can be safely called any time. | |
96 virtual std::unique_ptr<CompositorFrameSink> ReleaseCompositorFrameSink() = 0; | |
97 | |
98 // Frame Scheduling (main and compositor frames) requests ------- | |
99 | |
100 // Requests a main frame update even if no content has changed. This is used, | |
101 // for instance in the case of RequestAnimationFrame from blink to ensure the | |
102 // main frame update is run on the next tick without pre-emptively forcing a | |
103 // full commit synchronization or layer updates. | |
104 virtual void SetNeedsAnimate() = 0; | |
105 | |
106 // Requests a main frame update and also ensure that the host pulls layer | |
107 // updates from the client, even if no content might have changed, without | |
108 // forcing a full commit synchronization. | |
109 virtual void SetNeedsUpdateLayers() = 0; | |
110 | |
111 // Requests that the next main frame update performs a full commit | |
112 // synchronization. | |
113 virtual void SetNeedsCommit() = 0; | |
114 | |
115 // Returns true if a main frame (for any pipeline stage above) has been | |
116 // requested. | |
117 virtual bool BeginMainFrameRequested() const = 0; | |
118 | |
119 // Returns true if a main frame with commit synchronization has been | |
120 // requested. | |
121 virtual bool CommitRequested() const = 0; | |
122 | |
123 // Enables/disables the compositor from requesting main frame updates from the | |
124 // client. | |
125 virtual void SetDeferCommits(bool defer_commits) = 0; | |
126 | |
127 // Synchronously performs a main frame update and layer updates. Used only in | |
128 // single threaded mode when the compositor's internal scheduling is disabled. | |
129 virtual void LayoutAndUpdateLayers() = 0; | |
130 | |
131 // Synchronously performs a complete main frame update, commit and compositor | |
132 // frame. Used only in single threaded mode when the compositor's internal | |
133 // scheduling is disabled. | |
134 virtual void Composite(base::TimeTicks frame_begin_time) = 0; | |
135 | |
136 // Requests a redraw (compositor frame) for the complete viewport. | |
137 virtual void SetNeedsRedraw() = 0; | |
138 | |
139 // Requests a redraw (compositor frame) for the given rect. | |
140 virtual void SetNeedsRedrawRect(const gfx::Rect& damage_rect) = 0; | |
141 | |
142 // Requests a main frame (including layer updates) and ensures that this main | |
143 // frame results in a redraw for the complete viewport when producing the | |
144 // CompositorFrame. | |
145 virtual void SetNextCommitForcesRedraw() = 0; | |
146 | |
147 // Input Handling --------------------------------------------- | |
148 | |
149 // Notifies the compositor that input from the browser is being throttled till | |
150 // the next commit. The compositor will prioritize activation of the pending | |
151 // tree so a commit can be performed. | |
152 virtual void NotifyInputThrottledUntilCommit() = 0; | |
153 | |
154 // Sets the state of the top controls. (Used for URL bar animations on | |
155 // android). | |
156 virtual void UpdateTopControlsState(TopControlsState constraints, | |
157 TopControlsState current, | |
158 bool animate) = 0; | |
159 | |
160 // Returns a reference to the InputHandler used to respond to input events on | |
161 // the compositor thread. | |
162 virtual const base::WeakPtr<InputHandler>& GetInputHandler() const = 0; | |
163 | |
164 // Informs the compositor that an active fling gesture being processed on the | |
165 // main thread has been finished. | |
166 virtual void DidStopFlinging() = 0; | |
167 | |
168 // Debugging and benchmarks --------------------------------- | |
169 virtual void SetDebugState(const LayerTreeDebugState& debug_state) = 0; | |
170 virtual const LayerTreeDebugState& GetDebugState() const = 0; | |
171 | |
172 // Returns the id of the benchmark on success, 0 otherwise. | |
173 virtual int ScheduleMicroBenchmark( | |
174 const std::string& benchmark_name, | |
175 std::unique_ptr<base::Value> value, | |
176 const MicroBenchmark::DoneCallback& callback) = 0; | |
177 | |
178 // Returns true if the message was successfully delivered and handled. | |
179 virtual bool SendMessageToMicroBenchmark( | |
180 int id, | |
181 std::unique_ptr<base::Value> value) = 0; | |
182 | |
183 // Methods used internally in cc. These are not intended to be a part of the | |
184 // public API for use by the embedder ---------------------- | |
185 virtual SurfaceSequenceGenerator* GetSurfaceSequenceGenerator() = 0; | |
186 }; | |
187 | |
188 } // namespace cc | |
189 | |
190 #endif // CC_TREES_LAYER_TREE_HOST_INTERFACE_H_ | |
OLD | NEW |