Skip to content
This repository was archived by the owner on Oct 23, 2024. It is now read-only.

Commit dfdb641

Browse files
starwarfanstarwarfan
committed
Fix DCHECK in debug build
1 parent 7a77687 commit dfdb641

File tree

3 files changed

+100
-55
lines changed

3 files changed

+100
-55
lines changed

‎source/core/rtc_adapter/RtcAdapter.cc‎

Lines changed: 54 additions & 26 deletions
Original file line numberDiff line numberDiff line change
@@ -14,6 +14,7 @@
1414
#include <mutex>
1515

1616
#include <system_wrappers/include/clock.h>
17+
#include <system_wrappers/include/field_trial.h>
1718

1819
namespace rtc_adapter {
1920

@@ -37,15 +38,26 @@ class RTCProcessThread {
3738
std::unique_ptr<webrtc::ProcessThread> m_processThread;
3839
};
3940

40-
static rtc::scoped_refptr<webrtc::SharedModuleThread> g_moduleThread =
41-
webrtc::SharedModuleThread::Create(
42-
webrtc::ProcessThread::Create("ModuleProcessThread"), nullptr);
41+
static rtc::scoped_refptr<webrtc::SharedModuleThread> g_moduleThread;
4342

44-
static std::unique_ptr<RTCProcessThread> g_pacerThread
45-
= std::make_unique<RTCProcessThread>("PacerThread");
43+
static std::unique_ptr<RTCProcessThread> g_pacerThread;
4644

47-
static std::unique_ptr<webrtc::FieldTrialBasedConfig> g_fieldTrial=
48-
std::make_unique<webrtc::FieldTrialBasedConfig>();
45+
static std::unique_ptr<webrtc::FieldTrialBasedConfig> g_fieldTrial= []()
46+
{
47+
auto config = std::make_unique<webrtc::FieldTrialBasedConfig>();
48+
// webrtc::field_trial::InitFieldTrialsFromString("WebRTC-TaskQueuePacer/Enabled/");
49+
return config;
50+
}();
51+
52+
static std::shared_ptr<webrtc::RtcEventLog> g_eventLog =
53+
std::make_shared<webrtc::RtcEventLogNull>();
54+
55+
static std::shared_ptr<webrtc::TaskQueueFactory> g_taskQueueFactory =
56+
createStaticTaskQueueFactory();
57+
static std::shared_ptr<rtc::TaskQueue> g_taskQueue =
58+
std::make_shared<rtc::TaskQueue>(g_taskQueueFactory->CreateTaskQueue(
59+
"CallTaskQueue",
60+
webrtc::TaskQueueFactory::Priority::NORMAL));
4961

5062
class RtcAdapterImpl : public RtcAdapter,
5163
public CallOwner {
@@ -63,49 +75,65 @@ class RtcAdapterImpl : public RtcAdapter,
6375
AudioSendAdapter* createAudioSender(const Config&) override;
6476
void destoryAudioSender(AudioSendAdapter*) override;
6577

78+
79+
typedef std::shared_ptr<webrtc::Call> CallPtr;
80+
6681
// Implement CallOwner
67-
std::shared_ptr<webrtc::Call> call() override { return m_call; }
82+
std::shared_ptr<webrtc::Call> call() override
83+
{
84+
return m_callPtr ? (*m_callPtr) : nullptr;
85+
}
6886
std::shared_ptr<webrtc::TaskQueueFactory> taskQueueFactory() override
6987
{
70-
return m_taskQueueFactory;
88+
return g_taskQueueFactory;
7189
}
72-
std::shared_ptr<rtc::TaskQueue> taskQueue() override { return m_taskQueue; }
73-
std::shared_ptr<webrtc::RtcEventLog> eventLog() override { return m_eventLog; }
90+
std::shared_ptr<rtc::TaskQueue> taskQueue() override { return g_taskQueue; }
91+
std::shared_ptr<webrtc::RtcEventLog> eventLog() override { return g_eventLog; }
7492

7593
private:
7694
void initCall();
7795

78-
std::shared_ptr<webrtc::TaskQueueFactory> m_taskQueueFactory;
79-
std::shared_ptr<rtc::TaskQueue> m_taskQueue;
80-
std::shared_ptr<webrtc::RtcEventLog> m_eventLog;
81-
std::shared_ptr<webrtc::Call> m_call;
96+
std::shared_ptr<CallPtr> m_callPtr;
8297
};
8398

8499
RtcAdapterImpl::RtcAdapterImpl()
85-
: m_taskQueueFactory(createStaticTaskQueueFactory())
86-
, m_taskQueue(std::make_shared<rtc::TaskQueue>(m_taskQueueFactory->CreateTaskQueue(
87-
"CallTaskQueue",
88-
webrtc::TaskQueueFactory::Priority::NORMAL)))
89-
, m_eventLog(std::make_shared<webrtc::RtcEventLogNull>())
90100
{
91101
}
92102

93103
RtcAdapterImpl::~RtcAdapterImpl()
94104
{
105+
if (m_callPtr) {
106+
std::shared_ptr<CallPtr> pCallPtr = m_callPtr;
107+
m_callPtr.reset();
108+
g_taskQueue->PostTask([pCallPtr]() {
109+
if (*pCallPtr) {
110+
(*pCallPtr).reset();
111+
}
112+
});
113+
}
95114
}
96115

97116
void RtcAdapterImpl::initCall()
98117
{
99-
m_taskQueue->PostTask([this]() {
118+
m_callPtr.reset(new CallPtr());
119+
std::shared_ptr<CallPtr> pCallPtr = m_callPtr;
120+
g_taskQueue->PostTask([pCallPtr]() {
100121
// Initialize call
101-
if (!m_call) {
102-
webrtc::Call::Config call_config(m_eventLog.get());
103-
call_config.task_queue_factory = m_taskQueueFactory.get();
122+
if (!(*pCallPtr)) {
123+
webrtc::Call::Config call_config(g_eventLog.get());
124+
call_config.task_queue_factory = g_taskQueueFactory.get();
104125
call_config.trials = g_fieldTrial.get();
105126

127+
if (!g_moduleThread) {
128+
g_moduleThread = webrtc::SharedModuleThread::Create(
129+
webrtc::ProcessThread::Create("ModuleProcessThread"), nullptr);
130+
}
131+
132+
// Empty thread for pacer
106133
std::unique_ptr<webrtc::ProcessThread> pacerThreadProxy =
107-
std::make_unique<ProcessThreadProxy>(g_pacerThread->unwrap());
108-
m_call.reset(webrtc::Call::Create(
134+
std::make_unique<ProcessThreadProxy>(nullptr);
135+
136+
(*pCallPtr).reset(webrtc::Call::Create(
109137
call_config, webrtc::Clock::GetRealTimeClock(),
110138
g_moduleThread,
111139
std::move(pacerThreadProxy)));

‎source/core/rtc_adapter/thread/ProcessThreadProxy.h‎

Lines changed: 15 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -17,7 +17,6 @@ class ProcessThreadProxy : public webrtc::ProcessThread {
1717
ProcessThreadProxy(webrtc::ProcessThread* processThread)
1818
: m_processThread(processThread)
1919
{
20-
RTC_DCHECK(m_processThread);
2120
}
2221

2322
// Implements ProcessThread
@@ -34,36 +33,46 @@ class ProcessThreadProxy : public webrtc::ProcessThread {
3433
// Call actual ProcessThread's WakeUp
3534
virtual void WakeUp(webrtc::Module* module) override
3635
{
37-
m_processThread->WakeUp(module);
36+
if (m_processThread) {
37+
m_processThread->WakeUp(module);
38+
}
3839
}
3940

4041
// Implements webrtc::TaskQueueBase
4142
// Call actual ProcessThread's PostTask
4243
virtual void PostTask(std::unique_ptr<webrtc::QueuedTask> task) override
4344
{
44-
m_processThread->PostTask(std::move(task));
45+
if (m_processThread) {
46+
m_processThread->PostTask(std::move(task));
47+
}
4548
}
4649

4750
// Implements webrtc::TaskQueueBase
4851
// Call actual ProcessThread's PostDelayedTask
4952
virtual void PostDelayedTask(std::unique_ptr<webrtc::QueuedTask> task,
5053
uint32_t milliseconds) override
5154
{
52-
m_processThread->PostDelayedTask(std::move(task), milliseconds);
55+
if (m_processThread) {
56+
m_processThread->PostDelayedTask(std::move(task), milliseconds);
57+
}
5358
}
5459

5560
// Implements ProcessThread
5661
// Call actual ProcessThread's RegisterModule
5762
virtual void RegisterModule(webrtc::Module* module, const rtc::Location& from) override
5863
{
59-
m_processThread->RegisterModule(module, from);
64+
if (m_processThread) {
65+
m_processThread->RegisterModule(module, from);
66+
}
6067
}
6168

6269
// Implements ProcessThread
6370
// Call actual ProcessThread's DeRegisterModule
6471
virtual void DeRegisterModule(webrtc::Module* module) override
6572
{
66-
m_processThread->DeRegisterModule(module);
73+
if (m_processThread) {
74+
m_processThread->DeRegisterModule(module);
75+
}
6776
}
6877

6978
private:

‎source/core/rtc_adapter/thread/StaticTaskQueueFactory.cc‎

Lines changed: 31 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -25,32 +25,40 @@ class TaskQueueDummy final : public webrtc::TaskQueueBase {
2525
uint32_t milliseconds) override {}
2626
};
2727

28-
// QueuedTaskProxy only execute when the owner shared_ptr exists
29-
class QueuedTaskProxy : public webrtc::QueuedTask {
28+
// TaskQueueProxy holds a TaskQueueBase* and proxy its method without Delete
29+
class TaskQueueProxy : public webrtc::TaskQueueBase {
3030
public:
31-
QueuedTaskProxy(std::unique_ptr<webrtc::QueuedTask> task, std::shared_ptr<int> owner)
32-
: m_task(std::move(task)), m_owner(owner) {}
31+
// QueuedTaskProxy only execute when the owner shared_ptr exists
32+
class QueuedTaskProxy : public webrtc::QueuedTask {
33+
public:
34+
QueuedTaskProxy(
35+
std::unique_ptr<webrtc::QueuedTask> task,
36+
std::shared_ptr<int> owner,
37+
TaskQueueProxy* parent)
38+
: m_task(std::move(task))
39+
, m_owner(owner)
40+
, m_parent(parent) {}
3341

34-
// Implements webrtc::QueuedTask
35-
bool Run() override
36-
{
37-
if (auto owner = m_owner.lock()) {
38-
// Only run when owner exists
39-
QueuedTask* raw = m_task.release();
40-
if (raw->Run()) {
41-
delete raw;
42+
// Implements webrtc::QueuedTask
43+
bool Run() override
44+
{
45+
if (auto owner = m_owner.lock()) {
46+
// Set current to pass RTC_DCHECK
47+
webrtc::TaskQueueBase::CurrentTaskQueueSetter setCurrent(m_parent);
48+
// Only run when owner exists
49+
QueuedTask* raw = m_task.release();
50+
if (raw->Run()) {
51+
delete raw;
52+
}
4253
}
54+
return true;
4355
}
44-
return true;
45-
}
46-
private:
47-
std::unique_ptr<webrtc::QueuedTask> m_task;
48-
std::weak_ptr<int> m_owner;
49-
};
56+
private:
57+
std::unique_ptr<webrtc::QueuedTask> m_task;
58+
std::weak_ptr<int> m_owner;
59+
TaskQueueProxy* m_parent;
60+
};
5061

51-
// TaskQueueProxy holds a TaskQueueBase* and proxy its method without Delete
52-
class TaskQueueProxy : public webrtc::TaskQueueBase {
53-
public:
5462
TaskQueueProxy(webrtc::TaskQueueBase* taskQueue)
5563
: m_taskQueue(taskQueue), m_sp(std::make_shared<int>(1))
5664
{
@@ -73,14 +81,14 @@ class TaskQueueProxy : public webrtc::TaskQueueBase {
7381
void PostTask(std::unique_ptr<webrtc::QueuedTask> task) override
7482
{
7583
m_taskQueue->PostTask(
76-
std::make_unique<QueuedTaskProxy>(std::move(task), m_sp));
84+
std::make_unique<QueuedTaskProxy>(std::move(task), m_sp, this));
7785
}
7886
// Implements webrtc::TaskQueueBase
7987
void PostDelayedTask(std::unique_ptr<webrtc::QueuedTask> task,
8088
uint32_t milliseconds) override
8189
{
8290
m_taskQueue->PostDelayedTask(
83-
std::make_unique<QueuedTaskProxy>(std::move(task), m_sp), milliseconds);
91+
std::make_unique<QueuedTaskProxy>(std::move(task), m_sp, this), milliseconds);
8492
}
8593
private:
8694
webrtc::TaskQueueBase* m_taskQueue;

0 commit comments

Comments
 (0)