Lots of random cleanups, mostly for native_theme_win.cc:
[chromium-blink-merge.git] / cc / trees / layer_tree_host.h
blob1e977c3bfe3a91a77df53ef39c384d7386aa3dec
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.
5 #ifndef CC_TREES_LAYER_TREE_HOST_H_
6 #define CC_TREES_LAYER_TREE_HOST_H_
8 #include <limits>
9 #include <list>
10 #include <set>
11 #include <string>
12 #include <vector>
14 #include "base/basictypes.h"
15 #include "base/cancelable_callback.h"
16 #include "base/containers/hash_tables.h"
17 #include "base/memory/ref_counted.h"
18 #include "base/memory/scoped_ptr.h"
19 #include "base/memory/weak_ptr.h"
20 #include "base/time/time.h"
21 #include "base/timer/timer.h"
22 #include "cc/animation/animation_events.h"
23 #include "cc/base/cc_export.h"
24 #include "cc/base/scoped_ptr_vector.h"
25 #include "cc/base/swap_promise.h"
26 #include "cc/base/swap_promise_monitor.h"
27 #include "cc/debug/micro_benchmark.h"
28 #include "cc/debug/micro_benchmark_controller.h"
29 #include "cc/input/input_handler.h"
30 #include "cc/input/layer_selection_bound.h"
31 #include "cc/input/scrollbar.h"
32 #include "cc/input/top_controls_state.h"
33 #include "cc/layers/layer_lists.h"
34 #include "cc/output/output_surface.h"
35 #include "cc/resources/resource_format.h"
36 #include "cc/resources/scoped_ui_resource.h"
37 #include "cc/trees/layer_tree_host_client.h"
38 #include "cc/trees/layer_tree_host_common.h"
39 #include "cc/trees/layer_tree_settings.h"
40 #include "cc/trees/proxy.h"
41 #include "third_party/skia/include/core/SkColor.h"
42 #include "ui/gfx/rect.h"
44 namespace cc {
46 class AnimationRegistrar;
47 class HeadsUpDisplayLayer;
48 class Layer;
49 class LayerTreeHostImpl;
50 class LayerTreeHostImplClient;
51 class LayerTreeHostSingleThreadClient;
52 class PrioritizedResource;
53 class PrioritizedResourceManager;
54 class Region;
55 class RenderingStatsInstrumentation;
56 class ResourceProvider;
57 class ResourceUpdateQueue;
58 class SharedBitmapManager;
59 class TopControlsManager;
60 class UIResourceRequest;
61 struct RenderingStats;
62 struct ScrollAndScaleSet;
64 // Provides information on an Impl's rendering capabilities back to the
65 // LayerTreeHost.
66 struct CC_EXPORT RendererCapabilities {
67 RendererCapabilities(ResourceFormat best_texture_format,
68 bool allow_partial_texture_updates,
69 int max_texture_size,
70 bool using_shared_memory_resources);
72 RendererCapabilities();
73 ~RendererCapabilities();
75 // Duplicate any modification to this list to RendererCapabilitiesImpl.
76 ResourceFormat best_texture_format;
77 bool allow_partial_texture_updates;
78 int max_texture_size;
79 bool using_shared_memory_resources;
82 class CC_EXPORT LayerTreeHost {
83 public:
84 // The SharedBitmapManager will be used on the compositor thread.
85 static scoped_ptr<LayerTreeHost> CreateThreaded(
86 LayerTreeHostClient* client,
87 SharedBitmapManager* manager,
88 const LayerTreeSettings& settings,
89 scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner);
91 static scoped_ptr<LayerTreeHost> CreateSingleThreaded(
92 LayerTreeHostClient* client,
93 LayerTreeHostSingleThreadClient* single_thread_client,
94 SharedBitmapManager* manager,
95 const LayerTreeSettings& settings);
96 virtual ~LayerTreeHost();
98 void SetLayerTreeHostClientReady();
100 // LayerTreeHost interface to Proxy.
101 void WillBeginMainFrame() {
102 client_->WillBeginMainFrame(source_frame_number_);
104 void DidBeginMainFrame();
105 void UpdateClientAnimations(base::TimeTicks monotonic_frame_begin_time);
106 void AnimateLayers(base::TimeTicks monotonic_frame_begin_time);
107 void DidStopFlinging();
108 void Layout();
109 void BeginCommitOnImplThread(LayerTreeHostImpl* host_impl);
110 void FinishCommitOnImplThread(LayerTreeHostImpl* host_impl);
111 void WillCommit();
112 void CommitComplete();
113 scoped_ptr<OutputSurface> CreateOutputSurface();
114 virtual scoped_ptr<LayerTreeHostImpl> CreateLayerTreeHostImpl(
115 LayerTreeHostImplClient* client);
116 void DidLoseOutputSurface();
117 bool output_surface_lost() const { return output_surface_lost_; }
118 virtual void OnCreateAndInitializeOutputSurfaceAttempted(bool success);
119 void DidCommitAndDrawFrame() { client_->DidCommitAndDrawFrame(); }
120 void DidCompleteSwapBuffers() { client_->DidCompleteSwapBuffers(); }
121 void DeleteContentsTexturesOnImplThread(ResourceProvider* resource_provider);
122 bool UpdateLayers(ResourceUpdateQueue* queue);
124 LayerTreeHostClient* client() { return client_; }
125 const base::WeakPtr<InputHandler>& GetInputHandler() {
126 return input_handler_weak_ptr_;
129 void NotifyInputThrottledUntilCommit();
131 void Composite(base::TimeTicks frame_begin_time);
133 void FinishAllRendering();
135 void SetDeferCommits(bool defer_commits);
137 // Test only hook
138 virtual void DidDeferCommit();
140 int source_frame_number() const { return source_frame_number_; }
142 void SetNeedsDisplayOnAllLayers();
144 void CollectRenderingStats(RenderingStats* stats) const;
146 RenderingStatsInstrumentation* rendering_stats_instrumentation() const {
147 return rendering_stats_instrumentation_.get();
150 const RendererCapabilities& GetRendererCapabilities() const;
152 void SetNeedsAnimate();
153 virtual void SetNeedsUpdateLayers();
154 virtual void SetNeedsCommit();
155 virtual void SetNeedsFullTreeSync();
156 void SetNeedsRedraw();
157 void SetNeedsRedrawRect(const gfx::Rect& damage_rect);
158 bool CommitRequested() const;
159 bool BeginMainFrameRequested() const;
161 void SetNextCommitWaitsForActivation();
163 void SetNextCommitForcesRedraw();
165 void SetAnimationEvents(scoped_ptr<AnimationEventsVector> events);
167 void SetRootLayer(scoped_refptr<Layer> root_layer);
168 Layer* root_layer() { return root_layer_.get(); }
169 const Layer* root_layer() const { return root_layer_.get(); }
170 const Layer* page_scale_layer() const { return page_scale_layer_.get(); }
171 void RegisterViewportLayers(
172 scoped_refptr<Layer> page_scale_layer,
173 scoped_refptr<Layer> inner_viewport_scroll_layer,
174 scoped_refptr<Layer> outer_viewport_scroll_layer);
175 Layer* inner_viewport_scroll_layer() const {
176 return inner_viewport_scroll_layer_.get();
178 Layer* outer_viewport_scroll_layer() const {
179 return outer_viewport_scroll_layer_.get();
182 void RegisterSelection(const LayerSelectionBound& anchor,
183 const LayerSelectionBound& focus);
185 const LayerTreeSettings& settings() const { return settings_; }
187 void SetDebugState(const LayerTreeDebugState& debug_state);
188 const LayerTreeDebugState& debug_state() const { return debug_state_; }
190 bool has_gpu_rasterization_trigger() const {
191 return has_gpu_rasterization_trigger_;
193 void SetHasGpuRasterizationTrigger(bool has_trigger);
194 bool UseGpuRasterization() const;
196 void SetViewportSize(const gfx::Size& device_viewport_size);
197 void SetOverdrawBottomHeight(float overdraw_bottom_height);
199 gfx::Size device_viewport_size() const { return device_viewport_size_; }
200 float overdraw_bottom_height() const { return overdraw_bottom_height_; }
202 void ApplyPageScaleDeltaFromImplSide(float page_scale_delta);
203 void SetPageScaleFactorAndLimits(float page_scale_factor,
204 float min_page_scale_factor,
205 float max_page_scale_factor);
206 float page_scale_factor() const { return page_scale_factor_; }
208 SkColor background_color() const { return background_color_; }
209 void set_background_color(SkColor color) { background_color_ = color; }
211 void set_has_transparent_background(bool transparent) {
212 has_transparent_background_ = transparent;
215 void SetOverhangBitmap(const SkBitmap& bitmap);
217 PrioritizedResourceManager* contents_texture_manager() const {
218 return contents_texture_manager_.get();
221 void SetVisible(bool visible);
222 bool visible() const { return visible_; }
224 void StartPageScaleAnimation(const gfx::Vector2d& target_offset,
225 bool use_anchor,
226 float scale,
227 base::TimeDelta duration);
229 void ApplyScrollAndScale(ScrollAndScaleSet* info);
230 void SetImplTransform(const gfx::Transform& transform);
232 // Virtual for tests.
233 virtual void StartRateLimiter();
234 virtual void StopRateLimiter();
236 void RateLimit();
238 bool AlwaysUsePartialTextureUpdates();
239 size_t MaxPartialTextureUpdates() const;
240 bool RequestPartialTextureUpdate();
242 void SetDeviceScaleFactor(float device_scale_factor);
243 float device_scale_factor() const { return device_scale_factor_; }
245 void UpdateTopControlsState(TopControlsState constraints,
246 TopControlsState current,
247 bool animate);
249 HeadsUpDisplayLayer* hud_layer() const { return hud_layer_.get(); }
251 Proxy* proxy() const { return proxy_.get(); }
253 AnimationRegistrar* animation_registrar() const {
254 return animation_registrar_.get();
257 // Obtains a thorough dump of the LayerTreeHost as a value.
258 scoped_ptr<base::Value> AsValue() const;
260 bool in_paint_layer_contents() const { return in_paint_layer_contents_; }
262 // CreateUIResource creates a resource given a bitmap. The bitmap is
263 // generated via an interface function, which is called when initializing the
264 // resource and when the resource has been lost (due to lost context). The
265 // parameter of the interface is a single boolean, which indicates whether the
266 // resource has been lost or not. CreateUIResource returns an Id of the
267 // resource, which is always positive.
268 virtual UIResourceId CreateUIResource(UIResourceClient* client);
269 // Deletes a UI resource. May safely be called more than once.
270 virtual void DeleteUIResource(UIResourceId id);
271 // Put the recreation of all UI resources into the resource queue after they
272 // were evicted on the impl thread.
273 void RecreateUIResources();
275 virtual gfx::Size GetUIResourceSize(UIResourceId id) const;
277 bool UsingSharedMemoryResources();
278 int id() const { return id_; }
280 // Returns the id of the benchmark on success, 0 otherwise.
281 int ScheduleMicroBenchmark(const std::string& benchmark_name,
282 scoped_ptr<base::Value> value,
283 const MicroBenchmark::DoneCallback& callback);
284 // Returns true if the message was successfully delivered and handled.
285 bool SendMessageToMicroBenchmark(int id, scoped_ptr<base::Value> value);
287 // When a SwapPromiseMonitor is created on the main thread, it calls
288 // InsertSwapPromiseMonitor() to register itself with LayerTreeHost.
289 // When the monitor is destroyed, it calls RemoveSwapPromiseMonitor()
290 // to unregister itself.
291 void InsertSwapPromiseMonitor(SwapPromiseMonitor* monitor);
292 void RemoveSwapPromiseMonitor(SwapPromiseMonitor* monitor);
294 // Call this function when you expect there to be a swap buffer.
295 // See swap_promise.h for how to use SwapPromise.
296 void QueueSwapPromise(scoped_ptr<SwapPromise> swap_promise);
298 void BreakSwapPromises(SwapPromise::DidNotSwapReason reason);
300 protected:
301 LayerTreeHost(LayerTreeHostClient* client,
302 SharedBitmapManager* manager,
303 const LayerTreeSettings& settings);
304 void InitializeThreaded(
305 scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner);
306 void InitializeSingleThreaded(
307 LayerTreeHostSingleThreadClient* single_thread_client);
308 void InitializeForTesting(scoped_ptr<Proxy> proxy_for_testing);
309 void SetOutputSurfaceLostForTesting(bool is_lost) {
310 output_surface_lost_ = is_lost;
313 MicroBenchmarkController micro_benchmark_controller_;
315 private:
316 void InitializeProxy(scoped_ptr<Proxy> proxy);
318 void PaintLayerContents(
319 const RenderSurfaceLayerList& render_surface_layer_list,
320 ResourceUpdateQueue* queue,
321 bool* did_paint_content,
322 bool* need_more_updates);
323 void PaintMasksForRenderSurface(Layer* render_surface_layer,
324 ResourceUpdateQueue* queue,
325 bool* did_paint_content,
326 bool* need_more_updates);
327 bool UpdateLayers(Layer* root_layer, ResourceUpdateQueue* queue);
328 void UpdateHudLayer();
329 void TriggerPrepaint();
331 void ReduceMemoryUsage();
333 void PrioritizeTextures(
334 const RenderSurfaceLayerList& render_surface_layer_list);
335 void SetPrioritiesForSurfaces(size_t surface_memory_bytes);
336 void SetPrioritiesForLayers(const RenderSurfaceLayerList& update_list);
337 size_t CalculateMemoryForRenderSurfaces(
338 const RenderSurfaceLayerList& update_list);
340 bool AnimateLayersRecursive(Layer* current, base::TimeTicks time);
342 struct UIResourceClientData {
343 UIResourceClient* client;
344 gfx::Size size;
347 typedef base::hash_map<UIResourceId, UIResourceClientData>
348 UIResourceClientMap;
349 UIResourceClientMap ui_resource_client_map_;
350 int next_ui_resource_id_;
352 typedef std::list<UIResourceRequest> UIResourceRequestQueue;
353 UIResourceRequestQueue ui_resource_request_queue_;
355 void RecordGpuRasterizationHistogram();
356 void CalculateLCDTextMetricsCallback(Layer* layer);
358 void NotifySwapPromiseMonitorsOfSetNeedsCommit();
360 bool animating_;
361 bool needs_full_tree_sync_;
363 base::CancelableClosure prepaint_callback_;
365 LayerTreeHostClient* client_;
366 scoped_ptr<Proxy> proxy_;
368 int source_frame_number_;
369 scoped_ptr<RenderingStatsInstrumentation> rendering_stats_instrumentation_;
371 bool output_surface_lost_;
372 int num_failed_recreate_attempts_;
374 scoped_refptr<Layer> root_layer_;
375 scoped_refptr<HeadsUpDisplayLayer> hud_layer_;
377 scoped_ptr<PrioritizedResourceManager> contents_texture_manager_;
378 scoped_ptr<PrioritizedResource> surface_memory_placeholder_;
380 base::WeakPtr<InputHandler> input_handler_weak_ptr_;
381 base::WeakPtr<TopControlsManager> top_controls_manager_weak_ptr_;
383 const LayerTreeSettings settings_;
384 LayerTreeDebugState debug_state_;
386 gfx::Size device_viewport_size_;
387 float overdraw_bottom_height_;
388 float device_scale_factor_;
390 bool visible_;
392 base::OneShotTimer<LayerTreeHost> rate_limit_timer_;
394 float page_scale_factor_;
395 float min_page_scale_factor_;
396 float max_page_scale_factor_;
397 gfx::Transform impl_transform_;
398 bool trigger_idle_updates_;
399 bool has_gpu_rasterization_trigger_;
400 bool content_is_suitable_for_gpu_rasterization_;
401 bool gpu_rasterization_histogram_recorded_;
403 SkColor background_color_;
404 bool has_transparent_background_;
406 // If set, this texture is used to fill in the parts of the screen not
407 // covered by layers.
408 scoped_ptr<ScopedUIResource> overhang_ui_resource_;
410 typedef ScopedPtrVector<PrioritizedResource> TextureList;
411 size_t partial_texture_update_requests_;
413 scoped_ptr<AnimationRegistrar> animation_registrar_;
415 struct PendingPageScaleAnimation {
416 gfx::Vector2d target_offset;
417 bool use_anchor;
418 float scale;
419 base::TimeDelta duration;
421 scoped_ptr<PendingPageScaleAnimation> pending_page_scale_animation_;
423 bool in_paint_layer_contents_;
425 static const int kTotalFramesToUseForLCDTextMetrics = 50;
426 int total_frames_used_for_lcd_text_metrics_;
428 struct LCDTextMetrics {
429 LCDTextMetrics()
430 : total_num_cc_layers(0),
431 total_num_cc_layers_can_use_lcd_text(0),
432 total_num_cc_layers_will_use_lcd_text(0) {}
434 int64 total_num_cc_layers;
435 int64 total_num_cc_layers_can_use_lcd_text;
436 int64 total_num_cc_layers_will_use_lcd_text;
438 LCDTextMetrics lcd_text_metrics_;
439 int id_;
440 bool next_commit_forces_redraw_;
442 scoped_refptr<Layer> page_scale_layer_;
443 scoped_refptr<Layer> inner_viewport_scroll_layer_;
444 scoped_refptr<Layer> outer_viewport_scroll_layer_;
446 LayerSelectionBound selection_anchor_;
447 LayerSelectionBound selection_focus_;
449 SharedBitmapManager* shared_bitmap_manager_;
451 ScopedPtrVector<SwapPromise> swap_promise_list_;
452 std::set<SwapPromiseMonitor*> swap_promise_monitor_;
454 DISALLOW_COPY_AND_ASSIGN(LayerTreeHost);
457 } // namespace cc
459 #endif // CC_TREES_LAYER_TREE_HOST_H_