Roll WebRTC 13098:13104

jingle/glue/thread_wrapper.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "jingle/glue/thread_wrapper.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/lazy_instance.h"
 #include "base/macros.h"
 #include "base/threading/thread_local.h"
+#include "base/trace_event/trace_event.h"
 #include "third_party/webrtc/base/nullsocketserver.h"
 
 namespace jingle_glue {
 
 struct JingleThreadWrapper::PendingSend {
   PendingSend(const rtc::Message& message_value)
       : sending_thread(JingleThreadWrapper::current()),
         message(message_value),
         done_event(base::WaitableEvent::ResetPolicy::MANUAL,
                    base::WaitableEvent::InitialState::NOT_SIGNALED) {
@@ skipping 60 matching lines @@
   rtc::MessageQueueManager::Remove(this);
   g_jingle_thread_wrapper.Get().Set(nullptr);
 
   Clear(nullptr, rtc::MQID_ANY, nullptr);
 }
 
 void JingleThreadWrapper::WillDestroyCurrentMessageLoop() {
   delete this;
 }
 
-void JingleThreadWrapper::Post(rtc::MessageHandler* handler,
+void JingleThreadWrapper::Post(const rtc::Location& posted_from,
+                               rtc::MessageHandler* handler,
                                uint32_t message_id,
                                rtc::MessageData* data,
                                bool time_sensitive) {
-  PostTaskInternal(0, handler, message_id, data);
+  PostTaskInternal(posted_from, 0, handler, message_id, data);
 }
 
-void JingleThreadWrapper::PostDelayed(int delay_ms,
+void JingleThreadWrapper::PostDelayed(const rtc::Location& posted_from,
+                                      int delay_ms,
                                       rtc::MessageHandler* handler,
                                       uint32_t message_id,
                                       rtc::MessageData* data) {
-  PostTaskInternal(delay_ms, handler, message_id, data);
+  PostTaskInternal(posted_from, delay_ms, handler, message_id, data);
 }
 
 void JingleThreadWrapper::Clear(rtc::MessageHandler* handler,
                                 uint32_t id,
                                 rtc::MessageList* removed) {
   base::AutoLock auto_lock(lock_);
 
   for (MessagesQueue::iterator it = messages_.begin();
        it != messages_.end();) {
     MessagesQueue::iterator next = it;
@@ skipping 23 matching lines @@
         delete (*it)->message.pdata;
       }
       (*it)->done_event.Signal();
       pending_send_messages_.erase(it);
     }
 
     it = next;
   }
 }
 
-void JingleThreadWrapper::Send(rtc::MessageHandler* handler,
+void JingleThreadWrapper::Dispatch(rtc::Message* message) {
+  TRACE_EVENT2("webrtc", "JingleThreadWrapper::Dispatch", "src_file_and_line",
+               message->posted_from.file_and_line(), "src_func",
+               message->posted_from.function_name());
+  message->phandler->OnMessage(message);
+}
+
+void JingleThreadWrapper::Send(const rtc::Location& posted_from,
+                               rtc::MessageHandler* handler,
                                uint32_t id,
                                rtc::MessageData* data) {
   if (fStop_)
     return;
 
   JingleThreadWrapper* current_thread = JingleThreadWrapper::current();
   DCHECK(current_thread != nullptr) << "Send() can be called only from a "
       "thread that has JingleThreadWrapper.";
 
   rtc::Message message;
+  message.posted_from = posted_from;
   message.phandler = handler;
   message.message_id = id;
   message.pdata = data;
 
   if (current_thread == this) {
-    handler->OnMessage(&message);
+    Dispatch(&message);
     return;
   }
 
   // Send message from a thread different than |this|.
 
   // Allow inter-thread send only from threads that have
   // |send_allowed_| flag set.
   DCHECK(current_thread->send_allowed_) << "Send()'ing synchronous "
       "messages is not allowed from the current thread.";
 
@@ skipping 30 matching lines @@
       if (!pending_send_messages_.empty()) {
         pending_send = pending_send_messages_.front();
         pending_send_messages_.pop_front();
       } else {
         // Reset the event while |lock_| is still locked.
         pending_send_event_.Reset();
         break;
       }
     }
     if (pending_send) {
-      pending_send->message.phandler->OnMessage(&pending_send->message);
+      Dispatch(&pending_send->message);
       pending_send->done_event.Signal();
     }
   }
 }
 
-void JingleThreadWrapper::PostTaskInternal(int delay_ms,
+void JingleThreadWrapper::PostTaskInternal(const rtc::Location& posted_from,
+                                           int delay_ms,
                                            rtc::MessageHandler* handler,
                                            uint32_t message_id,
                                            rtc::MessageData* data) {
   int task_id;
   rtc::Message message;
+  message.posted_from = posted_from;
   message.phandler = handler;
   message.message_id = message_id;
   message.pdata = data;
   {
     base::AutoLock auto_lock(lock_);
     task_id = ++last_task_id_;
     messages_.insert(std::pair<int, rtc::Message>(task_id, message));
   }
 
   if (delay_ms <= 0) {
@@ skipping 19 matching lines @@
       message = it->second;
       messages_.erase(it);
     }
   }
 
   if (have_message) {
     if (message.message_id == rtc::MQID_DISPOSE) {
       DCHECK(message.phandler == nullptr);
       delete message.pdata;
     } else {
-      message.phandler->OnMessage(&message);
+      Dispatch(&message);
     }
   }
 }
 
 // All methods below are marked as not reached. See comments in the
 // header for more details.
 void JingleThreadWrapper::Quit() {
   NOTREACHED();
 }
 
 bool JingleThreadWrapper::IsQuitting() {
   NOTREACHED();
   return false;
 }
 
 void JingleThreadWrapper::Restart() {
   NOTREACHED();
 }
 
 bool JingleThreadWrapper::Get(rtc::Message*, int, bool) {
   NOTREACHED();
   return false;
 }
 
 bool JingleThreadWrapper::Peek(rtc::Message*, int) {
   NOTREACHED();
   return false;
 }
 
-void JingleThreadWrapper::PostAt(uint32_t,
+void JingleThreadWrapper::PostAt(const rtc::Location& posted_from,
+                                 uint32_t,
                                  rtc::MessageHandler*,
                                  uint32_t,
                                  rtc::MessageData*) {
   NOTREACHED();
 }
 
-void JingleThreadWrapper::Dispatch(rtc::Message* message) {
-  NOTREACHED();
-}
-
 void JingleThreadWrapper::ReceiveSends() {
   NOTREACHED();
 }
 
 int JingleThreadWrapper::GetDelay() {
   NOTREACHED();
   return 0;
 }
 
 void JingleThreadWrapper::Stop() {
   NOTREACHED();
 }
 
 void JingleThreadWrapper::Run() {
   NOTREACHED();
 }
 
 }  // namespace jingle_glue