OLD | NEW |
1 // Copyright 2016 The Chromium Authors. All rights reserved. | 1 // Copyright 2016 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 "core/loader/ThreadableLoader.h" | 5 #include "core/loader/ThreadableLoader.h" |
6 | 6 |
7 #include <memory> | 7 #include <memory> |
8 #include "core/dom/TaskRunnerHelper.h" | 8 #include "core/dom/TaskRunnerHelper.h" |
9 #include "core/loader/DocumentThreadableLoader.h" | 9 #include "core/loader/DocumentThreadableLoader.h" |
10 #include "core/loader/ThreadableLoaderClient.h" | 10 #include "core/loader/ThreadableLoaderClient.h" |
(...skipping 163 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
174 public WorkerLoaderProxyProvider { | 174 public WorkerLoaderProxyProvider { |
175 public: | 175 public: |
176 WorkerThreadableLoaderTestHelper() | 176 WorkerThreadableLoaderTestHelper() |
177 : dummy_page_holder_(DummyPageHolder::Create(IntSize(1, 1))) {} | 177 : dummy_page_holder_(DummyPageHolder::Create(IntSize(1, 1))) {} |
178 | 178 |
179 void CreateLoader( | 179 void CreateLoader( |
180 ThreadableLoaderClient* client, | 180 ThreadableLoaderClient* client, |
181 CrossOriginRequestPolicy cross_origin_request_policy) override { | 181 CrossOriginRequestPolicy cross_origin_request_policy) override { |
182 std::unique_ptr<WaitableEvent> completion_event = | 182 std::unique_ptr<WaitableEvent> completion_event = |
183 WTF::MakeUnique<WaitableEvent>(); | 183 WTF::MakeUnique<WaitableEvent>(); |
184 PostTaskToWorkerGlobalScope( | 184 worker_loading_task_runner_->PostTask( |
185 BLINK_FROM_HERE, | 185 BLINK_FROM_HERE, |
186 CrossThreadBind(&WorkerThreadableLoaderTestHelper::WorkerCreateLoader, | 186 CrossThreadBind(&WorkerThreadableLoaderTestHelper::WorkerCreateLoader, |
187 CrossThreadUnretained(this), | 187 CrossThreadUnretained(this), |
188 CrossThreadUnretained(client), | 188 CrossThreadUnretained(client), |
189 CrossThreadUnretained(completion_event.get()), | 189 CrossThreadUnretained(completion_event.get()), |
190 cross_origin_request_policy)); | 190 cross_origin_request_policy)); |
191 completion_event->Wait(); | 191 completion_event->Wait(); |
192 } | 192 } |
193 | 193 |
194 void StartLoader(const ResourceRequest& request) override { | 194 void StartLoader(const ResourceRequest& request) override { |
195 std::unique_ptr<WaitableEvent> completion_event = | 195 std::unique_ptr<WaitableEvent> completion_event = |
196 WTF::MakeUnique<WaitableEvent>(); | 196 WTF::MakeUnique<WaitableEvent>(); |
197 PostTaskToWorkerGlobalScope( | 197 worker_loading_task_runner_->PostTask( |
198 BLINK_FROM_HERE, | 198 BLINK_FROM_HERE, |
199 CrossThreadBind(&WorkerThreadableLoaderTestHelper::WorkerStartLoader, | 199 CrossThreadBind(&WorkerThreadableLoaderTestHelper::WorkerStartLoader, |
200 CrossThreadUnretained(this), | 200 CrossThreadUnretained(this), |
201 CrossThreadUnretained(completion_event.get()), | 201 CrossThreadUnretained(completion_event.get()), |
202 request)); | 202 request)); |
203 completion_event->Wait(); | 203 completion_event->Wait(); |
204 } | 204 } |
205 | 205 |
206 // Must be called on the worker thread. | 206 // Must be called on the worker thread. |
207 void CancelLoader() override { | 207 void CancelLoader() override { |
(...skipping 16 matching lines...) Expand all Loading... |
224 loader_ = nullptr; | 224 loader_ = nullptr; |
225 } | 225 } |
226 | 226 |
227 Checkpoint& GetCheckpoint() override { return checkpoint_; } | 227 Checkpoint& GetCheckpoint() override { return checkpoint_; } |
228 | 228 |
229 void CallCheckpoint(int n) override { | 229 void CallCheckpoint(int n) override { |
230 testing::RunPendingTasks(); | 230 testing::RunPendingTasks(); |
231 | 231 |
232 std::unique_ptr<WaitableEvent> completion_event = | 232 std::unique_ptr<WaitableEvent> completion_event = |
233 WTF::MakeUnique<WaitableEvent>(); | 233 WTF::MakeUnique<WaitableEvent>(); |
234 PostTaskToWorkerGlobalScope( | 234 worker_loading_task_runner_->PostTask( |
235 BLINK_FROM_HERE, | 235 BLINK_FROM_HERE, |
236 CrossThreadBind(&WorkerThreadableLoaderTestHelper::WorkerCallCheckpoint, | 236 CrossThreadBind(&WorkerThreadableLoaderTestHelper::WorkerCallCheckpoint, |
237 CrossThreadUnretained(this), | 237 CrossThreadUnretained(this), |
238 CrossThreadUnretained(completion_event.get()), n)); | 238 CrossThreadUnretained(completion_event.get()), n)); |
239 completion_event->Wait(); | 239 completion_event->Wait(); |
240 } | 240 } |
241 | 241 |
242 void OnSetUp() override { | 242 void OnSetUp() override { |
243 reporting_proxy_ = WTF::MakeUnique<WorkerReportingProxy>(); | 243 reporting_proxy_ = WTF::MakeUnique<WorkerReportingProxy>(); |
244 security_origin_ = GetDocument().GetSecurityOrigin(); | 244 security_origin_ = GetDocument().GetSecurityOrigin(); |
245 parent_frame_task_runners_ = | 245 parent_frame_task_runners_ = |
246 ParentFrameTaskRunners::Create(&dummy_page_holder_->GetFrame()); | 246 ParentFrameTaskRunners::Create(&dummy_page_holder_->GetFrame()); |
247 worker_thread_ = | 247 worker_thread_ = |
248 WTF::WrapUnique(new WorkerThreadForTest(this, *reporting_proxy_)); | 248 WTF::WrapUnique(new WorkerThreadForTest(this, *reporting_proxy_)); |
249 loading_context_ = ThreadableLoadingContext::Create(GetDocument()); | 249 loading_context_ = ThreadableLoadingContext::Create(GetDocument()); |
250 | 250 |
251 worker_thread_->StartWithSourceCode(security_origin_.Get(), | 251 worker_thread_->StartWithSourceCode(security_origin_.Get(), |
252 "//fake source code", | 252 "//fake source code", |
253 parent_frame_task_runners_.Get()); | 253 parent_frame_task_runners_.Get()); |
254 worker_thread_->WaitForInit(); | 254 worker_thread_->WaitForInit(); |
| 255 worker_loading_task_runner_ = |
| 256 TaskRunnerHelper::Get(TaskType::kUnspecedLoading, worker_thread_.get()); |
255 } | 257 } |
256 | 258 |
257 void OnServeRequests() override { testing::RunPendingTasks(); } | 259 void OnServeRequests() override { testing::RunPendingTasks(); } |
258 | 260 |
259 void OnTearDown() override { | 261 void OnTearDown() override { |
260 PostTaskToWorkerGlobalScope( | 262 worker_loading_task_runner_->PostTask( |
261 BLINK_FROM_HERE, | 263 BLINK_FROM_HERE, |
262 CrossThreadBind(&WorkerThreadableLoaderTestHelper::ClearLoader, | 264 CrossThreadBind(&WorkerThreadableLoaderTestHelper::ClearLoader, |
263 CrossThreadUnretained(this))); | 265 CrossThreadUnretained(this))); |
264 WaitableEvent event; | 266 WaitableEvent event; |
265 PostTaskToWorkerGlobalScope( | 267 worker_loading_task_runner_->PostTask( |
266 BLINK_FROM_HERE, | 268 BLINK_FROM_HERE, |
267 CrossThreadBind(&WaitableEvent::Signal, CrossThreadUnretained(&event))); | 269 CrossThreadBind(&WaitableEvent::Signal, CrossThreadUnretained(&event))); |
268 event.Wait(); | 270 event.Wait(); |
269 worker_thread_->TerminateAndWait(); | 271 worker_thread_->TerminateAndWait(); |
270 | 272 |
271 // Needed to clean up the things on the main thread side and | 273 // Needed to clean up the things on the main thread side and |
272 // avoid Resource leaks. | 274 // avoid Resource leaks. |
273 testing::RunPendingTasks(); | 275 testing::RunPendingTasks(); |
274 | 276 |
275 worker_thread_->GetWorkerLoaderProxy()->DetachProvider(this); | 277 worker_thread_->GetWorkerLoaderProxy()->DetachProvider(this); |
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
313 } | 315 } |
314 | 316 |
315 void WorkerCallCheckpoint(WaitableEvent* event, int n) { | 317 void WorkerCallCheckpoint(WaitableEvent* event, int n) { |
316 DCHECK(worker_thread_); | 318 DCHECK(worker_thread_); |
317 DCHECK(worker_thread_->IsCurrentThread()); | 319 DCHECK(worker_thread_->IsCurrentThread()); |
318 checkpoint_.Call(n); | 320 checkpoint_.Call(n); |
319 event->Signal(); | 321 event->Signal(); |
320 } | 322 } |
321 | 323 |
322 // WorkerLoaderProxyProvider methods. | 324 // WorkerLoaderProxyProvider methods. |
323 void PostTaskToLoader( | |
324 const WebTraceLocation& location, | |
325 std::unique_ptr<WTF::CrossThreadClosure> task) override { | |
326 DCHECK(worker_thread_); | |
327 DCHECK(worker_thread_->IsCurrentThread()); | |
328 parent_frame_task_runners_->Get(TaskType::kNetworking) | |
329 ->PostTask(BLINK_FROM_HERE, std::move(task)); | |
330 } | |
331 | |
332 void PostTaskToWorkerGlobalScope( | |
333 const WebTraceLocation& location, | |
334 std::unique_ptr<WTF::CrossThreadClosure> task) override { | |
335 DCHECK(worker_thread_); | |
336 TaskRunnerHelper::Get(TaskType::kNetworking, worker_thread_.get()) | |
337 ->PostTask(location, std::move(task)); | |
338 } | |
339 | |
340 ThreadableLoadingContext* GetThreadableLoadingContext() override { | 325 ThreadableLoadingContext* GetThreadableLoadingContext() override { |
341 return loading_context_.Get(); | 326 return loading_context_.Get(); |
342 } | 327 } |
343 | 328 |
344 RefPtr<SecurityOrigin> security_origin_; | 329 RefPtr<SecurityOrigin> security_origin_; |
345 std::unique_ptr<WorkerReportingProxy> reporting_proxy_; | 330 std::unique_ptr<WorkerReportingProxy> reporting_proxy_; |
346 std::unique_ptr<WorkerThreadForTest> worker_thread_; | 331 std::unique_ptr<WorkerThreadForTest> worker_thread_; |
347 | 332 |
348 std::unique_ptr<DummyPageHolder> dummy_page_holder_; | 333 std::unique_ptr<DummyPageHolder> dummy_page_holder_; |
349 // Accessed cross-thread when worker thread posts tasks to the parent. | 334 // Accessed cross-thread when worker thread posts tasks to the parent. |
350 CrossThreadPersistent<ParentFrameTaskRunners> parent_frame_task_runners_; | 335 CrossThreadPersistent<ParentFrameTaskRunners> parent_frame_task_runners_; |
| 336 RefPtr<WebTaskRunner> worker_loading_task_runner_; |
351 Checkpoint checkpoint_; | 337 Checkpoint checkpoint_; |
352 // |m_loader| must be touched only from the worker thread only. | 338 // |m_loader| must be touched only from the worker thread only. |
353 CrossThreadPersistent<ThreadableLoader> loader_; | 339 CrossThreadPersistent<ThreadableLoader> loader_; |
354 | 340 |
355 Persistent<ThreadableLoadingContext> loading_context_; | 341 Persistent<ThreadableLoadingContext> loading_context_; |
356 }; | 342 }; |
357 | 343 |
358 class ThreadableLoaderTest | 344 class ThreadableLoaderTest |
359 : public ::testing::TestWithParam<ThreadableLoaderToTest> { | 345 : public ::testing::TestWithParam<ThreadableLoaderToTest> { |
360 public: | 346 public: |
(...skipping 522 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
883 // test is not saying that didFailAccessControlCheck should be dispatched | 869 // test is not saying that didFailAccessControlCheck should be dispatched |
884 // synchronously, but is saying that even when a response is served | 870 // synchronously, but is saying that even when a response is served |
885 // synchronously it should not lead to a crash. | 871 // synchronously it should not lead to a crash. |
886 StartLoader(KURL(KURL(), "about:blank")); | 872 StartLoader(KURL(KURL(), "about:blank")); |
887 CallCheckpoint(2); | 873 CallCheckpoint(2); |
888 } | 874 } |
889 | 875 |
890 } // namespace | 876 } // namespace |
891 | 877 |
892 } // namespace blink | 878 } // namespace blink |
OLD | NEW |