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 "content/browser/service_worker/foreign_fetch_request_handler.h" | 5 #include "content/browser/service_worker/foreign_fetch_request_handler.h" |
6 | 6 |
7 #include "base/memory/ptr_util.h" | 7 #include "base/memory/ptr_util.h" |
8 #include "base/run_loop.h" | 8 #include "base/run_loop.h" |
9 #include "base/test/simple_test_tick_clock.h" | 9 #include "base/test/simple_test_tick_clock.h" |
10 #include "content/browser/browser_thread_impl.h" | 10 #include "content/browser/browser_thread_impl.h" |
(...skipping 50 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
61 SetBrowserClientForTesting(&test_content_browser_client_); | 61 SetBrowserClientForTesting(&test_content_browser_client_); |
62 } | 62 } |
63 ~ForeignFetchRequestHandlerTest() override {} | 63 ~ForeignFetchRequestHandlerTest() override {} |
64 | 64 |
65 void SetUp() override { | 65 void SetUp() override { |
66 const GURL kScope("https://valid.example.com/scope/"); | 66 const GURL kScope("https://valid.example.com/scope/"); |
67 const GURL kResource1("https://valid.example.com/scope/sw.js"); | 67 const GURL kResource1("https://valid.example.com/scope/sw.js"); |
68 const int64_t kRegistrationId = 0; | 68 const int64_t kRegistrationId = 0; |
69 const int64_t kVersionId = 0; | 69 const int64_t kVersionId = 0; |
70 helper_.reset(new EmbeddedWorkerTestHelper(base::FilePath())); | 70 helper_.reset(new EmbeddedWorkerTestHelper(base::FilePath())); |
71 | |
72 // Create a registration for the worker which has foreign fetch event | |
73 // handler. | |
71 registration_ = new ServiceWorkerRegistration(kScope, kRegistrationId, | 74 registration_ = new ServiceWorkerRegistration(kScope, kRegistrationId, |
72 context()->AsWeakPtr()); | 75 context()->AsWeakPtr()); |
73 version_ = new ServiceWorkerVersion(registration_.get(), kResource1, | 76 version_ = new ServiceWorkerVersion(registration_.get(), kResource1, |
74 kVersionId, context()->AsWeakPtr()); | 77 kVersionId, context()->AsWeakPtr()); |
75 | |
76 version_->set_foreign_fetch_scopes({kScope}); | 78 version_->set_foreign_fetch_scopes({kScope}); |
77 | 79 |
78 // An empty host. | |
79 std::unique_ptr<ServiceWorkerProviderHost> host( | |
80 new ServiceWorkerProviderHost( | |
81 helper_->mock_render_process_id(), MSG_ROUTING_NONE, | |
82 kMockProviderId, SERVICE_WORKER_PROVIDER_FOR_WINDOW, | |
83 ServiceWorkerProviderHost::FrameSecurityLevel::SECURE, | |
84 context()->AsWeakPtr(), nullptr)); | |
85 host->SetDocumentUrl(GURL("https://host/scope/")); | |
86 provider_host_ = host->AsWeakPtr(); | |
87 context()->AddProviderHost(std::move(host)); | |
falken
2017/02/08 06:53:51
I may be missing something but it looks like you c
shimazu
2017/02/13 03:25:56
Yes I can, but I thought that makes this test a bi
| |
88 | |
89 context()->storage()->LazyInitialize(base::Bind(&EmptyCallback)); | 80 context()->storage()->LazyInitialize(base::Bind(&EmptyCallback)); |
90 base::RunLoop().RunUntilIdle(); | 81 base::RunLoop().RunUntilIdle(); |
91 | 82 |
83 // Persist the registration data. | |
92 std::vector<ServiceWorkerDatabase::ResourceRecord> records; | 84 std::vector<ServiceWorkerDatabase::ResourceRecord> records; |
93 records.push_back( | 85 records.push_back( |
94 ServiceWorkerDatabase::ResourceRecord(10, version_->script_url(), 100)); | 86 ServiceWorkerDatabase::ResourceRecord(10, version_->script_url(), 100)); |
95 version_->script_cache_map()->SetResources(records); | 87 version_->script_cache_map()->SetResources(records); |
96 version_->set_fetch_handler_existence( | 88 version_->set_fetch_handler_existence( |
97 ServiceWorkerVersion::FetchHandlerExistence::EXISTS); | 89 ServiceWorkerVersion::FetchHandlerExistence::EXISTS); |
98 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); | 90 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); |
99 registration_->SetActiveVersion(version_); | 91 registration_->SetActiveVersion(version_); |
100 context()->storage()->StoreRegistration( | 92 context()->storage()->StoreRegistration( |
101 registration_.get(), version_.get(), | 93 registration_.get(), version_.get(), |
(...skipping 53 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
155 helper_->mock_render_process_id(), kMockProviderId, | 147 helper_->mock_render_process_id(), kMockProviderId, |
156 SkipServiceWorker::NONE, FETCH_REQUEST_MODE_CORS, | 148 SkipServiceWorker::NONE, FETCH_REQUEST_MODE_CORS, |
157 FETCH_CREDENTIALS_MODE_OMIT, FetchRedirectMode::FOLLOW_MODE, | 149 FETCH_CREDENTIALS_MODE_OMIT, FetchRedirectMode::FOLLOW_MODE, |
158 resource_type, REQUEST_CONTEXT_TYPE_FETCH, | 150 resource_type, REQUEST_CONTEXT_TYPE_FETCH, |
159 REQUEST_CONTEXT_FRAME_TYPE_NONE, nullptr, | 151 REQUEST_CONTEXT_FRAME_TYPE_NONE, nullptr, |
160 true /* initiated_in_secure_context */); | 152 true /* initiated_in_secure_context */); |
161 | 153 |
162 return ForeignFetchRequestHandler::GetHandler(request_.get()); | 154 return ForeignFetchRequestHandler::GetHandler(request_.get()); |
163 } | 155 } |
164 | 156 |
157 void CreateWindowTypeProviderHost() { | |
158 std::unique_ptr<ServiceWorkerProviderHost> host = | |
159 CreateProviderHostForWindow( | |
160 helper_->mock_render_process_id(), kMockProviderId, | |
161 true /* is_parent_frame_secure */, helper_->context()->AsWeakPtr()); | |
162 EXPECT_FALSE( | |
163 context()->GetProviderHost(host->process_id(), host->provider_id())); | |
164 host->SetDocumentUrl(GURL("https://host/scope/")); | |
165 provider_host_ = host->AsWeakPtr(); | |
166 context()->AddProviderHost(std::move(host)); | |
167 } | |
168 | |
165 void CreateServiceWorkerTypeProviderHost() { | 169 void CreateServiceWorkerTypeProviderHost() { |
166 std::unique_ptr<ServiceWorkerProviderHost> host( | 170 std::unique_ptr<ServiceWorkerProviderHost> host = |
167 new ServiceWorkerProviderHost( | 171 CreateProviderHostForServiceWorkerContext( |
168 helper_->mock_render_process_id(), MSG_ROUTING_NONE, | 172 helper_->mock_render_process_id(), kMockProviderId, |
169 kMockProviderId, SERVICE_WORKER_PROVIDER_FOR_CONTROLLER, | 173 true /* is_parent_frame_secure */, helper_->context()->AsWeakPtr()); |
170 ServiceWorkerProviderHost::FrameSecurityLevel::UNINITIALIZED, | 174 EXPECT_FALSE( |
171 context()->AsWeakPtr(), nullptr)); | 175 context()->GetProviderHost(host->process_id(), host->provider_id())); |
172 provider_host_ = host->AsWeakPtr(); | 176 provider_host_ = host->AsWeakPtr(); |
173 context()->RemoveProviderHost(host->process_id(), host->provider_id()); | |
174 context()->AddProviderHost(std::move(host)); | 177 context()->AddProviderHost(std::move(host)); |
175 | 178 |
179 // Create another worker whose requests will be intercepted by the foreign | |
180 // fetch event handler. | |
176 scoped_refptr<ServiceWorkerRegistration> registration = | 181 scoped_refptr<ServiceWorkerRegistration> registration = |
177 new ServiceWorkerRegistration(GURL("https://host/scope"), 1L, | 182 new ServiceWorkerRegistration(GURL("https://host/scope"), 1L, |
178 context()->AsWeakPtr()); | 183 context()->AsWeakPtr()); |
179 scoped_refptr<ServiceWorkerVersion> version = new ServiceWorkerVersion( | 184 scoped_refptr<ServiceWorkerVersion> version = new ServiceWorkerVersion( |
180 registration.get(), GURL("https://host/script.js"), 1L, | 185 registration.get(), GURL("https://host/script.js"), 1L, |
181 context()->AsWeakPtr()); | 186 context()->AsWeakPtr()); |
182 | 187 |
183 std::vector<ServiceWorkerDatabase::ResourceRecord> records; | 188 std::vector<ServiceWorkerDatabase::ResourceRecord> records; |
184 records.push_back( | 189 records.push_back( |
185 ServiceWorkerDatabase::ResourceRecord(10, version->script_url(), 100)); | 190 ServiceWorkerDatabase::ResourceRecord(10, version->script_url(), 100)); |
(...skipping 43 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
229 net::URLRequestContext url_request_context_; | 234 net::URLRequestContext url_request_context_; |
230 MockURLRequestDelegate url_request_delegate_; | 235 MockURLRequestDelegate url_request_delegate_; |
231 base::WeakPtr<ServiceWorkerProviderHost> provider_host_; | 236 base::WeakPtr<ServiceWorkerProviderHost> provider_host_; |
232 storage::BlobStorageContext blob_storage_context_; | 237 storage::BlobStorageContext blob_storage_context_; |
233 std::unique_ptr<net::URLRequest> request_; | 238 std::unique_ptr<net::URLRequest> request_; |
234 | 239 |
235 DISALLOW_COPY_AND_ASSIGN(ForeignFetchRequestHandlerTest); | 240 DISALLOW_COPY_AND_ASSIGN(ForeignFetchRequestHandlerTest); |
236 }; | 241 }; |
237 | 242 |
238 TEST_F(ForeignFetchRequestHandlerTest, CheckOriginTrialToken_NoToken) { | 243 TEST_F(ForeignFetchRequestHandlerTest, CheckOriginTrialToken_NoToken) { |
244 CreateWindowTypeProviderHost(); | |
239 EXPECT_TRUE(CheckOriginTrialToken(version())); | 245 EXPECT_TRUE(CheckOriginTrialToken(version())); |
240 std::unique_ptr<net::HttpResponseInfo> http_info( | 246 std::unique_ptr<net::HttpResponseInfo> http_info( |
241 CreateTestHttpResponseInfo()); | 247 CreateTestHttpResponseInfo()); |
242 version()->SetMainScriptHttpResponseInfo(*http_info); | 248 version()->SetMainScriptHttpResponseInfo(*http_info); |
243 EXPECT_FALSE(CheckOriginTrialToken(version())); | 249 EXPECT_FALSE(CheckOriginTrialToken(version())); |
244 } | 250 } |
245 | 251 |
246 TEST_F(ForeignFetchRequestHandlerTest, CheckOriginTrialToken_ValidToken) { | 252 TEST_F(ForeignFetchRequestHandlerTest, CheckOriginTrialToken_ValidToken) { |
253 CreateWindowTypeProviderHost(); | |
247 EXPECT_TRUE(CheckOriginTrialToken(version())); | 254 EXPECT_TRUE(CheckOriginTrialToken(version())); |
248 std::unique_ptr<net::HttpResponseInfo> http_info( | 255 std::unique_ptr<net::HttpResponseInfo> http_info( |
249 CreateTestHttpResponseInfo()); | 256 CreateTestHttpResponseInfo()); |
250 const std::string kOriginTrial("Origin-Trial: "); | 257 const std::string kOriginTrial("Origin-Trial: "); |
251 // Token for ForeignFetch which expires 2033-05-18. | 258 // Token for ForeignFetch which expires 2033-05-18. |
252 // generate_token.py valid.example.com ForeignFetch | 259 // generate_token.py valid.example.com ForeignFetch |
253 // --expire-timestamp=2000000000 | 260 // --expire-timestamp=2000000000 |
254 // TODO(horo): Generate this sample token during the build. | 261 // TODO(horo): Generate this sample token during the build. |
255 const std::string kFeatureToken( | 262 const std::string kFeatureToken( |
256 "AsDmvl17hoVfq9G6OT0VEhX28Nnl0VnbGZJoG6XFzosIamNfxNJ28m40PRA3PtFv3BfOlRe1" | 263 "AsDmvl17hoVfq9G6OT0VEhX28Nnl0VnbGZJoG6XFzosIamNfxNJ28m40PRA3PtFv3BfOlRe1" |
257 "5bLrEZhtICdDnwwAAABceyJvcmlnaW4iOiAiaHR0cHM6Ly92YWxpZC5leGFtcGxlLmNvbTo0" | 264 "5bLrEZhtICdDnwwAAABceyJvcmlnaW4iOiAiaHR0cHM6Ly92YWxpZC5leGFtcGxlLmNvbTo0" |
258 "NDMiLCAiZmVhdHVyZSI6ICJGb3JlaWduRmV0Y2giLCAiZXhwaXJ5IjogMjAwMDAwMDAwMH0" | 265 "NDMiLCAiZmVhdHVyZSI6ICJGb3JlaWduRmV0Y2giLCAiZXhwaXJ5IjogMjAwMDAwMDAwMH0" |
259 "="); | 266 "="); |
260 http_info->headers->AddHeader(kOriginTrial + kFeatureToken); | 267 http_info->headers->AddHeader(kOriginTrial + kFeatureToken); |
261 version()->SetMainScriptHttpResponseInfo(*http_info); | 268 version()->SetMainScriptHttpResponseInfo(*http_info); |
262 EXPECT_TRUE(CheckOriginTrialToken(version())); | 269 EXPECT_TRUE(CheckOriginTrialToken(version())); |
263 } | 270 } |
264 | 271 |
265 TEST_F(ForeignFetchRequestHandlerTest, CheckOriginTrialToken_InvalidToken) { | 272 TEST_F(ForeignFetchRequestHandlerTest, CheckOriginTrialToken_InvalidToken) { |
273 CreateWindowTypeProviderHost(); | |
266 EXPECT_TRUE(CheckOriginTrialToken(version())); | 274 EXPECT_TRUE(CheckOriginTrialToken(version())); |
267 std::unique_ptr<net::HttpResponseInfo> http_info( | 275 std::unique_ptr<net::HttpResponseInfo> http_info( |
268 CreateTestHttpResponseInfo()); | 276 CreateTestHttpResponseInfo()); |
269 const std::string kOriginTrial("Origin-Trial: "); | 277 const std::string kOriginTrial("Origin-Trial: "); |
270 // Token for FooBar which expires 2033-05-18. | 278 // Token for FooBar which expires 2033-05-18. |
271 // generate_token.py valid.example.com FooBar | 279 // generate_token.py valid.example.com FooBar |
272 // --expire-timestamp=2000000000 | 280 // --expire-timestamp=2000000000 |
273 // TODO(horo): Generate this sample token during the build. | 281 // TODO(horo): Generate this sample token during the build. |
274 const std::string kFeatureToken( | 282 const std::string kFeatureToken( |
275 "AqwtRpuoLdc6MKSFH8TbzoLFvLouL8VXTv6OJIqQvRtJBynRMbAbFwjUlcwMuj4pXUBbquBj" | 283 "AqwtRpuoLdc6MKSFH8TbzoLFvLouL8VXTv6OJIqQvRtJBynRMbAbFwjUlcwMuj4pXUBbquBj" |
276 "zj/w/d1H/ZsOcQIAAABWeyJvcmlnaW4iOiAiaHR0cHM6Ly92YWxpZC5leGFtcGxlLmNvbTo0" | 284 "zj/w/d1H/ZsOcQIAAABWeyJvcmlnaW4iOiAiaHR0cHM6Ly92YWxpZC5leGFtcGxlLmNvbTo0" |
277 "NDMiLCAiZmVhdHVyZSI6ICJGb29CYXIiLCAiZXhwaXJ5IjogMjAwMDAwMDAwMH0="); | 285 "NDMiLCAiZmVhdHVyZSI6ICJGb29CYXIiLCAiZXhwaXJ5IjogMjAwMDAwMDAwMH0="); |
278 http_info->headers->AddHeader(kOriginTrial + kFeatureToken); | 286 http_info->headers->AddHeader(kOriginTrial + kFeatureToken); |
279 version()->SetMainScriptHttpResponseInfo(*http_info); | 287 version()->SetMainScriptHttpResponseInfo(*http_info); |
280 EXPECT_FALSE(CheckOriginTrialToken(version())); | 288 EXPECT_FALSE(CheckOriginTrialToken(version())); |
281 } | 289 } |
282 | 290 |
283 TEST_F(ForeignFetchRequestHandlerTest, CheckOriginTrialToken_ExpiredToken) { | 291 TEST_F(ForeignFetchRequestHandlerTest, CheckOriginTrialToken_ExpiredToken) { |
292 CreateWindowTypeProviderHost(); | |
284 EXPECT_TRUE(CheckOriginTrialToken(version())); | 293 EXPECT_TRUE(CheckOriginTrialToken(version())); |
285 std::unique_ptr<net::HttpResponseInfo> http_info( | 294 std::unique_ptr<net::HttpResponseInfo> http_info( |
286 CreateTestHttpResponseInfo()); | 295 CreateTestHttpResponseInfo()); |
287 const std::string kOriginTrial("Origin-Trial: "); | 296 const std::string kOriginTrial("Origin-Trial: "); |
288 // Token for ForeignFetch which expired 2001-09-09. | 297 // Token for ForeignFetch which expired 2001-09-09. |
289 // generate_token.py valid.example.com ForeignFetch | 298 // generate_token.py valid.example.com ForeignFetch |
290 // --expire-timestamp=1000000000 | 299 // --expire-timestamp=1000000000 |
291 const std::string kFeatureToken( | 300 const std::string kFeatureToken( |
292 "AgBgj4Zhwzn85LJw7rzh4ZFRFqp49+9Es2SrCwZdDcoqtqQEjbvui4SKLn6GqMpr4DynGfJh" | 301 "AgBgj4Zhwzn85LJw7rzh4ZFRFqp49+9Es2SrCwZdDcoqtqQEjbvui4SKLn6GqMpr4DynGfJh" |
293 "tIy9dpOuK8PVTwkAAABceyJvcmlnaW4iOiAiaHR0cHM6Ly92YWxpZC5leGFtcGxlLmNvbTo0" | 302 "tIy9dpOuK8PVTwkAAABceyJvcmlnaW4iOiAiaHR0cHM6Ly92YWxpZC5leGFtcGxlLmNvbTo0" |
294 "NDMiLCAiZmVhdHVyZSI6ICJGb3JlaWduRmV0Y2giLCAiZXhwaXJ5IjogMTAwMDAwMDAwMH0" | 303 "NDMiLCAiZmVhdHVyZSI6ICJGb3JlaWduRmV0Y2giLCAiZXhwaXJ5IjogMTAwMDAwMDAwMH0" |
295 "="); | 304 "="); |
296 http_info->headers->AddHeader(kOriginTrial + kFeatureToken); | 305 http_info->headers->AddHeader(kOriginTrial + kFeatureToken); |
297 version()->SetMainScriptHttpResponseInfo(*http_info); | 306 version()->SetMainScriptHttpResponseInfo(*http_info); |
298 EXPECT_FALSE(CheckOriginTrialToken(version())); | 307 EXPECT_FALSE(CheckOriginTrialToken(version())); |
299 } | 308 } |
300 | 309 |
301 TEST_F(ForeignFetchRequestHandlerTest, InitializeHandler_Success) { | 310 TEST_F(ForeignFetchRequestHandlerTest, InitializeHandler_Success) { |
311 CreateWindowTypeProviderHost(); | |
302 EXPECT_TRUE(InitializeHandler(kValidUrl, RESOURCE_TYPE_IMAGE, | 312 EXPECT_TRUE(InitializeHandler(kValidUrl, RESOURCE_TYPE_IMAGE, |
303 nullptr /* initiator */)); | 313 nullptr /* initiator */)); |
304 } | 314 } |
305 | 315 |
306 TEST_F(ForeignFetchRequestHandlerTest, InitializeHandler_WrongResourceType) { | 316 TEST_F(ForeignFetchRequestHandlerTest, InitializeHandler_WrongResourceType) { |
317 CreateWindowTypeProviderHost(); | |
307 EXPECT_FALSE(InitializeHandler(kValidUrl, RESOURCE_TYPE_MAIN_FRAME, | 318 EXPECT_FALSE(InitializeHandler(kValidUrl, RESOURCE_TYPE_MAIN_FRAME, |
308 nullptr /* initiator */)); | 319 nullptr /* initiator */)); |
309 EXPECT_FALSE(InitializeHandler(kValidUrl, RESOURCE_TYPE_SUB_FRAME, | 320 EXPECT_FALSE(InitializeHandler(kValidUrl, RESOURCE_TYPE_SUB_FRAME, |
310 nullptr /* initiator */)); | 321 nullptr /* initiator */)); |
311 EXPECT_FALSE(InitializeHandler(kValidUrl, RESOURCE_TYPE_WORKER, | 322 EXPECT_FALSE(InitializeHandler(kValidUrl, RESOURCE_TYPE_WORKER, |
312 nullptr /* initiator */)); | 323 nullptr /* initiator */)); |
313 EXPECT_FALSE(InitializeHandler(kValidUrl, RESOURCE_TYPE_SHARED_WORKER, | 324 EXPECT_FALSE(InitializeHandler(kValidUrl, RESOURCE_TYPE_SHARED_WORKER, |
314 nullptr /* initiator */)); | 325 nullptr /* initiator */)); |
315 EXPECT_FALSE(InitializeHandler(kValidUrl, RESOURCE_TYPE_SERVICE_WORKER, | 326 EXPECT_FALSE(InitializeHandler(kValidUrl, RESOURCE_TYPE_SERVICE_WORKER, |
316 nullptr /* initiator */)); | 327 nullptr /* initiator */)); |
317 } | 328 } |
318 | 329 |
319 TEST_F(ForeignFetchRequestHandlerTest, InitializeHandler_SameOriginRequest) { | 330 TEST_F(ForeignFetchRequestHandlerTest, InitializeHandler_SameOriginRequest) { |
331 CreateWindowTypeProviderHost(); | |
320 EXPECT_FALSE(InitializeHandler(kValidUrl, RESOURCE_TYPE_IMAGE, | 332 EXPECT_FALSE(InitializeHandler(kValidUrl, RESOURCE_TYPE_IMAGE, |
321 kValidUrl /* initiator */)); | 333 kValidUrl /* initiator */)); |
322 } | 334 } |
323 | 335 |
324 TEST_F(ForeignFetchRequestHandlerTest, InitializeHandler_NoRegisteredHandlers) { | 336 TEST_F(ForeignFetchRequestHandlerTest, InitializeHandler_NoRegisteredHandlers) { |
337 CreateWindowTypeProviderHost(); | |
325 EXPECT_FALSE(InitializeHandler("https://invalid.example.com/foo", | 338 EXPECT_FALSE(InitializeHandler("https://invalid.example.com/foo", |
326 RESOURCE_TYPE_IMAGE, nullptr /* initiator */)); | 339 RESOURCE_TYPE_IMAGE, nullptr /* initiator */)); |
327 } | 340 } |
328 | 341 |
329 TEST_F(ForeignFetchRequestHandlerTest, InitializeHandler_TimeoutBehavior) { | 342 TEST_F(ForeignFetchRequestHandlerTest, |
343 InitializeHandler_TimeoutBehaviorForWindow) { | |
344 CreateWindowTypeProviderHost(); | |
330 ForeignFetchRequestHandler* handler = | 345 ForeignFetchRequestHandler* handler = |
331 InitializeHandler("https://valid.example.com/foo", RESOURCE_TYPE_IMAGE, | 346 InitializeHandler("https://valid.example.com/foo", RESOURCE_TYPE_IMAGE, |
332 nullptr /* initiator */); | 347 nullptr /* initiator */); |
333 ASSERT_TRUE(handler); | 348 ASSERT_TRUE(handler); |
334 | 349 |
335 EXPECT_EQ(base::nullopt, timeout_for_request(handler)); | 350 EXPECT_EQ(base::nullopt, timeout_for_request(handler)); |
351 } | |
336 | 352 |
353 TEST_F(ForeignFetchRequestHandlerTest, | |
354 InitializeHandler_TimeoutBehaviorForServiceWorker) { | |
337 CreateServiceWorkerTypeProviderHost(); | 355 CreateServiceWorkerTypeProviderHost(); |
338 ServiceWorkerVersion* version = provider_host()->running_hosted_version(); | 356 ServiceWorkerVersion* version = provider_host()->running_hosted_version(); |
339 std::unique_ptr<net::HttpResponseInfo> http_info( | 357 std::unique_ptr<net::HttpResponseInfo> http_info( |
340 CreateTestHttpResponseInfo()); | 358 CreateTestHttpResponseInfo()); |
341 version->SetMainScriptHttpResponseInfo(*http_info); | 359 version->SetMainScriptHttpResponseInfo(*http_info); |
342 | 360 |
343 // Set mock clock on version to check timeout behavior. | 361 // Set mock clock on version to check timeout behavior. |
344 base::SimpleTestTickClock* tick_clock = new base::SimpleTestTickClock(); | 362 base::SimpleTestTickClock* tick_clock = new base::SimpleTestTickClock(); |
345 tick_clock->SetNowTicks(base::TimeTicks::Now()); | 363 tick_clock->SetNowTicks(base::TimeTicks::Now()); |
346 version->SetTickClockForTesting(base::WrapUnique(tick_clock)); | 364 version->SetTickClockForTesting(base::WrapUnique(tick_clock)); |
347 | 365 |
348 // Make sure worker has a non-zero timeout. | 366 // Make sure worker has a non-zero timeout. |
349 version->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, | 367 version->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN, |
350 base::Bind(&ServiceWorkerUtils::NoOpStatusCallback)); | 368 base::Bind(&ServiceWorkerUtils::NoOpStatusCallback)); |
351 base::RunLoop().RunUntilIdle(); | 369 base::RunLoop().RunUntilIdle(); |
352 version->StartRequestWithCustomTimeout( | 370 version->StartRequestWithCustomTimeout( |
353 ServiceWorkerMetrics::EventType::ACTIVATE, | 371 ServiceWorkerMetrics::EventType::ACTIVATE, |
354 base::Bind(&ServiceWorkerUtils::NoOpStatusCallback), | 372 base::Bind(&ServiceWorkerUtils::NoOpStatusCallback), |
355 base::TimeDelta::FromSeconds(10), ServiceWorkerVersion::KILL_ON_TIMEOUT); | 373 base::TimeDelta::FromSeconds(10), ServiceWorkerVersion::KILL_ON_TIMEOUT); |
356 | 374 |
357 // Advance clock by a couple seconds. | 375 // Advance clock by a couple seconds. |
358 tick_clock->Advance(base::TimeDelta::FromSeconds(4)); | 376 tick_clock->Advance(base::TimeDelta::FromSeconds(4)); |
359 base::TimeDelta remaining_time = version->remaining_timeout(); | 377 base::TimeDelta remaining_time = version->remaining_timeout(); |
360 EXPECT_EQ(base::TimeDelta::FromSeconds(6), remaining_time); | 378 EXPECT_EQ(base::TimeDelta::FromSeconds(6), remaining_time); |
361 | 379 |
362 // Make sure new request only gets remaining timeout. | 380 // Make sure new request only gets remaining timeout. |
363 handler = InitializeHandler("https://valid.example.com/foo", | 381 ForeignFetchRequestHandler* handler = |
364 RESOURCE_TYPE_IMAGE, nullptr /* initiator */); | 382 InitializeHandler("https://valid.example.com/foo", RESOURCE_TYPE_IMAGE, |
383 nullptr /* initiator */); | |
365 ASSERT_TRUE(handler); | 384 ASSERT_TRUE(handler); |
366 EXPECT_EQ(remaining_time, timeout_for_request(handler)); | 385 ASSERT_TRUE(timeout_for_request(handler).has_value()); |
386 EXPECT_EQ(remaining_time, timeout_for_request(handler).value()); | |
367 } | 387 } |
368 | 388 |
369 } // namespace content | 389 } // namespace content |
OLD | NEW |