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 <stddef.h> | 5 #include <stddef.h> |
6 #include <stdint.h> | 6 #include <stdint.h> |
7 | 7 |
8 #include <map> | 8 #include <map> |
9 #include <memory> | 9 #include <memory> |
10 #include <utility> | 10 #include <utility> |
(...skipping 479 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
490 fetch_run_loop.QuitClosure(), &prepare_result, | 490 fetch_run_loop.QuitClosure(), &prepare_result, |
491 &fetch_result)); | 491 &fetch_result)); |
492 fetch_run_loop.Run(); | 492 fetch_run_loop.Run(); |
493 ASSERT_TRUE(prepare_result); | 493 ASSERT_TRUE(prepare_result); |
494 *result = fetch_result.result; | 494 *result = fetch_result.result; |
495 *response = fetch_result.response; | 495 *response = fetch_result.response; |
496 *blob_data_handle = std::move(fetch_result.blob_data_handle); | 496 *blob_data_handle = std::move(fetch_result.blob_data_handle); |
497 ASSERT_EQ(SERVICE_WORKER_OK, fetch_result.status); | 497 ASSERT_EQ(SERVICE_WORKER_OK, fetch_result.status); |
498 } | 498 } |
499 | 499 |
500 void FetchTestHelper( | |
501 const std::string& worker_url, | |
502 ServiceWorkerFetchEventResult* result, | |
503 ServiceWorkerResponse* response, | |
504 std::unique_ptr<storage::BlobDataHandle>* blob_data_handle) { | |
505 RunOnIOThread(base::Bind(&self::SetUpRegistrationOnIOThread, | |
506 base::Unretained(this), worker_url)); | |
507 FetchOnRegisteredWorker(result, response, blob_data_handle); | |
508 } | |
509 | |
510 void SetUpRegistrationOnIOThread(const std::string& worker_url) { | 500 void SetUpRegistrationOnIOThread(const std::string& worker_url) { |
511 ASSERT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO)); | 501 ASSERT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO)); |
512 const GURL pattern = embedded_test_server()->GetURL("/service_worker/"); | 502 const GURL pattern = embedded_test_server()->GetURL("/service_worker/"); |
513 registration_ = new ServiceWorkerRegistration( | 503 registration_ = new ServiceWorkerRegistration( |
514 pattern, | 504 pattern, |
515 wrapper()->context()->storage()->NewRegistrationId(), | 505 wrapper()->context()->storage()->NewRegistrationId(), |
516 wrapper()->context()->AsWeakPtr()); | 506 wrapper()->context()->AsWeakPtr()); |
517 // Set the update check time to avoid triggering updates in the middle of | 507 // Set the update check time to avoid triggering updates in the middle of |
518 // tests. | 508 // tests. |
519 registration_->set_last_update_check(base::Time::Now()); | 509 registration_->set_last_update_check(base::Time::Now()); |
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
552 wrapper()->context()->AddProviderHost(std::move(host)); | 542 wrapper()->context()->AddProviderHost(std::move(host)); |
553 } | 543 } |
554 | 544 |
555 void AddWaitingWorkerOnIOThread(const std::string& worker_url) { | 545 void AddWaitingWorkerOnIOThread(const std::string& worker_url) { |
556 ASSERT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO)); | 546 ASSERT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO)); |
557 scoped_refptr<ServiceWorkerVersion> waiting_version( | 547 scoped_refptr<ServiceWorkerVersion> waiting_version( |
558 new ServiceWorkerVersion( | 548 new ServiceWorkerVersion( |
559 registration_.get(), embedded_test_server()->GetURL(worker_url), | 549 registration_.get(), embedded_test_server()->GetURL(worker_url), |
560 wrapper()->context()->storage()->NewVersionId(), | 550 wrapper()->context()->storage()->NewVersionId(), |
561 wrapper()->context()->AsWeakPtr())); | 551 wrapper()->context()->AsWeakPtr())); |
| 552 waiting_version->set_fetch_handler_existence( |
| 553 ServiceWorkerVersion::FetchHandlerExistence::EXISTS); |
562 waiting_version->SetStatus(ServiceWorkerVersion::INSTALLED); | 554 waiting_version->SetStatus(ServiceWorkerVersion::INSTALLED); |
563 registration_->SetWaitingVersion(waiting_version.get()); | 555 registration_->SetWaitingVersion(waiting_version.get()); |
564 registration_->ActivateWaitingVersionWhenReady(); | 556 registration_->ActivateWaitingVersionWhenReady(); |
565 } | 557 } |
566 | 558 |
567 void StartWorker(ServiceWorkerStatusCode expected_status) { | 559 void StartWorker(ServiceWorkerStatusCode expected_status) { |
568 ASSERT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::UI)); | 560 ASSERT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::UI)); |
569 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED; | 561 ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED; |
570 base::RunLoop start_run_loop; | 562 base::RunLoop start_run_loop; |
571 BrowserThread::PostTask( | 563 BrowserThread::PostTask( |
(...skipping 101 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
673 ServiceWorkerMsg_InstallEvent(request_id)); | 665 ServiceWorkerMsg_InstallEvent(request_id)); |
674 } | 666 } |
675 | 667 |
676 void ReceiveInstallEventOnIOThread(const base::Closure& done, | 668 void ReceiveInstallEventOnIOThread(const base::Closure& done, |
677 ServiceWorkerStatusCode* out_result, | 669 ServiceWorkerStatusCode* out_result, |
678 int request_id, | 670 int request_id, |
679 blink::WebServiceWorkerEventResult result, | 671 blink::WebServiceWorkerEventResult result, |
680 bool has_fetch_handler) { | 672 bool has_fetch_handler) { |
681 version_->FinishRequest( | 673 version_->FinishRequest( |
682 request_id, result == blink::WebServiceWorkerEventResultCompleted); | 674 request_id, result == blink::WebServiceWorkerEventResultCompleted); |
683 version_->set_has_fetch_handler(has_fetch_handler); | 675 version_->set_fetch_handler_existence( |
| 676 has_fetch_handler |
| 677 ? ServiceWorkerVersion::FetchHandlerExistence::EXISTS |
| 678 : ServiceWorkerVersion::FetchHandlerExistence::DOES_NOT_EXIST); |
684 | 679 |
685 ServiceWorkerStatusCode status = SERVICE_WORKER_OK; | 680 ServiceWorkerStatusCode status = SERVICE_WORKER_OK; |
686 if (result == blink::WebServiceWorkerEventResultRejected) | 681 if (result == blink::WebServiceWorkerEventResultRejected) |
687 status = SERVICE_WORKER_ERROR_EVENT_WAITUNTIL_REJECTED; | 682 status = SERVICE_WORKER_ERROR_EVENT_WAITUNTIL_REJECTED; |
688 | 683 |
689 *out_result = status; | 684 *out_result = status; |
690 if (!done.is_null()) | 685 if (!done.is_null()) |
691 BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, done); | 686 BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, done); |
692 } | 687 } |
693 | 688 |
694 void StoreOnIOThread(const base::Closure& done, | 689 void StoreOnIOThread(const base::Closure& done, |
695 ServiceWorkerStatusCode* result, | 690 ServiceWorkerStatusCode* result, |
696 int64_t version_id) { | 691 int64_t version_id) { |
697 ASSERT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO)); | 692 ASSERT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO)); |
698 ServiceWorkerVersion* version = | 693 ServiceWorkerVersion* version = |
699 wrapper()->context()->GetLiveVersion(version_id); | 694 wrapper()->context()->GetLiveVersion(version_id); |
700 wrapper()->context()->storage()->StoreRegistration( | 695 wrapper()->context()->storage()->StoreRegistration( |
701 registration_.get(), version, | 696 registration_.get(), version, |
702 CreateReceiver(BrowserThread::UI, done, result)); | 697 CreateReceiver(BrowserThread::UI, done, result)); |
703 } | 698 } |
704 | 699 |
705 void ActivateOnIOThread(const base::Closure& done, | 700 void ActivateOnIOThread(const base::Closure& done, |
706 ServiceWorkerStatusCode* result) { | 701 ServiceWorkerStatusCode* result) { |
707 ASSERT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO)); | 702 ASSERT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO)); |
| 703 version_->set_fetch_handler_existence( |
| 704 ServiceWorkerVersion::FetchHandlerExistence::EXISTS); |
708 version_->SetStatus(ServiceWorkerVersion::ACTIVATING); | 705 version_->SetStatus(ServiceWorkerVersion::ACTIVATING); |
709 registration_->SetActiveVersion(version_.get()); | 706 registration_->SetActiveVersion(version_.get()); |
710 version_->RunAfterStartWorker( | 707 version_->RunAfterStartWorker( |
711 ServiceWorkerMetrics::EventType::ACTIVATE, | 708 ServiceWorkerMetrics::EventType::ACTIVATE, |
712 base::Bind(&self::DispatchActivateEventOnIOThread, | 709 base::Bind(&self::DispatchActivateEventOnIOThread, |
713 base::Unretained(this), done, result), | 710 base::Unretained(this), done, result), |
714 CreateReceiver(BrowserThread::UI, done, result)); | 711 CreateReceiver(BrowserThread::UI, done, result)); |
715 } | 712 } |
716 | 713 |
717 void DispatchActivateEventOnIOThread(const base::Closure& done, | 714 void DispatchActivateEventOnIOThread(const base::Closure& done, |
(...skipping 103 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
821 | 818 |
822 // Start a worker for nonexistent URL. | 819 // Start a worker for nonexistent URL. |
823 StartWorker(SERVICE_WORKER_ERROR_NETWORK); | 820 StartWorker(SERVICE_WORKER_ERROR_NETWORK); |
824 } | 821 } |
825 | 822 |
826 IN_PROC_BROWSER_TEST_F(ServiceWorkerVersionBrowserTest, ReadResourceFailure) { | 823 IN_PROC_BROWSER_TEST_F(ServiceWorkerVersionBrowserTest, ReadResourceFailure) { |
827 // Create a registration. | 824 // Create a registration. |
828 RunOnIOThread(base::Bind(&self::SetUpRegistrationOnIOThread, | 825 RunOnIOThread(base::Bind(&self::SetUpRegistrationOnIOThread, |
829 base::Unretained(this), | 826 base::Unretained(this), |
830 "/service_worker/worker.js")); | 827 "/service_worker/worker.js")); |
| 828 version_->set_fetch_handler_existence( |
| 829 ServiceWorkerVersion::FetchHandlerExistence::EXISTS); |
831 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); | 830 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); |
832 | 831 |
833 // Add a non-existent resource to the version. | 832 // Add a non-existent resource to the version. |
834 std::vector<ServiceWorkerDatabase::ResourceRecord> records; | 833 std::vector<ServiceWorkerDatabase::ResourceRecord> records; |
835 records.push_back( | 834 records.push_back( |
836 ServiceWorkerDatabase::ResourceRecord(30, version_->script_url(), 100)); | 835 ServiceWorkerDatabase::ResourceRecord(30, version_->script_url(), 100)); |
837 version_->script_cache_map()->SetResources(records); | 836 version_->script_cache_map()->SetResources(records); |
838 | 837 |
839 // Store the registration. | 838 // Store the registration. |
840 StoreRegistration(version_->version_id(), SERVICE_WORKER_OK); | 839 StoreRegistration(version_->version_id(), SERVICE_WORKER_OK); |
(...skipping 66 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
907 | 906 |
908 IN_PROC_BROWSER_TEST_F(ServiceWorkerVersionBrowserTest, | 907 IN_PROC_BROWSER_TEST_F(ServiceWorkerVersionBrowserTest, |
909 InstallWithWaitUntil_Fulfilled) { | 908 InstallWithWaitUntil_Fulfilled) { |
910 InstallTestHelper("/service_worker/worker_install_fulfilled.js", | 909 InstallTestHelper("/service_worker/worker_install_fulfilled.js", |
911 SERVICE_WORKER_OK); | 910 SERVICE_WORKER_OK); |
912 } | 911 } |
913 | 912 |
914 IN_PROC_BROWSER_TEST_F(ServiceWorkerVersionBrowserTest, | 913 IN_PROC_BROWSER_TEST_F(ServiceWorkerVersionBrowserTest, |
915 InstallWithFetchHandler) { | 914 InstallWithFetchHandler) { |
916 InstallTestHelper("/service_worker/fetch_event.js", SERVICE_WORKER_OK); | 915 InstallTestHelper("/service_worker/fetch_event.js", SERVICE_WORKER_OK); |
917 EXPECT_TRUE(version_->has_fetch_handler()); | 916 EXPECT_EQ(ServiceWorkerVersion::FetchHandlerExistence::EXISTS, |
| 917 version_->fetch_handler_existence()); |
918 } | 918 } |
919 | 919 |
920 IN_PROC_BROWSER_TEST_F(ServiceWorkerVersionBrowserTest, | 920 IN_PROC_BROWSER_TEST_F(ServiceWorkerVersionBrowserTest, |
921 InstallWithoutFetchHandler) { | 921 InstallWithoutFetchHandler) { |
922 InstallTestHelper("/service_worker/worker.js", SERVICE_WORKER_OK); | 922 InstallTestHelper("/service_worker/worker.js", SERVICE_WORKER_OK); |
923 EXPECT_FALSE(version_->has_fetch_handler()); | 923 EXPECT_EQ(ServiceWorkerVersion::FetchHandlerExistence::DOES_NOT_EXIST, |
| 924 version_->fetch_handler_existence()); |
924 } | 925 } |
925 | 926 |
926 // Check that ServiceWorker script requests set a "Service-Worker: script" | 927 // Check that ServiceWorker script requests set a "Service-Worker: script" |
927 // header. | 928 // header. |
928 IN_PROC_BROWSER_TEST_F(ServiceWorkerVersionBrowserTest, | 929 IN_PROC_BROWSER_TEST_F(ServiceWorkerVersionBrowserTest, |
929 ServiceWorkerScriptHeader) { | 930 ServiceWorkerScriptHeader) { |
930 embedded_test_server()->RegisterRequestHandler( | 931 embedded_test_server()->RegisterRequestHandler( |
931 base::Bind(&VerifyServiceWorkerHeaderInRequest)); | 932 base::Bind(&VerifyServiceWorkerHeaderInRequest)); |
932 InstallTestHelper("/service_worker/generated_sw.js", SERVICE_WORKER_OK); | 933 InstallTestHelper("/service_worker/generated_sw.js", SERVICE_WORKER_OK); |
933 } | 934 } |
(...skipping 129 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1063 | 1064 |
1064 // Terminating a worker, even one in an infinite loop, is treated as if | 1065 // Terminating a worker, even one in an infinite loop, is treated as if |
1065 // waitUntil was rejected in the renderer code. | 1066 // waitUntil was rejected in the renderer code. |
1066 EXPECT_EQ(SERVICE_WORKER_ERROR_EVENT_WAITUNTIL_REJECTED, status); | 1067 EXPECT_EQ(SERVICE_WORKER_ERROR_EVENT_WAITUNTIL_REJECTED, status); |
1067 } | 1068 } |
1068 | 1069 |
1069 IN_PROC_BROWSER_TEST_F(ServiceWorkerVersionBrowserTest, FetchEvent_Response) { | 1070 IN_PROC_BROWSER_TEST_F(ServiceWorkerVersionBrowserTest, FetchEvent_Response) { |
1070 ServiceWorkerFetchEventResult result; | 1071 ServiceWorkerFetchEventResult result; |
1071 ServiceWorkerResponse response; | 1072 ServiceWorkerResponse response; |
1072 std::unique_ptr<storage::BlobDataHandle> blob_data_handle; | 1073 std::unique_ptr<storage::BlobDataHandle> blob_data_handle; |
1073 FetchTestHelper("/service_worker/fetch_event.js", | 1074 ActivateTestHelper("/service_worker/fetch_event.js", SERVICE_WORKER_OK); |
1074 &result, &response, &blob_data_handle); | 1075 |
| 1076 FetchOnRegisteredWorker(&result, &response, &blob_data_handle); |
1075 ASSERT_EQ(SERVICE_WORKER_FETCH_EVENT_RESULT_RESPONSE, result); | 1077 ASSERT_EQ(SERVICE_WORKER_FETCH_EVENT_RESULT_RESPONSE, result); |
1076 EXPECT_EQ(301, response.status_code); | 1078 EXPECT_EQ(301, response.status_code); |
1077 EXPECT_EQ("Moved Permanently", response.status_text); | 1079 EXPECT_EQ("Moved Permanently", response.status_text); |
1078 ServiceWorkerHeaderMap expected_headers; | 1080 ServiceWorkerHeaderMap expected_headers; |
1079 expected_headers["content-language"] = "fi"; | 1081 expected_headers["content-language"] = "fi"; |
1080 expected_headers["content-type"] = "text/html; charset=UTF-8"; | 1082 expected_headers["content-type"] = "text/html; charset=UTF-8"; |
1081 EXPECT_EQ(expected_headers, response.headers); | 1083 EXPECT_EQ(expected_headers, response.headers); |
1082 | 1084 |
1083 std::string body; | 1085 std::string body; |
1084 RunOnIOThread( | 1086 RunOnIOThread( |
1085 base::Bind(&ReadResponseBody, | 1087 base::Bind(&ReadResponseBody, |
1086 &body, base::Owned(blob_data_handle.release()))); | 1088 &body, base::Owned(blob_data_handle.release()))); |
1087 EXPECT_EQ("This resource is gone. Gone, gone, gone.", body); | 1089 EXPECT_EQ("This resource is gone. Gone, gone, gone.", body); |
1088 } | 1090 } |
1089 | 1091 |
1090 IN_PROC_BROWSER_TEST_F(ServiceWorkerVersionBrowserTest, | 1092 IN_PROC_BROWSER_TEST_F(ServiceWorkerVersionBrowserTest, |
1091 FetchEvent_ResponseViaCache) { | 1093 FetchEvent_ResponseViaCache) { |
1092 ServiceWorkerFetchEventResult result; | 1094 ServiceWorkerFetchEventResult result; |
1093 ServiceWorkerResponse response1; | 1095 ServiceWorkerResponse response1; |
1094 ServiceWorkerResponse response2; | 1096 ServiceWorkerResponse response2; |
1095 std::unique_ptr<storage::BlobDataHandle> blob_data_handle; | 1097 std::unique_ptr<storage::BlobDataHandle> blob_data_handle; |
1096 const base::Time start_time(base::Time::Now()); | 1098 const base::Time start_time(base::Time::Now()); |
1097 | 1099 ActivateTestHelper("/service_worker/fetch_event_response_via_cache.js", |
1098 RunOnIOThread( | 1100 SERVICE_WORKER_OK); |
1099 base::Bind(&self::SetUpRegistrationOnIOThread, base::Unretained(this), | |
1100 "/service_worker/fetch_event_response_via_cache.js")); | |
1101 | 1101 |
1102 FetchOnRegisteredWorker(&result, &response1, &blob_data_handle); | 1102 FetchOnRegisteredWorker(&result, &response1, &blob_data_handle); |
1103 ASSERT_EQ(SERVICE_WORKER_FETCH_EVENT_RESULT_RESPONSE, result); | 1103 ASSERT_EQ(SERVICE_WORKER_FETCH_EVENT_RESULT_RESPONSE, result); |
1104 EXPECT_EQ(200, response1.status_code); | 1104 EXPECT_EQ(200, response1.status_code); |
1105 EXPECT_EQ("OK", response1.status_text); | 1105 EXPECT_EQ("OK", response1.status_text); |
1106 EXPECT_TRUE(response1.response_time >= start_time); | 1106 EXPECT_TRUE(response1.response_time >= start_time); |
1107 EXPECT_FALSE(response1.is_in_cache_storage); | 1107 EXPECT_FALSE(response1.is_in_cache_storage); |
1108 EXPECT_EQ(std::string(), response2.cache_storage_cache_name); | 1108 EXPECT_EQ(std::string(), response2.cache_storage_cache_name); |
1109 | 1109 |
1110 FetchOnRegisteredWorker(&result, &response2, &blob_data_handle); | 1110 FetchOnRegisteredWorker(&result, &response2, &blob_data_handle); |
1111 ASSERT_EQ(SERVICE_WORKER_FETCH_EVENT_RESULT_RESPONSE, result); | 1111 ASSERT_EQ(SERVICE_WORKER_FETCH_EVENT_RESULT_RESPONSE, result); |
1112 EXPECT_EQ(200, response2.status_code); | 1112 EXPECT_EQ(200, response2.status_code); |
1113 EXPECT_EQ("OK", response2.status_text); | 1113 EXPECT_EQ("OK", response2.status_text); |
1114 EXPECT_EQ(response1.response_time, response2.response_time); | 1114 EXPECT_EQ(response1.response_time, response2.response_time); |
1115 EXPECT_TRUE(response2.is_in_cache_storage); | 1115 EXPECT_TRUE(response2.is_in_cache_storage); |
1116 EXPECT_EQ("cache_name", response2.cache_storage_cache_name); | 1116 EXPECT_EQ("cache_name", response2.cache_storage_cache_name); |
1117 } | 1117 } |
1118 | 1118 |
1119 IN_PROC_BROWSER_TEST_F(ServiceWorkerVersionBrowserTest, | 1119 IN_PROC_BROWSER_TEST_F(ServiceWorkerVersionBrowserTest, |
1120 FetchEvent_respondWithRejection) { | 1120 FetchEvent_respondWithRejection) { |
1121 ServiceWorkerFetchEventResult result; | 1121 ServiceWorkerFetchEventResult result; |
1122 ServiceWorkerResponse response; | 1122 ServiceWorkerResponse response; |
1123 std::unique_ptr<storage::BlobDataHandle> blob_data_handle; | 1123 std::unique_ptr<storage::BlobDataHandle> blob_data_handle; |
1124 | 1124 ActivateTestHelper("/service_worker/fetch_event_rejected.js", |
1125 RunOnIOThread(base::Bind(&self::SetUpRegistrationOnIOThread, | 1125 SERVICE_WORKER_OK); |
1126 base::Unretained(this), | |
1127 "/service_worker/fetch_event_rejected.js")); | |
1128 | 1126 |
1129 ConsoleListener console_listener; | 1127 ConsoleListener console_listener; |
1130 RunOnIOThread(base::Bind(&EmbeddedWorkerInstance::AddListener, | 1128 RunOnIOThread(base::Bind(&EmbeddedWorkerInstance::AddListener, |
1131 base::Unretained(version_->embedded_worker()), | 1129 base::Unretained(version_->embedded_worker()), |
1132 &console_listener)); | 1130 &console_listener)); |
1133 | 1131 |
1134 FetchOnRegisteredWorker(&result, &response, &blob_data_handle); | 1132 FetchOnRegisteredWorker(&result, &response, &blob_data_handle); |
1135 const base::string16 expected1 = base::ASCIIToUTF16( | 1133 const base::string16 expected1 = base::ASCIIToUTF16( |
1136 "resulted in a network error response: the promise was rejected."); | 1134 "resulted in a network error response: the promise was rejected."); |
1137 const base::string16 expected2 = | 1135 const base::string16 expected2 = |
(...skipping 887 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2025 | 2023 |
2026 IN_PROC_BROWSER_TEST_F(ServiceWorkerDisableWebSecurityTest, UpdateNoCrash) { | 2024 IN_PROC_BROWSER_TEST_F(ServiceWorkerDisableWebSecurityTest, UpdateNoCrash) { |
2027 const char kPageUrl[] = "/service_worker/disable_web_security_update.html"; | 2025 const char kPageUrl[] = "/service_worker/disable_web_security_update.html"; |
2028 const char kScopeUrl[] = "/service_worker/scope/"; | 2026 const char kScopeUrl[] = "/service_worker/scope/"; |
2029 const char kWorkerUrl[] = "/service_worker/fetch_event_blob.js"; | 2027 const char kWorkerUrl[] = "/service_worker/fetch_event_blob.js"; |
2030 RegisterServiceWorkerOnCrossOriginServer(kScopeUrl, kWorkerUrl); | 2028 RegisterServiceWorkerOnCrossOriginServer(kScopeUrl, kWorkerUrl); |
2031 RunTestWithCrossOriginURL(kPageUrl, kScopeUrl); | 2029 RunTestWithCrossOriginURL(kPageUrl, kScopeUrl); |
2032 } | 2030 } |
2033 | 2031 |
2034 } // namespace content | 2032 } // namespace content |
OLD | NEW |