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 42 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
53 class ServiceWorkerContextRequestHandlerTest : public testing::Test { | 53 class ServiceWorkerContextRequestHandlerTest : public testing::Test { |
54 public: | 54 public: |
55 ServiceWorkerContextRequestHandlerTest() | 55 ServiceWorkerContextRequestHandlerTest() |
56 : browser_thread_bundle_(TestBrowserThreadBundle::IO_MAINLOOP) {} | 56 : browser_thread_bundle_(TestBrowserThreadBundle::IO_MAINLOOP) {} |
57 | 57 |
58 void SetUp() override { | 58 void SetUp() override { |
59 helper_.reset(new EmbeddedWorkerTestHelper(base::FilePath())); | 59 helper_.reset(new EmbeddedWorkerTestHelper(base::FilePath())); |
60 context()->storage()->LazyInitialize(base::Bind(&base::DoNothing)); | 60 context()->storage()->LazyInitialize(base::Bind(&base::DoNothing)); |
61 base::RunLoop().RunUntilIdle(); | 61 base::RunLoop().RunUntilIdle(); |
62 | 62 |
| 63 SetUpServiceWorker(); |
| 64 } |
| 65 |
| 66 void TearDown() override { |
| 67 version_ = nullptr; |
| 68 registration_ = nullptr; |
| 69 helper_.reset(); |
| 70 } |
| 71 |
| 72 ServiceWorkerContextCore* context() const { return helper_->context(); } |
| 73 |
| 74 void SetUpServiceWorker() { |
| 75 SetUpServiceWorkerWithOptions(false /* use_cache */); |
| 76 } |
| 77 |
| 78 void SetUpServiceWorkerWithOptions(bool use_cache) { |
63 // A new unstored registration/version. | 79 // A new unstored registration/version. |
64 scope_ = GURL("https://host/scope/"); | 80 scope_ = GURL("https://host/scope/"); |
65 script_url_ = GURL("https://host/script.js"); | 81 script_url_ = GURL("https://host/script.js"); |
66 import_script_url_ = GURL("https://host/import.js"); | 82 import_script_url_ = GURL("https://host/import.js"); |
67 registration_ = new ServiceWorkerRegistration( | 83 registration_ = new ServiceWorkerRegistration( |
68 scope_, 1L, context()->AsWeakPtr()); | 84 scope_, use_cache, context()->storage()->NewRegistrationId(), |
| 85 context()->AsWeakPtr()); |
69 version_ = new ServiceWorkerVersion(registration_.get(), script_url_, | 86 version_ = new ServiceWorkerVersion(registration_.get(), script_url_, |
70 context()->storage()->NewVersionId(), | 87 context()->storage()->NewVersionId(), |
71 context()->AsWeakPtr()); | 88 context()->AsWeakPtr()); |
| 89 |
72 SetUpProvider(); | 90 SetUpProvider(); |
73 | 91 |
74 std::unique_ptr<MockHttpProtocolHandler> handler( | 92 std::unique_ptr<MockHttpProtocolHandler> handler( |
75 new MockHttpProtocolHandler( | 93 new MockHttpProtocolHandler( |
76 helper_->browser_context()->GetResourceContext())); | 94 helper_->browser_context()->GetResourceContext())); |
77 url_request_job_factory_.SetProtocolHandler("https", std::move(handler)); | 95 url_request_job_factory_.SetProtocolHandler("https", std::move(handler)); |
78 url_request_context_.set_job_factory(&url_request_job_factory_); | 96 url_request_context_.set_job_factory(&url_request_job_factory_); |
79 } | 97 } |
80 | 98 |
81 void TearDown() override { | |
82 version_ = nullptr; | |
83 registration_ = nullptr; | |
84 helper_.reset(); | |
85 } | |
86 | |
87 ServiceWorkerContextCore* context() const { return helper_->context(); } | |
88 | |
89 void SetUpProvider() { | 99 void SetUpProvider() { |
90 std::unique_ptr<ServiceWorkerProviderHost> host = | 100 std::unique_ptr<ServiceWorkerProviderHost> host = |
91 CreateProviderHostForServiceWorkerContext( | 101 CreateProviderHostForServiceWorkerContext( |
92 helper_->mock_render_process_id(), 1 /* provider_id */, | 102 helper_->mock_render_process_id(), 1 /* provider_id */, |
93 true /* is_parent_frame_secure */, context()->AsWeakPtr()); | 103 true /* is_parent_frame_secure */, context()->AsWeakPtr()); |
94 provider_host_ = host->AsWeakPtr(); | 104 provider_host_ = host->AsWeakPtr(); |
95 context()->AddProviderHost(std::move(host)); | 105 context()->AddProviderHost(std::move(host)); |
96 provider_host_->running_hosted_version_ = version_; | 106 provider_host_->running_hosted_version_ = version_; |
97 } | 107 } |
98 | 108 |
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
131 net::URLRequestContext url_request_context_; | 141 net::URLRequestContext url_request_context_; |
132 MockURLRequestDelegate url_request_delegate_; | 142 MockURLRequestDelegate url_request_delegate_; |
133 net::URLRequestJobFactoryImpl url_request_job_factory_; | 143 net::URLRequestJobFactoryImpl url_request_job_factory_; |
134 GURL scope_; | 144 GURL scope_; |
135 GURL script_url_; | 145 GURL script_url_; |
136 GURL import_script_url_; | 146 GURL import_script_url_; |
137 storage::BlobStorageContext blob_storage_context_; | 147 storage::BlobStorageContext blob_storage_context_; |
138 }; | 148 }; |
139 | 149 |
140 TEST_F(ServiceWorkerContextRequestHandlerTest, UpdateBefore24Hours) { | 150 TEST_F(ServiceWorkerContextRequestHandlerTest, UpdateBefore24Hours) { |
| 151 SetUpServiceWorker(); |
141 // Give the registration a very recent last update time and pretend | 152 // Give the registration a very recent last update time and pretend |
142 // we're installing a new version. | 153 // we're installing a new version. |
143 registration_->set_last_update_check(base::Time::Now()); | 154 registration_->set_last_update_check(base::Time::Now()); |
| 155 version_->SetStatus(ServiceWorkerVersion::NEW); |
| 156 |
| 157 // Conduct a resource fetch for the main script. |
| 158 base::HistogramTester histograms; |
| 159 std::unique_ptr<net::URLRequest> request(CreateRequest(script_url_)); |
| 160 std::unique_ptr<ServiceWorkerContextRequestHandler> handler( |
| 161 CreateHandler(RESOURCE_TYPE_SERVICE_WORKER)); |
| 162 std::unique_ptr<net::URLRequestJob> job( |
| 163 handler->MaybeCreateJob(request.get(), nullptr, nullptr)); |
| 164 ASSERT_TRUE(job.get()); |
| 165 ServiceWorkerWriteToCacheJob* sw_job = |
| 166 static_cast<ServiceWorkerWriteToCacheJob*>(job.get()); |
| 167 histograms.ExpectUniqueSample( |
| 168 "ServiceWorker.ContextRequestHandlerStatus.NewWorker.MainScript", |
| 169 static_cast<int>( |
| 170 ServiceWorkerContextRequestHandler::CreateJobStatus::WRITE_JOB), |
| 171 1); |
| 172 |
| 173 // Verify the net request is initialized to bypass the browser cache. |
| 174 EXPECT_TRUE(sw_job->net_request_->load_flags() & net::LOAD_BYPASS_CACHE); |
| 175 } |
| 176 |
| 177 TEST_F(ServiceWorkerContextRequestHandlerTest, UpdateBefore24HoursUsingCache) { |
| 178 SetUpServiceWorkerWithOptions(true /* use_cache */); |
| 179 // Give the registration a very recent last update time and pretend |
| 180 // we're installing a new version. |
| 181 registration_->set_last_update_check(base::Time::Now()); |
144 version_->SetStatus(ServiceWorkerVersion::NEW); | 182 version_->SetStatus(ServiceWorkerVersion::NEW); |
145 | 183 |
146 // Conduct a resource fetch for the main script. | 184 // Conduct a resource fetch for the main script. |
147 base::HistogramTester histograms; | 185 base::HistogramTester histograms; |
148 std::unique_ptr<net::URLRequest> request(CreateRequest(script_url_)); | 186 std::unique_ptr<net::URLRequest> request(CreateRequest(script_url_)); |
149 std::unique_ptr<ServiceWorkerContextRequestHandler> handler( | 187 std::unique_ptr<ServiceWorkerContextRequestHandler> handler( |
150 CreateHandler(RESOURCE_TYPE_SERVICE_WORKER)); | 188 CreateHandler(RESOURCE_TYPE_SERVICE_WORKER)); |
151 std::unique_ptr<net::URLRequestJob> job( | 189 std::unique_ptr<net::URLRequestJob> job( |
152 handler->MaybeCreateJob(request.get(), nullptr, nullptr)); | 190 handler->MaybeCreateJob(request.get(), nullptr, nullptr)); |
153 ASSERT_TRUE(job.get()); | 191 ASSERT_TRUE(job.get()); |
154 ServiceWorkerWriteToCacheJob* sw_job = | 192 ServiceWorkerWriteToCacheJob* sw_job = |
155 static_cast<ServiceWorkerWriteToCacheJob*>(job.get()); | 193 static_cast<ServiceWorkerWriteToCacheJob*>(job.get()); |
156 histograms.ExpectUniqueSample( | 194 histograms.ExpectUniqueSample( |
157 "ServiceWorker.ContextRequestHandlerStatus.NewWorker.MainScript", | 195 "ServiceWorker.ContextRequestHandlerStatus.NewWorker.MainScript", |
158 static_cast<int>( | 196 static_cast<int>( |
159 ServiceWorkerContextRequestHandler::CreateJobStatus::WRITE_JOB), | 197 ServiceWorkerContextRequestHandler::CreateJobStatus::WRITE_JOB), |
160 1); | 198 1); |
161 | 199 |
162 // Verify the net request is not initialized to bypass the browser cache. | 200 // Verify the net request is not initialized to bypass the browser cache. |
163 EXPECT_FALSE(sw_job->net_request_->load_flags() & net::LOAD_BYPASS_CACHE); | 201 EXPECT_FALSE(sw_job->net_request_->load_flags() & net::LOAD_BYPASS_CACHE); |
164 } | 202 } |
165 | 203 |
166 TEST_F(ServiceWorkerContextRequestHandlerTest, UpdateAfter24Hours) { | 204 TEST_F(ServiceWorkerContextRequestHandlerTest, UpdateAfter24HoursUsingCache) { |
| 205 SetUpServiceWorkerWithOptions(true /* use_cache */); |
167 // Give the registration a old update time and pretend | 206 // Give the registration a old update time and pretend |
168 // we're installing a new version. | 207 // we're installing a new version. |
169 registration_->set_last_update_check( | 208 registration_->set_last_update_check( |
170 base::Time::Now() - base::TimeDelta::FromDays(7)); | 209 base::Time::Now() - base::TimeDelta::FromDays(7)); |
171 version_->SetStatus(ServiceWorkerVersion::NEW); | 210 version_->SetStatus(ServiceWorkerVersion::NEW); |
172 | 211 |
173 // Conduct a resource fetch for the main script. | 212 // Conduct a resource fetch for the main script. |
174 base::HistogramTester histograms; | 213 base::HistogramTester histograms; |
175 std::unique_ptr<net::URLRequest> request(CreateRequest(script_url_)); | 214 std::unique_ptr<net::URLRequest> request(CreateRequest(script_url_)); |
176 std::unique_ptr<ServiceWorkerContextRequestHandler> handler( | 215 std::unique_ptr<ServiceWorkerContextRequestHandler> handler( |
177 CreateHandler(RESOURCE_TYPE_SERVICE_WORKER)); | 216 CreateHandler(RESOURCE_TYPE_SERVICE_WORKER)); |
178 std::unique_ptr<net::URLRequestJob> job( | 217 std::unique_ptr<net::URLRequestJob> job( |
179 handler->MaybeCreateJob(request.get(), nullptr, nullptr)); | 218 handler->MaybeCreateJob(request.get(), nullptr, nullptr)); |
180 ASSERT_TRUE(job.get()); | 219 ASSERT_TRUE(job.get()); |
181 ServiceWorkerWriteToCacheJob* sw_job = | 220 ServiceWorkerWriteToCacheJob* sw_job = |
182 static_cast<ServiceWorkerWriteToCacheJob*>(job.get()); | 221 static_cast<ServiceWorkerWriteToCacheJob*>(job.get()); |
183 histograms.ExpectUniqueSample( | 222 histograms.ExpectUniqueSample( |
184 "ServiceWorker.ContextRequestHandlerStatus.NewWorker.MainScript", | 223 "ServiceWorker.ContextRequestHandlerStatus.NewWorker.MainScript", |
185 static_cast<int>( | 224 static_cast<int>( |
186 ServiceWorkerContextRequestHandler::CreateJobStatus::WRITE_JOB), | 225 ServiceWorkerContextRequestHandler::CreateJobStatus::WRITE_JOB), |
187 1); | 226 1); |
188 | 227 |
189 // Verify the net request is initialized to bypass the browser cache. | 228 // Verify the net request is initialized to bypass the browser cache. |
190 EXPECT_TRUE(sw_job->net_request_->load_flags() & net::LOAD_BYPASS_CACHE); | 229 EXPECT_TRUE(sw_job->net_request_->load_flags() & net::LOAD_BYPASS_CACHE); |
191 } | 230 } |
192 | 231 |
193 TEST_F(ServiceWorkerContextRequestHandlerTest, UpdateForceBypassCache) { | 232 TEST_F(ServiceWorkerContextRequestHandlerTest, UpdateForceBypassCache) { |
| 233 SetUpServiceWorkerWithOptions(true /* use_cache */); |
194 // Give the registration a very recent last update time and pretend | 234 // Give the registration a very recent last update time and pretend |
195 // we're installing a new version. | 235 // we're installing a new version. |
196 registration_->set_last_update_check(base::Time::Now()); | 236 registration_->set_last_update_check(base::Time::Now()); |
197 version_->SetStatus(ServiceWorkerVersion::NEW); | 237 version_->SetStatus(ServiceWorkerVersion::NEW); |
198 version_->set_force_bypass_cache_for_scripts(true); | 238 version_->set_force_bypass_cache_for_scripts(true); |
199 | 239 |
200 // Conduct a resource fetch for the main script. | 240 // Conduct a resource fetch for the main script. |
201 std::unique_ptr<net::URLRequest> request(CreateRequest(script_url_)); | 241 std::unique_ptr<net::URLRequest> request(CreateRequest(script_url_)); |
202 std::unique_ptr<ServiceWorkerContextRequestHandler> handler( | 242 std::unique_ptr<ServiceWorkerContextRequestHandler> handler( |
203 CreateHandler(RESOURCE_TYPE_SERVICE_WORKER)); | 243 CreateHandler(RESOURCE_TYPE_SERVICE_WORKER)); |
204 std::unique_ptr<net::URLRequestJob> job( | 244 std::unique_ptr<net::URLRequestJob> job( |
205 handler->MaybeCreateJob(request.get(), nullptr, nullptr)); | 245 handler->MaybeCreateJob(request.get(), nullptr, nullptr)); |
206 ASSERT_TRUE(job.get()); | 246 ASSERT_TRUE(job.get()); |
207 ServiceWorkerWriteToCacheJob* sw_job = | 247 ServiceWorkerWriteToCacheJob* sw_job = |
208 static_cast<ServiceWorkerWriteToCacheJob*>(job.get()); | 248 static_cast<ServiceWorkerWriteToCacheJob*>(job.get()); |
209 | 249 |
210 // Verify the net request is initialized to bypass the browser cache. | 250 // Verify the net request is initialized to bypass the browser cache. |
211 EXPECT_TRUE(sw_job->net_request_->load_flags() & net::LOAD_BYPASS_CACHE); | 251 EXPECT_TRUE(sw_job->net_request_->load_flags() & net::LOAD_BYPASS_CACHE); |
212 } | 252 } |
213 | 253 |
214 TEST_F(ServiceWorkerContextRequestHandlerTest, | 254 TEST_F(ServiceWorkerContextRequestHandlerTest, |
215 ServiceWorkerDataRequestAnnotation) { | 255 ServiceWorkerDataRequestAnnotation) { |
| 256 SetUpServiceWorker(); |
216 version_->SetStatus(ServiceWorkerVersion::NEW); | 257 version_->SetStatus(ServiceWorkerVersion::NEW); |
217 | 258 |
218 // Conduct a resource fetch for the main script. | 259 // Conduct a resource fetch for the main script. |
219 base::HistogramTester histograms; | 260 base::HistogramTester histograms; |
220 std::unique_ptr<net::URLRequest> request(CreateRequest(script_url_)); | 261 std::unique_ptr<net::URLRequest> request(CreateRequest(script_url_)); |
221 std::unique_ptr<ServiceWorkerContextRequestHandler> handler( | 262 std::unique_ptr<ServiceWorkerContextRequestHandler> handler( |
222 CreateHandler(RESOURCE_TYPE_SERVICE_WORKER)); | 263 CreateHandler(RESOURCE_TYPE_SERVICE_WORKER)); |
223 std::unique_ptr<net::URLRequestJob> job( | 264 std::unique_ptr<net::URLRequestJob> job( |
224 handler->MaybeCreateJob(request.get(), nullptr, nullptr)); | 265 handler->MaybeCreateJob(request.get(), nullptr, nullptr)); |
225 ASSERT_TRUE(job.get()); | 266 ASSERT_TRUE(job.get()); |
226 ServiceWorkerWriteToCacheJob* sw_job = | 267 ServiceWorkerWriteToCacheJob* sw_job = |
227 static_cast<ServiceWorkerWriteToCacheJob*>(job.get()); | 268 static_cast<ServiceWorkerWriteToCacheJob*>(job.get()); |
228 | 269 |
229 histograms.ExpectUniqueSample( | 270 histograms.ExpectUniqueSample( |
230 "ServiceWorker.ContextRequestHandlerStatus.NewWorker.MainScript", | 271 "ServiceWorker.ContextRequestHandlerStatus.NewWorker.MainScript", |
231 static_cast<int>( | 272 static_cast<int>( |
232 ServiceWorkerContextRequestHandler::CreateJobStatus::WRITE_JOB), | 273 ServiceWorkerContextRequestHandler::CreateJobStatus::WRITE_JOB), |
233 1); | 274 1); |
234 // Verify that the request is properly annotated as originating from a | 275 // Verify that the request is properly annotated as originating from a |
235 // Service Worker. | 276 // Service Worker. |
236 EXPECT_TRUE(ResourceRequestInfo::OriginatedFromServiceWorker( | 277 EXPECT_TRUE(ResourceRequestInfo::OriginatedFromServiceWorker( |
237 sw_job->net_request_.get())); | 278 sw_job->net_request_.get())); |
238 } | 279 } |
239 | 280 |
240 // Tests starting a service worker when the skip_service_worker flag is on. The | 281 // Tests starting a service worker when the skip_service_worker flag is on. The |
241 // flag should be ignored. | 282 // flag should be ignored. |
242 TEST_F(ServiceWorkerContextRequestHandlerTest, | 283 TEST_F(ServiceWorkerContextRequestHandlerTest, |
243 SkipServiceWorkerForServiceWorkerRequest) { | 284 SkipServiceWorkerForServiceWorkerRequest) { |
| 285 SetUpServiceWorker(); |
244 // Conduct a resource fetch for the main script. | 286 // Conduct a resource fetch for the main script. |
245 version_->SetStatus(ServiceWorkerVersion::NEW); | 287 version_->SetStatus(ServiceWorkerVersion::NEW); |
246 std::unique_ptr<net::URLRequest> request(CreateRequest(script_url_)); | 288 std::unique_ptr<net::URLRequest> request(CreateRequest(script_url_)); |
247 ServiceWorkerRequestHandler::InitializeHandler( | 289 ServiceWorkerRequestHandler::InitializeHandler( |
248 request.get(), helper_->context_wrapper(), &blob_storage_context_, | 290 request.get(), helper_->context_wrapper(), &blob_storage_context_, |
249 helper_->mock_render_process_id(), provider_host_->provider_id(), | 291 helper_->mock_render_process_id(), provider_host_->provider_id(), |
250 true /* skip_service_worker */, FETCH_REQUEST_MODE_NO_CORS, | 292 true /* skip_service_worker */, FETCH_REQUEST_MODE_NO_CORS, |
251 FETCH_CREDENTIALS_MODE_OMIT, FetchRedirectMode::FOLLOW_MODE, | 293 FETCH_CREDENTIALS_MODE_OMIT, FetchRedirectMode::FOLLOW_MODE, |
252 RESOURCE_TYPE_SERVICE_WORKER, REQUEST_CONTEXT_TYPE_SERVICE_WORKER, | 294 RESOURCE_TYPE_SERVICE_WORKER, REQUEST_CONTEXT_TYPE_SERVICE_WORKER, |
253 REQUEST_CONTEXT_FRAME_TYPE_NONE, nullptr); | 295 REQUEST_CONTEXT_FRAME_TYPE_NONE, nullptr); |
254 // Verify a ServiceWorkerRequestHandler was created. | 296 // Verify a ServiceWorkerRequestHandler was created. |
255 ServiceWorkerRequestHandler* handler = | 297 ServiceWorkerRequestHandler* handler = |
256 ServiceWorkerRequestHandler::GetHandler(request.get()); | 298 ServiceWorkerRequestHandler::GetHandler(request.get()); |
257 EXPECT_TRUE(handler); | 299 EXPECT_TRUE(handler); |
258 } | 300 } |
259 | 301 |
260 TEST_F(ServiceWorkerContextRequestHandlerTest, NewWorker) { | 302 TEST_F(ServiceWorkerContextRequestHandlerTest, NewWorker) { |
| 303 SetUpServiceWorker(); |
261 // Conduct a resource fetch for the main script. | 304 // Conduct a resource fetch for the main script. |
262 { | 305 { |
263 base::HistogramTester histograms; | 306 base::HistogramTester histograms; |
264 std::unique_ptr<net::URLRequest> request(CreateRequest(script_url_)); | 307 std::unique_ptr<net::URLRequest> request(CreateRequest(script_url_)); |
265 std::unique_ptr<ServiceWorkerContextRequestHandler> handler( | 308 std::unique_ptr<ServiceWorkerContextRequestHandler> handler( |
266 CreateHandler(RESOURCE_TYPE_SERVICE_WORKER)); | 309 CreateHandler(RESOURCE_TYPE_SERVICE_WORKER)); |
267 std::unique_ptr<net::URLRequestJob> job( | 310 std::unique_ptr<net::URLRequestJob> job( |
268 handler->MaybeCreateJob(request.get(), nullptr, nullptr)); | 311 handler->MaybeCreateJob(request.get(), nullptr, nullptr)); |
269 EXPECT_TRUE(job); | 312 EXPECT_TRUE(job); |
270 histograms.ExpectUniqueSample( | 313 histograms.ExpectUniqueSample( |
(...skipping 14 matching lines...) Expand all Loading... |
285 EXPECT_TRUE(job); | 328 EXPECT_TRUE(job); |
286 histograms.ExpectUniqueSample( | 329 histograms.ExpectUniqueSample( |
287 "ServiceWorker.ContextRequestHandlerStatus.NewWorker.ImportedScript", | 330 "ServiceWorker.ContextRequestHandlerStatus.NewWorker.ImportedScript", |
288 static_cast<int>( | 331 static_cast<int>( |
289 ServiceWorkerContextRequestHandler::CreateJobStatus::WRITE_JOB), | 332 ServiceWorkerContextRequestHandler::CreateJobStatus::WRITE_JOB), |
290 1); | 333 1); |
291 } | 334 } |
292 } | 335 } |
293 | 336 |
294 TEST_F(ServiceWorkerContextRequestHandlerTest, InstalledWorker) { | 337 TEST_F(ServiceWorkerContextRequestHandlerTest, InstalledWorker) { |
| 338 SetUpServiceWorker(); |
295 using Resource = ServiceWorkerDatabase::ResourceRecord; | 339 using Resource = ServiceWorkerDatabase::ResourceRecord; |
296 std::vector<Resource> resources = { | 340 std::vector<Resource> resources = { |
297 Resource(context()->storage()->NewResourceId(), script_url_, 100), | 341 Resource(context()->storage()->NewResourceId(), script_url_, 100), |
298 Resource(context()->storage()->NewResourceId(), import_script_url_, 100)}; | 342 Resource(context()->storage()->NewResourceId(), import_script_url_, 100)}; |
299 version_->script_cache_map()->SetResources(resources); | 343 version_->script_cache_map()->SetResources(resources); |
300 version_->set_fetch_handler_existence( | 344 version_->set_fetch_handler_existence( |
301 ServiceWorkerVersion::FetchHandlerExistence::EXISTS); | 345 ServiceWorkerVersion::FetchHandlerExistence::EXISTS); |
302 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); | 346 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); |
303 registration_->SetActiveVersion(version_); | 347 registration_->SetActiveVersion(version_); |
304 | 348 |
(...skipping 25 matching lines...) Expand all Loading... |
330 histograms.ExpectUniqueSample( | 374 histograms.ExpectUniqueSample( |
331 "ServiceWorker.ContextRequestHandlerStatus.InstalledWorker." | 375 "ServiceWorker.ContextRequestHandlerStatus.InstalledWorker." |
332 "ImportedScript", | 376 "ImportedScript", |
333 static_cast<int>( | 377 static_cast<int>( |
334 ServiceWorkerContextRequestHandler::CreateJobStatus::READ_JOB), | 378 ServiceWorkerContextRequestHandler::CreateJobStatus::READ_JOB), |
335 1); | 379 1); |
336 } | 380 } |
337 } | 381 } |
338 | 382 |
339 TEST_F(ServiceWorkerContextRequestHandlerTest, Incumbent) { | 383 TEST_F(ServiceWorkerContextRequestHandlerTest, Incumbent) { |
| 384 SetUpServiceWorker(); |
340 // Make an incumbent version. | 385 // Make an incumbent version. |
341 scoped_refptr<ServiceWorkerVersion> incumbent = new ServiceWorkerVersion( | 386 scoped_refptr<ServiceWorkerVersion> incumbent = new ServiceWorkerVersion( |
342 registration_.get(), script_url_, context()->storage()->NewVersionId(), | 387 registration_.get(), script_url_, context()->storage()->NewVersionId(), |
343 context()->AsWeakPtr()); | 388 context()->AsWeakPtr()); |
344 incumbent->set_fetch_handler_existence( | 389 incumbent->set_fetch_handler_existence( |
345 ServiceWorkerVersion::FetchHandlerExistence::EXISTS); | 390 ServiceWorkerVersion::FetchHandlerExistence::EXISTS); |
346 std::vector<ServiceWorkerDatabase::ResourceRecord> resources = { | 391 std::vector<ServiceWorkerDatabase::ResourceRecord> resources = { |
347 ServiceWorkerDatabase::ResourceRecord( | 392 ServiceWorkerDatabase::ResourceRecord( |
348 context()->storage()->NewResourceId(), script_url_, 100)}; | 393 context()->storage()->NewResourceId(), script_url_, 100)}; |
349 incumbent->script_cache_map()->SetResources(resources); | 394 incumbent->script_cache_map()->SetResources(resources); |
(...skipping 11 matching lines...) Expand all Loading... |
361 std::unique_ptr<net::URLRequestJob> job( | 406 std::unique_ptr<net::URLRequestJob> job( |
362 handler->MaybeCreateJob(request.get(), nullptr, nullptr)); | 407 handler->MaybeCreateJob(request.get(), nullptr, nullptr)); |
363 histograms.ExpectUniqueSample( | 408 histograms.ExpectUniqueSample( |
364 "ServiceWorker.ContextRequestHandlerStatus.NewWorker.MainScript", | 409 "ServiceWorker.ContextRequestHandlerStatus.NewWorker.MainScript", |
365 static_cast<int>(ServiceWorkerContextRequestHandler::CreateJobStatus:: | 410 static_cast<int>(ServiceWorkerContextRequestHandler::CreateJobStatus:: |
366 WRITE_JOB_WITH_INCUMBENT), | 411 WRITE_JOB_WITH_INCUMBENT), |
367 1); | 412 1); |
368 } | 413 } |
369 | 414 |
370 TEST_F(ServiceWorkerContextRequestHandlerTest, ErrorCases) { | 415 TEST_F(ServiceWorkerContextRequestHandlerTest, ErrorCases) { |
| 416 SetUpServiceWorker(); |
371 { | 417 { |
372 // Set up a request. | 418 // Set up a request. |
373 base::HistogramTester histograms; | 419 base::HistogramTester histograms; |
374 std::unique_ptr<net::URLRequest> request(CreateRequest(script_url_)); | 420 std::unique_ptr<net::URLRequest> request(CreateRequest(script_url_)); |
375 InitializeHandler(request.get()); | 421 InitializeHandler(request.get()); |
376 | 422 |
377 // Make the version redundant. | 423 // Make the version redundant. |
378 version_->SetStatus(ServiceWorkerVersion::REDUNDANT); | 424 version_->SetStatus(ServiceWorkerVersion::REDUNDANT); |
379 | 425 |
380 // Verify that the request fails. | 426 // Verify that the request fails. |
(...skipping 48 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
429 EXPECT_EQ(net::ERR_FAILED, url_request_delegate_.request_status()); | 475 EXPECT_EQ(net::ERR_FAILED, url_request_delegate_.request_status()); |
430 histograms.ExpectUniqueSample( | 476 histograms.ExpectUniqueSample( |
431 "ServiceWorker.ContextRequestHandlerStatus.NewWorker.MainScript", | 477 "ServiceWorker.ContextRequestHandlerStatus.NewWorker.MainScript", |
432 static_cast<int>(ServiceWorkerContextRequestHandler::CreateJobStatus:: | 478 static_cast<int>(ServiceWorkerContextRequestHandler::CreateJobStatus:: |
433 ERROR_NO_CONTEXT), | 479 ERROR_NO_CONTEXT), |
434 1); | 480 1); |
435 } | 481 } |
436 } | 482 } |
437 | 483 |
438 } // namespace content | 484 } // namespace content |
OLD | NEW |