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_IMPL_H_ 6 #define CC_TREES_LAYER_TREE_HOST_IMPL_H_ 7 8 #include <list> 9 #include <set> 10 #include <string> 11 #include <vector> 12 13 #include "base/basictypes.h" 14 #include "base/containers/hash_tables.h" 15 #include "base/memory/scoped_ptr.h" 16 #include "base/time/time.h" 17 #include "cc/animation/animation_events.h" 18 #include "cc/animation/animation_registrar.h" 19 #include "cc/animation/scrollbar_animation_controller.h" 20 #include "cc/base/cc_export.h" 21 #include "cc/debug/micro_benchmark_controller_impl.h" 22 #include "cc/input/input_handler.h" 23 #include "cc/input/layer_scroll_offset_delegate.h" 24 #include "cc/input/top_controls_manager_client.h" 25 #include "cc/layers/layer_lists.h" 26 #include "cc/layers/render_pass_sink.h" 27 #include "cc/output/begin_frame_args.h" 28 #include "cc/output/managed_memory_policy.h" 29 #include "cc/output/output_surface_client.h" 30 #include "cc/output/renderer.h" 31 #include "cc/quads/render_pass.h" 32 #include "cc/resources/resource_provider.h" 33 #include "cc/resources/tile_manager.h" 34 #include "cc/scheduler/draw_result.h" 35 #include "skia/ext/refptr.h" 36 #include "third_party/skia/include/core/SkColor.h" 37 #include "ui/gfx/rect.h" 38 39 namespace cc { 40 41 class CompletionEvent; 42 class CompositorFrameMetadata; 43 class DebugRectHistory; 44 class EvictionTilePriorityQueue; 45 class FrameRateCounter; 46 class LayerImpl; 47 class LayerTreeHostImplTimeSourceAdapter; 48 class LayerTreeImpl; 49 class MemoryHistory; 50 class PageScaleAnimation; 51 class PaintTimeCounter; 52 class PictureLayerImpl; 53 class RasterTilePriorityQueue; 54 class RasterWorkerPool; 55 class RenderPassDrawQuad; 56 class RenderingStatsInstrumentation; 57 class ResourcePool; 58 class ScrollbarLayerImplBase; 59 class TextureMailboxDeleter; 60 class TopControlsManager; 61 class UIResourceBitmap; 62 class UIResourceRequest; 63 struct RendererCapabilitiesImpl; 64 65 // LayerTreeHost->Proxy callback interface. 66 class LayerTreeHostImplClient { 67 public: 68 virtual void UpdateRendererCapabilitiesOnImplThread() = 0; 69 virtual void DidLoseOutputSurfaceOnImplThread() = 0; 70 virtual void CommitVSyncParameters(base::TimeTicks timebase, 71 base::TimeDelta interval) = 0; 72 virtual void SetEstimatedParentDrawTime(base::TimeDelta draw_time) = 0; 73 virtual void SetMaxSwapsPendingOnImplThread(int max) = 0; 74 virtual void DidSwapBuffersOnImplThread() = 0; 75 virtual void DidSwapBuffersCompleteOnImplThread() = 0; 76 virtual void BeginFrame(const BeginFrameArgs& args) = 0; 77 virtual void OnCanDrawStateChanged(bool can_draw) = 0; 78 virtual void NotifyReadyToActivate() = 0; 79 // Please call these 3 functions through 80 // LayerTreeHostImpl's SetNeedsRedraw(), SetNeedsRedrawRect() and 81 // SetNeedsAnimate(). 82 virtual void SetNeedsRedrawOnImplThread() = 0; 83 virtual void SetNeedsRedrawRectOnImplThread(const gfx::Rect& damage_rect) = 0; 84 virtual void SetNeedsAnimateOnImplThread() = 0; 85 virtual void DidInitializeVisibleTileOnImplThread() = 0; 86 virtual void SetNeedsCommitOnImplThread() = 0; 87 virtual void SetNeedsManageTilesOnImplThread() = 0; 88 virtual void PostAnimationEventsToMainThreadOnImplThread( 89 scoped_ptr<AnimationEventsVector> events) = 0; 90 // Returns true if resources were deleted by this call. 91 virtual bool ReduceContentsTextureMemoryOnImplThread( 92 size_t limit_bytes, 93 int priority_cutoff) = 0; 94 virtual bool IsInsideDraw() = 0; 95 virtual void RenewTreePriority() = 0; 96 virtual void PostDelayedScrollbarFadeOnImplThread( 97 const base::Closure& start_fade, 98 base::TimeDelta delay) = 0; 99 virtual void DidActivateSyncTree() = 0; 100 virtual void DidManageTiles() = 0; 101 102 protected: ~LayerTreeHostImplClient()103 virtual ~LayerTreeHostImplClient() {} 104 }; 105 106 // LayerTreeHostImpl owns the LayerImpl trees as well as associated rendering 107 // state. 108 class CC_EXPORT LayerTreeHostImpl 109 : public InputHandler, 110 public RendererClient, 111 public TileManagerClient, 112 public OutputSurfaceClient, 113 public TopControlsManagerClient, 114 public ScrollbarAnimationControllerClient, 115 public base::SupportsWeakPtr<LayerTreeHostImpl> { 116 public: 117 static scoped_ptr<LayerTreeHostImpl> Create( 118 const LayerTreeSettings& settings, 119 LayerTreeHostImplClient* client, 120 Proxy* proxy, 121 RenderingStatsInstrumentation* rendering_stats_instrumentation, 122 SharedBitmapManager* manager, 123 int id); 124 virtual ~LayerTreeHostImpl(); 125 126 // InputHandler implementation 127 virtual void BindToClient(InputHandlerClient* client) OVERRIDE; 128 virtual InputHandler::ScrollStatus ScrollBegin( 129 const gfx::Point& viewport_point, 130 InputHandler::ScrollInputType type) OVERRIDE; 131 virtual InputHandler::ScrollStatus ScrollAnimated( 132 const gfx::Point& viewport_point, 133 const gfx::Vector2dF& scroll_delta) OVERRIDE; 134 virtual bool ScrollBy(const gfx::Point& viewport_point, 135 const gfx::Vector2dF& scroll_delta) OVERRIDE; 136 virtual bool ScrollVerticallyByPage(const gfx::Point& viewport_point, 137 ScrollDirection direction) OVERRIDE; 138 virtual void SetRootLayerScrollOffsetDelegate( 139 LayerScrollOffsetDelegate* root_layer_scroll_offset_delegate) OVERRIDE; 140 virtual void OnRootLayerDelegatedScrollOffsetChanged() OVERRIDE; 141 virtual void ScrollEnd() OVERRIDE; 142 virtual InputHandler::ScrollStatus FlingScrollBegin() OVERRIDE; 143 virtual void MouseMoveAt(const gfx::Point& viewport_point) OVERRIDE; 144 virtual void PinchGestureBegin() OVERRIDE; 145 virtual void PinchGestureUpdate(float magnify_delta, 146 const gfx::Point& anchor) OVERRIDE; 147 virtual void PinchGestureEnd() OVERRIDE; 148 virtual void SetNeedsAnimate() OVERRIDE; 149 virtual bool IsCurrentlyScrollingLayerAt( 150 const gfx::Point& viewport_point, 151 InputHandler::ScrollInputType type) OVERRIDE; 152 virtual bool HaveTouchEventHandlersAt( 153 const gfx::Point& viewport_port) OVERRIDE; 154 virtual scoped_ptr<SwapPromiseMonitor> CreateLatencyInfoSwapPromiseMonitor( 155 ui::LatencyInfo* latency) OVERRIDE; 156 157 // TopControlsManagerClient implementation. 158 virtual void SetControlsTopOffset(float offset) OVERRIDE; 159 virtual float ControlsTopOffset() const OVERRIDE; 160 virtual void DidChangeTopControlsPosition() OVERRIDE; 161 virtual bool HaveRootScrollLayer() const OVERRIDE; 162 163 struct CC_EXPORT FrameData : public RenderPassSink { 164 FrameData(); 165 virtual ~FrameData(); 166 void AsValueInto(base::debug::TracedValue* value) const; 167 168 std::vector<gfx::Rect> occluding_screen_space_rects; 169 std::vector<gfx::Rect> non_occluding_screen_space_rects; 170 RenderPassList render_passes; 171 RenderPassIdHashMap render_passes_by_id; 172 const LayerImplList* render_surface_layer_list; 173 LayerImplList will_draw_layers; 174 bool contains_incomplete_tile; 175 bool has_no_damage; 176 177 // RenderPassSink implementation. 178 virtual void AppendRenderPass(scoped_ptr<RenderPass> render_pass) OVERRIDE; 179 }; 180 181 virtual void BeginMainFrameAborted(bool did_handle); 182 virtual void BeginCommit(); 183 virtual void CommitComplete(); 184 virtual void Animate(base::TimeTicks monotonic_time); 185 virtual void UpdateAnimationState(bool start_ready_animations); 186 void ActivateAnimations(); 187 void MainThreadHasStoppedFlinging(); 188 void UpdateBackgroundAnimateTicking(bool should_background_tick); 189 void DidAnimateScrollOffset(); 190 void SetViewportDamage(const gfx::Rect& damage_rect); 191 192 virtual void ManageTiles(); 193 194 // Returns DRAW_SUCCESS unless problems occured preparing the frame, and we 195 // should try to avoid displaying the frame. If PrepareToDraw is called, 196 // DidDrawAllLayers must also be called, regardless of whether DrawLayers is 197 // called between the two. 198 virtual DrawResult PrepareToDraw(FrameData* frame); 199 virtual void DrawLayers(FrameData* frame, base::TimeTicks frame_begin_time); 200 // Must be called if and only if PrepareToDraw was called. 201 void DidDrawAllLayers(const FrameData& frame); 202 settings()203 const LayerTreeSettings& settings() const { return settings_; } 204 205 // Evict all textures by enforcing a memory policy with an allocation of 0. 206 void EvictTexturesForTesting(); 207 208 // When blocking, this prevents client_->NotifyReadyToActivate() from being 209 // called. When disabled, it calls client_->NotifyReadyToActivate() 210 // immediately if any notifications had been blocked while blocking. 211 virtual void BlockNotifyReadyToActivateForTesting(bool block); 212 213 // This allows us to inject DidInitializeVisibleTile events for testing. 214 void DidInitializeVisibleTileForTesting(); 215 216 // Resets all of the trees to an empty state. 217 void ResetTreesForTesting(); 218 void ResetRecycleTreeForTesting(); 219 220 DrawMode GetDrawMode() const; 221 222 // Viewport size in draw space: this size is in physical pixels and is used 223 // for draw properties, tilings, quads and render passes. 224 gfx::Size DrawViewportSize() const; 225 226 // Viewport rect in view space used for tiling prioritization. 227 const gfx::Rect ViewportRectForTilePriority() const; 228 229 // RendererClient implementation. 230 virtual void SetFullRootLayerDamage() OVERRIDE; 231 232 // TileManagerClient implementation. 233 virtual const std::vector<PictureLayerImpl*>& GetPictureLayers() 234 const OVERRIDE; 235 virtual void NotifyReadyToActivate() OVERRIDE; 236 virtual void NotifyTileStateChanged(const Tile* tile) OVERRIDE; 237 virtual void BuildRasterQueue(RasterTilePriorityQueue* queue, 238 TreePriority tree_priority) OVERRIDE; 239 virtual void BuildEvictionQueue(EvictionTilePriorityQueue* queue, 240 TreePriority tree_priority) OVERRIDE; 241 242 // ScrollbarAnimationControllerClient implementation. 243 virtual void PostDelayedScrollbarFade(const base::Closure& start_fade, 244 base::TimeDelta delay) OVERRIDE; 245 virtual void SetNeedsScrollbarAnimationFrame() OVERRIDE; 246 247 // OutputSurfaceClient implementation. 248 virtual void DeferredInitialize() OVERRIDE; 249 virtual void ReleaseGL() OVERRIDE; 250 virtual void CommitVSyncParameters(base::TimeTicks timebase, 251 base::TimeDelta interval) OVERRIDE; 252 virtual void SetNeedsRedrawRect(const gfx::Rect& rect) OVERRIDE; 253 virtual void BeginFrame(const BeginFrameArgs& args) OVERRIDE; 254 255 virtual void SetExternalDrawConstraints( 256 const gfx::Transform& transform, 257 const gfx::Rect& viewport, 258 const gfx::Rect& clip, 259 const gfx::Rect& viewport_rect_for_tile_priority, 260 const gfx::Transform& transform_for_tile_priority, 261 bool resourceless_software_draw) OVERRIDE; 262 virtual void DidLoseOutputSurface() OVERRIDE; 263 virtual void DidSwapBuffers() OVERRIDE; 264 virtual void DidSwapBuffersComplete() OVERRIDE; 265 virtual void ReclaimResources(const CompositorFrameAck* ack) OVERRIDE; 266 virtual void SetMemoryPolicy(const ManagedMemoryPolicy& policy) OVERRIDE; 267 virtual void SetTreeActivationCallback(const base::Closure& callback) 268 OVERRIDE; 269 270 // Called from LayerTreeImpl. 271 void OnCanDrawStateChangedForTree(); 272 273 // Implementation. id()274 int id() const { return id_; } 275 bool CanDraw() const; output_surface()276 OutputSurface* output_surface() const { return output_surface_.get(); } 277 278 std::string LayerTreeAsJson() const; 279 280 void FinishAllRendering(); 281 int SourceAnimationFrameNumber() const; 282 283 virtual bool InitializeRenderer(scoped_ptr<OutputSurface> output_surface); tile_manager()284 TileManager* tile_manager() { return tile_manager_.get(); } 285 void SetUseGpuRasterization(bool use_gpu); use_gpu_rasterization()286 bool use_gpu_rasterization() const { return use_gpu_rasterization_; } create_low_res_tiling()287 bool create_low_res_tiling() const { 288 return settings_.create_low_res_tiling && !use_gpu_rasterization_; 289 } resource_pool()290 ResourcePool* resource_pool() { return resource_pool_.get(); } renderer()291 Renderer* renderer() { return renderer_.get(); } 292 const RendererCapabilitiesImpl& GetRendererCapabilities() const; 293 294 virtual bool SwapBuffers(const FrameData& frame); 295 void SetNeedsBeginFrame(bool enable); 296 virtual void WillBeginImplFrame(const BeginFrameArgs& args); 297 void DidModifyTilePriorities(); 298 active_tree()299 LayerTreeImpl* active_tree() { return active_tree_.get(); } active_tree()300 const LayerTreeImpl* active_tree() const { return active_tree_.get(); } pending_tree()301 LayerTreeImpl* pending_tree() { return pending_tree_.get(); } pending_tree()302 const LayerTreeImpl* pending_tree() const { return pending_tree_.get(); } recycle_tree()303 LayerTreeImpl* recycle_tree() { return recycle_tree_.get(); } recycle_tree()304 const LayerTreeImpl* recycle_tree() const { return recycle_tree_.get(); } 305 // Returns the tree LTH synchronizes with. sync_tree()306 LayerTreeImpl* sync_tree() { 307 return pending_tree_ ? pending_tree_.get() : active_tree_.get(); 308 } 309 virtual void CreatePendingTree(); 310 virtual void UpdateVisibleTiles(); 311 virtual void ActivateSyncTree(); 312 313 // Shortcuts to layers on the active tree. 314 LayerImpl* RootLayer() const; 315 LayerImpl* InnerViewportScrollLayer() const; 316 LayerImpl* OuterViewportScrollLayer() const; 317 LayerImpl* CurrentlyScrollingLayer() const; 318 scroll_layer_id_when_mouse_over_scrollbar()319 int scroll_layer_id_when_mouse_over_scrollbar() const { 320 return scroll_layer_id_when_mouse_over_scrollbar_; 321 } scroll_affects_scroll_handler()322 bool scroll_affects_scroll_handler() const { 323 return scroll_affects_scroll_handler_; 324 } 325 void QueueSwapPromiseForMainThreadScrollUpdate( 326 scoped_ptr<SwapPromise> swap_promise); 327 328 bool IsActivelyScrolling() const; 329 330 virtual void SetVisible(bool visible); visible()331 bool visible() const { return visible_; } 332 SetNeedsCommit()333 void SetNeedsCommit() { client_->SetNeedsCommitOnImplThread(); } 334 void SetNeedsRedraw(); 335 336 ManagedMemoryPolicy ActualManagedMemoryPolicy() const; 337 338 size_t memory_allocation_limit_bytes() const; 339 int memory_allocation_priority_cutoff() const; 340 341 void SetViewportSize(const gfx::Size& device_viewport_size); device_viewport_size()342 gfx::Size device_viewport_size() const { return device_viewport_size_; } 343 344 void SetOverhangUIResource(UIResourceId overhang_ui_resource_id, 345 const gfx::Size& overhang_ui_resource_size); 346 347 void SetDeviceScaleFactor(float device_scale_factor); device_scale_factor()348 float device_scale_factor() const { return device_scale_factor_; } 349 350 const gfx::Transform& DrawTransform() const; 351 352 scoped_ptr<ScrollAndScaleSet> ProcessScrollDeltas(); 353 needs_animate_layers()354 bool needs_animate_layers() const { 355 return !animation_registrar_->active_animation_controllers().empty(); 356 } 357 set_max_memory_needed_bytes(size_t bytes)358 void set_max_memory_needed_bytes(size_t bytes) { 359 max_memory_needed_bytes_ = bytes; 360 } 361 fps_counter()362 FrameRateCounter* fps_counter() { 363 return fps_counter_.get(); 364 } paint_time_counter()365 PaintTimeCounter* paint_time_counter() { 366 return paint_time_counter_.get(); 367 } memory_history()368 MemoryHistory* memory_history() { 369 return memory_history_.get(); 370 } debug_rect_history()371 DebugRectHistory* debug_rect_history() { 372 return debug_rect_history_.get(); 373 } resource_provider()374 ResourceProvider* resource_provider() { 375 return resource_provider_.get(); 376 } top_controls_manager()377 TopControlsManager* top_controls_manager() { 378 return top_controls_manager_.get(); 379 } global_tile_state()380 const GlobalStateThatImpactsTilePriority& global_tile_state() { 381 return global_tile_state_; 382 } 383 proxy()384 Proxy* proxy() const { return proxy_; } 385 animation_registrar()386 AnimationRegistrar* animation_registrar() const { 387 return animation_registrar_.get(); 388 } 389 390 void SetDebugState(const LayerTreeDebugState& new_debug_state); debug_state()391 const LayerTreeDebugState& debug_state() const { return debug_state_; } 392 393 class CC_EXPORT CullRenderPassesWithNoQuads { 394 public: 395 bool ShouldRemoveRenderPass(const RenderPassDrawQuad& quad, 396 const FrameData& frame) const; 397 398 // Iterates in draw order, so that when a surface is removed, and its 399 // target becomes empty, then its target can be removed also. RenderPassListBegin(const RenderPassList & list)400 size_t RenderPassListBegin(const RenderPassList& list) const { return 0; } RenderPassListEnd(const RenderPassList & list)401 size_t RenderPassListEnd(const RenderPassList& list) const { 402 return list.size(); 403 } RenderPassListNext(size_t it)404 size_t RenderPassListNext(size_t it) const { return it + 1; } 405 }; 406 407 template <typename RenderPassCuller> 408 static void RemoveRenderPasses(RenderPassCuller culler, FrameData* frame); 409 accumulated_root_overscroll()410 gfx::Vector2dF accumulated_root_overscroll() const { 411 return accumulated_root_overscroll_; 412 } 413 pinch_gesture_active()414 bool pinch_gesture_active() const { return pinch_gesture_active_; } 415 416 void SetTreePriority(TreePriority priority); 417 418 void UpdateCurrentBeginFrameArgs(const BeginFrameArgs& args); 419 void ResetCurrentBeginFrameArgsForNextFrame(); 420 virtual BeginFrameArgs CurrentBeginFrameArgs() const; 421 422 // Expected time between two begin impl frame calls. begin_impl_frame_interval()423 base::TimeDelta begin_impl_frame_interval() const { 424 return begin_impl_frame_interval_; 425 } 426 AsValueInto(base::debug::TracedValue * value)427 void AsValueInto(base::debug::TracedValue* value) const { 428 return AsValueWithFrameInto(NULL, value); 429 } 430 void AsValueWithFrameInto(FrameData* frame, 431 base::debug::TracedValue* value) const; 432 scoped_refptr<base::debug::ConvertableToTraceFormat> AsValue() const; 433 scoped_refptr<base::debug::ConvertableToTraceFormat> AsValueWithFrame( 434 FrameData* frame) const; 435 scoped_refptr<base::debug::ConvertableToTraceFormat> ActivationStateAsValue() 436 const; 437 void ActivationStateAsValueInto(base::debug::TracedValue* value) const; 438 page_scale_animation_active()439 bool page_scale_animation_active() const { return !!page_scale_animation_; } 440 441 virtual void CreateUIResource(UIResourceId uid, 442 const UIResourceBitmap& bitmap); 443 // Deletes a UI resource. May safely be called more than once. 444 virtual void DeleteUIResource(UIResourceId uid); 445 void EvictAllUIResources(); 446 bool EvictedUIResourcesExist() const; 447 448 virtual ResourceProvider::ResourceId ResourceIdForUIResource( 449 UIResourceId uid) const; 450 451 virtual bool IsUIResourceOpaque(UIResourceId uid) const; 452 453 struct UIResourceData { 454 ResourceProvider::ResourceId resource_id; 455 gfx::Size size; 456 bool opaque; 457 }; 458 459 void ScheduleMicroBenchmark(scoped_ptr<MicroBenchmarkImpl> benchmark); 460 461 CompositorFrameMetadata MakeCompositorFrameMetadata() const; 462 // Viewport rectangle and clip in nonflipped window space. These rects 463 // should only be used by Renderer subclasses to populate glViewport/glClip 464 // and their software-mode equivalents. 465 gfx::Rect DeviceViewport() const; 466 gfx::Rect DeviceClip() const; 467 468 // When a SwapPromiseMonitor is created on the impl thread, it calls 469 // InsertSwapPromiseMonitor() to register itself with LayerTreeHostImpl. 470 // When the monitor is destroyed, it calls RemoveSwapPromiseMonitor() 471 // to unregister itself. 472 void InsertSwapPromiseMonitor(SwapPromiseMonitor* monitor); 473 void RemoveSwapPromiseMonitor(SwapPromiseMonitor* monitor); 474 475 void RegisterPictureLayerImpl(PictureLayerImpl* layer); 476 void UnregisterPictureLayerImpl(PictureLayerImpl* layer); 477 478 void GetPictureLayerImplPairs( 479 std::vector<PictureLayerImpl::Pair>* layers) const; 480 481 void SetTopControlsLayoutHeight(float height); 482 483 protected: 484 LayerTreeHostImpl( 485 const LayerTreeSettings& settings, 486 LayerTreeHostImplClient* client, 487 Proxy* proxy, 488 RenderingStatsInstrumentation* rendering_stats_instrumentation, 489 SharedBitmapManager* manager, 490 int id); 491 492 void UpdateInnerViewportContainerSize(); 493 494 // Virtual for testing. 495 virtual void AnimateLayers(base::TimeTicks monotonic_time); 496 497 // Virtual for testing. 498 virtual base::TimeDelta LowFrequencyAnimationInterval() const; 499 500 const AnimationRegistrar::AnimationControllerMap& active_animation_controllers()501 active_animation_controllers() const { 502 return animation_registrar_->active_animation_controllers(); 503 } 504 manage_tiles_needed()505 bool manage_tiles_needed() const { return tile_priorities_dirty_; } 506 507 LayerTreeHostImplClient* client_; 508 Proxy* proxy_; 509 510 private: 511 void CreateAndSetRenderer(); 512 void CreateAndSetTileManager(); 513 void DestroyTileManager(); 514 void ReleaseTreeResources(); 515 void EnforceZeroBudget(bool zero_budget); 516 517 bool UsePendingTreeForSync() const; 518 bool UseZeroCopyRasterizer() const; 519 bool UseOneCopyRasterizer() const; 520 521 void ScrollViewportBy(gfx::Vector2dF scroll_delta); 522 void AnimatePageScale(base::TimeTicks monotonic_time); 523 void AnimateScrollbars(base::TimeTicks monotonic_time); 524 void AnimateTopControls(base::TimeTicks monotonic_time); 525 526 gfx::Vector2dF ScrollLayerWithViewportSpaceDelta( 527 LayerImpl* layer_impl, 528 float scale_from_viewport_to_screen_space, 529 const gfx::PointF& viewport_point, 530 const gfx::Vector2dF& viewport_delta); 531 532 void TrackDamageForAllSurfaces( 533 LayerImpl* root_draw_layer, 534 const LayerImplList& render_surface_layer_list); 535 536 void UpdateTileManagerMemoryPolicy(const ManagedMemoryPolicy& policy); 537 538 // This function should only be called from PrepareToDraw, as DidDrawAllLayers 539 // must be called if this helper function is called. Returns DRAW_SUCCESS if 540 // the frame should be drawn. 541 DrawResult CalculateRenderPasses(FrameData* frame); 542 543 void ClearCurrentlyScrollingLayer(); 544 545 bool HandleMouseOverScrollbar(LayerImpl* layer_impl, 546 const gfx::PointF& device_viewport_point); 547 548 void AnimateScrollbarsRecursive(LayerImpl* layer, 549 base::TimeTicks time); 550 551 LayerImpl* FindScrollLayerForDeviceViewportPoint( 552 const gfx::PointF& device_viewport_point, 553 InputHandler::ScrollInputType type, 554 LayerImpl* layer_hit_by_point, 555 bool* scroll_on_main_thread, 556 bool* optional_has_ancestor_scroll_handler) const; 557 float DeviceSpaceDistanceToLayer(const gfx::PointF& device_viewport_point, 558 LayerImpl* layer_impl); 559 void StartScrollbarFadeRecursive(LayerImpl* layer); 560 void SetManagedMemoryPolicy(const ManagedMemoryPolicy& policy, 561 bool zero_budget); 562 void EnforceManagedMemoryPolicy(const ManagedMemoryPolicy& policy); 563 564 void DidInitializeVisibleTile(); 565 566 void MarkUIResourceNotEvicted(UIResourceId uid); 567 568 void NotifySwapPromiseMonitorsOfSetNeedsRedraw(); 569 void NotifySwapPromiseMonitorsOfForwardingToMainThread(); 570 571 typedef base::hash_map<UIResourceId, UIResourceData> 572 UIResourceMap; 573 UIResourceMap ui_resource_map_; 574 575 // Resources that were evicted by EvictAllUIResources. Resources are removed 576 // from this when they are touched by a create or destroy from the UI resource 577 // request queue. 578 std::set<UIResourceId> evicted_ui_resources_; 579 580 scoped_ptr<OutputSurface> output_surface_; 581 582 // |resource_provider_| and |tile_manager_| can be NULL, e.g. when using tile- 583 // free rendering - see OutputSurface::ForcedDrawToSoftwareDevice(). 584 scoped_ptr<ResourceProvider> resource_provider_; 585 scoped_ptr<TileManager> tile_manager_; 586 bool use_gpu_rasterization_; 587 scoped_ptr<RasterWorkerPool> raster_worker_pool_; 588 scoped_ptr<ResourcePool> resource_pool_; 589 scoped_ptr<ResourcePool> staging_resource_pool_; 590 scoped_ptr<Renderer> renderer_; 591 592 GlobalStateThatImpactsTilePriority global_tile_state_; 593 594 // Tree currently being drawn. 595 scoped_ptr<LayerTreeImpl> active_tree_; 596 597 // In impl-side painting mode, tree with possibly incomplete rasterized 598 // content. May be promoted to active by ActivatePendingTree(). 599 scoped_ptr<LayerTreeImpl> pending_tree_; 600 601 // In impl-side painting mode, inert tree with layers that can be recycled 602 // by the next sync from the main thread. 603 scoped_ptr<LayerTreeImpl> recycle_tree_; 604 605 InputHandlerClient* input_handler_client_; 606 bool did_lock_scrolling_layer_; 607 bool should_bubble_scrolls_; 608 bool wheel_scrolling_; 609 bool scroll_affects_scroll_handler_; 610 int scroll_layer_id_when_mouse_over_scrollbar_; 611 ScopedPtrVector<SwapPromise> swap_promises_for_main_thread_scroll_update_; 612 613 bool tile_priorities_dirty_; 614 615 // The optional delegate for the root layer scroll offset. 616 LayerScrollOffsetDelegate* root_layer_scroll_offset_delegate_; 617 LayerTreeSettings settings_; 618 LayerTreeDebugState debug_state_; 619 bool visible_; 620 ManagedMemoryPolicy cached_managed_memory_policy_; 621 622 gfx::Vector2dF accumulated_root_overscroll_; 623 624 bool pinch_gesture_active_; 625 bool pinch_gesture_end_should_clear_scrolling_layer_; 626 gfx::Point previous_pinch_anchor_; 627 628 scoped_ptr<TopControlsManager> top_controls_manager_; 629 630 scoped_ptr<PageScaleAnimation> page_scale_animation_; 631 632 // This is used for ticking animations slowly when hidden. 633 scoped_ptr<LayerTreeHostImplTimeSourceAdapter> time_source_client_adapter_; 634 635 scoped_ptr<FrameRateCounter> fps_counter_; 636 scoped_ptr<PaintTimeCounter> paint_time_counter_; 637 scoped_ptr<MemoryHistory> memory_history_; 638 scoped_ptr<DebugRectHistory> debug_rect_history_; 639 640 scoped_ptr<TextureMailboxDeleter> texture_mailbox_deleter_; 641 642 // The maximum memory that would be used by the prioritized resource 643 // manager, if there were no limit on memory usage. 644 size_t max_memory_needed_bytes_; 645 646 bool zero_budget_; 647 648 // Viewport size passed in from the main thread, in physical pixels. This 649 // value is the default size for all concepts of physical viewport (draw 650 // viewport, scrolling viewport and device viewport), but it can be 651 // overridden. 652 gfx::Size device_viewport_size_; 653 654 // Conversion factor from CSS pixels to physical pixels when 655 // pageScaleFactor=1. 656 float device_scale_factor_; 657 658 // UI resource to use for drawing overhang gutters. 659 UIResourceId overhang_ui_resource_id_; 660 gfx::Size overhang_ui_resource_size_; 661 662 // Optional top-level constraints that can be set by the OutputSurface. 663 // - external_transform_ applies a transform above the root layer 664 // - external_viewport_ is used DrawProperties, tile management and 665 // glViewport/window projection matrix. 666 // - external_clip_ specifies a top-level clip rect 667 // - viewport_rect_for_tile_priority_ is the rect in view space used for 668 // tiling priority. 669 gfx::Transform external_transform_; 670 gfx::Rect external_viewport_; 671 gfx::Rect external_clip_; 672 gfx::Rect viewport_rect_for_tile_priority_; 673 bool resourceless_software_draw_; 674 675 gfx::Rect viewport_damage_rect_; 676 677 BeginFrameArgs current_begin_frame_args_; 678 679 // Expected time between two begin impl frame calls. 680 base::TimeDelta begin_impl_frame_interval_; 681 682 scoped_ptr<AnimationRegistrar> animation_registrar_; 683 684 RenderingStatsInstrumentation* rendering_stats_instrumentation_; 685 MicroBenchmarkControllerImpl micro_benchmark_controller_; 686 687 bool need_to_update_visible_tiles_before_draw_; 688 689 // Optional callback to notify of new tree activations. 690 base::Closure tree_activation_callback_; 691 692 SharedBitmapManager* shared_bitmap_manager_; 693 int id_; 694 695 std::set<SwapPromiseMonitor*> swap_promise_monitor_; 696 697 std::vector<PictureLayerImpl*> picture_layers_; 698 std::vector<PictureLayerImpl::Pair> picture_layer_pairs_; 699 700 DISALLOW_COPY_AND_ASSIGN(LayerTreeHostImpl); 701 }; 702 703 } // namespace cc 704 705 #endif // CC_TREES_LAYER_TREE_HOST_IMPL_H_ 706