Delete SignalThread class.

webrtc/base/nethelpers.cc

Index: webrtc/base/nethelpers.cc
diff --git a/webrtc/base/nethelpers.cc b/webrtc/base/nethelpers.cc
index 6c11ef8c38fa04800df834bc8fa0f0f8939b3b89..60dcf93bf9cc80ca579929b1cfd19b84d3d0ba14 100644
--- a/webrtc/base/nethelpers.cc
+++ b/webrtc/base/nethelpers.cc
@@ -25,13 +25,17 @@
 #endif
 #endif  // defined(WEBRTC_POSIX) && !defined(__native_client__)
 
+#include "webrtc/base/bind.h"
 #include "webrtc/base/byteorder.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
-#include "webrtc/base/signalthread.h"
+#include "webrtc/base/ptr_util.h"
+#include "webrtc/base/task_queue.h"
+#include "webrtc/base/thread.h"
 
 namespace rtc {
 
+namespace {
 int ResolveHostname(const std::string& hostname, int family,
                     std::vector<IPAddress>* addresses) {
 #ifdef __native_client__
@@ -81,17 +85,31 @@ int ResolveHostname(const std::string& hostname, int family,
   return 0;
 #endif  // !__native_client__
 }
+}  // namespace
 
 // AsyncResolver
 AsyncResolver::AsyncResolver()
-    : SignalThread(false /* use_socket_server */), error_(-1) {}
+    : construction_thread_(Thread::Current()) {}

[tommi, 2017/06/19 13:01:47]

add RTC_DCHECK that construction_thread_ is never null in the ctor (catch it
early)

[nisse-webrtc, 2017/06/19 14:07:20]

Done.

 
-AsyncResolver::~AsyncResolver() = default;
+AsyncResolver::~AsyncResolver() {
+  RTC_DCHECK(construction_thread_->IsCurrent());
+}
 
 void AsyncResolver::Start(const SocketAddress& addr) {
+  RTC_DCHECK(construction_thread_->IsCurrent());
+  RTC_DCHECK(!resolver_queue_);
+  // TODO(nisse): Support injection of task queue at construction?
+  resolver_queue_ = rtc::MakeUnique<TaskQueue>("AsyncResolverQueue");
   addr_ = addr;
-  // SignalThred Start will kickoff the resolve process.
-  SignalThread::Start();
+  resolver_queue_->PostTask([this](){
+      std::vector<IPAddress> addresses;
+      int error = ResolveHostname(addr_.hostname().c_str(), addr_.family(),
+                                  &addresses);
+      // Ensure SignalDone is called on the main thread.
+      construction_thread_->Invoke<void>(
+          RTC_FROM_HERE, rtc::Bind(&AsyncResolver::ResolveDone, this,
+                                   error, std::move(addresses)));
+    });
 }
 
 bool AsyncResolver::GetResolvedAddress(int family, SocketAddress* addr) const {
@@ -113,15 +131,18 @@ int AsyncResolver::GetError() const {
 }
 
 void AsyncResolver::Destroy(bool wait) {
-  SignalThread::Destroy(wait);
-}
-
-void AsyncResolver::DoWork() {
-  error_ = ResolveHostname(addr_.hostname().c_str(), addr_.family(),
-                           &addresses_);
+  RTC_DCHECK(construction_thread_->IsCurrent());
+  // If we don't wait here, we will nevertheless wait in the destructor.
+  if (wait) {
+    // Destroy task queue, blocks on any cyrrently runnign task.
+    resolver_queue_.reset();
+  }
 }
 
-void AsyncResolver::OnWorkDone() {
+void AsyncResolver::ResolveDone(int error, std::vector<IPAddress> addresses) {
+  RTC_DCHECK(construction_thread_->IsCurrent());
+  error_ = error;
+  addresses_ = std::move(addresses);
   SignalDone(this);
 }