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 page_visible_(true), | 28 page_visible_(true), |
29 disable_background_timer_throttling_(disable_background_timer_throttling), | 29 disable_background_timer_throttling_(disable_background_timer_throttling), |
30 allow_virtual_time_to_advance_(true) { | 30 allow_virtual_time_to_advance_(true), |
31 have_seen_loading_task_(false), | |
32 virtual_time_(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_) | |
42 renderer_scheduler_->UnregisterTimeDomain(virtual_time_domain_.get()); | |
43 } | 43 } |
44 | 44 |
45 void WebViewSchedulerImpl::setPageVisible(bool page_visible) { | 45 void WebViewSchedulerImpl::setPageVisible(bool page_visible) { |
46 if (disable_background_timer_throttling_ || page_visible_ == page_visible) | 46 if (disable_background_timer_throttling_ || page_visible_ == page_visible) |
47 return; | 47 return; |
48 | 48 |
49 page_visible_ = page_visible; | 49 page_visible_ = page_visible; |
50 | 50 |
51 for (WebFrameSchedulerImpl* frame_scheduler : frame_schedulers_) { | 51 for (WebFrameSchedulerImpl* frame_scheduler : frame_schedulers_) { |
52 frame_scheduler->setPageVisible(page_visible_); | 52 frame_scheduler->setPageVisible(page_visible_); |
(...skipping 23 matching lines...) Expand all Loading... | |
76 void WebViewSchedulerImpl::AddConsoleWarning(const std::string& message) { | 76 void WebViewSchedulerImpl::AddConsoleWarning(const std::string& message) { |
77 if (!web_view_ || !web_view_->mainFrame()) | 77 if (!web_view_ || !web_view_->mainFrame()) |
78 return; | 78 return; |
79 blink::WebConsoleMessage console_message( | 79 blink::WebConsoleMessage console_message( |
80 blink::WebConsoleMessage::LevelWarning, | 80 blink::WebConsoleMessage::LevelWarning, |
81 blink::WebString::fromUTF8(message)); | 81 blink::WebString::fromUTF8(message)); |
82 web_view_->mainFrame()->addMessageToConsole(console_message); | 82 web_view_->mainFrame()->addMessageToConsole(console_message); |
83 } | 83 } |
84 | 84 |
85 void WebViewSchedulerImpl::enableVirtualTime() { | 85 void WebViewSchedulerImpl::enableVirtualTime() { |
86 // If we've already switched to virtual time then we don't need to do | 86 if (virtual_time_) |
87 // anything more. | |
88 if (virtual_time_domain_.get()) | |
89 return; | 87 return; |
90 | 88 |
91 virtual_time_domain_.reset(new AutoAdvancingVirtualTimeDomain( | 89 virtual_time_ = true; |
92 renderer_scheduler_->tick_clock()->NowTicks())); | 90 renderer_scheduler_->virtual_time_domain()->SetCanAdvanceVirtualTime( |
93 renderer_scheduler_->RegisterTimeDomain(virtual_time_domain_.get()); | |
94 | |
95 virtual_time_domain_->SetCanAdvanceVirtualTime( | |
96 allow_virtual_time_to_advance_); | 91 allow_virtual_time_to_advance_); |
97 | 92 |
98 for (WebFrameSchedulerImpl* frame_scheduler : frame_schedulers_) { | 93 renderer_scheduler_->EnableVirtualTime(); |
99 frame_scheduler->OnVirtualTimeDomainChanged(); | |
100 } | |
101 } | 94 } |
102 | 95 |
103 void WebViewSchedulerImpl::setAllowVirtualTimeToAdvance( | 96 void WebViewSchedulerImpl::setAllowVirtualTimeToAdvance( |
104 bool allow_virtual_time_to_advance) { | 97 bool allow_virtual_time_to_advance) { |
105 if (allow_virtual_time_to_advance_ == allow_virtual_time_to_advance) | 98 allow_virtual_time_to_advance_ = allow_virtual_time_to_advance; |
99 | |
100 if (!virtual_time_) | |
106 return; | 101 return; |
107 | 102 |
108 allow_virtual_time_to_advance_ = allow_virtual_time_to_advance; | 103 renderer_scheduler_->virtual_time_domain()->SetCanAdvanceVirtualTime( |
109 | 104 allow_virtual_time_to_advance); |
110 if (virtual_time_domain_) { | |
111 virtual_time_domain_->SetCanAdvanceVirtualTime( | |
112 allow_virtual_time_to_advance); | |
113 } | |
114 } | 105 } |
115 | 106 |
116 bool WebViewSchedulerImpl::virtualTimeAllowedToAdvance() const { | 107 bool WebViewSchedulerImpl::virtualTimeAllowedToAdvance() const { |
117 return allow_virtual_time_to_advance_; | 108 return allow_virtual_time_to_advance_; |
118 } | 109 } |
119 | 110 |
120 void WebViewSchedulerImpl::DidStartLoading(unsigned long identifier) { | 111 void WebViewSchedulerImpl::DidStartLoading(unsigned long identifier) { |
121 pending_loads_.insert(identifier); | 112 pending_loads_.insert(identifier); |
113 have_seen_loading_task_ = true; | |
122 | 114 |
123 if (virtual_time_policy_ != | 115 if (virtual_time_policy_ != |
124 VirtualTimePolicy::PAUSE_IF_NETWORK_FETCHES_PENDING) { | 116 VirtualTimePolicy::PAUSE_IF_NETWORK_FETCHES_PENDING) { |
125 return; | 117 return; |
126 } | 118 } |
127 | 119 |
128 if (pending_loads_.size() == 1u) | 120 if (pending_loads_.size() == 1u) |
129 setAllowVirtualTimeToAdvance(false); | 121 setAllowVirtualTimeToAdvance(false); |
130 } | 122 } |
131 | 123 |
(...skipping 15 matching lines...) Expand all Loading... | |
147 switch (virtual_time_policy_) { | 139 switch (virtual_time_policy_) { |
148 case VirtualTimePolicy::ADVANCE: | 140 case VirtualTimePolicy::ADVANCE: |
149 setAllowVirtualTimeToAdvance(true); | 141 setAllowVirtualTimeToAdvance(true); |
150 break; | 142 break; |
151 | 143 |
152 case VirtualTimePolicy::PAUSE: | 144 case VirtualTimePolicy::PAUSE: |
153 setAllowVirtualTimeToAdvance(false); | 145 setAllowVirtualTimeToAdvance(false); |
154 break; | 146 break; |
155 | 147 |
156 case VirtualTimePolicy::PAUSE_IF_NETWORK_FETCHES_PENDING: | 148 case VirtualTimePolicy::PAUSE_IF_NETWORK_FETCHES_PENDING: |
157 setAllowVirtualTimeToAdvance(pending_loads_.size() == 0); | 149 // We pause virtual time until we've seen a loading task posted, because |
150 // otherwise we could advance virtual time arbitarially far before the | |
Sami
2016/07/29 14:05:51
typo: arbitrarily
alex clarke (OOO till 29th)
2016/07/29 14:42:16
Done.
| |
151 // first load arrives. | |
152 setAllowVirtualTimeToAdvance(pending_loads_.size() == 0 && | |
153 have_seen_loading_task_); | |
158 break; | 154 break; |
159 } | 155 } |
160 } | 156 } |
161 | 157 |
162 } // namespace scheduler | 158 } // namespace scheduler |
OLD | NEW |