Ensure OAuth2TokenServiceRequest::Core is destroyed on owner thread.

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 "base/bind.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 53 matching lines @@
   // Called on the token service thread.
   virtual void StopOnTokenServiceThread() = 0;
 
   base::SingleThreadTaskRunner* token_service_task_runner();
   OAuth2TokenService* token_service();
   OAuth2TokenServiceRequest* owner();
 
  private:
   friend class base::RefCountedThreadSafe<OAuth2TokenServiceRequest::Core>;
 
+  void DoNothing();
+
   scoped_refptr<base::SingleThreadTaskRunner> token_service_task_runner_;
   OAuth2TokenServiceRequest* owner_;
   TokenServiceProvider* provider_;
   DISALLOW_COPY_AND_ASSIGN(Core);
 };
 
 OAuth2TokenServiceRequest::Core::Core(OAuth2TokenServiceRequest* owner,
                                       TokenServiceProvider* provider)
     : owner_(owner), provider_(provider) {
   DCHECK(owner_);
@@ skipping 13 matching lines @@
                  this));
 }
 
 void OAuth2TokenServiceRequest::Core::Stop() {
   DCHECK(CalledOnValidThread());
   DCHECK(!IsStopped());
 
   // Detaches |owner_| from this instance so |owner_| will be called back only
   // if |Stop()| has never been called.
   owner_ = NULL;
-  token_service_task_runner_->PostTask(
+
+  // 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));
+                 this),
+      base::Bind(&OAuth2TokenServiceRequest::Core::DoNothing, this));
 }
 
 bool OAuth2TokenServiceRequest::Core::IsStopped() const {
   DCHECK(CalledOnValidThread());
   return owner_ == NULL;
 }
 
 base::SingleThreadTaskRunner*
 OAuth2TokenServiceRequest::Core::token_service_task_runner() {
   return token_service_task_runner_;
 }
 
 OAuth2TokenService* OAuth2TokenServiceRequest::Core::token_service() {
   DCHECK(token_service_task_runner_->BelongsToCurrentThread());
   return provider_->GetTokenService();
 }
 
 OAuth2TokenServiceRequest* OAuth2TokenServiceRequest::Core::owner() {
   DCHECK(CalledOnValidThread());
   return owner_;
 }
 
+void OAuth2TokenServiceRequest::Core::DoNothing() {
+  DCHECK(CalledOnValidThread());
+}
+
 namespace {
 
 // An implementation of Core for getting an access token.
 class RequestCore : public OAuth2TokenServiceRequest::Core,
                     public OAuth2TokenService::Consumer {
  public:
   RequestCore(OAuth2TokenServiceRequest* owner,
               OAuth2TokenServiceRequest::TokenServiceProvider* provider,
               OAuth2TokenService::Consumer* consumer,
               const std::string& account_id,
@@ skipping 196 matching lines @@
     const std::string& account_id)
     : account_id_(account_id) {
   DCHECK(!account_id_.empty());
 }
 
 void OAuth2TokenServiceRequest::StartWithCore(const scoped_refptr<Core>& core) {
   DCHECK(core);
   core_ = core;
   core_->Start();
 }