Adding more detail to MessageQueue::Dispatch logging.

webrtc/p2p/base/p2ptransportchannel_unittest.cc

 /*
  *  Copyright 2009 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 637 matching lines @@
 
   // We pass the candidates directly to the other side.
   void OnCandidateGathered(cricket::TransportChannelImpl* ch,
                            const cricket::Candidate& c) {
     if (force_relay_ && c.type() != cricket::RELAY_PORT_TYPE)
       return;
 
     if (GetEndpoint(ch)->save_candidates_) {
       GetEndpoint(ch)->saved_candidates_.push_back(new CandidatesData(ch, c));
     } else {
-      main_->Post(this, MSG_ADD_CANDIDATES, new CandidatesData(ch, c));
+      main_->Post(RTC_FROM_HERE, this, MSG_ADD_CANDIDATES,
+                  new CandidatesData(ch, c));
     }
   }
 
   void PauseCandidates(int endpoint) {
     GetEndpoint(endpoint)->save_candidates_ = true;
   }
 
   void OnCandidatesRemoved(cricket::TransportChannelImpl* ch,
                            const std::vector<cricket::Candidate>& candidates) {
     // Candidate removals are not paused.
     CandidatesData* candidates_data = new CandidatesData(ch, candidates);
-    main_->Post(this, MSG_REMOVE_CANDIDATES, candidates_data);
+    main_->Post(RTC_FROM_HERE, this, MSG_REMOVE_CANDIDATES, candidates_data);
   }
 
   // Tcp candidate verification has to be done when they are generated.
   void VerifySavedTcpCandidates(int endpoint, const std::string& tcptype) {
     for (auto& data : GetEndpoint(endpoint)->saved_candidates_) {
       for (auto& candidate : data->candidates) {
         EXPECT_EQ(candidate.protocol(), cricket::TCP_PROTOCOL_NAME);
         EXPECT_EQ(candidate.tcptype(), tcptype);
         if (candidate.tcptype() == cricket::TCPTYPE_ACTIVE_STR) {
           EXPECT_EQ(candidate.address().port(), cricket::DISCARD_PORT);
         } else if (candidate.tcptype() == cricket::TCPTYPE_PASSIVE_STR) {
           EXPECT_NE(candidate.address().port(), cricket::DISCARD_PORT);
         } else {
           FAIL() << "Unknown tcptype: " << candidate.tcptype();
         }
       }
     }
   }
 
   void ResumeCandidates(int endpoint) {
     Endpoint* ed = GetEndpoint(endpoint);
     std::vector<CandidatesData*>::iterator it = ed->saved_candidates_.begin();
     for (; it != ed->saved_candidates_.end(); ++it) {
-      main_->Post(this, MSG_ADD_CANDIDATES, *it);
+      main_->Post(RTC_FROM_HERE, this, MSG_ADD_CANDIDATES, *it);
     }
     ed->saved_candidates_.clear();
     ed->save_candidates_ = false;
   }
 
   void OnMessage(rtc::Message* msg) {
     switch (msg->message_id) {
       case MSG_ADD_CANDIDATES: {
         std::unique_ptr<CandidatesData> data(
             static_cast<CandidatesData*>(msg->pdata));
@@ skipping 2210 matching lines @@
 
   // TCP Relay/Relay is the next.
   VerifyNextPingableConnection(cricket::RELAY_PORT_TYPE,
                                cricket::RELAY_PORT_TYPE,
                                cricket::TCP_PROTOCOL_NAME);
 
   // Finally, Local/Relay will be pinged.
   VerifyNextPingableConnection(cricket::LOCAL_PORT_TYPE,
                                cricket::RELAY_PORT_TYPE);
 }