Revert of Make the default ctor of rtc::Thread, protected (patchset #3 id:40001 of https://codereview.webrtc.org/2981623002/ )

Reason for revert:
Break projects.

Original issue's description:
> Make the default ctor of rtc::Thread, protected.
> The goal is to force use of Thread::Create or Thread::CreateWithSocketServer.
>
> The default constructor constructs a 'default' socket server, which is usually a 'physical' socket server, but not always. Not every instance of Thread actually needs to have network support, so it's better to have this be explicit instead of unknowingly instantiate one.
>
> BUG=none
>
> Review-Url: https://codereview.webrtc.org/2981623002
> Cr-Commit-Position: refs/heads/master@{#19001}
> Committed: a8a3515997

TBR=kthelgason@webrtc.org,tommi@webrtc.org
# Skipping CQ checks because original CL landed less than 1 days ago.
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true
BUG=none

Review-Url: https://codereview.webrtc.org/2979963002
Cr-Commit-Position: refs/heads/master@{#19003}

webrtc/pc/channelmanager_unittest.cc

@@ -38,9 +38,7 @@ static const VideoCodec kVideoCodecs[] = {
 class ChannelManagerTest : public testing::Test {
  protected:
   ChannelManagerTest()
-      : network_(rtc::Thread::CreateWithSocketServer()),
+      : fme_(new cricket::FakeMediaEngine()),
-        worker_(rtc::Thread::Create()),
-        fme_(new cricket::FakeMediaEngine()),
         fdme_(new cricket::FakeDataEngine()),
         cm_(new cricket::ChannelManager(
             std::unique_ptr<MediaEngineInterface>(fme_),
@@ -54,8 +52,8 @@ class ChannelManagerTest : public testing::Test {
   }
 
   webrtc::RtcEventLogNullImpl event_log_;
-  std::unique_ptr<rtc::Thread> network_;
+  rtc::Thread network_;
-  std::unique_ptr<rtc::Thread> worker_;
+  rtc::Thread worker_;
   // |fme_| and |fdme_| are actually owned by |cm_|.
   cricket::FakeMediaEngine* fme_;
   cricket::FakeDataEngine* fdme_;
@@ -76,14 +74,14 @@ TEST_F(ChannelManagerTest, StartupShutdown) {
 
 // Test that we startup/shutdown properly with a worker thread.
 TEST_F(ChannelManagerTest, StartupShutdownOnThread) {
-  network_->Start();
+  network_.Start();
-  worker_->Start();
+  worker_.Start();
   EXPECT_FALSE(cm_->initialized());
   EXPECT_EQ(rtc::Thread::Current(), cm_->worker_thread());
-  EXPECT_TRUE(cm_->set_network_thread(network_.get()));
+  EXPECT_TRUE(cm_->set_network_thread(&network_));
-  EXPECT_EQ(network_.get(), cm_->network_thread());
+  EXPECT_EQ(&network_, cm_->network_thread());
-  EXPECT_TRUE(cm_->set_worker_thread(worker_.get()));
+  EXPECT_TRUE(cm_->set_worker_thread(&worker_));
-  EXPECT_EQ(worker_.get(), cm_->worker_thread());
+  EXPECT_EQ(&worker_, cm_->worker_thread());
   EXPECT_TRUE(cm_->Init());
   EXPECT_TRUE(cm_->initialized());
   // Setting the network or worker thread while initialized should fail.
@@ -123,13 +121,13 @@ TEST_F(ChannelManagerTest, CreateDestroyChannels) {
 
 // Test that we can create and destroy a voice and video channel with a worker.
 TEST_F(ChannelManagerTest, CreateDestroyChannelsOnThread) {
-  network_->Start();
+  network_.Start();
-  worker_->Start();
+  worker_.Start();
-  EXPECT_TRUE(cm_->set_worker_thread(worker_.get()));
+  EXPECT_TRUE(cm_->set_worker_thread(&worker_));
-  EXPECT_TRUE(cm_->set_network_thread(network_.get()));
+  EXPECT_TRUE(cm_->set_network_thread(&network_));
   EXPECT_TRUE(cm_->Init());
-  transport_controller_.reset(new cricket::FakeTransportController(
+  transport_controller_.reset(
-      network_.get(), ICEROLE_CONTROLLING));
+      new cricket::FakeTransportController(&network_, ICEROLE_CONTROLLING));
   cricket::DtlsTransportInternal* rtp_transport =
       transport_controller_->CreateDtlsTransport(
           cricket::CN_AUDIO, cricket::ICE_CANDIDATE_COMPONENT_RTP);

webrtc/pc/peerconnectionendtoend_unittest.cc

@@ -54,14 +54,12 @@ class PeerConnectionEndToEndTest
       DataChannelList;
 
   PeerConnectionEndToEndTest() {
-    network_thread_ = rtc::Thread::CreateWithSocketServer();
+    RTC_CHECK(network_thread_.Start());
-    worker_thread_ = rtc::Thread::Create();
+    RTC_CHECK(worker_thread_.Start());
-    RTC_CHECK(network_thread_->Start());
-    RTC_CHECK(worker_thread_->Start());
     caller_ = new rtc::RefCountedObject<PeerConnectionTestWrapper>(
-        "caller", network_thread_.get(), worker_thread_.get());
+        "caller", &network_thread_, &worker_thread_);
     callee_ = new rtc::RefCountedObject<PeerConnectionTestWrapper>(
-        "callee", network_thread_.get(), worker_thread_.get());
+        "callee", &network_thread_, &worker_thread_);
     webrtc::PeerConnectionInterface::IceServer ice_server;
     ice_server.uri = "stun:stun.l.google.com:19302";
     config_.servers.push_back(ice_server);
@@ -167,8 +165,8 @@ class PeerConnectionEndToEndTest
   }
 
  protected:
-  std::unique_ptr<rtc::Thread> network_thread_;
+  rtc::Thread network_thread_;
-  std::unique_ptr<rtc::Thread> worker_thread_;
+  rtc::Thread worker_thread_;
   rtc::scoped_refptr<PeerConnectionTestWrapper> caller_;
   rtc::scoped_refptr<PeerConnectionTestWrapper> callee_;
   DataChannelList caller_signaled_data_channels_;

webrtc/pc/peerconnectioninterface_unittest.cc

@@ -1278,15 +1278,14 @@ TEST_F(PeerConnectionInterfaceTest, CreatePeerConnectionWithPooledCandidates) {
 // and on the correct thread.
 TEST_F(PeerConnectionInterfaceTest,
        CreatePeerConnectionInitializesPortAllocator) {
-  std::unique_ptr<rtc::Thread> network_thread(
+  rtc::Thread network_thread;
-      rtc::Thread::CreateWithSocketServer());
+  network_thread.Start();
-  network_thread->Start();
   rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface> pc_factory(
       webrtc::CreatePeerConnectionFactory(
-          network_thread.get(), rtc::Thread::Current(), rtc::Thread::Current(),
+          &network_thread, rtc::Thread::Current(), rtc::Thread::Current(),
           nullptr, nullptr, nullptr));
   std::unique_ptr<cricket::FakePortAllocator> port_allocator(
-      new cricket::FakePortAllocator(network_thread.get(), nullptr));
+      new cricket::FakePortAllocator(&network_thread, nullptr));
   cricket::FakePortAllocator* raw_port_allocator = port_allocator.get();
   PeerConnectionInterface::RTCConfiguration config;
   rtc::scoped_refptr<PeerConnectionInterface> pc(

webrtc/pc/proxy_unittest.cc

@@ -95,7 +95,7 @@ class SignalingProxyTest : public testing::Test {
 
  protected:
   void SetUp() override {
-    signaling_thread_ = rtc::Thread::Create();
+    signaling_thread_.reset(new rtc::Thread());
     ASSERT_TRUE(signaling_thread_->Start());
     fake_ = Fake::Create();
     fake_signaling_proxy_ =
@@ -182,8 +182,8 @@ class ProxyTest : public testing::Test {
 
  protected:
   void SetUp() override {
-    signaling_thread_ = rtc::Thread::Create();
+    signaling_thread_.reset(new rtc::Thread());
-    worker_thread_ = rtc::Thread::Create();
+    worker_thread_.reset(new rtc::Thread());
     ASSERT_TRUE(signaling_thread_->Start());
     ASSERT_TRUE(worker_thread_->Start());
     fake_ = Fake::Create();
@@ -283,22 +283,20 @@ END_PROXY_MAP()
 class OwnedProxyTest : public testing::Test {
  public:
   OwnedProxyTest()
-      : signaling_thread_(rtc::Thread::Create()),
+      : foo_(new Foo()),
-        worker_thread_(rtc::Thread::Create()),
+        foo_proxy_(FooProxy::Create(&signaling_thread_,
-        foo_(new Foo()),
+                                    &worker_thread_,
-        foo_proxy_(FooProxy::Create(signaling_thread_.get(),
-                                    worker_thread_.get(),
                                     std::unique_ptr<FooInterface>(foo_))) {
-    signaling_thread_->Start();
+    signaling_thread_.Start();
-    worker_thread_->Start();
+    worker_thread_.Start();
   }
 
-  void CheckSignalingThread() { EXPECT_TRUE(signaling_thread_->IsCurrent()); }
+  void CheckSignalingThread() { EXPECT_TRUE(signaling_thread_.IsCurrent()); }
-  void CheckWorkerThread() { EXPECT_TRUE(worker_thread_->IsCurrent()); }
+  void CheckWorkerThread() { EXPECT_TRUE(worker_thread_.IsCurrent()); }
 
  protected:
-  std::unique_ptr<rtc::Thread> signaling_thread_;
+  rtc::Thread signaling_thread_;
-  std::unique_ptr<rtc::Thread> worker_thread_;
+  rtc::Thread worker_thread_;
   Foo* foo_;  // Owned by foo_proxy_, not this class.
   std::unique_ptr<FooInterface> foo_proxy_;
 };

webrtc/pc/rtcstats_integrationtest.cc

@@ -34,15 +34,14 @@ const int64_t kGetStatsTimeoutMs = 10000;
 class RTCStatsIntegrationTest : public testing::Test {
  public:
   RTCStatsIntegrationTest()
-      : network_thread_(new rtc::Thread(&virtual_socket_server_)),
+      : network_thread_(&virtual_socket_server_), worker_thread_() {
-        worker_thread_(rtc::Thread::Create()) {
+    RTC_CHECK(network_thread_.Start());
-    RTC_CHECK(network_thread_->Start());
+    RTC_CHECK(worker_thread_.Start());
-    RTC_CHECK(worker_thread_->Start());
 
     caller_ = new rtc::RefCountedObject<PeerConnectionTestWrapper>(
-        "caller", network_thread_.get(), worker_thread_.get());
+        "caller", &network_thread_, &worker_thread_);
     callee_ = new rtc::RefCountedObject<PeerConnectionTestWrapper>(
-        "callee", network_thread_.get(), worker_thread_.get());
+        "callee", &network_thread_, &worker_thread_);
   }
 
   void StartCall() {
@@ -97,8 +96,8 @@ class RTCStatsIntegrationTest : public testing::Test {
   // |network_thread_| uses |virtual_socket_server_| so they must be
   // constructed/destructed in the correct order.
   rtc::VirtualSocketServer virtual_socket_server_;
-  std::unique_ptr<rtc::Thread> network_thread_;
+  rtc::Thread network_thread_;
-  std::unique_ptr<rtc::Thread> worker_thread_;
+  rtc::Thread worker_thread_;
   rtc::scoped_refptr<PeerConnectionTestWrapper> caller_;
   rtc::scoped_refptr<PeerConnectionTestWrapper> callee_;
 };

webrtc/pc/test/fakeaudiocapturemodule.cc

@@ -624,7 +624,7 @@ bool FakeAudioCaptureModule::ShouldStartProcessing() {
 void FakeAudioCaptureModule::UpdateProcessing(bool start) {
   if (start) {
     if (!process_thread_) {
-      process_thread_ = rtc::Thread::Create();
+      process_thread_.reset(new rtc::Thread());
       process_thread_->Start();
     }
     process_thread_->Post(RTC_FROM_HERE, this, MSG_START_PROCESS);

webrtc/rtc_base/criticalsection_unittest.cc

@@ -201,7 +201,7 @@ struct CompareAndSwapOp {
 void StartThreads(std::vector<std::unique_ptr<Thread>>* threads,
                   MessageHandler* handler) {
   for (int i = 0; i < kNumThreads; ++i) {
-    std::unique_ptr<Thread> thread(Thread::Create());
+    std::unique_ptr<Thread> thread(new Thread());
     thread->Start();
     thread->Post(RTC_FROM_HERE, handler);
     threads->push_back(std::move(thread));

webrtc/rtc_base/messagequeue_unittest.cc

@@ -38,9 +38,9 @@ class MessageQueueTest: public testing::Test, public MessageQueue {
   bool IsLocked() {
     // We have to do this on a worker thread, or else the TryEnter will
     // succeed, since our critical sections are reentrant.
-    std::unique_ptr<Thread> worker(Thread::CreateWithSocketServer());
+    Thread worker;
-    worker->Start();
+    worker.Start();
-    return worker->Invoke<bool>(
+    return worker.Invoke<bool>(
         RTC_FROM_HERE, rtc::Bind(&MessageQueueTest::IsLocked_Worker, this));
   }
 };
@@ -152,10 +152,10 @@ TEST(MessageQueueManager, Clear) {
 // all registered message queues.
 TEST(MessageQueueManager, ProcessAllMessageQueues) {
   Event entered_process_all_message_queues(true, false);
-  auto a = Thread::CreateWithSocketServer();
+  Thread a;
-  auto b = Thread::CreateWithSocketServer();
+  Thread b;
-  a->Start();
+  a.Start();
-  b->Start();
+  b.Start();
 
   volatile int messages_processed = 0;
   FunctorMessageHandler<void, std::function<void()>> incrementer(
@@ -173,10 +173,10 @@ TEST(MessageQueueManager, ProcessAllMessageQueues) {
       });
 
   // Post messages (both delayed and non delayed) to both threads.
-  a->Post(RTC_FROM_HERE, &incrementer);
+  a.Post(RTC_FROM_HERE, &incrementer);
-  b->Post(RTC_FROM_HERE, &incrementer);
+  b.Post(RTC_FROM_HERE, &incrementer);
-  a->PostDelayed(RTC_FROM_HERE, 0, &incrementer);
+  a.PostDelayed(RTC_FROM_HERE, 0, &incrementer);
-  b->PostDelayed(RTC_FROM_HERE, 0, &incrementer);
+  b.PostDelayed(RTC_FROM_HERE, 0, &incrementer);
   rtc::Thread::Current()->Post(RTC_FROM_HERE, &event_signaler);
 
   MessageQueueManager::ProcessAllMessageQueues();
@@ -185,9 +185,9 @@ TEST(MessageQueueManager, ProcessAllMessageQueues) {
 
 // Test that ProcessAllMessageQueues doesn't hang if a thread is quitting.
 TEST(MessageQueueManager, ProcessAllMessageQueuesWithQuittingThread) {
-  auto t = Thread::CreateWithSocketServer();
+  Thread t;
-  t->Start();
+  t.Start();
-  t->Quit();
+  t.Quit();
   MessageQueueManager::ProcessAllMessageQueues();
 }
 
@@ -195,8 +195,8 @@ TEST(MessageQueueManager, ProcessAllMessageQueuesWithQuittingThread) {
 // messages.
 TEST(MessageQueueManager, ProcessAllMessageQueuesWithClearedQueue) {
   Event entered_process_all_message_queues(true, false);
-  auto t = Thread::CreateWithSocketServer();
+  Thread t;
-  t->Start();
+  t.Start();
 
   FunctorMessageHandler<void, std::function<void()>> clearer(
       [&entered_process_all_message_queues] {
@@ -213,7 +213,7 @@ TEST(MessageQueueManager, ProcessAllMessageQueuesWithClearedQueue) {
       });
 
   // Post messages (both delayed and non delayed) to both threads.
-  t->Post(RTC_FROM_HERE, &clearer);
+  t.Post(RTC_FROM_HERE, &clearer);
   rtc::Thread::Current()->Post(RTC_FROM_HERE, &event_signaler);
   MessageQueueManager::ProcessAllMessageQueues();
 }
@@ -231,7 +231,7 @@ class EmptyHandler : public MessageHandler {
 };
 
 TEST(MessageQueueManager, ClearReentrant) {
-  std::unique_ptr<Thread> t(Thread::Create());
+  Thread t;
   EmptyHandler handler;
   RefCountedHandler* inner_handler(
       new rtc::RefCountedObject<RefCountedHandler>());
@@ -242,7 +242,7 @@ TEST(MessageQueueManager, ClearReentrant) {
   // The inner handler will be removed in a re-entrant fashion from the
   // message queue of the thread while the outer handler is removed, verifying
   // that the iterator is not invalidated in "MessageQueue::Clear".
-  t->Post(RTC_FROM_HERE, inner_handler, 0);
+  t.Post(RTC_FROM_HERE, inner_handler, 0);
-  t->Post(RTC_FROM_HERE, &handler, 0,
+  t.Post(RTC_FROM_HERE, &handler, 0,
-          new ScopedRefMessageData<RefCountedHandler>(inner_handler));
+      new ScopedRefMessageData<RefCountedHandler>(inner_handler));
 }

webrtc/rtc_base/nullsocketserver_unittest.cc

@@ -28,9 +28,9 @@ class NullSocketServerTest
 };
 
 TEST_F(NullSocketServerTest, WaitAndSet) {
-  auto thread = Thread::Create();
+  Thread thread;
-  EXPECT_TRUE(thread->Start());
+  EXPECT_TRUE(thread.Start());
-  thread->Post(RTC_FROM_HERE, this, 0);
+  thread.Post(RTC_FROM_HERE, this, 0);
   // The process_io will be ignored.
   const bool process_io = true;
   EXPECT_TRUE_WAIT(ss_.Wait(SocketServer::kForever, process_io), kTimeout);

webrtc/rtc_base/physicalsocketserver_unittest.cc

@@ -610,7 +610,7 @@ TEST_F(PosixSignalDeliveryTest, SignalOnDifferentThread) {
   // Start a new thread that raises it. It will have to be delivered to that
   // thread. Our implementation should safely handle it and dispatch
   // RecordSignal() on this thread.
-  std::unique_ptr<Thread> thread(Thread::CreateWithSocketServer());
+  std::unique_ptr<Thread> thread(new Thread());
   std::unique_ptr<RaiseSigTermRunnable> runnable(new RaiseSigTermRunnable());
   thread->Start(runnable.get());
   EXPECT_TRUE(ss_->Wait(1500, true));

webrtc/rtc_base/rtccertificategenerator_unittest.cc

@@ -24,7 +24,7 @@ class RTCCertificateGeneratorFixture : public RTCCertificateGeneratorCallback {
  public:
   RTCCertificateGeneratorFixture()
       : signaling_thread_(Thread::Current()),
-        worker_thread_(Thread::Create()),
+        worker_thread_(new Thread()),
         generate_async_completed_(false) {
     RTC_CHECK(signaling_thread_);
     RTC_CHECK(worker_thread_->Start());

webrtc/rtc_base/socket_unittest.cc

@@ -681,7 +681,7 @@ void SocketTest::SocketServerWaitInternal(const IPAddress& loopback) {
   EXPECT_FALSE(sink.Check(accepted.get(), SSE_READ));
 
   // Shouldn't signal when blocked in a thread Send, where process_io is false.
-  std::unique_ptr<Thread> thread(Thread::CreateWithSocketServer());
+  std::unique_ptr<Thread> thread(new Thread());
   thread->Start();
   Sleeper sleeper;
   TypedMessageData<AsyncSocket*> data(client.get());

webrtc/rtc_base/thread.h

@@ -101,10 +101,9 @@ class Runnable {
 // WARNING! SUBCLASSES MUST CALL Stop() IN THEIR DESTRUCTORS!  See ~Thread().
 
 class LOCKABLE Thread : public MessageQueue {
- protected:
-  Thread();
-
  public:
+  // Create a new Thread and optionally assign it to the passed SocketServer.
+  Thread();
   explicit Thread(SocketServer* ss);
   explicit Thread(std::unique_ptr<SocketServer> ss);
 

webrtc/rtc_base/thread_unittest.cc

@@ -195,24 +195,24 @@ TEST(ThreadTest, DISABLED_Main) {
   const SocketAddress addr("127.0.0.1", 0);
 
   // Create the messaging client on its own thread.
-  auto th1 = Thread::CreateWithSocketServer();
+  Thread th1;
-  Socket* socket =
+  Socket* socket = th1.socketserver()->CreateAsyncSocket(addr.family(),
-      th1->socketserver()->CreateAsyncSocket(addr.family(), SOCK_DGRAM);
+                                                         SOCK_DGRAM);
-  MessageClient msg_client(th1.get(), socket);
+  MessageClient msg_client(&th1, socket);
 
   // Create the socket client on its own thread.
-  auto th2 = Thread::CreateWithSocketServer();
+  Thread th2;
   AsyncSocket* asocket =
-      th2->socketserver()->CreateAsyncSocket(addr.family(), SOCK_DGRAM);
+      th2.socketserver()->CreateAsyncSocket(addr.family(), SOCK_DGRAM);
-  SocketClient sock_client(asocket, addr, th1.get(), &msg_client);
+  SocketClient sock_client(asocket, addr, &th1, &msg_client);
 
   socket->Connect(sock_client.address());
 
-  th1->Start();
+  th1.Start();
-  th2->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.
@@ -221,9 +221,9 @@ TEST(ThreadTest, DISABLED_Main) {
 
   // 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);
@@ -236,19 +236,23 @@ TEST(ThreadTest, DISABLED_Main) {
 // There's no easy way to verify the name was set properly at this time.
 TEST(ThreadTest, Names) {
   // Default name
-  auto thread = Thread::CreateWithSocketServer();
+  Thread *thread;
+  thread = new Thread();
   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 = Thread::CreateWithSocketServer();
+  thread = new Thread();
   EXPECT_TRUE(thread->SetName("Abcdefghijklmnopqrstuvwxyz1234567890", this));
   EXPECT_TRUE(thread->Start());
   thread->Stop();
+  delete thread;
 }
 
 TEST(ThreadTest, Wrap) {
@@ -266,21 +270,21 @@ TEST(ThreadTest, Wrap) {
 
 TEST(ThreadTest, Invoke) {
   // Create and start the thread.
-  auto thread = Thread::CreateWithSocketServer();
+  Thread thread;
-  thread->Start();
+  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));
+  EXPECT_EQ(999, thread.Invoke<int>(RTC_FROM_HERE, &LocalFuncs::Func1));
-  thread->Invoke<void>(RTC_FROM_HERE, &LocalFuncs::Func2);
+  thread.Invoke<void>(RTC_FROM_HERE, &LocalFuncs::Func2);
 }
 
 // Verifies that two threads calling Invoke on each other at the same time does
@@ -290,8 +294,8 @@ TEST(ThreadTest, TwoThreadsInvokeNoDeadlock) {
   Thread* current_thread = Thread::Current();
   ASSERT_TRUE(current_thread != nullptr);
 
-  auto other_thread = Thread::CreateWithSocketServer();
+  Thread other_thread;
-  other_thread->Start();
+  other_thread.Start();
 
   struct LocalFuncs {
     static void Set(bool* out) { *out = true; }
@@ -301,7 +305,7 @@ TEST(ThreadTest, TwoThreadsInvokeNoDeadlock) {
   };
 
   bool called = false;
-  other_thread->Invoke<void>(
+  other_thread.Invoke<void>(
       RTC_FROM_HERE, Bind(&LocalFuncs::InvokeSet, current_thread, &called));
 
   EXPECT_TRUE(called);
@@ -313,10 +317,9 @@ TEST(ThreadTest, TwoThreadsInvokeNoDeadlock) {
 TEST(ThreadTest, ThreeThreadsInvoke) {
   AutoThread thread;
   Thread* thread_a = Thread::Current();
-  auto thread_b = Thread::CreateWithSocketServer();
+  Thread thread_b, thread_c;
-  auto thread_c = Thread::CreateWithSocketServer();
+  thread_b.Start();
-  thread_b->Start();
+  thread_c.Start();
-  thread_c->Start();
 
   class LockedBool {
    public:
@@ -374,9 +377,9 @@ TEST(ThreadTest, ThreeThreadsInvoke) {
   // 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,
+  thread_b.Invoke<void>(RTC_FROM_HERE,
-                         Bind(&LocalFuncs::AsyncInvokeSetAndWait, &invoker,
+                        Bind(&LocalFuncs::AsyncInvokeSetAndWait, &invoker,
-                              thread_c.get(), thread_a, &thread_a_called));
+                             &thread_c, thread_a, &thread_a_called));
   EXPECT_FALSE(thread_a_called.Get());
 
   EXPECT_TRUE_WAIT(thread_a_called.Get(), 2000);
@@ -403,9 +406,9 @@ class SetNameOnSignalQueueDestroyedTester : public sigslot::has_slots<> {
 };
 
 TEST(ThreadTest, SetNameOnSignalQueueDestroyed) {
-  auto thread1 = Thread::CreateWithSocketServer();
+  Thread* thread1 = new Thread();
-  SetNameOnSignalQueueDestroyedTester tester1(thread1.get());
+  SetNameOnSignalQueueDestroyedTester tester1(thread1);
-  thread1.reset();
+  delete thread1;
 
   Thread* thread2 = new AutoThread();
   SetNameOnSignalQueueDestroyedTester tester2(thread2);
@@ -435,13 +438,12 @@ class AsyncInvokeTest : public testing::Test {
 TEST_F(AsyncInvokeTest, FireAndForget) {
   AsyncInvoker invoker;
   // Create and start the thread.
-  auto thread = Thread::CreateWithSocketServer();
+  Thread thread;
-  thread->Start();
+  thread.Start();
   // Try calling functor.
   AtomicBool called;
-  invoker.AsyncInvoke<void>(RTC_FROM_HERE, thread.get(), FunctorB(&called));
+  invoker.AsyncInvoke<void>(RTC_FROM_HERE, &thread, FunctorB(&called));
   EXPECT_TRUE_WAIT(called.get(), kWaitTimeout);
-  thread->Stop();
 }
 
 TEST_F(AsyncInvokeTest, KillInvokerDuringExecute) {
@@ -452,12 +454,12 @@ TEST_F(AsyncInvokeTest, KillInvokerDuringExecute) {
   Event functor_continue(false, false);
   Event functor_finished(false, false);
 
-  auto thread = Thread::CreateWithSocketServer();
+  Thread thread;
-  thread->Start();
+  thread.Start();
   volatile bool invoker_destroyed = false;
   {
     AsyncInvoker invoker;
-    invoker.AsyncInvoke<void>(RTC_FROM_HERE, thread.get(),
+    invoker.AsyncInvoke<void>(RTC_FROM_HERE, &thread,
                               [&functor_started, &functor_continue,
                                &functor_finished, &invoker_destroyed] {
                                 functor_started.Set();
@@ -548,7 +550,7 @@ struct CreateInvoker {
 // 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(Thread::Create());
+  std::unique_ptr<Thread> thread(new Thread());
   thread->Start();
   std::unique_ptr<GuardedAsyncInvoker> invoker;
   // Create the invoker on |thread|.

webrtc/rtc_base/timeutils_unittest.cc

@@ -349,8 +349,8 @@ TEST(FakeClock, SettingTimeWakesThreads) {
   FakeClock clock;
   SetClockForTesting(&clock);
 
-  std::unique_ptr<Thread> worker(Thread::CreateWithSocketServer());
+  Thread worker;
-  worker->Start();
+  worker.Start();
 
   // Post an event that won't be executed for 10 seconds.
   Event message_handler_dispatched(false, false);
@@ -358,7 +358,7 @@ TEST(FakeClock, SettingTimeWakesThreads) {
     message_handler_dispatched.Set();
   };
   FunctorMessageHandler<void, decltype(functor)> handler(functor);
-  worker->PostDelayed(RTC_FROM_HERE, 60000, &handler);
+  worker.PostDelayed(RTC_FROM_HERE, 60000, &handler);
 
   // Wait for a bit for the worker thread to be started and enter its socket
   // select(). Otherwise this test would be trivial since the worker thread
@@ -369,7 +369,7 @@ TEST(FakeClock, SettingTimeWakesThreads) {
   // and dispatch the message instantly.
   clock.AdvanceTime(TimeDelta::FromSeconds(60u));
   EXPECT_TRUE(message_handler_dispatched.Wait(0));
-  worker->Stop();
+  worker.Stop();
 
   SetClockForTesting(nullptr);
 

webrtc/sdk/android/src/jni/androidmediadecoder_jni.cc

@@ -55,7 +55,7 @@ namespace webrtc_jni {
 // Logging macros.
 #define TAG_DECODER "MediaCodecVideoDecoder"
 #ifdef TRACK_BUFFER_TIMING
-#define ALOGV(...) \
+#define ALOGV(...)
   __android_log_print(ANDROID_LOG_VERBOSE, TAG_DECODER, __VA_ARGS__)
 #else
 #define ALOGV(...)
@@ -180,25 +180,24 @@ class MediaCodecVideoDecoder : public webrtc::VideoDecoder,
   std::vector<jobject> input_buffers_;
 };
 
-MediaCodecVideoDecoder::MediaCodecVideoDecoder(JNIEnv* jni,
+MediaCodecVideoDecoder::MediaCodecVideoDecoder(
-                                               VideoCodecType codecType,
+    JNIEnv* jni, VideoCodecType codecType, jobject render_egl_context) :
-                                               jobject render_egl_context)
+    codecType_(codecType),
-    : codecType_(codecType),
+    render_egl_context_(render_egl_context),
-      render_egl_context_(render_egl_context),
+    key_frame_required_(true),
-      key_frame_required_(true),
+    inited_(false),
-      inited_(false),
+    sw_fallback_required_(false),
-      sw_fallback_required_(false),
+    codec_thread_(new Thread()),
-      codec_thread_(Thread::Create()),
+    j_media_codec_video_decoder_class_(
-      j_media_codec_video_decoder_class_(
+        jni,
-          jni,
+        FindClass(jni, "org/webrtc/MediaCodecVideoDecoder")),
-          FindClass(jni, "org/webrtc/MediaCodecVideoDecoder")),
+          j_media_codec_video_decoder_(
-      j_media_codec_video_decoder_(
+              jni,
-          jni,
+              jni->NewObject(*j_media_codec_video_decoder_class_,
-          jni->NewObject(*j_media_codec_video_decoder_class_,
+                   GetMethodID(jni,
-                         GetMethodID(jni,
+                              *j_media_codec_video_decoder_class_,
-                                     *j_media_codec_video_decoder_class_,
+                              "<init>",
-                                     "<init>",
+                              "()V"))) {
-                                     "()V"))) {
   codec_thread_->SetName("MediaCodecVideoDecoder", NULL);
   RTC_CHECK(codec_thread_->Start()) << "Failed to start MediaCodecVideoDecoder";