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_TREES_LAYER_TREE_HOST_H_ 6 #define CC_TREES_LAYER_TREE_HOST_H_ 7 8 #include <limits> 9 #include <list> 10 #include <set> 11 #include <string> 12 #include <vector> 13 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/scrollbar.h" 31 #include "cc/input/top_controls_state.h" 32 #include "cc/layers/layer_lists.h" 33 #include "cc/output/output_surface.h" 34 #include "cc/resources/resource_format.h" 35 #include "cc/resources/scoped_ui_resource.h" 36 #include "cc/trees/layer_tree_host_client.h" 37 #include "cc/trees/layer_tree_host_common.h" 38 #include "cc/trees/layer_tree_settings.h" 39 #include "cc/trees/occlusion_tracker.h" 40 #include "cc/trees/proxy.h" 41 #include "third_party/skia/include/core/SkColor.h" 42 #include "ui/gfx/rect.h" 43 44 namespace cc { 45 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; 63 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 bool using_offscreen_context3d, 70 int max_texture_size, 71 bool using_shared_memory_resources); 72 73 RendererCapabilities(); 74 ~RendererCapabilities(); 75 76 // Duplicate any modification to this list to RendererCapabilitiesImpl. 77 ResourceFormat best_texture_format; 78 bool allow_partial_texture_updates; 79 bool using_offscreen_context3d; 80 int max_texture_size; 81 bool using_shared_memory_resources; 82 }; 83 84 class CC_EXPORT LayerTreeHost { 85 public: 86 // The SharedBitmapManager will be used on the compositor thread. 87 static scoped_ptr<LayerTreeHost> CreateThreaded( 88 LayerTreeHostClient* client, 89 SharedBitmapManager* manager, 90 const LayerTreeSettings& settings, 91 scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner); 92 93 static scoped_ptr<LayerTreeHost> CreateSingleThreaded( 94 LayerTreeHostClient* client, 95 LayerTreeHostSingleThreadClient* single_thread_client, 96 SharedBitmapManager* manager, 97 const LayerTreeSettings& settings); 98 virtual ~LayerTreeHost(); 99 100 void SetLayerTreeHostClientReady(); 101 set_needs_filter_context()102 void set_needs_filter_context() { needs_filter_context_ = true; } needs_offscreen_context()103 bool needs_offscreen_context() const { 104 return needs_filter_context_; 105 } 106 107 // LayerTreeHost interface to Proxy. WillBeginMainFrame()108 void WillBeginMainFrame() { 109 client_->WillBeginMainFrame(source_frame_number_); 110 } 111 void DidBeginMainFrame(); 112 void UpdateClientAnimations(base::TimeTicks monotonic_frame_begin_time); 113 void AnimateLayers(base::TimeTicks monotonic_frame_begin_time); 114 void DidStopFlinging(); 115 void Layout(); 116 void BeginCommitOnImplThread(LayerTreeHostImpl* host_impl); 117 void FinishCommitOnImplThread(LayerTreeHostImpl* host_impl); 118 void WillCommit(); 119 void CommitComplete(); 120 scoped_ptr<OutputSurface> CreateOutputSurface(); 121 virtual scoped_ptr<LayerTreeHostImpl> CreateLayerTreeHostImpl( 122 LayerTreeHostImplClient* client); 123 void DidLoseOutputSurface(); output_surface_lost()124 bool output_surface_lost() const { return output_surface_lost_; } 125 enum CreateResult { 126 CreateSucceeded, 127 CreateFailedButTryAgain, 128 CreateFailedAndGaveUp, 129 }; 130 CreateResult OnCreateAndInitializeOutputSurfaceAttempted(bool success); DidCommitAndDrawFrame()131 void DidCommitAndDrawFrame() { client_->DidCommitAndDrawFrame(); } DidCompleteSwapBuffers()132 void DidCompleteSwapBuffers() { client_->DidCompleteSwapBuffers(); } 133 void DeleteContentsTexturesOnImplThread(ResourceProvider* resource_provider); 134 virtual void AcquireLayerTextures(); 135 // Returns false if we should abort this frame due to initialization failure. 136 bool InitializeOutputSurfaceIfNeeded(); 137 bool UpdateLayers(ResourceUpdateQueue* queue); 138 client()139 LayerTreeHostClient* client() { return client_; } GetInputHandler()140 const base::WeakPtr<InputHandler>& GetInputHandler() { 141 return input_handler_weak_ptr_; 142 } 143 144 void NotifyInputThrottledUntilCommit(); 145 146 void Composite(base::TimeTicks frame_begin_time); 147 148 // Composites and attempts to read back the result into the provided 149 // buffer. If it wasn't possible, e.g. due to context lost, will return 150 // false. 151 bool CompositeAndReadback(void* pixels, gfx::Rect rect_in_device_viewport); 152 153 void FinishAllRendering(); 154 155 void SetDeferCommits(bool defer_commits); 156 157 // Test only hook 158 virtual void DidDeferCommit(); 159 source_frame_number()160 int source_frame_number() const { return source_frame_number_; } 161 162 void SetNeedsDisplayOnAllLayers(); 163 164 void CollectRenderingStats(RenderingStats* stats) const; 165 rendering_stats_instrumentation()166 RenderingStatsInstrumentation* rendering_stats_instrumentation() const { 167 return rendering_stats_instrumentation_.get(); 168 } 169 170 const RendererCapabilities& GetRendererCapabilities() const; 171 172 void SetNeedsAnimate(); 173 virtual void SetNeedsUpdateLayers(); 174 virtual void SetNeedsCommit(); 175 virtual void SetNeedsFullTreeSync(); 176 void SetNeedsRedraw(); 177 void SetNeedsRedrawRect(gfx::Rect damage_rect); 178 bool CommitRequested() const; 179 bool BeginMainFrameRequested() const; 180 181 void SetNextCommitWaitsForActivation(); 182 183 void SetNextCommitForcesRedraw(); 184 185 void SetAnimationEvents(scoped_ptr<AnimationEventsVector> events, 186 base::Time wall_clock_time); 187 188 void SetRootLayer(scoped_refptr<Layer> root_layer); root_layer()189 Layer* root_layer() { return root_layer_.get(); } root_layer()190 const Layer* root_layer() const { return root_layer_.get(); } page_scale_layer()191 const Layer* page_scale_layer() const { return page_scale_layer_.get(); } 192 void RegisterViewportLayers( 193 scoped_refptr<Layer> page_scale_layer, 194 scoped_refptr<Layer> inner_viewport_scroll_layer, 195 scoped_refptr<Layer> outer_viewport_scroll_layer); 196 settings()197 const LayerTreeSettings& settings() const { return settings_; } 198 199 void SetDebugState(const LayerTreeDebugState& debug_state); debug_state()200 const LayerTreeDebugState& debug_state() const { return debug_state_; } 201 202 void SetViewportSize(gfx::Size device_viewport_size); 203 void SetOverdrawBottomHeight(float overdraw_bottom_height); 204 device_viewport_size()205 gfx::Size device_viewport_size() const { return device_viewport_size_; } overdraw_bottom_height()206 float overdraw_bottom_height() const { return overdraw_bottom_height_; } 207 208 void ApplyPageScaleDeltaFromImplSide(float page_scale_delta); 209 void SetPageScaleFactorAndLimits(float page_scale_factor, 210 float min_page_scale_factor, 211 float max_page_scale_factor); page_scale_factor()212 float page_scale_factor() const { return page_scale_factor_; } 213 background_color()214 SkColor background_color() const { return background_color_; } set_background_color(SkColor color)215 void set_background_color(SkColor color) { background_color_ = color; } 216 set_has_transparent_background(bool transparent)217 void set_has_transparent_background(bool transparent) { 218 has_transparent_background_ = transparent; 219 } 220 221 void SetOverhangBitmap(const SkBitmap& bitmap); 222 contents_texture_manager()223 PrioritizedResourceManager* contents_texture_manager() const { 224 return contents_texture_manager_.get(); 225 } 226 227 void SetVisible(bool visible); visible()228 bool visible() const { return visible_; } 229 230 void StartPageScaleAnimation(gfx::Vector2d target_offset, 231 bool use_anchor, 232 float scale, 233 base::TimeDelta duration); 234 235 void ApplyScrollAndScale(const ScrollAndScaleSet& info); 236 237 void SetImplTransform(const gfx::Transform& transform); 238 239 // Virtual for tests. 240 virtual void StartRateLimiter(); 241 virtual void StopRateLimiter(); 242 243 void RateLimit(); 244 245 bool AlwaysUsePartialTextureUpdates(); 246 size_t MaxPartialTextureUpdates() const; 247 bool RequestPartialTextureUpdate(); 248 249 void SetDeviceScaleFactor(float device_scale_factor); device_scale_factor()250 float device_scale_factor() const { return device_scale_factor_; } 251 252 void UpdateTopControlsState(TopControlsState constraints, 253 TopControlsState current, 254 bool animate); 255 hud_layer()256 HeadsUpDisplayLayer* hud_layer() const { return hud_layer_.get(); } 257 proxy()258 Proxy* proxy() const { return proxy_.get(); } 259 animation_registrar()260 AnimationRegistrar* animation_registrar() const { 261 return animation_registrar_.get(); 262 } 263 264 // Obtains a thorough dump of the LayerTreeHost as a value. 265 scoped_ptr<base::Value> AsValue() const; 266 in_paint_layer_contents()267 bool in_paint_layer_contents() const { return in_paint_layer_contents_; } 268 269 // CreateUIResource creates a resource given a bitmap. The bitmap is 270 // generated via an interface function, which is called when initializing the 271 // resource and when the resource has been lost (due to lost context). The 272 // parameter of the interface is a single boolean, which indicates whether the 273 // resource has been lost or not. CreateUIResource returns an Id of the 274 // resource, which is always positive. 275 virtual UIResourceId CreateUIResource(UIResourceClient* client); 276 // Deletes a UI resource. May safely be called more than once. 277 virtual void DeleteUIResource(UIResourceId id); 278 // Put the recreation of all UI resources into the resource queue after they 279 // were evicted on the impl thread. 280 void RecreateUIResources(); 281 282 virtual gfx::Size GetUIResourceSize(UIResourceId id) const; 283 284 bool UsingSharedMemoryResources(); id()285 int id() const { return id_; } 286 287 bool ScheduleMicroBenchmark(const std::string& benchmark_name, 288 scoped_ptr<base::Value> value, 289 const MicroBenchmark::DoneCallback& callback); 290 291 // When a SwapPromiseMonitor is created on the main thread, it calls 292 // InsertSwapPromiseMonitor() to register itself with LayerTreeHost. 293 // When the monitor is destroyed, it calls RemoveSwapPromiseMonitor() 294 // to unregister itself. 295 void InsertSwapPromiseMonitor(SwapPromiseMonitor* monitor); 296 void RemoveSwapPromiseMonitor(SwapPromiseMonitor* monitor); 297 298 // Call this function when you expect there to be a swap buffer. 299 // See swap_promise.h for how to use SwapPromise. 300 void QueueSwapPromise(scoped_ptr<SwapPromise> swap_promise); 301 302 void BreakSwapPromises(SwapPromise::DidNotSwapReason reason); 303 304 protected: 305 LayerTreeHost(LayerTreeHostClient* client, 306 SharedBitmapManager* manager, 307 const LayerTreeSettings& settings); 308 bool InitializeThreaded( 309 scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner); 310 bool InitializeSingleThreaded( 311 LayerTreeHostSingleThreadClient* single_thread_client); 312 bool InitializeForTesting(scoped_ptr<Proxy> proxy_for_testing); SetOutputSurfaceLostForTesting(bool is_lost)313 void SetOutputSurfaceLostForTesting(bool is_lost) { 314 output_surface_lost_ = is_lost; 315 } 316 317 MicroBenchmarkController micro_benchmark_controller_; 318 319 private: 320 bool InitializeProxy(scoped_ptr<Proxy> proxy); 321 322 void PaintLayerContents( 323 const RenderSurfaceLayerList& render_surface_layer_list, 324 ResourceUpdateQueue* queue, 325 bool* did_paint_content, 326 bool* need_more_updates); 327 void PaintMasksForRenderSurface(Layer* render_surface_layer, 328 ResourceUpdateQueue* queue, 329 bool* did_paint_content, 330 bool* need_more_updates); 331 bool UpdateLayers(Layer* root_layer, ResourceUpdateQueue* queue); 332 void UpdateHudLayer(); 333 void TriggerPrepaint(); 334 335 void ReduceMemoryUsage(); 336 337 void PrioritizeTextures( 338 const RenderSurfaceLayerList& render_surface_layer_list, 339 OverdrawMetrics* metrics); 340 void SetPrioritiesForSurfaces(size_t surface_memory_bytes); 341 void SetPrioritiesForLayers(const RenderSurfaceLayerList& update_list); 342 size_t CalculateMemoryForRenderSurfaces( 343 const RenderSurfaceLayerList& update_list); 344 345 bool AnimateLayersRecursive(Layer* current, base::TimeTicks time); 346 347 struct UIResourceClientData { 348 UIResourceClient* client; 349 gfx::Size size; 350 }; 351 352 typedef base::hash_map<UIResourceId, UIResourceClientData> 353 UIResourceClientMap; 354 UIResourceClientMap ui_resource_client_map_; 355 int next_ui_resource_id_; 356 357 typedef std::list<UIResourceRequest> UIResourceRequestQueue; 358 UIResourceRequestQueue ui_resource_request_queue_; 359 360 void CalculateLCDTextMetricsCallback(Layer* layer); 361 362 void NotifySwapPromiseMonitorsOfSetNeedsCommit(); 363 364 bool animating_; 365 bool needs_full_tree_sync_; 366 bool needs_filter_context_; 367 368 base::CancelableClosure prepaint_callback_; 369 370 LayerTreeHostClient* client_; 371 scoped_ptr<Proxy> proxy_; 372 373 int source_frame_number_; 374 scoped_ptr<RenderingStatsInstrumentation> rendering_stats_instrumentation_; 375 376 bool output_surface_can_be_initialized_; 377 bool output_surface_lost_; 378 int num_failed_recreate_attempts_; 379 380 scoped_refptr<Layer> root_layer_; 381 scoped_refptr<HeadsUpDisplayLayer> hud_layer_; 382 383 scoped_ptr<PrioritizedResourceManager> contents_texture_manager_; 384 scoped_ptr<PrioritizedResource> surface_memory_placeholder_; 385 386 base::WeakPtr<InputHandler> input_handler_weak_ptr_; 387 base::WeakPtr<TopControlsManager> top_controls_manager_weak_ptr_; 388 389 const LayerTreeSettings settings_; 390 LayerTreeDebugState debug_state_; 391 392 gfx::Size device_viewport_size_; 393 float overdraw_bottom_height_; 394 float device_scale_factor_; 395 396 bool visible_; 397 398 base::OneShotTimer<LayerTreeHost> rate_limit_timer_; 399 400 float page_scale_factor_; 401 float min_page_scale_factor_; 402 float max_page_scale_factor_; 403 gfx::Transform impl_transform_; 404 bool trigger_idle_updates_; 405 406 SkColor background_color_; 407 bool has_transparent_background_; 408 409 // If set, this texture is used to fill in the parts of the screen not 410 // covered by layers. 411 scoped_ptr<ScopedUIResource> overhang_ui_resource_; 412 413 typedef ScopedPtrVector<PrioritizedResource> TextureList; 414 size_t partial_texture_update_requests_; 415 416 scoped_ptr<AnimationRegistrar> animation_registrar_; 417 418 struct PendingPageScaleAnimation { 419 gfx::Vector2d target_offset; 420 bool use_anchor; 421 float scale; 422 base::TimeDelta duration; 423 }; 424 scoped_ptr<PendingPageScaleAnimation> pending_page_scale_animation_; 425 426 bool in_paint_layer_contents_; 427 428 static const int kTotalFramesToUseForLCDTextMetrics = 50; 429 int total_frames_used_for_lcd_text_metrics_; 430 431 struct LCDTextMetrics { LCDTextMetricsLCDTextMetrics432 LCDTextMetrics() 433 : total_num_cc_layers(0), 434 total_num_cc_layers_can_use_lcd_text(0), 435 total_num_cc_layers_will_use_lcd_text(0) {} 436 437 int64 total_num_cc_layers; 438 int64 total_num_cc_layers_can_use_lcd_text; 439 int64 total_num_cc_layers_will_use_lcd_text; 440 }; 441 LCDTextMetrics lcd_text_metrics_; 442 int id_; 443 bool next_commit_forces_redraw_; 444 445 scoped_refptr<Layer> page_scale_layer_; 446 scoped_refptr<Layer> inner_viewport_scroll_layer_; 447 scoped_refptr<Layer> outer_viewport_scroll_layer_; 448 449 SharedBitmapManager* shared_bitmap_manager_; 450 451 ScopedPtrVector<SwapPromise> swap_promise_list_; 452 std::set<SwapPromiseMonitor*> swap_promise_monitor_; 453 454 DISALLOW_COPY_AND_ASSIGN(LayerTreeHost); 455 }; 456 457 } // namespace cc 458 459 #endif // CC_TREES_LAYER_TREE_HOST_H_ 460