OLD | NEW |
1 // Copyright 2015 The Chromium Authors. All rights reserved. | 1 // Copyright 2015 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "components/scheduler/renderer/web_view_scheduler_impl.h" | 5 #include "components/scheduler/renderer/web_view_scheduler_impl.h" |
6 | 6 |
7 #include "base/logging.h" | 7 #include "base/logging.h" |
| 8 #include "components/scheduler/base/real_time_domain.h" |
8 #include "components/scheduler/base/virtual_time_domain.h" | 9 #include "components/scheduler/base/virtual_time_domain.h" |
9 #include "components/scheduler/child/scheduler_tqm_delegate.h" | 10 #include "components/scheduler/child/scheduler_tqm_delegate.h" |
10 #include "components/scheduler/renderer/auto_advancing_virtual_time_domain.h" | 11 #include "components/scheduler/renderer/auto_advancing_virtual_time_domain.h" |
11 #include "components/scheduler/renderer/renderer_scheduler_impl.h" | 12 #include "components/scheduler/renderer/renderer_scheduler_impl.h" |
12 #include "components/scheduler/renderer/web_frame_scheduler_impl.h" | 13 #include "components/scheduler/renderer/web_frame_scheduler_impl.h" |
13 #include "third_party/WebKit/public/platform/WebFrameScheduler.h" | 14 #include "third_party/WebKit/public/platform/WebFrameScheduler.h" |
14 #include "third_party/WebKit/public/web/WebConsoleMessage.h" | 15 #include "third_party/WebKit/public/web/WebConsoleMessage.h" |
15 #include "third_party/WebKit/public/web/WebFrame.h" | 16 #include "third_party/WebKit/public/web/WebFrame.h" |
16 #include "third_party/WebKit/public/web/WebView.h" | 17 #include "third_party/WebKit/public/web/WebView.h" |
17 | 18 |
18 namespace scheduler { | 19 namespace scheduler { |
19 | 20 |
20 WebViewSchedulerImpl::WebViewSchedulerImpl( | 21 WebViewSchedulerImpl::WebViewSchedulerImpl( |
21 blink::WebView* web_view, | 22 blink::WebView* web_view, |
22 RendererSchedulerImpl* renderer_scheduler, | 23 RendererSchedulerImpl* renderer_scheduler, |
23 bool disable_background_timer_throttling) | 24 bool disable_background_timer_throttling) |
24 : virtual_time_pump_policy_(TaskQueue::PumpPolicy::AUTO), | 25 : virtual_time_pump_policy_(TaskQueue::PumpPolicy::AUTO), |
25 web_view_(web_view), | 26 web_view_(web_view), |
26 renderer_scheduler_(renderer_scheduler), | 27 renderer_scheduler_(renderer_scheduler), |
27 virtual_time_policy_(VirtualTimePolicy::ADVANCE), | 28 virtual_time_policy_(VirtualTimePolicy::ADVANCE), |
28 page_visible_(true), | 29 page_visible_(true), |
29 disable_background_timer_throttling_(disable_background_timer_throttling), | 30 disable_background_timer_throttling_(disable_background_timer_throttling), |
30 allow_virtual_time_to_advance_(true) { | 31 allow_virtual_time_to_advance_(true), |
| 32 have_seen_loading_task_(false) { |
31 renderer_scheduler->AddWebViewScheduler(this); | 33 renderer_scheduler->AddWebViewScheduler(this); |
32 } | 34 } |
33 | 35 |
34 WebViewSchedulerImpl::~WebViewSchedulerImpl() { | 36 WebViewSchedulerImpl::~WebViewSchedulerImpl() { |
35 // TODO(alexclarke): Find out why we can't rely on the web view outliving the | 37 // TODO(alexclarke): Find out why we can't rely on the web view outliving the |
36 // frame. | 38 // frame. |
37 for (WebFrameSchedulerImpl* frame_scheduler : frame_schedulers_) { | 39 for (WebFrameSchedulerImpl* frame_scheduler : frame_schedulers_) { |
38 frame_scheduler->DetachFromWebViewScheduler(); | 40 frame_scheduler->DetachFromWebViewScheduler(); |
39 } | 41 } |
40 renderer_scheduler_->RemoveWebViewScheduler(this); | 42 renderer_scheduler_->RemoveWebViewScheduler(this); |
41 if (virtual_time_domain_) | 43 if (virtual_time_domain_) { |
| 44 // Since we're just about to delete virtual_time_domain_ we'd better move |
| 45 // the per-thread task queues back to the RealTimeDomain or we risk a UAF |
| 46 // when the task queues get deleted. |
| 47 renderer_scheduler_->SetPerThreadTaskRunnerTimeDomain( |
| 48 renderer_scheduler_->real_time_domain()); |
42 renderer_scheduler_->UnregisterTimeDomain(virtual_time_domain_.get()); | 49 renderer_scheduler_->UnregisterTimeDomain(virtual_time_domain_.get()); |
| 50 } |
43 } | 51 } |
44 | 52 |
45 void WebViewSchedulerImpl::setPageVisible(bool page_visible) { | 53 void WebViewSchedulerImpl::setPageVisible(bool page_visible) { |
46 if (disable_background_timer_throttling_ || page_visible_ == page_visible) | 54 if (disable_background_timer_throttling_ || page_visible_ == page_visible) |
47 return; | 55 return; |
48 | 56 |
49 page_visible_ = page_visible; | 57 page_visible_ = page_visible; |
50 | 58 |
51 for (WebFrameSchedulerImpl* frame_scheduler : frame_schedulers_) { | 59 for (WebFrameSchedulerImpl* frame_scheduler : frame_schedulers_) { |
52 frame_scheduler->setPageVisible(page_visible_); | 60 frame_scheduler->setPageVisible(page_visible_); |
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
91 virtual_time_domain_.reset(new AutoAdvancingVirtualTimeDomain( | 99 virtual_time_domain_.reset(new AutoAdvancingVirtualTimeDomain( |
92 renderer_scheduler_->tick_clock()->NowTicks())); | 100 renderer_scheduler_->tick_clock()->NowTicks())); |
93 renderer_scheduler_->RegisterTimeDomain(virtual_time_domain_.get()); | 101 renderer_scheduler_->RegisterTimeDomain(virtual_time_domain_.get()); |
94 | 102 |
95 virtual_time_domain_->SetCanAdvanceVirtualTime( | 103 virtual_time_domain_->SetCanAdvanceVirtualTime( |
96 allow_virtual_time_to_advance_); | 104 allow_virtual_time_to_advance_); |
97 | 105 |
98 for (WebFrameSchedulerImpl* frame_scheduler : frame_schedulers_) { | 106 for (WebFrameSchedulerImpl* frame_scheduler : frame_schedulers_) { |
99 frame_scheduler->OnVirtualTimeDomainChanged(); | 107 frame_scheduler->OnVirtualTimeDomainChanged(); |
100 } | 108 } |
| 109 |
| 110 // For determinism the per-thread task queues must use virtual time too. |
| 111 renderer_scheduler_->SetPerThreadTaskRunnerTimeDomain( |
| 112 virtual_time_domain_.get()); |
101 } | 113 } |
102 | 114 |
103 void WebViewSchedulerImpl::setAllowVirtualTimeToAdvance( | 115 void WebViewSchedulerImpl::setAllowVirtualTimeToAdvance( |
104 bool allow_virtual_time_to_advance) { | 116 bool allow_virtual_time_to_advance) { |
105 if (allow_virtual_time_to_advance_ == allow_virtual_time_to_advance) | 117 if (allow_virtual_time_to_advance_ == allow_virtual_time_to_advance) |
106 return; | 118 return; |
107 | 119 |
108 allow_virtual_time_to_advance_ = allow_virtual_time_to_advance; | 120 allow_virtual_time_to_advance_ = allow_virtual_time_to_advance; |
109 | 121 |
110 if (virtual_time_domain_) { | 122 if (virtual_time_domain_) { |
111 virtual_time_domain_->SetCanAdvanceVirtualTime( | 123 virtual_time_domain_->SetCanAdvanceVirtualTime( |
112 allow_virtual_time_to_advance); | 124 allow_virtual_time_to_advance); |
113 } | 125 } |
114 } | 126 } |
115 | 127 |
116 bool WebViewSchedulerImpl::virtualTimeAllowedToAdvance() const { | 128 bool WebViewSchedulerImpl::virtualTimeAllowedToAdvance() const { |
117 return allow_virtual_time_to_advance_; | 129 return allow_virtual_time_to_advance_; |
118 } | 130 } |
119 | 131 |
120 void WebViewSchedulerImpl::DidStartLoading(unsigned long identifier) { | 132 void WebViewSchedulerImpl::DidStartLoading(unsigned long identifier) { |
121 pending_loads_.insert(identifier); | 133 pending_loads_.insert(identifier); |
| 134 have_seen_loading_task_ = true; |
122 | 135 |
123 if (virtual_time_policy_ != | 136 if (virtual_time_policy_ != |
124 VirtualTimePolicy::PAUSE_IF_NETWORK_FETCHES_PENDING) { | 137 VirtualTimePolicy::PAUSE_IF_NETWORK_FETCHES_PENDING) { |
125 return; | 138 return; |
126 } | 139 } |
127 | 140 |
128 if (pending_loads_.size() == 1u) | 141 if (pending_loads_.size() == 1u) |
129 setAllowVirtualTimeToAdvance(false); | 142 setAllowVirtualTimeToAdvance(false); |
130 } | 143 } |
131 | 144 |
(...skipping 15 matching lines...) Expand all Loading... |
147 switch (virtual_time_policy_) { | 160 switch (virtual_time_policy_) { |
148 case VirtualTimePolicy::ADVANCE: | 161 case VirtualTimePolicy::ADVANCE: |
149 setAllowVirtualTimeToAdvance(true); | 162 setAllowVirtualTimeToAdvance(true); |
150 break; | 163 break; |
151 | 164 |
152 case VirtualTimePolicy::PAUSE: | 165 case VirtualTimePolicy::PAUSE: |
153 setAllowVirtualTimeToAdvance(false); | 166 setAllowVirtualTimeToAdvance(false); |
154 break; | 167 break; |
155 | 168 |
156 case VirtualTimePolicy::PAUSE_IF_NETWORK_FETCHES_PENDING: | 169 case VirtualTimePolicy::PAUSE_IF_NETWORK_FETCHES_PENDING: |
157 setAllowVirtualTimeToAdvance(pending_loads_.size() == 0); | 170 // We pause virtual time until we've seen a loading task posted, because |
| 171 // otherwise we could advance virtual time arbitarially far before the |
| 172 // first load arrives. |
| 173 setAllowVirtualTimeToAdvance(pending_loads_.size() == 0 && |
| 174 have_seen_loading_task_); |
158 break; | 175 break; |
159 } | 176 } |
160 } | 177 } |
161 | 178 |
162 } // namespace scheduler | 179 } // namespace scheduler |
OLD | NEW |