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 : web_view_(web_view), |
25 web_view_(web_view), | |
26 renderer_scheduler_(renderer_scheduler), | 26 renderer_scheduler_(renderer_scheduler), |
27 virtual_time_policy_(VirtualTimePolicy::ADVANCE), | 27 virtual_time_policy_(VirtualTimePolicy::ADVANCE), |
28 background_parser_count_(0), | 28 background_parser_count_(0), |
29 page_visible_(true), | 29 page_visible_(true), |
30 disable_background_timer_throttling_(disable_background_timer_throttling), | 30 disable_background_timer_throttling_(disable_background_timer_throttling), |
31 allow_virtual_time_to_advance_(true) { | 31 allow_virtual_time_to_advance_(true), |
| 32 have_seen_loading_task_(false), |
| 33 virtual_time_(false) { |
32 renderer_scheduler->AddWebViewScheduler(this); | 34 renderer_scheduler->AddWebViewScheduler(this); |
33 } | 35 } |
34 | 36 |
35 WebViewSchedulerImpl::~WebViewSchedulerImpl() { | 37 WebViewSchedulerImpl::~WebViewSchedulerImpl() { |
36 // TODO(alexclarke): Find out why we can't rely on the web view outliving the | 38 // TODO(alexclarke): Find out why we can't rely on the web view outliving the |
37 // frame. | 39 // frame. |
38 for (WebFrameSchedulerImpl* frame_scheduler : frame_schedulers_) { | 40 for (WebFrameSchedulerImpl* frame_scheduler : frame_schedulers_) { |
39 frame_scheduler->DetachFromWebViewScheduler(); | 41 frame_scheduler->DetachFromWebViewScheduler(); |
40 } | 42 } |
41 renderer_scheduler_->RemoveWebViewScheduler(this); | 43 renderer_scheduler_->RemoveWebViewScheduler(this); |
42 if (virtual_time_domain_) | |
43 renderer_scheduler_->UnregisterTimeDomain(virtual_time_domain_.get()); | |
44 } | 44 } |
45 | 45 |
46 void WebViewSchedulerImpl::setPageVisible(bool page_visible) { | 46 void WebViewSchedulerImpl::setPageVisible(bool page_visible) { |
47 if (disable_background_timer_throttling_ || page_visible_ == page_visible) | 47 if (disable_background_timer_throttling_ || page_visible_ == page_visible) |
48 return; | 48 return; |
49 | 49 |
50 page_visible_ = page_visible; | 50 page_visible_ = page_visible; |
51 | 51 |
52 for (WebFrameSchedulerImpl* frame_scheduler : frame_schedulers_) { | 52 for (WebFrameSchedulerImpl* frame_scheduler : frame_schedulers_) { |
53 frame_scheduler->setPageVisible(page_visible_); | 53 frame_scheduler->setPageVisible(page_visible_); |
(...skipping 23 matching lines...) Expand all Loading... |
77 void WebViewSchedulerImpl::AddConsoleWarning(const std::string& message) { | 77 void WebViewSchedulerImpl::AddConsoleWarning(const std::string& message) { |
78 if (!web_view_ || !web_view_->mainFrame()) | 78 if (!web_view_ || !web_view_->mainFrame()) |
79 return; | 79 return; |
80 blink::WebConsoleMessage console_message( | 80 blink::WebConsoleMessage console_message( |
81 blink::WebConsoleMessage::LevelWarning, | 81 blink::WebConsoleMessage::LevelWarning, |
82 blink::WebString::fromUTF8(message)); | 82 blink::WebString::fromUTF8(message)); |
83 web_view_->mainFrame()->addMessageToConsole(console_message); | 83 web_view_->mainFrame()->addMessageToConsole(console_message); |
84 } | 84 } |
85 | 85 |
86 void WebViewSchedulerImpl::enableVirtualTime() { | 86 void WebViewSchedulerImpl::enableVirtualTime() { |
87 // If we've already switched to virtual time then we don't need to do | 87 if (virtual_time_) |
88 // anything more. | |
89 if (virtual_time_domain_.get()) | |
90 return; | 88 return; |
91 | 89 |
92 virtual_time_domain_.reset(new AutoAdvancingVirtualTimeDomain( | 90 virtual_time_ = true; |
93 renderer_scheduler_->tick_clock()->NowTicks())); | 91 renderer_scheduler_->GetVirtualTimeDomain()->SetCanAdvanceVirtualTime( |
94 renderer_scheduler_->RegisterTimeDomain(virtual_time_domain_.get()); | |
95 | |
96 virtual_time_domain_->SetCanAdvanceVirtualTime( | |
97 allow_virtual_time_to_advance_); | 92 allow_virtual_time_to_advance_); |
98 | 93 |
99 for (WebFrameSchedulerImpl* frame_scheduler : frame_schedulers_) { | 94 renderer_scheduler_->EnableVirtualTime(); |
100 frame_scheduler->OnVirtualTimeDomainChanged(); | |
101 } | |
102 } | 95 } |
103 | 96 |
104 void WebViewSchedulerImpl::setAllowVirtualTimeToAdvance( | 97 void WebViewSchedulerImpl::setAllowVirtualTimeToAdvance( |
105 bool allow_virtual_time_to_advance) { | 98 bool allow_virtual_time_to_advance) { |
106 if (allow_virtual_time_to_advance_ == allow_virtual_time_to_advance) | 99 allow_virtual_time_to_advance_ = allow_virtual_time_to_advance; |
| 100 |
| 101 if (!virtual_time_) |
107 return; | 102 return; |
108 | 103 |
109 allow_virtual_time_to_advance_ = allow_virtual_time_to_advance; | 104 renderer_scheduler_->GetVirtualTimeDomain()->SetCanAdvanceVirtualTime( |
110 | 105 allow_virtual_time_to_advance); |
111 if (virtual_time_domain_) { | |
112 virtual_time_domain_->SetCanAdvanceVirtualTime( | |
113 allow_virtual_time_to_advance); | |
114 } | |
115 } | 106 } |
116 | 107 |
117 bool WebViewSchedulerImpl::virtualTimeAllowedToAdvance() const { | 108 bool WebViewSchedulerImpl::virtualTimeAllowedToAdvance() const { |
118 return allow_virtual_time_to_advance_; | 109 return allow_virtual_time_to_advance_; |
119 } | 110 } |
120 | 111 |
121 void WebViewSchedulerImpl::DidStartLoading(unsigned long identifier) { | 112 void WebViewSchedulerImpl::DidStartLoading(unsigned long identifier) { |
122 pending_loads_.insert(identifier); | 113 pending_loads_.insert(identifier); |
| 114 have_seen_loading_task_ = true; |
123 ApplyVirtualTimePolicy(); | 115 ApplyVirtualTimePolicy(); |
124 } | 116 } |
125 | 117 |
126 void WebViewSchedulerImpl::DidStopLoading(unsigned long identifier) { | 118 void WebViewSchedulerImpl::DidStopLoading(unsigned long identifier) { |
127 pending_loads_.erase(identifier); | 119 pending_loads_.erase(identifier); |
128 ApplyVirtualTimePolicy(); | 120 ApplyVirtualTimePolicy(); |
129 } | 121 } |
130 | 122 |
131 void WebViewSchedulerImpl::IncrementBackgroundParserCount() { | 123 void WebViewSchedulerImpl::IncrementBackgroundParserCount() { |
132 background_parser_count_++; | 124 background_parser_count_++; |
(...skipping 22 matching lines...) Expand all Loading... |
155 ApplyVirtualTimePolicy(); | 147 ApplyVirtualTimePolicy(); |
156 break; | 148 break; |
157 } | 149 } |
158 } | 150 } |
159 | 151 |
160 void WebViewSchedulerImpl::ApplyVirtualTimePolicy() { | 152 void WebViewSchedulerImpl::ApplyVirtualTimePolicy() { |
161 if (virtual_time_policy_ != VirtualTimePolicy::DETERMINISTIC_LOADING) { | 153 if (virtual_time_policy_ != VirtualTimePolicy::DETERMINISTIC_LOADING) { |
162 return; | 154 return; |
163 } | 155 } |
164 | 156 |
| 157 // We pause virtual time until we've seen a loading task posted, because |
| 158 // otherwise we could advance virtual time arbitarially far before the |
| 159 // first load arrives. |
165 setAllowVirtualTimeToAdvance(pending_loads_.size() == 0 && | 160 setAllowVirtualTimeToAdvance(pending_loads_.size() == 0 && |
166 background_parser_count_ == 0); | 161 background_parser_count_ == 0 && |
| 162 have_seen_loading_task_); |
167 } | 163 } |
168 | 164 |
169 } // namespace scheduler | 165 } // namespace scheduler |
OLD | NEW |