Add helper class GuardedAsyncInvoker to protect against thread dying

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/checks.h"
 #include "webrtc/base/logging.h"
 
 namespace rtc {
 
 AsyncInvoker::AsyncInvoker() : destroying_(false) {}
 
 AsyncInvoker::~AsyncInvoker() {
   destroying_ = true;
   SignalInvokerDestroyed();
   // Messages for this need to be cleared *before* our destructor is complete.
@@ skipping 46 matching lines @@
                                    uint32 delay_ms,
                                    uint32 id) {
   if (destroying_) {
     LOG(LS_WARNING) << "Tried to invoke while destroying the invoker.";
     return;
   }
   thread->PostDelayed(delay_ms, this, id,
                       new ScopedRefMessageData<AsyncClosure>(closure));
 }
 
+GuardedAsyncInvoker::GuardedAsyncInvoker() : thread_(Thread::Current()) {
+  thread_->SignalQueueDestroyed.connect(this,
+                                        &GuardedAsyncInvoker::ThreadDestroyed);
+}
+
+GuardedAsyncInvoker::~GuardedAsyncInvoker() {
+}
+
+void GuardedAsyncInvoker::Flush(uint32 id) {
+  rtc::CritScope cs(&crit_);
+  if (thread_ != nullptr)
+    invoker_.Flush(thread_, id);
+}
+
+void GuardedAsyncInvoker::ThreadDestroyed() {
+  rtc::CritScope cs(&crit_);
+  thread_ = nullptr;

[tommi (sloooow) - chröme, 2015/08/19 20:01:54]

should we DCHECK that thread_ is not nullptr first?  Just to catch a weird state
where we'd somehow get more than one notification.

[magjed_webrtc, 2015/08/20 10:28:33]

Done.

+}
+
 NotifyingAsyncClosureBase::NotifyingAsyncClosureBase(AsyncInvoker* invoker,
                                                      Thread* calling_thread)
     : invoker_(invoker), calling_thread_(calling_thread) {
   calling_thread->SignalQueueDestroyed.connect(
       this, &NotifyingAsyncClosureBase::CancelCallback);
   invoker->SignalInvokerDestroyed.connect(
       this, &NotifyingAsyncClosureBase::CancelCallback);
 }
 
 NotifyingAsyncClosureBase::~NotifyingAsyncClosureBase() {
@@ skipping 10 matching lines @@
 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_ == NULL means do not trigger the callback.
   calling_thread_ = NULL;
 }
 
 }  // namespace rtc