Make the default ctor of rtc::Thread, protected

webrtc/pc/proxy_unittest.cc

 /*
  *  Copyright 2013 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 77 matching lines @@
 END_PROXY_MAP()
 #undef FakeProxy
 
 class SignalingProxyTest : public testing::Test {
  public:
   // Checks that the functions are called on the right thread.
   void CheckSignalingThread() { EXPECT_TRUE(signaling_thread_->IsCurrent()); }
 
  protected:
   void SetUp() override {
-    signaling_thread_.reset(new rtc::Thread());
+    signaling_thread_ = rtc::Thread::Create();
     ASSERT_TRUE(signaling_thread_->Start());
     fake_ = Fake::Create();
     fake_signaling_proxy_ =
         FakeSignalingProxy::Create(signaling_thread_.get(), fake_.get());
   }
 
  protected:
   std::unique_ptr<rtc::Thread> signaling_thread_;
   rtc::scoped_refptr<FakeInterface> fake_signaling_proxy_;
   rtc::scoped_refptr<Fake> fake_;
@@ skipping 66 matching lines @@
 }
 
 class ProxyTest : public testing::Test {
  public:
   // Checks that the functions are called on the right thread.
   void CheckSignalingThread() { EXPECT_TRUE(signaling_thread_->IsCurrent()); }
   void CheckWorkerThread() { EXPECT_TRUE(worker_thread_->IsCurrent()); }
 
  protected:
   void SetUp() override {
-    signaling_thread_.reset(new rtc::Thread());
-    worker_thread_.reset(new rtc::Thread());
+    signaling_thread_ = rtc::Thread::Create();
+    worker_thread_ = rtc::Thread::Create();
     ASSERT_TRUE(signaling_thread_->Start());
     ASSERT_TRUE(worker_thread_->Start());
     fake_ = Fake::Create();
     fake_proxy_ = FakeProxy::Create(signaling_thread_.get(),
                                     worker_thread_.get(), fake_.get());
   }
 
  protected:
   std::unique_ptr<rtc::Thread> signaling_thread_;
   std::unique_ptr<rtc::Thread> worker_thread_;
@@ skipping 79 matching lines @@
 };
 
 BEGIN_OWNED_PROXY_MAP(Foo)
   PROXY_SIGNALING_THREAD_DESTRUCTOR()
   PROXY_METHOD0(void, Bar)
 END_PROXY_MAP()
 
 class OwnedProxyTest : public testing::Test {
  public:
   OwnedProxyTest()
-      : foo_(new Foo()),
-        foo_proxy_(FooProxy::Create(&signaling_thread_,
-                                    &worker_thread_,
+      : signaling_thread_(rtc::Thread::Create()),
+        worker_thread_(rtc::Thread::Create()),
+        foo_(new Foo()),
+        foo_proxy_(FooProxy::Create(signaling_thread_.get(),
+                                    worker_thread_.get(),
                                     std::unique_ptr<FooInterface>(foo_))) {
-    signaling_thread_.Start();
-    worker_thread_.Start();
+    signaling_thread_->Start();
+    worker_thread_->Start();
   }
 
-  void CheckSignalingThread() { EXPECT_TRUE(signaling_thread_.IsCurrent()); }
-  void CheckWorkerThread() { EXPECT_TRUE(worker_thread_.IsCurrent()); }
+  void CheckSignalingThread() { EXPECT_TRUE(signaling_thread_->IsCurrent()); }
+  void CheckWorkerThread() { EXPECT_TRUE(worker_thread_->IsCurrent()); }
 
  protected:
-  rtc::Thread signaling_thread_;
-  rtc::Thread worker_thread_;
+  std::unique_ptr<rtc::Thread> signaling_thread_;
+  std::unique_ptr<rtc::Thread> worker_thread_;
   Foo* foo_;  // Owned by foo_proxy_, not this class.
   std::unique_ptr<FooInterface> foo_proxy_;
 };
 
 // Just tests that a method can be invoked using an "owned proxy" (as opposed
 // to normal ref-counted version).
 TEST_F(OwnedProxyTest, BasicTest) {
   EXPECT_CALL(*foo_, Bar())
       .Times(Exactly(1))
       .WillOnce(InvokeWithoutArgs(this, &OwnedProxyTest::CheckSignalingThread));
   foo_proxy_->Bar();
 }
 
 }  // namespace webrtc