Partial Reland of Make the default ctor of rtc::Thread, protected

webrtc/rtc_base/thread_unittest.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 <memory>
 
 #include "webrtc/rtc_base/asyncinvoker.h"
 #include "webrtc/rtc_base/asyncudpsocket.h"
 #include "webrtc/rtc_base/event.h"
 #include "webrtc/rtc_base/gunit.h"
+#include "webrtc/rtc_base/nullsocketserver.h"
 #include "webrtc/rtc_base/physicalsocketserver.h"
 #include "webrtc/rtc_base/sigslot.h"
 #include "webrtc/rtc_base/socketaddress.h"
 #include "webrtc/rtc_base/thread.h"
 
 #if defined(WEBRTC_WIN)
 #include <comdef.h>  // NOLINT
 #endif
 
 using namespace rtc;
@@ skipping 72 matching lines @@
     EXPECT_GE(socket_->Send(&result, sizeof(result)), 0);
     delete msg;
   }
 
  private:
   Socket* socket_;
 };
 
 class CustomThread : public rtc::Thread {
  public:
-  CustomThread() {}
+  CustomThread()
+      : Thread(std::unique_ptr<SocketServer>(new rtc::NullSocketServer())) {}
   virtual ~CustomThread() { Stop(); }
   bool Start() { return false; }
 
   bool WrapCurrent() {
     return Thread::WrapCurrent();
   }
   void UnwrapCurrent() {
     Thread::UnwrapCurrent();
   }
 };
 
 
 // A thread that does nothing when it runs and signals an event
 // when it is destroyed.
 class SignalWhenDestroyedThread : public Thread {
  public:
   SignalWhenDestroyedThread(Event* event)
-      : event_(event) {
-  }
+      : Thread(std::unique_ptr<SocketServer>(new NullSocketServer())),
+        event_(event) {}
 
   virtual ~SignalWhenDestroyedThread() {
     Stop();
     event_->Set();
   }
 
   virtual void Run() {
     // Do nothing.
   }
 
@@ skipping 49 matching lines @@
     Thread::Current()->ProcessMessages(50);
     return 24;
   }
 };
 
 // See: https://code.google.com/p/webrtc/issues/detail?id=2409
 TEST(ThreadTest, DISABLED_Main) {
   const SocketAddress addr("127.0.0.1", 0);
 
   // Create the messaging client on its own thread.
-  Thread th1;
-  Socket* socket = th1.socketserver()->CreateAsyncSocket(addr.family(),
-                                                         SOCK_DGRAM);
-  MessageClient msg_client(&th1, socket);
+  auto th1 = Thread::CreateWithSocketServer();
+  Socket* socket =
+      th1->socketserver()->CreateAsyncSocket(addr.family(), SOCK_DGRAM);
+  MessageClient msg_client(th1.get(), socket);
 
   // Create the socket client on its own thread.
-  Thread th2;
+  auto th2 = Thread::CreateWithSocketServer();
   AsyncSocket* asocket =
-      th2.socketserver()->CreateAsyncSocket(addr.family(), SOCK_DGRAM);
-  SocketClient sock_client(asocket, addr, &th1, &msg_client);
+      th2->socketserver()->CreateAsyncSocket(addr.family(), SOCK_DGRAM);
+  SocketClient sock_client(asocket, addr, th1.get(), &msg_client);
 
   socket->Connect(sock_client.address());
 
-  th1.Start();
-  th2.Start();
+  th1->Start();
+  th2->Start();
 
   // Get the messages started.
-  th1.PostDelayed(RTC_FROM_HERE, 100, &msg_client, 0, new TestMessage(1));
+  th1->PostDelayed(RTC_FROM_HERE, 100, &msg_client, 0, new TestMessage(1));
 
   // Give the clients a little while to run.
   // Messages will be processed at 100, 300, 500, 700, 900.
   Thread* th_main = Thread::Current();
   th_main->ProcessMessages(1000);
 
   // Stop the sending client. Give the receiver a bit longer to run, in case
   // it is running on a machine that is under load (e.g. the build machine).
-  th1.Stop();
+  th1->Stop();
   th_main->ProcessMessages(200);
-  th2.Stop();
+  th2->Stop();
 
   // Make sure the results were correct
   EXPECT_EQ(5, msg_client.count);
   EXPECT_EQ(34, msg_client.last);
   EXPECT_EQ(5, sock_client.count);
   EXPECT_EQ(55, sock_client.last);
 }
 
 // Test that setting thread names doesn't cause a malfunction.
 // There's no easy way to verify the name was set properly at this time.
 TEST(ThreadTest, Names) {
   // Default name
-  Thread *thread;
-  thread = new Thread();
+  auto thread = Thread::CreateWithSocketServer();
   EXPECT_TRUE(thread->Start());
   thread->Stop();
-  delete thread;
-  thread = new Thread();
   // Name with no object parameter
+  thread = Thread::CreateWithSocketServer();
   EXPECT_TRUE(thread->SetName("No object", nullptr));
   EXPECT_TRUE(thread->Start());
   thread->Stop();
-  delete thread;
   // Really long name
-  thread = new Thread();
+  thread = Thread::CreateWithSocketServer();
   EXPECT_TRUE(thread->SetName("Abcdefghijklmnopqrstuvwxyz1234567890", this));
   EXPECT_TRUE(thread->Start());
   thread->Stop();
-  delete thread;
 }
 
 TEST(ThreadTest, Wrap) {
   Thread* current_thread = Thread::Current();
   current_thread->UnwrapCurrent();
   CustomThread* cthread = new CustomThread();
   EXPECT_TRUE(cthread->WrapCurrent());
   EXPECT_TRUE(cthread->RunningForTest());
   EXPECT_FALSE(cthread->IsOwned());
   cthread->UnwrapCurrent();
   EXPECT_FALSE(cthread->RunningForTest());
   delete cthread;
   current_thread->WrapCurrent();
 }
 
 TEST(ThreadTest, Invoke) {
   // Create and start the thread.
-  Thread thread;
-  thread.Start();
+  auto thread = Thread::CreateWithSocketServer();
+  thread->Start();
   // Try calling functors.
-  EXPECT_EQ(42, thread.Invoke<int>(RTC_FROM_HERE, FunctorA()));
+  EXPECT_EQ(42, thread->Invoke<int>(RTC_FROM_HERE, FunctorA()));
   AtomicBool called;
   FunctorB f2(&called);
-  thread.Invoke<void>(RTC_FROM_HERE, f2);
+  thread->Invoke<void>(RTC_FROM_HERE, f2);
   EXPECT_TRUE(called.get());
   // Try calling bare functions.
   struct LocalFuncs {
     static int Func1() { return 999; }
     static void Func2() {}
   };
-  EXPECT_EQ(999, thread.Invoke<int>(RTC_FROM_HERE, &LocalFuncs::Func1));
-  thread.Invoke<void>(RTC_FROM_HERE, &LocalFuncs::Func2);
+  EXPECT_EQ(999, thread->Invoke<int>(RTC_FROM_HERE, &LocalFuncs::Func1));
+  thread->Invoke<void>(RTC_FROM_HERE, &LocalFuncs::Func2);
 }
 
 // Verifies that two threads calling Invoke on each other at the same time does
 // not deadlock.
 TEST(ThreadTest, TwoThreadsInvokeNoDeadlock) {
   AutoThread thread;
   Thread* current_thread = Thread::Current();
   ASSERT_TRUE(current_thread != nullptr);
 
-  Thread other_thread;
-  other_thread.Start();
+  auto other_thread = Thread::CreateWithSocketServer();
+  other_thread->Start();
 
   struct LocalFuncs {
     static void Set(bool* out) { *out = true; }
     static void InvokeSet(Thread* thread, bool* out) {
       thread->Invoke<void>(RTC_FROM_HERE, Bind(&Set, out));
     }
   };
 
   bool called = false;
-  other_thread.Invoke<void>(
+  other_thread->Invoke<void>(
       RTC_FROM_HERE, Bind(&LocalFuncs::InvokeSet, current_thread, &called));
 
   EXPECT_TRUE(called);
 }
 
 // Verifies that if thread A invokes a call on thread B and thread C is trying
 // to invoke A at the same time, thread A does not handle C's invoke while
 // invoking B.
 TEST(ThreadTest, ThreeThreadsInvoke) {
   AutoThread thread;
   Thread* thread_a = Thread::Current();
-  Thread thread_b, thread_c;
-  thread_b.Start();
-  thread_c.Start();
+  auto thread_b = Thread::CreateWithSocketServer();
+  auto thread_c = Thread::CreateWithSocketServer();
+  thread_b->Start();
+  thread_c->Start();
 
   class LockedBool {
    public:
     explicit LockedBool(bool value) : value_(value) {}
 
     void Set(bool value) {
       CritScope lock(&crit_);
       value_ = value;
     }
 
@@ skipping 37 matching lines @@
       EXPECT_TRUE_WAIT(async_invoked.Get(), 2000);
     }
   };
 
   AsyncInvoker invoker;
   LockedBool thread_a_called(false);
 
   // Start the sequence A --(invoke)--> B --(async invoke)--> C --(invoke)--> A.
   // Thread B returns when C receives the call and C should be blocked until A
   // starts to process messages.
-  thread_b.Invoke<void>(RTC_FROM_HERE,
-                        Bind(&LocalFuncs::AsyncInvokeSetAndWait, &invoker,
-                             &thread_c, thread_a, &thread_a_called));
+  thread_b->Invoke<void>(RTC_FROM_HERE,
+                         Bind(&LocalFuncs::AsyncInvokeSetAndWait, &invoker,
+                              thread_c.get(), thread_a, &thread_a_called));
   EXPECT_FALSE(thread_a_called.Get());
 
   EXPECT_TRUE_WAIT(thread_a_called.Get(), 2000);
 }
 
 // Set the name on a thread when the underlying QueueDestroyed signal is
 // triggered. This causes an error if the object is already partially
 // destroyed.
 class SetNameOnSignalQueueDestroyedTester : public sigslot::has_slots<> {
  public:
   SetNameOnSignalQueueDestroyedTester(Thread* thread) : thread_(thread) {
     thread->SignalQueueDestroyed.connect(
         this, &SetNameOnSignalQueueDestroyedTester::OnQueueDestroyed);
   }
 
   void OnQueueDestroyed() {
     // Makes sure that if we access the Thread while it's being destroyed, that
     // it doesn't cause a problem because the vtable has been modified.
     thread_->SetName("foo", nullptr);
   }
 
  private:
   Thread* thread_;
 };
 
 TEST(ThreadTest, SetNameOnSignalQueueDestroyed) {
-  Thread* thread1 = new Thread();
-  SetNameOnSignalQueueDestroyedTester tester1(thread1);
-  delete thread1;
+  auto thread1 = Thread::CreateWithSocketServer();
+  SetNameOnSignalQueueDestroyedTester tester1(thread1.get());
+  thread1.reset();
 
   Thread* thread2 = new AutoThread();
   SetNameOnSignalQueueDestroyedTester tester2(thread2);
   delete thread2;
 }
 
 class AsyncInvokeTest : public testing::Test {
  public:
   void IntCallback(int value) {
     EXPECT_EQ(expected_thread_, Thread::Current());
     int_value_ = value;
   }
   void SetExpectedThreadForIntCallback(Thread* thread) {
     expected_thread_ = thread;
   }
 
  protected:
   enum { kWaitTimeout = 1000 };
   AsyncInvokeTest()
       : int_value_(0),
         expected_thread_(nullptr) {}
 
   int int_value_;
   Thread* expected_thread_;
 };
 
 TEST_F(AsyncInvokeTest, FireAndForget) {
   AsyncInvoker invoker;
   // Create and start the thread.
-  Thread thread;
-  thread.Start();
+  auto thread = Thread::CreateWithSocketServer();
+  thread->Start();
   // Try calling functor.
   AtomicBool called;
-  invoker.AsyncInvoke<void>(RTC_FROM_HERE, &thread, FunctorB(&called));
+  invoker.AsyncInvoke<void>(RTC_FROM_HERE, thread.get(), FunctorB(&called));
   EXPECT_TRUE_WAIT(called.get(), kWaitTimeout);
+  thread->Stop();
 }
 
 TEST_F(AsyncInvokeTest, KillInvokerDuringExecute) {
   // Use these events to get in a state where the functor is in the middle of
   // executing, and then to wait for it to finish, ensuring the "EXPECT_FALSE"
   // is run.
   Event functor_started(false, false);
   Event functor_continue(false, false);
   Event functor_finished(false, false);
 
-  Thread thread;
-  thread.Start();
+  auto thread = Thread::CreateWithSocketServer();
+  thread->Start();
   volatile bool invoker_destroyed = false;
   {
     AsyncInvoker invoker;
-    invoker.AsyncInvoke<void>(RTC_FROM_HERE, &thread,
+    invoker.AsyncInvoke<void>(RTC_FROM_HERE, thread.get(),
                               [&functor_started, &functor_continue,
                                &functor_finished, &invoker_destroyed] {
                                 functor_started.Set();
                                 functor_continue.Wait(Event::kForever);
                                 rtc::Thread::Current()->SleepMs(kWaitTimeout);
                                 EXPECT_FALSE(invoker_destroyed);
                                 functor_finished.Set();
                               });
     functor_started.Wait(Event::kForever);
 
@@ skipping 70 matching lines @@
 struct CreateInvoker {
   CreateInvoker(std::unique_ptr<GuardedAsyncInvoker>* invoker)
       : invoker_(invoker) {}
   void operator()() { invoker_->reset(new GuardedAsyncInvoker()); }
   std::unique_ptr<GuardedAsyncInvoker>* invoker_;
 };
 
 // Test that we can call AsyncInvoke<void>() after the thread died.
 TEST_F(GuardedAsyncInvokeTest, KillThreadFireAndForget) {
   // Create and start the thread.
-  std::unique_ptr<Thread> thread(new Thread());
+  std::unique_ptr<Thread> thread(Thread::Create());
   thread->Start();
   std::unique_ptr<GuardedAsyncInvoker> invoker;
   // Create the invoker on |thread|.
   thread->Invoke<void>(RTC_FROM_HERE, CreateInvoker(&invoker));
   // Kill |thread|.
   thread = nullptr;
   // Try calling functor.
   AtomicBool called;
   EXPECT_FALSE(invoker->AsyncInvoke<void>(RTC_FROM_HERE, FunctorB(&called)));
   // With thread gone, nothing should happen.
@@ skipping 40 matching lines @@
   // Execute pending calls with id == 5.
   EXPECT_TRUE(invoker.Flush(5));
   EXPECT_TRUE(flag1.get());
   EXPECT_FALSE(flag2.get());
   flag1 = false;
   // Execute all pending calls. The id == 5 call should not execute again.
   EXPECT_TRUE(invoker.Flush());
   EXPECT_FALSE(flag1.get());
   EXPECT_TRUE(flag2.get());
 }