1 // Copyright 2011 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "cc/trees/layer_tree_host.h"
6
7 #include <stddef.h>
8 #include <stdint.h>
9
10 #include <algorithm>
11 #include <memory>
12 #include <string>
13 #include <unordered_map>
14
15 #include "base/atomic_sequence_num.h"
16 #include "base/auto_reset.h"
17 #include "base/bind.h"
18 #include "base/command_line.h"
19 #include "base/containers/adapters.h"
20 #include "base/location.h"
21 #include "base/memory/ptr_util.h"
22 #include "base/metrics/histogram_functions.h"
23 #include "base/metrics/histogram_macros.h"
24 #include "base/numerics/safe_math.h"
25 #include "base/single_thread_task_runner.h"
26 #include "base/stl_util.h"
27 #include "base/strings/string_number_conversions.h"
28 #include "base/strings/stringprintf.h"
29 #include "base/threading/thread_task_runner_handle.h"
30 #include "base/timer/elapsed_timer.h"
31 #include "base/trace_event/trace_event.h"
32 #include "base/trace_event/traced_value.h"
33 #include "build/build_config.h"
34 #include "cc/base/devtools_instrumentation.h"
35 #include "cc/base/histograms.h"
36 #include "cc/base/math_util.h"
37 #include "cc/debug/rendering_stats_instrumentation.h"
38 #include "cc/input/layer_selection_bound.h"
39 #include "cc/input/overscroll_behavior.h"
40 #include "cc/input/page_scale_animation.h"
41 #include "cc/layers/heads_up_display_layer.h"
42 #include "cc/layers/heads_up_display_layer_impl.h"
43 #include "cc/layers/layer.h"
44 #include "cc/layers/painted_scrollbar_layer.h"
45 #include "cc/paint/paint_worklet_layer_painter.h"
46 #include "cc/resources/ui_resource_manager.h"
47 #include "cc/trees/clip_node.h"
48 #include "cc/trees/draw_property_utils.h"
49 #include "cc/trees/effect_node.h"
50 #include "cc/trees/layer_tree_host_client.h"
51 #include "cc/trees/layer_tree_host_impl.h"
52 #include "cc/trees/layer_tree_impl.h"
53 #include "cc/trees/mutator_host.h"
54 #include "cc/trees/property_tree_builder.h"
55 #include "cc/trees/proxy_main.h"
56 #include "cc/trees/render_frame_metadata_observer.h"
57 #include "cc/trees/scroll_and_scale_set.h"
58 #include "cc/trees/scroll_node.h"
59 #include "cc/trees/single_thread_proxy.h"
60 #include "cc/trees/swap_promise_manager.h"
61 #include "cc/trees/transform_node.h"
62 #include "cc/trees/tree_synchronizer.h"
63 #include "cc/trees/ukm_manager.h"
64 #include "services/metrics/public/cpp/ukm_recorder.h"
65 #include "services/tracing/public/cpp/perfetto/flow_event_utils.h"
66 #include "services/tracing/public/cpp/perfetto/macros.h"
67 #include "ui/gfx/geometry/size_conversions.h"
68 #include "ui/gfx/geometry/vector2d_conversions.h"
69 #include "ui/gfx/presentation_feedback.h"
70
71 namespace {
72 static base::AtomicSequenceNumber s_layer_tree_host_sequence_number;
73 static base::AtomicSequenceNumber s_image_decode_sequence_number;
74 } // namespace
75
76 namespace cc {
77 namespace {
78
AreEmbedTokensEqual(const viz::LocalSurfaceId & lsi1,const viz::LocalSurfaceId & lsi2)79 bool AreEmbedTokensEqual(const viz::LocalSurfaceId& lsi1,
80 const viz::LocalSurfaceId& lsi2) {
81 return lsi1.embed_token() == lsi2.embed_token();
82 }
83
AreParentSequencesEqual(const viz::LocalSurfaceId & lsi1,const viz::LocalSurfaceId & lsi2)84 bool AreParentSequencesEqual(const viz::LocalSurfaceId& lsi1,
85 const viz::LocalSurfaceId& lsi2) {
86 return lsi1.parent_sequence_number() == lsi2.parent_sequence_number();
87 }
88
89 } // namespace
90
91 LayerTreeHost::InitParams::InitParams() = default;
92 LayerTreeHost::InitParams::~InitParams() = default;
93 LayerTreeHost::InitParams::InitParams(InitParams&&) = default;
94 LayerTreeHost::InitParams& LayerTreeHost::InitParams::operator=(InitParams&&) =
95 default;
96
CreateThreaded(scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner,InitParams params)97 std::unique_ptr<LayerTreeHost> LayerTreeHost::CreateThreaded(
98 scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner,
99 InitParams params) {
100 DCHECK(params.settings);
101 scoped_refptr<base::SingleThreadTaskRunner> main_task_runner =
102 params.main_task_runner;
103 DCHECK(main_task_runner);
104 DCHECK(impl_task_runner);
105 auto layer_tree_host = base::WrapUnique(
106 new LayerTreeHost(std::move(params), CompositorMode::THREADED));
107 layer_tree_host->InitializeThreaded(std::move(main_task_runner),
108 std::move(impl_task_runner));
109 return layer_tree_host;
110 }
111
CreateSingleThreaded(LayerTreeHostSingleThreadClient * single_thread_client,InitParams params)112 std::unique_ptr<LayerTreeHost> LayerTreeHost::CreateSingleThreaded(
113 LayerTreeHostSingleThreadClient* single_thread_client,
114 InitParams params) {
115 DCHECK(params.settings);
116 scoped_refptr<base::SingleThreadTaskRunner> main_task_runner =
117 params.main_task_runner;
118 auto layer_tree_host = base::WrapUnique(
119 new LayerTreeHost(std::move(params), CompositorMode::SINGLE_THREADED));
120 layer_tree_host->InitializeSingleThreaded(single_thread_client,
121 std::move(main_task_runner));
122 return layer_tree_host;
123 }
124
LayerTreeHost(InitParams params,CompositorMode mode)125 LayerTreeHost::LayerTreeHost(InitParams params, CompositorMode mode)
126 : micro_benchmark_controller_(this),
127 image_worker_task_runner_(std::move(params.image_worker_task_runner)),
128 ukm_recorder_factory_(std::move(params.ukm_recorder_factory)),
129 compositor_mode_(mode),
130 ui_resource_manager_(std::make_unique<UIResourceManager>()),
131 client_(params.client),
132 scheduling_client_(params.scheduling_client),
133 rendering_stats_instrumentation_(RenderingStatsInstrumentation::Create()),
134 settings_(*params.settings),
135 debug_state_(settings_.initial_debug_state),
136 id_(s_layer_tree_host_sequence_number.GetNext() + 1),
137 task_graph_runner_(params.task_graph_runner),
138 event_listener_properties_(),
139 mutator_host_(params.mutator_host) {
140 DCHECK(task_graph_runner_);
141 DCHECK(!settings_.enable_checker_imaging || image_worker_task_runner_);
142
143 mutator_host_->SetMutatorHostClient(this);
144
145 rendering_stats_instrumentation_->set_record_rendering_stats(
146 debug_state_.RecordRenderingStats());
147 }
148
InitializeThreaded(scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner)149 void LayerTreeHost::InitializeThreaded(
150 scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
151 scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner) {
152 task_runner_provider_ =
153 TaskRunnerProvider::Create(main_task_runner, impl_task_runner);
154 std::unique_ptr<ProxyMain> proxy_main =
155 std::make_unique<ProxyMain>(this, task_runner_provider_.get());
156 InitializeProxy(std::move(proxy_main));
157 }
158
InitializeSingleThreaded(LayerTreeHostSingleThreadClient * single_thread_client,scoped_refptr<base::SingleThreadTaskRunner> main_task_runner)159 void LayerTreeHost::InitializeSingleThreaded(
160 LayerTreeHostSingleThreadClient* single_thread_client,
161 scoped_refptr<base::SingleThreadTaskRunner> main_task_runner) {
162 task_runner_provider_ = TaskRunnerProvider::Create(main_task_runner, nullptr);
163 InitializeProxy(SingleThreadProxy::Create(this, single_thread_client,
164 task_runner_provider_.get()));
165 }
166
InitializeForTesting(std::unique_ptr<TaskRunnerProvider> task_runner_provider,std::unique_ptr<Proxy> proxy_for_testing)167 void LayerTreeHost::InitializeForTesting(
168 std::unique_ptr<TaskRunnerProvider> task_runner_provider,
169 std::unique_ptr<Proxy> proxy_for_testing) {
170 task_runner_provider_ = std::move(task_runner_provider);
171 InitializeProxy(std::move(proxy_for_testing));
172 }
173
SetTaskRunnerProviderForTesting(std::unique_ptr<TaskRunnerProvider> task_runner_provider)174 void LayerTreeHost::SetTaskRunnerProviderForTesting(
175 std::unique_ptr<TaskRunnerProvider> task_runner_provider) {
176 DCHECK(!task_runner_provider_);
177 task_runner_provider_ = std::move(task_runner_provider);
178 }
179
SetUIResourceManagerForTesting(std::unique_ptr<UIResourceManager> ui_resource_manager)180 void LayerTreeHost::SetUIResourceManagerForTesting(
181 std::unique_ptr<UIResourceManager> ui_resource_manager) {
182 ui_resource_manager_ = std::move(ui_resource_manager);
183 }
184
InitializeProxy(std::unique_ptr<Proxy> proxy)185 void LayerTreeHost::InitializeProxy(std::unique_ptr<Proxy> proxy) {
186 TRACE_EVENT0("cc", "LayerTreeHost::InitializeForReal");
187 DCHECK(task_runner_provider_);
188
189 proxy_ = std::move(proxy);
190 proxy_->Start();
191
192 UpdateDeferMainFrameUpdateInternal();
193
194 mutator_host_->SetSupportsScrollAnimations(proxy_->SupportsImplScrolling());
195 }
196
~LayerTreeHost()197 LayerTreeHost::~LayerTreeHost() {
198 // Track when we're inside a main frame to see if compositor is being
199 // destroyed midway which causes a crash. crbug.com/895883
200 CHECK(!inside_main_frame_);
201 TRACE_EVENT0("cc", "LayerTreeHost::~LayerTreeHost");
202
203 // Clear any references into the LayerTreeHost.
204 mutator_host_->SetMutatorHostClient(nullptr);
205
206 if (root_layer_) {
207 root_layer_->SetLayerTreeHost(nullptr);
208
209 // The root layer must be destroyed before the layer tree. We've made a
210 // contract with our animation controllers that the animation_host will
211 // outlive them, and we must make good.
212 root_layer_ = nullptr;
213 }
214
215 // Fail any pending image decodes.
216 for (auto& pair : pending_image_decodes_)
217 std::move(pair.second).Run(false);
218
219 if (proxy_) {
220 DCHECK(task_runner_provider_->IsMainThread());
221 proxy_->Stop();
222
223 // Proxy must be destroyed before the Task Runner Provider.
224 proxy_ = nullptr;
225 }
226 }
227
GetId() const228 int LayerTreeHost::GetId() const {
229 return id_;
230 }
231
SourceFrameNumber() const232 int LayerTreeHost::SourceFrameNumber() const {
233 return source_frame_number_;
234 }
235
GetUIResourceManager() const236 UIResourceManager* LayerTreeHost::GetUIResourceManager() const {
237 return ui_resource_manager_.get();
238 }
239
GetTaskRunnerProvider() const240 TaskRunnerProvider* LayerTreeHost::GetTaskRunnerProvider() const {
241 return task_runner_provider_.get();
242 }
243
GetSwapPromiseManager()244 SwapPromiseManager* LayerTreeHost::GetSwapPromiseManager() {
245 return &swap_promise_manager_;
246 }
247
248 std::unique_ptr<EventsMetricsManager::ScopedMonitor>
GetScopedEventMetricsMonitor(const EventMetrics & event_metrics)249 LayerTreeHost::GetScopedEventMetricsMonitor(const EventMetrics& event_metrics) {
250 return events_metrics_manager_.GetScopedMonitor(event_metrics);
251 }
252
ClearEventsMetrics()253 void LayerTreeHost::ClearEventsMetrics() {
254 // Take evens metrics and drop them.
255 events_metrics_manager_.TakeSavedEventsMetrics();
256 }
257
GetSettings() const258 const LayerTreeSettings& LayerTreeHost::GetSettings() const {
259 return settings_;
260 }
261
QueueSwapPromise(std::unique_ptr<SwapPromise> swap_promise)262 void LayerTreeHost::QueueSwapPromise(
263 std::unique_ptr<SwapPromise> swap_promise) {
264 swap_promise_manager_.QueueSwapPromise(std::move(swap_promise));
265
266 // Request a main frame if one is not already in progress. This might either
267 // A) request a commit ahead of time or B) request a commit which is not
268 // needed because there are not pending updates. If B) then the frame will
269 // be aborted early and the swap promises will be broken (see
270 // EarlyOut_NoUpdates).
271 if (!inside_main_frame_)
272 SetNeedsAnimate();
273 }
274
WillBeginMainFrame()275 void LayerTreeHost::WillBeginMainFrame() {
276 inside_main_frame_ = true;
277 devtools_instrumentation::WillBeginMainThreadFrame(GetId(),
278 SourceFrameNumber());
279 client_->WillBeginMainFrame();
280 }
281
DidBeginMainFrame()282 void LayerTreeHost::DidBeginMainFrame() {
283 inside_main_frame_ = false;
284 client_->DidBeginMainFrame();
285 }
286
BeginMainFrameNotExpectedSoon()287 void LayerTreeHost::BeginMainFrameNotExpectedSoon() {
288 client_->BeginMainFrameNotExpectedSoon();
289 }
290
BeginMainFrameNotExpectedUntil(base::TimeTicks time)291 void LayerTreeHost::BeginMainFrameNotExpectedUntil(base::TimeTicks time) {
292 client_->BeginMainFrameNotExpectedUntil(time);
293 }
294
BeginMainFrame(const viz::BeginFrameArgs & args)295 void LayerTreeHost::BeginMainFrame(const viz::BeginFrameArgs& args) {
296 client_->BeginMainFrame(args);
297 }
298
GetDebugState() const299 const LayerTreeDebugState& LayerTreeHost::GetDebugState() const {
300 return debug_state_;
301 }
302
RequestMainFrameUpdate(bool report_cc_metrics)303 void LayerTreeHost::RequestMainFrameUpdate(bool report_cc_metrics) {
304 client_->UpdateLayerTreeHost();
305 if (report_cc_metrics)
306 begin_main_frame_metrics_ = client_->GetBeginMainFrameMetrics();
307 else
308 begin_main_frame_metrics_.reset();
309 }
310
311 // This function commits the LayerTreeHost to an impl tree. When modifying
312 // this function, keep in mind that the function *runs* on the impl thread! Any
313 // code that is logically a main thread operation, e.g. deletion of a Layer,
314 // should be delayed until the LayerTreeHost::CommitComplete, which will run
315 // after the commit, but on the main thread.
FinishCommitOnImplThread(LayerTreeHostImpl * host_impl)316 void LayerTreeHost::FinishCommitOnImplThread(LayerTreeHostImpl* host_impl) {
317 DCHECK(task_runner_provider_->IsImplThread());
318
319 TRACE_EVENT0("cc,benchmark", "LayerTreeHost::FinishCommitOnImplThread");
320
321 LayerTreeImpl* sync_tree = host_impl->sync_tree();
322 sync_tree->lifecycle().AdvanceTo(LayerTreeLifecycle::kBeginningSync);
323
324 if (next_commit_forces_redraw_) {
325 sync_tree->ForceRedrawNextActivation();
326 next_commit_forces_redraw_ = false;
327 }
328 if (next_commit_forces_recalculate_raster_scales_) {
329 sync_tree->ForceRecalculateRasterScales();
330 next_commit_forces_recalculate_raster_scales_ = false;
331 }
332
333 sync_tree->set_source_frame_number(SourceFrameNumber());
334 if (!pending_presentation_time_callbacks_.empty()) {
335 sync_tree->AddPresentationCallbacks(
336 std::move(pending_presentation_time_callbacks_));
337 pending_presentation_time_callbacks_.clear();
338 }
339
340 if (needs_full_tree_sync_)
341 TreeSynchronizer::SynchronizeTrees(root_layer(), sync_tree);
342
343 if (clear_caches_on_next_commit_) {
344 clear_caches_on_next_commit_ = false;
345 proxy_->ClearHistory();
346 host_impl->ClearCaches();
347 }
348
349 {
350 TRACE_EVENT0("cc", "LayerTreeHost::PushProperties");
351
352 PushPropertyTreesTo(sync_tree);
353 sync_tree->lifecycle().AdvanceTo(LayerTreeLifecycle::kSyncedPropertyTrees);
354
355 PushSurfaceRangesTo(sync_tree);
356 TreeSynchronizer::PushLayerProperties(this, sync_tree);
357 sync_tree->lifecycle().AdvanceTo(
358 LayerTreeLifecycle::kSyncedLayerProperties);
359
360 PushLayerTreePropertiesTo(sync_tree);
361 PushLayerTreeHostPropertiesTo(host_impl);
362
363 sync_tree->PassSwapPromises(swap_promise_manager_.TakeSwapPromises());
364 sync_tree->AppendEventsMetricsFromMainThread(
365 events_metrics_manager_.TakeSavedEventsMetrics());
366
367 sync_tree->set_ui_resource_request_queue(
368 ui_resource_manager_->TakeUIResourcesRequests());
369
370 // This must happen after synchronizing property trees and after pushing
371 // properties, which updates the clobber_active_value flag.
372 // TODO(pdr): Enforce this comment with DCHECKS and a lifecycle state.
373 sync_tree->property_trees()->scroll_tree.PushScrollUpdatesFromMainThread(
374 property_trees(), sync_tree);
375
376 // This must happen after synchronizing property trees and after push
377 // properties, which updates property tree indices, but before animation
378 // host pushes properties as animation host push properties can change
379 // KeyframeModel::InEffect and we want the old InEffect value for updating
380 // property tree scrolling and animation.
381 // TODO(pdr): Enforce this comment with DCHECKS and a lifecycle state.
382 sync_tree->UpdatePropertyTreeAnimationFromMainThread();
383
384 TRACE_EVENT0("cc", "LayerTreeHost::AnimationHost::PushProperties");
385 DCHECK(host_impl->mutator_host());
386 mutator_host_->PushPropertiesTo(host_impl->mutator_host());
387 MoveChangeTrackingToLayers(sync_tree);
388
389 // Updating elements affects whether animations are in effect based on their
390 // properties so run after pushing updated animation properties.
391 host_impl->UpdateElements(ElementListType::PENDING);
392
393 sync_tree->lifecycle().AdvanceTo(LayerTreeLifecycle::kNotSyncing);
394 }
395
396 // Transfer image decode requests to the impl thread.
397 for (auto& request : queued_image_decodes_) {
398 int next_id = s_image_decode_sequence_number.GetNext();
399 pending_image_decodes_[next_id] = std::move(request.second);
400 host_impl->QueueImageDecode(next_id, std::move(request.first));
401 }
402 queued_image_decodes_.clear();
403
404 micro_benchmark_controller_.ScheduleImplBenchmarks(host_impl);
405 property_trees_.ResetAllChangeTracking();
406
407 // Dump property trees and layers if run with:
408 // --vmodule=layer_tree_host=3
409 if (VLOG_IS_ON(3)) {
410 const char* client_name = GetClientNameForMetrics();
411 if (!client_name)
412 client_name = "<unknown client>";
413 VLOG(3) << "After finishing (" << client_name
414 << ") commit on impl, the sync tree:"
415 << "\nproperty_trees:\n"
416 << sync_tree->property_trees()->ToString() << "\n"
417 << "cc::LayerImpls:\n"
418 << sync_tree->LayerListAsJson();
419 }
420 }
421
MoveChangeTrackingToLayers(LayerTreeImpl * tree_impl)422 void LayerTreeHost::MoveChangeTrackingToLayers(LayerTreeImpl* tree_impl) {
423 // This is only true for single-thread compositing (i.e. not via Blink).
424 bool property_trees_changed_on_active_tree =
425 tree_impl->IsActiveTree() && tree_impl->property_trees()->changed;
426
427 if (property_trees_changed_on_active_tree) {
428 // Property trees may store damage status. We preserve the sync tree damage
429 // status by pushing the damage status from sync tree property trees to main
430 // thread property trees or by moving it onto the layers.
431 if (root_layer_) {
432 if (property_trees_.sequence_number ==
433 tree_impl->property_trees()->sequence_number)
434 tree_impl->property_trees()->PushChangeTrackingTo(&property_trees_);
435 else
436 tree_impl->MoveChangeTrackingToLayers();
437 }
438 } else {
439 tree_impl->MoveChangeTrackingToLayers();
440 }
441 }
442
ImageDecodesFinished(const std::vector<std::pair<int,bool>> & results)443 void LayerTreeHost::ImageDecodesFinished(
444 const std::vector<std::pair<int, bool>>& results) {
445 // Issue stored callbacks and remove them from the pending list.
446 for (const auto& pair : results) {
447 auto it = pending_image_decodes_.find(pair.first);
448 DCHECK(it != pending_image_decodes_.end());
449 std::move(it->second).Run(pair.second);
450 pending_image_decodes_.erase(it);
451 }
452 }
453
PushPropertyTreesTo(LayerTreeImpl * tree_impl)454 void LayerTreeHost::PushPropertyTreesTo(LayerTreeImpl* tree_impl) {
455 bool property_trees_changed_on_active_tree =
456 tree_impl->IsActiveTree() && tree_impl->property_trees()->changed;
457 // Property trees may store damage status. We preserve the sync tree damage
458 // status by pushing the damage status from sync tree property trees to main
459 // thread property trees or by moving it onto the layers.
460 if (root_layer_ && property_trees_changed_on_active_tree) {
461 if (property_trees_.sequence_number ==
462 tree_impl->property_trees()->sequence_number)
463 tree_impl->property_trees()->PushChangeTrackingTo(&property_trees_);
464 else
465 tree_impl->MoveChangeTrackingToLayers();
466 }
467
468 tree_impl->SetPropertyTrees(&property_trees_);
469 }
470
WillCommit()471 void LayerTreeHost::WillCommit() {
472 swap_promise_manager_.WillCommit();
473 client_->WillCommit();
474 }
475
UpdateDeferMainFrameUpdateInternal()476 void LayerTreeHost::UpdateDeferMainFrameUpdateInternal() {
477 proxy_->SetDeferMainFrameUpdate(
478 defer_main_frame_update_count_ > 0 ||
479 !local_surface_id_allocation_from_parent_.IsValid());
480 }
481
IsUsingLayerLists() const482 bool LayerTreeHost::IsUsingLayerLists() const {
483 return settings_.use_layer_lists && !force_use_property_tree_builder_;
484 }
485
CommitComplete()486 void LayerTreeHost::CommitComplete() {
487 source_frame_number_++;
488 client_->DidCommit(impl_commit_start_time_);
489 impl_commit_start_time_ = base::TimeTicks();
490 if (did_complete_scale_animation_) {
491 client_->DidCompletePageScaleAnimation();
492 did_complete_scale_animation_ = false;
493 }
494 }
495
SetLayerTreeFrameSink(std::unique_ptr<LayerTreeFrameSink> surface)496 void LayerTreeHost::SetLayerTreeFrameSink(
497 std::unique_ptr<LayerTreeFrameSink> surface) {
498 TRACE_EVENT0("cc", "LayerTreeHost::SetLayerTreeFrameSink");
499 DCHECK(surface);
500
501 DCHECK(!new_layer_tree_frame_sink_);
502 new_layer_tree_frame_sink_ = std::move(surface);
503 proxy_->SetLayerTreeFrameSink(new_layer_tree_frame_sink_.get());
504 }
505
ReleaseLayerTreeFrameSink()506 std::unique_ptr<LayerTreeFrameSink> LayerTreeHost::ReleaseLayerTreeFrameSink() {
507 DCHECK(!visible_);
508
509 DidLoseLayerTreeFrameSink();
510 proxy_->ReleaseLayerTreeFrameSink();
511 return std::move(current_layer_tree_frame_sink_);
512 }
513
RequestNewLayerTreeFrameSink()514 void LayerTreeHost::RequestNewLayerTreeFrameSink() {
515 client_->RequestNewLayerTreeFrameSink();
516 }
517
DidInitializeLayerTreeFrameSink()518 void LayerTreeHost::DidInitializeLayerTreeFrameSink() {
519 DCHECK(new_layer_tree_frame_sink_);
520 current_layer_tree_frame_sink_ = std::move(new_layer_tree_frame_sink_);
521 client_->DidInitializeLayerTreeFrameSink();
522 }
523
DidFailToInitializeLayerTreeFrameSink()524 void LayerTreeHost::DidFailToInitializeLayerTreeFrameSink() {
525 DCHECK(new_layer_tree_frame_sink_);
526 // Note: It is safe to drop all output surface references here as
527 // LayerTreeHostImpl will not keep a pointer to either the old or
528 // new LayerTreeFrameSink after failing to initialize the new one.
529 current_layer_tree_frame_sink_ = nullptr;
530 new_layer_tree_frame_sink_ = nullptr;
531 client_->DidFailToInitializeLayerTreeFrameSink();
532 }
533
CreateLayerTreeHostImpl(LayerTreeHostImplClient * client)534 std::unique_ptr<LayerTreeHostImpl> LayerTreeHost::CreateLayerTreeHostImpl(
535 LayerTreeHostImplClient* client) {
536 DCHECK(task_runner_provider_->IsImplThread());
537
538 const bool supports_impl_scrolling = task_runner_provider_->HasImplThread();
539 std::unique_ptr<MutatorHost> mutator_host_impl =
540 mutator_host_->CreateImplInstance(supports_impl_scrolling);
541
542 if (!settings_.scroll_animation_duration_for_testing.is_zero()) {
543 mutator_host_->SetScrollAnimationDurationForTesting(
544 settings_.scroll_animation_duration_for_testing);
545 }
546
547 std::unique_ptr<LayerTreeHostImpl> host_impl = LayerTreeHostImpl::Create(
548 settings_, client, task_runner_provider_.get(),
549 rendering_stats_instrumentation_.get(), task_graph_runner_,
550 std::move(mutator_host_impl), id_, std::move(image_worker_task_runner_),
551 scheduling_client_);
552 if (ukm_recorder_factory_) {
553 host_impl->InitializeUkm(ukm_recorder_factory_->CreateRecorder());
554 ukm_recorder_factory_.reset();
555 }
556
557 task_graph_runner_ = nullptr;
558 input_handler_weak_ptr_ = host_impl->AsWeakPtr();
559 return host_impl;
560 }
561
DidLoseLayerTreeFrameSink()562 void LayerTreeHost::DidLoseLayerTreeFrameSink() {
563 TRACE_EVENT0("cc", "LayerTreeHost::DidLoseLayerTreeFrameSink");
564 DCHECK(task_runner_provider_->IsMainThread());
565 SetNeedsCommit();
566 }
567
ScopedDeferMainFrameUpdate(LayerTreeHost * host)568 ScopedDeferMainFrameUpdate::ScopedDeferMainFrameUpdate(LayerTreeHost* host)
569 : host_(host->defer_main_frame_update_weak_ptr_factory_.GetWeakPtr()) {
570 host->defer_main_frame_update_count_++;
571 host->UpdateDeferMainFrameUpdateInternal();
572 }
573
~ScopedDeferMainFrameUpdate()574 ScopedDeferMainFrameUpdate::~ScopedDeferMainFrameUpdate() {
575 LayerTreeHost* host = host_.get();
576 if (host) {
577 DCHECK_GT(host->defer_main_frame_update_count_, 0u);
578 if (--host->defer_main_frame_update_count_ == 0)
579 host->UpdateDeferMainFrameUpdateInternal();
580 }
581 }
582
583 std::unique_ptr<ScopedDeferMainFrameUpdate>
DeferMainFrameUpdate()584 LayerTreeHost::DeferMainFrameUpdate() {
585 return std::make_unique<ScopedDeferMainFrameUpdate>(this);
586 }
587
OnDeferMainFrameUpdatesChanged(bool defer_status)588 void LayerTreeHost::OnDeferMainFrameUpdatesChanged(bool defer_status) {
589 client_->OnDeferMainFrameUpdatesChanged(defer_status);
590 }
591
StartDeferringCommits(base::TimeDelta timeout)592 void LayerTreeHost::StartDeferringCommits(base::TimeDelta timeout) {
593 proxy_->StartDeferringCommits(timeout);
594 }
595
StopDeferringCommits(PaintHoldingCommitTrigger trigger)596 void LayerTreeHost::StopDeferringCommits(PaintHoldingCommitTrigger trigger) {
597 proxy_->StopDeferringCommits(trigger);
598 }
599
OnDeferCommitsChanged(bool defer_status)600 void LayerTreeHost::OnDeferCommitsChanged(bool defer_status) {
601 client_->OnDeferCommitsChanged(defer_status);
602 }
603
604 DISABLE_CFI_PERF
SetNeedsAnimate()605 void LayerTreeHost::SetNeedsAnimate() {
606 proxy_->SetNeedsAnimate();
607 swap_promise_manager_.NotifySwapPromiseMonitorsOfSetNeedsCommit();
608 events_metrics_manager_.SaveActiveEventMetrics();
609 }
610
611 DISABLE_CFI_PERF
SetNeedsUpdateLayers()612 void LayerTreeHost::SetNeedsUpdateLayers() {
613 proxy_->SetNeedsUpdateLayers();
614 swap_promise_manager_.NotifySwapPromiseMonitorsOfSetNeedsCommit();
615 events_metrics_manager_.SaveActiveEventMetrics();
616 }
617
SetNeedsCommit()618 void LayerTreeHost::SetNeedsCommit() {
619 proxy_->SetNeedsCommit();
620 swap_promise_manager_.NotifySwapPromiseMonitorsOfSetNeedsCommit();
621 events_metrics_manager_.SaveActiveEventMetrics();
622 }
623
RequestedMainFramePendingForTesting() const624 bool LayerTreeHost::RequestedMainFramePendingForTesting() const {
625 return proxy_->RequestedAnimatePending();
626 }
627
SetNeedsRecalculateRasterScales()628 void LayerTreeHost::SetNeedsRecalculateRasterScales() {
629 next_commit_forces_recalculate_raster_scales_ = true;
630 proxy_->SetNeedsCommit();
631 }
632
SetNeedsRedrawRect(const gfx::Rect & damage_rect)633 void LayerTreeHost::SetNeedsRedrawRect(const gfx::Rect& damage_rect) {
634 proxy_->SetNeedsRedraw(damage_rect);
635 }
636
CommitRequested() const637 bool LayerTreeHost::CommitRequested() const {
638 return proxy_->CommitRequested();
639 }
640
SetNextCommitWaitsForActivation()641 void LayerTreeHost::SetNextCommitWaitsForActivation() {
642 proxy_->SetNextCommitWaitsForActivation();
643 }
644
SetNeedsCommitWithForcedRedraw()645 void LayerTreeHost::SetNeedsCommitWithForcedRedraw() {
646 next_commit_forces_redraw_ = true;
647 proxy_->SetNeedsCommit();
648 }
649
SetDebugState(const LayerTreeDebugState & debug_state)650 void LayerTreeHost::SetDebugState(const LayerTreeDebugState& debug_state) {
651 LayerTreeDebugState new_debug_state =
652 LayerTreeDebugState::Unite(settings_.initial_debug_state, debug_state);
653
654 if (LayerTreeDebugState::Equal(debug_state_, new_debug_state))
655 return;
656
657 debug_state_ = new_debug_state;
658
659 rendering_stats_instrumentation_->set_record_rendering_stats(
660 debug_state_.RecordRenderingStats());
661
662 SetNeedsCommit();
663 }
664
ApplyPageScaleDeltaFromImplSide(float page_scale_delta)665 void LayerTreeHost::ApplyPageScaleDeltaFromImplSide(float page_scale_delta) {
666 DCHECK(CommitRequested());
667 if (page_scale_delta == 1.f)
668 return;
669 float page_scale = page_scale_factor_ * page_scale_delta;
670 SetPageScaleFromImplSide(page_scale);
671 }
672
SetVisible(bool visible)673 void LayerTreeHost::SetVisible(bool visible) {
674 if (visible_ == visible)
675 return;
676 visible_ = visible;
677 proxy_->SetVisible(visible);
678 }
679
IsVisible() const680 bool LayerTreeHost::IsVisible() const {
681 return visible_;
682 }
683
LayoutAndUpdateLayers()684 void LayerTreeHost::LayoutAndUpdateLayers() {
685 DCHECK(IsSingleThreaded());
686 // This function is only valid when not using the scheduler.
687 DCHECK(!settings_.single_thread_proxy_scheduler);
688 RequestMainFrameUpdate(false);
689 UpdateLayers();
690 }
691
Composite(base::TimeTicks frame_begin_time,bool raster)692 void LayerTreeHost::Composite(base::TimeTicks frame_begin_time, bool raster) {
693 DCHECK(IsSingleThreaded());
694 // This function is only valid when not using the scheduler.
695 DCHECK(!settings_.single_thread_proxy_scheduler);
696 SingleThreadProxy* proxy = static_cast<SingleThreadProxy*>(proxy_.get());
697 proxy->CompositeImmediately(frame_begin_time, raster);
698 }
699
UpdateLayers()700 bool LayerTreeHost::UpdateLayers() {
701 if (!root_layer()) {
702 property_trees_.clear();
703 viewport_property_ids_ = ViewportPropertyIds();
704 return false;
705 }
706
707 DCHECK(!root_layer()->parent());
708 base::ElapsedTimer timer;
709
710 client_->WillUpdateLayers();
711 bool result = DoUpdateLayers();
712 client_->DidUpdateLayers();
713 micro_benchmark_controller_.DidUpdateLayers();
714
715 base::TimeDelta elapsed_delta = timer.Elapsed();
716 if (begin_main_frame_metrics_)
717 begin_main_frame_metrics_->update_layers = elapsed_delta;
718 if (const char* client_name = GetClientNameForMetrics()) {
719 auto elapsed = elapsed_delta.InMicroseconds();
720
721 std::string histogram_name =
722 base::StringPrintf("Compositing.%s.LayersUpdateTime", client_name);
723 base::UmaHistogramCounts10M(histogram_name, elapsed);
724 }
725
726 return result;
727 }
728
DidPresentCompositorFrame(uint32_t frame_token,std::vector<LayerTreeHost::PresentationTimeCallback> callbacks,const gfx::PresentationFeedback & feedback)729 void LayerTreeHost::DidPresentCompositorFrame(
730 uint32_t frame_token,
731 std::vector<LayerTreeHost::PresentationTimeCallback> callbacks,
732 const gfx::PresentationFeedback& feedback) {
733 for (auto& callback : callbacks)
734 std::move(callback).Run(feedback);
735 client_->DidPresentCompositorFrame(frame_token, feedback);
736 }
737
DidCompletePageScaleAnimation()738 void LayerTreeHost::DidCompletePageScaleAnimation() {
739 did_complete_scale_animation_ = true;
740 }
741
RecordGpuRasterizationHistogram(const LayerTreeHostImpl * host_impl)742 void LayerTreeHost::RecordGpuRasterizationHistogram(
743 const LayerTreeHostImpl* host_impl) {
744 // Gpu rasterization is only supported for Renderer compositors.
745 // Checking for IsSingleThreaded() to exclude Browser compositors.
746 if (gpu_rasterization_histogram_recorded_ || IsSingleThreaded())
747 return;
748
749 bool gpu_rasterization_enabled = false;
750 if (host_impl->layer_tree_frame_sink()) {
751 viz::ContextProvider* compositor_context_provider =
752 host_impl->layer_tree_frame_sink()->context_provider();
753 if (compositor_context_provider) {
754 gpu_rasterization_enabled =
755 compositor_context_provider->ContextCapabilities().gpu_rasterization;
756 }
757 }
758
759 // Record how widely gpu rasterization is enabled.
760 // This number takes device/gpu whitelisting/backlisting into account.
761 // Note that we do not consider the forced gpu rasterization mode, which is
762 // mostly used for debugging purposes.
763 UMA_HISTOGRAM_BOOLEAN("Renderer4.GpuRasterizationEnabled",
764 gpu_rasterization_enabled);
765 gpu_rasterization_histogram_recorded_ = true;
766 }
767
LayersAsString() const768 std::string LayerTreeHost::LayersAsString() const {
769 std::string layers;
770 for (const auto* layer : *this)
771 layers += layer->ToString() + "\n";
772 return layers;
773 }
774
CaptureContent(std::vector<NodeId> * content)775 bool LayerTreeHost::CaptureContent(std::vector<NodeId>* content) {
776 if (viewport_visible_rect_.IsEmpty())
777 return false;
778
779 gfx::Rect rect = gfx::Rect(viewport_visible_rect_.width(),
780 viewport_visible_rect_.height());
781 for (auto* layer : *this)
782 layer->CaptureContent(rect, content);
783
784 return true;
785 }
786
DoUpdateLayers()787 bool LayerTreeHost::DoUpdateLayers() {
788 TRACE_EVENT1("cc,benchmark", "LayerTreeHost::DoUpdateLayers",
789 "source_frame_number", SourceFrameNumber());
790
791 UpdateHudLayer(debug_state_.ShowHudInfo());
792
793 // In layer lists mode, the cc property trees are built directly and do not
794 // need to be built here.
795 if (!IsUsingLayerLists()) {
796 TRACE_EVENT0("cc", "LayerTreeHost::UpdateLayers::BuildPropertyTrees");
797 PropertyTreeBuilder::BuildPropertyTrees(this);
798 TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
799 "LayerTreeHost::UpdateLayers_BuiltPropertyTrees",
800 TRACE_EVENT_SCOPE_THREAD, "property_trees",
801 property_trees_.AsTracedValue());
802 } else {
803 TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
804 "LayerTreeHost::UpdateLayers_ReceivedPropertyTrees",
805 TRACE_EVENT_SCOPE_THREAD, "property_trees",
806 property_trees_.AsTracedValue());
807 // The HUD layer is managed outside the layer list sent to LayerTreeHost
808 // and needs to have its property tree state set.
809 if (hud_layer_ && root_layer_.get()) {
810 hud_layer_->SetTransformTreeIndex(root_layer_->transform_tree_index());
811 hud_layer_->SetEffectTreeIndex(root_layer_->effect_tree_index());
812 hud_layer_->SetClipTreeIndex(root_layer_->clip_tree_index());
813 hud_layer_->SetScrollTreeIndex(root_layer_->scroll_tree_index());
814 hud_layer_->set_property_tree_sequence_number(
815 root_layer_->property_tree_sequence_number());
816 }
817 }
818
819 #if DCHECK_IS_ON()
820 // Ensure property tree nodes were created for all layers. When using layer
821 // lists, this can fail if blink doesn't setup layers or nodes correctly in
822 // |PaintArtifactCompositor|. When not using layer lists, this can fail if
823 // |PropertyTreeBuilder::BuildPropertyTrees| fails to create property tree
824 // nodes.
825 for (auto* layer : *this) {
826 DCHECK(property_trees_.effect_tree.Node(layer->effect_tree_index()));
827 DCHECK(property_trees_.transform_tree.Node(layer->transform_tree_index()));
828 DCHECK(property_trees_.clip_tree.Node(layer->clip_tree_index()));
829 DCHECK(property_trees_.scroll_tree.Node(layer->scroll_tree_index()));
830 }
831 #else
832 // This is a quick sanity check for readiness of paint properties.
833 // TODO(crbug.com/913464): This is to help analysis of crashes of the bug.
834 // Remove this CHECK when we close the bug.
835 CHECK(property_trees_.effect_tree.Node(root_layer_->effect_tree_index()));
836 #endif
837
838 draw_property_utils::UpdatePropertyTrees(this);
839
840 LayerList update_layer_list;
841 draw_property_utils::FindLayersThatNeedUpdates(this, &update_layer_list);
842 bool did_paint_content = PaintContent(update_layer_list);
843 return did_paint_content;
844 }
845
ApplyViewportChanges(const ScrollAndScaleSet & info)846 void LayerTreeHost::ApplyViewportChanges(const ScrollAndScaleSet& info) {
847 gfx::ScrollOffset inner_viewport_scroll_delta;
848 if (info.inner_viewport_scroll.element_id)
849 inner_viewport_scroll_delta = info.inner_viewport_scroll.scroll_delta;
850
851 if (inner_viewport_scroll_delta.IsZero() && info.page_scale_delta == 1.f &&
852 info.elastic_overscroll_delta.IsZero() && !info.top_controls_delta &&
853 !info.bottom_controls_delta &&
854 !info.browser_controls_constraint_changed &&
855 !info.scroll_gesture_did_end &&
856 info.is_pinch_gesture_active == is_pinch_gesture_active_from_impl_) {
857 return;
858 }
859 is_pinch_gesture_active_from_impl_ = info.is_pinch_gesture_active;
860
861 // Preemptively apply the scroll offset and scale delta here before sending
862 // it to the client. If the client comes back and sets it to the same
863 // value, then the layer can early out without needing a full commit.
864 if (auto* inner_scroll = property_trees()->scroll_tree.Node(
865 viewport_property_ids_.inner_scroll)) {
866 if (IsUsingLayerLists()) {
867 auto& scroll_tree = property_trees()->scroll_tree;
868 scroll_tree.NotifyDidScroll(
869 inner_scroll->element_id,
870 scroll_tree.current_scroll_offset(inner_scroll->element_id) +
871 inner_viewport_scroll_delta,
872 info.inner_viewport_scroll.snap_target_element_ids);
873 } else if (auto* inner_scroll_layer =
874 LayerByElementId(inner_scroll->element_id)) {
875 inner_scroll_layer->SetScrollOffsetFromImplSide(
876 inner_scroll_layer->scroll_offset() + inner_viewport_scroll_delta);
877 }
878 }
879
880 ApplyPageScaleDeltaFromImplSide(info.page_scale_delta);
881 SetElasticOverscrollFromImplSide(elastic_overscroll_ +
882 info.elastic_overscroll_delta);
883 // TODO(ccameron): pass the elastic overscroll here so that input events
884 // may be translated appropriately.
885 client_->ApplyViewportChanges(
886 {inner_viewport_scroll_delta, info.elastic_overscroll_delta,
887 info.page_scale_delta, info.is_pinch_gesture_active,
888 info.top_controls_delta, info.bottom_controls_delta,
889 info.browser_controls_constraint, info.scroll_gesture_did_end});
890 SetNeedsUpdateLayers();
891 }
892
RecordManipulationTypeCounts(const ScrollAndScaleSet & scroll_info)893 void LayerTreeHost::RecordManipulationTypeCounts(
894 const ScrollAndScaleSet& scroll_info) {
895 client_->RecordManipulationTypeCounts(scroll_info.manipulation_info);
896 }
897
SendOverscrollAndScrollEndEventsFromImplSide(const ScrollAndScaleSet & info)898 void LayerTreeHost::SendOverscrollAndScrollEndEventsFromImplSide(
899 const ScrollAndScaleSet& info) {
900 if (info.scroll_latched_element_id == ElementId())
901 return;
902
903 if (!info.overscroll_delta.IsZero()) {
904 client_->SendOverscrollEventFromImplSide(info.overscroll_delta,
905 info.scroll_latched_element_id);
906 }
907 if (info.scroll_gesture_did_end)
908 client_->SendScrollEndEventFromImplSide(info.scroll_latched_element_id);
909 }
910
ApplyScrollAndScale(ScrollAndScaleSet * info)911 void LayerTreeHost::ApplyScrollAndScale(ScrollAndScaleSet* info) {
912 DCHECK(info);
913 TRACE_EVENT0("cc", "LayerTreeHost::ApplyScrollAndScale");
914
915 using perfetto::protos::pbzero::ChromeLatencyInfo;
916 using perfetto::protos::pbzero::TrackEvent;
917
918 for (auto& swap_promise : info->swap_promises) {
919 TRACE_EVENT(
920 "input,benchmark", "LatencyInfo.Flow",
921 [&swap_promise](perfetto::EventContext ctx) {
922 ChromeLatencyInfo* info = ctx.event()->set_chrome_latency_info();
923 info->set_trace_id(swap_promise->TraceId());
924 info->set_step(ChromeLatencyInfo::STEP_MAIN_THREAD_SCROLL_UPDATE);
925 tracing::FillFlowEvent(ctx, TrackEvent::LegacyEvent::FLOW_INOUT,
926 swap_promise->TraceId());
927 });
928 swap_promise_manager_.QueueSwapPromise(std::move(swap_promise));
929 }
930
931 if (root_layer_) {
932 auto& scroll_tree = property_trees()->scroll_tree;
933 for (auto& scroll : info->scrolls) {
934 if (IsUsingLayerLists()) {
935 TRACE_EVENT_INSTANT2(
936 "cc", "NotifyDidScroll", TRACE_EVENT_SCOPE_THREAD, "cur_y",
937 scroll_tree.current_scroll_offset(scroll.element_id).y(), "delta",
938 scroll.scroll_delta.y());
939 scroll_tree.NotifyDidScroll(
940 scroll.element_id,
941 scroll_tree.current_scroll_offset(scroll.element_id) +
942 scroll.scroll_delta,
943 scroll.snap_target_element_ids);
944 } else if (Layer* layer = LayerByElementId(scroll.element_id)) {
945 layer->SetScrollOffsetFromImplSide(layer->scroll_offset() +
946 scroll.scroll_delta);
947 SetNeedsUpdateLayers();
948 }
949 }
950 for (auto& scrollbar : info->scrollbars) {
951 scroll_tree.NotifyDidChangeScrollbarsHidden(scrollbar.element_id,
952 scrollbar.hidden);
953 }
954 }
955
956 SendOverscrollAndScrollEndEventsFromImplSide(*info);
957
958 // This needs to happen after scroll deltas have been sent to prevent top
959 // controls from clamping the layout viewport both on the compositor and
960 // on the main thread.
961 ApplyViewportChanges(*info);
962
963 RecordManipulationTypeCounts(*info);
964 }
965
ApplyMutatorEvents(std::unique_ptr<MutatorEvents> events)966 void LayerTreeHost::ApplyMutatorEvents(std::unique_ptr<MutatorEvents> events) {
967 DCHECK(task_runner_provider_->IsMainThread());
968 if (!events->IsEmpty())
969 mutator_host_->SetAnimationEvents(std::move(events));
970 }
971
RecordStartOfFrameMetrics()972 void LayerTreeHost::RecordStartOfFrameMetrics() {
973 client_->RecordStartOfFrameMetrics();
974 }
975
RecordEndOfFrameMetrics(base::TimeTicks frame_begin_time,ActiveFrameSequenceTrackers trackers)976 void LayerTreeHost::RecordEndOfFrameMetrics(
977 base::TimeTicks frame_begin_time,
978 ActiveFrameSequenceTrackers trackers) {
979 client_->RecordEndOfFrameMetrics(frame_begin_time, trackers);
980 }
981
GetInputHandler() const982 const base::WeakPtr<InputHandler>& LayerTreeHost::GetInputHandler() const {
983 return input_handler_weak_ptr_;
984 }
985
UpdateBrowserControlsState(BrowserControlsState constraints,BrowserControlsState current,bool animate)986 void LayerTreeHost::UpdateBrowserControlsState(BrowserControlsState constraints,
987 BrowserControlsState current,
988 bool animate) {
989 // Browser controls are only used in threaded mode but Blink layout tests may
990 // call into this. The single threaded version is a no-op.
991 proxy_->UpdateBrowserControlsState(constraints, current, animate);
992 }
993
AnimateLayers(base::TimeTicks monotonic_time)994 void LayerTreeHost::AnimateLayers(base::TimeTicks monotonic_time) {
995 std::unique_ptr<MutatorEvents> events = mutator_host_->CreateEvents();
996
997 if (mutator_host_->TickAnimations(monotonic_time,
998 property_trees()->scroll_tree, true))
999 mutator_host_->UpdateAnimationState(true, events.get());
1000
1001 if (!events->IsEmpty()) {
1002 // If not using layer lists, animation state changes will require
1003 // rebuilding property trees to track them.
1004 if (!IsUsingLayerLists())
1005 property_trees_.needs_rebuild = true;
1006
1007 // A commit is required to push animation changes to the compositor.
1008 SetNeedsCommit();
1009 }
1010 }
1011
ScheduleMicroBenchmark(const std::string & benchmark_name,std::unique_ptr<base::Value> value,MicroBenchmark::DoneCallback callback)1012 int LayerTreeHost::ScheduleMicroBenchmark(
1013 const std::string& benchmark_name,
1014 std::unique_ptr<base::Value> value,
1015 MicroBenchmark::DoneCallback callback) {
1016 return micro_benchmark_controller_.ScheduleRun(
1017 benchmark_name, std::move(value), std::move(callback));
1018 }
1019
SendMessageToMicroBenchmark(int id,std::unique_ptr<base::Value> value)1020 bool LayerTreeHost::SendMessageToMicroBenchmark(
1021 int id,
1022 std::unique_ptr<base::Value> value) {
1023 return micro_benchmark_controller_.SendMessage(id, std::move(value));
1024 }
1025
SetLayerTreeMutator(std::unique_ptr<LayerTreeMutator> mutator)1026 void LayerTreeHost::SetLayerTreeMutator(
1027 std::unique_ptr<LayerTreeMutator> mutator) {
1028 // The animation worklet system assumes that the mutator will never be called
1029 // from the main thread, which will not be the case if we're running in
1030 // single-threaded mode.
1031 if (!task_runner_provider_->HasImplThread()) {
1032 DLOG(ERROR) << "LayerTreeMutator not supported in single-thread mode";
1033 return;
1034 }
1035 proxy_->SetMutator(std::move(mutator));
1036 }
1037
SetPaintWorkletLayerPainter(std::unique_ptr<PaintWorkletLayerPainter> painter)1038 void LayerTreeHost::SetPaintWorkletLayerPainter(
1039 std::unique_ptr<PaintWorkletLayerPainter> painter) {
1040 // The paint worklet system assumes that the painter will never be called from
1041 // the main thread, which will not be the case if we're running in
1042 // single-threaded mode.
1043 DCHECK(task_runner_provider_->HasImplThread())
1044 << "PaintWorkletLayerPainter not supported in single-thread mode";
1045 proxy_->SetPaintWorkletLayerPainter(std::move(painter));
1046 }
1047
IsSingleThreaded() const1048 bool LayerTreeHost::IsSingleThreaded() const {
1049 DCHECK(compositor_mode_ != CompositorMode::SINGLE_THREADED ||
1050 !task_runner_provider_->HasImplThread());
1051 return compositor_mode_ == CompositorMode::SINGLE_THREADED;
1052 }
1053
IsThreaded() const1054 bool LayerTreeHost::IsThreaded() const {
1055 DCHECK(compositor_mode_ != CompositorMode::THREADED ||
1056 task_runner_provider_->HasImplThread());
1057 return compositor_mode_ == CompositorMode::THREADED;
1058 }
1059
RequestPresentationTimeForNextFrame(PresentationTimeCallback callback)1060 void LayerTreeHost::RequestPresentationTimeForNextFrame(
1061 PresentationTimeCallback callback) {
1062 pending_presentation_time_callbacks_.push_back(std::move(callback));
1063 }
1064
SetRootLayer(scoped_refptr<Layer> root_layer)1065 void LayerTreeHost::SetRootLayer(scoped_refptr<Layer> root_layer) {
1066 if (root_layer_.get() == root_layer.get())
1067 return;
1068
1069 if (root_layer_.get())
1070 root_layer_->SetLayerTreeHost(nullptr);
1071 root_layer_ = root_layer;
1072 if (root_layer_.get()) {
1073 DCHECK(!root_layer_->parent());
1074 root_layer_->SetLayerTreeHost(this);
1075 }
1076
1077 if (hud_layer_.get())
1078 hud_layer_->RemoveFromParent();
1079
1080 // Reset gpu rasterization tracking.
1081 // This flag is sticky until a new tree comes along.
1082 gpu_rasterization_histogram_recorded_ = false;
1083
1084 force_use_property_tree_builder_ = false;
1085
1086 SetNeedsFullTreeSync();
1087 }
1088
SetNonBlinkManagedRootLayer(scoped_refptr<Layer> root_layer)1089 void LayerTreeHost::SetNonBlinkManagedRootLayer(
1090 scoped_refptr<Layer> root_layer) {
1091 SetRootLayer(std::move(root_layer));
1092
1093 DCHECK(!root_layer || root_layer_->children().empty());
1094 if (IsUsingLayerLists() && root_layer_)
1095 force_use_property_tree_builder_ = true;
1096 }
1097
RegisterViewportPropertyIds(const ViewportPropertyIds & ids)1098 void LayerTreeHost::RegisterViewportPropertyIds(
1099 const ViewportPropertyIds& ids) {
1100 DCHECK(IsUsingLayerLists());
1101 viewport_property_ids_ = ids;
1102 // Outer viewport properties exist only if inner viewport property exists.
1103 DCHECK(ids.inner_scroll != ScrollTree::kInvalidNodeId ||
1104 (ids.outer_scroll == ScrollTree::kInvalidNodeId &&
1105 ids.outer_clip == ClipTree::kInvalidNodeId));
1106 }
1107
InnerViewportScrollLayerForTesting() const1108 Layer* LayerTreeHost::InnerViewportScrollLayerForTesting() const {
1109 auto* scroll_node =
1110 property_trees()->scroll_tree.Node(viewport_property_ids_.inner_scroll);
1111 return scroll_node ? LayerByElementId(scroll_node->element_id) : nullptr;
1112 }
1113
OuterViewportScrollLayerForTesting() const1114 Layer* LayerTreeHost::OuterViewportScrollLayerForTesting() const {
1115 auto* scroll_node =
1116 property_trees()->scroll_tree.Node(viewport_property_ids_.outer_scroll);
1117 return scroll_node ? LayerByElementId(scroll_node->element_id) : nullptr;
1118 }
1119
RegisterSelection(const LayerSelection & selection)1120 void LayerTreeHost::RegisterSelection(const LayerSelection& selection) {
1121 if (selection_ == selection)
1122 return;
1123
1124 selection_ = selection;
1125 SetNeedsCommit();
1126 }
1127
SetHaveScrollEventHandlers(bool have_event_handlers)1128 void LayerTreeHost::SetHaveScrollEventHandlers(bool have_event_handlers) {
1129 if (have_scroll_event_handlers_ == have_event_handlers)
1130 return;
1131
1132 have_scroll_event_handlers_ = have_event_handlers;
1133 SetNeedsCommit();
1134 }
1135
SetEventListenerProperties(EventListenerClass event_class,EventListenerProperties properties)1136 void LayerTreeHost::SetEventListenerProperties(
1137 EventListenerClass event_class,
1138 EventListenerProperties properties) {
1139 const size_t index = static_cast<size_t>(event_class);
1140 if (event_listener_properties_[index] == properties)
1141 return;
1142
1143 // If the mouse wheel event listener is blocking, then every layer in the
1144 // layer tree sets a wheel event handler region to be its entire bounds,
1145 // otherwise it sets it to empty.
1146 //
1147 // Thus when it changes, we want to request every layer to push properties
1148 // and recompute its wheel event handler region, since the computation is
1149 // done in PushPropertiesTo.
1150 if (event_class == EventListenerClass::kMouseWheel) {
1151 bool new_property_is_blocking =
1152 properties == EventListenerProperties::kBlocking ||
1153 properties == EventListenerProperties::kBlockingAndPassive;
1154 EventListenerProperties old_properties = event_listener_properties_[index];
1155 bool old_property_is_blocking =
1156 old_properties == EventListenerProperties::kBlocking ||
1157 old_properties == EventListenerProperties::kBlockingAndPassive;
1158
1159 if (old_property_is_blocking != new_property_is_blocking) {
1160 for (auto* layer : *this)
1161 layer->SetNeedsPushProperties();
1162 }
1163 }
1164
1165 event_listener_properties_[index] = properties;
1166 SetNeedsCommit();
1167 }
1168
SetViewportRectAndScale(const gfx::Rect & device_viewport_rect,float device_scale_factor,const viz::LocalSurfaceIdAllocation & local_surface_id_allocation_from_parent)1169 void LayerTreeHost::SetViewportRectAndScale(
1170 const gfx::Rect& device_viewport_rect,
1171 float device_scale_factor,
1172 const viz::LocalSurfaceIdAllocation&
1173 local_surface_id_allocation_from_parent) {
1174 const viz::LocalSurfaceId previous_local_surface_id =
1175 local_surface_id_allocation_from_parent_.local_surface_id();
1176 SetLocalSurfaceIdAllocationFromParent(
1177 local_surface_id_allocation_from_parent);
1178
1179 bool device_viewport_rect_changed = false;
1180 if (device_viewport_rect_ != device_viewport_rect) {
1181 device_viewport_rect_ = device_viewport_rect;
1182 device_viewport_rect_changed = true;
1183 }
1184 bool painted_device_scale_factor_changed = false;
1185 bool device_scale_factor_changed = false;
1186 if (settings_.use_painted_device_scale_factor) {
1187 DCHECK_EQ(device_scale_factor_, 1.f);
1188 if (painted_device_scale_factor_ != device_scale_factor) {
1189 painted_device_scale_factor_ = device_scale_factor;
1190 painted_device_scale_factor_changed = true;
1191 }
1192 } else {
1193 DCHECK_EQ(painted_device_scale_factor_, 1.f);
1194 if (device_scale_factor_ != device_scale_factor) {
1195 device_scale_factor_ = device_scale_factor;
1196 device_scale_factor_changed = true;
1197 }
1198 }
1199
1200 if (device_viewport_rect_changed || painted_device_scale_factor_changed ||
1201 device_scale_factor_changed) {
1202 SetPropertyTreesNeedRebuild();
1203 SetNeedsCommit();
1204 }
1205 }
1206
SetViewportVisibleRect(const gfx::Rect & visible_rect)1207 void LayerTreeHost::SetViewportVisibleRect(const gfx::Rect& visible_rect) {
1208 if (visible_rect == viewport_visible_rect_)
1209 return;
1210
1211 viewport_visible_rect_ = visible_rect;
1212 }
1213
SetBrowserControlsParams(const BrowserControlsParams & params)1214 void LayerTreeHost::SetBrowserControlsParams(
1215 const BrowserControlsParams& params) {
1216 if (browser_controls_params_ == params)
1217 return;
1218
1219 browser_controls_params_ = params;
1220 SetNeedsCommit();
1221 }
1222
SetBrowserControlsShownRatio(float top_ratio,float bottom_ratio)1223 void LayerTreeHost::SetBrowserControlsShownRatio(float top_ratio,
1224 float bottom_ratio) {
1225 if (top_controls_shown_ratio_ == top_ratio &&
1226 bottom_controls_shown_ratio_ == bottom_ratio)
1227 return;
1228
1229 top_controls_shown_ratio_ = top_ratio;
1230 bottom_controls_shown_ratio_ = bottom_ratio;
1231 SetNeedsCommit();
1232 }
1233
SetOverscrollBehavior(const OverscrollBehavior & behavior)1234 void LayerTreeHost::SetOverscrollBehavior(const OverscrollBehavior& behavior) {
1235 if (overscroll_behavior_ == behavior)
1236 return;
1237 overscroll_behavior_ = behavior;
1238 SetNeedsCommit();
1239 }
1240
SetPageScaleFactorAndLimits(float page_scale_factor,float min_page_scale_factor,float max_page_scale_factor)1241 void LayerTreeHost::SetPageScaleFactorAndLimits(float page_scale_factor,
1242 float min_page_scale_factor,
1243 float max_page_scale_factor) {
1244 if (page_scale_factor_ == page_scale_factor &&
1245 min_page_scale_factor_ == min_page_scale_factor &&
1246 max_page_scale_factor_ == max_page_scale_factor)
1247 return;
1248 DCHECK_GE(page_scale_factor, min_page_scale_factor);
1249 DCHECK_LE(page_scale_factor, max_page_scale_factor);
1250 // We should never process non-unit page_scale_delta for an OOPIF subframe.
1251 // TODO(wjmaclean): Remove this dcheck as a pre-condition to closing the bug.
1252 // https://crbug.com/845097
1253 DCHECK(!settings_.is_layer_tree_for_subframe ||
1254 page_scale_factor == page_scale_factor_)
1255 << "Setting PSF in oopif subframe: old psf = " << page_scale_factor_
1256 << ", new psf = " << page_scale_factor;
1257
1258 page_scale_factor_ = page_scale_factor;
1259 min_page_scale_factor_ = min_page_scale_factor;
1260 max_page_scale_factor_ = max_page_scale_factor;
1261 SetPropertyTreesNeedRebuild();
1262 SetNeedsCommit();
1263 }
1264
StartPageScaleAnimation(const gfx::Vector2d & target_offset,bool use_anchor,float scale,base::TimeDelta duration)1265 void LayerTreeHost::StartPageScaleAnimation(const gfx::Vector2d& target_offset,
1266 bool use_anchor,
1267 float scale,
1268 base::TimeDelta duration) {
1269 pending_page_scale_animation_.reset(new PendingPageScaleAnimation(
1270 target_offset, use_anchor, scale, duration));
1271
1272 SetNeedsCommit();
1273 }
1274
HasPendingPageScaleAnimation() const1275 bool LayerTreeHost::HasPendingPageScaleAnimation() const {
1276 return !!pending_page_scale_animation_.get();
1277 }
1278
SetRecordingScaleFactor(float recording_scale_factor)1279 void LayerTreeHost::SetRecordingScaleFactor(float recording_scale_factor) {
1280 if (recording_scale_factor_ == recording_scale_factor)
1281 return;
1282 recording_scale_factor_ = recording_scale_factor;
1283 }
1284
SetRasterColorSpace(const gfx::ColorSpace & raster_color_space)1285 void LayerTreeHost::SetRasterColorSpace(
1286 const gfx::ColorSpace& raster_color_space) {
1287 if (raster_color_space_ == raster_color_space)
1288 return;
1289 raster_color_space_ = raster_color_space;
1290 for (auto* layer : *this)
1291 layer->SetNeedsDisplay();
1292 }
1293
SetExternalPageScaleFactor(float page_scale_factor,bool is_external_pinch_gesture_active)1294 void LayerTreeHost::SetExternalPageScaleFactor(
1295 float page_scale_factor,
1296 bool is_external_pinch_gesture_active) {
1297 if (external_page_scale_factor_ == page_scale_factor &&
1298 is_external_pinch_gesture_active_ == is_external_pinch_gesture_active) {
1299 return;
1300 }
1301
1302 external_page_scale_factor_ = page_scale_factor;
1303 is_external_pinch_gesture_active_ = is_external_pinch_gesture_active;
1304 SetNeedsCommit();
1305 }
1306
SetLocalSurfaceIdAllocationFromParent(const viz::LocalSurfaceIdAllocation & local_surface_id_allocation_from_parent)1307 void LayerTreeHost::SetLocalSurfaceIdAllocationFromParent(
1308 const viz::LocalSurfaceIdAllocation&
1309 local_surface_id_allocation_from_parent) {
1310 const viz::LocalSurfaceId& local_surface_id_from_parent =
1311 local_surface_id_allocation_from_parent.local_surface_id();
1312 const viz::LocalSurfaceId current_local_surface_id_from_parent =
1313 local_surface_id_allocation_from_parent_.local_surface_id();
1314
1315 // If the viz::LocalSurfaceId is valid but the allocation time is invalid then
1316 // this API is not being used correctly.
1317 DCHECK_EQ(local_surface_id_from_parent.is_valid(),
1318 local_surface_id_allocation_from_parent.IsValid());
1319
1320 // These traces are split into two due to the usage of TRACE_ID_GLOBAL for the
1321 // incoming flow (it comes from a different process), and TRACE_ID_LOCAL for
1322 // the outgoing flow. The outgoing flow uses local to ensure that it doesn't
1323 // flow into the wrong trace in different process.
1324 TRACE_EVENT_WITH_FLOW2(
1325 TRACE_DISABLED_BY_DEFAULT("viz.surface_id_flow"),
1326 "LocalSurfaceId.Submission.Flow",
1327 TRACE_ID_GLOBAL(local_surface_id_from_parent.submission_trace_id()),
1328 TRACE_EVENT_FLAG_FLOW_IN, "step", "SetLocalSurfaceAllocationIdFromParent",
1329 "local_surface_id_allocation",
1330 local_surface_id_allocation_from_parent.ToString());
1331 TRACE_EVENT_WITH_FLOW2(
1332 TRACE_DISABLED_BY_DEFAULT("viz.surface_id_flow"),
1333 "LocalSurfaceId.Submission.Flow",
1334 TRACE_ID_LOCAL(local_surface_id_from_parent.submission_trace_id()),
1335 TRACE_EVENT_FLAG_FLOW_OUT, "step",
1336 "SetLocalSurfaceAllocationIdFromParent", "local_surface_id_allocation",
1337 local_surface_id_allocation_from_parent.ToString());
1338 // Always update the cached state of the viz::LocalSurfaceId to reflect the
1339 // latest value received from our parent.
1340 local_surface_id_allocation_from_parent_ =
1341 local_surface_id_allocation_from_parent;
1342
1343 // If the parent sequence number has not advanced, then there is no need to
1344 // commit anything. This can occur when the child sequence number has
1345 // advanced. Which means that child has changed visual properites, and the
1346 // parent agreed upon these without needing to further advance its sequence
1347 // number. When this occurs the child is already up-to-date and a commit here
1348 // is simply redundant.
1349 if (AreEmbedTokensEqual(current_local_surface_id_from_parent,
1350 local_surface_id_from_parent) &&
1351 AreParentSequencesEqual(current_local_surface_id_from_parent,
1352 local_surface_id_from_parent)) {
1353 return;
1354 }
1355 UpdateDeferMainFrameUpdateInternal();
1356 SetNeedsCommit();
1357 }
1358
RequestNewLocalSurfaceId()1359 void LayerTreeHost::RequestNewLocalSurfaceId() {
1360 // We can still request a new viz::LocalSurfaceId but that request will be
1361 // deferred until we have a valid viz::LocalSurfaceId from the parent.
1362 if (new_local_surface_id_request_)
1363 return;
1364 new_local_surface_id_request_ = true;
1365 SetNeedsCommit();
1366 }
1367
TakeNewLocalSurfaceIdRequest()1368 bool LayerTreeHost::TakeNewLocalSurfaceIdRequest() {
1369 bool new_local_surface_id_request = new_local_surface_id_request_;
1370 new_local_surface_id_request_ = false;
1371 return new_local_surface_id_request;
1372 }
1373
RegisterLayer(Layer * layer)1374 void LayerTreeHost::RegisterLayer(Layer* layer) {
1375 DCHECK(!LayerById(layer->id()));
1376 DCHECK(!in_paint_layer_contents_);
1377 layer_id_map_[layer->id()] = layer;
1378 if (!IsUsingLayerLists() && layer->element_id()) {
1379 mutator_host_->RegisterElementId(layer->element_id(),
1380 ElementListType::ACTIVE);
1381 }
1382 }
1383
UnregisterLayer(Layer * layer)1384 void LayerTreeHost::UnregisterLayer(Layer* layer) {
1385 DCHECK(LayerById(layer->id()));
1386 DCHECK(!in_paint_layer_contents_);
1387 if (!IsUsingLayerLists() && layer->element_id()) {
1388 mutator_host_->UnregisterElementId(layer->element_id(),
1389 ElementListType::ACTIVE);
1390 }
1391 layers_that_should_push_properties_.erase(layer);
1392 layer_id_map_.erase(layer->id());
1393 }
1394
LayerById(int id) const1395 Layer* LayerTreeHost::LayerById(int id) const {
1396 auto iter = layer_id_map_.find(id);
1397 return iter != layer_id_map_.end() ? iter->second : nullptr;
1398 }
1399
PaintContent(const LayerList & update_layer_list)1400 bool LayerTreeHost::PaintContent(const LayerList& update_layer_list) {
1401 base::AutoReset<bool> painting(&in_paint_layer_contents_, true);
1402 bool did_paint_content = false;
1403 for (const auto& layer : update_layer_list) {
1404 did_paint_content |= layer->Update();
1405 }
1406 return did_paint_content;
1407 }
1408
AddSurfaceRange(const viz::SurfaceRange & surface_range)1409 void LayerTreeHost::AddSurfaceRange(const viz::SurfaceRange& surface_range) {
1410 if (++surface_ranges_[surface_range] == 1)
1411 needs_surface_ranges_sync_ = true;
1412 }
1413
RemoveSurfaceRange(const viz::SurfaceRange & surface_range)1414 void LayerTreeHost::RemoveSurfaceRange(const viz::SurfaceRange& surface_range) {
1415 auto iter = surface_ranges_.find(surface_range);
1416 if (iter == surface_ranges_.end())
1417 return;
1418
1419 if (--iter->second <= 0) {
1420 surface_ranges_.erase(iter);
1421 needs_surface_ranges_sync_ = true;
1422 }
1423 }
1424
SurfaceRanges() const1425 base::flat_set<viz::SurfaceRange> LayerTreeHost::SurfaceRanges() const {
1426 base::flat_set<viz::SurfaceRange> ranges;
1427 for (auto& map_entry : surface_ranges_)
1428 ranges.insert(map_entry.first);
1429 return ranges;
1430 }
1431
AddLayerShouldPushProperties(Layer * layer)1432 void LayerTreeHost::AddLayerShouldPushProperties(Layer* layer) {
1433 layers_that_should_push_properties_.insert(layer);
1434 }
1435
RemoveLayerShouldPushProperties(Layer * layer)1436 void LayerTreeHost::RemoveLayerShouldPushProperties(Layer* layer) {
1437 layers_that_should_push_properties_.erase(layer);
1438 }
1439
ClearLayersThatShouldPushProperties()1440 void LayerTreeHost::ClearLayersThatShouldPushProperties() {
1441 layers_that_should_push_properties_.clear();
1442 }
1443
SetPageScaleFromImplSide(float page_scale)1444 void LayerTreeHost::SetPageScaleFromImplSide(float page_scale) {
1445 DCHECK(CommitRequested());
1446 // We should never process non-unit page_scale_delta for an OOPIF subframe.
1447 // TODO(wjmaclean): Remove this check as a pre-condition to closing the bug.
1448 // https://crbug.com/845097
1449 DCHECK(!settings_.is_layer_tree_for_subframe ||
1450 page_scale == page_scale_factor_)
1451 << "Setting PSF in oopif subframe: old psf = " << page_scale_factor_
1452 << ", new psf = " << page_scale;
1453 page_scale_factor_ = page_scale;
1454 SetPropertyTreesNeedRebuild();
1455 }
1456
SetElasticOverscrollFromImplSide(gfx::Vector2dF elastic_overscroll)1457 void LayerTreeHost::SetElasticOverscrollFromImplSide(
1458 gfx::Vector2dF elastic_overscroll) {
1459 DCHECK(CommitRequested());
1460 elastic_overscroll_ = elastic_overscroll;
1461 }
1462
UpdateHudLayer(bool show_hud_info)1463 void LayerTreeHost::UpdateHudLayer(bool show_hud_info) {
1464 if (show_hud_info) {
1465 if (!hud_layer_.get())
1466 hud_layer_ = HeadsUpDisplayLayer::Create();
1467 if (root_layer_.get() && !hud_layer_->parent())
1468 root_layer_->AddChild(hud_layer_);
1469 hud_layer_->UpdateLocationAndSize(device_viewport_rect_.size(),
1470 device_scale_factor_);
1471 } else if (hud_layer_.get()) {
1472 hud_layer_->RemoveFromParent();
1473 hud_layer_ = nullptr;
1474 }
1475 }
1476
is_hud_layer(const Layer * layer) const1477 bool LayerTreeHost::is_hud_layer(const Layer* layer) const {
1478 return hud_layer() == layer;
1479 }
1480
SetNeedsFullTreeSync()1481 void LayerTreeHost::SetNeedsFullTreeSync() {
1482 needs_full_tree_sync_ = true;
1483 property_trees_.needs_rebuild = true;
1484 SetNeedsCommit();
1485 }
1486
SetPropertyTreesNeedRebuild()1487 void LayerTreeHost::SetPropertyTreesNeedRebuild() {
1488 property_trees_.needs_rebuild = true;
1489 SetNeedsUpdateLayers();
1490 }
1491
PushLayerTreePropertiesTo(LayerTreeImpl * tree_impl)1492 void LayerTreeHost::PushLayerTreePropertiesTo(LayerTreeImpl* tree_impl) {
1493 tree_impl->set_needs_full_tree_sync(needs_full_tree_sync_);
1494 needs_full_tree_sync_ = false;
1495
1496 if (hud_layer_.get()) {
1497 LayerImpl* hud_impl = tree_impl->LayerById(hud_layer_->id());
1498 tree_impl->set_hud_layer(static_cast<HeadsUpDisplayLayerImpl*>(hud_impl));
1499 } else {
1500 tree_impl->set_hud_layer(nullptr);
1501 }
1502
1503 tree_impl->set_background_color(background_color_);
1504 tree_impl->set_have_scroll_event_handlers(have_scroll_event_handlers_);
1505 tree_impl->set_event_listener_properties(
1506 EventListenerClass::kTouchStartOrMove,
1507 event_listener_properties(EventListenerClass::kTouchStartOrMove));
1508 tree_impl->set_event_listener_properties(
1509 EventListenerClass::kMouseWheel,
1510 event_listener_properties(EventListenerClass::kMouseWheel));
1511 tree_impl->set_event_listener_properties(
1512 EventListenerClass::kTouchEndOrCancel,
1513 event_listener_properties(EventListenerClass::kTouchEndOrCancel));
1514
1515 tree_impl->SetViewportPropertyIds(viewport_property_ids_);
1516
1517 tree_impl->RegisterSelection(selection_);
1518
1519 tree_impl->PushPageScaleFromMainThread(
1520 page_scale_factor_, min_page_scale_factor_, max_page_scale_factor_);
1521
1522 tree_impl->SetBrowserControlsParams(browser_controls_params_);
1523 tree_impl->set_overscroll_behavior(overscroll_behavior_);
1524 tree_impl->PushBrowserControlsFromMainThread(top_controls_shown_ratio_,
1525 bottom_controls_shown_ratio_);
1526 tree_impl->elastic_overscroll()->PushMainToPending(elastic_overscroll_);
1527 if (tree_impl->IsActiveTree())
1528 tree_impl->elastic_overscroll()->PushPendingToActive();
1529
1530 tree_impl->SetRasterColorSpace(raster_color_space_);
1531 tree_impl->SetExternalPageScaleFactor(external_page_scale_factor_);
1532
1533 tree_impl->set_painted_device_scale_factor(painted_device_scale_factor_);
1534 tree_impl->SetDeviceScaleFactor(device_scale_factor_);
1535 tree_impl->SetDeviceViewportRect(device_viewport_rect_);
1536
1537 if (TakeNewLocalSurfaceIdRequest())
1538 tree_impl->RequestNewLocalSurfaceId();
1539
1540 tree_impl->SetLocalSurfaceIdAllocationFromParent(
1541 local_surface_id_allocation_from_parent_);
1542
1543 if (pending_page_scale_animation_) {
1544 tree_impl->SetPendingPageScaleAnimation(
1545 std::move(pending_page_scale_animation_));
1546 }
1547
1548 if (TakeForceSendMetadataRequest())
1549 tree_impl->RequestForceSendMetadata();
1550
1551 tree_impl->set_has_ever_been_drawn(false);
1552
1553 // TODO(ericrk): The viewport changes caused by |top_controls_shown_ratio_|
1554 // changes should propagate back to the main tree. This does not currently
1555 // happen, so we must force the impl tree to update its viewports if
1556 // |top_controls_shown_ratio_| is greater than 0.0f and less than 1.0f
1557 // (partially shown). crbug.com/875943
1558 if (top_controls_shown_ratio_ > 0.0f && top_controls_shown_ratio_ < 1.0f) {
1559 tree_impl->UpdateViewportContainerSizes();
1560 }
1561
1562 tree_impl->set_display_transform_hint(display_transform_hint_);
1563 }
1564
PushSurfaceRangesTo(LayerTreeImpl * tree_impl)1565 void LayerTreeHost::PushSurfaceRangesTo(LayerTreeImpl* tree_impl) {
1566 if (needs_surface_ranges_sync()) {
1567 tree_impl->ClearSurfaceRanges();
1568 tree_impl->SetSurfaceRanges(SurfaceRanges());
1569 // Reset for next update
1570 set_needs_surface_ranges_sync(false);
1571 }
1572 }
1573
PushLayerTreeHostPropertiesTo(LayerTreeHostImpl * host_impl)1574 void LayerTreeHost::PushLayerTreeHostPropertiesTo(
1575 LayerTreeHostImpl* host_impl) {
1576 host_impl->set_external_pinch_gesture_active(
1577 is_external_pinch_gesture_active_);
1578 RecordGpuRasterizationHistogram(host_impl);
1579
1580 host_impl->SetDebugState(debug_state_);
1581 }
1582
LayerByElementId(ElementId element_id) const1583 Layer* LayerTreeHost::LayerByElementId(ElementId element_id) const {
1584 auto iter = element_layers_map_.find(element_id);
1585 return iter != element_layers_map_.end() ? iter->second : nullptr;
1586 }
1587
RegisterElement(ElementId element_id,Layer * layer)1588 void LayerTreeHost::RegisterElement(ElementId element_id,
1589 Layer* layer) {
1590 element_layers_map_[element_id] = layer;
1591 if (!IsUsingLayerLists())
1592 mutator_host_->RegisterElementId(element_id, ElementListType::ACTIVE);
1593 }
1594
UnregisterElement(ElementId element_id)1595 void LayerTreeHost::UnregisterElement(ElementId element_id) {
1596 if (!IsUsingLayerLists())
1597 mutator_host_->UnregisterElementId(element_id, ElementListType::ACTIVE);
1598 element_layers_map_.erase(element_id);
1599 }
1600
UpdateActiveElements()1601 void LayerTreeHost::UpdateActiveElements() {
1602 DCHECK(IsUsingLayerLists());
1603 mutator_host_->UpdateRegisteredElementIds(ElementListType::ACTIVE);
1604 }
1605
SetElementIdsForTesting()1606 void LayerTreeHost::SetElementIdsForTesting() {
1607 for (auto* layer : *this)
1608 layer->SetElementId(LayerIdToElementIdForTesting(layer->id()));
1609 }
1610
BuildPropertyTreesForTesting()1611 void LayerTreeHost::BuildPropertyTreesForTesting() {
1612 PropertyTreeBuilder::BuildPropertyTrees(this);
1613 }
1614
IsElementInPropertyTrees(ElementId element_id,ElementListType list_type) const1615 bool LayerTreeHost::IsElementInPropertyTrees(ElementId element_id,
1616 ElementListType list_type) const {
1617 if (IsUsingLayerLists()) {
1618 return list_type == ElementListType::ACTIVE &&
1619 property_trees()->HasElement(element_id);
1620 }
1621 return list_type == ElementListType::ACTIVE && LayerByElementId(element_id);
1622 }
1623
SetMutatorsNeedCommit()1624 void LayerTreeHost::SetMutatorsNeedCommit() {
1625 SetNeedsCommit();
1626 }
1627
SetMutatorsNeedRebuildPropertyTrees()1628 void LayerTreeHost::SetMutatorsNeedRebuildPropertyTrees() {
1629 property_trees_.needs_rebuild = true;
1630 }
1631
SetElementFilterMutated(ElementId element_id,ElementListType list_type,const FilterOperations & filters)1632 void LayerTreeHost::SetElementFilterMutated(ElementId element_id,
1633 ElementListType list_type,
1634 const FilterOperations& filters) {
1635 if (IsUsingLayerLists()) {
1636 // In BlinkGenPropertyTrees/CompositeAfterPaint we always have property
1637 // tree nodes and can set the filter directly on the effect node.
1638 property_trees_.effect_tree.OnFilterAnimated(element_id, filters);
1639 return;
1640 }
1641
1642 Layer* layer = LayerByElementId(element_id);
1643 DCHECK(layer);
1644 layer->OnFilterAnimated(filters);
1645 }
1646
SetElementBackdropFilterMutated(ElementId element_id,ElementListType list_type,const FilterOperations & backdrop_filters)1647 void LayerTreeHost::SetElementBackdropFilterMutated(
1648 ElementId element_id,
1649 ElementListType list_type,
1650 const FilterOperations& backdrop_filters) {
1651 if (IsUsingLayerLists()) {
1652 // In BlinkGenPropertyTrees/CompositeAfterPaint we always have property
1653 // tree nodes and can set the backdrop_filter directly on the effect node.
1654 property_trees_.effect_tree.OnBackdropFilterAnimated(element_id,
1655 backdrop_filters);
1656 return;
1657 }
1658
1659 Layer* layer = LayerByElementId(element_id);
1660 DCHECK(layer);
1661 layer->OnBackdropFilterAnimated(backdrop_filters);
1662 }
1663
SetElementOpacityMutated(ElementId element_id,ElementListType list_type,float opacity)1664 void LayerTreeHost::SetElementOpacityMutated(ElementId element_id,
1665 ElementListType list_type,
1666 float opacity) {
1667 DCHECK_GE(opacity, 0.f);
1668 DCHECK_LE(opacity, 1.f);
1669
1670 if (IsUsingLayerLists()) {
1671 property_trees_.effect_tree.OnOpacityAnimated(element_id, opacity);
1672 return;
1673 }
1674
1675 Layer* layer = LayerByElementId(element_id);
1676 DCHECK(layer);
1677 layer->OnOpacityAnimated(opacity);
1678
1679 if (EffectNode* node =
1680 property_trees_.effect_tree.Node(layer->effect_tree_index())) {
1681 DCHECK_EQ(layer->effect_tree_index(), node->id);
1682 if (node->opacity == opacity)
1683 return;
1684
1685 node->opacity = opacity;
1686 property_trees_.effect_tree.set_needs_update(true);
1687 }
1688
1689 SetNeedsUpdateLayers();
1690 }
1691
SetElementTransformMutated(ElementId element_id,ElementListType list_type,const gfx::Transform & transform)1692 void LayerTreeHost::SetElementTransformMutated(
1693 ElementId element_id,
1694 ElementListType list_type,
1695 const gfx::Transform& transform) {
1696 if (IsUsingLayerLists()) {
1697 property_trees_.transform_tree.OnTransformAnimated(element_id, transform);
1698 return;
1699 }
1700
1701 Layer* layer = LayerByElementId(element_id);
1702 DCHECK(layer);
1703 layer->OnTransformAnimated(transform);
1704
1705 if (layer->has_transform_node()) {
1706 TransformNode* node =
1707 property_trees_.transform_tree.Node(layer->transform_tree_index());
1708 if (node->local == transform)
1709 return;
1710
1711 node->local = transform;
1712 node->needs_local_transform_update = true;
1713 node->has_potential_animation = true;
1714 property_trees_.transform_tree.set_needs_update(true);
1715 }
1716
1717 SetNeedsUpdateLayers();
1718 }
1719
SetElementScrollOffsetMutated(ElementId element_id,ElementListType list_type,const gfx::ScrollOffset & scroll_offset)1720 void LayerTreeHost::SetElementScrollOffsetMutated(
1721 ElementId element_id,
1722 ElementListType list_type,
1723 const gfx::ScrollOffset& scroll_offset) {
1724 // Do nothing. Scroll deltas will be sent from the compositor thread back
1725 // to the main thread in the same manner as during non-animated
1726 // compositor-driven scrolling.
1727 }
1728
ElementIsAnimatingChanged(const PropertyToElementIdMap & element_id_map,ElementListType list_type,const PropertyAnimationState & mask,const PropertyAnimationState & state)1729 void LayerTreeHost::ElementIsAnimatingChanged(
1730 const PropertyToElementIdMap& element_id_map,
1731 ElementListType list_type,
1732 const PropertyAnimationState& mask,
1733 const PropertyAnimationState& state) {
1734 DCHECK_EQ(ElementListType::ACTIVE, list_type);
1735 property_trees()->ElementIsAnimatingChanged(element_id_map, mask, state,
1736 true);
1737 }
1738
AnimationScalesChanged(ElementId element_id,ElementListType list_type,float maximum_scale,float starting_scale)1739 void LayerTreeHost::AnimationScalesChanged(ElementId element_id,
1740 ElementListType list_type,
1741 float maximum_scale,
1742 float starting_scale) {
1743 DCHECK_EQ(ElementListType::ACTIVE, list_type);
1744 property_trees()->AnimationScalesChanged(element_id, maximum_scale,
1745 starting_scale);
1746 }
1747
GetScrollOffsetForAnimation(ElementId element_id) const1748 gfx::ScrollOffset LayerTreeHost::GetScrollOffsetForAnimation(
1749 ElementId element_id) const {
1750 return property_trees()->scroll_tree.current_scroll_offset(element_id);
1751 }
1752
QueueImageDecode(const PaintImage & image,base::OnceCallback<void (bool)> callback)1753 void LayerTreeHost::QueueImageDecode(const PaintImage& image,
1754 base::OnceCallback<void(bool)> callback) {
1755 TRACE_EVENT0("cc", "LayerTreeHost::QueueImageDecode");
1756 queued_image_decodes_.emplace_back(image, std::move(callback));
1757 SetNeedsCommit();
1758 }
1759
begin() const1760 LayerListIterator LayerTreeHost::begin() const {
1761 return LayerListIterator(root_layer_.get());
1762 }
1763
end() const1764 LayerListIterator LayerTreeHost::end() const {
1765 return LayerListIterator(nullptr);
1766 }
1767
rbegin()1768 LayerListReverseIterator LayerTreeHost::rbegin() {
1769 return LayerListReverseIterator(root_layer_.get());
1770 }
1771
rend()1772 LayerListReverseIterator LayerTreeHost::rend() {
1773 return LayerListReverseIterator(nullptr);
1774 }
1775
SetPropertyTreesForTesting(const PropertyTrees * property_trees)1776 void LayerTreeHost::SetPropertyTreesForTesting(
1777 const PropertyTrees* property_trees) {
1778 property_trees_ = *property_trees;
1779 }
1780
SetNeedsDisplayOnAllLayers()1781 void LayerTreeHost::SetNeedsDisplayOnAllLayers() {
1782 for (auto* layer : *this)
1783 layer->SetNeedsDisplay();
1784 }
1785
SetHasCopyRequest(bool has_copy_request)1786 void LayerTreeHost::SetHasCopyRequest(bool has_copy_request) {
1787 has_copy_request_ = has_copy_request;
1788 }
1789
RequestBeginMainFrameNotExpected(bool new_state)1790 void LayerTreeHost::RequestBeginMainFrameNotExpected(bool new_state) {
1791 proxy_->RequestBeginMainFrameNotExpected(new_state);
1792 }
1793
SetSourceURL(ukm::SourceId source_id,const GURL & url)1794 void LayerTreeHost::SetSourceURL(ukm::SourceId source_id, const GURL& url) {
1795 // Clears image caches and resets the scheduling history for the content
1796 // produced by this host so far.
1797 clear_caches_on_next_commit_ = true;
1798 proxy_->SetSourceURL(source_id, url);
1799 }
1800
SetRenderFrameObserver(std::unique_ptr<RenderFrameMetadataObserver> observer)1801 void LayerTreeHost::SetRenderFrameObserver(
1802 std::unique_ptr<RenderFrameMetadataObserver> observer) {
1803 proxy_->SetRenderFrameObserver(std::move(observer));
1804 }
1805
TakeForceSendMetadataRequest()1806 bool LayerTreeHost::TakeForceSendMetadataRequest() {
1807 bool force_send_metadata_request = force_send_metadata_request_;
1808 force_send_metadata_request_ = false;
1809 return force_send_metadata_request;
1810 }
1811
1812 } // namespace cc
1813