Adding more detail to MessageQueue::Dispatch logging.

webrtc/pc/channel.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 189 matching lines @@
   // Eats any outstanding messages or packets.
   worker_thread_->Clear(&invoker_);
   worker_thread_->Clear(this);
   // We must destroy the media channel before the transport channel, otherwise
   // the media channel may try to send on the dead transport channel. NULLing
   // is not an effective strategy since the sends will come on another thread.
   delete media_channel_;
   // Note that we don't just call SetTransportChannel_n(nullptr) because that
   // would call a pure virtual method which we can't do from a destructor.
   network_thread_->Invoke<void>(
-      Bind(&BaseChannel::DestroyTransportChannels_n, this));
+      RTC_FROM_HERE, Bind(&BaseChannel::DestroyTransportChannels_n, this));
   LOG(LS_INFO) << "Destroyed channel";
 }
 
 void BaseChannel::DisconnectTransportChannels_n() {
   // Send any outstanding RTCP packets.
   FlushRtcpMessages_n();
 
   // Stop signals from transport channels, but keep them alive because
   // media_channel may use them from a different thread.
   if (transport_channel_) {
@@ skipping 17 matching lines @@
     transport_controller_->DestroyTransportChannel_n(
         transport_name_, cricket::ICE_CANDIDATE_COMPONENT_RTCP);
   }
   // Clear pending send packets/messages.
   network_thread_->Clear(&invoker_);
   network_thread_->Clear(this);
 }
 
 bool BaseChannel::Init_w(const std::string* bundle_transport_name) {
   if (!network_thread_->Invoke<bool>(
+          RTC_FROM_HERE,
           Bind(&BaseChannel::InitNetwork_n, this, bundle_transport_name))) {
     return false;
   }
 
   // Both RTP and RTCP channels are set, we can call SetInterface on
   // media channel and it can set network options.
   RTC_DCHECK(worker_thread_->IsCurrent());
   media_channel_->SetInterface(this);
   return true;
 }
@@ skipping 16 matching lines @@
   return true;
 }
 
 void BaseChannel::Deinit() {
   RTC_DCHECK(worker_thread_->IsCurrent());
   media_channel_->SetInterface(NULL);
   // Packets arrive on the network thread, processing packets calls virtual
   // functions, so need to stop this process in Deinit that is called in
   // derived classes destructor.
   network_thread_->Invoke<void>(
-      Bind(&BaseChannel::DisconnectTransportChannels_n, this));
+      RTC_FROM_HERE, Bind(&BaseChannel::DisconnectTransportChannels_n, this));
 }
 
 bool BaseChannel::SetTransport(const std::string& transport_name) {
   return network_thread_->Invoke<bool>(
-      Bind(&BaseChannel::SetTransport_n, this, transport_name));
+      RTC_FROM_HERE, Bind(&BaseChannel::SetTransport_n, this, transport_name));
 }
 
 bool BaseChannel::SetTransport_n(const std::string& transport_name) {
   RTC_DCHECK(network_thread_->IsCurrent());
 
   if (transport_name == transport_name_) {
     // Nothing to do if transport name isn't changing
     return true;
   }
 
@@ skipping 123 matching lines @@
 
   tc->SignalWritableState.disconnect(this);
   tc->SignalReadPacket.disconnect(this);
   tc->SignalReadyToSend.disconnect(this);
   tc->SignalDtlsState.disconnect(this);
   tc->SignalSelectedCandidatePairChanged.disconnect(this);
   tc->SignalSentPacket.disconnect(this);
 }
 
 bool BaseChannel::Enable(bool enable) {
-  worker_thread_->Invoke<void>(Bind(
-      enable ? &BaseChannel::EnableMedia_w : &BaseChannel::DisableMedia_w,
-      this));
+  worker_thread_->Invoke<void>(
+      RTC_FROM_HERE,
+      Bind(enable ? &BaseChannel::EnableMedia_w : &BaseChannel::DisableMedia_w,
+           this));
   return true;
 }
 
 bool BaseChannel::AddRecvStream(const StreamParams& sp) {
-  return InvokeOnWorker(Bind(&BaseChannel::AddRecvStream_w, this, sp));
+  return InvokeOnWorker(RTC_FROM_HERE,
+                        Bind(&BaseChannel::AddRecvStream_w, this, sp));
 }
 
 bool BaseChannel::RemoveRecvStream(uint32_t ssrc) {
-  return InvokeOnWorker(Bind(&BaseChannel::RemoveRecvStream_w, this, ssrc));
+  return InvokeOnWorker(RTC_FROM_HERE,
+                        Bind(&BaseChannel::RemoveRecvStream_w, this, ssrc));
 }
 
 bool BaseChannel::AddSendStream(const StreamParams& sp) {
   return InvokeOnWorker(
-      Bind(&MediaChannel::AddSendStream, media_channel(), sp));
+      RTC_FROM_HERE, Bind(&MediaChannel::AddSendStream, media_channel(), sp));
 }
 
 bool BaseChannel::RemoveSendStream(uint32_t ssrc) {
-  return InvokeOnWorker(
-      Bind(&MediaChannel::RemoveSendStream, media_channel(), ssrc));
+  return InvokeOnWorker(RTC_FROM_HERE, Bind(&MediaChannel::RemoveSendStream,
+                                            media_channel(), ssrc));
 }
 
 bool BaseChannel::SetLocalContent(const MediaContentDescription* content,
                                   ContentAction action,
                                   std::string* error_desc) {
   TRACE_EVENT0("webrtc", "BaseChannel::SetLocalContent");
-  return InvokeOnWorker(Bind(&BaseChannel::SetLocalContent_w,
-                             this, content, action, error_desc));
+  return InvokeOnWorker(RTC_FROM_HERE, Bind(&BaseChannel::SetLocalContent_w,
+                                            this, content, action, error_desc));
 }
 
 bool BaseChannel::SetRemoteContent(const MediaContentDescription* content,
                                    ContentAction action,
                                    std::string* error_desc) {
   TRACE_EVENT0("webrtc", "BaseChannel::SetRemoteContent");
-  return InvokeOnWorker(Bind(&BaseChannel::SetRemoteContent_w,
-                             this, content, action, error_desc));
+  return InvokeOnWorker(RTC_FROM_HERE, Bind(&BaseChannel::SetRemoteContent_w,
+                                            this, content, action, error_desc));
 }
 
 void BaseChannel::StartConnectionMonitor(int cms) {
   // We pass in the BaseChannel instead of the transport_channel_
   // because if the transport_channel_ changes, the ConnectionMonitor
   // would be pointing to the wrong TransportChannel.
   // We pass in the network thread because on that thread connection monitor
   // will call BaseChannel::GetConnectionStats which must be called on the
   // network thread.
   connection_monitor_.reset(
@@ skipping 19 matching lines @@
   // Receive data if we are enabled and have local content,
   return enabled() && IsReceiveContentDirection(local_content_direction_);
 }
 
 bool BaseChannel::IsReadyToSend_w() const {
   // Send outgoing data if we are enabled, have local and remote content,
   // and we have had some form of connectivity.
   return enabled() && IsReceiveContentDirection(remote_content_direction_) &&
          IsSendContentDirection(local_content_direction_) &&
          network_thread_->Invoke<bool>(
-             Bind(&BaseChannel::IsTransportReadyToSend_n, this));
+             RTC_FROM_HERE, Bind(&BaseChannel::IsTransportReadyToSend_n, this));
 }
 
 bool BaseChannel::IsTransportReadyToSend_n() const {
   return was_ever_writable() &&
          (srtp_filter_.IsActive() || !ShouldSetupDtlsSrtp_n());
 }
 
 bool BaseChannel::SendPacket(rtc::CopyOnWriteBuffer* packet,
                              const rtc::PacketOptions& options) {
   return SendPacket(false, packet, options);
 }
 
 bool BaseChannel::SendRtcp(rtc::CopyOnWriteBuffer* packet,
                            const rtc::PacketOptions& options) {
   return SendPacket(true, packet, options);
 }
 
 int BaseChannel::SetOption(SocketType type, rtc::Socket::Option opt,
                            int value) {
   return network_thread_->Invoke<int>(
-      Bind(&BaseChannel::SetOption_n, this, type, opt, value));
+      RTC_FROM_HERE, Bind(&BaseChannel::SetOption_n, this, type, opt, value));
 }
 
 int BaseChannel::SetOption_n(SocketType type,
                              rtc::Socket::Option opt,
                              int value) {
   RTC_DCHECK(network_thread_->IsCurrent());
   TransportChannel* channel = nullptr;
   switch (type) {
     case ST_RTP:
       channel = transport_channel_;
@@ skipping 60 matching lines @@
   RTC_DCHECK(network_thread_->IsCurrent());
   std::string transport_name = channel->transport_name();
   rtc::NetworkRoute network_route;
   if (selected_candidate_pair) {
     network_route = rtc::NetworkRoute(
         selected_candidate_pair->local_candidate().network_id(),
         selected_candidate_pair->remote_candidate().network_id(),
         last_sent_packet_id);
   }
   invoker_.AsyncInvoke<void>(
-      worker_thread_, Bind(&MediaChannel::OnNetworkRouteChanged, media_channel_,
-                           transport_name, network_route));
+      RTC_FROM_HERE, worker_thread_,
+      Bind(&MediaChannel::OnNetworkRouteChanged, media_channel_, transport_name,
+           network_route));
 }
 
 void BaseChannel::SetReadyToSend(bool rtcp, bool ready) {
   RTC_DCHECK(network_thread_->IsCurrent());
   if (rtcp) {
     rtcp_ready_to_send_ = ready;
   } else {
     rtp_ready_to_send_ = ready;
   }
 
   bool ready_to_send =
       (rtp_ready_to_send_ &&
        // In the case of rtcp mux |rtcp_transport_channel_| will be null.
        (rtcp_ready_to_send_ || !rtcp_transport_channel_));
 
   invoker_.AsyncInvoke<void>(
-      worker_thread_,
+      RTC_FROM_HERE, worker_thread_,
       Bind(&MediaChannel::OnReadyToSend, media_channel_, ready_to_send));
 }
 
 bool BaseChannel::PacketIsRtcp(const TransportChannel* channel,
                                const char* data, size_t len) {
   return (channel == rtcp_transport_channel_ ||
           rtcp_mux_filter_.DemuxRtcp(data, static_cast<int>(len)));
 }
 
 bool BaseChannel::SendPacket(bool rtcp,
                              rtc::CopyOnWriteBuffer* packet,
                              const rtc::PacketOptions& options) {
   // SendPacket gets called from MediaEngine, on a pacer or an encoder thread.
   // If the thread is not our network thread, we will post to our network
   // so that the real work happens on our network. This avoids us having to
   // synchronize access to all the pieces of the send path, including
   // SRTP and the inner workings of the transport channels.
   // The only downside is that we can't return a proper failure code if
   // needed. Since UDP is unreliable anyway, this should be a non-issue.
   if (!network_thread_->IsCurrent()) {
     // Avoid a copy by transferring the ownership of the packet data.
     int message_id = rtcp ? MSG_SEND_RTCP_PACKET : MSG_SEND_RTP_PACKET;
     SendPacketMessageData* data = new SendPacketMessageData;
     data->packet = std::move(*packet);
     data->options = options;
-    network_thread_->Post(this, message_id, data);
+    network_thread_->Post(RTC_FROM_HERE, this, message_id, data);
     return true;
   }
   TRACE_EVENT0("webrtc", "BaseChannel::SendPacket");
 
   // Now that we are on the correct thread, ensure we have a place to send this
   // packet before doing anything. (We might get RTCP packets that we don't
   // intend to send.) If we've negotiated RTCP mux, send RTCP over the RTP
   // transport.
   TransportChannel* channel = (!rtcp || rtcp_mux_filter_.IsActive()) ?
       transport_channel_ : rtcp_transport_channel_;
@@ skipping 114 matching lines @@
                                const rtc::PacketTime& packet_time) {
   RTC_DCHECK(network_thread_->IsCurrent());
   if (!WantsPacket(rtcp, packet)) {
     return;
   }
 
   // We are only interested in the first rtp packet because that
   // indicates the media has started flowing.
   if (!has_received_packet_ && !rtcp) {
     has_received_packet_ = true;
-    signaling_thread()->Post(this, MSG_FIRSTPACKETRECEIVED);
+    signaling_thread()->Post(RTC_FROM_HERE, this, MSG_FIRSTPACKETRECEIVED);
   }
 
   // Unprotect the packet, if needed.
   if (srtp_filter_.IsActive()) {
     TRACE_EVENT0("webrtc", "SRTP Decode");
     char* data = packet->data<char>();
     int len = static_cast<int>(packet->size());
     bool res;
     if (!rtcp) {
       res = srtp_filter_.UnprotectRtp(data, len, &len);
@@ skipping 29 matching lines @@
     //    on the channel that the packets are being sent on. It's really good
     //    practice to wait for both RTP and RTCP to be good to go before sending
     //    media, to prevent weird failure modes, so it's fine for us to just eat
     //    packets here. This is all sidestepped if RTCP mux is used anyway.
     LOG(LS_WARNING) << "Can't process incoming " << PacketType(rtcp)
                     << " packet when SRTP is inactive and crypto is required";
     return;
   }
 
   invoker_.AsyncInvoke<void>(
-      worker_thread_,
+      RTC_FROM_HERE, worker_thread_,
       Bind(&BaseChannel::OnPacketReceived, this, rtcp, *packet, packet_time));
 }
 
 void BaseChannel::OnPacketReceived(bool rtcp,
                                    const rtc::CopyOnWriteBuffer& packet,
                                    const rtc::PacketTime& packet_time) {
   RTC_DCHECK(worker_thread_->IsCurrent());
   // Need to copy variable because OnRtcpReceived/OnPacketReceived
   // requires non-const pointer to buffer. This doesn't memcpy the actual data.
   rtc::CopyOnWriteBuffer data(packet);
@@ skipping 83 matching lines @@
 
   was_ever_writable_ = true;
   MaybeSetupDtlsSrtp_n();
   writable_ = true;
   ChangeState();
 }
 
 void BaseChannel::SignalDtlsSetupFailure_n(bool rtcp) {
   RTC_DCHECK(network_thread_->IsCurrent());
   invoker_.AsyncInvoke<void>(
-      signaling_thread(),
+      RTC_FROM_HERE, signaling_thread(),
       Bind(&BaseChannel::SignalDtlsSetupFailure_s, this, rtcp));
 }
 
 void BaseChannel::SignalDtlsSetupFailure_s(bool rtcp) {
   ASSERT(signaling_thread() == rtc::Thread::Current());
   SignalDtlsSetupFailure(this, rtcp);
 }
 
 bool BaseChannel::SetDtlsSrtpCryptoSuites_n(TransportChannel* tc, bool rtcp) {
   std::vector<int> crypto_suites;
@@ skipping 138 matching lines @@
     ContentAction action,
     ContentSource src,
     std::string* error_desc) {
   if (action == CA_UPDATE) {
     // These parameters never get changed by a CA_UDPATE.
     return true;
   }
 
   // Cache secure_required_ for belt and suspenders check on SendPacket
   return network_thread_->Invoke<bool>(
-      Bind(&BaseChannel::SetRtpTransportParameters_n, this, content, action,
-           src, error_desc));
+      RTC_FROM_HERE, Bind(&BaseChannel::SetRtpTransportParameters_n, this,
+                          content, action, src, error_desc));
 }
 
 bool BaseChannel::SetRtpTransportParameters_n(
     const MediaContentDescription* content,
     ContentAction action,
     ContentSource src,
     std::string* error_desc) {
   RTC_DCHECK(network_thread_->IsCurrent());
 
   if (src == CS_LOCAL) {
@@ skipping 65 matching lines @@
       break;
   }
   if (!ret) {
     SafeSetError("Failed to setup SRTP filter.", error_desc);
     return false;
   }
   return true;
 }
 
 void BaseChannel::ActivateRtcpMux() {
-  network_thread_->Invoke<void>(Bind(&BaseChannel::ActivateRtcpMux_n, this));
+  network_thread_->Invoke<void>(RTC_FROM_HERE,
+                                Bind(&BaseChannel::ActivateRtcpMux_n, this));
 }
 
 void BaseChannel::ActivateRtcpMux_n() {
   if (!rtcp_mux_filter_.IsActive()) {
     rtcp_mux_filter_.SetActive();
     SetRtcpTransportChannel_n(nullptr, true);
     rtcp_transport_enabled_ = false;
   }
 }
 
@@ skipping 205 matching lines @@
     const std::vector<webrtc::RtpExtension>& extensions) {
 // Absolute Send Time extension id is used only with external auth,
 // so do not bother searching for it and making asyncronious call to set
 // something that is not used.
 #if defined(ENABLE_EXTERNAL_AUTH)
   const webrtc::RtpExtension* send_time_extension =
       FindHeaderExtension(extensions, webrtc::RtpExtension::kAbsSendTimeUri);
   int rtp_abs_sendtime_extn_id =
       send_time_extension ? send_time_extension->id : -1;
   invoker_.AsyncInvoke<void>(
-      network_thread_, Bind(&BaseChannel::CacheRtpAbsSendTimeHeaderExtension_n,
-                            this, rtp_abs_sendtime_extn_id));
+      RTC_FROM_HERE, network_thread_,
+      Bind(&BaseChannel::CacheRtpAbsSendTimeHeaderExtension_n, this,
+           rtp_abs_sendtime_extn_id));
 #endif
 }
 
 void BaseChannel::CacheRtpAbsSendTimeHeaderExtension_n(
     int rtp_abs_sendtime_extn_id) {
   rtp_abs_sendtime_extn_id_ = rtp_abs_sendtime_extn_id;
 }
 
 void BaseChannel::OnMessage(rtc::Message *pmsg) {
   TRACE_EVENT0("webrtc", "BaseChannel::OnMessage");
@@ skipping 15 matching lines @@
   }
 }
 
 void BaseChannel::FlushRtcpMessages_n() {
   // Flush all remaining RTCP messages. This should only be called in
   // destructor.
   RTC_DCHECK(network_thread_->IsCurrent());
   rtc::MessageList rtcp_messages;
   network_thread_->Clear(this, MSG_SEND_RTCP_PACKET, &rtcp_messages);
   for (const auto& message : rtcp_messages) {
-    network_thread_->Send(this, MSG_SEND_RTCP_PACKET, message.pdata);
+    network_thread_->Send(RTC_FROM_HERE, this, MSG_SEND_RTCP_PACKET,
+                          message.pdata);
   }
 }
 
 void BaseChannel::SignalSentPacket_n(TransportChannel* /* channel */,
                                      const rtc::SentPacket& sent_packet) {
   RTC_DCHECK(network_thread_->IsCurrent());
   invoker_.AsyncInvoke<void>(
-      worker_thread_,
+      RTC_FROM_HERE, worker_thread_,
       rtc::Bind(&BaseChannel::SignalSentPacket_w, this, sent_packet));
 }
 
 void BaseChannel::SignalSentPacket_w(const rtc::SentPacket& sent_packet) {
   RTC_DCHECK(worker_thread_->IsCurrent());
   SignalSentPacket(sent_packet);
 }
 
 VoiceChannel::VoiceChannel(rtc::Thread* worker_thread,
                            rtc::Thread* network_thread,
@@ skipping 24 matching lines @@
   if (!BaseChannel::Init_w(bundle_transport_name)) {
     return false;
   }
   return true;
 }
 
 bool VoiceChannel::SetAudioSend(uint32_t ssrc,
                                 bool enable,
                                 const AudioOptions* options,
                                 AudioSource* source) {
-  return InvokeOnWorker(Bind(&VoiceMediaChannel::SetAudioSend, media_channel(),
+  return InvokeOnWorker(RTC_FROM_HERE,
+                        Bind(&VoiceMediaChannel::SetAudioSend, media_channel(),
                              ssrc, enable, options, source));
 }
 
 // TODO(juberti): Handle early media the right way. We should get an explicit
 // ringing message telling us to start playing local ringback, which we cancel
 // if any early media actually arrives. For now, we do the opposite, which is
 // to wait 1 second for early media, and start playing local ringback if none
 // arrives.
 void VoiceChannel::SetEarlyMedia(bool enable) {
   if (enable) {
     // Start the early media timeout
-    worker_thread()->PostDelayed(kEarlyMediaTimeout, this,
-                                MSG_EARLYMEDIATIMEOUT);
+    worker_thread()->PostDelayed(RTC_FROM_HERE, kEarlyMediaTimeout, this,
+                                 MSG_EARLYMEDIATIMEOUT);
   } else {
     // Stop the timeout if currently going.
     worker_thread()->Clear(this, MSG_EARLYMEDIATIMEOUT);
   }
 }
 
 bool VoiceChannel::CanInsertDtmf() {
-  return InvokeOnWorker(Bind(&VoiceMediaChannel::CanInsertDtmf,
-                             media_channel()));
+  return InvokeOnWorker(
+      RTC_FROM_HERE, Bind(&VoiceMediaChannel::CanInsertDtmf, media_channel()));
 }
 
 bool VoiceChannel::InsertDtmf(uint32_t ssrc,
                               int event_code,
                               int duration) {
-  return InvokeOnWorker(Bind(&VoiceChannel::InsertDtmf_w, this,
-                             ssrc, event_code, duration));
+  return InvokeOnWorker(RTC_FROM_HERE, Bind(&VoiceChannel::InsertDtmf_w, this,
+                                            ssrc, event_code, duration));
 }
 
 bool VoiceChannel::SetOutputVolume(uint32_t ssrc, double volume) {
-  return InvokeOnWorker(Bind(&VoiceMediaChannel::SetOutputVolume,
-                             media_channel(), ssrc, volume));
+  return InvokeOnWorker(RTC_FROM_HERE, Bind(&VoiceMediaChannel::SetOutputVolume,
+                                            media_channel(), ssrc, volume));
 }
 
 void VoiceChannel::SetRawAudioSink(
     uint32_t ssrc,
     std::unique_ptr<webrtc::AudioSinkInterface> sink) {
   // We need to work around Bind's lack of support for unique_ptr and ownership
   // passing.  So we invoke to our own little routine that gets a pointer to
   // our local variable.  This is OK since we're synchronously invoking.
-  InvokeOnWorker(Bind(&SetRawAudioSink_w, media_channel(), ssrc, &sink));
+  InvokeOnWorker(RTC_FROM_HERE,
+                 Bind(&SetRawAudioSink_w, media_channel(), ssrc, &sink));
 }
 
 webrtc::RtpParameters VoiceChannel::GetRtpSendParameters(uint32_t ssrc) const {
   return worker_thread()->Invoke<webrtc::RtpParameters>(
-      Bind(&VoiceChannel::GetRtpSendParameters_w, this, ssrc));
+      RTC_FROM_HERE, Bind(&VoiceChannel::GetRtpSendParameters_w, this, ssrc));
 }
 
 webrtc::RtpParameters VoiceChannel::GetRtpSendParameters_w(
     uint32_t ssrc) const {
   return media_channel()->GetRtpSendParameters(ssrc);
 }
 
 bool VoiceChannel::SetRtpSendParameters(
     uint32_t ssrc,
     const webrtc::RtpParameters& parameters) {
   return InvokeOnWorker(
+      RTC_FROM_HERE,
       Bind(&VoiceChannel::SetRtpSendParameters_w, this, ssrc, parameters));
 }
 
 bool VoiceChannel::SetRtpSendParameters_w(uint32_t ssrc,
                                           webrtc::RtpParameters parameters) {
   return media_channel()->SetRtpSendParameters(ssrc, parameters);
 }
 
 webrtc::RtpParameters VoiceChannel::GetRtpReceiveParameters(
     uint32_t ssrc) const {
   return worker_thread()->Invoke<webrtc::RtpParameters>(
+      RTC_FROM_HERE,
       Bind(&VoiceChannel::GetRtpReceiveParameters_w, this, ssrc));
 }
 
 webrtc::RtpParameters VoiceChannel::GetRtpReceiveParameters_w(
     uint32_t ssrc) const {
   return media_channel()->GetRtpReceiveParameters(ssrc);
 }
 
 bool VoiceChannel::SetRtpReceiveParameters(
     uint32_t ssrc,
     const webrtc::RtpParameters& parameters) {
   return InvokeOnWorker(
+      RTC_FROM_HERE,
       Bind(&VoiceChannel::SetRtpReceiveParameters_w, this, ssrc, parameters));
 }
 
 bool VoiceChannel::SetRtpReceiveParameters_w(uint32_t ssrc,
                                              webrtc::RtpParameters parameters) {
   return media_channel()->SetRtpReceiveParameters(ssrc, parameters);
 }
 
 bool VoiceChannel::GetStats(VoiceMediaInfo* stats) {
-  return InvokeOnWorker(Bind(&VoiceMediaChannel::GetStats,
-                             media_channel(), stats));
+  return InvokeOnWorker(RTC_FROM_HERE, Bind(&VoiceMediaChannel::GetStats,
+                                            media_channel(), stats));
 }
 
 void VoiceChannel::StartMediaMonitor(int cms) {
   media_monitor_.reset(new VoiceMediaMonitor(media_channel(), worker_thread(),
       rtc::Thread::Current()));
   media_monitor_->SignalUpdate.connect(
       this, &VoiceChannel::OnMediaMonitorUpdate);
   media_monitor_->Start(cms);
 }
 
@@ skipping 43 matching lines @@
 
   // Set a flag when we've received an RTP packet. If we're waiting for early
   // media, this will disable the timeout.
   if (!received_media_ && !PacketIsRtcp(channel, data, len)) {
     received_media_ = true;
   }
 }
 
 void BaseChannel::ChangeState() {
   RTC_DCHECK(network_thread_->IsCurrent());
-  invoker_.AsyncInvoke<void>(worker_thread_,
+  invoker_.AsyncInvoke<void>(RTC_FROM_HERE, worker_thread_,
                              Bind(&BaseChannel::ChangeState_w, this));
 }
 
 void VoiceChannel::ChangeState_w() {
   // Render incoming data if we're the active call, and we have the local
   // content. We receive data on the default channel and multiplexed streams.
   bool recv = IsReadyToReceive_w();
   media_channel()->SetPlayout(recv);
 
   // Send outgoing data if we're the active call, we have the remote content,
@@ skipping 185 matching lines @@
   StopMediaMonitor();
   // this can't be done in the base class, since it calls a virtual
   DisableMedia_w();
 
   Deinit();
 }
 
 bool VideoChannel::SetSink(uint32_t ssrc,
                            rtc::VideoSinkInterface<VideoFrame>* sink) {
   worker_thread()->Invoke<void>(
+      RTC_FROM_HERE,
       Bind(&VideoMediaChannel::SetSink, media_channel(), ssrc, sink));
   return true;
 }
 
 bool VideoChannel::SetVideoSend(
     uint32_t ssrc,
     bool mute,
     const VideoOptions* options,
     rtc::VideoSourceInterface<cricket::VideoFrame>* source) {
-  return InvokeOnWorker(Bind(&VideoMediaChannel::SetVideoSend, media_channel(),
+  return InvokeOnWorker(RTC_FROM_HERE,
+                        Bind(&VideoMediaChannel::SetVideoSend, media_channel(),
                              ssrc, mute, options, source));
 }
 
 webrtc::RtpParameters VideoChannel::GetRtpSendParameters(uint32_t ssrc) const {
   return worker_thread()->Invoke<webrtc::RtpParameters>(
-      Bind(&VideoChannel::GetRtpSendParameters_w, this, ssrc));
+      RTC_FROM_HERE, Bind(&VideoChannel::GetRtpSendParameters_w, this, ssrc));
 }
 
 webrtc::RtpParameters VideoChannel::GetRtpSendParameters_w(
     uint32_t ssrc) const {
   return media_channel()->GetRtpSendParameters(ssrc);
 }
 
 bool VideoChannel::SetRtpSendParameters(
     uint32_t ssrc,
     const webrtc::RtpParameters& parameters) {
   return InvokeOnWorker(
+      RTC_FROM_HERE,
       Bind(&VideoChannel::SetRtpSendParameters_w, this, ssrc, parameters));
 }
 
 bool VideoChannel::SetRtpSendParameters_w(uint32_t ssrc,
                                           webrtc::RtpParameters parameters) {
   return media_channel()->SetRtpSendParameters(ssrc, parameters);
 }
 
 webrtc::RtpParameters VideoChannel::GetRtpReceiveParameters(
     uint32_t ssrc) const {
   return worker_thread()->Invoke<webrtc::RtpParameters>(
+      RTC_FROM_HERE,
       Bind(&VideoChannel::GetRtpReceiveParameters_w, this, ssrc));
 }
 
 webrtc::RtpParameters VideoChannel::GetRtpReceiveParameters_w(
     uint32_t ssrc) const {
   return media_channel()->GetRtpReceiveParameters(ssrc);
 }
 
 bool VideoChannel::SetRtpReceiveParameters(
     uint32_t ssrc,
     const webrtc::RtpParameters& parameters) {
   return InvokeOnWorker(
+      RTC_FROM_HERE,
       Bind(&VideoChannel::SetRtpReceiveParameters_w, this, ssrc, parameters));
 }
 
 bool VideoChannel::SetRtpReceiveParameters_w(uint32_t ssrc,
                                              webrtc::RtpParameters parameters) {
   return media_channel()->SetRtpReceiveParameters(ssrc, parameters);
 }
 
 void VideoChannel::ChangeState_w() {
   // Send outgoing data if we're the active call, we have the remote content,
   // and we have had some form of connectivity.
   bool send = IsReadyToSend_w();
   if (!media_channel()->SetSend(send)) {
     LOG(LS_ERROR) << "Failed to SetSend on video channel";
     // TODO(gangji): Report error back to server.
   }
 
   LOG(LS_INFO) << "Changing video state, send=" << send;
 }
 
 bool VideoChannel::GetStats(VideoMediaInfo* stats) {
-  return InvokeOnWorker(
-      Bind(&VideoMediaChannel::GetStats, media_channel(), stats));
+  return InvokeOnWorker(RTC_FROM_HERE, Bind(&VideoMediaChannel::GetStats,
+                                            media_channel(), stats));
 }
 
 void VideoChannel::StartMediaMonitor(int cms) {
   media_monitor_.reset(new VideoMediaMonitor(media_channel(), worker_thread(),
       rtc::Thread::Current()));
   media_monitor_->SignalUpdate.connect(
       this, &VideoChannel::OnMediaMonitorUpdate);
   media_monitor_->Start(cms);
 }
 
@@ skipping 171 matching lines @@
   media_channel()->SignalReadyToSend.connect(
       this, &DataChannel::OnDataChannelReadyToSend);
   media_channel()->SignalStreamClosedRemotely.connect(
       this, &DataChannel::OnStreamClosedRemotely);
   return true;
 }
 
 bool DataChannel::SendData(const SendDataParams& params,
                            const rtc::CopyOnWriteBuffer& payload,
                            SendDataResult* result) {
-  return InvokeOnWorker(Bind(&DataMediaChannel::SendData,
-                             media_channel(), params, payload, result));
+  return InvokeOnWorker(
+      RTC_FROM_HERE, Bind(&DataMediaChannel::SendData, media_channel(), params,
+                          payload, result));
 }
 
 const ContentInfo* DataChannel::GetFirstContent(
     const SessionDescription* sdesc) {
   return GetFirstDataContent(sdesc);
 }
 
 bool DataChannel::WantsPacket(bool rtcp, const rtc::CopyOnWriteBuffer* packet) {
   if (data_channel_type_ == DCT_SCTP) {
     // TODO(pthatcher): Do this in a more robust way by checking for
@@ skipping 228 matching lines @@
 void DataChannel::OnMediaMonitorUpdate(
     DataMediaChannel* media_channel, const DataMediaInfo& info) {
   ASSERT(media_channel == this->media_channel());
   SignalMediaMonitor(this, info);
 }
 
 void DataChannel::OnDataReceived(
     const ReceiveDataParams& params, const char* data, size_t len) {
   DataReceivedMessageData* msg = new DataReceivedMessageData(
       params, data, len);
-  signaling_thread()->Post(this, MSG_DATARECEIVED, msg);
+  signaling_thread()->Post(RTC_FROM_HERE, this, MSG_DATARECEIVED, msg);
 }
 
 void DataChannel::OnDataChannelError(uint32_t ssrc,
                                      DataMediaChannel::Error err) {
   DataChannelErrorMessageData* data = new DataChannelErrorMessageData(
       ssrc, err);
-  signaling_thread()->Post(this, MSG_CHANNEL_ERROR, data);
+  signaling_thread()->Post(RTC_FROM_HERE, this, MSG_CHANNEL_ERROR, data);
 }
 
 void DataChannel::OnDataChannelReadyToSend(bool writable) {
   // This is usded for congestion control to indicate that the stream is ready
   // to send by the MediaChannel, as opposed to OnReadyToSend, which indicates
   // that the transport channel is ready.
-  signaling_thread()->Post(this, MSG_READYTOSENDDATA,
+  signaling_thread()->Post(RTC_FROM_HERE, this, MSG_READYTOSENDDATA,
                            new DataChannelReadyToSendMessageData(writable));
 }
 
 void DataChannel::GetSrtpCryptoSuites_n(std::vector<int>* crypto_suites) const {
   GetSupportedDataCryptoSuites(crypto_suites);
 }
 
 bool DataChannel::ShouldSetupDtlsSrtp_n() const {
   return data_channel_type_ == DCT_RTP && BaseChannel::ShouldSetupDtlsSrtp_n();
 }
 
 void DataChannel::OnStreamClosedRemotely(uint32_t sid) {
   rtc::TypedMessageData<uint32_t>* message =
       new rtc::TypedMessageData<uint32_t>(sid);
-  signaling_thread()->Post(this, MSG_STREAMCLOSEDREMOTELY, message);
+  signaling_thread()->Post(RTC_FROM_HERE, this, MSG_STREAMCLOSEDREMOTELY,
+                           message);
 }
 
 }  // namespace cricket