enne@chromium.org | cd57cc5a | 2012-10-12 22:43:41 | [diff] [blame] | 1 | // Copyright 2010 The Chromium Authors. All rights reserved. |
enne@chromium.org | 0fb2500 | 2012-10-12 07:20:02 | [diff] [blame] | 2 | // Use of this source code is governed by a BSD-style license that can be |
| 3 | // found in the LICENSE file. |
enne@chromium.org | cd57cc5a | 2012-10-12 22:43:41 | [diff] [blame] | 4 | |
jamesr@chromium.org | cc3cfaa | 2013-03-18 09:05:52 | [diff] [blame] | 5 | #ifndef CC_LAYERS_LAYER_H_ |
| 6 | #define CC_LAYERS_LAYER_H_ |
enne@chromium.org | cd57cc5a | 2012-10-12 22:43:41 | [diff] [blame] | 7 | |
vollick@chromium.org | 0e98cdd | 2013-08-23 00:44:30 | [diff] [blame] | 8 | #include <set> |
shawnsingh@chromium.org | c8686a0 | 2012-11-27 08:29:00 | [diff] [blame] | 9 | #include <string> |
shawnsingh@chromium.org | c8686a0 | 2012-11-27 08:29:00 | [diff] [blame] | 10 | |
danakj@chromium.org | 18a7019 | 2013-04-26 16:18:25 | [diff] [blame] | 11 | #include "base/callback.h" |
tfarina@chromium.org | a8461d8 | 2012-10-16 21:11:14 | [diff] [blame] | 12 | #include "base/memory/ref_counted.h" |
ajuma@chromium.org | e10cd02 | 2012-12-18 00:32:26 | [diff] [blame] | 13 | #include "base/observer_list.h" |
jamesr@chromium.org | 95e4e1a0 | 2013-03-18 07:09:09 | [diff] [blame] | 14 | #include "cc/animation/layer_animation_controller.h" |
jamesr@chromium.org | 95e4e1a0 | 2013-03-18 07:09:09 | [diff] [blame] | 15 | #include "cc/animation/layer_animation_value_observer.h" |
ajuma@chromium.org | b8384e2 | 2013-12-03 02:20:48 | [diff] [blame] | 16 | #include "cc/animation/layer_animation_value_provider.h" |
jamesr@chromium.org | 681ccff | 2013-03-18 06:13:52 | [diff] [blame] | 17 | #include "cc/base/cc_export.h" |
| 18 | #include "cc/base/region.h" |
danakj@chromium.org | 0e5f714 | 2013-05-24 06:45:36 | [diff] [blame] | 19 | #include "cc/base/scoped_ptr_vector.h" |
vmpstr@chromium.org | 666d7cf | 2013-10-12 01:30:29 | [diff] [blame] | 20 | #include "cc/debug/micro_benchmark.h" |
jamesr@chromium.org | cc3cfaa | 2013-03-18 09:05:52 | [diff] [blame] | 21 | #include "cc/layers/draw_properties.h" |
danakj@chromium.org | 50761e9 | 2013-03-29 20:51:28 | [diff] [blame] | 22 | #include "cc/layers/layer_lists.h" |
trchen@chromium.org | fe956c9c4 | 2013-04-09 04:26:33 | [diff] [blame] | 23 | #include "cc/layers/layer_position_constraint.h" |
reveman@chromium.org | 445881f | 2013-04-16 01:11:59 | [diff] [blame] | 24 | #include "cc/layers/paint_properties.h" |
jamesr@chromium.org | cc3cfaa | 2013-03-18 09:05:52 | [diff] [blame] | 25 | #include "cc/layers/render_surface.h" |
ajuma@chromium.org | ae6b1a7 | 2013-06-25 18:49:29 | [diff] [blame] | 26 | #include "cc/output/filter_operations.h" |
vollick | 51ed1a2 | 2014-12-17 02:03:00 | [diff] [blame^] | 27 | #include "cc/trees/property_tree.h" |
danakj@chromium.org | 1940c4e | 2012-12-04 05:08:15 | [diff] [blame] | 28 | #include "skia/ext/refptr.h" |
tfarina@chromium.org | ddf9df8 | 2012-10-16 06:52:46 | [diff] [blame] | 29 | #include "third_party/skia/include/core/SkColor.h" |
danakj@chromium.org | 1940c4e | 2012-12-04 05:08:15 | [diff] [blame] | 30 | #include "third_party/skia/include/core/SkImageFilter.h" |
alokp@chromium.org | f7837a9 | 2013-08-21 03:00:05 | [diff] [blame] | 31 | #include "third_party/skia/include/core/SkPicture.h" |
rosca@adobe.com | 7bbeaf4e | 2013-11-26 10:27:22 | [diff] [blame] | 32 | #include "third_party/skia/include/core/SkXfermode.h" |
heejin.r.chung | d28506ba | 2014-10-23 16:36:20 | [diff] [blame] | 33 | #include "ui/gfx/geometry/point3_f.h" |
| 34 | #include "ui/gfx/geometry/rect.h" |
| 35 | #include "ui/gfx/geometry/rect_f.h" |
miletus | f57925d | 2014-10-01 19:38:13 | [diff] [blame] | 36 | #include "ui/gfx/geometry/scroll_offset.h" |
shawnsingh@chromium.org | c8686a0 | 2012-11-27 08:29:00 | [diff] [blame] | 37 | #include "ui/gfx/transform.h" |
enne@chromium.org | cd57cc5a | 2012-10-12 22:43:41 | [diff] [blame] | 38 | |
ajuma@chromium.org | db2586f | 2013-08-15 22:03:14 | [diff] [blame] | 39 | namespace gfx { |
| 40 | class BoxF; |
| 41 | } |
| 42 | |
chrishtr@gmail.com | 9f3be43 | 2013-12-03 03:53:22 | [diff] [blame] | 43 | namespace base { |
| 44 | namespace debug { |
| 45 | class ConvertableToTraceFormat; |
| 46 | } |
| 47 | } |
| 48 | |
enne@chromium.org | cd57cc5a | 2012-10-12 22:43:41 | [diff] [blame] | 49 | namespace cc { |
| 50 | |
vollick@chromium.org | 4d0786a | 2013-01-07 16:21:20 | [diff] [blame] | 51 | class Animation; |
tfarina@chromium.org | 3cae03e | 2013-06-26 22:13:52 | [diff] [blame] | 52 | class AnimationDelegate; |
enne@chromium.org | 96baf3e | 2012-10-22 23:09:55 | [diff] [blame] | 53 | struct AnimationEvent; |
danakj@chromium.org | 0e5f714 | 2013-05-24 06:45:36 | [diff] [blame] | 54 | class CopyOutputRequest; |
enne@chromium.org | 96baf3e | 2012-10-22 23:09:55 | [diff] [blame] | 55 | class LayerAnimationDelegate; |
ajuma@chromium.org | 7f5605c | 2013-04-08 18:08:35 | [diff] [blame] | 56 | class LayerAnimationEventObserver; |
qiankun.miao@intel.com | ae716ce | 2013-08-16 13:04:24 | [diff] [blame] | 57 | class LayerClient; |
enne@chromium.org | 96baf3e | 2012-10-22 23:09:55 | [diff] [blame] | 58 | class LayerImpl; |
| 59 | class LayerTreeHost; |
nduca@chromium.org | 8bef4057 | 2012-12-11 21:38:08 | [diff] [blame] | 60 | class LayerTreeImpl; |
enne@chromium.org | 96baf3e | 2012-10-22 23:09:55 | [diff] [blame] | 61 | class PriorityCalculator; |
egraether@chromium.org | d8411661 | 2013-03-29 05:32:49 | [diff] [blame] | 62 | class RenderingStatsInstrumentation; |
reveman@google.com | b4da203 | 2012-10-25 21:22:55 | [diff] [blame] | 63 | class ResourceUpdateQueue; |
wjmaclean@chromium.org | 80413d7 | 2013-08-30 20:25:33 | [diff] [blame] | 64 | class ScrollbarLayerInterface; |
danakj@chromium.org | d5467eb | 2014-08-22 01:16:43 | [diff] [blame] | 65 | class SimpleEnclosedRegion; |
enne@chromium.org | 96baf3e | 2012-10-22 23:09:55 | [diff] [blame] | 66 | struct AnimationEvent; |
danakj@chromium.org | 34ba1ffb | 2014-03-05 06:55:03 | [diff] [blame] | 67 | template <typename LayerType> |
| 68 | class OcclusionTracker; |
enne@chromium.org | cd57cc5a | 2012-10-12 22:43:41 | [diff] [blame] | 69 | |
| 70 | // Base class for composited layers. Special layer types are derived from |
| 71 | // this class. |
vollick@chromium.org | de4afb5e | 2012-12-20 00:11:34 | [diff] [blame] | 72 | class CC_EXPORT Layer : public base::RefCounted<Layer>, |
ajuma@chromium.org | b8384e2 | 2013-12-03 02:20:48 | [diff] [blame] | 73 | public LayerAnimationValueObserver, |
| 74 | public LayerAnimationValueProvider { |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 75 | public: |
vollick@chromium.org | 44d8e84c | 2013-10-19 19:13:22 | [diff] [blame] | 76 | typedef RenderSurfaceLayerList RenderSurfaceListType; |
| 77 | typedef LayerList LayerListType; |
| 78 | typedef RenderSurface RenderSurfaceType; |
| 79 | |
wjmaclean@chromium.org | b7c4783 | 2013-03-15 23:11:42 | [diff] [blame] | 80 | enum LayerIdLabels { |
wjmaclean@chromium.org | b7c4783 | 2013-03-15 23:11:42 | [diff] [blame] | 81 | INVALID_ID = -1, |
| 82 | }; |
enne@chromium.org | cd57cc5a | 2012-10-12 22:43:41 | [diff] [blame] | 83 | |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 84 | static scoped_refptr<Layer> Create(); |
enne@chromium.org | cd57cc5a | 2012-10-12 22:43:41 | [diff] [blame] | 85 | |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 86 | int id() const { return layer_id_; } |
enne@chromium.org | cd57cc5a | 2012-10-12 22:43:41 | [diff] [blame] | 87 | |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 88 | Layer* RootLayer(); |
| 89 | Layer* parent() { return parent_; } |
| 90 | const Layer* parent() const { return parent_; } |
| 91 | void AddChild(scoped_refptr<Layer> child); |
| 92 | void InsertChild(scoped_refptr<Layer> child, size_t index); |
| 93 | void ReplaceChild(Layer* reference, scoped_refptr<Layer> new_layer); |
| 94 | void RemoveFromParent(); |
| 95 | void RemoveAllChildren(); |
| 96 | void SetChildren(const LayerList& children); |
tfarina@chromium.org | f659521e | 2013-07-26 00:27:06 | [diff] [blame] | 97 | bool HasAncestor(const Layer* ancestor) const; |
enne@chromium.org | cd57cc5a | 2012-10-12 22:43:41 | [diff] [blame] | 98 | |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 99 | const LayerList& children() const { return children_; } |
| 100 | Layer* child_at(size_t index) { return children_[index].get(); } |
danakj@chromium.org | 18a7019 | 2013-04-26 16:18:25 | [diff] [blame] | 101 | |
danakj@chromium.org | 0e5f714 | 2013-05-24 06:45:36 | [diff] [blame] | 102 | // This requests the layer and its subtree be rendered and given to the |
| 103 | // callback. If the copy is unable to be produced (the layer is destroyed |
kulkarni.a | 4015690f1 | 2014-10-10 13:50:06 | [diff] [blame] | 104 | // first), then the callback is called with a nullptr/empty result. |
danakj@chromium.org | 0e5f714 | 2013-05-24 06:45:36 | [diff] [blame] | 105 | void RequestCopyOfOutput(scoped_ptr<CopyOutputRequest> request); |
| 106 | bool HasCopyRequest() const { |
| 107 | return !copy_requests_.empty(); |
danakj@chromium.org | 18a7019 | 2013-04-26 16:18:25 | [diff] [blame] | 108 | } |
enne@chromium.org | cd57cc5a | 2012-10-12 22:43:41 | [diff] [blame] | 109 | |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 110 | virtual void SetBackgroundColor(SkColor background_color); |
| 111 | SkColor background_color() const { return background_color_; } |
enne@chromium.org | 2c4cbec | 2013-06-04 21:14:50 | [diff] [blame] | 112 | // If contents_opaque(), return an opaque color else return a |
| 113 | // non-opaque color. Tries to return background_color(), if possible. |
| 114 | SkColor SafeOpaqueBackgroundColor() const; |
enne@chromium.org | cd57cc5a | 2012-10-12 22:43:41 | [diff] [blame] | 115 | |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 116 | // A layer's bounds are in logical, non-page-scaled pixels (however, the |
| 117 | // root layer's bounds are in physical pixels). |
prashant.n@samsung.com | 64348ea | 2014-01-29 22:58:26 | [diff] [blame] | 118 | void SetBounds(const gfx::Size& bounds); |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 119 | gfx::Size bounds() const { return bounds_; } |
enne@chromium.org | cd57cc5a | 2012-10-12 22:43:41 | [diff] [blame] | 120 | |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 121 | void SetMasksToBounds(bool masks_to_bounds); |
| 122 | bool masks_to_bounds() const { return masks_to_bounds_; } |
enne@chromium.org | cd57cc5a | 2012-10-12 22:43:41 | [diff] [blame] | 123 | |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 124 | void SetMaskLayer(Layer* mask_layer); |
| 125 | Layer* mask_layer() { return mask_layer_.get(); } |
| 126 | const Layer* mask_layer() const { return mask_layer_.get(); } |
enne@chromium.org | cd57cc5a | 2012-10-12 22:43:41 | [diff] [blame] | 127 | |
danakj | 19f0c9e | 2014-10-11 03:24:42 | [diff] [blame] | 128 | virtual void SetNeedsDisplayRect(const gfx::Rect& dirty_rect); |
| 129 | void SetNeedsDisplay() { SetNeedsDisplayRect(gfx::Rect(bounds())); } |
enne@chromium.org | cd57cc5a | 2012-10-12 22:43:41 | [diff] [blame] | 130 | |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 131 | void SetOpacity(float opacity); |
| 132 | float opacity() const { return opacity_; } |
| 133 | bool OpacityIsAnimating() const; |
wjmaclean@chromium.org | b7c4783 | 2013-03-15 23:11:42 | [diff] [blame] | 134 | virtual bool OpacityCanAnimateOnImplThread() const; |
rosca@adobe.com | 7bbeaf4e | 2013-11-26 10:27:22 | [diff] [blame] | 135 | |
| 136 | void SetBlendMode(SkXfermode::Mode blend_mode); |
| 137 | SkXfermode::Mode blend_mode() const { return blend_mode_; } |
| 138 | |
| 139 | bool uses_default_blend_mode() const { |
| 140 | return blend_mode_ == SkXfermode::kSrcOver_Mode; |
| 141 | } |
| 142 | |
| 143 | // A layer is root for an isolated group when it and all its descendants are |
| 144 | // drawn over a black and fully transparent background, creating an isolated |
| 145 | // group. It should be used along with SetBlendMode(), in order to restrict |
| 146 | // layers within the group to blend with layers outside this group. |
| 147 | void SetIsRootForIsolatedGroup(bool root); |
| 148 | bool is_root_for_isolated_group() const { |
| 149 | return is_root_for_isolated_group_; |
| 150 | } |
enne@chromium.org | cd57cc5a | 2012-10-12 22:43:41 | [diff] [blame] | 151 | |
ajuma@chromium.org | ae6b1a7 | 2013-06-25 18:49:29 | [diff] [blame] | 152 | void SetFilters(const FilterOperations& filters); |
| 153 | const FilterOperations& filters() const { return filters_; } |
ajuma@chromium.org | b4c6d81 | 2013-10-03 15:48:56 | [diff] [blame] | 154 | bool FilterIsAnimating() const; |
senorblanco@chromium.org | 4000abf | 2012-10-23 04:45:45 | [diff] [blame] | 155 | |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 156 | // Background filters are filters applied to what is behind this layer, when |
| 157 | // they are viewed through non-opaque regions in this layer. They are used |
| 158 | // through the WebLayer interface, and are not exposed to HTML. |
ajuma@chromium.org | ae6b1a7 | 2013-06-25 18:49:29 | [diff] [blame] | 159 | void SetBackgroundFilters(const FilterOperations& filters); |
| 160 | const FilterOperations& background_filters() const { |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 161 | return background_filters_; |
| 162 | } |
enne@chromium.org | cd57cc5a | 2012-10-12 22:43:41 | [diff] [blame] | 163 | |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 164 | virtual void SetContentsOpaque(bool opaque); |
| 165 | bool contents_opaque() const { return contents_opaque_; } |
enne@chromium.org | cd57cc5a | 2012-10-12 22:43:41 | [diff] [blame] | 166 | |
r.kasibhatla@samsung.com | 14bc5d68 | 2014-01-17 07:26:47 | [diff] [blame] | 167 | void SetPosition(const gfx::PointF& position); |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 168 | gfx::PointF position() const { return position_; } |
enne@chromium.org | cd57cc5a | 2012-10-12 22:43:41 | [diff] [blame] | 169 | |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 170 | void SetIsContainerForFixedPositionLayers(bool container); |
trchen@chromium.org | fe956c9c4 | 2013-04-09 04:26:33 | [diff] [blame] | 171 | bool IsContainerForFixedPositionLayers() const; |
enne@chromium.org | cd57cc5a | 2012-10-12 22:43:41 | [diff] [blame] | 172 | |
trchen@chromium.org | fe956c9c4 | 2013-04-09 04:26:33 | [diff] [blame] | 173 | void SetPositionConstraint(const LayerPositionConstraint& constraint); |
| 174 | const LayerPositionConstraint& position_constraint() const { |
| 175 | return position_constraint_; |
| 176 | } |
enne@chromium.org | cd57cc5a | 2012-10-12 22:43:41 | [diff] [blame] | 177 | |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 178 | void SetTransform(const gfx::Transform& transform); |
| 179 | const gfx::Transform& transform() const { return transform_; } |
| 180 | bool TransformIsAnimating() const; |
avallee@chromium.org | 08bdf1b | 2014-04-16 23:23:29 | [diff] [blame] | 181 | bool transform_is_invertible() const { return transform_is_invertible_; } |
chrishtr@chromium.org | a256641 | 2014-06-05 03:14:20 | [diff] [blame] | 182 | |
| 183 | void SetTransformOrigin(const gfx::Point3F&); |
vollick | 51ed1a2 | 2014-12-17 02:03:00 | [diff] [blame^] | 184 | gfx::Point3F transform_origin() const { return transform_origin_; } |
vollick@chromium.org | 0e98cdd | 2013-08-23 00:44:30 | [diff] [blame] | 185 | |
| 186 | void SetScrollParent(Layer* parent); |
| 187 | |
| 188 | Layer* scroll_parent() { return scroll_parent_; } |
| 189 | const Layer* scroll_parent() const { return scroll_parent_; } |
| 190 | |
| 191 | void AddScrollChild(Layer* child); |
| 192 | void RemoveScrollChild(Layer* child); |
| 193 | |
| 194 | std::set<Layer*>* scroll_children() { return scroll_children_.get(); } |
| 195 | const std::set<Layer*>* scroll_children() const { |
| 196 | return scroll_children_.get(); |
| 197 | } |
| 198 | |
| 199 | void SetClipParent(Layer* ancestor); |
| 200 | |
| 201 | Layer* clip_parent() { return clip_parent_; } |
| 202 | const Layer* clip_parent() const { |
| 203 | return clip_parent_; |
| 204 | } |
| 205 | |
| 206 | void AddClipChild(Layer* child); |
| 207 | void RemoveClipChild(Layer* child); |
| 208 | |
| 209 | std::set<Layer*>* clip_children() { return clip_children_.get(); } |
| 210 | const std::set<Layer*>* clip_children() const { |
| 211 | return clip_children_.get(); |
| 212 | } |
enne@chromium.org | cd57cc5a | 2012-10-12 22:43:41 | [diff] [blame] | 213 | |
vollick@chromium.org | 44d8e84c | 2013-10-19 19:13:22 | [diff] [blame] | 214 | DrawProperties<Layer>& draw_properties() { return draw_properties_; } |
| 215 | const DrawProperties<Layer>& draw_properties() const { |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 216 | return draw_properties_; |
| 217 | } |
shawnsingh@google.com | d76806f8 | 2012-12-05 21:41:50 | [diff] [blame] | 218 | |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 219 | // The following are shortcut accessors to get various information from |
| 220 | // draw_properties_ |
| 221 | const gfx::Transform& draw_transform() const { |
| 222 | return draw_properties_.target_space_transform; |
| 223 | } |
| 224 | const gfx::Transform& screen_space_transform() const { |
| 225 | return draw_properties_.screen_space_transform; |
| 226 | } |
| 227 | float draw_opacity() const { return draw_properties_.opacity; } |
| 228 | bool draw_opacity_is_animating() const { |
| 229 | return draw_properties_.opacity_is_animating; |
| 230 | } |
| 231 | bool draw_transform_is_animating() const { |
| 232 | return draw_properties_.target_space_transform_is_animating; |
| 233 | } |
| 234 | bool screen_space_transform_is_animating() const { |
| 235 | return draw_properties_.screen_space_transform_is_animating; |
| 236 | } |
| 237 | bool screen_space_opacity_is_animating() const { |
| 238 | return draw_properties_.screen_space_opacity_is_animating; |
| 239 | } |
| 240 | bool can_use_lcd_text() const { return draw_properties_.can_use_lcd_text; } |
| 241 | bool is_clipped() const { return draw_properties_.is_clipped; } |
| 242 | gfx::Rect clip_rect() const { return draw_properties_.clip_rect; } |
| 243 | gfx::Rect drawable_content_rect() const { |
| 244 | return draw_properties_.drawable_content_rect; |
| 245 | } |
| 246 | gfx::Rect visible_content_rect() const { |
| 247 | return draw_properties_.visible_content_rect; |
| 248 | } |
| 249 | Layer* render_target() { |
| 250 | DCHECK(!draw_properties_.render_target || |
| 251 | draw_properties_.render_target->render_surface()); |
| 252 | return draw_properties_.render_target; |
| 253 | } |
| 254 | const Layer* render_target() const { |
| 255 | DCHECK(!draw_properties_.render_target || |
| 256 | draw_properties_.render_target->render_surface()); |
| 257 | return draw_properties_.render_target; |
| 258 | } |
| 259 | RenderSurface* render_surface() const { |
| 260 | return draw_properties_.render_surface.get(); |
| 261 | } |
vollick@chromium.org | 420fdf6e | 2013-08-26 20:36:38 | [diff] [blame] | 262 | int num_unclipped_descendants() const { |
| 263 | return draw_properties_.num_unclipped_descendants; |
| 264 | } |
enne@chromium.org | cd57cc5a | 2012-10-12 22:43:41 | [diff] [blame] | 265 | |
miletus | f57925d | 2014-10-01 19:38:13 | [diff] [blame] | 266 | void SetScrollOffset(const gfx::ScrollOffset& scroll_offset); |
| 267 | gfx::ScrollOffset scroll_offset() const { return scroll_offset_; } |
| 268 | void SetScrollOffsetFromImplSide(const gfx::ScrollOffset& scroll_offset); |
enne@chromium.org | cd57cc5a | 2012-10-12 22:43:41 | [diff] [blame] | 269 | |
wjmaclean@chromium.org | adeda57 | 2014-01-31 00:49:47 | [diff] [blame] | 270 | void SetScrollClipLayerId(int clip_layer_id); |
| 271 | bool scrollable() const { return scroll_clip_layer_id_ != INVALID_ID; } |
enne@chromium.org | cd57cc5a | 2012-10-12 22:43:41 | [diff] [blame] | 272 | |
sadrul@chromium.org | 59a7d55 | 2013-10-22 03:36:43 | [diff] [blame] | 273 | void SetUserScrollable(bool horizontal, bool vertical); |
| 274 | bool user_scrollable_horizontal() const { |
| 275 | return user_scrollable_horizontal_; |
| 276 | } |
| 277 | bool user_scrollable_vertical() const { return user_scrollable_vertical_; } |
| 278 | |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 279 | void SetShouldScrollOnMainThread(bool should_scroll_on_main_thread); |
| 280 | bool should_scroll_on_main_thread() const { |
| 281 | return should_scroll_on_main_thread_; |
| 282 | } |
enne@chromium.org | cd57cc5a | 2012-10-12 22:43:41 | [diff] [blame] | 283 | |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 284 | void SetHaveWheelEventHandlers(bool have_wheel_event_handlers); |
| 285 | bool have_wheel_event_handlers() const { return have_wheel_event_handlers_; } |
enne@chromium.org | cd57cc5a | 2012-10-12 22:43:41 | [diff] [blame] | 286 | |
skyostil@chromium.org | f998c53 | 2014-03-31 20:02:51 | [diff] [blame] | 287 | void SetHaveScrollEventHandlers(bool have_scroll_event_handlers); |
| 288 | bool have_scroll_event_handlers() const { |
| 289 | return have_scroll_event_handlers_; |
| 290 | } |
| 291 | |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 292 | void SetNonFastScrollableRegion(const Region& non_fast_scrollable_region); |
| 293 | const Region& non_fast_scrollable_region() const { |
| 294 | return non_fast_scrollable_region_; |
| 295 | } |
enne@chromium.org | cd57cc5a | 2012-10-12 22:43:41 | [diff] [blame] | 296 | |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 297 | void SetTouchEventHandlerRegion(const Region& touch_event_handler_region); |
| 298 | const Region& touch_event_handler_region() const { |
| 299 | return touch_event_handler_region_; |
| 300 | } |
yusufo@chromium.org | 23d56be | 2012-11-08 00:33:34 | [diff] [blame] | 301 | |
tfarina@chromium.org | 28096ed | 2013-07-01 07:38:58 | [diff] [blame] | 302 | void set_did_scroll_callback(const base::Closure& callback) { |
| 303 | did_scroll_callback_ = callback; |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 304 | } |
enne@chromium.org | cd57cc5a | 2012-10-12 22:43:41 | [diff] [blame] | 305 | |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 306 | void SetDrawCheckerboardForMissingTiles(bool checkerboard); |
danakj@chromium.org | b74241eb | 2014-03-08 11:35:02 | [diff] [blame] | 307 | bool draw_checkerboard_for_missing_tiles() const { |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 308 | return draw_checkerboard_for_missing_tiles_; |
| 309 | } |
enne@chromium.org | cd57cc5a | 2012-10-12 22:43:41 | [diff] [blame] | 310 | |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 311 | void SetForceRenderSurface(bool force_render_surface); |
| 312 | bool force_render_surface() const { return force_render_surface_; } |
enne@chromium.org | cd57cc5a | 2012-10-12 22:43:41 | [diff] [blame] | 313 | |
miletus | f57925d | 2014-10-01 19:38:13 | [diff] [blame] | 314 | gfx::Vector2dF ScrollDelta() const { return gfx::Vector2dF(); } |
| 315 | gfx::ScrollOffset TotalScrollOffset() const { |
| 316 | return ScrollOffsetWithDelta(scroll_offset(), ScrollDelta()); |
enne@chromium.org | 4ec78f8 | 2013-07-11 18:45:47 | [diff] [blame] | 317 | } |
enne@chromium.org | cd57cc5a | 2012-10-12 22:43:41 | [diff] [blame] | 318 | |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 319 | void SetDoubleSided(bool double_sided); |
| 320 | bool double_sided() const { return double_sided_; } |
enne@chromium.org | cd57cc5a | 2012-10-12 22:43:41 | [diff] [blame] | 321 | |
vollick@chromium.org | 56fffdd | 2014-02-11 19:50:57 | [diff] [blame] | 322 | void SetShouldFlattenTransform(bool flatten); |
| 323 | bool should_flatten_transform() const { return should_flatten_transform_; } |
| 324 | |
thildebr@chromium.org | a9d4d4f | 2014-06-19 06:49:28 | [diff] [blame] | 325 | bool Is3dSorted() const { return sorting_context_id_ != 0; } |
enne@chromium.org | cd57cc5a | 2012-10-12 22:43:41 | [diff] [blame] | 326 | |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 327 | void set_use_parent_backface_visibility(bool use) { |
| 328 | use_parent_backface_visibility_ = use; |
| 329 | } |
| 330 | bool use_parent_backface_visibility() const { |
| 331 | return use_parent_backface_visibility_; |
| 332 | } |
enne@chromium.org | cd57cc5a | 2012-10-12 22:43:41 | [diff] [blame] | 333 | |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 334 | virtual void SetLayerTreeHost(LayerTreeHost* host); |
enne@chromium.org | cd57cc5a | 2012-10-12 22:43:41 | [diff] [blame] | 335 | |
awoloszyn@chromium.org | ad63b2f | 2014-08-11 17:39:54 | [diff] [blame] | 336 | virtual bool HasDelegatedContent() const; |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 337 | bool HasContributingDelegatedRenderPasses() const { return false; } |
enne@chromium.org | cd57cc5a | 2012-10-12 22:43:41 | [diff] [blame] | 338 | |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 339 | void SetIsDrawable(bool is_drawable); |
enne@chromium.org | cd57cc5a | 2012-10-12 22:43:41 | [diff] [blame] | 340 | |
danakj@chromium.org | c0ae06c | 2013-06-24 18:32:19 | [diff] [blame] | 341 | void SetHideLayerAndSubtree(bool hide); |
| 342 | bool hide_layer_and_subtree() const { return hide_layer_and_subtree_; } |
| 343 | |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 344 | void SetReplicaLayer(Layer* layer); |
| 345 | Layer* replica_layer() { return replica_layer_.get(); } |
| 346 | const Layer* replica_layer() const { return replica_layer_.get(); } |
enne@chromium.org | cd57cc5a | 2012-10-12 22:43:41 | [diff] [blame] | 347 | |
rsleevi@chromium.org | 22898ed | 2013-06-01 04:52:30 | [diff] [blame] | 348 | bool has_mask() const { return !!mask_layer_.get(); } |
| 349 | bool has_replica() const { return !!replica_layer_.get(); } |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 350 | bool replica_has_mask() const { |
rsleevi@chromium.org | 22898ed | 2013-06-01 04:52:30 | [diff] [blame] | 351 | return replica_layer_.get() && |
| 352 | (mask_layer_.get() || replica_layer_->mask_layer_.get()); |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 353 | } |
enne@chromium.org | cd57cc5a | 2012-10-12 22:43:41 | [diff] [blame] | 354 | |
awoloszyn@chromium.org | ad63b2f | 2014-08-11 17:39:54 | [diff] [blame] | 355 | int NumDescendantsThatDrawContent() const; |
| 356 | |
| 357 | // This is only virtual for tests. |
| 358 | // TODO(awoloszyn): Remove this once we no longer need it for tests |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 359 | virtual bool DrawsContent() const; |
awoloszyn@chromium.org | ad63b2f | 2014-08-11 17:39:54 | [diff] [blame] | 360 | |
| 361 | // This methods typically need to be overwritten by derived classes. |
reveman@chromium.org | 445881f | 2013-04-16 01:11:59 | [diff] [blame] | 362 | virtual void SavePaintProperties(); |
enne@chromium.org | 49304bde | 2013-07-08 21:31:22 | [diff] [blame] | 363 | // Returns true iff any resources were updated that need to be committed. |
| 364 | virtual bool Update(ResourceUpdateQueue* queue, |
danakj@chromium.org | 34ba1ffb | 2014-03-05 06:55:03 | [diff] [blame] | 365 | const OcclusionTracker<Layer>* occlusion); |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 366 | virtual bool NeedMoreUpdates(); |
| 367 | virtual void SetIsMask(bool is_mask) {} |
ccameron@chromium.org | 4830141f | 2013-05-18 01:36:05 | [diff] [blame] | 368 | virtual void ReduceMemoryUsage() {} |
ccameron@chromium.org | 039fa8c | 2013-10-09 22:37:28 | [diff] [blame] | 369 | virtual void OnOutputSurfaceCreated() {} |
alokp@chromium.org | a6c1b23 | 2014-05-05 23:53:08 | [diff] [blame] | 370 | virtual bool IsSuitableForGpuRasterization() const; |
enne@chromium.org | cd57cc5a | 2012-10-12 22:43:41 | [diff] [blame] | 371 | |
chrishtr@gmail.com | 9f3be43 | 2013-12-03 03:53:22 | [diff] [blame] | 372 | virtual scoped_refptr<base::debug::ConvertableToTraceFormat> TakeDebugInfo(); |
qiankun.miao@intel.com | ae716ce | 2013-08-16 13:04:24 | [diff] [blame] | 373 | |
| 374 | void SetLayerClient(LayerClient* client) { client_ = client; } |
| 375 | |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 376 | virtual void PushPropertiesTo(LayerImpl* layer); |
| 377 | |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 378 | void CreateRenderSurface(); |
danakj@chromium.org | 50761e9 | 2013-03-29 20:51:28 | [diff] [blame] | 379 | void ClearRenderSurface(); |
vollick@chromium.org | 7644fa2 | 2014-04-28 12:20:33 | [diff] [blame] | 380 | void ClearRenderSurfaceLayerList(); |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 381 | |
danakj@chromium.org | ed511b8d | 2013-03-25 03:29:29 | [diff] [blame] | 382 | // The contents scale converts from logical, non-page-scaled pixels to target |
| 383 | // pixels. The contents scale is 1 for the root layer as it is already in |
| 384 | // physical pixels. By default contents scale is forced to be 1 except for |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 385 | // subclasses of ContentsScalingLayer. |
| 386 | float contents_scale_x() const { return draw_properties_.contents_scale_x; } |
| 387 | float contents_scale_y() const { return draw_properties_.contents_scale_y; } |
| 388 | gfx::Size content_bounds() const { return draw_properties_.content_bounds; } |
enne@chromium.org | cd57cc5a | 2012-10-12 22:43:41 | [diff] [blame] | 389 | |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 390 | virtual void CalculateContentsScale(float ideal_contents_scale, |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 391 | float* contents_scale_x, |
| 392 | float* contents_scale_y, |
| 393 | gfx::Size* content_bounds); |
danakj@chromium.org | 518ee58 | 2012-10-24 18:29:44 | [diff] [blame] | 394 | |
danakj@chromium.org | 3698e79 | 2013-08-24 00:21:16 | [diff] [blame] | 395 | LayerTreeHost* layer_tree_host() { return layer_tree_host_; } |
| 396 | const LayerTreeHost* layer_tree_host() const { return layer_tree_host_; } |
enne@chromium.org | cd57cc5a | 2012-10-12 22:43:41 | [diff] [blame] | 397 | |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 398 | // Set the priority of all desired textures in this layer. |
| 399 | virtual void SetTexturePriorities(const PriorityCalculator& priority_calc) {} |
enne@chromium.org | cd57cc5a | 2012-10-12 22:43:41 | [diff] [blame] | 400 | |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 401 | bool AddAnimation(scoped_ptr<Animation> animation); |
| 402 | void PauseAnimation(int animation_id, double time_offset); |
| 403 | void RemoveAnimation(int animation_id); |
enne@chromium.org | cd57cc5a | 2012-10-12 22:43:41 | [diff] [blame] | 404 | |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 405 | LayerAnimationController* layer_animation_controller() { |
| 406 | return layer_animation_controller_.get(); |
| 407 | } |
ajuma@chromium.org | 7f5605c | 2013-04-08 18:08:35 | [diff] [blame] | 408 | void SetLayerAnimationControllerForTest( |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 409 | scoped_refptr<LayerAnimationController> controller); |
enne@chromium.org | cd57cc5a | 2012-10-12 22:43:41 | [diff] [blame] | 410 | |
tfarina@chromium.org | 3cae03e | 2013-06-26 22:13:52 | [diff] [blame] | 411 | void set_layer_animation_delegate(AnimationDelegate* delegate) { |
ajuma@chromium.org | 7f5605c | 2013-04-08 18:08:35 | [diff] [blame] | 412 | layer_animation_controller_->set_layer_animation_delegate(delegate); |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 413 | } |
enne@chromium.org | cd57cc5a | 2012-10-12 22:43:41 | [diff] [blame] | 414 | |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 415 | bool HasActiveAnimation() const; |
enne@chromium.org | cd57cc5a | 2012-10-12 22:43:41 | [diff] [blame] | 416 | |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 417 | void AddLayerAnimationEventObserver( |
| 418 | LayerAnimationEventObserver* animation_observer); |
| 419 | void RemoveLayerAnimationEventObserver( |
| 420 | LayerAnimationEventObserver* animation_observer); |
enne@chromium.org | cd57cc5a | 2012-10-12 22:43:41 | [diff] [blame] | 421 | |
danakj@chromium.org | d5467eb | 2014-08-22 01:16:43 | [diff] [blame] | 422 | virtual SimpleEnclosedRegion VisibleContentOpaqueRegion() const; |
ajuma@chromium.org | e10cd02 | 2012-12-18 00:32:26 | [diff] [blame] | 423 | |
wjmaclean@chromium.org | 80413d7 | 2013-08-30 20:25:33 | [diff] [blame] | 424 | virtual ScrollbarLayerInterface* ToScrollbarLayer(); |
enne@chromium.org | cd57cc5a | 2012-10-12 22:43:41 | [diff] [blame] | 425 | |
danakj | 19f0c9e | 2014-10-11 03:24:42 | [diff] [blame] | 426 | gfx::Rect LayerRectToContentRect(const gfx::Rect& layer_rect) const; |
enne@chromium.org | cd57cc5a | 2012-10-12 22:43:41 | [diff] [blame] | 427 | |
alokp@chromium.org | f7837a9 | 2013-08-21 03:00:05 | [diff] [blame] | 428 | virtual skia::RefPtr<SkPicture> GetPicture() const; |
| 429 | |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 430 | // Constructs a LayerImpl of the correct runtime type for this Layer type. |
| 431 | virtual scoped_ptr<LayerImpl> CreateLayerImpl(LayerTreeImpl* tree_impl); |
whunt@chromium.org | aedf4e5 | 2013-01-09 23:24:44 | [diff] [blame] | 432 | |
enne@chromium.org | 4460464 | 2013-08-01 01:14:09 | [diff] [blame] | 433 | bool NeedsDisplayForTesting() const { return !update_rect_.IsEmpty(); } |
danakj | 19f0c9e | 2014-10-11 03:24:42 | [diff] [blame] | 434 | void ResetNeedsDisplayForTesting() { update_rect_ = gfx::Rect(); } |
egraether@chromium.org | 9d4f41f8 | 2013-03-28 01:34:23 | [diff] [blame] | 435 | |
egraether@chromium.org | d8411661 | 2013-03-29 05:32:49 | [diff] [blame] | 436 | RenderingStatsInstrumentation* rendering_stats_instrumentation() const; |
| 437 | |
reveman@chromium.org | 445881f | 2013-04-16 01:11:59 | [diff] [blame] | 438 | const PaintProperties& paint_properties() const { |
| 439 | return paint_properties_; |
| 440 | } |
| 441 | |
danakj@chromium.org | 35a99a1 | 2013-05-09 23:52:29 | [diff] [blame] | 442 | // The scale at which contents should be rastered, to match the scale at |
| 443 | // which they will drawn to the screen. This scale is a component of the |
| 444 | // contents scale but does not include page/device scale factors. |
| 445 | // TODO(danakj): This goes away when TiledLayer goes away. |
| 446 | void set_raster_scale(float scale) { raster_scale_ = scale; } |
| 447 | float raster_scale() const { return raster_scale_; } |
| 448 | bool raster_scale_is_unknown() const { return raster_scale_ == 0.f; } |
| 449 | |
hartmanng@chromium.org | 7924c185 | 2013-05-24 16:18:43 | [diff] [blame] | 450 | virtual bool SupportsLCDText() const; |
| 451 | |
ajuma@chromium.org | 7a5a932 | 2014-02-25 12:54:57 | [diff] [blame] | 452 | void SetNeedsPushProperties(); |
danakj@chromium.org | f4e25f9 | 2013-07-13 20:54:53 | [diff] [blame] | 453 | bool needs_push_properties() const { return needs_push_properties_; } |
| 454 | bool descendant_needs_push_properties() const { |
| 455 | return num_dependents_need_push_properties_ > 0; |
ajuma@chromium.org | 7a5a932 | 2014-02-25 12:54:57 | [diff] [blame] | 456 | } |
| 457 | void reset_needs_push_properties_for_testing() { |
| 458 | needs_push_properties_ = false; |
danakj@chromium.org | f4e25f9 | 2013-07-13 20:54:53 | [diff] [blame] | 459 | } |
| 460 | |
vmpstr@chromium.org | 666d7cf | 2013-10-12 01:30:29 | [diff] [blame] | 461 | virtual void RunMicroBenchmark(MicroBenchmark* benchmark); |
| 462 | |
thildebr@chromium.org | a9d4d4f | 2014-06-19 06:49:28 | [diff] [blame] | 463 | void Set3dSortingContextId(int id); |
| 464 | int sorting_context_id() const { return sorting_context_id_; } |
| 465 | |
vollick | 51ed1a2 | 2014-12-17 02:03:00 | [diff] [blame^] | 466 | void set_transform_tree_index(int index) { transform_tree_index_ = index; } |
| 467 | void set_clip_tree_index(int index) { clip_tree_index_ = index; } |
| 468 | int clip_tree_index() const { return clip_tree_index_; } |
| 469 | int transform_tree_index() const { return transform_tree_index_; } |
| 470 | |
| 471 | void set_offset_to_transform_parent(gfx::Vector2dF offset) { |
| 472 | offset_to_transform_parent_ = offset; |
| 473 | } |
| 474 | gfx::Vector2dF offset_to_transform_parent() const { |
| 475 | return offset_to_transform_parent_; |
| 476 | } |
| 477 | |
| 478 | // TODO(vollick): Once we transition to transform and clip trees, rename these |
| 479 | // functions and related values. The "from property trees" functions below |
| 480 | // use the transform and clip trees. Eventually, we will use these functions |
| 481 | // to compute the official values, but these functions are retained for |
| 482 | // testing purposes until we've migrated. |
| 483 | |
| 484 | const gfx::Rect& visible_rect_from_property_trees() const { |
| 485 | return visible_rect_from_property_trees_; |
| 486 | } |
| 487 | void set_visible_rect_from_property_trees(const gfx::Rect& rect) { |
| 488 | visible_rect_from_property_trees_ = rect; |
| 489 | } |
| 490 | |
| 491 | gfx::Transform screen_space_transform_from_property_trees( |
| 492 | const TransformTree& tree) const; |
| 493 | gfx::Transform draw_transform_from_property_trees( |
| 494 | const TransformTree& tree) const; |
| 495 | |
| 496 | // TODO(vollick): These values are temporary and will be removed as soon as |
| 497 | // render surface determinations are moved out of CDP. They only exist because |
| 498 | // certain logic depends on whether or not a layer would render to a separate |
| 499 | // surface, but CDP destroys surfaces and targets it doesn't need, so without |
| 500 | // this boolean, this is impossible to determine after the fact without |
| 501 | // wastefully recomputing it. This is public for the time being so that it can |
| 502 | // be accessed from CDP. |
| 503 | bool has_render_surface() const { |
| 504 | return has_render_surface_; |
| 505 | } |
| 506 | void SetHasRenderSurface(bool has_render_surface) { |
| 507 | has_render_surface_ = has_render_surface; |
| 508 | } |
| 509 | |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 510 | protected: |
| 511 | friend class LayerImpl; |
| 512 | friend class TreeSynchronizer; |
dcheng | 716bedf | 2014-10-21 09:51:08 | [diff] [blame] | 513 | ~Layer() override; |
danakj@chromium.org | 090e1a7 | 2013-01-29 07:07:45 | [diff] [blame] | 514 | |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 515 | Layer(); |
enne@chromium.org | cd57cc5a | 2012-10-12 22:43:41 | [diff] [blame] | 516 | |
enne@chromium.org | 3519b87 | 2013-07-30 07:17:50 | [diff] [blame] | 517 | // These SetNeeds functions are in order of severity of update: |
| 518 | // |
| 519 | // Called when this layer has been modified in some way, but isn't sure |
| 520 | // that it needs a commit yet. It needs CalcDrawProperties and UpdateLayers |
| 521 | // before it knows whether or not a commit is required. |
| 522 | void SetNeedsUpdate(); |
| 523 | // Called when a property has been modified in a way that the layer |
| 524 | // knows immediately that a commit is required. This implies SetNeedsUpdate |
| 525 | // as well as SetNeedsPushProperties to push that property. |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 526 | void SetNeedsCommit(); |
enne@chromium.org | 3519b87 | 2013-07-30 07:17:50 | [diff] [blame] | 527 | // Called when there's been a change in layer structure. Implies both |
| 528 | // SetNeedsUpdate and SetNeedsCommit, but not SetNeedsPushProperties. |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 529 | void SetNeedsFullTreeSync(); |
danakj@chromium.org | 74b43cc | 2013-08-30 06:29:27 | [diff] [blame] | 530 | |
| 531 | // Called when the next commit should wait until the pending tree is activated |
| 532 | // before finishing the commit and unblocking the main thread. Used to ensure |
| 533 | // unused resources on the impl thread are returned before commit completes. |
| 534 | void SetNextCommitWaitsForActivation(); |
danakj@chromium.org | 35a99a1 | 2013-05-09 23:52:29 | [diff] [blame] | 535 | |
awoloszyn@chromium.org | ad63b2f | 2014-08-11 17:39:54 | [diff] [blame] | 536 | // Will recalculate whether the layer draws content and set draws_content_ |
| 537 | // appropriately. |
| 538 | void UpdateDrawsContent(bool has_drawable_content); |
| 539 | virtual bool HasDrawableContent() const; |
| 540 | |
| 541 | // Called when the layer's number of drawable descendants changes. |
| 542 | void AddDrawableDescendants(int num); |
| 543 | |
danakj@chromium.org | f4e25f9 | 2013-07-13 20:54:53 | [diff] [blame] | 544 | void AddDependentNeedsPushProperties(); |
| 545 | void RemoveDependentNeedsPushProperties(); |
| 546 | bool parent_should_know_need_push_properties() const { |
| 547 | return needs_push_properties() || descendant_needs_push_properties(); |
| 548 | } |
danakj@chromium.org | b28272ee | 2013-08-29 23:05:13 | [diff] [blame] | 549 | |
danakj@chromium.org | 74b43cc | 2013-08-30 06:29:27 | [diff] [blame] | 550 | bool IsPropertyChangeAllowed() const; |
| 551 | |
danakj@chromium.org | 35a99a1 | 2013-05-09 23:52:29 | [diff] [blame] | 552 | void reset_raster_scale_to_unknown() { raster_scale_ = 0.f; } |
enne@chromium.org | cd57cc5a | 2012-10-12 22:43:41 | [diff] [blame] | 553 | |
danakj@chromium.org | f4e25f9 | 2013-07-13 20:54:53 | [diff] [blame] | 554 | // This flag is set when the layer needs to push properties to the impl |
| 555 | // side. |
| 556 | bool needs_push_properties_; |
| 557 | |
| 558 | // The number of direct children or dependent layers that need to be recursed |
| 559 | // to in order for them or a descendent of them to push properties to the impl |
| 560 | // side. |
| 561 | int num_dependents_need_push_properties_; |
| 562 | |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 563 | // Tracks whether this layer may have changed stacking order with its |
| 564 | // siblings. |
| 565 | bool stacking_order_changed_; |
enne@chromium.org | cd57cc5a | 2012-10-12 22:43:41 | [diff] [blame] | 566 | |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 567 | // The update rect is the region of the compositor resource that was |
| 568 | // actually updated by the compositor. For layers that may do updating |
| 569 | // outside the compositor's control (i.e. plugin layers), this information |
| 570 | // is not available and the update rect will remain empty. |
| 571 | // Note this rect is in layer space (not content space). |
danakj | 19f0c9e | 2014-10-11 03:24:42 | [diff] [blame] | 572 | gfx::Rect update_rect_; |
enne@chromium.org | cd57cc5a | 2012-10-12 22:43:41 | [diff] [blame] | 573 | |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 574 | scoped_refptr<Layer> mask_layer_; |
enne@chromium.org | cd57cc5a | 2012-10-12 22:43:41 | [diff] [blame] | 575 | |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 576 | int layer_id_; |
enne@chromium.org | cd57cc5a | 2012-10-12 22:43:41 | [diff] [blame] | 577 | |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 578 | // When true, the layer is about to perform an update. Any commit requests |
enne@chromium.org | 3519b87 | 2013-07-30 07:17:50 | [diff] [blame] | 579 | // will be handled implicitly after the update completes. |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 580 | bool ignore_set_needs_commit_; |
enne@chromium.org | cd57cc5a | 2012-10-12 22:43:41 | [diff] [blame] | 581 | |
thildebr@chromium.org | a9d4d4f | 2014-06-19 06:49:28 | [diff] [blame] | 582 | // Layers that share a sorting context id will be sorted together in 3d |
| 583 | // space. 0 is a special value that means this layer will not be sorted and |
| 584 | // will be drawn in paint order. |
| 585 | int sorting_context_id_; |
| 586 | |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 587 | private: |
| 588 | friend class base::RefCounted<Layer>; |
danakj@chromium.org | 29493a1 | 2012-12-20 01:42:42 | [diff] [blame] | 589 | |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 590 | void SetParent(Layer* layer); |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 591 | bool DescendantIsFixedToContainerLayer() const; |
enne@chromium.org | cd57cc5a | 2012-10-12 22:43:41 | [diff] [blame] | 592 | |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 593 | // Returns the index of the child or -1 if not found. |
| 594 | int IndexOfChild(const Layer* reference); |
enne@chromium.org | cd57cc5a | 2012-10-12 22:43:41 | [diff] [blame] | 595 | |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 596 | // This should only be called from RemoveFromParent(). |
| 597 | void RemoveChildOrDependent(Layer* child); |
enne@chromium.org | cd57cc5a | 2012-10-12 22:43:41 | [diff] [blame] | 598 | |
ajuma@chromium.org | b8384e2 | 2013-12-03 02:20:48 | [diff] [blame] | 599 | // LayerAnimationValueProvider implementation. |
dcheng | 716bedf | 2014-10-21 09:51:08 | [diff] [blame] | 600 | gfx::ScrollOffset ScrollOffsetForAnimation() const override; |
ajuma@chromium.org | b8384e2 | 2013-12-03 02:20:48 | [diff] [blame] | 601 | |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 602 | // LayerAnimationValueObserver implementation. |
dcheng | 716bedf | 2014-10-21 09:51:08 | [diff] [blame] | 603 | void OnFilterAnimated(const FilterOperations& filters) override; |
| 604 | void OnOpacityAnimated(float opacity) override; |
| 605 | void OnTransformAnimated(const gfx::Transform& transform) override; |
| 606 | void OnScrollOffsetAnimated(const gfx::ScrollOffset& scroll_offset) override; |
| 607 | void OnAnimationWaitingForDeletion() override; |
| 608 | bool IsActive() const override; |
enne@chromium.org | cd57cc5a | 2012-10-12 22:43:41 | [diff] [blame] | 609 | |
vollick | 66133e8 | 2014-09-13 20:36:44 | [diff] [blame] | 610 | // If this layer has a scroll parent, it removes |this| from its list of |
| 611 | // scroll children. |
| 612 | void RemoveFromScrollTree(); |
| 613 | |
| 614 | // If this layer has a clip parent, it removes |this| from its list of clip |
| 615 | // children. |
| 616 | void RemoveFromClipTree(); |
| 617 | |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 618 | LayerList children_; |
| 619 | Layer* parent_; |
vollick@chromium.org | de4afb5e | 2012-12-20 00:11:34 | [diff] [blame] | 620 | |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 621 | // Layer instances have a weak pointer to their LayerTreeHost. |
| 622 | // This pointer value is nil when a Layer is not in a tree and is |
| 623 | // updated via SetLayerTreeHost() if a layer moves between trees. |
| 624 | LayerTreeHost* layer_tree_host_; |
enne@chromium.org | cd57cc5a | 2012-10-12 22:43:41 | [diff] [blame] | 625 | |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 626 | scoped_refptr<LayerAnimationController> layer_animation_controller_; |
vollick@chromium.org | de4afb5e | 2012-12-20 00:11:34 | [diff] [blame] | 627 | |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 628 | // Layer properties. |
| 629 | gfx::Size bounds_; |
enne@chromium.org | cd57cc5a | 2012-10-12 22:43:41 | [diff] [blame] | 630 | |
miletus | f57925d | 2014-10-01 19:38:13 | [diff] [blame] | 631 | gfx::ScrollOffset scroll_offset_; |
wjmaclean@chromium.org | adeda57 | 2014-01-31 00:49:47 | [diff] [blame] | 632 | // This variable indicates which ancestor layer (if any) whose size, |
| 633 | // transformed relative to this layer, defines the maximum scroll offset for |
| 634 | // this layer. |
| 635 | int scroll_clip_layer_id_; |
awoloszyn@chromium.org | ad63b2f | 2014-08-11 17:39:54 | [diff] [blame] | 636 | int num_descendants_that_draw_content_; |
vollick | 51ed1a2 | 2014-12-17 02:03:00 | [diff] [blame^] | 637 | int transform_tree_index_; |
| 638 | int opacity_tree_index_; |
| 639 | int clip_tree_index_; |
| 640 | gfx::Vector2dF offset_to_transform_parent_; |
vivek.vg@samsung.com | c55f3fc | 2013-12-10 05:48:48 | [diff] [blame] | 641 | bool should_scroll_on_main_thread_ : 1; |
| 642 | bool have_wheel_event_handlers_ : 1; |
skyostil@chromium.org | f998c53 | 2014-03-31 20:02:51 | [diff] [blame] | 643 | bool have_scroll_event_handlers_ : 1; |
vivek.vg@samsung.com | c55f3fc | 2013-12-10 05:48:48 | [diff] [blame] | 644 | bool user_scrollable_horizontal_ : 1; |
| 645 | bool user_scrollable_vertical_ : 1; |
| 646 | bool is_root_for_isolated_group_ : 1; |
| 647 | bool is_container_for_fixed_position_layers_ : 1; |
| 648 | bool is_drawable_ : 1; |
awoloszyn@chromium.org | ad63b2f | 2014-08-11 17:39:54 | [diff] [blame] | 649 | bool draws_content_ : 1; |
vivek.vg@samsung.com | c55f3fc | 2013-12-10 05:48:48 | [diff] [blame] | 650 | bool hide_layer_and_subtree_ : 1; |
| 651 | bool masks_to_bounds_ : 1; |
| 652 | bool contents_opaque_ : 1; |
| 653 | bool double_sided_ : 1; |
vollick@chromium.org | 56fffdd | 2014-02-11 19:50:57 | [diff] [blame] | 654 | bool should_flatten_transform_ : 1; |
vivek.vg@samsung.com | c55f3fc | 2013-12-10 05:48:48 | [diff] [blame] | 655 | bool use_parent_backface_visibility_ : 1; |
| 656 | bool draw_checkerboard_for_missing_tiles_ : 1; |
| 657 | bool force_render_surface_ : 1; |
avallee@chromium.org | 08bdf1b | 2014-04-16 23:23:29 | [diff] [blame] | 658 | bool transform_is_invertible_ : 1; |
vollick | 51ed1a2 | 2014-12-17 02:03:00 | [diff] [blame^] | 659 | bool has_render_surface_ : 1; |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 660 | Region non_fast_scrollable_region_; |
| 661 | Region touch_event_handler_region_; |
| 662 | gfx::PointF position_; |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 663 | SkColor background_color_; |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 664 | float opacity_; |
rosca@adobe.com | 7bbeaf4e | 2013-11-26 10:27:22 | [diff] [blame] | 665 | SkXfermode::Mode blend_mode_; |
ajuma@chromium.org | ae6b1a7 | 2013-06-25 18:49:29 | [diff] [blame] | 666 | FilterOperations filters_; |
| 667 | FilterOperations background_filters_; |
trchen@chromium.org | fe956c9c4 | 2013-04-09 04:26:33 | [diff] [blame] | 668 | LayerPositionConstraint position_constraint_; |
vollick@chromium.org | 0e98cdd | 2013-08-23 00:44:30 | [diff] [blame] | 669 | Layer* scroll_parent_; |
danakj | 6496cba | 2014-10-16 01:31:08 | [diff] [blame] | 670 | scoped_ptr<std::set<Layer*>> scroll_children_; |
vollick@chromium.org | 0e98cdd | 2013-08-23 00:44:30 | [diff] [blame] | 671 | |
| 672 | Layer* clip_parent_; |
danakj | 6496cba | 2014-10-16 01:31:08 | [diff] [blame] | 673 | scoped_ptr<std::set<Layer*>> clip_children_; |
enne@chromium.org | cd57cc5a | 2012-10-12 22:43:41 | [diff] [blame] | 674 | |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 675 | gfx::Transform transform_; |
chrishtr@chromium.org | a256641 | 2014-06-05 03:14:20 | [diff] [blame] | 676 | gfx::Point3F transform_origin_; |
enne@chromium.org | cd57cc5a | 2012-10-12 22:43:41 | [diff] [blame] | 677 | |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 678 | // Replica layer used for reflections. |
| 679 | scoped_refptr<Layer> replica_layer_; |
enne@chromium.org | cd57cc5a | 2012-10-12 22:43:41 | [diff] [blame] | 680 | |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 681 | // Transient properties. |
| 682 | float raster_scale_; |
danakj@chromium.org | 44e9a2f | 2013-04-26 13:13:21 | [diff] [blame] | 683 | |
qiankun.miao@intel.com | ae716ce | 2013-08-16 13:04:24 | [diff] [blame] | 684 | LayerClient* client_; |
| 685 | |
danakj@chromium.org | 0e5f714 | 2013-05-24 06:45:36 | [diff] [blame] | 686 | ScopedPtrVector<CopyOutputRequest> copy_requests_; |
danakj@chromium.org | 18a7019 | 2013-04-26 16:18:25 | [diff] [blame] | 687 | |
tfarina@chromium.org | 28096ed | 2013-07-01 07:38:58 | [diff] [blame] | 688 | base::Closure did_scroll_callback_; |
enne@chromium.org | cd57cc5a | 2012-10-12 22:43:41 | [diff] [blame] | 689 | |
vollick@chromium.org | 44d8e84c | 2013-10-19 19:13:22 | [diff] [blame] | 690 | DrawProperties<Layer> draw_properties_; |
shawnsingh@google.com | d76806f8 | 2012-12-05 21:41:50 | [diff] [blame] | 691 | |
reveman@chromium.org | 445881f | 2013-04-16 01:11:59 | [diff] [blame] | 692 | PaintProperties paint_properties_; |
| 693 | |
vollick | 51ed1a2 | 2014-12-17 02:03:00 | [diff] [blame^] | 694 | gfx::Rect visible_rect_from_property_trees_; |
danakj@chromium.org | 7aba666 | 2013-03-12 10:17:34 | [diff] [blame] | 695 | DISALLOW_COPY_AND_ASSIGN(Layer); |
enne@chromium.org | cd57cc5a | 2012-10-12 22:43:41 | [diff] [blame] | 696 | }; |
enne@chromium.org | cd57cc5a | 2012-10-12 22:43:41 | [diff] [blame] | 697 | |
tfarina@chromium.org | ddf9df8 | 2012-10-16 06:52:46 | [diff] [blame] | 698 | } // namespace cc |
| 699 | |
jamesr@chromium.org | cc3cfaa | 2013-03-18 09:05:52 | [diff] [blame] | 700 | #endif // CC_LAYERS_LAYER_H_ |