admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Make the default ctor of rtc::Thread, protected.

Browse Source 
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}
This commit is contained in:
tommi 2017-07-13 05:47:25 -07:00 committed by Commit Bot
parent abcf112ae0
commit a8a3515997
16 changed files with 150 additions and 142 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
webrtc/pc/channelmanager_unittest.cc
View File

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

14
webrtc/pc/peerconnectionendtoend_unittest.cc
View File

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

9
webrtc/pc/peerconnectioninterface_unittest.cc
View File

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

26
webrtc/pc/proxy_unittest.cc
View File

@ -95,7 +95,7 @@ class SignalingProxyTest : public testing::Test {
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_ =
@ -182,8 +182,8 @@ class ProxyTest : public testing::Test {
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();
@ -283,20 +283,22 @@ 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_;
};

15
webrtc/pc/rtcstats_integrationtest.cc
View File

@ -34,14 +34,15 @@ const int64_t kGetStatsTimeoutMs = 10000;
class RTCStatsIntegrationTest : public testing::Test {
public:
RTCStatsIntegrationTest()
: network_thread_(&virtual_socket_server_), worker_thread_() {
RTC_CHECK(network_thread_.Start());
RTC_CHECK(worker_thread_.Start());
: network_thread_(new rtc::Thread(&virtual_socket_server_)),
worker_thread_(rtc::Thread::Create()) {
RTC_CHECK(network_thread_->Start());
RTC_CHECK(worker_thread_->Start());
caller_ = new rtc::RefCountedObject<PeerConnectionTestWrapper>(
"caller", &network_thread_, &worker_thread_);
"caller", network_thread_.get(), worker_thread_.get());
callee_ = new rtc::RefCountedObject<PeerConnectionTestWrapper>(
"callee", &network_thread_, &worker_thread_);
"callee", network_thread_.get(), worker_thread_.get());
}
void StartCall() {
@ -96,8 +97,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_;
rtc::Thread network_thread_;
rtc::Thread worker_thread_;
std::unique_ptr<rtc::Thread> network_thread_;
std::unique_ptr<rtc::Thread> worker_thread_;
rtc::scoped_refptr<PeerConnectionTestWrapper> caller_;
rtc::scoped_refptr<PeerConnectionTestWrapper> callee_;
};

2
webrtc/pc/test/fakeaudiocapturemodule.cc
View File

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

2
webrtc/rtc_base/criticalsection_unittest.cc
View File

@ -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(new Thread());
std::unique_ptr<Thread> thread(Thread::Create());
thread->Start();
thread->Post(RTC_FROM_HERE, handler);
threads->push_back(std::move(thread));

40
webrtc/rtc_base/messagequeue_unittest.cc
View File

@ -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.
Thread worker;
worker.Start();
return worker.Invoke<bool>(
std::unique_ptr<Thread> worker(Thread::CreateWithSocketServer());
worker->Start();
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);
Thread a;
Thread b;
a.Start();
b.Start();
auto a = Thread::CreateWithSocketServer();
auto b = Thread::CreateWithSocketServer();
a->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);
b.Post(RTC_FROM_HERE, &incrementer);
a.PostDelayed(RTC_FROM_HERE, 0, &incrementer);
b.PostDelayed(RTC_FROM_HERE, 0, &incrementer);
a->Post(RTC_FROM_HERE, &incrementer);
b->Post(RTC_FROM_HERE, &incrementer);
a->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) {
Thread t;
t.Start();
t.Quit();
auto t = Thread::CreateWithSocketServer();
t->Start();
t->Quit();
MessageQueueManager::ProcessAllMessageQueues();
}
@ -195,8 +195,8 @@ TEST(MessageQueueManager, ProcessAllMessageQueuesWithQuittingThread) {
// messages.
TEST(MessageQueueManager, ProcessAllMessageQueuesWithClearedQueue) {
Event entered_process_all_message_queues(true, false);
Thread t;
t.Start();
auto t = Thread::CreateWithSocketServer();
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) {
Thread t;
std::unique_ptr<Thread> t(Thread::Create());
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, &handler, 0,
t->Post(RTC_FROM_HERE, inner_handler, 0);
t->Post(RTC_FROM_HERE, &handler, 0,
new ScopedRefMessageData<RefCountedHandler>(inner_handler));
}

6
webrtc/rtc_base/nullsocketserver_unittest.cc
View File

@ -28,9 +28,9 @@ class NullSocketServerTest
};
TEST_F(NullSocketServerTest, WaitAndSet) {
Thread thread;
EXPECT_TRUE(thread.Start());
thread.Post(RTC_FROM_HERE, this, 0);
auto thread = Thread::Create();
EXPECT_TRUE(thread->Start());
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);

2
webrtc/rtc_base/physicalsocketserver_unittest.cc
View File

@ -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(new Thread());
std::unique_ptr<Thread> thread(Thread::CreateWithSocketServer());
std::unique_ptr<RaiseSigTermRunnable> runnable(new RaiseSigTermRunnable());
thread->Start(runnable.get());
EXPECT_TRUE(ss_->Wait(1500, true));

2
webrtc/rtc_base/rtccertificategenerator_unittest.cc
View File

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

2
webrtc/rtc_base/socket_unittest.cc
View File

@ -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(new Thread());
std::unique_ptr<Thread> thread(Thread::CreateWithSocketServer());
thread->Start();
Sleeper sleeper;
TypedMessageData<AsyncSocket*> data(client.get());

5
webrtc/rtc_base/thread.h
View File

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

84
webrtc/rtc_base/thread_unittest.cc
View File

@ -195,24 +195,24 @@ 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.
@ -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,23 +236,19 @@ TEST(ThreadTest, DISABLED_Main) {
// 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) {
@ -270,21 +266,21 @@ TEST(ThreadTest, Wrap) {
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
@ -294,8 +290,8 @@ TEST(ThreadTest, TwoThreadsInvokeNoDeadlock) {
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; }
@ -305,7 +301,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);
@ -317,9 +313,10 @@ TEST(ThreadTest, TwoThreadsInvokeNoDeadlock) {
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:
@ -377,9 +374,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,
&thread_c, thread_a, &thread_a_called));
thread_c.get(), thread_a, &thread_a_called));
EXPECT_FALSE(thread_a_called.Get());
EXPECT_TRUE_WAIT(thread_a_called.Get(), 2000);
@ -406,9 +403,9 @@ class SetNameOnSignalQueueDestroyedTester : public sigslot::has_slots<> {
};
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);
@ -438,12 +435,13 @@ class AsyncInvokeTest : public testing::Test {
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) {
@ -454,12 +452,12 @@ TEST_F(AsyncInvokeTest, KillInvokerDuringExecute) {
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();
@ -550,7 +548,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(new Thread());
std::unique_ptr<Thread> thread(Thread::Create());
thread->Start();
std::unique_ptr<GuardedAsyncInvoker> invoker;
// Create the invoker on |thread|.

8
webrtc/rtc_base/timeutils_unittest.cc
View File

@ -349,8 +349,8 @@ TEST(FakeClock, SettingTimeWakesThreads) {
FakeClock clock;
SetClockForTesting(&clock);
Thread worker;
worker.Start();
std::unique_ptr<Thread> worker(Thread::CreateWithSocketServer());
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);

11
webrtc/sdk/android/src/jni/androidmediadecoder_jni.cc
View File

@ -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,14 +180,15 @@ class MediaCodecVideoDecoder : public webrtc::VideoDecoder,
std::vector<jobject> input_buffers_;
};
MediaCodecVideoDecoder::MediaCodecVideoDecoder(
JNIEnv* jni, VideoCodecType codecType, jobject render_egl_context) :
codecType_(codecType),
MediaCodecVideoDecoder::MediaCodecVideoDecoder(JNIEnv* jni,
VideoCodecType codecType,
jobject render_egl_context)
: codecType_(codecType),
render_egl_context_(render_egl_context),
key_frame_required_(true),
inited_(false),
sw_fallback_required_(false),
codec_thread_(new Thread()),
codec_thread_(Thread::Create()),
j_media_codec_video_decoder_class_(
jni,
FindClass(jni, "org/webrtc/MediaCodecVideoDecoder")),