Adding more detail to MessageQueue::Dispatch logging.

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 54 matching lines @@
 
   SocketAddress address() const { return socket_->GetLocalAddress(); }
 
   void OnPacket(AsyncPacketSocket* socket, const char* buf, size_t size,
                 const SocketAddress& remote_addr,
                 const PacketTime& packet_time) {
     EXPECT_EQ(size, sizeof(uint32_t));
     uint32_t prev = reinterpret_cast<const uint32_t*>(buf)[0];
     uint32_t result = Next(prev);
 
-    post_thread_->PostDelayed(200, post_handler_, 0, new TestMessage(result));
+    post_thread_->PostDelayed(RTC_FROM_HERE, 200, post_handler_, 0,
+                              new TestMessage(result));
   }
 
  private:
   AsyncUDPSocket* socket_;
   Thread* post_thread_;
   MessageHandler* post_handler_;
 };
 
 // Receives messages and sends on a socket.
 class MessageClient : public MessageHandler, public TestGenerator {
@@ skipping 118 matching lines @@
   AsyncSocket* asocket =
       th2.socketserver()->CreateAsyncSocket(addr.family(), SOCK_DGRAM);
   SocketClient sock_client(asocket, addr, &th1, &msg_client);
 
   socket->Connect(sock_client.address());
 
   th1.Start();
   th2.Start();
 
   // Get the messages started.
-  th1.PostDelayed(100, &msg_client, 0, new TestMessage(1));
+  th1.PostDelayed(RTC_FROM_HERE, 100, &msg_client, 0, new TestMessage(1));
 
   // Give the clients a little while to run.
   // Messages will be processed at 100, 300, 500, 700, 900.
   Thread* th_main = Thread::Current();
   th_main->ProcessMessages(1000);
 
   // Stop the sending client. Give the receiver a bit longer to run, in case
   // it is running on a machine that is under load (e.g. the build machine).
   th1.Stop();
   th_main->ProcessMessages(200);
@@ skipping 40 matching lines @@
   EXPECT_FALSE(cthread->RunningForTest());
   delete cthread;
   current_thread->WrapCurrent();
 }
 
 TEST(ThreadTest, Invoke) {
   // Create and start the thread.
   Thread thread;
   thread.Start();
   // Try calling functors.
-  EXPECT_EQ(42, thread.Invoke<int>(FunctorA()));
+  EXPECT_EQ(42, thread.Invoke<int>(RTC_FROM_HERE, FunctorA()));
   AtomicBool called;
   FunctorB f2(&called);
-  thread.Invoke<void>(f2);
+  thread.Invoke<void>(RTC_FROM_HERE, f2);
   EXPECT_TRUE(called.get());
   // Try calling bare functions.
   struct LocalFuncs {
     static int Func1() { return 999; }
     static void Func2() {}
   };
-  EXPECT_EQ(999, thread.Invoke<int>(&LocalFuncs::Func1));
-  thread.Invoke<void>(&LocalFuncs::Func2);
+  EXPECT_EQ(999, thread.Invoke<int>(RTC_FROM_HERE, &LocalFuncs::Func1));
+  thread.Invoke<void>(RTC_FROM_HERE, &LocalFuncs::Func2);
 }
 
 // Verifies that two threads calling Invoke on each other at the same time does
 // not deadlock.
 TEST(ThreadTest, TwoThreadsInvokeNoDeadlock) {
   AutoThread thread;
   Thread* current_thread = Thread::Current();
   ASSERT_TRUE(current_thread != NULL);
 
   Thread other_thread;
   other_thread.Start();
 
   struct LocalFuncs {
     static void Set(bool* out) { *out = true; }
     static void InvokeSet(Thread* thread, bool* out) {
-      thread->Invoke<void>(Bind(&Set, out));
+      thread->Invoke<void>(RTC_FROM_HERE, Bind(&Set, out));
     }
   };
 
   bool called = false;
   other_thread.Invoke<void>(
-      Bind(&LocalFuncs::InvokeSet, current_thread, &called));
+      RTC_FROM_HERE, Bind(&LocalFuncs::InvokeSet, current_thread, &called));
 
   EXPECT_TRUE(called);
 }
 
 // Verifies that if thread A invokes a call on thread B and thread C is trying
 // to invoke A at the same time, thread A does not handle C's invoke while
 // invoking B.
 TEST(ThreadTest, ThreeThreadsInvoke) {
   AutoThread thread;
   Thread* thread_a = Thread::Current();
@@ skipping 16 matching lines @@
     }
 
    private:
     CriticalSection crit_;
     bool value_ GUARDED_BY(crit_);
   };
 
   struct LocalFuncs {
     static void Set(LockedBool* out) { out->Set(true); }
     static void InvokeSet(Thread* thread, LockedBool* out) {
-      thread->Invoke<void>(Bind(&Set, out));
+      thread->Invoke<void>(RTC_FROM_HERE, Bind(&Set, out));
     }
 
     // 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) {
       CriticalSection crit;
       LockedBool async_invoked(false);
 
       AsyncInvoker invoker;
       invoker.AsyncInvoke<void>(
-          thread1, Bind(&SetAndInvokeSet, &async_invoked, thread2, out));
+          RTC_FROM_HERE, thread1,
+          Bind(&SetAndInvokeSet, &async_invoked, thread2, out));
 
       EXPECT_TRUE_WAIT(async_invoked.Get(), 2000);
     }
   };
 
   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>(Bind(&LocalFuncs::AsyncInvokeSetAndWait,
-                             &thread_c, thread_a, &thread_a_called));
+  thread_b.Invoke<void>(RTC_FROM_HERE,
+                        Bind(&LocalFuncs::AsyncInvokeSetAndWait, &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 29 matching lines @@
 }
 
 class AsyncInvokeTest : public testing::Test {
  public:
   void IntCallback(int value) {
     EXPECT_EQ(expected_thread_, Thread::Current());
     int_value_ = value;
   }
   void AsyncInvokeIntCallback(AsyncInvoker* invoker, Thread* thread) {
     expected_thread_ = thread;
-    invoker->AsyncInvoke(thread, FunctorC(),
+    invoker->AsyncInvoke(RTC_FROM_HERE, RTC_FROM_HERE, thread, FunctorC(),
                          &AsyncInvokeTest::IntCallback,
                          static_cast<AsyncInvokeTest*>(this));
     invoke_started_.Set();
   }
   void SetExpectedThreadForIntCallback(Thread* thread) {
     expected_thread_ = thread;
   }
 
  protected:
   enum { kWaitTimeout = 1000 };
   AsyncInvokeTest()
       : int_value_(0),
         invoke_started_(true, false),
         expected_thread_(NULL) {}
 
   int int_value_;
   Event invoke_started_;
   Thread* expected_thread_;
 };
 
 TEST_F(AsyncInvokeTest, FireAndForget) {
   AsyncInvoker invoker;
   // Create and start the thread.
   Thread thread;
   thread.Start();
   // Try calling functor.
   AtomicBool called;
-  invoker.AsyncInvoke<void>(&thread, FunctorB(&called));
+  invoker.AsyncInvoke<void>(RTC_FROM_HERE, &thread, FunctorB(&called));
   EXPECT_TRUE_WAIT(called.get(), kWaitTimeout);
 }
 
 TEST_F(AsyncInvokeTest, WithCallback) {
   AsyncInvoker invoker;
   // Create and start the thread.
   Thread thread;
   thread.Start();
   // Try calling functor.
   SetExpectedThreadForIntCallback(Thread::Current());
-  invoker.AsyncInvoke(&thread, FunctorA(),
+  invoker.AsyncInvoke(RTC_FROM_HERE, RTC_FROM_HERE, &thread, FunctorA(),
                       &AsyncInvokeTest::IntCallback,
                       static_cast<AsyncInvokeTest*>(this));
   EXPECT_EQ_WAIT(42, int_value_, kWaitTimeout);
 }
 
 TEST_F(AsyncInvokeTest, CancelInvoker) {
   // Create and start the thread.
   Thread thread;
   thread.Start();
   // Try destroying invoker during call.
   {
     AsyncInvoker invoker;
-    invoker.AsyncInvoke(&thread, FunctorC(),
+    invoker.AsyncInvoke(RTC_FROM_HERE, RTC_FROM_HERE, &thread, FunctorC(),
                         &AsyncInvokeTest::IntCallback,
                         static_cast<AsyncInvokeTest*>(this));
   }
   // With invoker gone, callback should be cancelled.
   Thread::Current()->ProcessMessages(kWaitTimeout);
   EXPECT_EQ(0, int_value_);
 }
 
 TEST_F(AsyncInvokeTest, CancelCallingThread) {
   AsyncInvoker invoker;
   { // Create and start the thread.
     Thread thread;
     thread.Start();
     // Try calling functor.
-    thread.Invoke<void>(Bind(&AsyncInvokeTest::AsyncInvokeIntCallback,
-                             static_cast<AsyncInvokeTest*>(this),
-                             &invoker, Thread::Current()));
+    thread.Invoke<void>(
+        RTC_FROM_HERE,
+        Bind(&AsyncInvokeTest::AsyncInvokeIntCallback,
+             static_cast<AsyncInvokeTest*>(this), &invoker, Thread::Current()));
     // Wait for the call to begin.
     ASSERT_TRUE(invoke_started_.Wait(kWaitTimeout));
   }
   // Calling thread is gone. Return message shouldn't happen.
   Thread::Current()->ProcessMessages(kWaitTimeout);
   EXPECT_EQ(0, int_value_);
 }
 
 TEST_F(AsyncInvokeTest, KillInvokerBeforeExecute) {
   Thread thread;
   thread.Start();
   {
     AsyncInvoker invoker;
     // Try calling functor.
-    thread.Invoke<void>(Bind(&AsyncInvokeTest::AsyncInvokeIntCallback,
-                             static_cast<AsyncInvokeTest*>(this),
-                             &invoker, Thread::Current()));
+    thread.Invoke<void>(
+        RTC_FROM_HERE,
+        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, Flush) {
   AsyncInvoker invoker;
   AtomicBool flag1;
   AtomicBool flag2;
   // Queue two async calls to the current thread.
-  invoker.AsyncInvoke<void>(Thread::Current(),
-                            FunctorB(&flag1));
-  invoker.AsyncInvoke<void>(Thread::Current(),
-                            FunctorB(&flag2));
+  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());
   // Force them to run now.
   invoker.Flush(Thread::Current());
   EXPECT_TRUE(flag1.get());
   EXPECT_TRUE(flag2.get());
 }
 
 TEST_F(AsyncInvokeTest, FlushWithIds) {
   AsyncInvoker invoker;
   AtomicBool flag1;
   AtomicBool flag2;
   // Queue two async calls to the current thread, one with a message id.
-  invoker.AsyncInvoke<void>(Thread::Current(),
-                            FunctorB(&flag1),
+  invoker.AsyncInvoke<void>(RTC_FROM_HERE, Thread::Current(), FunctorB(&flag1),
                             5);
-  invoker.AsyncInvoke<void>(Thread::Current(),
-                            FunctorB(&flag2));
+  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());
   // Execute pending calls with id == 5.
   invoker.Flush(Thread::Current(), 5);
   EXPECT_TRUE(flag1.get());
   EXPECT_FALSE(flag2.get());
   flag1 = false;
   // Execute all pending calls. The id == 5 call should not execute again.
   invoker.Flush(Thread::Current());
   EXPECT_FALSE(flag1.get());
   EXPECT_TRUE(flag2.get());
 }
 
 class GuardedAsyncInvokeTest : public testing::Test {
  public:
   void IntCallback(int value) {
     EXPECT_EQ(expected_thread_, Thread::Current());
     int_value_ = value;
   }
   void AsyncInvokeIntCallback(GuardedAsyncInvoker* invoker, Thread* thread) {
     expected_thread_ = thread;
-    invoker->AsyncInvoke(FunctorC(), &GuardedAsyncInvokeTest::IntCallback,
+    invoker->AsyncInvoke(RTC_FROM_HERE, RTC_FROM_HERE, FunctorC(),
+                         &GuardedAsyncInvokeTest::IntCallback,
                          static_cast<GuardedAsyncInvokeTest*>(this));
     invoke_started_.Set();
   }
   void SetExpectedThreadForIntCallback(Thread* thread) {
     expected_thread_ = thread;
   }
 
  protected:
   const static int kWaitTimeout = 1000;
   GuardedAsyncInvokeTest()
@@ skipping 14 matching lines @@
   std::unique_ptr<GuardedAsyncInvoker>* invoker_;
 };
 
 // Test that we can call AsyncInvoke<void>() after the thread died.
 TEST_F(GuardedAsyncInvokeTest, KillThreadFireAndForget) {
   // Create and start the thread.
   std::unique_ptr<Thread> thread(new Thread());
   thread->Start();
   std::unique_ptr<GuardedAsyncInvoker> invoker;
   // Create the invoker on |thread|.
-  thread->Invoke<void>(CreateInvoker(&invoker));
+  thread->Invoke<void>(RTC_FROM_HERE, CreateInvoker(&invoker));
   // Kill |thread|.
   thread = nullptr;
   // Try calling functor.
   AtomicBool called;
-  EXPECT_FALSE(invoker->AsyncInvoke<void>(FunctorB(&called)));
+  EXPECT_FALSE(invoker->AsyncInvoke<void>(RTC_FROM_HERE, FunctorB(&called)));
   // With thread gone, nothing should happen.
   WAIT(called.get(), kWaitTimeout);
   EXPECT_FALSE(called.get());
 }
 
 // Test that we can call AsyncInvoke with callback after the thread died.
 TEST_F(GuardedAsyncInvokeTest, KillThreadWithCallback) {
   // Create and start the thread.
   std::unique_ptr<Thread> thread(new Thread());
   thread->Start();
   std::unique_ptr<GuardedAsyncInvoker> invoker;
   // Create the invoker on |thread|.
-  thread->Invoke<void>(CreateInvoker(&invoker));
+  thread->Invoke<void>(RTC_FROM_HERE, CreateInvoker(&invoker));
   // Kill |thread|.
   thread = nullptr;
   // Try calling functor.
   EXPECT_FALSE(
-      invoker->AsyncInvoke(FunctorC(), &GuardedAsyncInvokeTest::IntCallback,
+      invoker->AsyncInvoke(RTC_FROM_HERE, RTC_FROM_HERE, FunctorC(),
+                           &GuardedAsyncInvokeTest::IntCallback,
                            static_cast<GuardedAsyncInvokeTest*>(this)));
   // With thread gone, callback should be cancelled.
   Thread::Current()->ProcessMessages(kWaitTimeout);
   EXPECT_EQ(0, int_value_);
 }
 
 // The remaining tests check that GuardedAsyncInvoker behaves as AsyncInvoker
 // when Thread is still alive.
 TEST_F(GuardedAsyncInvokeTest, FireAndForget) {
   GuardedAsyncInvoker invoker;
   // Try calling functor.
   AtomicBool called;
-  EXPECT_TRUE(invoker.AsyncInvoke<void>(FunctorB(&called)));
+  EXPECT_TRUE(invoker.AsyncInvoke<void>(RTC_FROM_HERE, FunctorB(&called)));
   EXPECT_TRUE_WAIT(called.get(), kWaitTimeout);
 }
 
 TEST_F(GuardedAsyncInvokeTest, WithCallback) {
   GuardedAsyncInvoker invoker;
   // Try calling functor.
   SetExpectedThreadForIntCallback(Thread::Current());
-  EXPECT_TRUE(invoker.AsyncInvoke(FunctorA(),
+  EXPECT_TRUE(invoker.AsyncInvoke(RTC_FROM_HERE, RTC_FROM_HERE, FunctorA(),
                                   &GuardedAsyncInvokeTest::IntCallback,
                                   static_cast<GuardedAsyncInvokeTest*>(this)));
   EXPECT_EQ_WAIT(42, int_value_, kWaitTimeout);
 }
 
 TEST_F(GuardedAsyncInvokeTest, CancelInvoker) {
   // Try destroying invoker during call.
   {
     GuardedAsyncInvoker invoker;
     EXPECT_TRUE(
-        invoker.AsyncInvoke(FunctorC(), &GuardedAsyncInvokeTest::IntCallback,
+        invoker.AsyncInvoke(RTC_FROM_HERE, RTC_FROM_HERE, FunctorC(),
+                            &GuardedAsyncInvokeTest::IntCallback,
                             static_cast<GuardedAsyncInvokeTest*>(this)));
   }
   // With invoker gone, callback should be cancelled.
   Thread::Current()->ProcessMessages(kWaitTimeout);
   EXPECT_EQ(0, int_value_);
 }
 
 TEST_F(GuardedAsyncInvokeTest, CancelCallingThread) {
   GuardedAsyncInvoker invoker;
   // Try destroying calling thread during call.
   {
     Thread thread;
     thread.Start();
     // Try calling functor.
-    thread.Invoke<void>(Bind(&GuardedAsyncInvokeTest::AsyncInvokeIntCallback,
+    thread.Invoke<void>(RTC_FROM_HERE,
+                        Bind(&GuardedAsyncInvokeTest::AsyncInvokeIntCallback,
                              static_cast<GuardedAsyncInvokeTest*>(this),
                              &invoker, Thread::Current()));
     // Wait for the call to begin.
     ASSERT_TRUE(invoke_started_.Wait(kWaitTimeout));
   }
   // Calling thread is gone. Return message shouldn't happen.
   Thread::Current()->ProcessMessages(kWaitTimeout);
   EXPECT_EQ(0, int_value_);
 }
 
 TEST_F(GuardedAsyncInvokeTest, KillInvokerBeforeExecute) {
   Thread thread;
   thread.Start();
   {
     GuardedAsyncInvoker invoker;
     // Try calling functor.
-    thread.Invoke<void>(Bind(&GuardedAsyncInvokeTest::AsyncInvokeIntCallback,
+    thread.Invoke<void>(RTC_FROM_HERE,
+                        Bind(&GuardedAsyncInvokeTest::AsyncInvokeIntCallback,
                              static_cast<GuardedAsyncInvokeTest*>(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(GuardedAsyncInvokeTest, Flush) {
   GuardedAsyncInvoker invoker;
   AtomicBool flag1;
   AtomicBool flag2;
   // Queue two async calls to the current thread.
-  EXPECT_TRUE(invoker.AsyncInvoke<void>(FunctorB(&flag1)));
-  EXPECT_TRUE(invoker.AsyncInvoke<void>(FunctorB(&flag2)));
+  EXPECT_TRUE(invoker.AsyncInvoke<void>(RTC_FROM_HERE, FunctorB(&flag1)));
+  EXPECT_TRUE(invoker.AsyncInvoke<void>(RTC_FROM_HERE, FunctorB(&flag2)));
   // Because we haven't pumped messages, these should not have run yet.
   EXPECT_FALSE(flag1.get());
   EXPECT_FALSE(flag2.get());
   // Force them to run now.
   EXPECT_TRUE(invoker.Flush());
   EXPECT_TRUE(flag1.get());
   EXPECT_TRUE(flag2.get());
 }
 
 TEST_F(GuardedAsyncInvokeTest, FlushWithIds) {
   GuardedAsyncInvoker invoker;
   AtomicBool flag1;
   AtomicBool flag2;
   // Queue two async calls to the current thread, one with a message id.
-  EXPECT_TRUE(invoker.AsyncInvoke<void>(FunctorB(&flag1), 5));
-  EXPECT_TRUE(invoker.AsyncInvoke<void>(FunctorB(&flag2)));
+  EXPECT_TRUE(invoker.AsyncInvoke<void>(RTC_FROM_HERE, FunctorB(&flag1), 5));
+  EXPECT_TRUE(invoker.AsyncInvoke<void>(RTC_FROM_HERE, FunctorB(&flag2)));
   // Because we haven't pumped messages, these should not have run yet.
   EXPECT_FALSE(flag1.get());
   EXPECT_FALSE(flag2.get());
   // Execute pending calls with id == 5.
   EXPECT_TRUE(invoker.Flush(5));
   EXPECT_TRUE(flag1.get());
   EXPECT_FALSE(flag2.get());
   flag1 = false;
   // Execute all pending calls. The id == 5 call should not execute again.
   EXPECT_TRUE(invoker.Flush());
@@ skipping 14 matching lines @@
       CoUninitialize();
     }
     done_ = true;
   }
   bool done_;
 };
 
 TEST_F(ComThreadTest, ComInited) {
   Thread* thread = new ComThread();
   EXPECT_TRUE(thread->Start());
-  thread->Post(this, 0);
+  thread->Post(RTC_FROM_HERE, this, 0);
   EXPECT_TRUE_WAIT(done_, 1000);
   delete thread;
 }
 #endif