blob: 5b21f5bc78a9ce8e9ff439a7e3cb1a30ead2dec9 [file] [log] [blame]
// Copyright 2010 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_LAYERS_LAYER_H_
#define CC_LAYERS_LAYER_H_
#include <stddef.h>
#include <stdint.h>
#include <set>
#include <string>
#include <unordered_map>
#include <vector>
#include "base/callback.h"
#include "base/macros.h"
#include "base/memory/ref_counted.h"
#include "base/observer_list.h"
#include "cc/base/filter_operations.h"
#include "cc/base/region.h"
#include "cc/benchmarks/micro_benchmark.h"
#include "cc/cc_export.h"
#include "cc/input/input_handler.h"
#include "cc/layers/layer_collections.h"
#include "cc/layers/layer_position_constraint.h"
#include "cc/layers/paint_properties.h"
#include "cc/paint/paint_record.h"
#include "cc/trees/element_id.h"
#include "cc/trees/mutator_host_client.h"
#include "cc/trees/property_tree.h"
#include "cc/trees/target_property.h"
#include "third_party/skia/include/core/SkColor.h"
#include "ui/gfx/geometry/point3_f.h"
#include "ui/gfx/geometry/rect.h"
#include "ui/gfx/geometry/rect_f.h"
#include "ui/gfx/geometry/scroll_offset.h"
#include "ui/gfx/transform.h"
namespace base {
namespace trace_event {
class ConvertableToTraceFormat;
}
}
namespace cc {
class CopyOutputRequest;
class LayerClient;
class LayerImpl;
class LayerTreeHost;
class LayerTreeHostCommon;
class LayerTreeImpl;
class MutatorHost;
class ScrollbarLayerInterface;
// Base class for composited layers. Special layer types are derived from
// this class.
class CC_EXPORT Layer : public base::RefCounted<Layer> {
public:
using LayerListType = LayerList;
using LayerIdMap = std::unordered_map<int, scoped_refptr<Layer>>;
enum LayerIdLabels {
INVALID_ID = -1,
};
enum LayerMaskType {
NOT_MASK = 0,
MULTI_TEXTURE_MASK,
SINGLE_TEXTURE_MASK,
};
static scoped_refptr<Layer> Create();
int id() const { return inputs_.layer_id; }
Layer* RootLayer();
Layer* parent() { return parent_; }
const Layer* parent() const { return parent_; }
void AddChild(scoped_refptr<Layer> child);
void InsertChild(scoped_refptr<Layer> child, size_t index);
void ReplaceChild(Layer* reference, scoped_refptr<Layer> new_layer);
void RemoveFromParent();
void RemoveAllChildren();
void SetChildren(const LayerList& children);
bool HasAncestor(const Layer* ancestor) const;
const LayerList& children() const { return inputs_.children; }
Layer* child_at(size_t index) { return inputs_.children[index].get(); }
// This requests the layer and its subtree be rendered and given to the
// callback. If the copy is unable to be produced (the layer is destroyed
// first), then the callback is called with a nullptr/empty result. If the
// request's source property is set, any prior uncommitted requests having the
// same source will be aborted.
void RequestCopyOfOutput(std::unique_ptr<CopyOutputRequest> request);
bool HasCopyRequest() const { return !inputs_.copy_requests.empty(); }
void SetSubtreeHasCopyRequest(bool subtree_has_copy_request);
bool SubtreeHasCopyRequest() const;
void TakeCopyRequests(
std::vector<std::unique_ptr<CopyOutputRequest>>* requests);
virtual void SetBackgroundColor(SkColor background_color);
SkColor background_color() const { return inputs_.background_color; }
void SetSafeOpaqueBackgroundColor(SkColor background_color);
// If contents_opaque(), return an opaque color else return a
// non-opaque color. Tries to return background_color(), if possible.
SkColor SafeOpaqueBackgroundColor() const;
// A layer's bounds are in logical, non-page-scaled pixels (however, the
// root layer's bounds are in physical pixels).
void SetBounds(const gfx::Size& bounds);
gfx::Size bounds() const { return inputs_.bounds; }
void SetMasksToBounds(bool masks_to_bounds);
bool masks_to_bounds() const { return inputs_.masks_to_bounds; }
void SetMaskLayer(Layer* mask_layer);
Layer* mask_layer() { return inputs_.mask_layer.get(); }
const Layer* mask_layer() const { return inputs_.mask_layer.get(); }
virtual void SetNeedsDisplayRect(const gfx::Rect& dirty_rect);
void SetNeedsDisplay() { SetNeedsDisplayRect(gfx::Rect(bounds())); }
virtual void SetOpacity(float opacity);
float opacity() const { return inputs_.opacity; }
float EffectiveOpacity() const;
virtual bool OpacityCanAnimateOnImplThread() const;
virtual bool AlwaysUseActiveTreeOpacity() const;
void SetBlendMode(SkBlendMode blend_mode);
SkBlendMode blend_mode() const { return inputs_.blend_mode; }
// A layer is root for an isolated group when it and all its descendants are
// drawn over a black and fully transparent background, creating an isolated
// group. It should be used along with SetBlendMode(), in order to restrict
// layers within the group to blend with layers outside this group.
void SetIsRootForIsolatedGroup(bool root);
bool is_root_for_isolated_group() const {
return inputs_.is_root_for_isolated_group;
}
void SetFilters(const FilterOperations& filters);
const FilterOperations& filters() const { return inputs_.filters; }
// Background filters are filters applied to what is behind this layer, when
// they are viewed through non-opaque regions in this layer. They are used
// through the WebLayer interface, and are not exposed to HTML.
void SetBackgroundFilters(const FilterOperations& filters);
const FilterOperations& background_filters() const {
return inputs_.background_filters;
}
void SetContentsOpaque(bool opaque);
bool contents_opaque() const { return inputs_.contents_opaque; }
void SetPosition(const gfx::PointF& position);
gfx::PointF position() const { return inputs_.position; }
// A layer that is a container for fixed position layers cannot be both
// scrollable and have a non-identity transform.
void SetIsContainerForFixedPositionLayers(bool container);
bool IsContainerForFixedPositionLayers() const;
gfx::Vector2dF FixedContainerSizeDelta() const {
return gfx::Vector2dF();
}
void SetPositionConstraint(const LayerPositionConstraint& constraint);
const LayerPositionConstraint& position_constraint() const {
return inputs_.position_constraint;
}
void SetStickyPositionConstraint(
const LayerStickyPositionConstraint& constraint);
const LayerStickyPositionConstraint& sticky_position_constraint() const {
return inputs_.sticky_position_constraint;
}
void SetTransform(const gfx::Transform& transform);
const gfx::Transform& transform() const { return inputs_.transform; }
void SetTransformOrigin(const gfx::Point3F&);
gfx::Point3F transform_origin() const { return inputs_.transform_origin; }
void SetScrollParent(Layer* parent);
Layer* scroll_parent() { return inputs_.scroll_parent; }
std::set<Layer*>* scroll_children() { return scroll_children_.get(); }
const std::set<Layer*>* scroll_children() const {
return scroll_children_.get();
}
void SetClipParent(Layer* ancestor);
Layer* clip_parent() { return inputs_.clip_parent; }
std::set<Layer*>* clip_children() { return clip_children_.get(); }
const std::set<Layer*>* clip_children() const {
return clip_children_.get();
}
gfx::Transform ScreenSpaceTransform() const;
void set_num_unclipped_descendants(size_t descendants) {
num_unclipped_descendants_ = descendants;
}
size_t num_unclipped_descendants() const {
return num_unclipped_descendants_;
}
void SetScrollOffset(const gfx::ScrollOffset& scroll_offset);
gfx::ScrollOffset scroll_offset() const { return inputs_.scroll_offset; }
void SetScrollOffsetFromImplSide(const gfx::ScrollOffset& scroll_offset);
void SetScrollClipLayerId(int clip_layer_id);
bool scrollable() const { return inputs_.scroll_clip_layer_id != INVALID_ID; }
Layer* scroll_clip_layer() const;
void SetUserScrollable(bool horizontal, bool vertical);
bool user_scrollable_horizontal() const {
return inputs_.user_scrollable_horizontal;
}
bool user_scrollable_vertical() const {
return inputs_.user_scrollable_vertical;
}
void AddMainThreadScrollingReasons(uint32_t main_thread_scrolling_reasons);
void ClearMainThreadScrollingReasons(
uint32_t main_thread_scrolling_reasons_to_clear);
uint32_t main_thread_scrolling_reasons() const {
return inputs_.main_thread_scrolling_reasons;
}
bool should_scroll_on_main_thread() const {
return !!inputs_.main_thread_scrolling_reasons;
}
void SetNonFastScrollableRegion(const Region& non_fast_scrollable_region);
const Region& non_fast_scrollable_region() const {
return inputs_.non_fast_scrollable_region;
}
void SetTouchEventHandlerRegion(const Region& touch_event_handler_region);
const Region& touch_event_handler_region() const {
return inputs_.touch_event_handler_region;
}
void set_did_scroll_callback(
const base::Callback<void(const gfx::ScrollOffset&)>& callback) {
inputs_.did_scroll_callback = callback;
}
void SetForceRenderSurfaceForTesting(bool force_render_surface);
bool force_render_surface_for_testing() const {
return force_render_surface_for_testing_;
}
gfx::ScrollOffset CurrentScrollOffset() const {
return inputs_.scroll_offset;
}
void SetDoubleSided(bool double_sided);
bool double_sided() const { return inputs_.double_sided; }
void SetShouldFlattenTransform(bool flatten);
bool should_flatten_transform() const {
return inputs_.should_flatten_transform;
}
bool Is3dSorted() const { return inputs_.sorting_context_id != 0; }
void SetUseParentBackfaceVisibility(bool use);
bool use_parent_backface_visibility() const {
return inputs_.use_parent_backface_visibility;
}
void SetUseLocalTransformForBackfaceVisibility(bool use_local);
bool use_local_transform_for_backface_visibility() const {
return use_local_transform_for_backface_visibility_;
}
void SetShouldCheckBackfaceVisibility(bool should_check_backface_visibility);
bool should_check_backface_visibility() const {
return should_check_backface_visibility_;
}
virtual void SetLayerTreeHost(LayerTreeHost* host);
void SetIsDrawable(bool is_drawable);
void SetHideLayerAndSubtree(bool hide);
bool hide_layer_and_subtree() const { return inputs_.hide_layer_and_subtree; }
void SetFiltersOrigin(const gfx::PointF& origin);
gfx::PointF filters_origin() const { return inputs_.filters_origin; }
int NumDescendantsThatDrawContent() const;
// This is only virtual for tests.
// TODO(awoloszyn): Remove this once we no longer need it for tests
virtual bool DrawsContent() const;
// This methods typically need to be overwritten by derived classes.
// TODO(chrishtr): Blink no longer resizes anything during paint. We can
// remove this.
virtual void SavePaintProperties();
// Returns true iff anything was updated that needs to be committed.
virtual bool Update();
virtual void SetLayerMaskType(Layer::LayerMaskType type) {}
virtual bool IsSuitableForGpuRasterization() const;
virtual std::unique_ptr<base::trace_event::ConvertableToTraceFormat>
TakeDebugInfo();
virtual void didUpdateMainThreadScrollingReasons();
void SetLayerClient(LayerClient* client) { inputs_.client = client; }
virtual bool IsSnapped();
virtual void PushPropertiesTo(LayerImpl* layer);
LayerTreeHost* GetLayerTreeHostForTesting() const { return layer_tree_host_; }
virtual ScrollbarLayerInterface* ToScrollbarLayer();
virtual sk_sp<SkPicture> GetPicture() const;
// Constructs a LayerImpl of the correct runtime type for this Layer type.
virtual std::unique_ptr<LayerImpl> CreateLayerImpl(LayerTreeImpl* tree_impl);
bool NeedsDisplayForTesting() const { return !inputs_.update_rect.IsEmpty(); }
void ResetNeedsDisplayForTesting() { inputs_.update_rect = gfx::Rect(); }
const PaintProperties& paint_properties() const {
return paint_properties_;
}
// Mark the layer as needing to push its properties to the LayerImpl during
// commit.
void SetNeedsPushProperties();
void ResetNeedsPushPropertiesForTesting();
virtual void RunMicroBenchmark(MicroBenchmark* benchmark);
void Set3dSortingContextId(int id);
int sorting_context_id() const { return inputs_.sorting_context_id; }
void set_property_tree_sequence_number(int sequence_number) {
property_tree_sequence_number_ = sequence_number;
}
int property_tree_sequence_number() { return property_tree_sequence_number_; }
void SetTransformTreeIndex(int index);
int transform_tree_index() const;
void SetClipTreeIndex(int index);
int clip_tree_index() const;
void SetEffectTreeIndex(int index);
int effect_tree_index() const;
void SetScrollTreeIndex(int index);
int scroll_tree_index() const;
void set_offset_to_transform_parent(gfx::Vector2dF offset) {
if (offset_to_transform_parent_ == offset)
return;
offset_to_transform_parent_ = offset;
SetNeedsPushProperties();
}
gfx::Vector2dF offset_to_transform_parent() const {
return offset_to_transform_parent_;
}
// TODO(enne): This needs a different name. It is a calculated value
// from the property tree builder and not a synonym for "should
// flatten transform".
void set_should_flatten_transform_from_property_tree(bool should_flatten) {
if (should_flatten_transform_from_property_tree_ == should_flatten)
return;
should_flatten_transform_from_property_tree_ = should_flatten;
SetNeedsPushProperties();
}
bool should_flatten_transform_from_property_tree() const {
return should_flatten_transform_from_property_tree_;
}
const gfx::Rect& visible_layer_rect_for_testing() const {
return visible_layer_rect_;
}
void set_visible_layer_rect(const gfx::Rect& rect) {
visible_layer_rect_ = rect;
}
// This is for tracking damage.
void SetSubtreePropertyChanged();
bool subtree_property_changed() const { return subtree_property_changed_; }
void SetMayContainVideo(bool yes);
bool has_copy_requests_in_target_subtree();
// Stable identifier for clients. See comment in cc/trees/element_id.h.
void SetElementId(ElementId id);
ElementId element_id() const { return inputs_.element_id; }
void SetMutableProperties(uint32_t properties);
uint32_t mutable_properties() const { return inputs_.mutable_properties; }
bool HasTickingAnimationForTesting() const;
void SetHasWillChangeTransformHint(bool has_will_change);
bool has_will_change_transform_hint() const {
return inputs_.has_will_change_transform_hint;
}
MutatorHost* GetMutatorHost() const;
ElementListType GetElementTypeForAnimation() const;
void SetScrollbarsHiddenFromImplSide(bool hidden);
void set_is_scroll_clip_layer() { is_scroll_clip_layer_ = true; }
const gfx::Rect& update_rect() const { return inputs_.update_rect; }
LayerTreeHost* layer_tree_host() const { return layer_tree_host_; }
// Called on the scroll layer to trigger showing the overlay scrollbars.
void ShowScrollbars() { needs_show_scrollbars_ = true; }
protected:
friend class LayerImpl;
friend class TreeSynchronizer;
virtual ~Layer();
Layer();
// These SetNeeds functions are in order of severity of update:
//
// Called when a property has been modified in a way that the layer knows
// immediately that a commit is required. This implies SetNeedsPushProperties
// to push that property.
void SetNeedsCommit();
// Called when there's been a change in layer structure. Implies
// SetNeedsCommit and property tree rebuld, but not SetNeedsPushProperties
// (the full tree is synced over).
void SetNeedsFullTreeSync();
// Called when the next commit should wait until the pending tree is activated
// before finishing the commit and unblocking the main thread. Used to ensure
// unused resources on the impl thread are returned before commit completes.
void SetNextCommitWaitsForActivation();
// Will recalculate whether the layer draws content and set draws_content_
// appropriately.
void UpdateDrawsContent(bool has_drawable_content);
virtual bool HasDrawableContent() const;
// Called when the layer's number of drawable descendants changes.
void AddDrawableDescendants(int num);
bool IsPropertyChangeAllowed() const;
// When true, the layer is about to perform an update. Any commit requests
// will be handled implicitly after the update completes.
bool ignore_set_needs_commit_;
private:
friend class base::RefCounted<Layer>;
friend class LayerTreeHostCommon;
friend class LayerTreeHost;
// Interactions with attached animations.
gfx::ScrollOffset ScrollOffsetForAnimation() const;
void OnFilterAnimated(const FilterOperations& filters);
void OnOpacityAnimated(float opacity);
void OnTransformAnimated(const gfx::Transform& transform);
void OnScrollOffsetAnimated(const gfx::ScrollOffset& scroll_offset);
bool FilterIsAnimating() const;
bool TransformIsAnimating() const;
bool ScrollOffsetAnimationWasInterrupted() const;
bool HasOnlyTranslationTransforms() const;
void AddScrollChild(Layer* child);
void RemoveScrollChild(Layer* child);
void AddClipChild(Layer* child);
void RemoveClipChild(Layer* child);
void SetParent(Layer* layer);
bool DescendantIsFixedToContainerLayer() const;
// This should only be called from RemoveFromParent().
void RemoveChildOrDependent(Layer* child);
// If this layer has a scroll parent, it removes |this| from its list of
// scroll children.
void RemoveFromScrollTree();
// If this layer has a clip parent, it removes |this| from its list of clip
// children.
void RemoveFromClipTree();
// When we detach or attach layer to new LayerTreeHost, all property trees'
// indices becomes invalid.
void InvalidatePropertyTreesIndices();
// This is set whenever a property changed on layer that affects whether this
// layer should own a property tree node or not.
void SetPropertyTreesNeedRebuild();
// Encapsulates all data, callbacks or interfaces received from the embedder.
// TODO(khushalsagar): This is only valid when PropertyTrees are built
// internally in cc. Update this for the SPv2 path where blink generates
// PropertyTrees.
struct Inputs {
explicit Inputs(int layer_id);
~Inputs();
int layer_id;
LayerList children;
// The update rect is the region of the compositor resource that was
// actually updated by the compositor. For layers that may do updating
// outside the compositor's control (i.e. plugin layers), this information
// is not available and the update rect will remain empty.
// Note this rect is in layer space (not content space).
gfx::Rect update_rect;
gfx::Size bounds;
bool masks_to_bounds;
scoped_refptr<Layer> mask_layer;
float opacity;
SkBlendMode blend_mode;
bool is_root_for_isolated_group : 1;
bool contents_opaque : 1;
gfx::PointF position;
gfx::Transform transform;
gfx::Point3F transform_origin;
bool is_drawable : 1;
bool double_sided : 1;
bool should_flatten_transform : 1;
// Layers that share a sorting context id will be sorted together in 3d
// space. 0 is a special value that means this layer will not be sorted
// and will be drawn in paint order.
int sorting_context_id;
bool use_parent_backface_visibility : 1;
SkColor background_color;
FilterOperations filters;
FilterOperations background_filters;
gfx::PointF filters_origin;
gfx::ScrollOffset scroll_offset;
// This variable indicates which ancestor layer (if any) whose size,
// transformed relative to this layer, defines the maximum scroll offset
// for this layer.
int scroll_clip_layer_id;
bool user_scrollable_horizontal : 1;
bool user_scrollable_vertical : 1;
uint32_t main_thread_scrolling_reasons;
Region non_fast_scrollable_region;
Region touch_event_handler_region;
bool is_container_for_fixed_position_layers : 1;
LayerPositionConstraint position_constraint;
LayerStickyPositionConstraint sticky_position_constraint;
ElementId element_id;
uint32_t mutable_properties;
Layer* scroll_parent;
Layer* clip_parent;
bool has_will_change_transform_hint : 1;
bool hide_layer_and_subtree : 1;
// The following elements can not and are not serialized.
LayerClient* client;
base::Callback<void(const gfx::ScrollOffset&)> did_scroll_callback;
std::vector<std::unique_ptr<CopyOutputRequest>> copy_requests;
};
Layer* parent_;
// Layer instances have a weak pointer to their LayerTreeHost.
// This pointer value is nil when a Layer is not in a tree and is
// updated via SetLayerTreeHost() if a layer moves between trees.
LayerTreeHost* layer_tree_host_;
Inputs inputs_;
int num_descendants_that_draw_content_;
int transform_tree_index_;
int effect_tree_index_;
int clip_tree_index_;
int scroll_tree_index_;
int property_tree_sequence_number_;
gfx::Vector2dF offset_to_transform_parent_;
bool should_flatten_transform_from_property_tree_ : 1;
bool draws_content_ : 1;
bool use_local_transform_for_backface_visibility_ : 1;
bool should_check_backface_visibility_ : 1;
bool force_render_surface_for_testing_ : 1;
bool subtree_property_changed_ : 1;
bool may_contain_video_ : 1;
bool is_scroll_clip_layer_ : 1;
bool needs_show_scrollbars_ : 1;
// This value is valid only when LayerTreeHost::has_copy_request() is true
bool subtree_has_copy_request_ : 1;
SkColor safe_opaque_background_color_;
std::unique_ptr<std::set<Layer*>> scroll_children_;
std::unique_ptr<std::set<Layer*>> clip_children_;
PaintProperties paint_properties_;
// These all act like draw properties, so don't need push properties.
gfx::Rect visible_layer_rect_;
size_t num_unclipped_descendants_;
DISALLOW_COPY_AND_ASSIGN(Layer);
};
} // namespace cc
#endif // CC_LAYERS_LAYER_H_