Delete SignalThread class.

webrtc/base/messagequeue.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.
  */
 #include <algorithm>
@@ skipping 26 matching lines @@
     *locked_ = false;
     cs_->Leave();
   }
 
  private:
   const CriticalSection* const cs_;
   bool* locked_;
 
   RTC_DISALLOW_COPY_AND_ASSIGN(DebugNonReentrantCritScope);
 };
+
+class FunctorPostMessageHandler : public MessageHandler {
+ public:
+  void OnMessage(Message* msg) override {
+    CallableData* data = static_cast<CallableData*>(msg->pdata);
+    data->Call();
+    delete data;
+  }
+};
+
 }  // namespace
 
 //------------------------------------------------------------------
 // MessageQueueManager
 
 MessageQueueManager* MessageQueueManager::instance_ = nullptr;
 
 MessageQueueManager* MessageQueueManager::Instance() {
   // Note: This is not thread safe, but it is first called before threads are
   // spawned.
@@ skipping 304 matching lines @@
 
 void MessageQueue::ReceiveSends() {
 }
 
 void MessageQueue::Post(const Location& posted_from,
                         MessageHandler* phandler,
                         uint32_t id,
                         MessageData* pdata,
                         bool time_sensitive) {
   if (IsQuitting())
     return;

[nisse-webrtc, 2017/06/27 08:27:17]

Unrelated to this cl, but shouldn't this code call 

  delete pdata

before returning, analogous to messages removed by Clear()?

It's also unclear to me what synchronization is intended with the use of the
|stop_| flag. What if Post method could gets to this check, sees IsQuitting()
false, and then is preempted? And by the time it's rescheduled, after lots of
other action, IsQuitting() might be true. When can that happen? And if it's
harmless, why do we have the check in the first place?

[tommi, 2017/06/27 12:01:14]

depends - I think there might be call sites that control deletion of pdata. It's
too bad that there isn't a return value or that ownership of pdata isn't passed
via unique_ptr.

[nisse-webrtc, 2017/06/28 11:47:54]

I was thinking that we should handle discarded messages in the same way, both if
they're discarded based on the quit flag here, or if they're put onto the list
but discarded later by the Clear() method. It's hard for caller to observe any
difference.

The comment just above the MessageData class says "App manages lifetime, except
when messages are purged", which isn't crystal clear.

 
   // Keep thread safe
   // Add the message to the end of the queue
   // Signal for the multiplexer to return
 
   {
     CritScope cs(&crit_);
     Message msg;
     msg.posted_from = posted_from;
     msg.phandler = phandler;
@@ skipping 140 matching lines @@
   int64_t start_time = TimeMillis();
   pmsg->phandler->OnMessage(pmsg);
   int64_t end_time = TimeMillis();
   int64_t diff = TimeDiff(end_time, start_time);
   if (diff >= kSlowDispatchLoggingThreshold) {
     LOG(LS_INFO) << "Message took " << diff << "ms to dispatch. Posted from: "
                  << pmsg->posted_from.ToString();
   }
 }
 
+void MessageQueue::PostFunctorInternal(const Location& posted_from,
+                                       CallableData* message_data) {
+  // Use static to ensure it outlives this scope. Safe since
+  // FunctorPostMessageHandler keeps no state.
+  static FunctorPostMessageHandler handler;
+  Post(posted_from, &handler, 0, message_data);
+}
+
 }  // namespace rtc