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" |
11 #include "base/memory/ptr_util.h" | 11 #include "base/memory/ptr_util.h" |
12 #include "base/run_loop.h" | 12 #include "base/run_loop.h" |
13 #include "base/test/histogram_tester.h" | 13 #include "base/test/histogram_tester.h" |
| 14 #include "base/time/time.h" |
14 #include "content/browser/service_worker/embedded_worker_registry.h" | 15 #include "content/browser/service_worker/embedded_worker_registry.h" |
15 #include "content/browser/service_worker/embedded_worker_status.h" | 16 #include "content/browser/service_worker/embedded_worker_status.h" |
16 #include "content/browser/service_worker/embedded_worker_test_helper.h" | 17 #include "content/browser/service_worker/embedded_worker_test_helper.h" |
17 #include "content/browser/service_worker/service_worker_context_core.h" | 18 #include "content/browser/service_worker/service_worker_context_core.h" |
18 #include "content/browser/service_worker/service_worker_registration.h" | 19 #include "content/browser/service_worker/service_worker_registration.h" |
19 #include "content/browser/service_worker/service_worker_test_utils.h" | 20 #include "content/browser/service_worker/service_worker_test_utils.h" |
20 #include "content/common/service_worker/service_worker_utils.h" | 21 #include "content/common/service_worker/service_worker_utils.h" |
21 #include "content/public/test/mock_render_process_host.h" | 22 #include "content/public/test/mock_render_process_host.h" |
22 #include "content/public/test/test_browser_thread_bundle.h" | 23 #include "content/public/test/test_browser_thread_bundle.h" |
23 #include "content/public/test/test_mojo_service.mojom.h" | 24 #include "content/public/test/test_mojo_service.mojom.h" |
24 #include "content/public/test/test_utils.h" | 25 #include "content/public/test/test_utils.h" |
25 #include "mojo/public/cpp/bindings/strong_binding.h" | 26 #include "mojo/public/cpp/bindings/strong_binding.h" |
26 #include "services/shell/public/cpp/interface_registry.h" | 27 #include "services/shell/public/cpp/interface_registry.h" |
27 #include "testing/gtest/include/gtest/gtest.h" | 28 #include "testing/gtest/include/gtest/gtest.h" |
28 | 29 |
29 // IPC messages for testing --------------------------------------------------- | 30 // IPC messages for testing --------------------------------------------------- |
30 | 31 |
31 #define IPC_MESSAGE_IMPL | 32 #define IPC_MESSAGE_IMPL |
32 #include "ipc/ipc_message_macros.h" | 33 #include "ipc/ipc_message_macros.h" |
33 | 34 |
34 #define IPC_MESSAGE_START TestMsgStart | 35 #define IPC_MESSAGE_START TestMsgStart |
35 | 36 |
36 IPC_MESSAGE_CONTROL0(TestMsg_Message) | 37 IPC_MESSAGE_CONTROL0(TestMsg_Message) |
37 IPC_MESSAGE_ROUTED1(TestMsg_MessageFromWorker, int) | 38 IPC_MESSAGE_ROUTED1(TestMsg_MessageFromWorker, int) |
38 | 39 |
39 IPC_MESSAGE_CONTROL1(TestMsg_TestEvent, int) | 40 IPC_MESSAGE_CONTROL1(TestMsg_TestEvent, int) |
40 IPC_MESSAGE_CONTROL2(TestMsg_TestEvent_Multiple, int, int) | 41 IPC_MESSAGE_CONTROL2(TestMsg_TestEvent_Multiple, int, int) |
41 IPC_MESSAGE_ROUTED2(TestMsg_TestEventResult, int, std::string) | 42 IPC_MESSAGE_ROUTED2(TestMsg_TestEventResult, int, std::string) |
42 IPC_MESSAGE_ROUTED2(TestMsg_TestSimpleEventResult, | 43 IPC_MESSAGE_ROUTED3(TestMsg_TestSimpleEventResult, |
43 int, | 44 int, |
44 blink::WebServiceWorkerEventResult) | 45 blink::WebServiceWorkerEventResult, |
| 46 base::Time) |
45 | 47 |
46 IPC_ENUM_TRAITS_MAX_VALUE(blink::WebServiceWorkerEventResult, | 48 IPC_ENUM_TRAITS_MAX_VALUE(blink::WebServiceWorkerEventResult, |
47 blink::WebServiceWorkerEventResultLast) | 49 blink::WebServiceWorkerEventResultLast) |
48 | 50 |
49 // --------------------------------------------------------------------------- | 51 // --------------------------------------------------------------------------- |
50 | 52 |
51 namespace content { | 53 namespace content { |
52 | 54 |
53 namespace { | 55 namespace { |
54 | 56 |
(...skipping 26 matching lines...) Expand all Loading... |
81 | 83 |
82 void SimulateSendEventResult(int embedded_worker_id, | 84 void SimulateSendEventResult(int embedded_worker_id, |
83 int request_id, | 85 int request_id, |
84 const std::string& reply) { | 86 const std::string& reply) { |
85 SimulateSend( | 87 SimulateSend( |
86 new TestMsg_TestEventResult(embedded_worker_id, request_id, reply)); | 88 new TestMsg_TestEventResult(embedded_worker_id, request_id, reply)); |
87 } | 89 } |
88 | 90 |
89 void SimulateSendSimpleEventResult(int embedded_worker_id, | 91 void SimulateSendSimpleEventResult(int embedded_worker_id, |
90 int request_id, | 92 int request_id, |
91 blink::WebServiceWorkerEventResult reply) { | 93 blink::WebServiceWorkerEventResult reply, |
92 SimulateSend(new TestMsg_TestSimpleEventResult(embedded_worker_id, | 94 base::Time dispatch_event_time) { |
93 request_id, reply)); | 95 SimulateSend(new TestMsg_TestSimpleEventResult( |
| 96 embedded_worker_id, request_id, reply, dispatch_event_time)); |
94 } | 97 } |
95 | 98 |
96 private: | 99 private: |
97 void OnMessage() { | 100 void OnMessage() { |
98 // Do nothing. | 101 // Do nothing. |
99 } | 102 } |
100 | 103 |
101 int current_embedded_worker_id_; | 104 int current_embedded_worker_id_; |
102 DISALLOW_COPY_AND_ASSIGN(MessageReceiver); | 105 DISALLOW_COPY_AND_ASSIGN(MessageReceiver); |
103 }; | 106 }; |
(...skipping 159 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
263 runner->Run(); | 266 runner->Run(); |
264 EXPECT_EQ(SERVICE_WORKER_ERROR_MAX_VALUE, status); | 267 EXPECT_EQ(SERVICE_WORKER_ERROR_MAX_VALUE, status); |
265 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, version_->running_status()); | 268 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, version_->running_status()); |
266 | 269 |
267 // Start request, as if an event is being dispatched. | 270 // Start request, as if an event is being dispatched. |
268 int request_id = version_->StartRequest( | 271 int request_id = version_->StartRequest( |
269 event_type, CreateReceiverOnCurrentThread(&status)); | 272 event_type, CreateReceiverOnCurrentThread(&status)); |
270 base::RunLoop().RunUntilIdle(); | 273 base::RunLoop().RunUntilIdle(); |
271 | 274 |
272 // And finish request, as if a response to the event was received. | 275 // And finish request, as if a response to the event was received. |
273 EXPECT_TRUE(version_->FinishRequest(request_id, true)); | 276 EXPECT_TRUE(version_->FinishRequest(request_id, true /* was_handled */, |
| 277 base::Time::Now())); |
274 base::RunLoop().RunUntilIdle(); | 278 base::RunLoop().RunUntilIdle(); |
275 EXPECT_EQ(SERVICE_WORKER_ERROR_MAX_VALUE, status); | 279 EXPECT_EQ(SERVICE_WORKER_ERROR_MAX_VALUE, status); |
276 } | 280 } |
277 | 281 |
278 TestBrowserThreadBundle thread_bundle_; | 282 TestBrowserThreadBundle thread_bundle_; |
279 std::unique_ptr<MessageReceiver> helper_; | 283 std::unique_ptr<MessageReceiver> helper_; |
280 scoped_refptr<ServiceWorkerRegistration> registration_; | 284 scoped_refptr<ServiceWorkerRegistration> registration_; |
281 scoped_refptr<ServiceWorkerVersion> version_; | 285 scoped_refptr<ServiceWorkerVersion> version_; |
282 GURL pattern_; | 286 GURL pattern_; |
283 | 287 |
(...skipping 361 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
645 idle_time = version_->idle_time_; | 649 idle_time = version_->idle_time_; |
646 SimulateDispatchEvent(ServiceWorkerMetrics::EventType::FETCH_MAIN_FRAME); | 650 SimulateDispatchEvent(ServiceWorkerMetrics::EventType::FETCH_MAIN_FRAME); |
647 EXPECT_LT(idle_time, version_->idle_time_); | 651 EXPECT_LT(idle_time, version_->idle_time_); |
648 | 652 |
649 // Starting and finishing a request resets the idle time. | 653 // Starting and finishing a request resets the idle time. |
650 version_->idle_time_ -= kOneSecond; | 654 version_->idle_time_ -= kOneSecond; |
651 idle_time = version_->idle_time_; | 655 idle_time = version_->idle_time_; |
652 int request_id = | 656 int request_id = |
653 version_->StartRequest(ServiceWorkerMetrics::EventType::SYNC, | 657 version_->StartRequest(ServiceWorkerMetrics::EventType::SYNC, |
654 CreateReceiverOnCurrentThread(&status)); | 658 CreateReceiverOnCurrentThread(&status)); |
655 EXPECT_TRUE(version_->FinishRequest(request_id, true)); | 659 EXPECT_TRUE(version_->FinishRequest(request_id, true /* was_handled */, |
| 660 base::Time::Now())); |
656 | 661 |
657 EXPECT_EQ(SERVICE_WORKER_OK, status); | 662 EXPECT_EQ(SERVICE_WORKER_OK, status); |
658 EXPECT_LT(idle_time, version_->idle_time_); | 663 EXPECT_LT(idle_time, version_->idle_time_); |
659 } | 664 } |
660 | 665 |
661 TEST_F(ServiceWorkerVersionTest, SetDevToolsAttached) { | 666 TEST_F(ServiceWorkerVersionTest, SetDevToolsAttached) { |
662 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED; | 667 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED; |
663 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, | 668 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, |
664 CreateReceiverOnCurrentThread(&status)); | 669 CreateReceiverOnCurrentThread(&status)); |
665 | 670 |
(...skipping 161 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
827 EXPECT_EQ(SERVICE_WORKER_ERROR_NETWORK, status); | 832 EXPECT_EQ(SERVICE_WORKER_ERROR_NETWORK, status); |
828 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, version_->running_status()); | 833 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, version_->running_status()); |
829 | 834 |
830 // Simulate timeout. | 835 // Simulate timeout. |
831 EXPECT_TRUE(version_->timeout_timer_.IsRunning()); | 836 EXPECT_TRUE(version_->timeout_timer_.IsRunning()); |
832 version_->SetAllRequestExpirations(base::TimeTicks::Now()); | 837 version_->SetAllRequestExpirations(base::TimeTicks::Now()); |
833 version_->timeout_timer_.user_task().Run(); | 838 version_->timeout_timer_.user_task().Run(); |
834 base::RunLoop().RunUntilIdle(); | 839 base::RunLoop().RunUntilIdle(); |
835 EXPECT_EQ(SERVICE_WORKER_ERROR_TIMEOUT, status); | 840 EXPECT_EQ(SERVICE_WORKER_ERROR_TIMEOUT, status); |
836 EXPECT_EQ(EmbeddedWorkerStatus::STOPPED, version_->running_status()); | 841 EXPECT_EQ(EmbeddedWorkerStatus::STOPPED, version_->running_status()); |
837 EXPECT_FALSE(version_->FinishRequest(request_id, true)); | 842 EXPECT_FALSE(version_->FinishRequest(request_id, true /* was_handled */, |
| 843 base::Time::Now())); |
838 } | 844 } |
839 | 845 |
840 TEST_F(ServiceWorkerVersionTest, RequestCustomizedTimeout) { | 846 TEST_F(ServiceWorkerVersionTest, RequestCustomizedTimeout) { |
841 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK; // dummy value | 847 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK; // dummy value |
842 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); | 848 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); |
843 | 849 |
844 version_->StartWorker(ServiceWorkerMetrics::EventType::SYNC, | 850 version_->StartWorker(ServiceWorkerMetrics::EventType::SYNC, |
845 base::Bind(&ServiceWorkerUtils::NoOpStatusCallback)); | 851 base::Bind(&ServiceWorkerUtils::NoOpStatusCallback)); |
846 base::RunLoop().RunUntilIdle(); | 852 base::RunLoop().RunUntilIdle(); |
847 | 853 |
848 // Create a request that should expire Now(). | 854 // Create a request that should expire Now(). |
849 int request_id = version_->StartRequestWithCustomTimeout( | 855 int request_id = version_->StartRequestWithCustomTimeout( |
850 ServiceWorkerMetrics::EventType::SYNC, | 856 ServiceWorkerMetrics::EventType::SYNC, |
851 CreateReceiverOnCurrentThread(&status), base::TimeDelta(), | 857 CreateReceiverOnCurrentThread(&status), base::TimeDelta(), |
852 ServiceWorkerVersion::CONTINUE_ON_TIMEOUT); | 858 ServiceWorkerVersion::CONTINUE_ON_TIMEOUT); |
853 | 859 |
854 base::RunLoop().RunUntilIdle(); | 860 base::RunLoop().RunUntilIdle(); |
855 EXPECT_TRUE(version_->timeout_timer_.IsRunning()); | 861 EXPECT_TRUE(version_->timeout_timer_.IsRunning()); |
856 version_->timeout_timer_.user_task().Run(); | 862 version_->timeout_timer_.user_task().Run(); |
857 base::RunLoop().RunUntilIdle(); | 863 base::RunLoop().RunUntilIdle(); |
858 EXPECT_EQ(SERVICE_WORKER_ERROR_TIMEOUT, status); | 864 EXPECT_EQ(SERVICE_WORKER_ERROR_TIMEOUT, status); |
859 | 865 |
860 EXPECT_FALSE(version_->FinishRequest(request_id, true)); | 866 EXPECT_FALSE(version_->FinishRequest(request_id, true /* was_handled */, |
| 867 base::Time::Now())); |
861 | 868 |
862 // CONTINUE_ON_TIMEOUT timeouts don't stop the service worker. | 869 // CONTINUE_ON_TIMEOUT timeouts don't stop the service worker. |
863 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, version_->running_status()); | 870 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, version_->running_status()); |
864 } | 871 } |
865 | 872 |
866 TEST_F(ServiceWorkerVersionTest, RequestCustomizedTimeoutKill) { | 873 TEST_F(ServiceWorkerVersionTest, RequestCustomizedTimeoutKill) { |
867 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK; // dummy value | 874 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK; // dummy value |
868 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); | 875 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); |
869 | 876 |
870 version_->StartWorker(ServiceWorkerMetrics::EventType::SYNC, | 877 version_->StartWorker(ServiceWorkerMetrics::EventType::SYNC, |
871 base::Bind(&ServiceWorkerUtils::NoOpStatusCallback)); | 878 base::Bind(&ServiceWorkerUtils::NoOpStatusCallback)); |
872 base::RunLoop().RunUntilIdle(); | 879 base::RunLoop().RunUntilIdle(); |
873 | 880 |
874 // Create a request that should expire Now(). | 881 // Create a request that should expire Now(). |
875 int request_id = version_->StartRequestWithCustomTimeout( | 882 int request_id = version_->StartRequestWithCustomTimeout( |
876 ServiceWorkerMetrics::EventType::SYNC, | 883 ServiceWorkerMetrics::EventType::SYNC, |
877 CreateReceiverOnCurrentThread(&status), base::TimeDelta(), | 884 CreateReceiverOnCurrentThread(&status), base::TimeDelta(), |
878 ServiceWorkerVersion::KILL_ON_TIMEOUT); | 885 ServiceWorkerVersion::KILL_ON_TIMEOUT); |
879 | 886 |
880 base::RunLoop().RunUntilIdle(); | 887 base::RunLoop().RunUntilIdle(); |
881 EXPECT_TRUE(version_->timeout_timer_.IsRunning()); | 888 EXPECT_TRUE(version_->timeout_timer_.IsRunning()); |
882 version_->timeout_timer_.user_task().Run(); | 889 version_->timeout_timer_.user_task().Run(); |
883 base::RunLoop().RunUntilIdle(); | 890 base::RunLoop().RunUntilIdle(); |
884 EXPECT_EQ(SERVICE_WORKER_ERROR_TIMEOUT, status); | 891 EXPECT_EQ(SERVICE_WORKER_ERROR_TIMEOUT, status); |
885 | 892 |
886 EXPECT_FALSE(version_->FinishRequest(request_id, true)); | 893 EXPECT_FALSE(version_->FinishRequest(request_id, true /* was_handled */, |
| 894 base::Time::Now())); |
887 | 895 |
888 // KILL_ON_TIMEOUT timeouts should stop the service worker. | 896 // KILL_ON_TIMEOUT timeouts should stop the service worker. |
889 EXPECT_EQ(EmbeddedWorkerStatus::STOPPED, version_->running_status()); | 897 EXPECT_EQ(EmbeddedWorkerStatus::STOPPED, version_->running_status()); |
890 } | 898 } |
891 | 899 |
892 TEST_F(ServiceWorkerVersionTest, MixedRequestTimeouts) { | 900 TEST_F(ServiceWorkerVersionTest, MixedRequestTimeouts) { |
893 ServiceWorkerStatusCode sync_status = | 901 ServiceWorkerStatusCode sync_status = |
894 SERVICE_WORKER_ERROR_NETWORK; // dummy value | 902 SERVICE_WORKER_ERROR_NETWORK; // dummy value |
895 ServiceWorkerStatusCode fetch_status = | 903 ServiceWorkerStatusCode fetch_status = |
896 SERVICE_WORKER_ERROR_NETWORK; // dummy value | 904 SERVICE_WORKER_ERROR_NETWORK; // dummy value |
(...skipping 19 matching lines...) Expand all Loading... |
916 EXPECT_TRUE(version_->timeout_timer_.IsRunning()); | 924 EXPECT_TRUE(version_->timeout_timer_.IsRunning()); |
917 version_->timeout_timer_.user_task().Run(); | 925 version_->timeout_timer_.user_task().Run(); |
918 base::RunLoop().RunUntilIdle(); | 926 base::RunLoop().RunUntilIdle(); |
919 EXPECT_EQ(SERVICE_WORKER_ERROR_TIMEOUT, sync_status); | 927 EXPECT_EQ(SERVICE_WORKER_ERROR_TIMEOUT, sync_status); |
920 EXPECT_EQ(SERVICE_WORKER_ERROR_NETWORK, fetch_status); | 928 EXPECT_EQ(SERVICE_WORKER_ERROR_NETWORK, fetch_status); |
921 | 929 |
922 // Background sync timeouts don't stop the service worker. | 930 // Background sync timeouts don't stop the service worker. |
923 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, version_->running_status()); | 931 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, version_->running_status()); |
924 | 932 |
925 // Gracefully handle the sync event finishing after the timeout. | 933 // Gracefully handle the sync event finishing after the timeout. |
926 EXPECT_FALSE(version_->FinishRequest(sync_request_id, true)); | 934 EXPECT_FALSE(version_->FinishRequest(sync_request_id, true /* was_handled */, |
| 935 base::Time::Now())); |
927 | 936 |
928 // Verify that the fetch times out later. | 937 // Verify that the fetch times out later. |
929 version_->SetAllRequestExpirations(base::TimeTicks::Now()); | 938 version_->SetAllRequestExpirations(base::TimeTicks::Now()); |
930 version_->timeout_timer_.user_task().Run(); | 939 version_->timeout_timer_.user_task().Run(); |
931 base::RunLoop().RunUntilIdle(); | 940 base::RunLoop().RunUntilIdle(); |
932 EXPECT_EQ(SERVICE_WORKER_ERROR_TIMEOUT, fetch_status); | 941 EXPECT_EQ(SERVICE_WORKER_ERROR_TIMEOUT, fetch_status); |
933 | 942 |
934 // Fetch request should no longer exist. | 943 // Fetch request should no longer exist. |
935 EXPECT_FALSE(version_->FinishRequest(fetch_request_id, true)); | 944 EXPECT_FALSE(version_->FinishRequest(fetch_request_id, true /* was_handled */, |
| 945 base::Time::Now())); |
936 | 946 |
937 // Other timeouts do stop the service worker. | 947 // Other timeouts do stop the service worker. |
938 EXPECT_EQ(EmbeddedWorkerStatus::STOPPED, version_->running_status()); | 948 EXPECT_EQ(EmbeddedWorkerStatus::STOPPED, version_->running_status()); |
939 } | 949 } |
940 | 950 |
941 TEST_F(ServiceWorkerFailToStartTest, RendererCrash) { | 951 TEST_F(ServiceWorkerFailToStartTest, RendererCrash) { |
942 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK; // dummy value | 952 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK; // dummy value |
943 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, | 953 version_->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, |
944 CreateReceiverOnCurrentThread(&status)); | 954 CreateReceiverOnCurrentThread(&status)); |
945 base::RunLoop().RunUntilIdle(); | 955 base::RunLoop().RunUntilIdle(); |
(...skipping 221 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1167 helper_->context()->RemoveAllProviderHostsForProcess(process_id); | 1177 helper_->context()->RemoveAllProviderHostsForProcess(process_id); |
1168 helper_->context()->embedded_worker_registry()->RemoveChildProcessSender( | 1178 helper_->context()->embedded_worker_registry()->RemoveChildProcessSender( |
1169 process_id); | 1179 process_id); |
1170 base::RunLoop().RunUntilIdle(); | 1180 base::RunLoop().RunUntilIdle(); |
1171 | 1181 |
1172 // Callback completed. | 1182 // Callback completed. |
1173 EXPECT_EQ(SERVICE_WORKER_ERROR_FAILED, status); | 1183 EXPECT_EQ(SERVICE_WORKER_ERROR_FAILED, status); |
1174 EXPECT_EQ(EmbeddedWorkerStatus::STOPPED, version_->running_status()); | 1184 EXPECT_EQ(EmbeddedWorkerStatus::STOPPED, version_->running_status()); |
1175 | 1185 |
1176 // Request already failed, calling finsh should return false. | 1186 // Request already failed, calling finsh should return false. |
1177 EXPECT_FALSE(version_->FinishRequest(request_id, true)); | 1187 EXPECT_FALSE(version_->FinishRequest(request_id, true /* was_handled */, |
| 1188 base::Time::Now())); |
1178 } | 1189 } |
1179 | 1190 |
1180 TEST_F(ServiceWorkerVersionWithMojoTest, MojoService) { | 1191 TEST_F(ServiceWorkerVersionWithMojoTest, MojoService) { |
1181 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK; // dummy value | 1192 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK; // dummy value |
1182 | 1193 |
1183 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); | 1194 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); |
1184 version_->StartWorker(ServiceWorkerMetrics::EventType::SYNC, | 1195 version_->StartWorker(ServiceWorkerMetrics::EventType::SYNC, |
1185 CreateReceiverOnCurrentThread(&status)); | 1196 CreateReceiverOnCurrentThread(&status)); |
1186 base::RunLoop().RunUntilIdle(); | 1197 base::RunLoop().RunUntilIdle(); |
1187 EXPECT_EQ(SERVICE_WORKER_OK, status); | 1198 EXPECT_EQ(SERVICE_WORKER_OK, status); |
1188 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, version_->running_status()); | 1199 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, version_->running_status()); |
1189 | 1200 |
1190 scoped_refptr<MessageLoopRunner> runner(new MessageLoopRunner); | 1201 scoped_refptr<MessageLoopRunner> runner(new MessageLoopRunner); |
1191 int request_id = version_->StartRequest( | 1202 int request_id = version_->StartRequest( |
1192 ServiceWorkerMetrics::EventType::SYNC, | 1203 ServiceWorkerMetrics::EventType::SYNC, |
1193 CreateReceiverOnCurrentThread(&status, runner->QuitClosure())); | 1204 CreateReceiverOnCurrentThread(&status, runner->QuitClosure())); |
1194 base::WeakPtr<mojom::TestMojoService> service = | 1205 base::WeakPtr<mojom::TestMojoService> service = |
1195 version_->GetMojoServiceForRequest<mojom::TestMojoService>(request_id); | 1206 version_->GetMojoServiceForRequest<mojom::TestMojoService>(request_id); |
1196 service->DoSomething(runner->QuitClosure()); | 1207 service->DoSomething(runner->QuitClosure()); |
1197 runner->Run(); | 1208 runner->Run(); |
1198 | 1209 |
1199 // Mojo service does exist in worker, so error callback should not have been | 1210 // Mojo service does exist in worker, so error callback should not have been |
1200 // called and FinishRequest should return true. | 1211 // called and FinishRequest should return true. |
1201 EXPECT_EQ(SERVICE_WORKER_OK, status); | 1212 EXPECT_EQ(SERVICE_WORKER_OK, status); |
1202 EXPECT_TRUE(version_->FinishRequest(request_id, true)); | 1213 EXPECT_TRUE(version_->FinishRequest(request_id, true /* was_handled */, |
| 1214 base::Time::Now())); |
1203 } | 1215 } |
1204 | 1216 |
1205 TEST_F(ServiceWorkerVersionTest, NonExistentMojoService) { | 1217 TEST_F(ServiceWorkerVersionTest, NonExistentMojoService) { |
1206 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK; // dummy value | 1218 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK; // dummy value |
1207 | 1219 |
1208 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); | 1220 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); |
1209 version_->StartWorker(ServiceWorkerMetrics::EventType::SYNC, | 1221 version_->StartWorker(ServiceWorkerMetrics::EventType::SYNC, |
1210 CreateReceiverOnCurrentThread(&status)); | 1222 CreateReceiverOnCurrentThread(&status)); |
1211 base::RunLoop().RunUntilIdle(); | 1223 base::RunLoop().RunUntilIdle(); |
1212 EXPECT_EQ(SERVICE_WORKER_OK, status); | 1224 EXPECT_EQ(SERVICE_WORKER_OK, status); |
1213 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, version_->running_status()); | 1225 EXPECT_EQ(EmbeddedWorkerStatus::RUNNING, version_->running_status()); |
1214 | 1226 |
1215 scoped_refptr<MessageLoopRunner> runner(new MessageLoopRunner); | 1227 scoped_refptr<MessageLoopRunner> runner(new MessageLoopRunner); |
1216 int request_id = version_->StartRequest( | 1228 int request_id = version_->StartRequest( |
1217 ServiceWorkerMetrics::EventType::SYNC, | 1229 ServiceWorkerMetrics::EventType::SYNC, |
1218 CreateReceiverOnCurrentThread(&status, runner->QuitClosure())); | 1230 CreateReceiverOnCurrentThread(&status, runner->QuitClosure())); |
1219 base::WeakPtr<mojom::TestMojoService> service = | 1231 base::WeakPtr<mojom::TestMojoService> service = |
1220 version_->GetMojoServiceForRequest<mojom::TestMojoService>(request_id); | 1232 version_->GetMojoServiceForRequest<mojom::TestMojoService>(request_id); |
1221 service->DoSomething(runner->QuitClosure()); | 1233 service->DoSomething(runner->QuitClosure()); |
1222 runner->Run(); | 1234 runner->Run(); |
1223 | 1235 |
1224 // Mojo service doesn't exist in worker, so error callback should have been | 1236 // Mojo service doesn't exist in worker, so error callback should have been |
1225 // called and FinishRequest should return false. | 1237 // called and FinishRequest should return false. |
1226 EXPECT_EQ(SERVICE_WORKER_ERROR_FAILED, status); | 1238 EXPECT_EQ(SERVICE_WORKER_ERROR_FAILED, status); |
1227 EXPECT_FALSE(version_->FinishRequest(request_id, true)); | 1239 EXPECT_FALSE(version_->FinishRequest(request_id, true /* was_handled */, |
| 1240 base::Time::Now())); |
1228 } | 1241 } |
1229 | 1242 |
1230 TEST_F(ServiceWorkerVersionTest, DispatchEvent) { | 1243 TEST_F(ServiceWorkerVersionTest, DispatchEvent) { |
1231 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK; // dummy value | 1244 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK; // dummy value |
1232 | 1245 |
1233 // Activate and start worker. | 1246 // Activate and start worker. |
1234 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); | 1247 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); |
1235 version_->StartWorker(ServiceWorkerMetrics::EventType::SYNC, | 1248 version_->StartWorker(ServiceWorkerMetrics::EventType::SYNC, |
1236 CreateReceiverOnCurrentThread(&status)); | 1249 CreateReceiverOnCurrentThread(&status)); |
1237 base::RunLoop().RunUntilIdle(); | 1250 base::RunLoop().RunUntilIdle(); |
(...skipping 24 matching lines...) Expand all Loading... |
1262 version_->embedded_worker()->embedded_worker_id(), request_id, reply); | 1275 version_->embedded_worker()->embedded_worker_id(), request_id, reply); |
1263 runner->Run(); | 1276 runner->Run(); |
1264 | 1277 |
1265 // Verify message callback got called with correct reply. | 1278 // Verify message callback got called with correct reply. |
1266 EXPECT_EQ(request_id, received_request_id); | 1279 EXPECT_EQ(request_id, received_request_id); |
1267 EXPECT_EQ(reply, received_data); | 1280 EXPECT_EQ(reply, received_data); |
1268 | 1281 |
1269 // Should not have timed out, so error callback should not have been | 1282 // Should not have timed out, so error callback should not have been |
1270 // called and FinishRequest should return true. | 1283 // called and FinishRequest should return true. |
1271 EXPECT_EQ(SERVICE_WORKER_OK, status); | 1284 EXPECT_EQ(SERVICE_WORKER_OK, status); |
1272 EXPECT_TRUE(version_->FinishRequest(request_id, true)); | 1285 EXPECT_TRUE(version_->FinishRequest(request_id, true /* was_handled */, |
| 1286 base::Time::Now())); |
1273 } | 1287 } |
1274 | 1288 |
1275 TEST_F(ServiceWorkerFailToStartTest, FailingWorkerUsesNewRendererProcess) { | 1289 TEST_F(ServiceWorkerFailToStartTest, FailingWorkerUsesNewRendererProcess) { |
1276 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_MAX_VALUE; | 1290 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_MAX_VALUE; |
1277 | 1291 |
1278 helper_->SimulateAddProcessToPattern(pattern_, | 1292 helper_->SimulateAddProcessToPattern(pattern_, |
1279 helper_->new_render_process_id()); | 1293 helper_->new_render_process_id()); |
1280 ServiceWorkerContextCore* context = helper_->context(); | 1294 ServiceWorkerContextCore* context = helper_->context(); |
1281 int64_t id = version_->version_id(); | 1295 int64_t id = version_->version_id(); |
1282 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); | 1296 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); |
(...skipping 125 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1408 std::string reply2("foobar"); | 1422 std::string reply2("foobar"); |
1409 helper_->SimulateSendEventResult( | 1423 helper_->SimulateSendEventResult( |
1410 version_->embedded_worker()->embedded_worker_id(), request_id2, reply2); | 1424 version_->embedded_worker()->embedded_worker_id(), request_id2, reply2); |
1411 runner2->Run(); | 1425 runner2->Run(); |
1412 | 1426 |
1413 // Verify correct message callback got called with correct reply. | 1427 // Verify correct message callback got called with correct reply. |
1414 EXPECT_EQ(0, received_request_id1); | 1428 EXPECT_EQ(0, received_request_id1); |
1415 EXPECT_EQ(request_id2, received_request_id2); | 1429 EXPECT_EQ(request_id2, received_request_id2); |
1416 EXPECT_EQ(reply2, received_data2); | 1430 EXPECT_EQ(reply2, received_data2); |
1417 EXPECT_EQ(SERVICE_WORKER_OK, status2); | 1431 EXPECT_EQ(SERVICE_WORKER_OK, status2); |
1418 EXPECT_TRUE(version_->FinishRequest(request_id2, true)); | 1432 EXPECT_TRUE(version_->FinishRequest(request_id2, true /* was_handled */, |
| 1433 base::Time::Now())); |
1419 | 1434 |
1420 // Reply to first event. | 1435 // Reply to first event. |
1421 std::string reply1("hello world"); | 1436 std::string reply1("hello world"); |
1422 helper_->SimulateSendEventResult( | 1437 helper_->SimulateSendEventResult( |
1423 version_->embedded_worker()->embedded_worker_id(), request_id1, reply1); | 1438 version_->embedded_worker()->embedded_worker_id(), request_id1, reply1); |
1424 runner1->Run(); | 1439 runner1->Run(); |
1425 | 1440 |
1426 // Verify correct response was received. | 1441 // Verify correct response was received. |
1427 EXPECT_EQ(request_id1, received_request_id1); | 1442 EXPECT_EQ(request_id1, received_request_id1); |
1428 EXPECT_EQ(request_id2, received_request_id2); | 1443 EXPECT_EQ(request_id2, received_request_id2); |
1429 EXPECT_EQ(reply1, received_data1); | 1444 EXPECT_EQ(reply1, received_data1); |
1430 EXPECT_EQ(SERVICE_WORKER_OK, status1); | 1445 EXPECT_EQ(SERVICE_WORKER_OK, status1); |
1431 EXPECT_TRUE(version_->FinishRequest(request_id1, true)); | 1446 EXPECT_TRUE(version_->FinishRequest(request_id1, true /* was_handled */, |
| 1447 base::Time::Now())); |
1432 } | 1448 } |
1433 | 1449 |
1434 TEST_F(ServiceWorkerVersionTest, DispatchSimpleEvent_Completed) { | 1450 TEST_F(ServiceWorkerVersionTest, DispatchSimpleEvent_Completed) { |
1435 ServiceWorkerStatusCode status = | 1451 ServiceWorkerStatusCode status = |
1436 SERVICE_WORKER_ERROR_MAX_VALUE; // dummy value | 1452 SERVICE_WORKER_ERROR_MAX_VALUE; // dummy value |
1437 | 1453 |
1438 // Activate and start worker. | 1454 // Activate and start worker. |
1439 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); | 1455 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); |
1440 version_->StartWorker(ServiceWorkerMetrics::EventType::SYNC, | 1456 version_->StartWorker(ServiceWorkerMetrics::EventType::SYNC, |
1441 CreateReceiverOnCurrentThread(&status)); | 1457 CreateReceiverOnCurrentThread(&status)); |
(...skipping 12 matching lines...) Expand all Loading... |
1454 | 1470 |
1455 // Verify event got dispatched to worker. | 1471 // Verify event got dispatched to worker. |
1456 base::RunLoop().RunUntilIdle(); | 1472 base::RunLoop().RunUntilIdle(); |
1457 ASSERT_EQ(1u, helper_->inner_ipc_sink()->message_count()); | 1473 ASSERT_EQ(1u, helper_->inner_ipc_sink()->message_count()); |
1458 const IPC::Message* msg = helper_->inner_ipc_sink()->GetMessageAt(0); | 1474 const IPC::Message* msg = helper_->inner_ipc_sink()->GetMessageAt(0); |
1459 EXPECT_EQ(TestMsg_TestEvent::ID, msg->type()); | 1475 EXPECT_EQ(TestMsg_TestEvent::ID, msg->type()); |
1460 | 1476 |
1461 // Simulate sending reply to event. | 1477 // Simulate sending reply to event. |
1462 helper_->SimulateSendSimpleEventResult( | 1478 helper_->SimulateSendSimpleEventResult( |
1463 version_->embedded_worker()->embedded_worker_id(), request_id, | 1479 version_->embedded_worker()->embedded_worker_id(), request_id, |
1464 blink::WebServiceWorkerEventResultCompleted); | 1480 blink::WebServiceWorkerEventResultCompleted, base::Time::Now()); |
1465 runner->Run(); | 1481 runner->Run(); |
1466 | 1482 |
1467 // Verify callback was called with correct status. | 1483 // Verify callback was called with correct status. |
1468 EXPECT_EQ(SERVICE_WORKER_OK, status); | 1484 EXPECT_EQ(SERVICE_WORKER_OK, status); |
1469 } | 1485 } |
1470 | 1486 |
1471 TEST_F(ServiceWorkerVersionTest, DispatchSimpleEvent_Rejected) { | 1487 TEST_F(ServiceWorkerVersionTest, DispatchSimpleEvent_Rejected) { |
1472 ServiceWorkerStatusCode status = | 1488 ServiceWorkerStatusCode status = |
1473 SERVICE_WORKER_ERROR_MAX_VALUE; // dummy value | 1489 SERVICE_WORKER_ERROR_MAX_VALUE; // dummy value |
1474 | 1490 |
(...skipping 16 matching lines...) Expand all Loading... |
1491 | 1507 |
1492 // Verify event got dispatched to worker. | 1508 // Verify event got dispatched to worker. |
1493 base::RunLoop().RunUntilIdle(); | 1509 base::RunLoop().RunUntilIdle(); |
1494 ASSERT_EQ(1u, helper_->inner_ipc_sink()->message_count()); | 1510 ASSERT_EQ(1u, helper_->inner_ipc_sink()->message_count()); |
1495 const IPC::Message* msg = helper_->inner_ipc_sink()->GetMessageAt(0); | 1511 const IPC::Message* msg = helper_->inner_ipc_sink()->GetMessageAt(0); |
1496 EXPECT_EQ(TestMsg_TestEvent::ID, msg->type()); | 1512 EXPECT_EQ(TestMsg_TestEvent::ID, msg->type()); |
1497 | 1513 |
1498 // Simulate sending reply to event. | 1514 // Simulate sending reply to event. |
1499 helper_->SimulateSendSimpleEventResult( | 1515 helper_->SimulateSendSimpleEventResult( |
1500 version_->embedded_worker()->embedded_worker_id(), request_id, | 1516 version_->embedded_worker()->embedded_worker_id(), request_id, |
1501 blink::WebServiceWorkerEventResultRejected); | 1517 blink::WebServiceWorkerEventResultRejected, base::Time::Now()); |
1502 runner->Run(); | 1518 runner->Run(); |
1503 | 1519 |
1504 // Verify callback was called with correct status. | 1520 // Verify callback was called with correct status. |
1505 EXPECT_EQ(SERVICE_WORKER_ERROR_EVENT_WAITUNTIL_REJECTED, status); | 1521 EXPECT_EQ(SERVICE_WORKER_ERROR_EVENT_WAITUNTIL_REJECTED, status); |
1506 } | 1522 } |
1507 | 1523 |
1508 TEST_F(ServiceWorkerVersionTest, DispatchEvent_MultipleResponse) { | 1524 TEST_F(ServiceWorkerVersionTest, DispatchEvent_MultipleResponse) { |
1509 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_MAX_VALUE; | 1525 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_MAX_VALUE; |
1510 | 1526 |
1511 // Activate and start worker. | 1527 // Activate and start worker. |
(...skipping 49 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1561 version_->embedded_worker()->embedded_worker_id(), request_id2, reply2); | 1577 version_->embedded_worker()->embedded_worker_id(), request_id2, reply2); |
1562 runner->Run(); | 1578 runner->Run(); |
1563 | 1579 |
1564 // Verify message callback got called with correct reply. | 1580 // Verify message callback got called with correct reply. |
1565 EXPECT_EQ(request_id2, received_request_id2); | 1581 EXPECT_EQ(request_id2, received_request_id2); |
1566 EXPECT_EQ(reply2, received_data2); | 1582 EXPECT_EQ(reply2, received_data2); |
1567 | 1583 |
1568 // Should not have timed out, so error callback should not have been | 1584 // Should not have timed out, so error callback should not have been |
1569 // called and FinishRequest should return true. | 1585 // called and FinishRequest should return true. |
1570 EXPECT_EQ(SERVICE_WORKER_OK, status); | 1586 EXPECT_EQ(SERVICE_WORKER_OK, status); |
1571 EXPECT_TRUE(version_->FinishRequest(request_id1, true)); | 1587 EXPECT_TRUE(version_->FinishRequest(request_id1, true /* was_handled */, |
1572 EXPECT_TRUE(version_->FinishRequest(request_id2, true)); | 1588 base::Time::Now())); |
| 1589 EXPECT_TRUE(version_->FinishRequest(request_id2, true /* was_handled */, |
| 1590 base::Time::Now())); |
1573 } | 1591 } |
1574 | 1592 |
1575 class ServiceWorkerNavigationHintUMATest : public ServiceWorkerVersionTest { | 1593 class ServiceWorkerNavigationHintUMATest : public ServiceWorkerVersionTest { |
1576 protected: | 1594 protected: |
1577 ServiceWorkerNavigationHintUMATest() : ServiceWorkerVersionTest() {} | 1595 ServiceWorkerNavigationHintUMATest() : ServiceWorkerVersionTest() {} |
1578 | 1596 |
1579 void StartWorker(ServiceWorkerMetrics::EventType purpose) { | 1597 void StartWorker(ServiceWorkerMetrics::EventType purpose) { |
1580 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_MAX_VALUE; | 1598 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_MAX_VALUE; |
1581 version_->StartWorker(purpose, CreateReceiverOnCurrentThread(&status)); | 1599 version_->StartWorker(purpose, CreateReceiverOnCurrentThread(&status)); |
1582 base::RunLoop().RunUntilIdle(); | 1600 base::RunLoop().RunUntilIdle(); |
(...skipping 136 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1719 histogram_tester_.ExpectTotalCount(kLinkMouseDown, 1); | 1737 histogram_tester_.ExpectTotalCount(kLinkMouseDown, 1); |
1720 histogram_tester_.ExpectTotalCount(kLinkTapDown, 0); | 1738 histogram_tester_.ExpectTotalCount(kLinkTapDown, 0); |
1721 EXPECT_EQ(SERVICE_WORKER_OK, status); | 1739 EXPECT_EQ(SERVICE_WORKER_OK, status); |
1722 StopWorker(); | 1740 StopWorker(); |
1723 // The UMA for kLinkMouseDown must be recorded when the worker stopped. | 1741 // The UMA for kLinkMouseDown must be recorded when the worker stopped. |
1724 histogram_tester_.ExpectTotalCount(kLinkMouseDown, 1); | 1742 histogram_tester_.ExpectTotalCount(kLinkMouseDown, 1); |
1725 histogram_tester_.ExpectTotalCount(kLinkTapDown, 1); | 1743 histogram_tester_.ExpectTotalCount(kLinkTapDown, 1); |
1726 } | 1744 } |
1727 | 1745 |
1728 } // namespace content | 1746 } // namespace content |
OLD | NEW |