Deprecate NonThreadSafe in components/invalidation in favor of SequenceChecker.

components/invalidation/impl/registration_manager.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/invalidation/impl/registration_manager.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <cstddef>
@@ skipping 47 matching lines @@
 // 1 hour.
 const int RegistrationManager::kMaxRegistrationDelaySeconds = 60 * 60;
 
 RegistrationManager::RegistrationManager(
     invalidation::InvalidationClient* invalidation_client)
     : invalidation_client_(invalidation_client) {
   DCHECK(invalidation_client_);
 }
 
 RegistrationManager::~RegistrationManager() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 }
 
 ObjectIdSet RegistrationManager::UpdateRegisteredIds(const ObjectIdSet& ids) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   const ObjectIdSet& old_ids = GetRegisteredIds();
   const ObjectIdSet& to_register = ids;
   ObjectIdSet to_unregister;
   std::set_difference(old_ids.begin(), old_ids.end(),
                       ids.begin(), ids.end(),
                       std::inserter(to_unregister, to_unregister.begin()),
                       ObjectIdLessThan());
 
   for (ObjectIdSet::const_iterator it = to_unregister.begin();
@@ skipping 10 matching lines @@
     if (!IsIdRegistered(*it)) {
       TryRegisterId(*it, false /* is-retry */);
     }
   }
 
   return to_unregister;
 }
 
 void RegistrationManager::MarkRegistrationLost(
     const invalidation::ObjectId& id) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   auto it = registration_statuses_.find(id);
   if (it == registration_statuses_.end()) {
     DVLOG(1) << "Attempt to mark non-existent registration for "
              << ObjectIdToString(id) << " as lost";
     return;
   }
   if (!it->second->enabled) {
     return;
   }
   it->second->state = invalidation::InvalidationListener::UNREGISTERED;
   bool is_retry = !it->second->last_registration_request.is_null();
   TryRegisterId(id, is_retry);
 }
 
 void RegistrationManager::MarkAllRegistrationsLost() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   for (auto it = registration_statuses_.begin();
        it != registration_statuses_.end(); ++it) {
     if (IsIdRegistered(it->first)) {
       MarkRegistrationLost(it->first);
     }
   }
 }
 
 void RegistrationManager::DisableId(const invalidation::ObjectId& id) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   auto it = registration_statuses_.find(id);
   if (it == registration_statuses_.end()) {
     DVLOG(1) << "Attempt to disable non-existent registration for "
              << ObjectIdToString(id);
     return;
   }
   it->second->Disable();
 }
 
 // static
@@ skipping 14 matching lines @@
   return std::max(min_retry_interval,
                   std::min(max_retry_interval, new_retry_interval));
 }
 
 ObjectIdSet RegistrationManager::GetRegisteredIdsForTest() const {
   return GetRegisteredIds();
 }
 
 RegistrationManager::PendingRegistrationMap
     RegistrationManager::GetPendingRegistrationsForTest() const {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   PendingRegistrationMap pending_registrations;
   for (const auto& status_pair : registration_statuses_) {
     const invalidation::ObjectId& id = status_pair.first;
     RegistrationStatus* status = status_pair.second.get();
     if (status->registration_timer.IsRunning()) {
       pending_registrations[id].last_registration_request =
           status->last_registration_request;
       pending_registrations[id].registration_attempt =
           status->last_registration_attempt;
       pending_registrations[id].delay = status->delay;
       pending_registrations[id].actual_delay =
           status->registration_timer.GetCurrentDelay();
     }
   }
   return pending_registrations;
 }
 
 void RegistrationManager::FirePendingRegistrationsForTest() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   for (const auto& status_pair : registration_statuses_) {
     if (status_pair.second->registration_timer.IsRunning()) {
       status_pair.second->DoRegister();
     }
   }
 }
 
 double RegistrationManager::GetJitter() {
   // |jitter| lies in [-1.0, 1.0), which is low-biased, but only
   // barely.
   //
   // TODO(akalin): Fix the bias.
   return 2.0 * base::RandDouble() - 1.0;
 }
 
 void RegistrationManager::TryRegisterId(const invalidation::ObjectId& id,
                                         bool is_retry) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   auto it = registration_statuses_.find(id);
   if (it == registration_statuses_.end()) {
     NOTREACHED() << "TryRegisterId called on " << ObjectIdToString(id)
                  << " which is not in the registration map";
     return;
   }
   RegistrationStatus* status = it->second.get();
   if (!status->enabled) {
     // Disabled, so do nothing.
     return;
@@ skipping 32 matching lines @@
   } else {
     DVLOG(2) << "Not a retry -- registering "
              << ObjectIdToString(id) << " immediately";
     status->delay = base::TimeDelta();
     status->next_delay = base::TimeDelta();
     status->DoRegister();
   }
 }
 
 void RegistrationManager::DoRegisterId(const invalidation::ObjectId& id) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   invalidation_client_->Register(id);
   auto it = registration_statuses_.find(id);
   if (it == registration_statuses_.end()) {
     NOTREACHED() << "DoRegisterId called on " << ObjectIdToString(id)
                  << " which is not in the registration map";
     return;
   }
   it->second->state = invalidation::InvalidationListener::REGISTERED;
   it->second->last_registration_request = base::Time::Now();
 }
 
 void RegistrationManager::UnregisterId(const invalidation::ObjectId& id) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   invalidation_client_->Unregister(id);
   auto it = registration_statuses_.find(id);
   if (it == registration_statuses_.end()) {
     NOTREACHED() << "UnregisterId called on " << ObjectIdToString(id)
                  << " which is not in the registration map";
     return;
   }
   registration_statuses_.erase(it);
 }
 
 
 ObjectIdSet RegistrationManager::GetRegisteredIds() const {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   ObjectIdSet ids;
   for (const auto& status_pair : registration_statuses_) {
     if (IsIdRegistered(status_pair.first)) {
       ids.insert(status_pair.first);
     }
   }
   return ids;
 }
 
 bool RegistrationManager::IsIdRegistered(
     const invalidation::ObjectId& id) const {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   auto it = registration_statuses_.find(id);
   return it != registration_statuses_.end() &&
       it->second->state == invalidation::InvalidationListener::REGISTERED;
 }
 
 }  // namespace syncer