Adding more detail to MessageQueue::Dispatch logging.

webrtc/api/quicdatachannel.cc

 /*
  *  Copyright 2016 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 74 matching lines @@
 }
 
 bool QuicDataChannel::Send(const DataBuffer& buffer) {
   RTC_DCHECK(signaling_thread_->IsCurrent());
   if (state_ != kOpen) {
     LOG(LS_ERROR) << "QUIC data channel " << id_
                   << " is not open so cannot send.";
     return false;
   }
   return worker_thread_->Invoke<bool>(
-      rtc::Bind(&QuicDataChannel::Send_w, this, buffer));
+      RTC_FROM_HERE, rtc::Bind(&QuicDataChannel::Send_w, this, buffer));
 }
 
 bool QuicDataChannel::Send_w(const DataBuffer& buffer) {
   RTC_DCHECK(worker_thread_->IsCurrent());
 
   // Encode and send the header containing the data channel ID and message ID.
   rtc::CopyOnWriteBuffer header;
   WriteQuicDataChannelMessageHeader(id_, ++next_message_id_, &header);
   RTC_DCHECK(quic_transport_channel_);
   cricket::ReliableQuicStream* stream =
@@ skipping 74 matching lines @@
     LOG(LS_INFO) << "Stream " << stream->id()
                  << " successfully wrote data for QUIC data channel " << id_;
     stream->Close();
   }
 }
 
 void QuicDataChannel::SetBufferedAmount_w(uint64_t buffered_amount) {
   RTC_DCHECK(worker_thread_->IsCurrent());
   buffered_amount_ = buffered_amount;
   invoker_.AsyncInvoke<void>(
-      signaling_thread_, rtc::Bind(&QuicDataChannel::OnBufferedAmountChange_s,
-                                   this, buffered_amount));
+      RTC_FROM_HERE, signaling_thread_,
+      rtc::Bind(&QuicDataChannel::OnBufferedAmountChange_s, this,
+                buffered_amount));
 }
 
 void QuicDataChannel::Close() {
   RTC_DCHECK(signaling_thread_->IsCurrent());
   if (state_ == kClosed || state_ == kClosing) {
     return;
   }
   LOG(LS_INFO) << "Closing QUIC data channel.";
   SetState_s(kClosing);
-  worker_thread_->Invoke<void>(rtc::Bind(&QuicDataChannel::Close_w, this));
+  worker_thread_->Invoke<void>(RTC_FROM_HERE,
+                               rtc::Bind(&QuicDataChannel::Close_w, this));
   SetState_s(kClosed);
 }
 
 void QuicDataChannel::Close_w() {
   RTC_DCHECK(worker_thread_->IsCurrent());
   for (auto& kv : incoming_quic_messages_) {
     Message& message = kv.second;
     cricket::ReliableQuicStream* stream = message.stream;
     stream->Close();
   }
@@ skipping 17 matching lines @@
       LOG(LS_WARNING) << "Ignoring duplicate transport channel.";
       return true;
     }
     LOG(LS_ERROR) << "|channel| does not match existing transport channel.";
     return false;
   }
 
   quic_transport_channel_ = channel;
   LOG(LS_INFO) << "Setting QuicTransportChannel for QUIC data channel " << id_;
   DataState data_channel_state = worker_thread_->Invoke<DataState>(
-      rtc::Bind(&QuicDataChannel::SetTransportChannel_w, this));
+      RTC_FROM_HERE, rtc::Bind(&QuicDataChannel::SetTransportChannel_w, this));
   SetState_s(data_channel_state);
   return true;
 }
 
 DataChannelInterface::DataState QuicDataChannel::SetTransportChannel_w() {
   RTC_DCHECK(worker_thread_->IsCurrent());
   quic_transport_channel_->SignalReadyToSend.connect(
       this, &QuicDataChannel::OnReadyToSend);
   quic_transport_channel_->SignalClosed.connect(
       this, &QuicDataChannel::OnConnectionClosed);
@@ skipping 12 matching lines @@
     message.stream->Close();
     return;
   }
   // A FIN is received if the message fits into a single QUIC stream frame and
   // the remote peer is done sending.
   if (message.stream->fin_received()) {
     LOG(LS_INFO) << "Stream " << message.stream->id()
                  << " has finished receiving data for QUIC data channel "
                  << id_;
     DataBuffer final_message(message.buffer, false);
-    invoker_.AsyncInvoke<void>(signaling_thread_,
+    invoker_.AsyncInvoke<void>(RTC_FROM_HERE, signaling_thread_,
                                rtc::Bind(&QuicDataChannel::OnMessage_s, this,
                                          std::move(final_message)));
     message.stream->Close();
     return;
   }
   // Otherwise the message is divided across multiple QUIC stream frames, so
   // queue the data. OnDataReceived() will be called each time the remaining
   // QUIC stream frames arrive.
   LOG(LS_INFO) << "QUIC data channel " << id_
                << " is queuing incoming data for stream "
@@ skipping 26 matching lines @@
     received_data.AppendData(data, len);
     return;
   }
   // Otherwise we are done receiving and can provide the data channel observer
   // with the message.
   LOG(LS_INFO) << "Stream " << stream_id
                << " has finished receiving data for QUIC data channel " << id_;
   received_data.AppendData(data, len);
   DataBuffer final_message(std::move(received_data), false);
   invoker_.AsyncInvoke<void>(
-      signaling_thread_,
+      RTC_FROM_HERE, signaling_thread_,
       rtc::Bind(&QuicDataChannel::OnMessage_s, this, std::move(final_message)));
   // Once the stream is closed, OnDataReceived will not fire for the stream.
   stream->Close();
 }
 
 void QuicDataChannel::OnReadyToSend(cricket::TransportChannel* channel) {
   RTC_DCHECK(worker_thread_->IsCurrent());
   RTC_DCHECK(channel == quic_transport_channel_);
   LOG(LS_INFO) << "QuicTransportChannel is ready to send";
   invoker_.AsyncInvoke<void>(
-      signaling_thread_, rtc::Bind(&QuicDataChannel::SetState_s, this, kOpen));
+      RTC_FROM_HERE, signaling_thread_,
+      rtc::Bind(&QuicDataChannel::SetState_s, this, kOpen));
 }
 
 void QuicDataChannel::OnWriteBlockedStreamClosed(net::QuicStreamId stream_id,
                                                  int error) {
   RTC_DCHECK(worker_thread_->IsCurrent());
   LOG(LS_VERBOSE) << "Write blocked stream " << stream_id << " is closed.";
   write_blocked_quic_streams_.erase(stream_id);
 }
 
 void QuicDataChannel::OnIncomingQueuedStreamClosed(net::QuicStreamId stream_id,
                                                    int error) {
   RTC_DCHECK(worker_thread_->IsCurrent());
   LOG(LS_VERBOSE) << "Incoming queued stream " << stream_id << " is closed.";
   incoming_quic_messages_.erase(stream_id);
 }
 
 void QuicDataChannel::OnConnectionClosed() {
   RTC_DCHECK(worker_thread_->IsCurrent());
-  invoker_.AsyncInvoke<void>(signaling_thread_,
+  invoker_.AsyncInvoke<void>(RTC_FROM_HERE, signaling_thread_,
                              rtc::Bind(&QuicDataChannel::Close, this));
 }
 
 void QuicDataChannel::OnMessage_s(const DataBuffer& received_data) {
   RTC_DCHECK(signaling_thread_->IsCurrent());
   if (observer_) {
     observer_->OnMessage(received_data);
   }
 }
 
@@ skipping 22 matching lines @@
 
 size_t QuicDataChannel::GetNumWriteBlockedStreams() const {
   return write_blocked_quic_streams_.size();
 }
 
 size_t QuicDataChannel::GetNumIncomingStreams() const {
   return incoming_quic_messages_.size();
 }
 
 }  // namespace webrtc