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/bitmap_raster_worker_pool.h"
50 #include "cc/resources/eviction_tile_priority_queue.h"
51 #include "cc/resources/gpu_raster_worker_pool.h"
52 #include "cc/resources/memory_history.h"
53 #include "cc/resources/one_copy_raster_worker_pool.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/resources/zero_copy_raster_worker_pool.h"
63 #include "cc/scheduler/delay_based_time_source.h"
64 #include "cc/trees/damage_tracker.h"
65 #include "cc/trees/layer_tree_host.h"
66 #include "cc/trees/layer_tree_host_common.h"
67 #include "cc/trees/layer_tree_impl.h"
68 #include "cc/trees/occlusion_tracker.h"
69 #include "cc/trees/single_thread_proxy.h"
70 #include "cc/trees/tree_synchronizer.h"
71 #include "gpu/command_buffer/client/gles2_interface.h"
72 #include "gpu/GLES2/gl2extchromium.h"
73 #include "ui/gfx/frame_time.h"
74 #include "ui/gfx/geometry/rect_conversions.h"
75 #include "ui/gfx/size_conversions.h"
76 #include "ui/gfx/vector2d_conversions.h"
81 void DidVisibilityChange(LayerTreeHostImpl* id, bool visible) {
83 TRACE_EVENT_ASYNC_BEGIN1("webkit",
84 "LayerTreeHostImpl::SetVisible",
91 TRACE_EVENT_ASYNC_END0("webkit", "LayerTreeHostImpl::SetVisible", id);
94 size_t GetMaxTransferBufferUsageBytes(
95 const ContextProvider::Capabilities& context_capabilities,
96 double refresh_rate) {
97 // We want to make sure the default transfer buffer size is equal to the
98 // amount of data that can be uploaded by the compositor to avoid stalling
100 // For reference Chromebook Pixel can upload 1MB in about 0.5ms.
101 const size_t kMaxBytesUploadedPerMs = 1024 * 1024 * 2;
103 // We need to upload at least enough work to keep the GPU process busy until
104 // the next time it can handle a request to start more uploads from the
105 // compositor. We assume that it will pick up any sent upload requests within
106 // the time of a vsync, since the browser will want to swap a frame within
107 // that time interval, and then uploads should have a chance to be processed.
108 size_t ms_per_frame = std::floor(1000.0 / refresh_rate);
109 size_t max_transfer_buffer_usage_bytes =
110 ms_per_frame * kMaxBytesUploadedPerMs;
112 // The context may request a lower limit based on the device capabilities.
113 return std::min(context_capabilities.max_transfer_buffer_usage_bytes,
114 max_transfer_buffer_usage_bytes);
117 unsigned GetMapImageTextureTarget(
118 const ContextProvider::Capabilities& context_capabilities) {
119 if (context_capabilities.gpu.egl_image_external)
120 return GL_TEXTURE_EXTERNAL_OES;
121 if (context_capabilities.gpu.texture_rectangle)
122 return GL_TEXTURE_RECTANGLE_ARB;
124 return GL_TEXTURE_2D;
127 size_t GetMaxStagingResourceCount() {
128 // Upper bound for number of staging resource to allow.
134 class LayerTreeHostImplTimeSourceAdapter : public TimeSourceClient {
136 static scoped_ptr<LayerTreeHostImplTimeSourceAdapter> Create(
137 LayerTreeHostImpl* layer_tree_host_impl,
138 scoped_refptr<DelayBasedTimeSource> time_source) {
139 return make_scoped_ptr(
140 new LayerTreeHostImplTimeSourceAdapter(layer_tree_host_impl,
143 virtual ~LayerTreeHostImplTimeSourceAdapter() {
144 time_source_->SetClient(NULL);
145 time_source_->SetActive(false);
148 virtual void OnTimerTick() OVERRIDE {
149 // In single threaded mode we attempt to simulate changing the current
150 // thread by maintaining a fake thread id. When we switch from one
151 // thread to another, we construct DebugScopedSetXXXThread objects that
152 // update the thread id. This lets DCHECKS that ensure we're on the
153 // right thread to work correctly in single threaded mode. The problem
154 // here is that the timer tasks are run via the message loop, and when
155 // they run, we've had no chance to construct a DebugScopedSetXXXThread
156 // object. The result is that we report that we're running on the main
157 // thread. In multi-threaded mode, this timer is run on the compositor
158 // thread, so to keep this consistent in single-threaded mode, we'll
159 // construct a DebugScopedSetImplThread object. There is no need to do
160 // this in multi-threaded mode since the real thread id's will be
161 // correct. In fact, setting fake thread id's interferes with the real
162 // thread id's and causes breakage.
163 scoped_ptr<DebugScopedSetImplThread> set_impl_thread;
164 if (!layer_tree_host_impl_->proxy()->HasImplThread()) {
165 set_impl_thread.reset(
166 new DebugScopedSetImplThread(layer_tree_host_impl_->proxy()));
169 layer_tree_host_impl_->Animate(
170 layer_tree_host_impl_->CurrentBeginFrameArgs().frame_time);
171 layer_tree_host_impl_->UpdateBackgroundAnimateTicking(true);
172 bool start_ready_animations = true;
173 layer_tree_host_impl_->UpdateAnimationState(start_ready_animations);
175 if (layer_tree_host_impl_->pending_tree()) {
176 layer_tree_host_impl_->pending_tree()->UpdateDrawProperties();
177 layer_tree_host_impl_->ManageTiles();
180 layer_tree_host_impl_->ResetCurrentBeginFrameArgsForNextFrame();
183 void SetActive(bool active) {
184 if (active != time_source_->Active())
185 time_source_->SetActive(active);
188 bool Active() const { return time_source_->Active(); }
191 LayerTreeHostImplTimeSourceAdapter(
192 LayerTreeHostImpl* layer_tree_host_impl,
193 scoped_refptr<DelayBasedTimeSource> time_source)
194 : layer_tree_host_impl_(layer_tree_host_impl),
195 time_source_(time_source) {
196 time_source_->SetClient(this);
199 LayerTreeHostImpl* layer_tree_host_impl_;
200 scoped_refptr<DelayBasedTimeSource> time_source_;
202 DISALLOW_COPY_AND_ASSIGN(LayerTreeHostImplTimeSourceAdapter);
205 LayerTreeHostImpl::FrameData::FrameData()
206 : contains_incomplete_tile(false), has_no_damage(false) {}
208 LayerTreeHostImpl::FrameData::~FrameData() {}
210 scoped_ptr<LayerTreeHostImpl> LayerTreeHostImpl::Create(
211 const LayerTreeSettings& settings,
212 LayerTreeHostImplClient* client,
214 RenderingStatsInstrumentation* rendering_stats_instrumentation,
215 SharedBitmapManager* manager,
217 return make_scoped_ptr(new LayerTreeHostImpl(
218 settings, client, proxy, rendering_stats_instrumentation, manager, id));
221 LayerTreeHostImpl::LayerTreeHostImpl(
222 const LayerTreeSettings& settings,
223 LayerTreeHostImplClient* client,
225 RenderingStatsInstrumentation* rendering_stats_instrumentation,
226 SharedBitmapManager* manager,
230 use_gpu_rasterization_(false),
231 input_handler_client_(NULL),
232 did_lock_scrolling_layer_(false),
233 should_bubble_scrolls_(false),
234 wheel_scrolling_(false),
235 scroll_affects_scroll_handler_(false),
236 scroll_layer_id_when_mouse_over_scrollbar_(0),
237 tile_priorities_dirty_(false),
238 root_layer_scroll_offset_delegate_(NULL),
241 cached_managed_memory_policy_(
242 PrioritizedResourceManager::DefaultMemoryAllocationLimit(),
243 gpu::MemoryAllocation::CUTOFF_ALLOW_EVERYTHING,
244 ManagedMemoryPolicy::kDefaultNumResourcesLimit),
245 pinch_gesture_active_(false),
246 pinch_gesture_end_should_clear_scrolling_layer_(false),
247 fps_counter_(FrameRateCounter::Create(proxy_->HasImplThread())),
248 paint_time_counter_(PaintTimeCounter::Create()),
249 memory_history_(MemoryHistory::Create()),
250 debug_rect_history_(DebugRectHistory::Create()),
251 texture_mailbox_deleter_(new TextureMailboxDeleter(
252 proxy_->HasImplThread() ? proxy_->ImplThreadTaskRunner()
253 : proxy_->MainThreadTaskRunner())),
254 max_memory_needed_bytes_(0),
256 device_scale_factor_(1.f),
257 overhang_ui_resource_id_(0),
258 resourceless_software_draw_(false),
259 begin_impl_frame_interval_(BeginFrameArgs::DefaultInterval()),
260 animation_registrar_(AnimationRegistrar::Create()),
261 rendering_stats_instrumentation_(rendering_stats_instrumentation),
262 micro_benchmark_controller_(this),
263 need_to_update_visible_tiles_before_draw_(false),
264 shared_bitmap_manager_(manager),
266 DCHECK(proxy_->IsImplThread());
267 DidVisibilityChange(this, visible_);
268 animation_registrar_->set_supports_scroll_animations(
269 proxy_->SupportsImplScrolling());
271 SetDebugState(settings.initial_debug_state);
273 // LTHI always has an active tree.
274 active_tree_ = LayerTreeImpl::create(this);
275 TRACE_EVENT_OBJECT_CREATED_WITH_ID(
276 TRACE_DISABLED_BY_DEFAULT("cc.debug"), "cc::LayerTreeHostImpl", id_);
278 if (settings.calculate_top_controls_position) {
279 top_controls_manager_ =
280 TopControlsManager::Create(this,
281 settings.top_controls_height,
282 settings.top_controls_show_threshold,
283 settings.top_controls_hide_threshold);
285 // TODO(bokan): This is a quick fix. The browser should lock the top
286 // controls to shown on creation but this appears not to work. Tracked
287 // in crbug.com/417680.
288 // Initialize with top controls showing.
289 SetControlsTopOffset(0.f);
293 LayerTreeHostImpl::~LayerTreeHostImpl() {
294 DCHECK(proxy_->IsImplThread());
295 TRACE_EVENT0("cc", "LayerTreeHostImpl::~LayerTreeHostImpl()");
296 TRACE_EVENT_OBJECT_DELETED_WITH_ID(
297 TRACE_DISABLED_BY_DEFAULT("cc.debug"), "cc::LayerTreeHostImpl", id_);
299 if (input_handler_client_) {
300 input_handler_client_->WillShutdown();
301 input_handler_client_ = NULL;
304 // The layer trees must be destroyed before the layer tree host. We've
305 // made a contract with our animation controllers that the registrar
306 // will outlive them, and we must make good.
308 recycle_tree_->Shutdown();
310 pending_tree_->Shutdown();
311 active_tree_->Shutdown();
312 recycle_tree_.reset();
313 pending_tree_.reset();
314 active_tree_.reset();
315 DestroyTileManager();
318 void LayerTreeHostImpl::BeginMainFrameAborted(bool did_handle) {
319 // If the begin frame data was handled, then scroll and scale set was applied
320 // by the main thread, so the active tree needs to be updated as if these sent
321 // values were applied and committed.
323 active_tree_->ApplySentScrollAndScaleDeltasFromAbortedCommit();
324 active_tree_->ResetContentsTexturesPurged();
328 void LayerTreeHostImpl::BeginCommit() {
329 TRACE_EVENT0("cc", "LayerTreeHostImpl::BeginCommit");
331 if (UsePendingTreeForSync())
335 void LayerTreeHostImpl::CommitComplete() {
336 TRACE_EVENT0("cc", "LayerTreeHostImpl::CommitComplete");
339 pending_tree_->ApplyScrollDeltasSinceBeginMainFrame();
340 sync_tree()->set_needs_update_draw_properties();
342 if (settings_.impl_side_painting) {
343 // Impl-side painting needs an update immediately post-commit to have the
344 // opportunity to create tilings. Other paths can call UpdateDrawProperties
345 // more lazily when needed prior to drawing.
346 sync_tree()->UpdateDrawProperties();
347 // Start working on newly created tiles immediately if needed.
348 if (tile_manager_ && tile_priorities_dirty_)
351 NotifyReadyToActivate();
353 // If we're not in impl-side painting, the tree is immediately considered
358 micro_benchmark_controller_.DidCompleteCommit();
361 bool LayerTreeHostImpl::CanDraw() const {
362 // Note: If you are changing this function or any other function that might
363 // affect the result of CanDraw, make sure to call
364 // client_->OnCanDrawStateChanged in the proper places and update the
365 // NotifyIfCanDrawChanged test.
368 TRACE_EVENT_INSTANT0("cc", "LayerTreeHostImpl::CanDraw no renderer",
369 TRACE_EVENT_SCOPE_THREAD);
373 // Must have an OutputSurface if |renderer_| is not NULL.
374 DCHECK(output_surface_);
376 // TODO(boliu): Make draws without root_layer work and move this below
377 // draw_and_swap_full_viewport_every_frame check. Tracked in crbug.com/264967.
378 if (!active_tree_->root_layer()) {
379 TRACE_EVENT_INSTANT0("cc", "LayerTreeHostImpl::CanDraw no root layer",
380 TRACE_EVENT_SCOPE_THREAD);
384 if (output_surface_->capabilities().draw_and_swap_full_viewport_every_frame)
387 if (DrawViewportSize().IsEmpty()) {
388 TRACE_EVENT_INSTANT0("cc", "LayerTreeHostImpl::CanDraw empty viewport",
389 TRACE_EVENT_SCOPE_THREAD);
392 if (active_tree_->ViewportSizeInvalid()) {
393 TRACE_EVENT_INSTANT0(
394 "cc", "LayerTreeHostImpl::CanDraw viewport size recently changed",
395 TRACE_EVENT_SCOPE_THREAD);
398 if (active_tree_->ContentsTexturesPurged()) {
399 TRACE_EVENT_INSTANT0(
400 "cc", "LayerTreeHostImpl::CanDraw contents textures purged",
401 TRACE_EVENT_SCOPE_THREAD);
404 if (EvictedUIResourcesExist()) {
405 TRACE_EVENT_INSTANT0(
406 "cc", "LayerTreeHostImpl::CanDraw UI resources evicted not recreated",
407 TRACE_EVENT_SCOPE_THREAD);
413 void LayerTreeHostImpl::Animate(base::TimeTicks monotonic_time) {
414 if (input_handler_client_)
415 input_handler_client_->Animate(monotonic_time);
416 AnimatePageScale(monotonic_time);
417 AnimateLayers(monotonic_time);
418 AnimateScrollbars(monotonic_time);
419 AnimateTopControls(monotonic_time);
422 void LayerTreeHostImpl::ManageTiles() {
425 if (!tile_priorities_dirty_)
428 tile_priorities_dirty_ = false;
429 tile_manager_->ManageTiles(global_tile_state_);
431 client_->DidManageTiles();
434 void LayerTreeHostImpl::StartPageScaleAnimation(
435 const gfx::Vector2d& target_offset,
438 base::TimeDelta duration) {
439 if (!InnerViewportScrollLayer())
442 gfx::Vector2dF scroll_total = active_tree_->TotalScrollOffset();
443 gfx::SizeF scaled_scrollable_size = active_tree_->ScrollableSize();
444 gfx::SizeF viewport_size =
445 active_tree_->InnerViewportContainerLayer()->bounds();
447 // Easing constants experimentally determined.
448 scoped_ptr<TimingFunction> timing_function =
449 CubicBezierTimingFunction::Create(.8, 0, .3, .9).PassAs<TimingFunction>();
451 page_scale_animation_ =
452 PageScaleAnimation::Create(scroll_total,
453 active_tree_->total_page_scale_factor(),
455 scaled_scrollable_size,
456 timing_function.Pass());
459 gfx::Vector2dF anchor(target_offset);
460 page_scale_animation_->ZoomWithAnchor(anchor,
462 duration.InSecondsF());
464 gfx::Vector2dF scaled_target_offset = target_offset;
465 page_scale_animation_->ZoomTo(scaled_target_offset,
467 duration.InSecondsF());
471 client_->SetNeedsCommitOnImplThread();
472 client_->RenewTreePriority();
475 bool LayerTreeHostImpl::IsCurrentlyScrollingLayerAt(
476 const gfx::Point& viewport_point,
477 InputHandler::ScrollInputType type) {
478 if (!CurrentlyScrollingLayer())
481 gfx::PointF device_viewport_point =
482 gfx::ScalePoint(viewport_point, device_scale_factor_);
484 LayerImpl* layer_impl =
485 active_tree_->FindLayerThatIsHitByPoint(device_viewport_point);
487 bool scroll_on_main_thread = false;
488 LayerImpl* scrolling_layer_impl = FindScrollLayerForDeviceViewportPoint(
489 device_viewport_point, type, layer_impl, &scroll_on_main_thread, NULL);
490 return CurrentlyScrollingLayer() == scrolling_layer_impl;
493 bool LayerTreeHostImpl::HaveTouchEventHandlersAt(
494 const gfx::Point& viewport_point) {
496 gfx::PointF device_viewport_point =
497 gfx::ScalePoint(viewport_point, device_scale_factor_);
499 LayerImpl* layer_impl =
500 active_tree_->FindLayerThatIsHitByPointInTouchHandlerRegion(
501 device_viewport_point);
503 return layer_impl != NULL;
506 scoped_ptr<SwapPromiseMonitor>
507 LayerTreeHostImpl::CreateLatencyInfoSwapPromiseMonitor(
508 ui::LatencyInfo* latency) {
509 return scoped_ptr<SwapPromiseMonitor>(
510 new LatencyInfoSwapPromiseMonitor(latency, NULL, this));
513 void LayerTreeHostImpl::QueueSwapPromiseForMainThreadScrollUpdate(
514 scoped_ptr<SwapPromise> swap_promise) {
515 swap_promises_for_main_thread_scroll_update_.push_back(swap_promise.Pass());
518 void LayerTreeHostImpl::TrackDamageForAllSurfaces(
519 LayerImpl* root_draw_layer,
520 const LayerImplList& render_surface_layer_list) {
521 // For now, we use damage tracking to compute a global scissor. To do this, we
522 // must compute all damage tracking before drawing anything, so that we know
523 // the root damage rect. The root damage rect is then used to scissor each
526 for (int surface_index = render_surface_layer_list.size() - 1;
529 LayerImpl* render_surface_layer = render_surface_layer_list[surface_index];
530 RenderSurfaceImpl* render_surface = render_surface_layer->render_surface();
531 DCHECK(render_surface);
532 render_surface->damage_tracker()->UpdateDamageTrackingState(
533 render_surface->layer_list(),
534 render_surface_layer->id(),
535 render_surface->SurfacePropertyChangedOnlyFromDescendant(),
536 render_surface->content_rect(),
537 render_surface_layer->mask_layer(),
538 render_surface_layer->filters());
542 void LayerTreeHostImpl::FrameData::AsValueInto(
543 base::debug::TracedValue* value) const {
544 value->SetBoolean("contains_incomplete_tile", contains_incomplete_tile);
545 value->SetBoolean("has_no_damage", has_no_damage);
547 // Quad data can be quite large, so only dump render passes if we select
550 TRACE_EVENT_CATEGORY_GROUP_ENABLED(
551 TRACE_DISABLED_BY_DEFAULT("cc.debug.quads"), &quads_enabled);
553 value->BeginArray("render_passes");
554 for (size_t i = 0; i < render_passes.size(); ++i) {
555 value->BeginDictionary();
556 render_passes[i]->AsValueInto(value);
557 value->EndDictionary();
563 void LayerTreeHostImpl::FrameData::AppendRenderPass(
564 scoped_ptr<RenderPass> render_pass) {
565 render_passes_by_id[render_pass->id] = render_pass.get();
566 render_passes.push_back(render_pass.Pass());
569 DrawMode LayerTreeHostImpl::GetDrawMode() const {
570 if (resourceless_software_draw_) {
571 return DRAW_MODE_RESOURCELESS_SOFTWARE;
572 } else if (output_surface_->context_provider()) {
573 return DRAW_MODE_HARDWARE;
575 DCHECK_EQ(!output_surface_->software_device(),
576 output_surface_->capabilities().delegated_rendering &&
577 !output_surface_->capabilities().deferred_gl_initialization)
578 << output_surface_->capabilities().delegated_rendering << " "
579 << output_surface_->capabilities().deferred_gl_initialization;
580 return DRAW_MODE_SOFTWARE;
584 static void AppendQuadsForLayer(
585 RenderPass* target_render_pass,
587 const OcclusionTracker<LayerImpl>& occlusion_tracker,
588 AppendQuadsData* append_quads_data) {
589 layer->AppendQuads(target_render_pass, occlusion_tracker, append_quads_data);
592 static void AppendQuadsForRenderSurfaceLayer(
593 RenderPass* target_render_pass,
595 const RenderPass* contributing_render_pass,
596 const OcclusionTracker<LayerImpl>& occlusion_tracker,
597 AppendQuadsData* append_quads_data) {
598 bool is_replica = false;
599 layer->render_surface()->AppendQuads(target_render_pass,
603 contributing_render_pass->id);
605 // Add replica after the surface so that it appears below the surface.
606 if (layer->has_replica()) {
608 layer->render_surface()->AppendQuads(target_render_pass,
612 contributing_render_pass->id);
616 static void AppendQuadsToFillScreen(
617 ResourceProvider::ResourceId overhang_resource_id,
618 const gfx::SizeF& overhang_resource_scaled_size,
619 const gfx::Rect& root_scroll_layer_rect,
620 RenderPass* target_render_pass,
621 LayerImpl* root_layer,
622 SkColor screen_background_color,
623 const OcclusionTracker<LayerImpl>& occlusion_tracker) {
624 if (!root_layer || !SkColorGetA(screen_background_color))
627 Region fill_region = occlusion_tracker.ComputeVisibleRegionInScreen();
628 if (fill_region.IsEmpty())
631 // Divide the fill region into the part to be filled with the overhang
632 // resource and the part to be filled with the background color.
633 Region screen_background_color_region = fill_region;
634 Region overhang_region;
635 if (overhang_resource_id) {
636 overhang_region = fill_region;
637 overhang_region.Subtract(root_scroll_layer_rect);
638 screen_background_color_region.Intersect(root_scroll_layer_rect);
641 // Manually create the quad state for the gutter quads, as the root layer
642 // doesn't have any bounds and so can't generate this itself.
643 // TODO(danakj): Make the gutter quads generated by the solid color layer
644 // (make it smarter about generating quads to fill unoccluded areas).
646 gfx::Rect root_target_rect = root_layer->render_surface()->content_rect();
648 int sorting_context_id = 0;
649 SharedQuadState* shared_quad_state =
650 target_render_pass->CreateAndAppendSharedQuadState();
651 shared_quad_state->SetAll(gfx::Transform(),
652 root_target_rect.size(),
657 SkXfermode::kSrcOver_Mode,
660 for (Region::Iterator fill_rects(screen_background_color_region);
661 fill_rects.has_rect();
663 gfx::Rect screen_space_rect = fill_rects.rect();
664 gfx::Rect visible_screen_space_rect = screen_space_rect;
665 // Skip the quad culler and just append the quads directly to avoid
667 SolidColorDrawQuad* quad =
668 target_render_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
669 quad->SetNew(shared_quad_state,
671 visible_screen_space_rect,
672 screen_background_color,
675 for (Region::Iterator fill_rects(overhang_region);
676 fill_rects.has_rect();
678 DCHECK(overhang_resource_id);
679 gfx::Rect screen_space_rect = fill_rects.rect();
680 gfx::Rect opaque_screen_space_rect = screen_space_rect;
681 gfx::Rect visible_screen_space_rect = screen_space_rect;
682 TextureDrawQuad* tex_quad =
683 target_render_pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
684 const float vertex_opacity[4] = {1.f, 1.f, 1.f, 1.f};
688 opaque_screen_space_rect,
689 visible_screen_space_rect,
690 overhang_resource_id,
693 screen_space_rect.x() / overhang_resource_scaled_size.width(),
694 screen_space_rect.y() / overhang_resource_scaled_size.height()),
696 screen_space_rect.right() / overhang_resource_scaled_size.width(),
697 screen_space_rect.bottom() /
698 overhang_resource_scaled_size.height()),
699 screen_background_color,
705 DrawResult LayerTreeHostImpl::CalculateRenderPasses(
707 DCHECK(frame->render_passes.empty());
709 DCHECK(active_tree_->root_layer());
711 TrackDamageForAllSurfaces(active_tree_->root_layer(),
712 *frame->render_surface_layer_list);
714 // If the root render surface has no visible damage, then don't generate a
716 RenderSurfaceImpl* root_surface =
717 active_tree_->root_layer()->render_surface();
718 bool root_surface_has_no_visible_damage =
719 !root_surface->damage_tracker()->current_damage_rect().Intersects(
720 root_surface->content_rect());
721 bool root_surface_has_contributing_layers =
722 !root_surface->layer_list().empty();
723 bool hud_wants_to_draw_ = active_tree_->hud_layer() &&
724 active_tree_->hud_layer()->IsAnimatingHUDContents();
725 if (root_surface_has_contributing_layers &&
726 root_surface_has_no_visible_damage &&
727 active_tree_->LayersWithCopyOutputRequest().empty() &&
728 !hud_wants_to_draw_) {
730 "LayerTreeHostImpl::CalculateRenderPasses::EmptyDamageRect");
731 frame->has_no_damage = true;
732 DCHECK(!output_surface_->capabilities()
733 .draw_and_swap_full_viewport_every_frame);
738 "LayerTreeHostImpl::CalculateRenderPasses",
739 "render_surface_layer_list.size()",
740 static_cast<uint64>(frame->render_surface_layer_list->size()));
742 // Create the render passes in dependency order.
743 for (int surface_index = frame->render_surface_layer_list->size() - 1;
746 LayerImpl* render_surface_layer =
747 (*frame->render_surface_layer_list)[surface_index];
748 RenderSurfaceImpl* render_surface = render_surface_layer->render_surface();
750 bool should_draw_into_render_pass =
751 render_surface_layer->parent() == NULL ||
752 render_surface->contributes_to_drawn_surface() ||
753 render_surface_layer->HasCopyRequest();
754 if (should_draw_into_render_pass)
755 render_surface_layer->render_surface()->AppendRenderPasses(frame);
758 // When we are displaying the HUD, change the root damage rect to cover the
759 // entire root surface. This will disable partial-swap/scissor optimizations
760 // that would prevent the HUD from updating, since the HUD does not cause
761 // damage itself, to prevent it from messing with damage visualizations. Since
762 // damage visualizations are done off the LayerImpls and RenderSurfaceImpls,
763 // changing the RenderPass does not affect them.
764 if (active_tree_->hud_layer()) {
765 RenderPass* root_pass = frame->render_passes.back();
766 root_pass->damage_rect = root_pass->output_rect;
769 OcclusionTracker<LayerImpl> occlusion_tracker(
770 active_tree_->root_layer()->render_surface()->content_rect());
771 occlusion_tracker.set_minimum_tracking_size(
772 settings_.minimum_occlusion_tracking_size);
774 if (debug_state_.show_occluding_rects) {
775 occlusion_tracker.set_occluding_screen_space_rects_container(
776 &frame->occluding_screen_space_rects);
778 if (debug_state_.show_non_occluding_rects) {
779 occlusion_tracker.set_non_occluding_screen_space_rects_container(
780 &frame->non_occluding_screen_space_rects);
783 // Add quads to the Render passes in front-to-back order to allow for testing
784 // occlusion and performing culling during the tree walk.
785 typedef LayerIterator<LayerImpl> LayerIteratorType;
787 // Typically when we are missing a texture and use a checkerboard quad, we
788 // still draw the frame. However when the layer being checkerboarded is moving
789 // due to an impl-animation, we drop the frame to avoid flashing due to the
790 // texture suddenly appearing in the future.
791 DrawResult draw_result = DRAW_SUCCESS;
792 // When we have a copy request for a layer, we need to draw no matter
793 // what, as the layer may disappear after this frame.
794 bool have_copy_request = false;
796 int layers_drawn = 0;
798 const DrawMode draw_mode = GetDrawMode();
800 int num_missing_tiles = 0;
801 int num_incomplete_tiles = 0;
803 LayerIteratorType end =
804 LayerIteratorType::End(frame->render_surface_layer_list);
805 for (LayerIteratorType it =
806 LayerIteratorType::Begin(frame->render_surface_layer_list);
809 RenderPassId target_render_pass_id =
810 it.target_render_surface_layer()->render_surface()->GetRenderPassId();
811 RenderPass* target_render_pass =
812 frame->render_passes_by_id[target_render_pass_id];
814 occlusion_tracker.EnterLayer(it);
816 AppendQuadsData append_quads_data(target_render_pass_id);
818 if (it.represents_target_render_surface()) {
819 if (it->HasCopyRequest()) {
820 have_copy_request = true;
821 it->TakeCopyRequestsAndTransformToTarget(
822 &target_render_pass->copy_requests);
824 } else if (it.represents_contributing_render_surface() &&
825 it->render_surface()->contributes_to_drawn_surface()) {
826 RenderPassId contributing_render_pass_id =
827 it->render_surface()->GetRenderPassId();
828 RenderPass* contributing_render_pass =
829 frame->render_passes_by_id[contributing_render_pass_id];
830 AppendQuadsForRenderSurfaceLayer(target_render_pass,
832 contributing_render_pass,
835 } else if (it.represents_itself() &&
836 !it->visible_content_rect().IsEmpty()) {
838 occlusion_tracker.GetCurrentOcclusionForLayer(it->draw_transform())
839 .IsOccluded(it->visible_content_rect());
840 if (!occluded && it->WillDraw(draw_mode, resource_provider_.get())) {
841 DCHECK_EQ(active_tree_, it->layer_tree_impl());
843 frame->will_draw_layers.push_back(*it);
845 if (it->HasContributingDelegatedRenderPasses()) {
846 RenderPassId contributing_render_pass_id =
847 it->FirstContributingRenderPassId();
848 while (frame->render_passes_by_id.find(contributing_render_pass_id) !=
849 frame->render_passes_by_id.end()) {
850 RenderPass* render_pass =
851 frame->render_passes_by_id[contributing_render_pass_id];
853 AppendQuadsData append_quads_data(render_pass->id);
854 AppendQuadsForLayer(render_pass,
859 contributing_render_pass_id =
860 it->NextContributingRenderPassId(contributing_render_pass_id);
864 AppendQuadsForLayer(target_render_pass,
873 rendering_stats_instrumentation_->AddVisibleContentArea(
874 append_quads_data.visible_content_area);
875 rendering_stats_instrumentation_->AddApproximatedVisibleContentArea(
876 append_quads_data.approximated_visible_content_area);
878 num_missing_tiles += append_quads_data.num_missing_tiles;
879 num_incomplete_tiles += append_quads_data.num_incomplete_tiles;
881 if (append_quads_data.num_missing_tiles) {
882 bool layer_has_animating_transform =
883 it->screen_space_transform_is_animating() ||
884 it->draw_transform_is_animating();
885 if (layer_has_animating_transform)
886 draw_result = DRAW_ABORTED_CHECKERBOARD_ANIMATIONS;
889 if (append_quads_data.num_incomplete_tiles ||
890 append_quads_data.num_missing_tiles) {
891 frame->contains_incomplete_tile = true;
892 if (active_tree()->RequiresHighResToDraw())
893 draw_result = DRAW_ABORTED_MISSING_HIGH_RES_CONTENT;
896 occlusion_tracker.LeaveLayer(it);
899 if (have_copy_request ||
900 output_surface_->capabilities().draw_and_swap_full_viewport_every_frame)
901 draw_result = DRAW_SUCCESS;
904 for (size_t i = 0; i < frame->render_passes.size(); ++i) {
905 for (QuadList::Iterator iter = frame->render_passes[i]->quad_list.begin();
906 iter != frame->render_passes[i]->quad_list.end();
908 DCHECK(iter->shared_quad_state);
909 DCHECK(frame->render_passes_by_id.find(frame->render_passes[i]->id)
910 != frame->render_passes_by_id.end());
913 DCHECK(frame->render_passes.back()->output_rect.origin().IsOrigin());
915 if (!active_tree_->has_transparent_background()) {
916 frame->render_passes.back()->has_transparent_background = false;
917 AppendQuadsToFillScreen(
918 ResourceIdForUIResource(overhang_ui_resource_id_),
919 gfx::ScaleSize(overhang_ui_resource_size_, device_scale_factor_),
920 active_tree_->RootScrollLayerDeviceViewportBounds(),
921 frame->render_passes.back(),
922 active_tree_->root_layer(),
923 active_tree_->background_color(),
927 RemoveRenderPasses(CullRenderPassesWithNoQuads(), frame);
928 renderer_->DecideRenderPassAllocationsForFrame(frame->render_passes);
930 // Any copy requests left in the tree are not going to get serviced, and
931 // should be aborted.
932 ScopedPtrVector<CopyOutputRequest> requests_to_abort;
933 while (!active_tree_->LayersWithCopyOutputRequest().empty()) {
934 LayerImpl* layer = active_tree_->LayersWithCopyOutputRequest().back();
935 layer->TakeCopyRequestsAndTransformToTarget(&requests_to_abort);
937 for (size_t i = 0; i < requests_to_abort.size(); ++i)
938 requests_to_abort[i]->SendEmptyResult();
940 // If we're making a frame to draw, it better have at least one render pass.
941 DCHECK(!frame->render_passes.empty());
943 if (active_tree_->has_ever_been_drawn()) {
944 UMA_HISTOGRAM_COUNTS_100(
945 "Compositing.RenderPass.AppendQuadData.NumMissingTiles",
947 UMA_HISTOGRAM_COUNTS_100(
948 "Compositing.RenderPass.AppendQuadData.NumIncompleteTiles",
949 num_incomplete_tiles);
952 // Should only have one render pass in resourceless software mode.
953 DCHECK(draw_mode != DRAW_MODE_RESOURCELESS_SOFTWARE ||
954 frame->render_passes.size() == 1u)
955 << frame->render_passes.size();
960 void LayerTreeHostImpl::MainThreadHasStoppedFlinging() {
961 if (input_handler_client_)
962 input_handler_client_->MainThreadHasStoppedFlinging();
965 void LayerTreeHostImpl::UpdateBackgroundAnimateTicking(
966 bool should_background_tick) {
967 DCHECK(proxy_->IsImplThread());
968 if (should_background_tick)
969 DCHECK(active_tree_->root_layer());
971 bool enabled = should_background_tick && needs_animate_layers();
973 // Lazily create the time_source adapter so that we can vary the interval for
975 if (!time_source_client_adapter_) {
976 time_source_client_adapter_ = LayerTreeHostImplTimeSourceAdapter::Create(
978 DelayBasedTimeSource::Create(
979 LowFrequencyAnimationInterval(),
980 proxy_->HasImplThread() ? proxy_->ImplThreadTaskRunner()
981 : proxy_->MainThreadTaskRunner()));
984 time_source_client_adapter_->SetActive(enabled);
987 void LayerTreeHostImpl::DidAnimateScrollOffset() {
988 client_->SetNeedsCommitOnImplThread();
989 client_->RenewTreePriority();
992 void LayerTreeHostImpl::SetViewportDamage(const gfx::Rect& damage_rect) {
993 viewport_damage_rect_.Union(damage_rect);
996 static inline RenderPass* FindRenderPassById(
997 RenderPassId render_pass_id,
998 const LayerTreeHostImpl::FrameData& frame) {
999 RenderPassIdHashMap::const_iterator it =
1000 frame.render_passes_by_id.find(render_pass_id);
1001 return it != frame.render_passes_by_id.end() ? it->second : NULL;
1004 static void RemoveRenderPassesRecursive(RenderPassId remove_render_pass_id,
1005 LayerTreeHostImpl::FrameData* frame) {
1006 RenderPass* remove_render_pass =
1007 FindRenderPassById(remove_render_pass_id, *frame);
1008 // The pass was already removed by another quad - probably the original, and
1009 // we are the replica.
1010 if (!remove_render_pass)
1012 RenderPassList& render_passes = frame->render_passes;
1013 RenderPassList::iterator to_remove = std::find(render_passes.begin(),
1014 render_passes.end(),
1015 remove_render_pass);
1017 DCHECK(to_remove != render_passes.end());
1019 scoped_ptr<RenderPass> removed_pass = render_passes.take(to_remove);
1020 frame->render_passes.erase(to_remove);
1021 frame->render_passes_by_id.erase(remove_render_pass_id);
1023 // Now follow up for all RenderPass quads and remove their RenderPasses
1025 const QuadList& quad_list = removed_pass->quad_list;
1026 QuadList::ConstBackToFrontIterator quad_list_iterator =
1027 quad_list.BackToFrontBegin();
1028 for (; quad_list_iterator != quad_list.BackToFrontEnd();
1029 ++quad_list_iterator) {
1030 const DrawQuad* current_quad = &*quad_list_iterator;
1031 if (current_quad->material != DrawQuad::RENDER_PASS)
1034 RenderPassId next_remove_render_pass_id =
1035 RenderPassDrawQuad::MaterialCast(current_quad)->render_pass_id;
1036 RemoveRenderPassesRecursive(next_remove_render_pass_id, frame);
1040 bool LayerTreeHostImpl::CullRenderPassesWithNoQuads::ShouldRemoveRenderPass(
1041 const RenderPassDrawQuad& quad, const FrameData& frame) const {
1042 const RenderPass* render_pass =
1043 FindRenderPassById(quad.render_pass_id, frame);
1047 // If any quad or RenderPass draws into this RenderPass, then keep it.
1048 const QuadList& quad_list = render_pass->quad_list;
1049 for (QuadList::ConstBackToFrontIterator quad_list_iterator =
1050 quad_list.BackToFrontBegin();
1051 quad_list_iterator != quad_list.BackToFrontEnd();
1052 ++quad_list_iterator) {
1053 const DrawQuad* current_quad = &*quad_list_iterator;
1055 if (current_quad->material != DrawQuad::RENDER_PASS)
1058 const RenderPass* contributing_pass = FindRenderPassById(
1059 RenderPassDrawQuad::MaterialCast(current_quad)->render_pass_id, frame);
1060 if (contributing_pass)
1066 // Defined for linking tests.
1067 template CC_EXPORT void LayerTreeHostImpl::RemoveRenderPasses<
1068 LayerTreeHostImpl::CullRenderPassesWithNoQuads>(
1069 CullRenderPassesWithNoQuads culler, FrameData*);
1072 template <typename RenderPassCuller>
1073 void LayerTreeHostImpl::RemoveRenderPasses(RenderPassCuller culler,
1075 for (size_t it = culler.RenderPassListBegin(frame->render_passes);
1076 it != culler.RenderPassListEnd(frame->render_passes);
1077 it = culler.RenderPassListNext(it)) {
1078 const RenderPass* current_pass = frame->render_passes[it];
1079 const QuadList& quad_list = current_pass->quad_list;
1080 QuadList::ConstBackToFrontIterator quad_list_iterator =
1081 quad_list.BackToFrontBegin();
1083 for (; quad_list_iterator != quad_list.BackToFrontEnd();
1084 ++quad_list_iterator) {
1085 const DrawQuad* current_quad = &*quad_list_iterator;
1087 if (current_quad->material != DrawQuad::RENDER_PASS)
1090 const RenderPassDrawQuad* render_pass_quad =
1091 RenderPassDrawQuad::MaterialCast(current_quad);
1092 if (!culler.ShouldRemoveRenderPass(*render_pass_quad, *frame))
1095 // We are changing the vector in the middle of iteration. Because we
1096 // delete render passes that draw into the current pass, we are
1097 // guaranteed that any data from the iterator to the end will not
1098 // change. So, capture the iterator position from the end of the
1099 // list, and restore it after the change.
1100 size_t position_from_end = frame->render_passes.size() - it;
1101 RemoveRenderPassesRecursive(render_pass_quad->render_pass_id, frame);
1102 it = frame->render_passes.size() - position_from_end;
1103 DCHECK_GE(frame->render_passes.size(), position_from_end);
1108 DrawResult LayerTreeHostImpl::PrepareToDraw(FrameData* frame) {
1110 "LayerTreeHostImpl::PrepareToDraw",
1111 "SourceFrameNumber",
1112 active_tree_->source_frame_number());
1114 if (need_to_update_visible_tiles_before_draw_ &&
1115 tile_manager_ && tile_manager_->UpdateVisibleTiles()) {
1116 DidInitializeVisibleTile();
1118 need_to_update_visible_tiles_before_draw_ = true;
1120 UMA_HISTOGRAM_CUSTOM_COUNTS(
1121 "Compositing.NumActiveLayers", active_tree_->NumLayers(), 1, 400, 20);
1123 bool ok = active_tree_->UpdateDrawProperties();
1124 DCHECK(ok) << "UpdateDrawProperties failed during draw";
1126 frame->render_surface_layer_list = &active_tree_->RenderSurfaceLayerList();
1127 frame->render_passes.clear();
1128 frame->render_passes_by_id.clear();
1129 frame->will_draw_layers.clear();
1130 frame->contains_incomplete_tile = false;
1131 frame->has_no_damage = false;
1133 if (active_tree_->root_layer()) {
1134 gfx::Rect device_viewport_damage_rect = viewport_damage_rect_;
1135 viewport_damage_rect_ = gfx::Rect();
1137 active_tree_->root_layer()->render_surface()->damage_tracker()->
1138 AddDamageNextUpdate(device_viewport_damage_rect);
1141 DrawResult draw_result = CalculateRenderPasses(frame);
1142 if (draw_result != DRAW_SUCCESS) {
1143 DCHECK(!output_surface_->capabilities()
1144 .draw_and_swap_full_viewport_every_frame);
1148 // If we return DRAW_SUCCESS, then we expect DrawLayers() to be called before
1149 // this function is called again.
1153 void LayerTreeHostImpl::EvictTexturesForTesting() {
1154 EnforceManagedMemoryPolicy(ManagedMemoryPolicy(0));
1157 void LayerTreeHostImpl::BlockNotifyReadyToActivateForTesting(bool block) {
1161 void LayerTreeHostImpl::DidInitializeVisibleTileForTesting() {
1162 // Add arbitrary damage, to trigger prepare-to-draws.
1163 // Here, setting damage as viewport size, used only for testing.
1164 SetFullRootLayerDamage();
1165 DidInitializeVisibleTile();
1168 void LayerTreeHostImpl::ResetTreesForTesting() {
1170 active_tree_->DetachLayerTree();
1171 active_tree_ = LayerTreeImpl::create(this);
1173 pending_tree_->DetachLayerTree();
1174 pending_tree_.reset();
1176 recycle_tree_->DetachLayerTree();
1177 recycle_tree_.reset();
1180 void LayerTreeHostImpl::ResetRecycleTreeForTesting() {
1182 recycle_tree_->DetachLayerTree();
1183 recycle_tree_.reset();
1186 void LayerTreeHostImpl::EnforceManagedMemoryPolicy(
1187 const ManagedMemoryPolicy& policy) {
1189 bool evicted_resources = client_->ReduceContentsTextureMemoryOnImplThread(
1190 visible_ ? policy.bytes_limit_when_visible : 0,
1191 ManagedMemoryPolicy::PriorityCutoffToValue(
1192 visible_ ? policy.priority_cutoff_when_visible
1193 : gpu::MemoryAllocation::CUTOFF_ALLOW_NOTHING));
1194 if (evicted_resources) {
1195 active_tree_->SetContentsTexturesPurged();
1197 pending_tree_->SetContentsTexturesPurged();
1198 client_->SetNeedsCommitOnImplThread();
1199 client_->OnCanDrawStateChanged(CanDraw());
1200 client_->RenewTreePriority();
1203 UpdateTileManagerMemoryPolicy(policy);
1206 void LayerTreeHostImpl::UpdateTileManagerMemoryPolicy(
1207 const ManagedMemoryPolicy& policy) {
1211 global_tile_state_.hard_memory_limit_in_bytes = 0;
1212 global_tile_state_.soft_memory_limit_in_bytes = 0;
1213 if (visible_ && policy.bytes_limit_when_visible > 0) {
1214 global_tile_state_.hard_memory_limit_in_bytes =
1215 policy.bytes_limit_when_visible;
1216 global_tile_state_.soft_memory_limit_in_bytes =
1217 (static_cast<int64>(global_tile_state_.hard_memory_limit_in_bytes) *
1218 settings_.max_memory_for_prepaint_percentage) /
1221 global_tile_state_.memory_limit_policy =
1222 ManagedMemoryPolicy::PriorityCutoffToTileMemoryLimitPolicy(
1224 policy.priority_cutoff_when_visible :
1225 gpu::MemoryAllocation::CUTOFF_ALLOW_NOTHING);
1226 global_tile_state_.num_resources_limit = policy.num_resources_limit;
1228 // TODO(reveman): We should avoid keeping around unused resources if
1229 // possible. crbug.com/224475
1230 // Unused limit is calculated from soft-limit, as hard-limit may
1231 // be very high and shouldn't typically be exceeded.
1232 size_t unused_memory_limit_in_bytes = static_cast<size_t>(
1233 (static_cast<int64>(global_tile_state_.soft_memory_limit_in_bytes) *
1234 settings_.max_unused_resource_memory_percentage) /
1237 DCHECK(resource_pool_);
1238 resource_pool_->CheckBusyResources();
1239 // Soft limit is used for resource pool such that memory returns to soft
1240 // limit after going over.
1241 resource_pool_->SetResourceUsageLimits(
1242 global_tile_state_.soft_memory_limit_in_bytes,
1243 unused_memory_limit_in_bytes,
1244 global_tile_state_.num_resources_limit);
1246 // Release all staging resources when invisible.
1247 if (staging_resource_pool_) {
1248 staging_resource_pool_->CheckBusyResources();
1249 staging_resource_pool_->SetResourceUsageLimits(
1250 std::numeric_limits<size_t>::max(),
1251 std::numeric_limits<size_t>::max(),
1252 visible_ ? GetMaxStagingResourceCount() : 0);
1255 DidModifyTilePriorities();
1258 void LayerTreeHostImpl::DidModifyTilePriorities() {
1259 DCHECK(settings_.impl_side_painting);
1260 // Mark priorities as dirty and schedule a ManageTiles().
1261 tile_priorities_dirty_ = true;
1262 client_->SetNeedsManageTilesOnImplThread();
1265 void LayerTreeHostImpl::DidInitializeVisibleTile() {
1266 if (client_ && !client_->IsInsideDraw())
1267 client_->DidInitializeVisibleTileOnImplThread();
1270 void LayerTreeHostImpl::GetPictureLayerImplPairs(
1271 std::vector<PictureLayerImpl::Pair>* layer_pairs) const {
1272 DCHECK(layer_pairs->empty());
1273 for (std::vector<PictureLayerImpl*>::const_iterator it =
1274 picture_layers_.begin();
1275 it != picture_layers_.end();
1277 PictureLayerImpl* layer = *it;
1279 // TODO(vmpstr): Iterators and should handle this instead. crbug.com/381704
1280 if (!layer->HasValidTilePriorities())
1283 PictureLayerImpl* twin_layer = layer->GetTwinLayer();
1285 // Ignore the twin layer when tile priorities are invalid.
1286 // TODO(vmpstr): Iterators should handle this instead. crbug.com/381704
1287 if (twin_layer && !twin_layer->HasValidTilePriorities())
1290 // If the current tree is ACTIVE_TREE, then always generate a layer_pair.
1291 // If current tree is PENDING_TREE, then only generate a layer_pair if
1292 // there is no twin layer.
1293 if (layer->GetTree() == ACTIVE_TREE) {
1294 DCHECK(!twin_layer || twin_layer->GetTree() == PENDING_TREE);
1295 layer_pairs->push_back(PictureLayerImpl::Pair(layer, twin_layer));
1296 } else if (!twin_layer) {
1297 layer_pairs->push_back(PictureLayerImpl::Pair(NULL, layer));
1302 void LayerTreeHostImpl::BuildRasterQueue(RasterTilePriorityQueue* queue,
1303 TreePriority tree_priority) {
1304 picture_layer_pairs_.clear();
1305 GetPictureLayerImplPairs(&picture_layer_pairs_);
1306 queue->Build(picture_layer_pairs_, tree_priority);
1309 void LayerTreeHostImpl::BuildEvictionQueue(EvictionTilePriorityQueue* queue,
1310 TreePriority tree_priority) {
1311 picture_layer_pairs_.clear();
1312 GetPictureLayerImplPairs(&picture_layer_pairs_);
1313 queue->Build(picture_layer_pairs_, tree_priority);
1316 const std::vector<PictureLayerImpl*>& LayerTreeHostImpl::GetPictureLayers()
1318 return picture_layers_;
1321 void LayerTreeHostImpl::NotifyReadyToActivate() {
1322 client_->NotifyReadyToActivate();
1325 void LayerTreeHostImpl::NotifyTileStateChanged(const Tile* tile) {
1326 TRACE_EVENT0("cc", "LayerTreeHostImpl::NotifyTileStateChanged");
1329 LayerImpl* layer_impl =
1330 active_tree_->FindActiveTreeLayerById(tile->layer_id());
1332 layer_impl->NotifyTileStateChanged(tile);
1335 if (pending_tree_) {
1336 LayerImpl* layer_impl =
1337 pending_tree_->FindPendingTreeLayerById(tile->layer_id());
1339 layer_impl->NotifyTileStateChanged(tile);
1343 void LayerTreeHostImpl::SetMemoryPolicy(const ManagedMemoryPolicy& policy) {
1344 SetManagedMemoryPolicy(policy, zero_budget_);
1347 void LayerTreeHostImpl::SetTreeActivationCallback(
1348 const base::Closure& callback) {
1349 DCHECK(proxy_->IsImplThread());
1350 DCHECK(settings_.impl_side_painting || callback.is_null());
1351 tree_activation_callback_ = callback;
1354 void LayerTreeHostImpl::SetManagedMemoryPolicy(
1355 const ManagedMemoryPolicy& policy, bool zero_budget) {
1356 if (cached_managed_memory_policy_ == policy && zero_budget_ == zero_budget)
1359 ManagedMemoryPolicy old_policy = ActualManagedMemoryPolicy();
1361 cached_managed_memory_policy_ = policy;
1362 zero_budget_ = zero_budget;
1363 ManagedMemoryPolicy actual_policy = ActualManagedMemoryPolicy();
1365 if (old_policy == actual_policy)
1368 if (!proxy_->HasImplThread()) {
1369 // In single-thread mode, this can be called on the main thread by
1370 // GLRenderer::OnMemoryAllocationChanged.
1371 DebugScopedSetImplThread impl_thread(proxy_);
1372 EnforceManagedMemoryPolicy(actual_policy);
1374 DCHECK(proxy_->IsImplThread());
1375 EnforceManagedMemoryPolicy(actual_policy);
1378 // If there is already enough memory to draw everything imaginable and the
1379 // new memory limit does not change this, then do not re-commit. Don't bother
1380 // skipping commits if this is not visible (commits don't happen when not
1381 // visible, there will almost always be a commit when this becomes visible).
1382 bool needs_commit = true;
1384 actual_policy.bytes_limit_when_visible >= max_memory_needed_bytes_ &&
1385 old_policy.bytes_limit_when_visible >= max_memory_needed_bytes_ &&
1386 actual_policy.priority_cutoff_when_visible ==
1387 old_policy.priority_cutoff_when_visible) {
1388 needs_commit = false;
1392 client_->SetNeedsCommitOnImplThread();
1395 void LayerTreeHostImpl::SetExternalDrawConstraints(
1396 const gfx::Transform& transform,
1397 const gfx::Rect& viewport,
1398 const gfx::Rect& clip,
1399 const gfx::Rect& viewport_rect_for_tile_priority,
1400 const gfx::Transform& transform_for_tile_priority,
1401 bool resourceless_software_draw) {
1402 gfx::Rect viewport_rect_for_tile_priority_in_view_space;
1403 if (!resourceless_software_draw) {
1404 gfx::Transform screen_to_view(gfx::Transform::kSkipInitialization);
1405 if (transform_for_tile_priority.GetInverse(&screen_to_view)) {
1406 // Convert from screen space to view space.
1407 viewport_rect_for_tile_priority_in_view_space =
1408 gfx::ToEnclosingRect(MathUtil::ProjectClippedRect(
1409 screen_to_view, viewport_rect_for_tile_priority));
1413 if (external_transform_ != transform || external_viewport_ != viewport ||
1414 resourceless_software_draw_ != resourceless_software_draw ||
1415 viewport_rect_for_tile_priority_ !=
1416 viewport_rect_for_tile_priority_in_view_space) {
1417 active_tree_->set_needs_update_draw_properties();
1420 external_transform_ = transform;
1421 external_viewport_ = viewport;
1422 external_clip_ = clip;
1423 viewport_rect_for_tile_priority_ =
1424 viewport_rect_for_tile_priority_in_view_space;
1425 resourceless_software_draw_ = resourceless_software_draw;
1428 void LayerTreeHostImpl::SetNeedsRedrawRect(const gfx::Rect& damage_rect) {
1429 if (damage_rect.IsEmpty())
1431 NotifySwapPromiseMonitorsOfSetNeedsRedraw();
1432 client_->SetNeedsRedrawRectOnImplThread(damage_rect);
1435 void LayerTreeHostImpl::BeginFrame(const BeginFrameArgs& args) {
1436 client_->BeginFrame(args);
1439 void LayerTreeHostImpl::DidSwapBuffers() {
1440 client_->DidSwapBuffersOnImplThread();
1443 void LayerTreeHostImpl::DidSwapBuffersComplete() {
1444 client_->DidSwapBuffersCompleteOnImplThread();
1447 void LayerTreeHostImpl::ReclaimResources(const CompositorFrameAck* ack) {
1448 // TODO(piman): We may need to do some validation on this ack before
1451 renderer_->ReceiveSwapBuffersAck(*ack);
1453 // In OOM, we now might be able to release more resources that were held
1454 // because they were exported.
1455 if (tile_manager_) {
1456 DCHECK(resource_pool_);
1458 resource_pool_->CheckBusyResources();
1459 resource_pool_->ReduceResourceUsage();
1461 // If we're not visible, we likely released resources, so we want to
1462 // aggressively flush here to make sure those DeleteTextures make it to the
1463 // GPU process to free up the memory.
1464 if (output_surface_->context_provider() && !visible_) {
1465 output_surface_->context_provider()->ContextGL()->ShallowFlushCHROMIUM();
1469 void LayerTreeHostImpl::OnCanDrawStateChangedForTree() {
1470 client_->OnCanDrawStateChanged(CanDraw());
1473 CompositorFrameMetadata LayerTreeHostImpl::MakeCompositorFrameMetadata() const {
1474 CompositorFrameMetadata metadata;
1475 metadata.device_scale_factor = device_scale_factor_;
1476 metadata.page_scale_factor = active_tree_->total_page_scale_factor();
1477 metadata.scrollable_viewport_size = active_tree_->ScrollableViewportSize();
1478 metadata.root_layer_size = active_tree_->ScrollableSize();
1479 metadata.min_page_scale_factor = active_tree_->min_page_scale_factor();
1480 metadata.max_page_scale_factor = active_tree_->max_page_scale_factor();
1481 if (top_controls_manager_) {
1482 metadata.location_bar_offset =
1483 gfx::Vector2dF(0.f, top_controls_manager_->ControlsTopOffset());
1484 metadata.location_bar_content_translation =
1485 gfx::Vector2dF(0.f, top_controls_manager_->ContentTopOffset());
1488 active_tree_->GetViewportSelection(&metadata.selection_start,
1489 &metadata.selection_end);
1491 if (!InnerViewportScrollLayer())
1494 metadata.root_scroll_offset = active_tree_->TotalScrollOffset();
1499 static void LayerTreeHostImplDidBeginTracingCallback(LayerImpl* layer) {
1500 layer->DidBeginTracing();
1503 void LayerTreeHostImpl::DrawLayers(FrameData* frame,
1504 base::TimeTicks frame_begin_time) {
1505 TRACE_EVENT0("cc", "LayerTreeHostImpl::DrawLayers");
1508 if (frame->has_no_damage) {
1509 TRACE_EVENT_INSTANT0("cc", "EarlyOut_NoDamage", TRACE_EVENT_SCOPE_THREAD);
1510 DCHECK(!output_surface_->capabilities()
1511 .draw_and_swap_full_viewport_every_frame);
1515 DCHECK(!frame->render_passes.empty());
1517 fps_counter_->SaveTimeStamp(frame_begin_time,
1518 !output_surface_->context_provider());
1519 bool on_main_thread = false;
1520 rendering_stats_instrumentation_->IncrementFrameCount(
1523 if (tile_manager_) {
1524 memory_history_->SaveEntry(
1525 tile_manager_->memory_stats_from_last_assign());
1528 if (debug_state_.ShowHudRects()) {
1529 debug_rect_history_->SaveDebugRectsForCurrentFrame(
1530 active_tree_->root_layer(),
1531 active_tree_->hud_layer(),
1532 *frame->render_surface_layer_list,
1533 frame->occluding_screen_space_rects,
1534 frame->non_occluding_screen_space_rects,
1538 if (!settings_.impl_side_painting && debug_state_.continuous_painting) {
1539 const RenderingStats& stats =
1540 rendering_stats_instrumentation_->GetRenderingStats();
1541 paint_time_counter_->SavePaintTime(stats.main_stats.paint_time);
1545 TRACE_EVENT_IS_NEW_TRACE(&is_new_trace);
1547 if (pending_tree_) {
1548 LayerTreeHostCommon::CallFunctionForSubtree(
1549 pending_tree_->root_layer(),
1550 base::Bind(&LayerTreeHostImplDidBeginTracingCallback));
1552 LayerTreeHostCommon::CallFunctionForSubtree(
1553 active_tree_->root_layer(),
1554 base::Bind(&LayerTreeHostImplDidBeginTracingCallback));
1558 TRACE_EVENT0("cc", "DrawLayers.FrameViewerTracing");
1559 TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(
1560 TRACE_DISABLED_BY_DEFAULT("cc.debug") ","
1561 TRACE_DISABLED_BY_DEFAULT("cc.debug.quads") ","
1562 TRACE_DISABLED_BY_DEFAULT("devtools.timeline.layers"),
1563 "cc::LayerTreeHostImpl",
1565 AsValueWithFrame(frame));
1568 const DrawMode draw_mode = GetDrawMode();
1570 // Because the contents of the HUD depend on everything else in the frame, the
1571 // contents of its texture are updated as the last thing before the frame is
1573 if (active_tree_->hud_layer()) {
1574 TRACE_EVENT0("cc", "DrawLayers.UpdateHudTexture");
1575 active_tree_->hud_layer()->UpdateHudTexture(draw_mode,
1576 resource_provider_.get());
1579 if (draw_mode == DRAW_MODE_RESOURCELESS_SOFTWARE) {
1580 bool disable_picture_quad_image_filtering =
1581 IsCurrentlyScrolling() || needs_animate_layers();
1583 scoped_ptr<SoftwareRenderer> temp_software_renderer =
1584 SoftwareRenderer::Create(this, &settings_, output_surface_.get(), NULL);
1585 temp_software_renderer->DrawFrame(&frame->render_passes,
1586 device_scale_factor_,
1589 disable_picture_quad_image_filtering);
1591 renderer_->DrawFrame(&frame->render_passes,
1592 device_scale_factor_,
1597 // The render passes should be consumed by the renderer.
1598 DCHECK(frame->render_passes.empty());
1599 frame->render_passes_by_id.clear();
1601 // The next frame should start by assuming nothing has changed, and changes
1602 // are noted as they occur.
1603 // TODO(boliu): If we did a temporary software renderer frame, propogate the
1604 // damage forward to the next frame.
1605 for (size_t i = 0; i < frame->render_surface_layer_list->size(); i++) {
1606 (*frame->render_surface_layer_list)[i]->render_surface()->damage_tracker()->
1607 DidDrawDamagedArea();
1609 active_tree_->root_layer()->ResetAllChangeTrackingForSubtree();
1611 active_tree_->set_has_ever_been_drawn(true);
1612 devtools_instrumentation::DidDrawFrame(id_);
1613 benchmark_instrumentation::IssueImplThreadRenderingStatsEvent(
1614 rendering_stats_instrumentation_->impl_thread_rendering_stats());
1615 rendering_stats_instrumentation_->AccumulateAndClearImplThreadStats();
1618 void LayerTreeHostImpl::DidDrawAllLayers(const FrameData& frame) {
1619 for (size_t i = 0; i < frame.will_draw_layers.size(); ++i)
1620 frame.will_draw_layers[i]->DidDraw(resource_provider_.get());
1622 // Once all layers have been drawn, pending texture uploads should no
1623 // longer block future uploads.
1624 resource_provider_->MarkPendingUploadsAsNonBlocking();
1627 void LayerTreeHostImpl::FinishAllRendering() {
1629 renderer_->Finish();
1632 void LayerTreeHostImpl::SetUseGpuRasterization(bool use_gpu) {
1633 if (use_gpu == use_gpu_rasterization_)
1636 use_gpu_rasterization_ = use_gpu;
1637 ReleaseTreeResources();
1639 // Replace existing tile manager with another one that uses appropriate
1641 if (tile_manager_) {
1642 DestroyTileManager();
1643 CreateAndSetTileManager();
1646 // We have released tilings for both active and pending tree.
1647 // We would not have any content to draw until the pending tree is activated.
1648 // Prevent the active tree from drawing until activation.
1649 active_tree_->SetRequiresHighResToDraw();
1652 const RendererCapabilitiesImpl&
1653 LayerTreeHostImpl::GetRendererCapabilities() const {
1654 return renderer_->Capabilities();
1657 bool LayerTreeHostImpl::SwapBuffers(const LayerTreeHostImpl::FrameData& frame) {
1658 active_tree()->ResetRequiresHighResToDraw();
1659 if (frame.has_no_damage) {
1660 active_tree()->BreakSwapPromises(SwapPromise::SWAP_FAILS);
1663 CompositorFrameMetadata metadata = MakeCompositorFrameMetadata();
1664 active_tree()->FinishSwapPromises(&metadata);
1665 for (size_t i = 0; i < metadata.latency_info.size(); i++) {
1666 TRACE_EVENT_FLOW_STEP0(
1669 TRACE_ID_DONT_MANGLE(metadata.latency_info[i].trace_id),
1672 renderer_->SwapBuffers(metadata);
1676 void LayerTreeHostImpl::SetNeedsBeginFrame(bool enable) {
1677 if (output_surface_)
1678 output_surface_->SetNeedsBeginFrame(enable);
1683 void LayerTreeHostImpl::WillBeginImplFrame(const BeginFrameArgs& args) {
1684 // Sample the frame time now. This time will be used for updating animations
1686 UpdateCurrentBeginFrameArgs(args);
1687 // Cache the begin impl frame interval
1688 begin_impl_frame_interval_ = args.interval;
1691 void LayerTreeHostImpl::UpdateInnerViewportContainerSize() {
1692 LayerImpl* container_layer = active_tree_->InnerViewportContainerLayer();
1693 if (!container_layer)
1696 if (top_controls_manager_) {
1697 container_layer->SetBoundsDelta(
1698 gfx::Vector2dF(0, active_tree_->top_controls_layout_height() -
1699 active_tree_->total_top_controls_content_offset()));
1703 void LayerTreeHostImpl::SetTopControlsLayoutHeight(float height) {
1704 if (active_tree_->top_controls_layout_height() == height)
1707 active_tree_->set_top_controls_layout_height(height);
1708 UpdateInnerViewportContainerSize();
1709 SetFullRootLayerDamage();
1712 void LayerTreeHostImpl::DidLoseOutputSurface() {
1713 if (resource_provider_)
1714 resource_provider_->DidLoseOutputSurface();
1715 client_->DidLoseOutputSurfaceOnImplThread();
1718 bool LayerTreeHostImpl::HaveRootScrollLayer() const {
1719 return !!InnerViewportScrollLayer();
1722 LayerImpl* LayerTreeHostImpl::RootLayer() const {
1723 return active_tree_->root_layer();
1726 LayerImpl* LayerTreeHostImpl::InnerViewportScrollLayer() const {
1727 return active_tree_->InnerViewportScrollLayer();
1730 LayerImpl* LayerTreeHostImpl::OuterViewportScrollLayer() const {
1731 return active_tree_->OuterViewportScrollLayer();
1734 LayerImpl* LayerTreeHostImpl::CurrentlyScrollingLayer() const {
1735 return active_tree_->CurrentlyScrollingLayer();
1738 bool LayerTreeHostImpl::IsCurrentlyScrolling() const {
1739 return CurrentlyScrollingLayer() ||
1740 (InnerViewportScrollLayer() &&
1741 InnerViewportScrollLayer()->IsExternalFlingActive()) ||
1742 (OuterViewportScrollLayer() &&
1743 OuterViewportScrollLayer()->IsExternalFlingActive());
1746 // Content layers can be either directly scrollable or contained in an outer
1747 // scrolling layer which applies the scroll transform. Given a content layer,
1748 // this function returns the associated scroll layer if any.
1749 static LayerImpl* FindScrollLayerForContentLayer(LayerImpl* layer_impl) {
1753 if (layer_impl->scrollable())
1756 if (layer_impl->DrawsContent() &&
1757 layer_impl->parent() &&
1758 layer_impl->parent()->scrollable())
1759 return layer_impl->parent();
1764 void LayerTreeHostImpl::CreatePendingTree() {
1765 CHECK(!pending_tree_);
1767 recycle_tree_.swap(pending_tree_);
1769 pending_tree_ = LayerTreeImpl::create(this);
1771 // Update the delta from the active tree, which may have
1772 // adjusted its delta prior to the pending tree being created.
1773 DCHECK_EQ(1.f, pending_tree_->sent_page_scale_delta());
1774 DCHECK_EQ(0.f, pending_tree_->sent_top_controls_delta());
1775 pending_tree_->SetPageScaleDelta(active_tree_->page_scale_delta() /
1776 active_tree_->sent_page_scale_delta());
1777 pending_tree_->set_top_controls_delta(
1778 active_tree_->top_controls_delta() -
1779 active_tree_->sent_top_controls_delta());
1781 client_->OnCanDrawStateChanged(CanDraw());
1782 TRACE_EVENT_ASYNC_BEGIN0("cc", "PendingTree:waiting", pending_tree_.get());
1785 void LayerTreeHostImpl::UpdateVisibleTiles() {
1786 if (tile_manager_ && tile_manager_->UpdateVisibleTiles())
1787 DidInitializeVisibleTile();
1788 need_to_update_visible_tiles_before_draw_ = false;
1791 void LayerTreeHostImpl::ActivateSyncTree() {
1792 need_to_update_visible_tiles_before_draw_ = true;
1794 if (pending_tree_) {
1795 TRACE_EVENT_ASYNC_END0("cc", "PendingTree:waiting", pending_tree_.get());
1797 active_tree_->SetRootLayerScrollOffsetDelegate(NULL);
1798 active_tree_->PushPersistedState(pending_tree_.get());
1799 // Process any requests in the UI resource queue. The request queue is
1800 // given in LayerTreeHost::FinishCommitOnImplThread. This must take place
1802 pending_tree_->ProcessUIResourceRequestQueue();
1804 if (pending_tree_->needs_full_tree_sync()) {
1805 active_tree_->SetRootLayer(
1806 TreeSynchronizer::SynchronizeTrees(pending_tree_->root_layer(),
1807 active_tree_->DetachLayerTree(),
1808 active_tree_.get()));
1810 TreeSynchronizer::PushProperties(pending_tree_->root_layer(),
1811 active_tree_->root_layer());
1812 pending_tree_->PushPropertiesTo(active_tree_.get());
1814 // Now that we've synced everything from the pending tree to the active
1815 // tree, rename the pending tree the recycle tree so we can reuse it on the
1817 DCHECK(!recycle_tree_);
1818 pending_tree_.swap(recycle_tree_);
1820 active_tree_->SetRootLayerScrollOffsetDelegate(
1821 root_layer_scroll_offset_delegate_);
1823 if (top_controls_manager_) {
1824 top_controls_manager_->SetControlsTopOffset(
1825 active_tree_->total_top_controls_content_offset() -
1826 top_controls_manager_->top_controls_height());
1829 UpdateInnerViewportContainerSize();
1831 active_tree_->ProcessUIResourceRequestQueue();
1834 active_tree_->DidBecomeActive();
1835 ActivateAnimations();
1836 if (settings_.impl_side_painting)
1837 client_->RenewTreePriority();
1839 client_->OnCanDrawStateChanged(CanDraw());
1840 client_->DidActivateSyncTree();
1841 if (!tree_activation_callback_.is_null())
1842 tree_activation_callback_.Run();
1844 if (debug_state_.continuous_painting) {
1845 const RenderingStats& stats =
1846 rendering_stats_instrumentation_->GetRenderingStats();
1847 paint_time_counter_->SavePaintTime(stats.main_stats.paint_time +
1848 stats.main_stats.record_time +
1849 stats.impl_stats.rasterize_time);
1852 if (time_source_client_adapter_ && time_source_client_adapter_->Active())
1853 DCHECK(active_tree_->root_layer());
1856 void LayerTreeHostImpl::SetVisible(bool visible) {
1857 DCHECK(proxy_->IsImplThread());
1859 if (visible_ == visible)
1862 DidVisibilityChange(this, visible_);
1863 EnforceManagedMemoryPolicy(ActualManagedMemoryPolicy());
1865 // If we just became visible, we have to ensure that we draw high res tiles,
1866 // to prevent checkerboard/low res flashes.
1868 active_tree()->SetRequiresHighResToDraw();
1870 EvictAllUIResources();
1872 // Evict tiles immediately if invisible since this tab may never get another
1873 // draw or timer tick.
1880 renderer_->SetVisible(visible);
1883 void LayerTreeHostImpl::SetNeedsAnimate() {
1884 NotifySwapPromiseMonitorsOfSetNeedsRedraw();
1885 client_->SetNeedsAnimateOnImplThread();
1888 void LayerTreeHostImpl::SetNeedsRedraw() {
1889 NotifySwapPromiseMonitorsOfSetNeedsRedraw();
1890 client_->SetNeedsRedrawOnImplThread();
1893 ManagedMemoryPolicy LayerTreeHostImpl::ActualManagedMemoryPolicy() const {
1894 ManagedMemoryPolicy actual = cached_managed_memory_policy_;
1895 if (debug_state_.rasterize_only_visible_content) {
1896 actual.priority_cutoff_when_visible =
1897 gpu::MemoryAllocation::CUTOFF_ALLOW_REQUIRED_ONLY;
1898 } else if (use_gpu_rasterization()) {
1899 actual.priority_cutoff_when_visible =
1900 gpu::MemoryAllocation::CUTOFF_ALLOW_NICE_TO_HAVE;
1904 actual.bytes_limit_when_visible = 0;
1910 size_t LayerTreeHostImpl::memory_allocation_limit_bytes() const {
1911 return ActualManagedMemoryPolicy().bytes_limit_when_visible;
1914 int LayerTreeHostImpl::memory_allocation_priority_cutoff() const {
1915 return ManagedMemoryPolicy::PriorityCutoffToValue(
1916 ActualManagedMemoryPolicy().priority_cutoff_when_visible);
1919 void LayerTreeHostImpl::ReleaseTreeResources() {
1920 active_tree_->ReleaseResources();
1922 pending_tree_->ReleaseResources();
1924 recycle_tree_->ReleaseResources();
1926 EvictAllUIResources();
1929 void LayerTreeHostImpl::CreateAndSetRenderer() {
1931 DCHECK(output_surface_);
1932 DCHECK(resource_provider_);
1934 if (output_surface_->capabilities().delegated_rendering) {
1935 renderer_ = DelegatingRenderer::Create(
1936 this, &settings_, output_surface_.get(), resource_provider_.get());
1937 } else if (output_surface_->context_provider()) {
1938 renderer_ = GLRenderer::Create(this,
1940 output_surface_.get(),
1941 resource_provider_.get(),
1942 texture_mailbox_deleter_.get(),
1943 settings_.highp_threshold_min);
1944 } else if (output_surface_->software_device()) {
1945 renderer_ = SoftwareRenderer::Create(
1946 this, &settings_, output_surface_.get(), resource_provider_.get());
1950 renderer_->SetVisible(visible_);
1951 SetFullRootLayerDamage();
1953 // See note in LayerTreeImpl::UpdateDrawProperties. Renderer needs to be
1954 // initialized to get max texture size. Also, after releasing resources,
1955 // trees need another update to generate new ones.
1956 active_tree_->set_needs_update_draw_properties();
1958 pending_tree_->set_needs_update_draw_properties();
1959 client_->UpdateRendererCapabilitiesOnImplThread();
1962 void LayerTreeHostImpl::CreateAndSetTileManager() {
1963 DCHECK(!tile_manager_);
1964 DCHECK(settings_.impl_side_painting);
1965 DCHECK(output_surface_);
1966 DCHECK(resource_provider_);
1967 DCHECK(proxy_->ImplThreadTaskRunner());
1969 ContextProvider* context_provider = output_surface_->context_provider();
1970 if (!context_provider) {
1972 ResourcePool::Create(resource_provider_.get(),
1974 resource_provider_->best_texture_format());
1976 raster_worker_pool_ =
1977 BitmapRasterWorkerPool::Create(proxy_->ImplThreadTaskRunner(),
1978 RasterWorkerPool::GetTaskGraphRunner(),
1979 resource_provider_.get());
1980 } else if (use_gpu_rasterization_) {
1982 ResourcePool::Create(resource_provider_.get(),
1984 resource_provider_->best_texture_format());
1986 raster_worker_pool_ =
1987 GpuRasterWorkerPool::Create(proxy_->ImplThreadTaskRunner(),
1989 resource_provider_.get());
1990 } else if (UseZeroCopyRasterizer()) {
1991 resource_pool_ = ResourcePool::Create(
1992 resource_provider_.get(),
1993 GetMapImageTextureTarget(context_provider->ContextCapabilities()),
1994 resource_provider_->best_texture_format());
1996 raster_worker_pool_ =
1997 ZeroCopyRasterWorkerPool::Create(proxy_->ImplThreadTaskRunner(),
1998 RasterWorkerPool::GetTaskGraphRunner(),
1999 resource_provider_.get());
2000 } else if (UseOneCopyRasterizer()) {
2001 // We need to create a staging resource pool when using copy rasterizer.
2002 staging_resource_pool_ = ResourcePool::Create(
2003 resource_provider_.get(),
2004 GetMapImageTextureTarget(context_provider->ContextCapabilities()),
2005 resource_provider_->best_texture_format());
2007 ResourcePool::Create(resource_provider_.get(),
2009 resource_provider_->best_texture_format());
2011 raster_worker_pool_ =
2012 OneCopyRasterWorkerPool::Create(proxy_->ImplThreadTaskRunner(),
2013 RasterWorkerPool::GetTaskGraphRunner(),
2015 resource_provider_.get(),
2016 staging_resource_pool_.get());
2018 resource_pool_ = ResourcePool::Create(
2019 resource_provider_.get(),
2021 resource_provider_->memory_efficient_texture_format());
2023 raster_worker_pool_ = PixelBufferRasterWorkerPool::Create(
2024 proxy_->ImplThreadTaskRunner(),
2025 RasterWorkerPool::GetTaskGraphRunner(),
2027 resource_provider_.get(),
2028 GetMaxTransferBufferUsageBytes(context_provider->ContextCapabilities(),
2029 settings_.refresh_rate));
2033 TileManager::Create(this,
2034 proxy_->ImplThreadTaskRunner(),
2035 resource_pool_.get(),
2036 raster_worker_pool_->AsRasterizer(),
2037 rendering_stats_instrumentation_);
2039 UpdateTileManagerMemoryPolicy(ActualManagedMemoryPolicy());
2040 need_to_update_visible_tiles_before_draw_ = false;
2043 void LayerTreeHostImpl::DestroyTileManager() {
2044 tile_manager_.reset();
2045 resource_pool_.reset();
2046 staging_resource_pool_.reset();
2047 raster_worker_pool_.reset();
2050 bool LayerTreeHostImpl::UsePendingTreeForSync() const {
2051 // In impl-side painting, synchronize to the pending tree so that it has
2052 // time to raster before being displayed.
2053 return settings_.impl_side_painting;
2056 bool LayerTreeHostImpl::UseZeroCopyRasterizer() const {
2057 return settings_.use_zero_copy && GetRendererCapabilities().using_map_image;
2060 bool LayerTreeHostImpl::UseOneCopyRasterizer() const {
2061 // Sync query support is required by one-copy rasterizer.
2062 return settings_.use_one_copy && GetRendererCapabilities().using_map_image &&
2063 resource_provider_->use_sync_query();
2066 void LayerTreeHostImpl::EnforceZeroBudget(bool zero_budget) {
2067 SetManagedMemoryPolicy(cached_managed_memory_policy_, zero_budget);
2070 bool LayerTreeHostImpl::InitializeRenderer(
2071 scoped_ptr<OutputSurface> output_surface) {
2072 TRACE_EVENT0("cc", "LayerTreeHostImpl::InitializeRenderer");
2074 // Since we will create a new resource provider, we cannot continue to use
2075 // the old resources (i.e. render_surfaces and texture IDs). Clear them
2076 // before we destroy the old resource provider.
2077 ReleaseTreeResources();
2079 // Note: order is important here.
2081 DestroyTileManager();
2082 resource_provider_.reset();
2083 output_surface_.reset();
2085 if (!output_surface->BindToClient(this))
2088 output_surface_ = output_surface.Pass();
2089 resource_provider_ =
2090 ResourceProvider::Create(output_surface_.get(),
2091 shared_bitmap_manager_,
2092 proxy_->blocking_main_thread_task_runner(),
2093 settings_.highp_threshold_min,
2094 settings_.use_rgba_4444_textures,
2095 settings_.texture_id_allocation_chunk_size,
2096 settings_.use_distance_field_text);
2098 if (output_surface_->capabilities().deferred_gl_initialization)
2099 EnforceZeroBudget(true);
2101 CreateAndSetRenderer();
2103 if (settings_.impl_side_painting)
2104 CreateAndSetTileManager();
2106 // Initialize vsync parameters to sane values.
2107 const base::TimeDelta display_refresh_interval =
2108 base::TimeDelta::FromMicroseconds(base::Time::kMicrosecondsPerSecond /
2109 settings_.refresh_rate);
2110 CommitVSyncParameters(base::TimeTicks(), display_refresh_interval);
2112 // TODO(brianderson): Don't use a hard-coded parent draw time.
2113 base::TimeDelta parent_draw_time =
2114 (!settings_.begin_frame_scheduling_enabled &&
2115 output_surface_->capabilities().adjust_deadline_for_parent)
2116 ? BeginFrameArgs::DefaultEstimatedParentDrawTime()
2117 : base::TimeDelta();
2118 client_->SetEstimatedParentDrawTime(parent_draw_time);
2120 int max_frames_pending = output_surface_->capabilities().max_frames_pending;
2121 if (max_frames_pending <= 0)
2122 max_frames_pending = OutputSurface::DEFAULT_MAX_FRAMES_PENDING;
2123 client_->SetMaxSwapsPendingOnImplThread(max_frames_pending);
2124 client_->OnCanDrawStateChanged(CanDraw());
2126 // There will not be anything to draw here, so set high res
2127 // to avoid checkerboards, typically when we are recovering
2128 // from lost context.
2129 active_tree_->SetRequiresHighResToDraw();
2134 void LayerTreeHostImpl::CommitVSyncParameters(base::TimeTicks timebase,
2135 base::TimeDelta interval) {
2136 client_->CommitVSyncParameters(timebase, interval);
2139 void LayerTreeHostImpl::DeferredInitialize() {
2140 DCHECK(output_surface_->capabilities().deferred_gl_initialization);
2141 DCHECK(settings_.impl_side_painting);
2142 DCHECK(output_surface_->context_provider());
2144 ReleaseTreeResources();
2146 DestroyTileManager();
2148 resource_provider_->InitializeGL();
2150 CreateAndSetRenderer();
2151 EnforceZeroBudget(false);
2152 CreateAndSetTileManager();
2154 client_->SetNeedsCommitOnImplThread();
2157 void LayerTreeHostImpl::ReleaseGL() {
2158 DCHECK(output_surface_->capabilities().deferred_gl_initialization);
2159 DCHECK(settings_.impl_side_painting);
2160 DCHECK(output_surface_->context_provider());
2162 ReleaseTreeResources();
2164 DestroyTileManager();
2166 resource_provider_->InitializeSoftware();
2167 output_surface_->ReleaseContextProvider();
2169 CreateAndSetRenderer();
2170 EnforceZeroBudget(true);
2171 CreateAndSetTileManager();
2173 client_->SetNeedsCommitOnImplThread();
2176 void LayerTreeHostImpl::SetViewportSize(const gfx::Size& device_viewport_size) {
2177 if (device_viewport_size == device_viewport_size_)
2181 active_tree_->SetViewportSizeInvalid();
2183 device_viewport_size_ = device_viewport_size;
2185 UpdateInnerViewportContainerSize();
2186 client_->OnCanDrawStateChanged(CanDraw());
2187 SetFullRootLayerDamage();
2188 active_tree_->set_needs_update_draw_properties();
2191 void LayerTreeHostImpl::SetOverhangUIResource(
2192 UIResourceId overhang_ui_resource_id,
2193 const gfx::Size& overhang_ui_resource_size) {
2194 overhang_ui_resource_id_ = overhang_ui_resource_id;
2195 overhang_ui_resource_size_ = overhang_ui_resource_size;
2198 void LayerTreeHostImpl::SetDeviceScaleFactor(float device_scale_factor) {
2199 if (device_scale_factor == device_scale_factor_)
2201 device_scale_factor_ = device_scale_factor;
2203 SetFullRootLayerDamage();
2206 const gfx::Rect LayerTreeHostImpl::ViewportRectForTilePriority() const {
2207 if (viewport_rect_for_tile_priority_.IsEmpty())
2208 return DeviceViewport();
2210 return viewport_rect_for_tile_priority_;
2213 gfx::Size LayerTreeHostImpl::DrawViewportSize() const {
2214 return DeviceViewport().size();
2217 gfx::Rect LayerTreeHostImpl::DeviceViewport() const {
2218 if (external_viewport_.IsEmpty())
2219 return gfx::Rect(device_viewport_size_);
2221 return external_viewport_;
2224 gfx::Rect LayerTreeHostImpl::DeviceClip() const {
2225 if (external_clip_.IsEmpty())
2226 return DeviceViewport();
2228 return external_clip_;
2231 const gfx::Transform& LayerTreeHostImpl::DrawTransform() const {
2232 return external_transform_;
2235 void LayerTreeHostImpl::DidChangeTopControlsPosition() {
2236 UpdateInnerViewportContainerSize();
2239 active_tree_->set_needs_update_draw_properties();
2240 SetFullRootLayerDamage();
2243 void LayerTreeHostImpl::SetControlsTopOffset(float offset) {
2244 float current_top_offset = active_tree_->top_controls_content_offset() -
2245 top_controls_manager_->top_controls_height();
2246 active_tree_->set_top_controls_delta(offset - current_top_offset);
2249 float LayerTreeHostImpl::ControlsTopOffset() const {
2250 return active_tree_->total_top_controls_content_offset() -
2251 top_controls_manager_->top_controls_height();
2254 void LayerTreeHostImpl::BindToClient(InputHandlerClient* client) {
2255 DCHECK(input_handler_client_ == NULL);
2256 input_handler_client_ = client;
2259 static LayerImpl* NextScrollLayer(LayerImpl* layer) {
2260 if (LayerImpl* scroll_parent = layer->scroll_parent())
2261 return scroll_parent;
2262 return layer->parent();
2265 LayerImpl* LayerTreeHostImpl::FindScrollLayerForDeviceViewportPoint(
2266 const gfx::PointF& device_viewport_point,
2267 InputHandler::ScrollInputType type,
2268 LayerImpl* layer_impl,
2269 bool* scroll_on_main_thread,
2270 bool* optional_has_ancestor_scroll_handler) const {
2271 DCHECK(scroll_on_main_thread);
2273 // Walk up the hierarchy and look for a scrollable layer.
2274 LayerImpl* potentially_scrolling_layer_impl = NULL;
2275 for (; layer_impl; layer_impl = NextScrollLayer(layer_impl)) {
2276 // The content layer can also block attempts to scroll outside the main
2278 ScrollStatus status = layer_impl->TryScroll(device_viewport_point, type);
2279 if (status == ScrollOnMainThread) {
2280 *scroll_on_main_thread = true;
2284 LayerImpl* scroll_layer_impl = FindScrollLayerForContentLayer(layer_impl);
2285 if (!scroll_layer_impl)
2288 status = scroll_layer_impl->TryScroll(device_viewport_point, type);
2289 // If any layer wants to divert the scroll event to the main thread, abort.
2290 if (status == ScrollOnMainThread) {
2291 *scroll_on_main_thread = true;
2295 if (optional_has_ancestor_scroll_handler &&
2296 scroll_layer_impl->have_scroll_event_handlers())
2297 *optional_has_ancestor_scroll_handler = true;
2299 if (status == ScrollStarted && !potentially_scrolling_layer_impl)
2300 potentially_scrolling_layer_impl = scroll_layer_impl;
2303 // Falling back to the root scroll layer ensures generation of root overscroll
2304 // notifications while preventing scroll updates from being unintentionally
2305 // forwarded to the main thread.
2306 if (!potentially_scrolling_layer_impl)
2307 potentially_scrolling_layer_impl = OuterViewportScrollLayer()
2308 ? OuterViewportScrollLayer()
2309 : InnerViewportScrollLayer();
2311 return potentially_scrolling_layer_impl;
2314 // Similar to LayerImpl::HasAncestor, but walks up the scroll parents.
2315 static bool HasScrollAncestor(LayerImpl* child, LayerImpl* scroll_ancestor) {
2316 DCHECK(scroll_ancestor);
2317 for (LayerImpl* ancestor = child; ancestor;
2318 ancestor = NextScrollLayer(ancestor)) {
2319 if (ancestor->scrollable())
2320 return ancestor == scroll_ancestor;
2325 InputHandler::ScrollStatus LayerTreeHostImpl::ScrollBegin(
2326 const gfx::Point& viewport_point,
2327 InputHandler::ScrollInputType type) {
2328 TRACE_EVENT0("cc", "LayerTreeHostImpl::ScrollBegin");
2330 if (top_controls_manager_)
2331 top_controls_manager_->ScrollBegin();
2333 DCHECK(!CurrentlyScrollingLayer());
2334 ClearCurrentlyScrollingLayer();
2336 gfx::PointF device_viewport_point = gfx::ScalePoint(viewport_point,
2337 device_scale_factor_);
2338 LayerImpl* layer_impl =
2339 active_tree_->FindLayerThatIsHitByPoint(device_viewport_point);
2342 LayerImpl* scroll_layer_impl =
2343 active_tree_->FindFirstScrollingLayerThatIsHitByPoint(
2344 device_viewport_point);
2345 if (scroll_layer_impl && !HasScrollAncestor(layer_impl, scroll_layer_impl))
2346 return ScrollUnknown;
2349 bool scroll_on_main_thread = false;
2350 LayerImpl* scrolling_layer_impl =
2351 FindScrollLayerForDeviceViewportPoint(device_viewport_point,
2354 &scroll_on_main_thread,
2355 &scroll_affects_scroll_handler_);
2357 if (scroll_on_main_thread) {
2358 UMA_HISTOGRAM_BOOLEAN("TryScroll.SlowScroll", true);
2359 return ScrollOnMainThread;
2362 if (scrolling_layer_impl) {
2363 active_tree_->SetCurrentlyScrollingLayer(scrolling_layer_impl);
2364 should_bubble_scrolls_ = (type != NonBubblingGesture);
2365 wheel_scrolling_ = (type == Wheel);
2366 client_->RenewTreePriority();
2367 UMA_HISTOGRAM_BOOLEAN("TryScroll.SlowScroll", false);
2368 return ScrollStarted;
2370 return ScrollIgnored;
2373 InputHandler::ScrollStatus LayerTreeHostImpl::ScrollAnimated(
2374 const gfx::Point& viewport_point,
2375 const gfx::Vector2dF& scroll_delta) {
2376 if (LayerImpl* layer_impl = CurrentlyScrollingLayer()) {
2377 Animation* animation =
2378 layer_impl->layer_animation_controller()->GetAnimation(
2379 Animation::ScrollOffset);
2381 return ScrollIgnored;
2383 ScrollOffsetAnimationCurve* curve =
2384 animation->curve()->ToScrollOffsetAnimationCurve();
2386 gfx::Vector2dF new_target = curve->target_value() + scroll_delta;
2387 new_target.SetToMax(gfx::Vector2dF());
2388 new_target.SetToMin(layer_impl->MaxScrollOffset());
2390 curve->UpdateTarget(animation->TrimTimeToCurrentIteration(
2391 CurrentBeginFrameArgs().frame_time),
2394 return ScrollStarted;
2396 // ScrollAnimated is only used for wheel scrolls. We use the same bubbling
2397 // behavior as ScrollBy to determine which layer to animate, but we do not
2398 // do the Android-specific things in ScrollBy like showing top controls.
2399 InputHandler::ScrollStatus scroll_status = ScrollBegin(viewport_point, Wheel);
2400 if (scroll_status == ScrollStarted) {
2401 gfx::Vector2dF pending_delta = scroll_delta;
2402 for (LayerImpl* layer_impl = CurrentlyScrollingLayer(); layer_impl;
2403 layer_impl = layer_impl->parent()) {
2404 if (!layer_impl->scrollable())
2407 gfx::Vector2dF current_offset = layer_impl->TotalScrollOffset();
2408 gfx::Vector2dF target_offset = current_offset + pending_delta;
2409 target_offset.SetToMax(gfx::Vector2dF());
2410 target_offset.SetToMin(layer_impl->MaxScrollOffset());
2411 gfx::Vector2dF actual_delta = target_offset - current_offset;
2413 const float kEpsilon = 0.1f;
2414 bool can_layer_scroll = (std::abs(actual_delta.x()) > kEpsilon ||
2415 std::abs(actual_delta.y()) > kEpsilon);
2417 if (!can_layer_scroll) {
2418 layer_impl->ScrollBy(actual_delta);
2419 pending_delta -= actual_delta;
2423 active_tree_->SetCurrentlyScrollingLayer(layer_impl);
2425 scoped_ptr<ScrollOffsetAnimationCurve> curve =
2426 ScrollOffsetAnimationCurve::Create(target_offset,
2427 EaseInOutTimingFunction::Create());
2428 curve->SetInitialValue(current_offset);
2430 scoped_ptr<Animation> animation =
2431 Animation::Create(curve.PassAs<AnimationCurve>(),
2432 AnimationIdProvider::NextAnimationId(),
2433 AnimationIdProvider::NextGroupId(),
2434 Animation::ScrollOffset);
2435 animation->set_is_impl_only(true);
2437 layer_impl->layer_animation_controller()->AddAnimation(animation.Pass());
2440 return ScrollStarted;
2444 return scroll_status;
2447 gfx::Vector2dF LayerTreeHostImpl::ScrollLayerWithViewportSpaceDelta(
2448 LayerImpl* layer_impl,
2449 float scale_from_viewport_to_screen_space,
2450 const gfx::PointF& viewport_point,
2451 const gfx::Vector2dF& viewport_delta) {
2452 // Layers with non-invertible screen space transforms should not have passed
2453 // the scroll hit test in the first place.
2454 DCHECK(layer_impl->screen_space_transform().IsInvertible());
2455 gfx::Transform inverse_screen_space_transform(
2456 gfx::Transform::kSkipInitialization);
2457 bool did_invert = layer_impl->screen_space_transform().GetInverse(
2458 &inverse_screen_space_transform);
2459 // TODO(shawnsingh): With the advent of impl-side crolling for non-root
2460 // layers, we may need to explicitly handle uninvertible transforms here.
2463 gfx::PointF screen_space_point =
2464 gfx::ScalePoint(viewport_point, scale_from_viewport_to_screen_space);
2466 gfx::Vector2dF screen_space_delta = viewport_delta;
2467 screen_space_delta.Scale(scale_from_viewport_to_screen_space);
2469 // First project the scroll start and end points to local layer space to find
2470 // the scroll delta in layer coordinates.
2471 bool start_clipped, end_clipped;
2472 gfx::PointF screen_space_end_point = screen_space_point + screen_space_delta;
2473 gfx::PointF local_start_point =
2474 MathUtil::ProjectPoint(inverse_screen_space_transform,
2477 gfx::PointF local_end_point =
2478 MathUtil::ProjectPoint(inverse_screen_space_transform,
2479 screen_space_end_point,
2482 // In general scroll point coordinates should not get clipped.
2483 DCHECK(!start_clipped);
2484 DCHECK(!end_clipped);
2485 if (start_clipped || end_clipped)
2486 return gfx::Vector2dF();
2488 // local_start_point and local_end_point are in content space but we want to
2489 // move them to layer space for scrolling.
2490 float width_scale = 1.f / layer_impl->contents_scale_x();
2491 float height_scale = 1.f / layer_impl->contents_scale_y();
2492 local_start_point.Scale(width_scale, height_scale);
2493 local_end_point.Scale(width_scale, height_scale);
2495 // Apply the scroll delta.
2496 gfx::Vector2dF previous_delta = layer_impl->ScrollDelta();
2497 layer_impl->ScrollBy(local_end_point - local_start_point);
2499 // Get the end point in the layer's content space so we can apply its
2500 // ScreenSpaceTransform.
2501 gfx::PointF actual_local_end_point = local_start_point +
2502 layer_impl->ScrollDelta() -
2504 gfx::PointF actual_local_content_end_point =
2505 gfx::ScalePoint(actual_local_end_point,
2507 1.f / height_scale);
2509 // Calculate the applied scroll delta in viewport space coordinates.
2510 gfx::PointF actual_screen_space_end_point =
2511 MathUtil::MapPoint(layer_impl->screen_space_transform(),
2512 actual_local_content_end_point,
2514 DCHECK(!end_clipped);
2516 return gfx::Vector2dF();
2517 gfx::PointF actual_viewport_end_point =
2518 gfx::ScalePoint(actual_screen_space_end_point,
2519 1.f / scale_from_viewport_to_screen_space);
2520 return actual_viewport_end_point - viewport_point;
2523 static gfx::Vector2dF ScrollLayerWithLocalDelta(LayerImpl* layer_impl,
2524 const gfx::Vector2dF& local_delta) {
2525 gfx::Vector2dF previous_delta(layer_impl->ScrollDelta());
2526 layer_impl->ScrollBy(local_delta);
2527 return layer_impl->ScrollDelta() - previous_delta;
2530 bool LayerTreeHostImpl::ScrollBy(const gfx::Point& viewport_point,
2531 const gfx::Vector2dF& scroll_delta) {
2532 TRACE_EVENT0("cc", "LayerTreeHostImpl::ScrollBy");
2533 if (!CurrentlyScrollingLayer())
2536 gfx::Vector2dF pending_delta = scroll_delta;
2537 gfx::Vector2dF unused_root_delta;
2538 bool did_scroll_x = false;
2539 bool did_scroll_y = false;
2540 bool did_scroll_top_controls = false;
2541 // TODO(wjmaclean) Should we guard against CurrentlyScrollingLayer() == 0
2543 bool consume_by_top_controls =
2544 top_controls_manager_ &&
2545 (((CurrentlyScrollingLayer() == InnerViewportScrollLayer() ||
2546 CurrentlyScrollingLayer() == OuterViewportScrollLayer()) &&
2547 InnerViewportScrollLayer()->MaxScrollOffset().y() > 0) ||
2548 scroll_delta.y() < 0);
2550 for (LayerImpl* layer_impl = CurrentlyScrollingLayer();
2552 layer_impl = layer_impl->parent()) {
2553 if (!layer_impl->scrollable())
2556 if (layer_impl == InnerViewportScrollLayer()) {
2557 // Only allow bubble scrolling when the scroll is in the direction to make
2558 // the top controls visible.
2559 gfx::Vector2dF applied_delta;
2560 gfx::Vector2dF excess_delta;
2561 if (consume_by_top_controls) {
2562 excess_delta = top_controls_manager_->ScrollBy(pending_delta);
2563 applied_delta = pending_delta - excess_delta;
2564 pending_delta = excess_delta;
2565 // Force updating of vertical adjust values if needed.
2566 if (applied_delta.y() != 0) {
2567 did_scroll_top_controls = true;
2568 layer_impl->ScrollbarParametersDidChange();
2571 // Track root layer deltas for reporting overscroll.
2572 unused_root_delta = pending_delta;
2575 gfx::Vector2dF applied_delta;
2576 // Gesture events need to be transformed from viewport coordinates to local
2577 // layer coordinates so that the scrolling contents exactly follow the
2578 // user's finger. In contrast, wheel events represent a fixed amount of
2579 // scrolling so we can just apply them directly.
2580 if (!wheel_scrolling_) {
2581 float scale_from_viewport_to_screen_space = device_scale_factor_;
2583 ScrollLayerWithViewportSpaceDelta(layer_impl,
2584 scale_from_viewport_to_screen_space,
2585 viewport_point, pending_delta);
2587 applied_delta = ScrollLayerWithLocalDelta(layer_impl, pending_delta);
2590 const float kEpsilon = 0.1f;
2591 if (layer_impl == InnerViewportScrollLayer()) {
2592 unused_root_delta.Subtract(applied_delta);
2593 if (std::abs(unused_root_delta.x()) < kEpsilon)
2594 unused_root_delta.set_x(0.0f);
2595 if (std::abs(unused_root_delta.y()) < kEpsilon)
2596 unused_root_delta.set_y(0.0f);
2597 // Disable overscroll on axes which is impossible to scroll.
2598 if (settings_.report_overscroll_only_for_scrollable_axes) {
2599 if (std::abs(active_tree_->TotalMaxScrollOffset().x()) <= kEpsilon)
2600 unused_root_delta.set_x(0.0f);
2601 if (std::abs(active_tree_->TotalMaxScrollOffset().y()) <= kEpsilon)
2602 unused_root_delta.set_y(0.0f);
2606 // If the layer wasn't able to move, try the next one in the hierarchy.
2607 bool did_move_layer_x = std::abs(applied_delta.x()) > kEpsilon;
2608 bool did_move_layer_y = std::abs(applied_delta.y()) > kEpsilon;
2609 did_scroll_x |= did_move_layer_x;
2610 did_scroll_y |= did_move_layer_y;
2611 if (!did_move_layer_x && !did_move_layer_y) {
2612 // Scrolls should always bubble between the outer and inner viewports
2613 if (should_bubble_scrolls_ || !did_lock_scrolling_layer_ ||
2614 layer_impl == OuterViewportScrollLayer())
2620 did_lock_scrolling_layer_ = true;
2621 if (!should_bubble_scrolls_) {
2622 active_tree_->SetCurrentlyScrollingLayer(layer_impl);
2626 // If the applied delta is within 45 degrees of the input delta, bail out to
2627 // make it easier to scroll just one layer in one direction without
2628 // affecting any of its parents.
2629 float angle_threshold = 45;
2630 if (MathUtil::SmallestAngleBetweenVectors(
2631 applied_delta, pending_delta) < angle_threshold) {
2632 pending_delta = gfx::Vector2d();
2636 // Allow further movement only on an axis perpendicular to the direction in
2637 // which the layer moved.
2638 gfx::Vector2dF perpendicular_axis(-applied_delta.y(), applied_delta.x());
2639 pending_delta = MathUtil::ProjectVector(pending_delta, perpendicular_axis);
2641 if (gfx::ToRoundedVector2d(pending_delta).IsZero())
2645 bool did_scroll_content = did_scroll_x || did_scroll_y;
2646 if (did_scroll_content) {
2647 // If we are scrolling with an active scroll handler, forward latency
2648 // tracking information to the main thread so the delay introduced by the
2649 // handler is accounted for.
2650 if (scroll_affects_scroll_handler())
2651 NotifySwapPromiseMonitorsOfForwardingToMainThread();
2652 client_->SetNeedsCommitOnImplThread();
2654 client_->RenewTreePriority();
2657 // Scrolling along an axis resets accumulated root overscroll for that axis.
2659 accumulated_root_overscroll_.set_x(0);
2661 accumulated_root_overscroll_.set_y(0);
2663 accumulated_root_overscroll_ += unused_root_delta;
2664 bool did_overscroll = !unused_root_delta.IsZero();
2665 if (did_overscroll && input_handler_client_) {
2666 input_handler_client_->DidOverscroll(
2667 viewport_point, accumulated_root_overscroll_, unused_root_delta);
2670 return did_scroll_content || did_scroll_top_controls;
2673 // This implements scrolling by page as described here:
2674 // http://msdn.microsoft.com/en-us/library/windows/desktop/ms645601(v=vs.85).aspx#_win32_The_Mouse_Wheel
2675 // for events with WHEEL_PAGESCROLL set.
2676 bool LayerTreeHostImpl::ScrollVerticallyByPage(const gfx::Point& viewport_point,
2677 ScrollDirection direction) {
2678 DCHECK(wheel_scrolling_);
2680 for (LayerImpl* layer_impl = CurrentlyScrollingLayer();
2682 layer_impl = layer_impl->parent()) {
2683 if (!layer_impl->scrollable())
2686 if (!layer_impl->HasScrollbar(VERTICAL))
2689 float height = layer_impl->clip_height();
2691 // These magical values match WebKit and are designed to scroll nearly the
2692 // entire visible content height but leave a bit of overlap.
2693 float page = std::max(height * 0.875f, 1.f);
2694 if (direction == SCROLL_BACKWARD)
2697 gfx::Vector2dF delta = gfx::Vector2dF(0.f, page);
2699 gfx::Vector2dF applied_delta = ScrollLayerWithLocalDelta(layer_impl, delta);
2701 if (!applied_delta.IsZero()) {
2702 client_->SetNeedsCommitOnImplThread();
2704 client_->RenewTreePriority();
2708 active_tree_->SetCurrentlyScrollingLayer(layer_impl);
2714 void LayerTreeHostImpl::SetRootLayerScrollOffsetDelegate(
2715 LayerScrollOffsetDelegate* root_layer_scroll_offset_delegate) {
2716 root_layer_scroll_offset_delegate_ = root_layer_scroll_offset_delegate;
2717 active_tree_->SetRootLayerScrollOffsetDelegate(
2718 root_layer_scroll_offset_delegate_);
2721 void LayerTreeHostImpl::OnRootLayerDelegatedScrollOffsetChanged() {
2722 DCHECK(root_layer_scroll_offset_delegate_ != NULL);
2723 client_->SetNeedsCommitOnImplThread();
2724 active_tree_->set_needs_update_draw_properties();
2727 void LayerTreeHostImpl::ClearCurrentlyScrollingLayer() {
2728 active_tree_->ClearCurrentlyScrollingLayer();
2729 did_lock_scrolling_layer_ = false;
2730 scroll_affects_scroll_handler_ = false;
2731 accumulated_root_overscroll_ = gfx::Vector2dF();
2734 void LayerTreeHostImpl::ScrollEnd() {
2735 if (top_controls_manager_)
2736 top_controls_manager_->ScrollEnd();
2737 ClearCurrentlyScrollingLayer();
2740 InputHandler::ScrollStatus LayerTreeHostImpl::FlingScrollBegin() {
2741 if (!active_tree_->CurrentlyScrollingLayer())
2742 return ScrollIgnored;
2744 if (settings_.ignore_root_layer_flings &&
2745 (active_tree_->CurrentlyScrollingLayer() == InnerViewportScrollLayer() ||
2746 active_tree_->CurrentlyScrollingLayer() == OuterViewportScrollLayer())) {
2747 ClearCurrentlyScrollingLayer();
2748 return ScrollIgnored;
2751 if (!wheel_scrolling_) {
2752 // Allow the fling to lock to the first layer that moves after the initial
2753 // fling |ScrollBy()| event.
2754 did_lock_scrolling_layer_ = false;
2755 should_bubble_scrolls_ = false;
2758 return ScrollStarted;
2761 float LayerTreeHostImpl::DeviceSpaceDistanceToLayer(
2762 const gfx::PointF& device_viewport_point,
2763 LayerImpl* layer_impl) {
2765 return std::numeric_limits<float>::max();
2767 gfx::Rect layer_impl_bounds(
2768 layer_impl->content_bounds());
2770 gfx::RectF device_viewport_layer_impl_bounds = MathUtil::MapClippedRect(
2771 layer_impl->screen_space_transform(),
2774 return device_viewport_layer_impl_bounds.ManhattanDistanceToPoint(
2775 device_viewport_point);
2778 void LayerTreeHostImpl::MouseMoveAt(const gfx::Point& viewport_point) {
2779 gfx::PointF device_viewport_point = gfx::ScalePoint(viewport_point,
2780 device_scale_factor_);
2781 LayerImpl* layer_impl =
2782 active_tree_->FindLayerThatIsHitByPoint(device_viewport_point);
2783 if (HandleMouseOverScrollbar(layer_impl, device_viewport_point))
2786 if (scroll_layer_id_when_mouse_over_scrollbar_) {
2787 LayerImpl* scroll_layer_impl = active_tree_->LayerById(
2788 scroll_layer_id_when_mouse_over_scrollbar_);
2790 // The check for a null scroll_layer_impl below was added to see if it will
2791 // eliminate the crashes described in http://crbug.com/326635.
2792 // TODO(wjmaclean) Add a unit test if this fixes the crashes.
2793 ScrollbarAnimationController* animation_controller =
2794 scroll_layer_impl ? scroll_layer_impl->scrollbar_animation_controller()
2796 if (animation_controller)
2797 animation_controller->DidMouseMoveOffScrollbar();
2798 scroll_layer_id_when_mouse_over_scrollbar_ = 0;
2801 bool scroll_on_main_thread = false;
2802 LayerImpl* scroll_layer_impl =
2803 FindScrollLayerForDeviceViewportPoint(device_viewport_point,
2804 InputHandler::Gesture,
2806 &scroll_on_main_thread,
2808 if (scroll_on_main_thread || !scroll_layer_impl)
2811 ScrollbarAnimationController* animation_controller =
2812 scroll_layer_impl->scrollbar_animation_controller();
2813 if (!animation_controller)
2816 // TODO(wjmaclean) Is it ok to choose distance from more than two scrollbars?
2817 float distance_to_scrollbar = std::numeric_limits<float>::max();
2818 for (LayerImpl::ScrollbarSet::iterator it =
2819 scroll_layer_impl->scrollbars()->begin();
2820 it != scroll_layer_impl->scrollbars()->end();
2822 distance_to_scrollbar =
2823 std::min(distance_to_scrollbar,
2824 DeviceSpaceDistanceToLayer(device_viewport_point, *it));
2826 animation_controller->DidMouseMoveNear(distance_to_scrollbar /
2827 device_scale_factor_);
2830 bool LayerTreeHostImpl::HandleMouseOverScrollbar(LayerImpl* layer_impl,
2831 const gfx::PointF& device_viewport_point) {
2832 if (layer_impl && layer_impl->ToScrollbarLayer()) {
2833 int scroll_layer_id = layer_impl->ToScrollbarLayer()->ScrollLayerId();
2834 layer_impl = active_tree_->LayerById(scroll_layer_id);
2835 if (layer_impl && layer_impl->scrollbar_animation_controller()) {
2836 scroll_layer_id_when_mouse_over_scrollbar_ = scroll_layer_id;
2837 layer_impl->scrollbar_animation_controller()->DidMouseMoveNear(0);
2839 scroll_layer_id_when_mouse_over_scrollbar_ = 0;
2848 void LayerTreeHostImpl::PinchGestureBegin() {
2849 pinch_gesture_active_ = true;
2850 previous_pinch_anchor_ = gfx::Point();
2851 client_->RenewTreePriority();
2852 pinch_gesture_end_should_clear_scrolling_layer_ = !CurrentlyScrollingLayer();
2853 if (active_tree_->OuterViewportScrollLayer()) {
2854 active_tree_->SetCurrentlyScrollingLayer(
2855 active_tree_->OuterViewportScrollLayer());
2857 active_tree_->SetCurrentlyScrollingLayer(
2858 active_tree_->InnerViewportScrollLayer());
2860 if (top_controls_manager_)
2861 top_controls_manager_->PinchBegin();
2864 void LayerTreeHostImpl::PinchGestureUpdate(float magnify_delta,
2865 const gfx::Point& anchor) {
2866 if (!InnerViewportScrollLayer())
2869 TRACE_EVENT0("cc", "LayerTreeHostImpl::PinchGestureUpdate");
2871 // For a moment the scroll offset ends up being outside of the max range. This
2872 // confuses the delegate so we switch it off till after we're done processing
2873 // the pinch update.
2874 active_tree_->SetRootLayerScrollOffsetDelegate(NULL);
2876 // Keep the center-of-pinch anchor specified by (x, y) in a stable
2877 // position over the course of the magnify.
2878 float page_scale_delta = active_tree_->page_scale_delta();
2879 gfx::PointF previous_scale_anchor =
2880 gfx::ScalePoint(anchor, 1.f / page_scale_delta);
2881 active_tree_->SetPageScaleDelta(page_scale_delta * magnify_delta);
2882 page_scale_delta = active_tree_->page_scale_delta();
2883 gfx::PointF new_scale_anchor =
2884 gfx::ScalePoint(anchor, 1.f / page_scale_delta);
2885 gfx::Vector2dF move = previous_scale_anchor - new_scale_anchor;
2887 previous_pinch_anchor_ = anchor;
2889 move.Scale(1 / active_tree_->page_scale_factor());
2890 // If clamping the inner viewport scroll offset causes a change, it should
2891 // be accounted for from the intended move.
2892 move -= InnerViewportScrollLayer()->ClampScrollToMaxScrollOffset();
2894 // We manually manage the bubbling behaviour here as it is different to that
2895 // implemented in LayerTreeHostImpl::ScrollBy(). Specifically:
2896 // 1) we want to explicit limit the bubbling to the outer/inner viewports,
2897 // 2) we don't want the directional limitations on the unused parts that
2898 // ScrollBy() implements, and
2899 // 3) pinching should not engage the top controls manager.
2900 gfx::Vector2dF unused = OuterViewportScrollLayer()
2901 ? OuterViewportScrollLayer()->ScrollBy(move)
2904 if (!unused.IsZero()) {
2905 InnerViewportScrollLayer()->ScrollBy(unused);
2906 InnerViewportScrollLayer()->ClampScrollToMaxScrollOffset();
2909 active_tree_->SetRootLayerScrollOffsetDelegate(
2910 root_layer_scroll_offset_delegate_);
2912 client_->SetNeedsCommitOnImplThread();
2914 client_->RenewTreePriority();
2917 void LayerTreeHostImpl::PinchGestureEnd() {
2918 pinch_gesture_active_ = false;
2919 if (pinch_gesture_end_should_clear_scrolling_layer_) {
2920 pinch_gesture_end_should_clear_scrolling_layer_ = false;
2921 ClearCurrentlyScrollingLayer();
2923 if (top_controls_manager_)
2924 top_controls_manager_->PinchEnd();
2925 client_->SetNeedsCommitOnImplThread();
2928 static void CollectScrollDeltas(ScrollAndScaleSet* scroll_info,
2929 LayerImpl* layer_impl) {
2933 gfx::Vector2d scroll_delta =
2934 gfx::ToFlooredVector2d(layer_impl->ScrollDelta());
2935 if (!scroll_delta.IsZero()) {
2936 LayerTreeHostCommon::ScrollUpdateInfo scroll;
2937 scroll.layer_id = layer_impl->id();
2938 scroll.scroll_delta = scroll_delta;
2939 scroll_info->scrolls.push_back(scroll);
2940 layer_impl->SetSentScrollDelta(scroll_delta);
2943 for (size_t i = 0; i < layer_impl->children().size(); ++i)
2944 CollectScrollDeltas(scroll_info, layer_impl->children()[i]);
2947 scoped_ptr<ScrollAndScaleSet> LayerTreeHostImpl::ProcessScrollDeltas() {
2948 scoped_ptr<ScrollAndScaleSet> scroll_info(new ScrollAndScaleSet());
2950 CollectScrollDeltas(scroll_info.get(), active_tree_->root_layer());
2951 scroll_info->page_scale_delta = active_tree_->page_scale_delta();
2952 active_tree_->set_sent_page_scale_delta(scroll_info->page_scale_delta);
2953 scroll_info->swap_promises.swap(swap_promises_for_main_thread_scroll_update_);
2954 scroll_info->top_controls_delta = active_tree()->top_controls_delta();
2955 active_tree_->set_sent_top_controls_delta(scroll_info->top_controls_delta);
2957 return scroll_info.Pass();
2960 void LayerTreeHostImpl::SetFullRootLayerDamage() {
2961 SetViewportDamage(gfx::Rect(DrawViewportSize()));
2964 void LayerTreeHostImpl::ScrollViewportBy(gfx::Vector2dF scroll_delta) {
2965 DCHECK(InnerViewportScrollLayer());
2966 LayerImpl* scroll_layer = OuterViewportScrollLayer()
2967 ? OuterViewportScrollLayer()
2968 : InnerViewportScrollLayer();
2970 gfx::Vector2dF unused_delta = scroll_layer->ScrollBy(scroll_delta);
2972 if (!unused_delta.IsZero() && (scroll_layer == OuterViewportScrollLayer()))
2973 InnerViewportScrollLayer()->ScrollBy(unused_delta);
2976 void LayerTreeHostImpl::AnimatePageScale(base::TimeTicks monotonic_time) {
2977 if (!page_scale_animation_)
2980 gfx::Vector2dF scroll_total = active_tree_->TotalScrollOffset();
2982 if (!page_scale_animation_->IsAnimationStarted())
2983 page_scale_animation_->StartAnimation(monotonic_time);
2985 active_tree_->SetPageScaleDelta(
2986 page_scale_animation_->PageScaleFactorAtTime(monotonic_time) /
2987 active_tree_->page_scale_factor());
2988 gfx::Vector2dF next_scroll =
2989 page_scale_animation_->ScrollOffsetAtTime(monotonic_time);
2991 ScrollViewportBy(next_scroll - scroll_total);
2994 if (page_scale_animation_->IsAnimationCompleteAtTime(monotonic_time)) {
2995 page_scale_animation_.reset();
2996 client_->SetNeedsCommitOnImplThread();
2997 client_->RenewTreePriority();
3003 void LayerTreeHostImpl::AnimateTopControls(base::TimeTicks time) {
3004 if (!top_controls_manager_ || !top_controls_manager_->animation())
3007 gfx::Vector2dF scroll = top_controls_manager_->Animate(time);
3009 if (top_controls_manager_->animation())
3012 if (active_tree_->TotalScrollOffset().y() == 0.f)
3015 if (scroll.IsZero())
3018 ScrollViewportBy(gfx::ScaleVector2d(
3019 scroll, 1.f / active_tree_->total_page_scale_factor()));
3021 client_->SetNeedsCommitOnImplThread();
3022 client_->RenewTreePriority();
3025 void LayerTreeHostImpl::AnimateLayers(base::TimeTicks monotonic_time) {
3026 if (!settings_.accelerated_animation_enabled ||
3027 !needs_animate_layers() ||
3028 !active_tree_->root_layer())
3031 TRACE_EVENT0("cc", "LayerTreeHostImpl::AnimateLayers");
3032 AnimationRegistrar::AnimationControllerMap copy =
3033 animation_registrar_->active_animation_controllers();
3034 for (AnimationRegistrar::AnimationControllerMap::iterator iter = copy.begin();
3037 (*iter).second->Animate(monotonic_time);
3042 void LayerTreeHostImpl::UpdateAnimationState(bool start_ready_animations) {
3043 if (!settings_.accelerated_animation_enabled ||
3044 !needs_animate_layers() ||
3045 !active_tree_->root_layer())
3048 TRACE_EVENT0("cc", "LayerTreeHostImpl::UpdateAnimationState");
3049 scoped_ptr<AnimationEventsVector> events =
3050 make_scoped_ptr(new AnimationEventsVector);
3051 AnimationRegistrar::AnimationControllerMap copy =
3052 animation_registrar_->active_animation_controllers();
3053 for (AnimationRegistrar::AnimationControllerMap::iterator iter = copy.begin();
3056 (*iter).second->UpdateState(start_ready_animations, events.get());
3058 if (!events->empty()) {
3059 client_->PostAnimationEventsToMainThreadOnImplThread(events.Pass());
3065 void LayerTreeHostImpl::ActivateAnimations() {
3066 if (!settings_.accelerated_animation_enabled || !needs_animate_layers() ||
3067 !active_tree_->root_layer())
3070 TRACE_EVENT0("cc", "LayerTreeHostImpl::ActivateAnimations");
3071 AnimationRegistrar::AnimationControllerMap copy =
3072 animation_registrar_->active_animation_controllers();
3073 for (AnimationRegistrar::AnimationControllerMap::iterator iter = copy.begin();
3076 (*iter).second->ActivateAnimations();
3079 base::TimeDelta LayerTreeHostImpl::LowFrequencyAnimationInterval() const {
3080 return base::TimeDelta::FromSeconds(1);
3083 std::string LayerTreeHostImpl::LayerTreeAsJson() const {
3085 if (active_tree_->root_layer()) {
3086 scoped_ptr<base::Value> json(active_tree_->root_layer()->LayerTreeAsJson());
3087 base::JSONWriter::WriteWithOptions(
3088 json.get(), base::JSONWriter::OPTIONS_PRETTY_PRINT, &str);
3093 int LayerTreeHostImpl::SourceAnimationFrameNumber() const {
3094 return fps_counter_->current_frame_number();
3097 void LayerTreeHostImpl::AnimateScrollbars(base::TimeTicks time) {
3098 AnimateScrollbarsRecursive(active_tree_->root_layer(), time);
3101 void LayerTreeHostImpl::AnimateScrollbarsRecursive(LayerImpl* layer,
3102 base::TimeTicks time) {
3106 ScrollbarAnimationController* scrollbar_controller =
3107 layer->scrollbar_animation_controller();
3108 if (scrollbar_controller)
3109 scrollbar_controller->Animate(time);
3111 for (size_t i = 0; i < layer->children().size(); ++i)
3112 AnimateScrollbarsRecursive(layer->children()[i], time);
3115 void LayerTreeHostImpl::PostDelayedScrollbarFade(
3116 const base::Closure& start_fade,
3117 base::TimeDelta delay) {
3118 client_->PostDelayedScrollbarFadeOnImplThread(start_fade, delay);
3121 void LayerTreeHostImpl::SetNeedsScrollbarAnimationFrame() {
3122 TRACE_EVENT_INSTANT0(
3124 "LayerTreeHostImpl::SetNeedsRedraw due to scrollbar fade",
3125 TRACE_EVENT_SCOPE_THREAD);
3129 void LayerTreeHostImpl::SetTreePriority(TreePriority priority) {
3133 if (global_tile_state_.tree_priority == priority)
3135 global_tile_state_.tree_priority = priority;
3136 DidModifyTilePriorities();
3139 void LayerTreeHostImpl::UpdateCurrentBeginFrameArgs(
3140 const BeginFrameArgs& args) {
3141 DCHECK(!current_begin_frame_args_.IsValid());
3142 current_begin_frame_args_ = args;
3143 // TODO(skyostil): Stop overriding the frame time once the usage of frame
3144 // timing is unified.
3145 current_begin_frame_args_.frame_time = gfx::FrameTime::Now();
3148 void LayerTreeHostImpl::ResetCurrentBeginFrameArgsForNextFrame() {
3149 current_begin_frame_args_ = BeginFrameArgs();
3152 BeginFrameArgs LayerTreeHostImpl::CurrentBeginFrameArgs() const {
3153 // Try to use the current frame time to keep animations non-jittery. But if
3154 // we're not in a frame (because this is during an input event or a delayed
3155 // task), fall back to physical time. This should still be monotonic.
3156 if (current_begin_frame_args_.IsValid())
3157 return current_begin_frame_args_;
3158 return BeginFrameArgs::Create(gfx::FrameTime::Now(),
3160 BeginFrameArgs::DefaultInterval());
3163 scoped_refptr<base::debug::ConvertableToTraceFormat>
3164 LayerTreeHostImpl::AsValue() const {
3165 return AsValueWithFrame(NULL);
3168 scoped_refptr<base::debug::ConvertableToTraceFormat>
3169 LayerTreeHostImpl::AsValueWithFrame(FrameData* frame) const {
3170 scoped_refptr<base::debug::TracedValue> state =
3171 new base::debug::TracedValue();
3172 AsValueWithFrameInto(frame, state.get());
3176 void LayerTreeHostImpl::AsValueWithFrameInto(
3178 base::debug::TracedValue* state) const {
3179 if (this->pending_tree_) {
3180 state->BeginDictionary("activation_state");
3181 ActivationStateAsValueInto(state);
3182 state->EndDictionary();
3184 state->BeginDictionary("device_viewport_size");
3185 MathUtil::AddToTracedValue(device_viewport_size_, state);
3186 state->EndDictionary();
3188 std::set<const Tile*> tiles;
3189 active_tree_->GetAllTilesForTracing(&tiles);
3191 pending_tree_->GetAllTilesForTracing(&tiles);
3193 state->BeginArray("active_tiles");
3194 for (std::set<const Tile*>::const_iterator it = tiles.begin();
3197 const Tile* tile = *it;
3199 state->BeginDictionary();
3200 tile->AsValueInto(state);
3201 state->EndDictionary();
3205 if (tile_manager_) {
3206 state->BeginDictionary("tile_manager_basic_state");
3207 tile_manager_->BasicStateAsValueInto(state);
3208 state->EndDictionary();
3210 state->BeginDictionary("active_tree");
3211 active_tree_->AsValueInto(state);
3212 state->EndDictionary();
3213 if (pending_tree_) {
3214 state->BeginDictionary("pending_tree");
3215 pending_tree_->AsValueInto(state);
3216 state->EndDictionary();
3219 state->BeginDictionary("frame");
3220 frame->AsValueInto(state);
3221 state->EndDictionary();
3225 scoped_refptr<base::debug::ConvertableToTraceFormat>
3226 LayerTreeHostImpl::ActivationStateAsValue() const {
3227 scoped_refptr<base::debug::TracedValue> state =
3228 new base::debug::TracedValue();
3229 ActivationStateAsValueInto(state.get());
3233 void LayerTreeHostImpl::ActivationStateAsValueInto(
3234 base::debug::TracedValue* state) const {
3235 TracedValue::SetIDRef(this, state, "lthi");
3236 if (tile_manager_) {
3237 state->BeginDictionary("tile_manager");
3238 tile_manager_->BasicStateAsValueInto(state);
3239 state->EndDictionary();
3243 void LayerTreeHostImpl::SetDebugState(
3244 const LayerTreeDebugState& new_debug_state) {
3245 if (LayerTreeDebugState::Equal(debug_state_, new_debug_state))
3247 if (debug_state_.continuous_painting != new_debug_state.continuous_painting)
3248 paint_time_counter_->ClearHistory();
3250 debug_state_ = new_debug_state;
3251 UpdateTileManagerMemoryPolicy(ActualManagedMemoryPolicy());
3252 SetFullRootLayerDamage();
3255 void LayerTreeHostImpl::CreateUIResource(UIResourceId uid,
3256 const UIResourceBitmap& bitmap) {
3259 GLint wrap_mode = 0;
3260 switch (bitmap.GetWrapMode()) {
3261 case UIResourceBitmap::CLAMP_TO_EDGE:
3262 wrap_mode = GL_CLAMP_TO_EDGE;
3264 case UIResourceBitmap::REPEAT:
3265 wrap_mode = GL_REPEAT;
3269 // Allow for multiple creation requests with the same UIResourceId. The
3270 // previous resource is simply deleted.
3271 ResourceProvider::ResourceId id = ResourceIdForUIResource(uid);
3273 DeleteUIResource(uid);
3275 ResourceFormat format = resource_provider_->best_texture_format();
3276 switch (bitmap.GetFormat()) {
3277 case UIResourceBitmap::RGBA8:
3279 case UIResourceBitmap::ALPHA_8:
3282 case UIResourceBitmap::ETC1:
3287 resource_provider_->CreateResource(bitmap.GetSize(),
3289 ResourceProvider::TextureHintImmutable,
3292 UIResourceData data;
3293 data.resource_id = id;
3294 data.size = bitmap.GetSize();
3295 data.opaque = bitmap.GetOpaque();
3297 ui_resource_map_[uid] = data;
3299 AutoLockUIResourceBitmap bitmap_lock(bitmap);
3300 resource_provider_->SetPixels(id,
3301 bitmap_lock.GetPixels(),
3302 gfx::Rect(bitmap.GetSize()),
3303 gfx::Rect(bitmap.GetSize()),
3304 gfx::Vector2d(0, 0));
3305 MarkUIResourceNotEvicted(uid);
3308 void LayerTreeHostImpl::DeleteUIResource(UIResourceId uid) {
3309 ResourceProvider::ResourceId id = ResourceIdForUIResource(uid);
3311 resource_provider_->DeleteResource(id);
3312 ui_resource_map_.erase(uid);
3314 MarkUIResourceNotEvicted(uid);
3317 void LayerTreeHostImpl::EvictAllUIResources() {
3318 if (ui_resource_map_.empty())
3321 for (UIResourceMap::const_iterator iter = ui_resource_map_.begin();
3322 iter != ui_resource_map_.end();
3324 evicted_ui_resources_.insert(iter->first);
3325 resource_provider_->DeleteResource(iter->second.resource_id);
3327 ui_resource_map_.clear();
3329 client_->SetNeedsCommitOnImplThread();
3330 client_->OnCanDrawStateChanged(CanDraw());
3331 client_->RenewTreePriority();
3334 ResourceProvider::ResourceId LayerTreeHostImpl::ResourceIdForUIResource(
3335 UIResourceId uid) const {
3336 UIResourceMap::const_iterator iter = ui_resource_map_.find(uid);
3337 if (iter != ui_resource_map_.end())
3338 return iter->second.resource_id;
3342 bool LayerTreeHostImpl::IsUIResourceOpaque(UIResourceId uid) const {
3343 UIResourceMap::const_iterator iter = ui_resource_map_.find(uid);
3344 DCHECK(iter != ui_resource_map_.end());
3345 return iter->second.opaque;
3348 bool LayerTreeHostImpl::EvictedUIResourcesExist() const {
3349 return !evicted_ui_resources_.empty();
3352 void LayerTreeHostImpl::MarkUIResourceNotEvicted(UIResourceId uid) {
3353 std::set<UIResourceId>::iterator found_in_evicted =
3354 evicted_ui_resources_.find(uid);
3355 if (found_in_evicted == evicted_ui_resources_.end())
3357 evicted_ui_resources_.erase(found_in_evicted);
3358 if (evicted_ui_resources_.empty())
3359 client_->OnCanDrawStateChanged(CanDraw());
3362 void LayerTreeHostImpl::ScheduleMicroBenchmark(
3363 scoped_ptr<MicroBenchmarkImpl> benchmark) {
3364 micro_benchmark_controller_.ScheduleRun(benchmark.Pass());
3367 void LayerTreeHostImpl::InsertSwapPromiseMonitor(SwapPromiseMonitor* monitor) {
3368 swap_promise_monitor_.insert(monitor);
3371 void LayerTreeHostImpl::RemoveSwapPromiseMonitor(SwapPromiseMonitor* monitor) {
3372 swap_promise_monitor_.erase(monitor);
3375 void LayerTreeHostImpl::NotifySwapPromiseMonitorsOfSetNeedsRedraw() {
3376 std::set<SwapPromiseMonitor*>::iterator it = swap_promise_monitor_.begin();
3377 for (; it != swap_promise_monitor_.end(); it++)
3378 (*it)->OnSetNeedsRedrawOnImpl();
3381 void LayerTreeHostImpl::NotifySwapPromiseMonitorsOfForwardingToMainThread() {
3382 std::set<SwapPromiseMonitor*>::iterator it = swap_promise_monitor_.begin();
3383 for (; it != swap_promise_monitor_.end(); it++)
3384 (*it)->OnForwardScrollUpdateToMainThreadOnImpl();
3387 void LayerTreeHostImpl::RegisterPictureLayerImpl(PictureLayerImpl* layer) {
3388 DCHECK(std::find(picture_layers_.begin(), picture_layers_.end(), layer) ==
3389 picture_layers_.end());
3390 picture_layers_.push_back(layer);
3393 void LayerTreeHostImpl::UnregisterPictureLayerImpl(PictureLayerImpl* layer) {
3394 std::vector<PictureLayerImpl*>::iterator it =
3395 std::find(picture_layers_.begin(), picture_layers_.end(), layer);
3396 DCHECK(it != picture_layers_.end());
3397 picture_layers_.erase(it);