diff options
Diffstat (limited to 'chromium/cc/trees/layer_tree_impl.cc')
| -rw-r--r-- | chromium/cc/trees/layer_tree_impl.cc | 475 |
1 files changed, 160 insertions, 315 deletions
diff --git a/chromium/cc/trees/layer_tree_impl.cc b/chromium/cc/trees/layer_tree_impl.cc index 1bb42de1429..27812c1d31e 100644 --- a/chromium/cc/trees/layer_tree_impl.cc +++ b/chromium/cc/trees/layer_tree_impl.cc @@ -31,7 +31,6 @@ #include "cc/layers/effect_tree_layer_list_iterator.h" #include "cc/layers/heads_up_display_layer_impl.h" #include "cc/layers/layer.h" -#include "cc/layers/layer_list_iterator.h" #include "cc/layers/render_surface_impl.h" #include "cc/layers/scrollbar_layer_impl_base.h" #include "cc/resources/ui_resource_request.h" @@ -39,12 +38,10 @@ #include "cc/trees/draw_property_utils.h" #include "cc/trees/effect_node.h" #include "cc/trees/layer_tree_frame_sink.h" -#include "cc/trees/layer_tree_host_common.h" #include "cc/trees/layer_tree_host_impl.h" #include "cc/trees/mutator_host.h" #include "cc/trees/occlusion_tracker.h" #include "cc/trees/property_tree.h" -#include "cc/trees/property_tree_builder.h" #include "cc/trees/scroll_node.h" #include "cc/trees/transform_node.h" #include "components/viz/common/traced_value.h" @@ -61,31 +58,33 @@ namespace { class ViewportAnchor { public: ViewportAnchor(ScrollNode* inner_scroll, - LayerImpl* outer_scroll, + ScrollNode* outer_scroll, LayerTreeImpl* tree_impl) : inner_(inner_scroll), outer_(outer_scroll), tree_impl_(tree_impl) { viewport_in_content_coordinates_ = scroll_tree().current_scroll_offset(inner_->element_id); - if (outer_) - viewport_in_content_coordinates_ += outer_->CurrentScrollOffset(); + if (outer_) { + viewport_in_content_coordinates_ += + scroll_tree().current_scroll_offset(outer_->element_id); + } } void ResetViewportToAnchoredPosition() { DCHECK(outer_); scroll_tree().ClampScrollToMaxScrollOffset(inner_, tree_impl_); - outer_->ClampScrollToMaxScrollOffset(); + scroll_tree().ClampScrollToMaxScrollOffset(outer_, tree_impl_); gfx::ScrollOffset viewport_location = scroll_tree().current_scroll_offset(inner_->element_id) + - outer_->CurrentScrollOffset(); + scroll_tree().current_scroll_offset(outer_->element_id); gfx::Vector2dF delta = viewport_in_content_coordinates_.DeltaFrom(viewport_location); delta = scroll_tree().ScrollBy(inner_, delta, tree_impl_); - outer_->ScrollBy(delta); + scroll_tree().ScrollBy(outer_, delta, tree_impl_); } private: @@ -94,7 +93,7 @@ class ViewportAnchor { } ScrollNode* inner_; - LayerImpl* outer_; + ScrollNode* outer_; LayerTreeImpl* tree_impl_; gfx::ScrollOffset viewport_in_content_coordinates_; }; @@ -123,7 +122,6 @@ LayerTreeImpl::LayerTreeImpl( : host_impl_(host_impl), source_frame_number_(-1), is_first_frame_after_commit_tracker_(-1), - root_layer_for_testing_(nullptr), hud_layer_(nullptr), background_color_(0), last_scrolled_scroll_node_index_(ScrollTree::kInvalidNodeId), @@ -134,7 +132,6 @@ LayerTreeImpl::LayerTreeImpl( device_scale_factor_(1.f), painted_device_scale_factor_(1.f), elastic_overscroll_(elastic_overscroll), - layers_(new OwnedLayerImplList), needs_update_draw_properties_(true), scrollbar_geometries_need_update_(false), needs_full_tree_sync_(true), @@ -155,7 +152,6 @@ LayerTreeImpl::~LayerTreeImpl() { // Need to explicitly clear the tree prior to destroying this so that // the LayerTreeImpl pointer is still valid in the LayerImpl dtor. DCHECK(LayerListIsEmpty()); - DCHECK(layers_->empty()); } void LayerTreeImpl::Shutdown() { @@ -166,42 +162,23 @@ void LayerTreeImpl::Shutdown() { } void LayerTreeImpl::ReleaseResources() { -#if DCHECK_IS_ON() - // These DCHECKs catch tests that add layers to the tree but fail to build the - // layer list afterward. - LayerListIterator<LayerImpl> it(root_layer_for_testing_); - size_t i = 0; - for (; it != LayerListIterator<LayerImpl>(nullptr); ++it, ++i) { - DCHECK_LT(i, layer_list_.size()); - DCHECK_EQ(layer_list_[i], *it); - } -#endif - - if (!LayerListIsEmpty()) { - LayerTreeHostCommon::CallFunctionForEveryLayer( - this, [](LayerImpl* layer) { layer->ReleaseResources(); }); - } + for (auto* layer : *this) + layer->ReleaseResources(); } void LayerTreeImpl::OnPurgeMemory() { - if (!LayerListIsEmpty()) { - LayerTreeHostCommon::CallFunctionForEveryLayer( - this, [](LayerImpl* layer) { layer->OnPurgeMemory(); }); - } + for (auto* layer : *this) + layer->OnPurgeMemory(); } void LayerTreeImpl::ReleaseTileResources() { - if (!LayerListIsEmpty()) { - LayerTreeHostCommon::CallFunctionForEveryLayer( - this, [](LayerImpl* layer) { layer->ReleaseTileResources(); }); - } + for (auto* layer : *this) + layer->ReleaseTileResources(); } void LayerTreeImpl::RecreateTileResources() { - if (!LayerListIsEmpty()) { - LayerTreeHostCommon::CallFunctionForEveryLayer( - this, [](LayerImpl* layer) { layer->RecreateTileResources(); }); - } + for (auto* layer : *this) + layer->RecreateTileResources(); } void LayerTreeImpl::DidUpdateScrollOffset(ElementId id) { @@ -269,23 +246,27 @@ void LayerTreeImpl::UpdateScrollbarGeometries() { scroll_node->scrolls_outer_viewport; if (is_viewport_scrollbar) { gfx::SizeF viewport_bounds(bounds_size); - if (scroll_node->scrolls_inner_viewport && OuterViewportScrollLayer()) { - // Add offset and bounds contribution of outer viewport. - current_offset += OuterViewportScrollLayer()->CurrentScrollOffset(); - gfx::SizeF outer_viewport_bounds(scroll_tree.container_bounds( - OuterViewportScrollLayer()->scroll_tree_index())); - viewport_bounds.SetToMin(outer_viewport_bounds); - - // The scrolling size is only determined by the outer viewport. - scroll_node = scroll_tree.FindNodeFromElementId( - OuterViewportScrollLayer()->element_id()); - scrolling_size = gfx::SizeF(scroll_node->bounds); + if (scroll_node->scrolls_inner_viewport) { + DCHECK_EQ(scroll_node, InnerViewportScrollNode()); + if (auto* outer_scroll_node = OuterViewportScrollNode()) { + // Add offset and bounds contribution of outer viewport. + current_offset += + scroll_tree.current_scroll_offset(outer_scroll_node->element_id); + gfx::SizeF outer_viewport_bounds( + scroll_tree.container_bounds(outer_scroll_node->id)); + viewport_bounds.SetToMin(outer_viewport_bounds); + // The scrolling size is only determined by the outer viewport. + scrolling_size = gfx::SizeF(outer_scroll_node->bounds); + } } else { + DCHECK_EQ(scroll_node, OuterViewportScrollNode()); + auto* inner_scroll_node = InnerViewportScrollNode(); + DCHECK(inner_scroll_node); // Add offset and bounds contribution of inner viewport. - current_offset += scroll_tree.current_scroll_offset( - InnerViewportScrollNode()->element_id); + current_offset += + scroll_tree.current_scroll_offset(inner_scroll_node->element_id); gfx::SizeF inner_viewport_bounds( - scroll_tree.container_bounds(InnerViewportScrollNode()->id)); + scroll_tree.container_bounds(inner_scroll_node->id)); viewport_bounds.SetToMin(inner_viewport_bounds); } viewport_bounds.Scale(1 / current_page_scale_factor()); @@ -322,14 +303,9 @@ bool LayerTreeImpl::LayerListIsEmpty() const { } void LayerTreeImpl::SetRootLayerForTesting(std::unique_ptr<LayerImpl> layer) { - if (root_layer_for_testing_ && layer.get() != root_layer_for_testing_) - RemoveLayer(root_layer_for_testing_->id()); - root_layer_for_testing_ = layer.get(); - ClearLayerList(); - if (layer) { + DetachLayers(); + if (layer) AddLayer(std::move(layer)); - BuildLayerListForTesting(); - } host_impl_->OnCanDrawStateChangedForTree(); } @@ -337,22 +313,6 @@ void LayerTreeImpl::OnCanDrawStateChangedForTree() { host_impl_->OnCanDrawStateChangedForTree(); } -void LayerTreeImpl::AddToLayerList(LayerImpl* layer) { - layer_list_.push_back(layer); -} - -void LayerTreeImpl::ClearLayerList() { - layer_list_.clear(); -} - -void LayerTreeImpl::BuildLayerListForTesting() { - ClearLayerList(); - LayerListIterator<LayerImpl> it(root_layer_for_testing_); - for (; it != LayerListIterator<LayerImpl>(nullptr); ++it) { - AddToLayerList(*it); - } -} - void LayerTreeImpl::InvalidateRegionForImages( const PaintImageIdFlatSet& images_to_invalidate) { TRACE_EVENT_BEGIN1("cc", "LayerTreeImpl::InvalidateRegionForImages", @@ -392,7 +352,7 @@ void LayerTreeImpl::UpdateViewportContainerSizes() { if (!InnerViewportScrollNode()) return; - ViewportAnchor anchor(InnerViewportScrollNode(), OuterViewportScrollLayer(), + ViewportAnchor anchor(InnerViewportScrollNode(), OuterViewportScrollNode(), this); // Top/bottom controls always share the same shown ratio. @@ -424,34 +384,23 @@ void LayerTreeImpl::UpdateViewportContainerSizes() { property_trees->SetInnerViewportContainerBoundsDelta(bounds_delta); - ClipNode* inner_clip_node = property_trees->clip_tree.Node( - InnerViewportScrollLayer()->clip_tree_index()); - inner_clip_node->clip.set_height( - InnerViewportScrollNode()->container_bounds.height() + bounds_delta.y()); - // Adjust the outer viewport container as well, since adjusting only the // inner may cause its bounds to exceed those of the outer, causing scroll // clamping. - if (OuterViewportScrollNode()) { + if (auto* outer_scroll = OuterViewportScrollNode()) { gfx::Vector2dF scaled_bounds_delta = gfx::ScaleVector2d(bounds_delta, 1.f / min_page_scale_factor()); property_trees->SetOuterViewportContainerBoundsDelta(scaled_bounds_delta); - property_trees->SetInnerViewportScrollBoundsDelta(scaled_bounds_delta); - - ClipNode* outer_clip_node = property_trees->clip_tree.Node( - OuterViewportScrollLayer()->clip_tree_index()); - - float adjusted_container_height = - OuterViewportScrollNode()->container_bounds.height() + - scaled_bounds_delta.y(); - outer_clip_node->clip.set_height(adjusted_container_height); - - // Expand all clips between the outer viewport and the inner viewport. - auto* outer_ancestor = property_trees->clip_tree.parent(outer_clip_node); - while (outer_ancestor && outer_ancestor != inner_clip_node) { - outer_ancestor->clip.Union(outer_clip_node->clip); - outer_ancestor = property_trees->clip_tree.parent(outer_ancestor); + // outer_viewport_container_bounds_delta and + // inner_viewport_scroll_bounds_delta are the same thing. + DCHECK_EQ(scaled_bounds_delta, + property_trees->inner_viewport_scroll_bounds_delta()); + + if (auto* outer_clip_node = OuterViewportClipNode()) { + float adjusted_container_height = + outer_scroll->container_bounds.height() + scaled_bounds_delta.y(); + outer_clip_node->clip.set_height(adjusted_container_height); } anchor.ResetViewportToAnchoredPosition(); @@ -465,59 +414,48 @@ void LayerTreeImpl::UpdateViewportContainerSizes() { // delta. SetScrollbarGeometriesNeedUpdate(); set_needs_update_draw_properties(); - - // For pre-BlinkGenPropertyTrees mode, we need to ensure the layers are - // appropriately updated. - if (!settings().use_layer_lists) { - if (OuterViewportContainerLayer()) - OuterViewportContainerLayer()->NoteLayerPropertyChanged(); - if (InnerViewportScrollLayer()) - InnerViewportScrollLayer()->NoteLayerPropertyChanged(); - if (OuterViewportScrollLayer()) - OuterViewportScrollLayer()->NoteLayerPropertyChanged(); - } } bool LayerTreeImpl::IsRootLayer(const LayerImpl* layer) const { - return layer_list_.empty() ? false : layer_list_[0] == layer; + return !layer_list_.empty() && layer_list_[0].get() == layer; } gfx::ScrollOffset LayerTreeImpl::TotalScrollOffset() const { gfx::ScrollOffset offset; - auto& scroll_tree = property_trees()->scroll_tree; + const auto& scroll_tree = property_trees()->scroll_tree; - if (InnerViewportScrollNode()) { - offset += scroll_tree.current_scroll_offset( - InnerViewportScrollNode()->element_id); - } + if (auto* inner_scroll = InnerViewportScrollNode()) + offset += scroll_tree.current_scroll_offset(inner_scroll->element_id); - if (OuterViewportScrollLayer()) - offset += OuterViewportScrollLayer()->CurrentScrollOffset(); + if (auto* outer_scroll = OuterViewportScrollNode()) + offset += scroll_tree.current_scroll_offset(outer_scroll->element_id); return offset; } gfx::ScrollOffset LayerTreeImpl::TotalMaxScrollOffset() const { gfx::ScrollOffset offset; - const ScrollTree& scroll_tree = property_trees()->scroll_tree; + const auto& scroll_tree = property_trees()->scroll_tree; - if (auto* inner_node = InnerViewportScrollNode()) - offset += scroll_tree.MaxScrollOffset(inner_node->id); + if (viewport_property_ids_.inner_scroll != ScrollTree::kInvalidNodeId) + offset += scroll_tree.MaxScrollOffset(viewport_property_ids_.inner_scroll); - if (auto* outer_node = OuterViewportScrollNode()) - offset += scroll_tree.MaxScrollOffset(outer_node->id); + if (viewport_property_ids_.outer_scroll != ScrollTree::kInvalidNodeId) + offset += scroll_tree.MaxScrollOffset(viewport_property_ids_.outer_scroll); return offset; } -std::unique_ptr<OwnedLayerImplList> LayerTreeImpl::DetachLayers() { - root_layer_for_testing_ = nullptr; - layer_list_.clear(); +OwnedLayerImplList LayerTreeImpl::DetachLayers() { render_surface_list_.clear(); set_needs_update_draw_properties(); - std::unique_ptr<OwnedLayerImplList> ret = std::move(layers_); - layers_.reset(new OwnedLayerImplList); - return ret; + return std::move(layer_list_); +} + +OwnedLayerImplList LayerTreeImpl::DetachLayersKeepingRootLayerForTesting() { + auto layers = DetachLayers(); + SetRootLayerForTesting(std::move(layers[0])); + return layers; } void LayerTreeImpl::SetPropertyTrees(PropertyTrees* property_trees) { @@ -594,18 +532,10 @@ void LayerTreeImpl::PushPropertiesTo(LayerTreeImpl* target_tree) { target_tree->PassSwapPromises(std::move(swap_promise_list_)); swap_promise_list_.clear(); - target_tree->set_browser_controls_shrink_blink_size( - browser_controls_shrink_blink_size_); - target_tree->SetTopControlsHeight(top_controls_height_); - target_tree->SetBottomControlsHeight(bottom_controls_height_); - target_tree->PushBrowserControls(nullptr); - - target_tree->set_overscroll_behavior(overscroll_behavior_); - // The page scale factor update can affect scrolling which requires that // these ids are set, so this must be before PushPageScaleFactorAndLimits. - target_tree->SetViewportLayersFromIds(viewport_layer_ids_); - target_tree->set_viewport_property_ids(viewport_property_ids_); + // Setting browser controls below also needs viewport scroll properties. + target_tree->SetViewportPropertyIds(viewport_property_ids_); // Active tree already shares the page_scale_factor object with pending // tree so only the limits need to be provided. @@ -613,6 +543,14 @@ void LayerTreeImpl::PushPropertiesTo(LayerTreeImpl* target_tree) { max_page_scale_factor()); target_tree->SetExternalPageScaleFactor(external_page_scale_factor_); + target_tree->set_browser_controls_shrink_blink_size( + browser_controls_shrink_blink_size_); + target_tree->SetTopControlsHeight(top_controls_height_); + target_tree->SetBottomControlsHeight(bottom_controls_height_); + target_tree->PushBrowserControls(nullptr); + + target_tree->set_overscroll_behavior(overscroll_behavior_); + target_tree->SetRasterColorSpace(raster_color_space_id_, raster_color_space_); target_tree->elastic_overscroll()->PushPendingToActive(); @@ -664,12 +602,12 @@ void LayerTreeImpl::PushPropertiesTo(LayerTreeImpl* target_tree) { } void LayerTreeImpl::HandleTickmarksVisibilityChange() { - if (!host_impl_->ViewportMainScrollLayer()) + if (!host_impl_->ViewportMainScrollNode()) return; ScrollbarAnimationController* controller = host_impl_->ScrollbarAnimationControllerForElementId( - OuterViewportScrollLayer()->element_id()); + host_impl_->ViewportMainScrollNode()->element_id); if (!controller) return; @@ -687,10 +625,9 @@ void LayerTreeImpl::HandleTickmarksVisibilityChange() { } void LayerTreeImpl::HandleScrollbarShowRequestsFromMain() { - LayerTreeHostCommon::CallFunctionForEveryLayer(this, [this]( - LayerImpl* layer) { + for (auto* layer : *this) { if (!layer->needs_show_scrollbars()) - return; + continue; ScrollbarAnimationController* controller = host_impl_->ScrollbarAnimationControllerForElementId( layer->element_id()); @@ -698,7 +635,7 @@ void LayerTreeImpl::HandleScrollbarShowRequestsFromMain() { controller->DidRequestShowFromMainThread(); layer->set_needs_show_scrollbars(false); } - }); + } } void LayerTreeImpl::MoveChangeTrackingToLayers() { @@ -723,30 +660,6 @@ void LayerTreeImpl::ForceRecalculateRasterScales() { layer->ResetRasterScale(); } -LayerImplList::const_iterator LayerTreeImpl::begin() const { - return layer_list_.cbegin(); -} - -LayerImplList::const_iterator LayerTreeImpl::end() const { - return layer_list_.cend(); -} - -LayerImplList::const_reverse_iterator LayerTreeImpl::rbegin() const { - return layer_list_.crbegin(); -} - -LayerImplList::const_reverse_iterator LayerTreeImpl::rend() const { - return layer_list_.crend(); -} - -LayerImplList::reverse_iterator LayerTreeImpl::rbegin() { - return layer_list_.rbegin(); -} - -LayerImplList::reverse_iterator LayerTreeImpl::rend() { - return layer_list_.rend(); -} - bool LayerTreeImpl::IsElementInPropertyTree(ElementId element_id) const { return property_trees()->HasElement(element_id); } @@ -857,6 +770,18 @@ LayerTreeImpl::TakePresentationCallbacks() { return callbacks; } +LayerImpl* LayerTreeImpl::InnerViewportScrollLayerForTesting() const { + if (auto* scroll_node = InnerViewportScrollNode()) + return LayerByElementId(scroll_node->element_id); + return nullptr; +} + +LayerImpl* LayerTreeImpl::OuterViewportScrollLayerForTesting() const { + if (auto* scroll_node = OuterViewportScrollNode()) + return LayerByElementId(scroll_node->element_id); + return nullptr; +} + ScrollNode* LayerTreeImpl::CurrentlyScrollingNode() { DCHECK(IsActiveTree()); return property_trees_.scroll_tree.CurrentlyScrollingNode(); @@ -1005,26 +930,11 @@ void LayerTreeImpl::UpdateTransformAnimation(ElementId element_id, } } -TransformNode* LayerTreeImpl::PageScaleTransformNode() { - auto* page_scale = PageScaleLayer(); - if (!page_scale) { - // TODO(crbug.com/909750): Check all other callers of PageScaleLayer() and - // switch to viewport_property_ids_.page_scale_transform if needed. - return property_trees()->transform_tree.Node( - viewport_property_ids_.page_scale_transform); - } - - return property_trees()->transform_tree.Node( - page_scale->transform_tree_index()); -} - void LayerTreeImpl::UpdatePageScaleNode() { if (!PageScaleTransformNode()) { DCHECK(layer_list_.empty() || current_page_scale_factor() == 1); return; } - - DCHECK(!IsRootLayer(PageScaleLayer())); draw_property_utils::UpdatePageScaleFactor( property_trees(), PageScaleTransformNode(), current_page_scale_factor()); } @@ -1178,10 +1088,10 @@ void LayerTreeImpl::DidUpdatePageScale() { host_impl_->FlashAllScrollbars(true); return; } - if (host_impl_->ViewportMainScrollLayer()) { + if (auto* scroll_node = host_impl_->ViewportMainScrollNode()) { if (ScrollbarAnimationController* controller = host_impl_->ScrollbarAnimationControllerForElementId( - OuterViewportScrollLayer()->element_id())) + scroll_node->element_id)) controller->DidScrollUpdate(); } } @@ -1275,14 +1185,14 @@ gfx::SizeF LayerTreeImpl::ScrollableViewportSize() const { } gfx::Rect LayerTreeImpl::RootScrollLayerDeviceViewportBounds() const { - LayerImpl* root_scroll_layer = OuterViewportScrollLayer() - ? OuterViewportScrollLayer() - : InnerViewportScrollLayer(); - if (!root_scroll_layer) + const ScrollNode* root_scroll_node = OuterViewportScrollNode(); + if (!root_scroll_node) + root_scroll_node = InnerViewportScrollNode(); + if (!root_scroll_node) return gfx::Rect(); return MathUtil::MapEnclosingClippedRect( - root_scroll_layer->ScreenSpaceTransform(), - gfx::Rect(root_scroll_layer->bounds())); + property_trees()->transform_tree.ToScreen(root_scroll_node->transform_id), + gfx::Rect(root_scroll_node->bounds)); } void LayerTreeImpl::ApplySentScrollAndScaleDeltasFromAbortedCommit() { @@ -1298,61 +1208,54 @@ void LayerTreeImpl::ApplySentScrollAndScaleDeltasFromAbortedCommit() { property_trees()->scroll_tree.ApplySentScrollDeltasFromAbortedCommit(); } -void LayerTreeImpl::SetViewportLayersFromIds(const ViewportLayerIds& ids) { - if (viewport_layer_ids_ == ids) - return; +void LayerTreeImpl::SetViewportPropertyIds(const ViewportPropertyIds& ids) { + viewport_property_ids_ = ids; + // Outer viewport properties exist only if inner viewport property exists. + DCHECK(ids.inner_scroll != ScrollTree::kInvalidNodeId || + (ids.outer_scroll == ScrollTree::kInvalidNodeId && + ids.outer_clip == ClipTree::kInvalidNodeId)); - viewport_layer_ids_ = ids; + if (auto* inner_scroll = InnerViewportScrollNode()) { + if (auto* inner_scroll_layer = LayerByElementId(inner_scroll->element_id)) + inner_scroll_layer->set_is_inner_viewport_scroll_layer(); + } +} - // Set the viewport layer types. - if (auto* inner_container = InnerViewportContainerLayer()) - inner_container->SetViewportLayerType(INNER_VIEWPORT_CONTAINER); - if (auto* inner_scroll = InnerViewportScrollLayer()) - inner_scroll->SetViewportLayerType(INNER_VIEWPORT_SCROLL); - if (auto* outer_container = OuterViewportContainerLayer()) - outer_container->SetViewportLayerType(OUTER_VIEWPORT_CONTAINER); - if (auto* outer_scroll = OuterViewportScrollLayer()) - outer_scroll->SetViewportLayerType(OUTER_VIEWPORT_SCROLL); +const TransformNode* LayerTreeImpl::OverscrollElasticityTransformNode() const { + return property_trees()->transform_tree.Node( + viewport_property_ids_.overscroll_elasticity_transform); } -void LayerTreeImpl::ClearViewportLayers() { - SetViewportLayersFromIds(ViewportLayerIds()); +const TransformNode* LayerTreeImpl::PageScaleTransformNode() const { + return property_trees()->transform_tree.Node( + viewport_property_ids_.page_scale_transform); } const ScrollNode* LayerTreeImpl::InnerViewportScrollNode() const { - auto* inner_scroll = InnerViewportScrollLayer(); - if (!inner_scroll) { - // TODO(crbug.com/909750): Check all other callers of - // InnerViewportScrollLayer() and switch to - // viewport_property_ids_.inner_scroll if needed. - return property_trees()->scroll_tree.Node( - viewport_property_ids_.inner_scroll); - } - return property_trees()->scroll_tree.Node(inner_scroll->scroll_tree_index()); + return property_trees()->scroll_tree.Node( + viewport_property_ids_.inner_scroll); +} + +const ClipNode* LayerTreeImpl::OuterViewportClipNode() const { + return property_trees()->clip_tree.Node(viewport_property_ids_.outer_clip); } const ScrollNode* LayerTreeImpl::OuterViewportScrollNode() const { - if (!OuterViewportScrollLayer()) - return nullptr; return property_trees()->scroll_tree.Node( - OuterViewportScrollLayer()->scroll_tree_index()); + viewport_property_ids_.outer_scroll); } // For unit tests, we use the layer's id as its element id. -static void SetElementIdForTesting(LayerImpl* layer) { - layer->SetElementId(LayerIdToElementIdForTesting(layer->id())); -} - void LayerTreeImpl::SetElementIdsForTesting() { - LayerListIterator<LayerImpl> it(root_layer_for_testing_); - for (; it != LayerListIterator<LayerImpl>(nullptr); ++it) { - if (!it->element_id()) - SetElementIdForTesting(*it); + for (auto* layer : *this) { + if (!layer->element_id()) + layer->SetElementId(LayerIdToElementIdForTesting(layer->id())); } } bool LayerTreeImpl::UpdateDrawProperties( - bool update_image_animation_controller) { + bool update_image_animation_controller, + LayerImplList* output_update_layer_list_for_testing) { if (!needs_update_draw_properties_) return true; @@ -1388,14 +1291,9 @@ bool LayerTreeImpl::UpdateDrawProperties( // We verify visible rect calculations whenever we verify clip tree // calculations except when this function is explicitly passed a flag asking // us to skip it. - LayerTreeHostCommon::CalcDrawPropsImplInputs inputs( - layer_list_[0], GetDeviceViewport(), host_impl_->DrawTransform(), - device_scale_factor(), current_page_scale_factor(), PageScaleLayer(), - InnerViewportScrollLayer(), OuterViewportScrollLayer(), - elastic_overscroll()->Current(IsActiveTree()), - OverscrollElasticityElementId(), max_texture_size(), - &render_surface_list_, &property_trees_, PageScaleTransformNode()); - LayerTreeHostCommon::CalculateDrawProperties(&inputs); + draw_property_utils::CalculateDrawProperties( + this, &render_surface_list_, output_update_layer_list_for_testing); + if (const char* client_name = GetClientNameForMetrics()) { UMA_HISTOGRAM_COUNTS_1M( base::StringPrintf( @@ -1450,14 +1348,6 @@ bool LayerTreeImpl::UpdateDrawProperties( occlusion_tracker.GetCurrentOcclusionForContributingSurface( draw_transform); render_surface->set_occlusion_in_content_space(occlusion); - // Masks are used to draw the contributing surface, so should have - // the same occlusion as the surface (nothing inside the surface - // occludes them). - if (LayerImpl* mask = render_surface->MaskLayer()) { - mask->draw_properties().occlusion_in_content_space = - occlusion_tracker.GetCurrentOcclusionForContributingSurface( - draw_transform * render_surface->SurfaceScale()); - } } occlusion_tracker.LeaveLayer(it); @@ -1514,24 +1404,6 @@ void LayerTreeImpl::UpdateCanUseLCDText() { DidModifyTilePriorities(); } -void LayerTreeImpl::BuildLayerListAndPropertyTreesForTesting() { - BuildLayerListForTesting(); - BuildPropertyTreesForTesting(); -} - -void LayerTreeImpl::BuildPropertyTreesForTesting() { - SetElementIdsForTesting(); - property_trees_.needs_rebuild = true; - PropertyTreeBuilder::BuildPropertyTrees( - layer_list_[0], PageScaleLayer(), InnerViewportScrollLayer(), - OuterViewportScrollLayer(), OverscrollElasticityElementId(), - elastic_overscroll()->Current(IsActiveTree()), - current_page_scale_factor(), device_scale_factor(), - gfx::Rect(GetDeviceViewport().size()), host_impl_->DrawTransform(), - &property_trees_); - host_impl_->UpdateElements(GetElementTypeForAnimation()); -} - const RenderSurfaceList& LayerTreeImpl::GetRenderSurfaceList() const { // If this assert triggers, then the list is dirty. DCHECK(!needs_update_draw_properties_); @@ -1546,8 +1418,9 @@ const Region& LayerTreeImpl::UnoccludedScreenSpaceRegion() const { } gfx::SizeF LayerTreeImpl::ScrollableSize() const { - auto* scroll_node = OuterViewportScrollNode() ? OuterViewportScrollNode() - : InnerViewportScrollNode(); + auto* scroll_node = OuterViewportScrollNode(); + if (!scroll_node) + scroll_node = InnerViewportScrollNode(); if (!scroll_node) return gfx::SizeF(); const auto& scroll_tree = property_trees()->scroll_tree; @@ -1564,11 +1437,11 @@ LayerImpl* LayerTreeImpl::LayerById(int id) const { // TODO(masonfreed): If this shows up on profiles, this could use // a layer_element_map_ approach similar to LayerById(). LayerImpl* LayerTreeImpl::LayerByElementId(ElementId element_id) const { - auto it = std::find_if(layer_list_.rbegin(), layer_list_.rend(), - [&element_id](LayerImpl* layer_impl) { - return layer_impl->element_id() == element_id; - }); - if (it == layer_list_.rend()) + auto it = + std::find_if(rbegin(), rend(), [&element_id](LayerImpl* layer_impl) { + return layer_impl->element_id() == element_id; + }); + if (it == rend()) return nullptr; return *it; } @@ -1618,26 +1491,13 @@ void LayerTreeImpl::UnregisterLayer(LayerImpl* layer) { layer_id_map_.erase(layer->id()); } -// These manage ownership of the LayerImpl. void LayerTreeImpl::AddLayer(std::unique_ptr<LayerImpl> layer) { - DCHECK(!base::Contains(*layers_, layer)); DCHECK(layer); - layers_->push_back(std::move(layer)); + DCHECK(!base::Contains(layer_list_, layer)); + layer_list_.push_back(std::move(layer)); set_needs_update_draw_properties(); } -std::unique_ptr<LayerImpl> LayerTreeImpl::RemoveLayer(int id) { - for (auto it = layers_->begin(); it != layers_->end(); ++it) { - if ((*it) && (*it)->id() != id) - continue; - std::unique_ptr<LayerImpl> ret = std::move(*it); - set_needs_update_draw_properties(); - layers_->erase(it); - return ret; - } - return nullptr; -} - size_t LayerTreeImpl::NumLayers() { return layer_id_map_.size(); } @@ -1652,10 +1512,8 @@ void LayerTreeImpl::DidBecomeActive() { // if we were in a good state. host_impl_->ResetRequiresHighResToDraw(); - if (!layer_list_.empty()) { - LayerTreeHostCommon::CallFunctionForEveryLayer( - this, [](LayerImpl* layer) { layer->DidBecomeActive(); }); - } + for (auto* layer : *this) + layer->DidBecomeActive(); for (const auto& swap_promise : swap_promise_list_) swap_promise->DidActivate(); @@ -1820,11 +1678,10 @@ void LayerTreeImpl::SetNeedsRedraw() { void LayerTreeImpl::GetAllPrioritizedTilesForTracing( std::vector<PrioritizedTile>* prioritized_tiles) const { - for (auto it = layer_list_.rbegin(); it != layer_list_.rend(); ++it) { - LayerImpl* layer_impl = *it; - if (!layer_impl->contributes_to_drawn_render_surface()) + for (auto* layer : base::Reversed(*this)) { + if (!layer->contributes_to_drawn_render_surface()) continue; - layer_impl->GetAllPrioritizedTilesForTracing(prioritized_tiles); + layer->GetAllPrioritizedTilesForTracing(prioritized_tiles); } } @@ -1834,10 +1691,10 @@ void LayerTreeImpl::AsValueInto(base::trace_event::TracedValue* state) const { state->SetInteger("source_frame_number", source_frame_number_); state->BeginArray("render_surface_layer_list"); - for (auto it = layer_list_.rbegin(); it != layer_list_.rend(); ++it) { - if (!(*it)->contributes_to_drawn_render_surface()) + for (auto* layer : base::Reversed(*this)) { + if (layer->contributes_to_drawn_render_surface()) continue; - viz::TracedValue::AppendIDRef(*it, state); + viz::TracedValue::AppendIDRef(layer, state); } state->EndArray(); @@ -2245,11 +2102,12 @@ static void FindClosestMatchingLayer(const gfx::PointF& screen_space_point, float distance_to_intersection = 0.f; bool hit = false; - if (layer->Is3dSorted()) + if (layer->Is3dSorted()) { hit = PointHitsLayer(layer, screen_space_point, &distance_to_intersection); - else + } else { hit = PointHitsLayer(layer, screen_space_point, nullptr); + } if (!hit) continue; @@ -2287,7 +2145,7 @@ LayerImpl* LayerTreeImpl::FindFirstScrollingLayerOrScrollbarThatIsHitByPoint( return nullptr; FindClosestMatchingLayerState state; - LayerImpl* root_layer = layer_list_[0]; + LayerImpl* root_layer = layer_list_[0].get(); FindClosestMatchingLayer(screen_space_point, root_layer, HitTestScrollingLayerOrScrollbarFunctor(), &state); return state.closest_match; @@ -2304,7 +2162,7 @@ LayerImpl* LayerTreeImpl::FindLayerThatIsHitByPoint( if (!UpdateDrawProperties()) return nullptr; FindClosestMatchingLayerState state; - FindClosestMatchingLayer(screen_space_point, layer_list_[0], + FindClosestMatchingLayer(screen_space_point, layer_list_[0].get(), HitTestVisibleScrollableOrTouchableFunctor(), &state); return state.closest_match; @@ -2337,7 +2195,8 @@ LayerImpl* LayerTreeImpl::FindLayerThatIsHitByPointInEventHandlerRegion( if (!UpdateDrawProperties()) return nullptr; FindClosestMatchingLayerState state; - FindClosestMatchingLayer(screen_space_point, layer_list_[0], func, &state); + FindClosestMatchingLayer(screen_space_point, layer_list_[0].get(), func, + &state); return state.closest_match; } @@ -2506,7 +2365,7 @@ bool LayerTreeImpl::TakeForceSendMetadataRequest() { void LayerTreeImpl::ResetAllChangeTracking() { layers_that_should_push_properties_.clear(); // Iterate over all layers, including masks. - for (auto& layer : *layers_) + for (auto* layer : *this) layer->ResetChangeTracking(); property_trees_.ResetAllChangeTracking(); } @@ -2524,18 +2383,4 @@ std::string LayerTreeImpl::LayerListAsJson() const { return str; } -std::string LayerTreeImpl::LayerTreeAsJson() const { - std::string str; - if (root_layer_for_testing_) { - std::unique_ptr<base::Value> json( - root_layer_for_testing_->LayerTreeAsJson()); - base::JSONWriter::WriteWithOptions( - *json, - base::JSONWriter::OPTIONS_OMIT_DOUBLE_TYPE_PRESERVATION | - base::JSONWriter::OPTIONS_PRETTY_PRINT, - &str); - } - return str; -} - } // namespace cc |