OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "cc/trees/draw_property_utils.h" | 5 #include "cc/trees/draw_property_utils.h" |
6 | 6 |
7 #include <stddef.h> | 7 #include <stddef.h> |
8 | 8 |
9 #include <vector> | 9 #include <vector> |
10 | 10 |
11 #include "cc/base/math_util.h" | 11 #include "cc/base/math_util.h" |
12 #include "cc/layers/draw_properties.h" | 12 #include "cc/layers/draw_properties.h" |
13 #include "cc/layers/layer.h" | 13 #include "cc/layers/layer.h" |
14 #include "cc/layers/layer_impl.h" | 14 #include "cc/layers/layer_impl.h" |
| 15 #include "cc/trees/clip_node.h" |
| 16 #include "cc/trees/effect_node.h" |
15 #include "cc/trees/layer_tree_host.h" | 17 #include "cc/trees/layer_tree_host.h" |
16 #include "cc/trees/layer_tree_impl.h" | 18 #include "cc/trees/layer_tree_impl.h" |
17 #include "cc/trees/property_tree.h" | 19 #include "cc/trees/property_tree.h" |
18 #include "cc/trees/property_tree_builder.h" | 20 #include "cc/trees/property_tree_builder.h" |
| 21 #include "cc/trees/transform_node.h" |
19 #include "ui/gfx/geometry/rect_conversions.h" | 22 #include "ui/gfx/geometry/rect_conversions.h" |
20 | 23 |
21 namespace cc { | 24 namespace cc { |
22 | 25 |
23 namespace draw_property_utils { | 26 namespace draw_property_utils { |
24 | 27 |
25 namespace { | 28 namespace { |
26 | 29 |
27 static bool IsRootLayer(const Layer* layer) { | 30 static bool IsRootLayer(const Layer* layer) { |
28 return !layer->parent(); | 31 return !layer->parent(); |
(...skipping 10 matching lines...) Expand all Loading... |
39 if (layer->has_render_surface()) | 42 if (layer->has_render_surface()) |
40 return; | 43 return; |
41 | 44 |
42 DCHECK(layer->filters().IsEmpty()) << "layer: " << layer->id(); | 45 DCHECK(layer->filters().IsEmpty()) << "layer: " << layer->id(); |
43 DCHECK(!IsRootLayer(layer)) << "layer: " << layer->id(); | 46 DCHECK(!IsRootLayer(layer)) << "layer: " << layer->id(); |
44 EffectNode* effect_node = | 47 EffectNode* effect_node = |
45 layer->layer_tree_impl()->property_trees()->effect_tree.Node( | 48 layer->layer_tree_impl()->property_trees()->effect_tree.Node( |
46 layer->effect_tree_index()); | 49 layer->effect_tree_index()); |
47 if (effect_node->owner_id != layer->id()) | 50 if (effect_node->owner_id != layer->id()) |
48 return; | 51 return; |
49 DCHECK_EQ(effect_node->data.mask_layer_id, -1) << "layer: " << layer->id(); | 52 DCHECK_EQ(effect_node->mask_layer_id, -1) << "layer: " << layer->id(); |
50 DCHECK_EQ(effect_node->data.replica_layer_id, -1) << "layer: " << layer->id(); | 53 DCHECK_EQ(effect_node->replica_layer_id, -1) << "layer: " << layer->id(); |
51 DCHECK(effect_node->data.background_filters.IsEmpty()); | 54 DCHECK(effect_node->background_filters.IsEmpty()); |
52 } | 55 } |
53 | 56 |
54 #endif | 57 #endif |
55 | 58 |
56 static void AddSublayerScaleToTransform(const int effect_node_id, | 59 static void AddSublayerScaleToTransform(const int effect_node_id, |
57 const EffectTree& effect_tree, | 60 const EffectTree& effect_tree, |
58 gfx::Transform* transform) { | 61 gfx::Transform* transform) { |
59 const EffectNode* effect_node = effect_tree.Node(effect_node_id); | 62 const EffectNode* effect_node = effect_tree.Node(effect_node_id); |
60 const EffectNode* target_effect_node = | 63 const EffectNode* target_effect_node = |
61 effect_node->data.has_render_surface | 64 effect_node->has_render_surface |
62 ? effect_node | 65 ? effect_node |
63 : effect_tree.Node(effect_node->data.target_id); | 66 : effect_tree.Node(effect_node->target_id); |
64 transform->matrix().postScale(target_effect_node->data.sublayer_scale.x(), | 67 transform->matrix().postScale(target_effect_node->sublayer_scale.x(), |
65 target_effect_node->data.sublayer_scale.y(), | 68 target_effect_node->sublayer_scale.y(), 1.f); |
66 1.f); | |
67 } | 69 } |
68 | 70 |
69 #if DCHECK_IS_ON() | 71 #if DCHECK_IS_ON() |
70 void VerifySublayerScalesMatch(const int effect_node_id, | 72 void VerifySublayerScalesMatch(const int effect_node_id, |
71 const int target_transform_id, | 73 const int target_transform_id, |
72 const EffectTree& effect_tree, | 74 const EffectTree& effect_tree, |
73 const TransformTree& transform_tree) { | 75 const TransformTree& transform_tree) { |
74 const TransformNode* target_transform_node = | 76 const TransformNode* target_transform_node = |
75 transform_tree.Node(target_transform_id); | 77 transform_tree.Node(target_transform_id); |
76 const EffectNode* effect_node = effect_tree.Node(effect_node_id); | 78 const EffectNode* effect_node = effect_tree.Node(effect_node_id); |
77 const EffectNode* target_effect_node = | 79 const EffectNode* target_effect_node = |
78 effect_node->data.has_render_surface | 80 effect_node->has_render_surface |
79 ? effect_node | 81 ? effect_node |
80 : effect_tree.Node(effect_node->data.target_id); | 82 : effect_tree.Node(effect_node->target_id); |
81 DCHECK(target_transform_node->data.sublayer_scale == | 83 DCHECK(target_transform_node->sublayer_scale == |
82 target_effect_node->data.sublayer_scale) | 84 target_effect_node->sublayer_scale) |
83 << " sublayer scale from transform tree: " | 85 << " sublayer scale from transform tree: " |
84 << target_transform_node->data.sublayer_scale.ToString() | 86 << target_transform_node->sublayer_scale.ToString() |
85 << " sublayer scale from effect tree: " | 87 << " sublayer scale from effect tree: " |
86 << target_effect_node->data.sublayer_scale.ToString(); | 88 << target_effect_node->sublayer_scale.ToString(); |
87 } | 89 } |
88 #endif | 90 #endif |
89 | 91 |
90 template <typename LayerType> | 92 template <typename LayerType> |
91 bool ComputeClipRectInTargetSpace(const LayerType* layer, | 93 bool ComputeClipRectInTargetSpace(const LayerType* layer, |
92 const ClipNode* clip_node, | 94 const ClipNode* clip_node, |
93 const TransformTree& transform_tree, | 95 const TransformTree& transform_tree, |
94 const EffectTree& effect_tree, | 96 const EffectTree& effect_tree, |
95 int target_node_id, | 97 int target_node_id, |
96 gfx::RectF* clip_rect_in_target_space) { | 98 gfx::RectF* clip_rect_in_target_space) { |
97 DCHECK(layer->clip_tree_index() == clip_node->id); | 99 DCHECK(layer->clip_tree_index() == clip_node->id); |
98 DCHECK(clip_node->data.target_id != target_node_id); | 100 DCHECK(clip_node->target_id != target_node_id); |
99 | 101 |
100 gfx::Transform clip_to_target; | 102 gfx::Transform clip_to_target; |
101 if (clip_node->data.target_id > target_node_id) { | 103 if (clip_node->target_id > target_node_id) { |
102 // In this case, layer has a scroll parent. We need to keep the scale | 104 // In this case, layer has a scroll parent. We need to keep the scale |
103 // at the layer's target but remove the scale at the scroll parent's | 105 // at the layer's target but remove the scale at the scroll parent's |
104 // target. | 106 // target. |
105 if (transform_tree.ComputeTransform(clip_node->data.target_id, | 107 if (transform_tree.ComputeTransform(clip_node->target_id, target_node_id, |
106 target_node_id, &clip_to_target)) { | 108 &clip_to_target)) { |
107 // We don't have to apply sublayer scale when target is root. | 109 // We don't have to apply sublayer scale when target is root. |
108 if (target_node_id != 0) { | 110 if (target_node_id != 0) { |
109 AddSublayerScaleToTransform(layer->effect_tree_index(), effect_tree, | 111 AddSublayerScaleToTransform(layer->effect_tree_index(), effect_tree, |
110 &clip_to_target); | 112 &clip_to_target); |
111 #if DCHECK_IS_ON() | 113 #if DCHECK_IS_ON() |
112 VerifySublayerScalesMatch(layer->effect_tree_index(), target_node_id, | 114 VerifySublayerScalesMatch(layer->effect_tree_index(), target_node_id, |
113 effect_tree, transform_tree); | 115 effect_tree, transform_tree); |
114 #endif | 116 #endif |
115 } | 117 } |
116 | 118 |
117 const TransformNode* source_node = | 119 const TransformNode* source_node = |
118 transform_tree.Node(clip_node->data.target_id); | 120 transform_tree.Node(clip_node->target_id); |
119 if (source_node->data.sublayer_scale.x() != 0.f && | 121 if (source_node->sublayer_scale.x() != 0.f && |
120 source_node->data.sublayer_scale.y() != 0.f) | 122 source_node->sublayer_scale.y() != 0.f) |
121 clip_to_target.Scale(1.0f / source_node->data.sublayer_scale.x(), | 123 clip_to_target.Scale(1.0f / source_node->sublayer_scale.x(), |
122 1.0f / source_node->data.sublayer_scale.y()); | 124 1.0f / source_node->sublayer_scale.y()); |
123 *clip_rect_in_target_space = MathUtil::MapClippedRect( | 125 *clip_rect_in_target_space = MathUtil::MapClippedRect( |
124 clip_to_target, clip_node->data.clip_in_target_space); | 126 clip_to_target, clip_node->clip_in_target_space); |
125 } else { | 127 } else { |
126 return false; | 128 return false; |
127 } | 129 } |
128 } else { | 130 } else { |
129 if (transform_tree.ComputeTransform(clip_node->data.target_id, | 131 if (transform_tree.ComputeTransform(clip_node->target_id, target_node_id, |
130 target_node_id, &clip_to_target)) { | 132 &clip_to_target)) { |
131 *clip_rect_in_target_space = MathUtil::ProjectClippedRect( | 133 *clip_rect_in_target_space = MathUtil::ProjectClippedRect( |
132 clip_to_target, clip_node->data.clip_in_target_space); | 134 clip_to_target, clip_node->clip_in_target_space); |
133 } else { | 135 } else { |
134 return false; | 136 return false; |
135 } | 137 } |
136 } | 138 } |
137 return true; | 139 return true; |
138 } | 140 } |
139 | 141 |
140 struct ConditionalClip { | 142 struct ConditionalClip { |
141 bool is_clipped; | 143 bool is_clipped; |
142 gfx::RectF clip_rect; | 144 gfx::RectF clip_rect; |
(...skipping 33 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
176 return ConditionalClip{true, // is_clipped. | 178 return ConditionalClip{true, // is_clipped. |
177 MathUtil::MapClippedRect(current_to_target, rect)}; | 179 MathUtil::MapClippedRect(current_to_target, rect)}; |
178 | 180 |
179 return ConditionalClip{true, // is_clipped. | 181 return ConditionalClip{true, // is_clipped. |
180 MathUtil::ProjectClippedRect(current_to_target, rect)}; | 182 MathUtil::ProjectClippedRect(current_to_target, rect)}; |
181 } | 183 } |
182 | 184 |
183 static ConditionalClip ComputeCurrentClip(const ClipNode* clip_node, | 185 static ConditionalClip ComputeCurrentClip(const ClipNode* clip_node, |
184 const TransformTree& transform_tree, | 186 const TransformTree& transform_tree, |
185 int target_transform_id) { | 187 int target_transform_id) { |
186 if (clip_node->data.transform_id != target_transform_id) | 188 if (clip_node->transform_id != target_transform_id) |
187 return ComputeLocalRectInTargetSpace(clip_node->data.clip, transform_tree, | 189 return ComputeLocalRectInTargetSpace(clip_node->clip, transform_tree, |
188 clip_node->data.transform_id, | 190 clip_node->transform_id, |
189 target_transform_id); | 191 target_transform_id); |
190 | 192 |
191 gfx::RectF current_clip = clip_node->data.clip; | 193 gfx::RectF current_clip = clip_node->clip; |
192 gfx::Vector2dF sublayer_scale = | 194 gfx::Vector2dF sublayer_scale = |
193 transform_tree.Node(target_transform_id)->data.sublayer_scale; | 195 transform_tree.Node(target_transform_id)->sublayer_scale; |
194 if (sublayer_scale.x() > 0 && sublayer_scale.y() > 0) | 196 if (sublayer_scale.x() > 0 && sublayer_scale.y() > 0) |
195 current_clip.Scale(sublayer_scale.x(), sublayer_scale.y()); | 197 current_clip.Scale(sublayer_scale.x(), sublayer_scale.y()); |
196 return ConditionalClip{true /* is_clipped */, current_clip}; | 198 return ConditionalClip{true /* is_clipped */, current_clip}; |
197 } | 199 } |
198 | 200 |
199 static ConditionalClip ComputeAccumulatedClip( | 201 static ConditionalClip ComputeAccumulatedClip( |
200 const ClipTree& clip_tree, | 202 const ClipTree& clip_tree, |
201 int local_clip_id, | 203 int local_clip_id, |
202 const EffectTree& effect_tree, | 204 const EffectTree& effect_tree, |
203 int target_id, | 205 int target_id, |
204 const TransformTree& transform_tree) { | 206 const TransformTree& transform_tree) { |
205 const ClipNode* clip_node = clip_tree.Node(local_clip_id); | 207 const ClipNode* clip_node = clip_tree.Node(local_clip_id); |
206 const EffectNode* target_node = effect_tree.Node(target_id); | 208 const EffectNode* target_node = effect_tree.Node(target_id); |
207 int target_transform_id = target_node->data.transform_id; | 209 int target_transform_id = target_node->transform_id; |
208 bool is_clipped = false; | 210 bool is_clipped = false; |
209 | 211 |
210 // Collect all the clips that need to be accumulated. | 212 // Collect all the clips that need to be accumulated. |
211 std::stack<const ClipNode*> parent_chain; | 213 std::stack<const ClipNode*> parent_chain; |
212 | 214 |
213 // If target is not direct ancestor of clip, this will find least common | 215 // If target is not direct ancestor of clip, this will find least common |
214 // ancestor between the target and the clip. | 216 // ancestor between the target and the clip. |
215 while (target_node->id >= 0 && clip_node->id >= 0) { | 217 while (target_node->id >= 0 && clip_node->id >= 0) { |
216 while (target_node->data.clip_id > clip_node->id || | 218 while (target_node->clip_id > clip_node->id || |
217 target_node->data.has_unclipped_descendants) { | 219 target_node->has_unclipped_descendants) { |
218 target_node = effect_tree.Node(target_node->data.target_id); | 220 target_node = effect_tree.Node(target_node->target_id); |
219 } | 221 } |
220 if (target_node->data.clip_id == clip_node->id) | 222 if (target_node->clip_id == clip_node->id) |
221 break; | 223 break; |
222 while (target_node->data.clip_id < clip_node->id) { | 224 while (target_node->clip_id < clip_node->id) { |
223 parent_chain.push(clip_node); | 225 parent_chain.push(clip_node); |
224 clip_node = clip_tree.parent(clip_node); | 226 clip_node = clip_tree.parent(clip_node); |
225 } | 227 } |
226 if (target_node->data.clip_id == clip_node->id) { | 228 if (target_node->clip_id == clip_node->id) { |
227 // Target is responsible for applying this clip_node (id equals to | 229 // Target is responsible for applying this clip_node (id equals to |
228 // target_node's clip id), no need to accumulate this as part of clip | 230 // target_node's clip id), no need to accumulate this as part of clip |
229 // rect. | 231 // rect. |
230 clip_node = parent_chain.top(); | 232 clip_node = parent_chain.top(); |
231 parent_chain.pop(); | 233 parent_chain.pop(); |
232 break; | 234 break; |
233 } | 235 } |
234 } | 236 } |
235 | 237 |
236 // TODO(weiliangc): If we don't create clip for render surface, we don't need | 238 // TODO(weiliangc): If we don't create clip for render surface, we don't need |
237 // to check applies_local_clip. | 239 // to check applies_local_clip. |
238 while (!clip_node->data.applies_local_clip && parent_chain.size() > 0) { | 240 while (!clip_node->applies_local_clip && parent_chain.size() > 0) { |
239 clip_node = parent_chain.top(); | 241 clip_node = parent_chain.top(); |
240 parent_chain.pop(); | 242 parent_chain.pop(); |
241 } | 243 } |
242 | 244 |
243 if (!clip_node->data.applies_local_clip) | 245 if (!clip_node->applies_local_clip) |
244 // No clip node applying clip in between. | 246 // No clip node applying clip in between. |
245 return ConditionalClip{false, gfx::RectF()}; | 247 return ConditionalClip{false, gfx::RectF()}; |
246 | 248 |
247 ConditionalClip current_clip = | 249 ConditionalClip current_clip = |
248 ComputeCurrentClip(clip_node, transform_tree, target_transform_id); | 250 ComputeCurrentClip(clip_node, transform_tree, target_transform_id); |
249 is_clipped = current_clip.is_clipped; | 251 is_clipped = current_clip.is_clipped; |
250 gfx::RectF accumulated_clip = current_clip.clip_rect; | 252 gfx::RectF accumulated_clip = current_clip.clip_rect; |
251 | 253 |
252 while (parent_chain.size() > 0) { | 254 while (parent_chain.size() > 0) { |
253 clip_node = parent_chain.top(); | 255 clip_node = parent_chain.top(); |
254 parent_chain.pop(); | 256 parent_chain.pop(); |
255 if (!clip_node->data.applies_local_clip) { | 257 if (!clip_node->applies_local_clip) { |
256 continue; | 258 continue; |
257 } | 259 } |
258 ConditionalClip current_clip = | 260 ConditionalClip current_clip = |
259 ComputeCurrentClip(clip_node, transform_tree, target_transform_id); | 261 ComputeCurrentClip(clip_node, transform_tree, target_transform_id); |
260 | 262 |
261 // If transform is not invertible, no clip will be applied. | 263 // If transform is not invertible, no clip will be applied. |
262 if (!current_clip.is_clipped) | 264 if (!current_clip.is_clipped) |
263 return ConditionalClip{false, gfx::RectF()}; | 265 return ConditionalClip{false, gfx::RectF()}; |
264 | 266 |
265 is_clipped = true; | 267 is_clipped = true; |
266 accumulated_clip = | 268 accumulated_clip = |
267 gfx::IntersectRects(accumulated_clip, current_clip.clip_rect); | 269 gfx::IntersectRects(accumulated_clip, current_clip.clip_rect); |
268 } | 270 } |
269 | 271 |
270 return ConditionalClip{ | 272 return ConditionalClip{ |
271 is_clipped, accumulated_clip.IsEmpty() ? gfx::RectF() : accumulated_clip}; | 273 is_clipped, accumulated_clip.IsEmpty() ? gfx::RectF() : accumulated_clip}; |
272 } | 274 } |
273 | 275 |
274 template <typename LayerType> | 276 template <typename LayerType> |
275 void CalculateClipRects( | 277 void CalculateClipRects( |
276 const typename LayerType::LayerListType& visible_layer_list, | 278 const typename LayerType::LayerListType& visible_layer_list, |
277 const ClipTree& clip_tree, | 279 const ClipTree& clip_tree, |
278 const TransformTree& transform_tree, | 280 const TransformTree& transform_tree, |
279 const EffectTree& effect_tree, | 281 const EffectTree& effect_tree, |
280 bool non_root_surfaces_enabled) { | 282 bool non_root_surfaces_enabled) { |
281 for (auto& layer : visible_layer_list) { | 283 for (auto& layer : visible_layer_list) { |
282 const ClipNode* clip_node = clip_tree.Node(layer->clip_tree_index()); | 284 const ClipNode* clip_node = clip_tree.Node(layer->clip_tree_index()); |
283 if (!non_root_surfaces_enabled) { | 285 if (!non_root_surfaces_enabled) { |
284 layer->set_clip_rect( | 286 layer->set_clip_rect( |
285 gfx::ToEnclosingRect(clip_node->data.clip_in_target_space)); | 287 gfx::ToEnclosingRect(clip_node->clip_in_target_space)); |
286 continue; | 288 continue; |
287 } | 289 } |
288 | 290 |
289 // When both the layer and the target are unclipped, the entire layer | 291 // When both the layer and the target are unclipped, the entire layer |
290 // content rect is visible. | 292 // content rect is visible. |
291 const bool fully_visible = !clip_node->data.layers_are_clipped && | 293 const bool fully_visible = |
292 !clip_node->data.target_is_clipped; | 294 !clip_node->layers_are_clipped && !clip_node->target_is_clipped; |
293 | 295 |
294 if (!fully_visible) { | 296 if (!fully_visible) { |
295 const TransformNode* transform_node = | 297 const TransformNode* transform_node = |
296 transform_tree.Node(layer->transform_tree_index()); | 298 transform_tree.Node(layer->transform_tree_index()); |
297 int target_node_id = transform_tree.ContentTargetId(transform_node->id); | 299 int target_node_id = transform_tree.ContentTargetId(transform_node->id); |
298 | 300 |
299 // The clip node stores clip rect in its target space. | 301 // The clip node stores clip rect in its target space. |
300 gfx::RectF clip_rect_in_target_space = | 302 gfx::RectF clip_rect_in_target_space = clip_node->clip_in_target_space; |
301 clip_node->data.clip_in_target_space; | |
302 | 303 |
303 // If required, this clip rect should be mapped to the current layer's | 304 // If required, this clip rect should be mapped to the current layer's |
304 // target space. | 305 // target space. |
305 if (clip_node->data.target_id != target_node_id) { | 306 if (clip_node->target_id != target_node_id) { |
306 // In this case, layer has a clip parent or scroll parent (or shares the | 307 // In this case, layer has a clip parent or scroll parent (or shares the |
307 // target with an ancestor layer that has clip parent) and the clip | 308 // target with an ancestor layer that has clip parent) and the clip |
308 // parent's target is different from the layer's target. As the layer's | 309 // parent's target is different from the layer's target. As the layer's |
309 // target has unclippped descendants, it is unclippped. | 310 // target has unclippped descendants, it is unclippped. |
310 if (!clip_node->data.layers_are_clipped) | 311 if (!clip_node->layers_are_clipped) |
311 continue; | 312 continue; |
312 | 313 |
313 // Compute the clip rect in target space and store it. | 314 // Compute the clip rect in target space and store it. |
314 if (!ComputeClipRectInTargetSpace(layer, clip_node, transform_tree, | 315 if (!ComputeClipRectInTargetSpace(layer, clip_node, transform_tree, |
315 effect_tree, target_node_id, | 316 effect_tree, target_node_id, |
316 &clip_rect_in_target_space)) | 317 &clip_rect_in_target_space)) |
317 continue; | 318 continue; |
318 } | 319 } |
319 | 320 |
320 if (!clip_rect_in_target_space.IsEmpty()) { | 321 if (!clip_rect_in_target_space.IsEmpty()) { |
(...skipping 17 matching lines...) Expand all Loading... |
338 } | 339 } |
339 | 340 |
340 bool GetLayerClipRect(const LayerImpl* layer, | 341 bool GetLayerClipRect(const LayerImpl* layer, |
341 const ClipNode* clip_node, | 342 const ClipNode* clip_node, |
342 const TransformTree& transform_tree, | 343 const TransformTree& transform_tree, |
343 const EffectTree& effect_tree, | 344 const EffectTree& effect_tree, |
344 int target_node_id, | 345 int target_node_id, |
345 gfx::RectF* clip_rect_in_target_space) { | 346 gfx::RectF* clip_rect_in_target_space) { |
346 // This is equivalent of calling ComputeClipRectInTargetSpace. | 347 // This is equivalent of calling ComputeClipRectInTargetSpace. |
347 *clip_rect_in_target_space = gfx::RectF(layer->clip_rect()); | 348 *clip_rect_in_target_space = gfx::RectF(layer->clip_rect()); |
348 return transform_tree.Node(target_node_id)->data.ancestors_are_invertible; | 349 return transform_tree.Node(target_node_id)->ancestors_are_invertible; |
349 } | 350 } |
350 | 351 |
351 template <typename LayerType> | 352 template <typename LayerType> |
352 void CalculateVisibleRects( | 353 void CalculateVisibleRects( |
353 const typename LayerType::LayerListType& visible_layer_list, | 354 const typename LayerType::LayerListType& visible_layer_list, |
354 const ClipTree& clip_tree, | 355 const ClipTree& clip_tree, |
355 const TransformTree& transform_tree, | 356 const TransformTree& transform_tree, |
356 const EffectTree& effect_tree, | 357 const EffectTree& effect_tree, |
357 bool non_root_surfaces_enabled) { | 358 bool non_root_surfaces_enabled) { |
358 for (auto& layer : visible_layer_list) { | 359 for (auto& layer : visible_layer_list) { |
(...skipping 11 matching lines...) Expand all Loading... |
370 continue; | 371 continue; |
371 } | 372 } |
372 | 373 |
373 gfx::RectF accumulated_clip_in_copy_request_space = | 374 gfx::RectF accumulated_clip_in_copy_request_space = |
374 accumulated_clip_rect.clip_rect; | 375 accumulated_clip_rect.clip_rect; |
375 | 376 |
376 const EffectNode* copy_request_effect_node = | 377 const EffectNode* copy_request_effect_node = |
377 effect_tree.Node(effect_ancestor_with_copy_request); | 378 effect_tree.Node(effect_ancestor_with_copy_request); |
378 ConditionalClip clip_in_layer_space = ComputeTargetRectInLocalSpace( | 379 ConditionalClip clip_in_layer_space = ComputeTargetRectInLocalSpace( |
379 accumulated_clip_in_copy_request_space, transform_tree, | 380 accumulated_clip_in_copy_request_space, transform_tree, |
380 copy_request_effect_node->data.transform_id, | 381 copy_request_effect_node->transform_id, |
381 layer->transform_tree_index()); | 382 layer->transform_tree_index()); |
382 | 383 |
383 if (clip_in_layer_space.is_clipped) { | 384 if (clip_in_layer_space.is_clipped) { |
384 gfx::RectF clip_rect = clip_in_layer_space.clip_rect; | 385 gfx::RectF clip_rect = clip_in_layer_space.clip_rect; |
385 clip_rect.Offset(-layer->offset_to_transform_parent()); | 386 clip_rect.Offset(-layer->offset_to_transform_parent()); |
386 gfx::Rect visible_rect = gfx::ToEnclosingRect(clip_rect); | 387 gfx::Rect visible_rect = gfx::ToEnclosingRect(clip_rect); |
387 visible_rect.Intersect(gfx::Rect(layer_bounds)); | 388 visible_rect.Intersect(gfx::Rect(layer_bounds)); |
388 layer->set_visible_layer_rect(visible_rect); | 389 layer->set_visible_layer_rect(visible_rect); |
389 } else { | 390 } else { |
390 layer->set_visible_layer_rect(gfx::Rect(layer_bounds)); | 391 layer->set_visible_layer_rect(gfx::Rect(layer_bounds)); |
391 } | 392 } |
392 continue; | 393 continue; |
393 } | 394 } |
394 | 395 |
395 const ClipNode* clip_node = clip_tree.Node(layer->clip_tree_index()); | 396 const ClipNode* clip_node = clip_tree.Node(layer->clip_tree_index()); |
396 const TransformNode* transform_node = | 397 const TransformNode* transform_node = |
397 transform_tree.Node(layer->transform_tree_index()); | 398 transform_tree.Node(layer->transform_tree_index()); |
398 if (!non_root_surfaces_enabled) { | 399 if (!non_root_surfaces_enabled) { |
399 // When we only have a root surface, the clip node and the layer must | 400 // When we only have a root surface, the clip node and the layer must |
400 // necessarily have the same target (the root). | 401 // necessarily have the same target (the root). |
401 if (transform_node->data.ancestors_are_invertible) { | 402 if (transform_node->ancestors_are_invertible) { |
402 gfx::RectF combined_clip_rect_in_target_space = | 403 gfx::RectF combined_clip_rect_in_target_space = |
403 clip_node->data.combined_clip_in_target_space; | 404 clip_node->combined_clip_in_target_space; |
404 gfx::Transform target_to_content; | 405 gfx::Transform target_to_content; |
405 target_to_content.Translate(-layer->offset_to_transform_parent().x(), | 406 target_to_content.Translate(-layer->offset_to_transform_parent().x(), |
406 -layer->offset_to_transform_parent().y()); | 407 -layer->offset_to_transform_parent().y()); |
407 target_to_content.PreconcatTransform( | 408 target_to_content.PreconcatTransform( |
408 transform_tree.FromScreen(transform_node->id)); | 409 transform_tree.FromScreen(transform_node->id)); |
409 | 410 |
410 gfx::Rect visible_rect = | 411 gfx::Rect visible_rect = |
411 gfx::ToEnclosingRect(MathUtil::ProjectClippedRect( | 412 gfx::ToEnclosingRect(MathUtil::ProjectClippedRect( |
412 target_to_content, combined_clip_rect_in_target_space)); | 413 target_to_content, combined_clip_rect_in_target_space)); |
413 visible_rect.Intersect(gfx::Rect(layer_bounds)); | 414 visible_rect.Intersect(gfx::Rect(layer_bounds)); |
414 layer->set_visible_layer_rect(visible_rect); | 415 layer->set_visible_layer_rect(visible_rect); |
415 } else { | 416 } else { |
416 layer->set_visible_layer_rect(gfx::Rect(layer_bounds)); | 417 layer->set_visible_layer_rect(gfx::Rect(layer_bounds)); |
417 } | 418 } |
418 continue; | 419 continue; |
419 } | 420 } |
420 | 421 |
421 // When both the layer and the target are unclipped, the entire layer | 422 // When both the layer and the target are unclipped, the entire layer |
422 // content rect is visible. | 423 // content rect is visible. |
423 const bool fully_visible = !clip_node->data.layers_are_clipped && | 424 const bool fully_visible = |
424 !clip_node->data.target_is_clipped; | 425 !clip_node->layers_are_clipped && !clip_node->target_is_clipped; |
425 | 426 |
426 if (fully_visible) { | 427 if (fully_visible) { |
427 layer->set_visible_layer_rect(gfx::Rect(layer_bounds)); | 428 layer->set_visible_layer_rect(gfx::Rect(layer_bounds)); |
428 continue; | 429 continue; |
429 } | 430 } |
430 | 431 |
431 int target_node_id = transform_tree.ContentTargetId(transform_node->id); | 432 int target_node_id = transform_tree.ContentTargetId(transform_node->id); |
432 | 433 |
433 // The clip node stores clip rect in its target space. If required, | 434 // The clip node stores clip rect in its target space. If required, |
434 // this clip rect should be mapped to the current layer's target space. | 435 // this clip rect should be mapped to the current layer's target space. |
435 gfx::RectF combined_clip_rect_in_target_space; | 436 gfx::RectF combined_clip_rect_in_target_space; |
436 | 437 |
437 if (clip_node->data.target_id != target_node_id) { | 438 if (clip_node->target_id != target_node_id) { |
438 // In this case, layer has a clip parent or scroll parent (or shares the | 439 // In this case, layer has a clip parent or scroll parent (or shares the |
439 // target with an ancestor layer that has clip parent) and the clip | 440 // target with an ancestor layer that has clip parent) and the clip |
440 // parent's target is different from the layer's target. As the layer's | 441 // parent's target is different from the layer's target. As the layer's |
441 // target has unclippped descendants, it is unclippped. | 442 // target has unclippped descendants, it is unclippped. |
442 if (!clip_node->data.layers_are_clipped) { | 443 if (!clip_node->layers_are_clipped) { |
443 layer->set_visible_layer_rect(gfx::Rect(layer_bounds)); | 444 layer->set_visible_layer_rect(gfx::Rect(layer_bounds)); |
444 continue; | 445 continue; |
445 } | 446 } |
446 | 447 |
447 // We use the clip node's clip_in_target_space (and not | 448 // We use the clip node's clip_in_target_space (and not |
448 // combined_clip_in_target_space) here because we want to clip | 449 // combined_clip_in_target_space) here because we want to clip |
449 // with respect to clip parent's local clip and not its combined clip as | 450 // with respect to clip parent's local clip and not its combined clip as |
450 // the combined clip has even the clip parent's target's clip baked into | 451 // the combined clip has even the clip parent's target's clip baked into |
451 // it and as our target is different, we don't want to use it in our | 452 // it and as our target is different, we don't want to use it in our |
452 // visible rect computation. | 453 // visible rect computation. |
453 if (!GetLayerClipRect(layer, clip_node, transform_tree, effect_tree, | 454 if (!GetLayerClipRect(layer, clip_node, transform_tree, effect_tree, |
454 target_node_id, | 455 target_node_id, |
455 &combined_clip_rect_in_target_space)) { | 456 &combined_clip_rect_in_target_space)) { |
456 layer->set_visible_layer_rect(gfx::Rect(layer_bounds)); | 457 layer->set_visible_layer_rect(gfx::Rect(layer_bounds)); |
457 continue; | 458 continue; |
458 } | 459 } |
459 } else { | 460 } else { |
460 if (clip_node->data.target_is_clipped) { | 461 if (clip_node->target_is_clipped) { |
461 combined_clip_rect_in_target_space = | 462 combined_clip_rect_in_target_space = |
462 clip_node->data.combined_clip_in_target_space; | 463 clip_node->combined_clip_in_target_space; |
463 } else { | 464 } else { |
464 combined_clip_rect_in_target_space = | 465 combined_clip_rect_in_target_space = clip_node->clip_in_target_space; |
465 clip_node->data.clip_in_target_space; | |
466 } | 466 } |
467 } | 467 } |
468 | 468 |
469 // The clip rect should be intersected with layer rect in target space. | 469 // The clip rect should be intersected with layer rect in target space. |
470 gfx::Transform content_to_target = | 470 gfx::Transform content_to_target = |
471 transform_tree.ToTarget(transform_node->id); | 471 transform_tree.ToTarget(transform_node->id); |
472 content_to_target.Translate(layer->offset_to_transform_parent().x(), | 472 content_to_target.Translate(layer->offset_to_transform_parent().x(), |
473 layer->offset_to_transform_parent().y()); | 473 layer->offset_to_transform_parent().y()); |
474 gfx::Rect layer_content_rect = gfx::Rect(layer_bounds); | 474 gfx::Rect layer_content_rect = gfx::Rect(layer_bounds); |
475 gfx::RectF layer_content_bounds_in_target_space = MathUtil::MapClippedRect( | 475 gfx::RectF layer_content_bounds_in_target_space = MathUtil::MapClippedRect( |
476 content_to_target, gfx::RectF(layer_content_rect)); | 476 content_to_target, gfx::RectF(layer_content_rect)); |
477 // If the layer is fully contained within the clip, treat it as fully | 477 // If the layer is fully contained within the clip, treat it as fully |
478 // visible. | 478 // visible. |
479 if (!layer_content_bounds_in_target_space.IsEmpty() && | 479 if (!layer_content_bounds_in_target_space.IsEmpty() && |
480 combined_clip_rect_in_target_space.Contains( | 480 combined_clip_rect_in_target_space.Contains( |
481 layer_content_bounds_in_target_space)) { | 481 layer_content_bounds_in_target_space)) { |
482 layer->set_visible_layer_rect(gfx::Rect(layer_bounds)); | 482 layer->set_visible_layer_rect(gfx::Rect(layer_bounds)); |
483 continue; | 483 continue; |
484 } | 484 } |
485 | 485 |
486 combined_clip_rect_in_target_space.Intersect( | 486 combined_clip_rect_in_target_space.Intersect( |
487 layer_content_bounds_in_target_space); | 487 layer_content_bounds_in_target_space); |
488 if (combined_clip_rect_in_target_space.IsEmpty()) { | 488 if (combined_clip_rect_in_target_space.IsEmpty()) { |
489 layer->set_visible_layer_rect(gfx::Rect()); | 489 layer->set_visible_layer_rect(gfx::Rect()); |
490 continue; | 490 continue; |
491 } | 491 } |
492 | 492 |
493 gfx::Transform target_to_layer; | 493 gfx::Transform target_to_layer; |
494 if (transform_node->data.ancestors_are_invertible) { | 494 if (transform_node->ancestors_are_invertible) { |
495 target_to_layer = transform_tree.FromTarget(transform_node->id); | 495 target_to_layer = transform_tree.FromTarget(transform_node->id); |
496 } else { | 496 } else { |
497 if (!transform_tree.ComputeTransformWithSourceSublayerScale( | 497 if (!transform_tree.ComputeTransformWithSourceSublayerScale( |
498 target_node_id, transform_node->id, &target_to_layer)) { | 498 target_node_id, transform_node->id, &target_to_layer)) { |
499 // An animated singular transform may become non-singular during the | 499 // An animated singular transform may become non-singular during the |
500 // animation, so we still need to compute a visible rect. In this | 500 // animation, so we still need to compute a visible rect. In this |
501 // situation, we treat the entire layer as visible. | 501 // situation, we treat the entire layer as visible. |
502 layer->set_visible_layer_rect(gfx::Rect(layer_bounds)); | 502 layer->set_visible_layer_rect(gfx::Rect(layer_bounds)); |
503 continue; | 503 continue; |
504 } | 504 } |
505 } | 505 } |
506 | 506 |
507 gfx::Transform target_to_content; | 507 gfx::Transform target_to_content; |
508 target_to_content.Translate(-layer->offset_to_transform_parent().x(), | 508 target_to_content.Translate(-layer->offset_to_transform_parent().x(), |
509 -layer->offset_to_transform_parent().y()); | 509 -layer->offset_to_transform_parent().y()); |
510 target_to_content.PreconcatTransform(target_to_layer); | 510 target_to_content.PreconcatTransform(target_to_layer); |
511 | 511 |
512 gfx::Rect visible_rect = gfx::ToEnclosingRect(MathUtil::ProjectClippedRect( | 512 gfx::Rect visible_rect = gfx::ToEnclosingRect(MathUtil::ProjectClippedRect( |
513 target_to_content, combined_clip_rect_in_target_space)); | 513 target_to_content, combined_clip_rect_in_target_space)); |
514 visible_rect.Intersect(gfx::Rect(layer_bounds)); | 514 visible_rect.Intersect(gfx::Rect(layer_bounds)); |
515 layer->set_visible_layer_rect(visible_rect); | 515 layer->set_visible_layer_rect(visible_rect); |
516 } | 516 } |
517 } | 517 } |
518 | 518 |
519 static bool HasSingularTransform(int transform_tree_index, | 519 static bool HasSingularTransform(int transform_tree_index, |
520 const TransformTree& tree) { | 520 const TransformTree& tree) { |
521 const TransformNode* node = tree.Node(transform_tree_index); | 521 const TransformNode* node = tree.Node(transform_tree_index); |
522 return !node->data.is_invertible || !node->data.ancestors_are_invertible; | 522 return !node->is_invertible || !node->ancestors_are_invertible; |
523 } | 523 } |
524 | 524 |
525 template <typename LayerType> | 525 template <typename LayerType> |
526 static int TransformTreeIndexForBackfaceVisibility(LayerType* layer, | 526 static int TransformTreeIndexForBackfaceVisibility(LayerType* layer, |
527 const TransformTree& tree) { | 527 const TransformTree& tree) { |
528 if (!layer->use_parent_backface_visibility()) | 528 if (!layer->use_parent_backface_visibility()) |
529 return layer->transform_tree_index(); | 529 return layer->transform_tree_index(); |
530 const TransformNode* node = tree.Node(layer->transform_tree_index()); | 530 const TransformNode* node = tree.Node(layer->transform_tree_index()); |
531 return layer->id() == node->owner_id ? tree.parent(node)->id : node->id; | 531 return layer->id() == node->owner_id ? tree.parent(node)->id : node->id; |
532 } | 532 } |
533 | 533 |
534 template <typename LayerType> | 534 template <typename LayerType> |
535 static bool IsLayerBackFaceVisible(LayerType* layer, | 535 static bool IsLayerBackFaceVisible(LayerType* layer, |
536 int transform_tree_index, | 536 int transform_tree_index, |
537 const TransformTree& tree) { | 537 const TransformTree& tree) { |
538 const TransformNode* node = tree.Node(transform_tree_index); | 538 const TransformNode* node = tree.Node(transform_tree_index); |
539 return layer->use_local_transform_for_backface_visibility() | 539 return layer->use_local_transform_for_backface_visibility() |
540 ? node->data.local.IsBackFaceVisible() | 540 ? node->local.IsBackFaceVisible() |
541 : tree.ToTarget(transform_tree_index).IsBackFaceVisible(); | 541 : tree.ToTarget(transform_tree_index).IsBackFaceVisible(); |
542 } | 542 } |
543 | 543 |
544 static inline bool TransformToScreenIsKnown(Layer* layer, | 544 static inline bool TransformToScreenIsKnown(Layer* layer, |
545 int transform_tree_index, | 545 int transform_tree_index, |
546 const TransformTree& tree) { | 546 const TransformTree& tree) { |
547 const TransformNode* node = tree.Node(transform_tree_index); | 547 const TransformNode* node = tree.Node(transform_tree_index); |
548 return !node->data.to_screen_is_potentially_animated; | 548 return !node->to_screen_is_potentially_animated; |
549 } | 549 } |
550 | 550 |
551 static inline bool TransformToScreenIsKnown(LayerImpl* layer, | 551 static inline bool TransformToScreenIsKnown(LayerImpl* layer, |
552 int transform_tree_index, | 552 int transform_tree_index, |
553 const TransformTree& tree) { | 553 const TransformTree& tree) { |
554 return true; | 554 return true; |
555 } | 555 } |
556 | 556 |
557 template <typename LayerType> | 557 template <typename LayerType> |
558 static bool LayerNeedsUpdateInternal(LayerType* layer, | 558 static bool LayerNeedsUpdateInternal(LayerType* layer, |
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
595 | 595 |
596 return true; | 596 return true; |
597 } | 597 } |
598 | 598 |
599 void FindLayersThatNeedUpdates(LayerTreeImpl* layer_tree_impl, | 599 void FindLayersThatNeedUpdates(LayerTreeImpl* layer_tree_impl, |
600 const TransformTree& transform_tree, | 600 const TransformTree& transform_tree, |
601 const EffectTree& effect_tree, | 601 const EffectTree& effect_tree, |
602 std::vector<LayerImpl*>* visible_layer_list) { | 602 std::vector<LayerImpl*>* visible_layer_list) { |
603 for (auto* layer_impl : *layer_tree_impl) { | 603 for (auto* layer_impl : *layer_tree_impl) { |
604 bool layer_is_drawn = | 604 bool layer_is_drawn = |
605 effect_tree.Node(layer_impl->effect_tree_index())->data.is_drawn; | 605 effect_tree.Node(layer_impl->effect_tree_index())->is_drawn; |
606 | 606 |
607 if (!IsRootLayer(layer_impl) && | 607 if (!IsRootLayer(layer_impl) && |
608 LayerShouldBeSkipped(layer_impl, layer_is_drawn, transform_tree, | 608 LayerShouldBeSkipped(layer_impl, layer_is_drawn, transform_tree, |
609 effect_tree)) | 609 effect_tree)) |
610 continue; | 610 continue; |
611 | 611 |
612 if (LayerNeedsUpdate(layer_impl, layer_is_drawn, transform_tree)) | 612 if (LayerNeedsUpdate(layer_impl, layer_is_drawn, transform_tree)) |
613 visible_layer_list->push_back(layer_impl); | 613 visible_layer_list->push_back(layer_impl); |
614 } | 614 } |
615 } | 615 } |
616 | 616 |
617 void UpdateRenderSurfaceForLayer(EffectTree* effect_tree, | 617 void UpdateRenderSurfaceForLayer(EffectTree* effect_tree, |
618 bool non_root_surfaces_enabled, | 618 bool non_root_surfaces_enabled, |
619 LayerImpl* layer) { | 619 LayerImpl* layer) { |
620 if (!non_root_surfaces_enabled) { | 620 if (!non_root_surfaces_enabled) { |
621 layer->SetHasRenderSurface(IsRootLayer(layer)); | 621 layer->SetHasRenderSurface(IsRootLayer(layer)); |
622 return; | 622 return; |
623 } | 623 } |
624 | 624 |
625 EffectNode* node = effect_tree->Node(layer->effect_tree_index()); | 625 EffectNode* node = effect_tree->Node(layer->effect_tree_index()); |
626 | 626 |
627 if (node->owner_id == layer->id() && node->data.has_render_surface) | 627 if (node->owner_id == layer->id() && node->has_render_surface) |
628 layer->SetHasRenderSurface(true); | 628 layer->SetHasRenderSurface(true); |
629 else | 629 else |
630 layer->SetHasRenderSurface(false); | 630 layer->SetHasRenderSurface(false); |
631 } | 631 } |
632 } // namespace | 632 } // namespace |
633 | 633 |
634 template <typename LayerType> | 634 template <typename LayerType> |
635 static inline bool LayerShouldBeSkippedInternal( | 635 static inline bool LayerShouldBeSkippedInternal( |
636 LayerType* layer, | 636 LayerType* layer, |
637 bool layer_is_drawn, | 637 bool layer_is_drawn, |
638 const TransformTree& transform_tree, | 638 const TransformTree& transform_tree, |
639 const EffectTree& effect_tree) { | 639 const EffectTree& effect_tree) { |
640 const TransformNode* transform_node = | 640 const TransformNode* transform_node = |
641 transform_tree.Node(layer->transform_tree_index()); | 641 transform_tree.Node(layer->transform_tree_index()); |
642 const EffectNode* effect_node = effect_tree.Node(layer->effect_tree_index()); | 642 const EffectNode* effect_node = effect_tree.Node(layer->effect_tree_index()); |
643 | 643 |
644 if (effect_node->data.has_render_surface && | 644 if (effect_node->has_render_surface && |
645 effect_node->data.num_copy_requests_in_subtree > 0) | 645 effect_node->num_copy_requests_in_subtree > 0) |
646 return false; | 646 return false; |
647 // If the layer transform is not invertible, it should be skipped. | 647 // If the layer transform is not invertible, it should be skipped. |
648 // TODO(ajuma): Correctly process subtrees with singular transform for the | 648 // TODO(ajuma): Correctly process subtrees with singular transform for the |
649 // case where we may animate to a non-singular transform and wish to | 649 // case where we may animate to a non-singular transform and wish to |
650 // pre-raster. | 650 // pre-raster. |
651 return !transform_node->data.node_and_ancestors_are_animated_or_invertible || | 651 return !transform_node->node_and_ancestors_are_animated_or_invertible || |
652 effect_node->data.hidden_by_backface_visibility || | 652 effect_node->hidden_by_backface_visibility || !effect_node->is_drawn; |
653 !effect_node->data.is_drawn; | |
654 } | 653 } |
655 | 654 |
656 bool LayerShouldBeSkipped(LayerImpl* layer, | 655 bool LayerShouldBeSkipped(LayerImpl* layer, |
657 bool layer_is_drawn, | 656 bool layer_is_drawn, |
658 const TransformTree& transform_tree, | 657 const TransformTree& transform_tree, |
659 const EffectTree& effect_tree) { | 658 const EffectTree& effect_tree) { |
660 return LayerShouldBeSkippedInternal(layer, layer_is_drawn, transform_tree, | 659 return LayerShouldBeSkippedInternal(layer, layer_is_drawn, transform_tree, |
661 effect_tree); | 660 effect_tree); |
662 } | 661 } |
663 | 662 |
664 bool LayerShouldBeSkipped(Layer* layer, | 663 bool LayerShouldBeSkipped(Layer* layer, |
665 bool layer_is_drawn, | 664 bool layer_is_drawn, |
666 const TransformTree& transform_tree, | 665 const TransformTree& transform_tree, |
667 const EffectTree& effect_tree) { | 666 const EffectTree& effect_tree) { |
668 return LayerShouldBeSkippedInternal(layer, layer_is_drawn, transform_tree, | 667 return LayerShouldBeSkippedInternal(layer, layer_is_drawn, transform_tree, |
669 effect_tree); | 668 effect_tree); |
670 } | 669 } |
671 | 670 |
672 void FindLayersThatNeedUpdates(LayerTreeHost* layer_tree_host, | 671 void FindLayersThatNeedUpdates(LayerTreeHost* layer_tree_host, |
673 const TransformTree& transform_tree, | 672 const TransformTree& transform_tree, |
674 const EffectTree& effect_tree, | 673 const EffectTree& effect_tree, |
675 LayerList* update_layer_list) { | 674 LayerList* update_layer_list) { |
676 for (auto* layer : *layer_tree_host) { | 675 for (auto* layer : *layer_tree_host) { |
677 bool layer_is_drawn = | 676 bool layer_is_drawn = |
678 effect_tree.Node(layer->effect_tree_index())->data.is_drawn; | 677 effect_tree.Node(layer->effect_tree_index())->is_drawn; |
679 | 678 |
680 if (!IsRootLayer(layer) && | 679 if (!IsRootLayer(layer) && |
681 LayerShouldBeSkipped(layer, layer_is_drawn, transform_tree, | 680 LayerShouldBeSkipped(layer, layer_is_drawn, transform_tree, |
682 effect_tree)) | 681 effect_tree)) |
683 continue; | 682 continue; |
684 | 683 |
685 if (LayerNeedsUpdate(layer, layer_is_drawn, transform_tree)) { | 684 if (LayerNeedsUpdate(layer, layer_is_drawn, transform_tree)) { |
686 update_layer_list->push_back(layer); | 685 update_layer_list->push_back(layer); |
687 } | 686 } |
688 | 687 |
(...skipping 17 matching lines...) Expand all Loading... |
706 | 705 |
707 void ComputeClips(ClipTree* clip_tree, | 706 void ComputeClips(ClipTree* clip_tree, |
708 const TransformTree& transform_tree, | 707 const TransformTree& transform_tree, |
709 bool non_root_surfaces_enabled) { | 708 bool non_root_surfaces_enabled) { |
710 if (!clip_tree->needs_update()) | 709 if (!clip_tree->needs_update()) |
711 return; | 710 return; |
712 for (int i = 1; i < static_cast<int>(clip_tree->size()); ++i) { | 711 for (int i = 1; i < static_cast<int>(clip_tree->size()); ++i) { |
713 ClipNode* clip_node = clip_tree->Node(i); | 712 ClipNode* clip_node = clip_tree->Node(i); |
714 | 713 |
715 if (clip_node->id == 1) { | 714 if (clip_node->id == 1) { |
716 ResetIfHasNanCoordinate(&clip_node->data.clip); | 715 ResetIfHasNanCoordinate(&clip_node->clip); |
717 clip_node->data.clip_in_target_space = clip_node->data.clip; | 716 clip_node->clip_in_target_space = clip_node->clip; |
718 clip_node->data.combined_clip_in_target_space = clip_node->data.clip; | 717 clip_node->combined_clip_in_target_space = clip_node->clip; |
719 continue; | 718 continue; |
720 } | 719 } |
721 const TransformNode* transform_node = | 720 const TransformNode* transform_node = |
722 transform_tree.Node(clip_node->data.transform_id); | 721 transform_tree.Node(clip_node->transform_id); |
723 ClipNode* parent_clip_node = clip_tree->parent(clip_node); | 722 ClipNode* parent_clip_node = clip_tree->parent(clip_node); |
724 | 723 |
725 gfx::Transform parent_to_current; | 724 gfx::Transform parent_to_current; |
726 const TransformNode* parent_target_transform_node = | 725 const TransformNode* parent_target_transform_node = |
727 transform_tree.Node(parent_clip_node->data.target_id); | 726 transform_tree.Node(parent_clip_node->target_id); |
728 bool success = true; | 727 bool success = true; |
729 | 728 |
730 // Clips must be combined in target space. We cannot, for example, combine | 729 // Clips must be combined in target space. We cannot, for example, combine |
731 // clips in the space of the child clip. The reason is non-affine | 730 // clips in the space of the child clip. The reason is non-affine |
732 // transforms. Say we have the following tree T->A->B->C, and B clips C, but | 731 // transforms. Say we have the following tree T->A->B->C, and B clips C, but |
733 // draw into target T. It may be the case that A applies a perspective | 732 // draw into target T. It may be the case that A applies a perspective |
734 // transform, and B and C are at different z positions. When projected into | 733 // transform, and B and C are at different z positions. When projected into |
735 // target space, the relative sizes and positions of B and C can shift. | 734 // target space, the relative sizes and positions of B and C can shift. |
736 // Since it's the relationship in target space that matters, that's where we | 735 // Since it's the relationship in target space that matters, that's where we |
737 // must combine clips. For each clip node, we save the clip rects in its | 736 // must combine clips. For each clip node, we save the clip rects in its |
738 // target space. So, we need to get the ancestor clip rect in the current | 737 // target space. So, we need to get the ancestor clip rect in the current |
739 // clip node's target space. | 738 // clip node's target space. |
740 gfx::RectF parent_combined_clip_in_target_space = | 739 gfx::RectF parent_combined_clip_in_target_space = |
741 parent_clip_node->data.combined_clip_in_target_space; | 740 parent_clip_node->combined_clip_in_target_space; |
742 gfx::RectF parent_clip_in_target_space = | 741 gfx::RectF parent_clip_in_target_space = |
743 parent_clip_node->data.clip_in_target_space; | 742 parent_clip_node->clip_in_target_space; |
744 if (parent_target_transform_node && | 743 if (parent_target_transform_node && |
745 parent_target_transform_node->id != clip_node->data.target_id && | 744 parent_target_transform_node->id != clip_node->target_id && |
746 non_root_surfaces_enabled) { | 745 non_root_surfaces_enabled) { |
747 success &= transform_tree.ComputeTransformWithDestinationSublayerScale( | 746 success &= transform_tree.ComputeTransformWithDestinationSublayerScale( |
748 parent_target_transform_node->id, clip_node->data.target_id, | 747 parent_target_transform_node->id, clip_node->target_id, |
749 &parent_to_current); | 748 &parent_to_current); |
750 if (parent_target_transform_node->data.sublayer_scale.x() > 0 && | 749 if (parent_target_transform_node->sublayer_scale.x() > 0 && |
751 parent_target_transform_node->data.sublayer_scale.y() > 0) | 750 parent_target_transform_node->sublayer_scale.y() > 0) |
752 parent_to_current.Scale( | 751 parent_to_current.Scale( |
753 1.f / parent_target_transform_node->data.sublayer_scale.x(), | 752 1.f / parent_target_transform_node->sublayer_scale.x(), |
754 1.f / parent_target_transform_node->data.sublayer_scale.y()); | 753 1.f / parent_target_transform_node->sublayer_scale.y()); |
755 // If we can't compute a transform, it's because we had to use the inverse | 754 // If we can't compute a transform, it's because we had to use the inverse |
756 // of a singular transform. We won't draw in this case, so there's no need | 755 // of a singular transform. We won't draw in this case, so there's no need |
757 // to compute clips. | 756 // to compute clips. |
758 if (!success) | 757 if (!success) |
759 continue; | 758 continue; |
760 parent_combined_clip_in_target_space = MathUtil::ProjectClippedRect( | 759 parent_combined_clip_in_target_space = MathUtil::ProjectClippedRect( |
761 parent_to_current, | 760 parent_to_current, parent_clip_node->combined_clip_in_target_space); |
762 parent_clip_node->data.combined_clip_in_target_space); | |
763 parent_clip_in_target_space = MathUtil::ProjectClippedRect( | 761 parent_clip_in_target_space = MathUtil::ProjectClippedRect( |
764 parent_to_current, parent_clip_node->data.clip_in_target_space); | 762 parent_to_current, parent_clip_node->clip_in_target_space); |
765 } | 763 } |
766 // Only nodes affected by ancestor clips will have their clip adjusted due | 764 // Only nodes affected by ancestor clips will have their clip adjusted due |
767 // to intersecting with an ancestor clip. But, we still need to propagate | 765 // to intersecting with an ancestor clip. But, we still need to propagate |
768 // the combined clip to our children because if they are clipped, they may | 766 // the combined clip to our children because if they are clipped, they may |
769 // need to clip using our parent clip and if we don't propagate it here, | 767 // need to clip using our parent clip and if we don't propagate it here, |
770 // it will be lost. | 768 // it will be lost. |
771 if (clip_node->data.resets_clip && non_root_surfaces_enabled) { | 769 if (clip_node->resets_clip && non_root_surfaces_enabled) { |
772 if (clip_node->data.applies_local_clip) { | 770 if (clip_node->applies_local_clip) { |
773 clip_node->data.clip_in_target_space = MathUtil::MapClippedRect( | 771 clip_node->clip_in_target_space = MathUtil::MapClippedRect( |
774 transform_tree.ToTarget(clip_node->data.transform_id), | 772 transform_tree.ToTarget(clip_node->transform_id), clip_node->clip); |
775 clip_node->data.clip); | 773 ResetIfHasNanCoordinate(&clip_node->clip_in_target_space); |
776 ResetIfHasNanCoordinate(&clip_node->data.clip_in_target_space); | 774 clip_node->combined_clip_in_target_space = |
777 clip_node->data.combined_clip_in_target_space = | 775 gfx::IntersectRects(clip_node->clip_in_target_space, |
778 gfx::IntersectRects(clip_node->data.clip_in_target_space, | |
779 parent_combined_clip_in_target_space); | 776 parent_combined_clip_in_target_space); |
780 } else { | 777 } else { |
781 DCHECK(!clip_node->data.target_is_clipped); | 778 DCHECK(!clip_node->target_is_clipped); |
782 DCHECK(!clip_node->data.layers_are_clipped); | 779 DCHECK(!clip_node->layers_are_clipped); |
783 clip_node->data.combined_clip_in_target_space = | 780 clip_node->combined_clip_in_target_space = |
784 parent_combined_clip_in_target_space; | 781 parent_combined_clip_in_target_space; |
785 } | 782 } |
786 ResetIfHasNanCoordinate(&clip_node->data.combined_clip_in_target_space); | 783 ResetIfHasNanCoordinate(&clip_node->combined_clip_in_target_space); |
787 continue; | 784 continue; |
788 } | 785 } |
789 bool use_only_parent_clip = !clip_node->data.applies_local_clip; | 786 bool use_only_parent_clip = !clip_node->applies_local_clip; |
790 if (use_only_parent_clip) { | 787 if (use_only_parent_clip) { |
791 clip_node->data.combined_clip_in_target_space = | 788 clip_node->combined_clip_in_target_space = |
792 parent_combined_clip_in_target_space; | 789 parent_combined_clip_in_target_space; |
793 if (!non_root_surfaces_enabled) { | 790 if (!non_root_surfaces_enabled) { |
794 clip_node->data.clip_in_target_space = | 791 clip_node->clip_in_target_space = |
795 parent_clip_node->data.clip_in_target_space; | 792 parent_clip_node->clip_in_target_space; |
796 } else if (!clip_node->data.target_is_clipped) { | 793 } else if (!clip_node->target_is_clipped) { |
797 clip_node->data.clip_in_target_space = parent_clip_in_target_space; | 794 clip_node->clip_in_target_space = parent_clip_in_target_space; |
798 } else { | 795 } else { |
799 // Render Surface applies clip and the owning layer itself applies | 796 // Render Surface applies clip and the owning layer itself applies |
800 // no clip. So, clip_in_target_space is not used and hence we can set | 797 // no clip. So, clip_in_target_space is not used and hence we can set |
801 // it to an empty rect. | 798 // it to an empty rect. |
802 clip_node->data.clip_in_target_space = gfx::RectF(); | 799 clip_node->clip_in_target_space = gfx::RectF(); |
803 } | 800 } |
804 } else { | 801 } else { |
805 gfx::Transform source_to_target; | 802 gfx::Transform source_to_target; |
806 | 803 |
807 if (!non_root_surfaces_enabled) { | 804 if (!non_root_surfaces_enabled) { |
808 source_to_target = | 805 source_to_target = transform_tree.ToScreen(clip_node->transform_id); |
809 transform_tree.ToScreen(clip_node->data.transform_id); | |
810 } else if (transform_tree.ContentTargetId(transform_node->id) == | 806 } else if (transform_tree.ContentTargetId(transform_node->id) == |
811 clip_node->data.target_id) { | 807 clip_node->target_id) { |
812 source_to_target = | 808 source_to_target = transform_tree.ToTarget(clip_node->transform_id); |
813 transform_tree.ToTarget(clip_node->data.transform_id); | |
814 } else { | 809 } else { |
815 success = transform_tree.ComputeTransformWithDestinationSublayerScale( | 810 success = transform_tree.ComputeTransformWithDestinationSublayerScale( |
816 transform_node->id, clip_node->data.target_id, &source_to_target); | 811 transform_node->id, clip_node->target_id, &source_to_target); |
817 // source_to_target computation should be successful as target is an | 812 // source_to_target computation should be successful as target is an |
818 // ancestor of the transform node. | 813 // ancestor of the transform node. |
819 DCHECK(success); | 814 DCHECK(success); |
820 } | 815 } |
821 | 816 |
822 gfx::RectF source_clip_in_target_space = | 817 gfx::RectF source_clip_in_target_space = |
823 MathUtil::MapClippedRect(source_to_target, clip_node->data.clip); | 818 MathUtil::MapClippedRect(source_to_target, clip_node->clip); |
824 | 819 |
825 // With surfaces disabled, the only case where we use only the local clip | 820 // With surfaces disabled, the only case where we use only the local clip |
826 // for layer clipping is the case where no non-viewport ancestor node | 821 // for layer clipping is the case where no non-viewport ancestor node |
827 // applies a local clip. | 822 // applies a local clip. |
828 bool layer_clipping_uses_only_local_clip = | 823 bool layer_clipping_uses_only_local_clip = |
829 non_root_surfaces_enabled | 824 non_root_surfaces_enabled |
830 ? clip_node->data.layer_clipping_uses_only_local_clip | 825 ? clip_node->layer_clipping_uses_only_local_clip |
831 : !parent_clip_node->data | 826 : !parent_clip_node->layers_are_clipped_when_surfaces_disabled; |
832 .layers_are_clipped_when_surfaces_disabled; | |
833 if (!layer_clipping_uses_only_local_clip) { | 827 if (!layer_clipping_uses_only_local_clip) { |
834 clip_node->data.clip_in_target_space = gfx::IntersectRects( | 828 clip_node->clip_in_target_space = gfx::IntersectRects( |
835 parent_clip_in_target_space, source_clip_in_target_space); | 829 parent_clip_in_target_space, source_clip_in_target_space); |
836 } else { | 830 } else { |
837 clip_node->data.clip_in_target_space = source_clip_in_target_space; | 831 clip_node->clip_in_target_space = source_clip_in_target_space; |
838 } | 832 } |
839 | 833 |
840 clip_node->data.combined_clip_in_target_space = gfx::IntersectRects( | 834 clip_node->combined_clip_in_target_space = gfx::IntersectRects( |
841 parent_combined_clip_in_target_space, source_clip_in_target_space); | 835 parent_combined_clip_in_target_space, source_clip_in_target_space); |
842 } | 836 } |
843 ResetIfHasNanCoordinate(&clip_node->data.clip_in_target_space); | 837 ResetIfHasNanCoordinate(&clip_node->clip_in_target_space); |
844 ResetIfHasNanCoordinate(&clip_node->data.combined_clip_in_target_space); | 838 ResetIfHasNanCoordinate(&clip_node->combined_clip_in_target_space); |
845 } | 839 } |
846 clip_tree->set_needs_update(false); | 840 clip_tree->set_needs_update(false); |
847 } | 841 } |
848 | 842 |
849 void ComputeTransforms(TransformTree* transform_tree) { | 843 void ComputeTransforms(TransformTree* transform_tree) { |
850 if (!transform_tree->needs_update()) | 844 if (!transform_tree->needs_update()) |
851 return; | 845 return; |
852 for (int i = 1; i < static_cast<int>(transform_tree->size()); ++i) | 846 for (int i = 1; i < static_cast<int>(transform_tree->size()); ++i) |
853 transform_tree->UpdateTransforms(i); | 847 transform_tree->UpdateTransforms(i); |
854 transform_tree->set_needs_update(false); | 848 transform_tree->set_needs_update(false); |
855 } | 849 } |
856 | 850 |
857 void UpdateRenderTarget(EffectTree* effect_tree, | 851 void UpdateRenderTarget(EffectTree* effect_tree, |
858 bool can_render_to_separate_surface) { | 852 bool can_render_to_separate_surface) { |
859 for (int i = 1; i < static_cast<int>(effect_tree->size()); ++i) { | 853 for (int i = 1; i < static_cast<int>(effect_tree->size()); ++i) { |
860 EffectNode* node = effect_tree->Node(i); | 854 EffectNode* node = effect_tree->Node(i); |
861 if (i == 1) { | 855 if (i == 1) { |
862 // Render target on the first effect node is root. | 856 // Render target on the first effect node is root. |
863 node->data.target_id = 0; | 857 node->target_id = 0; |
864 } else if (!can_render_to_separate_surface) { | 858 } else if (!can_render_to_separate_surface) { |
865 node->data.target_id = 1; | 859 node->target_id = 1; |
866 } else if (effect_tree->parent(node)->data.has_render_surface) { | 860 } else if (effect_tree->parent(node)->has_render_surface) { |
867 node->data.target_id = node->parent_id; | 861 node->target_id = node->parent_id; |
868 } else { | 862 } else { |
869 node->data.target_id = effect_tree->parent(node)->data.target_id; | 863 node->target_id = effect_tree->parent(node)->target_id; |
870 } | 864 } |
871 } | 865 } |
872 } | 866 } |
873 | 867 |
874 void ComputeEffects(EffectTree* effect_tree) { | 868 void ComputeEffects(EffectTree* effect_tree) { |
875 if (!effect_tree->needs_update()) | 869 if (!effect_tree->needs_update()) |
876 return; | 870 return; |
877 for (int i = 1; i < static_cast<int>(effect_tree->size()); ++i) | 871 for (int i = 1; i < static_cast<int>(effect_tree->size()); ++i) |
878 effect_tree->UpdateEffects(i); | 872 effect_tree->UpdateEffects(i); |
879 effect_tree->set_needs_update(false); | 873 effect_tree->set_needs_update(false); |
880 } | 874 } |
881 | 875 |
882 static void ComputeClipsWithEffectTree(PropertyTrees* property_trees) { | 876 static void ComputeClipsWithEffectTree(PropertyTrees* property_trees) { |
883 EffectTree* effect_tree = &property_trees->effect_tree; | 877 EffectTree* effect_tree = &property_trees->effect_tree; |
884 const ClipTree* clip_tree = &property_trees->clip_tree; | 878 const ClipTree* clip_tree = &property_trees->clip_tree; |
885 const TransformTree* transform_tree = &property_trees->transform_tree; | 879 const TransformTree* transform_tree = &property_trees->transform_tree; |
886 EffectNode* root_effect_node = effect_tree->Node(1); | 880 EffectNode* root_effect_node = effect_tree->Node(1); |
887 const RenderSurfaceImpl* root_render_surface = | 881 const RenderSurfaceImpl* root_render_surface = |
888 root_effect_node->data.render_surface; | 882 root_effect_node->render_surface; |
889 gfx::Rect root_clip = gfx::ToEnclosingRect( | 883 gfx::Rect root_clip = |
890 clip_tree->Node(root_effect_node->data.clip_id)->data.clip); | 884 gfx::ToEnclosingRect(clip_tree->Node(root_effect_node->clip_id)->clip); |
891 if (root_render_surface->is_clipped()) | 885 if (root_render_surface->is_clipped()) |
892 DCHECK(root_clip == root_render_surface->clip_rect()) | 886 DCHECK(root_clip == root_render_surface->clip_rect()) |
893 << "clip on root render surface: " | 887 << "clip on root render surface: " |
894 << root_render_surface->clip_rect().ToString() | 888 << root_render_surface->clip_rect().ToString() |
895 << " v.s. root effect node's clip: " << root_clip.ToString(); | 889 << " v.s. root effect node's clip: " << root_clip.ToString(); |
896 for (int i = 2; i < static_cast<int>(effect_tree->size()); ++i) { | 890 for (int i = 2; i < static_cast<int>(effect_tree->size()); ++i) { |
897 EffectNode* effect_node = effect_tree->Node(i); | 891 EffectNode* effect_node = effect_tree->Node(i); |
898 const EffectNode* target_node = | 892 const EffectNode* target_node = effect_tree->Node(effect_node->target_id); |
899 effect_tree->Node(effect_node->data.target_id); | |
900 ConditionalClip accumulated_clip_rect = | 893 ConditionalClip accumulated_clip_rect = |
901 ComputeAccumulatedClip(*clip_tree, effect_node->data.clip_id, | 894 ComputeAccumulatedClip(*clip_tree, effect_node->clip_id, *effect_tree, |
902 *effect_tree, target_node->id, *transform_tree); | 895 target_node->id, *transform_tree); |
903 gfx::RectF accumulated_clip = accumulated_clip_rect.clip_rect; | 896 gfx::RectF accumulated_clip = accumulated_clip_rect.clip_rect; |
904 const RenderSurfaceImpl* render_surface = effect_node->data.render_surface; | 897 const RenderSurfaceImpl* render_surface = effect_node->render_surface; |
905 if (render_surface && render_surface->is_clipped()) { | 898 if (render_surface && render_surface->is_clipped()) { |
906 DCHECK(gfx::ToEnclosingRect(accumulated_clip) == | 899 DCHECK(gfx::ToEnclosingRect(accumulated_clip) == |
907 render_surface->clip_rect()) | 900 render_surface->clip_rect()) |
908 << " render surface's clip rect: " | 901 << " render surface's clip rect: " |
909 << render_surface->clip_rect().ToString() | 902 << render_surface->clip_rect().ToString() |
910 << " v.s. accumulated clip: " | 903 << " v.s. accumulated clip: " |
911 << gfx::ToEnclosingRect(accumulated_clip).ToString(); | 904 << gfx::ToEnclosingRect(accumulated_clip).ToString(); |
912 } | 905 } |
913 } | 906 } |
914 } | 907 } |
915 | 908 |
916 static void ComputeLayerClipRect(const PropertyTrees* property_trees, | 909 static void ComputeLayerClipRect(const PropertyTrees* property_trees, |
917 const LayerImpl* layer) { | 910 const LayerImpl* layer) { |
918 const EffectTree* effect_tree = &property_trees->effect_tree; | 911 const EffectTree* effect_tree = &property_trees->effect_tree; |
919 const ClipTree* clip_tree = &property_trees->clip_tree; | 912 const ClipTree* clip_tree = &property_trees->clip_tree; |
920 const TransformTree* transform_tree = &property_trees->transform_tree; | 913 const TransformTree* transform_tree = &property_trees->transform_tree; |
921 const EffectNode* effect_node = effect_tree->Node(layer->effect_tree_index()); | 914 const EffectNode* effect_node = effect_tree->Node(layer->effect_tree_index()); |
922 const EffectNode* target_node = | 915 const EffectNode* target_node = |
923 effect_node->data.has_render_surface | 916 effect_node->has_render_surface |
924 ? effect_node | 917 ? effect_node |
925 : effect_tree->Node(effect_node->data.target_id); | 918 : effect_tree->Node(effect_node->target_id); |
926 // TODO(weiliangc): When effect node has up to date render surface info on | 919 // TODO(weiliangc): When effect node has up to date render surface info on |
927 // compositor thread, no need to check for resourceless draw mode | 920 // compositor thread, no need to check for resourceless draw mode |
928 if (!property_trees->non_root_surfaces_enabled) { | 921 if (!property_trees->non_root_surfaces_enabled) { |
929 target_node = effect_tree->Node(1); | 922 target_node = effect_tree->Node(1); |
930 } | 923 } |
931 | 924 |
932 ConditionalClip accumulated_clip_rect = | 925 ConditionalClip accumulated_clip_rect = |
933 ComputeAccumulatedClip(*clip_tree, layer->clip_tree_index(), *effect_tree, | 926 ComputeAccumulatedClip(*clip_tree, layer->clip_tree_index(), *effect_tree, |
934 target_node->id, *transform_tree); | 927 target_node->id, *transform_tree); |
935 | 928 |
936 gfx::RectF accumulated_clip = accumulated_clip_rect.clip_rect; | 929 gfx::RectF accumulated_clip = accumulated_clip_rect.clip_rect; |
937 | 930 |
938 if ((!property_trees->non_root_surfaces_enabled && | 931 if ((!property_trees->non_root_surfaces_enabled && |
939 clip_tree->Node(layer->clip_tree_index()) | 932 clip_tree->Node(layer->clip_tree_index()) |
940 ->data.layers_are_clipped_when_surfaces_disabled) || | 933 ->layers_are_clipped_when_surfaces_disabled) || |
941 clip_tree->Node(layer->clip_tree_index())->data.layers_are_clipped) { | 934 clip_tree->Node(layer->clip_tree_index())->layers_are_clipped) { |
942 DCHECK(layer->clip_rect() == gfx::ToEnclosingRect(accumulated_clip)) | 935 DCHECK(layer->clip_rect() == gfx::ToEnclosingRect(accumulated_clip)) |
943 << " layer: " << layer->id() << " clip id: " << layer->clip_tree_index() | 936 << " layer: " << layer->id() << " clip id: " << layer->clip_tree_index() |
944 << " layer clip: " << layer->clip_rect().ToString() << " v.s. " | 937 << " layer clip: " << layer->clip_rect().ToString() << " v.s. " |
945 << gfx::ToEnclosingRect(accumulated_clip).ToString() | 938 << gfx::ToEnclosingRect(accumulated_clip).ToString() |
946 << " and clip node clip: " | 939 << " and clip node clip: " |
947 << gfx::ToEnclosingRect(clip_tree->Node(layer->clip_tree_index()) | 940 << gfx::ToEnclosingRect( |
948 ->data.clip_in_target_space) | 941 clip_tree->Node(layer->clip_tree_index())->clip_in_target_space) |
949 .ToString(); | 942 .ToString(); |
950 } | 943 } |
951 } | 944 } |
952 | 945 |
953 static int FindTargetTransformTreeIndexFromEffectTree( | 946 static int FindTargetTransformTreeIndexFromEffectTree( |
954 const EffectTree& effect_tree, | 947 const EffectTree& effect_tree, |
955 const int effect_tree_index) { | 948 const int effect_tree_index) { |
956 const EffectNode* node = effect_tree.Node(effect_tree_index); | 949 const EffectNode* node = effect_tree.Node(effect_tree_index); |
957 if (node->data.has_render_surface) | 950 if (node->has_render_surface) |
958 return node->data.transform_id; | 951 return node->transform_id; |
959 node = effect_tree.Node(node->data.target_id); | 952 node = effect_tree.Node(node->target_id); |
960 return node->data.transform_id; | 953 return node->transform_id; |
961 } | 954 } |
962 | 955 |
963 static void VerifyDrawTransformsMatch(LayerImpl* layer, | 956 static void VerifyDrawTransformsMatch(LayerImpl* layer, |
964 PropertyTrees* property_trees) { | 957 PropertyTrees* property_trees) { |
965 const int source_id = layer->transform_tree_index(); | 958 const int source_id = layer->transform_tree_index(); |
966 int destination_id = FindTargetTransformTreeIndexFromEffectTree( | 959 int destination_id = FindTargetTransformTreeIndexFromEffectTree( |
967 property_trees->effect_tree, layer->effect_tree_index()); | 960 property_trees->effect_tree, layer->effect_tree_index()); |
968 gfx::Transform draw_transform; | 961 gfx::Transform draw_transform; |
969 property_trees->transform_tree.ComputeTransform(source_id, destination_id, | 962 property_trees->transform_tree.ComputeTransform(source_id, destination_id, |
970 &draw_transform); | 963 &draw_transform); |
(...skipping 121 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1092 void ComputeVisibleRects(LayerImpl* root_layer, | 1085 void ComputeVisibleRects(LayerImpl* root_layer, |
1093 PropertyTrees* property_trees, | 1086 PropertyTrees* property_trees, |
1094 bool can_render_to_separate_surface, | 1087 bool can_render_to_separate_surface, |
1095 LayerImplList* visible_layer_list) { | 1088 LayerImplList* visible_layer_list) { |
1096 for (auto* layer : *root_layer->layer_tree_impl()) { | 1089 for (auto* layer : *root_layer->layer_tree_impl()) { |
1097 UpdateRenderSurfaceForLayer(&property_trees->effect_tree, | 1090 UpdateRenderSurfaceForLayer(&property_trees->effect_tree, |
1098 can_render_to_separate_surface, layer); | 1091 can_render_to_separate_surface, layer); |
1099 EffectNode* node = | 1092 EffectNode* node = |
1100 property_trees->effect_tree.Node(layer->effect_tree_index()); | 1093 property_trees->effect_tree.Node(layer->effect_tree_index()); |
1101 if (node->owner_id == layer->id()) | 1094 if (node->owner_id == layer->id()) |
1102 node->data.render_surface = layer->render_surface(); | 1095 node->render_surface = layer->render_surface(); |
1103 #if DCHECK_IS_ON() | 1096 #if DCHECK_IS_ON() |
1104 if (can_render_to_separate_surface) | 1097 if (can_render_to_separate_surface) |
1105 ValidateRenderSurfaceForLayer(layer); | 1098 ValidateRenderSurfaceForLayer(layer); |
1106 #endif | 1099 #endif |
1107 } | 1100 } |
1108 ComputeVisibleRectsInternal(root_layer, property_trees, | 1101 ComputeVisibleRectsInternal(root_layer, property_trees, |
1109 can_render_to_separate_surface, | 1102 can_render_to_separate_surface, |
1110 visible_layer_list); | 1103 visible_layer_list); |
1111 } | 1104 } |
1112 | 1105 |
(...skipping 18 matching lines...) Expand all Loading... |
1131 if (!owns_non_root_surface) { | 1124 if (!owns_non_root_surface) { |
1132 // If you're not the root, or you don't own a surface, you need to apply | 1125 // If you're not the root, or you don't own a surface, you need to apply |
1133 // your local offset. | 1126 // your local offset. |
1134 xform = tree.ToTarget(layer->transform_tree_index()); | 1127 xform = tree.ToTarget(layer->transform_tree_index()); |
1135 if (layer->should_flatten_transform_from_property_tree()) | 1128 if (layer->should_flatten_transform_from_property_tree()) |
1136 xform.FlattenTo2d(); | 1129 xform.FlattenTo2d(); |
1137 xform.Translate(layer->offset_to_transform_parent().x(), | 1130 xform.Translate(layer->offset_to_transform_parent().x(), |
1138 layer->offset_to_transform_parent().y()); | 1131 layer->offset_to_transform_parent().y()); |
1139 } else { | 1132 } else { |
1140 // Surfaces need to apply their sublayer scale. | 1133 // Surfaces need to apply their sublayer scale. |
1141 xform.Scale(node->data.sublayer_scale.x(), node->data.sublayer_scale.y()); | 1134 xform.Scale(node->sublayer_scale.x(), node->sublayer_scale.y()); |
1142 } | 1135 } |
1143 return xform; | 1136 return xform; |
1144 } | 1137 } |
1145 | 1138 |
1146 static void SetSurfaceDrawTransform(const TransformTree& transform_tree, | 1139 static void SetSurfaceDrawTransform(const TransformTree& transform_tree, |
1147 const EffectTree& effect_tree, | 1140 const EffectTree& effect_tree, |
1148 RenderSurfaceImpl* render_surface) { | 1141 RenderSurfaceImpl* render_surface) { |
1149 const TransformNode* transform_node = | 1142 const TransformNode* transform_node = |
1150 transform_tree.Node(render_surface->TransformTreeIndex()); | 1143 transform_tree.Node(render_surface->TransformTreeIndex()); |
1151 const EffectNode* effect_node = | 1144 const EffectNode* effect_node = |
1152 effect_tree.Node(render_surface->EffectTreeIndex()); | 1145 effect_tree.Node(render_surface->EffectTreeIndex()); |
1153 // The draw transform of root render surface is identity tranform. | 1146 // The draw transform of root render surface is identity tranform. |
1154 if (transform_node->id == 1) { | 1147 if (transform_node->id == 1) { |
1155 render_surface->SetDrawTransform(gfx::Transform()); | 1148 render_surface->SetDrawTransform(gfx::Transform()); |
1156 return; | 1149 return; |
1157 } | 1150 } |
1158 | 1151 |
1159 gfx::Transform render_surface_transform; | 1152 gfx::Transform render_surface_transform; |
1160 const TransformNode* target_transform_node = | 1153 const TransformNode* target_transform_node = |
1161 transform_tree.Node(transform_tree.TargetId(transform_node->id)); | 1154 transform_tree.Node(transform_tree.TargetId(transform_node->id)); |
1162 transform_tree.ComputeTransform(transform_node->id, target_transform_node->id, | 1155 transform_tree.ComputeTransform(transform_node->id, target_transform_node->id, |
1163 &render_surface_transform); | 1156 &render_surface_transform); |
1164 // We don't have to apply sublayer scale when target is root. | 1157 // We don't have to apply sublayer scale when target is root. |
1165 if (target_transform_node->id != 0) { | 1158 if (target_transform_node->id != 0) { |
1166 AddSublayerScaleToTransform(effect_node->data.target_id, effect_tree, | 1159 AddSublayerScaleToTransform(effect_node->target_id, effect_tree, |
1167 &render_surface_transform); | 1160 &render_surface_transform); |
1168 #if DCHECK_IS_ON() | 1161 #if DCHECK_IS_ON() |
1169 VerifySublayerScalesMatch(effect_node->data.target_id, | 1162 VerifySublayerScalesMatch(effect_node->target_id, target_transform_node->id, |
1170 target_transform_node->id, effect_tree, | 1163 effect_tree, transform_tree); |
1171 transform_tree); | |
1172 #endif | 1164 #endif |
1173 } | 1165 } |
1174 | 1166 |
1175 DCHECK(transform_node->data.sublayer_scale == | 1167 DCHECK(transform_node->sublayer_scale == effect_node->sublayer_scale); |
1176 effect_node->data.sublayer_scale); | 1168 if (effect_node->sublayer_scale.x() != 0.0 && |
1177 if (effect_node->data.sublayer_scale.x() != 0.0 && | 1169 effect_node->sublayer_scale.y() != 0.0) |
1178 effect_node->data.sublayer_scale.y() != 0.0) | 1170 render_surface_transform.Scale(1.0 / effect_node->sublayer_scale.x(), |
1179 render_surface_transform.Scale(1.0 / effect_node->data.sublayer_scale.x(), | 1171 1.0 / effect_node->sublayer_scale.y()); |
1180 1.0 / effect_node->data.sublayer_scale.y()); | |
1181 render_surface->SetDrawTransform(render_surface_transform); | 1172 render_surface->SetDrawTransform(render_surface_transform); |
1182 } | 1173 } |
1183 | 1174 |
1184 static void SetSurfaceIsClipped(const ClipNode* clip_node, | 1175 static void SetSurfaceIsClipped(const ClipNode* clip_node, |
1185 RenderSurfaceImpl* render_surface) { | 1176 RenderSurfaceImpl* render_surface) { |
1186 DCHECK(render_surface->OwningLayerId() == clip_node->owner_id) | 1177 DCHECK(render_surface->OwningLayerId() == clip_node->owner_id) |
1187 << "we now create clip node for every render surface"; | 1178 << "we now create clip node for every render surface"; |
1188 | 1179 |
1189 render_surface->SetIsClipped(clip_node->data.target_is_clipped); | 1180 render_surface->SetIsClipped(clip_node->target_is_clipped); |
1190 } | 1181 } |
1191 | 1182 |
1192 static void SetSurfaceClipRect(const ClipNode* parent_clip_node, | 1183 static void SetSurfaceClipRect(const ClipNode* parent_clip_node, |
1193 const TransformTree& transform_tree, | 1184 const TransformTree& transform_tree, |
1194 RenderSurfaceImpl* render_surface) { | 1185 RenderSurfaceImpl* render_surface) { |
1195 if (!render_surface->is_clipped()) { | 1186 if (!render_surface->is_clipped()) { |
1196 render_surface->SetClipRect(gfx::Rect()); | 1187 render_surface->SetClipRect(gfx::Rect()); |
1197 return; | 1188 return; |
1198 } | 1189 } |
1199 | 1190 |
1200 const TransformNode* transform_node = | 1191 const TransformNode* transform_node = |
1201 transform_tree.Node(render_surface->TransformTreeIndex()); | 1192 transform_tree.Node(render_surface->TransformTreeIndex()); |
1202 if (transform_tree.TargetId(transform_node->id) == | 1193 if (transform_tree.TargetId(transform_node->id) == |
1203 parent_clip_node->data.target_id) { | 1194 parent_clip_node->target_id) { |
1204 render_surface->SetClipRect( | 1195 render_surface->SetClipRect( |
1205 gfx::ToEnclosingRect(parent_clip_node->data.clip_in_target_space)); | 1196 gfx::ToEnclosingRect(parent_clip_node->clip_in_target_space)); |
1206 return; | 1197 return; |
1207 } | 1198 } |
1208 | 1199 |
1209 // In this case, the clip child has reset the clip node for subtree and hence | 1200 // In this case, the clip child has reset the clip node for subtree and hence |
1210 // the parent clip node's clip rect is in clip parent's target space and not | 1201 // the parent clip node's clip rect is in clip parent's target space and not |
1211 // our target space. We need to transform it to our target space. | 1202 // our target space. We need to transform it to our target space. |
1212 gfx::Transform clip_parent_target_to_target; | 1203 gfx::Transform clip_parent_target_to_target; |
1213 const bool success = | 1204 const bool success = |
1214 transform_tree.ComputeTransformWithDestinationSublayerScale( | 1205 transform_tree.ComputeTransformWithDestinationSublayerScale( |
1215 parent_clip_node->data.target_id, | 1206 parent_clip_node->target_id, |
1216 transform_tree.TargetId(transform_node->id), | 1207 transform_tree.TargetId(transform_node->id), |
1217 &clip_parent_target_to_target); | 1208 &clip_parent_target_to_target); |
1218 | 1209 |
1219 if (!success) { | 1210 if (!success) { |
1220 render_surface->SetClipRect(gfx::Rect()); | 1211 render_surface->SetClipRect(gfx::Rect()); |
1221 return; | 1212 return; |
1222 } | 1213 } |
1223 | 1214 |
1224 DCHECK_LT(parent_clip_node->data.target_id, | 1215 DCHECK_LT(parent_clip_node->target_id, |
1225 transform_tree.TargetId(transform_node->id)); | 1216 transform_tree.TargetId(transform_node->id)); |
1226 render_surface->SetClipRect(gfx::ToEnclosingRect(MathUtil::ProjectClippedRect( | 1217 render_surface->SetClipRect(gfx::ToEnclosingRect(MathUtil::ProjectClippedRect( |
1227 clip_parent_target_to_target, | 1218 clip_parent_target_to_target, parent_clip_node->clip_in_target_space))); |
1228 parent_clip_node->data.clip_in_target_space))); | |
1229 } | 1219 } |
1230 | 1220 |
1231 template <typename LayerType> | 1221 template <typename LayerType> |
1232 static gfx::Transform ScreenSpaceTransformInternal(LayerType* layer, | 1222 static gfx::Transform ScreenSpaceTransformInternal(LayerType* layer, |
1233 const TransformTree& tree) { | 1223 const TransformTree& tree) { |
1234 gfx::Transform xform(1, 0, 0, 1, layer->offset_to_transform_parent().x(), | 1224 gfx::Transform xform(1, 0, 0, 1, layer->offset_to_transform_parent().x(), |
1235 layer->offset_to_transform_parent().y()); | 1225 layer->offset_to_transform_parent().y()); |
1236 gfx::Transform ssxform = tree.ToScreen(layer->transform_tree_index()); | 1226 gfx::Transform ssxform = tree.ToScreen(layer->transform_tree_index()); |
1237 xform.ConcatTransform(ssxform); | 1227 xform.ConcatTransform(ssxform); |
1238 if (layer->should_flatten_transform_from_property_tree()) | 1228 if (layer->should_flatten_transform_from_property_tree()) |
(...skipping 28 matching lines...) Expand all Loading... |
1267 } | 1257 } |
1268 return draw_opacity; | 1258 return draw_opacity; |
1269 } | 1259 } |
1270 | 1260 |
1271 static void SetSurfaceDrawOpacity(const EffectTree& tree, | 1261 static void SetSurfaceDrawOpacity(const EffectTree& tree, |
1272 RenderSurfaceImpl* render_surface) { | 1262 RenderSurfaceImpl* render_surface) { |
1273 // Draw opacity of a surface is the product of opacities between the surface | 1263 // Draw opacity of a surface is the product of opacities between the surface |
1274 // (included) and its target surface (excluded). | 1264 // (included) and its target surface (excluded). |
1275 const EffectNode* node = tree.Node(render_surface->EffectTreeIndex()); | 1265 const EffectNode* node = tree.Node(render_surface->EffectTreeIndex()); |
1276 float draw_opacity = tree.EffectiveOpacity(node); | 1266 float draw_opacity = tree.EffectiveOpacity(node); |
1277 for (node = tree.parent(node); node && !node->data.has_render_surface; | 1267 for (node = tree.parent(node); node && !node->has_render_surface; |
1278 node = tree.parent(node)) { | 1268 node = tree.parent(node)) { |
1279 draw_opacity *= tree.EffectiveOpacity(node); | 1269 draw_opacity *= tree.EffectiveOpacity(node); |
1280 } | 1270 } |
1281 render_surface->SetDrawOpacity(draw_opacity); | 1271 render_surface->SetDrawOpacity(draw_opacity); |
1282 } | 1272 } |
1283 | 1273 |
1284 static gfx::Rect LayerDrawableContentRect( | 1274 static gfx::Rect LayerDrawableContentRect( |
1285 const LayerImpl* layer, | 1275 const LayerImpl* layer, |
1286 const gfx::Rect& layer_bounds_in_target_space, | 1276 const gfx::Rect& layer_bounds_in_target_space, |
1287 const gfx::Rect& clip_rect) { | 1277 const gfx::Rect& clip_rect) { |
1288 if (layer->is_clipped()) | 1278 if (layer->is_clipped()) |
1289 return IntersectRects(layer_bounds_in_target_space, clip_rect); | 1279 return IntersectRects(layer_bounds_in_target_space, clip_rect); |
1290 | 1280 |
1291 return layer_bounds_in_target_space; | 1281 return layer_bounds_in_target_space; |
1292 } | 1282 } |
1293 | 1283 |
1294 static gfx::Transform ReplicaToSurfaceTransform( | 1284 static gfx::Transform ReplicaToSurfaceTransform( |
1295 const RenderSurfaceImpl* render_surface, | 1285 const RenderSurfaceImpl* render_surface, |
1296 const TransformTree& tree) { | 1286 const TransformTree& tree) { |
1297 gfx::Transform replica_to_surface; | 1287 gfx::Transform replica_to_surface; |
1298 if (!render_surface->HasReplica()) | 1288 if (!render_surface->HasReplica()) |
1299 return replica_to_surface; | 1289 return replica_to_surface; |
1300 const LayerImpl* replica_layer = render_surface->ReplicaLayer(); | 1290 const LayerImpl* replica_layer = render_surface->ReplicaLayer(); |
1301 const TransformNode* surface_transform_node = | 1291 const TransformNode* surface_transform_node = |
1302 tree.Node(render_surface->TransformTreeIndex()); | 1292 tree.Node(render_surface->TransformTreeIndex()); |
1303 replica_to_surface.Scale(surface_transform_node->data.sublayer_scale.x(), | 1293 replica_to_surface.Scale(surface_transform_node->sublayer_scale.x(), |
1304 surface_transform_node->data.sublayer_scale.y()); | 1294 surface_transform_node->sublayer_scale.y()); |
1305 replica_to_surface.Translate(replica_layer->offset_to_transform_parent().x(), | 1295 replica_to_surface.Translate(replica_layer->offset_to_transform_parent().x(), |
1306 replica_layer->offset_to_transform_parent().y()); | 1296 replica_layer->offset_to_transform_parent().y()); |
1307 gfx::Transform replica_transform_node_to_surface; | 1297 gfx::Transform replica_transform_node_to_surface; |
1308 tree.ComputeTransform(replica_layer->transform_tree_index(), | 1298 tree.ComputeTransform(replica_layer->transform_tree_index(), |
1309 render_surface->TransformTreeIndex(), | 1299 render_surface->TransformTreeIndex(), |
1310 &replica_transform_node_to_surface); | 1300 &replica_transform_node_to_surface); |
1311 replica_to_surface.PreconcatTransform(replica_transform_node_to_surface); | 1301 replica_to_surface.PreconcatTransform(replica_transform_node_to_surface); |
1312 if (surface_transform_node->data.sublayer_scale.x() != 0 && | 1302 if (surface_transform_node->sublayer_scale.x() != 0 && |
1313 surface_transform_node->data.sublayer_scale.y() != 0) { | 1303 surface_transform_node->sublayer_scale.y() != 0) { |
1314 replica_to_surface.Scale( | 1304 replica_to_surface.Scale(1.0 / surface_transform_node->sublayer_scale.x(), |
1315 1.0 / surface_transform_node->data.sublayer_scale.x(), | 1305 1.0 / surface_transform_node->sublayer_scale.y()); |
1316 1.0 / surface_transform_node->data.sublayer_scale.y()); | |
1317 } | 1306 } |
1318 return replica_to_surface; | 1307 return replica_to_surface; |
1319 } | 1308 } |
1320 | 1309 |
1321 void ComputeLayerDrawProperties(LayerImpl* layer, | 1310 void ComputeLayerDrawProperties(LayerImpl* layer, |
1322 const PropertyTrees* property_trees) { | 1311 const PropertyTrees* property_trees) { |
1323 const TransformNode* transform_node = | 1312 const TransformNode* transform_node = |
1324 property_trees->transform_tree.Node(layer->transform_tree_index()); | 1313 property_trees->transform_tree.Node(layer->transform_tree_index()); |
1325 const ClipNode* clip_node = | 1314 const ClipNode* clip_node = |
1326 property_trees->clip_tree.Node(layer->clip_tree_index()); | 1315 property_trees->clip_tree.Node(layer->clip_tree_index()); |
1327 | 1316 |
1328 layer->draw_properties().screen_space_transform = | 1317 layer->draw_properties().screen_space_transform = |
1329 ScreenSpaceTransformInternal(layer, property_trees->transform_tree); | 1318 ScreenSpaceTransformInternal(layer, property_trees->transform_tree); |
1330 if (property_trees->non_root_surfaces_enabled) { | 1319 if (property_trees->non_root_surfaces_enabled) { |
1331 layer->draw_properties().target_space_transform = | 1320 layer->draw_properties().target_space_transform = |
1332 DrawTransform(layer, property_trees->transform_tree); | 1321 DrawTransform(layer, property_trees->transform_tree); |
1333 } else { | 1322 } else { |
1334 layer->draw_properties().target_space_transform = | 1323 layer->draw_properties().target_space_transform = |
1335 layer->draw_properties().screen_space_transform; | 1324 layer->draw_properties().screen_space_transform; |
1336 } | 1325 } |
1337 layer->draw_properties().screen_space_transform_is_animating = | 1326 layer->draw_properties().screen_space_transform_is_animating = |
1338 transform_node->data.to_screen_is_potentially_animated; | 1327 transform_node->to_screen_is_potentially_animated; |
1339 | 1328 |
1340 layer->draw_properties().opacity = | 1329 layer->draw_properties().opacity = |
1341 LayerDrawOpacity(layer, property_trees->effect_tree); | 1330 LayerDrawOpacity(layer, property_trees->effect_tree); |
1342 if (property_trees->non_root_surfaces_enabled) { | 1331 if (property_trees->non_root_surfaces_enabled) { |
1343 layer->draw_properties().is_clipped = clip_node->data.layers_are_clipped; | 1332 layer->draw_properties().is_clipped = clip_node->layers_are_clipped; |
1344 } else { | 1333 } else { |
1345 layer->draw_properties().is_clipped = | 1334 layer->draw_properties().is_clipped = |
1346 clip_node->data.layers_are_clipped_when_surfaces_disabled; | 1335 clip_node->layers_are_clipped_when_surfaces_disabled; |
1347 } | 1336 } |
1348 | 1337 |
1349 gfx::Rect bounds_in_target_space = MathUtil::MapEnclosingClippedRect( | 1338 gfx::Rect bounds_in_target_space = MathUtil::MapEnclosingClippedRect( |
1350 layer->draw_properties().target_space_transform, | 1339 layer->draw_properties().target_space_transform, |
1351 gfx::Rect(layer->bounds())); | 1340 gfx::Rect(layer->bounds())); |
1352 layer->draw_properties().drawable_content_rect = LayerDrawableContentRect( | 1341 layer->draw_properties().drawable_content_rect = LayerDrawableContentRect( |
1353 layer, bounds_in_target_space, layer->draw_properties().clip_rect); | 1342 layer, bounds_in_target_space, layer->draw_properties().clip_rect); |
1354 } | 1343 } |
1355 | 1344 |
1356 void ComputeMaskDrawProperties(LayerImpl* mask_layer, | 1345 void ComputeMaskDrawProperties(LayerImpl* mask_layer, |
(...skipping 63 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1420 // TODO(enne): property trees can't ask the layer these things, but | 1409 // TODO(enne): property trees can't ask the layer these things, but |
1421 // the page scale layer should *just* be the page scale. | 1410 // the page scale layer should *just* be the page scale. |
1422 #if DCHECK_IS_ON() | 1411 #if DCHECK_IS_ON() |
1423 ValidatePageScaleLayer(page_scale_layer); | 1412 ValidatePageScaleLayer(page_scale_layer); |
1424 #endif | 1413 #endif |
1425 | 1414 |
1426 if (IsRootLayer(page_scale_layer)) { | 1415 if (IsRootLayer(page_scale_layer)) { |
1427 // When the page scale layer is also the root layer, the node should also | 1416 // When the page scale layer is also the root layer, the node should also |
1428 // store the combined scale factor and not just the page scale factor. | 1417 // store the combined scale factor and not just the page scale factor. |
1429 float post_local_scale_factor = page_scale_factor * device_scale_factor; | 1418 float post_local_scale_factor = page_scale_factor * device_scale_factor; |
1430 node->data.post_local_scale_factor = post_local_scale_factor; | 1419 node->post_local_scale_factor = post_local_scale_factor; |
1431 node->data.post_local = device_transform; | 1420 node->post_local = device_transform; |
1432 node->data.post_local.Scale(post_local_scale_factor, | 1421 node->post_local.Scale(post_local_scale_factor, post_local_scale_factor); |
1433 post_local_scale_factor); | |
1434 } else { | 1422 } else { |
1435 node->data.post_local_scale_factor = page_scale_factor; | 1423 node->post_local_scale_factor = page_scale_factor; |
1436 node->data.update_post_local_transform(gfx::PointF(), gfx::Point3F()); | 1424 node->update_post_local_transform(gfx::PointF(), gfx::Point3F()); |
1437 } | 1425 } |
1438 node->data.needs_local_transform_update = true; | 1426 node->needs_local_transform_update = true; |
1439 property_trees->transform_tree.set_needs_update(true); | 1427 property_trees->transform_tree.set_needs_update(true); |
1440 } | 1428 } |
1441 | 1429 |
1442 void UpdatePageScaleFactor(PropertyTrees* property_trees, | 1430 void UpdatePageScaleFactor(PropertyTrees* property_trees, |
1443 const LayerImpl* page_scale_layer, | 1431 const LayerImpl* page_scale_layer, |
1444 float page_scale_factor, | 1432 float page_scale_factor, |
1445 float device_scale_factor, | 1433 float device_scale_factor, |
1446 const gfx::Transform device_transform) { | 1434 const gfx::Transform device_transform) { |
1447 UpdatePageScaleFactorInternal(property_trees, page_scale_layer, | 1435 UpdatePageScaleFactorInternal(property_trees, page_scale_layer, |
1448 page_scale_factor, device_scale_factor, | 1436 page_scale_factor, device_scale_factor, |
(...skipping 15 matching lines...) Expand all Loading... |
1464 PropertyTrees* property_trees, | 1452 PropertyTrees* property_trees, |
1465 const LayerType* overscroll_elasticity_layer, | 1453 const LayerType* overscroll_elasticity_layer, |
1466 const gfx::Vector2dF& elastic_overscroll) { | 1454 const gfx::Vector2dF& elastic_overscroll) { |
1467 if (!overscroll_elasticity_layer) { | 1455 if (!overscroll_elasticity_layer) { |
1468 DCHECK(elastic_overscroll.IsZero()); | 1456 DCHECK(elastic_overscroll.IsZero()); |
1469 return; | 1457 return; |
1470 } | 1458 } |
1471 | 1459 |
1472 TransformNode* node = property_trees->transform_tree.Node( | 1460 TransformNode* node = property_trees->transform_tree.Node( |
1473 overscroll_elasticity_layer->transform_tree_index()); | 1461 overscroll_elasticity_layer->transform_tree_index()); |
1474 if (node->data.scroll_offset == gfx::ScrollOffset(elastic_overscroll)) | 1462 if (node->scroll_offset == gfx::ScrollOffset(elastic_overscroll)) |
1475 return; | 1463 return; |
1476 | 1464 |
1477 node->data.scroll_offset = gfx::ScrollOffset(elastic_overscroll); | 1465 node->scroll_offset = gfx::ScrollOffset(elastic_overscroll); |
1478 node->data.needs_local_transform_update = true; | 1466 node->needs_local_transform_update = true; |
1479 property_trees->transform_tree.set_needs_update(true); | 1467 property_trees->transform_tree.set_needs_update(true); |
1480 } | 1468 } |
1481 | 1469 |
1482 void UpdateElasticOverscroll(PropertyTrees* property_trees, | 1470 void UpdateElasticOverscroll(PropertyTrees* property_trees, |
1483 const LayerImpl* overscroll_elasticity_layer, | 1471 const LayerImpl* overscroll_elasticity_layer, |
1484 const gfx::Vector2dF& elastic_overscroll) { | 1472 const gfx::Vector2dF& elastic_overscroll) { |
1485 UpdateElasticOverscrollInternal(property_trees, overscroll_elasticity_layer, | 1473 UpdateElasticOverscrollInternal(property_trees, overscroll_elasticity_layer, |
1486 elastic_overscroll); | 1474 elastic_overscroll); |
1487 } | 1475 } |
1488 | 1476 |
1489 void UpdateElasticOverscroll(PropertyTrees* property_trees, | 1477 void UpdateElasticOverscroll(PropertyTrees* property_trees, |
1490 const Layer* overscroll_elasticity_layer, | 1478 const Layer* overscroll_elasticity_layer, |
1491 const gfx::Vector2dF& elastic_overscroll) { | 1479 const gfx::Vector2dF& elastic_overscroll) { |
1492 UpdateElasticOverscrollInternal(property_trees, overscroll_elasticity_layer, | 1480 UpdateElasticOverscrollInternal(property_trees, overscroll_elasticity_layer, |
1493 elastic_overscroll); | 1481 elastic_overscroll); |
1494 } | 1482 } |
1495 | 1483 |
1496 } // namespace draw_property_utils | 1484 } // namespace draw_property_utils |
1497 | 1485 |
1498 } // namespace cc | 1486 } // namespace cc |
OLD | NEW |