OLD | NEW |
1 // Copyright 2011 The Chromium Authors. All rights reserved. | 1 // Copyright 2011 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/layer_tree_impl.h" | 5 #include "cc/trees/layer_tree_impl.h" |
6 | 6 |
7 #include "base/debug/trace_event.h" | 7 #include "base/debug/trace_event.h" |
8 #include "cc/animation/keyframed_animation_curve.h" | 8 #include "cc/animation/keyframed_animation_curve.h" |
9 #include "cc/animation/scrollbar_animation_controller.h" | 9 #include "cc/animation/scrollbar_animation_controller.h" |
10 #include "cc/base/math_util.h" | 10 #include "cc/base/math_util.h" |
11 #include "cc/base/util.h" | 11 #include "cc/base/util.h" |
12 #include "cc/debug/traced_value.h" | 12 #include "cc/debug/traced_value.h" |
13 #include "cc/layers/heads_up_display_layer_impl.h" | 13 #include "cc/layers/heads_up_display_layer_impl.h" |
14 #include "cc/layers/layer.h" | 14 #include "cc/layers/layer.h" |
15 #include "cc/layers/render_surface_impl.h" | 15 #include "cc/layers/render_surface_impl.h" |
16 #include "cc/layers/scrollbar_layer_impl_base.h" | 16 #include "cc/layers/scrollbar_layer_impl_base.h" |
17 #include "cc/resources/ui_resource_request.h" | 17 #include "cc/resources/ui_resource_request.h" |
18 #include "cc/trees/layer_tree_host_common.h" | 18 #include "cc/trees/layer_tree_host_common.h" |
19 #include "cc/trees/layer_tree_host_impl.h" | 19 #include "cc/trees/layer_tree_host_impl.h" |
20 #include "ui/gfx/size_conversions.h" | 20 #include "ui/gfx/size_conversions.h" |
21 #include "ui/gfx/vector2d_conversions.h" | 21 #include "ui/gfx/vector2d_conversions.h" |
22 | 22 |
23 namespace cc { | 23 namespace cc { |
24 | 24 |
25 // This class exists to split the LayerScrollOffsetDelegate between the | |
26 // InnerViewportScrollLayer and the OuterViewportScrollLayer in a manner | |
27 // that never requires the embedder or LayerImpl to know about. | |
28 class LayerScrollOffsetDelegateProxy : public LayerScrollOffsetDelegate { | |
29 public: | |
30 LayerScrollOffsetDelegateProxy(LayerImpl* layer, | |
31 LayerScrollOffsetDelegate* delegate, | |
32 LayerTreeImpl* layer_tree) | |
33 : layer_(layer), | |
34 delegate_(delegate), | |
35 layer_tree_impl_(layer_tree) {} | |
36 | |
37 gfx::Vector2dF last_set_scroll_offset() const { | |
38 return last_set_scroll_offset_; | |
39 } | |
40 | |
41 // LayerScrollOffsetDelegate implementation. | |
42 | |
43 virtual void SetTotalScrollOffset(const gfx::Vector2dF& new_offset) OVERRIDE { | |
44 last_set_scroll_offset_ = new_offset; | |
45 layer_tree_impl_->UpdateScrollOffsetDelegate(); | |
46 } | |
47 | |
48 virtual gfx::Vector2dF GetTotalScrollOffset() OVERRIDE { | |
49 return layer_tree_impl_->GetDelegatedScrollOffset(layer_); | |
50 } | |
51 | |
52 virtual bool IsExternalFlingActive() const OVERRIDE { | |
53 return delegate_->IsExternalFlingActive(); | |
54 } | |
55 | |
56 // Functions below this point are never called by LayerImpl on its | |
57 // LayerScrollOffsetDelegate, and so are not implemented. | |
58 virtual void SetMaxScrollOffset(const gfx::Vector2dF&) OVERRIDE { | |
59 NOTIMPLEMENTED(); | |
60 } | |
61 | |
62 virtual void SetTotalPageScaleFactor(float scale) OVERRIDE { | |
63 NOTIMPLEMENTED(); | |
64 } | |
65 | |
66 virtual void SetScrollableSize(const gfx::SizeF& scrollable_size) OVERRIDE { | |
67 NOTIMPLEMENTED(); | |
68 } | |
69 | |
70 private: | |
71 LayerImpl* layer_; | |
72 LayerScrollOffsetDelegate* delegate_; | |
73 LayerTreeImpl* layer_tree_impl_; | |
74 gfx::Vector2dF last_set_scroll_offset_; | |
75 }; | |
76 | |
77 LayerTreeImpl::LayerTreeImpl(LayerTreeHostImpl* layer_tree_host_impl) | 25 LayerTreeImpl::LayerTreeImpl(LayerTreeHostImpl* layer_tree_host_impl) |
78 : layer_tree_host_impl_(layer_tree_host_impl), | 26 : layer_tree_host_impl_(layer_tree_host_impl), |
79 source_frame_number_(-1), | 27 source_frame_number_(-1), |
80 hud_layer_(0), | 28 hud_layer_(0), |
| 29 root_scroll_layer_(NULL), |
81 currently_scrolling_layer_(NULL), | 30 currently_scrolling_layer_(NULL), |
82 root_layer_scroll_offset_delegate_(NULL), | 31 root_layer_scroll_offset_delegate_(NULL), |
83 background_color_(0), | 32 background_color_(0), |
84 has_transparent_background_(false), | 33 has_transparent_background_(false), |
85 page_scale_layer_(NULL), | 34 page_scale_layer_(NULL), |
86 inner_viewport_scroll_layer_(NULL), | 35 inner_viewport_scroll_layer_(NULL), |
87 outer_viewport_scroll_layer_(NULL), | 36 outer_viewport_scroll_layer_(NULL), |
88 page_scale_factor_(1), | 37 page_scale_factor_(1), |
89 page_scale_delta_(1), | 38 page_scale_delta_(1), |
90 sent_page_scale_delta_(1), | 39 sent_page_scale_delta_(1), |
91 min_page_scale_factor_(0), | 40 min_page_scale_factor_(0), |
92 max_page_scale_factor_(0), | 41 max_page_scale_factor_(0), |
93 scrolling_layer_id_from_previous_tree_(0), | 42 scrolling_layer_id_from_previous_tree_(0), |
94 contents_textures_purged_(false), | 43 contents_textures_purged_(false), |
95 viewport_size_invalid_(false), | 44 viewport_size_invalid_(false), |
96 needs_update_draw_properties_(true), | 45 needs_update_draw_properties_(true), |
97 needs_full_tree_sync_(true), | 46 needs_full_tree_sync_(true), |
98 next_activation_forces_redraw_(false) { | 47 next_activation_forces_redraw_(false) { |
99 } | 48 } |
100 | 49 |
101 LayerTreeImpl::~LayerTreeImpl() { | 50 LayerTreeImpl::~LayerTreeImpl() { |
102 // Need to explicitly clear the tree prior to destroying this so that | 51 // Need to explicitly clear the tree prior to destroying this so that |
103 // the LayerTreeImpl pointer is still valid in the LayerImpl dtor. | 52 // the LayerTreeImpl pointer is still valid in the LayerImpl dtor. |
104 root_layer_.reset(); | 53 root_layer_.reset(); |
105 } | 54 } |
106 | 55 |
| 56 static LayerImpl* FindRootScrollLayerRecursive(LayerImpl* layer) { |
| 57 if (!layer) |
| 58 return NULL; |
| 59 |
| 60 if (layer->scrollable()) |
| 61 return layer; |
| 62 |
| 63 for (size_t i = 0; i < layer->children().size(); ++i) { |
| 64 LayerImpl* found = FindRootScrollLayerRecursive(layer->children()[i]); |
| 65 if (found) |
| 66 return found; |
| 67 } |
| 68 |
| 69 return NULL; |
| 70 } |
| 71 |
107 void LayerTreeImpl::SetRootLayer(scoped_ptr<LayerImpl> layer) { | 72 void LayerTreeImpl::SetRootLayer(scoped_ptr<LayerImpl> layer) { |
108 if (inner_viewport_scroll_layer_) | 73 if (root_scroll_layer_) |
109 inner_viewport_scroll_layer_->SetScrollOffsetDelegate(NULL); | 74 root_scroll_layer_->SetScrollOffsetDelegate(NULL); |
110 if (outer_viewport_scroll_layer_) | |
111 outer_viewport_scroll_layer_->SetScrollOffsetDelegate(NULL); | |
112 inner_viewport_scroll_delegate_proxy_.reset(); | |
113 outer_viewport_scroll_delegate_proxy_.reset(); | |
114 | |
115 root_layer_ = layer.Pass(); | 75 root_layer_ = layer.Pass(); |
116 currently_scrolling_layer_ = NULL; | 76 currently_scrolling_layer_ = NULL; |
117 inner_viewport_scroll_layer_ = NULL; | 77 root_scroll_layer_ = NULL; |
118 outer_viewport_scroll_layer_ = NULL; | |
119 page_scale_layer_ = NULL; | |
120 | 78 |
121 layer_tree_host_impl_->OnCanDrawStateChangedForTree(); | 79 layer_tree_host_impl_->OnCanDrawStateChangedForTree(); |
122 } | 80 } |
123 | 81 |
124 LayerImpl* LayerTreeImpl::InnerViewportScrollLayer() const { | 82 void LayerTreeImpl::FindRootScrollLayer() { |
125 return inner_viewport_scroll_layer_; | 83 root_scroll_layer_ = FindRootScrollLayerRecursive(root_layer_.get()); |
126 } | |
127 | 84 |
128 LayerImpl* LayerTreeImpl::OuterViewportScrollLayer() const { | 85 if (root_scroll_layer_) { |
129 return outer_viewport_scroll_layer_; | 86 UpdateMaxScrollOffset(); |
130 } | 87 root_scroll_layer_->SetScrollOffsetDelegate( |
| 88 root_layer_scroll_offset_delegate_); |
| 89 } |
131 | 90 |
132 gfx::Vector2dF LayerTreeImpl::TotalScrollOffset() const { | 91 if (scrolling_layer_id_from_previous_tree_) { |
133 gfx::Vector2dF offset; | 92 currently_scrolling_layer_ = LayerTreeHostCommon::FindLayerInSubtree( |
| 93 root_layer_.get(), |
| 94 scrolling_layer_id_from_previous_tree_); |
| 95 } |
134 | 96 |
135 if (inner_viewport_scroll_layer_) | 97 scrolling_layer_id_from_previous_tree_ = 0; |
136 offset += inner_viewport_scroll_layer_->TotalScrollOffset(); | |
137 | |
138 if (outer_viewport_scroll_layer_) | |
139 offset += outer_viewport_scroll_layer_->TotalScrollOffset(); | |
140 | |
141 return offset; | |
142 } | |
143 | |
144 gfx::Vector2dF LayerTreeImpl::TotalMaxScrollOffset() const { | |
145 gfx::Vector2dF offset; | |
146 | |
147 if (inner_viewport_scroll_layer_) | |
148 offset += inner_viewport_scroll_layer_->MaxScrollOffset(); | |
149 | |
150 if (outer_viewport_scroll_layer_) | |
151 offset += outer_viewport_scroll_layer_->MaxScrollOffset(); | |
152 | |
153 return offset; | |
154 } | |
155 gfx::Vector2dF LayerTreeImpl::TotalScrollDelta() const { | |
156 DCHECK(inner_viewport_scroll_layer_); | |
157 gfx::Vector2dF delta = inner_viewport_scroll_layer_->ScrollDelta(); | |
158 | |
159 if (outer_viewport_scroll_layer_) | |
160 delta += outer_viewport_scroll_layer_->ScrollDelta(); | |
161 | |
162 return delta; | |
163 } | 98 } |
164 | 99 |
165 scoped_ptr<LayerImpl> LayerTreeImpl::DetachLayerTree() { | 100 scoped_ptr<LayerImpl> LayerTreeImpl::DetachLayerTree() { |
166 // Clear all data structures that have direct references to the layer tree. | 101 // Clear all data structures that have direct references to the layer tree. |
167 scrolling_layer_id_from_previous_tree_ = | 102 scrolling_layer_id_from_previous_tree_ = |
168 currently_scrolling_layer_ ? currently_scrolling_layer_->id() : 0; | 103 currently_scrolling_layer_ ? currently_scrolling_layer_->id() : 0; |
169 if (inner_viewport_scroll_layer_) | 104 if (root_scroll_layer_) |
170 inner_viewport_scroll_layer_->SetScrollOffsetDelegate(NULL); | 105 root_scroll_layer_->SetScrollOffsetDelegate(NULL); |
171 if (outer_viewport_scroll_layer_) | 106 root_scroll_layer_ = NULL; |
172 outer_viewport_scroll_layer_->SetScrollOffsetDelegate(NULL); | |
173 inner_viewport_scroll_delegate_proxy_.reset(); | |
174 outer_viewport_scroll_delegate_proxy_.reset(); | |
175 inner_viewport_scroll_layer_ = NULL; | |
176 outer_viewport_scroll_layer_ = NULL; | |
177 page_scale_layer_ = NULL; | |
178 currently_scrolling_layer_ = NULL; | 107 currently_scrolling_layer_ = NULL; |
179 | 108 |
180 render_surface_layer_list_.clear(); | 109 render_surface_layer_list_.clear(); |
181 set_needs_update_draw_properties(); | 110 set_needs_update_draw_properties(); |
182 return root_layer_.Pass(); | 111 return root_layer_.Pass(); |
183 } | 112 } |
184 | 113 |
185 void LayerTreeImpl::PushPropertiesTo(LayerTreeImpl* target_tree) { | 114 void LayerTreeImpl::PushPropertiesTo(LayerTreeImpl* target_tree) { |
186 // The request queue should have been processed and does not require a push. | 115 // The request queue should have been processed and does not require a push. |
187 DCHECK_EQ(ui_resource_request_queue_.size(), 0u); | 116 DCHECK_EQ(ui_resource_request_queue_.size(), 0u); |
188 | 117 |
189 if (next_activation_forces_redraw_) { | 118 if (next_activation_forces_redraw_) { |
190 layer_tree_host_impl_->SetFullRootLayerDamage(); | 119 layer_tree_host_impl_->SetFullRootLayerDamage(); |
191 next_activation_forces_redraw_ = false; | 120 next_activation_forces_redraw_ = false; |
192 } | 121 } |
193 | 122 |
194 target_tree->PassSwapPromises(&swap_promise_list_); | 123 target_tree->PassSwapPromises(&swap_promise_list_); |
195 | 124 |
196 target_tree->SetPageScaleFactorAndLimits( | 125 target_tree->SetPageScaleFactorAndLimits( |
197 page_scale_factor(), min_page_scale_factor(), max_page_scale_factor()); | 126 page_scale_factor(), min_page_scale_factor(), max_page_scale_factor()); |
198 target_tree->SetPageScaleDelta( | 127 target_tree->SetPageScaleDelta( |
199 target_tree->page_scale_delta() / target_tree->sent_page_scale_delta()); | 128 target_tree->page_scale_delta() / target_tree->sent_page_scale_delta()); |
200 target_tree->set_sent_page_scale_delta(1); | 129 target_tree->set_sent_page_scale_delta(1); |
201 | 130 |
202 if (page_scale_layer_ && inner_viewport_scroll_layer_) { | 131 if (settings().use_pinch_virtual_viewport) { |
203 target_tree->SetViewportLayersFromIds( | 132 target_tree->SetViewportLayersFromIds( |
204 page_scale_layer_->id(), | 133 page_scale_layer_->id(), |
205 inner_viewport_scroll_layer_->id(), | 134 inner_viewport_scroll_layer_->id(), |
206 outer_viewport_scroll_layer_ ? outer_viewport_scroll_layer_->id() | 135 outer_viewport_scroll_layer_ ? outer_viewport_scroll_layer_->id() |
207 : Layer::INVALID_ID); | 136 : Layer::INVALID_ID); |
208 } else { | |
209 target_tree->ClearViewportLayers(); | |
210 } | 137 } |
211 // This should match the property synchronization in | 138 // This should match the property synchronization in |
212 // LayerTreeHost::finishCommitOnImplThread(). | 139 // LayerTreeHost::finishCommitOnImplThread(). |
213 target_tree->set_source_frame_number(source_frame_number()); | 140 target_tree->set_source_frame_number(source_frame_number()); |
214 target_tree->set_background_color(background_color()); | 141 target_tree->set_background_color(background_color()); |
215 target_tree->set_has_transparent_background(has_transparent_background()); | 142 target_tree->set_has_transparent_background(has_transparent_background()); |
216 | 143 |
217 if (ContentsTexturesPurged()) | 144 if (ContentsTexturesPurged()) |
218 target_tree->SetContentsTexturesPurged(); | 145 target_tree->SetContentsTexturesPurged(); |
219 else | 146 else |
220 target_tree->ResetContentsTexturesPurged(); | 147 target_tree->ResetContentsTexturesPurged(); |
221 | 148 |
222 if (ViewportSizeInvalid()) | 149 if (ViewportSizeInvalid()) |
223 target_tree->SetViewportSizeInvalid(); | 150 target_tree->SetViewportSizeInvalid(); |
224 else | 151 else |
225 target_tree->ResetViewportSizeInvalid(); | 152 target_tree->ResetViewportSizeInvalid(); |
226 | 153 |
227 if (hud_layer()) | 154 if (hud_layer()) |
228 target_tree->set_hud_layer(static_cast<HeadsUpDisplayLayerImpl*>( | 155 target_tree->set_hud_layer(static_cast<HeadsUpDisplayLayerImpl*>( |
229 LayerTreeHostCommon::FindLayerInSubtree( | 156 LayerTreeHostCommon::FindLayerInSubtree( |
230 target_tree->root_layer(), hud_layer()->id()))); | 157 target_tree->root_layer(), hud_layer()->id()))); |
231 else | 158 else |
232 target_tree->set_hud_layer(NULL); | 159 target_tree->set_hud_layer(NULL); |
233 } | 160 } |
234 | 161 |
| 162 LayerImpl* LayerTreeImpl::RootScrollLayer() const { |
| 163 return root_scroll_layer_; |
| 164 } |
| 165 |
235 LayerImpl* LayerTreeImpl::RootContainerLayer() const { | 166 LayerImpl* LayerTreeImpl::RootContainerLayer() const { |
236 return inner_viewport_scroll_layer_ ? inner_viewport_scroll_layer_->parent() | 167 return root_scroll_layer_ ? root_scroll_layer_->parent() : NULL; |
237 : NULL; | |
238 } | 168 } |
239 | 169 |
240 LayerImpl* LayerTreeImpl::CurrentlyScrollingLayer() const { | 170 LayerImpl* LayerTreeImpl::CurrentlyScrollingLayer() const { |
241 DCHECK(IsActiveTree()); | 171 DCHECK(IsActiveTree()); |
242 return currently_scrolling_layer_; | 172 return currently_scrolling_layer_; |
243 } | 173 } |
244 | 174 |
245 void LayerTreeImpl::SetCurrentlyScrollingLayer(LayerImpl* layer) { | 175 void LayerTreeImpl::SetCurrentlyScrollingLayer(LayerImpl* layer) { |
246 if (currently_scrolling_layer_ == layer) | 176 if (currently_scrolling_layer_ == layer) |
247 return; | 177 return; |
248 | 178 |
249 if (currently_scrolling_layer_ && | 179 if (currently_scrolling_layer_ && |
250 currently_scrolling_layer_->scrollbar_animation_controller()) | 180 currently_scrolling_layer_->scrollbar_animation_controller()) |
251 currently_scrolling_layer_->scrollbar_animation_controller()-> | 181 currently_scrolling_layer_->scrollbar_animation_controller()-> |
252 DidScrollGestureEnd(CurrentPhysicalTimeTicks()); | 182 DidScrollGestureEnd(CurrentPhysicalTimeTicks()); |
253 currently_scrolling_layer_ = layer; | 183 currently_scrolling_layer_ = layer; |
254 if (layer && layer->scrollbar_animation_controller()) | 184 if (layer && layer->scrollbar_animation_controller()) |
255 layer->scrollbar_animation_controller()->DidScrollGestureBegin(); | 185 layer->scrollbar_animation_controller()->DidScrollGestureBegin(); |
256 } | 186 } |
257 | 187 |
258 void LayerTreeImpl::ClearCurrentlyScrollingLayer() { | 188 void LayerTreeImpl::ClearCurrentlyScrollingLayer() { |
259 SetCurrentlyScrollingLayer(NULL); | 189 SetCurrentlyScrollingLayer(NULL); |
260 scrolling_layer_id_from_previous_tree_ = 0; | 190 scrolling_layer_id_from_previous_tree_ = 0; |
261 } | 191 } |
262 | 192 |
263 float LayerTreeImpl::VerticalAdjust(const LayerImpl* layer) const { | |
264 DCHECK(layer); | |
265 if (layer->parent() != RootContainerLayer()) | |
266 return 0.f; | |
267 | |
268 return layer_tree_host_impl_->UnscaledScrollableViewportSize().height() - | |
269 RootContainerLayer()->bounds().height(); | |
270 } | |
271 | |
272 namespace { | |
273 | |
274 void ForceScrollbarParameterUpdateAfterScaleChange(LayerImpl* current_layer) { | |
275 if (!current_layer) | |
276 return; | |
277 | |
278 while (current_layer) { | |
279 current_layer->ScrollbarParametersDidChange(); | |
280 current_layer = current_layer->parent(); | |
281 } | |
282 } | |
283 | |
284 } // namespace | |
285 | |
286 void LayerTreeImpl::SetPageScaleFactorAndLimits(float page_scale_factor, | 193 void LayerTreeImpl::SetPageScaleFactorAndLimits(float page_scale_factor, |
287 float min_page_scale_factor, float max_page_scale_factor) { | 194 float min_page_scale_factor, float max_page_scale_factor) { |
288 if (!page_scale_factor) | 195 if (!page_scale_factor) |
289 return; | 196 return; |
290 | 197 |
291 min_page_scale_factor_ = min_page_scale_factor; | 198 min_page_scale_factor_ = min_page_scale_factor; |
292 max_page_scale_factor_ = max_page_scale_factor; | 199 max_page_scale_factor_ = max_page_scale_factor; |
293 page_scale_factor_ = page_scale_factor; | 200 page_scale_factor_ = page_scale_factor; |
294 | 201 |
295 if (root_layer_scroll_offset_delegate_) { | 202 if (root_layer_scroll_offset_delegate_) { |
296 root_layer_scroll_offset_delegate_->SetTotalPageScaleFactor( | 203 root_layer_scroll_offset_delegate_->SetTotalPageScaleFactor( |
297 total_page_scale_factor()); | 204 total_page_scale_factor()); |
298 } | 205 } |
299 | |
300 ForceScrollbarParameterUpdateAfterScaleChange(page_scale_layer()); | |
301 } | 206 } |
302 | 207 |
303 void LayerTreeImpl::SetPageScaleDelta(float delta) { | 208 void LayerTreeImpl::SetPageScaleDelta(float delta) { |
304 // Clamp to the current min/max limits. | 209 // Clamp to the current min/max limits. |
305 float total = page_scale_factor_ * delta; | 210 float total = page_scale_factor_ * delta; |
306 if (min_page_scale_factor_ && total < min_page_scale_factor_) | 211 if (min_page_scale_factor_ && total < min_page_scale_factor_) |
307 delta = min_page_scale_factor_ / page_scale_factor_; | 212 delta = min_page_scale_factor_ / page_scale_factor_; |
308 else if (max_page_scale_factor_ && total > max_page_scale_factor_) | 213 else if (max_page_scale_factor_ && total > max_page_scale_factor_) |
309 delta = max_page_scale_factor_ / page_scale_factor_; | 214 delta = max_page_scale_factor_ / page_scale_factor_; |
310 | 215 |
311 if (delta == page_scale_delta_) | 216 if (delta == page_scale_delta_) |
312 return; | 217 return; |
313 | 218 |
314 page_scale_delta_ = delta; | 219 page_scale_delta_ = delta; |
315 | 220 |
316 if (IsActiveTree()) { | 221 if (IsActiveTree()) { |
317 LayerTreeImpl* pending_tree = layer_tree_host_impl_->pending_tree(); | 222 LayerTreeImpl* pending_tree = layer_tree_host_impl_->pending_tree(); |
318 if (pending_tree) { | 223 if (pending_tree) { |
319 DCHECK_EQ(1, pending_tree->sent_page_scale_delta()); | 224 DCHECK_EQ(1, pending_tree->sent_page_scale_delta()); |
320 pending_tree->SetPageScaleDelta( | 225 pending_tree->SetPageScaleDelta( |
321 page_scale_delta_ / sent_page_scale_delta_); | 226 page_scale_delta_ / sent_page_scale_delta_); |
322 } | 227 } |
323 } | 228 } |
324 | 229 |
| 230 UpdateMaxScrollOffset(); |
325 set_needs_update_draw_properties(); | 231 set_needs_update_draw_properties(); |
326 | 232 |
327 if (root_layer_scroll_offset_delegate_) { | 233 if (root_layer_scroll_offset_delegate_) { |
328 root_layer_scroll_offset_delegate_->SetTotalPageScaleFactor( | 234 root_layer_scroll_offset_delegate_->SetTotalPageScaleFactor( |
329 total_page_scale_factor()); | 235 total_page_scale_factor()); |
330 } | 236 } |
331 } | 237 } |
332 | 238 |
333 gfx::SizeF LayerTreeImpl::ScrollableViewportSize() const { | 239 gfx::SizeF LayerTreeImpl::ScrollableViewportSize() const { |
334 if (outer_viewport_scroll_layer_) | 240 return gfx::ScaleSize(layer_tree_host_impl_->UnscaledScrollableViewportSize(), |
335 return layer_tree_host_impl_->UnscaledScrollableViewportSize(); | 241 1.0f / total_page_scale_factor()); |
336 else | |
337 return gfx::ScaleSize( | |
338 layer_tree_host_impl_->UnscaledScrollableViewportSize(), | |
339 1.0f / total_page_scale_factor()); | |
340 } | 242 } |
341 | 243 |
342 gfx::Rect LayerTreeImpl::RootScrollLayerDeviceViewportBounds() const { | 244 gfx::Rect LayerTreeImpl::RootScrollLayerDeviceViewportBounds() const { |
343 LayerImpl* root_scroll_layer = | 245 if (!root_scroll_layer_ || root_scroll_layer_->children().empty()) |
344 OuterViewportScrollLayer() ? OuterViewportScrollLayer() | |
345 : InnerViewportScrollLayer(); | |
346 if (!root_scroll_layer || root_scroll_layer->children().empty()) | |
347 return gfx::Rect(); | 246 return gfx::Rect(); |
348 LayerImpl* layer = root_scroll_layer->children()[0]; | 247 LayerImpl* layer = root_scroll_layer_->children()[0]; |
349 return MathUtil::MapClippedRect( | 248 return MathUtil::MapClippedRect( |
350 layer->screen_space_transform(), | 249 layer->screen_space_transform(), |
351 gfx::Rect(layer->content_bounds())); | 250 gfx::Rect(layer->content_bounds())); |
352 } | 251 } |
353 | 252 |
| 253 void LayerTreeImpl::UpdateMaxScrollOffset() { |
| 254 LayerImpl* root_scroll = RootScrollLayer(); |
| 255 if (!root_scroll || !root_scroll->children().size()) |
| 256 return; |
| 257 |
| 258 gfx::Vector2dF max_scroll = gfx::Rect(ScrollableSize()).bottom_right() - |
| 259 gfx::RectF(ScrollableViewportSize()).bottom_right(); |
| 260 |
| 261 // The viewport may be larger than the contents in some cases, such as |
| 262 // having a vertical scrollbar but no horizontal overflow. |
| 263 max_scroll.SetToMax(gfx::Vector2dF()); |
| 264 |
| 265 root_scroll_layer_->SetMaxScrollOffset(gfx::ToFlooredVector2d(max_scroll)); |
| 266 } |
| 267 |
354 static void ApplySentScrollDeltasFromAbortedCommitTo(LayerImpl* layer) { | 268 static void ApplySentScrollDeltasFromAbortedCommitTo(LayerImpl* layer) { |
355 layer->ApplySentScrollDeltasFromAbortedCommit(); | 269 layer->ApplySentScrollDeltasFromAbortedCommit(); |
356 } | 270 } |
357 | 271 |
358 void LayerTreeImpl::ApplySentScrollAndScaleDeltasFromAbortedCommit() { | 272 void LayerTreeImpl::ApplySentScrollAndScaleDeltasFromAbortedCommit() { |
359 DCHECK(IsActiveTree()); | 273 DCHECK(IsActiveTree()); |
360 | 274 |
361 page_scale_factor_ *= sent_page_scale_delta_; | 275 page_scale_factor_ *= sent_page_scale_delta_; |
362 page_scale_delta_ /= sent_page_scale_delta_; | 276 page_scale_delta_ /= sent_page_scale_delta_; |
363 sent_page_scale_delta_ = 1.f; | 277 sent_page_scale_delta_ = 1.f; |
(...skipping 26 matching lines...) Expand all Loading... |
390 DCHECK(page_scale_layer_); | 304 DCHECK(page_scale_layer_); |
391 | 305 |
392 inner_viewport_scroll_layer_ = | 306 inner_viewport_scroll_layer_ = |
393 LayerById(inner_viewport_scroll_layer_id); | 307 LayerById(inner_viewport_scroll_layer_id); |
394 DCHECK(inner_viewport_scroll_layer_); | 308 DCHECK(inner_viewport_scroll_layer_); |
395 | 309 |
396 outer_viewport_scroll_layer_ = | 310 outer_viewport_scroll_layer_ = |
397 LayerById(outer_viewport_scroll_layer_id); | 311 LayerById(outer_viewport_scroll_layer_id); |
398 DCHECK(outer_viewport_scroll_layer_ || | 312 DCHECK(outer_viewport_scroll_layer_ || |
399 outer_viewport_scroll_layer_id == Layer::INVALID_ID); | 313 outer_viewport_scroll_layer_id == Layer::INVALID_ID); |
400 | |
401 if (!root_layer_scroll_offset_delegate_) | |
402 return; | |
403 | |
404 inner_viewport_scroll_delegate_proxy_ = make_scoped_ptr( | |
405 new LayerScrollOffsetDelegateProxy(inner_viewport_scroll_layer_, | |
406 root_layer_scroll_offset_delegate_, | |
407 this)); | |
408 | |
409 if (outer_viewport_scroll_layer_) | |
410 outer_viewport_scroll_delegate_proxy_ = make_scoped_ptr( | |
411 new LayerScrollOffsetDelegateProxy(outer_viewport_scroll_layer_, | |
412 root_layer_scroll_offset_delegate_, | |
413 this)); | |
414 } | 314 } |
415 | 315 |
416 void LayerTreeImpl::ClearViewportLayers() { | 316 void LayerTreeImpl::ClearViewportLayers() { |
417 page_scale_layer_ = NULL; | 317 page_scale_layer_ = NULL; |
418 inner_viewport_scroll_layer_ = NULL; | 318 inner_viewport_scroll_layer_ = NULL; |
419 outer_viewport_scroll_layer_ = NULL; | 319 outer_viewport_scroll_layer_ = NULL; |
420 } | 320 } |
421 | 321 |
| 322 // TODO(wjmaclean) This needs to go away, and be replaced with a single core |
| 323 // of login that works for both scrollbar layer types. This is already planned |
| 324 // as part of the larger pinch-zoom re-factoring viewport. |
| 325 void LayerTreeImpl::UpdateSolidColorScrollbars() { |
| 326 LayerImpl* root_scroll = RootScrollLayer(); |
| 327 DCHECK(root_scroll); |
| 328 DCHECK(IsActiveTree()); |
| 329 |
| 330 gfx::RectF scrollable_viewport( |
| 331 gfx::PointAtOffsetFromOrigin(root_scroll->TotalScrollOffset()), |
| 332 ScrollableViewportSize()); |
| 333 float vertical_adjust = 0.0f; |
| 334 if (RootContainerLayer()) |
| 335 vertical_adjust = |
| 336 layer_tree_host_impl_->UnscaledScrollableViewportSize().height() - |
| 337 RootContainerLayer()->bounds().height(); |
| 338 if (ScrollbarLayerImplBase* horiz = |
| 339 root_scroll->horizontal_scrollbar_layer()) { |
| 340 horiz->SetVerticalAdjust(vertical_adjust); |
| 341 horiz->SetVisibleToTotalLengthRatio( |
| 342 scrollable_viewport.width() / ScrollableSize().width()); |
| 343 } |
| 344 if (ScrollbarLayerImplBase* vertical = |
| 345 root_scroll->vertical_scrollbar_layer()) { |
| 346 vertical->SetVerticalAdjust(vertical_adjust); |
| 347 vertical->SetVisibleToTotalLengthRatio( |
| 348 scrollable_viewport.height() / ScrollableSize().height()); |
| 349 } |
| 350 } |
| 351 |
422 void LayerTreeImpl::UpdateDrawProperties() { | 352 void LayerTreeImpl::UpdateDrawProperties() { |
| 353 if (IsActiveTree() && RootScrollLayer() && RootContainerLayer()) |
| 354 UpdateRootScrollLayerSizeDelta(); |
| 355 |
423 if (IsActiveTree() && RootContainerLayer()) | 356 if (IsActiveTree() && RootContainerLayer()) |
424 UpdateRootScrollLayerSizeDelta(); | 357 UpdateSolidColorScrollbars(); |
425 | 358 |
426 needs_update_draw_properties_ = false; | 359 needs_update_draw_properties_ = false; |
427 render_surface_layer_list_.clear(); | 360 render_surface_layer_list_.clear(); |
428 | 361 |
429 // For max_texture_size. | 362 // For max_texture_size. |
430 if (!layer_tree_host_impl_->renderer()) | 363 if (!layer_tree_host_impl_->renderer()) |
431 return; | 364 return; |
432 | 365 |
433 if (!root_layer()) | 366 if (!root_layer()) |
434 return; | 367 return; |
(...skipping 59 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
494 "CalcDrawProperties should not set_needs_update_draw_properties()"; | 427 "CalcDrawProperties should not set_needs_update_draw_properties()"; |
495 } | 428 } |
496 | 429 |
497 const LayerImplList& LayerTreeImpl::RenderSurfaceLayerList() const { | 430 const LayerImplList& LayerTreeImpl::RenderSurfaceLayerList() const { |
498 // If this assert triggers, then the list is dirty. | 431 // If this assert triggers, then the list is dirty. |
499 DCHECK(!needs_update_draw_properties_); | 432 DCHECK(!needs_update_draw_properties_); |
500 return render_surface_layer_list_; | 433 return render_surface_layer_list_; |
501 } | 434 } |
502 | 435 |
503 gfx::Size LayerTreeImpl::ScrollableSize() const { | 436 gfx::Size LayerTreeImpl::ScrollableSize() const { |
504 LayerImpl* root_scroll_layer = OuterViewportScrollLayer() ? | 437 if (!root_scroll_layer_ || root_scroll_layer_->children().empty()) |
505 OuterViewportScrollLayer() : InnerViewportScrollLayer(); | |
506 if (!root_scroll_layer || root_scroll_layer->children().empty()) | |
507 return gfx::Size(); | 438 return gfx::Size(); |
508 return root_scroll_layer->children()[0]->bounds(); | 439 return root_scroll_layer_->children()[0]->bounds(); |
509 } | 440 } |
510 | 441 |
511 LayerImpl* LayerTreeImpl::LayerById(int id) { | 442 LayerImpl* LayerTreeImpl::LayerById(int id) { |
512 LayerIdMap::iterator iter = layer_id_map_.find(id); | 443 LayerIdMap::iterator iter = layer_id_map_.find(id); |
513 return iter != layer_id_map_.end() ? iter->second : NULL; | 444 return iter != layer_id_map_.end() ? iter->second : NULL; |
514 } | 445 } |
515 | 446 |
516 void LayerTreeImpl::RegisterLayer(LayerImpl* layer) { | 447 void LayerTreeImpl::RegisterLayer(LayerImpl* layer) { |
517 DCHECK(!LayerById(layer->id())); | 448 DCHECK(!LayerById(layer->id())); |
518 layer_id_map_[layer->id()] = layer; | 449 layer_id_map_[layer->id()] = layer; |
(...skipping 13 matching lines...) Expand all Loading... |
532 static void DidBecomeActiveRecursive(LayerImpl* layer) { | 463 static void DidBecomeActiveRecursive(LayerImpl* layer) { |
533 layer->DidBecomeActive(); | 464 layer->DidBecomeActive(); |
534 for (size_t i = 0; i < layer->children().size(); ++i) | 465 for (size_t i = 0; i < layer->children().size(); ++i) |
535 DidBecomeActiveRecursive(layer->children()[i]); | 466 DidBecomeActiveRecursive(layer->children()[i]); |
536 } | 467 } |
537 | 468 |
538 void LayerTreeImpl::DidBecomeActive() { | 469 void LayerTreeImpl::DidBecomeActive() { |
539 if (!root_layer()) | 470 if (!root_layer()) |
540 return; | 471 return; |
541 | 472 |
542 if (scrolling_layer_id_from_previous_tree_) { | |
543 currently_scrolling_layer_ = LayerTreeHostCommon::FindLayerInSubtree( | |
544 root_layer_.get(), | |
545 scrolling_layer_id_from_previous_tree_); | |
546 } | |
547 | |
548 DidBecomeActiveRecursive(root_layer()); | 473 DidBecomeActiveRecursive(root_layer()); |
| 474 FindRootScrollLayer(); |
549 } | 475 } |
550 | 476 |
551 bool LayerTreeImpl::ContentsTexturesPurged() const { | 477 bool LayerTreeImpl::ContentsTexturesPurged() const { |
552 return contents_textures_purged_; | 478 return contents_textures_purged_; |
553 } | 479 } |
554 | 480 |
555 void LayerTreeImpl::SetContentsTexturesPurged() { | 481 void LayerTreeImpl::SetContentsTexturesPurged() { |
556 if (contents_textures_purged_) | 482 if (contents_textures_purged_) |
557 return; | 483 return; |
558 contents_textures_purged_ = true; | 484 contents_textures_purged_ = true; |
(...skipping 170 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
729 state->Set("render_surface_layer_list", | 655 state->Set("render_surface_layer_list", |
730 render_surface_layer_list.release()); | 656 render_surface_layer_list.release()); |
731 return state.PassAs<base::Value>(); | 657 return state.PassAs<base::Value>(); |
732 } | 658 } |
733 | 659 |
734 void LayerTreeImpl::SetRootLayerScrollOffsetDelegate( | 660 void LayerTreeImpl::SetRootLayerScrollOffsetDelegate( |
735 LayerScrollOffsetDelegate* root_layer_scroll_offset_delegate) { | 661 LayerScrollOffsetDelegate* root_layer_scroll_offset_delegate) { |
736 if (root_layer_scroll_offset_delegate_ == root_layer_scroll_offset_delegate) | 662 if (root_layer_scroll_offset_delegate_ == root_layer_scroll_offset_delegate) |
737 return; | 663 return; |
738 | 664 |
739 if (!root_layer_scroll_offset_delegate) { | 665 root_layer_scroll_offset_delegate_ = root_layer_scroll_offset_delegate; |
740 // Make sure we remove the proxies from their layers before | 666 |
741 // releasing them. | 667 if (root_scroll_layer_) { |
742 if (InnerViewportScrollLayer()) | 668 root_scroll_layer_->SetScrollOffsetDelegate( |
743 InnerViewportScrollLayer()->SetScrollOffsetDelegate(NULL); | 669 root_layer_scroll_offset_delegate_); |
744 if (OuterViewportScrollLayer()) | |
745 OuterViewportScrollLayer()->SetScrollOffsetDelegate(NULL); | |
746 inner_viewport_scroll_delegate_proxy_.reset(); | |
747 outer_viewport_scroll_delegate_proxy_.reset(); | |
748 } | 670 } |
749 | 671 |
750 root_layer_scroll_offset_delegate_ = root_layer_scroll_offset_delegate; | |
751 | |
752 if (root_layer_scroll_offset_delegate_) { | 672 if (root_layer_scroll_offset_delegate_) { |
753 root_layer_scroll_offset_delegate_->SetTotalScrollOffset( | |
754 TotalScrollOffset()); | |
755 root_layer_scroll_offset_delegate_->SetMaxScrollOffset( | |
756 TotalMaxScrollOffset()); | |
757 root_layer_scroll_offset_delegate_->SetScrollableSize(ScrollableSize()); | 673 root_layer_scroll_offset_delegate_->SetScrollableSize(ScrollableSize()); |
758 root_layer_scroll_offset_delegate_->SetTotalPageScaleFactor( | 674 root_layer_scroll_offset_delegate_->SetTotalPageScaleFactor( |
759 total_page_scale_factor()); | 675 total_page_scale_factor()); |
760 | |
761 if (inner_viewport_scroll_layer_) { | |
762 inner_viewport_scroll_delegate_proxy_ = make_scoped_ptr( | |
763 new LayerScrollOffsetDelegateProxy(InnerViewportScrollLayer(), | |
764 root_layer_scroll_offset_delegate_, | |
765 this)); | |
766 inner_viewport_scroll_layer_->SetScrollOffsetDelegate( | |
767 inner_viewport_scroll_delegate_proxy_.get()); | |
768 } | |
769 | |
770 if (outer_viewport_scroll_layer_) { | |
771 outer_viewport_scroll_delegate_proxy_ = make_scoped_ptr( | |
772 new LayerScrollOffsetDelegateProxy(OuterViewportScrollLayer(), | |
773 root_layer_scroll_offset_delegate_, | |
774 this)); | |
775 outer_viewport_scroll_layer_->SetScrollOffsetDelegate( | |
776 outer_viewport_scroll_delegate_proxy_.get()); | |
777 } | |
778 } | 676 } |
779 } | 677 } |
780 | 678 |
781 void LayerTreeImpl::UpdateScrollOffsetDelegate() { | |
782 DCHECK(InnerViewportScrollLayer()); | |
783 DCHECK(root_layer_scroll_offset_delegate_); | |
784 | |
785 gfx::Vector2dF offset = | |
786 inner_viewport_scroll_delegate_proxy_->last_set_scroll_offset(); | |
787 | |
788 if (OuterViewportScrollLayer()) | |
789 offset += | |
790 outer_viewport_scroll_delegate_proxy_->last_set_scroll_offset(); | |
791 | |
792 root_layer_scroll_offset_delegate_->SetTotalScrollOffset(offset); | |
793 root_layer_scroll_offset_delegate_->SetMaxScrollOffset( | |
794 TotalMaxScrollOffset()); | |
795 } | |
796 | |
797 gfx::Vector2dF LayerTreeImpl::GetDelegatedScrollOffset(LayerImpl* layer) { | |
798 DCHECK(root_layer_scroll_offset_delegate_); | |
799 DCHECK(InnerViewportScrollLayer()); | |
800 if (layer == InnerViewportScrollLayer() && !OuterViewportScrollLayer()) | |
801 return root_layer_scroll_offset_delegate_->GetTotalScrollOffset(); | |
802 | |
803 // If we get here, we have both inner/outer viewports, and need to distribute | |
804 // the scroll offset between them. | |
805 DCHECK(inner_viewport_scroll_delegate_proxy_); | |
806 DCHECK(outer_viewport_scroll_delegate_proxy_); | |
807 gfx::Vector2dF inner_viewport_offset = | |
808 inner_viewport_scroll_delegate_proxy_->last_set_scroll_offset(); | |
809 gfx::Vector2dF outer_viewport_offset = | |
810 outer_viewport_scroll_delegate_proxy_->last_set_scroll_offset(); | |
811 | |
812 // It may be nothing has changed. | |
813 gfx::Vector2dF delegate_offset = | |
814 root_layer_scroll_offset_delegate_->GetTotalScrollOffset(); | |
815 if (inner_viewport_offset + outer_viewport_offset == delegate_offset) { | |
816 if (layer == InnerViewportScrollLayer()) | |
817 return inner_viewport_offset; | |
818 else | |
819 return outer_viewport_offset; | |
820 } | |
821 | |
822 gfx::Vector2d max_outer_viewport_scroll_offset = | |
823 OuterViewportScrollLayer()->MaxScrollOffset(); | |
824 | |
825 outer_viewport_offset = delegate_offset - inner_viewport_offset; | |
826 outer_viewport_offset.SetToMin(max_outer_viewport_scroll_offset); | |
827 outer_viewport_offset.SetToMax(gfx::Vector2d()); | |
828 | |
829 if (layer == OuterViewportScrollLayer()) | |
830 return outer_viewport_offset; | |
831 | |
832 inner_viewport_offset = delegate_offset - outer_viewport_offset; | |
833 | |
834 return inner_viewport_offset; | |
835 } | |
836 | |
837 // TODO(wjmaclean) Rename this function, as we no longer have a | |
838 // "RootScrollLayer". | |
839 void LayerTreeImpl::UpdateRootScrollLayerSizeDelta() { | 679 void LayerTreeImpl::UpdateRootScrollLayerSizeDelta() { |
840 // TODO(wjmaclean) verify this is really the right thing to do in cases where | 680 LayerImpl* root_scroll = RootScrollLayer(); |
841 // the pinch virtual viewport is active. | |
842 LayerImpl* root_scroll = InnerViewportScrollLayer(); | |
843 LayerImpl* root_container = RootContainerLayer(); | 681 LayerImpl* root_container = RootContainerLayer(); |
844 DCHECK(root_scroll); | 682 DCHECK(root_scroll); |
845 DCHECK(root_container); | 683 DCHECK(root_container); |
846 DCHECK(IsActiveTree()); | 684 DCHECK(IsActiveTree()); |
847 | 685 |
848 gfx::Vector2dF scrollable_viewport_size = | 686 gfx::Vector2dF scrollable_viewport_size = |
849 gfx::RectF(ScrollableViewportSize()).bottom_right() - gfx::PointF(); | 687 gfx::RectF(ScrollableViewportSize()).bottom_right() - gfx::PointF(); |
850 | 688 |
851 gfx::Vector2dF original_viewport_size = | 689 gfx::Vector2dF original_viewport_size = |
852 gfx::RectF(root_container->bounds()).bottom_right() - | 690 gfx::RectF(root_container->bounds()).bottom_right() - |
(...skipping 99 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
952 const std::vector<LayerImpl*>& LayerTreeImpl::LayersWithCopyOutputRequest() | 790 const std::vector<LayerImpl*>& LayerTreeImpl::LayersWithCopyOutputRequest() |
953 const { | 791 const { |
954 // Only the active tree needs to know about layers with copy requests, as | 792 // Only the active tree needs to know about layers with copy requests, as |
955 // they are aborted if not serviced during draw. | 793 // they are aborted if not serviced during draw. |
956 DCHECK(IsActiveTree()); | 794 DCHECK(IsActiveTree()); |
957 | 795 |
958 return layers_with_copy_output_request_; | 796 return layers_with_copy_output_request_; |
959 } | 797 } |
960 | 798 |
961 } // namespace cc | 799 } // namespace cc |
OLD | NEW |