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_host_impl.h"
10 #include "base/basictypes.h"
11 #include "base/containers/hash_tables.h"
12 #include "base/debug/trace_event_argument.h"
13 #include "base/json/json_writer.h"
14 #include "base/metrics/histogram.h"
15 #include "base/stl_util.h"
16 #include "base/strings/stringprintf.h"
17 #include "cc/animation/animation_id_provider.h"
18 #include "cc/animation/scroll_offset_animation_curve.h"
19 #include "cc/animation/scrollbar_animation_controller.h"
20 #include "cc/animation/timing_function.h"
21 #include "cc/base/latency_info_swap_promise_monitor.h"
22 #include "cc/base/math_util.h"
23 #include "cc/base/util.h"
24 #include "cc/debug/benchmark_instrumentation.h"
25 #include "cc/debug/debug_rect_history.h"
26 #include "cc/debug/devtools_instrumentation.h"
27 #include "cc/debug/frame_rate_counter.h"
28 #include "cc/debug/paint_time_counter.h"
29 #include "cc/debug/rendering_stats_instrumentation.h"
30 #include "cc/debug/traced_value.h"
31 #include "cc/input/page_scale_animation.h"
32 #include "cc/input/top_controls_manager.h"
33 #include "cc/layers/append_quads_data.h"
34 #include "cc/layers/heads_up_display_layer_impl.h"
35 #include "cc/layers/layer_impl.h"
36 #include "cc/layers/layer_iterator.h"
37 #include "cc/layers/painted_scrollbar_layer_impl.h"
38 #include "cc/layers/render_surface_impl.h"
39 #include "cc/layers/scrollbar_layer_impl_base.h"
40 #include "cc/output/compositor_frame_metadata.h"
41 #include "cc/output/copy_output_request.h"
42 #include "cc/output/delegating_renderer.h"
43 #include "cc/output/gl_renderer.h"
44 #include "cc/output/software_renderer.h"
45 #include "cc/quads/render_pass_draw_quad.h"
46 #include "cc/quads/shared_quad_state.h"
47 #include "cc/quads/solid_color_draw_quad.h"
48 #include "cc/quads/texture_draw_quad.h"
49 #include "cc/resources/eviction_tile_priority_queue.h"
50 #include "cc/resources/gpu_raster_worker_pool.h"
51 #include "cc/resources/image_copy_raster_worker_pool.h"
52 #include "cc/resources/image_raster_worker_pool.h"
53 #include "cc/resources/memory_history.h"
54 #include "cc/resources/picture_layer_tiling.h"
55 #include "cc/resources/pixel_buffer_raster_worker_pool.h"
56 #include "cc/resources/prioritized_resource_manager.h"
57 #include "cc/resources/raster_tile_priority_queue.h"
58 #include "cc/resources/raster_worker_pool.h"
59 #include "cc/resources/resource_pool.h"
60 #include "cc/resources/texture_mailbox_deleter.h"
61 #include "cc/resources/ui_resource_bitmap.h"
62 #include "cc/scheduler/delay_based_time_source.h"
63 #include "cc/trees/damage_tracker.h"
64 #include "cc/trees/layer_tree_host.h"
65 #include "cc/trees/layer_tree_host_common.h"
66 #include "cc/trees/layer_tree_impl.h"
67 #include "cc/trees/occlusion_tracker.h"
68 #include "cc/trees/single_thread_proxy.h"
69 #include "cc/trees/tree_synchronizer.h"
70 #include "gpu/command_buffer/client/gles2_interface.h"
71 #include "gpu/GLES2/gl2extchromium.h"
72 #include "ui/gfx/frame_time.h"
73 #include "ui/gfx/geometry/rect_conversions.h"
74 #include "ui/gfx/size_conversions.h"
75 #include "ui/gfx/vector2d_conversions.h"
79 void DidVisibilityChange(cc::LayerTreeHostImpl
* id
, bool visible
) {
81 TRACE_EVENT_ASYNC_BEGIN1("webkit",
82 "LayerTreeHostImpl::SetVisible",
89 TRACE_EVENT_ASYNC_END0("webkit", "LayerTreeHostImpl::SetVisible", id
);
92 size_t GetMaxTransferBufferUsageBytes(cc::ContextProvider
* context_provider
,
93 double refresh_rate
) {
94 // Software compositing should not use this value in production. Just use a
95 // default value when testing uploads with the software compositor.
96 if (!context_provider
)
97 return std::numeric_limits
<size_t>::max();
99 // We want to make sure the default transfer buffer size is equal to the
100 // amount of data that can be uploaded by the compositor to avoid stalling
102 // For reference Chromebook Pixel can upload 1MB in about 0.5ms.
103 const size_t kMaxBytesUploadedPerMs
= 1024 * 1024 * 2;
105 // We need to upload at least enough work to keep the GPU process busy until
106 // the next time it can handle a request to start more uploads from the
107 // compositor. We assume that it will pick up any sent upload requests within
108 // the time of a vsync, since the browser will want to swap a frame within
109 // that time interval, and then uploads should have a chance to be processed.
110 size_t ms_per_frame
= std::floor(1000.0 / refresh_rate
);
111 size_t max_transfer_buffer_usage_bytes
=
112 ms_per_frame
* kMaxBytesUploadedPerMs
;
114 // The context may request a lower limit based on the device capabilities.
116 context_provider
->ContextCapabilities().max_transfer_buffer_usage_bytes
,
117 max_transfer_buffer_usage_bytes
);
120 unsigned GetMapImageTextureTarget(cc::ContextProvider
* context_provider
) {
121 if (!context_provider
)
122 return GL_TEXTURE_2D
;
124 if (context_provider
->ContextCapabilities().gpu
.egl_image_external
)
125 return GL_TEXTURE_EXTERNAL_OES
;
126 if (context_provider
->ContextCapabilities().gpu
.texture_rectangle
)
127 return GL_TEXTURE_RECTANGLE_ARB
;
129 return GL_TEXTURE_2D
;
136 class LayerTreeHostImplTimeSourceAdapter
: public TimeSourceClient
{
138 static scoped_ptr
<LayerTreeHostImplTimeSourceAdapter
> Create(
139 LayerTreeHostImpl
* layer_tree_host_impl
,
140 scoped_refptr
<DelayBasedTimeSource
> time_source
) {
141 return make_scoped_ptr(
142 new LayerTreeHostImplTimeSourceAdapter(layer_tree_host_impl
,
145 virtual ~LayerTreeHostImplTimeSourceAdapter() {
146 time_source_
->SetClient(NULL
);
147 time_source_
->SetActive(false);
150 virtual void OnTimerTick() OVERRIDE
{
151 // In single threaded mode we attempt to simulate changing the current
152 // thread by maintaining a fake thread id. When we switch from one
153 // thread to another, we construct DebugScopedSetXXXThread objects that
154 // update the thread id. This lets DCHECKS that ensure we're on the
155 // right thread to work correctly in single threaded mode. The problem
156 // here is that the timer tasks are run via the message loop, and when
157 // they run, we've had no chance to construct a DebugScopedSetXXXThread
158 // object. The result is that we report that we're running on the main
159 // thread. In multi-threaded mode, this timer is run on the compositor
160 // thread, so to keep this consistent in single-threaded mode, we'll
161 // construct a DebugScopedSetImplThread object. There is no need to do
162 // this in multi-threaded mode since the real thread id's will be
163 // correct. In fact, setting fake thread id's interferes with the real
164 // thread id's and causes breakage.
165 scoped_ptr
<DebugScopedSetImplThread
> set_impl_thread
;
166 if (!layer_tree_host_impl_
->proxy()->HasImplThread()) {
167 set_impl_thread
.reset(
168 new DebugScopedSetImplThread(layer_tree_host_impl_
->proxy()));
171 layer_tree_host_impl_
->Animate(
172 layer_tree_host_impl_
->CurrentBeginFrameArgs().frame_time
);
173 layer_tree_host_impl_
->UpdateBackgroundAnimateTicking(true);
174 bool start_ready_animations
= true;
175 layer_tree_host_impl_
->UpdateAnimationState(start_ready_animations
);
177 if (layer_tree_host_impl_
->pending_tree()) {
178 layer_tree_host_impl_
->pending_tree()->UpdateDrawProperties();
179 layer_tree_host_impl_
->ManageTiles();
182 layer_tree_host_impl_
->ResetCurrentBeginFrameArgsForNextFrame();
185 void SetActive(bool active
) {
186 if (active
!= time_source_
->Active())
187 time_source_
->SetActive(active
);
190 bool Active() const { return time_source_
->Active(); }
193 LayerTreeHostImplTimeSourceAdapter(
194 LayerTreeHostImpl
* layer_tree_host_impl
,
195 scoped_refptr
<DelayBasedTimeSource
> time_source
)
196 : layer_tree_host_impl_(layer_tree_host_impl
),
197 time_source_(time_source
) {
198 time_source_
->SetClient(this);
201 LayerTreeHostImpl
* layer_tree_host_impl_
;
202 scoped_refptr
<DelayBasedTimeSource
> time_source_
;
204 DISALLOW_COPY_AND_ASSIGN(LayerTreeHostImplTimeSourceAdapter
);
207 LayerTreeHostImpl::FrameData::FrameData()
208 : contains_incomplete_tile(false), has_no_damage(false) {}
210 LayerTreeHostImpl::FrameData::~FrameData() {}
212 scoped_ptr
<LayerTreeHostImpl
> LayerTreeHostImpl::Create(
213 const LayerTreeSettings
& settings
,
214 LayerTreeHostImplClient
* client
,
216 RenderingStatsInstrumentation
* rendering_stats_instrumentation
,
217 SharedBitmapManager
* manager
,
219 return make_scoped_ptr(new LayerTreeHostImpl(
220 settings
, client
, proxy
, rendering_stats_instrumentation
, manager
, id
));
223 LayerTreeHostImpl::LayerTreeHostImpl(
224 const LayerTreeSettings
& settings
,
225 LayerTreeHostImplClient
* client
,
227 RenderingStatsInstrumentation
* rendering_stats_instrumentation
,
228 SharedBitmapManager
* manager
,
232 use_gpu_rasterization_(false),
233 input_handler_client_(NULL
),
234 did_lock_scrolling_layer_(false),
235 should_bubble_scrolls_(false),
236 wheel_scrolling_(false),
237 scroll_affects_scroll_handler_(false),
238 scroll_layer_id_when_mouse_over_scrollbar_(0),
239 tile_priorities_dirty_(false),
240 root_layer_scroll_offset_delegate_(NULL
),
243 cached_managed_memory_policy_(
244 PrioritizedResourceManager::DefaultMemoryAllocationLimit(),
245 gpu::MemoryAllocation::CUTOFF_ALLOW_EVERYTHING
,
246 ManagedMemoryPolicy::kDefaultNumResourcesLimit
),
247 pinch_gesture_active_(false),
248 pinch_gesture_end_should_clear_scrolling_layer_(false),
249 fps_counter_(FrameRateCounter::Create(proxy_
->HasImplThread())),
250 paint_time_counter_(PaintTimeCounter::Create()),
251 memory_history_(MemoryHistory::Create()),
252 debug_rect_history_(DebugRectHistory::Create()),
253 texture_mailbox_deleter_(new TextureMailboxDeleter(
254 proxy_
->HasImplThread() ? proxy_
->ImplThreadTaskRunner()
255 : proxy_
->MainThreadTaskRunner())),
256 max_memory_needed_bytes_(0),
258 device_scale_factor_(1.f
),
259 overhang_ui_resource_id_(0),
260 resourceless_software_draw_(false),
261 begin_impl_frame_interval_(BeginFrameArgs::DefaultInterval()),
262 animation_registrar_(AnimationRegistrar::Create()),
263 rendering_stats_instrumentation_(rendering_stats_instrumentation
),
264 micro_benchmark_controller_(this),
265 need_to_update_visible_tiles_before_draw_(false),
266 shared_bitmap_manager_(manager
),
268 transfer_buffer_memory_limit_(0u) {
269 DCHECK(proxy_
->IsImplThread());
270 DidVisibilityChange(this, visible_
);
271 animation_registrar_
->set_supports_scroll_animations(
272 proxy_
->SupportsImplScrolling());
274 SetDebugState(settings
.initial_debug_state
);
276 if (settings
.calculate_top_controls_position
) {
277 top_controls_manager_
=
278 TopControlsManager::Create(this,
279 settings
.top_controls_height
,
280 settings
.top_controls_show_threshold
,
281 settings
.top_controls_hide_threshold
);
284 SetDebugState(settings
.initial_debug_state
);
286 // LTHI always has an active tree.
287 active_tree_
= LayerTreeImpl::create(this);
288 TRACE_EVENT_OBJECT_CREATED_WITH_ID(
289 TRACE_DISABLED_BY_DEFAULT("cc.debug"), "cc::LayerTreeHostImpl", id_
);
292 LayerTreeHostImpl::~LayerTreeHostImpl() {
293 DCHECK(proxy_
->IsImplThread());
294 TRACE_EVENT0("cc", "LayerTreeHostImpl::~LayerTreeHostImpl()");
295 TRACE_EVENT_OBJECT_DELETED_WITH_ID(
296 TRACE_DISABLED_BY_DEFAULT("cc.debug"), "cc::LayerTreeHostImpl", id_
);
298 if (input_handler_client_
) {
299 input_handler_client_
->WillShutdown();
300 input_handler_client_
= NULL
;
303 // The layer trees must be destroyed before the layer tree host. We've
304 // made a contract with our animation controllers that the registrar
305 // will outlive them, and we must make good.
307 recycle_tree_
->Shutdown();
309 pending_tree_
->Shutdown();
310 active_tree_
->Shutdown();
311 recycle_tree_
.reset();
312 pending_tree_
.reset();
313 active_tree_
.reset();
314 DestroyTileManager();
317 void LayerTreeHostImpl::BeginMainFrameAborted(bool did_handle
) {
318 // If the begin frame data was handled, then scroll and scale set was applied
319 // by the main thread, so the active tree needs to be updated as if these sent
320 // values were applied and committed.
322 active_tree_
->ApplySentScrollAndScaleDeltasFromAbortedCommit();
323 active_tree_
->ResetContentsTexturesPurged();
327 void LayerTreeHostImpl::BeginCommit() {
328 TRACE_EVENT0("cc", "LayerTreeHostImpl::BeginCommit");
330 if (UsePendingTreeForSync())
334 void LayerTreeHostImpl::CommitComplete() {
335 TRACE_EVENT0("cc", "LayerTreeHostImpl::CommitComplete");
338 pending_tree_
->ApplyScrollDeltasSinceBeginMainFrame();
339 sync_tree()->set_needs_update_draw_properties();
341 if (settings_
.impl_side_painting
) {
342 // Impl-side painting needs an update immediately post-commit to have the
343 // opportunity to create tilings. Other paths can call UpdateDrawProperties
344 // more lazily when needed prior to drawing.
345 sync_tree()->UpdateDrawProperties();
346 // Start working on newly created tiles immediately if needed.
347 if (tile_manager_
&& tile_priorities_dirty_
)
350 NotifyReadyToActivate();
352 // If we're not in impl-side painting, the tree is immediately considered
357 micro_benchmark_controller_
.DidCompleteCommit();
360 bool LayerTreeHostImpl::CanDraw() const {
361 // Note: If you are changing this function or any other function that might
362 // affect the result of CanDraw, make sure to call
363 // client_->OnCanDrawStateChanged in the proper places and update the
364 // NotifyIfCanDrawChanged test.
367 TRACE_EVENT_INSTANT0("cc", "LayerTreeHostImpl::CanDraw no renderer",
368 TRACE_EVENT_SCOPE_THREAD
);
372 // Must have an OutputSurface if |renderer_| is not NULL.
373 DCHECK(output_surface_
);
375 // TODO(boliu): Make draws without root_layer work and move this below
376 // draw_and_swap_full_viewport_every_frame check. Tracked in crbug.com/264967.
377 if (!active_tree_
->root_layer()) {
378 TRACE_EVENT_INSTANT0("cc", "LayerTreeHostImpl::CanDraw no root layer",
379 TRACE_EVENT_SCOPE_THREAD
);
383 if (output_surface_
->capabilities().draw_and_swap_full_viewport_every_frame
)
386 if (DrawViewportSize().IsEmpty()) {
387 TRACE_EVENT_INSTANT0("cc", "LayerTreeHostImpl::CanDraw empty viewport",
388 TRACE_EVENT_SCOPE_THREAD
);
391 if (active_tree_
->ViewportSizeInvalid()) {
392 TRACE_EVENT_INSTANT0(
393 "cc", "LayerTreeHostImpl::CanDraw viewport size recently changed",
394 TRACE_EVENT_SCOPE_THREAD
);
397 if (active_tree_
->ContentsTexturesPurged()) {
398 TRACE_EVENT_INSTANT0(
399 "cc", "LayerTreeHostImpl::CanDraw contents textures purged",
400 TRACE_EVENT_SCOPE_THREAD
);
403 if (EvictedUIResourcesExist()) {
404 TRACE_EVENT_INSTANT0(
405 "cc", "LayerTreeHostImpl::CanDraw UI resources evicted not recreated",
406 TRACE_EVENT_SCOPE_THREAD
);
412 void LayerTreeHostImpl::Animate(base::TimeTicks monotonic_time
) {
413 if (input_handler_client_
)
414 input_handler_client_
->Animate(monotonic_time
);
415 AnimatePageScale(monotonic_time
);
416 AnimateLayers(monotonic_time
);
417 AnimateScrollbars(monotonic_time
);
418 AnimateTopControls(monotonic_time
);
421 void LayerTreeHostImpl::ManageTiles() {
424 if (!tile_priorities_dirty_
)
427 tile_priorities_dirty_
= false;
428 tile_manager_
->ManageTiles(global_tile_state_
);
430 client_
->DidManageTiles();
433 void LayerTreeHostImpl::StartPageScaleAnimation(
434 const gfx::Vector2d
& target_offset
,
437 base::TimeDelta duration
) {
438 if (!InnerViewportScrollLayer())
441 gfx::Vector2dF scroll_total
= active_tree_
->TotalScrollOffset();
442 gfx::SizeF scaled_scrollable_size
= active_tree_
->ScrollableSize();
443 gfx::SizeF viewport_size
=
444 active_tree_
->InnerViewportContainerLayer()->bounds();
446 // Easing constants experimentally determined.
447 scoped_ptr
<TimingFunction
> timing_function
=
448 CubicBezierTimingFunction::Create(.8, 0, .3, .9).PassAs
<TimingFunction
>();
450 page_scale_animation_
=
451 PageScaleAnimation::Create(scroll_total
,
452 active_tree_
->total_page_scale_factor(),
454 scaled_scrollable_size
,
455 timing_function
.Pass());
458 gfx::Vector2dF
anchor(target_offset
);
459 page_scale_animation_
->ZoomWithAnchor(anchor
,
461 duration
.InSecondsF());
463 gfx::Vector2dF scaled_target_offset
= target_offset
;
464 page_scale_animation_
->ZoomTo(scaled_target_offset
,
466 duration
.InSecondsF());
470 client_
->SetNeedsCommitOnImplThread();
471 client_
->RenewTreePriority();
474 bool LayerTreeHostImpl::IsCurrentlyScrollingLayerAt(
475 const gfx::Point
& viewport_point
,
476 InputHandler::ScrollInputType type
) {
477 if (!CurrentlyScrollingLayer())
480 gfx::PointF device_viewport_point
=
481 gfx::ScalePoint(viewport_point
, device_scale_factor_
);
483 LayerImpl
* layer_impl
=
484 active_tree_
->FindLayerThatIsHitByPoint(device_viewport_point
);
486 bool scroll_on_main_thread
= false;
487 LayerImpl
* scrolling_layer_impl
= FindScrollLayerForDeviceViewportPoint(
488 device_viewport_point
, type
, layer_impl
, &scroll_on_main_thread
, NULL
);
489 return CurrentlyScrollingLayer() == scrolling_layer_impl
;
492 bool LayerTreeHostImpl::HaveTouchEventHandlersAt(
493 const gfx::Point
& viewport_point
) {
495 gfx::PointF device_viewport_point
=
496 gfx::ScalePoint(viewport_point
, device_scale_factor_
);
498 LayerImpl
* layer_impl
=
499 active_tree_
->FindLayerThatIsHitByPointInTouchHandlerRegion(
500 device_viewport_point
);
502 return layer_impl
!= NULL
;
505 scoped_ptr
<SwapPromiseMonitor
>
506 LayerTreeHostImpl::CreateLatencyInfoSwapPromiseMonitor(
507 ui::LatencyInfo
* latency
) {
508 return scoped_ptr
<SwapPromiseMonitor
>(
509 new LatencyInfoSwapPromiseMonitor(latency
, NULL
, this));
512 void LayerTreeHostImpl::QueueSwapPromiseForMainThreadScrollUpdate(
513 scoped_ptr
<SwapPromise
> swap_promise
) {
514 swap_promises_for_main_thread_scroll_update_
.push_back(swap_promise
.Pass());
517 void LayerTreeHostImpl::TrackDamageForAllSurfaces(
518 LayerImpl
* root_draw_layer
,
519 const LayerImplList
& render_surface_layer_list
) {
520 // For now, we use damage tracking to compute a global scissor. To do this, we
521 // must compute all damage tracking before drawing anything, so that we know
522 // the root damage rect. The root damage rect is then used to scissor each
525 for (int surface_index
= render_surface_layer_list
.size() - 1;
528 LayerImpl
* render_surface_layer
= render_surface_layer_list
[surface_index
];
529 RenderSurfaceImpl
* render_surface
= render_surface_layer
->render_surface();
530 DCHECK(render_surface
);
531 render_surface
->damage_tracker()->UpdateDamageTrackingState(
532 render_surface
->layer_list(),
533 render_surface_layer
->id(),
534 render_surface
->SurfacePropertyChangedOnlyFromDescendant(),
535 render_surface
->content_rect(),
536 render_surface_layer
->mask_layer(),
537 render_surface_layer
->filters());
541 void LayerTreeHostImpl::FrameData::AsValueInto(
542 base::debug::TracedValue
* value
) const {
543 value
->SetBoolean("contains_incomplete_tile", contains_incomplete_tile
);
544 value
->SetBoolean("has_no_damage", has_no_damage
);
546 // Quad data can be quite large, so only dump render passes if we select
549 TRACE_EVENT_CATEGORY_GROUP_ENABLED(
550 TRACE_DISABLED_BY_DEFAULT("cc.debug.quads"), &quads_enabled
);
552 value
->BeginArray("render_passes");
553 for (size_t i
= 0; i
< render_passes
.size(); ++i
) {
554 value
->BeginDictionary();
555 render_passes
[i
]->AsValueInto(value
);
556 value
->EndDictionary();
562 void LayerTreeHostImpl::FrameData::AppendRenderPass(
563 scoped_ptr
<RenderPass
> render_pass
) {
564 render_passes_by_id
[render_pass
->id
] = render_pass
.get();
565 render_passes
.push_back(render_pass
.Pass());
568 DrawMode
LayerTreeHostImpl::GetDrawMode() const {
569 if (resourceless_software_draw_
) {
570 return DRAW_MODE_RESOURCELESS_SOFTWARE
;
571 } else if (output_surface_
->context_provider()) {
572 return DRAW_MODE_HARDWARE
;
574 DCHECK_EQ(!output_surface_
->software_device(),
575 output_surface_
->capabilities().delegated_rendering
&&
576 !output_surface_
->capabilities().deferred_gl_initialization
)
577 << output_surface_
->capabilities().delegated_rendering
<< " "
578 << output_surface_
->capabilities().deferred_gl_initialization
;
579 return DRAW_MODE_SOFTWARE
;
583 static void AppendQuadsForLayer(
584 RenderPass
* target_render_pass
,
586 const OcclusionTracker
<LayerImpl
>& occlusion_tracker
,
587 AppendQuadsData
* append_quads_data
) {
588 layer
->AppendQuads(target_render_pass
, occlusion_tracker
, append_quads_data
);
591 static void AppendQuadsForRenderSurfaceLayer(
592 RenderPass
* target_render_pass
,
594 const RenderPass
* contributing_render_pass
,
595 const OcclusionTracker
<LayerImpl
>& occlusion_tracker
,
596 AppendQuadsData
* append_quads_data
) {
597 bool is_replica
= false;
598 layer
->render_surface()->AppendQuads(target_render_pass
,
602 contributing_render_pass
->id
);
604 // Add replica after the surface so that it appears below the surface.
605 if (layer
->has_replica()) {
607 layer
->render_surface()->AppendQuads(target_render_pass
,
611 contributing_render_pass
->id
);
615 static void AppendQuadsToFillScreen(
616 ResourceProvider::ResourceId overhang_resource_id
,
617 const gfx::SizeF
& overhang_resource_scaled_size
,
618 const gfx::Rect
& root_scroll_layer_rect
,
619 RenderPass
* target_render_pass
,
620 LayerImpl
* root_layer
,
621 SkColor screen_background_color
,
622 const OcclusionTracker
<LayerImpl
>& occlusion_tracker
) {
623 if (!root_layer
|| !SkColorGetA(screen_background_color
))
626 Region fill_region
= occlusion_tracker
.ComputeVisibleRegionInScreen();
627 if (fill_region
.IsEmpty())
630 // Divide the fill region into the part to be filled with the overhang
631 // resource and the part to be filled with the background color.
632 Region screen_background_color_region
= fill_region
;
633 Region overhang_region
;
634 if (overhang_resource_id
) {
635 overhang_region
= fill_region
;
636 overhang_region
.Subtract(root_scroll_layer_rect
);
637 screen_background_color_region
.Intersect(root_scroll_layer_rect
);
640 // Manually create the quad state for the gutter quads, as the root layer
641 // doesn't have any bounds and so can't generate this itself.
642 // TODO(danakj): Make the gutter quads generated by the solid color layer
643 // (make it smarter about generating quads to fill unoccluded areas).
645 gfx::Rect root_target_rect
= root_layer
->render_surface()->content_rect();
647 int sorting_context_id
= 0;
648 SharedQuadState
* shared_quad_state
=
649 target_render_pass
->CreateAndAppendSharedQuadState();
650 shared_quad_state
->SetAll(gfx::Transform(),
651 root_target_rect
.size(),
656 SkXfermode::kSrcOver_Mode
,
659 for (Region::Iterator
fill_rects(screen_background_color_region
);
660 fill_rects
.has_rect();
662 gfx::Rect screen_space_rect
= fill_rects
.rect();
663 gfx::Rect visible_screen_space_rect
= screen_space_rect
;
664 // Skip the quad culler and just append the quads directly to avoid
666 SolidColorDrawQuad
* quad
=
667 target_render_pass
->CreateAndAppendDrawQuad
<SolidColorDrawQuad
>();
668 quad
->SetNew(shared_quad_state
,
670 visible_screen_space_rect
,
671 screen_background_color
,
674 for (Region::Iterator
fill_rects(overhang_region
);
675 fill_rects
.has_rect();
677 DCHECK(overhang_resource_id
);
678 gfx::Rect screen_space_rect
= fill_rects
.rect();
679 gfx::Rect opaque_screen_space_rect
= screen_space_rect
;
680 gfx::Rect visible_screen_space_rect
= screen_space_rect
;
681 TextureDrawQuad
* tex_quad
=
682 target_render_pass
->CreateAndAppendDrawQuad
<TextureDrawQuad
>();
683 const float vertex_opacity
[4] = {1.f
, 1.f
, 1.f
, 1.f
};
687 opaque_screen_space_rect
,
688 visible_screen_space_rect
,
689 overhang_resource_id
,
692 screen_space_rect
.x() / overhang_resource_scaled_size
.width(),
693 screen_space_rect
.y() / overhang_resource_scaled_size
.height()),
695 screen_space_rect
.right() / overhang_resource_scaled_size
.width(),
696 screen_space_rect
.bottom() /
697 overhang_resource_scaled_size
.height()),
698 screen_background_color
,
704 DrawResult
LayerTreeHostImpl::CalculateRenderPasses(
706 DCHECK(frame
->render_passes
.empty());
708 DCHECK(active_tree_
->root_layer());
710 TrackDamageForAllSurfaces(active_tree_
->root_layer(),
711 *frame
->render_surface_layer_list
);
713 // If the root render surface has no visible damage, then don't generate a
715 RenderSurfaceImpl
* root_surface
=
716 active_tree_
->root_layer()->render_surface();
717 bool root_surface_has_no_visible_damage
=
718 !root_surface
->damage_tracker()->current_damage_rect().Intersects(
719 root_surface
->content_rect());
720 bool root_surface_has_contributing_layers
=
721 !root_surface
->layer_list().empty();
722 bool hud_wants_to_draw_
= active_tree_
->hud_layer() &&
723 active_tree_
->hud_layer()->IsAnimatingHUDContents();
724 if (root_surface_has_contributing_layers
&&
725 root_surface_has_no_visible_damage
&&
726 active_tree_
->LayersWithCopyOutputRequest().empty() &&
727 !hud_wants_to_draw_
) {
729 "LayerTreeHostImpl::CalculateRenderPasses::EmptyDamageRect");
730 frame
->has_no_damage
= true;
731 DCHECK(!output_surface_
->capabilities()
732 .draw_and_swap_full_viewport_every_frame
);
737 "LayerTreeHostImpl::CalculateRenderPasses",
738 "render_surface_layer_list.size()",
739 static_cast<uint64
>(frame
->render_surface_layer_list
->size()));
741 // Create the render passes in dependency order.
742 for (int surface_index
= frame
->render_surface_layer_list
->size() - 1;
745 LayerImpl
* render_surface_layer
=
746 (*frame
->render_surface_layer_list
)[surface_index
];
747 RenderSurfaceImpl
* render_surface
= render_surface_layer
->render_surface();
749 bool should_draw_into_render_pass
=
750 render_surface_layer
->parent() == NULL
||
751 render_surface
->contributes_to_drawn_surface() ||
752 render_surface_layer
->HasCopyRequest();
753 if (should_draw_into_render_pass
)
754 render_surface_layer
->render_surface()->AppendRenderPasses(frame
);
757 // When we are displaying the HUD, change the root damage rect to cover the
758 // entire root surface. This will disable partial-swap/scissor optimizations
759 // that would prevent the HUD from updating, since the HUD does not cause
760 // damage itself, to prevent it from messing with damage visualizations. Since
761 // damage visualizations are done off the LayerImpls and RenderSurfaceImpls,
762 // changing the RenderPass does not affect them.
763 if (active_tree_
->hud_layer()) {
764 RenderPass
* root_pass
= frame
->render_passes
.back();
765 root_pass
->damage_rect
= root_pass
->output_rect
;
768 OcclusionTracker
<LayerImpl
> occlusion_tracker(
769 active_tree_
->root_layer()->render_surface()->content_rect());
770 occlusion_tracker
.set_minimum_tracking_size(
771 settings_
.minimum_occlusion_tracking_size
);
773 if (debug_state_
.show_occluding_rects
) {
774 occlusion_tracker
.set_occluding_screen_space_rects_container(
775 &frame
->occluding_screen_space_rects
);
777 if (debug_state_
.show_non_occluding_rects
) {
778 occlusion_tracker
.set_non_occluding_screen_space_rects_container(
779 &frame
->non_occluding_screen_space_rects
);
782 // Add quads to the Render passes in front-to-back order to allow for testing
783 // occlusion and performing culling during the tree walk.
784 typedef LayerIterator
<LayerImpl
> LayerIteratorType
;
786 // Typically when we are missing a texture and use a checkerboard quad, we
787 // still draw the frame. However when the layer being checkerboarded is moving
788 // due to an impl-animation, we drop the frame to avoid flashing due to the
789 // texture suddenly appearing in the future.
790 DrawResult draw_result
= DRAW_SUCCESS
;
791 // When we have a copy request for a layer, we need to draw no matter
792 // what, as the layer may disappear after this frame.
793 bool have_copy_request
= false;
795 int layers_drawn
= 0;
797 const DrawMode draw_mode
= GetDrawMode();
799 int num_missing_tiles
= 0;
800 int num_incomplete_tiles
= 0;
802 LayerIteratorType end
=
803 LayerIteratorType::End(frame
->render_surface_layer_list
);
804 for (LayerIteratorType it
=
805 LayerIteratorType::Begin(frame
->render_surface_layer_list
);
808 RenderPassId target_render_pass_id
=
809 it
.target_render_surface_layer()->render_surface()->GetRenderPassId();
810 RenderPass
* target_render_pass
=
811 frame
->render_passes_by_id
[target_render_pass_id
];
813 occlusion_tracker
.EnterLayer(it
);
815 AppendQuadsData
append_quads_data(target_render_pass_id
);
817 if (it
.represents_target_render_surface()) {
818 if (it
->HasCopyRequest()) {
819 have_copy_request
= true;
820 it
->TakeCopyRequestsAndTransformToTarget(
821 &target_render_pass
->copy_requests
);
823 } else if (it
.represents_contributing_render_surface() &&
824 it
->render_surface()->contributes_to_drawn_surface()) {
825 RenderPassId contributing_render_pass_id
=
826 it
->render_surface()->GetRenderPassId();
827 RenderPass
* contributing_render_pass
=
828 frame
->render_passes_by_id
[contributing_render_pass_id
];
829 AppendQuadsForRenderSurfaceLayer(target_render_pass
,
831 contributing_render_pass
,
834 } else if (it
.represents_itself() &&
835 !it
->visible_content_rect().IsEmpty()) {
836 bool occluded
= occlusion_tracker
.Occluded(it
->render_target(),
837 it
->visible_content_rect(),
838 it
->draw_transform());
839 if (!occluded
&& it
->WillDraw(draw_mode
, resource_provider_
.get())) {
840 DCHECK_EQ(active_tree_
, it
->layer_tree_impl());
842 frame
->will_draw_layers
.push_back(*it
);
844 if (it
->HasContributingDelegatedRenderPasses()) {
845 RenderPassId contributing_render_pass_id
=
846 it
->FirstContributingRenderPassId();
847 while (frame
->render_passes_by_id
.find(contributing_render_pass_id
) !=
848 frame
->render_passes_by_id
.end()) {
849 RenderPass
* render_pass
=
850 frame
->render_passes_by_id
[contributing_render_pass_id
];
852 AppendQuadsData
append_quads_data(render_pass
->id
);
853 AppendQuadsForLayer(render_pass
,
858 contributing_render_pass_id
=
859 it
->NextContributingRenderPassId(contributing_render_pass_id
);
863 AppendQuadsForLayer(target_render_pass
,
872 rendering_stats_instrumentation_
->AddVisibleContentArea(
873 append_quads_data
.visible_content_area
);
874 rendering_stats_instrumentation_
->AddApproximatedVisibleContentArea(
875 append_quads_data
.approximated_visible_content_area
);
877 num_missing_tiles
+= append_quads_data
.num_missing_tiles
;
878 num_incomplete_tiles
+= append_quads_data
.num_incomplete_tiles
;
880 if (append_quads_data
.num_missing_tiles
) {
881 bool layer_has_animating_transform
=
882 it
->screen_space_transform_is_animating() ||
883 it
->draw_transform_is_animating();
884 if (layer_has_animating_transform
)
885 draw_result
= DRAW_ABORTED_CHECKERBOARD_ANIMATIONS
;
888 if (append_quads_data
.num_incomplete_tiles
||
889 append_quads_data
.num_missing_tiles
) {
890 frame
->contains_incomplete_tile
= true;
891 if (active_tree()->RequiresHighResToDraw())
892 draw_result
= DRAW_ABORTED_MISSING_HIGH_RES_CONTENT
;
895 occlusion_tracker
.LeaveLayer(it
);
898 if (have_copy_request
||
899 output_surface_
->capabilities().draw_and_swap_full_viewport_every_frame
)
900 draw_result
= DRAW_SUCCESS
;
903 for (size_t i
= 0; i
< frame
->render_passes
.size(); ++i
) {
904 for (size_t j
= 0; j
< frame
->render_passes
[i
]->quad_list
.size(); ++j
)
905 DCHECK(frame
->render_passes
[i
]->quad_list
[j
]->shared_quad_state
);
906 DCHECK(frame
->render_passes_by_id
.find(frame
->render_passes
[i
]->id
)
907 != frame
->render_passes_by_id
.end());
910 DCHECK(frame
->render_passes
.back()->output_rect
.origin().IsOrigin());
912 if (!active_tree_
->has_transparent_background()) {
913 frame
->render_passes
.back()->has_transparent_background
= false;
914 AppendQuadsToFillScreen(
915 ResourceIdForUIResource(overhang_ui_resource_id_
),
916 gfx::ScaleSize(overhang_ui_resource_size_
, device_scale_factor_
),
917 active_tree_
->RootScrollLayerDeviceViewportBounds(),
918 frame
->render_passes
.back(),
919 active_tree_
->root_layer(),
920 active_tree_
->background_color(),
924 RemoveRenderPasses(CullRenderPassesWithNoQuads(), frame
);
925 renderer_
->DecideRenderPassAllocationsForFrame(frame
->render_passes
);
927 // Any copy requests left in the tree are not going to get serviced, and
928 // should be aborted.
929 ScopedPtrVector
<CopyOutputRequest
> requests_to_abort
;
930 while (!active_tree_
->LayersWithCopyOutputRequest().empty()) {
931 LayerImpl
* layer
= active_tree_
->LayersWithCopyOutputRequest().back();
932 layer
->TakeCopyRequestsAndTransformToTarget(&requests_to_abort
);
934 for (size_t i
= 0; i
< requests_to_abort
.size(); ++i
)
935 requests_to_abort
[i
]->SendEmptyResult();
937 // If we're making a frame to draw, it better have at least one render pass.
938 DCHECK(!frame
->render_passes
.empty());
940 if (active_tree_
->has_ever_been_drawn()) {
941 UMA_HISTOGRAM_COUNTS_100(
942 "Compositing.RenderPass.AppendQuadData.NumMissingTiles",
944 UMA_HISTOGRAM_COUNTS_100(
945 "Compositing.RenderPass.AppendQuadData.NumIncompleteTiles",
946 num_incomplete_tiles
);
949 // Should only have one render pass in resourceless software mode.
950 DCHECK(draw_mode
!= DRAW_MODE_RESOURCELESS_SOFTWARE
||
951 frame
->render_passes
.size() == 1u)
952 << frame
->render_passes
.size();
957 void LayerTreeHostImpl::MainThreadHasStoppedFlinging() {
958 if (input_handler_client_
)
959 input_handler_client_
->MainThreadHasStoppedFlinging();
962 void LayerTreeHostImpl::UpdateBackgroundAnimateTicking(
963 bool should_background_tick
) {
964 DCHECK(proxy_
->IsImplThread());
965 if (should_background_tick
)
966 DCHECK(active_tree_
->root_layer());
968 bool enabled
= should_background_tick
&& needs_animate_layers();
970 // Lazily create the time_source adapter so that we can vary the interval for
972 if (!time_source_client_adapter_
) {
973 time_source_client_adapter_
= LayerTreeHostImplTimeSourceAdapter::Create(
975 DelayBasedTimeSource::Create(
976 LowFrequencyAnimationInterval(),
977 proxy_
->HasImplThread() ? proxy_
->ImplThreadTaskRunner()
978 : proxy_
->MainThreadTaskRunner()));
981 time_source_client_adapter_
->SetActive(enabled
);
984 void LayerTreeHostImpl::DidAnimateScrollOffset() {
985 client_
->SetNeedsCommitOnImplThread();
986 client_
->RenewTreePriority();
989 void LayerTreeHostImpl::SetViewportDamage(const gfx::Rect
& damage_rect
) {
990 viewport_damage_rect_
.Union(damage_rect
);
993 static inline RenderPass
* FindRenderPassById(
994 RenderPassId render_pass_id
,
995 const LayerTreeHostImpl::FrameData
& frame
) {
996 RenderPassIdHashMap::const_iterator it
=
997 frame
.render_passes_by_id
.find(render_pass_id
);
998 return it
!= frame
.render_passes_by_id
.end() ? it
->second
: NULL
;
1001 static void RemoveRenderPassesRecursive(RenderPassId remove_render_pass_id
,
1002 LayerTreeHostImpl::FrameData
* frame
) {
1003 RenderPass
* remove_render_pass
=
1004 FindRenderPassById(remove_render_pass_id
, *frame
);
1005 // The pass was already removed by another quad - probably the original, and
1006 // we are the replica.
1007 if (!remove_render_pass
)
1009 RenderPassList
& render_passes
= frame
->render_passes
;
1010 RenderPassList::iterator to_remove
= std::find(render_passes
.begin(),
1011 render_passes
.end(),
1012 remove_render_pass
);
1014 DCHECK(to_remove
!= render_passes
.end());
1016 scoped_ptr
<RenderPass
> removed_pass
= render_passes
.take(to_remove
);
1017 frame
->render_passes
.erase(to_remove
);
1018 frame
->render_passes_by_id
.erase(remove_render_pass_id
);
1020 // Now follow up for all RenderPass quads and remove their RenderPasses
1022 const QuadList
& quad_list
= removed_pass
->quad_list
;
1023 QuadList::ConstBackToFrontIterator quad_list_iterator
=
1024 quad_list
.BackToFrontBegin();
1025 for (; quad_list_iterator
!= quad_list
.BackToFrontEnd();
1026 ++quad_list_iterator
) {
1027 DrawQuad
* current_quad
= (*quad_list_iterator
);
1028 if (current_quad
->material
!= DrawQuad::RENDER_PASS
)
1031 RenderPassId next_remove_render_pass_id
=
1032 RenderPassDrawQuad::MaterialCast(current_quad
)->render_pass_id
;
1033 RemoveRenderPassesRecursive(next_remove_render_pass_id
, frame
);
1037 bool LayerTreeHostImpl::CullRenderPassesWithNoQuads::ShouldRemoveRenderPass(
1038 const RenderPassDrawQuad
& quad
, const FrameData
& frame
) const {
1039 const RenderPass
* render_pass
=
1040 FindRenderPassById(quad
.render_pass_id
, frame
);
1044 // If any quad or RenderPass draws into this RenderPass, then keep it.
1045 const QuadList
& quad_list
= render_pass
->quad_list
;
1046 for (QuadList::ConstBackToFrontIterator quad_list_iterator
=
1047 quad_list
.BackToFrontBegin();
1048 quad_list_iterator
!= quad_list
.BackToFrontEnd();
1049 ++quad_list_iterator
) {
1050 DrawQuad
* current_quad
= *quad_list_iterator
;
1052 if (current_quad
->material
!= DrawQuad::RENDER_PASS
)
1055 const RenderPass
* contributing_pass
= FindRenderPassById(
1056 RenderPassDrawQuad::MaterialCast(current_quad
)->render_pass_id
, frame
);
1057 if (contributing_pass
)
1063 // Defined for linking tests.
1064 template CC_EXPORT
void LayerTreeHostImpl::RemoveRenderPasses
<
1065 LayerTreeHostImpl::CullRenderPassesWithNoQuads
>(
1066 CullRenderPassesWithNoQuads culler
, FrameData
*);
1069 template <typename RenderPassCuller
>
1070 void LayerTreeHostImpl::RemoveRenderPasses(RenderPassCuller culler
,
1072 for (size_t it
= culler
.RenderPassListBegin(frame
->render_passes
);
1073 it
!= culler
.RenderPassListEnd(frame
->render_passes
);
1074 it
= culler
.RenderPassListNext(it
)) {
1075 const RenderPass
* current_pass
= frame
->render_passes
[it
];
1076 const QuadList
& quad_list
= current_pass
->quad_list
;
1077 QuadList::ConstBackToFrontIterator quad_list_iterator
=
1078 quad_list
.BackToFrontBegin();
1080 for (; quad_list_iterator
!= quad_list
.BackToFrontEnd();
1081 ++quad_list_iterator
) {
1082 DrawQuad
* current_quad
= *quad_list_iterator
;
1084 if (current_quad
->material
!= DrawQuad::RENDER_PASS
)
1087 const RenderPassDrawQuad
* render_pass_quad
=
1088 RenderPassDrawQuad::MaterialCast(current_quad
);
1089 if (!culler
.ShouldRemoveRenderPass(*render_pass_quad
, *frame
))
1092 // We are changing the vector in the middle of iteration. Because we
1093 // delete render passes that draw into the current pass, we are
1094 // guaranteed that any data from the iterator to the end will not
1095 // change. So, capture the iterator position from the end of the
1096 // list, and restore it after the change.
1097 size_t position_from_end
= frame
->render_passes
.size() - it
;
1098 RemoveRenderPassesRecursive(render_pass_quad
->render_pass_id
, frame
);
1099 it
= frame
->render_passes
.size() - position_from_end
;
1100 DCHECK_GE(frame
->render_passes
.size(), position_from_end
);
1105 DrawResult
LayerTreeHostImpl::PrepareToDraw(FrameData
* frame
) {
1107 "LayerTreeHostImpl::PrepareToDraw",
1108 "SourceFrameNumber",
1109 active_tree_
->source_frame_number());
1111 if (need_to_update_visible_tiles_before_draw_
&&
1112 tile_manager_
&& tile_manager_
->UpdateVisibleTiles()) {
1113 DidInitializeVisibleTile();
1115 need_to_update_visible_tiles_before_draw_
= true;
1117 UMA_HISTOGRAM_CUSTOM_COUNTS(
1118 "Compositing.NumActiveLayers", active_tree_
->NumLayers(), 1, 400, 20);
1120 bool ok
= active_tree_
->UpdateDrawProperties();
1121 DCHECK(ok
) << "UpdateDrawProperties failed during draw";
1123 frame
->render_surface_layer_list
= &active_tree_
->RenderSurfaceLayerList();
1124 frame
->render_passes
.clear();
1125 frame
->render_passes_by_id
.clear();
1126 frame
->will_draw_layers
.clear();
1127 frame
->contains_incomplete_tile
= false;
1128 frame
->has_no_damage
= false;
1130 if (active_tree_
->root_layer()) {
1131 gfx::Rect device_viewport_damage_rect
= viewport_damage_rect_
;
1132 viewport_damage_rect_
= gfx::Rect();
1134 active_tree_
->root_layer()->render_surface()->damage_tracker()->
1135 AddDamageNextUpdate(device_viewport_damage_rect
);
1138 DrawResult draw_result
= CalculateRenderPasses(frame
);
1139 if (draw_result
!= DRAW_SUCCESS
) {
1140 DCHECK(!output_surface_
->capabilities()
1141 .draw_and_swap_full_viewport_every_frame
);
1145 // If we return DRAW_SUCCESS, then we expect DrawLayers() to be called before
1146 // this function is called again.
1150 void LayerTreeHostImpl::EvictTexturesForTesting() {
1151 EnforceManagedMemoryPolicy(ManagedMemoryPolicy(0));
1154 void LayerTreeHostImpl::BlockNotifyReadyToActivateForTesting(bool block
) {
1158 void LayerTreeHostImpl::DidInitializeVisibleTileForTesting() {
1159 // Add arbitrary damage, to trigger prepare-to-draws.
1160 // Here, setting damage as viewport size, used only for testing.
1161 SetFullRootLayerDamage();
1162 DidInitializeVisibleTile();
1165 void LayerTreeHostImpl::ResetTreesForTesting() {
1167 active_tree_
->DetachLayerTree();
1168 active_tree_
= LayerTreeImpl::create(this);
1170 pending_tree_
->DetachLayerTree();
1171 pending_tree_
.reset();
1173 recycle_tree_
->DetachLayerTree();
1174 recycle_tree_
.reset();
1177 void LayerTreeHostImpl::ResetRecycleTreeForTesting() {
1179 recycle_tree_
->DetachLayerTree();
1180 recycle_tree_
.reset();
1183 void LayerTreeHostImpl::EnforceManagedMemoryPolicy(
1184 const ManagedMemoryPolicy
& policy
) {
1186 bool evicted_resources
= client_
->ReduceContentsTextureMemoryOnImplThread(
1187 visible_
? policy
.bytes_limit_when_visible
: 0,
1188 ManagedMemoryPolicy::PriorityCutoffToValue(
1189 visible_
? policy
.priority_cutoff_when_visible
1190 : gpu::MemoryAllocation::CUTOFF_ALLOW_NOTHING
));
1191 if (evicted_resources
) {
1192 active_tree_
->SetContentsTexturesPurged();
1194 pending_tree_
->SetContentsTexturesPurged();
1195 client_
->SetNeedsCommitOnImplThread();
1196 client_
->OnCanDrawStateChanged(CanDraw());
1197 client_
->RenewTreePriority();
1200 UpdateTileManagerMemoryPolicy(policy
);
1203 void LayerTreeHostImpl::UpdateTileManagerMemoryPolicy(
1204 const ManagedMemoryPolicy
& policy
) {
1208 global_tile_state_
.hard_memory_limit_in_bytes
= 0;
1209 global_tile_state_
.soft_memory_limit_in_bytes
= 0;
1210 if (visible_
&& policy
.bytes_limit_when_visible
> 0) {
1211 global_tile_state_
.hard_memory_limit_in_bytes
=
1212 policy
.bytes_limit_when_visible
;
1213 global_tile_state_
.soft_memory_limit_in_bytes
=
1214 (static_cast<int64
>(global_tile_state_
.hard_memory_limit_in_bytes
) *
1215 settings_
.max_memory_for_prepaint_percentage
) /
1218 global_tile_state_
.memory_limit_policy
=
1219 ManagedMemoryPolicy::PriorityCutoffToTileMemoryLimitPolicy(
1221 policy
.priority_cutoff_when_visible
:
1222 gpu::MemoryAllocation::CUTOFF_ALLOW_NOTHING
);
1223 global_tile_state_
.num_resources_limit
= policy
.num_resources_limit
;
1225 // TODO(reveman): We should avoid keeping around unused resources if
1226 // possible. crbug.com/224475
1227 // Unused limit is calculated from soft-limit, as hard-limit may
1228 // be very high and shouldn't typically be exceeded.
1229 size_t unused_memory_limit_in_bytes
= static_cast<size_t>(
1230 (static_cast<int64
>(global_tile_state_
.soft_memory_limit_in_bytes
) *
1231 settings_
.max_unused_resource_memory_percentage
) /
1234 DCHECK(resource_pool_
);
1235 resource_pool_
->CheckBusyResources();
1236 // Soft limit is used for resource pool such that memory returns to soft
1237 // limit after going over.
1238 resource_pool_
->SetResourceUsageLimits(
1239 global_tile_state_
.soft_memory_limit_in_bytes
,
1240 unused_memory_limit_in_bytes
,
1241 global_tile_state_
.num_resources_limit
);
1243 // Staging pool resources are used as transfer buffers so we use
1244 // |transfer_buffer_memory_limit_| as the memory limit for this resource pool.
1245 if (staging_resource_pool_
) {
1246 staging_resource_pool_
->CheckBusyResources();
1247 staging_resource_pool_
->SetResourceUsageLimits(
1248 visible_
? transfer_buffer_memory_limit_
: 0,
1249 transfer_buffer_memory_limit_
,
1250 std::numeric_limits
<size_t>::max());
1253 DidModifyTilePriorities();
1256 void LayerTreeHostImpl::DidModifyTilePriorities() {
1257 DCHECK(settings_
.impl_side_painting
);
1258 // Mark priorities as dirty and schedule a ManageTiles().
1259 tile_priorities_dirty_
= true;
1260 client_
->SetNeedsManageTilesOnImplThread();
1263 void LayerTreeHostImpl::DidInitializeVisibleTile() {
1264 if (client_
&& !client_
->IsInsideDraw())
1265 client_
->DidInitializeVisibleTileOnImplThread();
1268 void LayerTreeHostImpl::GetPictureLayerImplPairs(
1269 std::vector
<PictureLayerImpl::Pair
>* layer_pairs
) const {
1270 DCHECK(layer_pairs
->empty());
1271 for (std::vector
<PictureLayerImpl
*>::const_iterator it
=
1272 picture_layers_
.begin();
1273 it
!= picture_layers_
.end();
1275 PictureLayerImpl
* layer
= *it
;
1277 // TODO(vmpstr): Iterators and should handle this instead. crbug.com/381704
1278 if (!layer
->HasValidTilePriorities())
1281 PictureLayerImpl
* twin_layer
= layer
->GetTwinLayer();
1283 // Ignore the twin layer when tile priorities are invalid.
1284 // TODO(vmpstr): Iterators should handle this instead. crbug.com/381704
1285 if (twin_layer
&& !twin_layer
->HasValidTilePriorities())
1288 // If the current tree is ACTIVE_TREE, then always generate a layer_pair.
1289 // If current tree is PENDING_TREE, then only generate a layer_pair if
1290 // there is no twin layer.
1291 if (layer
->GetTree() == ACTIVE_TREE
) {
1292 DCHECK(!twin_layer
|| twin_layer
->GetTree() == PENDING_TREE
);
1293 layer_pairs
->push_back(PictureLayerImpl::Pair(layer
, twin_layer
));
1294 } else if (!twin_layer
) {
1295 layer_pairs
->push_back(PictureLayerImpl::Pair(NULL
, layer
));
1300 void LayerTreeHostImpl::BuildRasterQueue(RasterTilePriorityQueue
* queue
,
1301 TreePriority tree_priority
) {
1302 picture_layer_pairs_
.clear();
1303 GetPictureLayerImplPairs(&picture_layer_pairs_
);
1304 queue
->Build(picture_layer_pairs_
, tree_priority
);
1307 void LayerTreeHostImpl::BuildEvictionQueue(EvictionTilePriorityQueue
* queue
,
1308 TreePriority tree_priority
) {
1309 picture_layer_pairs_
.clear();
1310 GetPictureLayerImplPairs(&picture_layer_pairs_
);
1311 queue
->Build(picture_layer_pairs_
, tree_priority
);
1314 const std::vector
<PictureLayerImpl
*>& LayerTreeHostImpl::GetPictureLayers()
1316 return picture_layers_
;
1319 void LayerTreeHostImpl::NotifyReadyToActivate() {
1320 client_
->NotifyReadyToActivate();
1323 void LayerTreeHostImpl::NotifyTileStateChanged(const Tile
* tile
) {
1324 TRACE_EVENT0("cc", "LayerTreeHostImpl::NotifyTileStateChanged");
1327 LayerImpl
* layer_impl
=
1328 active_tree_
->FindActiveTreeLayerById(tile
->layer_id());
1330 layer_impl
->NotifyTileStateChanged(tile
);
1333 if (pending_tree_
) {
1334 LayerImpl
* layer_impl
=
1335 pending_tree_
->FindPendingTreeLayerById(tile
->layer_id());
1337 layer_impl
->NotifyTileStateChanged(tile
);
1341 void LayerTreeHostImpl::SetMemoryPolicy(const ManagedMemoryPolicy
& policy
) {
1342 SetManagedMemoryPolicy(policy
, zero_budget_
);
1345 void LayerTreeHostImpl::SetTreeActivationCallback(
1346 const base::Closure
& callback
) {
1347 DCHECK(proxy_
->IsImplThread());
1348 DCHECK(settings_
.impl_side_painting
|| callback
.is_null());
1349 tree_activation_callback_
= callback
;
1352 void LayerTreeHostImpl::SetManagedMemoryPolicy(
1353 const ManagedMemoryPolicy
& policy
, bool zero_budget
) {
1354 if (cached_managed_memory_policy_
== policy
&& zero_budget_
== zero_budget
)
1357 ManagedMemoryPolicy old_policy
= ActualManagedMemoryPolicy();
1359 cached_managed_memory_policy_
= policy
;
1360 zero_budget_
= zero_budget
;
1361 ManagedMemoryPolicy actual_policy
= ActualManagedMemoryPolicy();
1363 if (old_policy
== actual_policy
)
1366 if (!proxy_
->HasImplThread()) {
1367 // In single-thread mode, this can be called on the main thread by
1368 // GLRenderer::OnMemoryAllocationChanged.
1369 DebugScopedSetImplThread
impl_thread(proxy_
);
1370 EnforceManagedMemoryPolicy(actual_policy
);
1372 DCHECK(proxy_
->IsImplThread());
1373 EnforceManagedMemoryPolicy(actual_policy
);
1376 // If there is already enough memory to draw everything imaginable and the
1377 // new memory limit does not change this, then do not re-commit. Don't bother
1378 // skipping commits if this is not visible (commits don't happen when not
1379 // visible, there will almost always be a commit when this becomes visible).
1380 bool needs_commit
= true;
1382 actual_policy
.bytes_limit_when_visible
>= max_memory_needed_bytes_
&&
1383 old_policy
.bytes_limit_when_visible
>= max_memory_needed_bytes_
&&
1384 actual_policy
.priority_cutoff_when_visible
==
1385 old_policy
.priority_cutoff_when_visible
) {
1386 needs_commit
= false;
1390 client_
->SetNeedsCommitOnImplThread();
1393 void LayerTreeHostImpl::SetExternalDrawConstraints(
1394 const gfx::Transform
& transform
,
1395 const gfx::Rect
& viewport
,
1396 const gfx::Rect
& clip
,
1397 const gfx::Rect
& viewport_rect_for_tile_priority
,
1398 const gfx::Transform
& transform_for_tile_priority
,
1399 bool resourceless_software_draw
) {
1400 gfx::Rect viewport_rect_for_tile_priority_in_view_space
;
1401 if (!resourceless_software_draw
) {
1402 gfx::Transform
screen_to_view(gfx::Transform::kSkipInitialization
);
1403 if (transform_for_tile_priority
.GetInverse(&screen_to_view
)) {
1404 // Convert from screen space to view space.
1405 viewport_rect_for_tile_priority_in_view_space
=
1406 gfx::ToEnclosingRect(MathUtil::ProjectClippedRect(
1407 screen_to_view
, viewport_rect_for_tile_priority
));
1411 if (external_transform_
!= transform
|| external_viewport_
!= viewport
||
1412 resourceless_software_draw_
!= resourceless_software_draw
||
1413 viewport_rect_for_tile_priority_
!=
1414 viewport_rect_for_tile_priority_in_view_space
) {
1415 active_tree_
->set_needs_update_draw_properties();
1418 external_transform_
= transform
;
1419 external_viewport_
= viewport
;
1420 external_clip_
= clip
;
1421 viewport_rect_for_tile_priority_
=
1422 viewport_rect_for_tile_priority_in_view_space
;
1423 resourceless_software_draw_
= resourceless_software_draw
;
1426 void LayerTreeHostImpl::SetNeedsRedrawRect(const gfx::Rect
& damage_rect
) {
1427 if (damage_rect
.IsEmpty())
1429 NotifySwapPromiseMonitorsOfSetNeedsRedraw();
1430 client_
->SetNeedsRedrawRectOnImplThread(damage_rect
);
1433 void LayerTreeHostImpl::BeginFrame(const BeginFrameArgs
& args
) {
1434 client_
->BeginFrame(args
);
1437 void LayerTreeHostImpl::DidSwapBuffers() {
1438 client_
->DidSwapBuffersOnImplThread();
1441 void LayerTreeHostImpl::DidSwapBuffersComplete() {
1442 client_
->DidSwapBuffersCompleteOnImplThread();
1445 void LayerTreeHostImpl::ReclaimResources(const CompositorFrameAck
* ack
) {
1446 // TODO(piman): We may need to do some validation on this ack before
1449 renderer_
->ReceiveSwapBuffersAck(*ack
);
1451 // In OOM, we now might be able to release more resources that were held
1452 // because they were exported.
1453 if (tile_manager_
) {
1454 DCHECK(resource_pool_
);
1456 resource_pool_
->CheckBusyResources();
1457 resource_pool_
->ReduceResourceUsage();
1459 // If we're not visible, we likely released resources, so we want to
1460 // aggressively flush here to make sure those DeleteTextures make it to the
1461 // GPU process to free up the memory.
1462 if (output_surface_
->context_provider() && !visible_
) {
1463 output_surface_
->context_provider()->ContextGL()->ShallowFlushCHROMIUM();
1467 void LayerTreeHostImpl::OnCanDrawStateChangedForTree() {
1468 client_
->OnCanDrawStateChanged(CanDraw());
1471 CompositorFrameMetadata
LayerTreeHostImpl::MakeCompositorFrameMetadata() const {
1472 CompositorFrameMetadata metadata
;
1473 metadata
.device_scale_factor
= device_scale_factor_
;
1474 metadata
.page_scale_factor
= active_tree_
->total_page_scale_factor();
1475 metadata
.scrollable_viewport_size
= active_tree_
->ScrollableViewportSize();
1476 metadata
.root_layer_size
= active_tree_
->ScrollableSize();
1477 metadata
.min_page_scale_factor
= active_tree_
->min_page_scale_factor();
1478 metadata
.max_page_scale_factor
= active_tree_
->max_page_scale_factor();
1479 if (top_controls_manager_
) {
1480 metadata
.location_bar_offset
=
1481 gfx::Vector2dF(0.f
, top_controls_manager_
->ControlsTopOffset());
1482 metadata
.location_bar_content_translation
=
1483 gfx::Vector2dF(0.f
, top_controls_manager_
->ContentTopOffset());
1486 active_tree_
->GetViewportSelection(&metadata
.selection_start
,
1487 &metadata
.selection_end
);
1489 if (!InnerViewportScrollLayer())
1492 metadata
.root_scroll_offset
= active_tree_
->TotalScrollOffset();
1497 static void LayerTreeHostImplDidBeginTracingCallback(LayerImpl
* layer
) {
1498 layer
->DidBeginTracing();
1501 void LayerTreeHostImpl::DrawLayers(FrameData
* frame
,
1502 base::TimeTicks frame_begin_time
) {
1503 TRACE_EVENT0("cc", "LayerTreeHostImpl::DrawLayers");
1506 if (frame
->has_no_damage
) {
1507 TRACE_EVENT_INSTANT0("cc", "EarlyOut_NoDamage", TRACE_EVENT_SCOPE_THREAD
);
1508 DCHECK(!output_surface_
->capabilities()
1509 .draw_and_swap_full_viewport_every_frame
);
1513 DCHECK(!frame
->render_passes
.empty());
1515 fps_counter_
->SaveTimeStamp(frame_begin_time
,
1516 !output_surface_
->context_provider());
1517 bool on_main_thread
= false;
1518 rendering_stats_instrumentation_
->IncrementFrameCount(
1521 if (tile_manager_
) {
1522 memory_history_
->SaveEntry(
1523 tile_manager_
->memory_stats_from_last_assign());
1526 if (debug_state_
.ShowHudRects()) {
1527 debug_rect_history_
->SaveDebugRectsForCurrentFrame(
1528 active_tree_
->root_layer(),
1529 active_tree_
->hud_layer(),
1530 *frame
->render_surface_layer_list
,
1531 frame
->occluding_screen_space_rects
,
1532 frame
->non_occluding_screen_space_rects
,
1536 if (!settings_
.impl_side_painting
&& debug_state_
.continuous_painting
) {
1537 const RenderingStats
& stats
=
1538 rendering_stats_instrumentation_
->GetRenderingStats();
1539 paint_time_counter_
->SavePaintTime(stats
.main_stats
.paint_time
);
1543 TRACE_EVENT_IS_NEW_TRACE(&is_new_trace
);
1545 if (pending_tree_
) {
1546 LayerTreeHostCommon::CallFunctionForSubtree(
1547 pending_tree_
->root_layer(),
1548 base::Bind(&LayerTreeHostImplDidBeginTracingCallback
));
1550 LayerTreeHostCommon::CallFunctionForSubtree(
1551 active_tree_
->root_layer(),
1552 base::Bind(&LayerTreeHostImplDidBeginTracingCallback
));
1556 TRACE_EVENT0("cc", "DrawLayers.FrameViewerTracing");
1557 TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(
1558 TRACE_DISABLED_BY_DEFAULT("cc.debug") ","
1559 TRACE_DISABLED_BY_DEFAULT("cc.debug.quads") ","
1560 TRACE_DISABLED_BY_DEFAULT("devtools.timeline.layers"),
1561 "cc::LayerTreeHostImpl",
1563 AsValueWithFrame(frame
));
1566 const DrawMode draw_mode
= GetDrawMode();
1568 // Because the contents of the HUD depend on everything else in the frame, the
1569 // contents of its texture are updated as the last thing before the frame is
1571 if (active_tree_
->hud_layer()) {
1572 TRACE_EVENT0("cc", "DrawLayers.UpdateHudTexture");
1573 active_tree_
->hud_layer()->UpdateHudTexture(draw_mode
,
1574 resource_provider_
.get());
1577 if (draw_mode
== DRAW_MODE_RESOURCELESS_SOFTWARE
) {
1578 bool disable_picture_quad_image_filtering
=
1579 IsCurrentlyScrolling() || needs_animate_layers();
1581 scoped_ptr
<SoftwareRenderer
> temp_software_renderer
=
1582 SoftwareRenderer::Create(this, &settings_
, output_surface_
.get(), NULL
);
1583 temp_software_renderer
->DrawFrame(&frame
->render_passes
,
1584 device_scale_factor_
,
1587 disable_picture_quad_image_filtering
);
1589 renderer_
->DrawFrame(&frame
->render_passes
,
1590 device_scale_factor_
,
1595 // The render passes should be consumed by the renderer.
1596 DCHECK(frame
->render_passes
.empty());
1597 frame
->render_passes_by_id
.clear();
1599 // The next frame should start by assuming nothing has changed, and changes
1600 // are noted as they occur.
1601 // TODO(boliu): If we did a temporary software renderer frame, propogate the
1602 // damage forward to the next frame.
1603 for (size_t i
= 0; i
< frame
->render_surface_layer_list
->size(); i
++) {
1604 (*frame
->render_surface_layer_list
)[i
]->render_surface()->damage_tracker()->
1605 DidDrawDamagedArea();
1607 active_tree_
->root_layer()->ResetAllChangeTrackingForSubtree();
1609 active_tree_
->set_has_ever_been_drawn(true);
1610 devtools_instrumentation::DidDrawFrame(id_
);
1611 benchmark_instrumentation::IssueImplThreadRenderingStatsEvent(
1612 rendering_stats_instrumentation_
->impl_thread_rendering_stats());
1613 rendering_stats_instrumentation_
->AccumulateAndClearImplThreadStats();
1616 void LayerTreeHostImpl::DidDrawAllLayers(const FrameData
& frame
) {
1617 for (size_t i
= 0; i
< frame
.will_draw_layers
.size(); ++i
)
1618 frame
.will_draw_layers
[i
]->DidDraw(resource_provider_
.get());
1620 // Once all layers have been drawn, pending texture uploads should no
1621 // longer block future uploads.
1622 resource_provider_
->MarkPendingUploadsAsNonBlocking();
1625 void LayerTreeHostImpl::FinishAllRendering() {
1627 renderer_
->Finish();
1630 void LayerTreeHostImpl::SetUseGpuRasterization(bool use_gpu
) {
1631 if (use_gpu
== use_gpu_rasterization_
)
1634 use_gpu_rasterization_
= use_gpu
;
1635 ReleaseTreeResources();
1637 // Replace existing tile manager with another one that uses appropriate
1639 if (tile_manager_
) {
1640 DestroyTileManager();
1641 CreateAndSetTileManager();
1644 // We have released tilings for both active and pending tree.
1645 // We would not have any content to draw until the pending tree is activated.
1646 // Prevent the active tree from drawing until activation.
1647 active_tree_
->SetRequiresHighResToDraw();
1650 const RendererCapabilitiesImpl
&
1651 LayerTreeHostImpl::GetRendererCapabilities() const {
1652 return renderer_
->Capabilities();
1655 bool LayerTreeHostImpl::SwapBuffers(const LayerTreeHostImpl::FrameData
& frame
) {
1656 active_tree()->ResetRequiresHighResToDraw();
1657 if (frame
.has_no_damage
) {
1658 active_tree()->BreakSwapPromises(SwapPromise::SWAP_FAILS
);
1661 CompositorFrameMetadata metadata
= MakeCompositorFrameMetadata();
1662 active_tree()->FinishSwapPromises(&metadata
);
1663 for (size_t i
= 0; i
< metadata
.latency_info
.size(); i
++) {
1664 TRACE_EVENT_FLOW_STEP0(
1667 TRACE_ID_DONT_MANGLE(metadata
.latency_info
[i
].trace_id
),
1670 renderer_
->SwapBuffers(metadata
);
1674 void LayerTreeHostImpl::SetNeedsBeginFrame(bool enable
) {
1675 if (output_surface_
)
1676 output_surface_
->SetNeedsBeginFrame(enable
);
1681 void LayerTreeHostImpl::WillBeginImplFrame(const BeginFrameArgs
& args
) {
1682 // Sample the frame time now. This time will be used for updating animations
1684 UpdateCurrentBeginFrameArgs(args
);
1685 // Cache the begin impl frame interval
1686 begin_impl_frame_interval_
= args
.interval
;
1689 void LayerTreeHostImpl::UpdateInnerViewportContainerSize() {
1690 LayerImpl
* container_layer
= active_tree_
->InnerViewportContainerLayer();
1691 if (!container_layer
)
1694 if (top_controls_manager_
) {
1695 container_layer
->SetBoundsDelta(
1696 gfx::Vector2dF(0, active_tree_
->top_controls_layout_height() -
1697 active_tree_
->total_top_controls_top_offset() -
1698 top_controls_manager_
->controls_height()));
1702 void LayerTreeHostImpl::SetTopControlsLayoutHeight(float height
) {
1703 if (active_tree_
->top_controls_layout_height() == height
)
1706 active_tree_
->set_top_controls_layout_height(height
);
1707 UpdateInnerViewportContainerSize();
1708 SetFullRootLayerDamage();
1711 void LayerTreeHostImpl::DidLoseOutputSurface() {
1712 if (resource_provider_
)
1713 resource_provider_
->DidLoseOutputSurface();
1714 client_
->DidLoseOutputSurfaceOnImplThread();
1717 bool LayerTreeHostImpl::HaveRootScrollLayer() const {
1718 return !!InnerViewportScrollLayer();
1721 LayerImpl
* LayerTreeHostImpl::RootLayer() const {
1722 return active_tree_
->root_layer();
1725 LayerImpl
* LayerTreeHostImpl::InnerViewportScrollLayer() const {
1726 return active_tree_
->InnerViewportScrollLayer();
1729 LayerImpl
* LayerTreeHostImpl::OuterViewportScrollLayer() const {
1730 return active_tree_
->OuterViewportScrollLayer();
1733 LayerImpl
* LayerTreeHostImpl::CurrentlyScrollingLayer() const {
1734 return active_tree_
->CurrentlyScrollingLayer();
1737 bool LayerTreeHostImpl::IsCurrentlyScrolling() const {
1738 return CurrentlyScrollingLayer() ||
1739 (InnerViewportScrollLayer() &&
1740 InnerViewportScrollLayer()->IsExternalFlingActive()) ||
1741 (OuterViewportScrollLayer() &&
1742 OuterViewportScrollLayer()->IsExternalFlingActive());
1745 // Content layers can be either directly scrollable or contained in an outer
1746 // scrolling layer which applies the scroll transform. Given a content layer,
1747 // this function returns the associated scroll layer if any.
1748 static LayerImpl
* FindScrollLayerForContentLayer(LayerImpl
* layer_impl
) {
1752 if (layer_impl
->scrollable())
1755 if (layer_impl
->DrawsContent() &&
1756 layer_impl
->parent() &&
1757 layer_impl
->parent()->scrollable())
1758 return layer_impl
->parent();
1763 void LayerTreeHostImpl::CreatePendingTree() {
1764 CHECK(!pending_tree_
);
1766 recycle_tree_
.swap(pending_tree_
);
1768 pending_tree_
= LayerTreeImpl::create(this);
1770 // Update the delta from the active tree, which may have
1771 // adjusted its delta prior to the pending tree being created.
1772 DCHECK_EQ(1.f
, pending_tree_
->sent_page_scale_delta());
1773 DCHECK_EQ(0.f
, pending_tree_
->sent_top_controls_delta());
1774 pending_tree_
->SetPageScaleDelta(active_tree_
->page_scale_delta() /
1775 active_tree_
->sent_page_scale_delta());
1776 pending_tree_
->set_top_controls_delta(
1777 active_tree_
->top_controls_delta() -
1778 active_tree_
->sent_top_controls_delta());
1780 client_
->OnCanDrawStateChanged(CanDraw());
1781 TRACE_EVENT_ASYNC_BEGIN0("cc", "PendingTree:waiting", pending_tree_
.get());
1784 void LayerTreeHostImpl::UpdateVisibleTiles() {
1785 if (tile_manager_
&& tile_manager_
->UpdateVisibleTiles())
1786 DidInitializeVisibleTile();
1787 need_to_update_visible_tiles_before_draw_
= false;
1790 void LayerTreeHostImpl::ActivateSyncTree() {
1791 need_to_update_visible_tiles_before_draw_
= true;
1793 if (pending_tree_
) {
1794 TRACE_EVENT_ASYNC_END0("cc", "PendingTree:waiting", pending_tree_
.get());
1796 active_tree_
->SetRootLayerScrollOffsetDelegate(NULL
);
1797 active_tree_
->PushPersistedState(pending_tree_
.get());
1798 // Process any requests in the UI resource queue. The request queue is
1799 // given in LayerTreeHost::FinishCommitOnImplThread. This must take place
1801 pending_tree_
->ProcessUIResourceRequestQueue();
1803 if (pending_tree_
->needs_full_tree_sync()) {
1804 active_tree_
->SetRootLayer(
1805 TreeSynchronizer::SynchronizeTrees(pending_tree_
->root_layer(),
1806 active_tree_
->DetachLayerTree(),
1807 active_tree_
.get()));
1809 TreeSynchronizer::PushProperties(pending_tree_
->root_layer(),
1810 active_tree_
->root_layer());
1811 pending_tree_
->PushPropertiesTo(active_tree_
.get());
1813 // Now that we've synced everything from the pending tree to the active
1814 // tree, rename the pending tree the recycle tree so we can reuse it on the
1816 DCHECK(!recycle_tree_
);
1817 pending_tree_
.swap(recycle_tree_
);
1819 active_tree_
->SetRootLayerScrollOffsetDelegate(
1820 root_layer_scroll_offset_delegate_
);
1822 if (top_controls_manager_
) {
1823 top_controls_manager_
->SetControlsTopOffset(
1824 active_tree_
->total_top_controls_top_offset());
1827 UpdateInnerViewportContainerSize();
1829 active_tree_
->ProcessUIResourceRequestQueue();
1832 active_tree_
->DidBecomeActive();
1833 ActivateAnimations();
1834 if (settings_
.impl_side_painting
)
1835 client_
->RenewTreePriority();
1837 client_
->OnCanDrawStateChanged(CanDraw());
1838 client_
->DidActivateSyncTree();
1839 if (!tree_activation_callback_
.is_null())
1840 tree_activation_callback_
.Run();
1842 if (debug_state_
.continuous_painting
) {
1843 const RenderingStats
& stats
=
1844 rendering_stats_instrumentation_
->GetRenderingStats();
1845 paint_time_counter_
->SavePaintTime(stats
.main_stats
.paint_time
+
1846 stats
.main_stats
.record_time
+
1847 stats
.impl_stats
.rasterize_time
);
1850 if (time_source_client_adapter_
&& time_source_client_adapter_
->Active())
1851 DCHECK(active_tree_
->root_layer());
1854 void LayerTreeHostImpl::SetVisible(bool visible
) {
1855 DCHECK(proxy_
->IsImplThread());
1857 if (visible_
== visible
)
1860 DidVisibilityChange(this, visible_
);
1861 EnforceManagedMemoryPolicy(ActualManagedMemoryPolicy());
1863 // If we just became visible, we have to ensure that we draw high res tiles,
1864 // to prevent checkerboard/low res flashes.
1866 active_tree()->SetRequiresHighResToDraw();
1868 EvictAllUIResources();
1870 // Evict tiles immediately if invisible since this tab may never get another
1871 // draw or timer tick.
1878 renderer_
->SetVisible(visible
);
1881 void LayerTreeHostImpl::SetNeedsAnimate() {
1882 NotifySwapPromiseMonitorsOfSetNeedsRedraw();
1883 client_
->SetNeedsAnimateOnImplThread();
1886 void LayerTreeHostImpl::SetNeedsRedraw() {
1887 NotifySwapPromiseMonitorsOfSetNeedsRedraw();
1888 client_
->SetNeedsRedrawOnImplThread();
1891 ManagedMemoryPolicy
LayerTreeHostImpl::ActualManagedMemoryPolicy() const {
1892 ManagedMemoryPolicy actual
= cached_managed_memory_policy_
;
1893 if (debug_state_
.rasterize_only_visible_content
) {
1894 actual
.priority_cutoff_when_visible
=
1895 gpu::MemoryAllocation::CUTOFF_ALLOW_REQUIRED_ONLY
;
1896 } else if (use_gpu_rasterization()) {
1897 actual
.priority_cutoff_when_visible
=
1898 gpu::MemoryAllocation::CUTOFF_ALLOW_NICE_TO_HAVE
;
1902 actual
.bytes_limit_when_visible
= 0;
1908 size_t LayerTreeHostImpl::memory_allocation_limit_bytes() const {
1909 return ActualManagedMemoryPolicy().bytes_limit_when_visible
;
1912 int LayerTreeHostImpl::memory_allocation_priority_cutoff() const {
1913 return ManagedMemoryPolicy::PriorityCutoffToValue(
1914 ActualManagedMemoryPolicy().priority_cutoff_when_visible
);
1917 void LayerTreeHostImpl::ReleaseTreeResources() {
1918 active_tree_
->ReleaseResources();
1920 pending_tree_
->ReleaseResources();
1922 recycle_tree_
->ReleaseResources();
1924 EvictAllUIResources();
1927 void LayerTreeHostImpl::CreateAndSetRenderer() {
1929 DCHECK(output_surface_
);
1930 DCHECK(resource_provider_
);
1932 if (output_surface_
->capabilities().delegated_rendering
) {
1933 renderer_
= DelegatingRenderer::Create(
1934 this, &settings_
, output_surface_
.get(), resource_provider_
.get());
1935 } else if (output_surface_
->context_provider()) {
1936 renderer_
= GLRenderer::Create(this,
1938 output_surface_
.get(),
1939 resource_provider_
.get(),
1940 texture_mailbox_deleter_
.get(),
1941 settings_
.highp_threshold_min
);
1942 } else if (output_surface_
->software_device()) {
1943 renderer_
= SoftwareRenderer::Create(
1944 this, &settings_
, output_surface_
.get(), resource_provider_
.get());
1948 renderer_
->SetVisible(visible_
);
1949 SetFullRootLayerDamage();
1951 // See note in LayerTreeImpl::UpdateDrawProperties. Renderer needs to be
1952 // initialized to get max texture size. Also, after releasing resources,
1953 // trees need another update to generate new ones.
1954 active_tree_
->set_needs_update_draw_properties();
1956 pending_tree_
->set_needs_update_draw_properties();
1957 client_
->UpdateRendererCapabilitiesOnImplThread();
1960 void LayerTreeHostImpl::CreateAndSetTileManager() {
1961 DCHECK(!tile_manager_
);
1962 DCHECK(settings_
.impl_side_painting
);
1963 DCHECK(output_surface_
);
1964 DCHECK(resource_provider_
);
1965 DCHECK(proxy_
->ImplThreadTaskRunner());
1967 ContextProvider
* context_provider
= output_surface_
->context_provider();
1968 transfer_buffer_memory_limit_
=
1969 GetMaxTransferBufferUsageBytes(context_provider
, settings_
.refresh_rate
);
1971 if (use_gpu_rasterization_
&& context_provider
) {
1973 ResourcePool::Create(resource_provider_
.get(),
1975 resource_provider_
->best_texture_format());
1977 raster_worker_pool_
=
1978 GpuRasterWorkerPool::Create(proxy_
->ImplThreadTaskRunner(),
1980 resource_provider_
.get());
1981 } else if (UseOneCopyTextureUpload() && context_provider
) {
1982 // We need to create a staging resource pool when using copy rasterizer.
1983 staging_resource_pool_
=
1984 ResourcePool::Create(resource_provider_
.get(),
1985 GetMapImageTextureTarget(context_provider
),
1986 resource_provider_
->best_texture_format());
1988 ResourcePool::Create(resource_provider_
.get(),
1990 resource_provider_
->best_texture_format());
1992 raster_worker_pool_
= ImageCopyRasterWorkerPool::Create(
1993 proxy_
->ImplThreadTaskRunner(),
1994 RasterWorkerPool::GetTaskGraphRunner(),
1996 resource_provider_
.get(),
1997 staging_resource_pool_
.get());
1998 } else if (!UseZeroCopyTextureUpload() && context_provider
) {
1999 resource_pool_
= ResourcePool::Create(
2000 resource_provider_
.get(),
2002 resource_provider_
->memory_efficient_texture_format());
2004 raster_worker_pool_
= PixelBufferRasterWorkerPool::Create(
2005 proxy_
->ImplThreadTaskRunner(),
2006 RasterWorkerPool::GetTaskGraphRunner(),
2008 resource_provider_
.get(),
2009 transfer_buffer_memory_limit_
);
2012 ResourcePool::Create(resource_provider_
.get(),
2013 GetMapImageTextureTarget(context_provider
),
2014 resource_provider_
->best_texture_format());
2016 raster_worker_pool_
=
2017 ImageRasterWorkerPool::Create(proxy_
->ImplThreadTaskRunner(),
2018 RasterWorkerPool::GetTaskGraphRunner(),
2019 resource_provider_
.get());
2023 TileManager::Create(this,
2024 proxy_
->ImplThreadTaskRunner(),
2025 resource_pool_
.get(),
2026 raster_worker_pool_
->AsRasterizer(),
2027 rendering_stats_instrumentation_
);
2029 UpdateTileManagerMemoryPolicy(ActualManagedMemoryPolicy());
2030 need_to_update_visible_tiles_before_draw_
= false;
2033 void LayerTreeHostImpl::DestroyTileManager() {
2034 tile_manager_
.reset();
2035 resource_pool_
.reset();
2036 staging_resource_pool_
.reset();
2037 raster_worker_pool_
.reset();
2040 bool LayerTreeHostImpl::UsePendingTreeForSync() const {
2041 // In impl-side painting, synchronize to the pending tree so that it has
2042 // time to raster before being displayed.
2043 return settings_
.impl_side_painting
;
2046 bool LayerTreeHostImpl::UseZeroCopyTextureUpload() const {
2047 // Note: we use zero-copy by default when the renderer is using
2048 // shared memory resources.
2049 return (settings_
.use_zero_copy
||
2050 GetRendererCapabilities().using_shared_memory_resources
) &&
2051 GetRendererCapabilities().using_map_image
;
2054 bool LayerTreeHostImpl::UseOneCopyTextureUpload() const {
2055 // Sync query support is required by one-copy rasterizer.
2056 return settings_
.use_one_copy
&& GetRendererCapabilities().using_map_image
&&
2057 resource_provider_
->use_sync_query();
2060 void LayerTreeHostImpl::EnforceZeroBudget(bool zero_budget
) {
2061 SetManagedMemoryPolicy(cached_managed_memory_policy_
, zero_budget
);
2064 bool LayerTreeHostImpl::InitializeRenderer(
2065 scoped_ptr
<OutputSurface
> output_surface
) {
2066 TRACE_EVENT0("cc", "LayerTreeHostImpl::InitializeRenderer");
2068 // Since we will create a new resource provider, we cannot continue to use
2069 // the old resources (i.e. render_surfaces and texture IDs). Clear them
2070 // before we destroy the old resource provider.
2071 ReleaseTreeResources();
2073 // Note: order is important here.
2075 DestroyTileManager();
2076 resource_provider_
.reset();
2077 output_surface_
.reset();
2079 if (!output_surface
->BindToClient(this))
2082 output_surface_
= output_surface
.Pass();
2083 resource_provider_
=
2084 ResourceProvider::Create(output_surface_
.get(),
2085 shared_bitmap_manager_
,
2086 proxy_
->blocking_main_thread_task_runner(),
2087 settings_
.highp_threshold_min
,
2088 settings_
.use_rgba_4444_textures
,
2089 settings_
.texture_id_allocation_chunk_size
,
2090 settings_
.use_distance_field_text
);
2092 if (output_surface_
->capabilities().deferred_gl_initialization
)
2093 EnforceZeroBudget(true);
2095 CreateAndSetRenderer();
2097 if (settings_
.impl_side_painting
)
2098 CreateAndSetTileManager();
2100 // Initialize vsync parameters to sane values.
2101 const base::TimeDelta display_refresh_interval
=
2102 base::TimeDelta::FromMicroseconds(base::Time::kMicrosecondsPerSecond
/
2103 settings_
.refresh_rate
);
2104 CommitVSyncParameters(base::TimeTicks(), display_refresh_interval
);
2106 // TODO(brianderson): Don't use a hard-coded parent draw time.
2107 base::TimeDelta parent_draw_time
=
2108 (!settings_
.begin_frame_scheduling_enabled
&&
2109 output_surface_
->capabilities().adjust_deadline_for_parent
)
2110 ? BeginFrameArgs::DefaultEstimatedParentDrawTime()
2111 : base::TimeDelta();
2112 client_
->SetEstimatedParentDrawTime(parent_draw_time
);
2114 int max_frames_pending
= output_surface_
->capabilities().max_frames_pending
;
2115 if (max_frames_pending
<= 0)
2116 max_frames_pending
= OutputSurface::DEFAULT_MAX_FRAMES_PENDING
;
2117 client_
->SetMaxSwapsPendingOnImplThread(max_frames_pending
);
2118 client_
->OnCanDrawStateChanged(CanDraw());
2123 void LayerTreeHostImpl::CommitVSyncParameters(base::TimeTicks timebase
,
2124 base::TimeDelta interval
) {
2125 client_
->CommitVSyncParameters(timebase
, interval
);
2128 void LayerTreeHostImpl::DeferredInitialize() {
2129 DCHECK(output_surface_
->capabilities().deferred_gl_initialization
);
2130 DCHECK(settings_
.impl_side_painting
);
2131 DCHECK(output_surface_
->context_provider());
2133 ReleaseTreeResources();
2135 DestroyTileManager();
2137 resource_provider_
->InitializeGL();
2139 CreateAndSetRenderer();
2140 EnforceZeroBudget(false);
2141 CreateAndSetTileManager();
2143 client_
->SetNeedsCommitOnImplThread();
2146 void LayerTreeHostImpl::ReleaseGL() {
2147 DCHECK(output_surface_
->capabilities().deferred_gl_initialization
);
2148 DCHECK(settings_
.impl_side_painting
);
2149 DCHECK(output_surface_
->context_provider());
2151 ReleaseTreeResources();
2153 DestroyTileManager();
2155 resource_provider_
->InitializeSoftware();
2156 output_surface_
->ReleaseContextProvider();
2158 CreateAndSetRenderer();
2159 EnforceZeroBudget(true);
2160 CreateAndSetTileManager();
2162 client_
->SetNeedsCommitOnImplThread();
2165 void LayerTreeHostImpl::SetViewportSize(const gfx::Size
& device_viewport_size
) {
2166 if (device_viewport_size
== device_viewport_size_
)
2170 active_tree_
->SetViewportSizeInvalid();
2172 device_viewport_size_
= device_viewport_size
;
2174 UpdateInnerViewportContainerSize();
2175 client_
->OnCanDrawStateChanged(CanDraw());
2176 SetFullRootLayerDamage();
2177 active_tree_
->set_needs_update_draw_properties();
2180 void LayerTreeHostImpl::SetOverhangUIResource(
2181 UIResourceId overhang_ui_resource_id
,
2182 const gfx::Size
& overhang_ui_resource_size
) {
2183 overhang_ui_resource_id_
= overhang_ui_resource_id
;
2184 overhang_ui_resource_size_
= overhang_ui_resource_size
;
2187 void LayerTreeHostImpl::SetDeviceScaleFactor(float device_scale_factor
) {
2188 if (device_scale_factor
== device_scale_factor_
)
2190 device_scale_factor_
= device_scale_factor
;
2192 SetFullRootLayerDamage();
2195 const gfx::Rect
LayerTreeHostImpl::ViewportRectForTilePriority() const {
2196 if (viewport_rect_for_tile_priority_
.IsEmpty())
2197 return DeviceViewport();
2199 return viewport_rect_for_tile_priority_
;
2202 gfx::Size
LayerTreeHostImpl::DrawViewportSize() const {
2203 return DeviceViewport().size();
2206 gfx::Rect
LayerTreeHostImpl::DeviceViewport() const {
2207 if (external_viewport_
.IsEmpty())
2208 return gfx::Rect(device_viewport_size_
);
2210 return external_viewport_
;
2213 gfx::Rect
LayerTreeHostImpl::DeviceClip() const {
2214 if (external_clip_
.IsEmpty())
2215 return DeviceViewport();
2217 return external_clip_
;
2220 const gfx::Transform
& LayerTreeHostImpl::DrawTransform() const {
2221 return external_transform_
;
2224 void LayerTreeHostImpl::DidChangeTopControlsPosition() {
2225 UpdateInnerViewportContainerSize();
2228 active_tree_
->set_needs_update_draw_properties();
2229 SetFullRootLayerDamage();
2232 void LayerTreeHostImpl::SetControlsTopOffset(float offset
) {
2233 active_tree_
->set_top_controls_delta(
2234 offset
- active_tree_
->top_controls_top_offset());
2237 float LayerTreeHostImpl::ControlsTopOffset() const {
2238 return active_tree_
->total_top_controls_top_offset();
2241 void LayerTreeHostImpl::BindToClient(InputHandlerClient
* client
) {
2242 DCHECK(input_handler_client_
== NULL
);
2243 input_handler_client_
= client
;
2246 static LayerImpl
* NextScrollLayer(LayerImpl
* layer
) {
2247 if (LayerImpl
* scroll_parent
= layer
->scroll_parent())
2248 return scroll_parent
;
2249 return layer
->parent();
2252 LayerImpl
* LayerTreeHostImpl::FindScrollLayerForDeviceViewportPoint(
2253 const gfx::PointF
& device_viewport_point
,
2254 InputHandler::ScrollInputType type
,
2255 LayerImpl
* layer_impl
,
2256 bool* scroll_on_main_thread
,
2257 bool* optional_has_ancestor_scroll_handler
) const {
2258 DCHECK(scroll_on_main_thread
);
2260 // Walk up the hierarchy and look for a scrollable layer.
2261 LayerImpl
* potentially_scrolling_layer_impl
= NULL
;
2262 for (; layer_impl
; layer_impl
= NextScrollLayer(layer_impl
)) {
2263 // The content layer can also block attempts to scroll outside the main
2265 ScrollStatus status
= layer_impl
->TryScroll(device_viewport_point
, type
);
2266 if (status
== ScrollOnMainThread
) {
2267 *scroll_on_main_thread
= true;
2271 LayerImpl
* scroll_layer_impl
= FindScrollLayerForContentLayer(layer_impl
);
2272 if (!scroll_layer_impl
)
2275 status
= scroll_layer_impl
->TryScroll(device_viewport_point
, type
);
2276 // If any layer wants to divert the scroll event to the main thread, abort.
2277 if (status
== ScrollOnMainThread
) {
2278 *scroll_on_main_thread
= true;
2282 if (optional_has_ancestor_scroll_handler
&&
2283 scroll_layer_impl
->have_scroll_event_handlers())
2284 *optional_has_ancestor_scroll_handler
= true;
2286 if (status
== ScrollStarted
&& !potentially_scrolling_layer_impl
)
2287 potentially_scrolling_layer_impl
= scroll_layer_impl
;
2290 // Falling back to the root scroll layer ensures generation of root overscroll
2291 // notifications while preventing scroll updates from being unintentionally
2292 // forwarded to the main thread.
2293 if (!potentially_scrolling_layer_impl
)
2294 potentially_scrolling_layer_impl
= OuterViewportScrollLayer()
2295 ? OuterViewportScrollLayer()
2296 : InnerViewportScrollLayer();
2298 return potentially_scrolling_layer_impl
;
2301 // Similar to LayerImpl::HasAncestor, but walks up the scroll parents.
2302 static bool HasScrollAncestor(LayerImpl
* child
, LayerImpl
* scroll_ancestor
) {
2303 DCHECK(scroll_ancestor
);
2304 for (LayerImpl
* ancestor
= child
; ancestor
;
2305 ancestor
= NextScrollLayer(ancestor
)) {
2306 if (ancestor
->scrollable())
2307 return ancestor
== scroll_ancestor
;
2312 InputHandler::ScrollStatus
LayerTreeHostImpl::ScrollBegin(
2313 const gfx::Point
& viewport_point
,
2314 InputHandler::ScrollInputType type
) {
2315 TRACE_EVENT0("cc", "LayerTreeHostImpl::ScrollBegin");
2317 if (top_controls_manager_
)
2318 top_controls_manager_
->ScrollBegin();
2320 DCHECK(!CurrentlyScrollingLayer());
2321 ClearCurrentlyScrollingLayer();
2323 gfx::PointF device_viewport_point
= gfx::ScalePoint(viewport_point
,
2324 device_scale_factor_
);
2325 LayerImpl
* layer_impl
=
2326 active_tree_
->FindLayerThatIsHitByPoint(device_viewport_point
);
2329 LayerImpl
* scroll_layer_impl
=
2330 active_tree_
->FindFirstScrollingLayerThatIsHitByPoint(
2331 device_viewport_point
);
2332 if (scroll_layer_impl
&& !HasScrollAncestor(layer_impl
, scroll_layer_impl
))
2333 return ScrollUnknown
;
2336 bool scroll_on_main_thread
= false;
2337 LayerImpl
* scrolling_layer_impl
=
2338 FindScrollLayerForDeviceViewportPoint(device_viewport_point
,
2341 &scroll_on_main_thread
,
2342 &scroll_affects_scroll_handler_
);
2344 if (scroll_on_main_thread
) {
2345 UMA_HISTOGRAM_BOOLEAN("TryScroll.SlowScroll", true);
2346 return ScrollOnMainThread
;
2349 if (scrolling_layer_impl
) {
2350 active_tree_
->SetCurrentlyScrollingLayer(scrolling_layer_impl
);
2351 should_bubble_scrolls_
= (type
!= NonBubblingGesture
);
2352 wheel_scrolling_
= (type
== Wheel
);
2353 client_
->RenewTreePriority();
2354 UMA_HISTOGRAM_BOOLEAN("TryScroll.SlowScroll", false);
2355 return ScrollStarted
;
2357 return ScrollIgnored
;
2360 InputHandler::ScrollStatus
LayerTreeHostImpl::ScrollAnimated(
2361 const gfx::Point
& viewport_point
,
2362 const gfx::Vector2dF
& scroll_delta
) {
2363 if (LayerImpl
* layer_impl
= CurrentlyScrollingLayer()) {
2364 Animation
* animation
=
2365 layer_impl
->layer_animation_controller()->GetAnimation(
2366 Animation::ScrollOffset
);
2368 return ScrollIgnored
;
2370 ScrollOffsetAnimationCurve
* curve
=
2371 animation
->curve()->ToScrollOffsetAnimationCurve();
2373 gfx::Vector2dF new_target
= curve
->target_value() + scroll_delta
;
2374 new_target
.SetToMax(gfx::Vector2dF());
2375 new_target
.SetToMin(layer_impl
->MaxScrollOffset());
2377 curve
->UpdateTarget(animation
->TrimTimeToCurrentIteration(
2378 CurrentBeginFrameArgs().frame_time
),
2381 return ScrollStarted
;
2383 // ScrollAnimated is only used for wheel scrolls. We use the same bubbling
2384 // behavior as ScrollBy to determine which layer to animate, but we do not
2385 // do the Android-specific things in ScrollBy like showing top controls.
2386 InputHandler::ScrollStatus scroll_status
= ScrollBegin(viewport_point
, Wheel
);
2387 if (scroll_status
== ScrollStarted
) {
2388 gfx::Vector2dF pending_delta
= scroll_delta
;
2389 for (LayerImpl
* layer_impl
= CurrentlyScrollingLayer(); layer_impl
;
2390 layer_impl
= layer_impl
->parent()) {
2391 if (!layer_impl
->scrollable())
2394 gfx::Vector2dF current_offset
= layer_impl
->TotalScrollOffset();
2395 gfx::Vector2dF target_offset
= current_offset
+ pending_delta
;
2396 target_offset
.SetToMax(gfx::Vector2dF());
2397 target_offset
.SetToMin(layer_impl
->MaxScrollOffset());
2398 gfx::Vector2dF actual_delta
= target_offset
- current_offset
;
2400 const float kEpsilon
= 0.1f
;
2401 bool can_layer_scroll
= (std::abs(actual_delta
.x()) > kEpsilon
||
2402 std::abs(actual_delta
.y()) > kEpsilon
);
2404 if (!can_layer_scroll
) {
2405 layer_impl
->ScrollBy(actual_delta
);
2406 pending_delta
-= actual_delta
;
2410 active_tree_
->SetCurrentlyScrollingLayer(layer_impl
);
2412 scoped_ptr
<ScrollOffsetAnimationCurve
> curve
=
2413 ScrollOffsetAnimationCurve::Create(target_offset
,
2414 EaseInOutTimingFunction::Create());
2415 curve
->SetInitialValue(current_offset
);
2417 scoped_ptr
<Animation
> animation
=
2418 Animation::Create(curve
.PassAs
<AnimationCurve
>(),
2419 AnimationIdProvider::NextAnimationId(),
2420 AnimationIdProvider::NextGroupId(),
2421 Animation::ScrollOffset
);
2422 animation
->set_is_impl_only(true);
2424 layer_impl
->layer_animation_controller()->AddAnimation(animation
.Pass());
2427 return ScrollStarted
;
2431 return scroll_status
;
2434 gfx::Vector2dF
LayerTreeHostImpl::ScrollLayerWithViewportSpaceDelta(
2435 LayerImpl
* layer_impl
,
2436 float scale_from_viewport_to_screen_space
,
2437 const gfx::PointF
& viewport_point
,
2438 const gfx::Vector2dF
& viewport_delta
) {
2439 // Layers with non-invertible screen space transforms should not have passed
2440 // the scroll hit test in the first place.
2441 DCHECK(layer_impl
->screen_space_transform().IsInvertible());
2442 gfx::Transform
inverse_screen_space_transform(
2443 gfx::Transform::kSkipInitialization
);
2444 bool did_invert
= layer_impl
->screen_space_transform().GetInverse(
2445 &inverse_screen_space_transform
);
2446 // TODO(shawnsingh): With the advent of impl-side crolling for non-root
2447 // layers, we may need to explicitly handle uninvertible transforms here.
2450 gfx::PointF screen_space_point
=
2451 gfx::ScalePoint(viewport_point
, scale_from_viewport_to_screen_space
);
2453 gfx::Vector2dF screen_space_delta
= viewport_delta
;
2454 screen_space_delta
.Scale(scale_from_viewport_to_screen_space
);
2456 // First project the scroll start and end points to local layer space to find
2457 // the scroll delta in layer coordinates.
2458 bool start_clipped
, end_clipped
;
2459 gfx::PointF screen_space_end_point
= screen_space_point
+ screen_space_delta
;
2460 gfx::PointF local_start_point
=
2461 MathUtil::ProjectPoint(inverse_screen_space_transform
,
2464 gfx::PointF local_end_point
=
2465 MathUtil::ProjectPoint(inverse_screen_space_transform
,
2466 screen_space_end_point
,
2469 // In general scroll point coordinates should not get clipped.
2470 DCHECK(!start_clipped
);
2471 DCHECK(!end_clipped
);
2472 if (start_clipped
|| end_clipped
)
2473 return gfx::Vector2dF();
2475 // local_start_point and local_end_point are in content space but we want to
2476 // move them to layer space for scrolling.
2477 float width_scale
= 1.f
/ layer_impl
->contents_scale_x();
2478 float height_scale
= 1.f
/ layer_impl
->contents_scale_y();
2479 local_start_point
.Scale(width_scale
, height_scale
);
2480 local_end_point
.Scale(width_scale
, height_scale
);
2482 // Apply the scroll delta.
2483 gfx::Vector2dF previous_delta
= layer_impl
->ScrollDelta();
2484 layer_impl
->ScrollBy(local_end_point
- local_start_point
);
2486 // Get the end point in the layer's content space so we can apply its
2487 // ScreenSpaceTransform.
2488 gfx::PointF actual_local_end_point
= local_start_point
+
2489 layer_impl
->ScrollDelta() -
2491 gfx::PointF actual_local_content_end_point
=
2492 gfx::ScalePoint(actual_local_end_point
,
2494 1.f
/ height_scale
);
2496 // Calculate the applied scroll delta in viewport space coordinates.
2497 gfx::PointF actual_screen_space_end_point
=
2498 MathUtil::MapPoint(layer_impl
->screen_space_transform(),
2499 actual_local_content_end_point
,
2501 DCHECK(!end_clipped
);
2503 return gfx::Vector2dF();
2504 gfx::PointF actual_viewport_end_point
=
2505 gfx::ScalePoint(actual_screen_space_end_point
,
2506 1.f
/ scale_from_viewport_to_screen_space
);
2507 return actual_viewport_end_point
- viewport_point
;
2510 static gfx::Vector2dF
ScrollLayerWithLocalDelta(LayerImpl
* layer_impl
,
2511 const gfx::Vector2dF
& local_delta
) {
2512 gfx::Vector2dF
previous_delta(layer_impl
->ScrollDelta());
2513 layer_impl
->ScrollBy(local_delta
);
2514 return layer_impl
->ScrollDelta() - previous_delta
;
2517 bool LayerTreeHostImpl::ScrollBy(const gfx::Point
& viewport_point
,
2518 const gfx::Vector2dF
& scroll_delta
) {
2519 TRACE_EVENT0("cc", "LayerTreeHostImpl::ScrollBy");
2520 if (!CurrentlyScrollingLayer())
2523 gfx::Vector2dF pending_delta
= scroll_delta
;
2524 gfx::Vector2dF unused_root_delta
;
2525 bool did_scroll_x
= false;
2526 bool did_scroll_y
= false;
2527 bool did_scroll_top_controls
= false;
2528 // TODO(wjmaclean) Should we guard against CurrentlyScrollingLayer() == 0
2530 bool consume_by_top_controls
=
2531 top_controls_manager_
&&
2532 (((CurrentlyScrollingLayer() == InnerViewportScrollLayer() ||
2533 CurrentlyScrollingLayer() == OuterViewportScrollLayer()) &&
2534 InnerViewportScrollLayer()->MaxScrollOffset().y() > 0) ||
2535 scroll_delta
.y() < 0);
2537 for (LayerImpl
* layer_impl
= CurrentlyScrollingLayer();
2539 layer_impl
= layer_impl
->parent()) {
2540 if (!layer_impl
->scrollable())
2543 if (layer_impl
== InnerViewportScrollLayer()) {
2544 // Only allow bubble scrolling when the scroll is in the direction to make
2545 // the top controls visible.
2546 gfx::Vector2dF applied_delta
;
2547 gfx::Vector2dF excess_delta
;
2548 if (consume_by_top_controls
) {
2549 excess_delta
= top_controls_manager_
->ScrollBy(pending_delta
);
2550 applied_delta
= pending_delta
- excess_delta
;
2551 pending_delta
= excess_delta
;
2552 // Force updating of vertical adjust values if needed.
2553 if (applied_delta
.y() != 0) {
2554 did_scroll_top_controls
= true;
2555 layer_impl
->ScrollbarParametersDidChange();
2558 // Track root layer deltas for reporting overscroll.
2559 unused_root_delta
= pending_delta
;
2562 gfx::Vector2dF applied_delta
;
2563 // Gesture events need to be transformed from viewport coordinates to local
2564 // layer coordinates so that the scrolling contents exactly follow the
2565 // user's finger. In contrast, wheel events represent a fixed amount of
2566 // scrolling so we can just apply them directly.
2567 if (!wheel_scrolling_
) {
2568 float scale_from_viewport_to_screen_space
= device_scale_factor_
;
2570 ScrollLayerWithViewportSpaceDelta(layer_impl
,
2571 scale_from_viewport_to_screen_space
,
2572 viewport_point
, pending_delta
);
2574 applied_delta
= ScrollLayerWithLocalDelta(layer_impl
, pending_delta
);
2577 const float kEpsilon
= 0.1f
;
2578 if (layer_impl
== InnerViewportScrollLayer()) {
2579 unused_root_delta
.Subtract(applied_delta
);
2580 if (std::abs(unused_root_delta
.x()) < kEpsilon
)
2581 unused_root_delta
.set_x(0.0f
);
2582 if (std::abs(unused_root_delta
.y()) < kEpsilon
)
2583 unused_root_delta
.set_y(0.0f
);
2584 // Disable overscroll on axes which is impossible to scroll.
2585 if (settings_
.report_overscroll_only_for_scrollable_axes
) {
2586 if (std::abs(active_tree_
->TotalMaxScrollOffset().x()) <= kEpsilon
)
2587 unused_root_delta
.set_x(0.0f
);
2588 if (std::abs(active_tree_
->TotalMaxScrollOffset().y()) <= kEpsilon
)
2589 unused_root_delta
.set_y(0.0f
);
2593 // If the layer wasn't able to move, try the next one in the hierarchy.
2594 bool did_move_layer_x
= std::abs(applied_delta
.x()) > kEpsilon
;
2595 bool did_move_layer_y
= std::abs(applied_delta
.y()) > kEpsilon
;
2596 did_scroll_x
|= did_move_layer_x
;
2597 did_scroll_y
|= did_move_layer_y
;
2598 if (!did_move_layer_x
&& !did_move_layer_y
) {
2599 // Scrolls should always bubble between the outer and inner viewports
2600 if (should_bubble_scrolls_
|| !did_lock_scrolling_layer_
||
2601 layer_impl
== OuterViewportScrollLayer())
2607 did_lock_scrolling_layer_
= true;
2608 if (!should_bubble_scrolls_
) {
2609 active_tree_
->SetCurrentlyScrollingLayer(layer_impl
);
2613 // If the applied delta is within 45 degrees of the input delta, bail out to
2614 // make it easier to scroll just one layer in one direction without
2615 // affecting any of its parents.
2616 float angle_threshold
= 45;
2617 if (MathUtil::SmallestAngleBetweenVectors(
2618 applied_delta
, pending_delta
) < angle_threshold
) {
2619 pending_delta
= gfx::Vector2d();
2623 // Allow further movement only on an axis perpendicular to the direction in
2624 // which the layer moved.
2625 gfx::Vector2dF
perpendicular_axis(-applied_delta
.y(), applied_delta
.x());
2626 pending_delta
= MathUtil::ProjectVector(pending_delta
, perpendicular_axis
);
2628 if (gfx::ToRoundedVector2d(pending_delta
).IsZero())
2632 bool did_scroll_content
= did_scroll_x
|| did_scroll_y
;
2633 if (did_scroll_content
) {
2634 // If we are scrolling with an active scroll handler, forward latency
2635 // tracking information to the main thread so the delay introduced by the
2636 // handler is accounted for.
2637 if (scroll_affects_scroll_handler())
2638 NotifySwapPromiseMonitorsOfForwardingToMainThread();
2639 client_
->SetNeedsCommitOnImplThread();
2641 client_
->RenewTreePriority();
2644 // Scrolling along an axis resets accumulated root overscroll for that axis.
2646 accumulated_root_overscroll_
.set_x(0);
2648 accumulated_root_overscroll_
.set_y(0);
2650 accumulated_root_overscroll_
+= unused_root_delta
;
2651 bool did_overscroll
= !unused_root_delta
.IsZero();
2652 if (did_overscroll
&& input_handler_client_
) {
2653 input_handler_client_
->DidOverscroll(
2654 viewport_point
, accumulated_root_overscroll_
, unused_root_delta
);
2657 return did_scroll_content
|| did_scroll_top_controls
;
2660 // This implements scrolling by page as described here:
2661 // http://msdn.microsoft.com/en-us/library/windows/desktop/ms645601(v=vs.85).aspx#_win32_The_Mouse_Wheel
2662 // for events with WHEEL_PAGESCROLL set.
2663 bool LayerTreeHostImpl::ScrollVerticallyByPage(const gfx::Point
& viewport_point
,
2664 ScrollDirection direction
) {
2665 DCHECK(wheel_scrolling_
);
2667 for (LayerImpl
* layer_impl
= CurrentlyScrollingLayer();
2669 layer_impl
= layer_impl
->parent()) {
2670 if (!layer_impl
->scrollable())
2673 if (!layer_impl
->HasScrollbar(VERTICAL
))
2676 float height
= layer_impl
->clip_height();
2678 // These magical values match WebKit and are designed to scroll nearly the
2679 // entire visible content height but leave a bit of overlap.
2680 float page
= std::max(height
* 0.875f
, 1.f
);
2681 if (direction
== SCROLL_BACKWARD
)
2684 gfx::Vector2dF delta
= gfx::Vector2dF(0.f
, page
);
2686 gfx::Vector2dF applied_delta
= ScrollLayerWithLocalDelta(layer_impl
, delta
);
2688 if (!applied_delta
.IsZero()) {
2689 client_
->SetNeedsCommitOnImplThread();
2691 client_
->RenewTreePriority();
2695 active_tree_
->SetCurrentlyScrollingLayer(layer_impl
);
2701 void LayerTreeHostImpl::SetRootLayerScrollOffsetDelegate(
2702 LayerScrollOffsetDelegate
* root_layer_scroll_offset_delegate
) {
2703 root_layer_scroll_offset_delegate_
= root_layer_scroll_offset_delegate
;
2704 active_tree_
->SetRootLayerScrollOffsetDelegate(
2705 root_layer_scroll_offset_delegate_
);
2708 void LayerTreeHostImpl::OnRootLayerDelegatedScrollOffsetChanged() {
2709 DCHECK(root_layer_scroll_offset_delegate_
!= NULL
);
2710 client_
->SetNeedsCommitOnImplThread();
2711 active_tree_
->set_needs_update_draw_properties();
2714 void LayerTreeHostImpl::ClearCurrentlyScrollingLayer() {
2715 active_tree_
->ClearCurrentlyScrollingLayer();
2716 did_lock_scrolling_layer_
= false;
2717 scroll_affects_scroll_handler_
= false;
2718 accumulated_root_overscroll_
= gfx::Vector2dF();
2721 void LayerTreeHostImpl::ScrollEnd() {
2722 if (top_controls_manager_
)
2723 top_controls_manager_
->ScrollEnd();
2724 ClearCurrentlyScrollingLayer();
2727 InputHandler::ScrollStatus
LayerTreeHostImpl::FlingScrollBegin() {
2728 if (!active_tree_
->CurrentlyScrollingLayer())
2729 return ScrollIgnored
;
2731 if (settings_
.ignore_root_layer_flings
&&
2732 (active_tree_
->CurrentlyScrollingLayer() == InnerViewportScrollLayer() ||
2733 active_tree_
->CurrentlyScrollingLayer() == OuterViewportScrollLayer())) {
2734 ClearCurrentlyScrollingLayer();
2735 return ScrollIgnored
;
2738 if (!wheel_scrolling_
) {
2739 // Allow the fling to lock to the first layer that moves after the initial
2740 // fling |ScrollBy()| event.
2741 did_lock_scrolling_layer_
= false;
2742 should_bubble_scrolls_
= false;
2745 return ScrollStarted
;
2748 float LayerTreeHostImpl::DeviceSpaceDistanceToLayer(
2749 const gfx::PointF
& device_viewport_point
,
2750 LayerImpl
* layer_impl
) {
2752 return std::numeric_limits
<float>::max();
2754 gfx::Rect
layer_impl_bounds(
2755 layer_impl
->content_bounds());
2757 gfx::RectF device_viewport_layer_impl_bounds
= MathUtil::MapClippedRect(
2758 layer_impl
->screen_space_transform(),
2761 return device_viewport_layer_impl_bounds
.ManhattanDistanceToPoint(
2762 device_viewport_point
);
2765 void LayerTreeHostImpl::MouseMoveAt(const gfx::Point
& viewport_point
) {
2766 gfx::PointF device_viewport_point
= gfx::ScalePoint(viewport_point
,
2767 device_scale_factor_
);
2768 LayerImpl
* layer_impl
=
2769 active_tree_
->FindLayerThatIsHitByPoint(device_viewport_point
);
2770 if (HandleMouseOverScrollbar(layer_impl
, device_viewport_point
))
2773 if (scroll_layer_id_when_mouse_over_scrollbar_
) {
2774 LayerImpl
* scroll_layer_impl
= active_tree_
->LayerById(
2775 scroll_layer_id_when_mouse_over_scrollbar_
);
2777 // The check for a null scroll_layer_impl below was added to see if it will
2778 // eliminate the crashes described in http://crbug.com/326635.
2779 // TODO(wjmaclean) Add a unit test if this fixes the crashes.
2780 ScrollbarAnimationController
* animation_controller
=
2781 scroll_layer_impl
? scroll_layer_impl
->scrollbar_animation_controller()
2783 if (animation_controller
)
2784 animation_controller
->DidMouseMoveOffScrollbar();
2785 scroll_layer_id_when_mouse_over_scrollbar_
= 0;
2788 bool scroll_on_main_thread
= false;
2789 LayerImpl
* scroll_layer_impl
=
2790 FindScrollLayerForDeviceViewportPoint(device_viewport_point
,
2791 InputHandler::Gesture
,
2793 &scroll_on_main_thread
,
2795 if (scroll_on_main_thread
|| !scroll_layer_impl
)
2798 ScrollbarAnimationController
* animation_controller
=
2799 scroll_layer_impl
->scrollbar_animation_controller();
2800 if (!animation_controller
)
2803 // TODO(wjmaclean) Is it ok to choose distance from more than two scrollbars?
2804 float distance_to_scrollbar
= std::numeric_limits
<float>::max();
2805 for (LayerImpl::ScrollbarSet::iterator it
=
2806 scroll_layer_impl
->scrollbars()->begin();
2807 it
!= scroll_layer_impl
->scrollbars()->end();
2809 distance_to_scrollbar
=
2810 std::min(distance_to_scrollbar
,
2811 DeviceSpaceDistanceToLayer(device_viewport_point
, *it
));
2813 animation_controller
->DidMouseMoveNear(distance_to_scrollbar
/
2814 device_scale_factor_
);
2817 bool LayerTreeHostImpl::HandleMouseOverScrollbar(LayerImpl
* layer_impl
,
2818 const gfx::PointF
& device_viewport_point
) {
2819 if (layer_impl
&& layer_impl
->ToScrollbarLayer()) {
2820 int scroll_layer_id
= layer_impl
->ToScrollbarLayer()->ScrollLayerId();
2821 layer_impl
= active_tree_
->LayerById(scroll_layer_id
);
2822 if (layer_impl
&& layer_impl
->scrollbar_animation_controller()) {
2823 scroll_layer_id_when_mouse_over_scrollbar_
= scroll_layer_id
;
2824 layer_impl
->scrollbar_animation_controller()->DidMouseMoveNear(0);
2826 scroll_layer_id_when_mouse_over_scrollbar_
= 0;
2835 void LayerTreeHostImpl::PinchGestureBegin() {
2836 pinch_gesture_active_
= true;
2837 previous_pinch_anchor_
= gfx::Point();
2838 client_
->RenewTreePriority();
2839 pinch_gesture_end_should_clear_scrolling_layer_
= !CurrentlyScrollingLayer();
2840 if (active_tree_
->OuterViewportScrollLayer()) {
2841 active_tree_
->SetCurrentlyScrollingLayer(
2842 active_tree_
->OuterViewportScrollLayer());
2844 active_tree_
->SetCurrentlyScrollingLayer(
2845 active_tree_
->InnerViewportScrollLayer());
2847 if (top_controls_manager_
)
2848 top_controls_manager_
->PinchBegin();
2851 void LayerTreeHostImpl::PinchGestureUpdate(float magnify_delta
,
2852 const gfx::Point
& anchor
) {
2853 if (!InnerViewportScrollLayer())
2856 TRACE_EVENT0("cc", "LayerTreeHostImpl::PinchGestureUpdate");
2858 // For a moment the scroll offset ends up being outside of the max range. This
2859 // confuses the delegate so we switch it off till after we're done processing
2860 // the pinch update.
2861 active_tree_
->SetRootLayerScrollOffsetDelegate(NULL
);
2863 // Keep the center-of-pinch anchor specified by (x, y) in a stable
2864 // position over the course of the magnify.
2865 float page_scale_delta
= active_tree_
->page_scale_delta();
2866 gfx::PointF previous_scale_anchor
=
2867 gfx::ScalePoint(anchor
, 1.f
/ page_scale_delta
);
2868 active_tree_
->SetPageScaleDelta(page_scale_delta
* magnify_delta
);
2869 page_scale_delta
= active_tree_
->page_scale_delta();
2870 gfx::PointF new_scale_anchor
=
2871 gfx::ScalePoint(anchor
, 1.f
/ page_scale_delta
);
2872 gfx::Vector2dF move
= previous_scale_anchor
- new_scale_anchor
;
2874 previous_pinch_anchor_
= anchor
;
2876 move
.Scale(1 / active_tree_
->page_scale_factor());
2877 // If clamping the inner viewport scroll offset causes a change, it should
2878 // be accounted for from the intended move.
2879 move
-= InnerViewportScrollLayer()->ClampScrollToMaxScrollOffset();
2881 // We manually manage the bubbling behaviour here as it is different to that
2882 // implemented in LayerTreeHostImpl::ScrollBy(). Specifically:
2883 // 1) we want to explicit limit the bubbling to the outer/inner viewports,
2884 // 2) we don't want the directional limitations on the unused parts that
2885 // ScrollBy() implements, and
2886 // 3) pinching should not engage the top controls manager.
2887 gfx::Vector2dF unused
= OuterViewportScrollLayer()
2888 ? OuterViewportScrollLayer()->ScrollBy(move
)
2891 if (!unused
.IsZero()) {
2892 InnerViewportScrollLayer()->ScrollBy(unused
);
2893 InnerViewportScrollLayer()->ClampScrollToMaxScrollOffset();
2896 active_tree_
->SetRootLayerScrollOffsetDelegate(
2897 root_layer_scroll_offset_delegate_
);
2899 client_
->SetNeedsCommitOnImplThread();
2901 client_
->RenewTreePriority();
2904 void LayerTreeHostImpl::PinchGestureEnd() {
2905 pinch_gesture_active_
= false;
2906 if (pinch_gesture_end_should_clear_scrolling_layer_
) {
2907 pinch_gesture_end_should_clear_scrolling_layer_
= false;
2908 ClearCurrentlyScrollingLayer();
2910 if (top_controls_manager_
)
2911 top_controls_manager_
->PinchEnd();
2912 client_
->SetNeedsCommitOnImplThread();
2915 static void CollectScrollDeltas(ScrollAndScaleSet
* scroll_info
,
2916 LayerImpl
* layer_impl
) {
2920 gfx::Vector2d scroll_delta
=
2921 gfx::ToFlooredVector2d(layer_impl
->ScrollDelta());
2922 if (!scroll_delta
.IsZero()) {
2923 LayerTreeHostCommon::ScrollUpdateInfo scroll
;
2924 scroll
.layer_id
= layer_impl
->id();
2925 scroll
.scroll_delta
= scroll_delta
;
2926 scroll_info
->scrolls
.push_back(scroll
);
2927 layer_impl
->SetSentScrollDelta(scroll_delta
);
2930 for (size_t i
= 0; i
< layer_impl
->children().size(); ++i
)
2931 CollectScrollDeltas(scroll_info
, layer_impl
->children()[i
]);
2934 scoped_ptr
<ScrollAndScaleSet
> LayerTreeHostImpl::ProcessScrollDeltas() {
2935 scoped_ptr
<ScrollAndScaleSet
> scroll_info(new ScrollAndScaleSet());
2937 CollectScrollDeltas(scroll_info
.get(), active_tree_
->root_layer());
2938 scroll_info
->page_scale_delta
= active_tree_
->page_scale_delta();
2939 active_tree_
->set_sent_page_scale_delta(scroll_info
->page_scale_delta
);
2940 scroll_info
->swap_promises
.swap(swap_promises_for_main_thread_scroll_update_
);
2941 scroll_info
->top_controls_delta
= active_tree()->top_controls_delta();
2942 active_tree_
->set_sent_top_controls_delta(scroll_info
->top_controls_delta
);
2944 return scroll_info
.Pass();
2947 void LayerTreeHostImpl::SetFullRootLayerDamage() {
2948 SetViewportDamage(gfx::Rect(DrawViewportSize()));
2951 void LayerTreeHostImpl::ScrollViewportBy(gfx::Vector2dF scroll_delta
) {
2952 DCHECK(InnerViewportScrollLayer());
2953 LayerImpl
* scroll_layer
= OuterViewportScrollLayer()
2954 ? OuterViewportScrollLayer()
2955 : InnerViewportScrollLayer();
2957 gfx::Vector2dF unused_delta
= scroll_layer
->ScrollBy(scroll_delta
);
2959 if (!unused_delta
.IsZero() && (scroll_layer
== OuterViewportScrollLayer()))
2960 InnerViewportScrollLayer()->ScrollBy(unused_delta
);
2963 void LayerTreeHostImpl::AnimatePageScale(base::TimeTicks monotonic_time
) {
2964 if (!page_scale_animation_
)
2967 gfx::Vector2dF scroll_total
= active_tree_
->TotalScrollOffset();
2969 if (!page_scale_animation_
->IsAnimationStarted())
2970 page_scale_animation_
->StartAnimation(monotonic_time
);
2972 active_tree_
->SetPageScaleDelta(
2973 page_scale_animation_
->PageScaleFactorAtTime(monotonic_time
) /
2974 active_tree_
->page_scale_factor());
2975 gfx::Vector2dF next_scroll
=
2976 page_scale_animation_
->ScrollOffsetAtTime(monotonic_time
);
2978 ScrollViewportBy(next_scroll
- scroll_total
);
2981 if (page_scale_animation_
->IsAnimationCompleteAtTime(monotonic_time
)) {
2982 page_scale_animation_
.reset();
2983 client_
->SetNeedsCommitOnImplThread();
2984 client_
->RenewTreePriority();
2990 void LayerTreeHostImpl::AnimateTopControls(base::TimeTicks time
) {
2991 if (!top_controls_manager_
|| !top_controls_manager_
->animation())
2994 gfx::Vector2dF scroll
= top_controls_manager_
->Animate(time
);
2996 if (top_controls_manager_
->animation())
2999 if (active_tree_
->TotalScrollOffset().y() == 0.f
)
3002 if (scroll
.IsZero())
3005 ScrollViewportBy(gfx::ScaleVector2d(
3006 scroll
, 1.f
/ active_tree_
->total_page_scale_factor()));
3008 client_
->SetNeedsCommitOnImplThread();
3009 client_
->RenewTreePriority();
3012 void LayerTreeHostImpl::AnimateLayers(base::TimeTicks monotonic_time
) {
3013 if (!settings_
.accelerated_animation_enabled
||
3014 !needs_animate_layers() ||
3015 !active_tree_
->root_layer())
3018 TRACE_EVENT0("cc", "LayerTreeHostImpl::AnimateLayers");
3019 AnimationRegistrar::AnimationControllerMap copy
=
3020 animation_registrar_
->active_animation_controllers();
3021 for (AnimationRegistrar::AnimationControllerMap::iterator iter
= copy
.begin();
3024 (*iter
).second
->Animate(monotonic_time
);
3029 void LayerTreeHostImpl::UpdateAnimationState(bool start_ready_animations
) {
3030 if (!settings_
.accelerated_animation_enabled
||
3031 !needs_animate_layers() ||
3032 !active_tree_
->root_layer())
3035 TRACE_EVENT0("cc", "LayerTreeHostImpl::UpdateAnimationState");
3036 scoped_ptr
<AnimationEventsVector
> events
=
3037 make_scoped_ptr(new AnimationEventsVector
);
3038 AnimationRegistrar::AnimationControllerMap copy
=
3039 animation_registrar_
->active_animation_controllers();
3040 for (AnimationRegistrar::AnimationControllerMap::iterator iter
= copy
.begin();
3043 (*iter
).second
->UpdateState(start_ready_animations
, events
.get());
3045 if (!events
->empty()) {
3046 client_
->PostAnimationEventsToMainThreadOnImplThread(events
.Pass());
3052 void LayerTreeHostImpl::ActivateAnimations() {
3053 if (!settings_
.accelerated_animation_enabled
|| !needs_animate_layers() ||
3054 !active_tree_
->root_layer())
3057 TRACE_EVENT0("cc", "LayerTreeHostImpl::ActivateAnimations");
3058 AnimationRegistrar::AnimationControllerMap copy
=
3059 animation_registrar_
->active_animation_controllers();
3060 for (AnimationRegistrar::AnimationControllerMap::iterator iter
= copy
.begin();
3063 (*iter
).second
->ActivateAnimations();
3066 base::TimeDelta
LayerTreeHostImpl::LowFrequencyAnimationInterval() const {
3067 return base::TimeDelta::FromSeconds(1);
3070 std::string
LayerTreeHostImpl::LayerTreeAsJson() const {
3072 if (active_tree_
->root_layer()) {
3073 scoped_ptr
<base::Value
> json(active_tree_
->root_layer()->LayerTreeAsJson());
3074 base::JSONWriter::WriteWithOptions(
3075 json
.get(), base::JSONWriter::OPTIONS_PRETTY_PRINT
, &str
);
3080 int LayerTreeHostImpl::SourceAnimationFrameNumber() const {
3081 return fps_counter_
->current_frame_number();
3084 void LayerTreeHostImpl::AnimateScrollbars(base::TimeTicks time
) {
3085 AnimateScrollbarsRecursive(active_tree_
->root_layer(), time
);
3088 void LayerTreeHostImpl::AnimateScrollbarsRecursive(LayerImpl
* layer
,
3089 base::TimeTicks time
) {
3093 ScrollbarAnimationController
* scrollbar_controller
=
3094 layer
->scrollbar_animation_controller();
3095 if (scrollbar_controller
)
3096 scrollbar_controller
->Animate(time
);
3098 for (size_t i
= 0; i
< layer
->children().size(); ++i
)
3099 AnimateScrollbarsRecursive(layer
->children()[i
], time
);
3102 void LayerTreeHostImpl::PostDelayedScrollbarFade(
3103 const base::Closure
& start_fade
,
3104 base::TimeDelta delay
) {
3105 client_
->PostDelayedScrollbarFadeOnImplThread(start_fade
, delay
);
3108 void LayerTreeHostImpl::SetNeedsScrollbarAnimationFrame() {
3109 TRACE_EVENT_INSTANT0(
3111 "LayerTreeHostImpl::SetNeedsRedraw due to scrollbar fade",
3112 TRACE_EVENT_SCOPE_THREAD
);
3116 void LayerTreeHostImpl::SetTreePriority(TreePriority priority
) {
3120 if (global_tile_state_
.tree_priority
== priority
)
3122 global_tile_state_
.tree_priority
= priority
;
3123 DidModifyTilePriorities();
3126 void LayerTreeHostImpl::UpdateCurrentBeginFrameArgs(
3127 const BeginFrameArgs
& args
) {
3128 DCHECK(!current_begin_frame_args_
.IsValid());
3129 current_begin_frame_args_
= args
;
3130 // TODO(skyostil): Stop overriding the frame time once the usage of frame
3131 // timing is unified.
3132 current_begin_frame_args_
.frame_time
= gfx::FrameTime::Now();
3135 void LayerTreeHostImpl::ResetCurrentBeginFrameArgsForNextFrame() {
3136 current_begin_frame_args_
= BeginFrameArgs();
3139 BeginFrameArgs
LayerTreeHostImpl::CurrentBeginFrameArgs() const {
3140 // Try to use the current frame time to keep animations non-jittery. But if
3141 // we're not in a frame (because this is during an input event or a delayed
3142 // task), fall back to physical time. This should still be monotonic.
3143 if (current_begin_frame_args_
.IsValid())
3144 return current_begin_frame_args_
;
3145 return BeginFrameArgs::Create(gfx::FrameTime::Now(),
3147 BeginFrameArgs::DefaultInterval());
3150 scoped_refptr
<base::debug::ConvertableToTraceFormat
>
3151 LayerTreeHostImpl::AsValue() const {
3152 return AsValueWithFrame(NULL
);
3155 scoped_refptr
<base::debug::ConvertableToTraceFormat
>
3156 LayerTreeHostImpl::AsValueWithFrame(FrameData
* frame
) const {
3157 scoped_refptr
<base::debug::TracedValue
> state
=
3158 new base::debug::TracedValue();
3159 AsValueWithFrameInto(frame
, state
.get());
3163 void LayerTreeHostImpl::AsValueWithFrameInto(
3165 base::debug::TracedValue
* state
) const {
3166 if (this->pending_tree_
) {
3167 state
->BeginDictionary("activation_state");
3168 ActivationStateAsValueInto(state
);
3169 state
->EndDictionary();
3171 state
->BeginDictionary("device_viewport_size");
3172 MathUtil::AddToTracedValue(device_viewport_size_
, state
);
3173 state
->EndDictionary();
3175 std::set
<const Tile
*> tiles
;
3176 active_tree_
->GetAllTilesForTracing(&tiles
);
3178 pending_tree_
->GetAllTilesForTracing(&tiles
);
3180 state
->BeginArray("active_tiles");
3181 for (std::set
<const Tile
*>::const_iterator it
= tiles
.begin();
3184 const Tile
* tile
= *it
;
3186 state
->BeginDictionary();
3187 tile
->AsValueInto(state
);
3188 state
->EndDictionary();
3192 if (tile_manager_
) {
3193 state
->BeginDictionary("tile_manager_basic_state");
3194 tile_manager_
->BasicStateAsValueInto(state
);
3195 state
->EndDictionary();
3197 state
->BeginDictionary("active_tree");
3198 active_tree_
->AsValueInto(state
);
3199 state
->EndDictionary();
3200 if (pending_tree_
) {
3201 state
->BeginDictionary("pending_tree");
3202 pending_tree_
->AsValueInto(state
);
3203 state
->EndDictionary();
3206 state
->BeginDictionary("frame");
3207 frame
->AsValueInto(state
);
3208 state
->EndDictionary();
3212 scoped_refptr
<base::debug::ConvertableToTraceFormat
>
3213 LayerTreeHostImpl::ActivationStateAsValue() const {
3214 scoped_refptr
<base::debug::TracedValue
> state
=
3215 new base::debug::TracedValue();
3216 ActivationStateAsValueInto(state
.get());
3220 void LayerTreeHostImpl::ActivationStateAsValueInto(
3221 base::debug::TracedValue
* state
) const {
3222 TracedValue::SetIDRef(this, state
, "lthi");
3223 if (tile_manager_
) {
3224 state
->BeginDictionary("tile_manager");
3225 tile_manager_
->BasicStateAsValueInto(state
);
3226 state
->EndDictionary();
3230 void LayerTreeHostImpl::SetDebugState(
3231 const LayerTreeDebugState
& new_debug_state
) {
3232 if (LayerTreeDebugState::Equal(debug_state_
, new_debug_state
))
3234 if (debug_state_
.continuous_painting
!= new_debug_state
.continuous_painting
)
3235 paint_time_counter_
->ClearHistory();
3237 debug_state_
= new_debug_state
;
3238 UpdateTileManagerMemoryPolicy(ActualManagedMemoryPolicy());
3239 SetFullRootLayerDamage();
3242 void LayerTreeHostImpl::CreateUIResource(UIResourceId uid
,
3243 const UIResourceBitmap
& bitmap
) {
3246 GLint wrap_mode
= 0;
3247 switch (bitmap
.GetWrapMode()) {
3248 case UIResourceBitmap::CLAMP_TO_EDGE
:
3249 wrap_mode
= GL_CLAMP_TO_EDGE
;
3251 case UIResourceBitmap::REPEAT
:
3252 wrap_mode
= GL_REPEAT
;
3256 // Allow for multiple creation requests with the same UIResourceId. The
3257 // previous resource is simply deleted.
3258 ResourceProvider::ResourceId id
= ResourceIdForUIResource(uid
);
3260 DeleteUIResource(uid
);
3262 ResourceFormat format
= resource_provider_
->best_texture_format();
3263 switch (bitmap
.GetFormat()) {
3264 case UIResourceBitmap::RGBA8
:
3266 case UIResourceBitmap::ALPHA_8
:
3269 case UIResourceBitmap::ETC1
:
3274 resource_provider_
->CreateResource(bitmap
.GetSize(),
3276 ResourceProvider::TextureHintImmutable
,
3279 UIResourceData data
;
3280 data
.resource_id
= id
;
3281 data
.size
= bitmap
.GetSize();
3282 data
.opaque
= bitmap
.GetOpaque();
3284 ui_resource_map_
[uid
] = data
;
3286 AutoLockUIResourceBitmap
bitmap_lock(bitmap
);
3287 resource_provider_
->SetPixels(id
,
3288 bitmap_lock
.GetPixels(),
3289 gfx::Rect(bitmap
.GetSize()),
3290 gfx::Rect(bitmap
.GetSize()),
3291 gfx::Vector2d(0, 0));
3292 MarkUIResourceNotEvicted(uid
);
3295 void LayerTreeHostImpl::DeleteUIResource(UIResourceId uid
) {
3296 ResourceProvider::ResourceId id
= ResourceIdForUIResource(uid
);
3298 resource_provider_
->DeleteResource(id
);
3299 ui_resource_map_
.erase(uid
);
3301 MarkUIResourceNotEvicted(uid
);
3304 void LayerTreeHostImpl::EvictAllUIResources() {
3305 if (ui_resource_map_
.empty())
3308 for (UIResourceMap::const_iterator iter
= ui_resource_map_
.begin();
3309 iter
!= ui_resource_map_
.end();
3311 evicted_ui_resources_
.insert(iter
->first
);
3312 resource_provider_
->DeleteResource(iter
->second
.resource_id
);
3314 ui_resource_map_
.clear();
3316 client_
->SetNeedsCommitOnImplThread();
3317 client_
->OnCanDrawStateChanged(CanDraw());
3318 client_
->RenewTreePriority();
3321 ResourceProvider::ResourceId
LayerTreeHostImpl::ResourceIdForUIResource(
3322 UIResourceId uid
) const {
3323 UIResourceMap::const_iterator iter
= ui_resource_map_
.find(uid
);
3324 if (iter
!= ui_resource_map_
.end())
3325 return iter
->second
.resource_id
;
3329 bool LayerTreeHostImpl::IsUIResourceOpaque(UIResourceId uid
) const {
3330 UIResourceMap::const_iterator iter
= ui_resource_map_
.find(uid
);
3331 DCHECK(iter
!= ui_resource_map_
.end());
3332 return iter
->second
.opaque
;
3335 bool LayerTreeHostImpl::EvictedUIResourcesExist() const {
3336 return !evicted_ui_resources_
.empty();
3339 void LayerTreeHostImpl::MarkUIResourceNotEvicted(UIResourceId uid
) {
3340 std::set
<UIResourceId
>::iterator found_in_evicted
=
3341 evicted_ui_resources_
.find(uid
);
3342 if (found_in_evicted
== evicted_ui_resources_
.end())
3344 evicted_ui_resources_
.erase(found_in_evicted
);
3345 if (evicted_ui_resources_
.empty())
3346 client_
->OnCanDrawStateChanged(CanDraw());
3349 void LayerTreeHostImpl::ScheduleMicroBenchmark(
3350 scoped_ptr
<MicroBenchmarkImpl
> benchmark
) {
3351 micro_benchmark_controller_
.ScheduleRun(benchmark
.Pass());
3354 void LayerTreeHostImpl::InsertSwapPromiseMonitor(SwapPromiseMonitor
* monitor
) {
3355 swap_promise_monitor_
.insert(monitor
);
3358 void LayerTreeHostImpl::RemoveSwapPromiseMonitor(SwapPromiseMonitor
* monitor
) {
3359 swap_promise_monitor_
.erase(monitor
);
3362 void LayerTreeHostImpl::NotifySwapPromiseMonitorsOfSetNeedsRedraw() {
3363 std::set
<SwapPromiseMonitor
*>::iterator it
= swap_promise_monitor_
.begin();
3364 for (; it
!= swap_promise_monitor_
.end(); it
++)
3365 (*it
)->OnSetNeedsRedrawOnImpl();
3368 void LayerTreeHostImpl::NotifySwapPromiseMonitorsOfForwardingToMainThread() {
3369 std::set
<SwapPromiseMonitor
*>::iterator it
= swap_promise_monitor_
.begin();
3370 for (; it
!= swap_promise_monitor_
.end(); it
++)
3371 (*it
)->OnForwardScrollUpdateToMainThreadOnImpl();
3374 void LayerTreeHostImpl::RegisterPictureLayerImpl(PictureLayerImpl
* layer
) {
3375 DCHECK(std::find(picture_layers_
.begin(), picture_layers_
.end(), layer
) ==
3376 picture_layers_
.end());
3377 picture_layers_
.push_back(layer
);
3380 void LayerTreeHostImpl::UnregisterPictureLayerImpl(PictureLayerImpl
* layer
) {
3381 std::vector
<PictureLayerImpl
*>::iterator it
=
3382 std::find(picture_layers_
.begin(), picture_layers_
.end(), layer
);
3383 DCHECK(it
!= picture_layers_
.end());
3384 picture_layers_
.erase(it
);