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;
+};
+
+void FunctorPostMessageHandler::OnMessage(Message* msg) {
+  CallableData* data = static_cast<CallableData*>(msg->pdata);
+  data->call();
+  delete data;
+}

[kwiberg-webrtc, 2017/06/26 13:07:48]

Define this function inline? There's no downside to that when you define a class
in a .cc file.

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

Done.

+
 }  // 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 465 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)
+{

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

can you run git cl format?

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

Already done, in ps#14.

+  // FunctorPostMessageHandler keeps no state, create a static object.
+  RTC_DEFINE_STATIC_LOCAL(FunctorPostMessageHandler, handler, ());

[kwiberg-webrtc, 2017/06/26 13:07:48]

Why not just

  FunctorPostMessageHandler handler;

? That class has a trivial default constructor and a trivial destructor, since
it has no members.

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

It has to outlive this scope, since it's accessed (vtable lookup for OnMessage)
by the time the target thread gets to process the posted message.

But if you say a plain "static" definition works fine, I'll do that. The vtable
is initialized properly at link time, then?

[kwiberg-webrtc, 2017/06/27 09:16:28]

Ah, right, it has a vtable. But yes, as of C++11, function-local static
variables are threadsafely initialized (with a mutex if necessary, but as you
point out vtables might be initialized at link time), and vtables shouldn't have
to cause any work in the destructor, so a plain "static" definition works fine.
(RTC_DEFINE_STATIC_LOCAL relies on the same mechanisms for synchronizing the
creation of the object (but because of the heap allocation, we know there's
runtime initialization that needs to be mutexed). The only difference is that it
leaks the object into the heap, so that its destructor is never run, but that
should make no difference in this case.)

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

Good. But it still has to be in a local scope? (If we implement some cancel
mechanism as I outlined as option (1), it would help to move it into a global
unnamed namespace, but I'm not sure if that would involved constructor magic
before main(). 

+  Post(posted_from, &handler, 0, message_data);
+}
+
 }  // namespace rtc