OLD | NEW |
1 // Copyright 2015 The Chromium Authors. All rights reserved. | 1 // Copyright 2015 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/background_sync/background_sync_manager.h" | 5 #include "content/browser/background_sync/background_sync_manager.h" |
6 | 6 |
7 #include "base/files/scoped_temp_dir.h" | 7 #include "base/files/scoped_temp_dir.h" |
8 #include "base/logging.h" | 8 #include "base/logging.h" |
9 #include "base/run_loop.h" | 9 #include "base/run_loop.h" |
10 #include "base/thread_task_runner_handle.h" | 10 #include "base/thread_task_runner_handle.h" |
11 #include "content/browser/browser_thread_impl.h" | 11 #include "content/browser/browser_thread_impl.h" |
12 #include "content/browser/service_worker/embedded_worker_test_helper.h" | 12 #include "content/browser/service_worker/embedded_worker_test_helper.h" |
13 #include "content/browser/service_worker/service_worker_context_core.h" | 13 #include "content/browser/service_worker/service_worker_context_core.h" |
14 #include "content/browser/service_worker/service_worker_context_wrapper.h" | 14 #include "content/browser/service_worker/service_worker_context_wrapper.h" |
15 #include "content/browser/service_worker/service_worker_storage.h" | 15 #include "content/browser/service_worker/service_worker_storage.h" |
16 #include "content/public/test/test_browser_thread_bundle.h" | 16 #include "content/public/test/test_browser_thread_bundle.h" |
| 17 #include "net/base/network_change_notifier.h" |
17 #include "testing/gtest/include/gtest/gtest.h" | 18 #include "testing/gtest/include/gtest/gtest.h" |
18 | 19 |
19 namespace content { | 20 namespace content { |
20 | 21 |
21 namespace { | 22 namespace { |
22 | 23 |
23 const char kPattern1[] = "https://example.com/a"; | 24 const char kPattern1[] = "https://example.com/a"; |
24 const char kPattern2[] = "https://example.com/b"; | 25 const char kPattern2[] = "https://example.com/b"; |
25 const char kScript1[] = "https://example.com/a/script.js"; | 26 const char kScript1[] = "https://example.com/a/script.js"; |
26 const char kScript2[] = "https://example.com/b/script.js"; | 27 const char kScript2[] = "https://example.com/b/script.js"; |
(...skipping 16 matching lines...) Expand all Loading... |
43 EXPECT_EQ(SERVICE_WORKER_OK, status) << ServiceWorkerStatusToString(status); | 44 EXPECT_EQ(SERVICE_WORKER_OK, status) << ServiceWorkerStatusToString(status); |
44 *out_registration = registration; | 45 *out_registration = registration; |
45 } | 46 } |
46 | 47 |
47 void UnregisterServiceWorkerCallback(bool* called, | 48 void UnregisterServiceWorkerCallback(bool* called, |
48 ServiceWorkerStatusCode code) { | 49 ServiceWorkerStatusCode code) { |
49 EXPECT_EQ(SERVICE_WORKER_OK, code); | 50 EXPECT_EQ(SERVICE_WORKER_OK, code); |
50 *called = true; | 51 *called = true; |
51 } | 52 } |
52 | 53 |
| 54 void OneShotSuccessfulCallback( |
| 55 int* count, |
| 56 const scoped_refptr<ServiceWorkerVersion>& active_version, |
| 57 const ServiceWorkerVersion::StatusCallback& callback) { |
| 58 *count += 1; |
| 59 callback.Run(SERVICE_WORKER_OK); |
| 60 } |
| 61 |
| 62 void OneShotFailedCallback( |
| 63 int* count, |
| 64 const scoped_refptr<ServiceWorkerVersion>& active_version, |
| 65 const ServiceWorkerVersion::StatusCallback& callback) { |
| 66 *count += 1; |
| 67 callback.Run(SERVICE_WORKER_ERROR_FAILED); |
| 68 } |
| 69 |
| 70 void OneShotDelayedCallback( |
| 71 int* count, |
| 72 ServiceWorkerVersion::StatusCallback* out_callback, |
| 73 const scoped_refptr<ServiceWorkerVersion>& active_version, |
| 74 const ServiceWorkerVersion::StatusCallback& callback) { |
| 75 *count += 1; |
| 76 *out_callback = callback; |
| 77 } |
| 78 |
53 } // namespace | 79 } // namespace |
54 | 80 |
55 // A BackgroundSyncManager that can simulate delaying and corrupting the | 81 // A BackgroundSyncManager that can simulate delaying and corrupting the backend |
56 // backend. This class assumes (and verifies) that only one operation runs at a | 82 // storage and service worker onsync events. |
57 // time. | |
58 class TestBackgroundSyncManager : public BackgroundSyncManager { | 83 class TestBackgroundSyncManager : public BackgroundSyncManager { |
59 public: | 84 public: |
| 85 using OneShotCallback = |
| 86 base::Callback<void(const scoped_refptr<ServiceWorkerVersion>&, |
| 87 const ServiceWorkerVersion::StatusCallback&)>; |
| 88 |
60 explicit TestBackgroundSyncManager( | 89 explicit TestBackgroundSyncManager( |
61 const scoped_refptr<ServiceWorkerContextWrapper>& service_worker_context) | 90 const scoped_refptr<ServiceWorkerContextWrapper>& service_worker_context) |
62 : BackgroundSyncManager(service_worker_context) {} | 91 : BackgroundSyncManager(service_worker_context) {} |
63 | 92 |
64 void DoInit() { Init(); } | 93 void DoInit() { Init(); } |
65 | 94 |
66 void StoreDataInBackendContinue( | 95 void StoreDataInBackendContinue( |
67 int64 sw_registration_id, | 96 int64 sw_registration_id, |
68 const GURL& origin, | 97 const GURL& origin, |
69 const std::string& key, | 98 const std::string& key, |
(...skipping 12 matching lines...) Expand all Loading... |
82 | 111 |
83 void Continue() { | 112 void Continue() { |
84 continuation_.Run(); | 113 continuation_.Run(); |
85 continuation_.Reset(); | 114 continuation_.Reset(); |
86 } | 115 } |
87 | 116 |
88 void set_corrupt_backend(bool corrupt_backend) { | 117 void set_corrupt_backend(bool corrupt_backend) { |
89 corrupt_backend_ = corrupt_backend; | 118 corrupt_backend_ = corrupt_backend; |
90 } | 119 } |
91 void set_delay_backend(bool delay_backend) { delay_backend_ = delay_backend; } | 120 void set_delay_backend(bool delay_backend) { delay_backend_ = delay_backend; } |
| 121 void set_one_shot_callback(const OneShotCallback& callback) { |
| 122 one_shot_callback_ = callback; |
| 123 } |
92 | 124 |
93 protected: | 125 protected: |
94 void StoreDataInBackend( | 126 void StoreDataInBackend( |
95 int64 sw_registration_id, | 127 int64 sw_registration_id, |
96 const GURL& origin, | 128 const GURL& origin, |
97 const std::string& key, | 129 const std::string& key, |
98 const std::string& data, | 130 const std::string& data, |
99 const ServiceWorkerStorage::StatusCallback& callback) override { | 131 const ServiceWorkerStorage::StatusCallback& callback) override { |
100 EXPECT_TRUE(continuation_.is_null()); | 132 EXPECT_TRUE(continuation_.is_null()); |
101 if (corrupt_backend_) { | 133 if (corrupt_backend_) { |
(...skipping 25 matching lines...) Expand all Loading... |
127 } | 159 } |
128 continuation_ = | 160 continuation_ = |
129 base::Bind(&TestBackgroundSyncManager::GetDataFromBackendContinue, | 161 base::Bind(&TestBackgroundSyncManager::GetDataFromBackendContinue, |
130 base::Unretained(this), key, callback); | 162 base::Unretained(this), key, callback); |
131 if (delay_backend_) | 163 if (delay_backend_) |
132 return; | 164 return; |
133 | 165 |
134 Continue(); | 166 Continue(); |
135 } | 167 } |
136 | 168 |
| 169 void FireOneShotSync( |
| 170 const scoped_refptr<ServiceWorkerVersion>& active_version, |
| 171 const ServiceWorkerVersion::StatusCallback& callback) override { |
| 172 if (one_shot_callback_.is_null()) { |
| 173 BackgroundSyncManager::FireOneShotSync(active_version, callback); |
| 174 } else { |
| 175 one_shot_callback_.Run(active_version, callback); |
| 176 } |
| 177 } |
| 178 |
137 private: | 179 private: |
138 bool corrupt_backend_ = false; | 180 bool corrupt_backend_ = false; |
139 bool delay_backend_ = false; | 181 bool delay_backend_ = false; |
140 base::Closure continuation_; | 182 base::Closure continuation_; |
| 183 OneShotCallback one_shot_callback_; |
141 }; | 184 }; |
142 | 185 |
143 class BackgroundSyncManagerTest : public testing::Test { | 186 class BackgroundSyncManagerTest : public testing::Test { |
144 public: | 187 public: |
145 BackgroundSyncManagerTest() | 188 BackgroundSyncManagerTest() |
146 : browser_thread_bundle_(TestBrowserThreadBundle::IO_MAINLOOP), | 189 : browser_thread_bundle_(TestBrowserThreadBundle::IO_MAINLOOP), |
| 190 network_change_notifier_(net::NetworkChangeNotifier::CreateMock()), |
| 191 test_background_sync_manager_(nullptr), |
147 sync_reg_1_(BackgroundSyncManager::BackgroundSyncRegistration()), | 192 sync_reg_1_(BackgroundSyncManager::BackgroundSyncRegistration()), |
148 sync_reg_2_(BackgroundSyncManager::BackgroundSyncRegistration()), | 193 sync_reg_2_(BackgroundSyncManager::BackgroundSyncRegistration()), |
149 callback_error_(BackgroundSyncManager::ERROR_TYPE_OK), | 194 callback_error_(BackgroundSyncManager::ERROR_TYPE_OK), |
150 callback_sw_status_code_(SERVICE_WORKER_OK) { | 195 callback_sw_status_code_(SERVICE_WORKER_OK), |
| 196 sync_events_called_(0) { |
151 sync_reg_1_.tag = "foo"; | 197 sync_reg_1_.tag = "foo"; |
| 198 sync_reg_1_.periodicity = SYNC_ONE_SHOT; |
| 199 sync_reg_1_.network_state = NETWORK_STATE_ONLINE; |
| 200 sync_reg_1_.power_state = POWER_STATE_AUTO; |
| 201 |
152 sync_reg_2_.tag = "bar"; | 202 sync_reg_2_.tag = "bar"; |
| 203 sync_reg_2_.periodicity = SYNC_ONE_SHOT; |
| 204 sync_reg_2_.network_state = NETWORK_STATE_ONLINE; |
| 205 sync_reg_2_.power_state = POWER_STATE_AUTO; |
153 } | 206 } |
154 | 207 |
155 void SetUp() override { | 208 void SetUp() override { |
| 209 SetNetwork(net::NetworkChangeNotifier::CONNECTION_WIFI); |
| 210 |
156 helper_.reset( | 211 helper_.reset( |
157 new EmbeddedWorkerTestHelper(base::FilePath(), kRenderProcessId)); | 212 new EmbeddedWorkerTestHelper(base::FilePath(), kRenderProcessId)); |
158 | 213 |
159 background_sync_manager_ = | 214 background_sync_manager_ = |
160 BackgroundSyncManager::Create(helper_->context_wrapper()); | 215 BackgroundSyncManager::Create(helper_->context_wrapper()); |
161 | 216 |
162 // Wait for storage to finish initializing before registering service | 217 // Wait for storage to finish initializing before registering service |
163 // workers. | 218 // workers. |
164 base::RunLoop().RunUntilIdle(); | 219 base::RunLoop().RunUntilIdle(); |
165 RegisterServiceWorkers(); | 220 RegisterServiceWorkers(); |
(...skipping 22 matching lines...) Expand all Loading... |
188 base::Bind(FindServiceWorkerRegistrationCallback, &sw_registration_1_)); | 243 base::Bind(FindServiceWorkerRegistrationCallback, &sw_registration_1_)); |
189 | 244 |
190 helper_->context_wrapper()->FindRegistrationForId( | 245 helper_->context_wrapper()->FindRegistrationForId( |
191 sw_registration_id_2_, GURL(kPattern1).GetOrigin(), | 246 sw_registration_id_2_, GURL(kPattern1).GetOrigin(), |
192 base::Bind(FindServiceWorkerRegistrationCallback, &sw_registration_2_)); | 247 base::Bind(FindServiceWorkerRegistrationCallback, &sw_registration_2_)); |
193 base::RunLoop().RunUntilIdle(); | 248 base::RunLoop().RunUntilIdle(); |
194 EXPECT_TRUE(sw_registration_1_); | 249 EXPECT_TRUE(sw_registration_1_); |
195 EXPECT_TRUE(sw_registration_2_); | 250 EXPECT_TRUE(sw_registration_2_); |
196 } | 251 } |
197 | 252 |
| 253 void SetNetwork(net::NetworkChangeNotifier::ConnectionType connection_type) { |
| 254 net::NetworkChangeNotifier::NotifyObserversOfNetworkChangeForTests( |
| 255 connection_type); |
| 256 base::RunLoop().RunUntilIdle(); |
| 257 } |
| 258 |
198 void StatusAndRegistrationCallback( | 259 void StatusAndRegistrationCallback( |
199 bool* was_called, | 260 bool* was_called, |
200 BackgroundSyncManager::ErrorType error, | 261 BackgroundSyncManager::ErrorType error, |
201 const BackgroundSyncManager::BackgroundSyncRegistration& registration) { | 262 const BackgroundSyncManager::BackgroundSyncRegistration& registration) { |
202 *was_called = true; | 263 *was_called = true; |
203 callback_error_ = error; | 264 callback_error_ = error; |
204 callback_registration_ = registration; | 265 callback_registration_ = registration; |
205 } | 266 } |
206 | 267 |
207 void StatusCallback(bool* was_called, | 268 void StatusCallback(bool* was_called, |
208 BackgroundSyncManager::ErrorType error) { | 269 BackgroundSyncManager::ErrorType error) { |
209 *was_called = true; | 270 *was_called = true; |
210 callback_error_ = error; | 271 callback_error_ = error; |
211 } | 272 } |
212 | 273 |
213 protected: | 274 protected: |
214 TestBackgroundSyncManager* UseTestBackgroundSyncManager() { | 275 void UseTestBackgroundSyncManager() { |
215 TestBackgroundSyncManager* manager = | 276 test_background_sync_manager_ = |
216 new TestBackgroundSyncManager(helper_->context_wrapper()); | 277 new TestBackgroundSyncManager(helper_->context_wrapper()); |
217 background_sync_manager_.reset(manager); | 278 test_background_sync_manager_->DoInit(); |
218 manager->DoInit(); | 279 background_sync_manager_.reset(test_background_sync_manager_); |
219 return manager; | |
220 } | 280 } |
221 | 281 |
222 bool Register(const BackgroundSyncManager::BackgroundSyncRegistration& | 282 bool Register(const BackgroundSyncManager::BackgroundSyncRegistration& |
223 sync_registration) { | 283 sync_registration) { |
224 return RegisterWithServiceWorkerId(sw_registration_id_1_, | 284 return RegisterWithServiceWorkerId(sw_registration_id_1_, |
225 sync_registration); | 285 sync_registration); |
226 } | 286 } |
227 | 287 |
228 bool RegisterWithServiceWorkerId( | 288 bool RegisterWithServiceWorkerId( |
229 int64 sw_registration_id, | 289 int64 sw_registration_id, |
(...skipping 69 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
299 base::RunLoop().RunUntilIdle(); | 359 base::RunLoop().RunUntilIdle(); |
300 EXPECT_TRUE(called); | 360 EXPECT_TRUE(called); |
301 } | 361 } |
302 | 362 |
303 GURL PatternForSWId(int64 sw_id) { | 363 GURL PatternForSWId(int64 sw_id) { |
304 EXPECT_TRUE(sw_id == sw_registration_id_1_ || | 364 EXPECT_TRUE(sw_id == sw_registration_id_1_ || |
305 sw_id == sw_registration_id_2_); | 365 sw_id == sw_registration_id_2_); |
306 return sw_id == sw_registration_id_1_ ? GURL(kPattern1) : GURL(kPattern2); | 366 return sw_id == sw_registration_id_1_ ? GURL(kPattern1) : GURL(kPattern2); |
307 } | 367 } |
308 | 368 |
| 369 void InitSyncEventTest() { |
| 370 UseTestBackgroundSyncManager(); |
| 371 test_background_sync_manager_->set_one_shot_callback( |
| 372 base::Bind(OneShotSuccessfulCallback, &sync_events_called_)); |
| 373 base::RunLoop().RunUntilIdle(); |
| 374 } |
| 375 |
| 376 void InitFailedSyncEventTest() { |
| 377 UseTestBackgroundSyncManager(); |
| 378 test_background_sync_manager_->set_one_shot_callback( |
| 379 base::Bind(OneShotFailedCallback, &sync_events_called_)); |
| 380 base::RunLoop().RunUntilIdle(); |
| 381 } |
| 382 |
| 383 void InitDelayedSyncEventTest() { |
| 384 UseTestBackgroundSyncManager(); |
| 385 test_background_sync_manager_->set_one_shot_callback(base::Bind( |
| 386 OneShotDelayedCallback, &sync_events_called_, &sync_fired_callback_)); |
| 387 base::RunLoop().RunUntilIdle(); |
| 388 } |
| 389 |
| 390 void RegisterAndVerifySyncEventDelayed( |
| 391 const BackgroundSyncManager::BackgroundSyncRegistration& |
| 392 sync_registration) { |
| 393 int sync_events_called = sync_events_called_; |
| 394 EXPECT_TRUE(sync_fired_callback_.is_null()); |
| 395 |
| 396 EXPECT_TRUE(Register(sync_registration)); |
| 397 |
| 398 EXPECT_EQ(sync_events_called + 1, sync_events_called_); |
| 399 EXPECT_TRUE(GetRegistration(sync_reg_1_)); |
| 400 EXPECT_FALSE(sync_fired_callback_.is_null()); |
| 401 } |
| 402 |
309 TestBrowserThreadBundle browser_thread_bundle_; | 403 TestBrowserThreadBundle browser_thread_bundle_; |
| 404 scoped_ptr<net::NetworkChangeNotifier> network_change_notifier_; |
310 scoped_ptr<EmbeddedWorkerTestHelper> helper_; | 405 scoped_ptr<EmbeddedWorkerTestHelper> helper_; |
311 scoped_ptr<BackgroundSyncManager> background_sync_manager_; | 406 scoped_ptr<BackgroundSyncManager> background_sync_manager_; |
| 407 TestBackgroundSyncManager* test_background_sync_manager_; |
312 | 408 |
313 int64 sw_registration_id_1_; | 409 int64 sw_registration_id_1_; |
314 int64 sw_registration_id_2_; | 410 int64 sw_registration_id_2_; |
315 scoped_refptr<ServiceWorkerRegistration> sw_registration_1_; | 411 scoped_refptr<ServiceWorkerRegistration> sw_registration_1_; |
316 scoped_refptr<ServiceWorkerRegistration> sw_registration_2_; | 412 scoped_refptr<ServiceWorkerRegistration> sw_registration_2_; |
317 | 413 |
318 BackgroundSyncManager::BackgroundSyncRegistration sync_reg_1_; | 414 BackgroundSyncManager::BackgroundSyncRegistration sync_reg_1_; |
319 BackgroundSyncManager::BackgroundSyncRegistration sync_reg_2_; | 415 BackgroundSyncManager::BackgroundSyncRegistration sync_reg_2_; |
320 | 416 |
321 // Callback values. | 417 // Callback values. |
322 BackgroundSyncManager::ErrorType callback_error_; | 418 BackgroundSyncManager::ErrorType callback_error_; |
323 BackgroundSyncManager::BackgroundSyncRegistration callback_registration_; | 419 BackgroundSyncManager::BackgroundSyncRegistration callback_registration_; |
324 ServiceWorkerStatusCode callback_sw_status_code_; | 420 ServiceWorkerStatusCode callback_sw_status_code_; |
| 421 int sync_events_called_; |
| 422 ServiceWorkerVersion::StatusCallback sync_fired_callback_; |
325 }; | 423 }; |
326 | 424 |
327 TEST_F(BackgroundSyncManagerTest, Register) { | 425 TEST_F(BackgroundSyncManagerTest, Register) { |
328 EXPECT_TRUE(Register(sync_reg_1_)); | 426 EXPECT_TRUE(Register(sync_reg_1_)); |
329 } | 427 } |
330 | 428 |
331 TEST_F(BackgroundSyncManagerTest, RegistractionIntact) { | 429 TEST_F(BackgroundSyncManagerTest, RegistractionIntact) { |
332 EXPECT_TRUE(Register(sync_reg_1_)); | 430 EXPECT_TRUE(Register(sync_reg_1_)); |
333 EXPECT_STREQ(sync_reg_1_.tag.c_str(), callback_registration_.tag.c_str()); | 431 EXPECT_STREQ(sync_reg_1_.tag.c_str(), callback_registration_.tag.c_str()); |
334 EXPECT_NE( | 432 EXPECT_NE( |
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
379 sync_reg_2_.periodicity = SYNC_ONE_SHOT; | 477 sync_reg_2_.periodicity = SYNC_ONE_SHOT; |
380 EXPECT_TRUE(Register(sync_reg_1_)); | 478 EXPECT_TRUE(Register(sync_reg_1_)); |
381 EXPECT_TRUE(Register(sync_reg_2_)); | 479 EXPECT_TRUE(Register(sync_reg_2_)); |
382 EXPECT_TRUE(GetRegistration(sync_reg_1_)); | 480 EXPECT_TRUE(GetRegistration(sync_reg_1_)); |
383 EXPECT_EQ(SYNC_PERIODIC, callback_registration_.periodicity); | 481 EXPECT_EQ(SYNC_PERIODIC, callback_registration_.periodicity); |
384 EXPECT_TRUE(GetRegistration(sync_reg_2_)); | 482 EXPECT_TRUE(GetRegistration(sync_reg_2_)); |
385 EXPECT_EQ(SYNC_ONE_SHOT, callback_registration_.periodicity); | 483 EXPECT_EQ(SYNC_ONE_SHOT, callback_registration_.periodicity); |
386 } | 484 } |
387 | 485 |
388 TEST_F(BackgroundSyncManagerTest, RegisterBadBackend) { | 486 TEST_F(BackgroundSyncManagerTest, RegisterBadBackend) { |
389 TestBackgroundSyncManager* manager = UseTestBackgroundSyncManager(); | 487 UseTestBackgroundSyncManager(); |
390 manager->set_corrupt_backend(true); | 488 test_background_sync_manager_->set_corrupt_backend(true); |
391 EXPECT_FALSE(Register(sync_reg_1_)); | 489 EXPECT_FALSE(Register(sync_reg_1_)); |
392 manager->set_corrupt_backend(false); | 490 test_background_sync_manager_->set_corrupt_backend(false); |
393 EXPECT_FALSE(Register(sync_reg_1_)); | 491 EXPECT_FALSE(Register(sync_reg_1_)); |
394 EXPECT_FALSE(GetRegistration(sync_reg_1_)); | 492 EXPECT_FALSE(GetRegistration(sync_reg_1_)); |
395 } | 493 } |
396 | 494 |
397 TEST_F(BackgroundSyncManagerTest, TwoRegistrations) { | 495 TEST_F(BackgroundSyncManagerTest, TwoRegistrations) { |
398 EXPECT_TRUE(Register(sync_reg_1_)); | 496 EXPECT_TRUE(Register(sync_reg_1_)); |
399 EXPECT_TRUE(Register(sync_reg_2_)); | 497 EXPECT_TRUE(Register(sync_reg_2_)); |
400 } | 498 } |
401 | 499 |
402 TEST_F(BackgroundSyncManagerTest, GetRegistrationNonExisting) { | 500 TEST_F(BackgroundSyncManagerTest, GetRegistrationNonExisting) { |
403 EXPECT_FALSE(GetRegistration(sync_reg_1_)); | 501 EXPECT_FALSE(GetRegistration(sync_reg_1_)); |
404 } | 502 } |
405 | 503 |
406 TEST_F(BackgroundSyncManagerTest, GetRegistrationExisting) { | 504 TEST_F(BackgroundSyncManagerTest, GetRegistrationExisting) { |
407 EXPECT_TRUE(Register(sync_reg_1_)); | 505 EXPECT_TRUE(Register(sync_reg_1_)); |
408 EXPECT_TRUE(GetRegistration(sync_reg_1_)); | 506 EXPECT_TRUE(GetRegistration(sync_reg_1_)); |
409 EXPECT_FALSE(GetRegistration(sync_reg_2_)); | 507 EXPECT_FALSE(GetRegistration(sync_reg_2_)); |
410 } | 508 } |
411 | 509 |
412 TEST_F(BackgroundSyncManagerTest, GetRegistrationBadBackend) { | 510 TEST_F(BackgroundSyncManagerTest, GetRegistrationBadBackend) { |
413 TestBackgroundSyncManager* manager = UseTestBackgroundSyncManager(); | 511 UseTestBackgroundSyncManager(); |
414 EXPECT_TRUE(Register(sync_reg_1_)); | 512 EXPECT_TRUE(Register(sync_reg_1_)); |
415 manager->set_corrupt_backend(true); | 513 test_background_sync_manager_->set_corrupt_backend(true); |
416 EXPECT_TRUE(GetRegistration(sync_reg_1_)); | 514 EXPECT_TRUE(GetRegistration(sync_reg_1_)); |
417 EXPECT_FALSE(Register(sync_reg_2_)); | 515 EXPECT_FALSE(Register(sync_reg_2_)); |
418 // Registration should have discovered the bad backend and disabled the | 516 // Registration should have discovered the bad backend and disabled the |
419 // BackgroundSyncManager. | 517 // BackgroundSyncManager. |
420 EXPECT_FALSE(GetRegistration(sync_reg_1_)); | 518 EXPECT_FALSE(GetRegistration(sync_reg_1_)); |
421 manager->set_corrupt_backend(false); | 519 test_background_sync_manager_->set_corrupt_backend(false); |
422 EXPECT_FALSE(GetRegistration(sync_reg_1_)); | 520 EXPECT_FALSE(GetRegistration(sync_reg_1_)); |
423 } | 521 } |
424 | 522 |
425 TEST_F(BackgroundSyncManagerTest, Unregister) { | 523 TEST_F(BackgroundSyncManagerTest, Unregister) { |
426 EXPECT_TRUE(Register(sync_reg_1_)); | 524 EXPECT_TRUE(Register(sync_reg_1_)); |
427 EXPECT_TRUE(Unregister(callback_registration_)); | 525 EXPECT_TRUE(Unregister(callback_registration_)); |
428 EXPECT_FALSE(GetRegistration(sync_reg_1_)); | 526 EXPECT_FALSE(GetRegistration(sync_reg_1_)); |
429 } | 527 } |
430 | 528 |
431 TEST_F(BackgroundSyncManagerTest, UnregisterWrongId) { | 529 TEST_F(BackgroundSyncManagerTest, UnregisterWrongId) { |
(...skipping 15 matching lines...) Expand all Loading... |
447 | 545 |
448 TEST_F(BackgroundSyncManagerTest, UnregisterSecond) { | 546 TEST_F(BackgroundSyncManagerTest, UnregisterSecond) { |
449 EXPECT_TRUE(Register(sync_reg_1_)); | 547 EXPECT_TRUE(Register(sync_reg_1_)); |
450 EXPECT_TRUE(Register(sync_reg_2_)); | 548 EXPECT_TRUE(Register(sync_reg_2_)); |
451 EXPECT_TRUE(Unregister(callback_registration_)); | 549 EXPECT_TRUE(Unregister(callback_registration_)); |
452 EXPECT_TRUE(GetRegistration(sync_reg_1_)); | 550 EXPECT_TRUE(GetRegistration(sync_reg_1_)); |
453 EXPECT_TRUE(Register(sync_reg_2_)); | 551 EXPECT_TRUE(Register(sync_reg_2_)); |
454 } | 552 } |
455 | 553 |
456 TEST_F(BackgroundSyncManagerTest, UnregisterBadBackend) { | 554 TEST_F(BackgroundSyncManagerTest, UnregisterBadBackend) { |
457 TestBackgroundSyncManager* manager = UseTestBackgroundSyncManager(); | 555 UseTestBackgroundSyncManager(); |
458 sync_reg_1_.min_period += 1; | 556 sync_reg_1_.min_period += 1; |
459 EXPECT_TRUE(Register(sync_reg_1_)); | 557 EXPECT_TRUE(Register(sync_reg_1_)); |
460 EXPECT_TRUE(Register(sync_reg_2_)); | 558 EXPECT_TRUE(Register(sync_reg_2_)); |
461 manager->set_corrupt_backend(true); | 559 test_background_sync_manager_->set_corrupt_backend(true); |
462 EXPECT_FALSE(Unregister(callback_registration_)); | 560 EXPECT_FALSE(Unregister(callback_registration_)); |
463 // Unregister should have discovered the bad backend and disabled the | 561 // Unregister should have discovered the bad backend and disabled the |
464 // BackgroundSyncManager. | 562 // BackgroundSyncManager. |
465 manager->set_corrupt_backend(false); | 563 test_background_sync_manager_->set_corrupt_backend(false); |
466 EXPECT_FALSE(GetRegistration(sync_reg_1_)); | 564 EXPECT_FALSE(GetRegistration(sync_reg_1_)); |
467 EXPECT_FALSE(GetRegistration(sync_reg_2_)); | 565 EXPECT_FALSE(GetRegistration(sync_reg_2_)); |
468 } | 566 } |
469 | 567 |
470 TEST_F(BackgroundSyncManagerTest, RegistrationIncreasesId) { | 568 TEST_F(BackgroundSyncManagerTest, RegistrationIncreasesId) { |
471 EXPECT_TRUE(Register(sync_reg_1_)); | 569 EXPECT_TRUE(Register(sync_reg_1_)); |
472 BackgroundSyncManager::BackgroundSyncRegistration registered_sync = | 570 BackgroundSyncManager::BackgroundSyncRegistration registered_sync = |
473 callback_registration_; | 571 callback_registration_; |
474 BackgroundSyncManager::BackgroundSyncRegistration::RegistrationId cur_id = | 572 BackgroundSyncManager::BackgroundSyncRegistration::RegistrationId cur_id = |
475 callback_registration_.id; | 573 callback_registration_.id; |
(...skipping 302 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
778 EXPECT_TRUE(GetRegistration(sync_reg_1_)); | 876 EXPECT_TRUE(GetRegistration(sync_reg_1_)); |
779 EXPECT_TRUE(Unregister(callback_registration_)); | 877 EXPECT_TRUE(Unregister(callback_registration_)); |
780 EXPECT_FALSE(GetRegistration(sync_reg_1_)); | 878 EXPECT_FALSE(GetRegistration(sync_reg_1_)); |
781 EXPECT_TRUE(GetRegistration(sync_reg_2_)); | 879 EXPECT_TRUE(GetRegistration(sync_reg_2_)); |
782 EXPECT_EQ(SYNC_ONE_SHOT, callback_registration_.periodicity); | 880 EXPECT_EQ(SYNC_ONE_SHOT, callback_registration_.periodicity); |
783 | 881 |
784 EXPECT_TRUE(Unregister(callback_registration_)); | 882 EXPECT_TRUE(Unregister(callback_registration_)); |
785 EXPECT_FALSE(GetRegistration(sync_reg_2_)); | 883 EXPECT_FALSE(GetRegistration(sync_reg_2_)); |
786 } | 884 } |
787 | 885 |
| 886 TEST_F(BackgroundSyncManagerTest, OneShotFiresOnRegistration) { |
| 887 InitSyncEventTest(); |
| 888 |
| 889 EXPECT_TRUE(Register(sync_reg_1_)); |
| 890 EXPECT_EQ(1, sync_events_called_); |
| 891 EXPECT_FALSE(GetRegistration(sync_reg_1_)); |
| 892 } |
| 893 |
| 894 TEST_F(BackgroundSyncManagerTest, OneShotFiresOnNetworkChange) { |
| 895 InitSyncEventTest(); |
| 896 |
| 897 SetNetwork(net::NetworkChangeNotifier::CONNECTION_NONE); |
| 898 EXPECT_TRUE(Register(sync_reg_1_)); |
| 899 EXPECT_EQ(0, sync_events_called_); |
| 900 EXPECT_TRUE(GetRegistration(sync_reg_1_)); |
| 901 |
| 902 SetNetwork(net::NetworkChangeNotifier::CONNECTION_WIFI); |
| 903 base::RunLoop().RunUntilIdle(); |
| 904 EXPECT_EQ(1, sync_events_called_); |
| 905 EXPECT_FALSE(GetRegistration(sync_reg_1_)); |
| 906 } |
| 907 |
| 908 TEST_F(BackgroundSyncManagerTest, MultipleOneShotsFireOnNetworkChange) { |
| 909 InitSyncEventTest(); |
| 910 |
| 911 SetNetwork(net::NetworkChangeNotifier::CONNECTION_NONE); |
| 912 EXPECT_TRUE(Register(sync_reg_1_)); |
| 913 EXPECT_TRUE(Register(sync_reg_2_)); |
| 914 EXPECT_EQ(0, sync_events_called_); |
| 915 EXPECT_TRUE(GetRegistration(sync_reg_1_)); |
| 916 EXPECT_TRUE(GetRegistration(sync_reg_2_)); |
| 917 |
| 918 SetNetwork(net::NetworkChangeNotifier::CONNECTION_WIFI); |
| 919 base::RunLoop().RunUntilIdle(); |
| 920 EXPECT_EQ(2, sync_events_called_); |
| 921 EXPECT_FALSE(GetRegistration(sync_reg_1_)); |
| 922 EXPECT_FALSE(GetRegistration(sync_reg_2_)); |
| 923 } |
| 924 |
| 925 TEST_F(BackgroundSyncManagerTest, OneShotFiresOnManagerRestart) { |
| 926 InitSyncEventTest(); |
| 927 |
| 928 // Initially the event won't run because there is no network. |
| 929 SetNetwork(net::NetworkChangeNotifier::CONNECTION_NONE); |
| 930 EXPECT_TRUE(Register(sync_reg_1_)); |
| 931 EXPECT_EQ(0, sync_events_called_); |
| 932 EXPECT_TRUE(GetRegistration(sync_reg_1_)); |
| 933 |
| 934 // Simulate closing the browser. |
| 935 background_sync_manager_.reset(); |
| 936 |
| 937 // The next time the manager is started, the network is good. |
| 938 SetNetwork(net::NetworkChangeNotifier::CONNECTION_WIFI); |
| 939 InitSyncEventTest(); |
| 940 |
| 941 // The event should have fired. |
| 942 EXPECT_EQ(1, sync_events_called_); |
| 943 EXPECT_FALSE(GetRegistration(sync_reg_1_)); |
| 944 } |
| 945 |
| 946 TEST_F(BackgroundSyncManagerTest, FailedOneShotStillExists) { |
| 947 InitFailedSyncEventTest(); |
| 948 |
| 949 EXPECT_TRUE(Register(sync_reg_1_)); |
| 950 EXPECT_EQ(1, sync_events_called_); |
| 951 EXPECT_TRUE(GetRegistration(sync_reg_1_)); |
| 952 |
| 953 // The failed one-shot should stay registered but not fire until the |
| 954 // ServiceWorker is reloaded with an active client. Therefore, changing the |
| 955 // network should not cause the event to run again. |
| 956 SetNetwork(net::NetworkChangeNotifier::CONNECTION_2G); |
| 957 EXPECT_EQ(1, sync_events_called_); |
| 958 EXPECT_TRUE(GetRegistration(sync_reg_1_)); |
| 959 } |
| 960 |
| 961 TEST_F(BackgroundSyncManagerTest, DelayOneShotMidSync) { |
| 962 InitDelayedSyncEventTest(); |
| 963 |
| 964 RegisterAndVerifySyncEventDelayed(sync_reg_1_); |
| 965 |
| 966 // Finish firing the event and verify that the registration is removed. |
| 967 sync_fired_callback_.Run(SERVICE_WORKER_OK); |
| 968 base::RunLoop().RunUntilIdle(); |
| 969 EXPECT_EQ(1, sync_events_called_); |
| 970 EXPECT_FALSE(GetRegistration(sync_reg_1_)); |
| 971 } |
| 972 |
| 973 TEST_F(BackgroundSyncManagerTest, OverwriteRegistrationMidSync) { |
| 974 InitDelayedSyncEventTest(); |
| 975 |
| 976 sync_reg_1_.network_state = NETWORK_STATE_ANY; |
| 977 SetNetwork(net::NetworkChangeNotifier::CONNECTION_NONE); |
| 978 |
| 979 RegisterAndVerifySyncEventDelayed(sync_reg_1_); |
| 980 |
| 981 // Don't delay the next sync. |
| 982 test_background_sync_manager_->set_one_shot_callback( |
| 983 base::Bind(OneShotSuccessfulCallback, &sync_events_called_)); |
| 984 |
| 985 // Register a different sync event with the same tag, overwriting the first. |
| 986 sync_reg_1_.network_state = NETWORK_STATE_ONLINE; |
| 987 EXPECT_TRUE(Register(sync_reg_1_)); |
| 988 |
| 989 // The new sync event won't run as the network requirements aren't met. |
| 990 EXPECT_EQ(1, sync_events_called_); |
| 991 EXPECT_TRUE(GetRegistration(sync_reg_1_)); |
| 992 |
| 993 // Finish the first event, note that the second is still registered. |
| 994 sync_fired_callback_.Run(SERVICE_WORKER_OK); |
| 995 EXPECT_EQ(1, sync_events_called_); |
| 996 EXPECT_TRUE(GetRegistration(sync_reg_1_)); |
| 997 |
| 998 // Change the network and the second should run. |
| 999 SetNetwork(net::NetworkChangeNotifier::CONNECTION_WIFI); |
| 1000 base::RunLoop().RunUntilIdle(); |
| 1001 EXPECT_EQ(2, sync_events_called_); |
| 1002 EXPECT_FALSE(GetRegistration(sync_reg_1_)); |
| 1003 } |
| 1004 |
| 1005 TEST_F(BackgroundSyncManagerTest, ReregisterOneShotMidSync) { |
| 1006 InitDelayedSyncEventTest(); |
| 1007 |
| 1008 RegisterAndVerifySyncEventDelayed(sync_reg_1_); |
| 1009 |
| 1010 // Register the same sync, but don't delay it. It shouldn't run as it's |
| 1011 // already firing. |
| 1012 test_background_sync_manager_->set_one_shot_callback( |
| 1013 base::Bind(OneShotSuccessfulCallback, &sync_events_called_)); |
| 1014 EXPECT_TRUE(Register(sync_reg_1_)); |
| 1015 EXPECT_EQ(1, sync_events_called_); |
| 1016 EXPECT_TRUE(GetRegistration(sync_reg_1_)); |
| 1017 |
| 1018 // Finish the original event, note that the second never runs. |
| 1019 sync_fired_callback_.Run(SERVICE_WORKER_OK); |
| 1020 base::RunLoop().RunUntilIdle(); |
| 1021 EXPECT_EQ(1, sync_events_called_); |
| 1022 EXPECT_FALSE(GetRegistration(sync_reg_1_)); |
| 1023 } |
| 1024 |
| 1025 TEST_F(BackgroundSyncManagerTest, UnregisterOneShotMidSync) { |
| 1026 InitDelayedSyncEventTest(); |
| 1027 |
| 1028 RegisterAndVerifySyncEventDelayed(sync_reg_1_); |
| 1029 |
| 1030 EXPECT_TRUE(Unregister(callback_registration_)); |
| 1031 EXPECT_FALSE(GetRegistration(sync_reg_1_)); |
| 1032 |
| 1033 sync_fired_callback_.Run(SERVICE_WORKER_OK); |
| 1034 EXPECT_FALSE(GetRegistration(sync_reg_1_)); |
| 1035 } |
| 1036 |
| 1037 TEST_F(BackgroundSyncManagerTest, BadBackendMidSync) { |
| 1038 InitDelayedSyncEventTest(); |
| 1039 |
| 1040 RegisterAndVerifySyncEventDelayed(sync_reg_1_); |
| 1041 |
| 1042 test_background_sync_manager_->set_corrupt_backend(true); |
| 1043 sync_fired_callback_.Run(SERVICE_WORKER_OK); |
| 1044 base::RunLoop().RunUntilIdle(); |
| 1045 |
| 1046 // The backend should now be disabled because it couldn't unregister the |
| 1047 // one-shot. |
| 1048 EXPECT_FALSE(Register(sync_reg_2_)); |
| 1049 EXPECT_FALSE(RegisterWithServiceWorkerId(sw_registration_id_2_, sync_reg_2_)); |
| 1050 } |
| 1051 |
| 1052 TEST_F(BackgroundSyncManagerTest, UnregisterServiceWorkerMidSync) { |
| 1053 InitDelayedSyncEventTest(); |
| 1054 |
| 1055 RegisterAndVerifySyncEventDelayed(sync_reg_1_); |
| 1056 UnregisterServiceWorker(sw_registration_id_1_); |
| 1057 |
| 1058 sync_fired_callback_.Run(SERVICE_WORKER_OK); |
| 1059 |
| 1060 // The backend isn't disabled, but the first service worker registration is |
| 1061 // gone. |
| 1062 EXPECT_FALSE(GetRegistration(sync_reg_1_)); |
| 1063 EXPECT_FALSE(Register(sync_reg_1_)); |
| 1064 EXPECT_TRUE(RegisterWithServiceWorkerId(sw_registration_id_2_, sync_reg_1_)); |
| 1065 } |
| 1066 |
| 1067 TEST_F(BackgroundSyncManagerTest, KillManagerMidSync) { |
| 1068 InitDelayedSyncEventTest(); |
| 1069 |
| 1070 RegisterAndVerifySyncEventDelayed(sync_reg_1_); |
| 1071 |
| 1072 // Create a new manager which should fire the sync again on init. |
| 1073 InitSyncEventTest(); |
| 1074 EXPECT_FALSE(GetRegistration(sync_reg_1_)); |
| 1075 EXPECT_EQ(2, sync_events_called_); |
| 1076 } |
| 1077 |
788 } // namespace content | 1078 } // namespace content |
OLD | NEW |