Adding more detail to MessageQueue::Dispatch logging.

webrtc/p2p/base/pseudotcp_unittest.cc

 /*
  *  Copyright 2011 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 129 matching lines @@
                                      const char* buffer, size_t len) {
     // Randomly drop the desired percentage of packets.
     // Also drop packets that are larger than the configured MTU.
     if (rtc::CreateRandomId() % 100 < static_cast<uint32_t>(loss_)) {
       LOG(LS_VERBOSE) << "Randomly dropping packet, size=" << len;
     } else if (len > static_cast<size_t>(std::min(local_mtu_, remote_mtu_))) {
       LOG(LS_VERBOSE) << "Dropping packet that exceeds path MTU, size=" << len;
     } else {
       int id = (tcp == &local_) ? MSG_RPACKET : MSG_LPACKET;
       std::string packet(buffer, len);
-      rtc::Thread::Current()->PostDelayed(delay_, this, id,
-          rtc::WrapMessageData(packet));
+      rtc::Thread::Current()->PostDelayed(RTC_FROM_HERE, delay_, this, id,
+                                          rtc::WrapMessageData(packet));
     }
     return WR_SUCCESS;
   }
 
   void UpdateLocalClock() { UpdateClock(&local_, MSG_LCLOCK); }
   void UpdateRemoteClock() { UpdateClock(&remote_, MSG_RCLOCK); }
   void UpdateClock(PseudoTcp* tcp, uint32_t message) {
     long interval = 0;  // NOLINT
     tcp->GetNextClock(PseudoTcp::Now(), interval);
     interval = std::max<int>(interval, 0L);  // sometimes interval is < 0
     rtc::Thread::Current()->Clear(this, message);
-    rtc::Thread::Current()->PostDelayed(interval, this, message);
+    rtc::Thread::Current()->PostDelayed(RTC_FROM_HERE, interval, this, message);
   }
 
   virtual void OnMessage(rtc::Message* message) {
     switch (message->message_id) {
       case MSG_LPACKET: {
         const std::string& s(
             rtc::UseMessageData<std::string>(message->pdata));
         local_.NotifyPacket(s.c_str(), s.size());
         UpdateLocalClock();
         break;
@@ skipping 276 matching lines @@
     }
     send_stream_.Rewind();
 
     // Prepare the receive stream.
     recv_stream_.ReserveSize(size);
 
     // Connect and wait until connected.
     EXPECT_EQ(0, Connect());
     EXPECT_TRUE_WAIT(have_connected_, kConnectTimeoutMs);
 
-    rtc::Thread::Current()->Post(this, MSG_WRITE);
+    rtc::Thread::Current()->Post(RTC_FROM_HERE, this, MSG_WRITE);
     EXPECT_TRUE_WAIT(have_disconnected_, kTransferTimeoutMs);
 
     ASSERT_EQ(2u, send_position_.size());
     ASSERT_EQ(2u, recv_position_.size());
 
     const size_t estimated_recv_window = EstimateReceiveWindowSize();
 
     // The difference in consecutive send positions should equal the
     // receive window size or match very closely. This verifies that receive
     // window is open after receiver drained all the data.
@@ skipping 85 matching lines @@
 
     int message_queue_size =
         static_cast<int>(rtc::Thread::Current()->size());
     // The message queue will always have at least 2 messages, an RCLOCK and
     // an LCLOCK, since they are added back on the delay queue at the same time
     // they are pulled off and therefore are never really removed.
     if (message_queue_size > 2) {
       // If there are non-clock messages remaining, attempt to continue sending
       // after giving those messages time to process, which should free up the
       // send buffer.
-      rtc::Thread::Current()->PostDelayed(10, this, MSG_WRITE);
+      rtc::Thread::Current()->PostDelayed(RTC_FROM_HERE, 10, this, MSG_WRITE);
     } else {
       if (!remote_.isReceiveBufferFull()) {
         LOG(LS_ERROR) << "This shouldn't happen - the send buffer is full, "
                       << "the receive buffer is not, and there are no "
                       << "remaining messages to process.";
       }
       send_stream_.GetPosition(&position);
       send_position_.push_back(position);
 
       // Drain the receiver buffer.
@@ skipping 255 matching lines @@
 /* Test sending data with mismatched MTUs. We should detect this and reduce
 // our packet size accordingly.
 // TODO: This doesn't actually work right now. The current code
 // doesn't detect if the MTU is set too high on either side.
 TEST_F(PseudoTcpTest, TestSendWithMismatchedMtus) {
   SetLocalMtu(1500);
   SetRemoteMtu(1280);
   TestTransfer(1000000);
 }
 */