Replace deprecated base::NonThreadSafe in google_apis/gaia in favor of SequenceChecker.

google_apis/gaia/oauth2_token_service.cc

 // Copyright 2013 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 "google_apis/gaia/oauth2_token_service.h"
 
 #include <stdint.h>
 #include <utility>
 #include <vector>
 
@@ skipping 48 matching lines @@
 }
 
 OAuth2TokenService::RequestImpl::RequestImpl(
     const std::string& account_id,
     OAuth2TokenService::Consumer* consumer)
     : account_id_(account_id),
       consumer_(consumer) {
 }
 
 OAuth2TokenService::RequestImpl::~RequestImpl() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 }
 
 std::string OAuth2TokenService::RequestImpl::GetAccountId() const {
   return account_id_;
 }
 
 std::string OAuth2TokenService::RequestImpl::GetConsumerId() const {
   return consumer_->id();
 }
 
 void OAuth2TokenService::RequestImpl::InformConsumer(
     const GoogleServiceAuthError& error,
     const std::string& access_token,
     const base::Time& expiration_date) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (error.state() == GoogleServiceAuthError::NONE)
     consumer_->OnGetTokenSuccess(this, access_token, expiration_date);
   else
     consumer_->OnGetTokenFailure(this, error);
 }
 
 // Class that fetches an OAuth2 access token for a given account id and set of
 // scopes.
 //
 // It aims to meet OAuth2TokenService's requirements on token fetching. Retry
@@ skipping 293 matching lines @@
 OAuth2TokenService::Consumer::~Consumer() {
 }
 
 OAuth2TokenService::OAuth2TokenService(
     std::unique_ptr<OAuth2TokenServiceDelegate> delegate)
     : delegate_(std::move(delegate)) {
   DCHECK(delegate_);
 }
 
 OAuth2TokenService::~OAuth2TokenService() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   // Release all the pending fetchers.
   pending_fetchers_.clear();
 }
 
 OAuth2TokenServiceDelegate* OAuth2TokenService::GetDelegate() {
   return delegate_.get();
 }
 
 const OAuth2TokenServiceDelegate* OAuth2TokenService::GetDelegate() const {
   return delegate_.get();
@@ skipping 65 matching lines @@
 }
 
 std::unique_ptr<OAuth2TokenService::Request>
 OAuth2TokenService::StartRequestForClientWithContext(
     const std::string& account_id,
     net::URLRequestContextGetter* getter,
     const std::string& client_id,
     const std::string& client_secret,
     const ScopeSet& scopes,
     Consumer* consumer) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   // TODO(robliao): Remove ScopedTracker below once https://crbug.com/422460 is
   // fixed.
   tracked_objects::ScopedTracker tracking_profile1(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "422460 OAuth2TokenService::StartRequestForClientWithContext 1"));
   std::unique_ptr<RequestImpl> request(new RequestImpl(account_id, consumer));
   for (auto& observer : diagnostics_observer_list_)
     observer.OnAccessTokenRequested(account_id, consumer->id(), scopes);
 
@@ skipping 130 matching lines @@
     const ScopeSet& scopes,
     const std::string& access_token) {
   InvalidateAccessTokenImpl(account_id, client_id, scopes, access_token);
 }
 
 void OAuth2TokenService::InvalidateAccessTokenImpl(
     const std::string& account_id,
     const std::string& client_id,
     const ScopeSet& scopes,
     const std::string& access_token) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   RemoveCacheEntry(
       RequestParameters(client_id,
                         account_id,
                         scopes),
       access_token);
   delegate_->InvalidateAccessToken(account_id, client_id, scopes, access_token);
 }
 
 void OAuth2TokenService::OnFetchComplete(Fetcher* fetcher) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   // Update the auth error state so auth errors are appropriately communicated
   // to the user.
   UpdateAuthError(fetcher->GetAccountId(), fetcher->error());
 
   // Note |fetcher| is recorded in |pending_fetcher_| mapped to its refresh
   // token and scope set. This is guaranteed as follows; here a Fetcher is said
   // to be uncompleted if it has not finished calling back
   // OAuth2TokenService::OnFetchComplete().
   //
@@ skipping 46 matching lines @@
 }
 
 bool OAuth2TokenService::HasCacheEntry(
     const RequestParameters& request_parameters) {
   const CacheEntry* cache_entry = GetCacheEntry(request_parameters);
   return cache_entry && cache_entry->access_token.length();
 }
 
 const OAuth2TokenService::CacheEntry* OAuth2TokenService::GetCacheEntry(
     const RequestParameters& request_parameters) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   TokenCache::iterator token_iterator = token_cache_.find(request_parameters);
   if (token_iterator == token_cache_.end())
     return NULL;
   if (token_iterator->second.expiration_date <= base::Time::Now()) {
     token_cache_.erase(token_iterator);
     return NULL;
   }
   return &token_iterator->second;
 }
 
 bool OAuth2TokenService::RemoveCacheEntry(
     const RequestParameters& request_parameters,
     const std::string& token_to_remove) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   TokenCache::iterator token_iterator = token_cache_.find(request_parameters);
   if (token_iterator != token_cache_.end() &&
       token_iterator->second.access_token == token_to_remove) {
     for (auto& observer : diagnostics_observer_list_) {
       observer.OnTokenRemoved(request_parameters.account_id,
                               request_parameters.scopes);
     }
     token_cache_.erase(token_iterator);
     return true;
   }
   return false;
 }
 void OAuth2TokenService::UpdateAuthError(const std::string& account_id,
                                          const GoogleServiceAuthError& error) {
   delegate_->UpdateAuthError(account_id, error);
 }
 
 void OAuth2TokenService::RegisterCacheEntry(
     const std::string& client_id,
     const std::string& account_id,
     const OAuth2TokenService::ScopeSet& scopes,
     const std::string& access_token,
     const base::Time& expiration_date) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   CacheEntry& token = token_cache_[RequestParameters(client_id,
                                                      account_id,
                                                      scopes)];
   token.access_token = access_token;
   token.expiration_date = expiration_date;
 }
 
 void OAuth2TokenService::ClearCache() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   for (TokenCache::iterator iter = token_cache_.begin();
        iter != token_cache_.end(); ++iter) {
     for (auto& observer : diagnostics_observer_list_)
       observer.OnTokenRemoved(iter->first.account_id, iter->first.scopes);
   }
 
   token_cache_.clear();
 }
 
 void OAuth2TokenService::ClearCacheForAccount(const std::string& account_id) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   for (TokenCache::iterator iter = token_cache_.begin();
        iter != token_cache_.end();
        /* iter incremented in body */) {
     if (iter->first.account_id == account_id) {
       for (auto& observer : diagnostics_observer_list_)
         observer.OnTokenRemoved(account_id, iter->first.scopes);
       token_cache_.erase(iter++);
     } else {
       ++iter;
     }
@@ skipping 23 matching lines @@
 void OAuth2TokenService::CancelFetchers(
     std::vector<Fetcher*> fetchers_to_cancel) {
   for (auto iter = fetchers_to_cancel.begin(); iter != fetchers_to_cancel.end();
        ++iter) {
     (*iter)->Cancel();
   }
 }
 
 void OAuth2TokenService::set_max_authorization_token_fetch_retries_for_testing(
     int max_retries) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   max_fetch_retry_num_ = max_retries;
 }
 
 size_t OAuth2TokenService::GetNumPendingRequestsForTesting(
     const std::string& client_id,
     const std::string& account_id,
     const ScopeSet& scopes) const {
   auto iter = pending_fetchers_.find(
       OAuth2TokenService::RequestParameters(client_id, account_id, scopes));
   return iter == pending_fetchers_.end() ?
              0 : iter->second->GetWaitingRequestCount();
 }