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

google_apis/gaia/oauth2_token_service_request.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 "google_apis/gaia/oauth2_token_service_request.h"
 
 #include <memory>
 
 #include "base/bind.h"
 #include "base/location.h"
@@ skipping 20 matching lines @@
 // 2. Start() is called on owner thread, which calls StartOnTokenServiceThread()
 // on token service thread.
 //
 // 3. Request is executed.
 //
 // 4. Stop() is called on owner thread, which calls StopOnTokenServiceThread()
 // on token service thread.
 //
 // 5. Core is destroyed on owner thread.
 class OAuth2TokenServiceRequest::Core
-    : public base::NonThreadSafe,
-      public base::RefCountedThreadSafe<OAuth2TokenServiceRequest::Core> {
+    : public base::RefCountedThreadSafe<OAuth2TokenServiceRequest::Core> {
  public:
   // Note the thread where an instance of Core is constructed is referred to as
   // the "owner thread" here.
   Core(OAuth2TokenServiceRequest* owner,
        const scoped_refptr<TokenServiceProvider>& provider);
 
   // Starts the core.  Must be called on the owner thread.
   void Start();
 
   // Stops the core.  Must be called on the owner thread.
@@ skipping 12 matching lines @@
   // Called on the token service thread.
   virtual void StartOnTokenServiceThread() = 0;
 
   // Called on the token service thread.
   virtual void StopOnTokenServiceThread() = 0;
 
   base::SingleThreadTaskRunner* token_service_task_runner();
   OAuth2TokenService* token_service();
   OAuth2TokenServiceRequest* owner();
 
+  SEQUENCE_CHECKER(sequence_checker_);
+
  private:
   friend class base::RefCountedThreadSafe<OAuth2TokenServiceRequest::Core>;
 
   void DoNothing();
 
   scoped_refptr<base::SingleThreadTaskRunner> token_service_task_runner_;
   OAuth2TokenServiceRequest* owner_;
 
   // Clear on owner thread.  OAuth2TokenServiceRequest promises to clear its
   // last reference to TokenServiceProvider on the owner thread so the caller
@@ skipping 10 matching lines @@
   DCHECK(owner_);
   DCHECK(provider_.get());
   token_service_task_runner_ = provider_->GetTokenServiceTaskRunner();
   DCHECK(token_service_task_runner_.get());
 }
 
 OAuth2TokenServiceRequest::Core::~Core() {
 }
 
 void OAuth2TokenServiceRequest::Core::Start() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   token_service_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&OAuth2TokenServiceRequest::Core::StartOnTokenServiceThread,
                  this));
 }
 
 void OAuth2TokenServiceRequest::Core::Stop() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(!IsStopped());
 
   // Detaches |owner_| from this instance so |owner_| will be called back only
   // if |Stop()| has never been called.
   owner_ = NULL;
 
   // We are stopping and will likely be destroyed soon.  Use a reply closure
   // (DoNothing) to retain "this" and ensure we are destroyed in the owner
   // thread, not the task runner thread.  PostTaskAndReply guarantees that the
   // reply closure will execute after StopOnTokenServiceThread has completed.
   token_service_task_runner_->PostTaskAndReply(
       FROM_HERE,
       base::Bind(&OAuth2TokenServiceRequest::Core::StopOnTokenServiceThread,
                  this),
       base::Bind(&OAuth2TokenServiceRequest::Core::DoNothing, this));
 }
 
 bool OAuth2TokenServiceRequest::Core::IsStopped() const {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   return owner_ == NULL;
 }
 
 base::SingleThreadTaskRunner*
 OAuth2TokenServiceRequest::Core::token_service_task_runner() {
   return token_service_task_runner_.get();
 }
 
 OAuth2TokenService* OAuth2TokenServiceRequest::Core::token_service() {
   DCHECK(token_service_task_runner_->BelongsToCurrentThread());
   return provider_->GetTokenService();
 }
 
 OAuth2TokenServiceRequest* OAuth2TokenServiceRequest::Core::owner() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   return owner_;
 }
 
 void OAuth2TokenServiceRequest::Core::DoNothing() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 }
 
 namespace {
 
 // An implementation of Core for getting an access token.
 class RequestCore : public OAuth2TokenServiceRequest::Core,
                     public OAuth2TokenService::Consumer {
  public:
   RequestCore(OAuth2TokenServiceRequest* owner,
               const scoped_refptr<
@@ skipping 85 matching lines @@
   DCHECK(token_service_task_runner()->BelongsToCurrentThread());
   DCHECK_EQ(request_.get(), request);
   owner_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&RequestCore::InformOwnerOnGetTokenFailure, this, error));
   request_.reset();
 }
 
 void RequestCore::InformOwnerOnGetTokenSuccess(std::string access_token,
                                                base::Time expiration_time) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (!IsStopped()) {
     consumer_->OnGetTokenSuccess(owner(), access_token, expiration_time);
   }
 }
 
 void RequestCore::InformOwnerOnGetTokenFailure(GoogleServiceAuthError error) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (!IsStopped()) {
     consumer_->OnGetTokenFailure(owner(), error);
   }
 }
 
 // An implementation of Core for invalidating an access token.
 class InvalidateCore : public OAuth2TokenServiceRequest::Core {
  public:
   InvalidateCore(OAuth2TokenServiceRequest* owner,
                  const scoped_refptr<
@@ skipping 72 matching lines @@
     const OAuth2TokenService::ScopeSet& scopes,
     const std::string& access_token) {
   std::unique_ptr<OAuth2TokenServiceRequest> request(
       new OAuth2TokenServiceRequest(account_id));
   scoped_refptr<Core> core(new InvalidateCore(
       request.get(), provider, access_token, account_id, scopes));
   request->StartWithCore(core);
 }
 
 OAuth2TokenServiceRequest::~OAuth2TokenServiceRequest() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   core_->Stop();
 }
 
 std::string OAuth2TokenServiceRequest::GetAccountId() const {
   return account_id_;
 }
 
 OAuth2TokenServiceRequest::OAuth2TokenServiceRequest(
     const std::string& account_id)
     : account_id_(account_id) {
   DCHECK(!account_id_.empty());
 }
 
 void OAuth2TokenServiceRequest::StartWithCore(const scoped_refptr<Core>& core) {
   DCHECK(core.get());
   core_ = core;
   core_->Start();
 }