Add helper class GuardedAsyncInvoker to protect against thread dying

webrtc/base/asyncinvoker.h

 /*
  *  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.
  */
 
@@ skipping 126 matching lines @@
                 uint32 id);
   void DoInvokeDelayed(Thread* thread,
                        const scoped_refptr<AsyncClosure>& closure,
                        uint32 delay_ms,
                        uint32 id);
   bool destroying_;
 
   DISALLOW_COPY_AND_ASSIGN(AsyncInvoker);
 };
 
+// Similar to AsyncInvoker, but guards against the Thread being destroyed. It
+// will connect to the current thread in the constructor, and will get notified
+// when that thread is destroyed. After GuardedAsyncInvoker is constructed, it
+// can be used from other threads to post functors to the thread it was
+// constructed on. If that thread dies, any further calls to AsyncInvoke() will
+// be safely ignored.

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

Good comment.  Can we add something like "...being destroyed while there are
outstanding dangling pointers to it" so that the difference between these two
classes is perhaps a little more clear?

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

Done.

+class GuardedAsyncInvoker : public sigslot::has_slots<> {
+ public:
+  GuardedAsyncInvoker();
+  ~GuardedAsyncInvoker() override;
+
+  // Synchronously execute all outstanding calls we own, and wait for calls to
+  // complete before returning. Optionally filter by message id. The destructor
+  // will not wait for outstanding calls, so if that behavior is desired, call
+  // Flush() first.
+  void Flush(uint32 id = MQID_ANY);
+
+  // Call |functor| asynchronously with no callback upon completion. Returns
+  // immediately.
+  template <class ReturnT, class FunctorT>
+  void AsyncInvoke(const FunctorT& functor, uint32 id = 0) {

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

what about making this method return bool and return false in the case where
thread_ == nullptr?

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

Done.

+    rtc::CritScope cs(&crit_);
+    if (thread_ != nullptr)
+      invoker_.AsyncInvoke<ReturnT, FunctorT>(thread_, functor, id);
+  }
+
+  // Call |functor| asynchronously with |delay_ms|, with no callback upon
+  // completion. Returns immediately.
+  template <class ReturnT, class FunctorT>
+  void AsyncInvokeDelayed(const FunctorT& functor,
+                          uint32 delay_ms,
+                          uint32 id = 0) {
+    rtc::CritScope cs(&crit_);
+    if (thread_ != nullptr)

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

{} (and below)

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

Acknowledged.

+      invoker_.AsyncInvokeDelayed<ReturnT, FunctorT>(thread_, functor,
+                                                      delay_ms, id);
+  }
+
+  // Call |functor| asynchronously, calling |callback| when done.
+  template <class ReturnT, class FunctorT, class HostT>
+  void AsyncInvoke(const FunctorT& functor,
+                   void (HostT::*callback)(ReturnT),
+                   HostT* callback_host,
+                   uint32 id = 0) {
+    rtc::CritScope cs(&crit_);
+    if (thread_ != nullptr)
+      invoker_.AsyncInvoke<ReturnT, FunctorT, HostT>(
+          thread_, functor, callback, callback_host, id);
+  }
+
+  // Call |functor| asynchronously calling |callback| when done. Overloaded for
+  // void return.
+  template <class ReturnT, class FunctorT, class HostT>
+  void AsyncInvoke(const FunctorT& functor,
+                   void (HostT::*callback)(),
+                   HostT* callback_host,
+                   uint32 id = 0) {
+    rtc::CritScope cs(&crit_);
+    if (thread_ != nullptr)
+      invoker_.AsyncInvoke<ReturnT, FunctorT, HostT>(
+          thread_, functor, callback, callback_host, id);
+  }
+
+ private:
+  // Callback when |thread_| is destroyed.
+  void ThreadDestroyed();
+
+  CriticalSection crit_;
+  Thread* thread_ GUARDED_BY(crit_);
+  AsyncInvoker invoker_ GUARDED_BY(crit_);
+};
+
 }  // namespace rtc
 
-
 #endif  // WEBRTC_BASE_ASYNCINVOKER_H_