Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(1916)

Side by Side Diff: content/browser/background_sync/background_sync_manager.cc

Issue 1763123002: [BackgroundSync] Remove BackgroundSyncRegistrationHandle (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Address comments from PS6 Created 4 years, 9 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
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 <utility> 7 #include <utility>
8 8
9 #include "base/barrier_closure.h" 9 #include "base/barrier_closure.h"
10 #include "base/bind.h" 10 #include "base/bind.h"
11 #include "base/location.h" 11 #include "base/location.h"
12 #include "base/single_thread_task_runner.h" 12 #include "base/single_thread_task_runner.h"
13 #include "base/thread_task_runner_handle.h" 13 #include "base/thread_task_runner_handle.h"
14 #include "base/time/default_clock.h" 14 #include "base/time/default_clock.h"
15 #include "build/build_config.h" 15 #include "build/build_config.h"
16 #include "content/browser/background_sync/background_sync_metrics.h" 16 #include "content/browser/background_sync/background_sync_metrics.h"
17 #include "content/browser/background_sync/background_sync_network_observer.h" 17 #include "content/browser/background_sync/background_sync_network_observer.h"
18 #include "content/browser/background_sync/background_sync_registration_handle.h"
19 #include "content/browser/background_sync/background_sync_registration_options.h " 18 #include "content/browser/background_sync/background_sync_registration_options.h "
20 #include "content/browser/service_worker/service_worker_context_wrapper.h" 19 #include "content/browser/service_worker/service_worker_context_wrapper.h"
21 #include "content/browser/service_worker/service_worker_storage.h" 20 #include "content/browser/service_worker/service_worker_storage.h"
22 #include "content/browser/storage_partition_impl.h" 21 #include "content/browser/storage_partition_impl.h"
23 #include "content/common/service_worker/service_worker_type_converters.h" 22 #include "content/common/service_worker/service_worker_type_converters.h"
24 #include "content/public/browser/background_sync_controller.h" 23 #include "content/public/browser/background_sync_controller.h"
25 #include "content/public/browser/browser_context.h" 24 #include "content/public/browser/browser_context.h"
26 #include "content/public/browser/browser_thread.h" 25 #include "content/public/browser/browser_thread.h"
27 #include "content/public/common/background_sync.mojom.h" 26 #include "content/public/common/background_sync.mojom.h"
28 27
29 #if defined(OS_ANDROID) 28 #if defined(OS_ANDROID)
30 #include "content/browser/android/background_sync_network_observer_android.h" 29 #include "content/browser/android/background_sync_network_observer_android.h"
31 #endif 30 #endif
32 31
33 namespace content { 32 namespace content {
34 33
35 class BackgroundSyncManager::RefCountedRegistration
36 : public base::RefCounted<RefCountedRegistration> {
37 public:
38 BackgroundSyncRegistration* value() { return &registration_; }
39 const BackgroundSyncRegistration* value() const { return &registration_; }
40
41 private:
42 friend class base::RefCounted<RefCountedRegistration>;
43 ~RefCountedRegistration() = default;
44
45 BackgroundSyncRegistration registration_;
46 };
47
48 namespace { 34 namespace {
49 35
50 // The key used to index the background sync data in ServiceWorkerStorage. 36 // The key used to index the background sync data in ServiceWorkerStorage.
51 const char kBackgroundSyncUserDataKey[] = "BackgroundSyncUserData"; 37 const char kBackgroundSyncUserDataKey[] = "BackgroundSyncUserData";
52 38
53 void PostErrorResponse( 39 void PostErrorResponse(
54 BackgroundSyncStatus status, 40 BackgroundSyncStatus status,
55 const BackgroundSyncManager::StatusAndRegistrationCallback& callback) { 41 const BackgroundSyncManager::StatusAndRegistrationCallback& callback) {
56 base::ThreadTaskRunnerHandle::Get()->PostTask( 42 base::ThreadTaskRunnerHandle::Get()->PostTask(
57 FROM_HERE, 43 FROM_HERE,
58 base::Bind(callback, status, 44 base::Bind(callback, status,
59 base::Passed(scoped_ptr<BackgroundSyncRegistrationHandle>()))); 45 base::Passed(scoped_ptr<BackgroundSyncRegistration>())));
60 } 46 }
61 47
62 // Returns nullptr if the controller cannot be accessed for any reason. 48 // Returns nullptr if the controller cannot be accessed for any reason.
63 BackgroundSyncController* GetBackgroundSyncControllerOnUIThread( 49 BackgroundSyncController* GetBackgroundSyncControllerOnUIThread(
64 const scoped_refptr<ServiceWorkerContextWrapper>& service_worker_context) { 50 const scoped_refptr<ServiceWorkerContextWrapper>& service_worker_context) {
65 DCHECK_CURRENTLY_ON(BrowserThread::UI); 51 DCHECK_CURRENTLY_ON(BrowserThread::UI);
66 52
67 if (!service_worker_context) 53 if (!service_worker_context)
68 return nullptr; 54 return nullptr;
69 StoragePartitionImpl* storage_partition_impl = 55 StoragePartitionImpl* storage_partition_impl =
(...skipping 139 matching lines...) Expand 10 before | Expand all | Expand 10 after
209 void BackgroundSyncManager::GetRegistrations( 195 void BackgroundSyncManager::GetRegistrations(
210 int64_t sw_registration_id, 196 int64_t sw_registration_id,
211 const StatusAndRegistrationsCallback& callback) { 197 const StatusAndRegistrationsCallback& callback) {
212 DCHECK_CURRENTLY_ON(BrowserThread::IO); 198 DCHECK_CURRENTLY_ON(BrowserThread::IO);
213 199
214 if (disabled_) { 200 if (disabled_) {
215 base::ThreadTaskRunnerHandle::Get()->PostTask( 201 base::ThreadTaskRunnerHandle::Get()->PostTask(
216 FROM_HERE, 202 FROM_HERE,
217 base::Bind( 203 base::Bind(
218 callback, BACKGROUND_SYNC_STATUS_STORAGE_ERROR, 204 callback, BACKGROUND_SYNC_STATUS_STORAGE_ERROR,
219 base::Passed( 205 base::Passed(scoped_ptr<ScopedVector<BackgroundSyncRegistration>>(
220 scoped_ptr<ScopedVector<BackgroundSyncRegistrationHandle>>( 206 new ScopedVector<BackgroundSyncRegistration>()))));
221 new ScopedVector<BackgroundSyncRegistrationHandle>()))));
222 return; 207 return;
223 } 208 }
224 209
225 op_scheduler_.ScheduleOperation( 210 op_scheduler_.ScheduleOperation(
226 base::Bind(&BackgroundSyncManager::GetRegistrationsImpl, 211 base::Bind(&BackgroundSyncManager::GetRegistrationsImpl,
227 weak_ptr_factory_.GetWeakPtr(), sw_registration_id, 212 weak_ptr_factory_.GetWeakPtr(), sw_registration_id,
228 MakeStatusAndRegistrationsCompletion(callback))); 213 MakeStatusAndRegistrationsCompletion(callback)));
229 } 214 }
230 215
231 // Given a HandleId |handle_id|, return a new handle for the same
232 // registration.
233 scoped_ptr<BackgroundSyncRegistrationHandle>
234 BackgroundSyncManager::DuplicateRegistrationHandle(
235 BackgroundSyncRegistrationHandle::HandleId handle_id) {
236 DCHECK_CURRENTLY_ON(BrowserThread::IO);
237
238 scoped_refptr<RefCountedRegistration>* ref_registration =
239 registration_handle_ids_.Lookup(handle_id);
240 if (!ref_registration)
241 return scoped_ptr<BackgroundSyncRegistrationHandle>();
242 return CreateRegistrationHandle(ref_registration->get());
243 }
244
245 void BackgroundSyncManager::OnRegistrationDeleted(int64_t sw_registration_id, 216 void BackgroundSyncManager::OnRegistrationDeleted(int64_t sw_registration_id,
246 const GURL& pattern) { 217 const GURL& pattern) {
247 DCHECK_CURRENTLY_ON(BrowserThread::IO); 218 DCHECK_CURRENTLY_ON(BrowserThread::IO);
248 219
249 // Operations already in the queue will either fail when they write to storage 220 // Operations already in the queue will either fail when they write to storage
250 // or return stale results based on registrations loaded in memory. This is 221 // or return stale results based on registrations loaded in memory. This is
251 // inconsequential since the service worker is gone. 222 // inconsequential since the service worker is gone.
252 op_scheduler_.ScheduleOperation( 223 op_scheduler_.ScheduleOperation(
253 base::Bind(&BackgroundSyncManager::OnRegistrationDeletedImpl, 224 base::Bind(&BackgroundSyncManager::OnRegistrationDeletedImpl,
254 weak_ptr_factory_.GetWeakPtr(), sw_registration_id, 225 weak_ptr_factory_.GetWeakPtr(), sw_registration_id,
(...skipping 116 matching lines...) Expand 10 before | Expand all | Expand 10 after
371 const BackgroundSyncRegistrationProto& registration_proto = 342 const BackgroundSyncRegistrationProto& registration_proto =
372 registrations_proto.registration(i); 343 registrations_proto.registration(i);
373 344
374 if (registration_proto.id() >= registrations->next_id) { 345 if (registration_proto.id() >= registrations->next_id) {
375 corruption_detected = true; 346 corruption_detected = true;
376 break; 347 break;
377 } 348 }
378 349
379 RegistrationKey registration_key(registration_proto.tag()); 350 RegistrationKey registration_key(registration_proto.tag());
380 351
381 scoped_refptr<RefCountedRegistration> ref_registration( 352 BackgroundSyncRegistration* registration =
382 new RefCountedRegistration()); 353 &registrations->registration_map[registration_key];
383 registrations->registration_map[registration_key] = ref_registration;
384 BackgroundSyncRegistration* registration = ref_registration->value();
385 354
386 BackgroundSyncRegistrationOptions* options = registration->options(); 355 BackgroundSyncRegistrationOptions* options = registration->options();
387 options->tag = registration_proto.tag(); 356 options->tag = registration_proto.tag();
388 options->network_state = registration_proto.network_state(); 357 options->network_state = registration_proto.network_state();
389 358
390 registration->set_id(registration_proto.id()); 359 registration->set_id(registration_proto.id());
391 registration->set_num_attempts(registration_proto.num_attempts()); 360 registration->set_num_attempts(registration_proto.num_attempts());
392 registration->set_delay_until( 361 registration->set_delay_until(
393 base::Time::FromInternalValue(registration_proto.delay_until())); 362 base::Time::FromInternalValue(registration_proto.delay_until()));
394 } 363 }
(...skipping 80 matching lines...) Expand 10 before | Expand all | Expand 10 after
475 BACKGROUND_SYNC_STATUS_NO_SERVICE_WORKER); 444 BACKGROUND_SYNC_STATUS_NO_SERVICE_WORKER);
476 PostErrorResponse(BACKGROUND_SYNC_STATUS_NO_SERVICE_WORKER, callback); 445 PostErrorResponse(BACKGROUND_SYNC_STATUS_NO_SERVICE_WORKER, callback);
477 return; 446 return;
478 } 447 }
479 448
480 BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, 449 BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
481 base::Bind(&NotifyBackgroundSyncRegisteredOnUIThread, 450 base::Bind(&NotifyBackgroundSyncRegisteredOnUIThread,
482 service_worker_context_, 451 service_worker_context_,
483 sw_registration->pattern().GetOrigin())); 452 sw_registration->pattern().GetOrigin()));
484 453
485 RefCountedRegistration* existing_registration_ref = 454 BackgroundSyncRegistration* existing_registration =
486 LookupActiveRegistration(sw_registration_id, RegistrationKey(options)); 455 LookupActiveRegistration(sw_registration_id, RegistrationKey(options));
487 if (existing_registration_ref) { 456 if (existing_registration) {
488 DCHECK(existing_registration_ref->value()->options()->Equals(options)); 457 DCHECK(existing_registration->options()->Equals(options));
489 BackgroundSyncRegistration* existing_registration =
490 existing_registration_ref->value();
491 458
492 BackgroundSyncMetrics::RegistrationCouldFire registration_could_fire = 459 BackgroundSyncMetrics::RegistrationCouldFire registration_could_fire =
493 AreOptionConditionsMet(options) 460 AreOptionConditionsMet(options)
494 ? BackgroundSyncMetrics::REGISTRATION_COULD_FIRE 461 ? BackgroundSyncMetrics::REGISTRATION_COULD_FIRE
495 : BackgroundSyncMetrics::REGISTRATION_COULD_NOT_FIRE; 462 : BackgroundSyncMetrics::REGISTRATION_COULD_NOT_FIRE;
496 BackgroundSyncMetrics::CountRegisterSuccess( 463 BackgroundSyncMetrics::CountRegisterSuccess(
497 registration_could_fire, 464 registration_could_fire,
498 BackgroundSyncMetrics::REGISTRATION_IS_DUPLICATE); 465 BackgroundSyncMetrics::REGISTRATION_IS_DUPLICATE);
499 466
500 if (existing_registration->IsFiring()) { 467 if (existing_registration->IsFiring()) {
501 existing_registration->set_sync_state( 468 existing_registration->set_sync_state(
502 BackgroundSyncState::REREGISTERED_WHILE_FIRING); 469 BackgroundSyncState::REREGISTERED_WHILE_FIRING);
503 } 470 }
504 471
472 scoped_ptr<BackgroundSyncRegistration> out_registration(
473 new BackgroundSyncRegistration(*existing_registration));
474
505 base::ThreadTaskRunnerHandle::Get()->PostTask( 475 base::ThreadTaskRunnerHandle::Get()->PostTask(
506 FROM_HERE, 476 FROM_HERE, base::Bind(callback, BACKGROUND_SYNC_STATUS_OK,
507 base::Bind( 477 base::Passed(std::move(out_registration))));
iclelland 2016/03/11 14:50:12 nit: More succinct as base::Passed(make_scoped_p
jkarlin 2016/03/15 12:50:16 Done.
508 callback, BACKGROUND_SYNC_STATUS_OK,
509 base::Passed(CreateRegistrationHandle(existing_registration_ref))));
510 return; 478 return;
511 } 479 }
512 480
513 scoped_refptr<RefCountedRegistration> new_ref_registration( 481 BackgroundSyncRegistration new_registration;
514 new RefCountedRegistration());
515 BackgroundSyncRegistration* new_registration = new_ref_registration->value();
516 482
517 *new_registration->options() = options; 483 *new_registration.options() = options;
518 484
519 BackgroundSyncRegistrations* registrations = 485 BackgroundSyncRegistrations* registrations =
520 &active_registrations_[sw_registration_id]; 486 &active_registrations_[sw_registration_id];
521 new_registration->set_id(registrations->next_id++); 487 new_registration.set_id(registrations->next_id++);
522 488
523 AddActiveRegistration(sw_registration_id, 489 AddActiveRegistration(sw_registration_id,
524 sw_registration->pattern().GetOrigin(), 490 sw_registration->pattern().GetOrigin(),
525 new_ref_registration); 491 new_registration);
526 492
527 StoreRegistrations( 493 StoreRegistrations(
528 sw_registration_id, 494 sw_registration_id,
529 base::Bind(&BackgroundSyncManager::RegisterDidStore, 495 base::Bind(&BackgroundSyncManager::RegisterDidStore,
530 weak_ptr_factory_.GetWeakPtr(), sw_registration_id, 496 weak_ptr_factory_.GetWeakPtr(), sw_registration_id,
531 new_ref_registration, callback)); 497 new_registration, callback));
532 } 498 }
533 499
534 void BackgroundSyncManager::DisableAndClearManager( 500 void BackgroundSyncManager::DisableAndClearManager(
535 const base::Closure& callback) { 501 const base::Closure& callback) {
536 DCHECK_CURRENTLY_ON(BrowserThread::IO); 502 DCHECK_CURRENTLY_ON(BrowserThread::IO);
537 503
538 if (disabled_) { 504 if (disabled_) {
539 base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, 505 base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
540 base::Bind(callback)); 506 base::Bind(callback));
541 return; 507 return;
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after
580 void BackgroundSyncManager::DisableAndClearManagerClearedOne( 546 void BackgroundSyncManager::DisableAndClearManagerClearedOne(
581 const base::Closure& barrier_closure, 547 const base::Closure& barrier_closure,
582 ServiceWorkerStatusCode status) { 548 ServiceWorkerStatusCode status) {
583 DCHECK_CURRENTLY_ON(BrowserThread::IO); 549 DCHECK_CURRENTLY_ON(BrowserThread::IO);
584 550
585 // The status doesn't matter at this point, there is nothing else to be done. 551 // The status doesn't matter at this point, there is nothing else to be done.
586 base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, 552 base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
587 base::Bind(barrier_closure)); 553 base::Bind(barrier_closure));
588 } 554 }
589 555
590 BackgroundSyncManager::RefCountedRegistration* 556 BackgroundSyncRegistration* BackgroundSyncManager::LookupActiveRegistration(
591 BackgroundSyncManager::LookupActiveRegistration(
592 int64_t sw_registration_id, 557 int64_t sw_registration_id,
593 const RegistrationKey& registration_key) { 558 const RegistrationKey& registration_key) {
594 DCHECK_CURRENTLY_ON(BrowserThread::IO); 559 DCHECK_CURRENTLY_ON(BrowserThread::IO);
595 560
596 SWIdToRegistrationsMap::iterator it = 561 SWIdToRegistrationsMap::iterator it =
597 active_registrations_.find(sw_registration_id); 562 active_registrations_.find(sw_registration_id);
598 if (it == active_registrations_.end()) 563 if (it == active_registrations_.end())
599 return nullptr; 564 return nullptr;
600 565
601 BackgroundSyncRegistrations& registrations = it->second; 566 BackgroundSyncRegistrations& registrations = it->second;
602 DCHECK_LE(BackgroundSyncRegistration::kInitialId, registrations.next_id); 567 DCHECK_LE(BackgroundSyncRegistration::kInitialId, registrations.next_id);
603 DCHECK(!registrations.origin.is_empty()); 568 DCHECK(!registrations.origin.is_empty());
604 569
605 auto key_and_registration_iter = 570 auto key_and_registration_iter =
606 registrations.registration_map.find(registration_key); 571 registrations.registration_map.find(registration_key);
607 if (key_and_registration_iter == registrations.registration_map.end()) 572 if (key_and_registration_iter == registrations.registration_map.end())
608 return nullptr; 573 return nullptr;
609 574
610 return key_and_registration_iter->second.get(); 575 return &key_and_registration_iter->second;
611 } 576 }
612 577
613 void BackgroundSyncManager::StoreRegistrations( 578 void BackgroundSyncManager::StoreRegistrations(
614 int64_t sw_registration_id, 579 int64_t sw_registration_id,
615 const ServiceWorkerStorage::StatusCallback& callback) { 580 const ServiceWorkerStorage::StatusCallback& callback) {
616 DCHECK_CURRENTLY_ON(BrowserThread::IO); 581 DCHECK_CURRENTLY_ON(BrowserThread::IO);
617 582
618 // Serialize the data. 583 // Serialize the data.
619 const BackgroundSyncRegistrations& registrations = 584 const BackgroundSyncRegistrations& registrations =
620 active_registrations_[sw_registration_id]; 585 active_registrations_[sw_registration_id];
621 BackgroundSyncRegistrationsProto registrations_proto; 586 BackgroundSyncRegistrationsProto registrations_proto;
622 registrations_proto.set_next_registration_id(registrations.next_id); 587 registrations_proto.set_next_registration_id(registrations.next_id);
623 registrations_proto.set_origin(registrations.origin.spec()); 588 registrations_proto.set_origin(registrations.origin.spec());
624 589
625 for (const auto& key_and_registration : registrations.registration_map) { 590 for (const auto& key_and_registration : registrations.registration_map) {
626 const BackgroundSyncRegistration& registration = 591 const BackgroundSyncRegistration& registration =
627 *key_and_registration.second->value(); 592 key_and_registration.second;
628 BackgroundSyncRegistrationProto* registration_proto = 593 BackgroundSyncRegistrationProto* registration_proto =
629 registrations_proto.add_registration(); 594 registrations_proto.add_registration();
630 registration_proto->set_id(registration.id()); 595 registration_proto->set_id(registration.id());
631 registration_proto->set_tag(registration.options()->tag); 596 registration_proto->set_tag(registration.options()->tag);
632 registration_proto->set_network_state( 597 registration_proto->set_network_state(
633 registration.options()->network_state); 598 registration.options()->network_state);
634 registration_proto->set_num_attempts(registration.num_attempts()); 599 registration_proto->set_num_attempts(registration.num_attempts());
635 registration_proto->set_delay_until( 600 registration_proto->set_delay_until(
636 registration.delay_until().ToInternalValue()); 601 registration.delay_until().ToInternalValue());
637 } 602 }
638 std::string serialized; 603 std::string serialized;
639 bool success = registrations_proto.SerializeToString(&serialized); 604 bool success = registrations_proto.SerializeToString(&serialized);
640 DCHECK(success); 605 DCHECK(success);
641 606
642 StoreDataInBackend(sw_registration_id, registrations.origin, 607 StoreDataInBackend(sw_registration_id, registrations.origin,
643 kBackgroundSyncUserDataKey, serialized, callback); 608 kBackgroundSyncUserDataKey, serialized, callback);
644 } 609 }
645 610
646 void BackgroundSyncManager::RegisterDidStore( 611 void BackgroundSyncManager::RegisterDidStore(
647 int64_t sw_registration_id, 612 int64_t sw_registration_id,
648 const scoped_refptr<RefCountedRegistration>& new_registration_ref, 613 const BackgroundSyncRegistration& new_registration,
649 const StatusAndRegistrationCallback& callback, 614 const StatusAndRegistrationCallback& callback,
650 ServiceWorkerStatusCode status) { 615 ServiceWorkerStatusCode status) {
651 DCHECK_CURRENTLY_ON(BrowserThread::IO); 616 DCHECK_CURRENTLY_ON(BrowserThread::IO);
652 617
653 const BackgroundSyncRegistration* new_registration =
654 new_registration_ref->value();
655
656 if (status == SERVICE_WORKER_ERROR_NOT_FOUND) { 618 if (status == SERVICE_WORKER_ERROR_NOT_FOUND) {
657 // The service worker registration is gone. 619 // The service worker registration is gone.
658 BackgroundSyncMetrics::CountRegisterFailure( 620 BackgroundSyncMetrics::CountRegisterFailure(
659 BACKGROUND_SYNC_STATUS_STORAGE_ERROR); 621 BACKGROUND_SYNC_STATUS_STORAGE_ERROR);
660 active_registrations_.erase(sw_registration_id); 622 active_registrations_.erase(sw_registration_id);
661 PostErrorResponse(BACKGROUND_SYNC_STATUS_STORAGE_ERROR, callback); 623 PostErrorResponse(BACKGROUND_SYNC_STATUS_STORAGE_ERROR, callback);
662 return; 624 return;
663 } 625 }
664 626
665 if (status != SERVICE_WORKER_OK) { 627 if (status != SERVICE_WORKER_OK) {
666 LOG(ERROR) << "BackgroundSync failed to store registration due to backend " 628 LOG(ERROR) << "BackgroundSync failed to store registration due to backend "
667 "failure."; 629 "failure.";
668 BackgroundSyncMetrics::CountRegisterFailure( 630 BackgroundSyncMetrics::CountRegisterFailure(
669 BACKGROUND_SYNC_STATUS_STORAGE_ERROR); 631 BACKGROUND_SYNC_STATUS_STORAGE_ERROR);
670 DisableAndClearManager(base::Bind( 632 DisableAndClearManager(
671 callback, BACKGROUND_SYNC_STATUS_STORAGE_ERROR, 633 base::Bind(callback, BACKGROUND_SYNC_STATUS_STORAGE_ERROR,
672 base::Passed(scoped_ptr<BackgroundSyncRegistrationHandle>()))); 634 base::Passed(scoped_ptr<BackgroundSyncRegistration>())));
673 return; 635 return;
674 } 636 }
675 637
676 BackgroundSyncMetrics::RegistrationCouldFire registration_could_fire = 638 BackgroundSyncMetrics::RegistrationCouldFire registration_could_fire =
677 AreOptionConditionsMet(*new_registration->options()) 639 AreOptionConditionsMet(*new_registration.options())
678 ? BackgroundSyncMetrics::REGISTRATION_COULD_FIRE 640 ? BackgroundSyncMetrics::REGISTRATION_COULD_FIRE
679 : BackgroundSyncMetrics::REGISTRATION_COULD_NOT_FIRE; 641 : BackgroundSyncMetrics::REGISTRATION_COULD_NOT_FIRE;
680 BackgroundSyncMetrics::CountRegisterSuccess( 642 BackgroundSyncMetrics::CountRegisterSuccess(
681 registration_could_fire, 643 registration_could_fire,
682 BackgroundSyncMetrics::REGISTRATION_IS_NOT_DUPLICATE); 644 BackgroundSyncMetrics::REGISTRATION_IS_NOT_DUPLICATE);
683 645
684 FireReadyEvents(); 646 FireReadyEvents();
647
648 scoped_ptr<BackgroundSyncRegistration> out_registration(
649 new BackgroundSyncRegistration(new_registration));
650
685 base::ThreadTaskRunnerHandle::Get()->PostTask( 651 base::ThreadTaskRunnerHandle::Get()->PostTask(
686 FROM_HERE, 652 FROM_HERE, base::Bind(callback, BACKGROUND_SYNC_STATUS_OK,
687 base::Bind( 653 base::Passed(std::move(out_registration))));
iclelland 2016/03/11 14:50:12 Same as above (do we need the name out_registratio
jkarlin 2016/03/15 12:50:16 Done.
688 callback, BACKGROUND_SYNC_STATUS_OK,
689 base::Passed(CreateRegistrationHandle(new_registration_ref.get()))));
690 } 654 }
691 655
692 void BackgroundSyncManager::RemoveActiveRegistration( 656 void BackgroundSyncManager::RemoveActiveRegistration(
693 int64_t sw_registration_id, 657 int64_t sw_registration_id,
694 const RegistrationKey& registration_key) { 658 const RegistrationKey& registration_key) {
695 DCHECK_CURRENTLY_ON(BrowserThread::IO); 659 DCHECK_CURRENTLY_ON(BrowserThread::IO);
696 DCHECK(LookupActiveRegistration(sw_registration_id, registration_key)); 660 DCHECK(LookupActiveRegistration(sw_registration_id, registration_key));
697 661
698 BackgroundSyncRegistrations* registrations = 662 BackgroundSyncRegistrations* registrations =
699 &active_registrations_[sw_registration_id]; 663 &active_registrations_[sw_registration_id];
700 664
701 registrations->registration_map.erase(registration_key); 665 registrations->registration_map.erase(registration_key);
702 } 666 }
703 667
704 void BackgroundSyncManager::AddActiveRegistration( 668 void BackgroundSyncManager::AddActiveRegistration(
705 int64_t sw_registration_id, 669 int64_t sw_registration_id,
706 const GURL& origin, 670 const GURL& origin,
707 const scoped_refptr<RefCountedRegistration>& sync_registration) { 671 const BackgroundSyncRegistration& sync_registration) {
708 DCHECK_CURRENTLY_ON(BrowserThread::IO); 672 DCHECK_CURRENTLY_ON(BrowserThread::IO);
709 DCHECK(sync_registration->value()->IsValid()); 673 DCHECK(sync_registration.IsValid());
710 674
711 BackgroundSyncRegistrations* registrations = 675 BackgroundSyncRegistrations* registrations =
712 &active_registrations_[sw_registration_id]; 676 &active_registrations_[sw_registration_id];
713 registrations->origin = origin; 677 registrations->origin = origin;
714 678
715 RegistrationKey registration_key(*sync_registration->value()); 679 RegistrationKey registration_key(sync_registration);
716 registrations->registration_map[registration_key] = sync_registration; 680 registrations->registration_map[registration_key] = sync_registration;
717 } 681 }
718 682
719 void BackgroundSyncManager::StoreDataInBackend( 683 void BackgroundSyncManager::StoreDataInBackend(
720 int64_t sw_registration_id, 684 int64_t sw_registration_id,
721 const GURL& origin, 685 const GURL& origin,
722 const std::string& backend_key, 686 const std::string& backend_key,
723 const std::string& data, 687 const std::string& data,
724 const ServiceWorkerStorage::StatusCallback& callback) { 688 const ServiceWorkerStorage::StatusCallback& callback) {
725 DCHECK_CURRENTLY_ON(BrowserThread::IO); 689 DCHECK_CURRENTLY_ON(BrowserThread::IO);
726 690
727 service_worker_context_->StoreRegistrationUserData( 691 service_worker_context_->StoreRegistrationUserData(
728 sw_registration_id, origin, backend_key, data, callback); 692 sw_registration_id, origin, backend_key, data, callback);
729 } 693 }
730 694
731 void BackgroundSyncManager::GetDataFromBackend( 695 void BackgroundSyncManager::GetDataFromBackend(
732 const std::string& backend_key, 696 const std::string& backend_key,
733 const ServiceWorkerStorage::GetUserDataForAllRegistrationsCallback& 697 const ServiceWorkerStorage::GetUserDataForAllRegistrationsCallback&
734 callback) { 698 callback) {
735 DCHECK_CURRENTLY_ON(BrowserThread::IO); 699 DCHECK_CURRENTLY_ON(BrowserThread::IO);
736 700
737 service_worker_context_->GetUserDataForAllRegistrations(backend_key, 701 service_worker_context_->GetUserDataForAllRegistrations(backend_key,
738 callback); 702 callback);
739 } 703 }
740 704
741 void BackgroundSyncManager::DispatchSyncEvent( 705 void BackgroundSyncManager::DispatchSyncEvent(
742 BackgroundSyncRegistrationHandle::HandleId handle_id, 706 const std::string& tag,
743 const scoped_refptr<ServiceWorkerVersion>& active_version, 707 const scoped_refptr<ServiceWorkerVersion>& active_version,
744 BackgroundSyncEventLastChance last_chance, 708 BackgroundSyncEventLastChance last_chance,
745 const ServiceWorkerVersion::StatusCallback& callback) { 709 const ServiceWorkerVersion::StatusCallback& callback) {
746 DCHECK_CURRENTLY_ON(BrowserThread::IO); 710 DCHECK_CURRENTLY_ON(BrowserThread::IO);
747 DCHECK(active_version); 711 DCHECK(active_version);
748 712
749 if (active_version->running_status() != ServiceWorkerVersion::RUNNING) { 713 if (active_version->running_status() != ServiceWorkerVersion::RUNNING) {
750 active_version->RunAfterStartWorker( 714 active_version->RunAfterStartWorker(
751 base::Bind(&BackgroundSyncManager::DispatchSyncEvent, 715 base::Bind(&BackgroundSyncManager::DispatchSyncEvent,
752 weak_ptr_factory_.GetWeakPtr(), handle_id, active_version, 716 weak_ptr_factory_.GetWeakPtr(), tag, active_version,
753 last_chance, callback), 717 last_chance, callback),
754 callback); 718 callback);
755 return; 719 return;
756 } 720 }
757 721
758 int request_id = active_version->StartRequestWithCustomTimeout( 722 int request_id = active_version->StartRequestWithCustomTimeout(
759 ServiceWorkerMetrics::EventType::SYNC, callback, 723 ServiceWorkerMetrics::EventType::SYNC, callback,
760 parameters_->max_sync_event_duration, 724 parameters_->max_sync_event_duration,
761 ServiceWorkerVersion::CONTINUE_ON_TIMEOUT); 725 ServiceWorkerVersion::CONTINUE_ON_TIMEOUT);
762 base::WeakPtr<BackgroundSyncServiceClient> client = 726 base::WeakPtr<BackgroundSyncServiceClient> client =
763 active_version->GetMojoServiceForRequest<BackgroundSyncServiceClient>( 727 active_version->GetMojoServiceForRequest<BackgroundSyncServiceClient>(
764 request_id); 728 request_id);
765 729
766 // The ServiceWorkerVersion doesn't know when the client (javascript) is done
767 // with the registration so don't give it a BackgroundSyncRegistrationHandle.
768 // Once the render process gets the handle_id it can create its own handle
769 // (with a new unique handle id).
770 client->Sync( 730 client->Sync(
771 handle_id, last_chance, 731 tag, last_chance,
772 base::Bind(&OnSyncEventFinished, active_version, request_id, callback)); 732 base::Bind(&OnSyncEventFinished, active_version, request_id, callback));
773 } 733 }
774 734
775 void BackgroundSyncManager::ScheduleDelayedTask(const base::Closure& callback, 735 void BackgroundSyncManager::ScheduleDelayedTask(const base::Closure& callback,
776 base::TimeDelta delay) { 736 base::TimeDelta delay) {
777 base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(FROM_HERE, callback, 737 base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(FROM_HERE, callback,
778 delay); 738 delay);
779 } 739 }
780 740
781 void BackgroundSyncManager::HasMainFrameProviderHost( 741 void BackgroundSyncManager::HasMainFrameProviderHost(
782 const GURL& origin, 742 const GURL& origin,
783 const BoolCallback& callback) { 743 const BoolCallback& callback) {
784 service_worker_context_->HasMainFrameProviderHost(origin, callback); 744 service_worker_context_->HasMainFrameProviderHost(origin, callback);
785 } 745 }
786 746
787 scoped_ptr<BackgroundSyncRegistrationHandle>
788 BackgroundSyncManager::CreateRegistrationHandle(
789 const scoped_refptr<RefCountedRegistration>& registration) {
790 scoped_refptr<RefCountedRegistration>* ptr =
791 new scoped_refptr<RefCountedRegistration>(registration);
792
793 // Registration handles have unique handle ids. The handle id maps to an
794 // internal RefCountedRegistration (which has the persistent registration id)
795 // via
796 // registration_reference_ids_.
797 BackgroundSyncRegistrationHandle::HandleId handle_id =
798 registration_handle_ids_.Add(ptr);
799
800 return make_scoped_ptr(new BackgroundSyncRegistrationHandle(
801 weak_ptr_factory_.GetWeakPtr(), handle_id));
802 }
803
804 BackgroundSyncRegistration* BackgroundSyncManager::GetRegistrationForHandle(
805 BackgroundSyncRegistrationHandle::HandleId handle_id) const {
806 scoped_refptr<RefCountedRegistration>* ref_registration =
807 registration_handle_ids_.Lookup(handle_id);
808 if (!ref_registration)
809 return nullptr;
810 return (*ref_registration)->value();
811 }
812
813 void BackgroundSyncManager::ReleaseRegistrationHandle(
814 BackgroundSyncRegistrationHandle::HandleId handle_id) {
815 DCHECK_CURRENTLY_ON(BrowserThread::IO);
816 DCHECK(registration_handle_ids_.Lookup(handle_id));
817 registration_handle_ids_.Remove(handle_id);
818 }
819
820 void BackgroundSyncManager::GetRegistrationsImpl( 747 void BackgroundSyncManager::GetRegistrationsImpl(
821 int64_t sw_registration_id, 748 int64_t sw_registration_id,
822 const StatusAndRegistrationsCallback& callback) { 749 const StatusAndRegistrationsCallback& callback) {
823 DCHECK_CURRENTLY_ON(BrowserThread::IO); 750 DCHECK_CURRENTLY_ON(BrowserThread::IO);
824 751
825 scoped_ptr<ScopedVector<BackgroundSyncRegistrationHandle>> out_registrations( 752 scoped_ptr<ScopedVector<BackgroundSyncRegistration>> out_registrations(
826 new ScopedVector<BackgroundSyncRegistrationHandle>()); 753 new ScopedVector<BackgroundSyncRegistration>());
827 754
828 if (disabled_) { 755 if (disabled_) {
829 base::ThreadTaskRunnerHandle::Get()->PostTask( 756 base::ThreadTaskRunnerHandle::Get()->PostTask(
830 FROM_HERE, base::Bind(callback, BACKGROUND_SYNC_STATUS_STORAGE_ERROR, 757 FROM_HERE, base::Bind(callback, BACKGROUND_SYNC_STATUS_STORAGE_ERROR,
831 base::Passed(std::move(out_registrations)))); 758 base::Passed(std::move(out_registrations))));
832 return; 759 return;
833 } 760 }
834 761
835 SWIdToRegistrationsMap::iterator it = 762 SWIdToRegistrationsMap::iterator it =
836 active_registrations_.find(sw_registration_id); 763 active_registrations_.find(sw_registration_id);
837 764
838 if (it != active_registrations_.end()) { 765 if (it != active_registrations_.end()) {
839 const BackgroundSyncRegistrations& registrations = it->second; 766 const BackgroundSyncRegistrations& registrations = it->second;
840 for (const auto& tag_and_registration : registrations.registration_map) { 767 for (const auto& tag_and_registration : registrations.registration_map) {
841 RefCountedRegistration* registration = tag_and_registration.second.get(); 768 const BackgroundSyncRegistration& registration =
842 out_registrations->push_back( 769 tag_and_registration.second;
843 CreateRegistrationHandle(registration).release()); 770 BackgroundSyncRegistration* out_registration =
771 new BackgroundSyncRegistration(registration);
772 out_registrations->push_back(out_registration);
844 } 773 }
845 } 774 }
846 775
847 base::ThreadTaskRunnerHandle::Get()->PostTask( 776 base::ThreadTaskRunnerHandle::Get()->PostTask(
848 FROM_HERE, base::Bind(callback, BACKGROUND_SYNC_STATUS_OK, 777 FROM_HERE, base::Bind(callback, BACKGROUND_SYNC_STATUS_OK,
849 base::Passed(std::move(out_registrations)))); 778 base::Passed(std::move(out_registrations))));
850 } 779 }
851 780
852 bool BackgroundSyncManager::AreOptionConditionsMet( 781 bool BackgroundSyncManager::AreOptionConditionsMet(
853 const BackgroundSyncRegistrationOptions& options) { 782 const BackgroundSyncRegistrationOptions& options) {
(...skipping 15 matching lines...) Expand all
869 } 798 }
870 799
871 void BackgroundSyncManager::RunInBackgroundIfNecessary() { 800 void BackgroundSyncManager::RunInBackgroundIfNecessary() {
872 DCHECK_CURRENTLY_ON(BrowserThread::IO); 801 DCHECK_CURRENTLY_ON(BrowserThread::IO);
873 base::TimeDelta soonest_wakeup_delta = base::TimeDelta::Max(); 802 base::TimeDelta soonest_wakeup_delta = base::TimeDelta::Max();
874 803
875 for (const auto& sw_id_and_registrations : active_registrations_) { 804 for (const auto& sw_id_and_registrations : active_registrations_) {
876 for (const auto& key_and_registration : 805 for (const auto& key_and_registration :
877 sw_id_and_registrations.second.registration_map) { 806 sw_id_and_registrations.second.registration_map) {
878 const BackgroundSyncRegistration& registration = 807 const BackgroundSyncRegistration& registration =
879 *key_and_registration.second->value(); 808 key_and_registration.second;
880 if (registration.sync_state() == BackgroundSyncState::PENDING) { 809 if (registration.sync_state() == BackgroundSyncState::PENDING) {
881 if (clock_->Now() >= registration.delay_until()) { 810 if (clock_->Now() >= registration.delay_until()) {
882 soonest_wakeup_delta = base::TimeDelta(); 811 soonest_wakeup_delta = base::TimeDelta();
883 } else { 812 } else {
884 base::TimeDelta delay_delta = 813 base::TimeDelta delay_delta =
885 registration.delay_until() - clock_->Now(); 814 registration.delay_until() - clock_->Now();
886 if (delay_delta < soonest_wakeup_delta) 815 if (delay_delta < soonest_wakeup_delta)
887 soonest_wakeup_delta = delay_delta; 816 soonest_wakeup_delta = delay_delta;
888 } 817 }
889 } 818 }
(...skipping 45 matching lines...) Expand 10 before | Expand all | Expand 10 after
935 return; 864 return;
936 } 865 }
937 866
938 // Find the registrations that are ready to run. 867 // Find the registrations that are ready to run.
939 std::vector<std::pair<int64_t, RegistrationKey>> sw_id_and_keys_to_fire; 868 std::vector<std::pair<int64_t, RegistrationKey>> sw_id_and_keys_to_fire;
940 869
941 for (auto& sw_id_and_registrations : active_registrations_) { 870 for (auto& sw_id_and_registrations : active_registrations_) {
942 const int64_t service_worker_id = sw_id_and_registrations.first; 871 const int64_t service_worker_id = sw_id_and_registrations.first;
943 for (auto& key_and_registration : 872 for (auto& key_and_registration :
944 sw_id_and_registrations.second.registration_map) { 873 sw_id_and_registrations.second.registration_map) {
945 BackgroundSyncRegistration* registration = 874 BackgroundSyncRegistration* registration = &key_and_registration.second;
946 key_and_registration.second->value();
947 if (IsRegistrationReadyToFire(*registration)) { 875 if (IsRegistrationReadyToFire(*registration)) {
948 sw_id_and_keys_to_fire.push_back( 876 sw_id_and_keys_to_fire.push_back(
949 std::make_pair(service_worker_id, key_and_registration.first)); 877 std::make_pair(service_worker_id, key_and_registration.first));
950 // The state change is not saved to persistent storage because 878 // The state change is not saved to persistent storage because
951 // if the sync event is killed mid-sync then it should return to 879 // if the sync event is killed mid-sync then it should return to
952 // SYNC_STATE_PENDING. 880 // SYNC_STATE_PENDING.
953 registration->set_sync_state(BackgroundSyncState::FIRING); 881 registration->set_sync_state(BackgroundSyncState::FIRING);
954 } 882 }
955 } 883 }
956 } 884 }
(...skipping 15 matching lines...) Expand all
972 weak_ptr_factory_.GetWeakPtr(), callback)); 900 weak_ptr_factory_.GetWeakPtr(), callback));
973 901
974 // Record the total time taken after all events have run to completion. 902 // Record the total time taken after all events have run to completion.
975 base::Closure events_completed_barrier_closure = 903 base::Closure events_completed_barrier_closure =
976 base::BarrierClosure(sw_id_and_keys_to_fire.size(), 904 base::BarrierClosure(sw_id_and_keys_to_fire.size(),
977 base::Bind(&OnAllSyncEventsCompleted, start_time, 905 base::Bind(&OnAllSyncEventsCompleted, start_time,
978 sw_id_and_keys_to_fire.size())); 906 sw_id_and_keys_to_fire.size()));
979 907
980 for (const auto& sw_id_and_key : sw_id_and_keys_to_fire) { 908 for (const auto& sw_id_and_key : sw_id_and_keys_to_fire) {
981 int64_t service_worker_id = sw_id_and_key.first; 909 int64_t service_worker_id = sw_id_and_key.first;
982 const RefCountedRegistration* registration = 910 const BackgroundSyncRegistration* registration =
983 LookupActiveRegistration(service_worker_id, sw_id_and_key.second); 911 LookupActiveRegistration(service_worker_id, sw_id_and_key.second);
984 DCHECK(registration); 912 DCHECK(registration);
985 913
986 service_worker_context_->FindReadyRegistrationForId( 914 service_worker_context_->FindReadyRegistrationForId(
987 service_worker_id, active_registrations_[service_worker_id].origin, 915 service_worker_id, active_registrations_[service_worker_id].origin,
988 base::Bind(&BackgroundSyncManager::FireReadyEventsDidFindRegistration, 916 base::Bind(&BackgroundSyncManager::FireReadyEventsDidFindRegistration,
989 weak_ptr_factory_.GetWeakPtr(), sw_id_and_key.second, 917 weak_ptr_factory_.GetWeakPtr(), sw_id_and_key.second,
990 registration->value()->id(), events_fired_barrier_closure, 918 registration->id(), events_fired_barrier_closure,
991 events_completed_barrier_closure)); 919 events_completed_barrier_closure));
992 } 920 }
993 } 921 }
994 922
995 void BackgroundSyncManager::FireReadyEventsDidFindRegistration( 923 void BackgroundSyncManager::FireReadyEventsDidFindRegistration(
996 const RegistrationKey& registration_key, 924 const RegistrationKey& registration_key,
997 BackgroundSyncRegistration::RegistrationId registration_id, 925 BackgroundSyncRegistration::RegistrationId registration_id,
998 const base::Closure& event_fired_callback, 926 const base::Closure& event_fired_callback,
999 const base::Closure& event_completed_callback, 927 const base::Closure& event_completed_callback,
1000 ServiceWorkerStatusCode service_worker_status, 928 ServiceWorkerStatusCode service_worker_status,
1001 const scoped_refptr<ServiceWorkerRegistration>& 929 const scoped_refptr<ServiceWorkerRegistration>&
1002 service_worker_registration) { 930 service_worker_registration) {
1003 DCHECK_CURRENTLY_ON(BrowserThread::IO); 931 DCHECK_CURRENTLY_ON(BrowserThread::IO);
1004 if (service_worker_status != SERVICE_WORKER_OK) { 932 if (service_worker_status != SERVICE_WORKER_OK) {
1005 base::ThreadTaskRunnerHandle::Get()->PostTask( 933 base::ThreadTaskRunnerHandle::Get()->PostTask(
1006 FROM_HERE, base::Bind(event_fired_callback)); 934 FROM_HERE, base::Bind(event_fired_callback));
1007 base::ThreadTaskRunnerHandle::Get()->PostTask( 935 base::ThreadTaskRunnerHandle::Get()->PostTask(
1008 FROM_HERE, base::Bind(event_completed_callback)); 936 FROM_HERE, base::Bind(event_completed_callback));
1009 return; 937 return;
1010 } 938 }
1011 939
1012 RefCountedRegistration* registration = LookupActiveRegistration( 940 BackgroundSyncRegistration* registration = LookupActiveRegistration(
1013 service_worker_registration->id(), registration_key); 941 service_worker_registration->id(), registration_key);
1014 DCHECK(registration); 942 DCHECK(registration);
1015 943
1016 // Create a handle and keep it until the sync event completes. The client can
1017 // acquire its own handle for longer-term use.
1018 scoped_ptr<BackgroundSyncRegistrationHandle> registration_handle =
1019 CreateRegistrationHandle(registration);
1020
1021 num_firing_registrations_ += 1; 944 num_firing_registrations_ += 1;
1022 945
1023 BackgroundSyncRegistrationHandle::HandleId handle_id =
1024 registration_handle->handle_id();
1025
1026 BackgroundSyncEventLastChance last_chance = 946 BackgroundSyncEventLastChance last_chance =
1027 registration->value()->num_attempts() == 947 registration->num_attempts() == parameters_->max_sync_attempts - 1
1028 parameters_->max_sync_attempts - 1
1029 ? BackgroundSyncEventLastChance::IS_LAST_CHANCE 948 ? BackgroundSyncEventLastChance::IS_LAST_CHANCE
1030 : BackgroundSyncEventLastChance::IS_NOT_LAST_CHANCE; 949 : BackgroundSyncEventLastChance::IS_NOT_LAST_CHANCE;
1031 950
1032 HasMainFrameProviderHost( 951 HasMainFrameProviderHost(
1033 service_worker_registration->pattern().GetOrigin(), 952 service_worker_registration->pattern().GetOrigin(),
1034 base::Bind(&BackgroundSyncMetrics::RecordEventStarted)); 953 base::Bind(&BackgroundSyncMetrics::RecordEventStarted));
1035 954
1036 DispatchSyncEvent( 955 DispatchSyncEvent(
1037 handle_id, service_worker_registration->active_version(), last_chance, 956 registration->options()->tag,
957 service_worker_registration->active_version(), last_chance,
1038 base::Bind(&BackgroundSyncManager::EventComplete, 958 base::Bind(&BackgroundSyncManager::EventComplete,
1039 weak_ptr_factory_.GetWeakPtr(), service_worker_registration, 959 weak_ptr_factory_.GetWeakPtr(), service_worker_registration,
1040 service_worker_registration->id(), 960 service_worker_registration->id(), registration_key,
1041 base::Passed(std::move(registration_handle)),
1042 event_completed_callback)); 961 event_completed_callback));
1043 962
1044 base::ThreadTaskRunnerHandle::Get()->PostTask( 963 base::ThreadTaskRunnerHandle::Get()->PostTask(
1045 FROM_HERE, base::Bind(event_fired_callback)); 964 FROM_HERE, base::Bind(event_fired_callback));
1046 } 965 }
1047 966
1048 void BackgroundSyncManager::FireReadyEventsAllEventsFiring( 967 void BackgroundSyncManager::FireReadyEventsAllEventsFiring(
1049 const base::Closure& callback) { 968 const base::Closure& callback) {
1050 DCHECK_CURRENTLY_ON(BrowserThread::IO); 969 DCHECK_CURRENTLY_ON(BrowserThread::IO);
1051 970
1052 RunInBackgroundIfNecessary(); 971 RunInBackgroundIfNecessary();
1053 base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, 972 base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
1054 base::Bind(callback)); 973 base::Bind(callback));
1055 } 974 }
1056 975
1057 // |service_worker_registration| is just to keep the registration alive 976 // |service_worker_registration| is just to keep the registration alive
1058 // while the event is firing. 977 // while the event is firing.
1059 void BackgroundSyncManager::EventComplete( 978 void BackgroundSyncManager::EventComplete(
1060 const scoped_refptr<ServiceWorkerRegistration>& service_worker_registration, 979 const scoped_refptr<ServiceWorkerRegistration>& service_worker_registration,
1061 int64_t service_worker_id, 980 int64_t service_worker_id,
1062 scoped_ptr<BackgroundSyncRegistrationHandle> registration_handle, 981 const RegistrationKey& registration_key,
1063 const base::Closure& callback, 982 const base::Closure& callback,
1064 ServiceWorkerStatusCode status_code) { 983 ServiceWorkerStatusCode status_code) {
1065 DCHECK_CURRENTLY_ON(BrowserThread::IO); 984 DCHECK_CURRENTLY_ON(BrowserThread::IO);
1066 985
1067 if (disabled_) { 986 if (disabled_) {
1068 base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, 987 base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
1069 base::Bind(callback)); 988 base::Bind(callback));
1070 return; 989 return;
1071 } 990 }
1072 991
1073 op_scheduler_.ScheduleOperation(base::Bind( 992 op_scheduler_.ScheduleOperation(base::Bind(
1074 &BackgroundSyncManager::EventCompleteImpl, weak_ptr_factory_.GetWeakPtr(), 993 &BackgroundSyncManager::EventCompleteImpl, weak_ptr_factory_.GetWeakPtr(),
1075 service_worker_id, base::Passed(std::move(registration_handle)), 994 service_worker_id, registration_key, status_code,
1076 status_code, MakeClosureCompletion(callback))); 995 MakeClosureCompletion(callback)));
1077 } 996 }
1078 997
1079 void BackgroundSyncManager::EventCompleteImpl( 998 void BackgroundSyncManager::EventCompleteImpl(
1080 int64_t service_worker_id, 999 int64_t service_worker_id,
1081 scoped_ptr<BackgroundSyncRegistrationHandle> registration_handle, 1000 const RegistrationKey& registration_key,
1082 ServiceWorkerStatusCode status_code, 1001 ServiceWorkerStatusCode status_code,
1083 const base::Closure& callback) { 1002 const base::Closure& callback) {
1084 DCHECK_CURRENTLY_ON(BrowserThread::IO); 1003 DCHECK_CURRENTLY_ON(BrowserThread::IO);
1085 1004
1086 if (disabled_) { 1005 if (disabled_) {
1087 base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, 1006 base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
1088 base::Bind(callback)); 1007 base::Bind(callback));
1089 return; 1008 return;
1090 } 1009 }
1091 1010
1011 num_firing_registrations_ -= 1;
1012
1092 BackgroundSyncRegistration* registration = 1013 BackgroundSyncRegistration* registration =
1093 registration_handle->registration(); 1014 LookupActiveRegistration(service_worker_id, registration_key);
1094 DCHECK(registration); 1015 if (!registration) {
1016 base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
1017 base::Bind(callback));
1018 return;
1019 }
1020
1095 DCHECK_NE(BackgroundSyncState::PENDING, registration->sync_state()); 1021 DCHECK_NE(BackgroundSyncState::PENDING, registration->sync_state());
1096 1022
1097 registration->set_num_attempts(registration->num_attempts() + 1); 1023 registration->set_num_attempts(registration->num_attempts() + 1);
1098 1024
1099 num_firing_registrations_ -= 1;
1100
1101 // The event ran to completion, we should count it, no matter what happens 1025 // The event ran to completion, we should count it, no matter what happens
1102 // from here. 1026 // from here.
1103 ServiceWorkerRegistration* sw_registration = 1027 ServiceWorkerRegistration* sw_registration =
1104 service_worker_context_->GetLiveRegistration(service_worker_id); 1028 service_worker_context_->GetLiveRegistration(service_worker_id);
1105 if (sw_registration) { 1029 if (sw_registration) {
1106 HasMainFrameProviderHost( 1030 HasMainFrameProviderHost(
1107 sw_registration->pattern().GetOrigin(), 1031 sw_registration->pattern().GetOrigin(),
1108 base::Bind(&BackgroundSyncMetrics::RecordEventResult, 1032 base::Bind(&BackgroundSyncMetrics::RecordEventResult,
1109 status_code == SERVICE_WORKER_OK)); 1033 status_code == SERVICE_WORKER_OK));
1110 } 1034 }
(...skipping 12 matching lines...) Expand all
1123 registration->set_sync_state(BackgroundSyncState::PENDING); 1047 registration->set_sync_state(BackgroundSyncState::PENDING);
1124 registration->set_delay_until(clock_->Now() + 1048 registration->set_delay_until(clock_->Now() +
1125 parameters_->initial_retry_delay * 1049 parameters_->initial_retry_delay *
1126 pow(parameters_->retry_delay_factor, 1050 pow(parameters_->retry_delay_factor,
1127 registration->num_attempts() - 1)); 1051 registration->num_attempts() - 1));
1128 registration_completed = false; 1052 registration_completed = false;
1129 } 1053 }
1130 1054
1131 if (registration_completed) { 1055 if (registration_completed) {
1132 RegistrationKey key(*registration); 1056 RegistrationKey key(*registration);
1133 RefCountedRegistration* active_registration = 1057 BackgroundSyncRegistration* active_registration =
1134 LookupActiveRegistration(service_worker_id, key); 1058 LookupActiveRegistration(service_worker_id, key);
1135 if (active_registration && 1059 if (active_registration &&
1136 active_registration->value()->id() == registration->id()) { 1060 active_registration->id() == registration->id()) {
1137 RemoveActiveRegistration(service_worker_id, key); 1061 RemoveActiveRegistration(service_worker_id, key);
1138 } 1062 }
1139 } 1063 }
1140 1064
1141 StoreRegistrations( 1065 StoreRegistrations(
1142 service_worker_id, 1066 service_worker_id,
1143 base::Bind(&BackgroundSyncManager::EventCompleteDidStore, 1067 base::Bind(&BackgroundSyncManager::EventCompleteDidStore,
1144 weak_ptr_factory_.GetWeakPtr(), service_worker_id, callback)); 1068 weak_ptr_factory_.GetWeakPtr(), service_worker_id, callback));
1145 } 1069 }
1146 1070
(...skipping 75 matching lines...) Expand 10 before | Expand all | Expand 10 after
1222 Params... parameters) { 1146 Params... parameters) {
1223 DCHECK_CURRENTLY_ON(BrowserThread::IO); 1147 DCHECK_CURRENTLY_ON(BrowserThread::IO);
1224 1148
1225 callback.Run(parameters...); 1149 callback.Run(parameters...);
1226 op_scheduler_.CompleteOperationAndRunNext(); 1150 op_scheduler_.CompleteOperationAndRunNext();
1227 } 1151 }
1228 1152
1229 void BackgroundSyncManager::CompleteStatusAndRegistrationCallback( 1153 void BackgroundSyncManager::CompleteStatusAndRegistrationCallback(
1230 StatusAndRegistrationCallback callback, 1154 StatusAndRegistrationCallback callback,
1231 BackgroundSyncStatus status, 1155 BackgroundSyncStatus status,
1232 scoped_ptr<BackgroundSyncRegistrationHandle> registration_handle) { 1156 scoped_ptr<BackgroundSyncRegistration> registration) {
1233 DCHECK_CURRENTLY_ON(BrowserThread::IO); 1157 DCHECK_CURRENTLY_ON(BrowserThread::IO);
1234 1158
1235 callback.Run(status, std::move(registration_handle)); 1159 callback.Run(status, std::move(registration));
1236 op_scheduler_.CompleteOperationAndRunNext(); 1160 op_scheduler_.CompleteOperationAndRunNext();
1237 } 1161 }
1238 1162
1239 void BackgroundSyncManager::CompleteStatusAndRegistrationsCallback( 1163 void BackgroundSyncManager::CompleteStatusAndRegistrationsCallback(
1240 StatusAndRegistrationsCallback callback, 1164 StatusAndRegistrationsCallback callback,
1241 BackgroundSyncStatus status, 1165 BackgroundSyncStatus status,
1242 scoped_ptr<ScopedVector<BackgroundSyncRegistrationHandle>> 1166 scoped_ptr<ScopedVector<BackgroundSyncRegistration>> registration) {
iclelland 2016/03/11 14:50:12 nit: I think this should be plural 'registrations'
jkarlin 2016/03/15 12:50:16 Done.
1243 registration_handles) {
1244 DCHECK_CURRENTLY_ON(BrowserThread::IO); 1167 DCHECK_CURRENTLY_ON(BrowserThread::IO);
1245 1168
1246 callback.Run(status, std::move(registration_handles)); 1169 callback.Run(status, std::move(registration));
1247 op_scheduler_.CompleteOperationAndRunNext(); 1170 op_scheduler_.CompleteOperationAndRunNext();
1248 } 1171 }
1249 1172
1250 base::Closure BackgroundSyncManager::MakeEmptyCompletion() { 1173 base::Closure BackgroundSyncManager::MakeEmptyCompletion() {
1251 DCHECK_CURRENTLY_ON(BrowserThread::IO); 1174 DCHECK_CURRENTLY_ON(BrowserThread::IO);
1252 1175
1253 return MakeClosureCompletion(base::Bind(base::DoNothing)); 1176 return MakeClosureCompletion(base::Bind(base::DoNothing));
1254 } 1177 }
1255 1178
1256 base::Closure BackgroundSyncManager::MakeClosureCompletion( 1179 base::Closure BackgroundSyncManager::MakeClosureCompletion(
(...skipping 29 matching lines...) Expand all
1286 BackgroundSyncManager::MakeStatusCompletion(const StatusCallback& callback) { 1209 BackgroundSyncManager::MakeStatusCompletion(const StatusCallback& callback) {
1287 DCHECK_CURRENTLY_ON(BrowserThread::IO); 1210 DCHECK_CURRENTLY_ON(BrowserThread::IO);
1288 1211
1289 return base::Bind( 1212 return base::Bind(
1290 &BackgroundSyncManager::CompleteOperationCallback<StatusCallback, 1213 &BackgroundSyncManager::CompleteOperationCallback<StatusCallback,
1291 BackgroundSyncStatus>, 1214 BackgroundSyncStatus>,
1292 weak_ptr_factory_.GetWeakPtr(), callback); 1215 weak_ptr_factory_.GetWeakPtr(), callback);
1293 } 1216 }
1294 1217
1295 } // namespace content 1218 } // namespace content
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698