Adding more detail to MessageQueue::Dispatch logging.

webrtc/p2p/base/turnserver.cc

 /*
  *  Copyright 2012 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 613 matching lines @@
   ASSERT(username_attr != NULL);
   username_ = username_attr->GetString();
   const StunByteStringAttribute* origin_attr =
       msg->GetByteString(STUN_ATTR_ORIGIN);
   if (origin_attr) {
     origin_ = origin_attr->GetString();
   }
 
   // Figure out the lifetime and start the allocation timer.
   int lifetime_secs = ComputeLifetime(msg);
-  thread_->PostDelayed(lifetime_secs * 1000, this, MSG_ALLOCATION_TIMEOUT);
+  thread_->PostDelayed(RTC_FROM_HERE, lifetime_secs * 1000, this,
+                       MSG_ALLOCATION_TIMEOUT);
 
   LOG_J(LS_INFO, this) << "Created allocation, lifetime=" << lifetime_secs;
 
   // We've already validated all the important bits; just send a response here.
   TurnMessage response;
   InitResponse(msg, &response);
 
   StunAddressAttribute* mapped_addr_attr =
       new StunXorAddressAttribute(STUN_ATTR_XOR_MAPPED_ADDRESS, conn_.src());
   StunAddressAttribute* relayed_addr_attr =
       new StunXorAddressAttribute(STUN_ATTR_XOR_RELAYED_ADDRESS,
           external_socket_->GetLocalAddress());
   StunUInt32Attribute* lifetime_attr =
       new StunUInt32Attribute(STUN_ATTR_LIFETIME, lifetime_secs);
   VERIFY(response.AddAttribute(mapped_addr_attr));
   VERIFY(response.AddAttribute(relayed_addr_attr));
   VERIFY(response.AddAttribute(lifetime_attr));
 
   SendResponse(&response);
 }
 
 void TurnServerAllocation::HandleRefreshRequest(const TurnMessage* msg) {
   // Figure out the new lifetime.
   int lifetime_secs = ComputeLifetime(msg);
 
   // Reset the expiration timer.
   thread_->Clear(this, MSG_ALLOCATION_TIMEOUT);
-  thread_->PostDelayed(lifetime_secs * 1000, this, MSG_ALLOCATION_TIMEOUT);
+  thread_->PostDelayed(RTC_FROM_HERE, lifetime_secs * 1000, this,
+                       MSG_ALLOCATION_TIMEOUT);
 
   LOG_J(LS_INFO, this) << "Refreshed allocation, lifetime=" << lifetime_secs;
 
   // Send a success response with a LIFETIME attribute.
   TurnMessage response;
   InitResponse(msg, &response);
 
   StunUInt32Attribute* lifetime_attr =
       new StunUInt32Attribute(STUN_ATTR_LIFETIME, lifetime_secs);
   VERIFY(response.AddAttribute(lifetime_attr));
@@ skipping 244 matching lines @@
     : thread_(thread), peer_(peer) {
   Refresh();
 }
 
 TurnServerAllocation::Permission::~Permission() {
   thread_->Clear(this, MSG_ALLOCATION_TIMEOUT);
 }
 
 void TurnServerAllocation::Permission::Refresh() {
   thread_->Clear(this, MSG_ALLOCATION_TIMEOUT);
-  thread_->PostDelayed(kPermissionTimeout, this, MSG_ALLOCATION_TIMEOUT);
+  thread_->PostDelayed(RTC_FROM_HERE, kPermissionTimeout, this,
+                       MSG_ALLOCATION_TIMEOUT);
 }
 
 void TurnServerAllocation::Permission::OnMessage(rtc::Message* msg) {
   ASSERT(msg->message_id == MSG_ALLOCATION_TIMEOUT);
   SignalDestroyed(this);
   delete this;
 }
 
 TurnServerAllocation::Channel::Channel(rtc::Thread* thread, int id,
                              const rtc::SocketAddress& peer)
     : thread_(thread), id_(id), peer_(peer) {
   Refresh();
 }
 
 TurnServerAllocation::Channel::~Channel() {
   thread_->Clear(this, MSG_ALLOCATION_TIMEOUT);
 }
 
 void TurnServerAllocation::Channel::Refresh() {
   thread_->Clear(this, MSG_ALLOCATION_TIMEOUT);
-  thread_->PostDelayed(kChannelTimeout, this, MSG_ALLOCATION_TIMEOUT);
+  thread_->PostDelayed(RTC_FROM_HERE, kChannelTimeout, this,
+                       MSG_ALLOCATION_TIMEOUT);
 }
 
 void TurnServerAllocation::Channel::OnMessage(rtc::Message* msg) {
   ASSERT(msg->message_id == MSG_ALLOCATION_TIMEOUT);
   SignalDestroyed(this);
   delete this;
 }
 
 }  // namespace cricket