| // 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. |
| |
| #include "cc/layers/layer_impl.h" |
| |
| #include <stddef.h> |
| #include <stdint.h> |
| |
| #include <algorithm> |
| #include <utility> |
| |
| #include "base/json/json_reader.h" |
| #include "base/memory/ptr_util.h" |
| #include "base/numerics/safe_conversions.h" |
| #include "base/strings/stringprintf.h" |
| #include "base/trace_event/trace_event.h" |
| #include "base/trace_event/trace_event_argument.h" |
| #include "cc/base/math_util.h" |
| #include "cc/base/simple_enclosed_region.h" |
| #include "cc/benchmarks/micro_benchmark_impl.h" |
| #include "cc/debug/debug_colors.h" |
| #include "cc/debug/layer_tree_debug_state.h" |
| #include "cc/debug/traced_value.h" |
| #include "cc/input/main_thread_scrolling_reason.h" |
| #include "cc/input/scroll_state.h" |
| #include "cc/layers/layer.h" |
| #include "cc/layers/layer_utils.h" |
| #include "cc/output/copy_output_request.h" |
| #include "cc/quads/debug_border_draw_quad.h" |
| #include "cc/quads/render_pass.h" |
| #include "cc/trees/clip_node.h" |
| #include "cc/trees/draw_property_utils.h" |
| #include "cc/trees/effect_node.h" |
| #include "cc/trees/layer_tree_host_common.h" |
| #include "cc/trees/layer_tree_impl.h" |
| #include "cc/trees/layer_tree_settings.h" |
| #include "cc/trees/mutable_properties.h" |
| #include "cc/trees/mutator_host.h" |
| #include "cc/trees/proxy.h" |
| #include "cc/trees/scroll_node.h" |
| #include "cc/trees/transform_node.h" |
| #include "ui/gfx/geometry/box_f.h" |
| #include "ui/gfx/geometry/point_conversions.h" |
| #include "ui/gfx/geometry/quad_f.h" |
| #include "ui/gfx/geometry/rect_conversions.h" |
| #include "ui/gfx/geometry/size_conversions.h" |
| #include "ui/gfx/geometry/vector2d_conversions.h" |
| |
| namespace cc { |
| LayerImpl::LayerImpl(LayerTreeImpl* tree_impl, int id) |
| : layer_id_(id), |
| layer_tree_impl_(tree_impl), |
| test_properties_(nullptr), |
| scroll_clip_layer_id_(Layer::INVALID_ID), |
| main_thread_scrolling_reasons_( |
| MainThreadScrollingReason::kNotScrollingOnMain), |
| scrollable_(false), |
| should_flatten_transform_from_property_tree_(false), |
| layer_property_changed_(false), |
| may_contain_video_(false), |
| masks_to_bounds_(false), |
| contents_opaque_(false), |
| use_parent_backface_visibility_(false), |
| should_check_backface_visibility_(false), |
| draws_content_(false), |
| contributes_to_drawn_render_surface_(false), |
| should_hit_test_(false), |
| viewport_layer_type_(NOT_VIEWPORT_LAYER), |
| background_color_(0), |
| safe_opaque_background_color_(0), |
| transform_tree_index_(TransformTree::kInvalidNodeId), |
| effect_tree_index_(EffectTree::kInvalidNodeId), |
| clip_tree_index_(ClipTree::kInvalidNodeId), |
| scroll_tree_index_(ScrollTree::kInvalidNodeId), |
| current_draw_mode_(DRAW_MODE_NONE), |
| mutable_properties_(MutableProperty::kNone), |
| debug_info_(nullptr), |
| has_will_change_transform_hint_(false), |
| needs_push_properties_(false), |
| scrollbars_hidden_(false), |
| needs_show_scrollbars_(false), |
| raster_even_if_not_drawn_(false), |
| has_transform_node_(false) { |
| DCHECK_GT(layer_id_, 0); |
| |
| DCHECK(layer_tree_impl_); |
| layer_tree_impl_->RegisterLayer(this); |
| layer_tree_impl_->AddToElementMap(this); |
| |
| SetNeedsPushProperties(); |
| } |
| |
| LayerImpl::~LayerImpl() { |
| DCHECK_EQ(DRAW_MODE_NONE, current_draw_mode_); |
| |
| layer_tree_impl_->UnregisterLayer(this); |
| |
| layer_tree_impl_->RemoveFromElementMap(this); |
| |
| TRACE_EVENT_OBJECT_DELETED_WITH_ID( |
| TRACE_DISABLED_BY_DEFAULT("cc.debug"), "cc::LayerImpl", this); |
| } |
| |
| void LayerImpl::SetHasWillChangeTransformHint(bool has_will_change) { |
| has_will_change_transform_hint_ = has_will_change; |
| } |
| |
| |
| MutatorHost* LayerImpl::GetMutatorHost() const { |
| return layer_tree_impl_ ? layer_tree_impl_->mutator_host() : nullptr; |
| } |
| |
| ElementListType LayerImpl::GetElementTypeForAnimation() const { |
| return IsActive() ? ElementListType::ACTIVE : ElementListType::PENDING; |
| } |
| |
| void LayerImpl::SetDebugInfo( |
| std::unique_ptr<base::trace_event::ConvertableToTraceFormat> debug_info) { |
| owned_debug_info_ = std::move(debug_info); |
| debug_info_ = owned_debug_info_.get(); |
| SetNeedsPushProperties(); |
| } |
| |
| void LayerImpl::SetTransformTreeIndex(int index) { |
| transform_tree_index_ = index; |
| } |
| |
| void LayerImpl::SetClipTreeIndex(int index) { |
| clip_tree_index_ = index; |
| } |
| |
| void LayerImpl::SetEffectTreeIndex(int index) { |
| effect_tree_index_ = index; |
| } |
| |
| int LayerImpl::render_target_effect_tree_index() const { |
| EffectNode* effect_node = GetEffectTree().Node(effect_tree_index_); |
| |
| return GetEffectTree().GetRenderSurface(effect_tree_index_) |
| ? effect_node->id |
| : effect_node->target_id; |
| } |
| |
| void LayerImpl::SetScrollTreeIndex(int index) { |
| scroll_tree_index_ = index; |
| } |
| |
| void LayerImpl::PopulateSharedQuadState(SharedQuadState* state) const { |
| state->SetAll(draw_properties_.target_space_transform, gfx::Rect(bounds()), |
| draw_properties_.visible_layer_rect, draw_properties_.clip_rect, |
| draw_properties_.is_clipped, draw_properties_.opacity, |
| SkBlendMode::kSrcOver, GetSortingContextId()); |
| } |
| |
| void LayerImpl::PopulateScaledSharedQuadState( |
| SharedQuadState* state, |
| float layer_to_content_scale_x, |
| float layer_to_content_scale_y) const { |
| gfx::Transform scaled_draw_transform = |
| draw_properties_.target_space_transform; |
| scaled_draw_transform.Scale(SK_MScalar1 / layer_to_content_scale_x, |
| SK_MScalar1 / layer_to_content_scale_y); |
| gfx::Size scaled_bounds = gfx::ScaleToCeiledSize( |
| bounds(), layer_to_content_scale_x, layer_to_content_scale_y); |
| gfx::Rect scaled_visible_layer_rect = gfx::ScaleToEnclosingRect( |
| visible_layer_rect(), layer_to_content_scale_x, layer_to_content_scale_y); |
| scaled_visible_layer_rect.Intersect(gfx::Rect(scaled_bounds)); |
| |
| state->SetAll(scaled_draw_transform, gfx::Rect(scaled_bounds), |
| scaled_visible_layer_rect, draw_properties().clip_rect, |
| draw_properties().is_clipped, draw_properties().opacity, |
| SkBlendMode::kSrcOver, GetSortingContextId()); |
| } |
| |
| bool LayerImpl::WillDraw(DrawMode draw_mode, |
| ResourceProvider* resource_provider) { |
| // WillDraw/DidDraw must be matched. |
| DCHECK_NE(DRAW_MODE_NONE, draw_mode); |
| DCHECK_EQ(DRAW_MODE_NONE, current_draw_mode_); |
| current_draw_mode_ = draw_mode; |
| return true; |
| } |
| |
| void LayerImpl::DidDraw(ResourceProvider* resource_provider) { |
| DCHECK_NE(DRAW_MODE_NONE, current_draw_mode_); |
| current_draw_mode_ = DRAW_MODE_NONE; |
| } |
| |
| bool LayerImpl::ShowDebugBorders(DebugBorderType type) const { |
| return layer_tree_impl()->debug_state().show_debug_borders.test(type); |
| } |
| |
| void LayerImpl::GetDebugBorderProperties(SkColor* color, float* width) const { |
| float device_scale_factor = |
| layer_tree_impl() ? layer_tree_impl()->device_scale_factor() : 1; |
| |
| if (draws_content_) { |
| *color = DebugColors::ContentLayerBorderColor(); |
| *width = DebugColors::ContentLayerBorderWidth(device_scale_factor); |
| return; |
| } |
| |
| if (masks_to_bounds_) { |
| *color = DebugColors::MaskingLayerBorderColor(); |
| *width = DebugColors::MaskingLayerBorderWidth(device_scale_factor); |
| return; |
| } |
| |
| *color = DebugColors::ContainerLayerBorderColor(); |
| *width = DebugColors::ContainerLayerBorderWidth(device_scale_factor); |
| } |
| |
| void LayerImpl::AppendDebugBorderQuad( |
| RenderPass* render_pass, |
| const gfx::Size& bounds, |
| const SharedQuadState* shared_quad_state, |
| AppendQuadsData* append_quads_data) const { |
| SkColor color; |
| float width; |
| GetDebugBorderProperties(&color, &width); |
| AppendDebugBorderQuad(render_pass, bounds, shared_quad_state, |
| append_quads_data, color, width); |
| } |
| |
| void LayerImpl::AppendDebugBorderQuad(RenderPass* render_pass, |
| const gfx::Size& bounds, |
| const SharedQuadState* shared_quad_state, |
| AppendQuadsData* append_quads_data, |
| SkColor color, |
| float width) const { |
| if (!ShowDebugBorders(DebugBorderType::LAYER)) |
| return; |
| |
| gfx::Rect quad_rect(bounds); |
| gfx::Rect visible_quad_rect(quad_rect); |
| DebugBorderDrawQuad* debug_border_quad = |
| render_pass->CreateAndAppendDrawQuad<DebugBorderDrawQuad>(); |
| debug_border_quad->SetNew( |
| shared_quad_state, quad_rect, visible_quad_rect, color, width); |
| if (contents_opaque()) { |
| // When opaque, draw a second inner border that is thicker than the outer |
| // border, but more transparent. |
| static const float kFillOpacity = 0.3f; |
| SkColor fill_color = SkColorSetA( |
| color, static_cast<uint8_t>(SkColorGetA(color) * kFillOpacity)); |
| float fill_width = width * 3; |
| gfx::Rect fill_rect = quad_rect; |
| fill_rect.Inset(fill_width / 2.f, fill_width / 2.f); |
| if (fill_rect.IsEmpty()) |
| return; |
| gfx::Rect visible_fill_rect = |
| gfx::IntersectRects(visible_quad_rect, fill_rect); |
| DebugBorderDrawQuad* fill_quad = |
| render_pass->CreateAndAppendDrawQuad<DebugBorderDrawQuad>(); |
| fill_quad->SetNew(shared_quad_state, fill_rect, visible_fill_rect, |
| fill_color, fill_width); |
| } |
| } |
| |
| void LayerImpl::GetContentsResourceId(ResourceId* resource_id, |
| gfx::Size* resource_size, |
| gfx::SizeF* resource_uv_size) const { |
| NOTREACHED(); |
| *resource_id = 0; |
| } |
| |
| gfx::Vector2dF LayerImpl::ScrollBy(const gfx::Vector2dF& scroll) { |
| ScrollTree& scroll_tree = GetScrollTree(); |
| ScrollNode* scroll_node = scroll_tree.Node(scroll_tree_index()); |
| return scroll_tree.ScrollBy(scroll_node, scroll, layer_tree_impl()); |
| } |
| |
| void LayerImpl::SetScrollClipLayer(int scroll_clip_layer_id) { |
| if (scroll_clip_layer_id_ == scroll_clip_layer_id) |
| return; |
| scroll_clip_layer_id_ = scroll_clip_layer_id; |
| |
| // The scrolling bounds are determined from the scroll clip layer's bounds. |
| layer_tree_impl()->SetScrollbarGeometriesNeedUpdate(); |
| |
| bool scrollable = scroll_clip_layer_id_ != Layer::INVALID_ID; |
| SetScrollable(scrollable); |
| } |
| |
| LayerImpl* LayerImpl::scroll_clip_layer() const { |
| return layer_tree_impl()->LayerById(scroll_clip_layer_id_); |
| } |
| |
| void LayerImpl::SetScrollable(bool scrollable) { |
| if (scrollable_ == scrollable) |
| return; |
| scrollable_ = scrollable; |
| if (scrollable && layer_tree_impl()->settings().scrollbar_animator == |
| LayerTreeSettings::AURA_OVERLAY) { |
| set_needs_show_scrollbars(true); |
| } |
| } |
| |
| std::unique_ptr<LayerImpl> LayerImpl::CreateLayerImpl( |
| LayerTreeImpl* tree_impl) { |
| return LayerImpl::Create(tree_impl, layer_id_); |
| } |
| |
| bool LayerImpl::IsSnapped() { |
| return scrollable(); |
| } |
| |
| void LayerImpl::PushPropertiesTo(LayerImpl* layer) { |
| DCHECK(layer->IsActive()); |
| |
| // The ElementId should be set first because other setters depend on it such |
| // as LayerImpl::SetScrollClipLayer. |
| layer->SetElementId(element_id_); |
| |
| layer->has_transform_node_ = has_transform_node_; |
| layer->offset_to_transform_parent_ = offset_to_transform_parent_; |
| layer->main_thread_scrolling_reasons_ = main_thread_scrolling_reasons_; |
| layer->should_flatten_transform_from_property_tree_ = |
| should_flatten_transform_from_property_tree_; |
| layer->masks_to_bounds_ = masks_to_bounds_; |
| layer->contents_opaque_ = contents_opaque_; |
| layer->may_contain_video_ = may_contain_video_; |
| layer->use_parent_backface_visibility_ = use_parent_backface_visibility_; |
| layer->should_check_backface_visibility_ = should_check_backface_visibility_; |
| layer->draws_content_ = draws_content_; |
| layer->should_hit_test_ = should_hit_test_; |
| layer->non_fast_scrollable_region_ = non_fast_scrollable_region_; |
| layer->touch_action_region_ = touch_action_region_; |
| layer->background_color_ = background_color_; |
| layer->safe_opaque_background_color_ = safe_opaque_background_color_; |
| layer->position_ = position_; |
| layer->transform_tree_index_ = transform_tree_index_; |
| layer->effect_tree_index_ = effect_tree_index_; |
| layer->clip_tree_index_ = clip_tree_index_; |
| layer->scroll_tree_index_ = scroll_tree_index_; |
| layer->has_will_change_transform_hint_ = has_will_change_transform_hint_; |
| layer->scrollbars_hidden_ = scrollbars_hidden_; |
| layer->needs_show_scrollbars_ = needs_show_scrollbars_; |
| |
| if (layer_property_changed_) { |
| layer->layer_tree_impl()->set_needs_update_draw_properties(); |
| layer->layer_property_changed_ = true; |
| } |
| |
| layer->SetBounds(bounds_); |
| layer->SetScrollClipLayer(scroll_clip_layer_id_); |
| layer->SetScrollable(scrollable_); |
| layer->SetMutableProperties(mutable_properties_); |
| |
| // If the main thread commits multiple times before the impl thread actually |
| // draws, then damage tracking will become incorrect if we simply clobber the |
| // update_rect here. The LayerImpl's update_rect needs to accumulate (i.e. |
| // union) any update changes that have occurred on the main thread. |
| update_rect_.Union(layer->update_rect()); |
| layer->SetUpdateRect(update_rect_); |
| |
| if (owned_debug_info_) |
| layer->SetDebugInfo(std::move(owned_debug_info_)); |
| |
| // Reset any state that should be cleared for the next update. |
| needs_show_scrollbars_ = false; |
| layer_property_changed_ = false; |
| needs_push_properties_ = false; |
| update_rect_ = gfx::Rect(); |
| layer_tree_impl()->RemoveLayerShouldPushProperties(this); |
| } |
| |
| bool LayerImpl::IsAffectedByPageScale() const { |
| TransformTree& transform_tree = GetTransformTree(); |
| return transform_tree.Node(transform_tree_index()) |
| ->in_subtree_of_page_scale_layer; |
| } |
| |
| std::unique_ptr<base::DictionaryValue> LayerImpl::LayerTreeAsJson() { |
| std::unique_ptr<base::DictionaryValue> result(new base::DictionaryValue); |
| result->SetInteger("LayerId", id()); |
| result->SetString("LayerType", LayerTypeAsString()); |
| |
| auto list = base::MakeUnique<base::ListValue>(); |
| list->AppendInteger(bounds().width()); |
| list->AppendInteger(bounds().height()); |
| result->Set("Bounds", std::move(list)); |
| |
| list = base::MakeUnique<base::ListValue>(); |
| list->AppendDouble(position_.x()); |
| list->AppendDouble(position_.y()); |
| result->Set("Position", std::move(list)); |
| |
| const gfx::Transform& gfx_transform = test_properties()->transform; |
| double transform[16]; |
| gfx_transform.matrix().asColMajord(transform); |
| list = base::MakeUnique<base::ListValue>(); |
| for (int i = 0; i < 16; ++i) |
| list->AppendDouble(transform[i]); |
| result->Set("Transform", std::move(list)); |
| |
| result->SetBoolean("DrawsContent", draws_content_); |
| result->SetBoolean("Is3dSorted", Is3dSorted()); |
| result->SetDouble("OPACITY", Opacity()); |
| result->SetBoolean("ContentsOpaque", contents_opaque_); |
| |
| if (scrollable()) |
| result->SetBoolean("Scrollable", true); |
| |
| if (!touch_action_region_.region().IsEmpty()) { |
| std::unique_ptr<base::Value> region = |
| touch_action_region_.region().AsValue(); |
| result->Set("TouchRegion", std::move(region)); |
| } |
| |
| list = base::MakeUnique<base::ListValue>(); |
| for (size_t i = 0; i < test_properties()->children.size(); ++i) |
| list->Append(test_properties()->children[i]->LayerTreeAsJson()); |
| result->Set("Children", std::move(list)); |
| |
| return result; |
| } |
| |
| bool LayerImpl::LayerPropertyChanged() const { |
| if (layer_property_changed_ || GetPropertyTrees()->full_tree_damaged) |
| return true; |
| if (transform_tree_index() == TransformTree::kInvalidNodeId) |
| return false; |
| TransformNode* transform_node = |
| GetTransformTree().Node(transform_tree_index()); |
| if (transform_node && transform_node->transform_changed) |
| return true; |
| if (effect_tree_index() == EffectTree::kInvalidNodeId) |
| return false; |
| EffectNode* effect_node = GetEffectTree().Node(effect_tree_index()); |
| if (effect_node && effect_node->effect_changed) |
| return true; |
| return false; |
| } |
| |
| void LayerImpl::NoteLayerPropertyChanged() { |
| layer_property_changed_ = true; |
| layer_tree_impl()->set_needs_update_draw_properties(); |
| SetNeedsPushProperties(); |
| } |
| |
| void LayerImpl::ValidateQuadResourcesInternal(DrawQuad* quad) const { |
| #if DCHECK_IS_ON() |
| const ResourceProvider* resource_provider = |
| layer_tree_impl_->resource_provider(); |
| for (ResourceId resource_id : quad->resources) |
| resource_provider->ValidateResource(resource_id); |
| #endif |
| } |
| |
| const char* LayerImpl::LayerTypeAsString() const { |
| return "cc::LayerImpl"; |
| } |
| |
| void LayerImpl::ResetChangeTracking() { |
| layer_property_changed_ = false; |
| needs_push_properties_ = false; |
| |
| update_rect_.SetRect(0, 0, 0, 0); |
| damage_rect_.SetRect(0, 0, 0, 0); |
| } |
| |
| bool LayerImpl::has_copy_requests_in_target_subtree() { |
| return GetEffectTree().Node(effect_tree_index())->subtree_has_copy_request; |
| } |
| |
| void LayerImpl::UpdatePropertyTreeForScrollingAndAnimationIfNeeded() { |
| if (scrollable()) |
| UpdatePropertyTreeScrollOffset(); |
| |
| if (HasAnyAnimationTargetingProperty(TargetProperty::TRANSFORM)) { |
| if (TransformNode* node = |
| GetTransformTree().FindNodeFromElementId(element_id())) { |
| bool has_potential_animation = HasPotentiallyRunningTransformAnimation(); |
| if (node->has_potential_animation != has_potential_animation) { |
| node->has_potential_animation = has_potential_animation; |
| node->has_only_translation_animations = |
| GetMutatorHost()->HasOnlyTranslationTransforms( |
| element_id(), GetElementTypeForAnimation()); |
| GetTransformTree().set_needs_update(true); |
| layer_tree_impl()->set_needs_update_draw_properties(); |
| } |
| } |
| } |
| } |
| |
| gfx::ScrollOffset LayerImpl::ScrollOffsetForAnimation() const { |
| return CurrentScrollOffset(); |
| } |
| |
| bool LayerImpl::IsActive() const { |
| return layer_tree_impl_->IsActiveTree(); |
| } |
| |
| gfx::Size LayerImpl::bounds() const { |
| auto viewport_bounds_delta = gfx::ToCeiledVector2d(ViewportBoundsDelta()); |
| return gfx::Size(bounds_.width() + viewport_bounds_delta.x(), |
| bounds_.height() + viewport_bounds_delta.y()); |
| } |
| |
| gfx::SizeF LayerImpl::BoundsForScrolling() const { |
| auto viewport_bounds_delta = ViewportBoundsDelta(); |
| return gfx::SizeF(bounds_.width() + viewport_bounds_delta.x(), |
| bounds_.height() + viewport_bounds_delta.y()); |
| } |
| |
| void LayerImpl::SetBounds(const gfx::Size& bounds) { |
| if (bounds_ == bounds) |
| return; |
| |
| bounds_ = bounds; |
| |
| // Scrollbar positions depend on scrolling bounds and scroll clip bounds. |
| layer_tree_impl()->SetScrollbarGeometriesNeedUpdate(); |
| |
| NoteLayerPropertyChanged(); |
| } |
| |
| void LayerImpl::SetViewportBoundsDelta(const gfx::Vector2dF& bounds_delta) { |
| DCHECK(IsActive()); |
| |
| if (bounds_delta == ViewportBoundsDelta()) |
| return; |
| |
| PropertyTrees* property_trees = GetPropertyTrees(); |
| switch (viewport_layer_type_) { |
| case (INNER_VIEWPORT_CONTAINER): |
| property_trees->SetInnerViewportContainerBoundsDelta(bounds_delta); |
| break; |
| case (OUTER_VIEWPORT_CONTAINER): |
| property_trees->SetOuterViewportContainerBoundsDelta(bounds_delta); |
| break; |
| case (INNER_VIEWPORT_SCROLL): |
| property_trees->SetInnerViewportScrollBoundsDelta(bounds_delta); |
| break; |
| case (OUTER_VIEWPORT_SCROLL): |
| // OUTER_VIEWPORT_SCROLL should not have viewport bounds deltas. |
| NOTREACHED(); |
| } |
| |
| // Viewport scrollbar positions are determined using the viewport bounds |
| // delta. |
| layer_tree_impl()->SetScrollbarGeometriesNeedUpdate(); |
| |
| if (masks_to_bounds()) { |
| // If layer is clipping, then update the clip node using the new bounds. |
| ClipNode* clip_node = property_trees->clip_tree.Node(clip_tree_index()); |
| CHECK(clip_node); |
| DCHECK_EQ(clip_node->id, clip_tree_index()); |
| clip_node->clip = gfx::RectF(gfx::PointF() + offset_to_transform_parent(), |
| gfx::SizeF(bounds())); |
| property_trees->clip_tree.set_needs_update(true); |
| |
| property_trees->full_tree_damaged = true; |
| layer_tree_impl()->set_needs_update_draw_properties(); |
| } else { |
| NoteLayerPropertyChanged(); |
| } |
| } |
| |
| gfx::Vector2dF LayerImpl::ViewportBoundsDelta() const { |
| switch (viewport_layer_type_) { |
| case (INNER_VIEWPORT_CONTAINER): |
| return GetPropertyTrees()->inner_viewport_container_bounds_delta(); |
| case (OUTER_VIEWPORT_CONTAINER): |
| return GetPropertyTrees()->outer_viewport_container_bounds_delta(); |
| case (INNER_VIEWPORT_SCROLL): |
| return GetPropertyTrees()->inner_viewport_scroll_bounds_delta(); |
| default: |
| return gfx::Vector2dF(); |
| } |
| } |
| |
| ScrollbarLayerImplBase* LayerImpl::ToScrollbarLayer() { |
| return nullptr; |
| } |
| |
| void LayerImpl::SetDrawsContent(bool draws_content) { |
| if (draws_content_ == draws_content) |
| return; |
| |
| draws_content_ = draws_content; |
| if (draws_content) |
| SetShouldHitTest(true); |
| NoteLayerPropertyChanged(); |
| } |
| |
| void LayerImpl::SetShouldHitTest(bool should_hit_test) { |
| if (should_hit_test_ == should_hit_test) |
| return; |
| |
| should_hit_test_ = should_hit_test; |
| NoteLayerPropertyChanged(); |
| } |
| |
| void LayerImpl::SetBackgroundColor(SkColor background_color) { |
| if (background_color_ == background_color) |
| return; |
| |
| background_color_ = background_color; |
| NoteLayerPropertyChanged(); |
| } |
| |
| void LayerImpl::SetSafeOpaqueBackgroundColor(SkColor background_color) { |
| safe_opaque_background_color_ = background_color; |
| } |
| |
| SkColor LayerImpl::SafeOpaqueBackgroundColor() const { |
| if (contents_opaque()) |
| return safe_opaque_background_color_; |
| SkColor color = background_color(); |
| if (SkColorGetA(color) == 255) |
| color = SK_ColorTRANSPARENT; |
| return color; |
| } |
| |
| bool LayerImpl::HasPotentiallyRunningFilterAnimation() const { |
| return GetMutatorHost()->HasPotentiallyRunningFilterAnimation( |
| element_id(), GetElementTypeForAnimation()); |
| } |
| |
| void LayerImpl::SetMasksToBounds(bool masks_to_bounds) { |
| masks_to_bounds_ = masks_to_bounds; |
| } |
| |
| void LayerImpl::SetContentsOpaque(bool opaque) { |
| contents_opaque_ = opaque; |
| } |
| |
| float LayerImpl::Opacity() const { |
| if (const EffectNode* node = GetEffectTree().Node(effect_tree_index())) |
| return node->opacity; |
| else |
| return 1.f; |
| } |
| |
| const gfx::Transform& LayerImpl::Transform() const { |
| return GetTransformTree().Node(transform_tree_index())->local; |
| } |
| |
| void LayerImpl::SetElementId(ElementId element_id) { |
| if (element_id == element_id_) |
| return; |
| |
| TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("compositor-worker"), |
| "LayerImpl::SetElementId", "element", |
| element_id.AsValue().release()); |
| |
| layer_tree_impl_->RemoveFromElementMap(this); |
| element_id_ = element_id; |
| layer_tree_impl_->AddToElementMap(this); |
| |
| SetNeedsPushProperties(); |
| } |
| |
| void LayerImpl::SetMutableProperties(uint32_t properties) { |
| if (mutable_properties_ == properties) |
| return; |
| |
| TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("compositor-worker"), |
| "LayerImpl::SetMutableProperties", "properties", properties); |
| |
| mutable_properties_ = properties; |
| // If this layer is already in the element map, update its properties. |
| layer_tree_impl_->AddToElementMap(this); |
| } |
| |
| void LayerImpl::SetPosition(const gfx::PointF& position) { |
| position_ = position; |
| } |
| |
| bool LayerImpl::HasPotentiallyRunningTransformAnimation() const { |
| return GetMutatorHost()->HasPotentiallyRunningTransformAnimation( |
| element_id(), GetElementTypeForAnimation()); |
| } |
| |
| bool LayerImpl::HasAnyAnimationTargetingProperty( |
| TargetProperty::Type property) const { |
| return GetMutatorHost()->HasAnyAnimationTargetingProperty(element_id(), |
| property); |
| } |
| |
| bool LayerImpl::HasFilterAnimationThatInflatesBounds() const { |
| return GetMutatorHost()->HasFilterAnimationThatInflatesBounds(element_id()); |
| } |
| |
| bool LayerImpl::HasAnimationThatInflatesBounds() const { |
| return GetMutatorHost()->HasAnimationThatInflatesBounds(element_id()); |
| } |
| |
| bool LayerImpl::FilterAnimationBoundsForBox(const gfx::BoxF& box, |
| gfx::BoxF* bounds) const { |
| return GetMutatorHost()->FilterAnimationBoundsForBox(element_id(), box, |
| bounds); |
| } |
| |
| bool LayerImpl::TransformAnimationBoundsForBox(const gfx::BoxF& box, |
| gfx::BoxF* bounds) const { |
| return GetMutatorHost()->TransformAnimationBoundsForBox(element_id(), box, |
| bounds); |
| } |
| |
| void LayerImpl::SetUpdateRect(const gfx::Rect& update_rect) { |
| update_rect_ = update_rect; |
| SetNeedsPushProperties(); |
| } |
| |
| void LayerImpl::AddDamageRect(const gfx::Rect& damage_rect) { |
| damage_rect_.Union(damage_rect); |
| } |
| |
| void LayerImpl::SetCurrentScrollOffset(const gfx::ScrollOffset& scroll_offset) { |
| DCHECK(IsActive()); |
| if (GetScrollTree().SetScrollOffset(element_id(), scroll_offset)) |
| layer_tree_impl()->DidUpdateScrollOffset(element_id()); |
| } |
| |
| gfx::ScrollOffset LayerImpl::CurrentScrollOffset() const { |
| return GetScrollTree().current_scroll_offset(element_id()); |
| } |
| |
| void LayerImpl::UpdatePropertyTreeScrollOffset() { |
| // TODO(enne): in the future, scrolling should update the scroll tree |
| // directly instead of going through layers. |
| TransformTree& transform_tree = GetTransformTree(); |
| TransformNode* node = transform_tree.Node(transform_tree_index_); |
| DCHECK(node); |
| // TODO(pdr): This is a workaround for https://crbug.com/712298 to avoid |
| // crashing when there's no transform node. This workaround should be removed. |
| if (!node) |
| return; |
| gfx::ScrollOffset current_offset = CurrentScrollOffset(); |
| if (node->scroll_offset != current_offset) { |
| node->scroll_offset = current_offset; |
| node->needs_local_transform_update = true; |
| transform_tree.set_needs_update(true); |
| } |
| } |
| |
| SimpleEnclosedRegion LayerImpl::VisibleOpaqueRegion() const { |
| if (contents_opaque()) |
| return SimpleEnclosedRegion(visible_layer_rect()); |
| return SimpleEnclosedRegion(); |
| } |
| |
| void LayerImpl::DidBeginTracing() {} |
| |
| void LayerImpl::ReleaseResources() {} |
| |
| void LayerImpl::ReleaseTileResources() {} |
| |
| void LayerImpl::RecreateTileResources() {} |
| |
| gfx::ScrollOffset LayerImpl::MaxScrollOffset() const { |
| return GetScrollTree().MaxScrollOffset(scroll_tree_index()); |
| } |
| |
| gfx::ScrollOffset LayerImpl::ClampScrollOffsetToLimits( |
| gfx::ScrollOffset offset) const { |
| offset.SetToMin(MaxScrollOffset()); |
| offset.SetToMax(gfx::ScrollOffset()); |
| return offset; |
| } |
| |
| gfx::Vector2dF LayerImpl::ClampScrollToMaxScrollOffset() { |
| gfx::ScrollOffset old_offset = CurrentScrollOffset(); |
| gfx::ScrollOffset clamped_offset = ClampScrollOffsetToLimits(old_offset); |
| gfx::Vector2dF delta = clamped_offset.DeltaFrom(old_offset); |
| if (!delta.IsZero()) |
| ScrollBy(delta); |
| return delta; |
| } |
| |
| void LayerImpl::SetNeedsPushProperties() { |
| // There's no need to push layer properties on the active tree. |
| if (!needs_push_properties_ && !layer_tree_impl()->IsActiveTree()) { |
| needs_push_properties_ = true; |
| layer_tree_impl()->AddLayerShouldPushProperties(this); |
| } |
| } |
| |
| void LayerImpl::GetAllPrioritizedTilesForTracing( |
| std::vector<PrioritizedTile>* prioritized_tiles) const { |
| } |
| |
| void LayerImpl::AsValueInto(base::trace_event::TracedValue* state) const { |
| TracedValue::MakeDictIntoImplicitSnapshotWithCategory( |
| TRACE_DISABLED_BY_DEFAULT("cc.debug"), |
| state, |
| "cc::LayerImpl", |
| LayerTypeAsString(), |
| this); |
| state->SetInteger("layer_id", id()); |
| MathUtil::AddToTracedValue("bounds", bounds_, state); |
| |
| state->SetDouble("opacity", Opacity()); |
| |
| MathUtil::AddToTracedValue("position", position_, state); |
| |
| state->SetInteger("draws_content", DrawsContent()); |
| state->SetInteger("gpu_memory_usage", |
| base::saturated_cast<int>(GPUMemoryUsageInBytes())); |
| |
| if (element_id_) |
| element_id_.AddToTracedValue(state); |
| |
| if (mutable_properties_ != MutableProperty::kNone) |
| state->SetInteger("mutable_properties", mutable_properties_); |
| |
| MathUtil::AddToTracedValue("scroll_offset", CurrentScrollOffset(), state); |
| |
| if (!ScreenSpaceTransform().IsIdentity()) |
| MathUtil::AddToTracedValue("screen_space_transform", ScreenSpaceTransform(), |
| state); |
| |
| bool clipped; |
| gfx::QuadF layer_quad = |
| MathUtil::MapQuad(ScreenSpaceTransform(), |
| gfx::QuadF(gfx::RectF(gfx::Rect(bounds()))), &clipped); |
| MathUtil::AddToTracedValue("layer_quad", layer_quad, state); |
| if (!touch_action_region_.region().IsEmpty()) { |
| state->BeginArray("touch_action_region_region"); |
| touch_action_region_.region().AsValueInto(state); |
| state->EndArray(); |
| } |
| if (!non_fast_scrollable_region_.IsEmpty()) { |
| state->BeginArray("non_fast_scrollable_region"); |
| non_fast_scrollable_region_.AsValueInto(state); |
| state->EndArray(); |
| } |
| |
| state->SetBoolean("can_use_lcd_text", CanUseLCDText()); |
| state->SetBoolean("contents_opaque", contents_opaque()); |
| |
| state->SetBoolean("has_animation_bounds", HasAnimationThatInflatesBounds()); |
| |
| state->SetBoolean("has_will_change_transform_hint", |
| has_will_change_transform_hint()); |
| |
| gfx::BoxF box; |
| if (LayerUtils::GetAnimationBounds(*this, &box)) |
| MathUtil::AddToTracedValue("animation_bounds", box, state); |
| |
| if (debug_info_) { |
| std::string str; |
| debug_info_->AppendAsTraceFormat(&str); |
| base::JSONReader json_reader; |
| std::unique_ptr<base::Value> debug_info_value(json_reader.ReadToValue(str)); |
| |
| if (debug_info_value->IsType(base::Value::Type::DICTIONARY)) { |
| base::DictionaryValue* dictionary_value = nullptr; |
| bool converted_to_dictionary = |
| debug_info_value->GetAsDictionary(&dictionary_value); |
| DCHECK(converted_to_dictionary); |
| for (base::DictionaryValue::Iterator it(*dictionary_value); !it.IsAtEnd(); |
| it.Advance()) { |
| state->SetValue(it.key().data(), it.value().CreateDeepCopy()); |
| } |
| } else { |
| NOTREACHED(); |
| } |
| } |
| } |
| |
| size_t LayerImpl::GPUMemoryUsageInBytes() const { return 0; } |
| |
| void LayerImpl::RunMicroBenchmark(MicroBenchmarkImpl* benchmark) { |
| benchmark->RunOnLayer(this); |
| } |
| |
| gfx::Transform LayerImpl::DrawTransform() const { |
| // Only drawn layers have up-to-date draw properties. |
| if (!contributes_to_drawn_render_surface()) { |
| return draw_property_utils::DrawTransform(this, GetTransformTree(), |
| GetEffectTree()); |
| } |
| |
| return draw_properties().target_space_transform; |
| } |
| |
| gfx::Transform LayerImpl::ScreenSpaceTransform() const { |
| // Only drawn layers have up-to-date draw properties. |
| if (!contributes_to_drawn_render_surface()) { |
| return draw_property_utils::ScreenSpaceTransform(this, GetTransformTree()); |
| } |
| |
| return draw_properties().screen_space_transform; |
| } |
| |
| bool LayerImpl::CanUseLCDText() const { |
| if (layer_tree_impl()->settings().layers_always_allowed_lcd_text) |
| return true; |
| if (!layer_tree_impl()->settings().can_use_lcd_text) |
| return false; |
| if (!contents_opaque()) |
| return false; |
| |
| if (GetEffectTree().Node(effect_tree_index())->screen_space_opacity != 1.f) |
| return false; |
| if (!GetTransformTree() |
| .Node(transform_tree_index()) |
| ->node_and_ancestors_have_only_integer_translation) |
| return false; |
| if (static_cast<int>(offset_to_transform_parent().x()) != |
| offset_to_transform_parent().x()) |
| return false; |
| if (static_cast<int>(offset_to_transform_parent().y()) != |
| offset_to_transform_parent().y()) |
| return false; |
| return true; |
| } |
| |
| int LayerImpl::GetSortingContextId() const { |
| return GetTransformTree().Node(transform_tree_index())->sorting_context_id; |
| } |
| |
| Region LayerImpl::GetInvalidationRegionForDebugging() { |
| return Region(update_rect_); |
| } |
| |
| gfx::Rect LayerImpl::GetEnclosingRectInTargetSpace() const { |
| return MathUtil::MapEnclosingClippedRect(DrawTransform(), |
| gfx::Rect(bounds())); |
| } |
| |
| gfx::Rect LayerImpl::GetScaledEnclosingRectInTargetSpace(float scale) const { |
| gfx::Transform scaled_draw_transform = DrawTransform(); |
| scaled_draw_transform.Scale(SK_MScalar1 / scale, SK_MScalar1 / scale); |
| gfx::Size scaled_bounds = gfx::ScaleToCeiledSize(bounds(), scale); |
| return MathUtil::MapEnclosingClippedRect(scaled_draw_transform, |
| gfx::Rect(scaled_bounds)); |
| } |
| |
| RenderSurfaceImpl* LayerImpl::render_target() { |
| return GetEffectTree().GetRenderSurface(render_target_effect_tree_index()); |
| } |
| |
| const RenderSurfaceImpl* LayerImpl::render_target() const { |
| return GetEffectTree().GetRenderSurface(render_target_effect_tree_index()); |
| } |
| |
| float LayerImpl::GetIdealContentsScale() const { |
| float page_scale = IsAffectedByPageScale() |
| ? layer_tree_impl()->current_page_scale_factor() |
| : 1.f; |
| float device_scale = layer_tree_impl()->device_scale_factor(); |
| |
| float default_scale = page_scale * device_scale; |
| if (!layer_tree_impl() |
| ->settings() |
| .layer_transforms_should_scale_layer_contents) { |
| return default_scale; |
| } |
| |
| const auto& transform = ScreenSpaceTransform(); |
| if (transform.HasPerspective()) { |
| float scale = MathUtil::ComputeApproximateMaxScale(transform); |
| // Since we're approximating the scale anyway, round it to the nearest |
| // integer to prevent jitter when animating the transform. |
| scale = std::round(scale); |
| // Don't let the scale fall below the default scale. |
| return std::max(scale, default_scale); |
| } |
| |
| gfx::Vector2dF transform_scales = |
| MathUtil::ComputeTransform2dScaleComponents(transform, default_scale); |
| return std::max(transform_scales.x(), transform_scales.y()); |
| } |
| |
| PropertyTrees* LayerImpl::GetPropertyTrees() const { |
| return layer_tree_impl_->property_trees(); |
| } |
| |
| ClipTree& LayerImpl::GetClipTree() const { |
| return GetPropertyTrees()->clip_tree; |
| } |
| |
| EffectTree& LayerImpl::GetEffectTree() const { |
| return GetPropertyTrees()->effect_tree; |
| } |
| |
| ScrollTree& LayerImpl::GetScrollTree() const { |
| return GetPropertyTrees()->scroll_tree; |
| } |
| |
| TransformTree& LayerImpl::GetTransformTree() const { |
| return GetPropertyTrees()->transform_tree; |
| } |
| |
| bool LayerImpl::HasValidPropertyTreeIndices() const { |
| // TODO(crbug.com/726423): LayerImpls should never have invalid PropertyTree |
| // indices. |
| const bool has_valid_transform_node = |
| !!GetTransformTree().Node(transform_tree_index()); |
| DCHECK(has_valid_transform_node); |
| |
| const bool has_valid_effect_node = |
| !!GetEffectTree().Node(effect_tree_index()); |
| DCHECK(has_valid_effect_node); |
| |
| const bool has_valid_clip_node = !!GetClipTree().Node(clip_tree_index()); |
| DCHECK(has_valid_clip_node); |
| |
| const bool has_valid_scroll_node = |
| !!GetScrollTree().Node(scroll_tree_index()); |
| DCHECK(has_valid_scroll_node); |
| |
| return has_valid_transform_node && has_valid_effect_node && |
| has_valid_clip_node && has_valid_scroll_node; |
| } |
| |
| } // namespace cc |