Adding more detail to MessageQueue::Dispatch logging.

webrtc/base/virtualsocket_unittest.cc

 /*
  *  Copyright 2006 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 18 matching lines @@
 
 // Sends at a constant rate but with random packet sizes.
 struct Sender : public MessageHandler {
   Sender(Thread* th, AsyncSocket* s, uint32_t rt)
       : thread(th),
         socket(new AsyncUDPSocket(s)),
         done(false),
         rate(rt),
         count(0) {
     last_send = rtc::TimeMillis();
-    thread->PostDelayed(NextDelay(), this, 1);
+    thread->PostDelayed(RTC_FROM_HERE, NextDelay(), this, 1);
   }
 
   uint32_t NextDelay() {
     uint32_t size = (rand() % 4096) + 1;
     return 1000 * size / rate;
   }
 
   void OnMessage(Message* pmsg) {
     ASSERT_EQ(1u, pmsg->message_id);
 
     if (done)
       return;
 
     int64_t cur_time = rtc::TimeMillis();
     int64_t delay = cur_time - last_send;
     uint32_t size = static_cast<uint32_t>(rate * delay / 1000);
     size = std::min<uint32_t>(size, 4096);
     size = std::max<uint32_t>(size, sizeof(uint32_t));
 
     count += size;
     memcpy(dummy, &cur_time, sizeof(cur_time));
     socket->Send(dummy, size, options);
 
     last_send = cur_time;
-    thread->PostDelayed(NextDelay(), this, 1);
+    thread->PostDelayed(RTC_FROM_HERE, NextDelay(), this, 1);
   }
 
   Thread* thread;
   std::unique_ptr<AsyncUDPSocket> socket;
   rtc::PacketOptions options;
   bool done;
   uint32_t rate;  // bytes per second
   uint32_t count;
   int64_t last_send;
   char dummy[4096];
 };
 
 struct Receiver : public MessageHandler, public sigslot::has_slots<> {
   Receiver(Thread* th, AsyncSocket* s, uint32_t bw)
       : thread(th),
         socket(new AsyncUDPSocket(s)),
         bandwidth(bw),
         done(false),
         count(0),
         sec_count(0),
         sum(0),
         sum_sq(0),
         samples(0) {
     socket->SignalReadPacket.connect(this, &Receiver::OnReadPacket);
-    thread->PostDelayed(1000, this, 1);
+    thread->PostDelayed(RTC_FROM_HERE, 1000, this, 1);
   }
 
   ~Receiver() {
     thread->Clear(this);
   }
 
   void OnReadPacket(AsyncPacketSocket* s, const char* data, size_t size,
                     const SocketAddress& remote_addr,
                     const PacketTime& packet_time) {
     ASSERT_EQ(socket.get(), s);
@@ skipping 14 matching lines @@
     ASSERT_EQ(1u, pmsg->message_id);
 
     if (done)
       return;
 
     // It is always possible for us to receive more than expected because
     // packets can be further delayed in delivery.
     if (bandwidth > 0)
       ASSERT_TRUE(sec_count <= 5 * bandwidth / 4);
     sec_count = 0;
-    thread->PostDelayed(1000, this, 1);
+    thread->PostDelayed(RTC_FROM_HERE, 1000, this, 1);
   }
 
   Thread* thread;
   std::unique_ptr<AsyncUDPSocket> socket;
   uint32_t bandwidth;
   bool done;
   size_t count;
   size_t sec_count;
   double sum;
   double sum_sq;
@@ skipping 917 matching lines @@
           << " N=" << kTestSamples[sidx];
         EXPECT_NEAR(kStdDev, stddev, 0.1 * kStdDev)
           << "M=" << kTestMean[midx]
           << " SD=" << kStdDev
           << " N=" << kTestSamples[sidx];
         delete f;
       }
     }
   }
 }