Adding more detail to MessageQueue::Dispatch logging.

webrtc/api/dtlsidentitystore.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 40 matching lines @@
  private:
   void GenerateIdentity_w() {
     LOG(LS_INFO) << "Generating identity, using keytype " << key_type_;
     std::unique_ptr<rtc::SSLIdentity> identity(
         rtc::SSLIdentity::Generate(kIdentityName, key_type_));
 
     // Posting to |this| avoids touching |store_| on threads other than
     // |signaling_thread_| and thus avoids having to use locks.
     IdentityResultMessageData* msg = new IdentityResultMessageData(
         new IdentityResult(key_type_, std::move(identity)));
-    signaling_thread_->Post(this, MSG_GENERATE_IDENTITY_RESULT, msg);
+    signaling_thread_->Post(FROM_HERE, this, MSG_GENERATE_IDENTITY_RESULT, msg);
   }
 
   void OnMessage(rtc::Message* msg) override {
     switch (msg->message_id) {
       case MSG_GENERATE_IDENTITY:
         // This message always runs on the worker thread.
         GenerateIdentity_w();
 
         // Must delete |this|, owned by msg->pdata, on the signaling thread to
         // avoid races on disconnecting the signal.
-        signaling_thread_->Post(this, MSG_DESTROY, msg->pdata);
+        signaling_thread_->Post(FROM_HERE, this, MSG_DESTROY, msg->pdata);
         break;
       case MSG_GENERATE_IDENTITY_RESULT:
         RTC_DCHECK(signaling_thread_->IsCurrent());
         {
           std::unique_ptr<IdentityResultMessageData> pdata(
               static_cast<IdentityResultMessageData*>(msg->pdata));
           if (store_) {
             store_->OnIdentityGenerated(pdata->data()->key_type_,
                                         std::move(pdata->data()->identity_));
           }
@@ skipping 73 matching lines @@
     request_info_[key_type].request_observers_.push(observer);
 
     // Already have a free identity generated?
     if (request_info_[key_type].free_identity_.get()) {
       // Return identity async - post even though we are on |signaling_thread_|.
       LOG(LS_VERBOSE) << "Using a free DTLS identity.";
       ++request_info_[key_type].gen_in_progress_counts_;
       IdentityResultMessageData* msg =
           new IdentityResultMessageData(new IdentityResult(
               key_type, std::move(request_info_[key_type].free_identity_)));
-      signaling_thread_->Post(this, MSG_GENERATE_IDENTITY_RESULT, msg);
+      signaling_thread_->Post(FROM_HERE, this, MSG_GENERATE_IDENTITY_RESULT,
+                              msg);
       return;
     }
 
     // Free identity in the process of being generated?
     if (request_info_[key_type].gen_in_progress_counts_ ==
             request_info_[key_type].request_observers_.size()) {
       // No need to do anything, the free identity will be returned to the
       // observer in a MSG_GENERATE_IDENTITY_RESULT.
       return;
     }
   }
 
   // Enqueue/Post a worker task to do the generation.
   ++request_info_[key_type].gen_in_progress_counts_;
   WorkerTask* task = new WorkerTask(this, key_type);  // Post 1 task/request.
   // The WorkerTask is owned by the message data to make sure it will not be
   // leaked even if the task does not get run.
   WorkerTaskMessageData* msg = new WorkerTaskMessageData(task);
-  worker_thread_->Post(task, MSG_GENERATE_IDENTITY, msg);
+  worker_thread_->Post(FROM_HERE, task, MSG_GENERATE_IDENTITY, msg);
 }
 
 void DtlsIdentityStoreImpl::OnIdentityGenerated(
     rtc::KeyType key_type,
     std::unique_ptr<rtc::SSLIdentity> identity) {
   RTC_DCHECK(signaling_thread_->IsCurrent());
 
   RTC_DCHECK(request_info_[key_type].gen_in_progress_counts_);
   --request_info_[key_type].gen_in_progress_counts_;
 
@@ skipping 26 matching lines @@
         key_type == rtc::KT_RSA &&             // Only necessary for RSA.
         !request_info_[key_type].free_identity_.get() &&
         request_info_[key_type].request_observers_.size() ==
             request_info_[key_type].gen_in_progress_counts_) {
       GenerateIdentity(key_type, nullptr);
     }
   }
 }
 
 }  // namespace webrtc