Replace deprecated base::NonThreadSafe in components/signin in favor of SequenceChecker.

components/signin/core/browser/account_fetcher_service.cc

 // Copyright 2015 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/signin/core/browser/account_fetcher_service.h"
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/memory/ptr_util.h"
@@ skipping 47 matching lines @@
       signin_client_(nullptr),
       invalidation_service_(nullptr),
       network_fetches_enabled_(false),
       profile_loaded_(false),
       refresh_tokens_loaded_(false),
       shutdown_called_(false),
       scheduled_refresh_enabled_(true),
       child_info_request_(nullptr) {}
 
 AccountFetcherService::~AccountFetcherService() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(shutdown_called_);
 }
 
 // static
 void AccountFetcherService::RegisterPrefs(
     user_prefs::PrefRegistrySyncable* user_prefs) {
   user_prefs->RegisterInt64Pref(kLastUpdatePref, 0);
 }
 
 void AccountFetcherService::Initialize(
@@ skipping 57 matching lines @@
     RefreshAccountInfo(*it, only_fetch_if_invalid);
   }
 }
 
 // Child account status is refreshed through invalidations which are only
 // available for the primary account. Finding the primary account requires a
 // dependency on signin_manager which we get around by only allowing a single
 // account. This is possible since we only support a single account to be a
 // child anyway.
 void AccountFetcherService::UpdateChildInfo() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   std::vector<std::string> accounts = token_service_->GetAccounts();
   if (accounts.size() == 1) {
     const std::string& candidate = accounts[0];
     if (candidate == child_request_account_id_)
       return;
     if (!child_request_account_id_.empty())
       ResetChildInfo();
     if (!AccountSupportsUserInfo(candidate))
       return;
     child_request_account_id_ = candidate;
     StartFetchingChildInfo(candidate);
   } else {
     ResetChildInfo();
   }
 }
 
 void AccountFetcherService::MaybeEnableNetworkFetches() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (!profile_loaded_ || !refresh_tokens_loaded_)
     return;
   if (!network_fetches_enabled_) {
     network_fetches_enabled_ = true;
     ScheduleNextRefresh();
   }
   RefreshAllAccountInfo(true);
   UpdateChildInfo();
 }
 
@@ skipping 18 matching lines @@
   } else {
     timer_.Start(FROM_HERE, kRefreshFromTokenServiceDelay - time_since_update,
                  this,
                  &AccountFetcherService::RefreshAllAccountsAndScheduleNext);
   }
 }
 
 // Starts fetching user information. This is called periodically to refresh.
 void AccountFetcherService::StartFetchingUserInfo(
     const std::string& account_id) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(network_fetches_enabled_);
 
   std::unique_ptr<AccountInfoFetcher>& request =
       user_info_requests_[account_id];
   if (!request) {
     DVLOG(1) << "StartFetching " << account_id;
     std::unique_ptr<AccountInfoFetcher> fetcher =
         base::MakeUnique<AccountInfoFetcher>(
             token_service_, signin_client_->GetURLRequestContext(), this,
             account_id);
@@ skipping 121 matching lines @@
   DVLOG(1) << "REVOKED " << account_id;
 
   if (!network_fetches_enabled_)
     return;
   user_info_requests_.erase(account_id);
   UpdateChildInfo();
   account_tracker_service_->StopTrackingAccount(account_id);
 }
 
 void AccountFetcherService::OnRefreshTokensLoaded() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   refresh_tokens_loaded_ = true;
   MaybeEnableNetworkFetches();
 }