Relanding #2: Fixing crash that can occur if signal is modified while firing.

webrtc/base/asyncinvoker.cc

 /*
  *  Copyright 2014 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include "webrtc/base/asyncinvoker.h"
 
 #include "webrtc/base/atomicops.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 
 namespace rtc {
 
 AsyncInvoker::AsyncInvoker() : invocation_complete_(false, false) {}
 
 AsyncInvoker::~AsyncInvoker() {
   destroying_ = true;
-  SignalInvokerDestroyed();
   // Messages for this need to be cleared *before* our destructor is complete.
   MessageQueueManager::Clear(this);
   // And we need to wait for any invocations that are still in progress on
   // other threads.
   while (AtomicOps::AcquireLoad(&pending_invocations_)) {
     // If the destructor was called while AsyncInvoke was being called by
     // another thread, WITHIN an AsyncInvoked functor, it may do another
     // Thread::Post even after we called MessageQueueManager::Clear(this). So
     // we need to keep calling Clear to discard these posts.
     MessageQueueManager::Clear(this);
@@ skipping 85 matching lines @@
 
 NotifyingAsyncClosureBase::NotifyingAsyncClosureBase(
     AsyncInvoker* invoker,
     const Location& callback_posted_from,
     Thread* calling_thread)
     : AsyncClosure(invoker),
       callback_posted_from_(callback_posted_from),
       calling_thread_(calling_thread) {
   calling_thread->SignalQueueDestroyed.connect(
       this, &NotifyingAsyncClosureBase::CancelCallback);
-  invoker->SignalInvokerDestroyed.connect(
-      this, &NotifyingAsyncClosureBase::CancelCallback);
+  // Note: We don't need to listen for the invoker being destroyed, because it
+  // will wait for this closure to be destroyed (and pending_invocations_ to go
+  // to 0) before its destructor completes.
 }
 
 NotifyingAsyncClosureBase::~NotifyingAsyncClosureBase() {
   disconnect_all();
 }
 
 void NotifyingAsyncClosureBase::TriggerCallback() {
   CritScope cs(&crit_);
   if (!CallbackCanceled() && !callback_.empty()) {
     invoker_->AsyncInvoke<void>(callback_posted_from_, calling_thread_,
                                 callback_);
   }
 }
 
 void NotifyingAsyncClosureBase::CancelCallback() {
   // If the callback is triggering when this is called, block the
   // destructor of the dying object here by waiting until the callback
   // is done triggering.
   CritScope cs(&crit_);
   // calling_thread_ == nullptr means do not trigger the callback.
   calling_thread_ = nullptr;
 }
 
 }  // namespace rtc