Adding more detail to MessageQueue::Dispatch logging.

webrtc/pc/channel_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 250 matching lines @@
   bool AddStream1(int id) {
     return channel1_->AddRecvStream(cricket::StreamParams::CreateLegacy(id));
   }
   bool RemoveStream1(int id) {
     return channel1_->RemoveRecvStream(id);
   }
 
   cricket::FakeTransport* GetTransport1() {
     std::string name = channel1_->content_name();
     return network_thread_->Invoke<cricket::FakeTransport*>(
+        RTC_FROM_HERE,
         [this, name] { return transport_controller1_->GetTransport_n(name); });
   }
   cricket::FakeTransport* GetTransport2() {
     std::string name = channel2_->content_name();
     return network_thread_->Invoke<cricket::FakeTransport*>(
+        RTC_FROM_HERE,
         [this, name] { return transport_controller2_->GetTransport_n(name); });
   }
 
   void SendRtp1() {
     media_channel1_->SendRtp(rtp_packet_.data(), rtp_packet_.size(),
                              rtc::PacketOptions());
   }
   void SendRtp2() {
     media_channel2_->SendRtp(rtp_packet_.data(), rtp_packet_.size(),
                              rtc::PacketOptions());
@@ skipping 107 matching lines @@
 
   // Will manage the lifetime of a CallThread, making sure it's
   // destroyed before this object goes out of scope.
   class ScopedCallThread {
    public:
     template <class FunctorT>
     ScopedCallThread(const FunctorT& functor)
         : thread_(rtc::Thread::Create()),
           task_(new rtc::FunctorMessageHandler<void, FunctorT>(functor)) {
       thread_->Start();
-      thread_->Post(task_.get());
+      thread_->Post(RTC_FROM_HERE, task_.get());
     }
 
     ~ScopedCallThread() { thread_->Stop(); }
 
     rtc::Thread* thread() { return thread_.get(); }
 
    private:
     std::unique_ptr<rtc::Thread> thread_;
     std::unique_ptr<rtc::MessageHandler> task_;
   };
@@ skipping 490 matching lines @@
     CreateChannels(0, 0);
 
     cricket::TransportChannel* transport_channel1 =
         channel1_->transport_channel();
     ASSERT_TRUE(transport_channel1);
     typename T::MediaChannel* media_channel1 =
         static_cast<typename T::MediaChannel*>(channel1_->media_channel());
     ASSERT_TRUE(media_channel1);
 
     media_channel1->set_num_network_route_changes(0);
-    network_thread_->Invoke<void>([transport_channel1] {
+    network_thread_->Invoke<void>(RTC_FROM_HERE, [transport_channel1] {
       // The transport channel becomes disconnected.
       transport_channel1->SignalSelectedCandidatePairChanged(transport_channel1,
                                                              nullptr, -1);
     });
     WaitForThreads();
     EXPECT_EQ(1, media_channel1->num_network_route_changes());
     EXPECT_FALSE(media_channel1->last_network_route().connected);
     media_channel1->set_num_network_route_changes(0);
 
-    network_thread_->Invoke<void>([this, transport_channel1, media_channel1,
-                                   kLocalNetId, kRemoteNetId, kLastPacketId] {
+    network_thread_->Invoke<void>(RTC_FROM_HERE, [this, transport_channel1,
+                                                  media_channel1, kLocalNetId,
+                                                  kRemoteNetId, kLastPacketId] {
       // The transport channel becomes connected.
       rtc::SocketAddress local_address("192.168.1.1", 1000 /* port number */);
       rtc::SocketAddress remote_address("192.168.1.2", 2000 /* port number */);
       std::unique_ptr<cricket::CandidatePairInterface> candidate_pair(
           transport_controller1_->CreateFakeCandidatePair(
               local_address, kLocalNetId, remote_address, kRemoteNetId));
       transport_channel1->SignalSelectedCandidatePairChanged(
           transport_channel1, candidate_pair.get(), kLastPacketId);
     });
     WaitForThreads();
@@ skipping 512 matching lines @@
     SendRtp1();
     SendRtp2();
     WaitForThreads();
     EXPECT_TRUE(CheckRtp1());
     EXPECT_TRUE(CheckRtp2());
     EXPECT_TRUE(CheckNoRtp1());
     EXPECT_TRUE(CheckNoRtp2());
 
     // Lose writability, which should fail.
     network_thread_->Invoke<void>(
-        [this] { GetTransport1()->SetWritable(false); });
+        RTC_FROM_HERE, [this] { GetTransport1()->SetWritable(false); });
     SendRtp1();
     SendRtp2();
     WaitForThreads();
     EXPECT_TRUE(CheckRtp1());
     EXPECT_TRUE(CheckNoRtp2());
 
     // Regain writability
     network_thread_->Invoke<void>(
-        [this] { GetTransport1()->SetWritable(true); });
+        RTC_FROM_HERE, [this] { GetTransport1()->SetWritable(true); });
     EXPECT_TRUE(media_channel1_->sending());
     SendRtp1();
     SendRtp2();
     WaitForThreads();
     EXPECT_TRUE(CheckRtp1());
     EXPECT_TRUE(CheckRtp2());
     EXPECT_TRUE(CheckNoRtp1());
     EXPECT_TRUE(CheckNoRtp2());
 
     // Lose writability completely
     network_thread_->Invoke<void>(
-        [this] { GetTransport1()->SetDestination(NULL); });
+        RTC_FROM_HERE, [this] { GetTransport1()->SetDestination(NULL); });
     EXPECT_TRUE(media_channel1_->sending());
 
     // Should fail also.
     SendRtp1();
     SendRtp2();
     WaitForThreads();
     EXPECT_TRUE(CheckRtp1());
     EXPECT_TRUE(CheckNoRtp2());
 
     // Gain writability back
-    network_thread_->Invoke<void>(
-        [this] { GetTransport1()->SetDestination(GetTransport2()); });
+    network_thread_->Invoke<void>(RTC_FROM_HERE, [this] {
+      GetTransport1()->SetDestination(GetTransport2());
+    });
     EXPECT_TRUE(media_channel1_->sending());
     SendRtp1();
     SendRtp2();
     WaitForThreads();
     EXPECT_TRUE(CheckRtp1());
     EXPECT_TRUE(CheckRtp2());
     EXPECT_TRUE(CheckNoRtp1());
     EXPECT_TRUE(CheckNoRtp2());
   }
 
@@ skipping 279 matching lines @@
     media_channel2_->SendRtp(kBadPacket, sizeof(kBadPacket),
                              rtc::PacketOptions());
     WaitForThreads();
     EXPECT_EQ(cricket::SrtpFilter::ERROR_FAIL, error_handler.error_);
     EXPECT_EQ(cricket::SrtpFilter::PROTECT, error_handler.mode_);
 
     // Testing failures in receiving packets.
     error_handler.error_ = cricket::SrtpFilter::ERROR_NONE;
     error_handler.mode_ = cricket::SrtpFilter::UNPROTECT;
 
-    network_thread_->Invoke<void>([this] {
+    network_thread_->Invoke<void>(RTC_FROM_HERE, [this] {
       cricket::TransportChannel* transport_channel =
           channel2_->transport_channel();
       transport_channel->SignalReadPacket(
           transport_channel, reinterpret_cast<const char*>(kBadPacket),
           sizeof(kBadPacket), rtc::PacketTime(), 0);
     });
     EXPECT_EQ(cricket::SrtpFilter::ERROR_FAIL, error_handler.error_);
     EXPECT_EQ(cricket::SrtpFilter::UNPROTECT, error_handler.mode_);
   }
 
   void TestOnReadyToSend() {
     CreateChannels(RTCP, RTCP);
     TransportChannel* rtp = channel1_->transport_channel();
     TransportChannel* rtcp = channel1_->rtcp_transport_channel();
     EXPECT_FALSE(media_channel1_->ready_to_send());
 
-    network_thread_->Invoke<void>([rtp] { rtp->SignalReadyToSend(rtp); });
+    network_thread_->Invoke<void>(RTC_FROM_HERE,
+                                  [rtp] { rtp->SignalReadyToSend(rtp); });
     WaitForThreads();
     EXPECT_FALSE(media_channel1_->ready_to_send());
 
-    network_thread_->Invoke<void>([rtcp] { rtcp->SignalReadyToSend(rtcp); });
+    network_thread_->Invoke<void>(RTC_FROM_HERE,
+                                  [rtcp] { rtcp->SignalReadyToSend(rtcp); });
     WaitForThreads();
     // MediaChannel::OnReadyToSend only be called when both rtp and rtcp
     // channel are ready to send.
     EXPECT_TRUE(media_channel1_->ready_to_send());
 
     // rtp channel becomes not ready to send will be propagated to mediachannel
     network_thread_->Invoke<void>(
-        [this] { channel1_->SetReadyToSend(false, false); });
+        RTC_FROM_HERE, [this] { channel1_->SetReadyToSend(false, false); });
     WaitForThreads();
     EXPECT_FALSE(media_channel1_->ready_to_send());
 
     network_thread_->Invoke<void>(
-        [this] { channel1_->SetReadyToSend(false, true); });
+        RTC_FROM_HERE, [this] { channel1_->SetReadyToSend(false, true); });
     WaitForThreads();
     EXPECT_TRUE(media_channel1_->ready_to_send());
 
     // rtcp channel becomes not ready to send will be propagated to mediachannel
     network_thread_->Invoke<void>(
-        [this] { channel1_->SetReadyToSend(true, false); });
+        RTC_FROM_HERE, [this] { channel1_->SetReadyToSend(true, false); });
     WaitForThreads();
     EXPECT_FALSE(media_channel1_->ready_to_send());
 
     network_thread_->Invoke<void>(
-        [this] { channel1_->SetReadyToSend(true, true); });
+        RTC_FROM_HERE, [this] { channel1_->SetReadyToSend(true, true); });
     WaitForThreads();
     EXPECT_TRUE(media_channel1_->ready_to_send());
   }
 
   void TestOnReadyToSendWithRtcpMux() {
     CreateChannels(RTCP, RTCP);
     typename T::Content content;
     CreateContent(0, kPcmuCodec, kH264Codec, &content);
     // Both sides agree on mux. Should no longer be a separate RTCP channel.
     content.set_rtcp_mux(true);
     EXPECT_TRUE(channel1_->SetLocalContent(&content, CA_OFFER, NULL));
     EXPECT_TRUE(channel1_->SetRemoteContent(&content, CA_ANSWER, NULL));
     EXPECT_TRUE(channel1_->rtcp_transport_channel() == NULL);
     TransportChannel* rtp = channel1_->transport_channel();
     EXPECT_FALSE(media_channel1_->ready_to_send());
     // In the case of rtcp mux, the SignalReadyToSend() from rtp channel
     // should trigger the MediaChannel's OnReadyToSend.
-    network_thread_->Invoke<void>([rtp] { rtp->SignalReadyToSend(rtp); });
+    network_thread_->Invoke<void>(RTC_FROM_HERE,
+                                  [rtp] { rtp->SignalReadyToSend(rtp); });
     WaitForThreads();
     EXPECT_TRUE(media_channel1_->ready_to_send());
 
     network_thread_->Invoke<void>(
-        [this] { channel1_->SetReadyToSend(false, false); });
+        RTC_FROM_HERE, [this] { channel1_->SetReadyToSend(false, false); });
     WaitForThreads();
     EXPECT_FALSE(media_channel1_->ready_to_send());
   }
 
   bool SetRemoteContentWithBitrateLimit(int remote_limit) {
     typename T::Content content;
     CreateContent(0, kPcmuCodec, kH264Codec, &content);
     content.set_bandwidth(remote_limit);
     return channel1_->SetRemoteContent(&content, CA_OFFER, NULL);
   }
@@ skipping 42 matching lines @@
   void WaitForThreads() { WaitForThreads(rtc::ArrayView<rtc::Thread*>()); }
   static void ProcessThreadQueue(rtc::Thread* thread) {
     RTC_DCHECK(thread->IsCurrent());
     while (!thread->empty()) {
       thread->ProcessMessages(0);
     }
   }
   void WaitForThreads(rtc::ArrayView<rtc::Thread*> threads) {
     // |threads| and current thread post packets to network thread.
     for (rtc::Thread* thread : threads) {
-      thread->Invoke<void>([thread] { ProcessThreadQueue(thread); });
+      thread->Invoke<void>(RTC_FROM_HERE,
+                           [thread] { ProcessThreadQueue(thread); });
     }
     ProcessThreadQueue(rtc::Thread::Current());
     // Network thread move them around and post back to worker = current thread.
     if (!network_thread_->IsCurrent()) {
       network_thread_->Invoke<void>(
-          [this] { ProcessThreadQueue(network_thread_); });
+          RTC_FROM_HERE, [this] { ProcessThreadQueue(network_thread_); });
     }
     // Worker thread = current Thread process received messages.
     ProcessThreadQueue(rtc::Thread::Current());
   }
   // TODO(pbos): Remove playout from all media channels and let renderers mute
   // themselves.
   const bool verify_playout_;
   std::unique_ptr<rtc::Thread> network_thread_keeper_;
   rtc::Thread* network_thread_;
   std::unique_ptr<cricket::FakeTransportController> transport_controller1_;
@@ skipping 1647 matching lines @@
   };
   rtc::CopyOnWriteBuffer payload(data, 3);
   cricket::SendDataResult result;
   ASSERT_TRUE(media_channel1_->SendData(params, payload, &result));
   EXPECT_EQ(params.ssrc,
             media_channel1_->last_sent_data_params().ssrc);
   EXPECT_EQ("foo", media_channel1_->last_sent_data());
 }
 
 // TODO(pthatcher): TestSetReceiver?