Deprecate NonThreadSafe in components/invalidation in favor of SequenceChecker.

components/invalidation/impl/ticl_invalidation_service.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/ticl_invalidation_service.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/command_line.h"
@@ skipping 55 matching lines @@
       identity_provider_(std::move(identity_provider)),
       settings_provider_(std::move(settings_provider)),
       invalidator_registrar_(new syncer::InvalidatorRegistrar()),
       request_access_token_backoff_(&kRequestAccessTokenBackoffPolicy),
       network_channel_type_(GCM_NETWORK_CHANNEL),
       gcm_driver_(gcm_driver),
       request_context_(request_context),
       logger_() {}
 
 TiclInvalidationService::~TiclInvalidationService() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   invalidator_registrar_->UpdateInvalidatorState(
       syncer::INVALIDATOR_SHUTTING_DOWN);
   settings_provider_->RemoveObserver(this);
   identity_provider_->RemoveActiveAccountRefreshTokenObserver(this);
   identity_provider_->RemoveObserver(this);
   if (IsStarted()) {
     StopInvalidator();
   }
 }
 
 void TiclInvalidationService::Init(
     std::unique_ptr<syncer::InvalidationStateTracker>
         invalidation_state_tracker) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   invalidation_state_tracker_ = std::move(invalidation_state_tracker);
 
   if (invalidation_state_tracker_->GetInvalidatorClientId().empty()) {
     invalidation_state_tracker_->ClearAndSetNewClientId(
         GenerateInvalidatorClientId());
   }
 
   UpdateInvalidationNetworkChannel();
   if (IsReadyToStart()) {
     StartInvalidator(network_channel_type_);
@@ skipping 14 matching lines @@
   invalidation_state_tracker_ = std::move(invalidation_state_tracker);
   invalidator_.reset(invalidator);
 
   invalidator_->RegisterHandler(this);
   CHECK(invalidator_->UpdateRegisteredIds(
       this, invalidator_registrar_->GetAllRegisteredIds()));
 }
 
 void TiclInvalidationService::RegisterInvalidationHandler(
     syncer::InvalidationHandler* handler) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DVLOG(2) << "Registering an invalidation handler";
   invalidator_registrar_->RegisterHandler(handler);
   logger_.OnRegistration(handler->GetOwnerName());
 }
 
 bool TiclInvalidationService::UpdateRegisteredInvalidationIds(
     syncer::InvalidationHandler* handler,
     const syncer::ObjectIdSet& ids) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DVLOG(2) << "Registering ids: " << ids.size();
   if (!invalidator_registrar_->UpdateRegisteredIds(handler, ids))
     return false;
   if (invalidator_) {
     CHECK(invalidator_->UpdateRegisteredIds(
         this, invalidator_registrar_->GetAllRegisteredIds()));
   }
   logger_.OnUpdateIds(invalidator_registrar_->GetSanitizedHandlersIdsMap());
   return true;
 }
 
 void TiclInvalidationService::UnregisterInvalidationHandler(
     syncer::InvalidationHandler* handler) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DVLOG(2) << "Unregistering";
   invalidator_registrar_->UnregisterHandler(handler);
   if (invalidator_) {
     CHECK(invalidator_->UpdateRegisteredIds(
         this, invalidator_registrar_->GetAllRegisteredIds()));
   }
   logger_.OnUnregistration(handler->GetOwnerName());
 }
 
 syncer::InvalidatorState TiclInvalidationService::GetInvalidatorState() const {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (invalidator_) {
     DVLOG(2) << "GetInvalidatorState returning "
         << invalidator_->GetInvalidatorState();
     return invalidator_->GetInvalidatorState();
   } else {
     DVLOG(2) << "Invalidator currently stopped";
     return syncer::TRANSIENT_INVALIDATION_ERROR;
   }
 }
 
 std::string TiclInvalidationService::GetInvalidatorClientId() const {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   return invalidation_state_tracker_->GetInvalidatorClientId();
 }
 
 InvalidationLogger* TiclInvalidationService::GetInvalidationLogger() {
   return &logger_;
 }
 
 IdentityProvider* TiclInvalidationService::GetIdentityProvider() {
   return identity_provider_.get();
 }
@@ skipping 160 matching lines @@
 
   return true;
 }
 
 bool TiclInvalidationService::IsStarted() const {
   return invalidator_.get() != NULL;
 }
 
 void TiclInvalidationService::StartInvalidator(
     InvalidationNetworkChannel network_channel) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(!invalidator_);
   DCHECK(invalidation_state_tracker_);
   DCHECK(!invalidation_state_tracker_->GetInvalidatorClientId().empty());
 
   // Request access token for PushClientChannel. GCMNetworkChannel will request
   // access token before sending message to server.
   if (network_channel == PUSH_CLIENT_CHANNEL && access_token_.empty()) {
     DVLOG(1)
         << "TiclInvalidationService: "
         << "Deferring start until we have an access token.";
@@ skipping 73 matching lines @@
 }
 
 void TiclInvalidationService::StopInvalidator() {
   DCHECK(invalidator_);
   gcm_invalidation_bridge_.reset();
   invalidator_->UnregisterHandler(this);
   invalidator_.reset();
 }
 
 }  // namespace invalidation