[email protected] | 94f206c1 | 2012-08-25 00:09:14 | [diff] [blame] | 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 | |
[email protected] | 556fd29 | 2013-03-18 08:03:04 | [diff] [blame] | 5 | #include "cc/trees/single_thread_proxy.h" |
[email protected] | 94f206c1 | 2012-08-25 00:09:14 | [diff] [blame] | 6 | |
[email protected] | 74d9063c | 2013-01-18 03:14:47 | [diff] [blame] | 7 | #include "base/auto_reset.h" |
danakj | 60bc3bc | 2016-04-09 00:24:48 | [diff] [blame] | 8 | #include "base/memory/ptr_util.h" |
primiano | c06e238 | 2015-01-28 04:21:49 | [diff] [blame] | 9 | #include "base/trace_event/trace_event.h" |
chrishtr | 82b5d950 | 2017-03-20 18:25:33 | [diff] [blame] | 10 | #include "cc/base/devtools_instrumentation.h" |
| 11 | #include "cc/benchmarks/benchmark_instrumentation.h" |
David Bokan | 1e37ebf | 2018-10-16 13:53:37 | [diff] [blame] | 12 | #include "cc/input/browser_controls_offset_manager.h" |
khushalsagar | 8ec0740 | 2016-09-10 03:13:19 | [diff] [blame] | 13 | #include "cc/resources/ui_resource_manager.h" |
mithro | f7a2150 | 2014-12-17 03:24:48 | [diff] [blame] | 14 | #include "cc/scheduler/commit_earlyout_reason.h" |
brianderson | c9f5035 | 2015-06-24 03:38:58 | [diff] [blame] | 15 | #include "cc/scheduler/compositor_timing_history.h" |
| 16 | #include "cc/scheduler/scheduler.h" |
Brian Anderson | 242b9b0 | 2017-12-06 21:06:26 | [diff] [blame] | 17 | #include "cc/trees/latency_info_swap_promise.h" |
danakj | ba65a091 | 2017-09-21 16:38:42 | [diff] [blame] | 18 | #include "cc/trees/layer_tree_frame_sink.h" |
khushalsagar | e0e4486e | 2017-01-25 03:15:03 | [diff] [blame] | 19 | #include "cc/trees/layer_tree_host.h" |
jaydasika | 13c0506 | 2016-04-01 18:12:27 | [diff] [blame] | 20 | #include "cc/trees/layer_tree_host_common.h" |
[email protected] | 943528e | 2013-11-07 05:01:32 | [diff] [blame] | 21 | #include "cc/trees/layer_tree_host_single_thread_client.h" |
[email protected] | 556fd29 | 2013-03-18 08:03:04 | [diff] [blame] | 22 | #include "cc/trees/layer_tree_impl.h" |
loyso | c601b7b8 | 2016-11-10 02:56:44 | [diff] [blame] | 23 | #include "cc/trees/mutator_host.h" |
jonross | a2ff4f8 | 2018-02-16 17:27:46 | [diff] [blame] | 24 | #include "cc/trees/render_frame_metadata_observer.h" |
[email protected] | aeeedad | 2014-08-22 18:16:22 | [diff] [blame] | 25 | #include "cc/trees/scoped_abort_remaining_swap_promises.h" |
Fady Samuel | c645ffe | 2017-07-24 17:28:20 | [diff] [blame] | 26 | #include "components/viz/common/frame_sinks/delay_based_time_source.h" |
Xu Xing | 3254916 | 2017-07-17 22:25:43 | [diff] [blame] | 27 | #include "components/viz/common/gpu/context_provider.h" |
[email protected] | 94f206c1 | 2012-08-25 00:09:14 | [diff] [blame] | 28 | |
[email protected] | 9c88e56 | 2012-09-14 22:21:30 | [diff] [blame] | 29 | namespace cc { |
[email protected] | 94f206c1 | 2012-08-25 00:09:14 | [diff] [blame] | 30 | |
danakj | 60bc3bc | 2016-04-09 00:24:48 | [diff] [blame] | 31 | std::unique_ptr<Proxy> SingleThreadProxy::Create( |
khushalsagar | e0e4486e | 2017-01-25 03:15:03 | [diff] [blame] | 32 | LayerTreeHost* layer_tree_host, |
[email protected] | 27e6a21 | 2014-07-18 15:51:27 | [diff] [blame] | 33 | LayerTreeHostSingleThreadClient* client, |
khushalsagar | 767dd52 | 2015-12-16 05:14:05 | [diff] [blame] | 34 | TaskRunnerProvider* task_runner_provider) { |
danakj | 60bc3bc | 2016-04-09 00:24:48 | [diff] [blame] | 35 | return base::WrapUnique( |
khushalsagar | 767dd52 | 2015-12-16 05:14:05 | [diff] [blame] | 36 | new SingleThreadProxy(layer_tree_host, client, task_runner_provider)); |
[email protected] | 94f206c1 | 2012-08-25 00:09:14 | [diff] [blame] | 37 | } |
| 38 | |
khushalsagar | e0e4486e | 2017-01-25 03:15:03 | [diff] [blame] | 39 | SingleThreadProxy::SingleThreadProxy(LayerTreeHost* layer_tree_host, |
khushalsagar | 767dd52 | 2015-12-16 05:14:05 | [diff] [blame] | 40 | LayerTreeHostSingleThreadClient* client, |
| 41 | TaskRunnerProvider* task_runner_provider) |
khushalsagar | b7db1fe | 2015-11-12 00:51:27 | [diff] [blame] | 42 | : layer_tree_host_(layer_tree_host), |
danakj | 6c872fc0 | 2016-10-22 04:29:49 | [diff] [blame] | 43 | single_thread_client_(client), |
khushalsagar | b7db1fe | 2015-11-12 00:51:27 | [diff] [blame] | 44 | task_runner_provider_(task_runner_provider), |
[email protected] | a8a049c | 2013-03-11 23:27:06 | [diff] [blame] | 45 | next_frame_is_newly_committed_frame_(false), |
mithro | 51693e38 | 2015-05-07 23:52:41 | [diff] [blame] | 46 | #if DCHECK_IS_ON() |
mithro | 69fd3bb5 | 2015-05-01 03:45:02 | [diff] [blame] | 47 | inside_impl_frame_(false), |
mithro | 51693e38 | 2015-05-07 23:52:41 | [diff] [blame] | 48 | #endif |
[email protected] | aeeedad | 2014-08-22 18:16:22 | [diff] [blame] | 49 | inside_draw_(false), |
Stephen Chenney | 6d3f5ce | 2018-11-14 02:08:05 | [diff] [blame] | 50 | defer_main_frame_update_(false), |
brianderson | 49e101d2 | 2015-04-29 00:05:33 | [diff] [blame] | 51 | animate_requested_(false), |
[email protected] | aeeedad | 2014-08-22 18:16:22 | [diff] [blame] | 52 | commit_requested_(false), |
jbauman | 399aec1a | 2014-10-25 02:33:32 | [diff] [blame] | 53 | inside_synchronous_composite_(false), |
David Bokan | eaa5cc8 | 2018-10-12 15:50:40 | [diff] [blame] | 54 | needs_impl_frame_(false), |
danakj | c7afae5 | 2017-06-20 21:12:41 | [diff] [blame] | 55 | layer_tree_frame_sink_creation_requested_(false), |
| 56 | layer_tree_frame_sink_lost_(true), |
samans | 44b6dfc | 2017-04-19 16:50:53 | [diff] [blame] | 57 | frame_sink_bound_weak_factory_(this), |
[email protected] | aeeedad | 2014-08-22 18:16:22 | [diff] [blame] | 58 | weak_factory_(this) { |
[email protected] | a8a049c | 2013-03-11 23:27:06 | [diff] [blame] | 59 | TRACE_EVENT0("cc", "SingleThreadProxy::SingleThreadProxy"); |
khushalsagar | b7db1fe | 2015-11-12 00:51:27 | [diff] [blame] | 60 | DCHECK(task_runner_provider_); |
| 61 | DCHECK(task_runner_provider_->IsMainThread()); |
[email protected] | a8a049c | 2013-03-11 23:27:06 | [diff] [blame] | 62 | DCHECK(layer_tree_host); |
khushalsagar | 767dd52 | 2015-12-16 05:14:05 | [diff] [blame] | 63 | } |
danakj | fcdaba12 | 2015-04-24 21:41:52 | [diff] [blame] | 64 | |
enne | 2b0ad68 | 2016-09-21 01:44:47 | [diff] [blame] | 65 | void SingleThreadProxy::Start() { |
khushalsagar | 767dd52 | 2015-12-16 05:14:05 | [diff] [blame] | 66 | DebugScopedSetImplThread impl(task_runner_provider_); |
khushalsagar | 767dd52 | 2015-12-16 05:14:05 | [diff] [blame] | 67 | |
khushalsagar | cebe494 | 2016-09-07 23:27:01 | [diff] [blame] | 68 | const LayerTreeSettings& settings = layer_tree_host_->GetSettings(); |
khushalsagar | 6dc91d0 | 2017-02-28 05:10:07 | [diff] [blame] | 69 | DCHECK(settings.single_thread_proxy_scheduler || |
| 70 | !settings.enable_checker_imaging) |
| 71 | << "Checker-imaging is not supported in synchronous single threaded mode"; |
khushalsagar | cebe494 | 2016-09-07 23:27:01 | [diff] [blame] | 72 | if (settings.single_thread_proxy_scheduler && !scheduler_on_impl_thread_) { |
| 73 | SchedulerSettings scheduler_settings(settings.ToSchedulerSettings()); |
danakj | 5f2e92de | 2015-06-20 00:25:58 | [diff] [blame] | 74 | scheduler_settings.commit_to_active_tree = CommitToActiveTree(); |
brianderson | c9f5035 | 2015-06-24 03:38:58 | [diff] [blame] | 75 | |
danakj | 60bc3bc | 2016-04-09 00:24:48 | [diff] [blame] | 76 | std::unique_ptr<CompositorTimingHistory> compositor_timing_history( |
brianderson | c9f5035 | 2015-06-24 03:38:58 | [diff] [blame] | 77 | new CompositorTimingHistory( |
brianderson | bb917dd | 2016-02-20 05:21:14 | [diff] [blame] | 78 | scheduler_settings.using_synchronous_renderer_compositor, |
brianderson | c68220f | 2015-07-20 20:08:35 | [diff] [blame] | 79 | CompositorTimingHistory::BROWSER_UMA, |
khushalsagar | 767dd52 | 2015-12-16 05:14:05 | [diff] [blame] | 80 | layer_tree_host_->rendering_stats_instrumentation())); |
enne | 2b0ad68 | 2016-09-21 01:44:47 | [diff] [blame] | 81 | scheduler_on_impl_thread_.reset( |
| 82 | new Scheduler(this, scheduler_settings, layer_tree_host_->GetId(), |
| 83 | task_runner_provider_->MainThreadTaskRunner(), |
| 84 | std::move(compositor_timing_history))); |
danakj | fcdaba12 | 2015-04-24 21:41:52 | [diff] [blame] | 85 | } |
[email protected] | 94f206c1 | 2012-08-25 00:09:14 | [diff] [blame] | 86 | |
Walter Korman | aa326e4 | 2017-08-22 23:04:43 | [diff] [blame] | 87 | host_impl_ = layer_tree_host_->CreateLayerTreeHostImpl(this); |
[email protected] | a8a049c | 2013-03-11 23:27:06 | [diff] [blame] | 88 | } |
| 89 | |
| 90 | SingleThreadProxy::~SingleThreadProxy() { |
| 91 | TRACE_EVENT0("cc", "SingleThreadProxy::~SingleThreadProxy"); |
khushalsagar | b7db1fe | 2015-11-12 00:51:27 | [diff] [blame] | 92 | DCHECK(task_runner_provider_->IsMainThread()); |
[email protected] | 04049fc | 2013-05-01 03:13:20 | [diff] [blame] | 93 | // Make sure Stop() got called or never Started. |
Walter Korman | aa326e4 | 2017-08-22 23:04:43 | [diff] [blame] | 94 | DCHECK(!host_impl_); |
[email protected] | a8a049c | 2013-03-11 23:27:06 | [diff] [blame] | 95 | } |
| 96 | |
[email protected] | a8a049c | 2013-03-11 23:27:06 | [diff] [blame] | 97 | bool SingleThreadProxy::IsStarted() const { |
khushalsagar | b7db1fe | 2015-11-12 00:51:27 | [diff] [blame] | 98 | DCHECK(task_runner_provider_->IsMainThread()); |
Walter Korman | aa326e4 | 2017-08-22 23:04:43 | [diff] [blame] | 99 | return !!host_impl_; |
[email protected] | 94f206c1 | 2012-08-25 00:09:14 | [diff] [blame] | 100 | } |
| 101 | |
danakj | 009cdfdf | 2015-02-17 22:35:14 | [diff] [blame] | 102 | bool SingleThreadProxy::CommitToActiveTree() const { |
| 103 | // With SingleThreadProxy we skip the pending tree and commit directly to the |
| 104 | // active tree. |
| 105 | return true; |
| 106 | } |
| 107 | |
[email protected] | a8a049c | 2013-03-11 23:27:06 | [diff] [blame] | 108 | void SingleThreadProxy::SetVisible(bool visible) { |
mithro | 46adf5a | 2014-11-19 14:52:40 | [diff] [blame] | 109 | TRACE_EVENT1("cc", "SingleThreadProxy::SetVisible", "visible", visible); |
khushalsagar | b7db1fe | 2015-11-12 00:51:27 | [diff] [blame] | 110 | DebugScopedSetImplThread impl(task_runner_provider_); |
sunnyps | c3f6e0c | 2015-07-25 01:00:59 | [diff] [blame] | 111 | |
Walter Korman | aa326e4 | 2017-08-22 23:04:43 | [diff] [blame] | 112 | host_impl_->SetVisible(visible); |
sunnyps | c3f6e0c | 2015-07-25 01:00:59 | [diff] [blame] | 113 | |
[email protected] | aeeedad | 2014-08-22 18:16:22 | [diff] [blame] | 114 | if (scheduler_on_impl_thread_) |
Walter Korman | aa326e4 | 2017-08-22 23:04:43 | [diff] [blame] | 115 | scheduler_on_impl_thread_->SetVisible(host_impl_->visible()); |
[email protected] | a8a049c | 2013-03-11 23:27:06 | [diff] [blame] | 116 | } |
| 117 | |
danakj | c7afae5 | 2017-06-20 21:12:41 | [diff] [blame] | 118 | void SingleThreadProxy::RequestNewLayerTreeFrameSink() { |
khushalsagar | b7db1fe | 2015-11-12 00:51:27 | [diff] [blame] | 119 | DCHECK(task_runner_provider_->IsMainThread()); |
danakj | c7afae5 | 2017-06-20 21:12:41 | [diff] [blame] | 120 | layer_tree_frame_sink_creation_callback_.Cancel(); |
| 121 | if (layer_tree_frame_sink_creation_requested_) |
jbauman | 8ab0f9e | 2014-10-15 02:30:34 | [diff] [blame] | 122 | return; |
danakj | c7afae5 | 2017-06-20 21:12:41 | [diff] [blame] | 123 | layer_tree_frame_sink_creation_requested_ = true; |
| 124 | layer_tree_host_->RequestNewLayerTreeFrameSink(); |
enne | 2097cab | 2014-09-25 20:16:31 | [diff] [blame] | 125 | } |
[email protected] | 94f206c1 | 2012-08-25 00:09:14 | [diff] [blame] | 126 | |
danakj | c7afae5 | 2017-06-20 21:12:41 | [diff] [blame] | 127 | void SingleThreadProxy::ReleaseLayerTreeFrameSink() { |
| 128 | layer_tree_frame_sink_lost_ = true; |
samans | 44b6dfc | 2017-04-19 16:50:53 | [diff] [blame] | 129 | frame_sink_bound_weak_factory_.InvalidateWeakPtrs(); |
sohan.jyoti | 3a33d87 | 2015-09-18 22:32:55 | [diff] [blame] | 130 | if (scheduler_on_impl_thread_) |
danakj | c7afae5 | 2017-06-20 21:12:41 | [diff] [blame] | 131 | scheduler_on_impl_thread_->DidLoseLayerTreeFrameSink(); |
Walter Korman | aa326e4 | 2017-08-22 23:04:43 | [diff] [blame] | 132 | return host_impl_->ReleaseLayerTreeFrameSink(); |
sohan.jyoti | 3a33d87 | 2015-09-18 22:32:55 | [diff] [blame] | 133 | } |
| 134 | |
danakj | c7afae5 | 2017-06-20 21:12:41 | [diff] [blame] | 135 | void SingleThreadProxy::SetLayerTreeFrameSink( |
| 136 | LayerTreeFrameSink* layer_tree_frame_sink) { |
khushalsagar | b7db1fe | 2015-11-12 00:51:27 | [diff] [blame] | 137 | DCHECK(task_runner_provider_->IsMainThread()); |
danakj | c7afae5 | 2017-06-20 21:12:41 | [diff] [blame] | 138 | DCHECK(layer_tree_frame_sink_creation_requested_); |
[email protected] | da8e3b72b | 2014-04-25 02:33:45 | [diff] [blame] | 139 | |
enne | 7f8fdde | 2014-12-10 21:32:09 | [diff] [blame] | 140 | bool success; |
| 141 | { |
khushalsagar | b7db1fe | 2015-11-12 00:51:27 | [diff] [blame] | 142 | DebugScopedSetMainThreadBlocked main_thread_blocked(task_runner_provider_); |
| 143 | DebugScopedSetImplThread impl(task_runner_provider_); |
Xu Xing | 31616b9 | 2018-06-28 00:24:27 | [diff] [blame] | 144 | success = host_impl_->InitializeFrameSink(layer_tree_frame_sink); |
[email protected] | 04049fc | 2013-05-01 03:13:20 | [diff] [blame] | 145 | } |
| 146 | |
[email protected] | aeeedad | 2014-08-22 18:16:22 | [diff] [blame] | 147 | if (success) { |
samans | 44b6dfc | 2017-04-19 16:50:53 | [diff] [blame] | 148 | frame_sink_bound_weak_ptr_ = frame_sink_bound_weak_factory_.GetWeakPtr(); |
danakj | c7afae5 | 2017-06-20 21:12:41 | [diff] [blame] | 149 | layer_tree_host_->DidInitializeLayerTreeFrameSink(); |
[email protected] | aeeedad | 2014-08-22 18:16:22 | [diff] [blame] | 150 | if (scheduler_on_impl_thread_) |
danakj | c7afae5 | 2017-06-20 21:12:41 | [diff] [blame] | 151 | scheduler_on_impl_thread_->DidCreateAndInitializeLayerTreeFrameSink(); |
jbauman | 399aec1a | 2014-10-25 02:33:32 | [diff] [blame] | 152 | else if (!inside_synchronous_composite_) |
| 153 | SetNeedsCommit(); |
danakj | c7afae5 | 2017-06-20 21:12:41 | [diff] [blame] | 154 | layer_tree_frame_sink_creation_requested_ = false; |
| 155 | layer_tree_frame_sink_lost_ = false; |
enne | 7f8fdde | 2014-12-10 21:32:09 | [diff] [blame] | 156 | } else { |
danakj | c7afae5 | 2017-06-20 21:12:41 | [diff] [blame] | 157 | // DidFailToInitializeLayerTreeFrameSink is treated as a |
| 158 | // RequestNewLayerTreeFrameSink, and so |
| 159 | // layer_tree_frame_sink_creation_requested remains true. |
| 160 | layer_tree_host_->DidFailToInitializeLayerTreeFrameSink(); |
[email protected] | 04049fc | 2013-05-01 03:13:20 | [diff] [blame] | 161 | } |
[email protected] | 94f206c1 | 2012-08-25 00:09:14 | [diff] [blame] | 162 | } |
| 163 | |
[email protected] | 8b9e52b | 2014-01-17 16:35:31 | [diff] [blame] | 164 | void SingleThreadProxy::SetNeedsAnimate() { |
[email protected] | ccc08dc | 2014-01-30 07:33:20 | [diff] [blame] | 165 | TRACE_EVENT0("cc", "SingleThreadProxy::SetNeedsAnimate"); |
khushalsagar | b7db1fe | 2015-11-12 00:51:27 | [diff] [blame] | 166 | DCHECK(task_runner_provider_->IsMainThread()); |
danakj | 6c872fc0 | 2016-10-22 04:29:49 | [diff] [blame] | 167 | single_thread_client_->RequestScheduleAnimation(); |
brianderson | 49e101d2 | 2015-04-29 00:05:33 | [diff] [blame] | 168 | if (animate_requested_) |
| 169 | return; |
| 170 | animate_requested_ = true; |
khushalsagar | b7db1fe | 2015-11-12 00:51:27 | [diff] [blame] | 171 | DebugScopedSetImplThread impl(task_runner_provider_); |
brianderson | 49e101d2 | 2015-04-29 00:05:33 | [diff] [blame] | 172 | if (scheduler_on_impl_thread_) |
mithro | e77254b3 | 2015-07-22 09:36:01 | [diff] [blame] | 173 | scheduler_on_impl_thread_->SetNeedsBeginMainFrame(); |
[email protected] | c513417 | 2013-12-11 06:19:48 | [diff] [blame] | 174 | } |
| 175 | |
[email protected] | 8b9e52b | 2014-01-17 16:35:31 | [diff] [blame] | 176 | void SingleThreadProxy::SetNeedsUpdateLayers() { |
[email protected] | ccc08dc | 2014-01-30 07:33:20 | [diff] [blame] | 177 | TRACE_EVENT0("cc", "SingleThreadProxy::SetNeedsUpdateLayers"); |
khushalsagar | b7db1fe | 2015-11-12 00:51:27 | [diff] [blame] | 178 | DCHECK(task_runner_provider_->IsMainThread()); |
[email protected] | aeeedad | 2014-08-22 18:16:22 | [diff] [blame] | 179 | SetNeedsCommit(); |
[email protected] | 8b9e52b | 2014-01-17 16:35:31 | [diff] [blame] | 180 | } |
| 181 | |
enne | 98f3a6c | 2014-10-09 20:09:44 | [diff] [blame] | 182 | void SingleThreadProxy::DoCommit() { |
[email protected] | ccc08dc | 2014-01-30 07:33:20 | [diff] [blame] | 183 | TRACE_EVENT0("cc", "SingleThreadProxy::DoCommit"); |
khushalsagar | b7db1fe | 2015-11-12 00:51:27 | [diff] [blame] | 184 | DCHECK(task_runner_provider_->IsMainThread()); |
enne | 98f3a6c | 2014-10-09 20:09:44 | [diff] [blame] | 185 | |
[email protected] | aeeedad | 2014-08-22 18:16:22 | [diff] [blame] | 186 | layer_tree_host_->WillCommit(); |
caseq | 7d2f4c9 | 2015-02-04 16:43:27 | [diff] [blame] | 187 | devtools_instrumentation::ScopedCommitTrace commit_task( |
khushalsagar | cebe494 | 2016-09-07 23:27:01 | [diff] [blame] | 188 | layer_tree_host_->GetId()); |
[email protected] | aeeedad | 2014-08-22 18:16:22 | [diff] [blame] | 189 | |
[email protected] | a8a049c | 2013-03-11 23:27:06 | [diff] [blame] | 190 | // Commit immediately. |
| 191 | { |
khushalsagar | b7db1fe | 2015-11-12 00:51:27 | [diff] [blame] | 192 | DebugScopedSetMainThreadBlocked main_thread_blocked(task_runner_provider_); |
| 193 | DebugScopedSetImplThread impl(task_runner_provider_); |
[email protected] | f7c01c8 | 2013-07-02 22:58:46 | [diff] [blame] | 194 | |
Walter Korman | aa326e4 | 2017-08-22 23:04:43 | [diff] [blame] | 195 | host_impl_->ReadyToCommit(); |
| 196 | host_impl_->BeginCommit(); |
[email protected] | 94f206c1 | 2012-08-25 00:09:14 | [diff] [blame] | 197 | |
Walter Korman | aa326e4 | 2017-08-22 23:04:43 | [diff] [blame] | 198 | if (host_impl_->EvictedUIResourcesExist()) |
khushalsagar | 8ec0740 | 2016-09-10 03:13:19 | [diff] [blame] | 199 | layer_tree_host_->GetUIResourceManager()->RecreateUIResources(); |
[email protected] | 127bdc1a | 2013-09-11 01:44:48 | [diff] [blame] | 200 | |
Walter Korman | aa326e4 | 2017-08-22 23:04:43 | [diff] [blame] | 201 | layer_tree_host_->FinishCommitOnImplThread(host_impl_.get()); |
[email protected] | 94f206c1 | 2012-08-25 00:09:14 | [diff] [blame] | 202 | |
danakj | 3c3973b | 2015-08-25 21:50:18 | [diff] [blame] | 203 | if (scheduler_on_impl_thread_) |
| 204 | scheduler_on_impl_thread_->DidCommit(); |
| 205 | |
vmpstr | a840c6a | 2017-06-01 21:50:39 | [diff] [blame] | 206 | IssueImageDecodeFinishedCallbacks(); |
Walter Korman | aa326e4 | 2017-08-22 23:04:43 | [diff] [blame] | 207 | host_impl_->CommitComplete(); |
danakj | 3c3973b | 2015-08-25 21:50:18 | [diff] [blame] | 208 | |
danakj | 68803fc | 2015-06-19 20:55:53 | [diff] [blame] | 209 | // Commit goes directly to the active tree, but we need to synchronously |
| 210 | // "activate" the tree still during commit to satisfy any potential |
| 211 | // SetNextCommitWaitsForActivation calls. Unfortunately, the tree |
| 212 | // might not be ready to draw, so DidActivateSyncTree must set |
| 213 | // the flag to force the tree to not draw until textures are ready. |
| 214 | NotifyReadyToActivate(); |
enne | 98f3a6c | 2014-10-09 20:09:44 | [diff] [blame] | 215 | } |
| 216 | } |
| 217 | |
vmpstr | a840c6a | 2017-06-01 21:50:39 | [diff] [blame] | 218 | void SingleThreadProxy::IssueImageDecodeFinishedCallbacks() { |
| 219 | DCHECK(task_runner_provider_->IsImplThread()); |
| 220 | |
Vladimir Levin | bed5b37 | 2017-10-26 23:46:31 | [diff] [blame] | 221 | layer_tree_host_->ImageDecodesFinished( |
| 222 | host_impl_->TakeCompletedImageDecodeRequests()); |
vmpstr | a840c6a | 2017-06-01 21:50:39 | [diff] [blame] | 223 | } |
| 224 | |
enne | 98f3a6c | 2014-10-09 20:09:44 | [diff] [blame] | 225 | void SingleThreadProxy::CommitComplete() { |
danakj | 3c3973b | 2015-08-25 21:50:18 | [diff] [blame] | 226 | // Commit complete happens on the main side after activate to satisfy any |
| 227 | // SetNextCommitWaitsForActivation calls. |
Walter Korman | aa326e4 | 2017-08-22 23:04:43 | [diff] [blame] | 228 | DCHECK(!host_impl_->pending_tree()) |
enne | 98f3a6c | 2014-10-09 20:09:44 | [diff] [blame] | 229 | << "Activation is expected to have synchronously occurred by now."; |
enne | 98f3a6c | 2014-10-09 20:09:44 | [diff] [blame] | 230 | |
khushalsagar | b7db1fe | 2015-11-12 00:51:27 | [diff] [blame] | 231 | DebugScopedSetMainThread main(task_runner_provider_); |
[email protected] | 804c898 | 2013-03-13 16:32:21 | [diff] [blame] | 232 | layer_tree_host_->CommitComplete(); |
[email protected] | aeeedad | 2014-08-22 18:16:22 | [diff] [blame] | 233 | layer_tree_host_->DidBeginMainFrame(); |
[email protected] | aeeedad | 2014-08-22 18:16:22 | [diff] [blame] | 234 | |
[email protected] | a8a049c | 2013-03-11 23:27:06 | [diff] [blame] | 235 | next_frame_is_newly_committed_frame_ = true; |
[email protected] | 94f206c1 | 2012-08-25 00:09:14 | [diff] [blame] | 236 | } |
| 237 | |
[email protected] | a8a049c | 2013-03-11 23:27:06 | [diff] [blame] | 238 | void SingleThreadProxy::SetNeedsCommit() { |
khushalsagar | b7db1fe | 2015-11-12 00:51:27 | [diff] [blame] | 239 | DCHECK(task_runner_provider_->IsMainThread()); |
danakj | 6c872fc0 | 2016-10-22 04:29:49 | [diff] [blame] | 240 | single_thread_client_->RequestScheduleComposite(); |
danakj | fcdaba12 | 2015-04-24 21:41:52 | [diff] [blame] | 241 | if (commit_requested_) |
| 242 | return; |
brianderson | 49e101d2 | 2015-04-29 00:05:33 | [diff] [blame] | 243 | commit_requested_ = true; |
khushalsagar | b7db1fe | 2015-11-12 00:51:27 | [diff] [blame] | 244 | DebugScopedSetImplThread impl(task_runner_provider_); |
[email protected] | aeeedad | 2014-08-22 18:16:22 | [diff] [blame] | 245 | if (scheduler_on_impl_thread_) |
mithro | e77254b3 | 2015-07-22 09:36:01 | [diff] [blame] | 246 | scheduler_on_impl_thread_->SetNeedsBeginMainFrame(); |
[email protected] | 94f206c1 | 2012-08-25 00:09:14 | [diff] [blame] | 247 | } |
| 248 | |
[email protected] | 0023fc7 | 2014-01-10 20:05:06 | [diff] [blame] | 249 | void SingleThreadProxy::SetNeedsRedraw(const gfx::Rect& damage_rect) { |
[email protected] | ccc08dc | 2014-01-30 07:33:20 | [diff] [blame] | 250 | TRACE_EVENT0("cc", "SingleThreadProxy::SetNeedsRedraw"); |
khushalsagar | b7db1fe | 2015-11-12 00:51:27 | [diff] [blame] | 251 | DCHECK(task_runner_provider_->IsMainThread()); |
| 252 | DebugScopedSetImplThread impl(task_runner_provider_); |
Walter Korman | aa326e4 | 2017-08-22 23:04:43 | [diff] [blame] | 253 | host_impl_->SetViewportDamage(damage_rect); |
danakj | e41d978a | 2016-09-19 21:09:28 | [diff] [blame] | 254 | SetNeedsRedrawOnImplThread(); |
[email protected] | 94f206c1 | 2012-08-25 00:09:14 | [diff] [blame] | 255 | } |
| 256 | |
[email protected] | 74b43cc | 2013-08-30 06:29:27 | [diff] [blame] | 257 | void SingleThreadProxy::SetNextCommitWaitsForActivation() { |
enne | 98f3a6c | 2014-10-09 20:09:44 | [diff] [blame] | 258 | // Activation always forced in commit, so nothing to do. |
khushalsagar | b7db1fe | 2015-11-12 00:51:27 | [diff] [blame] | 259 | DCHECK(task_runner_provider_->IsMainThread()); |
[email protected] | 74b43cc | 2013-08-30 06:29:27 | [diff] [blame] | 260 | } |
| 261 | |
danakj | e6da4f1 | 2018-07-04 17:41:30 | [diff] [blame] | 262 | bool SingleThreadProxy::RequestedAnimatePending() { |
David Bokan | eaa5cc8 | 2018-10-12 15:50:40 | [diff] [blame] | 263 | return animate_requested_ || commit_requested_ || needs_impl_frame_; |
danakj | e6da4f1 | 2018-07-04 17:41:30 | [diff] [blame] | 264 | } |
| 265 | |
Stephen Chenney | 6d3f5ce | 2018-11-14 02:08:05 | [diff] [blame] | 266 | void SingleThreadProxy::SetDeferMainFrameUpdate(bool defer_main_frame_update) { |
khushalsagar | b7db1fe | 2015-11-12 00:51:27 | [diff] [blame] | 267 | DCHECK(task_runner_provider_->IsMainThread()); |
[email protected] | aeeedad | 2014-08-22 18:16:22 | [diff] [blame] | 268 | // Deferring commits only makes sense if there's a scheduler. |
| 269 | if (!scheduler_on_impl_thread_) |
| 270 | return; |
Stephen Chenney | 6d3f5ce | 2018-11-14 02:08:05 | [diff] [blame] | 271 | if (defer_main_frame_update_ == defer_main_frame_update) |
[email protected] | aeeedad | 2014-08-22 18:16:22 | [diff] [blame] | 272 | return; |
| 273 | |
Stephen Chenney | 6d3f5ce | 2018-11-14 02:08:05 | [diff] [blame] | 274 | if (defer_main_frame_update) |
| 275 | TRACE_EVENT_ASYNC_BEGIN0("cc", "SingleThreadProxy::SetDeferMainFrameUpdate", |
| 276 | this); |
[email protected] | aeeedad | 2014-08-22 18:16:22 | [diff] [blame] | 277 | else |
Stephen Chenney | 6d3f5ce | 2018-11-14 02:08:05 | [diff] [blame] | 278 | TRACE_EVENT_ASYNC_END0("cc", "SingleThreadProxy::SetDeferMainFrameUpdate", |
| 279 | this); |
[email protected] | aeeedad | 2014-08-22 18:16:22 | [diff] [blame] | 280 | |
Stephen Chenney | 6d3f5ce | 2018-11-14 02:08:05 | [diff] [blame] | 281 | defer_main_frame_update_ = defer_main_frame_update; |
| 282 | scheduler_on_impl_thread_->SetDeferMainFrameUpdate(defer_main_frame_update); |
[email protected] | 6b16679e | 2012-10-27 00:44:28 | [diff] [blame] | 283 | } |
| 284 | |
[email protected] | 174c6d4 | 2014-08-12 01:43:06 | [diff] [blame] | 285 | bool SingleThreadProxy::CommitRequested() const { |
khushalsagar | b7db1fe | 2015-11-12 00:51:27 | [diff] [blame] | 286 | DCHECK(task_runner_provider_->IsMainThread()); |
[email protected] | aeeedad | 2014-08-22 18:16:22 | [diff] [blame] | 287 | return commit_requested_; |
[email protected] | 174c6d4 | 2014-08-12 01:43:06 | [diff] [blame] | 288 | } |
[email protected] | a8a049c | 2013-03-11 23:27:06 | [diff] [blame] | 289 | |
[email protected] | a8a049c | 2013-03-11 23:27:06 | [diff] [blame] | 290 | void SingleThreadProxy::Stop() { |
| 291 | TRACE_EVENT0("cc", "SingleThreadProxy::stop"); |
khushalsagar | b7db1fe | 2015-11-12 00:51:27 | [diff] [blame] | 292 | DCHECK(task_runner_provider_->IsMainThread()); |
[email protected] | a8a049c | 2013-03-11 23:27:06 | [diff] [blame] | 293 | { |
khushalsagar | b7db1fe | 2015-11-12 00:51:27 | [diff] [blame] | 294 | DebugScopedSetMainThreadBlocked main_thread_blocked(task_runner_provider_); |
| 295 | DebugScopedSetImplThread impl(task_runner_provider_); |
[email protected] | a8a049c | 2013-03-11 23:27:06 | [diff] [blame] | 296 | |
sunnyps | da928f0a | 2016-10-08 00:32:53 | [diff] [blame] | 297 | // Prevent the scheduler from performing actions while we're in an |
| 298 | // inconsistent state. |
| 299 | if (scheduler_on_impl_thread_) |
| 300 | scheduler_on_impl_thread_->Stop(); |
danakj | c7afae5 | 2017-06-20 21:12:41 | [diff] [blame] | 301 | // Take away the LayerTreeFrameSink before destroying things so it doesn't |
danakj | 1120f4c | 2016-09-15 02:05:32 | [diff] [blame] | 302 | // try to call into its client mid-shutdown. |
Walter Korman | aa326e4 | 2017-08-22 23:04:43 | [diff] [blame] | 303 | host_impl_->ReleaseLayerTreeFrameSink(); |
Khushal | 7899efd | 2018-01-08 18:01:16 | [diff] [blame] | 304 | |
| 305 | // It is important to destroy LTHI before the Scheduler since it can make |
| 306 | // callbacks that access it during destruction cleanup. |
Walter Korman | aa326e4 | 2017-08-22 23:04:43 | [diff] [blame] | 307 | host_impl_ = nullptr; |
Khushal | 7899efd | 2018-01-08 18:01:16 | [diff] [blame] | 308 | scheduler_on_impl_thread_ = nullptr; |
[email protected] | a8a049c | 2013-03-11 23:27:06 | [diff] [blame] | 309 | } |
sunnyps | da928f0a | 2016-10-08 00:32:53 | [diff] [blame] | 310 | layer_tree_host_ = nullptr; |
[email protected] | a8a049c | 2013-03-11 23:27:06 | [diff] [blame] | 311 | } |
| 312 | |
flackr | f54e9b4 | 2016-05-31 15:20:10 | [diff] [blame] | 313 | void SingleThreadProxy::SetMutator(std::unique_ptr<LayerTreeMutator> mutator) { |
| 314 | DCHECK(task_runner_provider_->IsMainThread()); |
| 315 | DebugScopedSetImplThread impl(task_runner_provider_); |
Walter Korman | aa326e4 | 2017-08-22 23:04:43 | [diff] [blame] | 316 | host_impl_->SetLayerTreeMutator(std::move(mutator)); |
flackr | f54e9b4 | 2016-05-31 15:20:10 | [diff] [blame] | 317 | } |
| 318 | |
[email protected] | 3d9f743 | 2013-04-06 00:35:18 | [diff] [blame] | 319 | void SingleThreadProxy::OnCanDrawStateChanged(bool can_draw) { |
sunnyps | ad3235e | 2016-08-09 04:57:52 | [diff] [blame] | 320 | TRACE_EVENT1("cc", "SingleThreadProxy::OnCanDrawStateChanged", "can_draw", |
| 321 | can_draw); |
khushalsagar | b7db1fe | 2015-11-12 00:51:27 | [diff] [blame] | 322 | DCHECK(task_runner_provider_->IsImplThread()); |
[email protected] | aeeedad | 2014-08-22 18:16:22 | [diff] [blame] | 323 | if (scheduler_on_impl_thread_) |
| 324 | scheduler_on_impl_thread_->SetCanDraw(can_draw); |
[email protected] | 3d9f743 | 2013-04-06 00:35:18 | [diff] [blame] | 325 | } |
| 326 | |
[email protected] | 4f48f6e | 2013-08-27 06:33:38 | [diff] [blame] | 327 | void SingleThreadProxy::NotifyReadyToActivate() { |
enne | 98f3a6c | 2014-10-09 20:09:44 | [diff] [blame] | 328 | TRACE_EVENT0("cc", "SingleThreadProxy::NotifyReadyToActivate"); |
khushalsagar | b7db1fe | 2015-11-12 00:51:27 | [diff] [blame] | 329 | DebugScopedSetImplThread impl(task_runner_provider_); |
rogerm | 8aeea93 | 2017-04-19 21:26:57 | [diff] [blame] | 330 | if (scheduler_on_impl_thread_) |
| 331 | scheduler_on_impl_thread_->NotifyReadyToActivate(); |
[email protected] | 4f48f6e | 2013-08-27 06:33:38 | [diff] [blame] | 332 | } |
| 333 | |
ernstm | dfac03e | 2014-11-11 20:18:05 | [diff] [blame] | 334 | void SingleThreadProxy::NotifyReadyToDraw() { |
weiliangc | 8dac5a6 | 2015-04-02 06:12:35 | [diff] [blame] | 335 | TRACE_EVENT0("cc", "SingleThreadProxy::NotifyReadyToDraw"); |
khushalsagar | b7db1fe | 2015-11-12 00:51:27 | [diff] [blame] | 336 | DebugScopedSetImplThread impl(task_runner_provider_); |
weiliangc | 8dac5a6 | 2015-04-02 06:12:35 | [diff] [blame] | 337 | if (scheduler_on_impl_thread_) |
| 338 | scheduler_on_impl_thread_->NotifyReadyToDraw(); |
ernstm | dfac03e | 2014-11-11 20:18:05 | [diff] [blame] | 339 | } |
| 340 | |
[email protected] | c1bb5af | 2013-03-13 19:06:27 | [diff] [blame] | 341 | void SingleThreadProxy::SetNeedsRedrawOnImplThread() { |
danakj | 6c872fc0 | 2016-10-22 04:29:49 | [diff] [blame] | 342 | single_thread_client_->RequestScheduleComposite(); |
[email protected] | aeeedad | 2014-08-22 18:16:22 | [diff] [blame] | 343 | if (scheduler_on_impl_thread_) |
| 344 | scheduler_on_impl_thread_->SetNeedsRedraw(); |
[email protected] | a8a049c | 2013-03-11 23:27:06 | [diff] [blame] | 345 | } |
| 346 | |
danakj | a18e826a | 2015-12-03 00:27:03 | [diff] [blame] | 347 | void SingleThreadProxy::SetNeedsOneBeginImplFrameOnImplThread() { |
| 348 | TRACE_EVENT0("cc", |
| 349 | "SingleThreadProxy::SetNeedsOneBeginImplFrameOnImplThread"); |
danakj | 6c872fc0 | 2016-10-22 04:29:49 | [diff] [blame] | 350 | single_thread_client_->RequestScheduleComposite(); |
mithro | 719bf679 | 2014-11-10 15:36:47 | [diff] [blame] | 351 | if (scheduler_on_impl_thread_) |
danakj | a18e826a | 2015-12-03 00:27:03 | [diff] [blame] | 352 | scheduler_on_impl_thread_->SetNeedsOneBeginImplFrame(); |
David Bokan | eaa5cc8 | 2018-10-12 15:50:40 | [diff] [blame] | 353 | needs_impl_frame_ = true; |
[email protected] | 43b8f98 | 2014-04-30 21:24:33 | [diff] [blame] | 354 | } |
| 355 | |
vmiura | 59ea9b404 | 2014-12-09 20:50:39 | [diff] [blame] | 356 | void SingleThreadProxy::SetNeedsPrepareTilesOnImplThread() { |
| 357 | TRACE_EVENT0("cc", "SingleThreadProxy::SetNeedsPrepareTilesOnImplThread"); |
enne | 98f3a6c | 2014-10-09 20:09:44 | [diff] [blame] | 358 | if (scheduler_on_impl_thread_) |
vmiura | 59ea9b404 | 2014-12-09 20:50:39 | [diff] [blame] | 359 | scheduler_on_impl_thread_->SetNeedsPrepareTiles(); |
[email protected] | c48536a5 | 2013-09-14 00:02:08 | [diff] [blame] | 360 | } |
| 361 | |
[email protected] | c1bb5af | 2013-03-13 19:06:27 | [diff] [blame] | 362 | void SingleThreadProxy::SetNeedsCommitOnImplThread() { |
danakj | 6c872fc0 | 2016-10-22 04:29:49 | [diff] [blame] | 363 | single_thread_client_->RequestScheduleComposite(); |
[email protected] | aeeedad | 2014-08-22 18:16:22 | [diff] [blame] | 364 | if (scheduler_on_impl_thread_) |
mithro | e77254b3 | 2015-07-22 09:36:01 | [diff] [blame] | 365 | scheduler_on_impl_thread_->SetNeedsBeginMainFrame(); |
David Bokan | eaa5cc8 | 2018-10-12 15:50:40 | [diff] [blame] | 366 | commit_requested_ = true; |
[email protected] | a8a049c | 2013-03-11 23:27:06 | [diff] [blame] | 367 | } |
| 368 | |
sunnyps | 7d073dc | 2015-04-16 23:29:12 | [diff] [blame] | 369 | void SingleThreadProxy::SetVideoNeedsBeginFrames(bool needs_begin_frames) { |
| 370 | TRACE_EVENT1("cc", "SingleThreadProxy::SetVideoNeedsBeginFrames", |
| 371 | "needs_begin_frames", needs_begin_frames); |
| 372 | // In tests the layer tree is destroyed after the scheduler is. |
| 373 | if (scheduler_on_impl_thread_) |
| 374 | scheduler_on_impl_thread_->SetVideoNeedsBeginFrames(needs_begin_frames); |
| 375 | } |
| 376 | |
[email protected] | c1bb5af | 2013-03-13 19:06:27 | [diff] [blame] | 377 | void SingleThreadProxy::PostAnimationEventsToMainThreadOnImplThread( |
loyso | c601b7b8 | 2016-11-10 02:56:44 | [diff] [blame] | 378 | std::unique_ptr<MutatorEvents> events) { |
[email protected] | ccc08dc | 2014-01-30 07:33:20 | [diff] [blame] | 379 | TRACE_EVENT0( |
| 380 | "cc", "SingleThreadProxy::PostAnimationEventsToMainThreadOnImplThread"); |
khushalsagar | b7db1fe | 2015-11-12 00:51:27 | [diff] [blame] | 381 | DCHECK(task_runner_provider_->IsImplThread()); |
| 382 | DebugScopedSetMainThread main(task_runner_provider_); |
danakj | a04855a | 2015-11-18 20:39:10 | [diff] [blame] | 383 | layer_tree_host_->SetAnimationEvents(std::move(events)); |
[email protected] | a8a049c | 2013-03-11 23:27:06 | [diff] [blame] | 384 | } |
| 385 | |
Xida Chen | d8bb3b2 | 2017-10-26 17:14:52 | [diff] [blame] | 386 | size_t SingleThreadProxy::CompositedAnimationsCount() const { |
| 387 | return 0; |
| 388 | } |
| 389 | |
| 390 | size_t SingleThreadProxy::MainThreadAnimationsCount() const { |
| 391 | return 0; |
| 392 | } |
| 393 | |
Stephen McGruer | 1619b42 | 2018-02-20 18:46:55 | [diff] [blame] | 394 | bool SingleThreadProxy::CurrentFrameHadRAF() const { |
| 395 | return false; |
| 396 | } |
| 397 | |
| 398 | bool SingleThreadProxy::NextFrameHasPendingRAF() const { |
| 399 | return false; |
| 400 | } |
| 401 | |
sunnyps | ad3235e | 2016-08-09 04:57:52 | [diff] [blame] | 402 | bool SingleThreadProxy::IsInsideDraw() { |
| 403 | return inside_draw_; |
| 404 | } |
[email protected] | a8a049c | 2013-03-11 23:27:06 | [diff] [blame] | 405 | |
enne | 98f3a6c | 2014-10-09 20:09:44 | [diff] [blame] | 406 | void SingleThreadProxy::DidActivateSyncTree() { |
danakj | 68803fc | 2015-06-19 20:55:53 | [diff] [blame] | 407 | CommitComplete(); |
enne | 98f3a6c | 2014-10-09 20:09:44 | [diff] [blame] | 408 | } |
| 409 | |
brianderson | 6874981 | 2015-07-07 22:39:39 | [diff] [blame] | 410 | void SingleThreadProxy::WillPrepareTiles() { |
khushalsagar | b7db1fe | 2015-11-12 00:51:27 | [diff] [blame] | 411 | DCHECK(task_runner_provider_->IsImplThread()); |
brianderson | 6874981 | 2015-07-07 22:39:39 | [diff] [blame] | 412 | if (scheduler_on_impl_thread_) |
| 413 | scheduler_on_impl_thread_->WillPrepareTiles(); |
| 414 | } |
| 415 | |
vmiura | 59ea9b404 | 2014-12-09 20:50:39 | [diff] [blame] | 416 | void SingleThreadProxy::DidPrepareTiles() { |
khushalsagar | b7db1fe | 2015-11-12 00:51:27 | [diff] [blame] | 417 | DCHECK(task_runner_provider_->IsImplThread()); |
enne | 98f3a6c | 2014-10-09 20:09:44 | [diff] [blame] | 418 | if (scheduler_on_impl_thread_) |
vmiura | 59ea9b404 | 2014-12-09 20:50:39 | [diff] [blame] | 419 | scheduler_on_impl_thread_->DidPrepareTiles(); |
enne | 98f3a6c | 2014-10-09 20:09:44 | [diff] [blame] | 420 | } |
| 421 | |
rouslan | f7ebd883 | 2015-01-22 01:54:14 | [diff] [blame] | 422 | void SingleThreadProxy::DidCompletePageScaleAnimationOnImplThread() { |
| 423 | layer_tree_host_->DidCompletePageScaleAnimation(); |
| 424 | } |
| 425 | |
danakj | c7afae5 | 2017-06-20 21:12:41 | [diff] [blame] | 426 | void SingleThreadProxy::DidLoseLayerTreeFrameSinkOnImplThread() { |
danakj | 1120f4c | 2016-09-15 02:05:32 | [diff] [blame] | 427 | TRACE_EVENT0("cc", |
danakj | c7afae5 | 2017-06-20 21:12:41 | [diff] [blame] | 428 | "SingleThreadProxy::DidLoseLayerTreeFrameSinkOnImplThread"); |
[email protected] | aeeedad | 2014-08-22 18:16:22 | [diff] [blame] | 429 | { |
khushalsagar | b7db1fe | 2015-11-12 00:51:27 | [diff] [blame] | 430 | DebugScopedSetMainThread main(task_runner_provider_); |
[email protected] | aeeedad | 2014-08-22 18:16:22 | [diff] [blame] | 431 | // This must happen before we notify the scheduler as it may try to recreate |
| 432 | // the output surface if already in BEGIN_IMPL_FRAME_STATE_IDLE. |
danakj | c7afae5 | 2017-06-20 21:12:41 | [diff] [blame] | 433 | layer_tree_host_->DidLoseLayerTreeFrameSink(); |
[email protected] | aeeedad | 2014-08-22 18:16:22 | [diff] [blame] | 434 | } |
danakj | c7afae5 | 2017-06-20 21:12:41 | [diff] [blame] | 435 | single_thread_client_->DidLoseLayerTreeFrameSink(); |
[email protected] | aeeedad | 2014-08-22 18:16:22 | [diff] [blame] | 436 | if (scheduler_on_impl_thread_) |
danakj | c7afae5 | 2017-06-20 21:12:41 | [diff] [blame] | 437 | scheduler_on_impl_thread_->DidLoseLayerTreeFrameSink(); |
| 438 | layer_tree_frame_sink_lost_ = true; |
[email protected] | 4d7e46a | 2013-11-08 05:33:40 | [diff] [blame] | 439 | } |
| 440 | |
Fady Samuel | c645ffe | 2017-07-24 17:28:20 | [diff] [blame] | 441 | void SingleThreadProxy::SetBeginFrameSource(viz::BeginFrameSource* source) { |
enne | 19c10858 | 2016-04-14 03:35:32 | [diff] [blame] | 442 | if (scheduler_on_impl_thread_) |
| 443 | scheduler_on_impl_thread_->SetBeginFrameSource(source); |
| 444 | } |
| 445 | |
danakj | 9d12442 | 2016-10-14 03:15:08 | [diff] [blame] | 446 | void SingleThreadProxy::DidReceiveCompositorFrameAckOnImplThread() { |
miletus | fed8c43b | 2015-01-26 20:04:52 | [diff] [blame] | 447 | TRACE_EVENT0("cc,benchmark", |
danakj | 9d12442 | 2016-10-14 03:15:08 | [diff] [blame] | 448 | "SingleThreadProxy::DidReceiveCompositorFrameAckOnImplThread"); |
[email protected] | aeeedad | 2014-08-22 18:16:22 | [diff] [blame] | 449 | if (scheduler_on_impl_thread_) |
danakj | 9d12442 | 2016-10-14 03:15:08 | [diff] [blame] | 450 | scheduler_on_impl_thread_->DidReceiveCompositorFrameAck(); |
Karolina Soltys | 4d60b40 | 2018-10-01 19:28:20 | [diff] [blame] | 451 | if (layer_tree_host_->GetSettings().send_compositor_frame_ack) { |
| 452 | // We do a PostTask here because freeing resources in some cases (such as in |
| 453 | // TextureLayer) is PostTasked and we want to make sure ack is received |
| 454 | // after resources are returned. |
| 455 | task_runner_provider_->MainThreadTaskRunner()->PostTask( |
| 456 | FROM_HERE, base::Bind(&SingleThreadProxy::DidReceiveCompositorFrameAck, |
| 457 | frame_sink_bound_weak_ptr_)); |
| 458 | } |
[email protected] | 49306751 | 2012-09-19 23:34:10 | [diff] [blame] | 459 | } |
| 460 | |
danakj | c7afae5 | 2017-06-20 21:12:41 | [diff] [blame] | 461 | void SingleThreadProxy::OnDrawForLayerTreeFrameSink( |
James Wallace-Lee | fbb0e336 | 2018-06-18 23:57:47 | [diff] [blame] | 462 | bool resourceless_software_draw, |
| 463 | bool skip_draw) { |
sunnyps | eab5ac9 | 2015-04-02 20:26:13 | [diff] [blame] | 464 | NOTREACHED() << "Implemented by ThreadProxy for synchronous compositor."; |
| 465 | } |
| 466 | |
Khushal | 8360fc9 | 2017-07-26 01:53:25 | [diff] [blame] | 467 | void SingleThreadProxy::NeedsImplSideInvalidation( |
| 468 | bool needs_first_draw_on_activation) { |
Khushal | 4b6c4188 | 2018-02-16 09:02:10 | [diff] [blame] | 469 | if (scheduler_on_impl_thread_) { |
| 470 | scheduler_on_impl_thread_->SetNeedsImplSideInvalidation( |
| 471 | needs_first_draw_on_activation); |
| 472 | } |
khushalsagar | d3b8827d | 2017-02-18 18:42:54 | [diff] [blame] | 473 | } |
| 474 | |
vmpstr | a840c6a | 2017-06-01 21:50:39 | [diff] [blame] | 475 | void SingleThreadProxy::NotifyImageDecodeRequestFinished() { |
| 476 | // If we don't have a scheduler, then just issue the callbacks here. |
| 477 | // Otherwise, schedule a commit. |
| 478 | if (!scheduler_on_impl_thread_) { |
| 479 | DebugScopedSetMainThreadBlocked main_thread_blocked(task_runner_provider_); |
| 480 | DebugScopedSetImplThread impl(task_runner_provider_); |
| 481 | |
| 482 | IssueImageDecodeFinishedCallbacks(); |
| 483 | return; |
| 484 | } |
| 485 | SetNeedsCommitOnImplThread(); |
| 486 | } |
| 487 | |
Scott Violet | e979c01 | 2017-12-08 00:18:16 | [diff] [blame] | 488 | void SingleThreadProxy::DidPresentCompositorFrameOnImplThread( |
Sadrul Habib Chowdhury | 3d4df2e8 | 2018-06-02 05:18:00 | [diff] [blame] | 489 | uint32_t frame_token, |
| 490 | std::vector<LayerTreeHost::PresentationTimeCallback> callbacks, |
Sadrul Habib Chowdhury | b62a9730 | 2018-06-06 03:33:48 | [diff] [blame] | 491 | const gfx::PresentationFeedback& feedback) { |
Sadrul Habib Chowdhury | 3d4df2e8 | 2018-06-02 05:18:00 | [diff] [blame] | 492 | layer_tree_host_->DidPresentCompositorFrame(frame_token, std::move(callbacks), |
Sadrul Habib Chowdhury | b62a9730 | 2018-06-06 03:33:48 | [diff] [blame] | 493 | feedback); |
Scott Violet | e979c01 | 2017-12-08 00:18:16 | [diff] [blame] | 494 | } |
| 495 | |
Dan Elphick | 95929fd5 | 2017-06-13 09:15:07 | [diff] [blame] | 496 | void SingleThreadProxy::RequestBeginMainFrameNotExpected(bool new_state) { |
| 497 | if (scheduler_on_impl_thread_) { |
| 498 | scheduler_on_impl_thread_->SetMainThreadWantsBeginMainFrameNotExpected( |
| 499 | new_state); |
| 500 | } |
| 501 | } |
| 502 | |
Khushal | 4b6c4188 | 2018-02-16 09:02:10 | [diff] [blame] | 503 | void SingleThreadProxy::CompositeImmediately(base::TimeTicks frame_begin_time, |
| 504 | bool raster) { |
miletus | fed8c43b | 2015-01-26 20:04:52 | [diff] [blame] | 505 | TRACE_EVENT0("cc,benchmark", "SingleThreadProxy::CompositeImmediately"); |
khushalsagar | b7db1fe | 2015-11-12 00:51:27 | [diff] [blame] | 506 | DCHECK(task_runner_provider_->IsMainThread()); |
mithro | 51693e38 | 2015-05-07 23:52:41 | [diff] [blame] | 507 | #if DCHECK_IS_ON() |
mithro | c76d7031 | 2015-05-04 23:51:13 | [diff] [blame] | 508 | DCHECK(!inside_impl_frame_); |
mithro | 51693e38 | 2015-05-07 23:52:41 | [diff] [blame] | 509 | #endif |
jbauman | 399aec1a | 2014-10-25 02:33:32 | [diff] [blame] | 510 | base::AutoReset<bool> inside_composite(&inside_synchronous_composite_, true); |
| 511 | |
danakj | c7afae5 | 2017-06-20 21:12:41 | [diff] [blame] | 512 | if (layer_tree_frame_sink_lost_) { |
| 513 | RequestNewLayerTreeFrameSink(); |
| 514 | // RequestNewLayerTreeFrameSink could have synchronously created an output |
jbauman | 399aec1a | 2014-10-25 02:33:32 | [diff] [blame] | 515 | // surface, so check again before returning. |
danakj | c7afae5 | 2017-06-20 21:12:41 | [diff] [blame] | 516 | if (layer_tree_frame_sink_lost_) |
jbauman | 399aec1a | 2014-10-25 02:33:32 | [diff] [blame] | 517 | return; |
| 518 | } |
[email protected] | 51f81da | 2014-05-16 21:29:26 | [diff] [blame] | 519 | |
Fady Samuel | c296f5fb | 2017-07-21 04:02:19 | [diff] [blame] | 520 | viz::BeginFrameArgs begin_frame_args(viz::BeginFrameArgs::Create( |
| 521 | BEGINFRAME_FROM_HERE, viz::BeginFrameArgs::kManualSourceId, 1, |
| 522 | frame_begin_time, base::TimeTicks(), |
| 523 | viz::BeginFrameArgs::DefaultInterval(), viz::BeginFrameArgs::NORMAL)); |
mithro | c76d7031 | 2015-05-04 23:51:13 | [diff] [blame] | 524 | |
| 525 | // Start the impl frame. |
enne | 98f3a6c | 2014-10-09 20:09:44 | [diff] [blame] | 526 | { |
khushalsagar | b7db1fe | 2015-11-12 00:51:27 | [diff] [blame] | 527 | DebugScopedSetImplThread impl(task_runner_provider_); |
mithro | c76d7031 | 2015-05-04 23:51:13 | [diff] [blame] | 528 | WillBeginImplFrame(begin_frame_args); |
| 529 | } |
| 530 | |
| 531 | // Run the "main thread" and get it to commit. |
| 532 | { |
mithro | 51693e38 | 2015-05-07 23:52:41 | [diff] [blame] | 533 | #if DCHECK_IS_ON() |
mithro | c76d7031 | 2015-05-04 23:51:13 | [diff] [blame] | 534 | DCHECK(inside_impl_frame_); |
mithro | 51693e38 | 2015-05-07 23:52:41 | [diff] [blame] | 535 | #endif |
danakj | e6da4f1 | 2018-07-04 17:41:30 | [diff] [blame] | 536 | animate_requested_ = false; |
David Bokan | eaa5cc8 | 2018-10-12 15:50:40 | [diff] [blame] | 537 | needs_impl_frame_ = false; |
danakj | e6da4f1 | 2018-07-04 17:41:30 | [diff] [blame] | 538 | // Prevent new commits from being requested inside DoBeginMainFrame. |
| 539 | // Note: We do not want to prevent SetNeedsAnimate from requesting |
| 540 | // a commit here. |
| 541 | commit_requested_ = true; |
enne | 98f3a6c | 2014-10-09 20:09:44 | [diff] [blame] | 542 | DoBeginMainFrame(begin_frame_args); |
danakj | e6da4f1 | 2018-07-04 17:41:30 | [diff] [blame] | 543 | commit_requested_ = false; |
danakj | 97660d9 | 2017-03-27 14:11:49 | [diff] [blame] | 544 | DoPainting(); |
enne | 98f3a6c | 2014-10-09 20:09:44 | [diff] [blame] | 545 | DoCommit(); |
[email protected] | e034135 | 2013-04-06 05:01:20 | [diff] [blame] | 546 | |
khushalsagar | 8297ae99 | 2016-09-14 20:51:23 | [diff] [blame] | 547 | DCHECK_EQ( |
| 548 | 0u, |
| 549 | layer_tree_host_->GetSwapPromiseManager()->num_queued_swap_promises()) |
enne | 98f3a6c | 2014-10-09 20:09:44 | [diff] [blame] | 550 | << "Commit should always succeed and transfer promises."; |
| 551 | } |
| 552 | |
mithro | c76d7031 | 2015-05-04 23:51:13 | [diff] [blame] | 553 | // Finish the impl frame. |
enne | 98f3a6c | 2014-10-09 20:09:44 | [diff] [blame] | 554 | { |
khushalsagar | b7db1fe | 2015-11-12 00:51:27 | [diff] [blame] | 555 | DebugScopedSetImplThread impl(task_runner_provider_); |
Walter Korman | aa326e4 | 2017-08-22 23:04:43 | [diff] [blame] | 556 | host_impl_->ActivateSyncTree(); |
Khushal | 4b6c4188 | 2018-02-16 09:02:10 | [diff] [blame] | 557 | if (raster) { |
| 558 | host_impl_->PrepareTiles(); |
| 559 | host_impl_->SynchronouslyInitializeAllTiles(); |
| 560 | } |
enne | 69277cb | 2014-10-29 23:03:40 | [diff] [blame] | 561 | |
danakj | 12e2f6e | 2015-08-19 22:25:44 | [diff] [blame] | 562 | // TODO(danakj): Don't do this last... we prepared the wrong things. D: |
Walter Korman | aa326e4 | 2017-08-22 23:04:43 | [diff] [blame] | 563 | host_impl_->Animate(); |
mithro | 719bf679 | 2014-11-10 15:36:47 | [diff] [blame] | 564 | |
Khushal | 4b6c4188 | 2018-02-16 09:02:10 | [diff] [blame] | 565 | if (raster) { |
| 566 | LayerTreeHostImpl::FrameData frame; |
Sadrul Habib Chowdhury | 4a7940b | 2018-06-22 16:45:14 | [diff] [blame] | 567 | frame.begin_frame_ack = viz::BeginFrameAck(begin_frame_args, true); |
Khushal | 4b6c4188 | 2018-02-16 09:02:10 | [diff] [blame] | 568 | DoComposite(&frame); |
| 569 | } |
enne | 98f3a6c | 2014-10-09 20:09:44 | [diff] [blame] | 570 | |
| 571 | // DoComposite could abort, but because this is a synchronous composite |
| 572 | // another draw will never be scheduled, so break remaining promises. |
Walter Korman | aa326e4 | 2017-08-22 23:04:43 | [diff] [blame] | 573 | host_impl_->active_tree()->BreakSwapPromises(SwapPromise::SWAP_FAILS); |
mithro | c76d7031 | 2015-05-04 23:51:13 | [diff] [blame] | 574 | |
mithro | 51693e38 | 2015-05-07 23:52:41 | [diff] [blame] | 575 | DidFinishImplFrame(); |
enne | 98f3a6c | 2014-10-09 20:09:44 | [diff] [blame] | 576 | } |
[email protected] | 74d9063c | 2013-01-18 03:14:47 | [diff] [blame] | 577 | } |
| 578 | |
[email protected] | 5d8bec7 | 2014-07-03 03:03:11 | [diff] [blame] | 579 | bool SingleThreadProxy::SupportsImplScrolling() const { |
| 580 | return false; |
| 581 | } |
| 582 | |
[email protected] | 3d9f743 | 2013-04-06 00:35:18 | [diff] [blame] | 583 | bool SingleThreadProxy::ShouldComposite() const { |
khushalsagar | b7db1fe | 2015-11-12 00:51:27 | [diff] [blame] | 584 | DCHECK(task_runner_provider_->IsImplThread()); |
Walter Korman | aa326e4 | 2017-08-22 23:04:43 | [diff] [blame] | 585 | return host_impl_->visible() && host_impl_->CanDraw(); |
[email protected] | 3d9f743 | 2013-04-06 00:35:18 | [diff] [blame] | 586 | } |
| 587 | |
danakj | c7afae5 | 2017-06-20 21:12:41 | [diff] [blame] | 588 | void SingleThreadProxy::ScheduleRequestNewLayerTreeFrameSink() { |
| 589 | if (layer_tree_frame_sink_creation_callback_.IsCancelled() && |
| 590 | !layer_tree_frame_sink_creation_requested_) { |
| 591 | layer_tree_frame_sink_creation_callback_.Reset( |
| 592 | base::Bind(&SingleThreadProxy::RequestNewLayerTreeFrameSink, |
jbauman | 8ab0f9e | 2014-10-15 02:30:34 | [diff] [blame] | 593 | weak_factory_.GetWeakPtr())); |
khushalsagar | b7db1fe | 2015-11-12 00:51:27 | [diff] [blame] | 594 | task_runner_provider_->MainThreadTaskRunner()->PostTask( |
danakj | c7afae5 | 2017-06-20 21:12:41 | [diff] [blame] | 595 | FROM_HERE, layer_tree_frame_sink_creation_callback_.callback()); |
jbauman | 8ab0f9e | 2014-10-15 02:30:34 | [diff] [blame] | 596 | } |
| 597 | } |
| 598 | |
mithro | 248d172 | 2015-05-05 05:23:45 | [diff] [blame] | 599 | DrawResult SingleThreadProxy::DoComposite(LayerTreeHostImpl::FrameData* frame) { |
[email protected] | ccc08dc | 2014-01-30 07:33:20 | [diff] [blame] | 600 | TRACE_EVENT0("cc", "SingleThreadProxy::DoComposite"); |
[email protected] | 04049fc | 2013-05-01 03:13:20 | [diff] [blame] | 601 | |
enne | 98f3a6c | 2014-10-09 20:09:44 | [diff] [blame] | 602 | DrawResult draw_result; |
| 603 | bool draw_frame; |
[email protected] | a8a049c | 2013-03-11 23:27:06 | [diff] [blame] | 604 | { |
khushalsagar | b7db1fe | 2015-11-12 00:51:27 | [diff] [blame] | 605 | DebugScopedSetImplThread impl(task_runner_provider_); |
[email protected] | a8a049c | 2013-03-11 23:27:06 | [diff] [blame] | 606 | base::AutoReset<bool> mark_inside(&inside_draw_, true); |
| 607 | |
[email protected] | 3d9f743 | 2013-04-06 00:35:18 | [diff] [blame] | 608 | // We guard PrepareToDraw() with CanDraw() because it always returns a valid |
| 609 | // frame, so can only be used when such a frame is possible. Since |
| 610 | // DrawLayers() depends on the result of PrepareToDraw(), it is guarded on |
| 611 | // CanDraw() as well. |
[email protected] | 2aae9679 | 2014-05-15 23:10:50 | [diff] [blame] | 612 | if (!ShouldComposite()) { |
[email protected] | aeeedad | 2014-08-22 18:16:22 | [diff] [blame] | 613 | return DRAW_ABORTED_CANT_DRAW; |
[email protected] | 3d9f743 | 2013-04-06 00:35:18 | [diff] [blame] | 614 | } |
[email protected] | a8a049c | 2013-03-11 23:27:06 | [diff] [blame] | 615 | |
danakj | 097919e7 | 2016-09-07 19:50:55 | [diff] [blame] | 616 | // This CapturePostTasks should be destroyed before |
| 617 | // DidCommitAndDrawFrame() is called since that goes out to the |
| 618 | // embedder, and we want the embedder to receive its callbacks before that. |
| 619 | // NOTE: This maintains consistent ordering with the ThreadProxy since |
| 620 | // the DidCommitAndDrawFrame() must be post-tasked from the impl thread |
| 621 | // there as the main thread is not blocked, so any posted tasks inside |
| 622 | // the swap buffers will execute first. |
| 623 | DebugScopedSetMainThreadBlocked main_thread_blocked(task_runner_provider_); |
danakj | 097919e7 | 2016-09-07 19:50:55 | [diff] [blame] | 624 | |
Walter Korman | aa326e4 | 2017-08-22 23:04:43 | [diff] [blame] | 625 | draw_result = host_impl_->PrepareToDraw(frame); |
enne | 98f3a6c | 2014-10-09 20:09:44 | [diff] [blame] | 626 | draw_frame = draw_result == DRAW_SUCCESS; |
robliao | 27728e6 | 2015-03-21 07:39:34 | [diff] [blame] | 627 | if (draw_frame) { |
Walter Korman | aa326e4 | 2017-08-22 23:04:43 | [diff] [blame] | 628 | if (host_impl_->DrawLayers(frame)) { |
danakj | 097919e7 | 2016-09-07 19:50:55 | [diff] [blame] | 629 | if (scheduler_on_impl_thread_) |
danakj | c7afae5 | 2017-06-20 21:12:41 | [diff] [blame] | 630 | // Drawing implies we submitted a frame to the LayerTreeFrameSink. |
danakj | 9d12442 | 2016-10-14 03:15:08 | [diff] [blame] | 631 | scheduler_on_impl_thread_->DidSubmitCompositorFrame(); |
danakj | 6c872fc0 | 2016-10-22 04:29:49 | [diff] [blame] | 632 | single_thread_client_->DidSubmitCompositorFrame(); |
danakj | 097919e7 | 2016-09-07 19:50:55 | [diff] [blame] | 633 | } |
robliao | 27728e6 | 2015-03-21 07:39:34 | [diff] [blame] | 634 | } |
Walter Korman | aa326e4 | 2017-08-22 23:04:43 | [diff] [blame] | 635 | host_impl_->DidDrawAllLayers(*frame); |
[email protected] | a8a049c | 2013-03-11 23:27:06 | [diff] [blame] | 636 | |
danakj | 097919e7 | 2016-09-07 19:50:55 | [diff] [blame] | 637 | bool start_ready_animations = draw_frame; |
Walter Korman | aa326e4 | 2017-08-22 23:04:43 | [diff] [blame] | 638 | host_impl_->UpdateAnimationState(start_ready_animations); |
[email protected] | aeeedad | 2014-08-22 18:16:22 | [diff] [blame] | 639 | } |
| 640 | DidCommitAndDrawFrame(); |
| 641 | |
enne | 98f3a6c | 2014-10-09 20:09:44 | [diff] [blame] | 642 | return draw_result; |
[email protected] | a8a049c | 2013-03-11 23:27:06 | [diff] [blame] | 643 | } |
| 644 | |
[email protected] | aeeedad | 2014-08-22 18:16:22 | [diff] [blame] | 645 | void SingleThreadProxy::DidCommitAndDrawFrame() { |
[email protected] | a8a049c | 2013-03-11 23:27:06 | [diff] [blame] | 646 | if (next_frame_is_newly_committed_frame_) { |
khushalsagar | b7db1fe | 2015-11-12 00:51:27 | [diff] [blame] | 647 | DebugScopedSetMainThread main(task_runner_provider_); |
[email protected] | a8a049c | 2013-03-11 23:27:06 | [diff] [blame] | 648 | next_frame_is_newly_committed_frame_ = false; |
[email protected] | 804c898 | 2013-03-13 16:32:21 | [diff] [blame] | 649 | layer_tree_host_->DidCommitAndDrawFrame(); |
[email protected] | a8a049c | 2013-03-11 23:27:06 | [diff] [blame] | 650 | } |
| 651 | } |
| 652 | |
[email protected] | 4ea293f7 | 2014-08-13 03:03:17 | [diff] [blame] | 653 | bool SingleThreadProxy::MainFrameWillHappenForTesting() { |
danakj | fcdaba12 | 2015-04-24 21:41:52 | [diff] [blame] | 654 | if (!scheduler_on_impl_thread_) |
| 655 | return false; |
| 656 | return scheduler_on_impl_thread_->MainFrameForTestingWillHappen(); |
[email protected] | 4ea293f7 | 2014-08-13 03:03:17 | [diff] [blame] | 657 | } |
[email protected] | a8a049c | 2013-03-11 23:27:06 | [diff] [blame] | 658 | |
Fady Samuel | d26f7fb | 2018-06-19 04:13:37 | [diff] [blame] | 659 | void SingleThreadProxy::ClearHistory() { |
Khushal | 2f9cdf2 | 2018-01-08 21:47:08 | [diff] [blame] | 660 | DCHECK(task_runner_provider_->IsImplThread()); |
| 661 | if (scheduler_on_impl_thread_) |
Fady Samuel | d26f7fb | 2018-06-19 04:13:37 | [diff] [blame] | 662 | scheduler_on_impl_thread_->ClearHistory(); |
Khushal | 2f9cdf2 | 2018-01-08 21:47:08 | [diff] [blame] | 663 | } |
| 664 | |
jonross | a2ff4f8 | 2018-02-16 17:27:46 | [diff] [blame] | 665 | void SingleThreadProxy::SetRenderFrameObserver( |
| 666 | std::unique_ptr<RenderFrameMetadataObserver> observer) { |
jonross | c1877d6d | 2018-02-21 00:07:31 | [diff] [blame] | 667 | host_impl_->SetRenderFrameObserver(std::move(observer)); |
jonross | a2ff4f8 | 2018-02-16 17:27:46 | [diff] [blame] | 668 | } |
| 669 | |
David Bokan | 1e37ebf | 2018-10-16 13:53:37 | [diff] [blame] | 670 | void SingleThreadProxy::UpdateBrowserControlsState( |
| 671 | BrowserControlsState constraints, |
| 672 | BrowserControlsState current, |
| 673 | bool animate) { |
| 674 | host_impl_->browser_controls_manager()->UpdateBrowserControlsState( |
| 675 | constraints, current, animate); |
| 676 | } |
| 677 | |
James Wallace-Lee | e71cf58 | 2018-01-29 22:24:23 | [diff] [blame] | 678 | bool SingleThreadProxy::WillBeginImplFrame(const viz::BeginFrameArgs& args) { |
danakj | a18e826a | 2015-12-03 00:27:03 | [diff] [blame] | 679 | DebugScopedSetImplThread impl(task_runner_provider_); |
mithro | 51693e38 | 2015-05-07 23:52:41 | [diff] [blame] | 680 | #if DCHECK_IS_ON() |
mithro | 69fd3bb5 | 2015-05-01 03:45:02 | [diff] [blame] | 681 | DCHECK(!inside_impl_frame_) |
| 682 | << "WillBeginImplFrame called while already inside an impl frame!"; |
| 683 | inside_impl_frame_ = true; |
mithro | 51693e38 | 2015-05-07 23:52:41 | [diff] [blame] | 684 | #endif |
James Wallace-Lee | e71cf58 | 2018-01-29 22:24:23 | [diff] [blame] | 685 | return host_impl_->WillBeginImplFrame(args); |
[email protected] | aeeedad | 2014-08-22 18:16:22 | [diff] [blame] | 686 | } |
| 687 | |
brianderson | 266dc3a | 2015-11-12 03:16:40 | [diff] [blame] | 688 | void SingleThreadProxy::ScheduledActionSendBeginMainFrame( |
Fady Samuel | c296f5fb | 2017-07-21 04:02:19 | [diff] [blame] | 689 | const viz::BeginFrameArgs& begin_frame_args) { |
[email protected] | aeeedad | 2014-08-22 18:16:22 | [diff] [blame] | 690 | TRACE_EVENT0("cc", "SingleThreadProxy::ScheduledActionSendBeginMainFrame"); |
sunnyps | ad3235e | 2016-08-09 04:57:52 | [diff] [blame] | 691 | #if DCHECK_IS_ON() |
[email protected] | aeeedad | 2014-08-22 18:16:22 | [diff] [blame] | 692 | // Although this proxy is single-threaded, it's problematic to synchronously |
| 693 | // have BeginMainFrame happen after ScheduledActionSendBeginMainFrame. This |
| 694 | // could cause a commit to occur in between a series of SetNeedsCommit calls |
| 695 | // (i.e. property modifications) causing some to fall on one frame and some to |
| 696 | // fall on the next. Doing it asynchronously instead matches the semantics of |
| 697 | // ThreadProxy::SetNeedsCommit where SetNeedsCommit will not cause a |
| 698 | // synchronous commit. |
mithro | 69fd3bb5 | 2015-05-01 03:45:02 | [diff] [blame] | 699 | DCHECK(inside_impl_frame_) |
| 700 | << "BeginMainFrame should only be sent inside a BeginImplFrame"; |
mithro | 51693e38 | 2015-05-07 23:52:41 | [diff] [blame] | 701 | #endif |
mithro | 69fd3bb5 | 2015-05-01 03:45:02 | [diff] [blame] | 702 | |
Zhenyao Mo | 5b30cf3 | 2018-12-01 00:31:25 | [diff] [blame^] | 703 | host_impl_->WillSendBeginMainFrame(); |
khushalsagar | b7db1fe | 2015-11-12 00:51:27 | [diff] [blame] | 704 | task_runner_provider_->MainThreadTaskRunner()->PostTask( |
tzik | 4604bb5 | 2017-04-13 21:50:22 | [diff] [blame] | 705 | FROM_HERE, base::BindOnce(&SingleThreadProxy::BeginMainFrame, |
| 706 | weak_factory_.GetWeakPtr(), begin_frame_args)); |
Walter Korman | aa326e4 | 2017-08-22 23:04:43 | [diff] [blame] | 707 | host_impl_->DidSendBeginMainFrame(); |
[email protected] | aeeedad | 2014-08-22 18:16:22 | [diff] [blame] | 708 | } |
| 709 | |
kylechar | d96169b | 2018-11-02 00:55:00 | [diff] [blame] | 710 | void SingleThreadProxy::FrameIntervalUpdated(base::TimeDelta interval) { |
| 711 | DebugScopedSetMainThread main(task_runner_provider_); |
| 712 | single_thread_client_->FrameIntervalUpdated(interval); |
| 713 | } |
| 714 | |
rmcilroy | 0a19362a | 2015-02-18 12:34:25 | [diff] [blame] | 715 | void SingleThreadProxy::SendBeginMainFrameNotExpectedSoon() { |
| 716 | layer_tree_host_->BeginMainFrameNotExpectedSoon(); |
| 717 | } |
| 718 | |
delphick | 9db74aa | 2017-05-05 10:20:49 | [diff] [blame] | 719 | void SingleThreadProxy::ScheduledActionBeginMainFrameNotExpectedUntil( |
| 720 | base::TimeTicks time) { |
| 721 | layer_tree_host_->BeginMainFrameNotExpectedUntil(time); |
| 722 | } |
| 723 | |
Fady Samuel | c296f5fb | 2017-07-21 04:02:19 | [diff] [blame] | 724 | void SingleThreadProxy::BeginMainFrame( |
| 725 | const viz::BeginFrameArgs& begin_frame_args) { |
Brian Anderson | 242b9b0 | 2017-12-06 21:06:26 | [diff] [blame] | 726 | // This checker assumes NotifyReadyToCommit in this stack causes a synchronous |
| 727 | // commit. |
| 728 | ScopedAbortRemainingSwapPromises swap_promise_checker( |
| 729 | layer_tree_host_->GetSwapPromiseManager()); |
| 730 | |
brianderson | 21aef16 | 2015-11-11 05:12:23 | [diff] [blame] | 731 | if (scheduler_on_impl_thread_) { |
| 732 | scheduler_on_impl_thread_->NotifyBeginMainFrameStarted( |
| 733 | base::TimeTicks::Now()); |
| 734 | } |
| 735 | |
danakj | fcdaba12 | 2015-04-24 21:41:52 | [diff] [blame] | 736 | commit_requested_ = false; |
David Bokan | eaa5cc8 | 2018-10-12 15:50:40 | [diff] [blame] | 737 | needs_impl_frame_ = false; |
brianderson | 49e101d2 | 2015-04-29 00:05:33 | [diff] [blame] | 738 | animate_requested_ = false; |
danakj | fcdaba12 | 2015-04-24 21:41:52 | [diff] [blame] | 739 | |
Stephen Chenney | 6d3f5ce | 2018-11-14 02:08:05 | [diff] [blame] | 740 | if (defer_main_frame_update_) { |
simonhong | c6309f79 | 2015-01-31 15:47:15 | [diff] [blame] | 741 | TRACE_EVENT_INSTANT0("cc", "EarlyOut_DeferCommit", |
| 742 | TRACE_EVENT_SCOPE_THREAD); |
| 743 | BeginMainFrameAbortedOnImplThread( |
| 744 | CommitEarlyOutReason::ABORTED_DEFERRED_COMMIT); |
[email protected] | aeeedad | 2014-08-22 18:16:22 | [diff] [blame] | 745 | return; |
| 746 | } |
| 747 | |
khushalsagar | cebe494 | 2016-09-07 23:27:01 | [diff] [blame] | 748 | if (!layer_tree_host_->IsVisible()) { |
[email protected] | aeeedad | 2014-08-22 18:16:22 | [diff] [blame] | 749 | TRACE_EVENT_INSTANT0("cc", "EarlyOut_NotVisible", TRACE_EVENT_SCOPE_THREAD); |
mithro | f7a2150 | 2014-12-17 03:24:48 | [diff] [blame] | 750 | BeginMainFrameAbortedOnImplThread( |
| 751 | CommitEarlyOutReason::ABORTED_NOT_VISIBLE); |
[email protected] | aeeedad | 2014-08-22 18:16:22 | [diff] [blame] | 752 | return; |
| 753 | } |
| 754 | |
danakj | fcdaba12 | 2015-04-24 21:41:52 | [diff] [blame] | 755 | // Prevent new commits from being requested inside DoBeginMainFrame. |
brianderson | 49e101d2 | 2015-04-29 00:05:33 | [diff] [blame] | 756 | // Note: We do not want to prevent SetNeedsAnimate from requesting |
| 757 | // a commit here. |
danakj | fcdaba12 | 2015-04-24 21:41:52 | [diff] [blame] | 758 | commit_requested_ = true; |
| 759 | |
enne | 98f3a6c | 2014-10-09 20:09:44 | [diff] [blame] | 760 | DoBeginMainFrame(begin_frame_args); |
danakj | 97660d9 | 2017-03-27 14:11:49 | [diff] [blame] | 761 | |
| 762 | // New commits requested inside UpdateLayers should be respected. |
| 763 | commit_requested_ = false; |
| 764 | |
| 765 | // At this point the main frame may have deferred commits to avoid committing |
| 766 | // right now. |
Stephen Chenney | 6d3f5ce | 2018-11-14 02:08:05 | [diff] [blame] | 767 | if (defer_main_frame_update_ || begin_frame_args.animate_only) { |
danakj | 97660d9 | 2017-03-27 14:11:49 | [diff] [blame] | 768 | TRACE_EVENT_INSTANT0("cc", "EarlyOut_DeferCommit_InsideBeginMainFrame", |
| 769 | TRACE_EVENT_SCOPE_THREAD); |
| 770 | BeginMainFrameAbortedOnImplThread( |
| 771 | CommitEarlyOutReason::ABORTED_DEFERRED_COMMIT); |
| 772 | layer_tree_host_->DidBeginMainFrame(); |
| 773 | return; |
| 774 | } |
| 775 | |
Brian Anderson | 242b9b0 | 2017-12-06 21:06:26 | [diff] [blame] | 776 | // Queue the LATENCY_BEGIN_FRAME_UI_MAIN_COMPONENT swap promise only once we |
| 777 | // know we will commit since QueueSwapPromise itself requests a commit. |
| 778 | ui::LatencyInfo new_latency_info(ui::SourceEventType::FRAME); |
| 779 | new_latency_info.AddLatencyNumberWithTimestamp( |
Sadrul Habib Chowdhury | 41154dc0 | 2018-06-09 04:25:01 | [diff] [blame] | 780 | ui::LATENCY_BEGIN_FRAME_UI_MAIN_COMPONENT, begin_frame_args.frame_time, |
Navid Zolghadr | 5870ee11 | 2018-05-18 19:08:30 | [diff] [blame] | 781 | 1); |
Brian Anderson | 242b9b0 | 2017-12-06 21:06:26 | [diff] [blame] | 782 | layer_tree_host_->QueueSwapPromise( |
| 783 | std::make_unique<LatencyInfoSwapPromise>(new_latency_info)); |
| 784 | |
danakj | 97660d9 | 2017-03-27 14:11:49 | [diff] [blame] | 785 | DoPainting(); |
enne | 98f3a6c | 2014-10-09 20:09:44 | [diff] [blame] | 786 | } |
| 787 | |
| 788 | void SingleThreadProxy::DoBeginMainFrame( |
Fady Samuel | c296f5fb | 2017-07-21 04:02:19 | [diff] [blame] | 789 | const viz::BeginFrameArgs& begin_frame_args) { |
Khushal | 4b6c4188 | 2018-02-16 09:02:10 | [diff] [blame] | 790 | // The impl-side scroll deltas may be manipulated directly via the |
| 791 | // InputHandler on the UI thread and the scale deltas may change when they are |
| 792 | // clamped on the impl thread. |
tapted | 4b70c52 | 2016-08-13 09:09:32 | [diff] [blame] | 793 | std::unique_ptr<ScrollAndScaleSet> scroll_info = |
Walter Korman | aa326e4 | 2017-08-22 23:04:43 | [diff] [blame] | 794 | host_impl_->ProcessScrollDeltas(); |
tapted | 4b70c52 | 2016-08-13 09:09:32 | [diff] [blame] | 795 | layer_tree_host_->ApplyScrollAndScale(scroll_info.get()); |
| 796 | |
enne | 98f3a6c | 2014-10-09 20:09:44 | [diff] [blame] | 797 | layer_tree_host_->WillBeginMainFrame(); |
| 798 | layer_tree_host_->BeginMainFrame(begin_frame_args); |
| 799 | layer_tree_host_->AnimateLayers(begin_frame_args.frame_time); |
Stephen Chenney | ec431261 | 2018-11-21 12:40:16 | [diff] [blame] | 800 | layer_tree_host_->RequestMainFrameUpdate( |
| 801 | false /* record_main_frame_metrics */); |
danakj | 97660d9 | 2017-03-27 14:11:49 | [diff] [blame] | 802 | } |
enne | 98f3a6c | 2014-10-09 20:09:44 | [diff] [blame] | 803 | |
danakj | 97660d9 | 2017-03-27 14:11:49 | [diff] [blame] | 804 | void SingleThreadProxy::DoPainting() { |
danakj | 5f46636a | 2015-06-19 00:01:40 | [diff] [blame] | 805 | layer_tree_host_->UpdateLayers(); |
enne | 98f3a6c | 2014-10-09 20:09:44 | [diff] [blame] | 806 | |
mithro | f7a2150 | 2014-12-17 03:24:48 | [diff] [blame] | 807 | // TODO(enne): SingleThreadProxy does not support cancelling commits yet, |
| 808 | // search for CommitEarlyOutReason::FINISHED_NO_UPDATES inside |
| 809 | // thread_proxy.cc |
brianderson | 21aef16 | 2015-11-11 05:12:23 | [diff] [blame] | 810 | if (scheduler_on_impl_thread_) |
enne | 98f3a6c | 2014-10-09 20:09:44 | [diff] [blame] | 811 | scheduler_on_impl_thread_->NotifyReadyToCommit(); |
[email protected] | aeeedad | 2014-08-22 18:16:22 | [diff] [blame] | 812 | } |
| 813 | |
mithro | f7a2150 | 2014-12-17 03:24:48 | [diff] [blame] | 814 | void SingleThreadProxy::BeginMainFrameAbortedOnImplThread( |
| 815 | CommitEarlyOutReason reason) { |
khushalsagar | b7db1fe | 2015-11-12 00:51:27 | [diff] [blame] | 816 | DebugScopedSetImplThread impl(task_runner_provider_); |
[email protected] | aeeedad | 2014-08-22 18:16:22 | [diff] [blame] | 817 | DCHECK(scheduler_on_impl_thread_->CommitPending()); |
Walter Korman | aa326e4 | 2017-08-22 23:04:43 | [diff] [blame] | 818 | DCHECK(!host_impl_->pending_tree()); |
[email protected] | aeeedad | 2014-08-22 18:16:22 | [diff] [blame] | 819 | |
sunnyps | ad3235e | 2016-08-09 04:57:52 | [diff] [blame] | 820 | std::vector<std::unique_ptr<SwapPromise>> empty_swap_promises; |
Walter Korman | aa326e4 | 2017-08-22 23:04:43 | [diff] [blame] | 821 | host_impl_->BeginMainFrameAborted(reason, std::move(empty_swap_promises)); |
mithro | f7a2150 | 2014-12-17 03:24:48 | [diff] [blame] | 822 | scheduler_on_impl_thread_->BeginMainFrameAborted(reason); |
[email protected] | aeeedad | 2014-08-22 18:16:22 | [diff] [blame] | 823 | } |
| 824 | |
danakj | 9d12442 | 2016-10-14 03:15:08 | [diff] [blame] | 825 | DrawResult SingleThreadProxy::ScheduledActionDrawIfPossible() { |
khushalsagar | b7db1fe | 2015-11-12 00:51:27 | [diff] [blame] | 826 | DebugScopedSetImplThread impl(task_runner_provider_); |
[email protected] | aeeedad | 2014-08-22 18:16:22 | [diff] [blame] | 827 | LayerTreeHostImpl::FrameData frame; |
eseckler | dde665f | 2017-03-07 20:19:27 | [diff] [blame] | 828 | frame.begin_frame_ack = |
| 829 | scheduler_on_impl_thread_->CurrentBeginFrameAckForActiveTree(); |
mithro | 248d172 | 2015-05-05 05:23:45 | [diff] [blame] | 830 | return DoComposite(&frame); |
[email protected] | aeeedad | 2014-08-22 18:16:22 | [diff] [blame] | 831 | } |
| 832 | |
danakj | 9d12442 | 2016-10-14 03:15:08 | [diff] [blame] | 833 | DrawResult SingleThreadProxy::ScheduledActionDrawForced() { |
[email protected] | aeeedad | 2014-08-22 18:16:22 | [diff] [blame] | 834 | NOTREACHED(); |
| 835 | return INVALID_RESULT; |
| 836 | } |
| 837 | |
| 838 | void SingleThreadProxy::ScheduledActionCommit() { |
khushalsagar | b7db1fe | 2015-11-12 00:51:27 | [diff] [blame] | 839 | DebugScopedSetMainThread main(task_runner_provider_); |
enne | 98f3a6c | 2014-10-09 20:09:44 | [diff] [blame] | 840 | DoCommit(); |
[email protected] | aeeedad | 2014-08-22 18:16:22 | [diff] [blame] | 841 | } |
| 842 | |
[email protected] | aeeedad | 2014-08-22 18:16:22 | [diff] [blame] | 843 | void SingleThreadProxy::ScheduledActionActivateSyncTree() { |
khushalsagar | b7db1fe | 2015-11-12 00:51:27 | [diff] [blame] | 844 | DebugScopedSetImplThread impl(task_runner_provider_); |
Walter Korman | aa326e4 | 2017-08-22 23:04:43 | [diff] [blame] | 845 | host_impl_->ActivateSyncTree(); |
[email protected] | aeeedad | 2014-08-22 18:16:22 | [diff] [blame] | 846 | } |
| 847 | |
danakj | c7afae5 | 2017-06-20 21:12:41 | [diff] [blame] | 848 | void SingleThreadProxy::ScheduledActionBeginLayerTreeFrameSinkCreation() { |
khushalsagar | b7db1fe | 2015-11-12 00:51:27 | [diff] [blame] | 849 | DebugScopedSetMainThread main(task_runner_provider_); |
[email protected] | aeeedad | 2014-08-22 18:16:22 | [diff] [blame] | 850 | DCHECK(scheduler_on_impl_thread_); |
| 851 | // If possible, create the output surface in a post task. Synchronously |
| 852 | // creating the output surface makes tests more awkward since this differs |
| 853 | // from the ThreadProxy behavior. However, sometimes there is no |
| 854 | // task runner. |
khushalsagar | b7db1fe | 2015-11-12 00:51:27 | [diff] [blame] | 855 | if (task_runner_provider_->MainThreadTaskRunner()) { |
danakj | c7afae5 | 2017-06-20 21:12:41 | [diff] [blame] | 856 | ScheduleRequestNewLayerTreeFrameSink(); |
[email protected] | aeeedad | 2014-08-22 18:16:22 | [diff] [blame] | 857 | } else { |
danakj | c7afae5 | 2017-06-20 21:12:41 | [diff] [blame] | 858 | RequestNewLayerTreeFrameSink(); |
[email protected] | aeeedad | 2014-08-22 18:16:22 | [diff] [blame] | 859 | } |
| 860 | } |
| 861 | |
vmiura | 59ea9b404 | 2014-12-09 20:50:39 | [diff] [blame] | 862 | void SingleThreadProxy::ScheduledActionPrepareTiles() { |
| 863 | TRACE_EVENT0("cc", "SingleThreadProxy::ScheduledActionPrepareTiles"); |
khushalsagar | b7db1fe | 2015-11-12 00:51:27 | [diff] [blame] | 864 | DebugScopedSetImplThread impl(task_runner_provider_); |
Walter Korman | aa326e4 | 2017-08-22 23:04:43 | [diff] [blame] | 865 | host_impl_->PrepareTiles(); |
[email protected] | aeeedad | 2014-08-22 18:16:22 | [diff] [blame] | 866 | } |
| 867 | |
James Wallace-Lee | fbb0e336 | 2018-06-18 23:57:47 | [diff] [blame] | 868 | void SingleThreadProxy::ScheduledActionInvalidateLayerTreeFrameSink( |
| 869 | bool needs_redraw) { |
danakj | a5df5379 | 2018-04-26 18:36:39 | [diff] [blame] | 870 | // This is an Android WebView codepath, which only uses multi-thread |
| 871 | // compositor. So this should not occur in single-thread mode. |
| 872 | NOTREACHED() << "Android Webview use-case, so multi-thread only"; |
sunnyps | eab5ac9 | 2015-04-02 20:26:13 | [diff] [blame] | 873 | } |
| 874 | |
khushalsagar | ab73d50 | 2017-02-24 02:26:46 | [diff] [blame] | 875 | void SingleThreadProxy::ScheduledActionPerformImplSideInvalidation() { |
khushalsagar | 6dc91d0 | 2017-02-28 05:10:07 | [diff] [blame] | 876 | DCHECK(scheduler_on_impl_thread_); |
| 877 | |
| 878 | DebugScopedSetImplThread impl(task_runner_provider_); |
Walter Korman | aa326e4 | 2017-08-22 23:04:43 | [diff] [blame] | 879 | host_impl_->InvalidateContentOnImplSide(); |
khushalsagar | 6dc91d0 | 2017-02-28 05:10:07 | [diff] [blame] | 880 | |
| 881 | // Invalidations go directly to the active tree, so we synchronously call |
| 882 | // NotifyReadyToActivate to update the scheduler and LTHI state correctly. |
| 883 | // Since in single-threaded mode the scheduler will wait for a ready to draw |
| 884 | // signal from LTHI, the draw will remain blocked till the invalidated tiles |
| 885 | // are ready. |
| 886 | NotifyReadyToActivate(); |
khushalsagar | ab73d50 | 2017-02-24 02:26:46 | [diff] [blame] | 887 | } |
| 888 | |
mithro | 51693e38 | 2015-05-07 23:52:41 | [diff] [blame] | 889 | void SingleThreadProxy::DidFinishImplFrame() { |
Walter Korman | aa326e4 | 2017-08-22 23:04:43 | [diff] [blame] | 890 | host_impl_->DidFinishImplFrame(); |
mithro | 51693e38 | 2015-05-07 23:52:41 | [diff] [blame] | 891 | #if DCHECK_IS_ON() |
mithro | 69fd3bb5 | 2015-05-01 03:45:02 | [diff] [blame] | 892 | DCHECK(inside_impl_frame_) |
mithro | 51693e38 | 2015-05-07 23:52:41 | [diff] [blame] | 893 | << "DidFinishImplFrame called while not inside an impl frame!"; |
mithro | 69fd3bb5 | 2015-05-01 03:45:02 | [diff] [blame] | 894 | inside_impl_frame_ = false; |
mithro | 51693e38 | 2015-05-07 23:52:41 | [diff] [blame] | 895 | #endif |
[email protected] | aeeedad | 2014-08-22 18:16:22 | [diff] [blame] | 896 | } |
| 897 | |
Fady Samuel | c296f5fb | 2017-07-21 04:02:19 | [diff] [blame] | 898 | void SingleThreadProxy::DidNotProduceFrame(const viz::BeginFrameAck& ack) { |
eseckler | 9404a23 | 2017-05-22 14:49:43 | [diff] [blame] | 899 | DebugScopedSetImplThread impl(task_runner_provider_); |
Walter Korman | aa326e4 | 2017-08-22 23:04:43 | [diff] [blame] | 900 | host_impl_->DidNotProduceFrame(ack); |
eseckler | 9404a23 | 2017-05-22 14:49:43 | [diff] [blame] | 901 | } |
| 902 | |
yiyix | 807099e | 2018-11-09 05:24:28 | [diff] [blame] | 903 | void SingleThreadProxy::WillNotReceiveBeginFrame() { |
| 904 | host_impl_->DidNotNeedBeginFrame(); |
| 905 | } |
| 906 | |
samans | 44b6dfc | 2017-04-19 16:50:53 | [diff] [blame] | 907 | void SingleThreadProxy::DidReceiveCompositorFrameAck() { |
| 908 | layer_tree_host_->DidReceiveCompositorFrameAck(); |
| 909 | } |
| 910 | |
[email protected] | bc5e77c | 2012-11-05 20:00:49 | [diff] [blame] | 911 | } // namespace cc |