Adding more detail to MessageQueue::Dispatch logging.

webrtc/api/java/jni/androidmediaencoder_jni.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 395 matching lines @@
       RTC_NOTREACHED() << "Unsupported codec without configured QP thresholds.";
       scale_ = false;
     }
     QualityScaler::Resolution res = quality_scaler_.GetScaledResolution();
     init_width = res.width;
     init_height = res.height;
     ALOGD << "Scaled resolution: " << init_width << " x " << init_height;
   }
 
   return codec_thread_->Invoke<int32_t>(
-      Bind(&MediaCodecVideoEncoder::InitEncodeOnCodecThread,
-           this,
-           init_width,
-           init_height,
-           codec_settings->startBitrate,
-           codec_settings->maxFramerate,
-           false /* use_surface */));
+      RTC_FROM_HERE,
+      Bind(&MediaCodecVideoEncoder::InitEncodeOnCodecThread, this, init_width,
+           init_height, codec_settings->startBitrate,
+           codec_settings->maxFramerate, false /* use_surface */));
 }
 
 int32_t MediaCodecVideoEncoder::Encode(
     const webrtc::VideoFrame& frame,
     const webrtc::CodecSpecificInfo* /* codec_specific_info */,
     const std::vector<webrtc::FrameType>* frame_types) {
-  return codec_thread_->Invoke<int32_t>(Bind(
-      &MediaCodecVideoEncoder::EncodeOnCodecThread, this, frame, frame_types));
+  return codec_thread_->Invoke<int32_t>(
+      RTC_FROM_HERE, Bind(&MediaCodecVideoEncoder::EncodeOnCodecThread, this,
+                          frame, frame_types));
 }
 
 int32_t MediaCodecVideoEncoder::RegisterEncodeCompleteCallback(
     webrtc::EncodedImageCallback* callback) {
   return codec_thread_->Invoke<int32_t>(
+      RTC_FROM_HERE,
       Bind(&MediaCodecVideoEncoder::RegisterEncodeCompleteCallbackOnCodecThread,
-           this,
-           callback));
+           this, callback));
 }
 
 int32_t MediaCodecVideoEncoder::Release() {
   ALOGD << "EncoderRelease request";
   return codec_thread_->Invoke<int32_t>(
-      Bind(&MediaCodecVideoEncoder::ReleaseOnCodecThread, this));
+      RTC_FROM_HERE, Bind(&MediaCodecVideoEncoder::ReleaseOnCodecThread, this));
 }
 
 int32_t MediaCodecVideoEncoder::SetChannelParameters(uint32_t /* packet_loss */,
                                                      int64_t /* rtt */) {
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 int32_t MediaCodecVideoEncoder::SetRates(uint32_t new_bit_rate,
                                          uint32_t frame_rate) {
   return codec_thread_->Invoke<int32_t>(
-      Bind(&MediaCodecVideoEncoder::SetRatesOnCodecThread,
-           this,
-           new_bit_rate,
-           frame_rate));
+      RTC_FROM_HERE, Bind(&MediaCodecVideoEncoder::SetRatesOnCodecThread, this,
+                          new_bit_rate, frame_rate));
 }
 
 void MediaCodecVideoEncoder::OnMessage(rtc::Message* msg) {
   RTC_DCHECK(codec_thread_checker_.CalledOnValidThread());
   JNIEnv* jni = AttachCurrentThreadIfNeeded();
   ScopedLocalRefFrame local_ref_frame(jni);
 
   // We only ever send one message to |this| directly (not through a Bind()'d
   // functor), so expect no ID/data.
   RTC_CHECK(!msg->message_id) << "Unexpected message!";
   RTC_CHECK(!msg->pdata) << "Unexpected message!";
   if (!inited_) {
     return;
   }
 
   // It would be nice to recover from a failure here if one happened, but it's
   // unclear how to signal such a failure to the app, so instead we stay silent
   // about it and let the next app-called API method reveal the borkedness.
   DeliverPendingOutputs(jni);
 
   // If there aren't more frames to deliver, we can stop the loop
   if (!input_frame_infos_.empty()) {
-    codec_thread_->PostDelayed(kMediaCodecPollMs, this);
+    codec_thread_->PostDelayed(RTC_FROM_HERE, kMediaCodecPollMs, this);
   } else {
     output_delivery_loop_running_ = false;
   }
 }
 
 bool MediaCodecVideoEncoder::ResetCodecOnCodecThread() {
   RTC_DCHECK(codec_thread_checker_.CalledOnValidThread());
   ALOGE << "ResetOnCodecThread";
   if (ReleaseOnCodecThread() != WEBRTC_VIDEO_CODEC_OK ||
       InitEncodeOnCodecThread(width_, height_, 0, 0, false) !=
@@ skipping 243 matching lines @@
       time_before_calling_encode, input_frame.timestamp(),
       input_frame.render_time_ms(), input_frame.rotation());
 
   last_input_timestamp_ms_ =
       current_timestamp_us_ / rtc::kNumMicrosecsPerMillisec;
 
   current_timestamp_us_ += rtc::kNumMicrosecsPerSec / last_set_fps_;
 
   if (!output_delivery_loop_running_) {
     output_delivery_loop_running_ = true;
-    codec_thread_->PostDelayed(kMediaCodecPollMs, this);
+    codec_thread_->PostDelayed(RTC_FROM_HERE, kMediaCodecPollMs, this);
   }
 
   if (!DeliverPendingOutputs(jni)) {
     ALOGE << "Failed deliver pending outputs.";
     ResetCodecOnCodecThread();
     return WEBRTC_VIDEO_CODEC_ERROR;
   }
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
@@ skipping 415 matching lines @@
     return (int32_t)(head - buffer);
   }
   return -1;
 }
 
 void MediaCodecVideoEncoder::OnDroppedFrame() {
   // Methods running on the codec thread should call OnDroppedFrameOnCodecThread
   // directly.
   RTC_DCHECK(!codec_thread_checker_.CalledOnValidThread());
   codec_thread_->Invoke<void>(
+      RTC_FROM_HERE,
       Bind(&MediaCodecVideoEncoder::OnDroppedFrameOnCodecThread, this));
 }
 
 void MediaCodecVideoEncoder::OnDroppedFrameOnCodecThread() {
   RTC_DCHECK(codec_thread_checker_.CalledOnValidThread());
   // Report dropped frame to quality_scaler_.
   if (scale_)
     quality_scaler_.ReportDroppedFrame();
 }
 
@@ skipping 84 matching lines @@
   return supported_codecs_;
 }
 
 void MediaCodecVideoEncoderFactory::DestroyVideoEncoder(
     webrtc::VideoEncoder* encoder) {
   ALOGD << "Destroy video encoder.";
   delete encoder;
 }
 
 }  // namespace webrtc_jni