Adding more detail to MessageQueue::Dispatch logging.

webrtc/p2p/base/transportcontroller.cc

 /*
  *  Copyright 2015 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 33 matching lines @@
 
 TransportController::TransportController(rtc::Thread* signaling_thread,
                                          rtc::Thread* network_thread,
                                          PortAllocator* port_allocator)
     : signaling_thread_(signaling_thread),
       network_thread_(network_thread),
       port_allocator_(port_allocator) {}
 
 TransportController::~TransportController() {
   network_thread_->Invoke<void>(
+      RTC_FROM_HERE,
       rtc::Bind(&TransportController::DestroyAllTransports_n, this));
   signaling_thread_->Clear(this);
 }
 
 bool TransportController::SetSslMaxProtocolVersion(
     rtc::SSLProtocolVersion version) {
-  return network_thread_->Invoke<bool>(rtc::Bind(
-      &TransportController::SetSslMaxProtocolVersion_n, this, version));
+  return network_thread_->Invoke<bool>(
+      RTC_FROM_HERE, rtc::Bind(&TransportController::SetSslMaxProtocolVersion_n,
+                               this, version));
 }
 
 void TransportController::SetIceConfig(const IceConfig& config) {
   network_thread_->Invoke<void>(
+      RTC_FROM_HERE,
       rtc::Bind(&TransportController::SetIceConfig_n, this, config));
 }
 
 void TransportController::SetIceRole(IceRole ice_role) {
   network_thread_->Invoke<void>(
+      RTC_FROM_HERE,
       rtc::Bind(&TransportController::SetIceRole_n, this, ice_role));
 }
 
 bool TransportController::GetSslRole(const std::string& transport_name,
                                      rtc::SSLRole* role) {
-  return network_thread_->Invoke<bool>(rtc::Bind(
-      &TransportController::GetSslRole_n, this, transport_name, role));
+  return network_thread_->Invoke<bool>(
+      RTC_FROM_HERE, rtc::Bind(&TransportController::GetSslRole_n, this,
+                               transport_name, role));
 }
 
 bool TransportController::SetLocalCertificate(
     const rtc::scoped_refptr<rtc::RTCCertificate>& certificate) {
-  return network_thread_->Invoke<bool>(rtc::Bind(
-      &TransportController::SetLocalCertificate_n, this, certificate));
+  return network_thread_->Invoke<bool>(
+      RTC_FROM_HERE, rtc::Bind(&TransportController::SetLocalCertificate_n,
+                               this, certificate));
 }
 
 bool TransportController::GetLocalCertificate(
     const std::string& transport_name,
     rtc::scoped_refptr<rtc::RTCCertificate>* certificate) {
   return network_thread_->Invoke<bool>(
-      rtc::Bind(&TransportController::GetLocalCertificate_n, this,
-                transport_name, certificate));
+      RTC_FROM_HERE, rtc::Bind(&TransportController::GetLocalCertificate_n,
+                               this, transport_name, certificate));
 }
 
 std::unique_ptr<rtc::SSLCertificate>
 TransportController::GetRemoteSSLCertificate(
     const std::string& transport_name) {
   return network_thread_->Invoke<std::unique_ptr<rtc::SSLCertificate>>(
-      rtc::Bind(&TransportController::GetRemoteSSLCertificate_n, this,
-                transport_name));
+      RTC_FROM_HERE, rtc::Bind(&TransportController::GetRemoteSSLCertificate_n,
+                               this, transport_name));
 }
 
 bool TransportController::SetLocalTransportDescription(
     const std::string& transport_name,
     const TransportDescription& tdesc,
     ContentAction action,
     std::string* err) {
   return network_thread_->Invoke<bool>(
+      RTC_FROM_HERE,
       rtc::Bind(&TransportController::SetLocalTransportDescription_n, this,
                 transport_name, tdesc, action, err));
 }
 
 bool TransportController::SetRemoteTransportDescription(
     const std::string& transport_name,
     const TransportDescription& tdesc,
     ContentAction action,
     std::string* err) {
   return network_thread_->Invoke<bool>(
+      RTC_FROM_HERE,
       rtc::Bind(&TransportController::SetRemoteTransportDescription_n, this,
                 transport_name, tdesc, action, err));
 }
 
 void TransportController::MaybeStartGathering() {
   network_thread_->Invoke<void>(
+      RTC_FROM_HERE,
       rtc::Bind(&TransportController::MaybeStartGathering_n, this));
 }
 
 bool TransportController::AddRemoteCandidates(const std::string& transport_name,
                                               const Candidates& candidates,
                                               std::string* err) {
   return network_thread_->Invoke<bool>(
-      rtc::Bind(&TransportController::AddRemoteCandidates_n, this,
-                transport_name, candidates, err));
+      RTC_FROM_HERE, rtc::Bind(&TransportController::AddRemoteCandidates_n,
+                               this, transport_name, candidates, err));
 }
 
 bool TransportController::RemoveRemoteCandidates(const Candidates& candidates,
                                                  std::string* err) {
-  return network_thread_->Invoke<bool>(rtc::Bind(
-      &TransportController::RemoveRemoteCandidates_n, this, candidates, err));
+  return network_thread_->Invoke<bool>(
+      RTC_FROM_HERE, rtc::Bind(&TransportController::RemoveRemoteCandidates_n,
+                               this, candidates, err));
 }
 
 bool TransportController::ReadyForRemoteCandidates(
     const std::string& transport_name) {
-  return network_thread_->Invoke<bool>(rtc::Bind(
-      &TransportController::ReadyForRemoteCandidates_n, this, transport_name));
+  return network_thread_->Invoke<bool>(
+      RTC_FROM_HERE, rtc::Bind(&TransportController::ReadyForRemoteCandidates_n,
+                               this, transport_name));
 }
 
 bool TransportController::GetStats(const std::string& transport_name,
                                    TransportStats* stats) {
   return network_thread_->Invoke<bool>(
+      RTC_FROM_HERE,
       rtc::Bind(&TransportController::GetStats_n, this, transport_name, stats));
 }
 
 TransportChannel* TransportController::CreateTransportChannel_n(
     const std::string& transport_name,
     int component) {
   RTC_DCHECK(network_thread_->IsCurrent());
 
   auto it = FindChannel_n(transport_name, component);
   if (it != channels_.end()) {
@@ skipping 388 matching lines @@
 
   // We should never signal peer-reflexive candidates.
   if (candidate.type() == PRFLX_PORT_TYPE) {
     RTC_DCHECK(false);
     return;
   }
   std::vector<Candidate> candidates;
   candidates.push_back(candidate);
   CandidatesData* data =
       new CandidatesData(channel->transport_name(), candidates);
-  signaling_thread_->Post(this, MSG_CANDIDATESGATHERED, data);
+  signaling_thread_->Post(RTC_FROM_HERE, this, MSG_CANDIDATESGATHERED, data);
 }
 
 void TransportController::OnChannelCandidatesRemoved_n(
     TransportChannelImpl* channel,
     const Candidates& candidates) {
   invoker_.AsyncInvoke<void>(
-      signaling_thread_,
+      RTC_FROM_HERE, signaling_thread_,
       rtc::Bind(&TransportController::OnChannelCandidatesRemoved, this,
                 candidates));
 }
 
 void TransportController::OnChannelCandidatesRemoved(
     const Candidates& candidates) {
   RTC_DCHECK(signaling_thread_->IsCurrent());
   SignalCandidatesRemoved(candidates);
 }
 
@@ skipping 52 matching lines @@
   if (any_failed) {
     new_connection_state = kIceConnectionFailed;
   } else if (all_completed) {
     new_connection_state = kIceConnectionCompleted;
   } else if (all_connected) {
     new_connection_state = kIceConnectionConnected;
   }
   if (connection_state_ != new_connection_state) {
     connection_state_ = new_connection_state;
     signaling_thread_->Post(
-        this, MSG_ICECONNECTIONSTATE,
+        RTC_FROM_HERE, this, MSG_ICECONNECTIONSTATE,
         new rtc::TypedMessageData<IceConnectionState>(new_connection_state));
   }
 
   if (receiving_ != any_receiving) {
     receiving_ = any_receiving;
-    signaling_thread_->Post(this, MSG_RECEIVING,
+    signaling_thread_->Post(RTC_FROM_HERE, this, MSG_RECEIVING,
                             new rtc::TypedMessageData<bool>(any_receiving));
   }
 
   if (all_done_gathering) {
     new_gathering_state = kIceGatheringComplete;
   } else if (any_gathering) {
     new_gathering_state = kIceGatheringGathering;
   }
   if (gathering_state_ != new_gathering_state) {
     gathering_state_ = new_gathering_state;
     signaling_thread_->Post(
-        this, MSG_ICEGATHERINGSTATE,
+        RTC_FROM_HERE, this, MSG_ICEGATHERINGSTATE,
         new rtc::TypedMessageData<IceGatheringState>(new_gathering_state));
   }
 }
 
 }  // namespace cricket