OLD | NEW |
---|---|
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 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 "content/browser/service_worker/service_worker_version.h" | 5 #include "content/browser/service_worker/service_worker_version.h" |
6 | 6 |
7 #include <stdint.h> | 7 #include <stdint.h> |
8 #include <tuple> | 8 #include <tuple> |
9 | 9 |
10 #include "base/macros.h" | 10 #include "base/macros.h" |
(...skipping 274 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
285 DISALLOW_COPY_AND_ASSIGN(ServiceWorkerVersionTest); | 285 DISALLOW_COPY_AND_ASSIGN(ServiceWorkerVersionTest); |
286 }; | 286 }; |
287 | 287 |
288 class MessageReceiverDisallowStart : public MessageReceiver { | 288 class MessageReceiverDisallowStart : public MessageReceiver { |
289 public: | 289 public: |
290 MessageReceiverDisallowStart() : MessageReceiver() {} | 290 MessageReceiverDisallowStart() : MessageReceiver() {} |
291 ~MessageReceiverDisallowStart() override {} | 291 ~MessageReceiverDisallowStart() override {} |
292 | 292 |
293 enum class StartMode { STALL, FAIL, SUCCEED }; | 293 enum class StartMode { STALL, FAIL, SUCCEED }; |
294 | 294 |
295 void OnStartWorker( | 295 void OnStartWorker(int embedded_worker_id, |
296 int embedded_worker_id, | 296 int64_t service_worker_version_id, |
297 int64_t service_worker_version_id, | 297 const GURL& scope, |
298 const GURL& scope, | 298 const GURL& script_url, |
299 const GURL& script_url, | 299 bool pause_after_download, |
300 bool pause_after_download, | 300 mojom::ServiceWorkerEventDispatcherRequest request, |
301 mojom::ServiceWorkerEventDispatcherRequest request) override { | 301 mojom::EmbeddedWorkerInstanceHostAssociatedPtrInfo |
302 instance_host) override { | |
302 switch (mode_) { | 303 switch (mode_) { |
303 case StartMode::STALL: | 304 case StartMode::STALL: |
305 // Prepare for OnStopWorker(). | |
306 instance_host_ptr_map_[embedded_worker_id].Bind( | |
307 std::move(instance_host)); | |
shimazu
2017/04/10 05:09:22
What happen if the |instance_host| isn't kept?
It'
leonhsl(Using Gerrit)
2017/04/10 06:10:36
In the following 2 tests OnStopWorker() will be ca
shimazu
2017/04/10 09:33:40
Ah, got it. Thanks!
I feel code is a bit duplicate
shimazu
2017/04/11 04:32:40
Sorry for late!
The reason why I feel a bit weird
| |
304 break; // Do nothing. | 308 break; // Do nothing. |
305 case StartMode::FAIL: | 309 case StartMode::FAIL: |
306 ASSERT_EQ(current_mock_instance_index_ + 1, | 310 ASSERT_EQ(current_mock_instance_index_ + 1, |
307 mock_instance_clients()->size()); | 311 mock_instance_clients()->size()); |
308 // Remove the connection by peer | 312 // Remove the connection by peer |
309 mock_instance_clients()->at(current_mock_instance_index_).reset(); | 313 mock_instance_clients()->at(current_mock_instance_index_).reset(); |
310 break; | 314 break; |
311 case StartMode::SUCCEED: | 315 case StartMode::SUCCEED: |
312 MessageReceiver::OnStartWorker( | 316 MessageReceiver::OnStartWorker( |
313 embedded_worker_id, service_worker_version_id, scope, script_url, | 317 embedded_worker_id, service_worker_version_id, scope, script_url, |
314 pause_after_download, std::move(request)); | 318 pause_after_download, std::move(request), std::move(instance_host)); |
315 break; | 319 break; |
316 } | 320 } |
317 current_mock_instance_index_++; | 321 current_mock_instance_index_++; |
318 } | 322 } |
319 | 323 |
324 void OnStopWorker(int embedded_worker_id) override { | |
325 if (instance_host_ptr_map_[embedded_worker_id]) { | |
326 instance_host_ptr_map_[embedded_worker_id]->OnStopped(); | |
327 base::RunLoop().RunUntilIdle(); | |
328 return; | |
329 } | |
330 EmbeddedWorkerTestHelper::OnStopWorker(embedded_worker_id); | |
331 } | |
332 | |
320 void set_start_mode(StartMode mode) { mode_ = mode; } | 333 void set_start_mode(StartMode mode) { mode_ = mode; } |
321 | 334 |
322 private: | 335 private: |
323 uint32_t current_mock_instance_index_ = 0; | 336 uint32_t current_mock_instance_index_ = 0; |
324 StartMode mode_ = StartMode::STALL; | 337 StartMode mode_ = StartMode::STALL; |
338 | |
339 std::map< | |
340 int /* embedded_worker_id */, | |
341 mojom::EmbeddedWorkerInstanceHostAssociatedPtr /* instance_host_ptr */> | |
342 instance_host_ptr_map_; | |
325 DISALLOW_COPY_AND_ASSIGN(MessageReceiverDisallowStart); | 343 DISALLOW_COPY_AND_ASSIGN(MessageReceiverDisallowStart); |
326 }; | 344 }; |
327 | 345 |
328 class ServiceWorkerFailToStartTest : public ServiceWorkerVersionTest { | 346 class ServiceWorkerFailToStartTest : public ServiceWorkerVersionTest { |
329 protected: | 347 protected: |
330 ServiceWorkerFailToStartTest() : ServiceWorkerVersionTest() {} | 348 ServiceWorkerFailToStartTest() : ServiceWorkerVersionTest() {} |
331 | 349 |
332 void set_start_mode(MessageReceiverDisallowStart::StartMode mode) { | 350 void set_start_mode(MessageReceiverDisallowStart::StartMode mode) { |
333 MessageReceiverDisallowStart* helper = | 351 MessageReceiverDisallowStart* helper = |
334 static_cast<MessageReceiverDisallowStart*>(helper_.get()); | 352 static_cast<MessageReceiverDisallowStart*>(helper_.get()); |
335 helper->set_start_mode(mode); | 353 helper->set_start_mode(mode); |
336 } | 354 } |
337 | 355 |
338 std::unique_ptr<MessageReceiver> GetMessageReceiver() override { | 356 std::unique_ptr<MessageReceiver> GetMessageReceiver() override { |
339 return base::MakeUnique<MessageReceiverDisallowStart>(); | 357 return base::MakeUnique<MessageReceiverDisallowStart>(); |
340 } | 358 } |
341 | 359 |
342 private: | 360 private: |
343 DISALLOW_COPY_AND_ASSIGN(ServiceWorkerFailToStartTest); | 361 DISALLOW_COPY_AND_ASSIGN(ServiceWorkerFailToStartTest); |
344 }; | 362 }; |
345 | 363 |
346 class NoOpStopWorkerEmbeddedWorkerInstanceClient | 364 class NoOpStopWorkerEmbeddedWorkerInstanceClient |
347 : public EmbeddedWorkerTestHelper::MockEmbeddedWorkerInstanceClient { | 365 : public EmbeddedWorkerTestHelper::MockEmbeddedWorkerInstanceClient { |
348 public: | 366 public: |
349 explicit NoOpStopWorkerEmbeddedWorkerInstanceClient( | 367 explicit NoOpStopWorkerEmbeddedWorkerInstanceClient( |
350 base::WeakPtr<EmbeddedWorkerTestHelper> helper) | 368 base::WeakPtr<EmbeddedWorkerTestHelper> helper) |
351 : EmbeddedWorkerTestHelper::MockEmbeddedWorkerInstanceClient(helper) {} | 369 : EmbeddedWorkerTestHelper::MockEmbeddedWorkerInstanceClient(helper) {} |
352 ~NoOpStopWorkerEmbeddedWorkerInstanceClient() override { | 370 ~NoOpStopWorkerEmbeddedWorkerInstanceClient() override { |
353 // Stop callback should be called once. | |
354 if (pending_stop_callback_) | |
355 pending_stop_callback_.Run(); | |
356 } | 371 } |
357 | 372 |
358 protected: | 373 protected: |
359 void StopWorker(const StopWorkerCallback& callback) override { | 374 void StopWorker() override { |
360 pending_stop_callback_ = std::move(callback); | |
361 // Do nothing. | 375 // Do nothing. |
362 } | 376 } |
363 | 377 |
364 StopWorkerCallback pending_stop_callback_; | |
365 | |
366 private: | 378 private: |
367 DISALLOW_COPY_AND_ASSIGN(NoOpStopWorkerEmbeddedWorkerInstanceClient); | 379 DISALLOW_COPY_AND_ASSIGN(NoOpStopWorkerEmbeddedWorkerInstanceClient); |
368 }; | 380 }; |
369 | 381 |
370 class MessageReceiverDisallowStop : public MessageReceiver { | 382 class MessageReceiverDisallowStop : public MessageReceiver { |
371 public: | 383 public: |
372 MessageReceiverDisallowStop() : MessageReceiver() { | 384 MessageReceiverDisallowStop() : MessageReceiver() { |
373 CreateAndRegisterMockInstanceClient< | 385 CreateAndRegisterMockInstanceClient< |
374 NoOpStopWorkerEmbeddedWorkerInstanceClient>(AsWeakPtr()); | 386 NoOpStopWorkerEmbeddedWorkerInstanceClient>(AsWeakPtr()); |
375 } | 387 } |
376 ~MessageReceiverDisallowStop() override {} | 388 ~MessageReceiverDisallowStop() override {} |
377 | 389 |
378 void OnStopWorker( | 390 void OnStopWorker(int embedded_worker_id) override { |
379 const mojom::EmbeddedWorkerInstanceClient::StopWorkerCallback& callback) | |
380 override { | |
381 // Do nothing. | 391 // Do nothing. |
382 } | 392 } |
383 | 393 |
384 private: | 394 private: |
385 DISALLOW_COPY_AND_ASSIGN(MessageReceiverDisallowStop); | 395 DISALLOW_COPY_AND_ASSIGN(MessageReceiverDisallowStop); |
386 }; | 396 }; |
387 | 397 |
388 class ServiceWorkerStallInStoppingTest : public ServiceWorkerVersionTest { | 398 class ServiceWorkerStallInStoppingTest : public ServiceWorkerVersionTest { |
389 protected: | 399 protected: |
390 ServiceWorkerStallInStoppingTest() : ServiceWorkerVersionTest() {} | 400 ServiceWorkerStallInStoppingTest() : ServiceWorkerVersionTest() {} |
(...skipping 432 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
823 ~MessageReceiverControlEvents() override {} | 833 ~MessageReceiverControlEvents() override {} |
824 | 834 |
825 void OnExtendableMessageEvent( | 835 void OnExtendableMessageEvent( |
826 mojom::ExtendableMessageEventPtr event, | 836 mojom::ExtendableMessageEventPtr event, |
827 const mojom::ServiceWorkerEventDispatcher:: | 837 const mojom::ServiceWorkerEventDispatcher:: |
828 DispatchExtendableMessageEventCallback& callback) override { | 838 DispatchExtendableMessageEventCallback& callback) override { |
829 EXPECT_FALSE(extendable_message_event_callback_); | 839 EXPECT_FALSE(extendable_message_event_callback_); |
830 extendable_message_event_callback_ = callback; | 840 extendable_message_event_callback_ = callback; |
831 } | 841 } |
832 | 842 |
833 void OnStopWorker( | 843 void OnStopWorker(int embedded_worker_id) override { |
834 const mojom::EmbeddedWorkerInstanceClient::StopWorkerCallback& callback) | |
835 override { | |
836 EXPECT_FALSE(stop_worker_callback_); | 844 EXPECT_FALSE(stop_worker_callback_); |
837 stop_worker_callback_ = callback; | 845 stop_worker_callback_ = |
846 base::Bind(&MessageReceiverControlEvents::SimulateWorkerStopped, | |
847 base::Unretained(this), embedded_worker_id); | |
838 } | 848 } |
839 | 849 |
840 const mojom::ServiceWorkerEventDispatcher:: | 850 const mojom::ServiceWorkerEventDispatcher:: |
841 DispatchExtendableMessageEventCallback& | 851 DispatchExtendableMessageEventCallback& |
842 extendable_message_event_callback() { | 852 extendable_message_event_callback() { |
843 return extendable_message_event_callback_; | 853 return extendable_message_event_callback_; |
844 } | 854 } |
845 | 855 |
846 const mojom::EmbeddedWorkerInstanceClient::StopWorkerCallback& | 856 const base::Closure& stop_worker_callback() { return stop_worker_callback_; } |
847 stop_worker_callback() { | |
848 return stop_worker_callback_; | |
849 } | |
850 | 857 |
851 private: | 858 private: |
852 mojom::ServiceWorkerEventDispatcher::DispatchExtendableMessageEventCallback | 859 mojom::ServiceWorkerEventDispatcher::DispatchExtendableMessageEventCallback |
853 extendable_message_event_callback_; | 860 extendable_message_event_callback_; |
854 mojom::EmbeddedWorkerInstanceClient::StopWorkerCallback stop_worker_callback_; | 861 base::Closure stop_worker_callback_; |
855 }; | 862 }; |
856 | 863 |
857 class ServiceWorkerRequestTimeoutTest : public ServiceWorkerVersionTest { | 864 class ServiceWorkerRequestTimeoutTest : public ServiceWorkerVersionTest { |
858 protected: | 865 protected: |
859 ServiceWorkerRequestTimeoutTest() : ServiceWorkerVersionTest() {} | 866 ServiceWorkerRequestTimeoutTest() : ServiceWorkerVersionTest() {} |
860 | 867 |
861 std::unique_ptr<MessageReceiver> GetMessageReceiver() override { | 868 std::unique_ptr<MessageReceiver> GetMessageReceiver() override { |
862 return base::MakeUnique<MessageReceiverControlEvents>(); | 869 return base::MakeUnique<MessageReceiverControlEvents>(); |
863 } | 870 } |
864 | 871 |
865 const mojom::ServiceWorkerEventDispatcher:: | 872 const mojom::ServiceWorkerEventDispatcher:: |
866 DispatchExtendableMessageEventCallback& | 873 DispatchExtendableMessageEventCallback& |
867 extendable_message_event_callback() { | 874 extendable_message_event_callback() { |
868 return static_cast<MessageReceiverControlEvents*>(helper_.get()) | 875 return static_cast<MessageReceiverControlEvents*>(helper_.get()) |
869 ->extendable_message_event_callback(); | 876 ->extendable_message_event_callback(); |
870 } | 877 } |
871 | 878 |
872 const mojom::EmbeddedWorkerInstanceClient::StopWorkerCallback& | 879 const base::Closure& stop_worker_callback() { |
873 stop_worker_callback() { | |
874 return static_cast<MessageReceiverControlEvents*>(helper_.get()) | 880 return static_cast<MessageReceiverControlEvents*>(helper_.get()) |
875 ->stop_worker_callback(); | 881 ->stop_worker_callback(); |
876 } | 882 } |
877 | 883 |
878 private: | 884 private: |
879 DISALLOW_COPY_AND_ASSIGN(ServiceWorkerRequestTimeoutTest); | 885 DISALLOW_COPY_AND_ASSIGN(ServiceWorkerRequestTimeoutTest); |
880 }; | 886 }; |
881 | 887 |
882 TEST_F(ServiceWorkerRequestTimeoutTest, RequestTimeout) { | 888 TEST_F(ServiceWorkerRequestTimeoutTest, RequestTimeout) { |
883 ServiceWorkerStatusCode error_status = | 889 ServiceWorkerStatusCode error_status = |
(...skipping 721 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1605 // Should not have timed out, so error callback should not have been | 1611 // Should not have timed out, so error callback should not have been |
1606 // called and FinishRequest should return true. | 1612 // called and FinishRequest should return true. |
1607 EXPECT_EQ(SERVICE_WORKER_OK, status); | 1613 EXPECT_EQ(SERVICE_WORKER_OK, status); |
1608 EXPECT_TRUE(version_->FinishRequest(request_id1, true /* was_handled */, | 1614 EXPECT_TRUE(version_->FinishRequest(request_id1, true /* was_handled */, |
1609 base::Time::Now())); | 1615 base::Time::Now())); |
1610 EXPECT_TRUE(version_->FinishRequest(request_id2, true /* was_handled */, | 1616 EXPECT_TRUE(version_->FinishRequest(request_id2, true /* was_handled */, |
1611 base::Time::Now())); | 1617 base::Time::Now())); |
1612 } | 1618 } |
1613 | 1619 |
1614 } // namespace content | 1620 } // namespace content |
OLD | NEW |