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
3 // found in the LICENSE file.
5 #include "cc/trees/layer_tree_impl.h"
10 #include "base/debug/trace_event.h"
11 #include "base/debug/trace_event_argument.h"
12 #include "cc/animation/keyframed_animation_curve.h"
13 #include "cc/animation/scrollbar_animation_controller.h"
14 #include "cc/animation/scrollbar_animation_controller_linear_fade.h"
15 #include "cc/animation/scrollbar_animation_controller_thinning.h"
16 #include "cc/base/math_util.h"
17 #include "cc/base/util.h"
18 #include "cc/debug/devtools_instrumentation.h"
19 #include "cc/debug/traced_value.h"
20 #include "cc/input/page_scale_animation.h"
21 #include "cc/layers/heads_up_display_layer_impl.h"
22 #include "cc/layers/layer.h"
23 #include "cc/layers/layer_iterator.h"
24 #include "cc/layers/render_surface_impl.h"
25 #include "cc/layers/scrollbar_layer_impl_base.h"
26 #include "cc/resources/ui_resource_request.h"
27 #include "cc/trees/layer_tree_host_common.h"
28 #include "cc/trees/layer_tree_host_impl.h"
29 #include "cc/trees/occlusion_tracker.h"
30 #include "ui/gfx/point_conversions.h"
31 #include "ui/gfx/size_conversions.h"
32 #include "ui/gfx/vector2d_conversions.h"
36 // This class exists to split the LayerScrollOffsetDelegate between the
37 // InnerViewportScrollLayer and the OuterViewportScrollLayer in a manner
38 // that never requires the embedder or LayerImpl to know about.
39 class LayerScrollOffsetDelegateProxy
: public LayerImpl::ScrollOffsetDelegate
{
41 LayerScrollOffsetDelegateProxy(LayerImpl
* layer
,
42 LayerScrollOffsetDelegate
* delegate
,
43 LayerTreeImpl
* layer_tree
)
44 : layer_(layer
), delegate_(delegate
), layer_tree_impl_(layer_tree
) {}
45 virtual ~LayerScrollOffsetDelegateProxy() {}
47 gfx::ScrollOffset
last_set_scroll_offset() const {
48 return last_set_scroll_offset_
;
51 // LayerScrollOffsetDelegate implementation.
52 virtual void SetTotalScrollOffset(
53 const gfx::ScrollOffset
& new_offset
) override
{
54 last_set_scroll_offset_
= new_offset
;
55 layer_tree_impl_
->UpdateScrollOffsetDelegate();
58 virtual gfx::ScrollOffset
GetTotalScrollOffset() override
{
59 return layer_tree_impl_
->GetDelegatedScrollOffset(layer_
);
62 virtual bool IsExternalFlingActive() const override
{
63 return delegate_
->IsExternalFlingActive();
68 LayerScrollOffsetDelegate
* delegate_
;
69 LayerTreeImpl
* layer_tree_impl_
;
70 gfx::ScrollOffset last_set_scroll_offset_
;
73 LayerTreeImpl::LayerTreeImpl(LayerTreeHostImpl
* layer_tree_host_impl
)
74 : layer_tree_host_impl_(layer_tree_host_impl
),
75 source_frame_number_(-1),
77 currently_scrolling_layer_(NULL
),
78 root_layer_scroll_offset_delegate_(NULL
),
80 has_transparent_background_(false),
81 page_scale_layer_(NULL
),
82 inner_viewport_scroll_layer_(NULL
),
83 outer_viewport_scroll_layer_(NULL
),
84 page_scale_factor_(1),
86 sent_page_scale_delta_(1),
87 min_page_scale_factor_(0),
88 max_page_scale_factor_(0),
89 scrolling_layer_id_from_previous_tree_(0),
90 contents_textures_purged_(false),
91 requires_high_res_to_draw_(false),
92 viewport_size_invalid_(false),
93 needs_update_draw_properties_(true),
94 needs_full_tree_sync_(true),
95 next_activation_forces_redraw_(false),
96 has_ever_been_drawn_(false),
97 render_surface_layer_list_id_(0),
98 top_controls_layout_height_(0),
99 top_controls_content_offset_(0),
100 top_controls_delta_(0),
101 sent_top_controls_delta_(0) {
104 LayerTreeImpl::~LayerTreeImpl() {
105 BreakSwapPromises(SwapPromise::SWAP_FAILS
);
107 // Need to explicitly clear the tree prior to destroying this so that
108 // the LayerTreeImpl pointer is still valid in the LayerImpl dtor.
109 DCHECK(!root_layer_
);
110 DCHECK(layers_with_copy_output_request_
.empty());
113 void LayerTreeImpl::Shutdown() {
114 root_layer_
= nullptr;
117 void LayerTreeImpl::ReleaseResources() {
119 ReleaseResourcesRecursive(root_layer_
.get());
122 void LayerTreeImpl::SetRootLayer(scoped_ptr
<LayerImpl
> layer
) {
123 if (inner_viewport_scroll_layer_
)
124 inner_viewport_scroll_layer_
->SetScrollOffsetDelegate(NULL
);
125 if (outer_viewport_scroll_layer_
)
126 outer_viewport_scroll_layer_
->SetScrollOffsetDelegate(NULL
);
127 inner_viewport_scroll_delegate_proxy_
= nullptr;
128 outer_viewport_scroll_delegate_proxy_
= nullptr;
130 root_layer_
= layer
.Pass();
131 currently_scrolling_layer_
= NULL
;
132 inner_viewport_scroll_layer_
= NULL
;
133 outer_viewport_scroll_layer_
= NULL
;
134 page_scale_layer_
= NULL
;
136 layer_tree_host_impl_
->OnCanDrawStateChangedForTree();
139 LayerImpl
* LayerTreeImpl::InnerViewportScrollLayer() const {
140 return inner_viewport_scroll_layer_
;
143 LayerImpl
* LayerTreeImpl::OuterViewportScrollLayer() const {
144 return outer_viewport_scroll_layer_
;
147 gfx::ScrollOffset
LayerTreeImpl::TotalScrollOffset() const {
148 gfx::ScrollOffset offset
;
150 if (inner_viewport_scroll_layer_
)
151 offset
+= inner_viewport_scroll_layer_
->TotalScrollOffset();
153 if (outer_viewport_scroll_layer_
)
154 offset
+= outer_viewport_scroll_layer_
->TotalScrollOffset();
159 gfx::ScrollOffset
LayerTreeImpl::TotalMaxScrollOffset() const {
160 gfx::ScrollOffset offset
;
162 if (inner_viewport_scroll_layer_
)
163 offset
+= inner_viewport_scroll_layer_
->MaxScrollOffset();
165 if (outer_viewport_scroll_layer_
)
166 offset
+= outer_viewport_scroll_layer_
->MaxScrollOffset();
170 gfx::Vector2dF
LayerTreeImpl::TotalScrollDelta() const {
171 DCHECK(inner_viewport_scroll_layer_
);
172 gfx::Vector2dF delta
= inner_viewport_scroll_layer_
->ScrollDelta();
174 if (outer_viewport_scroll_layer_
)
175 delta
+= outer_viewport_scroll_layer_
->ScrollDelta();
180 scoped_ptr
<LayerImpl
> LayerTreeImpl::DetachLayerTree() {
181 // Clear all data structures that have direct references to the layer tree.
182 scrolling_layer_id_from_previous_tree_
=
183 currently_scrolling_layer_
? currently_scrolling_layer_
->id() : 0;
184 if (inner_viewport_scroll_layer_
)
185 inner_viewport_scroll_layer_
->SetScrollOffsetDelegate(NULL
);
186 if (outer_viewport_scroll_layer_
)
187 outer_viewport_scroll_layer_
->SetScrollOffsetDelegate(NULL
);
188 inner_viewport_scroll_delegate_proxy_
= nullptr;
189 outer_viewport_scroll_delegate_proxy_
= nullptr;
190 inner_viewport_scroll_layer_
= NULL
;
191 outer_viewport_scroll_layer_
= NULL
;
192 page_scale_layer_
= NULL
;
193 currently_scrolling_layer_
= NULL
;
195 render_surface_layer_list_
.clear();
196 set_needs_update_draw_properties();
197 return root_layer_
.Pass();
200 void LayerTreeImpl::PushPropertiesTo(LayerTreeImpl
* target_tree
) {
201 // The request queue should have been processed and does not require a push.
202 DCHECK_EQ(ui_resource_request_queue_
.size(), 0u);
204 if (next_activation_forces_redraw_
) {
205 target_tree
->ForceRedrawNextActivation();
206 next_activation_forces_redraw_
= false;
209 target_tree
->PassSwapPromises(&swap_promise_list_
);
211 target_tree
->top_controls_layout_height_
= top_controls_layout_height_
;
212 target_tree
->top_controls_content_offset_
= top_controls_content_offset_
;
213 target_tree
->top_controls_delta_
=
214 target_tree
->top_controls_delta_
-
215 target_tree
->sent_top_controls_delta_
;
216 target_tree
->sent_top_controls_delta_
= 0.f
;
218 target_tree
->SetPageScaleValues(
219 page_scale_factor(), min_page_scale_factor(), max_page_scale_factor(),
220 target_tree
->page_scale_delta() / target_tree
->sent_page_scale_delta());
221 target_tree
->set_sent_page_scale_delta(1);
223 target_tree
->page_scale_animation_
= page_scale_animation_
.Pass();
225 if (page_scale_layer_
&& inner_viewport_scroll_layer_
) {
226 target_tree
->SetViewportLayersFromIds(
227 page_scale_layer_
->id(),
228 inner_viewport_scroll_layer_
->id(),
229 outer_viewport_scroll_layer_
? outer_viewport_scroll_layer_
->id()
230 : Layer::INVALID_ID
);
232 target_tree
->ClearViewportLayers();
235 target_tree
->RegisterSelection(selection_start_
, selection_end_
);
237 // This should match the property synchronization in
238 // LayerTreeHost::finishCommitOnImplThread().
239 target_tree
->set_source_frame_number(source_frame_number());
240 target_tree
->set_background_color(background_color());
241 target_tree
->set_has_transparent_background(has_transparent_background());
243 if (ContentsTexturesPurged())
244 target_tree
->SetContentsTexturesPurged();
246 target_tree
->ResetContentsTexturesPurged();
248 if (ViewportSizeInvalid())
249 target_tree
->SetViewportSizeInvalid();
251 target_tree
->ResetViewportSizeInvalid();
254 target_tree
->set_hud_layer(static_cast<HeadsUpDisplayLayerImpl
*>(
255 LayerTreeHostCommon::FindLayerInSubtree(
256 target_tree
->root_layer(), hud_layer()->id())));
258 target_tree
->set_hud_layer(NULL
);
260 target_tree
->has_ever_been_drawn_
= false;
263 LayerImpl
* LayerTreeImpl::InnerViewportContainerLayer() const {
264 return inner_viewport_scroll_layer_
265 ? inner_viewport_scroll_layer_
->scroll_clip_layer()
269 LayerImpl
* LayerTreeImpl::CurrentlyScrollingLayer() const {
270 DCHECK(IsActiveTree());
271 return currently_scrolling_layer_
;
274 void LayerTreeImpl::SetCurrentlyScrollingLayer(LayerImpl
* layer
) {
275 if (currently_scrolling_layer_
== layer
)
278 if (currently_scrolling_layer_
&&
279 currently_scrolling_layer_
->scrollbar_animation_controller())
280 currently_scrolling_layer_
->scrollbar_animation_controller()
282 currently_scrolling_layer_
= layer
;
283 if (layer
&& layer
->scrollbar_animation_controller())
284 layer
->scrollbar_animation_controller()->DidScrollBegin();
287 void LayerTreeImpl::ClearCurrentlyScrollingLayer() {
288 SetCurrentlyScrollingLayer(NULL
);
289 scrolling_layer_id_from_previous_tree_
= 0;
294 void ForceScrollbarParameterUpdateAfterScaleChange(LayerImpl
* current_layer
) {
298 while (current_layer
) {
299 current_layer
->ScrollbarParametersDidChange();
300 current_layer
= current_layer
->parent();
306 void LayerTreeImpl::SetPageScaleFactorAndLimits(float page_scale_factor
,
307 float min_page_scale_factor
, float max_page_scale_factor
) {
308 SetPageScaleValues(page_scale_factor
, min_page_scale_factor
,
309 max_page_scale_factor
, page_scale_delta_
);
312 void LayerTreeImpl::SetPageScaleDelta(float delta
) {
313 SetPageScaleValues(page_scale_factor_
, min_page_scale_factor_
,
314 max_page_scale_factor_
, delta
);
317 void LayerTreeImpl::SetPageScaleValues(float page_scale_factor
,
318 float min_page_scale_factor
, float max_page_scale_factor
,
319 float page_scale_delta
) {
320 bool page_scale_changed
=
321 min_page_scale_factor
!= min_page_scale_factor_
||
322 max_page_scale_factor
!= max_page_scale_factor_
||
323 page_scale_factor
!= page_scale_factor_
;
325 min_page_scale_factor_
= min_page_scale_factor
;
326 max_page_scale_factor_
= max_page_scale_factor
;
327 page_scale_factor_
= page_scale_factor
;
329 float total
= page_scale_factor_
* page_scale_delta
;
330 if (min_page_scale_factor_
&& total
< min_page_scale_factor_
)
331 page_scale_delta
= min_page_scale_factor_
/ page_scale_factor_
;
332 else if (max_page_scale_factor_
&& total
> max_page_scale_factor_
)
333 page_scale_delta
= max_page_scale_factor_
/ page_scale_factor_
;
335 if (page_scale_delta_
== page_scale_delta
&& !page_scale_changed
)
338 if (page_scale_delta_
!= page_scale_delta
) {
339 page_scale_delta_
= page_scale_delta
;
341 if (IsActiveTree()) {
342 LayerTreeImpl
* pending_tree
= layer_tree_host_impl_
->pending_tree();
344 DCHECK_EQ(1, pending_tree
->sent_page_scale_delta());
345 pending_tree
->SetPageScaleDelta(
346 page_scale_delta_
/ sent_page_scale_delta_
);
350 set_needs_update_draw_properties();
353 if (root_layer_scroll_offset_delegate_
) {
354 root_layer_scroll_offset_delegate_
->UpdateRootLayerState(
356 TotalMaxScrollOffset(),
358 total_page_scale_factor(),
359 min_page_scale_factor_
,
360 max_page_scale_factor_
);
363 ForceScrollbarParameterUpdateAfterScaleChange(page_scale_layer());
366 gfx::SizeF
LayerTreeImpl::ScrollableViewportSize() const {
367 if (!InnerViewportContainerLayer())
370 return gfx::ScaleSize(InnerViewportContainerLayer()->bounds(),
371 1.0f
/ total_page_scale_factor());
374 gfx::Rect
LayerTreeImpl::RootScrollLayerDeviceViewportBounds() const {
375 LayerImpl
* root_scroll_layer
= OuterViewportScrollLayer()
376 ? OuterViewportScrollLayer()
377 : InnerViewportScrollLayer();
378 if (!root_scroll_layer
|| root_scroll_layer
->children().empty())
380 LayerImpl
* layer
= root_scroll_layer
->children()[0];
381 return MathUtil::MapEnclosingClippedRect(layer
->screen_space_transform(),
382 gfx::Rect(layer
->content_bounds()));
385 static void ApplySentScrollDeltasFromAbortedCommitTo(LayerImpl
* layer
) {
386 layer
->ApplySentScrollDeltasFromAbortedCommit();
389 void LayerTreeImpl::ApplySentScrollAndScaleDeltasFromAbortedCommit() {
390 DCHECK(IsActiveTree());
392 page_scale_factor_
*= sent_page_scale_delta_
;
393 page_scale_delta_
/= sent_page_scale_delta_
;
394 sent_page_scale_delta_
= 1.f
;
396 top_controls_content_offset_
+= sent_top_controls_delta_
;
397 top_controls_delta_
-= sent_top_controls_delta_
;
398 sent_top_controls_delta_
= 0.f
;
403 LayerTreeHostCommon::CallFunctionForSubtree(
404 root_layer(), base::Bind(&ApplySentScrollDeltasFromAbortedCommitTo
));
407 static void ApplyScrollDeltasSinceBeginMainFrameTo(LayerImpl
* layer
) {
408 layer
->ApplyScrollDeltasSinceBeginMainFrame();
411 void LayerTreeImpl::ApplyScrollDeltasSinceBeginMainFrame() {
412 DCHECK(IsPendingTree());
416 LayerTreeHostCommon::CallFunctionForSubtree(
417 root_layer(), base::Bind(&ApplyScrollDeltasSinceBeginMainFrameTo
));
420 void LayerTreeImpl::SetViewportLayersFromIds(
421 int page_scale_layer_id
,
422 int inner_viewport_scroll_layer_id
,
423 int outer_viewport_scroll_layer_id
) {
424 page_scale_layer_
= LayerById(page_scale_layer_id
);
425 DCHECK(page_scale_layer_
);
427 inner_viewport_scroll_layer_
=
428 LayerById(inner_viewport_scroll_layer_id
);
429 DCHECK(inner_viewport_scroll_layer_
);
431 outer_viewport_scroll_layer_
=
432 LayerById(outer_viewport_scroll_layer_id
);
433 DCHECK(outer_viewport_scroll_layer_
||
434 outer_viewport_scroll_layer_id
== Layer::INVALID_ID
);
436 if (!root_layer_scroll_offset_delegate_
)
439 inner_viewport_scroll_delegate_proxy_
= make_scoped_ptr(
440 new LayerScrollOffsetDelegateProxy(inner_viewport_scroll_layer_
,
441 root_layer_scroll_offset_delegate_
,
444 if (outer_viewport_scroll_layer_
)
445 outer_viewport_scroll_delegate_proxy_
= make_scoped_ptr(
446 new LayerScrollOffsetDelegateProxy(outer_viewport_scroll_layer_
,
447 root_layer_scroll_offset_delegate_
,
451 void LayerTreeImpl::ClearViewportLayers() {
452 page_scale_layer_
= NULL
;
453 inner_viewport_scroll_layer_
= NULL
;
454 outer_viewport_scroll_layer_
= NULL
;
457 bool LayerTreeImpl::UpdateDrawProperties() {
458 if (!needs_update_draw_properties_
)
461 // For max_texture_size.
462 if (!layer_tree_host_impl_
->renderer())
468 needs_update_draw_properties_
= false;
469 render_surface_layer_list_
.clear();
473 "LayerTreeImpl::UpdateDrawProperties",
477 source_frame_number_
);
478 LayerImpl
* page_scale_layer
=
479 page_scale_layer_
? page_scale_layer_
: InnerViewportContainerLayer();
480 bool can_render_to_separate_surface
=
481 (layer_tree_host_impl_
->GetDrawMode() !=
482 DRAW_MODE_RESOURCELESS_SOFTWARE
);
484 ++render_surface_layer_list_id_
;
485 LayerTreeHostCommon::CalcDrawPropsImplInputs
inputs(
488 layer_tree_host_impl_
->DrawTransform(),
489 device_scale_factor(),
490 total_page_scale_factor(),
492 resource_provider()->max_texture_size(),
493 settings().can_use_lcd_text
,
494 can_render_to_separate_surface
,
495 settings().layer_transforms_should_scale_layer_contents
,
496 &render_surface_layer_list_
,
497 render_surface_layer_list_id_
);
498 LayerTreeHostCommon::CalculateDrawProperties(&inputs
);
503 "LayerTreeImpl::UpdateTilePriorities",
507 source_frame_number_
);
508 scoped_ptr
<OcclusionTracker
<LayerImpl
> > occlusion_tracker
;
509 if (settings().use_occlusion_for_tile_prioritization
) {
510 occlusion_tracker
.reset(new OcclusionTracker
<LayerImpl
>(
511 root_layer()->render_surface()->content_rect()));
512 occlusion_tracker
->set_minimum_tracking_size(
513 settings().minimum_occlusion_tracking_size
);
516 bool resourceless_software_draw
= (layer_tree_host_impl_
->GetDrawMode() ==
517 DRAW_MODE_RESOURCELESS_SOFTWARE
);
519 // LayerIterator is used here instead of CallFunctionForSubtree to only
520 // UpdateTilePriorities on layers that will be visible (and thus have valid
521 // draw properties) and not because any ordering is required.
522 typedef LayerIterator
<LayerImpl
> LayerIteratorType
;
523 LayerIteratorType end
= LayerIteratorType::End(&render_surface_layer_list_
);
524 for (LayerIteratorType it
=
525 LayerIteratorType::Begin(&render_surface_layer_list_
);
528 if (occlusion_tracker
)
529 occlusion_tracker
->EnterLayer(it
);
531 LayerImpl
* layer
= *it
;
532 const Occlusion
& occlusion_in_content_space
=
533 occlusion_tracker
? occlusion_tracker
->GetCurrentOcclusionForLayer(
534 layer
->draw_transform())
537 if (it
.represents_itself()) {
538 layer
->UpdateTiles(occlusion_in_content_space
,
539 resourceless_software_draw
);
542 if (!it
.represents_contributing_render_surface()) {
543 if (occlusion_tracker
)
544 occlusion_tracker
->LeaveLayer(it
);
548 if (layer
->mask_layer()) {
549 layer
->mask_layer()->UpdateTiles(occlusion_in_content_space
,
550 resourceless_software_draw
);
552 if (layer
->replica_layer() && layer
->replica_layer()->mask_layer()) {
553 layer
->replica_layer()->mask_layer()->UpdateTiles(
554 occlusion_in_content_space
, resourceless_software_draw
);
557 if (occlusion_tracker
)
558 occlusion_tracker
->LeaveLayer(it
);
562 DCHECK(!needs_update_draw_properties_
) <<
563 "CalcDrawProperties should not set_needs_update_draw_properties()";
567 const LayerImplList
& LayerTreeImpl::RenderSurfaceLayerList() const {
568 // If this assert triggers, then the list is dirty.
569 DCHECK(!needs_update_draw_properties_
);
570 return render_surface_layer_list_
;
573 gfx::SizeF
LayerTreeImpl::ScrollableSize() const {
574 LayerImpl
* root_scroll_layer
= OuterViewportScrollLayer()
575 ? OuterViewportScrollLayer()
576 : InnerViewportScrollLayer();
577 if (!root_scroll_layer
|| root_scroll_layer
->children().empty())
579 return root_scroll_layer
->children()[0]->bounds();
582 LayerImpl
* LayerTreeImpl::LayerById(int id
) {
583 LayerIdMap::iterator iter
= layer_id_map_
.find(id
);
584 return iter
!= layer_id_map_
.end() ? iter
->second
: NULL
;
587 void LayerTreeImpl::RegisterLayer(LayerImpl
* layer
) {
588 DCHECK(!LayerById(layer
->id()));
589 layer_id_map_
[layer
->id()] = layer
;
592 void LayerTreeImpl::UnregisterLayer(LayerImpl
* layer
) {
593 DCHECK(LayerById(layer
->id()));
594 layer_id_map_
.erase(layer
->id());
597 size_t LayerTreeImpl::NumLayers() {
598 return layer_id_map_
.size();
601 void LayerTreeImpl::PushPersistedState(LayerTreeImpl
* pending_tree
) {
602 pending_tree
->SetCurrentlyScrollingLayer(
603 LayerTreeHostCommon::FindLayerInSubtree(pending_tree
->root_layer(),
604 currently_scrolling_layer_
? currently_scrolling_layer_
->id() : 0));
607 static void DidBecomeActiveRecursive(LayerImpl
* layer
) {
608 layer
->DidBecomeActive();
609 if (layer
->mask_layer())
610 layer
->mask_layer()->DidBecomeActive();
611 if (layer
->replica_layer() && layer
->replica_layer()->mask_layer())
612 layer
->replica_layer()->mask_layer()->DidBecomeActive();
614 for (size_t i
= 0; i
< layer
->children().size(); ++i
)
615 DidBecomeActiveRecursive(layer
->children()[i
]);
618 void LayerTreeImpl::DidBecomeActive() {
619 if (next_activation_forces_redraw_
) {
620 layer_tree_host_impl_
->SetFullRootLayerDamage();
621 next_activation_forces_redraw_
= false;
624 if (scrolling_layer_id_from_previous_tree_
) {
625 currently_scrolling_layer_
= LayerTreeHostCommon::FindLayerInSubtree(
626 root_layer(), scrolling_layer_id_from_previous_tree_
);
629 // Always reset this flag on activation, as we would only have activated
630 // if we were in a good state.
631 ResetRequiresHighResToDraw();
634 DidBecomeActiveRecursive(root_layer());
636 devtools_instrumentation::DidActivateLayerTree(layer_tree_host_impl_
->id(),
637 source_frame_number_
);
640 bool LayerTreeImpl::ContentsTexturesPurged() const {
641 return contents_textures_purged_
;
644 void LayerTreeImpl::SetContentsTexturesPurged() {
645 if (contents_textures_purged_
)
647 contents_textures_purged_
= true;
648 layer_tree_host_impl_
->OnCanDrawStateChangedForTree();
651 void LayerTreeImpl::ResetContentsTexturesPurged() {
652 if (!contents_textures_purged_
)
654 contents_textures_purged_
= false;
655 layer_tree_host_impl_
->OnCanDrawStateChangedForTree();
658 void LayerTreeImpl::SetRequiresHighResToDraw() {
659 requires_high_res_to_draw_
= true;
662 void LayerTreeImpl::ResetRequiresHighResToDraw() {
663 requires_high_res_to_draw_
= false;
666 bool LayerTreeImpl::RequiresHighResToDraw() const {
667 return requires_high_res_to_draw_
;
670 bool LayerTreeImpl::ViewportSizeInvalid() const {
671 return viewport_size_invalid_
;
674 void LayerTreeImpl::SetViewportSizeInvalid() {
675 viewport_size_invalid_
= true;
676 layer_tree_host_impl_
->OnCanDrawStateChangedForTree();
679 void LayerTreeImpl::ResetViewportSizeInvalid() {
680 viewport_size_invalid_
= false;
681 layer_tree_host_impl_
->OnCanDrawStateChangedForTree();
684 Proxy
* LayerTreeImpl::proxy() const {
685 return layer_tree_host_impl_
->proxy();
688 const LayerTreeSettings
& LayerTreeImpl::settings() const {
689 return layer_tree_host_impl_
->settings();
692 const RendererCapabilitiesImpl
& LayerTreeImpl::GetRendererCapabilities() const {
693 return layer_tree_host_impl_
->GetRendererCapabilities();
696 ContextProvider
* LayerTreeImpl::context_provider() const {
697 return output_surface()->context_provider();
700 OutputSurface
* LayerTreeImpl::output_surface() const {
701 return layer_tree_host_impl_
->output_surface();
704 ResourceProvider
* LayerTreeImpl::resource_provider() const {
705 return layer_tree_host_impl_
->resource_provider();
708 TileManager
* LayerTreeImpl::tile_manager() const {
709 return layer_tree_host_impl_
->tile_manager();
712 FrameRateCounter
* LayerTreeImpl::frame_rate_counter() const {
713 return layer_tree_host_impl_
->fps_counter();
716 PaintTimeCounter
* LayerTreeImpl::paint_time_counter() const {
717 return layer_tree_host_impl_
->paint_time_counter();
720 MemoryHistory
* LayerTreeImpl::memory_history() const {
721 return layer_tree_host_impl_
->memory_history();
724 gfx::Size
LayerTreeImpl::device_viewport_size() const {
725 return layer_tree_host_impl_
->device_viewport_size();
728 bool LayerTreeImpl::IsActiveTree() const {
729 return layer_tree_host_impl_
->active_tree() == this;
732 bool LayerTreeImpl::IsPendingTree() const {
733 return layer_tree_host_impl_
->pending_tree() == this;
736 bool LayerTreeImpl::IsRecycleTree() const {
737 return layer_tree_host_impl_
->recycle_tree() == this;
740 LayerImpl
* LayerTreeImpl::FindActiveTreeLayerById(int id
) {
741 LayerTreeImpl
* tree
= layer_tree_host_impl_
->active_tree();
744 return tree
->LayerById(id
);
747 LayerImpl
* LayerTreeImpl::FindPendingTreeLayerById(int id
) {
748 LayerTreeImpl
* tree
= layer_tree_host_impl_
->pending_tree();
751 return tree
->LayerById(id
);
754 LayerImpl
* LayerTreeImpl::FindRecycleTreeLayerById(int id
) {
755 LayerTreeImpl
* tree
= layer_tree_host_impl_
->recycle_tree();
758 return tree
->LayerById(id
);
761 bool LayerTreeImpl::PinchGestureActive() const {
762 return layer_tree_host_impl_
->pinch_gesture_active();
765 BeginFrameArgs
LayerTreeImpl::CurrentBeginFrameArgs() const {
766 return layer_tree_host_impl_
->CurrentBeginFrameArgs();
769 base::TimeDelta
LayerTreeImpl::begin_impl_frame_interval() const {
770 return layer_tree_host_impl_
->begin_impl_frame_interval();
773 void LayerTreeImpl::SetNeedsCommit() {
774 layer_tree_host_impl_
->SetNeedsCommit();
777 gfx::Rect
LayerTreeImpl::DeviceViewport() const {
778 return layer_tree_host_impl_
->DeviceViewport();
781 gfx::Size
LayerTreeImpl::DrawViewportSize() const {
782 return layer_tree_host_impl_
->DrawViewportSize();
785 const gfx::Rect
LayerTreeImpl::ViewportRectForTilePriority() const {
786 return layer_tree_host_impl_
->ViewportRectForTilePriority();
789 scoped_ptr
<ScrollbarAnimationController
>
790 LayerTreeImpl::CreateScrollbarAnimationController(LayerImpl
* scrolling_layer
) {
791 DCHECK(settings().scrollbar_fade_delay_ms
);
792 DCHECK(settings().scrollbar_fade_duration_ms
);
793 base::TimeDelta delay
=
794 base::TimeDelta::FromMilliseconds(settings().scrollbar_fade_delay_ms
);
795 base::TimeDelta duration
=
796 base::TimeDelta::FromMilliseconds(settings().scrollbar_fade_duration_ms
);
797 switch (settings().scrollbar_animator
) {
798 case LayerTreeSettings::LinearFade
: {
799 return ScrollbarAnimationControllerLinearFade::Create(
800 scrolling_layer
, layer_tree_host_impl_
, delay
, duration
);
802 case LayerTreeSettings::Thinning
: {
803 return ScrollbarAnimationControllerThinning::Create(
804 scrolling_layer
, layer_tree_host_impl_
, delay
, duration
);
806 case LayerTreeSettings::NoAnimator
:
813 void LayerTreeImpl::DidAnimateScrollOffset() {
814 layer_tree_host_impl_
->DidAnimateScrollOffset();
817 bool LayerTreeImpl::use_gpu_rasterization() const {
818 return layer_tree_host_impl_
->use_gpu_rasterization();
821 bool LayerTreeImpl::create_low_res_tiling() const {
822 return layer_tree_host_impl_
->create_low_res_tiling();
825 void LayerTreeImpl::SetNeedsRedraw() {
826 layer_tree_host_impl_
->SetNeedsRedraw();
829 const LayerTreeDebugState
& LayerTreeImpl::debug_state() const {
830 return layer_tree_host_impl_
->debug_state();
833 float LayerTreeImpl::device_scale_factor() const {
834 return layer_tree_host_impl_
->device_scale_factor();
837 DebugRectHistory
* LayerTreeImpl::debug_rect_history() const {
838 return layer_tree_host_impl_
->debug_rect_history();
841 AnimationRegistrar
* LayerTreeImpl::animationRegistrar() const {
842 return layer_tree_host_impl_
->animation_registrar();
845 void LayerTreeImpl::GetAllTilesForTracing(std::set
<const Tile
*>* tiles
) const {
846 typedef LayerIterator
<LayerImpl
> LayerIteratorType
;
847 LayerIteratorType end
= LayerIteratorType::End(&render_surface_layer_list_
);
848 for (LayerIteratorType it
=
849 LayerIteratorType::Begin(&render_surface_layer_list_
);
852 if (!it
.represents_itself())
854 LayerImpl
* layer_impl
= *it
;
855 layer_impl
->GetAllTilesForTracing(tiles
);
859 void LayerTreeImpl::AsValueInto(base::debug::TracedValue
* state
) const {
860 TracedValue::MakeDictIntoImplicitSnapshot(state
, "cc::LayerTreeImpl", this);
861 state
->SetInteger("source_frame_number", source_frame_number_
);
863 state
->BeginDictionary("root_layer");
864 root_layer_
->AsValueInto(state
);
865 state
->EndDictionary();
867 state
->BeginArray("render_surface_layer_list");
868 typedef LayerIterator
<LayerImpl
> LayerIteratorType
;
869 LayerIteratorType end
= LayerIteratorType::End(&render_surface_layer_list_
);
870 for (LayerIteratorType it
= LayerIteratorType::Begin(
871 &render_surface_layer_list_
); it
!= end
; ++it
) {
872 if (!it
.represents_itself())
874 TracedValue::AppendIDRef(*it
, state
);
878 state
->BeginArray("swap_promise_trace_ids");
879 for (size_t i
= 0; i
< swap_promise_list_
.size(); i
++)
880 state
->AppendDouble(swap_promise_list_
[i
]->TraceId());
884 void LayerTreeImpl::SetRootLayerScrollOffsetDelegate(
885 LayerScrollOffsetDelegate
* root_layer_scroll_offset_delegate
) {
886 if (root_layer_scroll_offset_delegate_
== root_layer_scroll_offset_delegate
)
889 if (!root_layer_scroll_offset_delegate
) {
890 // Make sure we remove the proxies from their layers before
892 if (InnerViewportScrollLayer())
893 InnerViewportScrollLayer()->SetScrollOffsetDelegate(NULL
);
894 if (OuterViewportScrollLayer())
895 OuterViewportScrollLayer()->SetScrollOffsetDelegate(NULL
);
896 inner_viewport_scroll_delegate_proxy_
= nullptr;
897 outer_viewport_scroll_delegate_proxy_
= nullptr;
900 root_layer_scroll_offset_delegate_
= root_layer_scroll_offset_delegate
;
902 if (root_layer_scroll_offset_delegate_
) {
903 root_layer_scroll_offset_delegate_
->UpdateRootLayerState(
905 TotalMaxScrollOffset(),
907 total_page_scale_factor(),
908 min_page_scale_factor(),
909 max_page_scale_factor());
911 if (inner_viewport_scroll_layer_
) {
912 inner_viewport_scroll_delegate_proxy_
= make_scoped_ptr(
913 new LayerScrollOffsetDelegateProxy(InnerViewportScrollLayer(),
914 root_layer_scroll_offset_delegate_
,
916 inner_viewport_scroll_layer_
->SetScrollOffsetDelegate(
917 inner_viewport_scroll_delegate_proxy_
.get());
920 if (outer_viewport_scroll_layer_
) {
921 outer_viewport_scroll_delegate_proxy_
= make_scoped_ptr(
922 new LayerScrollOffsetDelegateProxy(OuterViewportScrollLayer(),
923 root_layer_scroll_offset_delegate_
,
925 outer_viewport_scroll_layer_
->SetScrollOffsetDelegate(
926 outer_viewport_scroll_delegate_proxy_
.get());
931 void LayerTreeImpl::UpdateScrollOffsetDelegate() {
932 DCHECK(InnerViewportScrollLayer());
933 DCHECK(root_layer_scroll_offset_delegate_
);
935 gfx::ScrollOffset offset
=
936 inner_viewport_scroll_delegate_proxy_
->last_set_scroll_offset();
938 if (OuterViewportScrollLayer())
939 offset
+= outer_viewport_scroll_delegate_proxy_
->last_set_scroll_offset();
941 root_layer_scroll_offset_delegate_
->UpdateRootLayerState(
943 TotalMaxScrollOffset(),
945 total_page_scale_factor(),
946 min_page_scale_factor(),
947 max_page_scale_factor());
950 gfx::ScrollOffset
LayerTreeImpl::GetDelegatedScrollOffset(LayerImpl
* layer
) {
951 DCHECK(root_layer_scroll_offset_delegate_
);
952 DCHECK(InnerViewportScrollLayer());
953 if (layer
== InnerViewportScrollLayer() && !OuterViewportScrollLayer())
954 return root_layer_scroll_offset_delegate_
->GetTotalScrollOffset();
956 // If we get here, we have both inner/outer viewports, and need to distribute
957 // the scroll offset between them.
958 DCHECK(inner_viewport_scroll_delegate_proxy_
);
959 DCHECK(outer_viewport_scroll_delegate_proxy_
);
960 gfx::ScrollOffset inner_viewport_offset
=
961 inner_viewport_scroll_delegate_proxy_
->last_set_scroll_offset();
962 gfx::ScrollOffset outer_viewport_offset
=
963 outer_viewport_scroll_delegate_proxy_
->last_set_scroll_offset();
965 // It may be nothing has changed.
966 gfx::ScrollOffset delegate_offset
=
967 root_layer_scroll_offset_delegate_
->GetTotalScrollOffset();
968 if (inner_viewport_offset
+ outer_viewport_offset
== delegate_offset
) {
969 if (layer
== InnerViewportScrollLayer())
970 return inner_viewport_offset
;
972 return outer_viewport_offset
;
975 gfx::ScrollOffset max_outer_viewport_scroll_offset
=
976 OuterViewportScrollLayer()->MaxScrollOffset();
978 outer_viewport_offset
= delegate_offset
- inner_viewport_offset
;
979 outer_viewport_offset
.SetToMin(max_outer_viewport_scroll_offset
);
980 outer_viewport_offset
.SetToMax(gfx::ScrollOffset());
982 if (layer
== OuterViewportScrollLayer())
983 return outer_viewport_offset
;
985 inner_viewport_offset
= delegate_offset
- outer_viewport_offset
;
987 return inner_viewport_offset
;
990 void LayerTreeImpl::QueueSwapPromise(scoped_ptr
<SwapPromise
> swap_promise
) {
991 DCHECK(swap_promise
);
992 swap_promise_list_
.push_back(swap_promise
.Pass());
995 void LayerTreeImpl::PassSwapPromises(
996 ScopedPtrVector
<SwapPromise
>* new_swap_promise
) {
997 swap_promise_list_
.insert_and_take(swap_promise_list_
.end(),
999 new_swap_promise
->clear();
1002 void LayerTreeImpl::FinishSwapPromises(CompositorFrameMetadata
* metadata
) {
1003 for (size_t i
= 0; i
< swap_promise_list_
.size(); i
++)
1004 swap_promise_list_
[i
]->DidSwap(metadata
);
1005 swap_promise_list_
.clear();
1008 void LayerTreeImpl::BreakSwapPromises(SwapPromise::DidNotSwapReason reason
) {
1009 for (size_t i
= 0; i
< swap_promise_list_
.size(); i
++)
1010 swap_promise_list_
[i
]->DidNotSwap(reason
);
1011 swap_promise_list_
.clear();
1014 void LayerTreeImpl::DidModifyTilePriorities() {
1015 layer_tree_host_impl_
->DidModifyTilePriorities();
1018 void LayerTreeImpl::set_ui_resource_request_queue(
1019 const UIResourceRequestQueue
& queue
) {
1020 ui_resource_request_queue_
= queue
;
1023 ResourceProvider::ResourceId
LayerTreeImpl::ResourceIdForUIResource(
1024 UIResourceId uid
) const {
1025 return layer_tree_host_impl_
->ResourceIdForUIResource(uid
);
1028 bool LayerTreeImpl::IsUIResourceOpaque(UIResourceId uid
) const {
1029 return layer_tree_host_impl_
->IsUIResourceOpaque(uid
);
1032 void LayerTreeImpl::ProcessUIResourceRequestQueue() {
1033 while (ui_resource_request_queue_
.size() > 0) {
1034 UIResourceRequest req
= ui_resource_request_queue_
.front();
1035 ui_resource_request_queue_
.pop_front();
1037 switch (req
.GetType()) {
1038 case UIResourceRequest::UIResourceCreate
:
1039 layer_tree_host_impl_
->CreateUIResource(req
.GetId(), req
.GetBitmap());
1041 case UIResourceRequest::UIResourceDelete
:
1042 layer_tree_host_impl_
->DeleteUIResource(req
.GetId());
1044 case UIResourceRequest::UIResourceInvalidRequest
:
1050 // If all UI resource evictions were not recreated by processing this queue,
1051 // then another commit is required.
1052 if (layer_tree_host_impl_
->EvictedUIResourcesExist())
1053 layer_tree_host_impl_
->SetNeedsCommit();
1056 void LayerTreeImpl::AddLayerWithCopyOutputRequest(LayerImpl
* layer
) {
1057 // Only the active tree needs to know about layers with copy requests, as
1058 // they are aborted if not serviced during draw.
1059 DCHECK(IsActiveTree());
1061 // DCHECK(std::find(layers_with_copy_output_request_.begin(),
1062 // layers_with_copy_output_request_.end(),
1063 // layer) == layers_with_copy_output_request_.end());
1064 // TODO(danakj): Remove this once crash is found crbug.com/309777
1065 for (size_t i
= 0; i
< layers_with_copy_output_request_
.size(); ++i
) {
1066 CHECK(layers_with_copy_output_request_
[i
] != layer
)
1067 << i
<< " of " << layers_with_copy_output_request_
.size();
1069 layers_with_copy_output_request_
.push_back(layer
);
1072 void LayerTreeImpl::RemoveLayerWithCopyOutputRequest(LayerImpl
* layer
) {
1073 // Only the active tree needs to know about layers with copy requests, as
1074 // they are aborted if not serviced during draw.
1075 DCHECK(IsActiveTree());
1077 std::vector
<LayerImpl
*>::iterator it
= std::find(
1078 layers_with_copy_output_request_
.begin(),
1079 layers_with_copy_output_request_
.end(),
1081 DCHECK(it
!= layers_with_copy_output_request_
.end());
1082 layers_with_copy_output_request_
.erase(it
);
1084 // TODO(danakj): Remove this once crash is found crbug.com/309777
1085 for (size_t i
= 0; i
< layers_with_copy_output_request_
.size(); ++i
) {
1086 CHECK(layers_with_copy_output_request_
[i
] != layer
)
1087 << i
<< " of " << layers_with_copy_output_request_
.size();
1091 const std::vector
<LayerImpl
*>& LayerTreeImpl::LayersWithCopyOutputRequest()
1093 // Only the active tree needs to know about layers with copy requests, as
1094 // they are aborted if not serviced during draw.
1095 DCHECK(IsActiveTree());
1097 return layers_with_copy_output_request_
;
1100 void LayerTreeImpl::ReleaseResourcesRecursive(LayerImpl
* current
) {
1102 current
->ReleaseResources();
1103 if (current
->mask_layer())
1104 ReleaseResourcesRecursive(current
->mask_layer());
1105 if (current
->replica_layer())
1106 ReleaseResourcesRecursive(current
->replica_layer());
1107 for (size_t i
= 0; i
< current
->children().size(); ++i
)
1108 ReleaseResourcesRecursive(current
->children()[i
]);
1111 template <typename LayerType
>
1112 static inline bool LayerClipsSubtree(LayerType
* layer
) {
1113 return layer
->masks_to_bounds() || layer
->mask_layer();
1116 static bool PointHitsRect(
1117 const gfx::PointF
& screen_space_point
,
1118 const gfx::Transform
& local_space_to_screen_space_transform
,
1119 const gfx::RectF
& local_space_rect
,
1120 float* distance_to_camera
) {
1121 // If the transform is not invertible, then assume that this point doesn't hit
1123 gfx::Transform
inverse_local_space_to_screen_space(
1124 gfx::Transform::kSkipInitialization
);
1125 if (!local_space_to_screen_space_transform
.GetInverse(
1126 &inverse_local_space_to_screen_space
))
1129 // Transform the hit test point from screen space to the local space of the
1131 bool clipped
= false;
1132 gfx::Point3F planar_point
= MathUtil::ProjectPoint3D(
1133 inverse_local_space_to_screen_space
, screen_space_point
, &clipped
);
1134 gfx::PointF hit_test_point_in_local_space
=
1135 gfx::PointF(planar_point
.x(), planar_point
.y());
1137 // If ProjectPoint could not project to a valid value, then we assume that
1138 // this point doesn't hit this rect.
1142 if (!local_space_rect
.Contains(hit_test_point_in_local_space
))
1145 if (distance_to_camera
) {
1146 // To compute the distance to the camera, we have to take the planar point
1147 // and pull it back to world space and compute the displacement along the
1149 gfx::Point3F
planar_point_in_screen_space(planar_point
);
1150 local_space_to_screen_space_transform
.TransformPoint(
1151 &planar_point_in_screen_space
);
1152 *distance_to_camera
= planar_point_in_screen_space
.z();
1158 static bool PointHitsRegion(const gfx::PointF
& screen_space_point
,
1159 const gfx::Transform
& screen_space_transform
,
1160 const Region
& layer_space_region
,
1161 float layer_content_scale_x
,
1162 float layer_content_scale_y
) {
1163 // If the transform is not invertible, then assume that this point doesn't hit
1165 gfx::Transform
inverse_screen_space_transform(
1166 gfx::Transform::kSkipInitialization
);
1167 if (!screen_space_transform
.GetInverse(&inverse_screen_space_transform
))
1170 // Transform the hit test point from screen space to the local space of the
1172 bool clipped
= false;
1173 gfx::PointF hit_test_point_in_content_space
= MathUtil::ProjectPoint(
1174 inverse_screen_space_transform
, screen_space_point
, &clipped
);
1175 gfx::PointF hit_test_point_in_layer_space
=
1176 gfx::ScalePoint(hit_test_point_in_content_space
,
1177 1.f
/ layer_content_scale_x
,
1178 1.f
/ layer_content_scale_y
);
1180 // If ProjectPoint could not project to a valid value, then we assume that
1181 // this point doesn't hit this region.
1185 return layer_space_region
.Contains(
1186 gfx::ToRoundedPoint(hit_test_point_in_layer_space
));
1189 static const LayerImpl
* GetNextClippingLayer(const LayerImpl
* layer
) {
1190 if (layer
->scroll_parent())
1191 return layer
->scroll_parent();
1192 if (layer
->clip_parent())
1193 return layer
->clip_parent();
1194 return layer
->parent();
1197 static bool PointIsClippedBySurfaceOrClipRect(
1198 const gfx::PointF
& screen_space_point
,
1199 const LayerImpl
* layer
) {
1200 // Walk up the layer tree and hit-test any render_surfaces and any layer
1201 // clip rects that are active.
1202 for (; layer
; layer
= GetNextClippingLayer(layer
)) {
1203 if (layer
->render_surface() &&
1204 !PointHitsRect(screen_space_point
,
1205 layer
->render_surface()->screen_space_transform(),
1206 layer
->render_surface()->content_rect(),
1210 if (LayerClipsSubtree(layer
) &&
1211 !PointHitsRect(screen_space_point
,
1212 layer
->screen_space_transform(),
1213 gfx::Rect(layer
->content_bounds()),
1218 // If we have finished walking all ancestors without having already exited,
1219 // then the point is not clipped by any ancestors.
1223 static bool PointHitsLayer(const LayerImpl
* layer
,
1224 const gfx::PointF
& screen_space_point
,
1225 float* distance_to_intersection
) {
1226 gfx::RectF
content_rect(layer
->content_bounds());
1227 if (!PointHitsRect(screen_space_point
,
1228 layer
->screen_space_transform(),
1230 distance_to_intersection
))
1233 // At this point, we think the point does hit the layer, but we need to walk
1234 // up the parents to ensure that the layer was not clipped in such a way
1235 // that the hit point actually should not hit the layer.
1236 if (PointIsClippedBySurfaceOrClipRect(screen_space_point
, layer
))
1239 // Skip the HUD layer.
1240 if (layer
== layer
->layer_tree_impl()->hud_layer())
1246 struct FindClosestMatchingLayerDataForRecursion
{
1247 FindClosestMatchingLayerDataForRecursion()
1248 : closest_match(NULL
),
1249 closest_distance(-std::numeric_limits
<float>::infinity()) {}
1250 LayerImpl
* closest_match
;
1251 // Note that the positive z-axis points towards the camera, so bigger means
1252 // closer in this case, counterintuitively.
1253 float closest_distance
;
1256 template <typename Functor
>
1257 static void FindClosestMatchingLayer(
1258 const gfx::PointF
& screen_space_point
,
1260 const Functor
& func
,
1261 FindClosestMatchingLayerDataForRecursion
* data_for_recursion
) {
1262 for (int i
= layer
->children().size() - 1; i
>= 0; --i
) {
1263 FindClosestMatchingLayer(
1264 screen_space_point
, layer
->children()[i
], func
, data_for_recursion
);
1267 float distance_to_intersection
= 0.f
;
1269 PointHitsLayer(layer
, screen_space_point
, &distance_to_intersection
) &&
1270 ((!data_for_recursion
->closest_match
||
1271 distance_to_intersection
> data_for_recursion
->closest_distance
))) {
1272 data_for_recursion
->closest_distance
= distance_to_intersection
;
1273 data_for_recursion
->closest_match
= layer
;
1277 static bool ScrollsAnyDrawnRenderSurfaceLayerListMember(LayerImpl
* layer
) {
1278 if (!layer
->scrollable())
1280 if (layer
->IsDrawnRenderSurfaceLayerListMember())
1282 if (!layer
->scroll_children())
1284 for (std::set
<LayerImpl
*>::const_iterator it
=
1285 layer
->scroll_children()->begin();
1286 it
!= layer
->scroll_children()->end();
1288 if ((*it
)->IsDrawnRenderSurfaceLayerListMember())
1294 struct FindScrollingLayerFunctor
{
1295 bool operator()(LayerImpl
* layer
) const {
1296 return ScrollsAnyDrawnRenderSurfaceLayerListMember(layer
);
1300 LayerImpl
* LayerTreeImpl::FindFirstScrollingLayerThatIsHitByPoint(
1301 const gfx::PointF
& screen_space_point
) {
1302 FindClosestMatchingLayerDataForRecursion data_for_recursion
;
1303 FindClosestMatchingLayer(screen_space_point
,
1305 FindScrollingLayerFunctor(),
1306 &data_for_recursion
);
1307 return data_for_recursion
.closest_match
;
1310 struct HitTestVisibleScrollableOrTouchableFunctor
{
1311 bool operator()(LayerImpl
* layer
) const {
1312 return layer
->IsDrawnRenderSurfaceLayerListMember() ||
1313 ScrollsAnyDrawnRenderSurfaceLayerListMember(layer
) ||
1314 !layer
->touch_event_handler_region().IsEmpty() ||
1315 layer
->have_wheel_event_handlers();
1319 LayerImpl
* LayerTreeImpl::FindLayerThatIsHitByPoint(
1320 const gfx::PointF
& screen_space_point
) {
1323 if (!UpdateDrawProperties())
1325 FindClosestMatchingLayerDataForRecursion data_for_recursion
;
1326 FindClosestMatchingLayer(screen_space_point
,
1328 HitTestVisibleScrollableOrTouchableFunctor(),
1329 &data_for_recursion
);
1330 return data_for_recursion
.closest_match
;
1333 static bool LayerHasTouchEventHandlersAt(const gfx::PointF
& screen_space_point
,
1334 LayerImpl
* layer_impl
) {
1335 if (layer_impl
->touch_event_handler_region().IsEmpty())
1338 if (!PointHitsRegion(screen_space_point
,
1339 layer_impl
->screen_space_transform(),
1340 layer_impl
->touch_event_handler_region(),
1341 layer_impl
->contents_scale_x(),
1342 layer_impl
->contents_scale_y()))
1345 // At this point, we think the point does hit the touch event handler region
1346 // on the layer, but we need to walk up the parents to ensure that the layer
1347 // was not clipped in such a way that the hit point actually should not hit
1349 if (PointIsClippedBySurfaceOrClipRect(screen_space_point
, layer_impl
))
1355 struct FindTouchEventLayerFunctor
{
1356 bool operator()(LayerImpl
* layer
) const {
1357 return LayerHasTouchEventHandlersAt(screen_space_point
, layer
);
1359 const gfx::PointF screen_space_point
;
1362 LayerImpl
* LayerTreeImpl::FindLayerThatIsHitByPointInTouchHandlerRegion(
1363 const gfx::PointF
& screen_space_point
) {
1366 if (!UpdateDrawProperties())
1368 FindTouchEventLayerFunctor func
= {screen_space_point
};
1369 FindClosestMatchingLayerDataForRecursion data_for_recursion
;
1370 FindClosestMatchingLayer(
1371 screen_space_point
, root_layer(), func
, &data_for_recursion
);
1372 return data_for_recursion
.closest_match
;
1375 void LayerTreeImpl::RegisterSelection(const LayerSelectionBound
& start
,
1376 const LayerSelectionBound
& end
) {
1377 selection_start_
= start
;
1378 selection_end_
= end
;
1381 static ViewportSelectionBound
ComputeViewportSelection(
1382 const LayerSelectionBound
& layer_bound
,
1384 float device_scale_factor
) {
1385 ViewportSelectionBound viewport_bound
;
1386 viewport_bound
.type
= layer_bound
.type
;
1388 if (!layer
|| layer_bound
.type
== SELECTION_BOUND_EMPTY
)
1389 return viewport_bound
;
1391 gfx::PointF layer_scaled_top
= gfx::ScalePoint(layer_bound
.edge_top
,
1392 layer
->contents_scale_x(),
1393 layer
->contents_scale_y());
1394 gfx::PointF layer_scaled_bottom
= gfx::ScalePoint(layer_bound
.edge_bottom
,
1395 layer
->contents_scale_x(),
1396 layer
->contents_scale_y());
1398 bool clipped
= false;
1399 gfx::PointF screen_top
= MathUtil::MapPoint(
1400 layer
->screen_space_transform(), layer_scaled_top
, &clipped
);
1401 gfx::PointF screen_bottom
= MathUtil::MapPoint(
1402 layer
->screen_space_transform(), layer_scaled_bottom
, &clipped
);
1404 const float inv_scale
= 1.f
/ device_scale_factor
;
1405 viewport_bound
.edge_top
= gfx::ScalePoint(screen_top
, inv_scale
);
1406 viewport_bound
.edge_bottom
= gfx::ScalePoint(screen_bottom
, inv_scale
);
1408 // The bottom edge point is used for visibility testing as it is the logical
1409 // focal point for bound selection handles (this may change in the future).
1410 // Shifting the visibility point fractionally inward ensures that neighboring
1411 // or logically coincident layers aligned to integral DPI coordinates will not
1412 // spuriously occlude the bound.
1413 gfx::Vector2dF visibility_offset
= layer_scaled_top
- layer_scaled_bottom
;
1414 visibility_offset
.Scale(device_scale_factor
/ visibility_offset
.Length());
1415 gfx::PointF visibility_point
= layer_scaled_bottom
+ visibility_offset
;
1416 if (visibility_point
.x() <= 0)
1417 visibility_point
.set_x(visibility_point
.x() + device_scale_factor
);
1418 visibility_point
= MathUtil::MapPoint(
1419 layer
->screen_space_transform(), visibility_point
, &clipped
);
1421 float intersect_distance
= 0.f
;
1422 viewport_bound
.visible
=
1423 PointHitsLayer(layer
, visibility_point
, &intersect_distance
);
1425 return viewport_bound
;
1428 void LayerTreeImpl::GetViewportSelection(ViewportSelectionBound
* start
,
1429 ViewportSelectionBound
* end
) {
1433 *start
= ComputeViewportSelection(
1435 selection_start_
.layer_id
? LayerById(selection_start_
.layer_id
) : NULL
,
1436 device_scale_factor());
1437 if (start
->type
== SELECTION_BOUND_CENTER
||
1438 start
->type
== SELECTION_BOUND_EMPTY
) {
1441 *end
= ComputeViewportSelection(
1443 selection_end_
.layer_id
? LayerById(selection_end_
.layer_id
) : NULL
,
1444 device_scale_factor());
1448 void LayerTreeImpl::RegisterPictureLayerImpl(PictureLayerImpl
* layer
) {
1449 layer_tree_host_impl_
->RegisterPictureLayerImpl(layer
);
1452 void LayerTreeImpl::UnregisterPictureLayerImpl(PictureLayerImpl
* layer
) {
1453 layer_tree_host_impl_
->UnregisterPictureLayerImpl(layer
);
1456 void LayerTreeImpl::InputScrollAnimationFinished() {
1457 layer_tree_host_impl_
->ScrollEnd();
1460 BlockingTaskRunner
* LayerTreeImpl::BlockingMainThreadTaskRunner() const {
1461 return proxy()->blocking_main_thread_task_runner();
1464 void LayerTreeImpl::SetPageScaleAnimation(
1465 const gfx::Vector2d
& target_offset
,
1468 base::TimeDelta duration
) {
1469 if (!InnerViewportScrollLayer())
1472 gfx::ScrollOffset scroll_total
= TotalScrollOffset();
1473 gfx::SizeF scaled_scrollable_size
= ScrollableSize();
1474 gfx::SizeF viewport_size
= InnerViewportContainerLayer()->bounds();
1476 // Easing constants experimentally determined.
1477 scoped_ptr
<TimingFunction
> timing_function
=
1478 CubicBezierTimingFunction::Create(.8, 0, .3, .9);
1480 // TODO(miletus) : Pass in ScrollOffset.
1481 page_scale_animation_
=
1482 PageScaleAnimation::Create(ScrollOffsetToVector2dF(scroll_total
),
1483 total_page_scale_factor(),
1485 scaled_scrollable_size
,
1486 timing_function
.Pass());
1489 gfx::Vector2dF
anchor(target_offset
);
1490 page_scale_animation_
->ZoomWithAnchor(anchor
,
1492 duration
.InSecondsF());
1494 gfx::Vector2dF scaled_target_offset
= target_offset
;
1495 page_scale_animation_
->ZoomTo(scaled_target_offset
,
1497 duration
.InSecondsF());
1501 scoped_ptr
<PageScaleAnimation
> LayerTreeImpl::TakePageScaleAnimation() {
1502 return page_scale_animation_
.Pass();