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"
11 #include "base/trace_event/trace_event.h"
12 #include "base/trace_event/trace_event_argument.h"
13 #include "cc/animation/keyframed_animation_curve.h"
14 #include "cc/animation/scrollbar_animation_controller.h"
15 #include "cc/animation/scrollbar_animation_controller_linear_fade.h"
16 #include "cc/animation/scrollbar_animation_controller_thinning.h"
17 #include "cc/base/math_util.h"
18 #include "cc/base/synced_property.h"
19 #include "cc/debug/devtools_instrumentation.h"
20 #include "cc/debug/traced_value.h"
21 #include "cc/input/layer_scroll_offset_delegate.h"
22 #include "cc/input/page_scale_animation.h"
23 #include "cc/layers/heads_up_display_layer_impl.h"
24 #include "cc/layers/layer.h"
25 #include "cc/layers/layer_iterator.h"
26 #include "cc/layers/render_surface_impl.h"
27 #include "cc/layers/scrollbar_layer_impl_base.h"
28 #include "cc/resources/ui_resource_request.h"
29 #include "cc/trees/layer_tree_host_common.h"
30 #include "cc/trees/layer_tree_host_impl.h"
31 #include "cc/trees/occlusion_tracker.h"
32 #include "cc/trees/property_tree_builder.h"
33 #include "ui/gfx/geometry/point_conversions.h"
34 #include "ui/gfx/geometry/size_conversions.h"
35 #include "ui/gfx/geometry/vector2d_conversions.h"
39 LayerTreeImpl::LayerTreeImpl(
40 LayerTreeHostImpl
* layer_tree_host_impl
,
41 scoped_refptr
<SyncedProperty
<ScaleGroup
>> page_scale_factor
,
42 scoped_refptr
<SyncedTopControls
> top_controls_shown_ratio
,
43 scoped_refptr
<SyncedElasticOverscroll
> elastic_overscroll
)
44 : layer_tree_host_impl_(layer_tree_host_impl
),
45 source_frame_number_(-1),
47 currently_scrolling_layer_(NULL
),
48 root_layer_scroll_offset_delegate_(NULL
),
50 has_transparent_background_(false),
51 overscroll_elasticity_layer_(NULL
),
52 page_scale_layer_(NULL
),
53 inner_viewport_scroll_layer_(NULL
),
54 outer_viewport_scroll_layer_(NULL
),
55 page_scale_factor_(page_scale_factor
),
56 min_page_scale_factor_(0),
57 max_page_scale_factor_(0),
58 elastic_overscroll_(elastic_overscroll
),
59 scrolling_layer_id_from_previous_tree_(0),
60 contents_textures_purged_(false),
61 viewport_size_invalid_(false),
62 needs_update_draw_properties_(true),
63 needs_full_tree_sync_(true),
64 next_activation_forces_redraw_(false),
65 has_ever_been_drawn_(false),
66 render_surface_layer_list_id_(0),
67 top_controls_shrink_blink_size_(false),
68 top_controls_height_(0),
69 top_controls_shown_ratio_(top_controls_shown_ratio
) {
72 LayerTreeImpl::~LayerTreeImpl() {
73 BreakSwapPromises(IsActiveTree() ? SwapPromise::SWAP_FAILS
74 : SwapPromise::ACTIVATION_FAILS
);
76 // Need to explicitly clear the tree prior to destroying this so that
77 // the LayerTreeImpl pointer is still valid in the LayerImpl dtor.
79 DCHECK(layers_with_copy_output_request_
.empty());
82 void LayerTreeImpl::Shutdown() {
83 root_layer_
= nullptr;
86 void LayerTreeImpl::ReleaseResources() {
88 LayerTreeHostCommon::CallFunctionForSubtree(
89 root_layer_
.get(), [](LayerImpl
* layer
) { layer
->ReleaseResources(); });
93 void LayerTreeImpl::RecreateResources() {
95 LayerTreeHostCommon::CallFunctionForSubtree(
97 [](LayerImpl
* layer
) { layer
->RecreateResources(); });
101 void LayerTreeImpl::GatherFrameTimingRequestIds(
102 std::vector
<int64_t>* request_ids
) {
106 // TODO(vmpstr): Early out if there are no requests on any of the layers. For
107 // that, we need to inform LayerTreeImpl whenever there are requests when we
109 LayerTreeHostCommon::CallFunctionForSubtree(
110 root_layer_
.get(), [request_ids
](LayerImpl
* layer
) {
111 layer
->GatherFrameTimingRequestIds(request_ids
);
115 bool LayerTreeImpl::IsExternalScrollActive() const {
116 return root_layer_scroll_offset_delegate_
&&
117 root_layer_scroll_offset_delegate_
->IsExternalScrollActive();
120 void LayerTreeImpl::DidUpdateScrollOffset(int layer_id
) {
121 int inner_layer_id
= InnerViewportScrollLayer()
122 ? InnerViewportScrollLayer()->id()
124 int outer_layer_id
= OuterViewportScrollLayer()
125 ? OuterViewportScrollLayer()->id()
127 if (layer_id
!= outer_layer_id
&& layer_id
!= inner_layer_id
)
130 if (!root_layer_scroll_offset_delegate_
)
133 UpdateRootScrollOffsetDelegate();
136 void LayerTreeImpl::SetRootLayer(scoped_ptr
<LayerImpl
> layer
) {
137 root_layer_
= layer
.Pass();
138 currently_scrolling_layer_
= NULL
;
139 inner_viewport_scroll_layer_
= NULL
;
140 outer_viewport_scroll_layer_
= NULL
;
141 page_scale_layer_
= NULL
;
143 layer_tree_host_impl_
->OnCanDrawStateChangedForTree();
146 LayerImpl
* LayerTreeImpl::InnerViewportScrollLayer() const {
147 return inner_viewport_scroll_layer_
;
150 LayerImpl
* LayerTreeImpl::OuterViewportScrollLayer() const {
151 return outer_viewport_scroll_layer_
;
154 gfx::ScrollOffset
LayerTreeImpl::TotalScrollOffset() const {
155 gfx::ScrollOffset offset
;
157 if (inner_viewport_scroll_layer_
)
158 offset
+= inner_viewport_scroll_layer_
->CurrentScrollOffset();
160 if (outer_viewport_scroll_layer_
)
161 offset
+= outer_viewport_scroll_layer_
->CurrentScrollOffset();
166 gfx::ScrollOffset
LayerTreeImpl::TotalMaxScrollOffset() const {
167 gfx::ScrollOffset offset
;
169 if (inner_viewport_scroll_layer_
)
170 offset
+= inner_viewport_scroll_layer_
->MaxScrollOffset();
172 if (outer_viewport_scroll_layer_
)
173 offset
+= outer_viewport_scroll_layer_
->MaxScrollOffset();
178 scoped_ptr
<LayerImpl
> LayerTreeImpl::DetachLayerTree() {
179 // Clear all data structures that have direct references to the layer tree.
180 scrolling_layer_id_from_previous_tree_
=
181 currently_scrolling_layer_
? currently_scrolling_layer_
->id() : 0;
182 inner_viewport_scroll_layer_
= NULL
;
183 outer_viewport_scroll_layer_
= NULL
;
184 page_scale_layer_
= NULL
;
185 currently_scrolling_layer_
= NULL
;
187 render_surface_layer_list_
.clear();
188 set_needs_update_draw_properties();
189 return root_layer_
.Pass();
192 void LayerTreeImpl::PushPropertiesTo(LayerTreeImpl
* target_tree
) {
193 // The request queue should have been processed and does not require a push.
194 DCHECK_EQ(ui_resource_request_queue_
.size(), 0u);
196 target_tree
->SetPropertyTrees(property_trees_
);
198 if (next_activation_forces_redraw_
) {
199 target_tree
->ForceRedrawNextActivation();
200 next_activation_forces_redraw_
= false;
203 target_tree
->PassSwapPromises(&swap_promise_list_
);
205 target_tree
->set_top_controls_shrink_blink_size(
206 top_controls_shrink_blink_size_
);
207 target_tree
->set_top_controls_height(top_controls_height_
);
208 target_tree
->PushTopControls(nullptr);
210 // Active tree already shares the page_scale_factor object with pending
211 // tree so only the limits need to be provided.
212 target_tree
->PushPageScaleFactorAndLimits(nullptr, min_page_scale_factor(),
213 max_page_scale_factor());
214 target_tree
->elastic_overscroll()->PushPendingToActive();
216 target_tree
->pending_page_scale_animation_
=
217 pending_page_scale_animation_
.Pass();
219 if (page_scale_layer_
&& inner_viewport_scroll_layer_
) {
220 target_tree
->SetViewportLayersFromIds(
221 overscroll_elasticity_layer_
? overscroll_elasticity_layer_
->id()
223 page_scale_layer_
->id(), inner_viewport_scroll_layer_
->id(),
224 outer_viewport_scroll_layer_
? outer_viewport_scroll_layer_
->id()
225 : Layer::INVALID_ID
);
227 target_tree
->ClearViewportLayers();
230 target_tree
->RegisterSelection(selection_
);
232 // This should match the property synchronization in
233 // LayerTreeHost::finishCommitOnImplThread().
234 target_tree
->set_source_frame_number(source_frame_number());
235 target_tree
->set_background_color(background_color());
236 target_tree
->set_has_transparent_background(has_transparent_background());
238 if (ContentsTexturesPurged())
239 target_tree
->SetContentsTexturesPurged();
241 target_tree
->ResetContentsTexturesPurged();
243 if (ViewportSizeInvalid())
244 target_tree
->SetViewportSizeInvalid();
246 target_tree
->ResetViewportSizeInvalid();
249 target_tree
->set_hud_layer(static_cast<HeadsUpDisplayLayerImpl
*>(
250 LayerTreeHostCommon::FindLayerInSubtree(
251 target_tree
->root_layer(), hud_layer()->id())));
253 target_tree
->set_hud_layer(NULL
);
255 target_tree
->has_ever_been_drawn_
= false;
258 LayerImpl
* LayerTreeImpl::InnerViewportContainerLayer() const {
259 return inner_viewport_scroll_layer_
260 ? inner_viewport_scroll_layer_
->scroll_clip_layer()
264 LayerImpl
* LayerTreeImpl::OuterViewportContainerLayer() const {
265 return outer_viewport_scroll_layer_
266 ? outer_viewport_scroll_layer_
->scroll_clip_layer()
270 LayerImpl
* LayerTreeImpl::CurrentlyScrollingLayer() const {
271 DCHECK(IsActiveTree());
272 return currently_scrolling_layer_
;
275 void LayerTreeImpl::SetCurrentlyScrollingLayer(LayerImpl
* layer
) {
276 if (currently_scrolling_layer_
== layer
)
279 if (currently_scrolling_layer_
&&
280 currently_scrolling_layer_
->scrollbar_animation_controller())
281 currently_scrolling_layer_
->scrollbar_animation_controller()
283 currently_scrolling_layer_
= layer
;
284 if (layer
&& layer
->scrollbar_animation_controller())
285 layer
->scrollbar_animation_controller()->DidScrollBegin();
288 void LayerTreeImpl::ClearCurrentlyScrollingLayer() {
289 SetCurrentlyScrollingLayer(NULL
);
290 scrolling_layer_id_from_previous_tree_
= 0;
295 void ForceScrollbarParameterUpdateAfterScaleChange(LayerImpl
* current_layer
) {
299 while (current_layer
) {
300 current_layer
->ScrollbarParametersDidChange(false);
301 current_layer
= current_layer
->parent();
307 float LayerTreeImpl::ClampPageScaleFactorToLimits(
308 float page_scale_factor
) const {
309 if (min_page_scale_factor_
&& page_scale_factor
< min_page_scale_factor_
)
310 page_scale_factor
= min_page_scale_factor_
;
311 else if (max_page_scale_factor_
&& page_scale_factor
> max_page_scale_factor_
)
312 page_scale_factor
= max_page_scale_factor_
;
313 return page_scale_factor
;
316 void LayerTreeImpl::UpdatePropertyTreeScrollingFromMainThread() {
317 // TODO(enne): This should get replaced by pulling out scrolling into its own
318 // tree. Then scrolls would have their own way of synchronizing across
319 // commits. This occurs to push updates from scrolling deltas on the
320 // compositor thread that have occurred after begin frame to a newly-committed
324 LayerTreeHostCommon::CallFunctionForSubtree(
325 root_layer(), [](LayerImpl
* layer
) {
326 layer
->UpdatePropertyTreeForScrollingIfNeeded();
330 void LayerTreeImpl::SetPageScaleOnActiveTree(float active_page_scale
) {
331 DCHECK(IsActiveTree());
332 if (page_scale_factor()->SetCurrent(
333 ClampPageScaleFactorToLimits(active_page_scale
)))
334 DidUpdatePageScale();
337 void LayerTreeImpl::PushPageScaleFromMainThread(float page_scale_factor
,
338 float min_page_scale_factor
,
339 float max_page_scale_factor
) {
340 PushPageScaleFactorAndLimits(&page_scale_factor
, min_page_scale_factor
,
341 max_page_scale_factor
);
344 void LayerTreeImpl::PushPageScaleFactorAndLimits(const float* page_scale_factor
,
345 float min_page_scale_factor
,
346 float max_page_scale_factor
) {
347 DCHECK(page_scale_factor
|| IsActiveTree());
348 bool changed_page_scale
= false;
349 if (page_scale_factor
) {
350 DCHECK(!IsActiveTree() || !layer_tree_host_impl_
->pending_tree());
351 changed_page_scale
|= page_scale_factor_
->Delta() != 1.f
;
352 // TODO(enne): Once CDP goes away, ignore this call below. The only time
353 // the property trees will differ is if there's been a page scale on the
354 // compositor thread after the begin frame, which is the delta check above.
355 changed_page_scale
|=
356 page_scale_factor_
->PushFromMainThread(*page_scale_factor
);
358 if (IsActiveTree()) {
359 // TODO(enne): Pushing from pending to active should never require
360 // DidUpdatePageScale. The values should already be set by the fully
361 // computed property trees being synced from one tree to another. Remove
362 // this once CDP goes away.
363 changed_page_scale
|= page_scale_factor_
->PushPendingToActive();
366 changed_page_scale
|=
367 SetPageScaleFactorLimits(min_page_scale_factor
, max_page_scale_factor
);
369 if (changed_page_scale
)
370 DidUpdatePageScale();
373 void LayerTreeImpl::set_top_controls_shrink_blink_size(bool shrink
) {
374 if (top_controls_shrink_blink_size_
== shrink
)
377 top_controls_shrink_blink_size_
= shrink
;
379 layer_tree_host_impl_
->UpdateViewportContainerSizes();
382 void LayerTreeImpl::set_top_controls_height(float top_controls_height
) {
383 if (top_controls_height_
== top_controls_height
)
386 top_controls_height_
= top_controls_height
;
388 layer_tree_host_impl_
->UpdateViewportContainerSizes();
391 bool LayerTreeImpl::SetCurrentTopControlsShownRatio(float ratio
) {
392 ratio
= std::max(ratio
, 0.f
);
393 ratio
= std::min(ratio
, 1.f
);
394 return top_controls_shown_ratio_
->SetCurrent(ratio
);
397 void LayerTreeImpl::PushTopControlsFromMainThread(
398 float top_controls_shown_ratio
) {
399 PushTopControls(&top_controls_shown_ratio
);
402 void LayerTreeImpl::PushTopControls(const float* top_controls_shown_ratio
) {
403 DCHECK(top_controls_shown_ratio
|| IsActiveTree());
405 if (top_controls_shown_ratio
) {
406 DCHECK(!IsActiveTree() || !layer_tree_host_impl_
->pending_tree());
407 top_controls_shown_ratio_
->PushFromMainThread(*top_controls_shown_ratio
);
409 if (IsActiveTree()) {
410 if (top_controls_shown_ratio_
->PushPendingToActive())
411 layer_tree_host_impl_
->DidChangeTopControlsPosition();
415 bool LayerTreeImpl::SetPageScaleFactorLimits(float min_page_scale_factor
,
416 float max_page_scale_factor
) {
417 if (min_page_scale_factor
== min_page_scale_factor_
&&
418 max_page_scale_factor
== max_page_scale_factor_
)
421 min_page_scale_factor_
= min_page_scale_factor
;
422 max_page_scale_factor_
= max_page_scale_factor
;
427 void LayerTreeImpl::DidUpdatePageScale() {
429 page_scale_factor()->SetCurrent(
430 ClampPageScaleFactorToLimits(current_page_scale_factor()));
432 set_needs_update_draw_properties();
434 if (root_layer_scroll_offset_delegate_
) {
435 root_layer_scroll_offset_delegate_
->UpdateRootLayerState(
436 TotalScrollOffset(), TotalMaxScrollOffset(), ScrollableSize(),
437 current_page_scale_factor(), min_page_scale_factor_
,
438 max_page_scale_factor_
);
441 if (page_scale_layer() && page_scale_layer()->transform_tree_index() != -1) {
442 TransformNode
* node
= property_trees_
.transform_tree
.Node(
443 page_scale_layer()->transform_tree_index());
444 node
->data
.post_local_scale_factor
= current_page_scale_factor();
445 node
->data
.needs_local_transform_update
= true;
446 // TODO(enne): property trees can't ask the layer these things, but
447 // the page scale layer should *just* be the page scale.
448 DCHECK_EQ(page_scale_layer()->position().ToString(),
449 gfx::PointF().ToString());
450 DCHECK_EQ(page_scale_layer()->transform_origin().ToString(),
451 gfx::Point3F().ToString());
452 node
->data
.update_post_local_transform(gfx::PointF(), gfx::Point3F());
453 property_trees_
.transform_tree
.set_needs_update(true);
456 ForceScrollbarParameterUpdateAfterScaleChange(page_scale_layer());
458 HideInnerViewportScrollbarsIfNearMinimumScale();
461 void LayerTreeImpl::HideInnerViewportScrollbarsIfNearMinimumScale() {
462 if (!InnerViewportContainerLayer())
465 LayerImpl::ScrollbarSet
* scrollbars
=
466 InnerViewportContainerLayer()->scrollbars();
471 for (LayerImpl::ScrollbarSet::iterator it
= scrollbars
->begin();
472 it
!= scrollbars
->end();
474 ScrollbarLayerImplBase
* scrollbar
= *it
;
475 float minimum_scale_to_show_at
=
476 min_page_scale_factor() * settings().scrollbar_show_scale_threshold
;
477 scrollbar
->SetHideLayerAndSubtree(
478 current_page_scale_factor() < minimum_scale_to_show_at
);
482 SyncedProperty
<ScaleGroup
>* LayerTreeImpl::page_scale_factor() {
483 return page_scale_factor_
.get();
486 const SyncedProperty
<ScaleGroup
>* LayerTreeImpl::page_scale_factor() const {
487 return page_scale_factor_
.get();
490 gfx::SizeF
LayerTreeImpl::ScrollableViewportSize() const {
491 if (!InnerViewportContainerLayer())
494 return gfx::ScaleSize(InnerViewportContainerLayer()->BoundsForScrolling(),
495 1.0f
/ current_page_scale_factor());
498 gfx::Rect
LayerTreeImpl::RootScrollLayerDeviceViewportBounds() const {
499 LayerImpl
* root_scroll_layer
= OuterViewportScrollLayer()
500 ? OuterViewportScrollLayer()
501 : InnerViewportScrollLayer();
502 if (!root_scroll_layer
|| root_scroll_layer
->children().empty())
504 LayerImpl
* layer
= root_scroll_layer
->children()[0];
505 return MathUtil::MapEnclosingClippedRect(layer
->screen_space_transform(),
506 gfx::Rect(layer
->bounds()));
509 void LayerTreeImpl::ApplySentScrollAndScaleDeltasFromAbortedCommit() {
510 DCHECK(IsActiveTree());
512 page_scale_factor()->AbortCommit();
513 top_controls_shown_ratio()->AbortCommit();
514 elastic_overscroll()->AbortCommit();
519 LayerTreeHostCommon::CallFunctionForSubtree(
520 root_layer(), [](LayerImpl
* layer
) {
521 layer
->ApplySentScrollDeltasFromAbortedCommit();
525 void LayerTreeImpl::SetViewportLayersFromIds(
526 int overscroll_elasticity_layer_id
,
527 int page_scale_layer_id
,
528 int inner_viewport_scroll_layer_id
,
529 int outer_viewport_scroll_layer_id
) {
530 overscroll_elasticity_layer_
= LayerById(overscroll_elasticity_layer_id
);
531 page_scale_layer_
= LayerById(page_scale_layer_id
);
532 DCHECK(page_scale_layer_
);
534 inner_viewport_scroll_layer_
=
535 LayerById(inner_viewport_scroll_layer_id
);
536 DCHECK(inner_viewport_scroll_layer_
);
538 outer_viewport_scroll_layer_
=
539 LayerById(outer_viewport_scroll_layer_id
);
540 DCHECK(outer_viewport_scroll_layer_
||
541 outer_viewport_scroll_layer_id
== Layer::INVALID_ID
);
543 HideInnerViewportScrollbarsIfNearMinimumScale();
546 void LayerTreeImpl::ClearViewportLayers() {
547 page_scale_layer_
= NULL
;
548 inner_viewport_scroll_layer_
= NULL
;
549 outer_viewport_scroll_layer_
= NULL
;
552 bool LayerTreeImpl::UpdateDrawProperties(bool update_lcd_text
) {
553 if (!needs_update_draw_properties_
)
556 // Calling UpdateDrawProperties must clear this flag, so there can be no
557 // early outs before this.
558 needs_update_draw_properties_
= false;
560 // For max_texture_size. When the renderer is re-created in
561 // CreateAndSetRenderer, the needs update draw properties flag is set
563 if (!layer_tree_host_impl_
->renderer())
566 // Clear this after the renderer early out, as it should still be
567 // possible to hit test even without a renderer.
568 render_surface_layer_list_
.clear();
575 "cc", "LayerTreeImpl::UpdateDrawProperties::CalculateDrawProperties",
576 "IsActive", IsActiveTree(), "SourceFrameNumber", source_frame_number_
);
577 LayerImpl
* page_scale_layer
=
578 page_scale_layer_
? page_scale_layer_
: InnerViewportContainerLayer();
579 bool can_render_to_separate_surface
=
580 (layer_tree_host_impl_
->GetDrawMode() !=
581 DRAW_MODE_RESOURCELESS_SOFTWARE
);
583 ++render_surface_layer_list_id_
;
585 LayerTreeHostCommon::CalcDrawPropsImplInputs
inputs(
586 root_layer(), DrawViewportSize(),
587 layer_tree_host_impl_
->DrawTransform(), device_scale_factor(),
588 current_page_scale_factor(), page_scale_layer
,
589 elastic_overscroll()->Current(IsActiveTree()),
590 overscroll_elasticity_layer_
, resource_provider()->max_texture_size(),
591 settings().can_use_lcd_text
, settings().layers_always_allowed_lcd_text
,
592 can_render_to_separate_surface
,
593 settings().layer_transforms_should_scale_layer_contents
,
594 settings().verify_property_trees
, &render_surface_layer_list_
,
595 render_surface_layer_list_id_
, &property_trees_
);
596 LayerTreeHostCommon::CalculateDrawProperties(&inputs
);
600 TRACE_EVENT2("cc", "LayerTreeImpl::UpdateDrawProperties::Occlusion",
601 "IsActive", IsActiveTree(), "SourceFrameNumber",
602 source_frame_number_
);
603 OcclusionTracker
occlusion_tracker(
604 root_layer()->render_surface()->content_rect());
605 occlusion_tracker
.set_minimum_tracking_size(
606 settings().minimum_occlusion_tracking_size
);
608 // LayerIterator is used here instead of CallFunctionForSubtree to only
609 // UpdateTilePriorities on layers that will be visible (and thus have valid
610 // draw properties) and not because any ordering is required.
611 auto end
= LayerIterator
<LayerImpl
>::End(&render_surface_layer_list_
);
612 for (auto it
= LayerIterator
<LayerImpl
>::Begin(&render_surface_layer_list_
);
614 occlusion_tracker
.EnterLayer(it
);
616 // There are very few render targets so this should be cheap to do for
617 // each layer instead of something more complicated.
618 bool inside_replica
= false;
619 LayerImpl
* layer
= it
->render_target();
620 while (layer
&& !inside_replica
) {
621 if (layer
->render_target()->has_replica())
622 inside_replica
= true;
623 layer
= layer
->render_target()->parent();
626 // Don't use occlusion if a layer will appear in a replica, since the
627 // tile raster code does not know how to look for the replica and would
628 // consider it occluded even though the replica is visible.
629 // Since occlusion is only used for browser compositor (i.e.
630 // use_occlusion_for_tile_prioritization) and it won't use replicas,
631 // this should matter not.
633 if (it
.represents_itself()) {
634 Occlusion occlusion
=
635 inside_replica
? Occlusion()
636 : occlusion_tracker
.GetCurrentOcclusionForLayer(
637 it
->draw_transform());
638 it
->draw_properties().occlusion_in_content_space
= occlusion
;
641 if (it
.represents_contributing_render_surface()) {
642 // Surfaces aren't used by the tile raster code, so they can have
643 // occlusion regardless of replicas.
644 Occlusion occlusion
=
645 occlusion_tracker
.GetCurrentOcclusionForContributingSurface(
646 it
->render_surface()->draw_transform());
647 it
->render_surface()->set_occlusion_in_content_space(occlusion
);
648 // Masks are used to draw the contributing surface, so should have
649 // the same occlusion as the surface (nothing inside the surface
651 if (LayerImpl
* mask
= it
->mask_layer()) {
652 Occlusion mask_occlusion
=
655 : occlusion_tracker
.GetCurrentOcclusionForContributingSurface(
656 it
->render_surface()->draw_transform() *
657 it
->draw_transform());
658 mask
->draw_properties().occlusion_in_content_space
= mask_occlusion
;
660 if (LayerImpl
* replica
= it
->replica_layer()) {
661 if (LayerImpl
* mask
= replica
->mask_layer())
662 mask
->draw_properties().occlusion_in_content_space
= Occlusion();
666 occlusion_tracker
.LeaveLayer(it
);
669 unoccluded_screen_space_region_
=
670 occlusion_tracker
.ComputeVisibleRegionInScreen();
673 // It'd be ideal if this could be done earlier, but when the raster source
674 // is updated from the main thread during push properties, update draw
675 // properties has not occurred yet and so it's not clear whether or not the
676 // layer can or cannot use lcd text. So, this is the cleanup pass to
677 // determine if the raster source needs to be replaced with a non-lcd
678 // raster source due to draw properties.
679 if (update_lcd_text
) {
680 // TODO(enne): Make LTHI::sync_tree return this value.
681 LayerTreeImpl
* sync_tree
=
682 layer_tree_host_impl_
->proxy()->CommitToActiveTree()
683 ? layer_tree_host_impl_
->active_tree()
684 : layer_tree_host_impl_
->pending_tree();
685 // If this is not the sync tree, then it is not safe to update lcd text
686 // as it causes invalidations and the tiles may be in use.
687 DCHECK_EQ(this, sync_tree
);
688 for (const auto& layer
: picture_layers_
)
689 layer
->UpdateCanUseLCDTextAfterCommit();
693 TRACE_EVENT_BEGIN2("cc", "LayerTreeImpl::UpdateDrawProperties::UpdateTiles",
694 "IsActive", IsActiveTree(), "SourceFrameNumber",
695 source_frame_number_
);
696 const bool resourceless_software_draw
=
697 (layer_tree_host_impl_
->GetDrawMode() ==
698 DRAW_MODE_RESOURCELESS_SOFTWARE
);
699 size_t layers_updated_count
= 0;
700 bool tile_priorities_updated
= false;
701 for (PictureLayerImpl
* layer
: picture_layers_
) {
702 if (!layer
->IsDrawnRenderSurfaceLayerListMember())
704 ++layers_updated_count
;
705 tile_priorities_updated
|= layer
->UpdateTiles(resourceless_software_draw
);
708 if (tile_priorities_updated
)
709 DidModifyTilePriorities();
711 TRACE_EVENT_END1("cc", "LayerTreeImpl::UpdateTilePriorities",
712 "layers_updated_count", layers_updated_count
);
715 DCHECK(!needs_update_draw_properties_
) <<
716 "CalcDrawProperties should not set_needs_update_draw_properties()";
720 void LayerTreeImpl::BuildPropertyTreesForTesting() {
721 PropertyTreeBuilder::BuildPropertyTrees(
722 root_layer_
.get(), page_scale_layer_
, current_page_scale_factor(),
723 device_scale_factor(), gfx::Rect(DrawViewportSize()),
724 layer_tree_host_impl_
->DrawTransform(), &property_trees_
);
727 const LayerImplList
& LayerTreeImpl::RenderSurfaceLayerList() const {
728 // If this assert triggers, then the list is dirty.
729 DCHECK(!needs_update_draw_properties_
);
730 return render_surface_layer_list_
;
733 const Region
& LayerTreeImpl::UnoccludedScreenSpaceRegion() const {
734 // If this assert triggers, then the render_surface_layer_list_ is dirty, so
735 // the unoccluded_screen_space_region_ is not valid anymore.
736 DCHECK(!needs_update_draw_properties_
);
737 return unoccluded_screen_space_region_
;
740 gfx::Size
LayerTreeImpl::ScrollableSize() const {
741 LayerImpl
* root_scroll_layer
= OuterViewportScrollLayer()
742 ? OuterViewportScrollLayer()
743 : InnerViewportScrollLayer();
744 if (!root_scroll_layer
|| root_scroll_layer
->children().empty())
746 return root_scroll_layer
->children()[0]->bounds();
749 LayerImpl
* LayerTreeImpl::LayerById(int id
) {
750 LayerIdMap::iterator iter
= layer_id_map_
.find(id
);
751 return iter
!= layer_id_map_
.end() ? iter
->second
: NULL
;
754 void LayerTreeImpl::RegisterLayer(LayerImpl
* layer
) {
755 DCHECK(!LayerById(layer
->id()));
756 layer_id_map_
[layer
->id()] = layer
;
759 void LayerTreeImpl::UnregisterLayer(LayerImpl
* layer
) {
760 DCHECK(LayerById(layer
->id()));
761 layer_id_map_
.erase(layer
->id());
764 size_t LayerTreeImpl::NumLayers() {
765 return layer_id_map_
.size();
768 void LayerTreeImpl::PushPersistedState(LayerTreeImpl
* pending_tree
) {
769 pending_tree
->SetCurrentlyScrollingLayer(
770 LayerTreeHostCommon::FindLayerInSubtree(pending_tree
->root_layer(),
771 currently_scrolling_layer_
? currently_scrolling_layer_
->id() : 0));
774 void LayerTreeImpl::DidBecomeActive() {
775 if (next_activation_forces_redraw_
) {
776 layer_tree_host_impl_
->SetFullRootLayerDamage();
777 next_activation_forces_redraw_
= false;
780 if (scrolling_layer_id_from_previous_tree_
) {
781 currently_scrolling_layer_
= LayerTreeHostCommon::FindLayerInSubtree(
782 root_layer(), scrolling_layer_id_from_previous_tree_
);
785 // Always reset this flag on activation, as we would only have activated
786 // if we were in a good state.
787 layer_tree_host_impl_
->ResetRequiresHighResToDraw();
790 LayerTreeHostCommon::CallFunctionForSubtree(
791 root_layer(), [](LayerImpl
* layer
) { layer
->DidBecomeActive(); });
794 for (auto* swap_promise
: swap_promise_list_
)
795 swap_promise
->DidActivate();
796 devtools_instrumentation::DidActivateLayerTree(layer_tree_host_impl_
->id(),
797 source_frame_number_
);
800 bool LayerTreeImpl::ContentsTexturesPurged() const {
801 return contents_textures_purged_
;
804 void LayerTreeImpl::SetContentsTexturesPurged() {
805 if (contents_textures_purged_
)
807 contents_textures_purged_
= true;
808 layer_tree_host_impl_
->OnCanDrawStateChangedForTree();
811 void LayerTreeImpl::ResetContentsTexturesPurged() {
812 if (!contents_textures_purged_
)
814 contents_textures_purged_
= false;
815 layer_tree_host_impl_
->OnCanDrawStateChangedForTree();
818 bool LayerTreeImpl::RequiresHighResToDraw() const {
819 return layer_tree_host_impl_
->RequiresHighResToDraw();
822 bool LayerTreeImpl::ViewportSizeInvalid() const {
823 return viewport_size_invalid_
;
826 void LayerTreeImpl::SetViewportSizeInvalid() {
827 viewport_size_invalid_
= true;
828 layer_tree_host_impl_
->OnCanDrawStateChangedForTree();
831 void LayerTreeImpl::ResetViewportSizeInvalid() {
832 viewport_size_invalid_
= false;
833 layer_tree_host_impl_
->OnCanDrawStateChangedForTree();
836 Proxy
* LayerTreeImpl::proxy() const {
837 return layer_tree_host_impl_
->proxy();
840 const LayerTreeSettings
& LayerTreeImpl::settings() const {
841 return layer_tree_host_impl_
->settings();
844 const LayerTreeDebugState
& LayerTreeImpl::debug_state() const {
845 return layer_tree_host_impl_
->debug_state();
848 const RendererCapabilitiesImpl
& LayerTreeImpl::GetRendererCapabilities() const {
849 return layer_tree_host_impl_
->GetRendererCapabilities();
852 ContextProvider
* LayerTreeImpl::context_provider() const {
853 return output_surface()->context_provider();
856 OutputSurface
* LayerTreeImpl::output_surface() const {
857 return layer_tree_host_impl_
->output_surface();
860 ResourceProvider
* LayerTreeImpl::resource_provider() const {
861 return layer_tree_host_impl_
->resource_provider();
864 TileManager
* LayerTreeImpl::tile_manager() const {
865 return layer_tree_host_impl_
->tile_manager();
868 FrameRateCounter
* LayerTreeImpl::frame_rate_counter() const {
869 return layer_tree_host_impl_
->fps_counter();
872 PaintTimeCounter
* LayerTreeImpl::paint_time_counter() const {
873 return layer_tree_host_impl_
->paint_time_counter();
876 MemoryHistory
* LayerTreeImpl::memory_history() const {
877 return layer_tree_host_impl_
->memory_history();
880 gfx::Size
LayerTreeImpl::device_viewport_size() const {
881 return layer_tree_host_impl_
->device_viewport_size();
884 float LayerTreeImpl::device_scale_factor() const {
885 return layer_tree_host_impl_
->device_scale_factor();
888 DebugRectHistory
* LayerTreeImpl::debug_rect_history() const {
889 return layer_tree_host_impl_
->debug_rect_history();
892 bool LayerTreeImpl::IsActiveTree() const {
893 return layer_tree_host_impl_
->active_tree() == this;
896 bool LayerTreeImpl::IsPendingTree() const {
897 return layer_tree_host_impl_
->pending_tree() == this;
900 bool LayerTreeImpl::IsRecycleTree() const {
901 return layer_tree_host_impl_
->recycle_tree() == this;
904 bool LayerTreeImpl::IsSyncTree() const {
905 return layer_tree_host_impl_
->sync_tree() == this;
908 LayerImpl
* LayerTreeImpl::FindActiveTreeLayerById(int id
) {
909 LayerTreeImpl
* tree
= layer_tree_host_impl_
->active_tree();
912 return tree
->LayerById(id
);
915 LayerImpl
* LayerTreeImpl::FindPendingTreeLayerById(int id
) {
916 LayerTreeImpl
* tree
= layer_tree_host_impl_
->pending_tree();
919 return tree
->LayerById(id
);
922 bool LayerTreeImpl::PinchGestureActive() const {
923 return layer_tree_host_impl_
->pinch_gesture_active();
926 BeginFrameArgs
LayerTreeImpl::CurrentBeginFrameArgs() const {
927 return layer_tree_host_impl_
->CurrentBeginFrameArgs();
930 base::TimeDelta
LayerTreeImpl::CurrentBeginFrameInterval() const {
931 return layer_tree_host_impl_
->CurrentBeginFrameInterval();
934 void LayerTreeImpl::SetNeedsCommit() {
935 layer_tree_host_impl_
->SetNeedsCommit();
938 gfx::Rect
LayerTreeImpl::DeviceViewport() const {
939 return layer_tree_host_impl_
->DeviceViewport();
942 gfx::Size
LayerTreeImpl::DrawViewportSize() const {
943 return layer_tree_host_impl_
->DrawViewportSize();
946 const gfx::Rect
LayerTreeImpl::ViewportRectForTilePriority() const {
947 return layer_tree_host_impl_
->ViewportRectForTilePriority();
950 scoped_ptr
<ScrollbarAnimationController
>
951 LayerTreeImpl::CreateScrollbarAnimationController(LayerImpl
* scrolling_layer
) {
952 DCHECK(settings().scrollbar_fade_delay_ms
);
953 DCHECK(settings().scrollbar_fade_duration_ms
);
954 base::TimeDelta delay
=
955 base::TimeDelta::FromMilliseconds(settings().scrollbar_fade_delay_ms
);
956 base::TimeDelta resize_delay
= base::TimeDelta::FromMilliseconds(
957 settings().scrollbar_fade_resize_delay_ms
);
958 base::TimeDelta duration
=
959 base::TimeDelta::FromMilliseconds(settings().scrollbar_fade_duration_ms
);
960 switch (settings().scrollbar_animator
) {
961 case LayerTreeSettings::LINEAR_FADE
: {
962 return ScrollbarAnimationControllerLinearFade::Create(
964 layer_tree_host_impl_
,
969 case LayerTreeSettings::THINNING
: {
970 return ScrollbarAnimationControllerThinning::Create(scrolling_layer
,
971 layer_tree_host_impl_
,
976 case LayerTreeSettings::NO_ANIMATOR
:
983 void LayerTreeImpl::DidAnimateScrollOffset() {
984 layer_tree_host_impl_
->DidAnimateScrollOffset();
987 bool LayerTreeImpl::use_gpu_rasterization() const {
988 return layer_tree_host_impl_
->use_gpu_rasterization();
991 GpuRasterizationStatus
LayerTreeImpl::GetGpuRasterizationStatus() const {
992 return layer_tree_host_impl_
->gpu_rasterization_status();
995 bool LayerTreeImpl::create_low_res_tiling() const {
996 return layer_tree_host_impl_
->create_low_res_tiling();
999 void LayerTreeImpl::SetNeedsRedraw() {
1000 layer_tree_host_impl_
->SetNeedsRedraw();
1003 AnimationRegistrar
* LayerTreeImpl::GetAnimationRegistrar() const {
1004 return layer_tree_host_impl_
->animation_registrar();
1007 void LayerTreeImpl::GetAllPrioritizedTilesForTracing(
1008 std::vector
<PrioritizedTile
>* prioritized_tiles
) const {
1009 typedef LayerIterator
<LayerImpl
> LayerIteratorType
;
1010 LayerIteratorType end
= LayerIteratorType::End(&render_surface_layer_list_
);
1011 for (LayerIteratorType it
=
1012 LayerIteratorType::Begin(&render_surface_layer_list_
);
1015 if (!it
.represents_itself())
1017 LayerImpl
* layer_impl
= *it
;
1018 layer_impl
->GetAllPrioritizedTilesForTracing(prioritized_tiles
);
1022 void LayerTreeImpl::AsValueInto(base::trace_event::TracedValue
* state
) const {
1023 TracedValue::MakeDictIntoImplicitSnapshot(state
, "cc::LayerTreeImpl", this);
1024 state
->SetInteger("source_frame_number", source_frame_number_
);
1026 state
->BeginDictionary("root_layer");
1027 root_layer_
->AsValueInto(state
);
1028 state
->EndDictionary();
1030 state
->BeginArray("render_surface_layer_list");
1031 typedef LayerIterator
<LayerImpl
> LayerIteratorType
;
1032 LayerIteratorType end
= LayerIteratorType::End(&render_surface_layer_list_
);
1033 for (LayerIteratorType it
= LayerIteratorType::Begin(
1034 &render_surface_layer_list_
); it
!= end
; ++it
) {
1035 if (!it
.represents_itself())
1037 TracedValue::AppendIDRef(*it
, state
);
1041 state
->BeginArray("swap_promise_trace_ids");
1042 for (auto* swap_promise
: swap_promise_list_
)
1043 state
->AppendDouble(swap_promise
->TraceId());
1047 void LayerTreeImpl::SetRootLayerScrollOffsetDelegate(
1048 LayerScrollOffsetDelegate
* root_layer_scroll_offset_delegate
) {
1049 if (root_layer_scroll_offset_delegate_
== root_layer_scroll_offset_delegate
)
1052 root_layer_scroll_offset_delegate_
= root_layer_scroll_offset_delegate
;
1054 if (root_layer_scroll_offset_delegate_
) {
1055 root_layer_scroll_offset_delegate_
->UpdateRootLayerState(
1056 TotalScrollOffset(), TotalMaxScrollOffset(), ScrollableSize(),
1057 current_page_scale_factor(), min_page_scale_factor(),
1058 max_page_scale_factor());
1060 DistributeRootScrollOffset();
1064 void LayerTreeImpl::UpdateRootScrollOffsetDelegate() {
1065 DCHECK(root_layer_scroll_offset_delegate_
);
1067 gfx::ScrollOffset offset
= InnerViewportScrollLayer()->CurrentScrollOffset();
1069 if (OuterViewportScrollLayer())
1070 offset
+= OuterViewportScrollLayer()->CurrentScrollOffset();
1072 root_layer_scroll_offset_delegate_
->UpdateRootLayerState(
1073 offset
, TotalMaxScrollOffset(), ScrollableSize(),
1074 current_page_scale_factor(), min_page_scale_factor(),
1075 max_page_scale_factor());
1078 void LayerTreeImpl::DistributeRootScrollOffset() {
1079 if (!root_layer_scroll_offset_delegate_
)
1082 gfx::ScrollOffset root_offset
=
1083 root_layer_scroll_offset_delegate_
->GetTotalScrollOffset();
1085 if (!InnerViewportScrollLayer())
1088 DCHECK(OuterViewportScrollLayer());
1090 // If we get here, we have both inner/outer viewports, and need to distribute
1091 // the scroll offset between them.
1092 gfx::ScrollOffset inner_viewport_offset
=
1093 InnerViewportScrollLayer()->CurrentScrollOffset();
1094 gfx::ScrollOffset outer_viewport_offset
=
1095 OuterViewportScrollLayer()->CurrentScrollOffset();
1097 // It may be nothing has changed.
1098 if (inner_viewport_offset
+ outer_viewport_offset
== root_offset
)
1101 gfx::ScrollOffset max_outer_viewport_scroll_offset
=
1102 OuterViewportScrollLayer()->MaxScrollOffset();
1104 outer_viewport_offset
= root_offset
- inner_viewport_offset
;
1105 outer_viewport_offset
.SetToMin(max_outer_viewport_scroll_offset
);
1106 outer_viewport_offset
.SetToMax(gfx::ScrollOffset());
1108 OuterViewportScrollLayer()->SetCurrentScrollOffsetFromDelegate(
1109 outer_viewport_offset
);
1110 inner_viewport_offset
= root_offset
- outer_viewport_offset
;
1111 InnerViewportScrollLayer()->SetCurrentScrollOffsetFromDelegate(
1112 inner_viewport_offset
);
1114 UpdateRootScrollOffsetDelegate();
1117 void LayerTreeImpl::QueueSwapPromise(scoped_ptr
<SwapPromise
> swap_promise
) {
1118 DCHECK(swap_promise
);
1119 swap_promise_list_
.push_back(swap_promise
.Pass());
1122 void LayerTreeImpl::PassSwapPromises(
1123 ScopedPtrVector
<SwapPromise
>* new_swap_promise
) {
1124 swap_promise_list_
.insert_and_take(swap_promise_list_
.end(),
1126 new_swap_promise
->clear();
1129 void LayerTreeImpl::FinishSwapPromises(CompositorFrameMetadata
* metadata
) {
1130 for (auto* swap_promise
: swap_promise_list_
)
1131 swap_promise
->DidSwap(metadata
);
1132 swap_promise_list_
.clear();
1135 void LayerTreeImpl::BreakSwapPromises(SwapPromise::DidNotSwapReason reason
) {
1136 for (auto* swap_promise
: swap_promise_list_
)
1137 swap_promise
->DidNotSwap(reason
);
1138 swap_promise_list_
.clear();
1141 void LayerTreeImpl::DidModifyTilePriorities() {
1142 layer_tree_host_impl_
->DidModifyTilePriorities();
1145 void LayerTreeImpl::set_ui_resource_request_queue(
1146 const UIResourceRequestQueue
& queue
) {
1147 ui_resource_request_queue_
= queue
;
1150 ResourceId
LayerTreeImpl::ResourceIdForUIResource(UIResourceId uid
) const {
1151 return layer_tree_host_impl_
->ResourceIdForUIResource(uid
);
1154 bool LayerTreeImpl::IsUIResourceOpaque(UIResourceId uid
) const {
1155 return layer_tree_host_impl_
->IsUIResourceOpaque(uid
);
1158 void LayerTreeImpl::ProcessUIResourceRequestQueue() {
1159 for (const auto& req
: ui_resource_request_queue_
) {
1160 switch (req
.GetType()) {
1161 case UIResourceRequest::UI_RESOURCE_CREATE
:
1162 layer_tree_host_impl_
->CreateUIResource(req
.GetId(), req
.GetBitmap());
1164 case UIResourceRequest::UI_RESOURCE_DELETE
:
1165 layer_tree_host_impl_
->DeleteUIResource(req
.GetId());
1167 case UIResourceRequest::UI_RESOURCE_INVALID_REQUEST
:
1172 ui_resource_request_queue_
.clear();
1174 // If all UI resource evictions were not recreated by processing this queue,
1175 // then another commit is required.
1176 if (layer_tree_host_impl_
->EvictedUIResourcesExist())
1177 layer_tree_host_impl_
->SetNeedsCommit();
1180 void LayerTreeImpl::RegisterPictureLayerImpl(PictureLayerImpl
* layer
) {
1181 DCHECK(std::find(picture_layers_
.begin(), picture_layers_
.end(), layer
) ==
1182 picture_layers_
.end());
1183 picture_layers_
.push_back(layer
);
1186 void LayerTreeImpl::UnregisterPictureLayerImpl(PictureLayerImpl
* layer
) {
1187 std::vector
<PictureLayerImpl
*>::iterator it
=
1188 std::find(picture_layers_
.begin(), picture_layers_
.end(), layer
);
1189 DCHECK(it
!= picture_layers_
.end());
1190 picture_layers_
.erase(it
);
1193 void LayerTreeImpl::AddLayerWithCopyOutputRequest(LayerImpl
* layer
) {
1194 // Only the active tree needs to know about layers with copy requests, as
1195 // they are aborted if not serviced during draw.
1196 DCHECK(IsActiveTree());
1198 // DCHECK(std::find(layers_with_copy_output_request_.begin(),
1199 // layers_with_copy_output_request_.end(),
1200 // layer) == layers_with_copy_output_request_.end());
1201 // TODO(danakj): Remove this once crash is found crbug.com/309777
1202 for (size_t i
= 0; i
< layers_with_copy_output_request_
.size(); ++i
) {
1203 CHECK(layers_with_copy_output_request_
[i
] != layer
)
1204 << i
<< " of " << layers_with_copy_output_request_
.size();
1206 layers_with_copy_output_request_
.push_back(layer
);
1209 void LayerTreeImpl::RemoveLayerWithCopyOutputRequest(LayerImpl
* layer
) {
1210 // Only the active tree needs to know about layers with copy requests, as
1211 // they are aborted if not serviced during draw.
1212 DCHECK(IsActiveTree());
1214 std::vector
<LayerImpl
*>::iterator it
= std::find(
1215 layers_with_copy_output_request_
.begin(),
1216 layers_with_copy_output_request_
.end(),
1218 DCHECK(it
!= layers_with_copy_output_request_
.end());
1219 layers_with_copy_output_request_
.erase(it
);
1221 // TODO(danakj): Remove this once crash is found crbug.com/309777
1222 for (size_t i
= 0; i
< layers_with_copy_output_request_
.size(); ++i
) {
1223 CHECK(layers_with_copy_output_request_
[i
] != layer
)
1224 << i
<< " of " << layers_with_copy_output_request_
.size();
1228 const std::vector
<LayerImpl
*>& LayerTreeImpl::LayersWithCopyOutputRequest()
1230 // Only the active tree needs to know about layers with copy requests, as
1231 // they are aborted if not serviced during draw.
1232 DCHECK(IsActiveTree());
1234 return layers_with_copy_output_request_
;
1237 template <typename LayerType
>
1238 static inline bool LayerClipsSubtree(LayerType
* layer
) {
1239 return layer
->masks_to_bounds() || layer
->mask_layer();
1242 static bool PointHitsRect(
1243 const gfx::PointF
& screen_space_point
,
1244 const gfx::Transform
& local_space_to_screen_space_transform
,
1245 const gfx::RectF
& local_space_rect
,
1246 float* distance_to_camera
) {
1247 // If the transform is not invertible, then assume that this point doesn't hit
1249 gfx::Transform
inverse_local_space_to_screen_space(
1250 gfx::Transform::kSkipInitialization
);
1251 if (!local_space_to_screen_space_transform
.GetInverse(
1252 &inverse_local_space_to_screen_space
))
1255 // Transform the hit test point from screen space to the local space of the
1257 bool clipped
= false;
1258 gfx::Point3F planar_point
= MathUtil::ProjectPoint3D(
1259 inverse_local_space_to_screen_space
, screen_space_point
, &clipped
);
1260 gfx::PointF hit_test_point_in_local_space
=
1261 gfx::PointF(planar_point
.x(), planar_point
.y());
1263 // If ProjectPoint could not project to a valid value, then we assume that
1264 // this point doesn't hit this rect.
1268 if (!local_space_rect
.Contains(hit_test_point_in_local_space
))
1271 if (distance_to_camera
) {
1272 // To compute the distance to the camera, we have to take the planar point
1273 // and pull it back to world space and compute the displacement along the
1275 gfx::Point3F
planar_point_in_screen_space(planar_point
);
1276 local_space_to_screen_space_transform
.TransformPoint(
1277 &planar_point_in_screen_space
);
1278 *distance_to_camera
= planar_point_in_screen_space
.z();
1284 static bool PointHitsRegion(const gfx::PointF
& screen_space_point
,
1285 const gfx::Transform
& screen_space_transform
,
1286 const Region
& layer_space_region
) {
1287 // If the transform is not invertible, then assume that this point doesn't hit
1289 gfx::Transform
inverse_screen_space_transform(
1290 gfx::Transform::kSkipInitialization
);
1291 if (!screen_space_transform
.GetInverse(&inverse_screen_space_transform
))
1294 // Transform the hit test point from screen space to the local space of the
1296 bool clipped
= false;
1297 gfx::PointF hit_test_point_in_layer_space
= MathUtil::ProjectPoint(
1298 inverse_screen_space_transform
, screen_space_point
, &clipped
);
1300 // If ProjectPoint could not project to a valid value, then we assume that
1301 // this point doesn't hit this region.
1305 return layer_space_region
.Contains(
1306 gfx::ToRoundedPoint(hit_test_point_in_layer_space
));
1309 static const LayerImpl
* GetNextClippingLayer(const LayerImpl
* layer
) {
1310 if (layer
->scroll_parent())
1311 return layer
->scroll_parent();
1312 if (layer
->clip_parent())
1313 return layer
->clip_parent();
1314 return layer
->parent();
1317 static bool PointIsClippedBySurfaceOrClipRect(
1318 const gfx::PointF
& screen_space_point
,
1319 const LayerImpl
* layer
) {
1320 // Walk up the layer tree and hit-test any render_surfaces and any layer
1321 // clip rects that are active.
1322 for (; layer
; layer
= GetNextClippingLayer(layer
)) {
1323 if (layer
->render_surface() &&
1324 !PointHitsRect(screen_space_point
,
1325 layer
->render_surface()->screen_space_transform(),
1326 layer
->render_surface()->content_rect(),
1330 if (LayerClipsSubtree(layer
) &&
1331 !PointHitsRect(screen_space_point
, layer
->screen_space_transform(),
1332 gfx::Rect(layer
->bounds()), NULL
))
1336 // If we have finished walking all ancestors without having already exited,
1337 // then the point is not clipped by any ancestors.
1341 static bool PointHitsLayer(const LayerImpl
* layer
,
1342 const gfx::PointF
& screen_space_point
,
1343 float* distance_to_intersection
) {
1344 gfx::RectF
content_rect(layer
->bounds());
1345 if (!PointHitsRect(screen_space_point
,
1346 layer
->screen_space_transform(),
1348 distance_to_intersection
))
1351 // At this point, we think the point does hit the layer, but we need to walk
1352 // up the parents to ensure that the layer was not clipped in such a way
1353 // that the hit point actually should not hit the layer.
1354 if (PointIsClippedBySurfaceOrClipRect(screen_space_point
, layer
))
1357 // Skip the HUD layer.
1358 if (layer
== layer
->layer_tree_impl()->hud_layer())
1364 struct FindClosestMatchingLayerDataForRecursion
{
1365 FindClosestMatchingLayerDataForRecursion()
1366 : closest_match(NULL
),
1367 closest_distance(-std::numeric_limits
<float>::infinity()) {}
1368 LayerImpl
* closest_match
;
1369 // Note that the positive z-axis points towards the camera, so bigger means
1370 // closer in this case, counterintuitively.
1371 float closest_distance
;
1374 template <typename Functor
>
1375 static void FindClosestMatchingLayer(
1376 const gfx::PointF
& screen_space_point
,
1378 const Functor
& func
,
1379 FindClosestMatchingLayerDataForRecursion
* data_for_recursion
) {
1380 size_t children_size
= layer
->children().size();
1381 for (size_t i
= 0; i
< children_size
; ++i
) {
1382 size_t index
= children_size
- 1 - i
;
1383 FindClosestMatchingLayer(screen_space_point
, layer
->children()[index
], func
,
1384 data_for_recursion
);
1387 float distance_to_intersection
= 0.f
;
1389 PointHitsLayer(layer
, screen_space_point
, &distance_to_intersection
) &&
1390 ((!data_for_recursion
->closest_match
||
1391 distance_to_intersection
> data_for_recursion
->closest_distance
))) {
1392 data_for_recursion
->closest_distance
= distance_to_intersection
;
1393 data_for_recursion
->closest_match
= layer
;
1397 static bool ScrollsAnyDrawnRenderSurfaceLayerListMember(LayerImpl
* layer
) {
1398 if (!layer
->scrollable())
1400 if (layer
->layer_or_descendant_is_drawn())
1403 if (!layer
->scroll_children())
1405 for (std::set
<LayerImpl
*>::const_iterator it
=
1406 layer
->scroll_children()->begin();
1407 it
!= layer
->scroll_children()->end();
1409 if ((*it
)->layer_or_descendant_is_drawn())
1415 struct FindScrollingLayerFunctor
{
1416 bool operator()(LayerImpl
* layer
) const {
1417 return ScrollsAnyDrawnRenderSurfaceLayerListMember(layer
);
1421 LayerImpl
* LayerTreeImpl::FindFirstScrollingLayerThatIsHitByPoint(
1422 const gfx::PointF
& screen_space_point
) {
1423 FindClosestMatchingLayerDataForRecursion data_for_recursion
;
1424 FindClosestMatchingLayer(screen_space_point
,
1426 FindScrollingLayerFunctor(),
1427 &data_for_recursion
);
1428 return data_for_recursion
.closest_match
;
1431 struct HitTestVisibleScrollableOrTouchableFunctor
{
1432 bool operator()(LayerImpl
* layer
) const {
1433 return layer
->IsDrawnRenderSurfaceLayerListMember() ||
1434 ScrollsAnyDrawnRenderSurfaceLayerListMember(layer
) ||
1435 !layer
->touch_event_handler_region().IsEmpty() ||
1436 layer
->have_wheel_event_handlers();
1440 LayerImpl
* LayerTreeImpl::FindLayerThatIsHitByPoint(
1441 const gfx::PointF
& screen_space_point
) {
1444 bool update_lcd_text
= false;
1445 if (!UpdateDrawProperties(update_lcd_text
))
1447 FindClosestMatchingLayerDataForRecursion data_for_recursion
;
1448 FindClosestMatchingLayer(screen_space_point
,
1450 HitTestVisibleScrollableOrTouchableFunctor(),
1451 &data_for_recursion
);
1452 return data_for_recursion
.closest_match
;
1455 static bool LayerHasTouchEventHandlersAt(const gfx::PointF
& screen_space_point
,
1456 LayerImpl
* layer_impl
) {
1457 if (layer_impl
->touch_event_handler_region().IsEmpty())
1460 if (!PointHitsRegion(screen_space_point
, layer_impl
->screen_space_transform(),
1461 layer_impl
->touch_event_handler_region()))
1464 // At this point, we think the point does hit the touch event handler region
1465 // on the layer, but we need to walk up the parents to ensure that the layer
1466 // was not clipped in such a way that the hit point actually should not hit
1468 if (PointIsClippedBySurfaceOrClipRect(screen_space_point
, layer_impl
))
1474 struct FindWheelEventLayerFunctor
{
1475 bool operator()(LayerImpl
* layer
) const {
1476 return layer
->have_wheel_event_handlers();
1480 LayerImpl
* LayerTreeImpl::FindLayerWithWheelHandlerThatIsHitByPoint(
1481 const gfx::PointF
& screen_space_point
) {
1484 bool update_lcd_text
= false;
1485 if (!UpdateDrawProperties(update_lcd_text
))
1487 FindWheelEventLayerFunctor func
;
1488 FindClosestMatchingLayerDataForRecursion data_for_recursion
;
1489 FindClosestMatchingLayer(screen_space_point
, root_layer(), func
,
1490 &data_for_recursion
);
1491 return data_for_recursion
.closest_match
;
1494 struct FindTouchEventLayerFunctor
{
1495 bool operator()(LayerImpl
* layer
) const {
1496 return LayerHasTouchEventHandlersAt(screen_space_point
, layer
);
1498 const gfx::PointF screen_space_point
;
1501 LayerImpl
* LayerTreeImpl::FindLayerThatIsHitByPointInTouchHandlerRegion(
1502 const gfx::PointF
& screen_space_point
) {
1505 bool update_lcd_text
= false;
1506 if (!UpdateDrawProperties(update_lcd_text
))
1508 FindTouchEventLayerFunctor func
= {screen_space_point
};
1509 FindClosestMatchingLayerDataForRecursion data_for_recursion
;
1510 FindClosestMatchingLayer(
1511 screen_space_point
, root_layer(), func
, &data_for_recursion
);
1512 return data_for_recursion
.closest_match
;
1515 void LayerTreeImpl::RegisterSelection(const LayerSelection
& selection
) {
1516 selection_
= selection
;
1519 static ViewportSelectionBound
ComputeViewportSelectionBound(
1520 const LayerSelectionBound
& layer_bound
,
1522 float device_scale_factor
) {
1523 ViewportSelectionBound viewport_bound
;
1524 viewport_bound
.type
= layer_bound
.type
;
1526 if (!layer
|| layer_bound
.type
== SELECTION_BOUND_EMPTY
)
1527 return viewport_bound
;
1529 gfx::PointF layer_top
= layer_bound
.edge_top
;
1530 gfx::PointF layer_bottom
= layer_bound
.edge_bottom
;
1532 bool clipped
= false;
1533 gfx::PointF screen_top
=
1534 MathUtil::MapPoint(layer
->screen_space_transform(), layer_top
, &clipped
);
1535 gfx::PointF screen_bottom
= MathUtil::MapPoint(
1536 layer
->screen_space_transform(), layer_bottom
, &clipped
);
1538 const float inv_scale
= 1.f
/ device_scale_factor
;
1539 viewport_bound
.edge_top
= gfx::ScalePoint(screen_top
, inv_scale
);
1540 viewport_bound
.edge_bottom
= gfx::ScalePoint(screen_bottom
, inv_scale
);
1542 // The bottom edge point is used for visibility testing as it is the logical
1543 // focal point for bound selection handles (this may change in the future).
1544 // Shifting the visibility point fractionally inward ensures that neighboring
1545 // or logically coincident layers aligned to integral DPI coordinates will not
1546 // spuriously occlude the bound.
1547 gfx::Vector2dF visibility_offset
= layer_top
- layer_bottom
;
1548 visibility_offset
.Scale(device_scale_factor
/ visibility_offset
.Length());
1549 gfx::PointF visibility_point
= layer_bottom
+ visibility_offset
;
1550 if (visibility_point
.x() <= 0)
1551 visibility_point
.set_x(visibility_point
.x() + device_scale_factor
);
1552 visibility_point
= MathUtil::MapPoint(
1553 layer
->screen_space_transform(), visibility_point
, &clipped
);
1555 float intersect_distance
= 0.f
;
1556 viewport_bound
.visible
=
1557 PointHitsLayer(layer
, visibility_point
, &intersect_distance
);
1559 return viewport_bound
;
1562 void LayerTreeImpl::GetViewportSelection(ViewportSelection
* selection
) {
1565 selection
->start
= ComputeViewportSelectionBound(
1567 selection_
.start
.layer_id
? LayerById(selection_
.start
.layer_id
) : NULL
,
1568 device_scale_factor());
1569 selection
->is_editable
= selection_
.is_editable
;
1570 selection
->is_empty_text_form_control
= selection_
.is_empty_text_form_control
;
1571 if (selection
->start
.type
== SELECTION_BOUND_CENTER
||
1572 selection
->start
.type
== SELECTION_BOUND_EMPTY
) {
1573 selection
->end
= selection
->start
;
1575 selection
->end
= ComputeViewportSelectionBound(
1577 selection_
.end
.layer_id
? LayerById(selection_
.end
.layer_id
) : NULL
,
1578 device_scale_factor());
1582 void LayerTreeImpl::InputScrollAnimationFinished() {
1583 layer_tree_host_impl_
->ScrollEnd();
1586 bool LayerTreeImpl::SmoothnessTakesPriority() const {
1587 return layer_tree_host_impl_
->GetTreePriority() == SMOOTHNESS_TAKES_PRIORITY
;
1590 BlockingTaskRunner
* LayerTreeImpl::BlockingMainThreadTaskRunner() const {
1591 return proxy()->blocking_main_thread_task_runner();
1594 VideoFrameControllerClient
* LayerTreeImpl::GetVideoFrameControllerClient()
1596 return layer_tree_host_impl_
;
1599 void LayerTreeImpl::SetPendingPageScaleAnimation(
1600 scoped_ptr
<PendingPageScaleAnimation
> pending_animation
) {
1601 pending_page_scale_animation_
= pending_animation
.Pass();
1604 scoped_ptr
<PendingPageScaleAnimation
>
1605 LayerTreeImpl::TakePendingPageScaleAnimation() {
1606 return pending_page_scale_animation_
.Pass();