| // Copyright 2012 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_TREES_LAYER_TREE_IMPL_H_ |
| #define CC_TREES_LAYER_TREE_IMPL_H_ |
| |
| #include <map> |
| #include <memory> |
| #include <set> |
| #include <string> |
| #include <unordered_map> |
| #include <utility> |
| #include <vector> |
| |
| #include "base/containers/flat_set.h" |
| #include "base/time/time.h" |
| #include "base/values.h" |
| #include "cc/base/synced_property.h" |
| #include "cc/input/browser_controls_offset_manager.h" |
| #include "cc/input/event_listener_properties.h" |
| #include "cc/input/layer_selection_bound.h" |
| #include "cc/input/overscroll_behavior.h" |
| #include "cc/layers/layer_impl.h" |
| #include "cc/layers/layer_list_iterator.h" |
| #include "cc/metrics/event_metrics.h" |
| #include "cc/paint/discardable_image_map.h" |
| #include "cc/resources/ui_resource_client.h" |
| #include "cc/trees/browser_controls_params.h" |
| #include "cc/trees/layer_tree_host.h" |
| #include "cc/trees/layer_tree_host_impl.h" |
| #include "cc/trees/property_tree.h" |
| #include "cc/trees/swap_promise.h" |
| #include "components/viz/common/frame_sinks/begin_frame_args.h" |
| #include "ui/gfx/overlay_transform.h" |
| |
| namespace base { |
| namespace trace_event { |
| class TracedValue; |
| } |
| } |
| |
| namespace viz { |
| class ClientResourceProvider; |
| class ContextProvider; |
| } |
| |
| namespace cc { |
| |
| class DebugRectHistory; |
| class DroppedFrameCounter; |
| class HeadsUpDisplayLayerImpl; |
| class ImageDecodeCache; |
| class LayerTreeDebugState; |
| class LayerTreeImpl; |
| class LayerTreeFrameSink; |
| class LayerTreeSettings; |
| class MemoryHistory; |
| class PictureLayerImpl; |
| class TaskRunnerProvider; |
| class TileManager; |
| class UIResourceRequest; |
| class VideoFrameControllerClient; |
| struct PendingPageScaleAnimation; |
| |
| typedef std::vector<UIResourceRequest> UIResourceRequestQueue; |
| typedef SyncedProperty<AdditionGroup<float>> SyncedBrowserControls; |
| typedef SyncedProperty<AdditionGroup<gfx::Vector2dF>> SyncedElasticOverscroll; |
| |
| class LayerTreeLifecycle { |
| public: |
| enum LifecycleState { |
| kNotSyncing, |
| |
| // The following states are the steps performed when syncing properties to |
| // this tree (see: LayerTreeHost::FinishCommitOnImplThread or |
| // LayerTreeHostImpl::ActivateSyncTree). |
| kBeginningSync, |
| kSyncedPropertyTrees, |
| kSyncedLayerProperties, |
| kLastSyncState = kSyncedLayerProperties, |
| |
| // TODO(pdr): Add states to cover more than just the synchronization steps. |
| }; |
| |
| void AdvanceTo(LifecycleState); |
| |
| bool AllowsPropertyTreeAccess() const { |
| return state_ == kNotSyncing || state_ >= kSyncedPropertyTrees; |
| } |
| bool AllowsLayerPropertyAccess() const { |
| return state_ == kNotSyncing || state_ >= kSyncedLayerProperties; |
| } |
| |
| private: |
| LifecycleState state_ = kNotSyncing; |
| }; |
| |
| class CC_EXPORT LayerTreeImpl { |
| public: |
| // This is the number of times a fixed point has to be hit continuously by a |
| // layer to consider it as jittering. |
| enum : int { kFixedPointHitsThreshold = 3 }; |
| LayerTreeImpl( |
| LayerTreeHostImpl* host_impl, |
| scoped_refptr<SyncedProperty<ScaleGroup>> page_scale_factor, |
| scoped_refptr<SyncedBrowserControls> top_controls_shown_ratio, |
| scoped_refptr<SyncedBrowserControls> bottom_controls_shown_ratio, |
| scoped_refptr<SyncedElasticOverscroll> elastic_overscroll); |
| LayerTreeImpl(const LayerTreeImpl&) = delete; |
| virtual ~LayerTreeImpl(); |
| |
| LayerTreeImpl& operator=(const LayerTreeImpl&) = delete; |
| |
| void Shutdown(); |
| void ReleaseResources(); |
| void OnPurgeMemory(); |
| void ReleaseTileResources(); |
| void RecreateTileResources(); |
| |
| // Methods called by the layer tree that pass-through or access LTHI. |
| // --------------------------------------------------------------------------- |
| LayerTreeFrameSink* layer_tree_frame_sink(); |
| int max_texture_size() const; |
| const LayerTreeSettings& settings() const; |
| const LayerTreeDebugState& debug_state() const; |
| viz::ContextProvider* context_provider() const; |
| viz::ClientResourceProvider* resource_provider() const; |
| TileManager* tile_manager() const; |
| ImageDecodeCache* image_decode_cache() const; |
| ImageAnimationController* image_animation_controller() const; |
| DroppedFrameCounter* dropped_frame_counter() const; |
| MemoryHistory* memory_history() const; |
| DebugRectHistory* debug_rect_history() const; |
| bool IsActiveTree() const; |
| bool IsPendingTree() const; |
| bool IsRecycleTree() const; |
| bool IsSyncTree() const; |
| LayerImpl* FindActiveTreeLayerById(int id); |
| LayerImpl* FindPendingTreeLayerById(int id); |
| // TODO(bokan): PinchGestureActive is a layering violation, it's not related |
| // to what LayerTreeImpl does. |
| bool PinchGestureActive() const; |
| const viz::BeginFrameArgs& CurrentBeginFrameArgs() const; |
| base::TimeDelta CurrentBeginFrameInterval() const; |
| const gfx::Rect ViewportRectForTilePriority() const; |
| std::unique_ptr<ScrollbarAnimationController> |
| CreateScrollbarAnimationController(ElementId scroll_element_id, |
| float initial_opacity); |
| void DidAnimateScrollOffset(); |
| bool use_gpu_rasterization() const; |
| GpuRasterizationStatus GetGpuRasterizationStatus() const; |
| bool create_low_res_tiling() const; |
| bool RequiresHighResToDraw() const; |
| bool SmoothnessTakesPriority() const; |
| VideoFrameControllerClient* GetVideoFrameControllerClient() const; |
| MutatorHost* mutator_host() const { return host_impl_->mutator_host(); } |
| void UpdateImageDecodingHints( |
| base::flat_map<PaintImage::Id, PaintImage::DecodingMode> |
| decoding_mode_map); |
| int GetMSAASampleCountForRaster( |
| const scoped_refptr<DisplayItemList>& display_list); |
| gfx::ColorSpace GetRasterColorSpace( |
| gfx::ContentColorUsage content_color_usage) const; |
| |
| // Tree specific methods exposed to layer-impl tree. |
| // --------------------------------------------------------------------------- |
| void SetNeedsRedraw(); |
| |
| // Tracing methods. |
| // --------------------------------------------------------------------------- |
| void GetAllPrioritizedTilesForTracing( |
| std::vector<PrioritizedTile>* prioritized_tiles) const; |
| void AsValueInto(base::trace_event::TracedValue* dict) const; |
| |
| // Other public methods |
| // --------------------------------------------------------------------------- |
| LayerImpl* root_layer() { |
| return layer_list_.empty() ? nullptr : layer_list_[0].get(); |
| } |
| const RenderSurfaceImpl* RootRenderSurface() const; |
| bool LayerListIsEmpty() const; |
| void SetRootLayerForTesting(std::unique_ptr<LayerImpl>); |
| void OnCanDrawStateChangedForTree(); |
| bool IsRootLayer(const LayerImpl* layer) const; |
| |
| OwnedLayerImplList DetachLayers(); |
| OwnedLayerImplList DetachLayersKeepingRootLayerForTesting(); |
| |
| void SetPropertyTrees(PropertyTrees* property_trees); |
| PropertyTrees* property_trees() { |
| // TODO(pdr): We should enable this DCHECK because it will catch uses of |
| // stale property trees, but it currently fails too many existing tests. |
| // DCHECK(lifecycle().AllowsPropertyTreeAccess()); |
| return &property_trees_; |
| } |
| const PropertyTrees* property_trees() const { return &property_trees_; } |
| |
| void PushPropertyTreesTo(LayerTreeImpl* tree_impl); |
| void PushPropertiesTo(LayerTreeImpl* tree_impl); |
| void PushSurfaceRangesTo(LayerTreeImpl* tree_impl); |
| |
| void MoveChangeTrackingToLayers(); |
| |
| void ForceRecalculateRasterScales(); |
| |
| // Adapts an iterator of std::unique_ptr<LayerImpl> to an iterator of |
| // LayerImpl*. |
| template <typename Iterator> |
| class IteratorAdapter |
| : public std::iterator<std::forward_iterator_tag, LayerImpl*> { |
| public: |
| explicit IteratorAdapter(Iterator it) : it_(it) {} |
| bool operator==(IteratorAdapter o) const { return it_ == o.it_; } |
| bool operator!=(IteratorAdapter o) const { return !(*this == o); } |
| LayerImpl* operator*() const { return it_->get(); } |
| LayerImpl* operator->() const { return it_->get(); } |
| IteratorAdapter& operator++() { |
| ++it_; |
| return *this; |
| } |
| |
| private: |
| Iterator it_; |
| }; |
| using const_iterator = IteratorAdapter<OwnedLayerImplList::const_iterator>; |
| using const_reverse_iterator = |
| IteratorAdapter<OwnedLayerImplList::const_reverse_iterator>; |
| const_iterator begin() const { return const_iterator(layer_list_.cbegin()); } |
| const_iterator end() const { return const_iterator(layer_list_.cend()); } |
| const_reverse_iterator rbegin() const { |
| return const_reverse_iterator(layer_list_.crbegin()); |
| } |
| const_reverse_iterator rend() const { |
| return const_reverse_iterator(layer_list_.crend()); |
| } |
| |
| void SetTransformMutated(ElementId element_id, |
| const gfx::Transform& transform); |
| void SetOpacityMutated(ElementId element_id, float opacity); |
| void SetFilterMutated(ElementId element_id, const FilterOperations& filters); |
| void SetBackdropFilterMutated(ElementId element_id, |
| const FilterOperations& backdrop_filters); |
| |
| const std::unordered_map<ElementId, float, ElementIdHash>& |
| element_id_to_opacity_animations_for_testing() const { |
| return element_id_to_opacity_animations_; |
| } |
| const std::unordered_map<ElementId, gfx::Transform, ElementIdHash>& |
| element_id_to_transform_animations_for_testing() const { |
| return element_id_to_transform_animations_; |
| } |
| const std::unordered_map<ElementId, FilterOperations, ElementIdHash>& |
| element_id_to_filter_animations_for_testing() const { |
| return element_id_to_filter_animations_; |
| } |
| const std::unordered_map<ElementId, FilterOperations, ElementIdHash>& |
| element_id_to_backdrop_filter_animations_for_testing() const { |
| return element_id_to_backdrop_filter_animations_; |
| } |
| |
| int source_frame_number() const { return source_frame_number_; } |
| void set_source_frame_number(int frame_number) { |
| source_frame_number_ = frame_number; |
| } |
| |
| bool is_first_frame_after_commit() const { |
| return source_frame_number_ != is_first_frame_after_commit_tracker_; |
| } |
| |
| void set_is_first_frame_after_commit(bool is_first_frame_after_commit) { |
| is_first_frame_after_commit_tracker_ = |
| is_first_frame_after_commit ? -1 : source_frame_number_; |
| } |
| |
| const HeadsUpDisplayLayerImpl* hud_layer() const { return hud_layer_; } |
| HeadsUpDisplayLayerImpl* hud_layer() { return hud_layer_; } |
| void set_hud_layer(HeadsUpDisplayLayerImpl* layer_impl) { |
| hud_layer_ = layer_impl; |
| } |
| |
| gfx::ScrollOffset TotalScrollOffset() const; |
| gfx::ScrollOffset TotalMaxScrollOffset() const; |
| |
| void AddPresentationCallbacks( |
| std::vector<LayerTreeHost::PresentationTimeCallback> callbacks); |
| std::vector<LayerTreeHost::PresentationTimeCallback> |
| TakePresentationCallbacks(); |
| bool has_presentation_callbacks() const { |
| return !presentation_callbacks_.empty(); |
| } |
| |
| // The following viewport related property nodes will only ever be set on the |
| // main-frame's renderer (i.e. OOPIF and UI compositors will not have these |
| // set. |
| using ViewportPropertyIds = LayerTreeHost::ViewportPropertyIds; |
| void SetViewportPropertyIds(const ViewportPropertyIds& ids); |
| |
| const TransformNode* OverscrollElasticityTransformNode() const; |
| TransformNode* OverscrollElasticityTransformNode() { |
| return const_cast<TransformNode*>( |
| const_cast<const LayerTreeImpl*>(this) |
| ->OverscrollElasticityTransformNode()); |
| } |
| const TransformNode* PageScaleTransformNode() const; |
| TransformNode* PageScaleTransformNode() { |
| return const_cast<TransformNode*>( |
| const_cast<const LayerTreeImpl*>(this)->PageScaleTransformNode()); |
| } |
| const ScrollNode* InnerViewportScrollNode() const; |
| ScrollNode* InnerViewportScrollNode() { |
| return const_cast<ScrollNode*>( |
| const_cast<const LayerTreeImpl*>(this)->InnerViewportScrollNode()); |
| } |
| const ClipNode* OuterViewportClipNode() const; |
| ClipNode* OuterViewportClipNode() { |
| return const_cast<ClipNode*>( |
| const_cast<const LayerTreeImpl*>(this)->OuterViewportClipNode()); |
| } |
| const ScrollNode* OuterViewportScrollNode() const; |
| ScrollNode* OuterViewportScrollNode() { |
| return const_cast<ScrollNode*>( |
| const_cast<const LayerTreeImpl*>(this)->OuterViewportScrollNode()); |
| } |
| |
| LayerTreeHost::ViewportPropertyIds ViewportPropertyIdsForTesting() const { |
| return viewport_property_ids_; |
| } |
| LayerImpl* InnerViewportScrollLayerForTesting() const; |
| LayerImpl* OuterViewportScrollLayerForTesting() const; |
| |
| ScrollNode* CurrentlyScrollingNode(); |
| const ScrollNode* CurrentlyScrollingNode() const; |
| int LastScrolledScrollNodeIndex() const; |
| void SetCurrentlyScrollingNode(const ScrollNode* node); |
| void ClearCurrentlyScrollingNode(); |
| |
| void ApplySentScrollAndScaleDeltasFromAbortedCommit(); |
| |
| SkColor background_color() const { return background_color_; } |
| void set_background_color(SkColor color) { background_color_ = color; } |
| |
| gfx::OverlayTransform display_transform_hint() const { |
| return display_transform_hint_; |
| } |
| void set_display_transform_hint(gfx::OverlayTransform hint) { |
| display_transform_hint_ = hint; |
| } |
| |
| void UpdatePropertyTreeAnimationFromMainThread(); |
| |
| void SetPageScaleOnActiveTree(float active_page_scale); |
| void PushPageScaleFromMainThread(float page_scale_factor, |
| float min_page_scale_factor, |
| float max_page_scale_factor); |
| float current_page_scale_factor() const { |
| return page_scale_factor()->Current(IsActiveTree()); |
| } |
| float min_page_scale_factor() const { return min_page_scale_factor_; } |
| float max_page_scale_factor() const { return max_page_scale_factor_; } |
| |
| float page_scale_delta() const { return page_scale_factor()->Delta(); } |
| |
| SyncedProperty<ScaleGroup>* page_scale_factor(); |
| const SyncedProperty<ScaleGroup>* page_scale_factor() const; |
| |
| void SetDeviceScaleFactor(float device_scale_factor); |
| float device_scale_factor() const { return device_scale_factor_; } |
| |
| void set_painted_device_scale_factor(float painted_device_scale_factor) { |
| painted_device_scale_factor_ = painted_device_scale_factor; |
| } |
| float painted_device_scale_factor() const { |
| return painted_device_scale_factor_; |
| } |
| |
| void SetLocalSurfaceIdFromParent( |
| const viz::LocalSurfaceId& local_surface_id_from_parent); |
| const viz::LocalSurfaceId& local_surface_id_from_parent() const { |
| return local_surface_id_from_parent_; |
| } |
| |
| void RequestNewLocalSurfaceId(); |
| bool TakeNewLocalSurfaceIdRequest(); |
| bool new_local_surface_id_request_for_testing() const { |
| return new_local_surface_id_request_; |
| } |
| |
| void SetDeviceViewportRect(const gfx::Rect& device_viewport_rect); |
| |
| // TODO(fsamuel): The reason this is not a trivial accessor is because it |
| // may return an external viewport specified in LayerTreeHostImpl. In the |
| // future, all properties should flow through the pending and active layer |
| // trees and we shouldn't need to reach out to LayerTreeHostImpl. |
| gfx::Rect GetDeviceViewport() const; |
| |
| // This accessor is the same as above, except it only ever returns the |
| // internal (i.e. not external) device viewport. |
| gfx::Rect internal_device_viewport() { return device_viewport_rect_; } |
| |
| void SetDisplayColorSpaces( |
| const gfx::DisplayColorSpaces& display_color_spaces); |
| |
| // OOPIFs need to know the page scale factor used in the main frame, but it |
| // is distributed differently (via VisualPropertiesSync), and used only to |
| // set raster-scale (page_scale_factor has geometry implications that are |
| // inappropriate for OOPIFs). |
| void SetExternalPageScaleFactor(float external_page_scale_factor); |
| float external_page_scale_factor() const { |
| return external_page_scale_factor_; |
| } |
| // A function to provide page scale information for scaling scroll deltas. In |
| // top-level frames we store this value in page_scale_factor_, but for |
| // cross-process subframes it's stored in external_page_scale_factor_, so |
| // that it only affects raster scale. These cases are mutually exclusive, |
| // except for a page hosted in a <portal>, so only one of the values should |
| // ever vary from 1.f. |
| float page_scale_factor_for_scroll() const { |
| DCHECK(external_page_scale_factor_ == 1.f || |
| current_page_scale_factor() == 1.f || |
| !settings().is_layer_tree_for_subframe); |
| return external_page_scale_factor_ * current_page_scale_factor(); |
| } |
| const gfx::DisplayColorSpaces& display_color_spaces() const { |
| return display_color_spaces_; |
| } |
| |
| SyncedElasticOverscroll* elastic_overscroll() { |
| return elastic_overscroll_.get(); |
| } |
| const SyncedElasticOverscroll* elastic_overscroll() const { |
| return elastic_overscroll_.get(); |
| } |
| |
| SyncedBrowserControls* top_controls_shown_ratio() { |
| return top_controls_shown_ratio_.get(); |
| } |
| const SyncedBrowserControls* top_controls_shown_ratio() const { |
| return top_controls_shown_ratio_.get(); |
| } |
| SyncedBrowserControls* bottom_controls_shown_ratio() { |
| return bottom_controls_shown_ratio_.get(); |
| } |
| const SyncedBrowserControls* bottom_controls_shown_ratio() const { |
| return bottom_controls_shown_ratio_.get(); |
| } |
| gfx::Vector2dF current_elastic_overscroll() const { |
| return elastic_overscroll()->Current(IsActiveTree()); |
| } |
| |
| void SetElementIdsForTesting(); |
| |
| // Updates draw properties and render surface layer list, as well as tile |
| // priorities. Returns false if it was unable to update. Updating lcd |
| // text may cause invalidations, so should only be done after a commit. |
| bool UpdateDrawProperties( |
| bool update_image_animation_controller = true, |
| LayerImplList* output_update_layer_list_for_testing = nullptr); |
| |
| void set_needs_update_draw_properties() { |
| needs_update_draw_properties_ = true; |
| } |
| bool needs_update_draw_properties() const { |
| return needs_update_draw_properties_; |
| } |
| |
| bool is_in_resourceless_software_draw_mode() { |
| return (host_impl_->GetDrawMode() == DRAW_MODE_RESOURCELESS_SOFTWARE); |
| } |
| |
| void set_needs_full_tree_sync(bool needs) { needs_full_tree_sync_ = needs; } |
| bool needs_full_tree_sync() const { return needs_full_tree_sync_; } |
| |
| bool needs_surface_ranges_sync() const { return needs_surface_ranges_sync_; } |
| void set_needs_surface_ranges_sync(bool needs_surface_ranges_sync) { |
| needs_surface_ranges_sync_ = needs_surface_ranges_sync; |
| } |
| |
| void ForceRedrawNextActivation() { next_activation_forces_redraw_ = true; } |
| |
| void set_has_ever_been_drawn(bool has_drawn) { |
| has_ever_been_drawn_ = has_drawn; |
| } |
| bool has_ever_been_drawn() const { return has_ever_been_drawn_; } |
| |
| void set_ui_resource_request_queue(UIResourceRequestQueue queue); |
| |
| const RenderSurfaceList& GetRenderSurfaceList() const; |
| const Region& UnoccludedScreenSpaceRegion() const; |
| |
| // These return the size of the root scrollable area and the size of |
| // the user-visible scrolling viewport, in CSS layout coordinates. |
| gfx::SizeF ScrollableSize() const; |
| gfx::SizeF ScrollableViewportSize() const; |
| |
| gfx::Rect RootScrollLayerDeviceViewportBounds() const; |
| |
| LayerImpl* LayerById(int id) const; |
| LayerImpl* LayerByElementId(ElementId element_id) const; |
| |
| bool IsElementInPropertyTree(ElementId element_id) const; |
| |
| void AddToElementLayerList(ElementId element_id, LayerImpl* layer); |
| void RemoveFromElementLayerList(ElementId element_id); |
| |
| void SetSurfaceRanges(const base::flat_set<viz::SurfaceRange> surface_ranges); |
| const base::flat_set<viz::SurfaceRange>& SurfaceRanges() const; |
| void ClearSurfaceRanges(); |
| |
| void AddLayerShouldPushProperties(LayerImpl* layer); |
| void ClearLayersThatShouldPushProperties(); |
| const base::flat_set<LayerImpl*>& LayersThatShouldPushProperties() { |
| return layers_that_should_push_properties_; |
| } |
| |
| // These should be called by LayerImpl's ctor/dtor. |
| void RegisterLayer(LayerImpl* layer); |
| void UnregisterLayer(LayerImpl* layer); |
| |
| // Append a layer to the list. |
| void AddLayer(std::unique_ptr<LayerImpl> layer); |
| |
| size_t NumLayers(); |
| |
| void DidBecomeActive(); |
| |
| // Used for accessing the task runner and debug assertions. |
| TaskRunnerProvider* task_runner_provider() const; |
| |
| // Call this function when you expect there to be a swap buffer. |
| // See swap_promise.h for how to use SwapPromise. |
| // |
| // A swap promise queued by QueueSwapPromise travels with the layer |
| // information currently associated with the tree. For example, when |
| // a pending tree is activated, the swap promise is passed to the |
| // active tree along with the layer information. Similarly, when a |
| // new activation overwrites layer information on the active tree, |
| // queued swap promises are broken. |
| void QueueSwapPromise(std::unique_ptr<SwapPromise> swap_promise); |
| |
| // Queue a swap promise, pinned to this tree. Pinned swap promises |
| // may only be queued on the active tree. |
| // |
| // An active tree pinned swap promise will see only DidSwap() or |
| // DidNotSwap(SWAP_FAILS). No DidActivate() will be seen because |
| // that has already happened prior to queueing of the swap promise. |
| // |
| // Pinned active tree swap promises will not be broken prematurely |
| // on the active tree if a new tree is activated. |
| void QueuePinnedSwapPromise(std::unique_ptr<SwapPromise> swap_promise); |
| |
| // Takes ownership of |new_swap_promises|. Existing swap promises in |
| // |swap_promise_list_| are cancelled (SWAP_FAILS). |
| void PassSwapPromises( |
| std::vector<std::unique_ptr<SwapPromise>> new_swap_promises); |
| void AppendSwapPromises( |
| std::vector<std::unique_ptr<SwapPromise>> new_swap_promises); |
| void FinishSwapPromises(viz::CompositorFrameMetadata* metadata); |
| void ClearSwapPromises(); |
| void BreakSwapPromises(SwapPromise::DidNotSwapReason reason); |
| |
| void DidModifyTilePriorities(); |
| |
| viz::ResourceId ResourceIdForUIResource(UIResourceId uid) const; |
| void ProcessUIResourceRequestQueue(); |
| |
| bool IsUIResourceOpaque(UIResourceId uid) const; |
| |
| void RegisterPictureLayerImpl(PictureLayerImpl* layer); |
| void UnregisterPictureLayerImpl(PictureLayerImpl* layer); |
| const std::vector<PictureLayerImpl*>& picture_layers() const { |
| return picture_layers_; |
| } |
| |
| void NotifyLayerHasPaintWorkletsChanged(PictureLayerImpl* layer, |
| bool has_worklets); |
| const base::flat_set<PictureLayerImpl*>& picture_layers_with_paint_worklets() |
| const { |
| return picture_layers_with_paint_worklets_; |
| } |
| |
| void RegisterScrollbar(ScrollbarLayerImplBase* scrollbar_layer); |
| void UnregisterScrollbar(ScrollbarLayerImplBase* scrollbar_layer); |
| ScrollbarSet ScrollbarsFor(ElementId scroll_element_id) const; |
| |
| LayerImpl* FindFirstScrollingLayerOrScrollbarThatIsHitByPoint( |
| const gfx::PointF& screen_space_point); |
| |
| LayerImpl* FindLayerThatIsHitByPoint(const gfx::PointF& screen_space_point); |
| |
| LayerImpl* FindLayerThatIsHitByPointInTouchHandlerRegion( |
| const gfx::PointF& screen_space_point); |
| |
| LayerImpl* FindLayerThatIsHitByPointInWheelEventHandlerRegion( |
| const gfx::PointF& screen_space_point); |
| |
| // Return all layers with a hit non-fast scrollable region. |
| std::vector<const LayerImpl*> FindLayersHitByPointInNonFastScrollableRegion( |
| const gfx::PointF& screen_space_point); |
| // Returns all layers up to the first scroller or scrollbar layer, inclusive. |
| // The returned vector is sorted in order of top most come first. The back of |
| // the vector will be the scrollable layer if one was hit. |
| std::vector<const LayerImpl*> FindAllLayersUpToAndIncludingFirstScrollable( |
| const gfx::PointF& screen_space_point); |
| bool PointHitsNonFastScrollableRegion(const gfx::PointF& scree_space_point, |
| const LayerImpl& layer) const; |
| |
| // Returns the ElementId representing a frame's document at the given point. |
| // In cases where cc doesn't have enough information to perform accurate |
| // attribution (e.g. in the presence of a complex clip), kInvalidElementId is |
| // returned. |
| ElementId FindFrameElementIdAtPoint(const gfx::PointF& screen_space_point); |
| |
| void RegisterSelection(const LayerSelection& selection); |
| |
| bool HandleVisibilityChanged() const { return handle_visibility_changed_; } |
| void ResetHandleVisibilityChanged(); |
| |
| // Compute the current selection handle location and visbility with respect to |
| // the viewport. |
| void GetViewportSelection(viz::Selection<gfx::SelectionBound>* selection); |
| |
| bool browser_controls_shrink_blink_size() const { |
| return browser_controls_params_.browser_controls_shrink_blink_size; |
| } |
| bool SetCurrentBrowserControlsShownRatio(float top_ratio, float bottom_ratio); |
| float CurrentTopControlsShownRatio() const { |
| return top_controls_shown_ratio_->Current(IsActiveTree()); |
| } |
| float CurrentBottomControlsShownRatio() const { |
| return bottom_controls_shown_ratio_->Current(IsActiveTree()); |
| } |
| void SetBrowserControlsParams(const BrowserControlsParams& params); |
| float top_controls_height() const { |
| return browser_controls_params_.top_controls_height; |
| } |
| float top_controls_min_height() const { |
| return browser_controls_params_.top_controls_min_height; |
| } |
| void PushBrowserControlsFromMainThread(float top_controls_shown_ratio, |
| float bottom_controls_shown_ratio); |
| float bottom_controls_height() const { |
| return browser_controls_params_.bottom_controls_height; |
| } |
| float bottom_controls_min_height() const { |
| return browser_controls_params_.bottom_controls_min_height; |
| } |
| bool only_expand_top_controls_at_page_top() const { |
| return browser_controls_params_.only_expand_top_controls_at_page_top; |
| } |
| |
| void set_overscroll_behavior(const OverscrollBehavior& behavior); |
| OverscrollBehavior overscroll_behavior() const { |
| return overscroll_behavior_; |
| } |
| |
| void SetPendingPageScaleAnimation( |
| std::unique_ptr<PendingPageScaleAnimation> pending_animation); |
| std::unique_ptr<PendingPageScaleAnimation> TakePendingPageScaleAnimation(); |
| |
| void AppendEventsMetricsFromMainThread(EventMetrics::List events_metrics); |
| EventMetrics::List TakeEventsMetrics(); |
| |
| // Requests that we force send RenderFrameMetadata with the next frame. |
| void RequestForceSendMetadata() { force_send_metadata_request_ = true; } |
| bool TakeForceSendMetadataRequest(); |
| |
| void DidUpdateScrollOffset(ElementId id); |
| |
| // Mark the scrollbar geometries (e.g., thumb size and position) as needing an |
| // update. |
| void SetScrollbarGeometriesNeedUpdate() { |
| if (IsActiveTree()) { |
| scrollbar_geometries_need_update_ = true; |
| // Scrollbar geometries are updated in |UpdateDrawProperties|. |
| set_needs_update_draw_properties(); |
| } |
| } |
| bool ScrollbarGeometriesNeedUpdate() const { |
| return scrollbar_geometries_need_update_; |
| } |
| // Update the geometries of all scrollbars (e.g., thumb size and position). An |
| // update only occurs if a scroll-related layer has changed (see: |
| // SetScrollbarGeometriesNeedUpdate). |
| void UpdateScrollbarGeometries(); |
| |
| // See LayerTreeHost. |
| bool have_scroll_event_handlers() const { |
| return have_scroll_event_handlers_; |
| } |
| void set_have_scroll_event_handlers(bool have_event_handlers) { |
| have_scroll_event_handlers_ = have_event_handlers; |
| } |
| |
| // See LayerTreeHost. |
| EventListenerProperties event_listener_properties( |
| EventListenerClass event_class) const { |
| return event_listener_properties_[static_cast<size_t>(event_class)]; |
| } |
| void set_event_listener_properties(EventListenerClass event_class, |
| EventListenerProperties event_properties) { |
| event_listener_properties_[static_cast<size_t>(event_class)] = |
| event_properties; |
| } |
| |
| void ResetAllChangeTracking(); |
| |
| void HandleTickmarksVisibilityChange(); |
| void HandleScrollbarShowRequestsFromMain(); |
| |
| void InvalidateRegionForImages( |
| const PaintImageIdFlatSet& images_to_invalidate); |
| |
| void UpdateViewportContainerSizes(); |
| |
| LayerTreeLifecycle& lifecycle() { return lifecycle_; } |
| |
| std::string LayerListAsJson() const; |
| |
| AnimatedPaintWorkletTracker& paint_worklet_tracker() { |
| return host_impl_->paint_worklet_tracker(); |
| } |
| |
| const gfx::Transform& DrawTransform() const { |
| return host_impl_->DrawTransform(); |
| } |
| |
| bool IsInSynchronousComposite() const { |
| return host_impl_->IsInSynchronousComposite(); |
| } |
| |
| // These functions are used for plumbing DelegatedInkMetadata from blink |
| // through the compositor and into viz via a compositor frame. They should |
| // only be called after the JS API |updateInkTrailStartPoint| has been |
| // called, which populates the metadata with provided information. |
| void set_delegated_ink_metadata( |
| std::unique_ptr<viz::DelegatedInkMetadata> metadata) { |
| delegated_ink_metadata_ = std::move(metadata); |
| } |
| std::unique_ptr<viz::DelegatedInkMetadata> take_delegated_ink_metadata() { |
| return std::move(delegated_ink_metadata_); |
| } |
| |
| size_t events_metrics_from_main_thread_count_for_testing() const { |
| return events_metrics_from_main_thread_.size(); |
| } |
| |
| bool device_viewport_rect_changed() const { |
| return device_viewport_rect_changed_; |
| } |
| |
| protected: |
| float ClampPageScaleFactorToLimits(float page_scale_factor) const; |
| void PushPageScaleFactorAndLimits(const float* page_scale_factor, |
| float min_page_scale_factor, |
| float max_page_scale_factor); |
| bool SetPageScaleFactorLimits(float min_page_scale_factor, |
| float max_page_scale_factor); |
| void DidUpdatePageScale(); |
| void PushBrowserControls(const float* top_controls_shown_ratio, |
| const float* bottom_controls_shown_ratio); |
| bool ClampTopControlsShownRatio(); |
| bool ClampBottomControlsShownRatio(); |
| |
| private: |
| friend class LayerTreeHost; |
| |
| void UpdatePageScaleNode(); |
| |
| ElementListType GetElementTypeForAnimation() const; |
| void UpdateTransformAnimation(ElementId element_id, int transform_node_index); |
| template <typename Functor> |
| LayerImpl* FindLayerThatIsHitByPointInEventHandlerRegion( |
| const gfx::PointF& screen_space_point, |
| const Functor& func); |
| |
| LayerTreeHostImpl* host_impl_; |
| int source_frame_number_; |
| int is_first_frame_after_commit_tracker_; |
| HeadsUpDisplayLayerImpl* hud_layer_; |
| PropertyTrees property_trees_; |
| SkColor background_color_; |
| |
| int last_scrolled_scroll_node_index_; |
| |
| LayerTreeHost::ViewportPropertyIds viewport_property_ids_; |
| |
| LayerSelection selection_; |
| |
| scoped_refptr<SyncedProperty<ScaleGroup>> page_scale_factor_; |
| float min_page_scale_factor_; |
| float max_page_scale_factor_; |
| float external_page_scale_factor_; |
| |
| float device_scale_factor_; |
| float painted_device_scale_factor_; |
| gfx::DisplayColorSpaces display_color_spaces_; |
| |
| viz::LocalSurfaceId local_surface_id_from_parent_; |
| bool new_local_surface_id_request_ = false; |
| // Contains the physical rect of the device viewport, to be used in |
| // determining what needs to be drawn. |
| bool device_viewport_rect_changed_ = false; |
| gfx::Rect device_viewport_rect_; |
| |
| scoped_refptr<SyncedElasticOverscroll> elastic_overscroll_; |
| |
| // TODO(wangxianzhu): Combine layers_ and layer_list_ when we remove |
| // support of mask layers. |
| |
| OwnedLayerImplList layer_list_; |
| // Maps from layer id to layer. |
| LayerImplMap layer_id_map_; |
| |
| // Set of layers that need to push properties. |
| base::flat_set<LayerImpl*> layers_that_should_push_properties_; |
| |
| std::unordered_map<ElementId, float, ElementIdHash> |
| element_id_to_opacity_animations_; |
| std::unordered_map<ElementId, gfx::Transform, ElementIdHash> |
| element_id_to_transform_animations_; |
| std::unordered_map<ElementId, FilterOperations, ElementIdHash> |
| element_id_to_filter_animations_; |
| std::unordered_map<ElementId, FilterOperations, ElementIdHash> |
| element_id_to_backdrop_filter_animations_; |
| |
| struct ScrollbarLayerIds { |
| int horizontal = Layer::INVALID_ID; |
| int vertical = Layer::INVALID_ID; |
| }; |
| // Each scroll layer can have up to two scrollbar layers (vertical and |
| // horizontal). This mapping is maintained as part of scrollbar registration. |
| base::flat_map<ElementId, ScrollbarLayerIds> |
| element_id_to_scrollbar_layer_ids_; |
| |
| std::vector<PictureLayerImpl*> picture_layers_; |
| |
| // After commit (or impl-side invalidation), the LayerTreeHostImpl must walk |
| // all PictureLayerImpls that have PaintWorklets to ensure they are painted. |
| // To avoid unnecessary walking, we track that set here. |
| base::flat_set<PictureLayerImpl*> picture_layers_with_paint_worklets_; |
| |
| base::flat_set<viz::SurfaceRange> surface_layer_ranges_; |
| |
| // List of render surfaces for the most recently prepared frame. |
| RenderSurfaceList render_surface_list_; |
| // After drawing the |render_surface_list_| the areas in this region |
| // would not be fully covered by opaque content. |
| Region unoccluded_screen_space_region_; |
| |
| bool needs_update_draw_properties_; |
| |
| // True if a scrollbar geometry value has changed. For example, if the scroll |
| // offset changes, scrollbar thumb positions need to be updated. |
| bool scrollbar_geometries_need_update_; |
| |
| // In impl-side painting mode, this is true when the tree may contain |
| // structural differences relative to the active tree. |
| bool needs_full_tree_sync_; |
| |
| bool needs_surface_ranges_sync_; |
| |
| bool next_activation_forces_redraw_; |
| |
| bool has_ever_been_drawn_; |
| |
| bool handle_visibility_changed_; |
| |
| std::vector<std::unique_ptr<SwapPromise>> swap_promise_list_; |
| std::vector<std::unique_ptr<SwapPromise>> pinned_swap_promise_list_; |
| |
| UIResourceRequestQueue ui_resource_request_queue_; |
| |
| bool have_scroll_event_handlers_; |
| EventListenerProperties event_listener_properties_ |
| [static_cast<size_t>(EventListenerClass::kLast) + 1]; |
| |
| BrowserControlsParams browser_controls_params_; |
| |
| OverscrollBehavior overscroll_behavior_; |
| |
| // The amount that the browser controls are shown from 0 (hidden) to 1 (fully |
| // shown). |
| scoped_refptr<SyncedBrowserControls> top_controls_shown_ratio_; |
| scoped_refptr<SyncedBrowserControls> bottom_controls_shown_ratio_; |
| |
| std::unique_ptr<PendingPageScaleAnimation> pending_page_scale_animation_; |
| |
| // Whether we have a request to force-send RenderFrameMetadata with the next |
| // frame. |
| bool force_send_metadata_request_ = false; |
| |
| // Tracks the lifecycle which is used for enforcing dependencies between |
| // lifecycle states. See: |LayerTreeLifecycle|. |
| LayerTreeLifecycle lifecycle_; |
| |
| // Display transform hint to tag frames generated from this tree. |
| gfx::OverlayTransform display_transform_hint_ = gfx::OVERLAY_TRANSFORM_NONE; |
| |
| std::vector<LayerTreeHost::PresentationTimeCallback> presentation_callbacks_; |
| |
| // Event metrics that are reported back from the main thread. |
| EventMetrics::List events_metrics_from_main_thread_; |
| |
| std::unique_ptr<viz::DelegatedInkMetadata> delegated_ink_metadata_; |
| }; |
| |
| } // namespace cc |
| |
| #endif // CC_TREES_LAYER_TREE_IMPL_H_ |