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_controllee_request_handl
er.h" | 5 #include "content/browser/service_worker/service_worker_controllee_request_handl
er.h" |
6 | 6 |
7 #include <utility> | 7 #include <utility> |
8 #include <vector> | 8 #include <vector> |
9 | 9 |
10 #include "base/callback_helpers.h" | 10 #include "base/callback_helpers.h" |
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
48 int64_t service_worker_version_id, | 48 int64_t service_worker_version_id, |
49 const GURL& scope, | 49 const GURL& scope, |
50 const GURL& script_url, | 50 const GURL& script_url, |
51 bool pause_after_download) override { | 51 bool pause_after_download) override { |
52 SimulateWorkerStopped(embedded_worker_id); | 52 SimulateWorkerStopped(embedded_worker_id); |
53 } | 53 } |
54 }; | 54 }; |
55 | 55 |
56 class ServiceWorkerControlleeRequestHandlerTest : public testing::Test { | 56 class ServiceWorkerControlleeRequestHandlerTest : public testing::Test { |
57 public: | 57 public: |
| 58 class ServiceWorkerRequestTestResources { |
| 59 public: |
| 60 ServiceWorkerRequestTestResources( |
| 61 ServiceWorkerControlleeRequestHandlerTest* test, |
| 62 const GURL& url, |
| 63 ResourceType type) |
| 64 : test_(test), |
| 65 request_(test->url_request_context_.CreateRequest( |
| 66 url, |
| 67 net::DEFAULT_PRIORITY, |
| 68 &test->url_request_delegate_)), |
| 69 handler_(new ServiceWorkerControlleeRequestHandler( |
| 70 test->context()->AsWeakPtr(), |
| 71 test->provider_host_, |
| 72 base::WeakPtr<storage::BlobStorageContext>(), |
| 73 FETCH_REQUEST_MODE_NO_CORS, |
| 74 FETCH_CREDENTIALS_MODE_OMIT, |
| 75 FetchRedirectMode::FOLLOW_MODE, |
| 76 type, |
| 77 REQUEST_CONTEXT_TYPE_HYPERLINK, |
| 78 REQUEST_CONTEXT_FRAME_TYPE_TOP_LEVEL, |
| 79 scoped_refptr<ResourceRequestBody>())), |
| 80 job_(nullptr) {} |
| 81 |
| 82 ServiceWorkerURLRequestJob* MaybeCreateJob() { |
| 83 job_.reset(handler_->MaybeCreateJob(request_.get(), nullptr, |
| 84 &test_->mock_resource_context_)); |
| 85 return static_cast<ServiceWorkerURLRequestJob*>(job_.get()); |
| 86 } |
| 87 |
| 88 void ResetHandler() { handler_.reset(nullptr); } |
| 89 |
| 90 private: |
| 91 ServiceWorkerControlleeRequestHandlerTest* test_; |
| 92 std::unique_ptr<net::URLRequest> request_; |
| 93 std::unique_ptr<ServiceWorkerControlleeRequestHandler> handler_; |
| 94 std::unique_ptr<net::URLRequestJob> job_; |
| 95 }; |
| 96 |
58 ServiceWorkerControlleeRequestHandlerTest() | 97 ServiceWorkerControlleeRequestHandlerTest() |
59 : browser_thread_bundle_(TestBrowserThreadBundle::IO_MAINLOOP) {} | 98 : browser_thread_bundle_(TestBrowserThreadBundle::IO_MAINLOOP) {} |
60 | 99 |
61 void SetUp() override { | 100 void SetUp() override { |
62 SetUpWithHelper(new EmbeddedWorkerTestHelper(base::FilePath())); | 101 SetUpWithHelper(new EmbeddedWorkerTestHelper(base::FilePath())); |
63 } | 102 } |
64 | 103 |
65 void SetUpWithHelper(EmbeddedWorkerTestHelper* helper) { | 104 void SetUpWithHelper(EmbeddedWorkerTestHelper* helper) { |
66 helper_.reset(helper); | 105 helper_.reset(helper); |
67 | 106 |
(...skipping 56 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
124 } | 163 } |
125 }; | 164 }; |
126 | 165 |
127 TEST_F(ServiceWorkerControlleeRequestHandlerTest, DisallowServiceWorker) { | 166 TEST_F(ServiceWorkerControlleeRequestHandlerTest, DisallowServiceWorker) { |
128 ServiceWorkerTestContentBrowserClient test_browser_client; | 167 ServiceWorkerTestContentBrowserClient test_browser_client; |
129 ContentBrowserClient* old_browser_client = | 168 ContentBrowserClient* old_browser_client = |
130 SetBrowserClientForTesting(&test_browser_client); | 169 SetBrowserClientForTesting(&test_browser_client); |
131 | 170 |
132 // Store an activated worker. | 171 // Store an activated worker. |
133 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); | 172 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); |
| 173 version_->set_has_fetch_handler(true); |
134 registration_->SetActiveVersion(version_); | 174 registration_->SetActiveVersion(version_); |
135 context()->storage()->StoreRegistration( | 175 context()->storage()->StoreRegistration( |
136 registration_.get(), | 176 registration_.get(), |
137 version_.get(), | 177 version_.get(), |
138 base::Bind(&ServiceWorkerUtils::NoOpStatusCallback)); | 178 base::Bind(&ServiceWorkerUtils::NoOpStatusCallback)); |
139 base::RunLoop().RunUntilIdle(); | 179 base::RunLoop().RunUntilIdle(); |
140 | 180 |
141 // Conduct a main resource load. | 181 // Conduct a main resource load. |
142 const GURL kDocUrl("http://host/scope/doc"); | 182 ServiceWorkerRequestTestResources test_resources( |
143 std::unique_ptr<net::URLRequest> request = url_request_context_.CreateRequest( | 183 this, GURL("http://host/scope/doc"), RESOURCE_TYPE_MAIN_FRAME); |
144 kDocUrl, net::DEFAULT_PRIORITY, &url_request_delegate_); | 184 ServiceWorkerURLRequestJob* sw_job = test_resources.MaybeCreateJob(); |
145 std::unique_ptr<ServiceWorkerControlleeRequestHandler> handler( | |
146 new ServiceWorkerControlleeRequestHandler( | |
147 context()->AsWeakPtr(), provider_host_, | |
148 base::WeakPtr<storage::BlobStorageContext>(), | |
149 FETCH_REQUEST_MODE_NO_CORS, FETCH_CREDENTIALS_MODE_OMIT, | |
150 FetchRedirectMode::FOLLOW_MODE, RESOURCE_TYPE_MAIN_FRAME, | |
151 REQUEST_CONTEXT_TYPE_HYPERLINK, REQUEST_CONTEXT_FRAME_TYPE_TOP_LEVEL, | |
152 scoped_refptr<ResourceRequestBody>())); | |
153 std::unique_ptr<net::URLRequestJob> job( | |
154 handler->MaybeCreateJob(request.get(), nullptr, &mock_resource_context_)); | |
155 ServiceWorkerURLRequestJob* sw_job = | |
156 static_cast<ServiceWorkerURLRequestJob*>(job.get()); | |
157 | 185 |
158 EXPECT_FALSE(sw_job->ShouldFallbackToNetwork()); | 186 EXPECT_FALSE(sw_job->ShouldFallbackToNetwork()); |
159 EXPECT_FALSE(sw_job->ShouldForwardToServiceWorker()); | 187 EXPECT_FALSE(sw_job->ShouldForwardToServiceWorker()); |
160 EXPECT_FALSE(version_->HasControllee()); | 188 EXPECT_FALSE(version_->HasControllee()); |
161 base::RunLoop().RunUntilIdle(); | 189 base::RunLoop().RunUntilIdle(); |
162 | 190 |
163 // Verify we did not use the worker. | 191 // Verify we did not use the worker. |
164 EXPECT_TRUE(sw_job->ShouldFallbackToNetwork()); | 192 EXPECT_TRUE(sw_job->ShouldFallbackToNetwork()); |
165 EXPECT_FALSE(sw_job->ShouldForwardToServiceWorker()); | 193 EXPECT_FALSE(sw_job->ShouldForwardToServiceWorker()); |
166 EXPECT_FALSE(version_->HasControllee()); | 194 EXPECT_FALSE(version_->HasControllee()); |
167 | 195 |
168 SetBrowserClientForTesting(old_browser_client); | 196 SetBrowserClientForTesting(old_browser_client); |
169 } | 197 } |
170 | 198 |
171 TEST_F(ServiceWorkerControlleeRequestHandlerTest, ActivateWaitingVersion) { | 199 TEST_F(ServiceWorkerControlleeRequestHandlerTest, ActivateWaitingVersion) { |
172 // Store a registration that is installed but not activated yet. | 200 // Store a registration that is installed but not activated yet. |
173 version_->SetStatus(ServiceWorkerVersion::INSTALLED); | 201 version_->SetStatus(ServiceWorkerVersion::INSTALLED); |
| 202 version_->set_has_fetch_handler(true); |
174 registration_->SetWaitingVersion(version_); | 203 registration_->SetWaitingVersion(version_); |
175 context()->storage()->StoreRegistration( | 204 context()->storage()->StoreRegistration( |
176 registration_.get(), | 205 registration_.get(), |
177 version_.get(), | 206 version_.get(), |
178 base::Bind(&ServiceWorkerUtils::NoOpStatusCallback)); | 207 base::Bind(&ServiceWorkerUtils::NoOpStatusCallback)); |
179 base::RunLoop().RunUntilIdle(); | 208 base::RunLoop().RunUntilIdle(); |
180 | 209 |
181 // Conduct a main resource load. | 210 // Conduct a main resource load. |
182 const GURL kDocUrl("http://host/scope/doc"); | 211 ServiceWorkerRequestTestResources test_resources( |
183 std::unique_ptr<net::URLRequest> request = url_request_context_.CreateRequest( | 212 this, GURL("http://host/scope/doc"), RESOURCE_TYPE_MAIN_FRAME); |
184 kDocUrl, net::DEFAULT_PRIORITY, &url_request_delegate_); | 213 ServiceWorkerURLRequestJob* sw_job = test_resources.MaybeCreateJob(); |
185 std::unique_ptr<ServiceWorkerControlleeRequestHandler> handler( | |
186 new ServiceWorkerControlleeRequestHandler( | |
187 context()->AsWeakPtr(), provider_host_, | |
188 base::WeakPtr<storage::BlobStorageContext>(), | |
189 FETCH_REQUEST_MODE_NO_CORS, FETCH_CREDENTIALS_MODE_OMIT, | |
190 FetchRedirectMode::FOLLOW_MODE, RESOURCE_TYPE_MAIN_FRAME, | |
191 REQUEST_CONTEXT_TYPE_HYPERLINK, REQUEST_CONTEXT_FRAME_TYPE_TOP_LEVEL, | |
192 scoped_refptr<ResourceRequestBody>())); | |
193 std::unique_ptr<net::URLRequestJob> job( | |
194 handler->MaybeCreateJob(request.get(), nullptr, &mock_resource_context_)); | |
195 ServiceWorkerURLRequestJob* sw_job = | |
196 static_cast<ServiceWorkerURLRequestJob*>(job.get()); | |
197 | 214 |
198 EXPECT_FALSE(sw_job->ShouldFallbackToNetwork()); | 215 EXPECT_FALSE(sw_job->ShouldFallbackToNetwork()); |
199 EXPECT_FALSE(sw_job->ShouldForwardToServiceWorker()); | 216 EXPECT_FALSE(sw_job->ShouldForwardToServiceWorker()); |
200 EXPECT_FALSE(version_->HasControllee()); | 217 EXPECT_FALSE(version_->HasControllee()); |
201 | 218 |
202 base::RunLoop().RunUntilIdle(); | 219 base::RunLoop().RunUntilIdle(); |
203 | 220 |
204 EXPECT_EQ(ServiceWorkerVersion::ACTIVATED, | 221 EXPECT_EQ(ServiceWorkerVersion::ACTIVATED, |
205 version_->status()); | 222 version_->status()); |
206 EXPECT_FALSE(sw_job->ShouldFallbackToNetwork()); | 223 EXPECT_FALSE(sw_job->ShouldFallbackToNetwork()); |
207 EXPECT_TRUE(sw_job->ShouldForwardToServiceWorker()); | 224 EXPECT_TRUE(sw_job->ShouldForwardToServiceWorker()); |
208 EXPECT_TRUE(version_->HasControllee()); | 225 EXPECT_TRUE(version_->HasControllee()); |
209 | 226 |
210 // Navigations should trigger an update too. | 227 // Navigations should trigger an update too. |
211 handler.reset(NULL); | 228 test_resources.ResetHandler(); |
212 EXPECT_TRUE(version_->update_timer_.IsRunning()); | 229 EXPECT_TRUE(version_->update_timer_.IsRunning()); |
213 } | 230 } |
214 | 231 |
215 // Test that an installing registration is associated with a provider host. | 232 // Test that an installing registration is associated with a provider host. |
216 TEST_F(ServiceWorkerControlleeRequestHandlerTest, InstallingRegistration) { | 233 TEST_F(ServiceWorkerControlleeRequestHandlerTest, InstallingRegistration) { |
217 // Create an installing registration. | 234 // Create an installing registration. |
218 version_->SetStatus(ServiceWorkerVersion::INSTALLING); | 235 version_->SetStatus(ServiceWorkerVersion::INSTALLING); |
| 236 version_->set_has_fetch_handler(true); |
219 registration_->SetInstallingVersion(version_); | 237 registration_->SetInstallingVersion(version_); |
220 context()->storage()->NotifyInstallingRegistration(registration_.get()); | 238 context()->storage()->NotifyInstallingRegistration(registration_.get()); |
221 | 239 |
222 // Conduct a main resource load. | 240 // Conduct a main resource load. |
223 const GURL kDocUrl("http://host/scope/doc"); | 241 ServiceWorkerRequestTestResources test_resources( |
224 std::unique_ptr<net::URLRequest> request = url_request_context_.CreateRequest( | 242 this, GURL("http://host/scope/doc"), RESOURCE_TYPE_MAIN_FRAME); |
225 kDocUrl, net::DEFAULT_PRIORITY, &url_request_delegate_); | 243 ServiceWorkerURLRequestJob* job = test_resources.MaybeCreateJob(); |
226 std::unique_ptr<ServiceWorkerControlleeRequestHandler> handler( | 244 |
227 new ServiceWorkerControlleeRequestHandler( | |
228 context()->AsWeakPtr(), provider_host_, | |
229 base::WeakPtr<storage::BlobStorageContext>(), | |
230 FETCH_REQUEST_MODE_NO_CORS, FETCH_CREDENTIALS_MODE_OMIT, | |
231 FetchRedirectMode::FOLLOW_MODE, RESOURCE_TYPE_MAIN_FRAME, | |
232 REQUEST_CONTEXT_TYPE_HYPERLINK, REQUEST_CONTEXT_FRAME_TYPE_TOP_LEVEL, | |
233 scoped_refptr<ResourceRequestBody>())); | |
234 std::unique_ptr<net::URLRequestJob> job( | |
235 handler->MaybeCreateJob(request.get(), nullptr, &mock_resource_context_)); | |
236 base::RunLoop().RunUntilIdle(); | 245 base::RunLoop().RunUntilIdle(); |
237 | 246 |
238 // The handler should have fallen back to network and destroyed the job. The | 247 // The handler should have fallen back to network and destroyed the job. The |
239 // registration should be associated with the provider host, although it is | 248 // registration should be associated with the provider host, although it is |
240 // not controlled since there is no active version. | 249 // not controlled since there is no active version. |
241 EXPECT_FALSE(job); | 250 EXPECT_FALSE(job); |
242 EXPECT_EQ(registration_.get(), provider_host_->associated_registration()); | 251 EXPECT_EQ(registration_.get(), provider_host_->associated_registration()); |
243 EXPECT_EQ(version_.get(), provider_host_->installing_version()); | 252 EXPECT_EQ(version_.get(), provider_host_->installing_version()); |
244 EXPECT_FALSE(version_->HasControllee()); | 253 EXPECT_FALSE(version_->HasControllee()); |
245 EXPECT_FALSE(provider_host_->controlling_version()); | 254 EXPECT_FALSE(provider_host_->controlling_version()); |
246 } | 255 } |
247 | 256 |
248 // Test to not regress crbug/414118. | 257 // Test to not regress crbug/414118. |
249 TEST_F(ServiceWorkerControlleeRequestHandlerTest, DeletedProviderHost) { | 258 TEST_F(ServiceWorkerControlleeRequestHandlerTest, DeletedProviderHost) { |
250 // Store a registration so the call to FindRegistrationForDocument will read | 259 // Store a registration so the call to FindRegistrationForDocument will read |
251 // from the database. | 260 // from the database. |
252 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); | 261 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); |
| 262 version_->set_has_fetch_handler(true); |
253 registration_->SetActiveVersion(version_); | 263 registration_->SetActiveVersion(version_); |
254 context()->storage()->StoreRegistration( | 264 context()->storage()->StoreRegistration( |
255 registration_.get(), | 265 registration_.get(), |
256 version_.get(), | 266 version_.get(), |
257 base::Bind(&ServiceWorkerUtils::NoOpStatusCallback)); | 267 base::Bind(&ServiceWorkerUtils::NoOpStatusCallback)); |
258 base::RunLoop().RunUntilIdle(); | 268 base::RunLoop().RunUntilIdle(); |
259 version_ = NULL; | 269 version_ = NULL; |
260 registration_ = NULL; | 270 registration_ = NULL; |
261 | 271 |
262 // Conduct a main resource load. | 272 // Conduct a main resource load. |
263 const GURL kDocUrl("http://host/scope/doc"); | 273 ServiceWorkerRequestTestResources test_resources( |
264 std::unique_ptr<net::URLRequest> request = url_request_context_.CreateRequest( | 274 this, GURL("http://host/scope/doc"), RESOURCE_TYPE_MAIN_FRAME); |
265 kDocUrl, net::DEFAULT_PRIORITY, &url_request_delegate_); | 275 ServiceWorkerURLRequestJob* sw_job = test_resources.MaybeCreateJob(); |
266 std::unique_ptr<ServiceWorkerControlleeRequestHandler> handler( | |
267 new ServiceWorkerControlleeRequestHandler( | |
268 context()->AsWeakPtr(), provider_host_, | |
269 base::WeakPtr<storage::BlobStorageContext>(), | |
270 FETCH_REQUEST_MODE_NO_CORS, FETCH_CREDENTIALS_MODE_OMIT, | |
271 FetchRedirectMode::FOLLOW_MODE, RESOURCE_TYPE_MAIN_FRAME, | |
272 REQUEST_CONTEXT_TYPE_HYPERLINK, REQUEST_CONTEXT_FRAME_TYPE_TOP_LEVEL, | |
273 scoped_refptr<ResourceRequestBody>())); | |
274 std::unique_ptr<net::URLRequestJob> job( | |
275 handler->MaybeCreateJob(request.get(), nullptr, &mock_resource_context_)); | |
276 ServiceWorkerURLRequestJob* sw_job = | |
277 static_cast<ServiceWorkerURLRequestJob*>(job.get()); | |
278 | 276 |
279 EXPECT_FALSE(sw_job->ShouldFallbackToNetwork()); | 277 EXPECT_FALSE(sw_job->ShouldFallbackToNetwork()); |
280 EXPECT_FALSE(sw_job->ShouldForwardToServiceWorker()); | 278 EXPECT_FALSE(sw_job->ShouldForwardToServiceWorker()); |
281 | 279 |
282 // Shouldn't crash if the ProviderHost is deleted prior to completion of | 280 // Shouldn't crash if the ProviderHost is deleted prior to completion of |
283 // the database lookup. | 281 // the database lookup. |
284 context()->RemoveProviderHost(helper_->mock_render_process_id(), | 282 context()->RemoveProviderHost(helper_->mock_render_process_id(), |
285 kMockProviderId); | 283 kMockProviderId); |
286 EXPECT_FALSE(provider_host_.get()); | 284 EXPECT_FALSE(provider_host_.get()); |
287 base::RunLoop().RunUntilIdle(); | 285 base::RunLoop().RunUntilIdle(); |
288 EXPECT_TRUE(sw_job->ShouldFallbackToNetwork()); | 286 EXPECT_TRUE(sw_job->ShouldFallbackToNetwork()); |
289 EXPECT_FALSE(sw_job->ShouldForwardToServiceWorker()); | 287 EXPECT_FALSE(sw_job->ShouldForwardToServiceWorker()); |
290 } | 288 } |
291 | 289 |
| 290 TEST_F(ServiceWorkerControlleeRequestHandlerTest, FallbackWithNoFetchHandler) { |
| 291 version_->SetStatus(ServiceWorkerVersion::ACTIVATED); |
| 292 version_->set_has_fetch_handler(false); |
| 293 registration_->SetActiveVersion(version_); |
| 294 context()->storage()->StoreRegistration( |
| 295 registration_.get(), version_.get(), |
| 296 base::Bind(&ServiceWorkerUtils::NoOpStatusCallback)); |
| 297 base::RunLoop().RunUntilIdle(); |
| 298 |
| 299 ServiceWorkerRequestTestResources main_test_resources( |
| 300 this, GURL("http://host/scope/doc"), RESOURCE_TYPE_MAIN_FRAME); |
| 301 ServiceWorkerURLRequestJob* main_job = main_test_resources.MaybeCreateJob(); |
| 302 |
| 303 EXPECT_FALSE(main_job->ShouldFallbackToNetwork()); |
| 304 EXPECT_FALSE(main_job->ShouldForwardToServiceWorker()); |
| 305 EXPECT_FALSE(version_->HasControllee()); |
| 306 |
| 307 base::RunLoop().RunUntilIdle(); |
| 308 |
| 309 EXPECT_TRUE(main_job->ShouldFallbackToNetwork()); |
| 310 EXPECT_FALSE(main_job->ShouldForwardToServiceWorker()); |
| 311 EXPECT_TRUE(version_->HasControllee()); |
| 312 EXPECT_EQ(version_, provider_host_->controlling_version()); |
| 313 |
| 314 ServiceWorkerRequestTestResources sub_test_resources( |
| 315 this, GURL("http://host/scope/doc/subresource"), RESOURCE_TYPE_IMAGE); |
| 316 ServiceWorkerURLRequestJob* sub_job = sub_test_resources.MaybeCreateJob(); |
| 317 |
| 318 // This job shouldn't be created because this worker doesn't have fetch |
| 319 // handler. |
| 320 EXPECT_EQ(nullptr, sub_job); |
| 321 } |
| 322 |
292 } // namespace content | 323 } // namespace content |
OLD | NEW |