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/animation_host.h"
14 #include "cc/animation/keyframed_animation_curve.h"
15 #include "cc/animation/scrollbar_animation_controller.h"
16 #include "cc/animation/scrollbar_animation_controller_linear_fade.h"
17 #include "cc/animation/scrollbar_animation_controller_thinning.h"
18 #include "cc/base/math_util.h"
19 #include "cc/base/synced_property.h"
20 #include "cc/debug/devtools_instrumentation.h"
21 #include "cc/debug/traced_value.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.h"
33 #include "cc/trees/property_tree_builder.h"
34 #include "ui/gfx/geometry/box_f.h"
35 #include "ui/gfx/geometry/point_conversions.h"
36 #include "ui/gfx/geometry/size_conversions.h"
37 #include "ui/gfx/geometry/vector2d_conversions.h"
41 LayerTreeImpl::LayerTreeImpl(
42 LayerTreeHostImpl
* layer_tree_host_impl
,
43 scoped_refptr
<SyncedProperty
<ScaleGroup
>> page_scale_factor
,
44 scoped_refptr
<SyncedTopControls
> top_controls_shown_ratio
,
45 scoped_refptr
<SyncedElasticOverscroll
> elastic_overscroll
)
46 : layer_tree_host_impl_(layer_tree_host_impl
),
47 source_frame_number_(-1),
50 has_transparent_background_(false),
51 currently_scrolling_layer_id_(Layer::INVALID_ID
),
52 overscroll_elasticity_layer_id_(Layer::INVALID_ID
),
53 page_scale_layer_id_(Layer::INVALID_ID
),
54 inner_viewport_scroll_layer_id_(Layer::INVALID_ID
),
55 outer_viewport_scroll_layer_id_(Layer::INVALID_ID
),
56 page_scale_factor_(page_scale_factor
),
57 min_page_scale_factor_(0),
58 max_page_scale_factor_(0),
59 hide_pinch_scrollbars_near_min_scale_(false),
60 elastic_overscroll_(elastic_overscroll
),
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 void LayerTreeImpl::SetRootLayer(scoped_ptr
<LayerImpl
> layer
) {
116 root_layer_
= layer
.Pass();
118 layer_tree_host_impl_
->OnCanDrawStateChangedForTree();
121 LayerImpl
* LayerTreeImpl::InnerViewportScrollLayer() const {
122 return LayerById(inner_viewport_scroll_layer_id_
);
125 LayerImpl
* LayerTreeImpl::OuterViewportScrollLayer() const {
126 return LayerById(outer_viewport_scroll_layer_id_
);
129 gfx::ScrollOffset
LayerTreeImpl::TotalScrollOffset() const {
130 gfx::ScrollOffset offset
;
132 if (InnerViewportScrollLayer())
133 offset
+= InnerViewportScrollLayer()->CurrentScrollOffset();
135 if (OuterViewportScrollLayer())
136 offset
+= OuterViewportScrollLayer()->CurrentScrollOffset();
141 gfx::ScrollOffset
LayerTreeImpl::TotalMaxScrollOffset() const {
142 gfx::ScrollOffset offset
;
144 if (InnerViewportScrollLayer())
145 offset
+= InnerViewportScrollLayer()->MaxScrollOffset();
147 if (OuterViewportScrollLayer())
148 offset
+= OuterViewportScrollLayer()->MaxScrollOffset();
153 scoped_ptr
<LayerImpl
> LayerTreeImpl::DetachLayerTree() {
154 render_surface_layer_list_
.clear();
155 set_needs_update_draw_properties();
156 return root_layer_
.Pass();
159 static void UpdateClipTreeForBoundsDeltaOnLayer(LayerImpl
* layer
,
160 ClipTree
* clip_tree
) {
161 if (layer
&& layer
->masks_to_bounds()) {
162 ClipNode
* clip_node
= clip_tree
->Node(layer
->clip_tree_index());
164 DCHECK_EQ(layer
->id(), clip_node
->owner_id
);
165 gfx::Size bounds
= layer
->bounds();
166 if (clip_node
->data
.clip
.size() != bounds
) {
167 clip_node
->data
.clip
.set_size(bounds
);
168 clip_tree
->set_needs_update(true);
174 void LayerTreeImpl::UpdatePropertyTreesForBoundsDelta() {
175 DCHECK(IsActiveTree());
176 LayerImpl
* inner_container
= InnerViewportContainerLayer();
177 LayerImpl
* outer_container
= OuterViewportContainerLayer();
179 UpdateClipTreeForBoundsDeltaOnLayer(inner_container
,
180 &property_trees_
.clip_tree
);
181 UpdateClipTreeForBoundsDeltaOnLayer(InnerViewportScrollLayer(),
182 &property_trees_
.clip_tree
);
183 UpdateClipTreeForBoundsDeltaOnLayer(outer_container
,
184 &property_trees_
.clip_tree
);
186 TransformTree
& transform_tree
= property_trees_
.transform_tree
;
188 transform_tree
.SetInnerViewportBoundsDelta(inner_container
->bounds_delta());
190 transform_tree
.SetOuterViewportBoundsDelta(outer_container
->bounds_delta());
193 void LayerTreeImpl::PushPropertiesTo(LayerTreeImpl
* target_tree
) {
194 // The request queue should have been processed and does not require a push.
195 DCHECK_EQ(ui_resource_request_queue_
.size(), 0u);
197 target_tree
->SetPropertyTrees(property_trees_
);
199 if (next_activation_forces_redraw_
) {
200 target_tree
->ForceRedrawNextActivation();
201 next_activation_forces_redraw_
= false;
204 target_tree
->PassSwapPromises(&swap_promise_list_
);
206 target_tree
->set_top_controls_shrink_blink_size(
207 top_controls_shrink_blink_size_
);
208 target_tree
->set_top_controls_height(top_controls_height_
);
209 target_tree
->PushTopControls(nullptr);
211 target_tree
->set_hide_pinch_scrollbars_near_min_scale(
212 hide_pinch_scrollbars_near_min_scale_
);
214 // Active tree already shares the page_scale_factor object with pending
215 // tree so only the limits need to be provided.
216 target_tree
->PushPageScaleFactorAndLimits(nullptr, min_page_scale_factor(),
217 max_page_scale_factor());
218 target_tree
->elastic_overscroll()->PushPendingToActive();
220 target_tree
->pending_page_scale_animation_
=
221 pending_page_scale_animation_
.Pass();
223 target_tree
->SetViewportLayersFromIds(
224 overscroll_elasticity_layer_id_
, page_scale_layer_id_
,
225 inner_viewport_scroll_layer_id_
, outer_viewport_scroll_layer_id_
);
227 target_tree
->RegisterSelection(selection_
);
229 // This should match the property synchronization in
230 // LayerTreeHost::finishCommitOnImplThread().
231 target_tree
->set_source_frame_number(source_frame_number());
232 target_tree
->set_background_color(background_color());
233 target_tree
->set_has_transparent_background(has_transparent_background());
235 if (ViewportSizeInvalid())
236 target_tree
->SetViewportSizeInvalid();
238 target_tree
->ResetViewportSizeInvalid();
241 target_tree
->set_hud_layer(static_cast<HeadsUpDisplayLayerImpl
*>(
242 LayerTreeHostCommon::FindLayerInSubtree(
243 target_tree
->root_layer(), hud_layer()->id())));
245 target_tree
->set_hud_layer(NULL
);
247 target_tree
->has_ever_been_drawn_
= false;
250 LayerImpl
* LayerTreeImpl::InnerViewportContainerLayer() const {
251 return InnerViewportScrollLayer()
252 ? InnerViewportScrollLayer()->scroll_clip_layer()
256 LayerImpl
* LayerTreeImpl::OuterViewportContainerLayer() const {
257 return OuterViewportScrollLayer()
258 ? OuterViewportScrollLayer()->scroll_clip_layer()
262 LayerImpl
* LayerTreeImpl::CurrentlyScrollingLayer() const {
263 DCHECK(IsActiveTree());
264 return LayerById(currently_scrolling_layer_id_
);
267 void LayerTreeImpl::SetCurrentlyScrollingLayer(LayerImpl
* layer
) {
268 int new_id
= layer
? layer
->id() : Layer::INVALID_ID
;
269 if (currently_scrolling_layer_id_
== new_id
)
272 if (CurrentlyScrollingLayer() &&
273 CurrentlyScrollingLayer()->scrollbar_animation_controller())
274 CurrentlyScrollingLayer()->scrollbar_animation_controller()->DidScrollEnd();
275 currently_scrolling_layer_id_
= new_id
;
276 if (layer
&& layer
->scrollbar_animation_controller())
277 layer
->scrollbar_animation_controller()->DidScrollBegin();
280 void LayerTreeImpl::ClearCurrentlyScrollingLayer() {
281 SetCurrentlyScrollingLayer(NULL
);
286 void ForceScrollbarParameterUpdateAfterScaleChange(LayerImpl
* current_layer
) {
290 while (current_layer
) {
291 current_layer
->ScrollbarParametersDidChange(false);
292 current_layer
= current_layer
->parent();
298 float LayerTreeImpl::ClampPageScaleFactorToLimits(
299 float page_scale_factor
) const {
300 if (min_page_scale_factor_
&& page_scale_factor
< min_page_scale_factor_
)
301 page_scale_factor
= min_page_scale_factor_
;
302 else if (max_page_scale_factor_
&& page_scale_factor
> max_page_scale_factor_
)
303 page_scale_factor
= max_page_scale_factor_
;
304 return page_scale_factor
;
307 void LayerTreeImpl::UpdatePropertyTreeScrollingAndAnimationFromMainThread() {
308 // TODO(enne): This should get replaced by pulling out scrolling and
309 // animations into their own trees. Then scrolls and animations would have
310 // their own ways of synchronizing across commits. This occurs to push
311 // updates from scrolling deltas on the compositor thread that have occurred
312 // after begin frame and updates from animations that have ticked since begin
313 // frame to a newly-committed property tree.
316 LayerTreeHostCommon::CallFunctionForSubtree(
317 root_layer(), [](LayerImpl
* layer
) {
318 layer
->UpdatePropertyTreeForScrollingAndAnimationIfNeeded();
322 void LayerTreeImpl::SetPageScaleOnActiveTree(float active_page_scale
) {
323 DCHECK(IsActiveTree());
324 if (page_scale_factor()->SetCurrent(
325 ClampPageScaleFactorToLimits(active_page_scale
)))
326 DidUpdatePageScale();
329 void LayerTreeImpl::PushPageScaleFromMainThread(float page_scale_factor
,
330 float min_page_scale_factor
,
331 float max_page_scale_factor
) {
332 PushPageScaleFactorAndLimits(&page_scale_factor
, min_page_scale_factor
,
333 max_page_scale_factor
);
336 void LayerTreeImpl::PushPageScaleFactorAndLimits(const float* page_scale_factor
,
337 float min_page_scale_factor
,
338 float max_page_scale_factor
) {
339 DCHECK(page_scale_factor
|| IsActiveTree());
340 bool changed_page_scale
= false;
341 if (page_scale_factor
) {
342 DCHECK(!IsActiveTree() || !layer_tree_host_impl_
->pending_tree());
343 changed_page_scale
|= page_scale_factor_
->Delta() != 1.f
;
344 // TODO(enne): Once CDP goes away, ignore this call below. The only time
345 // the property trees will differ is if there's been a page scale on the
346 // compositor thread after the begin frame, which is the delta check above.
347 changed_page_scale
|=
348 page_scale_factor_
->PushFromMainThread(*page_scale_factor
);
350 if (IsActiveTree()) {
351 // TODO(enne): Pushing from pending to active should never require
352 // DidUpdatePageScale. The values should already be set by the fully
353 // computed property trees being synced from one tree to another. Remove
354 // this once CDP goes away.
355 changed_page_scale
|= page_scale_factor_
->PushPendingToActive();
358 changed_page_scale
|=
359 SetPageScaleFactorLimits(min_page_scale_factor
, max_page_scale_factor
);
361 if (changed_page_scale
)
362 DidUpdatePageScale();
365 void LayerTreeImpl::set_top_controls_shrink_blink_size(bool shrink
) {
366 if (top_controls_shrink_blink_size_
== shrink
)
369 top_controls_shrink_blink_size_
= shrink
;
371 layer_tree_host_impl_
->UpdateViewportContainerSizes();
374 void LayerTreeImpl::set_top_controls_height(float top_controls_height
) {
375 if (top_controls_height_
== top_controls_height
)
378 top_controls_height_
= top_controls_height
;
380 layer_tree_host_impl_
->UpdateViewportContainerSizes();
383 bool LayerTreeImpl::SetCurrentTopControlsShownRatio(float ratio
) {
384 ratio
= std::max(ratio
, 0.f
);
385 ratio
= std::min(ratio
, 1.f
);
386 return top_controls_shown_ratio_
->SetCurrent(ratio
);
389 void LayerTreeImpl::PushTopControlsFromMainThread(
390 float top_controls_shown_ratio
) {
391 PushTopControls(&top_controls_shown_ratio
);
394 void LayerTreeImpl::PushTopControls(const float* top_controls_shown_ratio
) {
395 DCHECK(top_controls_shown_ratio
|| IsActiveTree());
397 if (top_controls_shown_ratio
) {
398 DCHECK(!IsActiveTree() || !layer_tree_host_impl_
->pending_tree());
399 top_controls_shown_ratio_
->PushFromMainThread(*top_controls_shown_ratio
);
401 if (IsActiveTree()) {
402 if (top_controls_shown_ratio_
->PushPendingToActive())
403 layer_tree_host_impl_
->DidChangeTopControlsPosition();
407 bool LayerTreeImpl::SetPageScaleFactorLimits(float min_page_scale_factor
,
408 float max_page_scale_factor
) {
409 if (min_page_scale_factor
== min_page_scale_factor_
&&
410 max_page_scale_factor
== max_page_scale_factor_
)
413 min_page_scale_factor_
= min_page_scale_factor
;
414 max_page_scale_factor_
= max_page_scale_factor
;
419 void LayerTreeImpl::DidUpdatePageScale() {
421 page_scale_factor()->SetCurrent(
422 ClampPageScaleFactorToLimits(current_page_scale_factor()));
424 set_needs_update_draw_properties();
426 if (PageScaleLayer() && PageScaleLayer()->transform_tree_index() != -1) {
427 TransformNode
* node
= property_trees_
.transform_tree
.Node(
428 PageScaleLayer()->transform_tree_index());
429 node
->data
.post_local_scale_factor
= current_page_scale_factor();
430 node
->data
.needs_local_transform_update
= true;
431 // TODO(enne): property trees can't ask the layer these things, but
432 // the page scale layer should *just* be the page scale.
433 DCHECK_EQ(PageScaleLayer()->position().ToString(),
434 gfx::PointF().ToString());
435 DCHECK_EQ(PageScaleLayer()->transform_origin().ToString(),
436 gfx::Point3F().ToString());
437 node
->data
.update_post_local_transform(gfx::PointF(), gfx::Point3F());
438 property_trees_
.transform_tree
.set_needs_update(true);
441 ForceScrollbarParameterUpdateAfterScaleChange(PageScaleLayer());
442 HideInnerViewportScrollbarsIfNeeded();
445 void LayerTreeImpl::HideInnerViewportScrollbarsIfNeeded() {
446 if (!InnerViewportContainerLayer())
449 LayerImpl::ScrollbarSet
* scrollbars
=
450 InnerViewportContainerLayer()->scrollbars();
455 float minimum_scale_to_show_at
= min_page_scale_factor() * 1.05f
;
456 bool hide_scrollbars
=
457 hide_pinch_scrollbars_near_min_scale_
&&
458 (current_page_scale_factor() < minimum_scale_to_show_at
);
460 for (LayerImpl::ScrollbarSet::iterator it
= scrollbars
->begin();
461 it
!= scrollbars
->end(); ++it
)
462 (*it
)->SetHideLayerAndSubtree(hide_scrollbars
);
465 SyncedProperty
<ScaleGroup
>* LayerTreeImpl::page_scale_factor() {
466 return page_scale_factor_
.get();
469 const SyncedProperty
<ScaleGroup
>* LayerTreeImpl::page_scale_factor() const {
470 return page_scale_factor_
.get();
473 gfx::SizeF
LayerTreeImpl::ScrollableViewportSize() const {
474 if (!InnerViewportContainerLayer())
477 return gfx::ScaleSize(InnerViewportContainerLayer()->BoundsForScrolling(),
478 1.0f
/ current_page_scale_factor());
481 gfx::Rect
LayerTreeImpl::RootScrollLayerDeviceViewportBounds() const {
482 LayerImpl
* root_scroll_layer
= OuterViewportScrollLayer()
483 ? OuterViewportScrollLayer()
484 : InnerViewportScrollLayer();
485 if (!root_scroll_layer
|| root_scroll_layer
->children().empty())
487 LayerImpl
* layer
= root_scroll_layer
->children()[0];
488 return MathUtil::MapEnclosingClippedRect(layer
->screen_space_transform(),
489 gfx::Rect(layer
->bounds()));
492 void LayerTreeImpl::ApplySentScrollAndScaleDeltasFromAbortedCommit() {
493 DCHECK(IsActiveTree());
495 page_scale_factor()->AbortCommit();
496 top_controls_shown_ratio()->AbortCommit();
497 elastic_overscroll()->AbortCommit();
502 LayerTreeHostCommon::CallFunctionForSubtree(
503 root_layer(), [](LayerImpl
* layer
) {
504 layer
->ApplySentScrollDeltasFromAbortedCommit();
508 void LayerTreeImpl::SetViewportLayersFromIds(
509 int overscroll_elasticity_layer_id
,
510 int page_scale_layer_id
,
511 int inner_viewport_scroll_layer_id
,
512 int outer_viewport_scroll_layer_id
) {
513 overscroll_elasticity_layer_id_
= overscroll_elasticity_layer_id
;
514 page_scale_layer_id_
= page_scale_layer_id
;
515 inner_viewport_scroll_layer_id_
= inner_viewport_scroll_layer_id
;
516 outer_viewport_scroll_layer_id_
= outer_viewport_scroll_layer_id
;
518 HideInnerViewportScrollbarsIfNeeded();
521 void LayerTreeImpl::ClearViewportLayers() {
522 overscroll_elasticity_layer_id_
= Layer::INVALID_ID
;
523 page_scale_layer_id_
= Layer::INVALID_ID
;
524 inner_viewport_scroll_layer_id_
= Layer::INVALID_ID
;
525 outer_viewport_scroll_layer_id_
= Layer::INVALID_ID
;
528 bool LayerTreeImpl::UpdateDrawProperties(bool update_lcd_text
) {
529 if (!needs_update_draw_properties_
)
532 // Calling UpdateDrawProperties must clear this flag, so there can be no
533 // early outs before this.
534 needs_update_draw_properties_
= false;
536 // For max_texture_size. When the renderer is re-created in
537 // CreateAndSetRenderer, the needs update draw properties flag is set
539 if (!layer_tree_host_impl_
->renderer())
542 // Clear this after the renderer early out, as it should still be
543 // possible to hit test even without a renderer.
544 render_surface_layer_list_
.clear();
551 "cc", "LayerTreeImpl::UpdateDrawProperties::CalculateDrawProperties",
552 "IsActive", IsActiveTree(), "SourceFrameNumber", source_frame_number_
);
553 bool can_render_to_separate_surface
=
554 (layer_tree_host_impl_
->GetDrawMode() !=
555 DRAW_MODE_RESOURCELESS_SOFTWARE
);
557 ++render_surface_layer_list_id_
;
559 LayerTreeHostCommon::CalcDrawPropsImplInputs
inputs(
560 root_layer(), DrawViewportSize(),
561 layer_tree_host_impl_
->DrawTransform(), device_scale_factor(),
562 current_page_scale_factor(), PageScaleLayer(),
563 InnerViewportScrollLayer(), OuterViewportScrollLayer(),
564 elastic_overscroll()->Current(IsActiveTree()),
565 OverscrollElasticityLayer(), resource_provider()->max_texture_size(),
566 settings().can_use_lcd_text
, settings().layers_always_allowed_lcd_text
,
567 can_render_to_separate_surface
,
568 settings().layer_transforms_should_scale_layer_contents
,
569 settings().verify_property_trees
, &render_surface_layer_list_
,
570 render_surface_layer_list_id_
, &property_trees_
);
571 LayerTreeHostCommon::CalculateDrawProperties(&inputs
);
575 TRACE_EVENT2("cc", "LayerTreeImpl::UpdateDrawProperties::Occlusion",
576 "IsActive", IsActiveTree(), "SourceFrameNumber",
577 source_frame_number_
);
578 OcclusionTracker
occlusion_tracker(
579 root_layer()->render_surface()->content_rect());
580 occlusion_tracker
.set_minimum_tracking_size(
581 settings().minimum_occlusion_tracking_size
);
583 // LayerIterator is used here instead of CallFunctionForSubtree to only
584 // UpdateTilePriorities on layers that will be visible (and thus have valid
585 // draw properties) and not because any ordering is required.
586 LayerIterator end
= LayerIterator::End(&render_surface_layer_list_
);
587 for (LayerIterator it
= LayerIterator::Begin(&render_surface_layer_list_
);
589 occlusion_tracker
.EnterLayer(it
);
591 // There are very few render targets so this should be cheap to do for
592 // each layer instead of something more complicated.
593 bool inside_replica
= false;
594 LayerImpl
* layer
= it
->render_target();
595 while (layer
&& !inside_replica
) {
596 if (layer
->render_target()->has_replica())
597 inside_replica
= true;
598 layer
= layer
->render_target()->parent();
601 // Don't use occlusion if a layer will appear in a replica, since the
602 // tile raster code does not know how to look for the replica and would
603 // consider it occluded even though the replica is visible.
604 // Since occlusion is only used for browser compositor (i.e.
605 // use_occlusion_for_tile_prioritization) and it won't use replicas,
606 // this should matter not.
608 if (it
.represents_itself()) {
609 Occlusion occlusion
=
610 inside_replica
? Occlusion()
611 : occlusion_tracker
.GetCurrentOcclusionForLayer(
612 it
->draw_transform());
613 it
->draw_properties().occlusion_in_content_space
= occlusion
;
616 if (it
.represents_contributing_render_surface()) {
617 // Surfaces aren't used by the tile raster code, so they can have
618 // occlusion regardless of replicas.
619 Occlusion occlusion
=
620 occlusion_tracker
.GetCurrentOcclusionForContributingSurface(
621 it
->render_surface()->draw_transform());
622 it
->render_surface()->set_occlusion_in_content_space(occlusion
);
623 // Masks are used to draw the contributing surface, so should have
624 // the same occlusion as the surface (nothing inside the surface
626 if (LayerImpl
* mask
= it
->mask_layer()) {
627 Occlusion mask_occlusion
=
630 : occlusion_tracker
.GetCurrentOcclusionForContributingSurface(
631 it
->render_surface()->draw_transform() *
632 it
->draw_transform());
633 mask
->draw_properties().occlusion_in_content_space
= mask_occlusion
;
635 if (LayerImpl
* replica
= it
->replica_layer()) {
636 if (LayerImpl
* mask
= replica
->mask_layer())
637 mask
->draw_properties().occlusion_in_content_space
= Occlusion();
641 occlusion_tracker
.LeaveLayer(it
);
644 unoccluded_screen_space_region_
=
645 occlusion_tracker
.ComputeVisibleRegionInScreen();
648 // It'd be ideal if this could be done earlier, but when the raster source
649 // is updated from the main thread during push properties, update draw
650 // properties has not occurred yet and so it's not clear whether or not the
651 // layer can or cannot use lcd text. So, this is the cleanup pass to
652 // determine if the raster source needs to be replaced with a non-lcd
653 // raster source due to draw properties.
654 if (update_lcd_text
) {
655 // TODO(enne): Make LTHI::sync_tree return this value.
656 LayerTreeImpl
* sync_tree
=
657 layer_tree_host_impl_
->proxy()->CommitToActiveTree()
658 ? layer_tree_host_impl_
->active_tree()
659 : layer_tree_host_impl_
->pending_tree();
660 // If this is not the sync tree, then it is not safe to update lcd text
661 // as it causes invalidations and the tiles may be in use.
662 DCHECK_EQ(this, sync_tree
);
663 for (const auto& layer
: picture_layers_
)
664 layer
->UpdateCanUseLCDTextAfterCommit();
668 TRACE_EVENT_BEGIN2("cc", "LayerTreeImpl::UpdateDrawProperties::UpdateTiles",
669 "IsActive", IsActiveTree(), "SourceFrameNumber",
670 source_frame_number_
);
671 const bool resourceless_software_draw
=
672 (layer_tree_host_impl_
->GetDrawMode() ==
673 DRAW_MODE_RESOURCELESS_SOFTWARE
);
674 size_t layers_updated_count
= 0;
675 bool tile_priorities_updated
= false;
676 for (PictureLayerImpl
* layer
: picture_layers_
) {
677 if (!layer
->IsDrawnRenderSurfaceLayerListMember())
679 ++layers_updated_count
;
680 tile_priorities_updated
|= layer
->UpdateTiles(resourceless_software_draw
);
683 if (tile_priorities_updated
)
684 DidModifyTilePriorities();
686 TRACE_EVENT_END1("cc", "LayerTreeImpl::UpdateTilePriorities",
687 "layers_updated_count", layers_updated_count
);
690 DCHECK(!needs_update_draw_properties_
) <<
691 "CalcDrawProperties should not set_needs_update_draw_properties()";
695 void LayerTreeImpl::BuildPropertyTreesForTesting() {
696 LayerTreeHostCommon::PreCalculateMetaInformationForTesting(root_layer_
.get());
697 PropertyTreeBuilder::BuildPropertyTrees(
698 root_layer_
.get(), PageScaleLayer(), InnerViewportScrollLayer(),
699 OuterViewportScrollLayer(), current_page_scale_factor(),
700 device_scale_factor(), gfx::Rect(DrawViewportSize()),
701 layer_tree_host_impl_
->DrawTransform(), &property_trees_
);
704 const LayerImplList
& LayerTreeImpl::RenderSurfaceLayerList() const {
705 // If this assert triggers, then the list is dirty.
706 DCHECK(!needs_update_draw_properties_
);
707 return render_surface_layer_list_
;
710 const Region
& LayerTreeImpl::UnoccludedScreenSpaceRegion() const {
711 // If this assert triggers, then the render_surface_layer_list_ is dirty, so
712 // the unoccluded_screen_space_region_ is not valid anymore.
713 DCHECK(!needs_update_draw_properties_
);
714 return unoccluded_screen_space_region_
;
717 gfx::SizeF
LayerTreeImpl::ScrollableSize() const {
718 LayerImpl
* root_scroll_layer
= OuterViewportScrollLayer()
719 ? OuterViewportScrollLayer()
720 : InnerViewportScrollLayer();
721 if (!root_scroll_layer
|| root_scroll_layer
->children().empty())
724 gfx::SizeF content_size
=
725 root_scroll_layer
->children()[0]->BoundsForScrolling();
726 gfx::SizeF viewport_size
=
727 root_scroll_layer
->scroll_clip_layer()->BoundsForScrolling();
729 content_size
.SetToMax(viewport_size
);
733 LayerImpl
* LayerTreeImpl::LayerById(int id
) const {
734 LayerIdMap::const_iterator iter
= layer_id_map_
.find(id
);
735 return iter
!= layer_id_map_
.end() ? iter
->second
: NULL
;
738 void LayerTreeImpl::RegisterLayer(LayerImpl
* layer
) {
739 DCHECK(!LayerById(layer
->id()));
740 layer_id_map_
[layer
->id()] = layer
;
741 if (layer_tree_host_impl_
->animation_host())
742 layer_tree_host_impl_
->animation_host()->RegisterLayer(
744 IsActiveTree() ? LayerTreeType::ACTIVE
: LayerTreeType::PENDING
);
747 void LayerTreeImpl::UnregisterLayer(LayerImpl
* layer
) {
748 DCHECK(LayerById(layer
->id()));
749 if (layer_tree_host_impl_
->animation_host())
750 layer_tree_host_impl_
->animation_host()->UnregisterLayer(
752 IsActiveTree() ? LayerTreeType::ACTIVE
: LayerTreeType::PENDING
);
753 layer_id_map_
.erase(layer
->id());
756 size_t LayerTreeImpl::NumLayers() {
757 return layer_id_map_
.size();
760 void LayerTreeImpl::DidBecomeActive() {
761 if (next_activation_forces_redraw_
) {
762 layer_tree_host_impl_
->SetFullRootLayerDamage();
763 next_activation_forces_redraw_
= false;
766 // Always reset this flag on activation, as we would only have activated
767 // if we were in a good state.
768 layer_tree_host_impl_
->ResetRequiresHighResToDraw();
771 LayerTreeHostCommon::CallFunctionForSubtree(
772 root_layer(), [](LayerImpl
* layer
) { layer
->DidBecomeActive(); });
775 for (auto* swap_promise
: swap_promise_list_
)
776 swap_promise
->DidActivate();
777 devtools_instrumentation::DidActivateLayerTree(layer_tree_host_impl_
->id(),
778 source_frame_number_
);
781 bool LayerTreeImpl::RequiresHighResToDraw() const {
782 return layer_tree_host_impl_
->RequiresHighResToDraw();
785 bool LayerTreeImpl::ViewportSizeInvalid() const {
786 return viewport_size_invalid_
;
789 void LayerTreeImpl::SetViewportSizeInvalid() {
790 viewport_size_invalid_
= true;
791 layer_tree_host_impl_
->OnCanDrawStateChangedForTree();
794 void LayerTreeImpl::ResetViewportSizeInvalid() {
795 viewport_size_invalid_
= false;
796 layer_tree_host_impl_
->OnCanDrawStateChangedForTree();
799 Proxy
* LayerTreeImpl::proxy() const {
800 return layer_tree_host_impl_
->proxy();
803 const LayerTreeSettings
& LayerTreeImpl::settings() const {
804 return layer_tree_host_impl_
->settings();
807 const LayerTreeDebugState
& LayerTreeImpl::debug_state() const {
808 return layer_tree_host_impl_
->debug_state();
811 const RendererCapabilitiesImpl
& LayerTreeImpl::GetRendererCapabilities() const {
812 return layer_tree_host_impl_
->GetRendererCapabilities();
815 ContextProvider
* LayerTreeImpl::context_provider() const {
816 return output_surface()->context_provider();
819 OutputSurface
* LayerTreeImpl::output_surface() const {
820 return layer_tree_host_impl_
->output_surface();
823 ResourceProvider
* LayerTreeImpl::resource_provider() const {
824 return layer_tree_host_impl_
->resource_provider();
827 TileManager
* LayerTreeImpl::tile_manager() const {
828 return layer_tree_host_impl_
->tile_manager();
831 FrameRateCounter
* LayerTreeImpl::frame_rate_counter() const {
832 return layer_tree_host_impl_
->fps_counter();
835 MemoryHistory
* LayerTreeImpl::memory_history() const {
836 return layer_tree_host_impl_
->memory_history();
839 gfx::Size
LayerTreeImpl::device_viewport_size() const {
840 return layer_tree_host_impl_
->device_viewport_size();
843 float LayerTreeImpl::device_scale_factor() const {
844 return layer_tree_host_impl_
->device_scale_factor();
847 DebugRectHistory
* LayerTreeImpl::debug_rect_history() const {
848 return layer_tree_host_impl_
->debug_rect_history();
851 bool LayerTreeImpl::IsActiveTree() const {
852 return layer_tree_host_impl_
->active_tree() == this;
855 bool LayerTreeImpl::IsPendingTree() const {
856 return layer_tree_host_impl_
->pending_tree() == this;
859 bool LayerTreeImpl::IsRecycleTree() const {
860 return layer_tree_host_impl_
->recycle_tree() == this;
863 bool LayerTreeImpl::IsSyncTree() const {
864 return layer_tree_host_impl_
->sync_tree() == this;
867 LayerImpl
* LayerTreeImpl::FindActiveTreeLayerById(int id
) {
868 LayerTreeImpl
* tree
= layer_tree_host_impl_
->active_tree();
871 return tree
->LayerById(id
);
874 LayerImpl
* LayerTreeImpl::FindPendingTreeLayerById(int id
) {
875 LayerTreeImpl
* tree
= layer_tree_host_impl_
->pending_tree();
878 return tree
->LayerById(id
);
881 bool LayerTreeImpl::PinchGestureActive() const {
882 return layer_tree_host_impl_
->pinch_gesture_active();
885 BeginFrameArgs
LayerTreeImpl::CurrentBeginFrameArgs() const {
886 return layer_tree_host_impl_
->CurrentBeginFrameArgs();
889 base::TimeDelta
LayerTreeImpl::CurrentBeginFrameInterval() const {
890 return layer_tree_host_impl_
->CurrentBeginFrameInterval();
893 void LayerTreeImpl::SetNeedsCommit() {
894 layer_tree_host_impl_
->SetNeedsCommit();
897 gfx::Rect
LayerTreeImpl::DeviceViewport() const {
898 return layer_tree_host_impl_
->DeviceViewport();
901 gfx::Size
LayerTreeImpl::DrawViewportSize() const {
902 return layer_tree_host_impl_
->DrawViewportSize();
905 const gfx::Rect
LayerTreeImpl::ViewportRectForTilePriority() const {
906 return layer_tree_host_impl_
->ViewportRectForTilePriority();
909 scoped_ptr
<ScrollbarAnimationController
>
910 LayerTreeImpl::CreateScrollbarAnimationController(LayerImpl
* scrolling_layer
) {
911 DCHECK(settings().scrollbar_fade_delay_ms
);
912 DCHECK(settings().scrollbar_fade_duration_ms
);
913 base::TimeDelta delay
=
914 base::TimeDelta::FromMilliseconds(settings().scrollbar_fade_delay_ms
);
915 base::TimeDelta resize_delay
= base::TimeDelta::FromMilliseconds(
916 settings().scrollbar_fade_resize_delay_ms
);
917 base::TimeDelta duration
=
918 base::TimeDelta::FromMilliseconds(settings().scrollbar_fade_duration_ms
);
919 switch (settings().scrollbar_animator
) {
920 case LayerTreeSettings::LINEAR_FADE
: {
921 return ScrollbarAnimationControllerLinearFade::Create(
923 layer_tree_host_impl_
,
928 case LayerTreeSettings::THINNING
: {
929 return ScrollbarAnimationControllerThinning::Create(scrolling_layer
,
930 layer_tree_host_impl_
,
935 case LayerTreeSettings::NO_ANIMATOR
:
942 void LayerTreeImpl::DidAnimateScrollOffset() {
943 layer_tree_host_impl_
->DidAnimateScrollOffset();
946 bool LayerTreeImpl::use_gpu_rasterization() const {
947 return layer_tree_host_impl_
->use_gpu_rasterization();
950 GpuRasterizationStatus
LayerTreeImpl::GetGpuRasterizationStatus() const {
951 return layer_tree_host_impl_
->gpu_rasterization_status();
954 bool LayerTreeImpl::create_low_res_tiling() const {
955 return layer_tree_host_impl_
->create_low_res_tiling();
958 void LayerTreeImpl::SetNeedsRedraw() {
959 layer_tree_host_impl_
->SetNeedsRedraw();
962 AnimationRegistrar
* LayerTreeImpl::GetAnimationRegistrar() const {
963 return layer_tree_host_impl_
->animation_registrar();
966 void LayerTreeImpl::GetAllPrioritizedTilesForTracing(
967 std::vector
<PrioritizedTile
>* prioritized_tiles
) const {
968 LayerIterator end
= LayerIterator::End(&render_surface_layer_list_
);
969 for (LayerIterator it
= LayerIterator::Begin(&render_surface_layer_list_
);
971 if (!it
.represents_itself())
973 LayerImpl
* layer_impl
= *it
;
974 layer_impl
->GetAllPrioritizedTilesForTracing(prioritized_tiles
);
978 void LayerTreeImpl::AsValueInto(base::trace_event::TracedValue
* state
) const {
979 TracedValue::MakeDictIntoImplicitSnapshot(state
, "cc::LayerTreeImpl", this);
980 state
->SetInteger("source_frame_number", source_frame_number_
);
982 state
->BeginDictionary("root_layer");
983 root_layer_
->AsValueInto(state
);
984 state
->EndDictionary();
986 state
->BeginArray("render_surface_layer_list");
987 LayerIterator end
= LayerIterator::End(&render_surface_layer_list_
);
988 for (LayerIterator it
= LayerIterator::Begin(&render_surface_layer_list_
);
990 if (!it
.represents_itself())
992 TracedValue::AppendIDRef(*it
, state
);
996 state
->BeginArray("swap_promise_trace_ids");
997 for (auto* swap_promise
: swap_promise_list_
)
998 state
->AppendDouble(swap_promise
->TraceId());
1001 state
->BeginArray("pinned_swap_promise_trace_ids");
1002 for (auto* swap_promise
: pinned_swap_promise_list_
)
1003 state
->AppendDouble(swap_promise
->TraceId());
1007 void LayerTreeImpl::DistributeRootScrollOffset(
1008 const gfx::ScrollOffset
& root_offset
) {
1009 if (!InnerViewportScrollLayer())
1012 DCHECK(OuterViewportScrollLayer());
1014 // If we get here, we have both inner/outer viewports, and need to distribute
1015 // the scroll offset between them.
1016 gfx::ScrollOffset inner_viewport_offset
=
1017 InnerViewportScrollLayer()->CurrentScrollOffset();
1018 gfx::ScrollOffset outer_viewport_offset
=
1019 OuterViewportScrollLayer()->CurrentScrollOffset();
1021 // It may be nothing has changed.
1022 DCHECK(inner_viewport_offset
+ outer_viewport_offset
== TotalScrollOffset());
1023 if (inner_viewport_offset
+ outer_viewport_offset
== root_offset
)
1026 gfx::ScrollOffset max_outer_viewport_scroll_offset
=
1027 OuterViewportScrollLayer()->MaxScrollOffset();
1029 outer_viewport_offset
= root_offset
- inner_viewport_offset
;
1030 outer_viewport_offset
.SetToMin(max_outer_viewport_scroll_offset
);
1031 outer_viewport_offset
.SetToMax(gfx::ScrollOffset());
1033 OuterViewportScrollLayer()->SetCurrentScrollOffset(outer_viewport_offset
);
1034 inner_viewport_offset
= root_offset
- outer_viewport_offset
;
1035 InnerViewportScrollLayer()->SetCurrentScrollOffset(inner_viewport_offset
);
1038 void LayerTreeImpl::QueueSwapPromise(scoped_ptr
<SwapPromise
> swap_promise
) {
1039 DCHECK(swap_promise
);
1040 swap_promise_list_
.push_back(swap_promise
.Pass());
1043 void LayerTreeImpl::QueuePinnedSwapPromise(
1044 scoped_ptr
<SwapPromise
> swap_promise
) {
1045 DCHECK(IsActiveTree());
1046 DCHECK(swap_promise
);
1047 pinned_swap_promise_list_
.push_back(swap_promise
.Pass());
1050 void LayerTreeImpl::PassSwapPromises(
1051 ScopedPtrVector
<SwapPromise
>* new_swap_promise
) {
1052 for (auto* swap_promise
: swap_promise_list_
)
1053 swap_promise
->DidNotSwap(SwapPromise::SWAP_FAILS
);
1054 swap_promise_list_
.clear();
1055 swap_promise_list_
.swap(*new_swap_promise
);
1058 void LayerTreeImpl::FinishSwapPromises(CompositorFrameMetadata
* metadata
) {
1059 for (auto* swap_promise
: swap_promise_list_
)
1060 swap_promise
->DidSwap(metadata
);
1061 swap_promise_list_
.clear();
1062 for (auto* swap_promise
: pinned_swap_promise_list_
)
1063 swap_promise
->DidSwap(metadata
);
1064 pinned_swap_promise_list_
.clear();
1067 void LayerTreeImpl::BreakSwapPromises(SwapPromise::DidNotSwapReason reason
) {
1068 for (auto* swap_promise
: swap_promise_list_
)
1069 swap_promise
->DidNotSwap(reason
);
1070 swap_promise_list_
.clear();
1071 for (auto* swap_promise
: pinned_swap_promise_list_
)
1072 swap_promise
->DidNotSwap(reason
);
1073 pinned_swap_promise_list_
.clear();
1076 void LayerTreeImpl::DidModifyTilePriorities() {
1077 layer_tree_host_impl_
->DidModifyTilePriorities();
1080 void LayerTreeImpl::set_ui_resource_request_queue(
1081 const UIResourceRequestQueue
& queue
) {
1082 ui_resource_request_queue_
= queue
;
1085 ResourceId
LayerTreeImpl::ResourceIdForUIResource(UIResourceId uid
) const {
1086 return layer_tree_host_impl_
->ResourceIdForUIResource(uid
);
1089 bool LayerTreeImpl::IsUIResourceOpaque(UIResourceId uid
) const {
1090 return layer_tree_host_impl_
->IsUIResourceOpaque(uid
);
1093 void LayerTreeImpl::ProcessUIResourceRequestQueue() {
1094 for (const auto& req
: ui_resource_request_queue_
) {
1095 switch (req
.GetType()) {
1096 case UIResourceRequest::UI_RESOURCE_CREATE
:
1097 layer_tree_host_impl_
->CreateUIResource(req
.GetId(), req
.GetBitmap());
1099 case UIResourceRequest::UI_RESOURCE_DELETE
:
1100 layer_tree_host_impl_
->DeleteUIResource(req
.GetId());
1102 case UIResourceRequest::UI_RESOURCE_INVALID_REQUEST
:
1107 ui_resource_request_queue_
.clear();
1109 // If all UI resource evictions were not recreated by processing this queue,
1110 // then another commit is required.
1111 if (layer_tree_host_impl_
->EvictedUIResourcesExist())
1112 layer_tree_host_impl_
->SetNeedsCommit();
1115 void LayerTreeImpl::RegisterPictureLayerImpl(PictureLayerImpl
* layer
) {
1116 DCHECK(std::find(picture_layers_
.begin(), picture_layers_
.end(), layer
) ==
1117 picture_layers_
.end());
1118 picture_layers_
.push_back(layer
);
1121 void LayerTreeImpl::UnregisterPictureLayerImpl(PictureLayerImpl
* layer
) {
1122 std::vector
<PictureLayerImpl
*>::iterator it
=
1123 std::find(picture_layers_
.begin(), picture_layers_
.end(), layer
);
1124 DCHECK(it
!= picture_layers_
.end());
1125 picture_layers_
.erase(it
);
1128 void LayerTreeImpl::AddLayerWithCopyOutputRequest(LayerImpl
* layer
) {
1129 // Only the active tree needs to know about layers with copy requests, as
1130 // they are aborted if not serviced during draw.
1131 DCHECK(IsActiveTree());
1133 // DCHECK(std::find(layers_with_copy_output_request_.begin(),
1134 // layers_with_copy_output_request_.end(),
1135 // layer) == layers_with_copy_output_request_.end());
1136 // TODO(danakj): Remove this once crash is found crbug.com/309777
1137 for (size_t i
= 0; i
< layers_with_copy_output_request_
.size(); ++i
) {
1138 CHECK(layers_with_copy_output_request_
[i
] != layer
)
1139 << i
<< " of " << layers_with_copy_output_request_
.size();
1141 layers_with_copy_output_request_
.push_back(layer
);
1144 void LayerTreeImpl::RemoveLayerWithCopyOutputRequest(LayerImpl
* layer
) {
1145 // Only the active tree needs to know about layers with copy requests, as
1146 // they are aborted if not serviced during draw.
1147 DCHECK(IsActiveTree());
1149 std::vector
<LayerImpl
*>::iterator it
= std::find(
1150 layers_with_copy_output_request_
.begin(),
1151 layers_with_copy_output_request_
.end(),
1153 DCHECK(it
!= layers_with_copy_output_request_
.end());
1154 layers_with_copy_output_request_
.erase(it
);
1156 // TODO(danakj): Remove this once crash is found crbug.com/309777
1157 for (size_t i
= 0; i
< layers_with_copy_output_request_
.size(); ++i
) {
1158 CHECK(layers_with_copy_output_request_
[i
] != layer
)
1159 << i
<< " of " << layers_with_copy_output_request_
.size();
1163 const std::vector
<LayerImpl
*>& LayerTreeImpl::LayersWithCopyOutputRequest()
1165 // Only the active tree needs to know about layers with copy requests, as
1166 // they are aborted if not serviced during draw.
1167 DCHECK(IsActiveTree());
1169 return layers_with_copy_output_request_
;
1172 template <typename LayerType
>
1173 static inline bool LayerClipsSubtree(LayerType
* layer
) {
1174 return layer
->masks_to_bounds() || layer
->mask_layer();
1177 static bool PointHitsRect(
1178 const gfx::PointF
& screen_space_point
,
1179 const gfx::Transform
& local_space_to_screen_space_transform
,
1180 const gfx::Rect
& local_space_rect
,
1181 float* distance_to_camera
) {
1182 // If the transform is not invertible, then assume that this point doesn't hit
1184 gfx::Transform
inverse_local_space_to_screen_space(
1185 gfx::Transform::kSkipInitialization
);
1186 if (!local_space_to_screen_space_transform
.GetInverse(
1187 &inverse_local_space_to_screen_space
))
1190 // Transform the hit test point from screen space to the local space of the
1192 bool clipped
= false;
1193 gfx::Point3F planar_point
= MathUtil::ProjectPoint3D(
1194 inverse_local_space_to_screen_space
, screen_space_point
, &clipped
);
1195 gfx::PointF hit_test_point_in_local_space
=
1196 gfx::PointF(planar_point
.x(), planar_point
.y());
1198 // If ProjectPoint could not project to a valid value, then we assume that
1199 // this point doesn't hit this rect.
1203 if (!gfx::RectF(local_space_rect
).Contains(hit_test_point_in_local_space
))
1206 if (distance_to_camera
) {
1207 // To compute the distance to the camera, we have to take the planar point
1208 // and pull it back to world space and compute the displacement along the
1210 gfx::Point3F
planar_point_in_screen_space(planar_point
);
1211 local_space_to_screen_space_transform
.TransformPoint(
1212 &planar_point_in_screen_space
);
1213 *distance_to_camera
= planar_point_in_screen_space
.z();
1219 static bool PointHitsRegion(const gfx::PointF
& screen_space_point
,
1220 const gfx::Transform
& screen_space_transform
,
1221 const Region
& layer_space_region
) {
1222 // If the transform is not invertible, then assume that this point doesn't hit
1224 gfx::Transform
inverse_screen_space_transform(
1225 gfx::Transform::kSkipInitialization
);
1226 if (!screen_space_transform
.GetInverse(&inverse_screen_space_transform
))
1229 // Transform the hit test point from screen space to the local space of the
1231 bool clipped
= false;
1232 gfx::PointF hit_test_point_in_layer_space
= MathUtil::ProjectPoint(
1233 inverse_screen_space_transform
, screen_space_point
, &clipped
);
1235 // If ProjectPoint could not project to a valid value, then we assume that
1236 // this point doesn't hit this region.
1240 return layer_space_region
.Contains(
1241 gfx::ToRoundedPoint(hit_test_point_in_layer_space
));
1244 static const LayerImpl
* GetNextClippingLayer(const LayerImpl
* layer
) {
1245 if (layer
->scroll_parent())
1246 return layer
->scroll_parent();
1247 if (layer
->clip_parent())
1248 return layer
->clip_parent();
1249 return layer
->parent();
1252 static bool PointIsClippedBySurfaceOrClipRect(
1253 const gfx::PointF
& screen_space_point
,
1254 const LayerImpl
* layer
) {
1255 // Walk up the layer tree and hit-test any render_surfaces and any layer
1256 // clip rects that are active.
1257 for (; layer
; layer
= GetNextClippingLayer(layer
)) {
1258 if (layer
->render_surface() &&
1259 !PointHitsRect(screen_space_point
,
1260 layer
->render_surface()->screen_space_transform(),
1261 layer
->render_surface()->content_rect(),
1265 if (LayerClipsSubtree(layer
) &&
1266 !PointHitsRect(screen_space_point
, layer
->screen_space_transform(),
1267 gfx::Rect(layer
->bounds()), NULL
))
1271 // If we have finished walking all ancestors without having already exited,
1272 // then the point is not clipped by any ancestors.
1276 static bool PointHitsLayer(const LayerImpl
* layer
,
1277 const gfx::PointF
& screen_space_point
,
1278 float* distance_to_intersection
) {
1279 gfx::Rect
content_rect(layer
->bounds());
1280 if (!PointHitsRect(screen_space_point
,
1281 layer
->screen_space_transform(),
1283 distance_to_intersection
))
1286 // At this point, we think the point does hit the layer, but we need to walk
1287 // up the parents to ensure that the layer was not clipped in such a way
1288 // that the hit point actually should not hit the layer.
1289 if (PointIsClippedBySurfaceOrClipRect(screen_space_point
, layer
))
1292 // Skip the HUD layer.
1293 if (layer
== layer
->layer_tree_impl()->hud_layer())
1299 struct FindClosestMatchingLayerDataForRecursion
{
1300 FindClosestMatchingLayerDataForRecursion()
1301 : closest_match(NULL
),
1302 closest_distance(-std::numeric_limits
<float>::infinity()) {}
1303 LayerImpl
* closest_match
;
1304 // Note that the positive z-axis points towards the camera, so bigger means
1305 // closer in this case, counterintuitively.
1306 float closest_distance
;
1309 template <typename Functor
>
1310 static void FindClosestMatchingLayer(
1311 const gfx::PointF
& screen_space_point
,
1313 const Functor
& func
,
1314 FindClosestMatchingLayerDataForRecursion
* data_for_recursion
) {
1315 size_t children_size
= layer
->children().size();
1316 for (size_t i
= 0; i
< children_size
; ++i
) {
1317 size_t index
= children_size
- 1 - i
;
1318 FindClosestMatchingLayer(screen_space_point
, layer
->children()[index
], func
,
1319 data_for_recursion
);
1322 float distance_to_intersection
= 0.f
;
1324 PointHitsLayer(layer
, screen_space_point
, &distance_to_intersection
) &&
1325 ((!data_for_recursion
->closest_match
||
1326 distance_to_intersection
> data_for_recursion
->closest_distance
))) {
1327 data_for_recursion
->closest_distance
= distance_to_intersection
;
1328 data_for_recursion
->closest_match
= layer
;
1332 static bool ScrollsAnyDrawnRenderSurfaceLayerListMember(LayerImpl
* layer
) {
1333 if (!layer
->scrollable())
1335 if (layer
->layer_or_descendant_is_drawn())
1338 if (!layer
->scroll_children())
1340 for (std::set
<LayerImpl
*>::const_iterator it
=
1341 layer
->scroll_children()->begin();
1342 it
!= layer
->scroll_children()->end();
1344 if ((*it
)->layer_or_descendant_is_drawn())
1350 struct FindScrollingLayerFunctor
{
1351 bool operator()(LayerImpl
* layer
) const {
1352 return ScrollsAnyDrawnRenderSurfaceLayerListMember(layer
);
1356 LayerImpl
* LayerTreeImpl::FindFirstScrollingLayerThatIsHitByPoint(
1357 const gfx::PointF
& screen_space_point
) {
1358 FindClosestMatchingLayerDataForRecursion data_for_recursion
;
1359 FindClosestMatchingLayer(screen_space_point
,
1361 FindScrollingLayerFunctor(),
1362 &data_for_recursion
);
1363 return data_for_recursion
.closest_match
;
1366 struct HitTestVisibleScrollableOrTouchableFunctor
{
1367 bool operator()(LayerImpl
* layer
) const {
1368 return layer
->IsDrawnRenderSurfaceLayerListMember() ||
1369 ScrollsAnyDrawnRenderSurfaceLayerListMember(layer
) ||
1370 !layer
->touch_event_handler_region().IsEmpty() ||
1371 layer
->have_wheel_event_handlers();
1375 LayerImpl
* LayerTreeImpl::FindLayerThatIsHitByPoint(
1376 const gfx::PointF
& screen_space_point
) {
1379 bool update_lcd_text
= false;
1380 if (!UpdateDrawProperties(update_lcd_text
))
1382 FindClosestMatchingLayerDataForRecursion data_for_recursion
;
1383 FindClosestMatchingLayer(screen_space_point
,
1385 HitTestVisibleScrollableOrTouchableFunctor(),
1386 &data_for_recursion
);
1387 return data_for_recursion
.closest_match
;
1390 static bool LayerHasTouchEventHandlersAt(const gfx::PointF
& screen_space_point
,
1391 LayerImpl
* layer_impl
) {
1392 if (layer_impl
->touch_event_handler_region().IsEmpty())
1395 if (!PointHitsRegion(screen_space_point
, layer_impl
->screen_space_transform(),
1396 layer_impl
->touch_event_handler_region()))
1399 // At this point, we think the point does hit the touch event handler region
1400 // on the layer, but we need to walk up the parents to ensure that the layer
1401 // was not clipped in such a way that the hit point actually should not hit
1403 if (PointIsClippedBySurfaceOrClipRect(screen_space_point
, layer_impl
))
1409 struct FindWheelEventLayerFunctor
{
1410 bool operator()(LayerImpl
* layer
) const {
1411 return layer
->have_wheel_event_handlers();
1415 LayerImpl
* LayerTreeImpl::FindLayerWithWheelHandlerThatIsHitByPoint(
1416 const gfx::PointF
& screen_space_point
) {
1419 bool update_lcd_text
= false;
1420 if (!UpdateDrawProperties(update_lcd_text
))
1422 FindWheelEventLayerFunctor func
;
1423 FindClosestMatchingLayerDataForRecursion data_for_recursion
;
1424 FindClosestMatchingLayer(screen_space_point
, root_layer(), func
,
1425 &data_for_recursion
);
1426 return data_for_recursion
.closest_match
;
1429 struct FindTouchEventLayerFunctor
{
1430 bool operator()(LayerImpl
* layer
) const {
1431 return LayerHasTouchEventHandlersAt(screen_space_point
, layer
);
1433 const gfx::PointF screen_space_point
;
1436 LayerImpl
* LayerTreeImpl::FindLayerThatIsHitByPointInTouchHandlerRegion(
1437 const gfx::PointF
& screen_space_point
) {
1440 bool update_lcd_text
= false;
1441 if (!UpdateDrawProperties(update_lcd_text
))
1443 FindTouchEventLayerFunctor func
= {screen_space_point
};
1444 FindClosestMatchingLayerDataForRecursion data_for_recursion
;
1445 FindClosestMatchingLayer(
1446 screen_space_point
, root_layer(), func
, &data_for_recursion
);
1447 return data_for_recursion
.closest_match
;
1450 void LayerTreeImpl::RegisterSelection(const LayerSelection
& selection
) {
1451 selection_
= selection
;
1454 static ViewportSelectionBound
ComputeViewportSelectionBound(
1455 const LayerSelectionBound
& layer_bound
,
1457 float device_scale_factor
) {
1458 ViewportSelectionBound viewport_bound
;
1459 viewport_bound
.type
= layer_bound
.type
;
1461 if (!layer
|| layer_bound
.type
== SELECTION_BOUND_EMPTY
)
1462 return viewport_bound
;
1464 gfx::PointF layer_top
= layer_bound
.edge_top
;
1465 gfx::PointF layer_bottom
= layer_bound
.edge_bottom
;
1467 bool clipped
= false;
1468 gfx::PointF screen_top
=
1469 MathUtil::MapPoint(layer
->screen_space_transform(), layer_top
, &clipped
);
1470 gfx::PointF screen_bottom
= MathUtil::MapPoint(
1471 layer
->screen_space_transform(), layer_bottom
, &clipped
);
1473 // MapPoint can produce points with NaN components (even when no inputs are
1474 // NaN). Since consumers of ViewportSelectionBounds may round |edge_top| or
1475 // |edge_bottom| (and since rounding will crash on NaN), we return an empty
1477 if (std::isnan(screen_top
.x()) || std::isnan(screen_top
.y()) ||
1478 std::isnan(screen_bottom
.x()) || std::isnan(screen_bottom
.y()))
1479 return ViewportSelectionBound();
1481 const float inv_scale
= 1.f
/ device_scale_factor
;
1482 viewport_bound
.edge_top
= gfx::ScalePoint(screen_top
, inv_scale
);
1483 viewport_bound
.edge_bottom
= gfx::ScalePoint(screen_bottom
, inv_scale
);
1485 // The bottom edge point is used for visibility testing as it is the logical
1486 // focal point for bound selection handles (this may change in the future).
1487 // Shifting the visibility point fractionally inward ensures that neighboring
1488 // or logically coincident layers aligned to integral DPI coordinates will not
1489 // spuriously occlude the bound.
1490 gfx::Vector2dF visibility_offset
= layer_top
- layer_bottom
;
1491 visibility_offset
.Scale(device_scale_factor
/ visibility_offset
.Length());
1492 gfx::PointF visibility_point
= layer_bottom
+ visibility_offset
;
1493 if (visibility_point
.x() <= 0)
1494 visibility_point
.set_x(visibility_point
.x() + device_scale_factor
);
1495 visibility_point
= MathUtil::MapPoint(
1496 layer
->screen_space_transform(), visibility_point
, &clipped
);
1498 float intersect_distance
= 0.f
;
1499 viewport_bound
.visible
=
1500 PointHitsLayer(layer
, visibility_point
, &intersect_distance
);
1502 return viewport_bound
;
1505 void LayerTreeImpl::GetViewportSelection(ViewportSelection
* selection
) {
1508 selection
->start
= ComputeViewportSelectionBound(
1510 selection_
.start
.layer_id
? LayerById(selection_
.start
.layer_id
) : NULL
,
1511 device_scale_factor());
1512 selection
->is_editable
= selection_
.is_editable
;
1513 selection
->is_empty_text_form_control
= selection_
.is_empty_text_form_control
;
1514 if (selection
->start
.type
== SELECTION_BOUND_CENTER
||
1515 selection
->start
.type
== SELECTION_BOUND_EMPTY
) {
1516 selection
->end
= selection
->start
;
1518 selection
->end
= ComputeViewportSelectionBound(
1520 selection_
.end
.layer_id
? LayerById(selection_
.end
.layer_id
) : NULL
,
1521 device_scale_factor());
1525 void LayerTreeImpl::InputScrollAnimationFinished() {
1526 layer_tree_host_impl_
->ScrollEnd();
1529 bool LayerTreeImpl::SmoothnessTakesPriority() const {
1530 return layer_tree_host_impl_
->GetTreePriority() == SMOOTHNESS_TAKES_PRIORITY
;
1533 BlockingTaskRunner
* LayerTreeImpl::BlockingMainThreadTaskRunner() const {
1534 return proxy()->blocking_main_thread_task_runner();
1537 VideoFrameControllerClient
* LayerTreeImpl::GetVideoFrameControllerClient()
1539 return layer_tree_host_impl_
;
1542 void LayerTreeImpl::SetPendingPageScaleAnimation(
1543 scoped_ptr
<PendingPageScaleAnimation
> pending_animation
) {
1544 pending_page_scale_animation_
= pending_animation
.Pass();
1547 scoped_ptr
<PendingPageScaleAnimation
>
1548 LayerTreeImpl::TakePendingPageScaleAnimation() {
1549 return pending_page_scale_animation_
.Pass();
1552 bool LayerTreeImpl::IsAnimatingFilterProperty(const LayerImpl
* layer
) const {
1553 LayerTreeType tree_type
=
1554 IsActiveTree() ? LayerTreeType::ACTIVE
: LayerTreeType::PENDING
;
1555 return layer_tree_host_impl_
->animation_host()
1556 ? layer_tree_host_impl_
->animation_host()
1557 ->IsAnimatingFilterProperty(layer
->id(), tree_type
)
1561 bool LayerTreeImpl::IsAnimatingOpacityProperty(const LayerImpl
* layer
) const {
1562 LayerTreeType tree_type
=
1563 IsActiveTree() ? LayerTreeType::ACTIVE
: LayerTreeType::PENDING
;
1564 return layer_tree_host_impl_
->animation_host()
1565 ? layer_tree_host_impl_
->animation_host()
1566 ->IsAnimatingOpacityProperty(layer
->id(), tree_type
)
1570 bool LayerTreeImpl::IsAnimatingTransformProperty(const LayerImpl
* layer
) const {
1571 LayerTreeType tree_type
=
1572 IsActiveTree() ? LayerTreeType::ACTIVE
: LayerTreeType::PENDING
;
1573 return layer_tree_host_impl_
->animation_host()
1574 ? layer_tree_host_impl_
->animation_host()
1575 ->IsAnimatingTransformProperty(layer
->id(), tree_type
)
1579 bool LayerTreeImpl::HasPotentiallyRunningFilterAnimation(
1580 const LayerImpl
* layer
) const {
1581 LayerTreeType tree_type
=
1582 IsActiveTree() ? LayerTreeType::ACTIVE
: LayerTreeType::PENDING
;
1583 return layer_tree_host_impl_
->animation_host()
1584 ? layer_tree_host_impl_
->animation_host()
1585 ->HasPotentiallyRunningFilterAnimation(layer
->id(),
1590 bool LayerTreeImpl::HasPotentiallyRunningOpacityAnimation(
1591 const LayerImpl
* layer
) const {
1592 LayerTreeType tree_type
=
1593 IsActiveTree() ? LayerTreeType::ACTIVE
: LayerTreeType::PENDING
;
1594 return layer_tree_host_impl_
->animation_host()
1595 ? layer_tree_host_impl_
->animation_host()
1596 ->HasPotentiallyRunningOpacityAnimation(layer
->id(),
1601 bool LayerTreeImpl::HasPotentiallyRunningTransformAnimation(
1602 const LayerImpl
* layer
) const {
1603 LayerTreeType tree_type
=
1604 IsActiveTree() ? LayerTreeType::ACTIVE
: LayerTreeType::PENDING
;
1605 return layer_tree_host_impl_
->animation_host()
1606 ? layer_tree_host_impl_
->animation_host()
1607 ->HasPotentiallyRunningTransformAnimation(layer
->id(),
1612 bool LayerTreeImpl::HasAnyAnimationTargetingProperty(
1613 const LayerImpl
* layer
,
1614 Animation::TargetProperty property
) const {
1615 return layer_tree_host_impl_
->animation_host()
1616 ? layer_tree_host_impl_
->animation_host()
1617 ->HasAnyAnimationTargetingProperty(layer
->id(), property
)
1621 bool LayerTreeImpl::FilterIsAnimatingOnImplOnly(const LayerImpl
* layer
) const {
1622 return layer_tree_host_impl_
->animation_host()
1623 ? layer_tree_host_impl_
->animation_host()
1624 ->FilterIsAnimatingOnImplOnly(layer
->id())
1628 bool LayerTreeImpl::OpacityIsAnimatingOnImplOnly(const LayerImpl
* layer
) const {
1629 return layer_tree_host_impl_
->animation_host()
1630 ? layer_tree_host_impl_
->animation_host()
1631 ->OpacityIsAnimatingOnImplOnly(layer
->id())
1635 bool LayerTreeImpl::TransformIsAnimatingOnImplOnly(
1636 const LayerImpl
* layer
) const {
1637 return layer_tree_host_impl_
->animation_host()
1638 ? layer_tree_host_impl_
->animation_host()
1639 ->TransformIsAnimatingOnImplOnly(layer
->id())
1643 bool LayerTreeImpl::HasOnlyTranslationTransforms(const LayerImpl
* layer
) const {
1644 LayerTreeType tree_type
=
1645 IsActiveTree() ? LayerTreeType::ACTIVE
: LayerTreeType::PENDING
;
1646 return layer_tree_host_impl_
->animation_host()
1647 ? layer_tree_host_impl_
->animation_host()
1648 ->HasOnlyTranslationTransforms(layer
->id(), tree_type
)
1652 bool LayerTreeImpl::MaximumTargetScale(const LayerImpl
* layer
,
1653 float* max_scale
) const {
1655 LayerTreeType tree_type
=
1656 IsActiveTree() ? LayerTreeType::ACTIVE
: LayerTreeType::PENDING
;
1657 return layer_tree_host_impl_
->animation_host()
1658 ? layer_tree_host_impl_
->animation_host()->MaximumTargetScale(
1659 layer
->id(), tree_type
, max_scale
)
1663 bool LayerTreeImpl::AnimationStartScale(const LayerImpl
* layer
,
1664 float* start_scale
) const {
1666 LayerTreeType tree_type
=
1667 IsActiveTree() ? LayerTreeType::ACTIVE
: LayerTreeType::PENDING
;
1668 return layer_tree_host_impl_
->animation_host()
1669 ? layer_tree_host_impl_
->animation_host()->AnimationStartScale(
1670 layer
->id(), tree_type
, start_scale
)
1674 bool LayerTreeImpl::HasFilterAnimationThatInflatesBounds(
1675 const LayerImpl
* layer
) const {
1676 return layer_tree_host_impl_
->animation_host()
1677 ? layer_tree_host_impl_
->animation_host()
1678 ->HasFilterAnimationThatInflatesBounds(layer
->id())
1682 bool LayerTreeImpl::HasTransformAnimationThatInflatesBounds(
1683 const LayerImpl
* layer
) const {
1684 return layer_tree_host_impl_
->animation_host()
1685 ? layer_tree_host_impl_
->animation_host()
1686 ->HasTransformAnimationThatInflatesBounds(layer
->id())
1690 bool LayerTreeImpl::HasAnimationThatInflatesBounds(
1691 const LayerImpl
* layer
) const {
1692 return layer_tree_host_impl_
->animation_host()
1693 ? layer_tree_host_impl_
->animation_host()
1694 ->HasAnimationThatInflatesBounds(layer
->id())
1698 bool LayerTreeImpl::FilterAnimationBoundsForBox(const LayerImpl
* layer
,
1699 const gfx::BoxF
& box
,
1700 gfx::BoxF
* bounds
) const {
1701 return layer_tree_host_impl_
->animation_host()
1702 ? layer_tree_host_impl_
->animation_host()
1703 ->FilterAnimationBoundsForBox(layer
->id(), box
, bounds
)
1707 bool LayerTreeImpl::TransformAnimationBoundsForBox(const LayerImpl
* layer
,
1708 const gfx::BoxF
& box
,
1709 gfx::BoxF
* bounds
) const {
1710 *bounds
= gfx::BoxF();
1711 return layer_tree_host_impl_
->animation_host()
1712 ? layer_tree_host_impl_
->animation_host()
1713 ->TransformAnimationBoundsForBox(layer
->id(), box
, bounds
)