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