Adding more detail to MessageQueue::Dispatch logging.

webrtc/pc/channelmanager.cc

 /*
  *  Copyright 2004 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 63 matching lines @@
     Terminate();
     // If srtp is initialized (done by the Channel) then we must call
     // srtp_shutdown to free all crypto kernel lists. But we need to make sure
     // shutdown always called at the end, after channels are destroyed.
     // ChannelManager d'tor is always called last, it's safe place to call
     // shutdown.
     ShutdownSrtp();
   }
   // The media engine needs to be deleted on the worker thread for thread safe
   // destruction,
-  worker_thread_->Invoke<void>(Bind(
-      &ChannelManager::DestructorDeletes_w, this));
+  worker_thread_->Invoke<void>(
+      RTC_FROM_HERE, Bind(&ChannelManager::DestructorDeletes_w, this));
 }
 
 bool ChannelManager::SetVideoRtxEnabled(bool enable) {
   // To be safe, this call is only allowed before initialization. Apps like
   // Flute only have a singleton ChannelManager and we don't want this flag to
   // be toggled between calls or when there's concurrent calls. We expect apps
   // to enable this at startup and retain that setting for the lifetime of the
   // app.
   if (!initialized_) {
     enable_rtx_ = enable;
@@ skipping 47 matching lines @@
 bool ChannelManager::Init() {
   ASSERT(!initialized_);
   if (initialized_) {
     return false;
   }
   RTC_DCHECK(network_thread_);
   RTC_DCHECK(worker_thread_);
   if (!network_thread_->IsCurrent()) {
     // Do not allow invoking calls to other threads on the network thread.
     network_thread_->Invoke<bool>(
+        RTC_FROM_HERE,
         rtc::Bind(&rtc::Thread::SetAllowBlockingCalls, network_thread_, false));
   }
 
   initialized_ = worker_thread_->Invoke<bool>(
-      Bind(&ChannelManager::InitMediaEngine_w, this));
+      RTC_FROM_HERE, Bind(&ChannelManager::InitMediaEngine_w, this));
   ASSERT(initialized_);
   if (!initialized_) {
     return false;
   }
 
   // If audio_output_volume_ has been set via SetOutputVolume(), set the
   // audio output volume of the engine.
   if (kNotSetOutputVolume != audio_output_volume_ &&
       !SetOutputVolume(audio_output_volume_)) {
     LOG(LS_WARNING) << "Failed to SetOutputVolume to "
                     << audio_output_volume_;
   }
 
   return initialized_;
 }
 
 bool ChannelManager::InitMediaEngine_w() {
   ASSERT(worker_thread_ == rtc::Thread::Current());
   return media_engine_->Init();
 }
 
 void ChannelManager::Terminate() {
   ASSERT(initialized_);
   if (!initialized_) {
     return;
   }
-  worker_thread_->Invoke<void>(Bind(&ChannelManager::Terminate_w, this));
+  worker_thread_->Invoke<void>(RTC_FROM_HERE,
+                               Bind(&ChannelManager::Terminate_w, this));
   initialized_ = false;
 }
 
 void ChannelManager::DestructorDeletes_w() {
   ASSERT(worker_thread_ == rtc::Thread::Current());
   media_engine_.reset(NULL);
 }
 
 void ChannelManager::Terminate_w() {
   ASSERT(worker_thread_ == rtc::Thread::Current());
   // Need to destroy the voice/video channels
   while (!video_channels_.empty()) {
     DestroyVideoChannel_w(video_channels_.back());
   }
   while (!voice_channels_.empty()) {
     DestroyVoiceChannel_w(voice_channels_.back());
   }
 }
 
 VoiceChannel* ChannelManager::CreateVoiceChannel(
     webrtc::MediaControllerInterface* media_controller,
     TransportController* transport_controller,
     const std::string& content_name,
     const std::string* bundle_transport_name,
     bool rtcp,
     const AudioOptions& options) {
   return worker_thread_->Invoke<VoiceChannel*>(
-      Bind(&ChannelManager::CreateVoiceChannel_w, this, media_controller,
-           transport_controller, content_name, bundle_transport_name, rtcp,
-           options));
+      RTC_FROM_HERE, Bind(&ChannelManager::CreateVoiceChannel_w, this,
+                          media_controller, transport_controller, content_name,
+                          bundle_transport_name, rtcp, options));
 }
 
 VoiceChannel* ChannelManager::CreateVoiceChannel_w(
     webrtc::MediaControllerInterface* media_controller,
     TransportController* transport_controller,
     const std::string& content_name,
     const std::string* bundle_transport_name,
     bool rtcp,
     const AudioOptions& options) {
   ASSERT(initialized_);
@@ skipping 12 matching lines @@
     return nullptr;
   }
   voice_channels_.push_back(voice_channel);
   return voice_channel;
 }
 
 void ChannelManager::DestroyVoiceChannel(VoiceChannel* voice_channel) {
   TRACE_EVENT0("webrtc", "ChannelManager::DestroyVoiceChannel");
   if (voice_channel) {
     worker_thread_->Invoke<void>(
+        RTC_FROM_HERE,
         Bind(&ChannelManager::DestroyVoiceChannel_w, this, voice_channel));
   }
 }
 
 void ChannelManager::DestroyVoiceChannel_w(VoiceChannel* voice_channel) {
   TRACE_EVENT0("webrtc", "ChannelManager::DestroyVoiceChannel_w");
   // Destroy voice channel.
   ASSERT(initialized_);
   ASSERT(worker_thread_ == rtc::Thread::Current());
   VoiceChannels::iterator it = std::find(voice_channels_.begin(),
       voice_channels_.end(), voice_channel);
   ASSERT(it != voice_channels_.end());
   if (it == voice_channels_.end())
     return;
   voice_channels_.erase(it);
   delete voice_channel;
 }
 
 VideoChannel* ChannelManager::CreateVideoChannel(
     webrtc::MediaControllerInterface* media_controller,
     TransportController* transport_controller,
     const std::string& content_name,
     const std::string* bundle_transport_name,
     bool rtcp,
     const VideoOptions& options) {
   return worker_thread_->Invoke<VideoChannel*>(
-      Bind(&ChannelManager::CreateVideoChannel_w, this, media_controller,
-           transport_controller, content_name, bundle_transport_name, rtcp,
-           options));
+      RTC_FROM_HERE, Bind(&ChannelManager::CreateVideoChannel_w, this,
+                          media_controller, transport_controller, content_name,
+                          bundle_transport_name, rtcp, options));
 }
 
 VideoChannel* ChannelManager::CreateVideoChannel_w(
     webrtc::MediaControllerInterface* media_controller,
     TransportController* transport_controller,
     const std::string& content_name,
     const std::string* bundle_transport_name,
     bool rtcp,
     const VideoOptions& options) {
   ASSERT(initialized_);
@@ skipping 13 matching lines @@
     return NULL;
   }
   video_channels_.push_back(video_channel);
   return video_channel;
 }
 
 void ChannelManager::DestroyVideoChannel(VideoChannel* video_channel) {
   TRACE_EVENT0("webrtc", "ChannelManager::DestroyVideoChannel");
   if (video_channel) {
     worker_thread_->Invoke<void>(
+        RTC_FROM_HERE,
         Bind(&ChannelManager::DestroyVideoChannel_w, this, video_channel));
   }
 }
 
 void ChannelManager::DestroyVideoChannel_w(VideoChannel* video_channel) {
   TRACE_EVENT0("webrtc", "ChannelManager::DestroyVideoChannel_w");
   // Destroy video channel.
   ASSERT(initialized_);
   ASSERT(worker_thread_ == rtc::Thread::Current());
   VideoChannels::iterator it = std::find(video_channels_.begin(),
       video_channels_.end(), video_channel);
   ASSERT(it != video_channels_.end());
   if (it == video_channels_.end())
     return;
 
   video_channels_.erase(it);
   delete video_channel;
 }
 
 DataChannel* ChannelManager::CreateDataChannel(
     TransportController* transport_controller,
     const std::string& content_name,
     const std::string* bundle_transport_name,
     bool rtcp,
     DataChannelType channel_type) {
   return worker_thread_->Invoke<DataChannel*>(
+      RTC_FROM_HERE,
       Bind(&ChannelManager::CreateDataChannel_w, this, transport_controller,
            content_name, bundle_transport_name, rtcp, channel_type));
 }
 
 DataChannel* ChannelManager::CreateDataChannel_w(
     TransportController* transport_controller,
     const std::string& content_name,
     const std::string* bundle_transport_name,
     bool rtcp,
     DataChannelType data_channel_type) {
@@ skipping 16 matching lines @@
     return NULL;
   }
   data_channels_.push_back(data_channel);
   return data_channel;
 }
 
 void ChannelManager::DestroyDataChannel(DataChannel* data_channel) {
   TRACE_EVENT0("webrtc", "ChannelManager::DestroyDataChannel");
   if (data_channel) {
     worker_thread_->Invoke<void>(
+        RTC_FROM_HERE,
         Bind(&ChannelManager::DestroyDataChannel_w, this, data_channel));
   }
 }
 
 void ChannelManager::DestroyDataChannel_w(DataChannel* data_channel) {
   TRACE_EVENT0("webrtc", "ChannelManager::DestroyDataChannel_w");
   // Destroy data channel.
   ASSERT(initialized_);
   DataChannels::iterator it = std::find(data_channels_.begin(),
       data_channels_.end(), data_channel);
   ASSERT(it != data_channels_.end());
   if (it == data_channels_.end())
     return;
 
   data_channels_.erase(it);
   delete data_channel;
 }
 
 bool ChannelManager::GetOutputVolume(int* level) {
   if (!initialized_) {
     return false;
   }
   return worker_thread_->Invoke<bool>(
+      RTC_FROM_HERE,
       Bind(&MediaEngineInterface::GetOutputVolume, media_engine_.get(), level));
 }
 
 bool ChannelManager::SetOutputVolume(int level) {
   bool ret = level >= 0 && level <= 255;
   if (initialized_) {
     ret &= worker_thread_->Invoke<bool>(
-        Bind(&MediaEngineInterface::SetOutputVolume,
-             media_engine_.get(), level));
+        RTC_FROM_HERE, Bind(&MediaEngineInterface::SetOutputVolume,
+                            media_engine_.get(), level));
   }
 
   if (ret) {
     audio_output_volume_ = level;
   }
 
   return ret;
 }
 
 
 bool ChannelManager::StartAecDump(rtc::PlatformFile file,
                                   int64_t max_size_bytes) {
-  return worker_thread_->Invoke<bool>(Bind(&MediaEngineInterface::StartAecDump,
-                                           media_engine_.get(), file,
-                                           max_size_bytes));
+  return worker_thread_->Invoke<bool>(
+      RTC_FROM_HERE, Bind(&MediaEngineInterface::StartAecDump,
+                          media_engine_.get(), file, max_size_bytes));
 }
 
 void ChannelManager::StopAecDump() {
   worker_thread_->Invoke<void>(
+      RTC_FROM_HERE,
       Bind(&MediaEngineInterface::StopAecDump, media_engine_.get()));
 }
 
 bool ChannelManager::StartRtcEventLog(rtc::PlatformFile file,
                                       int64_t max_size_bytes) {
   return worker_thread_->Invoke<bool>(
-      Bind(&MediaEngineInterface::StartRtcEventLog, media_engine_.get(), file,
-           max_size_bytes));
+      RTC_FROM_HERE, Bind(&MediaEngineInterface::StartRtcEventLog,
+                          media_engine_.get(), file, max_size_bytes));
 }
 
 void ChannelManager::StopRtcEventLog() {
   worker_thread_->Invoke<void>(
+      RTC_FROM_HERE,
       Bind(&MediaEngineInterface::StopRtcEventLog, media_engine_.get()));
 }
 
 }  // namespace cricket