blob: c4319ad9efb676c97debdfa2063deccbb99b0d64 [file] [log] [blame]
[email protected]94f206c12012-08-25 00:09:141// 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.
4
[email protected]556fd292013-03-18 08:03:045#include "cc/trees/layer_tree_host_impl.h"
[email protected]94f206c12012-08-25 00:09:146
[email protected]ac7c7f52012-11-08 06:26:507#include <algorithm>
[email protected]b6eb8e332013-09-10 00:51:018#include <limits>
[email protected]ac7c7f52012-11-08 06:26:509
[email protected]ad5d1422012-10-19 13:40:2910#include "base/basictypes.h"
[email protected]34806722013-08-09 23:51:2111#include "base/containers/hash_tables.h"
[email protected]d12aa932014-08-01 13:10:3812#include "base/debug/trace_event_argument.h"
[email protected]4a23c374c2012-12-08 08:38:5513#include "base/json/json_writer.h"
[email protected]f5864912013-02-01 03:18:1414#include "base/metrics/histogram.h"
[email protected]de4afb5e2012-12-20 00:11:3415#include "base/stl_util.h"
[email protected]8e61d4b2013-06-10 22:11:4816#include "base/strings/stringprintf.h"
[email protected]749cbc62014-07-10 01:06:3517#include "cc/animation/animation_id_provider.h"
18#include "cc/animation/scroll_offset_animation_curve.h"
[email protected]95e4e1a02013-03-18 07:09:0919#include "cc/animation/scrollbar_animation_controller.h"
[email protected]85d136f782013-04-26 22:04:4020#include "cc/animation/timing_function.h"
[email protected]6be422b2013-12-08 06:47:3121#include "cc/base/latency_info_swap_promise_monitor.h"
[email protected]681ccff2013-03-18 06:13:5222#include "cc/base/math_util.h"
23#include "cc/base/util.h"
[email protected]adbe30f2013-10-11 21:12:3324#include "cc/debug/benchmark_instrumentation.h"
[email protected]6e84de22013-03-18 06:54:2725#include "cc/debug/debug_rect_history.h"
[email protected]dbe759a2013-12-02 19:23:0226#include "cc/debug/devtools_instrumentation.h"
[email protected]6e84de22013-03-18 06:54:2727#include "cc/debug/frame_rate_counter.h"
[email protected]6e84de22013-03-18 06:54:2728#include "cc/debug/paint_time_counter.h"
[email protected]372bad5f2013-03-21 16:38:4329#include "cc/debug/rendering_stats_instrumentation.h"
[email protected]f6742f52013-05-08 23:52:2230#include "cc/debug/traced_value.h"
[email protected]3052b10f2013-03-18 07:41:2131#include "cc/input/page_scale_animation.h"
ccameron4163cc352014-11-13 19:06:3632#include "cc/input/scroll_elasticity_helper.h"
[email protected]3052b10f2013-03-18 07:41:2133#include "cc/input/top_controls_manager.h"
[email protected]cc3cfaa2013-03-18 09:05:5234#include "cc/layers/append_quads_data.h"
35#include "cc/layers/heads_up_display_layer_impl.h"
[email protected]50761e92013-03-29 20:51:2836#include "cc/layers/layer_impl.h"
[email protected]cc3cfaa2013-03-18 09:05:5237#include "cc/layers/layer_iterator.h"
[email protected]3a83478b2013-08-22 20:55:1738#include "cc/layers/painted_scrollbar_layer_impl.h"
[email protected]50761e92013-03-29 20:51:2839#include "cc/layers/render_surface_impl.h"
[email protected]bf1cfd9a2013-09-26 05:43:0240#include "cc/layers/scrollbar_layer_impl_base.h"
[email protected]7f0d825f2013-03-18 07:24:3041#include "cc/output/compositor_frame_metadata.h"
[email protected]30fe19ff2013-07-04 00:54:4542#include "cc/output/copy_output_request.h"
[email protected]7f0d825f2013-03-18 07:24:3043#include "cc/output/delegating_renderer.h"
44#include "cc/output/gl_renderer.h"
45#include "cc/output/software_renderer.h"
[email protected]89e82672013-03-18 07:50:5646#include "cc/quads/render_pass_draw_quad.h"
47#include "cc/quads/shared_quad_state.h"
48#include "cc/quads/solid_color_draw_quad.h"
[email protected]9f4f6a32013-09-04 21:35:1249#include "cc/quads/texture_draw_quad.h"
reveman5ae838bb2014-09-24 23:30:1450#include "cc/resources/bitmap_raster_worker_pool.h"
[email protected]bf050582014-07-24 11:10:5851#include "cc/resources/eviction_tile_priority_queue.h"
[email protected]e1878b52014-07-01 09:21:1752#include "cc/resources/gpu_raster_worker_pool.h"
[email protected]e12dd0e2013-03-18 08:24:4053#include "cc/resources/memory_history.h"
reveman423e7da2014-09-23 16:57:4454#include "cc/resources/one_copy_raster_worker_pool.h"
[email protected]e12dd0e2013-03-18 08:24:4055#include "cc/resources/picture_layer_tiling.h"
[email protected]ec7541d2014-04-09 01:23:5356#include "cc/resources/pixel_buffer_raster_worker_pool.h"
[email protected]e12dd0e2013-03-18 08:24:4057#include "cc/resources/prioritized_resource_manager.h"
[email protected]bf050582014-07-24 11:10:5858#include "cc/resources/raster_tile_priority_queue.h"
[email protected]7beac1b52014-04-10 23:09:5659#include "cc/resources/raster_worker_pool.h"
[email protected]eece11e2014-04-12 03:07:1660#include "cc/resources/resource_pool.h"
[email protected]ea468c6c2013-09-10 08:25:1161#include "cc/resources/texture_mailbox_deleter.h"
[email protected]c9280762013-08-01 06:28:5762#include "cc/resources/ui_resource_bitmap.h"
reveman423e7da2014-09-23 16:57:4463#include "cc/resources/zero_copy_raster_worker_pool.h"
[email protected]be4655a2013-03-18 08:36:3164#include "cc/scheduler/delay_based_time_source.h"
[email protected]556fd292013-03-18 08:03:0465#include "cc/trees/damage_tracker.h"
66#include "cc/trees/layer_tree_host.h"
67#include "cc/trees/layer_tree_host_common.h"
68#include "cc/trees/layer_tree_impl.h"
[email protected]34ba1ffb2014-03-05 06:55:0369#include "cc/trees/occlusion_tracker.h"
[email protected]556fd292013-03-18 08:03:0470#include "cc/trees/single_thread_proxy.h"
71#include "cc/trees/tree_synchronizer.h"
[email protected]110fcc0e2014-07-16 15:52:4772#include "gpu/command_buffer/client/gles2_interface.h"
[email protected]8d7aa012013-11-23 21:19:1273#include "gpu/GLES2/gl2extchromium.h"
[email protected]de2cf8c2013-10-25 19:46:4674#include "ui/gfx/frame_time.h"
[email protected]bd5324592014-07-31 09:09:3375#include "ui/gfx/geometry/rect_conversions.h"
heejin.r.chungd28506ba2014-10-23 16:36:2076#include "ui/gfx/geometry/size_conversions.h"
77#include "ui/gfx/geometry/vector2d_conversions.h"
[email protected]94f206c12012-08-25 00:09:1478
reveman5ae838bb2014-09-24 23:30:1479namespace cc {
[email protected]94f206c12012-08-25 00:09:1480namespace {
81
bokanef971462014-10-13 22:58:3282// Small helper class that saves the current viewport location as the user sees
83// it and resets to the same location.
84class ViewportAnchor {
85 public:
86 ViewportAnchor(LayerImpl* inner_scroll, LayerImpl* outer_scroll)
87 : inner_(inner_scroll),
88 outer_(outer_scroll) {
89 viewport_in_content_coordinates_ = inner_->TotalScrollOffset();
90
91 if (outer_)
92 viewport_in_content_coordinates_ += outer_->TotalScrollOffset();
93 }
94
95 void ResetViewportToAnchoredPosition() {
96 DCHECK(outer_);
97
98 inner_->ClampScrollToMaxScrollOffset();
99 outer_->ClampScrollToMaxScrollOffset();
100
101 gfx::ScrollOffset viewport_location = inner_->TotalScrollOffset() +
102 outer_->TotalScrollOffset();
103
104 gfx::Vector2dF delta =
105 viewport_in_content_coordinates_.DeltaFrom(viewport_location);
106
107 delta = outer_->ScrollBy(delta);
108 inner_->ScrollBy(delta);
109 }
110
111 private:
112 LayerImpl* inner_;
113 LayerImpl* outer_;
114 gfx::ScrollOffset viewport_in_content_coordinates_;
115};
116
117
reveman5ae838bb2014-09-24 23:30:14118void DidVisibilityChange(LayerTreeHostImpl* id, bool visible) {
[email protected]c1bb5af2013-03-13 19:06:27119 if (visible) {
120 TRACE_EVENT_ASYNC_BEGIN1("webkit",
121 "LayerTreeHostImpl::SetVisible",
122 id,
123 "LayerTreeHostImpl",
124 id);
125 return;
126 }
[email protected]94f206c12012-08-25 00:09:14127
[email protected]c1bb5af2013-03-13 19:06:27128 TRACE_EVENT_ASYNC_END0("webkit", "LayerTreeHostImpl::SetVisible", id);
[email protected]94f206c12012-08-25 00:09:14129}
130
reveman5ae838bb2014-09-24 23:30:14131size_t GetMaxTransferBufferUsageBytes(
132 const ContextProvider::Capabilities& context_capabilities,
133 double refresh_rate) {
[email protected]b4664142013-11-08 00:50:31134 // We want to make sure the default transfer buffer size is equal to the
135 // amount of data that can be uploaded by the compositor to avoid stalling
136 // the pipeline.
137 // For reference Chromebook Pixel can upload 1MB in about 0.5ms.
138 const size_t kMaxBytesUploadedPerMs = 1024 * 1024 * 2;
danakje6a236bc2014-09-02 21:27:17139
140 // We need to upload at least enough work to keep the GPU process busy until
141 // the next time it can handle a request to start more uploads from the
142 // compositor. We assume that it will pick up any sent upload requests within
143 // the time of a vsync, since the browser will want to swap a frame within
144 // that time interval, and then uploads should have a chance to be processed.
145 size_t ms_per_frame = std::floor(1000.0 / refresh_rate);
146 size_t max_transfer_buffer_usage_bytes =
147 ms_per_frame * kMaxBytesUploadedPerMs;
148
149 // The context may request a lower limit based on the device capabilities.
reveman5ae838bb2014-09-24 23:30:14150 return std::min(context_capabilities.max_transfer_buffer_usage_bytes,
151 max_transfer_buffer_usage_bytes);
[email protected]b4664142013-11-08 00:50:31152}
153
reveman5ae838bb2014-09-24 23:30:14154unsigned GetMapImageTextureTarget(
155 const ContextProvider::Capabilities& context_capabilities) {
reveman90c2f762014-11-06 23:37:20156// TODO(reveman): This should be a setting passed to the compositor instead
157// of hard-coded here. The target that need to be used depends on our choice
158// of GpuMemoryBuffer type. Note: SURFACE_TEXTURE needs EXTERNAL_OES,
159// IO_SURFACE needs RECTANGLE_ARB. crbug.com/431059
160#if defined(OS_ANDROID)
reveman5ae838bb2014-09-24 23:30:14161 if (context_capabilities.gpu.egl_image_external)
[email protected]8d7aa012013-11-23 21:19:12162 return GL_TEXTURE_EXTERNAL_OES;
reveman90c2f762014-11-06 23:37:20163#endif
reveman5ae838bb2014-09-24 23:30:14164 if (context_capabilities.gpu.texture_rectangle)
[email protected]8d7aa012013-11-23 21:19:12165 return GL_TEXTURE_RECTANGLE_ARB;
[email protected]8d7aa012013-11-23 21:19:12166
167 return GL_TEXTURE_2D;
168}
169
revemanc84602a02014-09-24 15:41:25170size_t GetMaxStagingResourceCount() {
171 // Upper bound for number of staging resource to allow.
172 return 32;
173}
174
[email protected]c1bb5af2013-03-13 19:06:27175} // namespace
[email protected]94f206c12012-08-25 00:09:14176
danakja819c2552014-11-14 02:05:04177LayerTreeHostImpl::FrameData::FrameData() : has_no_damage(false) {
178}
[email protected]c1bb5af2013-03-13 19:06:27179
180LayerTreeHostImpl::FrameData::~FrameData() {}
181
182scoped_ptr<LayerTreeHostImpl> LayerTreeHostImpl::Create(
183 const LayerTreeSettings& settings,
184 LayerTreeHostImplClient* client,
[email protected]372bad5f2013-03-21 16:38:43185 Proxy* proxy,
[email protected]a7f35682013-10-22 23:05:57186 RenderingStatsInstrumentation* rendering_stats_instrumentation,
reveman22dd9292014-10-13 20:52:05187 SharedBitmapManager* shared_bitmap_manager,
revemanf9a8a2342014-10-28 17:54:52188 gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
[email protected]dbe759a2013-12-02 19:23:02189 int id) {
reveman22dd9292014-10-13 20:52:05190 return make_scoped_ptr(new LayerTreeHostImpl(settings,
191 client,
192 proxy,
193 rendering_stats_instrumentation,
194 shared_bitmap_manager,
195 gpu_memory_buffer_manager,
196 id));
[email protected]493067512012-09-19 23:34:10197}
198
[email protected]372bad5f2013-03-21 16:38:43199LayerTreeHostImpl::LayerTreeHostImpl(
200 const LayerTreeSettings& settings,
201 LayerTreeHostImplClient* client,
202 Proxy* proxy,
[email protected]a7f35682013-10-22 23:05:57203 RenderingStatsInstrumentation* rendering_stats_instrumentation,
reveman22dd9292014-10-13 20:52:05204 SharedBitmapManager* shared_bitmap_manager,
revemanf9a8a2342014-10-28 17:54:52205 gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
[email protected]dbe759a2013-12-02 19:23:02206 int id)
simonhonga7e3ac42014-11-11 20:50:22207 : client_(client),
[email protected]c1bb5af2013-03-13 19:06:27208 proxy_(proxy),
[email protected]13525d62014-05-20 21:22:04209 use_gpu_rasterization_(false),
[email protected]200a9c062013-05-20 04:34:37210 input_handler_client_(NULL),
[email protected]c1bb5af2013-03-13 19:06:27211 did_lock_scrolling_layer_(false),
212 should_bubble_scrolls_(false),
213 wheel_scrolling_(false),
[email protected]f161ca9e2014-04-01 13:57:01214 scroll_affects_scroll_handler_(false),
[email protected]f620b0e72013-10-01 21:38:24215 scroll_layer_id_when_mouse_over_scrollbar_(0),
[email protected]c48536a52013-09-14 00:02:08216 tile_priorities_dirty_(false),
[email protected]1960a712013-04-30 17:06:47217 root_layer_scroll_offset_delegate_(NULL),
[email protected]c1bb5af2013-03-13 19:06:27218 settings_(settings),
[email protected]c1bb5af2013-03-13 19:06:27219 visible_(true),
[email protected]3f2ff112013-08-03 02:41:07220 cached_managed_memory_policy_(
[email protected]b56c1302013-03-20 21:17:34221 PrioritizedResourceManager::DefaultMemoryAllocationLimit(),
[email protected]f44d5552013-10-29 04:56:29222 gpu::MemoryAllocation::CUTOFF_ALLOW_EVERYTHING,
[email protected]3f2ff112013-08-03 02:41:07223 ManagedMemoryPolicy::kDefaultNumResourcesLimit),
[email protected]c1bb5af2013-03-13 19:06:27224 pinch_gesture_active_(false),
[email protected]2fa342b82013-09-24 03:19:13225 pinch_gesture_end_should_clear_scrolling_layer_(false),
[email protected]9e3594522013-03-18 00:57:36226 fps_counter_(FrameRateCounter::Create(proxy_->HasImplThread())),
[email protected]7497316a2013-03-15 12:42:29227 paint_time_counter_(PaintTimeCounter::Create()),
[email protected]c1bb5af2013-03-13 19:06:27228 memory_history_(MemoryHistory::Create()),
[email protected]d35992782013-03-14 14:54:02229 debug_rect_history_(DebugRectHistory::Create()),
[email protected]dd909b1f2014-03-18 00:19:52230 texture_mailbox_deleter_(new TextureMailboxDeleter(
231 proxy_->HasImplThread() ? proxy_->ImplThreadTaskRunner()
232 : proxy_->MainThreadTaskRunner())),
[email protected]d7626ffd2013-03-29 00:17:42233 max_memory_needed_bytes_(0),
[email protected]50644642013-06-20 13:58:55234 zero_budget_(false),
[email protected]f224cc92013-06-06 23:23:32235 device_scale_factor_(1.f),
[email protected]9f4f6a32013-09-04 21:35:12236 overhang_ui_resource_id_(0),
[email protected]c05dfbb2014-07-10 22:49:04237 resourceless_software_draw_(false),
[email protected]c92195e2014-05-07 18:18:49238 begin_impl_frame_interval_(BeginFrameArgs::DefaultInterval()),
[email protected]372bad5f2013-03-21 16:38:43239 animation_registrar_(AnimationRegistrar::Create()),
[email protected]39643fb2013-07-09 17:28:19240 rendering_stats_instrumentation_(rendering_stats_instrumentation),
[email protected]5e5648a2013-11-18 00:39:33241 micro_benchmark_controller_(this),
reveman22dd9292014-10-13 20:52:05242 shared_bitmap_manager_(shared_bitmap_manager),
243 gpu_memory_buffer_manager_(gpu_memory_buffer_manager),
vmpstr61ed94a12014-10-09 04:49:30244 id_(id),
danakja819c2552014-11-14 02:05:04245 requires_high_res_to_draw_(false),
246 required_for_draw_tile_is_top_of_raster_queue_(false) {
[email protected]c1bb5af2013-03-13 19:06:27247 DCHECK(proxy_->IsImplThread());
248 DidVisibilityChange(this, visible_);
[email protected]5d8bec72014-07-03 03:03:11249 animation_registrar_->set_supports_scroll_animations(
250 proxy_->SupportsImplScrolling());
[email protected]c1bb5af2013-03-13 19:06:27251
[email protected]8e0176d2013-03-21 03:14:52252 SetDebugState(settings.initial_debug_state);
[email protected]c1bb5af2013-03-13 19:06:27253
bokan55b2f152014-09-15 14:47:59254 // LTHI always has an active tree.
255 active_tree_ = LayerTreeImpl::create(this);
256 TRACE_EVENT_OBJECT_CREATED_WITH_ID(
257 TRACE_DISABLED_BY_DEFAULT("cc.debug"), "cc::LayerTreeHostImpl", id_);
258
[email protected]8e0176d2013-03-21 03:14:52259 if (settings.calculate_top_controls_position) {
[email protected]c1bb5af2013-03-13 19:06:27260 top_controls_manager_ =
261 TopControlsManager::Create(this,
[email protected]8e0176d2013-03-21 03:14:52262 settings.top_controls_height,
263 settings.top_controls_show_threshold,
264 settings.top_controls_hide_threshold);
bokan0da0ba8b2014-09-25 19:17:26265
266 // TODO(bokan): This is a quick fix. The browser should lock the top
267 // controls to shown on creation but this appears not to work. Tracked
268 // in crbug.com/417680.
269 // Initialize with top controls showing.
270 SetControlsTopOffset(0.f);
[email protected]c1bb5af2013-03-13 19:06:27271 }
[email protected]493067512012-09-19 23:34:10272}
273
[email protected]c1bb5af2013-03-13 19:06:27274LayerTreeHostImpl::~LayerTreeHostImpl() {
275 DCHECK(proxy_->IsImplThread());
276 TRACE_EVENT0("cc", "LayerTreeHostImpl::~LayerTreeHostImpl()");
[email protected]9197dbcb2013-05-15 20:28:51277 TRACE_EVENT_OBJECT_DELETED_WITH_ID(
[email protected]a75441c2014-05-16 19:10:29278 TRACE_DISABLED_BY_DEFAULT("cc.debug"), "cc::LayerTreeHostImpl", id_);
[email protected]c1bb5af2013-03-13 19:06:27279
[email protected]200a9c062013-05-20 04:34:37280 if (input_handler_client_) {
281 input_handler_client_->WillShutdown();
282 input_handler_client_ = NULL;
283 }
ccameron4163cc352014-11-13 19:06:36284 if (scroll_elasticity_helper_)
285 scroll_elasticity_helper_.reset();
[email protected]200a9c062013-05-20 04:34:37286
[email protected]75deb742013-06-24 20:19:18287 // The layer trees must be destroyed before the layer tree host. We've
288 // made a contract with our animation controllers that the registrar
289 // will outlive them, and we must make good.
[email protected]df17af52014-02-06 02:20:40290 if (recycle_tree_)
291 recycle_tree_->Shutdown();
292 if (pending_tree_)
293 pending_tree_->Shutdown();
294 active_tree_->Shutdown();
danakjf446a072014-09-27 21:55:48295 recycle_tree_ = nullptr;
296 pending_tree_ = nullptr;
297 active_tree_ = nullptr;
[email protected]ced667b2014-05-22 21:49:53298 DestroyTileManager();
[email protected]94f206c12012-08-25 00:09:14299}
300
[email protected]097a0cbf2013-12-12 17:04:58301void LayerTreeHostImpl::BeginMainFrameAborted(bool did_handle) {
302 // If the begin frame data was handled, then scroll and scale set was applied
303 // by the main thread, so the active tree needs to be updated as if these sent
304 // values were applied and committed.
305 if (did_handle) {
306 active_tree_->ApplySentScrollAndScaleDeltasFromAbortedCommit();
307 active_tree_->ResetContentsTexturesPurged();
308 }
309}
310
[email protected]12a63da2014-06-13 06:06:22311void LayerTreeHostImpl::BeginCommit() {
312 TRACE_EVENT0("cc", "LayerTreeHostImpl::BeginCommit");
313
[email protected]fc20d142014-07-01 00:49:15314 if (UsePendingTreeForSync())
[email protected]12a63da2014-06-13 06:06:22315 CreatePendingTree();
316}
[email protected]3b31c6ac2012-12-06 21:27:29317
[email protected]c1bb5af2013-03-13 19:06:27318void LayerTreeHostImpl::CommitComplete() {
319 TRACE_EVENT0("cc", "LayerTreeHostImpl::CommitComplete");
[email protected]131a0c22013-02-12 18:31:08320
[email protected]fc20d142014-07-01 00:49:15321 if (pending_tree_)
322 pending_tree_->ApplyScrollDeltasSinceBeginMainFrame();
323 sync_tree()->set_needs_update_draw_properties();
324
[email protected]8e0176d2013-03-21 03:14:52325 if (settings_.impl_side_painting) {
[email protected]58241dc2013-08-20 01:39:25326 // Impl-side painting needs an update immediately post-commit to have the
327 // opportunity to create tilings. Other paths can call UpdateDrawProperties
328 // more lazily when needed prior to drawing.
[email protected]fc20d142014-07-01 00:49:15329 sync_tree()->UpdateDrawProperties();
[email protected]a23451e2013-06-07 20:58:26330 // Start working on newly created tiles immediately if needed.
[email protected]fc20d142014-07-01 00:49:15331 if (tile_manager_ && tile_priorities_dirty_)
[email protected]4f48f6e2013-08-27 06:33:38332 ManageTiles();
[email protected]fc20d142014-07-01 00:49:15333 else
334 NotifyReadyToActivate();
[email protected]c1bb5af2013-03-13 19:06:27335 } else {
[email protected]12a63da2014-06-13 06:06:22336 // If we're not in impl-side painting, the tree is immediately considered
337 // active.
[email protected]fc20d142014-07-01 00:49:15338 ActivateSyncTree();
[email protected]c1bb5af2013-03-13 19:06:27339 }
[email protected]3ba4cae2013-01-16 03:58:38340
[email protected]5e5648a2013-11-18 00:39:33341 micro_benchmark_controller_.DidCompleteCommit();
[email protected]94f206c12012-08-25 00:09:14342}
343
[email protected]6133cc232013-07-30 18:47:07344bool LayerTreeHostImpl::CanDraw() const {
[email protected]c1bb5af2013-03-13 19:06:27345 // Note: If you are changing this function or any other function that might
346 // affect the result of CanDraw, make sure to call
347 // client_->OnCanDrawStateChanged in the proper places and update the
348 // NotifyIfCanDrawChanged test.
[email protected]94f206c12012-08-25 00:09:14349
[email protected]6133cc232013-07-30 18:47:07350 if (!renderer_) {
351 TRACE_EVENT_INSTANT0("cc", "LayerTreeHostImpl::CanDraw no renderer",
352 TRACE_EVENT_SCOPE_THREAD);
353 return false;
354 }
355
356 // Must have an OutputSurface if |renderer_| is not NULL.
357 DCHECK(output_surface_);
358
359 // TODO(boliu): Make draws without root_layer work and move this below
360 // draw_and_swap_full_viewport_every_frame check. Tracked in crbug.com/264967.
[email protected]c1bb5af2013-03-13 19:06:27361 if (!active_tree_->root_layer()) {
[email protected]c76faea2013-03-26 07:42:42362 TRACE_EVENT_INSTANT0("cc", "LayerTreeHostImpl::CanDraw no root layer",
363 TRACE_EVENT_SCOPE_THREAD);
[email protected]2f1acc262012-11-16 21:42:22364 return false;
[email protected]c1bb5af2013-03-13 19:06:27365 }
[email protected]6133cc232013-07-30 18:47:07366
367 if (output_surface_->capabilities().draw_and_swap_full_viewport_every_frame)
368 return true;
369
[email protected]54af03522013-09-05 00:43:28370 if (DrawViewportSize().IsEmpty()) {
[email protected]c76faea2013-03-26 07:42:42371 TRACE_EVENT_INSTANT0("cc", "LayerTreeHostImpl::CanDraw empty viewport",
372 TRACE_EVENT_SCOPE_THREAD);
[email protected]c1bb5af2013-03-13 19:06:27373 return false;
374 }
375 if (active_tree_->ViewportSizeInvalid()) {
376 TRACE_EVENT_INSTANT0(
[email protected]c76faea2013-03-26 07:42:42377 "cc", "LayerTreeHostImpl::CanDraw viewport size recently changed",
378 TRACE_EVENT_SCOPE_THREAD);
[email protected]c1bb5af2013-03-13 19:06:27379 return false;
380 }
[email protected]c1bb5af2013-03-13 19:06:27381 if (active_tree_->ContentsTexturesPurged()) {
382 TRACE_EVENT_INSTANT0(
[email protected]c76faea2013-03-26 07:42:42383 "cc", "LayerTreeHostImpl::CanDraw contents textures purged",
384 TRACE_EVENT_SCOPE_THREAD);
[email protected]c1bb5af2013-03-13 19:06:27385 return false;
386 }
[email protected]127bdc1a2013-09-11 01:44:48387 if (EvictedUIResourcesExist()) {
388 TRACE_EVENT_INSTANT0(
389 "cc", "LayerTreeHostImpl::CanDraw UI resources evicted not recreated",
390 TRACE_EVENT_SCOPE_THREAD);
391 return false;
392 }
[email protected]c1bb5af2013-03-13 19:06:27393 return true;
[email protected]2f1acc262012-11-16 21:42:22394}
395
[email protected]27152642014-03-11 20:42:00396void LayerTreeHostImpl::Animate(base::TimeTicks monotonic_time) {
[email protected]200a9c062013-05-20 04:34:37397 if (input_handler_client_)
398 input_handler_client_->Animate(monotonic_time);
[email protected]c1bb5af2013-03-13 19:06:27399 AnimatePageScale(monotonic_time);
[email protected]27152642014-03-11 20:42:00400 AnimateLayers(monotonic_time);
[email protected]c1bb5af2013-03-13 19:06:27401 AnimateScrollbars(monotonic_time);
[email protected]ffb2720f2013-03-15 19:18:37402 AnimateTopControls(monotonic_time);
[email protected]94f206c12012-08-25 00:09:14403}
404
[email protected]c1bb5af2013-03-13 19:06:27405void LayerTreeHostImpl::ManageTiles() {
[email protected]a23451e2013-06-07 20:58:26406 if (!tile_manager_)
407 return;
[email protected]c48536a52013-09-14 00:02:08408 if (!tile_priorities_dirty_)
[email protected]a23451e2013-06-07 20:58:26409 return;
[email protected]54af03522013-09-05 00:43:28410
[email protected]c48536a52013-09-14 00:02:08411 tile_priorities_dirty_ = false;
[email protected]1bcced22013-09-24 13:51:19412 tile_manager_->ManageTiles(global_tile_state_);
[email protected]c1bb5af2013-03-13 19:06:27413
[email protected]99cc6b42014-01-17 00:12:57414 client_->DidManageTiles();
[email protected]f57bbc02012-11-21 07:02:15415}
416
[email protected]edcc1a12014-05-06 01:26:39417bool LayerTreeHostImpl::IsCurrentlyScrollingLayerAt(
418 const gfx::Point& viewport_point,
419 InputHandler::ScrollInputType type) {
420 if (!CurrentlyScrollingLayer())
421 return false;
422
[email protected]edcc1a12014-05-06 01:26:39423 gfx::PointF device_viewport_point =
424 gfx::ScalePoint(viewport_point, device_scale_factor_);
425
[email protected]28336d52014-05-12 19:07:28426 LayerImpl* layer_impl =
427 active_tree_->FindLayerThatIsHitByPoint(device_viewport_point);
[email protected]edcc1a12014-05-06 01:26:39428
429 bool scroll_on_main_thread = false;
430 LayerImpl* scrolling_layer_impl = FindScrollLayerForDeviceViewportPoint(
431 device_viewport_point, type, layer_impl, &scroll_on_main_thread, NULL);
432 return CurrentlyScrollingLayer() == scrolling_layer_impl;
433}
434
[email protected]47a723f2014-03-05 12:42:49435bool LayerTreeHostImpl::HaveTouchEventHandlersAt(
436 const gfx::Point& viewport_point) {
[email protected]f57bbc02012-11-21 07:02:15437
[email protected]c1bb5af2013-03-13 19:06:27438 gfx::PointF device_viewport_point =
439 gfx::ScalePoint(viewport_point, device_scale_factor_);
[email protected]f57bbc02012-11-21 07:02:15440
[email protected]c974d5d2013-10-24 01:02:48441 LayerImpl* layer_impl =
[email protected]28336d52014-05-12 19:07:28442 active_tree_->FindLayerThatIsHitByPointInTouchHandlerRegion(
443 device_viewport_point);
444
[email protected]c974d5d2013-10-24 01:02:48445 return layer_impl != NULL;
[email protected]c1bb5af2013-03-13 19:06:27446}
447
[email protected]6be422b2013-12-08 06:47:31448scoped_ptr<SwapPromiseMonitor>
449LayerTreeHostImpl::CreateLatencyInfoSwapPromiseMonitor(
450 ui::LatencyInfo* latency) {
danakjf446a072014-09-27 21:55:48451 return make_scoped_ptr(
[email protected]6be422b2013-12-08 06:47:31452 new LatencyInfoSwapPromiseMonitor(latency, NULL, this));
[email protected]b76329d2013-06-11 04:15:08453}
454
ccameron4163cc352014-11-13 19:06:36455ScrollElasticityHelper* LayerTreeHostImpl::CreateScrollElasticityHelper() {
456 DCHECK(!scroll_elasticity_helper_);
457 scroll_elasticity_helper_.reset(new ScrollElasticityHelper(this));
458 return scroll_elasticity_helper_.get();
459}
460
[email protected]dab0a422014-08-13 16:09:46461void LayerTreeHostImpl::QueueSwapPromiseForMainThreadScrollUpdate(
462 scoped_ptr<SwapPromise> swap_promise) {
463 swap_promises_for_main_thread_scroll_update_.push_back(swap_promise.Pass());
464}
465
[email protected]c1bb5af2013-03-13 19:06:27466void LayerTreeHostImpl::TrackDamageForAllSurfaces(
467 LayerImpl* root_draw_layer,
[email protected]50761e92013-03-29 20:51:28468 const LayerImplList& render_surface_layer_list) {
[email protected]c1bb5af2013-03-13 19:06:27469 // For now, we use damage tracking to compute a global scissor. To do this, we
470 // must compute all damage tracking before drawing anything, so that we know
471 // the root damage rect. The root damage rect is then used to scissor each
472 // surface.
473
474 for (int surface_index = render_surface_layer_list.size() - 1;
[email protected]bf691c22013-03-26 21:15:06475 surface_index >= 0;
[email protected]c1bb5af2013-03-13 19:06:27476 --surface_index) {
477 LayerImpl* render_surface_layer = render_surface_layer_list[surface_index];
478 RenderSurfaceImpl* render_surface = render_surface_layer->render_surface();
479 DCHECK(render_surface);
480 render_surface->damage_tracker()->UpdateDamageTrackingState(
481 render_surface->layer_list(),
482 render_surface_layer->id(),
483 render_surface->SurfacePropertyChangedOnlyFromDescendant(),
484 render_surface->content_rect(),
485 render_surface_layer->mask_layer(),
[email protected]1dc7943e2013-09-26 04:41:48486 render_surface_layer->filters());
[email protected]c1bb5af2013-03-13 19:06:27487 }
488}
489
[email protected]d12aa932014-08-01 13:10:38490void LayerTreeHostImpl::FrameData::AsValueInto(
491 base::debug::TracedValue* value) const {
[email protected]34806722013-08-09 23:51:21492 value->SetBoolean("has_no_damage", has_no_damage);
493
494 // Quad data can be quite large, so only dump render passes if we select
495 // cc.debug.quads.
496 bool quads_enabled;
497 TRACE_EVENT_CATEGORY_GROUP_ENABLED(
498 TRACE_DISABLED_BY_DEFAULT("cc.debug.quads"), &quads_enabled);
499 if (quads_enabled) {
[email protected]d12aa932014-08-01 13:10:38500 value->BeginArray("render_passes");
501 for (size_t i = 0; i < render_passes.size(); ++i) {
502 value->BeginDictionary();
503 render_passes[i]->AsValueInto(value);
504 value->EndDictionary();
505 }
506 value->EndArray();
[email protected]34806722013-08-09 23:51:21507 }
[email protected]34806722013-08-09 23:51:21508}
509
[email protected]c1bb5af2013-03-13 19:06:27510void LayerTreeHostImpl::FrameData::AppendRenderPass(
511 scoped_ptr<RenderPass> render_pass) {
512 render_passes_by_id[render_pass->id] = render_pass.get();
513 render_passes.push_back(render_pass.Pass());
514}
515
[email protected]c05dfbb2014-07-10 22:49:04516DrawMode LayerTreeHostImpl::GetDrawMode() const {
517 if (resourceless_software_draw_) {
[email protected]ffbb2212013-06-02 23:47:59518 return DRAW_MODE_RESOURCELESS_SOFTWARE;
[email protected]c05dfbb2014-07-10 22:49:04519 } else if (output_surface_->context_provider()) {
[email protected]ffbb2212013-06-02 23:47:59520 return DRAW_MODE_HARDWARE;
521 } else {
[email protected]c05dfbb2014-07-10 22:49:04522 DCHECK_EQ(!output_surface_->software_device(),
523 output_surface_->capabilities().delegated_rendering &&
524 !output_surface_->capabilities().deferred_gl_initialization)
525 << output_surface_->capabilities().delegated_rendering << " "
526 << output_surface_->capabilities().deferred_gl_initialization;
[email protected]ffbb2212013-06-02 23:47:59527 return DRAW_MODE_SOFTWARE;
528 }
529}
530
[email protected]34ba1ffb2014-03-05 06:55:03531static void AppendQuadsForLayer(
532 RenderPass* target_render_pass,
533 LayerImpl* layer,
534 const OcclusionTracker<LayerImpl>& occlusion_tracker,
535 AppendQuadsData* append_quads_data) {
vmpstr11b77b432014-10-07 20:11:40536 layer->AppendQuads(
537 target_render_pass,
538 occlusion_tracker.GetCurrentOcclusionForLayer(layer->draw_transform()),
539 append_quads_data);
[email protected]c1bb5af2013-03-13 19:06:27540}
541
542static void AppendQuadsForRenderSurfaceLayer(
543 RenderPass* target_render_pass,
544 LayerImpl* layer,
545 const RenderPass* contributing_render_pass,
[email protected]34ba1ffb2014-03-05 06:55:03546 const OcclusionTracker<LayerImpl>& occlusion_tracker,
[email protected]c1bb5af2013-03-13 19:06:27547 AppendQuadsData* append_quads_data) {
[email protected]c1bb5af2013-03-13 19:06:27548 bool is_replica = false;
[email protected]c6707fd2014-06-23 05:50:36549 layer->render_surface()->AppendQuads(target_render_pass,
550 occlusion_tracker,
[email protected]c1bb5af2013-03-13 19:06:27551 append_quads_data,
552 is_replica,
553 contributing_render_pass->id);
554
555 // Add replica after the surface so that it appears below the surface.
556 if (layer->has_replica()) {
557 is_replica = true;
[email protected]c6707fd2014-06-23 05:50:36558 layer->render_surface()->AppendQuads(target_render_pass,
559 occlusion_tracker,
[email protected]c1bb5af2013-03-13 19:06:27560 append_quads_data,
561 is_replica,
562 contributing_render_pass->id);
563 }
564}
565
566static void AppendQuadsToFillScreen(
[email protected]3744e27b2013-11-06 21:44:08567 ResourceProvider::ResourceId overhang_resource_id,
[email protected]cde98022014-01-16 19:59:20568 const gfx::SizeF& overhang_resource_scaled_size,
[email protected]0023fc72014-01-10 20:05:06569 const gfx::Rect& root_scroll_layer_rect,
[email protected]c1bb5af2013-03-13 19:06:27570 RenderPass* target_render_pass,
571 LayerImpl* root_layer,
572 SkColor screen_background_color,
[email protected]34ba1ffb2014-03-05 06:55:03573 const OcclusionTracker<LayerImpl>& occlusion_tracker) {
[email protected]c1bb5af2013-03-13 19:06:27574 if (!root_layer || !SkColorGetA(screen_background_color))
575 return;
576
577 Region fill_region = occlusion_tracker.ComputeVisibleRegionInScreen();
578 if (fill_region.IsEmpty())
579 return;
580
[email protected]3744e27b2013-11-06 21:44:08581 // Divide the fill region into the part to be filled with the overhang
582 // resource and the part to be filled with the background color.
583 Region screen_background_color_region = fill_region;
584 Region overhang_region;
585 if (overhang_resource_id) {
586 overhang_region = fill_region;
587 overhang_region.Subtract(root_scroll_layer_rect);
588 screen_background_color_region.Intersect(root_scroll_layer_rect);
589 }
590
[email protected]c1bb5af2013-03-13 19:06:27591 // Manually create the quad state for the gutter quads, as the root layer
592 // doesn't have any bounds and so can't generate this itself.
593 // TODO(danakj): Make the gutter quads generated by the solid color layer
594 // (make it smarter about generating quads to fill unoccluded areas).
595
596 gfx::Rect root_target_rect = root_layer->render_surface()->content_rect();
597 float opacity = 1.f;
[email protected]a9d4d4f2014-06-19 06:49:28598 int sorting_context_id = 0;
[email protected]c6707fd2014-06-23 05:50:36599 SharedQuadState* shared_quad_state =
600 target_render_pass->CreateAndAppendSharedQuadState();
[email protected]7785e1002014-02-20 21:04:32601 shared_quad_state->SetAll(gfx::Transform(),
[email protected]c1bb5af2013-03-13 19:06:27602 root_target_rect.size(),
603 root_target_rect,
604 root_target_rect,
[email protected]dc462d782012-11-21 21:43:01605 false,
[email protected]7bbeaf4e2013-11-26 10:27:22606 opacity,
[email protected]a9d4d4f2014-06-19 06:49:28607 SkXfermode::kSrcOver_Mode,
608 sorting_context_id);
[email protected]f57bbc02012-11-21 07:02:15609
[email protected]3744e27b2013-11-06 21:44:08610 for (Region::Iterator fill_rects(screen_background_color_region);
[email protected]c1bb5af2013-03-13 19:06:27611 fill_rects.has_rect();
612 fill_rects.next()) {
[email protected]7785e1002014-02-20 21:04:32613 gfx::Rect screen_space_rect = fill_rects.rect();
[email protected]9bf06c72014-03-07 18:16:24614 gfx::Rect visible_screen_space_rect = screen_space_rect;
[email protected]3744e27b2013-11-06 21:44:08615 // Skip the quad culler and just append the quads directly to avoid
616 // occlusion checks.
[email protected]f7030c32014-07-03 18:54:34617 SolidColorDrawQuad* quad =
618 target_render_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
[email protected]9bf06c72014-03-07 18:16:24619 quad->SetNew(shared_quad_state,
620 screen_space_rect,
621 visible_screen_space_rect,
622 screen_background_color,
623 false);
[email protected]3744e27b2013-11-06 21:44:08624 }
625 for (Region::Iterator fill_rects(overhang_region);
626 fill_rects.has_rect();
627 fill_rects.next()) {
628 DCHECK(overhang_resource_id);
[email protected]7785e1002014-02-20 21:04:32629 gfx::Rect screen_space_rect = fill_rects.rect();
[email protected]9bf06c72014-03-07 18:16:24630 gfx::Rect opaque_screen_space_rect = screen_space_rect;
631 gfx::Rect visible_screen_space_rect = screen_space_rect;
[email protected]f7030c32014-07-03 18:54:34632 TextureDrawQuad* tex_quad =
633 target_render_pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
[email protected]3744e27b2013-11-06 21:44:08634 const float vertex_opacity[4] = {1.f, 1.f, 1.f, 1.f};
635 tex_quad->SetNew(
636 shared_quad_state,
[email protected]7785e1002014-02-20 21:04:32637 screen_space_rect,
[email protected]9bf06c72014-03-07 18:16:24638 opaque_screen_space_rect,
639 visible_screen_space_rect,
[email protected]3744e27b2013-11-06 21:44:08640 overhang_resource_id,
641 false,
[email protected]7785e1002014-02-20 21:04:32642 gfx::PointF(
643 screen_space_rect.x() / overhang_resource_scaled_size.width(),
644 screen_space_rect.y() / overhang_resource_scaled_size.height()),
645 gfx::PointF(
646 screen_space_rect.right() / overhang_resource_scaled_size.width(),
647 screen_space_rect.bottom() /
648 overhang_resource_scaled_size.height()),
[email protected]3744e27b2013-11-06 21:44:08649 screen_background_color,
650 vertex_opacity,
651 false);
[email protected]c1bb5af2013-03-13 19:06:27652 }
[email protected]467b3612012-08-28 07:41:16653}
654
[email protected]30d82142014-05-12 04:26:02655DrawResult LayerTreeHostImpl::CalculateRenderPasses(
[email protected]7ddfe7e82014-01-30 07:22:11656 FrameData* frame) {
[email protected]c1bb5af2013-03-13 19:06:27657 DCHECK(frame->render_passes.empty());
[email protected]7ddfe7e82014-01-30 07:22:11658 DCHECK(CanDraw());
659 DCHECK(active_tree_->root_layer());
[email protected]2d692992012-12-19 01:19:32660
[email protected]c1bb5af2013-03-13 19:06:27661 TrackDamageForAllSurfaces(active_tree_->root_layer(),
662 *frame->render_surface_layer_list);
[email protected]94f206c12012-08-25 00:09:14663
[email protected]e0341352013-04-06 05:01:20664 // If the root render surface has no visible damage, then don't generate a
665 // frame at all.
666 RenderSurfaceImpl* root_surface =
667 active_tree_->root_layer()->render_surface();
668 bool root_surface_has_no_visible_damage =
669 !root_surface->damage_tracker()->current_damage_rect().Intersects(
670 root_surface->content_rect());
671 bool root_surface_has_contributing_layers =
672 !root_surface->layer_list().empty();
[email protected]5fda7f32014-03-12 20:44:29673 bool hud_wants_to_draw_ = active_tree_->hud_layer() &&
674 active_tree_->hud_layer()->IsAnimatingHUDContents();
[email protected]e0341352013-04-06 05:01:20675 if (root_surface_has_contributing_layers &&
[email protected]37c339be2014-02-06 09:44:23676 root_surface_has_no_visible_damage &&
[email protected]5fda7f32014-03-12 20:44:29677 active_tree_->LayersWithCopyOutputRequest().empty() &&
678 !hud_wants_to_draw_) {
[email protected]e0341352013-04-06 05:01:20679 TRACE_EVENT0("cc",
680 "LayerTreeHostImpl::CalculateRenderPasses::EmptyDamageRect");
681 frame->has_no_damage = true;
[email protected]6133cc232013-07-30 18:47:07682 DCHECK(!output_surface_->capabilities()
683 .draw_and_swap_full_viewport_every_frame);
[email protected]30d82142014-05-12 04:26:02684 return DRAW_SUCCESS;
[email protected]e0341352013-04-06 05:01:20685 }
686
[email protected]c1bb5af2013-03-13 19:06:27687 TRACE_EVENT1("cc",
688 "LayerTreeHostImpl::CalculateRenderPasses",
689 "render_surface_layer_list.size()",
[email protected]bf691c22013-03-26 21:15:06690 static_cast<uint64>(frame->render_surface_layer_list->size()));
[email protected]94f206c12012-08-25 00:09:14691
[email protected]c1bb5af2013-03-13 19:06:27692 // Create the render passes in dependency order.
693 for (int surface_index = frame->render_surface_layer_list->size() - 1;
[email protected]bf691c22013-03-26 21:15:06694 surface_index >= 0;
[email protected]c1bb5af2013-03-13 19:06:27695 --surface_index) {
696 LayerImpl* render_surface_layer =
697 (*frame->render_surface_layer_list)[surface_index];
[email protected]30fe19ff2013-07-04 00:54:45698 RenderSurfaceImpl* render_surface = render_surface_layer->render_surface();
699
700 bool should_draw_into_render_pass =
701 render_surface_layer->parent() == NULL ||
702 render_surface->contributes_to_drawn_surface() ||
703 render_surface_layer->HasCopyRequest();
704 if (should_draw_into_render_pass)
705 render_surface_layer->render_surface()->AppendRenderPasses(frame);
[email protected]c1bb5af2013-03-13 19:06:27706 }
[email protected]94f206c12012-08-25 00:09:14707
[email protected]f636ce82014-03-10 22:33:08708 // When we are displaying the HUD, change the root damage rect to cover the
709 // entire root surface. This will disable partial-swap/scissor optimizations
710 // that would prevent the HUD from updating, since the HUD does not cause
711 // damage itself, to prevent it from messing with damage visualizations. Since
712 // damage visualizations are done off the LayerImpls and RenderSurfaceImpls,
713 // changing the RenderPass does not affect them.
714 if (active_tree_->hud_layer()) {
715 RenderPass* root_pass = frame->render_passes.back();
716 root_pass->damage_rect = root_pass->output_rect;
717 }
718
[email protected]34ba1ffb2014-03-05 06:55:03719 OcclusionTracker<LayerImpl> occlusion_tracker(
[email protected]97c6a7342014-03-12 20:36:43720 active_tree_->root_layer()->render_surface()->content_rect());
[email protected]c1bb5af2013-03-13 19:06:27721 occlusion_tracker.set_minimum_tracking_size(
[email protected]8e0176d2013-03-21 03:14:52722 settings_.minimum_occlusion_tracking_size);
[email protected]94f206c12012-08-25 00:09:14723
[email protected]846f455b2013-03-18 19:07:41724 if (debug_state_.show_occluding_rects) {
[email protected]c1bb5af2013-03-13 19:06:27725 occlusion_tracker.set_occluding_screen_space_rects_container(
726 &frame->occluding_screen_space_rects);
727 }
[email protected]846f455b2013-03-18 19:07:41728 if (debug_state_.show_non_occluding_rects) {
[email protected]c1bb5af2013-03-13 19:06:27729 occlusion_tracker.set_non_occluding_screen_space_rects_container(
730 &frame->non_occluding_screen_space_rects);
731 }
[email protected]94f206c12012-08-25 00:09:14732
[email protected]ba1b33e2014-02-28 16:44:51733 // Add quads to the Render passes in front-to-back order to allow for testing
[email protected]c1bb5af2013-03-13 19:06:27734 // occlusion and performing culling during the tree walk.
[email protected]ba1b33e2014-02-28 16:44:51735 typedef LayerIterator<LayerImpl> LayerIteratorType;
[email protected]94f206c12012-08-25 00:09:14736
[email protected]c1bb5af2013-03-13 19:06:27737 // Typically when we are missing a texture and use a checkerboard quad, we
738 // still draw the frame. However when the layer being checkerboarded is moving
739 // due to an impl-animation, we drop the frame to avoid flashing due to the
740 // texture suddenly appearing in the future.
[email protected]30d82142014-05-12 04:26:02741 DrawResult draw_result = DRAW_SUCCESS;
[email protected]18a70192013-04-26 16:18:25742 // When we have a copy request for a layer, we need to draw no matter
743 // what, as the layer may disappear after this frame.
744 bool have_copy_request = false;
[email protected]94f206c12012-08-25 00:09:14745
[email protected]372bad5f2013-03-21 16:38:43746 int layers_drawn = 0;
747
[email protected]c05dfbb2014-07-10 22:49:04748 const DrawMode draw_mode = GetDrawMode();
[email protected]ffbb2212013-06-02 23:47:59749
[email protected]76ca89b2014-07-14 20:32:05750 int num_missing_tiles = 0;
751 int num_incomplete_tiles = 0;
752
[email protected]c1bb5af2013-03-13 19:06:27753 LayerIteratorType end =
[email protected]71dfcc72013-03-20 21:30:09754 LayerIteratorType::End(frame->render_surface_layer_list);
[email protected]c1bb5af2013-03-13 19:06:27755 for (LayerIteratorType it =
[email protected]71dfcc72013-03-20 21:30:09756 LayerIteratorType::Begin(frame->render_surface_layer_list);
[email protected]c1bb5af2013-03-13 19:06:27757 it != end;
758 ++it) {
[email protected]0cd7d6f72014-08-22 14:50:51759 RenderPassId target_render_pass_id =
760 it.target_render_surface_layer()->render_surface()->GetRenderPassId();
[email protected]c1bb5af2013-03-13 19:06:27761 RenderPass* target_render_pass =
762 frame->render_passes_by_id[target_render_pass_id];
[email protected]94f206c12012-08-25 00:09:14763
[email protected]e47b0a0a2013-11-18 23:26:22764 occlusion_tracker.EnterLayer(it);
[email protected]94f206c12012-08-25 00:09:14765
[email protected]30fe19ff2013-07-04 00:54:45766 AppendQuadsData append_quads_data(target_render_pass_id);
[email protected]89228202012-08-29 03:20:30767
[email protected]18a70192013-04-26 16:18:25768 if (it.represents_target_render_surface()) {
[email protected]0e5f7142013-05-24 06:45:36769 if (it->HasCopyRequest()) {
[email protected]18a70192013-04-26 16:18:25770 have_copy_request = true;
[email protected]d4d017e2013-06-20 21:46:11771 it->TakeCopyRequestsAndTransformToTarget(
772 &target_render_pass->copy_requests);
[email protected]18a70192013-04-26 16:18:25773 }
[email protected]30fe19ff2013-07-04 00:54:45774 } else if (it.represents_contributing_render_surface() &&
775 it->render_surface()->contributes_to_drawn_surface()) {
[email protected]0cd7d6f72014-08-22 14:50:51776 RenderPassId contributing_render_pass_id =
777 it->render_surface()->GetRenderPassId();
[email protected]c1bb5af2013-03-13 19:06:27778 RenderPass* contributing_render_pass =
779 frame->render_passes_by_id[contributing_render_pass_id];
780 AppendQuadsForRenderSurfaceLayer(target_render_pass,
781 *it,
782 contributing_render_pass,
783 occlusion_tracker,
784 &append_quads_data);
[email protected]8d964342014-05-15 18:22:27785 } else if (it.represents_itself() &&
[email protected]e1e768f2013-03-26 08:48:09786 !it->visible_content_rect().IsEmpty()) {
vmpstr01a5bf352014-09-17 22:57:31787 bool occluded =
788 occlusion_tracker.GetCurrentOcclusionForLayer(it->draw_transform())
789 .IsOccluded(it->visible_content_rect());
[email protected]fbc293322013-10-01 05:07:15790 if (!occluded && it->WillDraw(draw_mode, resource_provider_.get())) {
[email protected]c1bb5af2013-03-13 19:06:27791 DCHECK_EQ(active_tree_, it->layer_tree_impl());
[email protected]ffbb2212013-06-02 23:47:59792
[email protected]c1bb5af2013-03-13 19:06:27793 frame->will_draw_layers.push_back(*it);
[email protected]7d929c02012-09-20 17:26:57794
[email protected]c1bb5af2013-03-13 19:06:27795 if (it->HasContributingDelegatedRenderPasses()) {
[email protected]0cd7d6f72014-08-22 14:50:51796 RenderPassId contributing_render_pass_id =
[email protected]c1bb5af2013-03-13 19:06:27797 it->FirstContributingRenderPassId();
798 while (frame->render_passes_by_id.find(contributing_render_pass_id) !=
799 frame->render_passes_by_id.end()) {
800 RenderPass* render_pass =
801 frame->render_passes_by_id[contributing_render_pass_id];
[email protected]f5864912013-02-01 03:18:14802
[email protected]c1bb5af2013-03-13 19:06:27803 AppendQuadsData append_quads_data(render_pass->id);
804 AppendQuadsForLayer(render_pass,
805 *it,
806 occlusion_tracker,
807 &append_quads_data);
[email protected]7d929c02012-09-20 17:26:57808
[email protected]c1bb5af2013-03-13 19:06:27809 contributing_render_pass_id =
810 it->NextContributingRenderPassId(contributing_render_pass_id);
811 }
[email protected]94f206c12012-08-25 00:09:14812 }
813
[email protected]c1bb5af2013-03-13 19:06:27814 AppendQuadsForLayer(target_render_pass,
815 *it,
816 occlusion_tracker,
817 &append_quads_data);
818 }
[email protected]89228202012-08-29 03:20:30819
[email protected]372bad5f2013-03-21 16:38:43820 ++layers_drawn;
[email protected]94f206c12012-08-25 00:09:14821 }
822
[email protected]2bc19e532014-04-30 05:29:22823 rendering_stats_instrumentation_->AddVisibleContentArea(
824 append_quads_data.visible_content_area);
825 rendering_stats_instrumentation_->AddApproximatedVisibleContentArea(
826 append_quads_data.approximated_visible_content_area);
827
[email protected]76ca89b2014-07-14 20:32:05828 num_missing_tiles += append_quads_data.num_missing_tiles;
829 num_incomplete_tiles += append_quads_data.num_incomplete_tiles;
830
[email protected]e1e768f2013-03-26 08:48:09831 if (append_quads_data.num_missing_tiles) {
[email protected]c1bb5af2013-03-13 19:06:27832 bool layer_has_animating_transform =
833 it->screen_space_transform_is_animating() ||
834 it->draw_transform_is_animating();
[email protected]30d82142014-05-12 04:26:02835 if (layer_has_animating_transform)
836 draw_result = DRAW_ABORTED_CHECKERBOARD_ANIMATIONS;
[email protected]c1bb5af2013-03-13 19:06:27837 }
838
[email protected]76ca89b2014-07-14 20:32:05839 if (append_quads_data.num_incomplete_tiles ||
840 append_quads_data.num_missing_tiles) {
vmpstr61ed94a12014-10-09 04:49:30841 if (RequiresHighResToDraw())
[email protected]30d82142014-05-12 04:26:02842 draw_result = DRAW_ABORTED_MISSING_HIGH_RES_CONTENT;
[email protected]3d609bb2014-02-01 01:10:23843 }
[email protected]c1bb5af2013-03-13 19:06:27844
845 occlusion_tracker.LeaveLayer(it);
846 }
847
[email protected]6133cc232013-07-30 18:47:07848 if (have_copy_request ||
849 output_surface_->capabilities().draw_and_swap_full_viewport_every_frame)
[email protected]30d82142014-05-12 04:26:02850 draw_result = DRAW_SUCCESS;
[email protected]18a70192013-04-26 16:18:25851
[email protected]767f38d72014-03-18 21:26:41852#if DCHECK_IS_ON
weiliangc48805fce2014-10-29 20:30:12853 for (const auto& render_pass : frame->render_passes) {
854 for (const auto& quad : render_pass->quad_list)
855 DCHECK(quad->shared_quad_state);
weiliangc7eb7ee62014-10-07 00:04:40856 DCHECK(frame->render_passes_by_id.find(render_pass->id) !=
857 frame->render_passes_by_id.end());
[email protected]c1bb5af2013-03-13 19:06:27858 }
[email protected]94f206c12012-08-25 00:09:14859#endif
[email protected]c1bb5af2013-03-13 19:06:27860 DCHECK(frame->render_passes.back()->output_rect.origin().IsOrigin());
[email protected]94f206c12012-08-25 00:09:14861
[email protected]c1bb5af2013-03-13 19:06:27862 if (!active_tree_->has_transparent_background()) {
863 frame->render_passes.back()->has_transparent_background = false;
[email protected]3744e27b2013-11-06 21:44:08864 AppendQuadsToFillScreen(
865 ResourceIdForUIResource(overhang_ui_resource_id_),
866 gfx::ScaleSize(overhang_ui_resource_size_, device_scale_factor_),
867 active_tree_->RootScrollLayerDeviceViewportBounds(),
868 frame->render_passes.back(),
869 active_tree_->root_layer(),
870 active_tree_->background_color(),
871 occlusion_tracker);
[email protected]c1bb5af2013-03-13 19:06:27872 }
[email protected]94f206c12012-08-25 00:09:14873
[email protected]c1bb5af2013-03-13 19:06:27874 RemoveRenderPasses(CullRenderPassesWithNoQuads(), frame);
[email protected]45948712013-09-27 02:46:48875 renderer_->DecideRenderPassAllocationsForFrame(frame->render_passes);
[email protected]94f206c12012-08-25 00:09:14876
[email protected]30fe19ff2013-07-04 00:54:45877 // Any copy requests left in the tree are not going to get serviced, and
878 // should be aborted.
[email protected]19334ac2013-12-12 23:59:11879 ScopedPtrVector<CopyOutputRequest> requests_to_abort;
880 while (!active_tree_->LayersWithCopyOutputRequest().empty()) {
881 LayerImpl* layer = active_tree_->LayersWithCopyOutputRequest().back();
882 layer->TakeCopyRequestsAndTransformToTarget(&requests_to_abort);
[email protected]30fe19ff2013-07-04 00:54:45883 }
[email protected]19334ac2013-12-12 23:59:11884 for (size_t i = 0; i < requests_to_abort.size(); ++i)
885 requests_to_abort[i]->SendEmptyResult();
[email protected]30fe19ff2013-07-04 00:54:45886
[email protected]e0341352013-04-06 05:01:20887 // If we're making a frame to draw, it better have at least one render pass.
888 DCHECK(!frame->render_passes.empty());
[email protected]45948712013-09-27 02:46:48889
[email protected]759dc9f2014-07-23 19:18:51890 if (active_tree_->has_ever_been_drawn()) {
[email protected]76ca89b2014-07-14 20:32:05891 UMA_HISTOGRAM_COUNTS_100(
892 "Compositing.RenderPass.AppendQuadData.NumMissingTiles",
893 num_missing_tiles);
894 UMA_HISTOGRAM_COUNTS_100(
895 "Compositing.RenderPass.AppendQuadData.NumIncompleteTiles",
896 num_incomplete_tiles);
897 }
898
[email protected]45948712013-09-27 02:46:48899 // Should only have one render pass in resourceless software mode.
[email protected]c05dfbb2014-07-10 22:49:04900 DCHECK(draw_mode != DRAW_MODE_RESOURCELESS_SOFTWARE ||
901 frame->render_passes.size() == 1u)
902 << frame->render_passes.size();
[email protected]45948712013-09-27 02:46:48903
[email protected]7ddfe7e82014-01-30 07:22:11904 return draw_result;
[email protected]94f206c12012-08-25 00:09:14905}
906
[email protected]200a9c062013-05-20 04:34:37907void LayerTreeHostImpl::MainThreadHasStoppedFlinging() {
908 if (input_handler_client_)
909 input_handler_client_->MainThreadHasStoppedFlinging();
910}
911
[email protected]b8384e22013-12-03 02:20:48912void LayerTreeHostImpl::DidAnimateScrollOffset() {
913 client_->SetNeedsCommitOnImplThread();
914 client_->RenewTreePriority();
915}
916
[email protected]0023fc72014-01-10 20:05:06917void LayerTreeHostImpl::SetViewportDamage(const gfx::Rect& damage_rect) {
[email protected]878705be2013-04-15 22:44:02918 viewport_damage_rect_.Union(damage_rect);
919}
920
[email protected]c1bb5af2013-03-13 19:06:27921static inline RenderPass* FindRenderPassById(
[email protected]0cd7d6f72014-08-22 14:50:51922 RenderPassId render_pass_id,
[email protected]c1bb5af2013-03-13 19:06:27923 const LayerTreeHostImpl::FrameData& frame) {
924 RenderPassIdHashMap::const_iterator it =
925 frame.render_passes_by_id.find(render_pass_id);
926 return it != frame.render_passes_by_id.end() ? it->second : NULL;
[email protected]94f206c12012-08-25 00:09:14927}
928
[email protected]0cd7d6f72014-08-22 14:50:51929static void RemoveRenderPassesRecursive(RenderPassId remove_render_pass_id,
[email protected]c1bb5af2013-03-13 19:06:27930 LayerTreeHostImpl::FrameData* frame) {
931 RenderPass* remove_render_pass =
932 FindRenderPassById(remove_render_pass_id, *frame);
933 // The pass was already removed by another quad - probably the original, and
934 // we are the replica.
935 if (!remove_render_pass)
936 return;
937 RenderPassList& render_passes = frame->render_passes;
938 RenderPassList::iterator to_remove = std::find(render_passes.begin(),
939 render_passes.end(),
940 remove_render_pass);
[email protected]94f206c12012-08-25 00:09:14941
[email protected]c1bb5af2013-03-13 19:06:27942 DCHECK(to_remove != render_passes.end());
[email protected]94f206c12012-08-25 00:09:14943
[email protected]c1bb5af2013-03-13 19:06:27944 scoped_ptr<RenderPass> removed_pass = render_passes.take(to_remove);
945 frame->render_passes.erase(to_remove);
946 frame->render_passes_by_id.erase(remove_render_pass_id);
[email protected]94f206c12012-08-25 00:09:14947
[email protected]c1bb5af2013-03-13 19:06:27948 // Now follow up for all RenderPass quads and remove their RenderPasses
949 // recursively.
950 const QuadList& quad_list = removed_pass->quad_list;
weiliangc48805fce2014-10-29 20:30:12951 for (auto quad_list_iterator = quad_list.BackToFrontBegin();
952 quad_list_iterator != quad_list.BackToFrontEnd();
[email protected]c1bb5af2013-03-13 19:06:27953 ++quad_list_iterator) {
weiliangc48805fce2014-10-29 20:30:12954 const DrawQuad* current_quad = *quad_list_iterator;
[email protected]c1bb5af2013-03-13 19:06:27955 if (current_quad->material != DrawQuad::RENDER_PASS)
956 continue;
[email protected]94f206c12012-08-25 00:09:14957
[email protected]0cd7d6f72014-08-22 14:50:51958 RenderPassId next_remove_render_pass_id =
[email protected]c1bb5af2013-03-13 19:06:27959 RenderPassDrawQuad::MaterialCast(current_quad)->render_pass_id;
960 RemoveRenderPassesRecursive(next_remove_render_pass_id, frame);
961 }
[email protected]94f206c12012-08-25 00:09:14962}
963
[email protected]c1bb5af2013-03-13 19:06:27964bool LayerTreeHostImpl::CullRenderPassesWithNoQuads::ShouldRemoveRenderPass(
965 const RenderPassDrawQuad& quad, const FrameData& frame) const {
966 const RenderPass* render_pass =
967 FindRenderPassById(quad.render_pass_id, frame);
968 if (!render_pass)
969 return false;
[email protected]94f206c12012-08-25 00:09:14970
[email protected]c1bb5af2013-03-13 19:06:27971 // If any quad or RenderPass draws into this RenderPass, then keep it.
972 const QuadList& quad_list = render_pass->quad_list;
weiliangc48805fce2014-10-29 20:30:12973 for (auto quad_list_iterator = quad_list.BackToFrontBegin();
[email protected]ed511b8d2013-03-25 03:29:29974 quad_list_iterator != quad_list.BackToFrontEnd();
[email protected]c1bb5af2013-03-13 19:06:27975 ++quad_list_iterator) {
weiliangc48805fce2014-10-29 20:30:12976 const DrawQuad* current_quad = *quad_list_iterator;
[email protected]94f206c12012-08-25 00:09:14977
[email protected]c1bb5af2013-03-13 19:06:27978 if (current_quad->material != DrawQuad::RENDER_PASS)
979 return false;
[email protected]94f206c12012-08-25 00:09:14980
[email protected]c1bb5af2013-03-13 19:06:27981 const RenderPass* contributing_pass = FindRenderPassById(
982 RenderPassDrawQuad::MaterialCast(current_quad)->render_pass_id, frame);
983 if (contributing_pass)
984 return false;
985 }
986 return true;
[email protected]94f206c12012-08-25 00:09:14987}
988
989// Defined for linking tests.
[email protected]c1bb5af2013-03-13 19:06:27990template CC_EXPORT void LayerTreeHostImpl::RemoveRenderPasses<
[email protected]c1bb5af2013-03-13 19:06:27991 LayerTreeHostImpl::CullRenderPassesWithNoQuads>(
992 CullRenderPassesWithNoQuads culler, FrameData*);
[email protected]94f206c12012-08-25 00:09:14993
994// static
[email protected]c1bb5af2013-03-13 19:06:27995template <typename RenderPassCuller>
996void LayerTreeHostImpl::RemoveRenderPasses(RenderPassCuller culler,
997 FrameData* frame) {
998 for (size_t it = culler.RenderPassListBegin(frame->render_passes);
999 it != culler.RenderPassListEnd(frame->render_passes);
1000 it = culler.RenderPassListNext(it)) {
1001 const RenderPass* current_pass = frame->render_passes[it];
1002 const QuadList& quad_list = current_pass->quad_list;
[email protected]94f206c12012-08-25 00:09:141003
weiliangc48805fce2014-10-29 20:30:121004 for (auto quad_list_iterator = quad_list.BackToFrontBegin();
1005 quad_list_iterator != quad_list.BackToFrontEnd();
[email protected]c1bb5af2013-03-13 19:06:271006 ++quad_list_iterator) {
weiliangc48805fce2014-10-29 20:30:121007 const DrawQuad* current_quad = *quad_list_iterator;
[email protected]94f206c12012-08-25 00:09:141008
[email protected]c1bb5af2013-03-13 19:06:271009 if (current_quad->material != DrawQuad::RENDER_PASS)
1010 continue;
[email protected]94f206c12012-08-25 00:09:141011
[email protected]c1bb5af2013-03-13 19:06:271012 const RenderPassDrawQuad* render_pass_quad =
1013 RenderPassDrawQuad::MaterialCast(current_quad);
1014 if (!culler.ShouldRemoveRenderPass(*render_pass_quad, *frame))
1015 continue;
[email protected]94f206c12012-08-25 00:09:141016
[email protected]c1bb5af2013-03-13 19:06:271017 // We are changing the vector in the middle of iteration. Because we
1018 // delete render passes that draw into the current pass, we are
1019 // guaranteed that any data from the iterator to the end will not
1020 // change. So, capture the iterator position from the end of the
1021 // list, and restore it after the change.
1022 size_t position_from_end = frame->render_passes.size() - it;
1023 RemoveRenderPassesRecursive(render_pass_quad->render_pass_id, frame);
1024 it = frame->render_passes.size() - position_from_end;
1025 DCHECK_GE(frame->render_passes.size(), position_from_end);
[email protected]94f206c12012-08-25 00:09:141026 }
[email protected]c1bb5af2013-03-13 19:06:271027 }
[email protected]94f206c12012-08-25 00:09:141028}
1029
[email protected]2aae96792014-05-15 23:10:501030DrawResult LayerTreeHostImpl::PrepareToDraw(FrameData* frame) {
[email protected]7a52f43e2013-07-10 01:58:471031 TRACE_EVENT1("cc",
1032 "LayerTreeHostImpl::PrepareToDraw",
1033 "SourceFrameNumber",
1034 active_tree_->source_frame_number());
danakja819c2552014-11-14 02:05:041035 // This will cause NotifyTileStateChanged() to be called for any visible tiles
1036 // that completed, which will add damage to the frame for them so they appear
1037 // as part of the current frame being drawn.
1038 if (settings().impl_side_painting)
1039 tile_manager_->UpdateVisibleTiles();
[email protected]39643fb2013-07-09 17:28:191040
[email protected]aebf4622014-07-14 16:57:591041 UMA_HISTOGRAM_CUSTOM_COUNTS(
1042 "Compositing.NumActiveLayers", active_tree_->NumLayers(), 1, 400, 20);
1043
[email protected]8f7f298822014-06-13 00:23:321044 bool ok = active_tree_->UpdateDrawProperties();
1045 DCHECK(ok) << "UpdateDrawProperties failed during draw";
[email protected]2e7ca422012-12-20 02:57:271046
[email protected]c1bb5af2013-03-13 19:06:271047 frame->render_surface_layer_list = &active_tree_->RenderSurfaceLayerList();
1048 frame->render_passes.clear();
1049 frame->render_passes_by_id.clear();
1050 frame->will_draw_layers.clear();
[email protected]e0341352013-04-06 05:01:201051 frame->has_no_damage = false;
1052
1053 if (active_tree_->root_layer()) {
[email protected]2aae96792014-05-15 23:10:501054 gfx::Rect device_viewport_damage_rect = viewport_damage_rect_;
[email protected]878705be2013-04-15 22:44:021055 viewport_damage_rect_ = gfx::Rect();
[email protected]e0341352013-04-06 05:01:201056
1057 active_tree_->root_layer()->render_surface()->damage_tracker()->
1058 AddDamageNextUpdate(device_viewport_damage_rect);
1059 }
[email protected]94f206c12012-08-25 00:09:141060
[email protected]30d82142014-05-12 04:26:021061 DrawResult draw_result = CalculateRenderPasses(frame);
1062 if (draw_result != DRAW_SUCCESS) {
[email protected]6133cc232013-07-30 18:47:071063 DCHECK(!output_surface_->capabilities()
1064 .draw_and_swap_full_viewport_every_frame);
[email protected]7ddfe7e82014-01-30 07:22:111065 return draw_result;
[email protected]6133cc232013-07-30 18:47:071066 }
[email protected]94f206c12012-08-25 00:09:141067
[email protected]7ddfe7e82014-01-30 07:22:111068 // If we return DRAW_SUCCESS, then we expect DrawLayers() to be called before
1069 // this function is called again.
1070 return draw_result;
[email protected]94f206c12012-08-25 00:09:141071}
1072
[email protected]0309ba5e02013-06-26 04:11:081073void LayerTreeHostImpl::EvictTexturesForTesting() {
1074 EnforceManagedMemoryPolicy(ManagedMemoryPolicy(0));
1075}
1076
[email protected]4f48f6e2013-08-27 06:33:381077void LayerTreeHostImpl::BlockNotifyReadyToActivateForTesting(bool block) {
1078 NOTREACHED();
1079}
1080
[email protected]34bff2122014-05-16 04:09:341081void LayerTreeHostImpl::ResetTreesForTesting() {
1082 if (active_tree_)
1083 active_tree_->DetachLayerTree();
1084 active_tree_ = LayerTreeImpl::create(this);
1085 if (pending_tree_)
1086 pending_tree_->DetachLayerTree();
danakjf446a072014-09-27 21:55:481087 pending_tree_ = nullptr;
[email protected]34bff2122014-05-16 04:09:341088 if (recycle_tree_)
1089 recycle_tree_->DetachLayerTree();
danakjf446a072014-09-27 21:55:481090 recycle_tree_ = nullptr;
[email protected]34bff2122014-05-16 04:09:341091}
1092
[email protected]c1bb5af2013-03-13 19:06:271093void LayerTreeHostImpl::EnforceManagedMemoryPolicy(
1094 const ManagedMemoryPolicy& policy) {
[email protected]206a3922013-05-17 06:34:121095
[email protected]c1bb5af2013-03-13 19:06:271096 bool evicted_resources = client_->ReduceContentsTextureMemoryOnImplThread(
[email protected]0b8ef2842013-11-01 09:53:351097 visible_ ? policy.bytes_limit_when_visible : 0,
[email protected]46b8acc2013-03-19 22:38:351098 ManagedMemoryPolicy::PriorityCutoffToValue(
1099 visible_ ? policy.priority_cutoff_when_visible
[email protected]0b8ef2842013-11-01 09:53:351100 : gpu::MemoryAllocation::CUTOFF_ALLOW_NOTHING));
[email protected]c1bb5af2013-03-13 19:06:271101 if (evicted_resources) {
1102 active_tree_->SetContentsTexturesPurged();
1103 if (pending_tree_)
1104 pending_tree_->SetContentsTexturesPurged();
1105 client_->SetNeedsCommitOnImplThread();
1106 client_->OnCanDrawStateChanged(CanDraw());
1107 client_->RenewTreePriority();
1108 }
[email protected]8947cbe2012-11-28 05:27:431109
[email protected]8be1a9bf2013-05-01 03:45:191110 UpdateTileManagerMemoryPolicy(policy);
1111}
1112
1113void LayerTreeHostImpl::UpdateTileManagerMemoryPolicy(
1114 const ManagedMemoryPolicy& policy) {
1115 if (!tile_manager_)
1116 return;
1117
[email protected]25489c02014-02-13 23:18:411118 global_tile_state_.hard_memory_limit_in_bytes = 0;
1119 global_tile_state_.soft_memory_limit_in_bytes = 0;
1120 if (visible_ && policy.bytes_limit_when_visible > 0) {
1121 global_tile_state_.hard_memory_limit_in_bytes =
1122 policy.bytes_limit_when_visible;
1123 global_tile_state_.soft_memory_limit_in_bytes =
[email protected]831414e2014-02-22 02:27:371124 (static_cast<int64>(global_tile_state_.hard_memory_limit_in_bytes) *
1125 settings_.max_memory_for_prepaint_percentage) /
1126 100;
[email protected]25489c02014-02-13 23:18:411127 }
[email protected]1bcced22013-09-24 13:51:191128 global_tile_state_.memory_limit_policy =
[email protected]8be1a9bf2013-05-01 03:45:191129 ManagedMemoryPolicy::PriorityCutoffToTileMemoryLimitPolicy(
1130 visible_ ?
1131 policy.priority_cutoff_when_visible :
[email protected]0b8ef2842013-11-01 09:53:351132 gpu::MemoryAllocation::CUTOFF_ALLOW_NOTHING);
[email protected]1bcced22013-09-24 13:51:191133 global_tile_state_.num_resources_limit = policy.num_resources_limit;
[email protected]c48536a52013-09-14 00:02:081134
[email protected]b7635e02014-04-28 07:08:431135 // TODO(reveman): We should avoid keeping around unused resources if
1136 // possible. crbug.com/224475
1137 // Unused limit is calculated from soft-limit, as hard-limit may
1138 // be very high and shouldn't typically be exceeded.
1139 size_t unused_memory_limit_in_bytes = static_cast<size_t>(
1140 (static_cast<int64>(global_tile_state_.soft_memory_limit_in_bytes) *
1141 settings_.max_unused_resource_memory_percentage) /
1142 100);
1143
[email protected]eece11e2014-04-12 03:07:161144 DCHECK(resource_pool_);
reveman51883faa2014-10-29 21:04:401145 resource_pool_->CheckBusyResources(false);
[email protected]eece11e2014-04-12 03:07:161146 // Soft limit is used for resource pool such that memory returns to soft
1147 // limit after going over.
1148 resource_pool_->SetResourceUsageLimits(
1149 global_tile_state_.soft_memory_limit_in_bytes,
[email protected]b7635e02014-04-28 07:08:431150 unused_memory_limit_in_bytes,
[email protected]eece11e2014-04-12 03:07:161151 global_tile_state_.num_resources_limit);
1152
revemanc84602a02014-09-24 15:41:251153 // Release all staging resources when invisible.
[email protected]2cccfef2014-05-01 06:05:161154 if (staging_resource_pool_) {
reveman51883faa2014-10-29 21:04:401155 staging_resource_pool_->CheckBusyResources(false);
[email protected]2cccfef2014-05-01 06:05:161156 staging_resource_pool_->SetResourceUsageLimits(
revemanc84602a02014-09-24 15:41:251157 std::numeric_limits<size_t>::max(),
1158 std::numeric_limits<size_t>::max(),
1159 visible_ ? GetMaxStagingResourceCount() : 0);
[email protected]2cccfef2014-05-01 06:05:161160 }
1161
[email protected]c48536a52013-09-14 00:02:081162 DidModifyTilePriorities();
1163}
1164
1165void LayerTreeHostImpl::DidModifyTilePriorities() {
1166 DCHECK(settings_.impl_side_painting);
1167 // Mark priorities as dirty and schedule a ManageTiles().
1168 tile_priorities_dirty_ = true;
1169 client_->SetNeedsManageTilesOnImplThread();
[email protected]94f206c12012-08-25 00:09:141170}
1171
[email protected]bf050582014-07-24 11:10:581172void LayerTreeHostImpl::GetPictureLayerImplPairs(
e.hakkinen85c0bffe2014-11-12 20:02:301173 std::vector<PictureLayerImpl::Pair>* layer_pairs,
1174 bool need_valid_tile_priorities) const {
[email protected]bf050582014-07-24 11:10:581175 DCHECK(layer_pairs->empty());
1176 for (std::vector<PictureLayerImpl*>::const_iterator it =
1177 picture_layers_.begin();
1178 it != picture_layers_.end();
1179 ++it) {
1180 PictureLayerImpl* layer = *it;
1181
e.hakkinen85c0bffe2014-11-12 20:02:301182 if (!layer->IsOnActiveOrPendingTree() ||
1183 (need_valid_tile_priorities && !layer->HasValidTilePriorities()))
[email protected]bf050582014-07-24 11:10:581184 continue;
1185
danakj7b08e2862014-10-27 20:29:591186 PictureLayerImpl* twin_layer = layer->GetPendingOrActiveTwinLayer();
[email protected]bf050582014-07-24 11:10:581187
1188 // Ignore the twin layer when tile priorities are invalid.
e.hakkinen85c0bffe2014-11-12 20:02:301189 if (need_valid_tile_priorities && twin_layer &&
1190 !twin_layer->HasValidTilePriorities())
[email protected]bf050582014-07-24 11:10:581191 twin_layer = NULL;
1192
1193 // If the current tree is ACTIVE_TREE, then always generate a layer_pair.
1194 // If current tree is PENDING_TREE, then only generate a layer_pair if
1195 // there is no twin layer.
1196 if (layer->GetTree() == ACTIVE_TREE) {
e.hakkinen85c0bffe2014-11-12 20:02:301197 DCHECK_IMPLIES(twin_layer, twin_layer->GetTree() == PENDING_TREE);
[email protected]bf050582014-07-24 11:10:581198 layer_pairs->push_back(PictureLayerImpl::Pair(layer, twin_layer));
1199 } else if (!twin_layer) {
e.hakkinen85c0bffe2014-11-12 20:02:301200 DCHECK(layer->GetTree() == PENDING_TREE);
[email protected]bf050582014-07-24 11:10:581201 layer_pairs->push_back(PictureLayerImpl::Pair(NULL, layer));
1202 }
1203 }
1204}
1205
1206void LayerTreeHostImpl::BuildRasterQueue(RasterTilePriorityQueue* queue,
1207 TreePriority tree_priority) {
vmpstrd554d082014-10-15 18:11:251208 TRACE_EVENT0("cc", "LayerTreeHostImpl::BuildRasterQueue");
[email protected]bf050582014-07-24 11:10:581209 picture_layer_pairs_.clear();
e.hakkinen85c0bffe2014-11-12 20:02:301210 GetPictureLayerImplPairs(&picture_layer_pairs_, true);
[email protected]bf050582014-07-24 11:10:581211 queue->Build(picture_layer_pairs_, tree_priority);
danakja819c2552014-11-14 02:05:041212
1213 if (!queue->IsEmpty()) {
1214 // Only checking the Top() tile here isn't a definite answer that there is
1215 // or isn't something required for draw in this raster queue. It's just a
1216 // heuristic to let us hit the common case and proactively tell the
1217 // scheduler that we expect to draw within each vsync until we get all the
1218 // tiles ready to draw. If we happen to miss a required for draw tile here,
1219 // then we will miss telling the scheduler each frame that we intend to draw
1220 // so it may make worse scheduling decisions.
1221 required_for_draw_tile_is_top_of_raster_queue_ =
1222 queue->Top()->required_for_draw();
1223 } else {
1224 required_for_draw_tile_is_top_of_raster_queue_ = false;
1225 }
[email protected]bf050582014-07-24 11:10:581226}
1227
1228void LayerTreeHostImpl::BuildEvictionQueue(EvictionTilePriorityQueue* queue,
1229 TreePriority tree_priority) {
vmpstrd554d082014-10-15 18:11:251230 TRACE_EVENT0("cc", "LayerTreeHostImpl::BuildEvictionQueue");
[email protected]bf050582014-07-24 11:10:581231 picture_layer_pairs_.clear();
e.hakkinen85c0bffe2014-11-12 20:02:301232 GetPictureLayerImplPairs(&picture_layer_pairs_, false);
[email protected]bf050582014-07-24 11:10:581233 queue->Build(picture_layer_pairs_, tree_priority);
1234}
1235
1236const std::vector<PictureLayerImpl*>& LayerTreeHostImpl::GetPictureLayers()
1237 const {
[email protected]8aa39ecb2014-06-12 14:19:141238 return picture_layers_;
1239}
1240
[email protected]94bf75c2013-06-12 13:20:041241void LayerTreeHostImpl::NotifyReadyToActivate() {
[email protected]4f48f6e2013-08-27 06:33:381242 client_->NotifyReadyToActivate();
[email protected]94bf75c2013-06-12 13:20:041243}
1244
ernstmdfac03e2014-11-11 20:18:051245void LayerTreeHostImpl::NotifyReadyToDraw() {
danakja819c2552014-11-14 02:05:041246 // Tiles that are ready will cause NotifyTileStateChanged() to be called so we
1247 // don't need to schedule a draw here. Just stop WillBeginImplFrame() from
1248 // causing optimistic requests to draw a frame.
1249 required_for_draw_tile_is_top_of_raster_queue_ = false;
1250
ernstmdfac03e2014-11-11 20:18:051251 client_->NotifyReadyToDraw();
1252}
1253
[email protected]8f802b22014-05-27 21:28:121254void LayerTreeHostImpl::NotifyTileStateChanged(const Tile* tile) {
1255 TRACE_EVENT0("cc", "LayerTreeHostImpl::NotifyTileStateChanged");
[email protected]cfa7fd922014-04-29 11:50:031256
[email protected]90af23b2014-04-30 07:00:341257 if (active_tree_) {
1258 LayerImpl* layer_impl =
1259 active_tree_->FindActiveTreeLayerById(tile->layer_id());
1260 if (layer_impl)
[email protected]8f802b22014-05-27 21:28:121261 layer_impl->NotifyTileStateChanged(tile);
[email protected]90af23b2014-04-30 07:00:341262 }
1263
1264 if (pending_tree_) {
1265 LayerImpl* layer_impl =
1266 pending_tree_->FindPendingTreeLayerById(tile->layer_id());
1267 if (layer_impl)
[email protected]8f802b22014-05-27 21:28:121268 layer_impl->NotifyTileStateChanged(tile);
[email protected]cfa7fd922014-04-29 11:50:031269 }
danakja819c2552014-11-14 02:05:041270
1271 // Check for a non-null active tree to avoid doing this during shutdown.
1272 if (active_tree_ && !client_->IsInsideDraw() && tile->required_for_draw()) {
1273 // The LayerImpl::NotifyTileStateChanged() should damage the layer, so this
1274 // redraw will make those tiles be displayed.
1275 SetNeedsRedraw();
1276 }
[email protected]cfa7fd922014-04-29 11:50:031277}
1278
[email protected]3f2ff112013-08-03 02:41:071279void LayerTreeHostImpl::SetMemoryPolicy(const ManagedMemoryPolicy& policy) {
1280 SetManagedMemoryPolicy(policy, zero_budget_);
1281}
1282
[email protected]5f07afc2013-07-19 05:17:181283void LayerTreeHostImpl::SetTreeActivationCallback(
1284 const base::Closure& callback) {
1285 DCHECK(proxy_->IsImplThread());
1286 DCHECK(settings_.impl_side_painting || callback.is_null());
[email protected]2022c672013-07-23 19:55:261287 tree_activation_callback_ = callback;
[email protected]5f07afc2013-07-19 05:17:181288}
1289
[email protected]c1bb5af2013-03-13 19:06:271290void LayerTreeHostImpl::SetManagedMemoryPolicy(
[email protected]3f2ff112013-08-03 02:41:071291 const ManagedMemoryPolicy& policy, bool zero_budget) {
1292 if (cached_managed_memory_policy_ == policy && zero_budget_ == zero_budget)
[email protected]c1bb5af2013-03-13 19:06:271293 return;
[email protected]61de5812012-11-08 07:03:441294
[email protected]3f2ff112013-08-03 02:41:071295 ManagedMemoryPolicy old_policy = ActualManagedMemoryPolicy();
1296
1297 cached_managed_memory_policy_ = policy;
1298 zero_budget_ = zero_budget;
1299 ManagedMemoryPolicy actual_policy = ActualManagedMemoryPolicy();
1300
1301 if (old_policy == actual_policy)
1302 return;
1303
1304 if (!proxy_->HasImplThread()) {
1305 // In single-thread mode, this can be called on the main thread by
1306 // GLRenderer::OnMemoryAllocationChanged.
1307 DebugScopedSetImplThread impl_thread(proxy_);
1308 EnforceManagedMemoryPolicy(actual_policy);
1309 } else {
1310 DCHECK(proxy_->IsImplThread());
1311 EnforceManagedMemoryPolicy(actual_policy);
1312 }
[email protected]50644642013-06-20 13:58:551313
[email protected]d7626ffd2013-03-29 00:17:421314 // If there is already enough memory to draw everything imaginable and the
1315 // new memory limit does not change this, then do not re-commit. Don't bother
1316 // skipping commits if this is not visible (commits don't happen when not
1317 // visible, there will almost always be a commit when this becomes visible).
1318 bool needs_commit = true;
1319 if (visible() &&
[email protected]3f2ff112013-08-03 02:41:071320 actual_policy.bytes_limit_when_visible >= max_memory_needed_bytes_ &&
1321 old_policy.bytes_limit_when_visible >= max_memory_needed_bytes_ &&
1322 actual_policy.priority_cutoff_when_visible ==
1323 old_policy.priority_cutoff_when_visible) {
[email protected]d7626ffd2013-03-29 00:17:421324 needs_commit = false;
1325 }
1326
[email protected]d7626ffd2013-03-29 00:17:421327 if (needs_commit)
1328 client_->SetNeedsCommitOnImplThread();
[email protected]94f206c12012-08-25 00:09:141329}
1330
[email protected]f224cc92013-06-06 23:23:321331void LayerTreeHostImpl::SetExternalDrawConstraints(
1332 const gfx::Transform& transform,
[email protected]0023fc72014-01-10 20:05:061333 const gfx::Rect& viewport,
1334 const gfx::Rect& clip,
[email protected]bd5324592014-07-31 09:09:331335 const gfx::Rect& viewport_rect_for_tile_priority,
1336 const gfx::Transform& transform_for_tile_priority,
[email protected]c05dfbb2014-07-10 22:49:041337 bool resourceless_software_draw) {
[email protected]bd5324592014-07-31 09:09:331338 gfx::Rect viewport_rect_for_tile_priority_in_view_space;
1339 if (!resourceless_software_draw) {
1340 gfx::Transform screen_to_view(gfx::Transform::kSkipInitialization);
1341 if (transform_for_tile_priority.GetInverse(&screen_to_view)) {
1342 // Convert from screen space to view space.
1343 viewport_rect_for_tile_priority_in_view_space =
1344 gfx::ToEnclosingRect(MathUtil::ProjectClippedRect(
1345 screen_to_view, viewport_rect_for_tile_priority));
1346 }
1347 }
1348
[email protected]c05dfbb2014-07-10 22:49:041349 if (external_transform_ != transform || external_viewport_ != viewport ||
[email protected]bd5324592014-07-31 09:09:331350 resourceless_software_draw_ != resourceless_software_draw ||
1351 viewport_rect_for_tile_priority_ !=
1352 viewport_rect_for_tile_priority_in_view_space) {
[email protected]ea12b5502014-06-24 21:37:361353 active_tree_->set_needs_update_draw_properties();
1354 }
1355
[email protected]f224cc92013-06-06 23:23:321356 external_transform_ = transform;
1357 external_viewport_ = viewport;
[email protected]54af03522013-09-05 00:43:281358 external_clip_ = clip;
[email protected]bd5324592014-07-31 09:09:331359 viewport_rect_for_tile_priority_ =
1360 viewport_rect_for_tile_priority_in_view_space;
[email protected]c05dfbb2014-07-10 22:49:041361 resourceless_software_draw_ = resourceless_software_draw;
[email protected]f224cc92013-06-06 23:23:321362}
1363
[email protected]0023fc72014-01-10 20:05:061364void LayerTreeHostImpl::SetNeedsRedrawRect(const gfx::Rect& damage_rect) {
[email protected]6be422b2013-12-08 06:47:311365 if (damage_rect.IsEmpty())
1366 return;
1367 NotifySwapPromiseMonitorsOfSetNeedsRedraw();
[email protected]1cd9f5552013-04-26 04:22:031368 client_->SetNeedsRedrawRectOnImplThread(damage_rect);
1369}
1370
[email protected]4d7e46a2013-11-08 05:33:401371void LayerTreeHostImpl::DidSwapBuffers() {
1372 client_->DidSwapBuffersOnImplThread();
1373}
1374
[email protected]c14902662014-04-18 05:06:111375void LayerTreeHostImpl::DidSwapBuffersComplete() {
1376 client_->DidSwapBuffersCompleteOnImplThread();
[email protected]a7335e0b2013-09-18 09:34:511377}
1378
1379void LayerTreeHostImpl::ReclaimResources(const CompositorFrameAck* ack) {
[email protected]c1bb5af2013-03-13 19:06:271380 // TODO(piman): We may need to do some validation on this ack before
1381 // processing it.
[email protected]a7335e0b2013-09-18 09:34:511382 if (renderer_)
[email protected]36e5ff12013-06-11 12:19:291383 renderer_->ReceiveSwapBuffersAck(*ack);
[email protected]43b552672014-04-05 00:38:571384
1385 // In OOM, we now might be able to release more resources that were held
1386 // because they were exported.
1387 if (tile_manager_) {
[email protected]eece11e2014-04-12 03:07:161388 DCHECK(resource_pool_);
[email protected]43b552672014-04-05 00:38:571389
reveman51883faa2014-10-29 21:04:401390 resource_pool_->CheckBusyResources(false);
[email protected]eece11e2014-04-12 03:07:161391 resource_pool_->ReduceResourceUsage();
[email protected]43b552672014-04-05 00:38:571392 }
[email protected]e97908d2014-04-09 12:48:041393 // If we're not visible, we likely released resources, so we want to
1394 // aggressively flush here to make sure those DeleteTextures make it to the
1395 // GPU process to free up the memory.
[email protected]110fcc0e2014-07-16 15:52:471396 if (output_surface_->context_provider() && !visible_) {
1397 output_surface_->context_provider()->ContextGL()->ShallowFlushCHROMIUM();
1398 }
[email protected]a46f32932012-12-07 21:43:161399}
1400
[email protected]c1bb5af2013-03-13 19:06:271401void LayerTreeHostImpl::OnCanDrawStateChangedForTree() {
1402 client_->OnCanDrawStateChanged(CanDraw());
[email protected]3b31c6ac2012-12-06 21:27:291403}
1404
[email protected]c1bb5af2013-03-13 19:06:271405CompositorFrameMetadata LayerTreeHostImpl::MakeCompositorFrameMetadata() const {
1406 CompositorFrameMetadata metadata;
1407 metadata.device_scale_factor = device_scale_factor_;
1408 metadata.page_scale_factor = active_tree_->total_page_scale_factor();
[email protected]f3f611f2014-07-09 04:05:321409 metadata.scrollable_viewport_size = active_tree_->ScrollableViewportSize();
[email protected]c1bb5af2013-03-13 19:06:271410 metadata.root_layer_size = active_tree_->ScrollableSize();
1411 metadata.min_page_scale_factor = active_tree_->min_page_scale_factor();
1412 metadata.max_page_scale_factor = active_tree_->max_page_scale_factor();
1413 if (top_controls_manager_) {
1414 metadata.location_bar_offset =
bokan88eae012014-09-09 20:40:421415 gfx::Vector2dF(0.f, top_controls_manager_->ControlsTopOffset());
[email protected]c1bb5af2013-03-13 19:06:271416 metadata.location_bar_content_translation =
bokan88eae012014-09-09 20:40:421417 gfx::Vector2dF(0.f, top_controls_manager_->ContentTopOffset());
[email protected]c1bb5af2013-03-13 19:06:271418 }
[email protected]bf189f62012-12-18 03:42:111419
[email protected]ebb179b2014-07-16 17:54:411420 active_tree_->GetViewportSelection(&metadata.selection_start,
1421 &metadata.selection_end);
[email protected]19aec372014-07-01 19:08:491422
[email protected]adeda572014-01-31 00:49:471423 if (!InnerViewportScrollLayer())
[email protected]bf189f62012-12-18 03:42:111424 return metadata;
[email protected]c1bb5af2013-03-13 19:06:271425
miletusf57925d2014-10-01 19:38:131426 // TODO(miletus) : Change the metadata to hold ScrollOffset.
1427 metadata.root_scroll_offset = gfx::ScrollOffsetToVector2dF(
1428 active_tree_->TotalScrollOffset());
[email protected]c1bb5af2013-03-13 19:06:271429
1430 return metadata;
[email protected]bf189f62012-12-18 03:42:111431}
1432
[email protected]6f50b8fa2013-07-01 19:51:491433static void LayerTreeHostImplDidBeginTracingCallback(LayerImpl* layer) {
1434 layer->DidBeginTracing();
1435}
[email protected]37349bc2013-06-04 01:31:521436
[email protected]2e316b272014-07-19 05:01:201437void LayerTreeHostImpl::DrawLayers(FrameData* frame,
1438 base::TimeTicks frame_begin_time) {
[email protected]c1e6cc062013-08-24 03:35:351439 TRACE_EVENT0("cc", "LayerTreeHostImpl::DrawLayers");
[email protected]c1bb5af2013-03-13 19:06:271440 DCHECK(CanDraw());
[email protected]e0341352013-04-06 05:01:201441
[email protected]3519b872013-07-30 07:17:501442 if (frame->has_no_damage) {
[email protected]87b180cc2014-02-06 21:19:191443 TRACE_EVENT_INSTANT0("cc", "EarlyOut_NoDamage", TRACE_EVENT_SCOPE_THREAD);
[email protected]6133cc232013-07-30 18:47:071444 DCHECK(!output_surface_->capabilities()
1445 .draw_and_swap_full_viewport_every_frame);
[email protected]e0341352013-04-06 05:01:201446 return;
[email protected]3519b872013-07-30 07:17:501447 }
[email protected]e0341352013-04-06 05:01:201448
[email protected]c1bb5af2013-03-13 19:06:271449 DCHECK(!frame->render_passes.empty());
[email protected]94f206c12012-08-25 00:09:141450
[email protected]2e316b272014-07-19 05:01:201451 fps_counter_->SaveTimeStamp(frame_begin_time,
[email protected]213fcfc2013-08-24 14:59:271452 !output_surface_->context_provider());
jbauman477b5002014-10-06 18:14:241453 rendering_stats_instrumentation_->IncrementFrameCount(1);
[email protected]372bad5f2013-03-21 16:38:431454
[email protected]c1bb5af2013-03-13 19:06:271455 if (tile_manager_) {
1456 memory_history_->SaveEntry(
1457 tile_manager_->memory_stats_from_last_assign());
1458 }
[email protected]1191d9d2013-02-02 06:00:331459
[email protected]846f455b2013-03-18 19:07:411460 if (debug_state_.ShowHudRects()) {
[email protected]d35992782013-03-14 14:54:021461 debug_rect_history_->SaveDebugRectsForCurrentFrame(
[email protected]c1bb5af2013-03-13 19:06:271462 active_tree_->root_layer(),
[email protected]f636ce82014-03-10 22:33:081463 active_tree_->hud_layer(),
[email protected]c1bb5af2013-03-13 19:06:271464 *frame->render_surface_layer_list,
1465 frame->occluding_screen_space_rects,
1466 frame->non_occluding_screen_space_rects,
1467 debug_state_);
1468 }
[email protected]94f206c12012-08-25 00:09:141469
[email protected]a848c102013-03-26 08:59:091470 if (!settings_.impl_side_painting && debug_state_.continuous_painting) {
1471 const RenderingStats& stats =
1472 rendering_stats_instrumentation_->GetRenderingStats();
hendrikw3f7c2342014-11-08 01:59:281473 paint_time_counter_->SavePaintTime(
1474 stats.begin_main_frame_to_commit_duration.GetLastTimeDelta());
[email protected]a848c102013-03-26 08:59:091475 }
1476
[email protected]37349bc2013-06-04 01:31:521477 bool is_new_trace;
1478 TRACE_EVENT_IS_NEW_TRACE(&is_new_trace);
1479 if (is_new_trace) {
[email protected]6f50b8fa2013-07-01 19:51:491480 if (pending_tree_) {
1481 LayerTreeHostCommon::CallFunctionForSubtree(
1482 pending_tree_->root_layer(),
1483 base::Bind(&LayerTreeHostImplDidBeginTracingCallback));
1484 }
1485 LayerTreeHostCommon::CallFunctionForSubtree(
1486 active_tree_->root_layer(),
1487 base::Bind(&LayerTreeHostImplDidBeginTracingCallback));
[email protected]37349bc2013-06-04 01:31:521488 }
1489
[email protected]5b8da122014-06-25 20:00:081490 {
1491 TRACE_EVENT0("cc", "DrawLayers.FrameViewerTracing");
1492 TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(
1493 TRACE_DISABLED_BY_DEFAULT("cc.debug") ","
1494 TRACE_DISABLED_BY_DEFAULT("cc.debug.quads") ","
1495 TRACE_DISABLED_BY_DEFAULT("devtools.timeline.layers"),
1496 "cc::LayerTreeHostImpl",
1497 id_,
[email protected]d12aa932014-08-01 13:10:381498 AsValueWithFrame(frame));
[email protected]5b8da122014-06-25 20:00:081499 }
[email protected]131a0c22013-02-12 18:31:081500
[email protected]c05dfbb2014-07-10 22:49:041501 const DrawMode draw_mode = GetDrawMode();
1502
[email protected]c1bb5af2013-03-13 19:06:271503 // Because the contents of the HUD depend on everything else in the frame, the
1504 // contents of its texture are updated as the last thing before the frame is
1505 // drawn.
[email protected]671f6672013-10-01 07:31:071506 if (active_tree_->hud_layer()) {
1507 TRACE_EVENT0("cc", "DrawLayers.UpdateHudTexture");
[email protected]c05dfbb2014-07-10 22:49:041508 active_tree_->hud_layer()->UpdateHudTexture(draw_mode,
1509 resource_provider_.get());
[email protected]671f6672013-10-01 07:31:071510 }
[email protected]94f206c12012-08-25 00:09:141511
[email protected]c05dfbb2014-07-10 22:49:041512 if (draw_mode == DRAW_MODE_RESOURCELESS_SOFTWARE) {
[email protected]251699b2013-10-09 00:21:261513 bool disable_picture_quad_image_filtering =
jdduke16dde6e2014-10-24 00:22:561514 IsActivelyScrolling() || needs_animate_layers();
[email protected]573e8e32013-09-09 17:24:321515
[email protected]b09c1942013-05-10 00:06:371516 scoped_ptr<SoftwareRenderer> temp_software_renderer =
jbaumanc5be44c2014-11-20 22:17:121517 SoftwareRenderer::Create(this, &settings_.renderer_settings,
1518 output_surface_.get(), NULL);
[email protected]59fee302013-12-10 17:53:301519 temp_software_renderer->DrawFrame(&frame->render_passes,
[email protected]59fee302013-12-10 17:53:301520 device_scale_factor_,
1521 DeviceViewport(),
1522 DeviceClip(),
[email protected]59fee302013-12-10 17:53:301523 disable_picture_quad_image_filtering);
[email protected]b09c1942013-05-10 00:06:371524 } else {
[email protected]b5174d712013-08-28 08:10:431525 renderer_->DrawFrame(&frame->render_passes,
[email protected]573e8e32013-09-09 17:24:321526 device_scale_factor_,
[email protected]59fee302013-12-10 17:53:301527 DeviceViewport(),
1528 DeviceClip(),
[email protected]251699b2013-10-09 00:21:261529 false);
[email protected]b09c1942013-05-10 00:06:371530 }
[email protected]c1bb5af2013-03-13 19:06:271531 // The render passes should be consumed by the renderer.
1532 DCHECK(frame->render_passes.empty());
1533 frame->render_passes_by_id.clear();
[email protected]94f206c12012-08-25 00:09:141534
[email protected]c1bb5af2013-03-13 19:06:271535 // The next frame should start by assuming nothing has changed, and changes
1536 // are noted as they occur.
[email protected]573e8e32013-09-09 17:24:321537 // TODO(boliu): If we did a temporary software renderer frame, propogate the
1538 // damage forward to the next frame.
[email protected]264dc0332013-03-17 21:00:541539 for (size_t i = 0; i < frame->render_surface_layer_list->size(); i++) {
[email protected]c1bb5af2013-03-13 19:06:271540 (*frame->render_surface_layer_list)[i]->render_surface()->damage_tracker()->
1541 DidDrawDamagedArea();
1542 }
1543 active_tree_->root_layer()->ResetAllChangeTrackingForSubtree();
[email protected]c1e6cc062013-08-24 03:35:351544
[email protected]759dc9f2014-07-23 19:18:511545 active_tree_->set_has_ever_been_drawn(true);
[email protected]d73094482014-02-13 21:28:281546 devtools_instrumentation::DidDrawFrame(id_);
[email protected]1bbed7a2014-07-08 02:54:001547 benchmark_instrumentation::IssueImplThreadRenderingStatsEvent(
[email protected]adbe30f2013-10-11 21:12:331548 rendering_stats_instrumentation_->impl_thread_rendering_stats());
[email protected]a9dc0d0f2013-08-17 02:43:181549 rendering_stats_instrumentation_->AccumulateAndClearImplThreadStats();
[email protected]94f206c12012-08-25 00:09:141550}
1551
[email protected]c1bb5af2013-03-13 19:06:271552void LayerTreeHostImpl::DidDrawAllLayers(const FrameData& frame) {
1553 for (size_t i = 0; i < frame.will_draw_layers.size(); ++i)
1554 frame.will_draw_layers[i]->DidDraw(resource_provider_.get());
[email protected]b914e102012-10-02 08:11:521555
[email protected]c1bb5af2013-03-13 19:06:271556 // Once all layers have been drawn, pending texture uploads should no
1557 // longer block future uploads.
[email protected]d15d9622013-06-21 02:49:151558 resource_provider_->MarkPendingUploadsAsNonBlocking();
[email protected]94f206c12012-08-25 00:09:141559}
1560
[email protected]c1bb5af2013-03-13 19:06:271561void LayerTreeHostImpl::FinishAllRendering() {
1562 if (renderer_)
1563 renderer_->Finish();
[email protected]94f206c12012-08-25 00:09:141564}
1565
[email protected]13525d62014-05-20 21:22:041566void LayerTreeHostImpl::SetUseGpuRasterization(bool use_gpu) {
1567 if (use_gpu == use_gpu_rasterization_)
1568 return;
1569
1570 use_gpu_rasterization_ = use_gpu;
1571 ReleaseTreeResources();
1572
[email protected]ced667b2014-05-22 21:49:531573 // Replace existing tile manager with another one that uses appropriate
1574 // rasterizer.
1575 if (tile_manager_) {
1576 DestroyTileManager();
1577 CreateAndSetTileManager();
1578 }
1579
[email protected]13525d62014-05-20 21:22:041580 // We have released tilings for both active and pending tree.
1581 // We would not have any content to draw until the pending tree is activated.
1582 // Prevent the active tree from drawing until activation.
vmpstr61ed94a12014-10-09 04:49:301583 SetRequiresHighResToDraw();
[email protected]13525d62014-05-20 21:22:041584}
1585
[email protected]7a8bcd262014-01-15 12:54:581586const RendererCapabilitiesImpl&
1587LayerTreeHostImpl::GetRendererCapabilities() const {
[email protected]c1bb5af2013-03-13 19:06:271588 return renderer_->Capabilities();
[email protected]94f206c12012-08-25 00:09:141589}
1590
[email protected]e0341352013-04-06 05:01:201591bool LayerTreeHostImpl::SwapBuffers(const LayerTreeHostImpl::FrameData& frame) {
vmpstr61ed94a12014-10-09 04:49:301592 ResetRequiresHighResToDraw();
[email protected]b69c1db2013-11-27 00:05:191593 if (frame.has_no_damage) {
1594 active_tree()->BreakSwapPromises(SwapPromise::SWAP_FAILS);
[email protected]e0341352013-04-06 05:01:201595 return false;
[email protected]b69c1db2013-11-27 00:05:191596 }
[email protected]4a28a612013-11-27 02:06:331597 CompositorFrameMetadata metadata = MakeCompositorFrameMetadata();
[email protected]d359203a2013-11-29 06:16:551598 active_tree()->FinishSwapPromises(&metadata);
[email protected]15ba6dea2014-04-02 01:44:131599 for (size_t i = 0; i < metadata.latency_info.size(); i++) {
1600 TRACE_EVENT_FLOW_STEP0(
1601 "input",
1602 "LatencyInfo.Flow",
1603 TRACE_ID_DONT_MANGLE(metadata.latency_info[i].trace_id),
1604 "SwapBuffers");
1605 }
[email protected]4a28a612013-11-27 02:06:331606 renderer_->SwapBuffers(metadata);
[email protected]c5c506382013-04-30 04:42:161607 return true;
[email protected]94f206c12012-08-25 00:09:141608}
1609
[email protected]97e9ccd62014-04-12 01:07:151610void LayerTreeHostImpl::WillBeginImplFrame(const BeginFrameArgs& args) {
1611 // Sample the frame time now. This time will be used for updating animations
1612 // when we draw.
[email protected]04c5900d2014-08-18 13:38:361613 UpdateCurrentBeginFrameArgs(args);
[email protected]c92195e2014-05-07 18:18:491614 // Cache the begin impl frame interval
1615 begin_impl_frame_interval_ = args.interval;
danakja819c2552014-11-14 02:05:041616
1617 if (required_for_draw_tile_is_top_of_raster_queue_) {
1618 // Optimistically schedule a draw, as a tile required for draw is at the top
1619 // of the current raster queue. This will let us expect the tile to complete
1620 // and draw it within the impl frame we are beginning now.
1621 SetNeedsRedraw();
1622 }
[email protected]7ed47512013-03-26 22:28:451623}
1624
bokanef971462014-10-13 22:58:321625void LayerTreeHostImpl::UpdateViewportContainerSizes() {
1626 LayerImpl* inner_container = active_tree_->InnerViewportContainerLayer();
1627 LayerImpl* outer_container = active_tree_->OuterViewportContainerLayer();
1628
1629 if (!inner_container || !top_controls_manager_)
[email protected]fef74fd2014-02-27 06:28:171630 return;
1631
bokanef971462014-10-13 22:58:321632 ViewportAnchor anchor(InnerViewportScrollLayer(),
1633 OuterViewportScrollLayer());
1634
1635 // Adjust the inner viewport by shrinking/expanding the container to account
1636 // for the change in top controls height since the last Resize from Blink.
1637 inner_container->SetBoundsDelta(
1638 gfx::Vector2dF(0, active_tree_->top_controls_layout_height() -
1639 active_tree_->total_top_controls_content_offset()));
1640
1641 if (!outer_container || outer_container->BoundsForScrolling().IsEmpty())
1642 return;
1643
1644 // Adjust the outer viewport container as well, since adjusting only the
1645 // inner may cause its bounds to exceed those of the outer, causing scroll
1646 // clamping. We adjust it so it maintains the same aspect ratio as the
1647 // inner viewport.
1648 float aspect_ratio = inner_container->BoundsForScrolling().width() /
1649 inner_container->BoundsForScrolling().height();
1650 float target_height = outer_container->BoundsForScrolling().width() /
1651 aspect_ratio;
1652 float current_outer_height = outer_container->BoundsForScrolling().height() -
1653 outer_container->bounds_delta().y();
1654 gfx::Vector2dF delta(0, target_height - current_outer_height);
1655
1656 outer_container->SetBoundsDelta(delta);
1657 active_tree_->InnerViewportScrollLayer()->SetBoundsDelta(delta);
1658
1659 anchor.ResetViewportToAnchoredPosition();
bokan88eae012014-09-09 20:40:421660}
1661
1662void LayerTreeHostImpl::SetTopControlsLayoutHeight(float height) {
1663 if (active_tree_->top_controls_layout_height() == height)
1664 return;
1665
1666 active_tree_->set_top_controls_layout_height(height);
bokanef971462014-10-13 22:58:321667 UpdateViewportContainerSizes();
bokan88eae012014-09-09 20:40:421668 SetFullRootLayerDamage();
[email protected]ffb2720f2013-03-15 19:18:371669}
1670
enne69277cb2014-10-29 23:03:401671void LayerTreeHostImpl::SynchronouslyInitializeAllTiles() {
1672 // Only valid for the single-threaded non-scheduled/synchronous case
1673 // using the zero copy raster worker pool.
1674 single_thread_synchronous_task_graph_runner_->RunUntilIdle();
1675}
1676
[email protected]c1bb5af2013-03-13 19:06:271677void LayerTreeHostImpl::DidLoseOutputSurface() {
[email protected]13044fe72013-12-02 20:52:191678 if (resource_provider_)
1679 resource_provider_->DidLoseOutputSurface();
dnetob71e30c2014-08-25 23:27:201680 client_->DidLoseOutputSurfaceOnImplThread();
[email protected]94f206c12012-08-25 00:09:141681}
1682
[email protected]59adb112013-04-09 04:48:441683bool LayerTreeHostImpl::HaveRootScrollLayer() const {
[email protected]adeda572014-01-31 00:49:471684 return !!InnerViewportScrollLayer();
[email protected]69b50ec2013-01-19 04:58:011685}
1686
[email protected]c1bb5af2013-03-13 19:06:271687LayerImpl* LayerTreeHostImpl::RootLayer() const {
1688 return active_tree_->root_layer();
[email protected]8bef40572012-12-11 21:38:081689}
1690
[email protected]adeda572014-01-31 00:49:471691LayerImpl* LayerTreeHostImpl::InnerViewportScrollLayer() const {
1692 return active_tree_->InnerViewportScrollLayer();
1693}
1694
1695LayerImpl* LayerTreeHostImpl::OuterViewportScrollLayer() const {
1696 return active_tree_->OuterViewportScrollLayer();
[email protected]8bef40572012-12-11 21:38:081697}
1698
[email protected]c1bb5af2013-03-13 19:06:271699LayerImpl* LayerTreeHostImpl::CurrentlyScrollingLayer() const {
1700 return active_tree_->CurrentlyScrollingLayer();
[email protected]8bef40572012-12-11 21:38:081701}
1702
jdduke16dde6e2014-10-24 00:22:561703bool LayerTreeHostImpl::IsActivelyScrolling() const {
1704 return (did_lock_scrolling_layer_ && CurrentlyScrollingLayer()) ||
[email protected]adeda572014-01-31 00:49:471705 (InnerViewportScrollLayer() &&
1706 InnerViewportScrollLayer()->IsExternalFlingActive()) ||
1707 (OuterViewportScrollLayer() &&
1708 OuterViewportScrollLayer()->IsExternalFlingActive());
[email protected]251699b2013-10-09 00:21:261709}
1710
[email protected]94f206c12012-08-25 00:09:141711// Content layers can be either directly scrollable or contained in an outer
1712// scrolling layer which applies the scroll transform. Given a content layer,
1713// this function returns the associated scroll layer if any.
[email protected]c1bb5af2013-03-13 19:06:271714static LayerImpl* FindScrollLayerForContentLayer(LayerImpl* layer_impl) {
1715 if (!layer_impl)
[email protected]bf1cfd9a2013-09-26 05:43:021716 return NULL;
[email protected]c1bb5af2013-03-13 19:06:271717
1718 if (layer_impl->scrollable())
1719 return layer_impl;
1720
1721 if (layer_impl->DrawsContent() &&
1722 layer_impl->parent() &&
1723 layer_impl->parent()->scrollable())
1724 return layer_impl->parent();
1725
[email protected]bf1cfd9a2013-09-26 05:43:021726 return NULL;
[email protected]94f206c12012-08-25 00:09:141727}
1728
[email protected]c1bb5af2013-03-13 19:06:271729void LayerTreeHostImpl::CreatePendingTree() {
1730 CHECK(!pending_tree_);
1731 if (recycle_tree_)
1732 recycle_tree_.swap(pending_tree_);
1733 else
1734 pending_tree_ = LayerTreeImpl::create(this);
[email protected]12a63da2014-06-13 06:06:221735
1736 // Update the delta from the active tree, which may have
1737 // adjusted its delta prior to the pending tree being created.
1738 DCHECK_EQ(1.f, pending_tree_->sent_page_scale_delta());
bokan88eae012014-09-09 20:40:421739 DCHECK_EQ(0.f, pending_tree_->sent_top_controls_delta());
[email protected]12a63da2014-06-13 06:06:221740 pending_tree_->SetPageScaleDelta(active_tree_->page_scale_delta() /
1741 active_tree_->sent_page_scale_delta());
bokan88eae012014-09-09 20:40:421742 pending_tree_->set_top_controls_delta(
1743 active_tree_->top_controls_delta() -
1744 active_tree_->sent_top_controls_delta());
[email protected]12a63da2014-06-13 06:06:221745
[email protected]c1bb5af2013-03-13 19:06:271746 client_->OnCanDrawStateChanged(CanDraw());
[email protected]186468f2013-10-24 02:44:111747 TRACE_EVENT_ASYNC_BEGIN0("cc", "PendingTree:waiting", pending_tree_.get());
[email protected]2e7ca422012-12-20 02:57:271748}
1749
[email protected]fc20d142014-07-01 00:49:151750void LayerTreeHostImpl::ActivateSyncTree() {
[email protected]fc20d142014-07-01 00:49:151751 if (pending_tree_) {
1752 TRACE_EVENT_ASYNC_END0("cc", "PendingTree:waiting", pending_tree_.get());
1753
1754 active_tree_->SetRootLayerScrollOffsetDelegate(NULL);
1755 active_tree_->PushPersistedState(pending_tree_.get());
1756 // Process any requests in the UI resource queue. The request queue is
1757 // given in LayerTreeHost::FinishCommitOnImplThread. This must take place
1758 // before the swap.
1759 pending_tree_->ProcessUIResourceRequestQueue();
1760
1761 if (pending_tree_->needs_full_tree_sync()) {
1762 active_tree_->SetRootLayer(
1763 TreeSynchronizer::SynchronizeTrees(pending_tree_->root_layer(),
1764 active_tree_->DetachLayerTree(),
1765 active_tree_.get()));
1766 }
1767 TreeSynchronizer::PushProperties(pending_tree_->root_layer(),
1768 active_tree_->root_layer());
1769 pending_tree_->PushPropertiesTo(active_tree_.get());
1770
1771 // Now that we've synced everything from the pending tree to the active
1772 // tree, rename the pending tree the recycle tree so we can reuse it on the
1773 // next sync.
1774 DCHECK(!recycle_tree_);
1775 pending_tree_.swap(recycle_tree_);
1776
1777 active_tree_->SetRootLayerScrollOffsetDelegate(
1778 root_layer_scroll_offset_delegate_);
bokan88eae012014-09-09 20:40:421779
1780 if (top_controls_manager_) {
1781 top_controls_manager_->SetControlsTopOffset(
bokan55b2f152014-09-15 14:47:591782 active_tree_->total_top_controls_content_offset() -
1783 top_controls_manager_->top_controls_height());
bokan88eae012014-09-09 20:40:421784 }
1785
bokanef971462014-10-13 22:58:321786 UpdateViewportContainerSizes();
[email protected]fc20d142014-07-01 00:49:151787 } else {
1788 active_tree_->ProcessUIResourceRequestQueue();
[email protected]c1bb5af2013-03-13 19:06:271789 }
[email protected]48871fc2013-01-23 07:36:511790
[email protected]7d1b07e2013-10-01 17:31:301791 active_tree_->DidBecomeActive();
[email protected]b33348f2014-04-30 18:17:341792 ActivateAnimations();
[email protected]fc20d142014-07-01 00:49:151793 if (settings_.impl_side_painting)
1794 client_->RenewTreePriority();
[email protected]37386f052013-01-13 00:42:221795
[email protected]c1bb5af2013-03-13 19:06:271796 client_->OnCanDrawStateChanged(CanDraw());
[email protected]fc20d142014-07-01 00:49:151797 client_->DidActivateSyncTree();
1798 if (!tree_activation_callback_.is_null())
1799 tree_activation_callback_.Run();
[email protected]652cf132013-02-15 21:53:241800
[email protected]a848c102013-03-26 08:59:091801 if (debug_state_.continuous_painting) {
1802 const RenderingStats& stats =
[email protected]372bad5f2013-03-21 16:38:431803 rendering_stats_instrumentation_->GetRenderingStats();
hendrikwf17752712014-11-04 18:55:471804 // TODO(hendrikw): This requires a different metric when we commit directly
1805 // to the active tree. See crbug.com/429311.
1806 paint_time_counter_->SavePaintTime(
hendrikw3f7c2342014-11-08 01:59:281807 stats.commit_to_activate_duration.GetLastTimeDelta() +
1808 stats.draw_duration.GetLastTimeDelta());
[email protected]c1bb5af2013-03-13 19:06:271809 }
[email protected]2a61ad52013-05-13 14:01:291810
aelias74c39352014-10-14 03:48:141811 scoped_ptr<PageScaleAnimation> page_scale_animation =
1812 active_tree_->TakePageScaleAnimation();
1813 if (page_scale_animation) {
1814 page_scale_animation_ = page_scale_animation.Pass();
bokan915bf352014-10-02 21:57:141815 SetNeedsAnimate();
1816 client_->SetNeedsCommitOnImplThread();
1817 client_->RenewTreePriority();
1818 }
[email protected]2e7ca422012-12-20 02:57:271819}
1820
[email protected]c1bb5af2013-03-13 19:06:271821void LayerTreeHostImpl::SetVisible(bool visible) {
1822 DCHECK(proxy_->IsImplThread());
[email protected]94f206c12012-08-25 00:09:141823
[email protected]c1bb5af2013-03-13 19:06:271824 if (visible_ == visible)
1825 return;
1826 visible_ = visible;
1827 DidVisibilityChange(this, visible_);
[email protected]206a3922013-05-17 06:34:121828 EnforceManagedMemoryPolicy(ActualManagedMemoryPolicy());
[email protected]94f206c12012-08-25 00:09:141829
[email protected]10608052014-05-13 21:30:031830 // If we just became visible, we have to ensure that we draw high res tiles,
1831 // to prevent checkerboard/low res flashes.
1832 if (visible_)
vmpstr61ed94a12014-10-09 04:49:301833 SetRequiresHighResToDraw();
[email protected]10608052014-05-13 21:30:031834 else
[email protected]127bdc1a2013-09-11 01:44:481835 EvictAllUIResources();
1836
[email protected]0fa42e02013-08-20 01:16:051837 // Evict tiles immediately if invisible since this tab may never get another
1838 // draw or timer tick.
1839 if (!visible_)
1840 ManageTiles();
1841
[email protected]c1bb5af2013-03-13 19:06:271842 if (!renderer_)
1843 return;
[email protected]94f206c12012-08-25 00:09:141844
[email protected]c1bb5af2013-03-13 19:06:271845 renderer_->SetVisible(visible);
[email protected]94f206c12012-08-25 00:09:141846}
1847
[email protected]43b8f982014-04-30 21:24:331848void LayerTreeHostImpl::SetNeedsAnimate() {
1849 NotifySwapPromiseMonitorsOfSetNeedsRedraw();
1850 client_->SetNeedsAnimateOnImplThread();
1851}
1852
[email protected]6be422b2013-12-08 06:47:311853void LayerTreeHostImpl::SetNeedsRedraw() {
1854 NotifySwapPromiseMonitorsOfSetNeedsRedraw();
1855 client_->SetNeedsRedrawOnImplThread();
1856}
1857
[email protected]206a3922013-05-17 06:34:121858ManagedMemoryPolicy LayerTreeHostImpl::ActualManagedMemoryPolicy() const {
[email protected]3f2ff112013-08-03 02:41:071859 ManagedMemoryPolicy actual = cached_managed_memory_policy_;
[email protected]c92195e2014-05-07 18:18:491860 if (debug_state_.rasterize_only_visible_content) {
[email protected]3f2ff112013-08-03 02:41:071861 actual.priority_cutoff_when_visible =
[email protected]f44d5552013-10-29 04:56:291862 gpu::MemoryAllocation::CUTOFF_ALLOW_REQUIRED_ONLY;
[email protected]13525d62014-05-20 21:22:041863 } else if (use_gpu_rasterization()) {
[email protected]c92195e2014-05-07 18:18:491864 actual.priority_cutoff_when_visible =
1865 gpu::MemoryAllocation::CUTOFF_ALLOW_NICE_TO_HAVE;
[email protected]3f2ff112013-08-03 02:41:071866 }
[email protected]206a3922013-05-17 06:34:121867
[email protected]3f2ff112013-08-03 02:41:071868 if (zero_budget_) {
1869 actual.bytes_limit_when_visible = 0;
[email protected]3f2ff112013-08-03 02:41:071870 }
1871
[email protected]206a3922013-05-17 06:34:121872 return actual;
1873}
1874
[email protected]3f2ff112013-08-03 02:41:071875size_t LayerTreeHostImpl::memory_allocation_limit_bytes() const {
1876 return ActualManagedMemoryPolicy().bytes_limit_when_visible;
1877}
1878
[email protected]990e050a2013-09-23 18:50:211879int LayerTreeHostImpl::memory_allocation_priority_cutoff() const {
1880 return ManagedMemoryPolicy::PriorityCutoffToValue(
1881 ActualManagedMemoryPolicy().priority_cutoff_when_visible);
1882}
1883
[email protected]50644642013-06-20 13:58:551884void LayerTreeHostImpl::ReleaseTreeResources() {
[email protected]aeef2f02014-05-10 12:15:481885 active_tree_->ReleaseResources();
1886 if (pending_tree_)
1887 pending_tree_->ReleaseResources();
1888 if (recycle_tree_)
1889 recycle_tree_->ReleaseResources();
[email protected]c9280762013-08-01 06:28:571890
[email protected]127bdc1a2013-09-11 01:44:481891 EvictAllUIResources();
[email protected]50644642013-06-20 13:58:551892}
1893
[email protected]ced667b2014-05-22 21:49:531894void LayerTreeHostImpl::CreateAndSetRenderer() {
[email protected]50644642013-06-20 13:58:551895 DCHECK(!renderer_);
[email protected]ced667b2014-05-22 21:49:531896 DCHECK(output_surface_);
1897 DCHECK(resource_provider_);
1898
1899 if (output_surface_->capabilities().delegated_rendering) {
jbaumanc5be44c2014-11-20 22:17:121900 renderer_ = DelegatingRenderer::Create(this, &settings_.renderer_settings,
1901 output_surface_.get(),
1902 resource_provider_.get());
[email protected]ced667b2014-05-22 21:49:531903 } else if (output_surface_->context_provider()) {
jbaumanc5be44c2014-11-20 22:17:121904 renderer_ = GLRenderer::Create(
1905 this, &settings_.renderer_settings, output_surface_.get(),
1906 resource_provider_.get(), texture_mailbox_deleter_.get(),
1907 settings_.renderer_settings.highp_threshold_min);
[email protected]ced667b2014-05-22 21:49:531908 } else if (output_surface_->software_device()) {
jbaumanc5be44c2014-11-20 22:17:121909 renderer_ = SoftwareRenderer::Create(this, &settings_.renderer_settings,
1910 output_surface_.get(),
1911 resource_provider_.get());
[email protected]50644642013-06-20 13:58:551912 }
[email protected]0cfda302014-04-23 19:02:371913 DCHECK(renderer_);
[email protected]50644642013-06-20 13:58:551914
[email protected]0cfda302014-04-23 19:02:371915 renderer_->SetVisible(visible_);
1916 SetFullRootLayerDamage();
[email protected]b0a99ad22013-09-12 17:25:561917
[email protected]0cfda302014-04-23 19:02:371918 // See note in LayerTreeImpl::UpdateDrawProperties. Renderer needs to be
1919 // initialized to get max texture size. Also, after releasing resources,
1920 // trees need another update to generate new ones.
1921 active_tree_->set_needs_update_draw_properties();
1922 if (pending_tree_)
1923 pending_tree_->set_needs_update_draw_properties();
1924 client_->UpdateRendererCapabilitiesOnImplThread();
[email protected]50644642013-06-20 13:58:551925}
1926
[email protected]ced667b2014-05-22 21:49:531927void LayerTreeHostImpl::CreateAndSetTileManager() {
1928 DCHECK(!tile_manager_);
[email protected]50af3c22013-07-13 03:50:201929 DCHECK(settings_.impl_side_painting);
[email protected]ced667b2014-05-22 21:49:531930 DCHECK(output_surface_);
1931 DCHECK(resource_provider_);
enne03dbe8ae2014-10-30 01:32:551932
1933 CreateResourceAndRasterWorkerPool(
1934 &raster_worker_pool_, &resource_pool_, &staging_resource_pool_);
1935 DCHECK(raster_worker_pool_);
1936 DCHECK(resource_pool_);
1937
enne98f3a6c2014-10-09 20:09:441938 base::SingleThreadTaskRunner* task_runner =
1939 proxy_->HasImplThread() ? proxy_->ImplThreadTaskRunner()
1940 : proxy_->MainThreadTaskRunner();
1941 DCHECK(task_runner);
enne03dbe8ae2014-10-30 01:32:551942 size_t scheduled_raster_task_limit =
1943 IsSynchronousSingleThreaded() ? std::numeric_limits<size_t>::max()
1944 : settings_.scheduled_raster_task_limit;
enne98f3a6c2014-10-09 20:09:441945 tile_manager_ = TileManager::Create(this,
1946 task_runner,
1947 resource_pool_.get(),
1948 raster_worker_pool_->AsRasterizer(),
enne06a2caf2014-10-23 20:34:261949 rendering_stats_instrumentation_,
enne69277cb2014-10-29 23:03:401950 scheduled_raster_task_limit);
[email protected]b6eb8e332013-09-10 00:51:011951
[email protected]50af3c22013-07-13 03:50:201952 UpdateTileManagerMemoryPolicy(ActualManagedMemoryPolicy());
[email protected]50af3c22013-07-13 03:50:201953}
1954
enne03dbe8ae2014-10-30 01:32:551955void LayerTreeHostImpl::CreateResourceAndRasterWorkerPool(
1956 scoped_ptr<RasterWorkerPool>* raster_worker_pool,
1957 scoped_ptr<ResourcePool>* resource_pool,
1958 scoped_ptr<ResourcePool>* staging_resource_pool) {
1959 base::SingleThreadTaskRunner* task_runner =
1960 proxy_->HasImplThread() ? proxy_->ImplThreadTaskRunner()
1961 : proxy_->MainThreadTaskRunner();
1962 DCHECK(task_runner);
1963
1964 ContextProvider* context_provider = output_surface_->context_provider();
1965 bool should_use_zero_copy_rasterizer =
1966 settings_.use_zero_copy || IsSynchronousSingleThreaded();
1967
1968 if (!context_provider) {
1969 *resource_pool =
1970 ResourcePool::Create(resource_provider_.get(),
1971 GL_TEXTURE_2D,
1972 resource_provider_->best_texture_format());
1973
1974 *raster_worker_pool =
1975 BitmapRasterWorkerPool::Create(task_runner,
1976 RasterWorkerPool::GetTaskGraphRunner(),
1977 resource_provider_.get());
1978 } else if (use_gpu_rasterization_) {
1979 *resource_pool =
1980 ResourcePool::Create(resource_provider_.get(),
1981 GL_TEXTURE_2D,
1982 resource_provider_->best_texture_format());
1983
1984 *raster_worker_pool =
1985 GpuRasterWorkerPool::Create(task_runner,
1986 context_provider,
1987 resource_provider_.get(),
1988 settings_.use_distance_field_text);
1989 } else if (should_use_zero_copy_rasterizer && CanUseZeroCopyRasterizer()) {
1990 *resource_pool = ResourcePool::Create(
1991 resource_provider_.get(),
1992 GetMapImageTextureTarget(context_provider->ContextCapabilities()),
1993 resource_provider_->best_texture_format());
1994
1995 TaskGraphRunner* task_graph_runner;
1996 if (IsSynchronousSingleThreaded()) {
1997 DCHECK(!single_thread_synchronous_task_graph_runner_);
1998 single_thread_synchronous_task_graph_runner_.reset(new TaskGraphRunner);
1999 task_graph_runner = single_thread_synchronous_task_graph_runner_.get();
2000 } else {
2001 task_graph_runner = RasterWorkerPool::GetTaskGraphRunner();
2002 }
2003
2004 *raster_worker_pool = ZeroCopyRasterWorkerPool::Create(
2005 task_runner, task_graph_runner, resource_provider_.get());
2006 } else if (settings_.use_one_copy && CanUseOneCopyRasterizer()) {
2007 // We need to create a staging resource pool when using copy rasterizer.
2008 *staging_resource_pool = ResourcePool::Create(
2009 resource_provider_.get(),
2010 GetMapImageTextureTarget(context_provider->ContextCapabilities()),
2011 resource_provider_->best_texture_format());
2012 *resource_pool =
2013 ResourcePool::Create(resource_provider_.get(),
2014 GL_TEXTURE_2D,
2015 resource_provider_->best_texture_format());
2016
2017 *raster_worker_pool =
2018 OneCopyRasterWorkerPool::Create(task_runner,
2019 RasterWorkerPool::GetTaskGraphRunner(),
2020 context_provider,
2021 resource_provider_.get(),
2022 staging_resource_pool_.get());
2023 } else {
2024 *resource_pool = ResourcePool::Create(
2025 resource_provider_.get(),
2026 GL_TEXTURE_2D,
2027 resource_provider_->memory_efficient_texture_format());
2028
2029 *raster_worker_pool = PixelBufferRasterWorkerPool::Create(
jbaumanc5be44c2014-11-20 22:17:122030 task_runner, RasterWorkerPool::GetTaskGraphRunner(), context_provider,
enne03dbe8ae2014-10-30 01:32:552031 resource_provider_.get(),
jbaumanc5be44c2014-11-20 22:17:122032 GetMaxTransferBufferUsageBytes(
2033 context_provider->ContextCapabilities(),
2034 settings_.renderer_settings.refresh_rate));
enne03dbe8ae2014-10-30 01:32:552035 }
2036}
2037
[email protected]ced667b2014-05-22 21:49:532038void LayerTreeHostImpl::DestroyTileManager() {
danakjf446a072014-09-27 21:55:482039 tile_manager_ = nullptr;
2040 resource_pool_ = nullptr;
2041 staging_resource_pool_ = nullptr;
2042 raster_worker_pool_ = nullptr;
enne69277cb2014-10-29 23:03:402043 single_thread_synchronous_task_graph_runner_ = nullptr;
[email protected]ced667b2014-05-22 21:49:532044}
2045
[email protected]fc20d142014-07-01 00:49:152046bool LayerTreeHostImpl::UsePendingTreeForSync() const {
2047 // In impl-side painting, synchronize to the pending tree so that it has
2048 // time to raster before being displayed.
2049 return settings_.impl_side_painting;
2050}
2051
enne03dbe8ae2014-10-30 01:32:552052bool LayerTreeHostImpl::IsSynchronousSingleThreaded() const {
2053 return !proxy_->HasImplThread() && !settings_.single_thread_proxy_scheduler;
2054}
2055
enne69277cb2014-10-29 23:03:402056bool LayerTreeHostImpl::CanUseZeroCopyRasterizer() const {
2057 return GetRendererCapabilities().using_image;
[email protected]ced667b2014-05-22 21:49:532058}
2059
enne03dbe8ae2014-10-30 01:32:552060bool LayerTreeHostImpl::CanUseOneCopyRasterizer() const {
enne25d25532014-11-20 18:40:072061 return GetRendererCapabilities().using_image;
[email protected]ced667b2014-05-22 21:49:532062}
2063
[email protected]50644642013-06-20 13:58:552064void LayerTreeHostImpl::EnforceZeroBudget(bool zero_budget) {
[email protected]3f2ff112013-08-03 02:41:072065 SetManagedMemoryPolicy(cached_managed_memory_policy_, zero_budget);
[email protected]50644642013-06-20 13:58:552066}
2067
[email protected]c1bb5af2013-03-13 19:06:272068bool LayerTreeHostImpl::InitializeRenderer(
2069 scoped_ptr<OutputSurface> output_surface) {
[email protected]06630f832014-05-29 23:15:142070 TRACE_EVENT0("cc", "LayerTreeHostImpl::InitializeRenderer");
[email protected]ce2e8112013-11-28 07:44:362071
[email protected]c1bb5af2013-03-13 19:06:272072 // Since we will create a new resource provider, we cannot continue to use
2073 // the old resources (i.e. render_surfaces and texture IDs). Clear them
2074 // before we destroy the old resource provider.
[email protected]50644642013-06-20 13:58:552075 ReleaseTreeResources();
[email protected]45c4b1e2013-01-16 02:19:402076
[email protected]c1bb5af2013-03-13 19:06:272077 // Note: order is important here.
danakjf446a072014-09-27 21:55:482078 renderer_ = nullptr;
[email protected]ced667b2014-05-22 21:49:532079 DestroyTileManager();
danakjf446a072014-09-27 21:55:482080 resource_provider_ = nullptr;
2081 output_surface_ = nullptr;
[email protected]94f206c12012-08-25 00:09:142082
[email protected]c1bb5af2013-03-13 19:06:272083 if (!output_surface->BindToClient(this))
2084 return false;
[email protected]be3181652012-09-25 13:02:132085
[email protected]ced667b2014-05-22 21:49:532086 output_surface_ = output_surface.Pass();
jbaumanc5be44c2014-11-20 22:17:122087 resource_provider_ = ResourceProvider::Create(
2088 output_surface_.get(), shared_bitmap_manager_, gpu_memory_buffer_manager_,
2089 proxy_->blocking_main_thread_task_runner(),
2090 settings_.renderer_settings.highp_threshold_min,
2091 settings_.renderer_settings.use_rgba_4444_textures,
2092 settings_.renderer_settings.texture_id_allocation_chunk_size);
[email protected]2b154b22013-06-07 09:03:272093
[email protected]ced667b2014-05-22 21:49:532094 if (output_surface_->capabilities().deferred_gl_initialization)
[email protected]50644642013-06-20 13:58:552095 EnforceZeroBudget(true);
[email protected]be3181652012-09-25 13:02:132096
[email protected]ced667b2014-05-22 21:49:532097 CreateAndSetRenderer();
[email protected]be3181652012-09-25 13:02:132098
[email protected]ced667b2014-05-22 21:49:532099 if (settings_.impl_side_painting)
2100 CreateAndSetTileManager();
[email protected]fbe89f72013-05-21 07:24:242101
[email protected]3dc0c772014-04-26 10:06:052102 // Initialize vsync parameters to sane values.
2103 const base::TimeDelta display_refresh_interval =
jbaumanc5be44c2014-11-20 22:17:122104 base::TimeDelta::FromMicroseconds(
2105 base::Time::kMicrosecondsPerSecond /
2106 settings_.renderer_settings.refresh_rate);
[email protected]3dc0c772014-04-26 10:06:052107 CommitVSyncParameters(base::TimeTicks(), display_refresh_interval);
[email protected]049fc7a2013-06-18 12:32:352108
[email protected]3dc0c772014-04-26 10:06:052109 // TODO(brianderson): Don't use a hard-coded parent draw time.
2110 base::TimeDelta parent_draw_time =
simonhong2880b8e2014-11-11 23:25:362111 (!settings_.use_external_begin_frame_source &&
[email protected]4851dd22014-06-17 16:06:292112 output_surface_->capabilities().adjust_deadline_for_parent)
[email protected]1d142de82014-06-11 12:48:232113 ? BeginFrameArgs::DefaultEstimatedParentDrawTime()
[email protected]3dc0c772014-04-26 10:06:052114 : base::TimeDelta();
2115 client_->SetEstimatedParentDrawTime(parent_draw_time);
[email protected]049fc7a2013-06-18 12:32:352116
[email protected]ced667b2014-05-22 21:49:532117 int max_frames_pending = output_surface_->capabilities().max_frames_pending;
[email protected]049fc7a2013-06-18 12:32:352118 if (max_frames_pending <= 0)
[email protected]df3c24c92013-06-19 03:54:352119 max_frames_pending = OutputSurface::DEFAULT_MAX_FRAMES_PENDING;
[email protected]c14902662014-04-18 05:06:112120 client_->SetMaxSwapsPendingOnImplThread(max_frames_pending);
[email protected]c1bb5af2013-03-13 19:06:272121 client_->OnCanDrawStateChanged(CanDraw());
[email protected]8db2213c2012-09-05 22:08:212122
sohan.jyoti9d1e4202014-09-23 21:02:332123 // There will not be anything to draw here, so set high res
2124 // to avoid checkerboards, typically when we are recovering
2125 // from lost context.
vmpstr61ed94a12014-10-09 04:49:302126 SetRequiresHighResToDraw();
sohan.jyoti9d1e4202014-09-23 21:02:332127
[email protected]c1bb5af2013-03-13 19:06:272128 return true;
[email protected]94f206c12012-08-25 00:09:142129}
2130
[email protected]3dc0c772014-04-26 10:06:052131void LayerTreeHostImpl::CommitVSyncParameters(base::TimeTicks timebase,
2132 base::TimeDelta interval) {
2133 client_->CommitVSyncParameters(timebase, interval);
2134}
2135
[email protected]3b2eb882014-04-24 19:48:562136void LayerTreeHostImpl::DeferredInitialize() {
[email protected]2b154b22013-06-07 09:03:272137 DCHECK(output_surface_->capabilities().deferred_gl_initialization);
[email protected]50644642013-06-20 13:58:552138 DCHECK(settings_.impl_side_painting);
[email protected]0634cdd42013-08-16 00:46:092139 DCHECK(output_surface_->context_provider());
[email protected]2b154b22013-06-07 09:03:272140
[email protected]50644642013-06-20 13:58:552141 ReleaseTreeResources();
danakjf446a072014-09-27 21:55:482142 renderer_ = nullptr;
[email protected]105a723202014-06-12 14:18:272143 DestroyTileManager();
[email protected]2b154b22013-06-07 09:03:272144
[email protected]0cfda302014-04-23 19:02:372145 resource_provider_->InitializeGL();
[email protected]d9ca99e2013-08-28 21:49:482146
[email protected]ced667b2014-05-22 21:49:532147 CreateAndSetRenderer();
[email protected]3b2eb882014-04-24 19:48:562148 EnforceZeroBudget(false);
[email protected]105a723202014-06-12 14:18:272149 CreateAndSetTileManager();
2150
[email protected]3b2eb882014-04-24 19:48:562151 client_->SetNeedsCommitOnImplThread();
[email protected]2b154b22013-06-07 09:03:272152}
2153
[email protected]50af3c22013-07-13 03:50:202154void LayerTreeHostImpl::ReleaseGL() {
2155 DCHECK(output_surface_->capabilities().deferred_gl_initialization);
2156 DCHECK(settings_.impl_side_painting);
[email protected]0634cdd42013-08-16 00:46:092157 DCHECK(output_surface_->context_provider());
[email protected]50af3c22013-07-13 03:50:202158
2159 ReleaseTreeResources();
danakjf446a072014-09-27 21:55:482160 renderer_ = nullptr;
[email protected]ced667b2014-05-22 21:49:532161 DestroyTileManager();
[email protected]105a723202014-06-12 14:18:272162
[email protected]50af3c22013-07-13 03:50:202163 resource_provider_->InitializeSoftware();
[email protected]41b53ac2014-05-22 03:22:192164 output_surface_->ReleaseContextProvider();
[email protected]50af3c22013-07-13 03:50:202165
[email protected]105a723202014-06-12 14:18:272166 CreateAndSetRenderer();
[email protected]50af3c22013-07-13 03:50:202167 EnforceZeroBudget(true);
[email protected]ced667b2014-05-22 21:49:532168 CreateAndSetTileManager();
[email protected]50af3c22013-07-13 03:50:202169
[email protected]50af3c22013-07-13 03:50:202170 client_->SetNeedsCommitOnImplThread();
2171}
2172
[email protected]64348ea2014-01-29 22:58:262173void LayerTreeHostImpl::SetViewportSize(const gfx::Size& device_viewport_size) {
[email protected]18ce59702013-04-09 04:58:402174 if (device_viewport_size == device_viewport_size_)
[email protected]c1bb5af2013-03-13 19:06:272175 return;
[email protected]94f206c12012-08-25 00:09:142176
[email protected]54af03522013-09-05 00:43:282177 if (pending_tree_)
[email protected]c1bb5af2013-03-13 19:06:272178 active_tree_->SetViewportSizeInvalid();
[email protected]318822852013-02-14 00:54:272179
[email protected]c1bb5af2013-03-13 19:06:272180 device_viewport_size_ = device_viewport_size;
[email protected]94f206c12012-08-25 00:09:142181
bokanef971462014-10-13 22:58:322182 UpdateViewportContainerSizes();
[email protected]c1bb5af2013-03-13 19:06:272183 client_->OnCanDrawStateChanged(CanDraw());
[email protected]59adb112013-04-09 04:48:442184 SetFullRootLayerDamage();
[email protected]a533d9b82014-07-11 20:29:242185 active_tree_->set_needs_update_draw_properties();
[email protected]94f206c12012-08-25 00:09:142186}
2187
[email protected]9f4f6a32013-09-04 21:35:122188void LayerTreeHostImpl::SetOverhangUIResource(
2189 UIResourceId overhang_ui_resource_id,
[email protected]64348ea2014-01-29 22:58:262190 const gfx::Size& overhang_ui_resource_size) {
[email protected]9f4f6a32013-09-04 21:35:122191 overhang_ui_resource_id_ = overhang_ui_resource_id;
2192 overhang_ui_resource_size_ = overhang_ui_resource_size;
2193}
2194
[email protected]c1bb5af2013-03-13 19:06:272195void LayerTreeHostImpl::SetDeviceScaleFactor(float device_scale_factor) {
2196 if (device_scale_factor == device_scale_factor_)
2197 return;
2198 device_scale_factor_ = device_scale_factor;
[email protected]c0dd24c2012-08-30 23:25:272199
[email protected]59adb112013-04-09 04:48:442200 SetFullRootLayerDamage();
[email protected]94f206c12012-08-25 00:09:142201}
2202
[email protected]bd5324592014-07-31 09:09:332203const gfx::Rect LayerTreeHostImpl::ViewportRectForTilePriority() const {
2204 if (viewport_rect_for_tile_priority_.IsEmpty())
2205 return DeviceViewport();
2206
2207 return viewport_rect_for_tile_priority_;
2208}
2209
[email protected]54af03522013-09-05 00:43:282210gfx::Size LayerTreeHostImpl::DrawViewportSize() const {
2211 return DeviceViewport().size();
2212}
2213
[email protected]f224cc92013-06-06 23:23:322214gfx::Rect LayerTreeHostImpl::DeviceViewport() const {
2215 if (external_viewport_.IsEmpty())
2216 return gfx::Rect(device_viewport_size_);
2217
2218 return external_viewport_;
2219}
2220
[email protected]54af03522013-09-05 00:43:282221gfx::Rect LayerTreeHostImpl::DeviceClip() const {
2222 if (external_clip_.IsEmpty())
2223 return DeviceViewport();
2224
2225 return external_clip_;
2226}
2227
2228const gfx::Transform& LayerTreeHostImpl::DrawTransform() const {
[email protected]f224cc92013-06-06 23:23:322229 return external_transform_;
2230}
2231
[email protected]59adb112013-04-09 04:48:442232void LayerTreeHostImpl::DidChangeTopControlsPosition() {
bokanef971462014-10-13 22:58:322233 UpdateViewportContainerSizes();
[email protected]4e4136d2013-11-29 02:22:442234 SetNeedsRedraw();
[email protected]43b8f982014-04-30 21:24:332235 SetNeedsAnimate();
[email protected]59adb112013-04-09 04:48:442236 active_tree_->set_needs_update_draw_properties();
2237 SetFullRootLayerDamage();
[email protected]94f206c12012-08-25 00:09:142238}
2239
bokan88eae012014-09-09 20:40:422240void LayerTreeHostImpl::SetControlsTopOffset(float offset) {
bokan55b2f152014-09-15 14:47:592241 float current_top_offset = active_tree_->top_controls_content_offset() -
2242 top_controls_manager_->top_controls_height();
2243 active_tree_->set_top_controls_delta(offset - current_top_offset);
bokan88eae012014-09-09 20:40:422244}
2245
2246float LayerTreeHostImpl::ControlsTopOffset() const {
bokan55b2f152014-09-15 14:47:592247 return active_tree_->total_top_controls_content_offset() -
2248 top_controls_manager_->top_controls_height();
bokan88eae012014-09-09 20:40:422249}
2250
[email protected]200a9c062013-05-20 04:34:372251void LayerTreeHostImpl::BindToClient(InputHandlerClient* client) {
2252 DCHECK(input_handler_client_ == NULL);
2253 input_handler_client_ = client;
2254}
2255
[email protected]420fdf6e2013-08-26 20:36:382256static LayerImpl* NextScrollLayer(LayerImpl* layer) {
2257 if (LayerImpl* scroll_parent = layer->scroll_parent())
2258 return scroll_parent;
2259 return layer->parent();
2260}
2261
[email protected]f620b0e72013-10-01 21:38:242262LayerImpl* LayerTreeHostImpl::FindScrollLayerForDeviceViewportPoint(
[email protected]14bc5d682014-01-17 07:26:472263 const gfx::PointF& device_viewport_point,
2264 InputHandler::ScrollInputType type,
[email protected]f161ca9e2014-04-01 13:57:012265 LayerImpl* layer_impl,
2266 bool* scroll_on_main_thread,
[email protected]edcc1a12014-05-06 01:26:392267 bool* optional_has_ancestor_scroll_handler) const {
[email protected]bf1cfd9a2013-09-26 05:43:022268 DCHECK(scroll_on_main_thread);
[email protected]94f206c12012-08-25 00:09:142269
[email protected]c1bb5af2013-03-13 19:06:272270 // Walk up the hierarchy and look for a scrollable layer.
[email protected]8f7f298822014-06-13 00:23:322271 LayerImpl* potentially_scrolling_layer_impl = NULL;
[email protected]420fdf6e2013-08-26 20:36:382272 for (; layer_impl; layer_impl = NextScrollLayer(layer_impl)) {
[email protected]c1bb5af2013-03-13 19:06:272273 // The content layer can also block attempts to scroll outside the main
2274 // thread.
2275 ScrollStatus status = layer_impl->TryScroll(device_viewport_point, type);
2276 if (status == ScrollOnMainThread) {
[email protected]bf1cfd9a2013-09-26 05:43:022277 *scroll_on_main_thread = true;
2278 return NULL;
[email protected]94f206c12012-08-25 00:09:142279 }
2280
[email protected]c1bb5af2013-03-13 19:06:272281 LayerImpl* scroll_layer_impl = FindScrollLayerForContentLayer(layer_impl);
2282 if (!scroll_layer_impl)
2283 continue;
[email protected]94f206c12012-08-25 00:09:142284
[email protected]c1bb5af2013-03-13 19:06:272285 status = scroll_layer_impl->TryScroll(device_viewport_point, type);
[email protected]c1bb5af2013-03-13 19:06:272286 // If any layer wants to divert the scroll event to the main thread, abort.
2287 if (status == ScrollOnMainThread) {
[email protected]bf1cfd9a2013-09-26 05:43:022288 *scroll_on_main_thread = true;
2289 return NULL;
[email protected]94f206c12012-08-25 00:09:142290 }
2291
[email protected]edcc1a12014-05-06 01:26:392292 if (optional_has_ancestor_scroll_handler &&
[email protected]f161ca9e2014-04-01 13:57:012293 scroll_layer_impl->have_scroll_event_handlers())
[email protected]edcc1a12014-05-06 01:26:392294 *optional_has_ancestor_scroll_handler = true;
[email protected]f161ca9e2014-04-01 13:57:012295
[email protected]c1bb5af2013-03-13 19:06:272296 if (status == ScrollStarted && !potentially_scrolling_layer_impl)
2297 potentially_scrolling_layer_impl = scroll_layer_impl;
2298 }
2299
[email protected]edcc1a12014-05-06 01:26:392300 // Falling back to the root scroll layer ensures generation of root overscroll
2301 // notifications while preventing scroll updates from being unintentionally
2302 // forwarded to the main thread.
2303 if (!potentially_scrolling_layer_impl)
2304 potentially_scrolling_layer_impl = OuterViewportScrollLayer()
2305 ? OuterViewportScrollLayer()
2306 : InnerViewportScrollLayer();
2307
[email protected]bf1cfd9a2013-09-26 05:43:022308 return potentially_scrolling_layer_impl;
2309}
2310
[email protected]edcc1a12014-05-06 01:26:392311// Similar to LayerImpl::HasAncestor, but walks up the scroll parents.
[email protected]05ba53c2014-04-16 21:22:512312static bool HasScrollAncestor(LayerImpl* child, LayerImpl* scroll_ancestor) {
2313 DCHECK(scroll_ancestor);
2314 for (LayerImpl* ancestor = child; ancestor;
2315 ancestor = NextScrollLayer(ancestor)) {
2316 if (ancestor->scrollable())
2317 return ancestor == scroll_ancestor;
2318 }
2319 return false;
2320}
2321
[email protected]bf1cfd9a2013-09-26 05:43:022322InputHandler::ScrollStatus LayerTreeHostImpl::ScrollBegin(
[email protected]47a723f2014-03-05 12:42:492323 const gfx::Point& viewport_point,
2324 InputHandler::ScrollInputType type) {
[email protected]bf1cfd9a2013-09-26 05:43:022325 TRACE_EVENT0("cc", "LayerTreeHostImpl::ScrollBegin");
2326
2327 if (top_controls_manager_)
2328 top_controls_manager_->ScrollBegin();
2329
2330 DCHECK(!CurrentlyScrollingLayer());
2331 ClearCurrentlyScrollingLayer();
2332
[email protected]f620b0e72013-10-01 21:38:242333 gfx::PointF device_viewport_point = gfx::ScalePoint(viewport_point,
2334 device_scale_factor_);
[email protected]28336d52014-05-12 19:07:282335 LayerImpl* layer_impl =
2336 active_tree_->FindLayerThatIsHitByPoint(device_viewport_point);
[email protected]05ba53c2014-04-16 21:22:512337
2338 if (layer_impl) {
2339 LayerImpl* scroll_layer_impl =
[email protected]28336d52014-05-12 19:07:282340 active_tree_->FindFirstScrollingLayerThatIsHitByPoint(
2341 device_viewport_point);
[email protected]05ba53c2014-04-16 21:22:512342 if (scroll_layer_impl && !HasScrollAncestor(layer_impl, scroll_layer_impl))
2343 return ScrollUnknown;
2344 }
2345
[email protected]bf1cfd9a2013-09-26 05:43:022346 bool scroll_on_main_thread = false;
[email protected]edcc1a12014-05-06 01:26:392347 LayerImpl* scrolling_layer_impl =
[email protected]f161ca9e2014-04-01 13:57:012348 FindScrollLayerForDeviceViewportPoint(device_viewport_point,
2349 type,
2350 layer_impl,
2351 &scroll_on_main_thread,
2352 &scroll_affects_scroll_handler_);
[email protected]bf1cfd9a2013-09-26 05:43:022353
2354 if (scroll_on_main_thread) {
[email protected]bf1cfd9a2013-09-26 05:43:022355 UMA_HISTOGRAM_BOOLEAN("TryScroll.SlowScroll", true);
2356 return ScrollOnMainThread;
2357 }
2358
[email protected]edcc1a12014-05-06 01:26:392359 if (scrolling_layer_impl) {
2360 active_tree_->SetCurrentlyScrollingLayer(scrolling_layer_impl);
[email protected]c1bb5af2013-03-13 19:06:272361 should_bubble_scrolls_ = (type != NonBubblingGesture);
2362 wheel_scrolling_ = (type == Wheel);
[email protected]c1bb5af2013-03-13 19:06:272363 client_->RenewTreePriority();
2364 UMA_HISTOGRAM_BOOLEAN("TryScroll.SlowScroll", false);
2365 return ScrollStarted;
2366 }
2367 return ScrollIgnored;
[email protected]94f206c12012-08-25 00:09:142368}
2369
[email protected]749cbc62014-07-10 01:06:352370InputHandler::ScrollStatus LayerTreeHostImpl::ScrollAnimated(
2371 const gfx::Point& viewport_point,
2372 const gfx::Vector2dF& scroll_delta) {
[email protected]7a7d5be2014-07-18 22:37:262373 if (LayerImpl* layer_impl = CurrentlyScrollingLayer()) {
2374 Animation* animation =
2375 layer_impl->layer_animation_controller()->GetAnimation(
2376 Animation::ScrollOffset);
2377 if (!animation)
2378 return ScrollIgnored;
2379
2380 ScrollOffsetAnimationCurve* curve =
2381 animation->curve()->ToScrollOffsetAnimationCurve();
2382
miletusf57925d2014-10-01 19:38:132383 gfx::ScrollOffset new_target =
2384 gfx::ScrollOffsetWithDelta(curve->target_value(), scroll_delta);
2385 new_target.SetToMax(gfx::ScrollOffset());
[email protected]7a7d5be2014-07-18 22:37:262386 new_target.SetToMin(layer_impl->MaxScrollOffset());
2387
behara.ms71ff07f32014-11-12 05:09:082388 curve->UpdateTarget(
2389 animation->TrimTimeToCurrentIteration(
2390 CurrentBeginFrameArgs().frame_time).InSecondsF(),
2391 new_target);
[email protected]7a7d5be2014-07-18 22:37:262392
2393 return ScrollStarted;
[email protected]749cbc62014-07-10 01:06:352394 }
2395 // ScrollAnimated is only used for wheel scrolls. We use the same bubbling
2396 // behavior as ScrollBy to determine which layer to animate, but we do not
2397 // do the Android-specific things in ScrollBy like showing top controls.
2398 InputHandler::ScrollStatus scroll_status = ScrollBegin(viewport_point, Wheel);
2399 if (scroll_status == ScrollStarted) {
2400 gfx::Vector2dF pending_delta = scroll_delta;
2401 for (LayerImpl* layer_impl = CurrentlyScrollingLayer(); layer_impl;
2402 layer_impl = layer_impl->parent()) {
2403 if (!layer_impl->scrollable())
2404 continue;
2405
miletusf57925d2014-10-01 19:38:132406 gfx::ScrollOffset current_offset = layer_impl->TotalScrollOffset();
2407 gfx::ScrollOffset target_offset =
2408 ScrollOffsetWithDelta(current_offset, pending_delta);
2409 target_offset.SetToMax(gfx::ScrollOffset());
[email protected]749cbc62014-07-10 01:06:352410 target_offset.SetToMin(layer_impl->MaxScrollOffset());
miletusf57925d2014-10-01 19:38:132411 gfx::Vector2dF actual_delta = target_offset.DeltaFrom(current_offset);
[email protected]749cbc62014-07-10 01:06:352412
2413 const float kEpsilon = 0.1f;
2414 bool can_layer_scroll = (std::abs(actual_delta.x()) > kEpsilon ||
2415 std::abs(actual_delta.y()) > kEpsilon);
2416
2417 if (!can_layer_scroll) {
2418 layer_impl->ScrollBy(actual_delta);
2419 pending_delta -= actual_delta;
2420 continue;
2421 }
2422
2423 active_tree_->SetCurrentlyScrollingLayer(layer_impl);
2424
2425 scoped_ptr<ScrollOffsetAnimationCurve> curve =
2426 ScrollOffsetAnimationCurve::Create(target_offset,
2427 EaseInOutTimingFunction::Create());
2428 curve->SetInitialValue(current_offset);
2429
2430 scoped_ptr<Animation> animation =
danakjf446a072014-09-27 21:55:482431 Animation::Create(curve.Pass(),
[email protected]749cbc62014-07-10 01:06:352432 AnimationIdProvider::NextAnimationId(),
2433 AnimationIdProvider::NextGroupId(),
2434 Animation::ScrollOffset);
2435 animation->set_is_impl_only(true);
2436
2437 layer_impl->layer_animation_controller()->AddAnimation(animation.Pass());
2438
2439 SetNeedsAnimate();
2440 return ScrollStarted;
2441 }
2442 }
2443 ScrollEnd();
2444 return scroll_status;
2445}
2446
[email protected]c1bb5af2013-03-13 19:06:272447gfx::Vector2dF LayerTreeHostImpl::ScrollLayerWithViewportSpaceDelta(
2448 LayerImpl* layer_impl,
2449 float scale_from_viewport_to_screen_space,
[email protected]14bc5d682014-01-17 07:26:472450 const gfx::PointF& viewport_point,
[email protected]3244c9132014-01-23 10:39:122451 const gfx::Vector2dF& viewport_delta) {
[email protected]c1bb5af2013-03-13 19:06:272452 // 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);
[email protected]ca2902e92013-03-28 01:45:352459 // TODO(shawnsingh): With the advent of impl-side crolling for non-root
2460 // layers, we may need to explicitly handle uninvertible transforms here.
[email protected]c1bb5af2013-03-13 19:06:272461 DCHECK(did_invert);
[email protected]94f206c12012-08-25 00:09:142462
[email protected]c1bb5af2013-03-13 19:06:272463 gfx::PointF screen_space_point =
2464 gfx::ScalePoint(viewport_point, scale_from_viewport_to_screen_space);
[email protected]94f206c12012-08-25 00:09:142465
[email protected]c1bb5af2013-03-13 19:06:272466 gfx::Vector2dF screen_space_delta = viewport_delta;
2467 screen_space_delta.Scale(scale_from_viewport_to_screen_space);
2468
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 =
[email protected]fa816c62013-03-18 04:24:212474 MathUtil::ProjectPoint(inverse_screen_space_transform,
[email protected]c1bb5af2013-03-13 19:06:272475 screen_space_point,
[email protected]fa816c62013-03-18 04:24:212476 &start_clipped);
[email protected]c1bb5af2013-03-13 19:06:272477 gfx::PointF local_end_point =
[email protected]fa816c62013-03-18 04:24:212478 MathUtil::ProjectPoint(inverse_screen_space_transform,
[email protected]c1bb5af2013-03-13 19:06:272479 screen_space_end_point,
[email protected]fa816c62013-03-18 04:24:212480 &end_clipped);
[email protected]c1bb5af2013-03-13 19:06:272481
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();
2487
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);
2494
2495 // Apply the scroll delta.
[email protected]1960a712013-04-30 17:06:472496 gfx::Vector2dF previous_delta = layer_impl->ScrollDelta();
[email protected]c1bb5af2013-03-13 19:06:272497 layer_impl->ScrollBy(local_end_point - local_start_point);
2498
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 +
[email protected]1960a712013-04-30 17:06:472502 layer_impl->ScrollDelta() -
[email protected]c1bb5af2013-03-13 19:06:272503 previous_delta;
2504 gfx::PointF actual_local_content_end_point =
2505 gfx::ScalePoint(actual_local_end_point,
2506 1.f / width_scale,
2507 1.f / height_scale);
2508
2509 // Calculate the applied scroll delta in viewport space coordinates.
2510 gfx::PointF actual_screen_space_end_point =
[email protected]fa816c62013-03-18 04:24:212511 MathUtil::MapPoint(layer_impl->screen_space_transform(),
[email protected]c1bb5af2013-03-13 19:06:272512 actual_local_content_end_point,
[email protected]fa816c62013-03-18 04:24:212513 &end_clipped);
[email protected]c1bb5af2013-03-13 19:06:272514 DCHECK(!end_clipped);
2515 if (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;
[email protected]94f206c12012-08-25 00:09:142521}
2522
[email protected]c1bb5af2013-03-13 19:06:272523static gfx::Vector2dF ScrollLayerWithLocalDelta(LayerImpl* layer_impl,
[email protected]3244c9132014-01-23 10:39:122524 const gfx::Vector2dF& local_delta) {
[email protected]1960a712013-04-30 17:06:472525 gfx::Vector2dF previous_delta(layer_impl->ScrollDelta());
[email protected]c1bb5af2013-03-13 19:06:272526 layer_impl->ScrollBy(local_delta);
[email protected]1960a712013-04-30 17:06:472527 return layer_impl->ScrollDelta() - previous_delta;
[email protected]c1bb5af2013-03-13 19:06:272528}
2529
bokanef971462014-10-13 22:58:322530bool LayerTreeHostImpl::ShouldTopControlsConsumeScroll(
2531 const gfx::Vector2dF& scroll_delta) const {
2532 DCHECK(CurrentlyScrollingLayer());
2533
2534 if (!top_controls_manager_)
2535 return false;
2536
2537 // Always consume if it's in the direction to show the top controls.
2538 if (scroll_delta.y() < 0)
2539 return true;
2540
2541 if (CurrentlyScrollingLayer() != InnerViewportScrollLayer() &&
2542 CurrentlyScrollingLayer() != OuterViewportScrollLayer())
2543 return false;
2544
sujiths.s344435e2014-11-08 03:04:032545 if (active_tree()->TotalScrollOffset().y() <
2546 active_tree()->TotalMaxScrollOffset().y())
bokanef971462014-10-13 22:58:322547 return true;
2548
2549 return false;
2550}
2551
ccameron36d091f2014-11-07 03:18:502552InputHandlerScrollResult LayerTreeHostImpl::ScrollBy(
2553 const gfx::Point& viewport_point,
2554 const gfx::Vector2dF& scroll_delta) {
[email protected]c1bb5af2013-03-13 19:06:272555 TRACE_EVENT0("cc", "LayerTreeHostImpl::ScrollBy");
2556 if (!CurrentlyScrollingLayer())
ccameron36d091f2014-11-07 03:18:502557 return InputHandlerScrollResult();
[email protected]c1bb5af2013-03-13 19:06:272558
2559 gfx::Vector2dF pending_delta = scroll_delta;
[email protected]a2b5ded2013-05-20 21:32:532560 gfx::Vector2dF unused_root_delta;
[email protected]2bd503f2013-07-23 05:35:292561 bool did_scroll_x = false;
2562 bool did_scroll_y = false;
[email protected]f42cffb2014-03-08 18:03:252563 bool did_scroll_top_controls = false;
bokanef971462014-10-13 22:58:322564
2565 bool consume_by_top_controls = ShouldTopControlsConsumeScroll(scroll_delta);
[email protected]a91e4f82013-03-15 06:58:062566
bokana203a4b12014-11-18 16:28:082567 // There's an edge case where the outer viewport isn't scrollable when the
2568 // scroll starts, however, as the top controls show the outer viewport becomes
2569 // scrollable. Therefore, always try scrolling the outer viewport before the
2570 // inner.
2571 // TODO(bokan): Move the top controls logic out of the loop since the scroll
2572 // that causes the outer viewport to become scrollable will still be applied
2573 // to the inner viewport.
2574 LayerImpl* start_layer = CurrentlyScrollingLayer();
2575 if (start_layer == InnerViewportScrollLayer() && OuterViewportScrollLayer())
2576 start_layer = OuterViewportScrollLayer();
2577
2578 for (LayerImpl* layer_impl = start_layer;
[email protected]c1bb5af2013-03-13 19:06:272579 layer_impl;
2580 layer_impl = layer_impl->parent()) {
2581 if (!layer_impl->scrollable())
2582 continue;
2583
bokanef971462014-10-13 22:58:322584 if (layer_impl == InnerViewportScrollLayer() ||
2585 layer_impl == OuterViewportScrollLayer()) {
[email protected]d948c112014-01-10 02:13:532586 if (consume_by_top_controls) {
bokanef971462014-10-13 22:58:322587 gfx::Vector2dF excess_delta =
2588 top_controls_manager_->ScrollBy(pending_delta);
2589 gfx::Vector2dF applied_delta = pending_delta - excess_delta;
[email protected]adeda572014-01-31 00:49:472590 pending_delta = excess_delta;
2591 // Force updating of vertical adjust values if needed.
bokanef971462014-10-13 22:58:322592 if (applied_delta.y() != 0)
[email protected]f42cffb2014-03-08 18:03:252593 did_scroll_top_controls = true;
[email protected]a2b5ded2013-05-20 21:32:532594 }
2595 // Track root layer deltas for reporting overscroll.
bokanef971462014-10-13 22:58:322596 if (layer_impl == InnerViewportScrollLayer())
2597 unused_root_delta = pending_delta;
[email protected]60b4d252013-03-23 18:49:422598 }
2599
[email protected]c1bb5af2013-03-13 19:06:272600 gfx::Vector2dF applied_delta;
[email protected]c1bb5af2013-03-13 19:06:272601 // Gesture events need to be transformed from viewport coordinates to local
2602 // layer coordinates so that the scrolling contents exactly follow the
2603 // user's finger. In contrast, wheel events represent a fixed amount of
2604 // scrolling so we can just apply them directly.
2605 if (!wheel_scrolling_) {
2606 float scale_from_viewport_to_screen_space = device_scale_factor_;
2607 applied_delta =
2608 ScrollLayerWithViewportSpaceDelta(layer_impl,
2609 scale_from_viewport_to_screen_space,
2610 viewport_point, pending_delta);
2611 } else {
2612 applied_delta = ScrollLayerWithLocalDelta(layer_impl, pending_delta);
[email protected]94f206c12012-08-25 00:09:142613 }
[email protected]94f206c12012-08-25 00:09:142614
[email protected]9328ede2014-04-04 07:45:522615 const float kEpsilon = 0.1f;
[email protected]5b8a865c2014-04-03 00:35:512616 if (layer_impl == InnerViewportScrollLayer()) {
2617 unused_root_delta.Subtract(applied_delta);
[email protected]9328ede2014-04-04 07:45:522618 if (std::abs(unused_root_delta.x()) < kEpsilon)
[email protected]5b8a865c2014-04-03 00:35:512619 unused_root_delta.set_x(0.0f);
[email protected]9328ede2014-04-04 07:45:522620 if (std::abs(unused_root_delta.y()) < kEpsilon)
[email protected]5b8a865c2014-04-03 00:35:512621 unused_root_delta.set_y(0.0f);
[email protected]e9eb23f2014-04-11 13:42:032622 // Disable overscroll on axes which is impossible to scroll.
2623 if (settings_.report_overscroll_only_for_scrollable_axes) {
aeliasaf915a882014-10-14 04:12:042624 if (std::abs(active_tree_->TotalMaxScrollOffset().x()) <= kEpsilon ||
2625 !layer_impl->user_scrollable_horizontal())
[email protected]e9eb23f2014-04-11 13:42:032626 unused_root_delta.set_x(0.0f);
aeliasaf915a882014-10-14 04:12:042627 if (std::abs(active_tree_->TotalMaxScrollOffset().y()) <= kEpsilon ||
2628 !layer_impl->user_scrollable_vertical())
[email protected]e9eb23f2014-04-11 13:42:032629 unused_root_delta.set_y(0.0f);
2630 }
[email protected]5b8a865c2014-04-03 00:35:512631 }
2632
jddukea7173dd2014-11-19 22:05:282633 // Scrolls should bubble perfectly between the outer and inner viewports.
2634 bool allow_unrestricted_bubbling_for_current_layer =
2635 layer_impl == OuterViewportScrollLayer();
2636 bool allow_bubbling_for_current_layer =
2637 allow_unrestricted_bubbling_for_current_layer || should_bubble_scrolls_;
2638
[email protected]c1bb5af2013-03-13 19:06:272639 // If the layer wasn't able to move, try the next one in the hierarchy.
[email protected]9328ede2014-04-04 07:45:522640 bool did_move_layer_x = std::abs(applied_delta.x()) > kEpsilon;
2641 bool did_move_layer_y = std::abs(applied_delta.y()) > kEpsilon;
[email protected]2bd503f2013-07-23 05:35:292642 did_scroll_x |= did_move_layer_x;
2643 did_scroll_y |= did_move_layer_y;
2644 if (!did_move_layer_x && !did_move_layer_y) {
jddukea7173dd2014-11-19 22:05:282645 if (allow_bubbling_for_current_layer || !did_lock_scrolling_layer_)
[email protected]c1bb5af2013-03-13 19:06:272646 continue;
[email protected]db102612013-12-20 22:04:122647 else
2648 break;
[email protected]94f206c12012-08-25 00:09:142649 }
[email protected]a2b5ded2013-05-20 21:32:532650
[email protected]c1bb5af2013-03-13 19:06:272651 did_lock_scrolling_layer_ = true;
jddukea7173dd2014-11-19 22:05:282652 if (!allow_bubbling_for_current_layer) {
[email protected]0fc818e2013-03-18 06:45:202653 active_tree_->SetCurrentlyScrollingLayer(layer_impl);
[email protected]c1bb5af2013-03-13 19:06:272654 break;
[email protected]94f206c12012-08-25 00:09:142655 }
[email protected]94f206c12012-08-25 00:09:142656
jddukea7173dd2014-11-19 22:05:282657 if (allow_unrestricted_bubbling_for_current_layer) {
2658 pending_delta -= applied_delta;
2659 } else {
2660 // If the applied delta is within 45 degrees of the input delta, bail out
2661 // to make it easier to scroll just one layer in one direction without
2662 // affecting any of its parents.
2663 float angle_threshold = 45;
2664 if (MathUtil::SmallestAngleBetweenVectors(applied_delta, pending_delta) <
2665 angle_threshold) {
2666 pending_delta = gfx::Vector2dF();
2667 break;
2668 }
[email protected]c1bb5af2013-03-13 19:06:272669
jddukea7173dd2014-11-19 22:05:282670 // Allow further movement only on an axis perpendicular to the direction
2671 // in which the layer moved.
2672 gfx::Vector2dF perpendicular_axis(-applied_delta.y(), applied_delta.x());
2673 pending_delta =
2674 MathUtil::ProjectVector(pending_delta, perpendicular_axis);
2675 }
[email protected]c1bb5af2013-03-13 19:06:272676
[email protected]a2b5ded2013-05-20 21:32:532677 if (gfx::ToRoundedVector2d(pending_delta).IsZero())
[email protected]c1bb5af2013-03-13 19:06:272678 break;
2679 }
2680
[email protected]f42cffb2014-03-08 18:03:252681 bool did_scroll_content = did_scroll_x || did_scroll_y;
2682 if (did_scroll_content) {
[email protected]dab0a422014-08-13 16:09:462683 // If we are scrolling with an active scroll handler, forward latency
2684 // tracking information to the main thread so the delay introduced by the
2685 // handler is accounted for.
2686 if (scroll_affects_scroll_handler())
2687 NotifySwapPromiseMonitorsOfForwardingToMainThread();
[email protected]c1bb5af2013-03-13 19:06:272688 client_->SetNeedsCommitOnImplThread();
[email protected]4e4136d2013-11-29 02:22:442689 SetNeedsRedraw();
[email protected]c1bb5af2013-03-13 19:06:272690 client_->RenewTreePriority();
2691 }
[email protected]a2b5ded2013-05-20 21:32:532692
[email protected]2bd503f2013-07-23 05:35:292693 // Scrolling along an axis resets accumulated root overscroll for that axis.
2694 if (did_scroll_x)
2695 accumulated_root_overscroll_.set_x(0);
2696 if (did_scroll_y)
2697 accumulated_root_overscroll_.set_y(0);
[email protected]a2b5ded2013-05-20 21:32:532698 accumulated_root_overscroll_ += unused_root_delta;
[email protected]a2b5ded2013-05-20 21:32:532699
ccameron36d091f2014-11-07 03:18:502700 InputHandlerScrollResult scroll_result;
2701 scroll_result.did_scroll = did_scroll_content || did_scroll_top_controls;
2702 scroll_result.did_overscroll_root = !unused_root_delta.IsZero();
2703 scroll_result.accumulated_root_overscroll = accumulated_root_overscroll_;
2704 scroll_result.unused_scroll_delta = unused_root_delta;
2705 return scroll_result;
[email protected]4a23c374c2012-12-08 08:38:552706}
2707
[email protected]be782f52013-03-23 21:36:142708// This implements scrolling by page as described here:
2709// http://msdn.microsoft.com/en-us/library/windows/desktop/ms645601(v=vs.85).aspx#_win32_The_Mouse_Wheel
2710// for events with WHEEL_PAGESCROLL set.
[email protected]47a723f2014-03-05 12:42:492711bool LayerTreeHostImpl::ScrollVerticallyByPage(const gfx::Point& viewport_point,
[email protected]c28df4c12013-05-22 17:36:492712 ScrollDirection direction) {
[email protected]be782f52013-03-23 21:36:142713 DCHECK(wheel_scrolling_);
2714
2715 for (LayerImpl* layer_impl = CurrentlyScrollingLayer();
2716 layer_impl;
2717 layer_impl = layer_impl->parent()) {
2718 if (!layer_impl->scrollable())
2719 continue;
2720
[email protected]adeda572014-01-31 00:49:472721 if (!layer_impl->HasScrollbar(VERTICAL))
[email protected]be782f52013-03-23 21:36:142722 continue;
2723
bokancccfde72014-10-08 15:15:222724 float height = layer_impl->clip_height();
[email protected]be782f52013-03-23 21:36:142725
2726 // These magical values match WebKit and are designed to scroll nearly the
2727 // entire visible content height but leave a bit of overlap.
2728 float page = std::max(height * 0.875f, 1.f);
[email protected]c28df4c12013-05-22 17:36:492729 if (direction == SCROLL_BACKWARD)
[email protected]be782f52013-03-23 21:36:142730 page = -page;
2731
2732 gfx::Vector2dF delta = gfx::Vector2dF(0.f, page);
2733
2734 gfx::Vector2dF applied_delta = ScrollLayerWithLocalDelta(layer_impl, delta);
2735
2736 if (!applied_delta.IsZero()) {
[email protected]be782f52013-03-23 21:36:142737 client_->SetNeedsCommitOnImplThread();
[email protected]4e4136d2013-11-29 02:22:442738 SetNeedsRedraw();
[email protected]be782f52013-03-23 21:36:142739 client_->RenewTreePriority();
2740 return true;
2741 }
2742
2743 active_tree_->SetCurrentlyScrollingLayer(layer_impl);
2744 }
2745
2746 return false;
2747}
2748
[email protected]1960a712013-04-30 17:06:472749void LayerTreeHostImpl::SetRootLayerScrollOffsetDelegate(
2750 LayerScrollOffsetDelegate* root_layer_scroll_offset_delegate) {
2751 root_layer_scroll_offset_delegate_ = root_layer_scroll_offset_delegate;
2752 active_tree_->SetRootLayerScrollOffsetDelegate(
2753 root_layer_scroll_offset_delegate_);
2754}
2755
2756void LayerTreeHostImpl::OnRootLayerDelegatedScrollOffsetChanged() {
boliu7d5dbab2014-10-10 20:05:472757 DCHECK(root_layer_scroll_offset_delegate_);
[email protected]1960a712013-04-30 17:06:472758 client_->SetNeedsCommitOnImplThread();
boliu7d5dbab2014-10-10 20:05:472759 SetNeedsRedraw();
2760 active_tree_->OnRootLayerDelegatedScrollOffsetChanged();
[email protected]b4a3d462014-06-17 09:17:082761 active_tree_->set_needs_update_draw_properties();
[email protected]1960a712013-04-30 17:06:472762}
2763
[email protected]c1bb5af2013-03-13 19:06:272764void LayerTreeHostImpl::ClearCurrentlyScrollingLayer() {
2765 active_tree_->ClearCurrentlyScrollingLayer();
2766 did_lock_scrolling_layer_ = false;
[email protected]f161ca9e2014-04-01 13:57:012767 scroll_affects_scroll_handler_ = false;
[email protected]a2b5ded2013-05-20 21:32:532768 accumulated_root_overscroll_ = gfx::Vector2dF();
[email protected]94f206c12012-08-25 00:09:142769}
2770
[email protected]c1bb5af2013-03-13 19:06:272771void LayerTreeHostImpl::ScrollEnd() {
2772 if (top_controls_manager_)
2773 top_controls_manager_->ScrollEnd();
2774 ClearCurrentlyScrollingLayer();
[email protected]94f206c12012-08-25 00:09:142775}
2776
[email protected]5ff3c9782013-04-29 17:35:122777InputHandler::ScrollStatus LayerTreeHostImpl::FlingScrollBegin() {
[email protected]75147f52013-08-02 19:11:462778 if (!active_tree_->CurrentlyScrollingLayer())
2779 return ScrollIgnored;
[email protected]7c45d8152013-04-23 18:27:212780
[email protected]75147f52013-08-02 19:11:462781 if (settings_.ignore_root_layer_flings &&
[email protected]adeda572014-01-31 00:49:472782 (active_tree_->CurrentlyScrollingLayer() == InnerViewportScrollLayer() ||
2783 active_tree_->CurrentlyScrollingLayer() == OuterViewportScrollLayer())) {
[email protected]75147f52013-08-02 19:11:462784 ClearCurrentlyScrollingLayer();
2785 return ScrollIgnored;
2786 }
2787
[email protected]db102612013-12-20 22:04:122788 if (!wheel_scrolling_) {
2789 // Allow the fling to lock to the first layer that moves after the initial
2790 // fling |ScrollBy()| event.
2791 did_lock_scrolling_layer_ = false;
2792 should_bubble_scrolls_ = false;
2793 }
[email protected]df0c42342013-10-08 20:52:122794
[email protected]75147f52013-08-02 19:11:462795 return ScrollStarted;
[email protected]7c45d8152013-04-23 18:27:212796}
2797
[email protected]bf1cfd9a2013-09-26 05:43:022798float LayerTreeHostImpl::DeviceSpaceDistanceToLayer(
[email protected]14bc5d682014-01-17 07:26:472799 const gfx::PointF& device_viewport_point,
[email protected]bf1cfd9a2013-09-26 05:43:022800 LayerImpl* layer_impl) {
2801 if (!layer_impl)
2802 return std::numeric_limits<float>::max();
2803
2804 gfx::Rect layer_impl_bounds(
2805 layer_impl->content_bounds());
2806
2807 gfx::RectF device_viewport_layer_impl_bounds = MathUtil::MapClippedRect(
2808 layer_impl->screen_space_transform(),
2809 layer_impl_bounds);
2810
2811 return device_viewport_layer_impl_bounds.ManhattanDistanceToPoint(
2812 device_viewport_point);
2813}
2814
[email protected]47a723f2014-03-05 12:42:492815void LayerTreeHostImpl::MouseMoveAt(const gfx::Point& viewport_point) {
[email protected]f620b0e72013-10-01 21:38:242816 gfx::PointF device_viewport_point = gfx::ScalePoint(viewport_point,
2817 device_scale_factor_);
[email protected]28336d52014-05-12 19:07:282818 LayerImpl* layer_impl =
2819 active_tree_->FindLayerThatIsHitByPoint(device_viewport_point);
[email protected]f620b0e72013-10-01 21:38:242820 if (HandleMouseOverScrollbar(layer_impl, device_viewport_point))
2821 return;
2822
2823 if (scroll_layer_id_when_mouse_over_scrollbar_) {
2824 LayerImpl* scroll_layer_impl = active_tree_->LayerById(
2825 scroll_layer_id_when_mouse_over_scrollbar_);
2826
[email protected]5cd9ac12014-02-05 21:48:532827 // The check for a null scroll_layer_impl below was added to see if it will
2828 // eliminate the crashes described in http://crbug.com/326635.
2829 // TODO(wjmaclean) Add a unit test if this fixes the crashes.
[email protected]f620b0e72013-10-01 21:38:242830 ScrollbarAnimationController* animation_controller =
[email protected]5cd9ac12014-02-05 21:48:532831 scroll_layer_impl ? scroll_layer_impl->scrollbar_animation_controller()
2832 : NULL;
[email protected]930ff43b2014-05-02 05:24:002833 if (animation_controller)
2834 animation_controller->DidMouseMoveOffScrollbar();
[email protected]f620b0e72013-10-01 21:38:242835 scroll_layer_id_when_mouse_over_scrollbar_ = 0;
2836 }
2837
[email protected]bf1cfd9a2013-09-26 05:43:022838 bool scroll_on_main_thread = false;
[email protected]f161ca9e2014-04-01 13:57:012839 LayerImpl* scroll_layer_impl =
2840 FindScrollLayerForDeviceViewportPoint(device_viewport_point,
2841 InputHandler::Gesture,
2842 layer_impl,
2843 &scroll_on_main_thread,
2844 NULL);
[email protected]bf1cfd9a2013-09-26 05:43:022845 if (scroll_on_main_thread || !scroll_layer_impl)
2846 return;
2847
2848 ScrollbarAnimationController* animation_controller =
2849 scroll_layer_impl->scrollbar_animation_controller();
2850 if (!animation_controller)
2851 return;
2852
[email protected]adeda572014-01-31 00:49:472853 // TODO(wjmaclean) Is it ok to choose distance from more than two scrollbars?
2854 float distance_to_scrollbar = std::numeric_limits<float>::max();
2855 for (LayerImpl::ScrollbarSet::iterator it =
2856 scroll_layer_impl->scrollbars()->begin();
2857 it != scroll_layer_impl->scrollbars()->end();
2858 ++it)
2859 distance_to_scrollbar =
2860 std::min(distance_to_scrollbar,
2861 DeviceSpaceDistanceToLayer(device_viewport_point, *it));
[email protected]bf1cfd9a2013-09-26 05:43:022862
[email protected]930ff43b2014-05-02 05:24:002863 animation_controller->DidMouseMoveNear(distance_to_scrollbar /
2864 device_scale_factor_);
[email protected]bf1cfd9a2013-09-26 05:43:022865}
2866
[email protected]f620b0e72013-10-01 21:38:242867bool LayerTreeHostImpl::HandleMouseOverScrollbar(LayerImpl* layer_impl,
[email protected]14bc5d682014-01-17 07:26:472868 const gfx::PointF& device_viewport_point) {
[email protected]f620b0e72013-10-01 21:38:242869 if (layer_impl && layer_impl->ToScrollbarLayer()) {
2870 int scroll_layer_id = layer_impl->ToScrollbarLayer()->ScrollLayerId();
2871 layer_impl = active_tree_->LayerById(scroll_layer_id);
2872 if (layer_impl && layer_impl->scrollbar_animation_controller()) {
2873 scroll_layer_id_when_mouse_over_scrollbar_ = scroll_layer_id;
[email protected]930ff43b2014-05-02 05:24:002874 layer_impl->scrollbar_animation_controller()->DidMouseMoveNear(0);
[email protected]f620b0e72013-10-01 21:38:242875 } else {
2876 scroll_layer_id_when_mouse_over_scrollbar_ = 0;
2877 }
2878
2879 return true;
2880 }
2881
2882 return false;
2883}
2884
[email protected]c1bb5af2013-03-13 19:06:272885void LayerTreeHostImpl::PinchGestureBegin() {
2886 pinch_gesture_active_ = true;
2887 previous_pinch_anchor_ = gfx::Point();
2888 client_->RenewTreePriority();
[email protected]2fa342b82013-09-24 03:19:132889 pinch_gesture_end_should_clear_scrolling_layer_ = !CurrentlyScrollingLayer();
[email protected]adeda572014-01-31 00:49:472890 if (active_tree_->OuterViewportScrollLayer()) {
2891 active_tree_->SetCurrentlyScrollingLayer(
2892 active_tree_->OuterViewportScrollLayer());
2893 } else {
2894 active_tree_->SetCurrentlyScrollingLayer(
2895 active_tree_->InnerViewportScrollLayer());
2896 }
[email protected]a9bda5e2013-10-25 18:43:372897 if (top_controls_manager_)
2898 top_controls_manager_->PinchBegin();
[email protected]94f206c12012-08-25 00:09:142899}
2900
[email protected]c1bb5af2013-03-13 19:06:272901void LayerTreeHostImpl::PinchGestureUpdate(float magnify_delta,
[email protected]47a723f2014-03-05 12:42:492902 const gfx::Point& anchor) {
[email protected]b93480862014-02-20 13:07:032903 if (!InnerViewportScrollLayer())
2904 return;
[email protected]d3afa112012-12-08 06:24:282905
[email protected]b93480862014-02-20 13:07:032906 TRACE_EVENT0("cc", "LayerTreeHostImpl::PinchGestureUpdate");
[email protected]d3afa112012-12-08 06:24:282907
[email protected]ec2322e2014-05-15 16:32:002908 // For a moment the scroll offset ends up being outside of the max range. This
2909 // confuses the delegate so we switch it off till after we're done processing
2910 // the pinch update.
2911 active_tree_->SetRootLayerScrollOffsetDelegate(NULL);
2912
[email protected]c1bb5af2013-03-13 19:06:272913 // Keep the center-of-pinch anchor specified by (x, y) in a stable
2914 // position over the course of the magnify.
2915 float page_scale_delta = active_tree_->page_scale_delta();
2916 gfx::PointF previous_scale_anchor =
2917 gfx::ScalePoint(anchor, 1.f / page_scale_delta);
2918 active_tree_->SetPageScaleDelta(page_scale_delta * magnify_delta);
2919 page_scale_delta = active_tree_->page_scale_delta();
2920 gfx::PointF new_scale_anchor =
2921 gfx::ScalePoint(anchor, 1.f / page_scale_delta);
2922 gfx::Vector2dF move = previous_scale_anchor - new_scale_anchor;
2923
2924 previous_pinch_anchor_ = anchor;
2925
2926 move.Scale(1 / active_tree_->page_scale_factor());
[email protected]adeda572014-01-31 00:49:472927 // If clamping the inner viewport scroll offset causes a change, it should
2928 // be accounted for from the intended move.
2929 move -= InnerViewportScrollLayer()->ClampScrollToMaxScrollOffset();
[email protected]c1bb5af2013-03-13 19:06:272930
[email protected]adeda572014-01-31 00:49:472931 // We manually manage the bubbling behaviour here as it is different to that
2932 // implemented in LayerTreeHostImpl::ScrollBy(). Specifically:
2933 // 1) we want to explicit limit the bubbling to the outer/inner viewports,
2934 // 2) we don't want the directional limitations on the unused parts that
2935 // ScrollBy() implements, and
2936 // 3) pinching should not engage the top controls manager.
2937 gfx::Vector2dF unused = OuterViewportScrollLayer()
2938 ? OuterViewportScrollLayer()->ScrollBy(move)
2939 : move;
2940
2941 if (!unused.IsZero()) {
2942 InnerViewportScrollLayer()->ScrollBy(unused);
2943 InnerViewportScrollLayer()->ClampScrollToMaxScrollOffset();
2944 }
[email protected]c1bb5af2013-03-13 19:06:272945
[email protected]ec2322e2014-05-15 16:32:002946 active_tree_->SetRootLayerScrollOffsetDelegate(
2947 root_layer_scroll_offset_delegate_);
2948
[email protected]c1bb5af2013-03-13 19:06:272949 client_->SetNeedsCommitOnImplThread();
[email protected]4e4136d2013-11-29 02:22:442950 SetNeedsRedraw();
[email protected]c1bb5af2013-03-13 19:06:272951 client_->RenewTreePriority();
[email protected]d3afa112012-12-08 06:24:282952}
2953
[email protected]c1bb5af2013-03-13 19:06:272954void LayerTreeHostImpl::PinchGestureEnd() {
2955 pinch_gesture_active_ = false;
[email protected]2fa342b82013-09-24 03:19:132956 if (pinch_gesture_end_should_clear_scrolling_layer_) {
2957 pinch_gesture_end_should_clear_scrolling_layer_ = false;
2958 ClearCurrentlyScrollingLayer();
2959 }
[email protected]a9bda5e2013-10-25 18:43:372960 if (top_controls_manager_)
2961 top_controls_manager_->PinchEnd();
[email protected]c1bb5af2013-03-13 19:06:272962 client_->SetNeedsCommitOnImplThread();
danakj0eabca92014-10-28 19:48:202963 // When a pinch ends, we may be displaying content cached at incorrect scales,
2964 // so updating draw properties and drawing will ensure we are using the right
2965 // scales that we want when we're not inside a pinch.
2966 active_tree_->set_needs_update_draw_properties();
2967 SetNeedsRedraw();
[email protected]94f206c12012-08-25 00:09:142968}
2969
[email protected]c1bb5af2013-03-13 19:06:272970static void CollectScrollDeltas(ScrollAndScaleSet* scroll_info,
2971 LayerImpl* layer_impl) {
bokane7f7aa722014-10-29 15:43:542972 if (!layer_impl)
2973 return;
[email protected]94f206c12012-08-25 00:09:142974
[email protected]c1bb5af2013-03-13 19:06:272975 gfx::Vector2d scroll_delta =
[email protected]1960a712013-04-30 17:06:472976 gfx::ToFlooredVector2d(layer_impl->ScrollDelta());
[email protected]c1bb5af2013-03-13 19:06:272977 if (!scroll_delta.IsZero()) {
2978 LayerTreeHostCommon::ScrollUpdateInfo scroll;
[email protected]6ba914122013-03-22 16:26:392979 scroll.layer_id = layer_impl->id();
2980 scroll.scroll_delta = scroll_delta;
[email protected]c1bb5af2013-03-13 19:06:272981 scroll_info->scrolls.push_back(scroll);
2982 layer_impl->SetSentScrollDelta(scroll_delta);
2983 }
[email protected]94f206c12012-08-25 00:09:142984
[email protected]c1bb5af2013-03-13 19:06:272985 for (size_t i = 0; i < layer_impl->children().size(); ++i)
2986 CollectScrollDeltas(scroll_info, layer_impl->children()[i]);
[email protected]94f206c12012-08-25 00:09:142987}
2988
[email protected]c1bb5af2013-03-13 19:06:272989scoped_ptr<ScrollAndScaleSet> LayerTreeHostImpl::ProcessScrollDeltas() {
2990 scoped_ptr<ScrollAndScaleSet> scroll_info(new ScrollAndScaleSet());
[email protected]362f1e8b2013-01-21 16:54:302991
bokane7f7aa722014-10-29 15:43:542992 CollectScrollDeltas(scroll_info.get(), active_tree_->root_layer());
2993 scroll_info->page_scale_delta = active_tree_->page_scale_delta();
2994 active_tree_->set_sent_page_scale_delta(scroll_info->page_scale_delta);
2995 scroll_info->swap_promises.swap(swap_promises_for_main_thread_scroll_update_);
2996 scroll_info->top_controls_delta = active_tree()->top_controls_delta();
2997 active_tree_->set_sent_top_controls_delta(scroll_info->top_controls_delta);
[email protected]362f1e8b2013-01-21 16:54:302998
[email protected]c1bb5af2013-03-13 19:06:272999 return scroll_info.Pass();
[email protected]362f1e8b2013-01-21 16:54:303000}
3001
[email protected]c1bb5af2013-03-13 19:06:273002void LayerTreeHostImpl::SetFullRootLayerDamage() {
[email protected]54af03522013-09-05 00:43:283003 SetViewportDamage(gfx::Rect(DrawViewportSize()));
[email protected]829ad972013-01-28 23:36:103004}
3005
bokan59379b092014-09-29 13:47:213006void LayerTreeHostImpl::ScrollViewportInnerFirst(gfx::Vector2dF scroll_delta) {
3007 DCHECK(InnerViewportScrollLayer());
3008 LayerImpl* scroll_layer = InnerViewportScrollLayer();
3009
3010 gfx::Vector2dF unused_delta = scroll_layer->ScrollBy(scroll_delta);
3011 if (!unused_delta.IsZero() && OuterViewportScrollLayer())
3012 OuterViewportScrollLayer()->ScrollBy(unused_delta);
3013}
3014
[email protected]adeda572014-01-31 00:49:473015void LayerTreeHostImpl::ScrollViewportBy(gfx::Vector2dF scroll_delta) {
3016 DCHECK(InnerViewportScrollLayer());
3017 LayerImpl* scroll_layer = OuterViewportScrollLayer()
3018 ? OuterViewportScrollLayer()
3019 : InnerViewportScrollLayer();
3020
3021 gfx::Vector2dF unused_delta = scroll_layer->ScrollBy(scroll_delta);
3022
3023 if (!unused_delta.IsZero() && (scroll_layer == OuterViewportScrollLayer()))
3024 InnerViewportScrollLayer()->ScrollBy(unused_delta);
3025}
3026
[email protected]27152642014-03-11 20:42:003027void LayerTreeHostImpl::AnimatePageScale(base::TimeTicks monotonic_time) {
[email protected]adeda572014-01-31 00:49:473028 if (!page_scale_animation_)
[email protected]c1bb5af2013-03-13 19:06:273029 return;
3030
miletusf57925d2014-10-01 19:38:133031 gfx::ScrollOffset scroll_total = active_tree_->TotalScrollOffset();
[email protected]c1bb5af2013-03-13 19:06:273032
[email protected]34e1b512013-09-26 17:32:333033 if (!page_scale_animation_->IsAnimationStarted())
[email protected]ac22516a2014-05-15 17:31:363034 page_scale_animation_->StartAnimation(monotonic_time);
[email protected]34e1b512013-09-26 17:32:333035
[email protected]ac22516a2014-05-15 17:31:363036 active_tree_->SetPageScaleDelta(
3037 page_scale_animation_->PageScaleFactorAtTime(monotonic_time) /
3038 active_tree_->page_scale_factor());
miletusf57925d2014-10-01 19:38:133039 gfx::ScrollOffset next_scroll = gfx::ScrollOffset(
3040 page_scale_animation_->ScrollOffsetAtTime(monotonic_time));
[email protected]c1bb5af2013-03-13 19:06:273041
miletusf57925d2014-10-01 19:38:133042 ScrollViewportInnerFirst(next_scroll.DeltaFrom(scroll_total));
[email protected]4e4136d2013-11-29 02:22:443043 SetNeedsRedraw();
[email protected]c1bb5af2013-03-13 19:06:273044
[email protected]ac22516a2014-05-15 17:31:363045 if (page_scale_animation_->IsAnimationCompleteAtTime(monotonic_time)) {
danakjf446a072014-09-27 21:55:483046 page_scale_animation_ = nullptr;
[email protected]c1bb5af2013-03-13 19:06:273047 client_->SetNeedsCommitOnImplThread();
3048 client_->RenewTreePriority();
[email protected]43b8f982014-04-30 21:24:333049 } else {
3050 SetNeedsAnimate();
[email protected]c1bb5af2013-03-13 19:06:273051 }
[email protected]829ad972013-01-28 23:36:103052}
3053
[email protected]ffb2720f2013-03-15 19:18:373054void LayerTreeHostImpl::AnimateTopControls(base::TimeTicks time) {
[email protected]68d3fc12014-02-18 16:31:083055 if (!top_controls_manager_ || !top_controls_manager_->animation())
[email protected]ffb2720f2013-03-15 19:18:373056 return;
[email protected]ac3446d2014-08-13 08:51:203057
[email protected]ffb2720f2013-03-15 19:18:373058 gfx::Vector2dF scroll = top_controls_manager_->Animate(time);
[email protected]ac3446d2014-08-13 08:51:203059
3060 if (top_controls_manager_->animation())
3061 SetNeedsAnimate();
3062
[email protected]adeda572014-01-31 00:49:473063 if (active_tree_->TotalScrollOffset().y() == 0.f)
[email protected]5ef82622013-05-01 16:26:173064 return;
[email protected]ac3446d2014-08-13 08:51:203065
3066 if (scroll.IsZero())
3067 return;
3068
3069 ScrollViewportBy(gfx::ScaleVector2d(
3070 scroll, 1.f / active_tree_->total_page_scale_factor()));
3071 SetNeedsRedraw();
3072 client_->SetNeedsCommitOnImplThread();
3073 client_->RenewTreePriority();
[email protected]ffb2720f2013-03-15 19:18:373074}
3075
[email protected]27152642014-03-11 20:42:003076void LayerTreeHostImpl::AnimateLayers(base::TimeTicks monotonic_time) {
[email protected]8e0176d2013-03-21 03:14:523077 if (!settings_.accelerated_animation_enabled ||
[email protected]cd77bb62014-03-27 05:16:363078 !needs_animate_layers() ||
[email protected]c1bb5af2013-03-13 19:06:273079 !active_tree_->root_layer())
3080 return;
3081
3082 TRACE_EVENT0("cc", "LayerTreeHostImpl::AnimateLayers");
[email protected]c1bb5af2013-03-13 19:06:273083 AnimationRegistrar::AnimationControllerMap copy =
3084 animation_registrar_->active_animation_controllers();
3085 for (AnimationRegistrar::AnimationControllerMap::iterator iter = copy.begin();
3086 iter != copy.end();
3087 ++iter)
[email protected]ac22516a2014-05-15 17:31:363088 (*iter).second->Animate(monotonic_time);
[email protected]c1bb5af2013-03-13 19:06:273089
[email protected]43b8f982014-04-30 21:24:333090 SetNeedsAnimate();
[email protected]131a0c22013-02-12 18:31:083091}
3092
[email protected]3d9f7432013-04-06 00:35:183093void LayerTreeHostImpl::UpdateAnimationState(bool start_ready_animations) {
[email protected]8e0176d2013-03-21 03:14:523094 if (!settings_.accelerated_animation_enabled ||
[email protected]cd77bb62014-03-27 05:16:363095 !needs_animate_layers() ||
[email protected]c1bb5af2013-03-13 19:06:273096 !active_tree_->root_layer())
3097 return;
3098
3099 TRACE_EVENT0("cc", "LayerTreeHostImpl::UpdateAnimationState");
3100 scoped_ptr<AnimationEventsVector> events =
3101 make_scoped_ptr(new AnimationEventsVector);
3102 AnimationRegistrar::AnimationControllerMap copy =
3103 animation_registrar_->active_animation_controllers();
3104 for (AnimationRegistrar::AnimationControllerMap::iterator iter = copy.begin();
3105 iter != copy.end();
3106 ++iter)
[email protected]3d9f7432013-04-06 00:35:183107 (*iter).second->UpdateState(start_ready_animations, events.get());
[email protected]c1bb5af2013-03-13 19:06:273108
3109 if (!events->empty()) {
[email protected]85b57502014-03-11 15:37:483110 client_->PostAnimationEventsToMainThreadOnImplThread(events.Pass());
[email protected]c1bb5af2013-03-13 19:06:273111 }
[email protected]43b8f982014-04-30 21:24:333112
3113 SetNeedsAnimate();
[email protected]131a0c22013-02-12 18:31:083114}
3115
[email protected]b33348f2014-04-30 18:17:343116void LayerTreeHostImpl::ActivateAnimations() {
3117 if (!settings_.accelerated_animation_enabled || !needs_animate_layers() ||
3118 !active_tree_->root_layer())
3119 return;
3120
3121 TRACE_EVENT0("cc", "LayerTreeHostImpl::ActivateAnimations");
3122 AnimationRegistrar::AnimationControllerMap copy =
3123 animation_registrar_->active_animation_controllers();
3124 for (AnimationRegistrar::AnimationControllerMap::iterator iter = copy.begin();
3125 iter != copy.end();
3126 ++iter)
3127 (*iter).second->ActivateAnimations();
[email protected]b33348f2014-04-30 18:17:343128
mithro719bf6792014-11-10 15:36:473129 SetNeedsAnimate();
[email protected]c1bb5af2013-03-13 19:06:273130}
3131
[email protected]c1bb5af2013-03-13 19:06:273132std::string LayerTreeHostImpl::LayerTreeAsJson() const {
3133 std::string str;
3134 if (active_tree_->root_layer()) {
3135 scoped_ptr<base::Value> json(active_tree_->root_layer()->LayerTreeAsJson());
3136 base::JSONWriter::WriteWithOptions(
3137 json.get(), base::JSONWriter::OPTIONS_PRETTY_PRINT, &str);
3138 }
3139 return str;
3140}
3141
[email protected]c1bb5af2013-03-13 19:06:273142int LayerTreeHostImpl::SourceAnimationFrameNumber() const {
[email protected]9e3594522013-03-18 00:57:363143 return fps_counter_->current_frame_number();
[email protected]c1bb5af2013-03-13 19:06:273144}
3145
[email protected]c1bb5af2013-03-13 19:06:273146void LayerTreeHostImpl::AnimateScrollbars(base::TimeTicks time) {
3147 AnimateScrollbarsRecursive(active_tree_->root_layer(), time);
3148}
3149
3150void LayerTreeHostImpl::AnimateScrollbarsRecursive(LayerImpl* layer,
3151 base::TimeTicks time) {
3152 if (!layer)
3153 return;
3154
3155 ScrollbarAnimationController* scrollbar_controller =
3156 layer->scrollbar_animation_controller();
[email protected]930ff43b2014-05-02 05:24:003157 if (scrollbar_controller)
3158 scrollbar_controller->Animate(time);
[email protected]c1bb5af2013-03-13 19:06:273159
3160 for (size_t i = 0; i < layer->children().size(); ++i)
3161 AnimateScrollbarsRecursive(layer->children()[i], time);
3162}
3163
[email protected]930ff43b2014-05-02 05:24:003164void LayerTreeHostImpl::PostDelayedScrollbarFade(
3165 const base::Closure& start_fade,
3166 base::TimeDelta delay) {
3167 client_->PostDelayedScrollbarFadeOnImplThread(start_fade, delay);
[email protected]0fc818e2013-03-18 06:45:203168}
3169
[email protected]930ff43b2014-05-02 05:24:003170void LayerTreeHostImpl::SetNeedsScrollbarAnimationFrame() {
3171 TRACE_EVENT_INSTANT0(
3172 "cc",
3173 "LayerTreeHostImpl::SetNeedsRedraw due to scrollbar fade",
3174 TRACE_EVENT_SCOPE_THREAD);
3175 SetNeedsAnimate();
[email protected]0fc818e2013-03-18 06:45:203176}
3177
[email protected]c1bb5af2013-03-13 19:06:273178void LayerTreeHostImpl::SetTreePriority(TreePriority priority) {
3179 if (!tile_manager_)
3180 return;
3181
[email protected]1bcced22013-09-24 13:51:193182 if (global_tile_state_.tree_priority == priority)
[email protected]c1bb5af2013-03-13 19:06:273183 return;
[email protected]1bcced22013-09-24 13:51:193184 global_tile_state_.tree_priority = priority;
[email protected]c48536a52013-09-14 00:02:083185 DidModifyTilePriorities();
[email protected]c1bb5af2013-03-13 19:06:273186}
3187
vmpstr56ace232014-10-09 20:16:283188TreePriority LayerTreeHostImpl::GetTreePriority() const {
3189 return global_tile_state_.tree_priority;
3190}
3191
[email protected]04c5900d2014-08-18 13:38:363192void LayerTreeHostImpl::UpdateCurrentBeginFrameArgs(
3193 const BeginFrameArgs& args) {
3194 DCHECK(!current_begin_frame_args_.IsValid());
3195 current_begin_frame_args_ = args;
3196 // TODO(skyostil): Stop overriding the frame time once the usage of frame
3197 // timing is unified.
3198 current_begin_frame_args_.frame_time = gfx::FrameTime::Now();
[email protected]1dc06162014-03-26 22:54:453199}
3200
[email protected]04c5900d2014-08-18 13:38:363201void LayerTreeHostImpl::ResetCurrentBeginFrameArgsForNextFrame() {
3202 current_begin_frame_args_ = BeginFrameArgs();
[email protected]c1bb5af2013-03-13 19:06:273203}
3204
[email protected]04c5900d2014-08-18 13:38:363205BeginFrameArgs LayerTreeHostImpl::CurrentBeginFrameArgs() const {
[email protected]1dc06162014-03-26 22:54:453206 // Try to use the current frame time to keep animations non-jittery. But if
3207 // we're not in a frame (because this is during an input event or a delayed
3208 // task), fall back to physical time. This should still be monotonic.
[email protected]04c5900d2014-08-18 13:38:363209 if (current_begin_frame_args_.IsValid())
3210 return current_begin_frame_args_;
3211 return BeginFrameArgs::Create(gfx::FrameTime::Now(),
3212 base::TimeTicks(),
3213 BeginFrameArgs::DefaultInterval());
[email protected]21c9dee72013-06-15 01:20:053214}
3215
[email protected]d12aa932014-08-01 13:10:383216scoped_refptr<base::debug::ConvertableToTraceFormat>
3217LayerTreeHostImpl::AsValue() const {
3218 return AsValueWithFrame(NULL);
[email protected]f6742f52013-05-08 23:52:223219}
3220
[email protected]d12aa932014-08-01 13:10:383221scoped_refptr<base::debug::ConvertableToTraceFormat>
3222LayerTreeHostImpl::AsValueWithFrame(FrameData* frame) const {
3223 scoped_refptr<base::debug::TracedValue> state =
3224 new base::debug::TracedValue();
3225 AsValueWithFrameInto(frame, state.get());
3226 return state;
3227}
3228
simonhonga7e3ac42014-11-11 20:50:223229void LayerTreeHostImpl::AsValueInto(base::debug::TracedValue* value) const {
3230 return AsValueWithFrameInto(NULL, value);
3231}
3232
[email protected]d12aa932014-08-01 13:10:383233void LayerTreeHostImpl::AsValueWithFrameInto(
3234 FrameData* frame,
3235 base::debug::TracedValue* state) const {
3236 if (this->pending_tree_) {
3237 state->BeginDictionary("activation_state");
3238 ActivationStateAsValueInto(state);
3239 state->EndDictionary();
3240 }
3241 state->BeginDictionary("device_viewport_size");
3242 MathUtil::AddToTracedValue(device_viewport_size_, state);
3243 state->EndDictionary();
[email protected]0eded9ea2014-08-14 03:39:203244
vmpstrd7de03c2014-08-27 18:11:013245 std::set<const Tile*> tiles;
3246 active_tree_->GetAllTilesForTracing(&tiles);
3247 if (pending_tree_)
3248 pending_tree_->GetAllTilesForTracing(&tiles);
3249
3250 state->BeginArray("active_tiles");
3251 for (std::set<const Tile*>::const_iterator it = tiles.begin();
3252 it != tiles.end();
3253 ++it) {
3254 const Tile* tile = *it;
3255
3256 state->BeginDictionary();
3257 tile->AsValueInto(state);
3258 state->EndDictionary();
3259 }
3260 state->EndArray();
3261
3262 if (tile_manager_) {
[email protected]0eded9ea2014-08-14 03:39:203263 state->BeginDictionary("tile_manager_basic_state");
3264 tile_manager_->BasicStateAsValueInto(state);
3265 state->EndDictionary();
[email protected]d12aa932014-08-01 13:10:383266 }
3267 state->BeginDictionary("active_tree");
3268 active_tree_->AsValueInto(state);
3269 state->EndDictionary();
3270 if (pending_tree_) {
3271 state->BeginDictionary("pending_tree");
3272 pending_tree_->AsValueInto(state);
3273 state->EndDictionary();
3274 }
3275 if (frame) {
3276 state->BeginDictionary("frame");
3277 frame->AsValueInto(state);
3278 state->EndDictionary();
3279 }
3280}
3281
3282scoped_refptr<base::debug::ConvertableToTraceFormat>
3283LayerTreeHostImpl::ActivationStateAsValue() const {
3284 scoped_refptr<base::debug::TracedValue> state =
3285 new base::debug::TracedValue();
3286 ActivationStateAsValueInto(state.get());
3287 return state;
3288}
3289
3290void LayerTreeHostImpl::ActivationStateAsValueInto(
3291 base::debug::TracedValue* state) const {
3292 TracedValue::SetIDRef(this, state, "lthi");
3293 if (tile_manager_) {
3294 state->BeginDictionary("tile_manager");
3295 tile_manager_->BasicStateAsValueInto(state);
3296 state->EndDictionary();
3297 }
[email protected]131a0c22013-02-12 18:31:083298}
3299
[email protected]6e7fdeb2013-07-09 14:28:383300void LayerTreeHostImpl::SetDebugState(
3301 const LayerTreeDebugState& new_debug_state) {
3302 if (LayerTreeDebugState::Equal(debug_state_, new_debug_state))
3303 return;
3304 if (debug_state_.continuous_painting != new_debug_state.continuous_painting)
[email protected]c1bb5af2013-03-13 19:06:273305 paint_time_counter_->ClearHistory();
[email protected]652cf132013-02-15 21:53:243306
[email protected]6e7fdeb2013-07-09 14:28:383307 debug_state_ = new_debug_state;
[email protected]5547b4fe2013-10-01 23:14:123308 UpdateTileManagerMemoryPolicy(ActualManagedMemoryPolicy());
[email protected]6e7fdeb2013-07-09 14:28:383309 SetFullRootLayerDamage();
[email protected]d0d12192013-02-08 19:02:023310}
3311
[email protected]741fba422013-09-20 03:34:143312void LayerTreeHostImpl::CreateUIResource(UIResourceId uid,
3313 const UIResourceBitmap& bitmap) {
[email protected]c9280762013-08-01 06:28:573314 DCHECK_GT(uid, 0);
[email protected]c9280762013-08-01 06:28:573315
[email protected]efa48412013-09-05 15:30:163316 GLint wrap_mode = 0;
[email protected]741fba422013-09-20 03:34:143317 switch (bitmap.GetWrapMode()) {
[email protected]efa48412013-09-05 15:30:163318 case UIResourceBitmap::CLAMP_TO_EDGE:
3319 wrap_mode = GL_CLAMP_TO_EDGE;
3320 break;
3321 case UIResourceBitmap::REPEAT:
3322 wrap_mode = GL_REPEAT;
3323 break;
3324 }
3325
[email protected]c9280762013-08-01 06:28:573326 // Allow for multiple creation requests with the same UIResourceId. The
3327 // previous resource is simply deleted.
3328 ResourceProvider::ResourceId id = ResourceIdForUIResource(uid);
3329 if (id)
3330 DeleteUIResource(uid);
[email protected]6be50ba82013-11-08 12:04:123331
3332 ResourceFormat format = resource_provider_->best_texture_format();
[email protected]9b05baa2014-08-14 00:43:313333 switch (bitmap.GetFormat()) {
3334 case UIResourceBitmap::RGBA8:
3335 break;
3336 case UIResourceBitmap::ALPHA_8:
3337 format = ALPHA_8;
3338 break;
3339 case UIResourceBitmap::ETC1:
3340 format = ETC1;
3341 break;
[email protected]cffc3282014-08-15 23:38:243342 }
[email protected]655041f2014-08-21 22:58:583343 id =
3344 resource_provider_->CreateResource(bitmap.GetSize(),
3345 wrap_mode,
3346 ResourceProvider::TextureHintImmutable,
3347 format);
[email protected]c9280762013-08-01 06:28:573348
[email protected]efbdb3a2013-10-04 00:35:133349 UIResourceData data;
3350 data.resource_id = id;
3351 data.size = bitmap.GetSize();
[email protected]709c9542013-10-26 01:43:513352 data.opaque = bitmap.GetOpaque();
[email protected]efbdb3a2013-10-04 00:35:133353
3354 ui_resource_map_[uid] = data;
[email protected]f6668c892013-09-26 10:05:033355
3356 AutoLockUIResourceBitmap bitmap_lock(bitmap);
[email protected]c9280762013-08-01 06:28:573357 resource_provider_->SetPixels(id,
[email protected]f6668c892013-09-26 10:05:033358 bitmap_lock.GetPixels(),
[email protected]741fba422013-09-20 03:34:143359 gfx::Rect(bitmap.GetSize()),
3360 gfx::Rect(bitmap.GetSize()),
[email protected]c9280762013-08-01 06:28:573361 gfx::Vector2d(0, 0));
[email protected]127bdc1a2013-09-11 01:44:483362 MarkUIResourceNotEvicted(uid);
[email protected]c9280762013-08-01 06:28:573363}
3364
3365void LayerTreeHostImpl::DeleteUIResource(UIResourceId uid) {
3366 ResourceProvider::ResourceId id = ResourceIdForUIResource(uid);
3367 if (id) {
3368 resource_provider_->DeleteResource(id);
3369 ui_resource_map_.erase(uid);
3370 }
[email protected]127bdc1a2013-09-11 01:44:483371 MarkUIResourceNotEvicted(uid);
[email protected]c9280762013-08-01 06:28:573372}
3373
[email protected]127bdc1a2013-09-11 01:44:483374void LayerTreeHostImpl::EvictAllUIResources() {
3375 if (ui_resource_map_.empty())
3376 return;
3377
[email protected]5f4dc4f2013-09-05 14:58:213378 for (UIResourceMap::const_iterator iter = ui_resource_map_.begin();
3379 iter != ui_resource_map_.end();
3380 ++iter) {
[email protected]127bdc1a2013-09-11 01:44:483381 evicted_ui_resources_.insert(iter->first);
[email protected]efbdb3a2013-10-04 00:35:133382 resource_provider_->DeleteResource(iter->second.resource_id);
[email protected]5f4dc4f2013-09-05 14:58:213383 }
3384 ui_resource_map_.clear();
[email protected]127bdc1a2013-09-11 01:44:483385
3386 client_->SetNeedsCommitOnImplThread();
3387 client_->OnCanDrawStateChanged(CanDraw());
3388 client_->RenewTreePriority();
[email protected]5f4dc4f2013-09-05 14:58:213389}
3390
[email protected]c9280762013-08-01 06:28:573391ResourceProvider::ResourceId LayerTreeHostImpl::ResourceIdForUIResource(
3392 UIResourceId uid) const {
3393 UIResourceMap::const_iterator iter = ui_resource_map_.find(uid);
3394 if (iter != ui_resource_map_.end())
[email protected]efbdb3a2013-10-04 00:35:133395 return iter->second.resource_id;
[email protected]c9280762013-08-01 06:28:573396 return 0;
3397}
3398
[email protected]709c9542013-10-26 01:43:513399bool LayerTreeHostImpl::IsUIResourceOpaque(UIResourceId uid) const {
3400 UIResourceMap::const_iterator iter = ui_resource_map_.find(uid);
3401 DCHECK(iter != ui_resource_map_.end());
3402 return iter->second.opaque;
3403}
3404
[email protected]127bdc1a2013-09-11 01:44:483405bool LayerTreeHostImpl::EvictedUIResourcesExist() const {
3406 return !evicted_ui_resources_.empty();
3407}
3408
3409void LayerTreeHostImpl::MarkUIResourceNotEvicted(UIResourceId uid) {
3410 std::set<UIResourceId>::iterator found_in_evicted =
3411 evicted_ui_resources_.find(uid);
3412 if (found_in_evicted == evicted_ui_resources_.end())
3413 return;
3414 evicted_ui_resources_.erase(found_in_evicted);
3415 if (evicted_ui_resources_.empty())
3416 client_->OnCanDrawStateChanged(CanDraw());
3417}
3418
[email protected]5e5648a2013-11-18 00:39:333419void LayerTreeHostImpl::ScheduleMicroBenchmark(
3420 scoped_ptr<MicroBenchmarkImpl> benchmark) {
3421 micro_benchmark_controller_.ScheduleRun(benchmark.Pass());
3422}
3423
[email protected]6be422b2013-12-08 06:47:313424void LayerTreeHostImpl::InsertSwapPromiseMonitor(SwapPromiseMonitor* monitor) {
3425 swap_promise_monitor_.insert(monitor);
3426}
3427
3428void LayerTreeHostImpl::RemoveSwapPromiseMonitor(SwapPromiseMonitor* monitor) {
3429 swap_promise_monitor_.erase(monitor);
3430}
3431
3432void LayerTreeHostImpl::NotifySwapPromiseMonitorsOfSetNeedsRedraw() {
3433 std::set<SwapPromiseMonitor*>::iterator it = swap_promise_monitor_.begin();
3434 for (; it != swap_promise_monitor_.end(); it++)
3435 (*it)->OnSetNeedsRedrawOnImpl();
3436}
3437
[email protected]dab0a422014-08-13 16:09:463438void LayerTreeHostImpl::NotifySwapPromiseMonitorsOfForwardingToMainThread() {
3439 std::set<SwapPromiseMonitor*>::iterator it = swap_promise_monitor_.begin();
3440 for (; it != swap_promise_monitor_.end(); it++)
3441 (*it)->OnForwardScrollUpdateToMainThreadOnImpl();
3442}
3443
[email protected]8aa39ecb2014-06-12 14:19:143444void LayerTreeHostImpl::RegisterPictureLayerImpl(PictureLayerImpl* layer) {
3445 DCHECK(std::find(picture_layers_.begin(), picture_layers_.end(), layer) ==
3446 picture_layers_.end());
3447 picture_layers_.push_back(layer);
3448}
3449
3450void LayerTreeHostImpl::UnregisterPictureLayerImpl(PictureLayerImpl* layer) {
3451 std::vector<PictureLayerImpl*>::iterator it =
3452 std::find(picture_layers_.begin(), picture_layers_.end(), layer);
3453 DCHECK(it != picture_layers_.end());
3454 picture_layers_.erase(it);
3455}
3456
[email protected]d3143c732012-10-05 19:17:593457} // namespace cc