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_context_request_handler. h" | 5 #include "content/browser/service_worker/service_worker_context_request_handler. h" |
6 | 6 |
7 #include <utility> | 7 #include <utility> |
8 | 8 |
9 #include "base/files/scoped_temp_dir.h" | 9 #include "base/files/scoped_temp_dir.h" |
10 #include "base/logging.h" | 10 #include "base/logging.h" |
(...skipping 43 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
54 class ServiceWorkerContextRequestHandlerTest : public testing::Test { | 54 class ServiceWorkerContextRequestHandlerTest : public testing::Test { |
55 public: | 55 public: |
56 ServiceWorkerContextRequestHandlerTest() | 56 ServiceWorkerContextRequestHandlerTest() |
57 : browser_thread_bundle_(TestBrowserThreadBundle::IO_MAINLOOP) {} | 57 : browser_thread_bundle_(TestBrowserThreadBundle::IO_MAINLOOP) {} |
58 | 58 |
59 void SetUp() override { | 59 void SetUp() override { |
60 helper_.reset(new EmbeddedWorkerTestHelper(base::FilePath())); | 60 helper_.reset(new EmbeddedWorkerTestHelper(base::FilePath())); |
61 context()->storage()->LazyInitialize(base::Bind(&base::DoNothing)); | 61 context()->storage()->LazyInitialize(base::Bind(&base::DoNothing)); |
62 base::RunLoop().RunUntilIdle(); | 62 base::RunLoop().RunUntilIdle(); |
63 | 63 |
64 // A new unstored registration/version. | |
65 scope_ = GURL("https://host/scope/"); | 64 scope_ = GURL("https://host/scope/"); |
66 script_url_ = GURL("https://host/script.js"); | 65 script_url_ = GURL("https://host/script.js"); |
67 import_script_url_ = GURL("https://host/import.js"); | 66 import_script_url_ = GURL("https://host/import.js"); |
68 registration_ = new ServiceWorkerRegistration( | 67 provider_host_ = nullptr; |
69 ServiceWorkerRegistrationOptions(scope_), 1L, context()->AsWeakPtr()); | 68 |
70 version_ = new ServiceWorkerVersion(registration_.get(), script_url_, | 69 SetUpServiceWorker(); |
nhiroki
2017/07/21 04:39:46
All tests seem to explicitly call SetUpServiceWork
yuryu
2017/08/03 04:20:05
Actually these SetUpServiceWorker calls were not n
| |
71 context()->storage()->NewVersionId(), | |
72 context()->AsWeakPtr()); | |
73 SetUpProvider(); | 70 SetUpProvider(); |
74 | 71 |
75 std::unique_ptr<MockHttpProtocolHandler> handler( | 72 std::unique_ptr<MockHttpProtocolHandler> handler( |
76 new MockHttpProtocolHandler( | 73 new MockHttpProtocolHandler( |
77 helper_->browser_context()->GetResourceContext())); | 74 helper_->browser_context()->GetResourceContext())); |
78 url_request_job_factory_.SetProtocolHandler("https", std::move(handler)); | 75 url_request_job_factory_.SetProtocolHandler("https", std::move(handler)); |
79 url_request_context_.set_job_factory(&url_request_job_factory_); | 76 url_request_context_.set_job_factory(&url_request_job_factory_); |
80 } | 77 } |
81 | 78 |
82 void TearDown() override { | 79 void TearDown() override { |
83 version_ = nullptr; | 80 version_ = nullptr; |
84 registration_ = nullptr; | 81 registration_ = nullptr; |
85 helper_.reset(); | 82 helper_.reset(); |
86 } | 83 } |
87 | 84 |
88 ServiceWorkerContextCore* context() const { return helper_->context(); } | 85 ServiceWorkerContextCore* context() const { return helper_->context(); } |
89 | 86 |
87 void SetUpServiceWorker() { | |
88 SetUpServiceWorkerWithOptions( | |
89 blink::WebServiceWorkerUpdateViaCache::kImports); | |
nhiroki
2017/07/21 04:39:46
How about using default value? Default value in pr
yuryu
2017/08/03 04:20:05
Merged SetUpServiceWorker and SetUpServiceWorkerWi
| |
90 } | |
91 | |
92 void SetUpServiceWorkerWithOptions( | |
93 blink::WebServiceWorkerUpdateViaCache update_via_cache) { | |
94 // A new unstored registration/version. | |
nhiroki
2017/07/21 04:39:46
I feel this comment is not so useful for reading c
yuryu
2017/08/03 04:20:05
Removed.
| |
95 | |
96 registration_ = new ServiceWorkerRegistration( | |
97 ServiceWorkerRegistrationOptions(scope_, update_via_cache), | |
98 context()->storage()->NewRegistrationId(), context()->AsWeakPtr()); | |
99 version_ = new ServiceWorkerVersion(registration_.get(), script_url_, | |
100 context()->storage()->NewVersionId(), | |
101 context()->AsWeakPtr()); | |
102 | |
103 if (provider_host_) | |
104 provider_host_->running_hosted_version_ = version_; | |
105 } | |
106 | |
90 void SetUpProvider() { | 107 void SetUpProvider() { |
91 std::unique_ptr<ServiceWorkerProviderHost> host = | 108 std::unique_ptr<ServiceWorkerProviderHost> host = |
92 CreateProviderHostForServiceWorkerContext( | 109 CreateProviderHostForServiceWorkerContext( |
93 helper_->mock_render_process_id(), 1 /* provider_id */, | 110 helper_->mock_render_process_id(), 1 /* provider_id */, |
94 true /* is_parent_frame_secure */, context()->AsWeakPtr(), | 111 true /* is_parent_frame_secure */, context()->AsWeakPtr(), |
95 &remote_endpoint_); | 112 &remote_endpoint_); |
96 provider_host_ = host->AsWeakPtr(); | 113 provider_host_ = host->AsWeakPtr(); |
97 context()->AddProviderHost(std::move(host)); | 114 context()->AddProviderHost(std::move(host)); |
98 provider_host_->running_hosted_version_ = version_; | 115 provider_host_->running_hosted_version_ = version_; |
99 } | 116 } |
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
135 net::TestDelegate url_request_delegate_; | 152 net::TestDelegate url_request_delegate_; |
136 net::URLRequestJobFactoryImpl url_request_job_factory_; | 153 net::URLRequestJobFactoryImpl url_request_job_factory_; |
137 GURL scope_; | 154 GURL scope_; |
138 GURL script_url_; | 155 GURL script_url_; |
139 GURL import_script_url_; | 156 GURL import_script_url_; |
140 ServiceWorkerRemoteProviderEndpoint remote_endpoint_; | 157 ServiceWorkerRemoteProviderEndpoint remote_endpoint_; |
141 storage::BlobStorageContext blob_storage_context_; | 158 storage::BlobStorageContext blob_storage_context_; |
142 }; | 159 }; |
143 | 160 |
144 TEST_F(ServiceWorkerContextRequestHandlerTest, UpdateBefore24Hours) { | 161 TEST_F(ServiceWorkerContextRequestHandlerTest, UpdateBefore24Hours) { |
162 SetUpServiceWorker(); | |
145 // Give the registration a very recent last update time and pretend | 163 // Give the registration a very recent last update time and pretend |
146 // we're installing a new version. | 164 // we're installing a new version. |
147 registration_->set_last_update_check(base::Time::Now()); | 165 registration_->set_last_update_check(base::Time::Now()); |
166 version_->SetStatus(ServiceWorkerVersion::NEW); | |
167 | |
168 // Conduct a resource fetch for the main script. | |
169 base::HistogramTester histograms; | |
170 std::unique_ptr<net::URLRequest> request(CreateRequest(script_url_)); | |
171 std::unique_ptr<ServiceWorkerContextRequestHandler> handler( | |
172 CreateHandler(RESOURCE_TYPE_SERVICE_WORKER)); | |
173 std::unique_ptr<net::URLRequestJob> job( | |
174 handler->MaybeCreateJob(request.get(), nullptr, nullptr)); | |
175 ASSERT_TRUE(job.get()); | |
176 ServiceWorkerWriteToCacheJob* sw_job = | |
177 static_cast<ServiceWorkerWriteToCacheJob*>(job.get()); | |
178 histograms.ExpectUniqueSample( | |
179 "ServiceWorker.ContextRequestHandlerStatus.NewWorker.MainScript", | |
180 static_cast<int>( | |
181 ServiceWorkerContextRequestHandler::CreateJobStatus::WRITE_JOB), | |
182 1); | |
183 | |
184 // Verify the net request is initialized to bypass the browser cache. | |
185 EXPECT_TRUE(sw_job->net_request_->load_flags() & net::LOAD_BYPASS_CACHE); | |
186 } | |
187 | |
188 TEST_F(ServiceWorkerContextRequestHandlerTest, UpdateBefore24HoursUsingCache) { | |
189 SetUpServiceWorkerWithOptions(blink::WebServiceWorkerUpdateViaCache::kNone); | |
190 // Give the registration a very recent last update time and pretend | |
191 // we're installing a new version. | |
192 registration_->set_last_update_check(base::Time::Now()); | |
148 version_->SetStatus(ServiceWorkerVersion::NEW); | 193 version_->SetStatus(ServiceWorkerVersion::NEW); |
149 | 194 |
150 // Conduct a resource fetch for the main script. | 195 // Conduct a resource fetch for the main script. |
151 base::HistogramTester histograms; | 196 base::HistogramTester histograms; |
152 std::unique_ptr<net::URLRequest> request(CreateRequest(script_url_)); | 197 std::unique_ptr<net::URLRequest> request(CreateRequest(script_url_)); |
153 std::unique_ptr<ServiceWorkerContextRequestHandler> handler( | 198 std::unique_ptr<ServiceWorkerContextRequestHandler> handler( |
154 CreateHandler(RESOURCE_TYPE_SERVICE_WORKER)); | 199 CreateHandler(RESOURCE_TYPE_SERVICE_WORKER)); |
155 std::unique_ptr<net::URLRequestJob> job( | 200 std::unique_ptr<net::URLRequestJob> job( |
156 handler->MaybeCreateJob(request.get(), nullptr, nullptr)); | 201 handler->MaybeCreateJob(request.get(), nullptr, nullptr)); |
157 ASSERT_TRUE(job.get()); | 202 ASSERT_TRUE(job.get()); |
158 ServiceWorkerWriteToCacheJob* sw_job = | 203 ServiceWorkerWriteToCacheJob* sw_job = |
159 static_cast<ServiceWorkerWriteToCacheJob*>(job.get()); | 204 static_cast<ServiceWorkerWriteToCacheJob*>(job.get()); |
160 histograms.ExpectUniqueSample( | 205 histograms.ExpectUniqueSample( |
161 "ServiceWorker.ContextRequestHandlerStatus.NewWorker.MainScript", | 206 "ServiceWorker.ContextRequestHandlerStatus.NewWorker.MainScript", |
162 static_cast<int>( | 207 static_cast<int>( |
163 ServiceWorkerContextRequestHandler::CreateJobStatus::WRITE_JOB), | 208 ServiceWorkerContextRequestHandler::CreateJobStatus::WRITE_JOB), |
164 1); | 209 1); |
165 | 210 |
166 // Verify the net request is not initialized to bypass the browser cache. | 211 // Verify the net request is not initialized to bypass the browser cache. |
167 EXPECT_FALSE(sw_job->net_request_->load_flags() & net::LOAD_BYPASS_CACHE); | 212 EXPECT_FALSE(sw_job->net_request_->load_flags() & net::LOAD_BYPASS_CACHE); |
168 } | 213 } |
169 | 214 |
170 TEST_F(ServiceWorkerContextRequestHandlerTest, UpdateAfter24Hours) { | 215 TEST_F(ServiceWorkerContextRequestHandlerTest, UpdateAfter24HoursUsingCache) { |
216 SetUpServiceWorkerWithOptions(blink::WebServiceWorkerUpdateViaCache::kNone); | |
171 // Give the registration a old update time and pretend | 217 // Give the registration a old update time and pretend |
172 // we're installing a new version. | 218 // we're installing a new version. |
173 registration_->set_last_update_check( | 219 registration_->set_last_update_check( |
174 base::Time::Now() - base::TimeDelta::FromDays(7)); | 220 base::Time::Now() - base::TimeDelta::FromDays(7)); |
175 version_->SetStatus(ServiceWorkerVersion::NEW); | 221 version_->SetStatus(ServiceWorkerVersion::NEW); |
176 | 222 |
177 // Conduct a resource fetch for the main script. | 223 // Conduct a resource fetch for the main script. |
178 base::HistogramTester histograms; | 224 base::HistogramTester histograms; |
179 std::unique_ptr<net::URLRequest> request(CreateRequest(script_url_)); | 225 std::unique_ptr<net::URLRequest> request(CreateRequest(script_url_)); |
180 std::unique_ptr<ServiceWorkerContextRequestHandler> handler( | 226 std::unique_ptr<ServiceWorkerContextRequestHandler> handler( |
181 CreateHandler(RESOURCE_TYPE_SERVICE_WORKER)); | 227 CreateHandler(RESOURCE_TYPE_SERVICE_WORKER)); |
182 std::unique_ptr<net::URLRequestJob> job( | 228 std::unique_ptr<net::URLRequestJob> job( |
183 handler->MaybeCreateJob(request.get(), nullptr, nullptr)); | 229 handler->MaybeCreateJob(request.get(), nullptr, nullptr)); |
184 ASSERT_TRUE(job.get()); | 230 ASSERT_TRUE(job.get()); |
185 ServiceWorkerWriteToCacheJob* sw_job = | 231 ServiceWorkerWriteToCacheJob* sw_job = |
186 static_cast<ServiceWorkerWriteToCacheJob*>(job.get()); | 232 static_cast<ServiceWorkerWriteToCacheJob*>(job.get()); |
187 histograms.ExpectUniqueSample( | 233 histograms.ExpectUniqueSample( |
188 "ServiceWorker.ContextRequestHandlerStatus.NewWorker.MainScript", | 234 "ServiceWorker.ContextRequestHandlerStatus.NewWorker.MainScript", |
189 static_cast<int>( | 235 static_cast<int>( |
190 ServiceWorkerContextRequestHandler::CreateJobStatus::WRITE_JOB), | 236 ServiceWorkerContextRequestHandler::CreateJobStatus::WRITE_JOB), |
191 1); | 237 1); |
192 | 238 |
193 // Verify the net request is initialized to bypass the browser cache. | 239 // Verify the net request is initialized to bypass the browser cache. |
194 EXPECT_TRUE(sw_job->net_request_->load_flags() & net::LOAD_BYPASS_CACHE); | 240 EXPECT_TRUE(sw_job->net_request_->load_flags() & net::LOAD_BYPASS_CACHE); |
195 } | 241 } |
196 | 242 |
197 TEST_F(ServiceWorkerContextRequestHandlerTest, UpdateForceBypassCache) { | 243 TEST_F(ServiceWorkerContextRequestHandlerTest, UpdateForceBypassCache) { |
244 SetUpServiceWorkerWithOptions(blink::WebServiceWorkerUpdateViaCache::kNone); | |
198 // Give the registration a very recent last update time and pretend | 245 // Give the registration a very recent last update time and pretend |
199 // we're installing a new version. | 246 // we're installing a new version. |
200 registration_->set_last_update_check(base::Time::Now()); | 247 registration_->set_last_update_check(base::Time::Now()); |
201 version_->SetStatus(ServiceWorkerVersion::NEW); | 248 version_->SetStatus(ServiceWorkerVersion::NEW); |
202 version_->set_force_bypass_cache_for_scripts(true); | 249 version_->set_force_bypass_cache_for_scripts(true); |
203 | 250 |
204 // Conduct a resource fetch for the main script. | 251 // Conduct a resource fetch for the main script. |
205 std::unique_ptr<net::URLRequest> request(CreateRequest(script_url_)); | 252 std::unique_ptr<net::URLRequest> request(CreateRequest(script_url_)); |
206 std::unique_ptr<ServiceWorkerContextRequestHandler> handler( | 253 std::unique_ptr<ServiceWorkerContextRequestHandler> handler( |
207 CreateHandler(RESOURCE_TYPE_SERVICE_WORKER)); | 254 CreateHandler(RESOURCE_TYPE_SERVICE_WORKER)); |
208 std::unique_ptr<net::URLRequestJob> job( | 255 std::unique_ptr<net::URLRequestJob> job( |
209 handler->MaybeCreateJob(request.get(), nullptr, nullptr)); | 256 handler->MaybeCreateJob(request.get(), nullptr, nullptr)); |
210 ASSERT_TRUE(job.get()); | 257 ASSERT_TRUE(job.get()); |
211 ServiceWorkerWriteToCacheJob* sw_job = | 258 ServiceWorkerWriteToCacheJob* sw_job = |
212 static_cast<ServiceWorkerWriteToCacheJob*>(job.get()); | 259 static_cast<ServiceWorkerWriteToCacheJob*>(job.get()); |
213 | 260 |
214 // Verify the net request is initialized to bypass the browser cache. | 261 // Verify the net request is initialized to bypass the browser cache. |
215 EXPECT_TRUE(sw_job->net_request_->load_flags() & net::LOAD_BYPASS_CACHE); | 262 EXPECT_TRUE(sw_job->net_request_->load_flags() & net::LOAD_BYPASS_CACHE); |
216 } | 263 } |
217 | 264 |
218 TEST_F(ServiceWorkerContextRequestHandlerTest, | 265 TEST_F(ServiceWorkerContextRequestHandlerTest, |
219 ServiceWorkerDataRequestAnnotation) { | 266 ServiceWorkerDataRequestAnnotation) { |
267 SetUpServiceWorker(); | |
220 version_->SetStatus(ServiceWorkerVersion::NEW); | 268 version_->SetStatus(ServiceWorkerVersion::NEW); |
221 | 269 |
222 // Conduct a resource fetch for the main script. | 270 // Conduct a resource fetch for the main script. |
223 base::HistogramTester histograms; | 271 base::HistogramTester histograms; |
224 std::unique_ptr<net::URLRequest> request(CreateRequest(script_url_)); | 272 std::unique_ptr<net::URLRequest> request(CreateRequest(script_url_)); |
225 std::unique_ptr<ServiceWorkerContextRequestHandler> handler( | 273 std::unique_ptr<ServiceWorkerContextRequestHandler> handler( |
226 CreateHandler(RESOURCE_TYPE_SERVICE_WORKER)); | 274 CreateHandler(RESOURCE_TYPE_SERVICE_WORKER)); |
227 std::unique_ptr<net::URLRequestJob> job( | 275 std::unique_ptr<net::URLRequestJob> job( |
228 handler->MaybeCreateJob(request.get(), nullptr, nullptr)); | 276 handler->MaybeCreateJob(request.get(), nullptr, nullptr)); |
229 ASSERT_TRUE(job.get()); | 277 ASSERT_TRUE(job.get()); |
230 ServiceWorkerWriteToCacheJob* sw_job = | 278 ServiceWorkerWriteToCacheJob* sw_job = |
231 static_cast<ServiceWorkerWriteToCacheJob*>(job.get()); | 279 static_cast<ServiceWorkerWriteToCacheJob*>(job.get()); |
232 | 280 |
233 histograms.ExpectUniqueSample( | 281 histograms.ExpectUniqueSample( |
234 "ServiceWorker.ContextRequestHandlerStatus.NewWorker.MainScript", | 282 "ServiceWorker.ContextRequestHandlerStatus.NewWorker.MainScript", |
235 static_cast<int>( | 283 static_cast<int>( |
236 ServiceWorkerContextRequestHandler::CreateJobStatus::WRITE_JOB), | 284 ServiceWorkerContextRequestHandler::CreateJobStatus::WRITE_JOB), |
237 1); | 285 1); |
238 // Verify that the request is properly annotated as originating from a | 286 // Verify that the request is properly annotated as originating from a |
239 // Service Worker. | 287 // Service Worker. |
240 EXPECT_TRUE(ResourceRequestInfo::OriginatedFromServiceWorker( | 288 EXPECT_TRUE(ResourceRequestInfo::OriginatedFromServiceWorker( |
241 sw_job->net_request_.get())); | 289 sw_job->net_request_.get())); |
242 } | 290 } |
243 | 291 |
244 // Tests starting a service worker when the skip_service_worker flag is on. The | 292 // Tests starting a service worker when the skip_service_worker flag is on. The |
245 // flag should be ignored. | 293 // flag should be ignored. |
246 TEST_F(ServiceWorkerContextRequestHandlerTest, | 294 TEST_F(ServiceWorkerContextRequestHandlerTest, |
247 SkipServiceWorkerForServiceWorkerRequest) { | 295 SkipServiceWorkerForServiceWorkerRequest) { |
296 SetUpServiceWorker(); | |
248 // Conduct a resource fetch for the main script. | 297 // Conduct a resource fetch for the main script. |
249 version_->SetStatus(ServiceWorkerVersion::NEW); | 298 version_->SetStatus(ServiceWorkerVersion::NEW); |
250 std::unique_ptr<net::URLRequest> request(CreateRequest(script_url_)); | 299 std::unique_ptr<net::URLRequest> request(CreateRequest(script_url_)); |
251 ServiceWorkerRequestHandler::InitializeHandler( | 300 ServiceWorkerRequestHandler::InitializeHandler( |
252 request.get(), helper_->context_wrapper(), &blob_storage_context_, | 301 request.get(), helper_->context_wrapper(), &blob_storage_context_, |
253 helper_->mock_render_process_id(), provider_host_->provider_id(), | 302 helper_->mock_render_process_id(), provider_host_->provider_id(), |
254 true /* skip_service_worker */, FETCH_REQUEST_MODE_NO_CORS, | 303 true /* skip_service_worker */, FETCH_REQUEST_MODE_NO_CORS, |
255 FETCH_CREDENTIALS_MODE_OMIT, FetchRedirectMode::FOLLOW_MODE, | 304 FETCH_CREDENTIALS_MODE_OMIT, FetchRedirectMode::FOLLOW_MODE, |
256 RESOURCE_TYPE_SERVICE_WORKER, REQUEST_CONTEXT_TYPE_SERVICE_WORKER, | 305 RESOURCE_TYPE_SERVICE_WORKER, REQUEST_CONTEXT_TYPE_SERVICE_WORKER, |
257 REQUEST_CONTEXT_FRAME_TYPE_NONE, nullptr); | 306 REQUEST_CONTEXT_FRAME_TYPE_NONE, nullptr); |
258 // Verify a ServiceWorkerRequestHandler was created. | 307 // Verify a ServiceWorkerRequestHandler was created. |
259 ServiceWorkerRequestHandler* handler = | 308 ServiceWorkerRequestHandler* handler = |
260 ServiceWorkerRequestHandler::GetHandler(request.get()); | 309 ServiceWorkerRequestHandler::GetHandler(request.get()); |
261 EXPECT_TRUE(handler); | 310 EXPECT_TRUE(handler); |
262 } | 311 } |
263 | 312 |
264 TEST_F(ServiceWorkerContextRequestHandlerTest, NewWorker) { | 313 TEST_F(ServiceWorkerContextRequestHandlerTest, NewWorker) { |
314 SetUpServiceWorker(); | |
265 // Conduct a resource fetch for the main script. | 315 // Conduct a resource fetch for the main script. |
266 { | 316 { |
267 base::HistogramTester histograms; | 317 base::HistogramTester histograms; |
268 std::unique_ptr<net::URLRequest> request(CreateRequest(script_url_)); | 318 std::unique_ptr<net::URLRequest> request(CreateRequest(script_url_)); |
269 std::unique_ptr<ServiceWorkerContextRequestHandler> handler( | 319 std::unique_ptr<ServiceWorkerContextRequestHandler> handler( |
270 CreateHandler(RESOURCE_TYPE_SERVICE_WORKER)); | 320 CreateHandler(RESOURCE_TYPE_SERVICE_WORKER)); |
271 std::unique_ptr<net::URLRequestJob> job( | 321 std::unique_ptr<net::URLRequestJob> job( |
272 handler->MaybeCreateJob(request.get(), nullptr, nullptr)); | 322 handler->MaybeCreateJob(request.get(), nullptr, nullptr)); |
273 EXPECT_TRUE(job); | 323 EXPECT_TRUE(job); |
274 histograms.ExpectUniqueSample( | 324 histograms.ExpectUniqueSample( |
(...skipping 14 matching lines...) Expand all Loading... | |
289 EXPECT_TRUE(job); | 339 EXPECT_TRUE(job); |
290 histograms.ExpectUniqueSample( | 340 histograms.ExpectUniqueSample( |
291 "ServiceWorker.ContextRequestHandlerStatus.NewWorker.ImportedScript", | 341 "ServiceWorker.ContextRequestHandlerStatus.NewWorker.ImportedScript", |
292 static_cast<int>( | 342 static_cast<int>( |
293 ServiceWorkerContextRequestHandler::CreateJobStatus::WRITE_JOB), | 343 ServiceWorkerContextRequestHandler::CreateJobStatus::WRITE_JOB), |
294 1); | 344 1); |
295 } | 345 } |
296 } | 346 } |
297 | 347 |
298 TEST_F(ServiceWorkerContextRequestHandlerTest, InstalledWorker) { | 348 TEST_F(ServiceWorkerContextRequestHandlerTest, InstalledWorker) { |
349 SetUpServiceWorker(); | |
299 using Resource = ServiceWorkerDatabase::ResourceRecord; | 350 using Resource = ServiceWorkerDatabase::ResourceRecord; |
300 std::vector<Resource> resources = { | 351 std::vector<Resource> resources = { |
301 Resource(context()->storage()->NewResourceId(), script_url_, 100), | 352 Resource(context()->storage()->NewResourceId(), script_url_, 100), |
302 Resource(context()->storage()->NewResourceId(), import_script_url_, 100)}; | 353 Resource(context()->storage()->NewResourceId(), import_script_url_, 100)}; |
303 version_->script_cache_map()->SetResources(resources); | 354 version_->script_cache_map()->SetResources(resources); |
304 version_->set_fetch_handler_existence( | 355 version_->set_fetch_handler_existence( |
305 ServiceWorkerVersion::FetchHandlerExistence::EXISTS); | 356 ServiceWorkerVersion::FetchHandlerExistence::EXISTS); |
306 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); | 357 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); |
307 registration_->SetActiveVersion(version_); | 358 registration_->SetActiveVersion(version_); |
308 | 359 |
(...skipping 25 matching lines...) Expand all Loading... | |
334 histograms.ExpectUniqueSample( | 385 histograms.ExpectUniqueSample( |
335 "ServiceWorker.ContextRequestHandlerStatus.InstalledWorker." | 386 "ServiceWorker.ContextRequestHandlerStatus.InstalledWorker." |
336 "ImportedScript", | 387 "ImportedScript", |
337 static_cast<int>( | 388 static_cast<int>( |
338 ServiceWorkerContextRequestHandler::CreateJobStatus::READ_JOB), | 389 ServiceWorkerContextRequestHandler::CreateJobStatus::READ_JOB), |
339 1); | 390 1); |
340 } | 391 } |
341 } | 392 } |
342 | 393 |
343 TEST_F(ServiceWorkerContextRequestHandlerTest, Incumbent) { | 394 TEST_F(ServiceWorkerContextRequestHandlerTest, Incumbent) { |
395 SetUpServiceWorker(); | |
344 // Make an incumbent version. | 396 // Make an incumbent version. |
345 scoped_refptr<ServiceWorkerVersion> incumbent = new ServiceWorkerVersion( | 397 scoped_refptr<ServiceWorkerVersion> incumbent = new ServiceWorkerVersion( |
346 registration_.get(), script_url_, context()->storage()->NewVersionId(), | 398 registration_.get(), script_url_, context()->storage()->NewVersionId(), |
347 context()->AsWeakPtr()); | 399 context()->AsWeakPtr()); |
348 incumbent->set_fetch_handler_existence( | 400 incumbent->set_fetch_handler_existence( |
349 ServiceWorkerVersion::FetchHandlerExistence::EXISTS); | 401 ServiceWorkerVersion::FetchHandlerExistence::EXISTS); |
350 std::vector<ServiceWorkerDatabase::ResourceRecord> resources = { | 402 std::vector<ServiceWorkerDatabase::ResourceRecord> resources = { |
351 ServiceWorkerDatabase::ResourceRecord( | 403 ServiceWorkerDatabase::ResourceRecord( |
352 context()->storage()->NewResourceId(), script_url_, 100)}; | 404 context()->storage()->NewResourceId(), script_url_, 100)}; |
353 incumbent->script_cache_map()->SetResources(resources); | 405 incumbent->script_cache_map()->SetResources(resources); |
(...skipping 11 matching lines...) Expand all Loading... | |
365 std::unique_ptr<net::URLRequestJob> job( | 417 std::unique_ptr<net::URLRequestJob> job( |
366 handler->MaybeCreateJob(request.get(), nullptr, nullptr)); | 418 handler->MaybeCreateJob(request.get(), nullptr, nullptr)); |
367 histograms.ExpectUniqueSample( | 419 histograms.ExpectUniqueSample( |
368 "ServiceWorker.ContextRequestHandlerStatus.NewWorker.MainScript", | 420 "ServiceWorker.ContextRequestHandlerStatus.NewWorker.MainScript", |
369 static_cast<int>(ServiceWorkerContextRequestHandler::CreateJobStatus:: | 421 static_cast<int>(ServiceWorkerContextRequestHandler::CreateJobStatus:: |
370 WRITE_JOB_WITH_INCUMBENT), | 422 WRITE_JOB_WITH_INCUMBENT), |
371 1); | 423 1); |
372 } | 424 } |
373 | 425 |
374 TEST_F(ServiceWorkerContextRequestHandlerTest, ErrorCases) { | 426 TEST_F(ServiceWorkerContextRequestHandlerTest, ErrorCases) { |
427 SetUpServiceWorker(); | |
375 { | 428 { |
376 // Set up a request. | 429 // Set up a request. |
377 base::HistogramTester histograms; | 430 base::HistogramTester histograms; |
378 std::unique_ptr<net::URLRequest> request(CreateRequest(script_url_)); | 431 std::unique_ptr<net::URLRequest> request(CreateRequest(script_url_)); |
379 InitializeHandler(request.get()); | 432 InitializeHandler(request.get()); |
380 | 433 |
381 // Make the version redundant. | 434 // Make the version redundant. |
382 version_->SetStatus(ServiceWorkerVersion::REDUNDANT); | 435 version_->SetStatus(ServiceWorkerVersion::REDUNDANT); |
383 | 436 |
384 // Verify that the request fails. | 437 // Verify that the request fails. |
(...skipping 48 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
433 EXPECT_EQ(net::ERR_FAILED, url_request_delegate_.request_status()); | 486 EXPECT_EQ(net::ERR_FAILED, url_request_delegate_.request_status()); |
434 histograms.ExpectUniqueSample( | 487 histograms.ExpectUniqueSample( |
435 "ServiceWorker.ContextRequestHandlerStatus.NewWorker.MainScript", | 488 "ServiceWorker.ContextRequestHandlerStatus.NewWorker.MainScript", |
436 static_cast<int>(ServiceWorkerContextRequestHandler::CreateJobStatus:: | 489 static_cast<int>(ServiceWorkerContextRequestHandler::CreateJobStatus:: |
437 ERROR_NO_CONTEXT), | 490 ERROR_NO_CONTEXT), |
438 1); | 491 1); |
439 } | 492 } |
440 } | 493 } |
441 | 494 |
442 } // namespace content | 495 } // namespace content |
OLD | NEW |