Delete SignalThread class.

webrtc/rtc_base/messagequeue.h

 /*
  *  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 129 matching lines @@
 
 template<class T>
 class DisposeData : public MessageData {
  public:
   explicit DisposeData(T* data) : data_(data) { }
   virtual ~DisposeData() { delete data_; }
  private:
   T* data_;
 };
 
+class RunnableData : public MessageData {

[tommi, 2017/06/29 12:27:52]

can you add a TODO here to move over to using QueuedTask instead?

[nisse-webrtc, 2017/06/29 12:38:38]

Done.

+ public:
+  virtual void Run() = 0;
+};
+
+template <class FunctorT>
+class FunctorData : public RunnableData {
+ public:
+  explicit FunctorData(FunctorT functor) : functor_(std::move(functor)) {}
+  void Run() override { functor_(); }
+
+ private:
+  FunctorT functor_;
+};
+
 const uint32_t MQID_ANY = static_cast<uint32_t>(-1);
 const uint32_t MQID_DISPOSE = static_cast<uint32_t>(-2);
 
 // No destructor
 
 struct Message {
   Message()
       : phandler(nullptr), message_id(0), pdata(nullptr), ts_sensitive(0) {}
   inline bool Match(MessageHandler* handler, uint32_t id) const {
     return (handler == nullptr || handler == phandler) &&
@@ skipping 69 matching lines @@
   //  2) cmsWait seconds have elapsed (returns false)
   //  3) Stop() is called (returns false)
   virtual bool Get(Message *pmsg, int cmsWait = kForever,
                    bool process_io = true);
   virtual bool Peek(Message *pmsg, int cmsWait = 0);
   virtual void Post(const Location& posted_from,
                     MessageHandler* phandler,
                     uint32_t id = 0,
                     MessageData* pdata = nullptr,
                     bool time_sensitive = false);
+
+  // TODO(nisse): Replace with a method for posting a
+  // std::unique_ptr<QueuedTask>, to ease gradual conversion to using TaskQueue.
+  template <class FunctorT,
+            // Additional type check, or else it collides with calls to the
+            // above Post method with the optional arguments omitted.
+            typename std::enable_if<!std::is_pointer<FunctorT>::value>::type* =
+                nullptr>
+  void Post(const Location& posted_from, FunctorT functor) {
+    PostFunctorInternal(posted_from,
+                        new FunctorData<FunctorT>(std::move(functor)));
+  }
+
   virtual void PostDelayed(const Location& posted_from,
                            int cmsDelay,
                            MessageHandler* phandler,
                            uint32_t id = 0,
                            MessageData* pdata = nullptr);
   virtual void PostAt(const Location& posted_from,
                       int64_t tstamp,
                       MessageHandler* phandler,
                       uint32_t id = 0,
                       MessageData* pdata = nullptr);
@@ skipping 56 matching lines @@
   bool fPeekKeep_;
   Message msgPeek_;
   MessageList msgq_ GUARDED_BY(crit_);
   PriorityQueue dmsgq_ GUARDED_BY(crit_);
   uint32_t dmsgq_next_num_ GUARDED_BY(crit_);
   CriticalSection crit_;
   bool fInitialized_;
   bool fDestroyed_;
 
  private:
+  void PostFunctorInternal(const Location& posted_from,
+                           RunnableData* message_data);
+
   volatile int stop_;
 
   // The SocketServer might not be owned by MessageQueue.
   SocketServer* const ss_;
   // Used if SocketServer ownership lies with |this|.
   std::unique_ptr<SocketServer> own_ss_;
 
   RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(MessageQueue);
 };
 
 }  // namespace rtc
 
 #endif  // WEBRTC_RTC_BASE_MESSAGEQUEUE_H_