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