Making AsyncInvoker destructor thread-safe.

webrtc/base/thread_unittest.cc

 /*
  *  Copyright 2004 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 338 matching lines @@
     // Set |out| true and call InvokeSet on |thread|.
     static void SetAndInvokeSet(LockedBool* out,
                                 Thread* thread,
                                 LockedBool* out_inner) {
       out->Set(true);
       InvokeSet(thread, out_inner);
     }
 
     // Asynchronously invoke SetAndInvokeSet on |thread1| and wait until
     // |thread1| starts the call.
-    static void AsyncInvokeSetAndWait(
-        Thread* thread1, Thread* thread2, LockedBool* out) {
+    static void AsyncInvokeSetAndWait(AsyncInvoker* invoker,
+                                      Thread* thread1,
+                                      Thread* thread2,
+                                      LockedBool* out) {
       CriticalSection crit;
       LockedBool async_invoked(false);
 
-      AsyncInvoker invoker;
-      invoker.AsyncInvoke<void>(
+      invoker->AsyncInvoke<void>(
           RTC_FROM_HERE, thread1,
           Bind(&SetAndInvokeSet, &async_invoked, thread2, out));
 
       EXPECT_TRUE_WAIT(async_invoked.Get(), 2000);
     }
   };
 
+  AsyncInvoker invoker;
   LockedBool thread_a_called(false);
 
   // Start the sequence A --(invoke)--> B --(async invoke)--> C --(invoke)--> A.
   // Thread B returns when C receives the call and C should be blocked until A
   // starts to process messages.
   thread_b.Invoke<void>(RTC_FROM_HERE,
-                        Bind(&LocalFuncs::AsyncInvokeSetAndWait, &thread_c,
-                             thread_a, &thread_a_called));
+                        Bind(&LocalFuncs::AsyncInvokeSetAndWait, &invoker,
+                             &thread_c, thread_a, &thread_a_called));
   EXPECT_FALSE(thread_a_called.Get());
 
   EXPECT_TRUE_WAIT(thread_a_called.Get(), 2000);
 }
 
 // Set the name on a thread when the underlying QueueDestroyed signal is
 // triggered. This causes an error if the object is already partially
 // destroyed.
 class SetNameOnSignalQueueDestroyedTester : public sigslot::has_slots<> {
  public:
@@ skipping 126 matching lines @@
         Bind(&AsyncInvokeTest::AsyncInvokeIntCallback,
              static_cast<AsyncInvokeTest*>(this), &invoker, Thread::Current()));
     // Wait for the call to begin.
     ASSERT_TRUE(invoke_started_.Wait(kWaitTimeout));
   }
   // Invoker is destroyed. Function should not execute.
   Thread::Current()->ProcessMessages(kWaitTimeout);
   EXPECT_EQ(0, int_value_);
 }
 
+TEST_F(AsyncInvokeTest, KillInvokerDuringExecute) {
+  // Use these events to get in a state where the functor is in the middle of
+  // executing, and then to wait for it to finish, ensuring the "EXPECT_FALSE"
+  // is run.
+  Event functor_started(false, false);
+  Event functor_continue(false, false);
+  Event functor_finished(false, false);
+
+  Thread thread;
+  thread.Start();
+  volatile bool invoker_destroyed = false;
+  {
+    AsyncInvoker invoker;
+    invoker.AsyncInvoke<void>(RTC_FROM_HERE, &thread,
+                              [&functor_started, &functor_continue,
+                               &functor_finished, &invoker_destroyed] {
+                                functor_started.Set();
+                                functor_continue.Wait(Event::kForever);
+                                rtc::Thread::Current()->SleepMs(kWaitTimeout);
+                                EXPECT_FALSE(invoker_destroyed);
+                                functor_finished.Set();
+                              });
+    functor_started.Wait(Event::kForever);
+
+    // Allow the functor to continue and immediately destroy the invoker.
+    functor_continue.Set();
+  }
+
+  // If the destructor DIDN'T wait for the functor to finish executing, it will
+  // hit the EXPECT_FALSE(invoker_destroyed) after it finishes sleeping for a
+  // second.
+  invoker_destroyed = true;
+  functor_finished.Wait(Event::kForever);
+}
+
 TEST_F(AsyncInvokeTest, Flush) {
   AsyncInvoker invoker;
   AtomicBool flag1;
   AtomicBool flag2;
   // Queue two async calls to the current thread.
   invoker.AsyncInvoke<void>(RTC_FROM_HERE, Thread::Current(), FunctorB(&flag1));
   invoker.AsyncInvoke<void>(RTC_FROM_HERE, Thread::Current(), FunctorB(&flag2));
   // Because we haven't pumped messages, these should not have run yet.
   EXPECT_FALSE(flag1.get());
   EXPECT_FALSE(flag2.get());
@@ skipping 226 matching lines @@
 };
 
 TEST_F(ComThreadTest, ComInited) {
   Thread* thread = new ComThread();
   EXPECT_TRUE(thread->Start());
   thread->Post(RTC_FROM_HERE, this, 0);
   EXPECT_TRUE_WAIT(done_, 1000);
   delete thread;
 }
 #endif