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

Delete static method TaskQueue::IsCurrent.

Browse Source 
The static method takes a queue name as argument. Used only in one
place, a DCHECK in IncomingVideoStream, which is converted to use
the non-static version of IsCurrent.

BUG=webrtc:8166

Review-Url: https://codereview.webrtc.org/3004873002
Cr-Commit-Position: refs/heads/master@{#19657}
This commit is contained in:
nisse 2017-09-04 05:18:21 -07:00 committed by Commit Bot
parent 334f9e6a8d
commit 2c7b7a633f
6 changed files with 11 additions and 39 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
webrtc/common_video/incoming_video_stream.cc
View File

@ -37,7 +37,7 @@ class IncomingVideoStream::NewFrameTask : public rtc::QueuedTask {
private:
bool Run() override {
RTC_DCHECK(rtc::TaskQueue::IsCurrent(kIncomingQueueName));
RTC_DCHECK(stream_->incoming_render_queue_.IsCurrent());
if (stream_->render_buffers_.AddFrame(std::move(frame_)) == 1)
stream_->Dequeue();
return true;

1
webrtc/rtc_base/task_queue.h
View File

@ -170,7 +170,6 @@ class LOCKABLE TaskQueue {
static TaskQueue* Current();
// Used for DCHECKing the current queue.
static bool IsCurrent(const char* queue_name);
bool IsCurrent() const;
// TODO(tommi): For better debuggability, implement RTC_FROM_HERE.

7
webrtc/rtc_base/task_queue_gcd.cc
View File

@ -145,13 +145,6 @@ TaskQueue* TaskQueue::Current() {
return static_cast<TaskQueue*>(pthread_getspecific(GetQueuePtrTls()));
}
// static
bool TaskQueue::IsCurrent(const char* queue_name) {
TaskQueue* current = Current();
return current &&
strcmp(queue_name, dispatch_queue_get_label(current->queue_)) == 0;
}
bool TaskQueue::IsCurrent() const {
RTC_DCHECK(queue_);
return this == Current();

12
webrtc/rtc_base/task_queue_libevent.cc
View File

@ -119,7 +119,6 @@ class TaskQueue::Impl : public RefCountInterface {
static TaskQueue* CurrentQueue();
// Used for DCHECKing the current queue.
static bool IsCurrent(const char* queue_name);
bool IsCurrent() const;
void PostTask(std::unique_ptr<QueuedTask> task);
@ -337,12 +336,6 @@ TaskQueue* TaskQueue::Impl::CurrentQueue() {
return nullptr;
}
// static
bool TaskQueue::Impl::IsCurrent(const char* queue_name) {
TaskQueue::Impl* current = Current();
return current && current->thread_.name().compare(queue_name) == 0;
}
bool TaskQueue::Impl::IsCurrent() const {
return IsThreadRefEqual(thread_.GetThreadRef(), CurrentThreadRef());
}
@ -503,11 +496,6 @@ TaskQueue* TaskQueue::Current() {
}
// Used for DCHECKing the current queue.
// static
bool TaskQueue::IsCurrent(const char* queue_name) {
return TaskQueue::Impl::IsCurrent(queue_name);
}
bool TaskQueue::IsCurrent() const {
return impl_->IsCurrent();
}

22
webrtc/rtc_base/task_queue_unittest.cc
View File

@ -47,8 +47,7 @@ class EnableHighResTimers {
}
namespace {
void CheckCurrent(const char* expected_queue, Event* signal, TaskQueue* queue) {
EXPECT_TRUE(TaskQueue::IsCurrent(expected_queue));
void CheckCurrent(Event* signal, TaskQueue* queue) {
EXPECT_TRUE(queue->IsCurrent());
if (signal)
signal->Set();
@ -71,7 +70,7 @@ TEST(TaskQueueTest, PostAndCheckCurrent) {
EXPECT_FALSE(queue.IsCurrent());
EXPECT_FALSE(TaskQueue::Current());
queue.PostTask(Bind(&CheckCurrent, kQueueName, &event, &queue));
queue.PostTask(Bind(&CheckCurrent, &event, &queue));
EXPECT_TRUE(event.Wait(1000));
}
@ -132,7 +131,7 @@ TEST(TaskQueueTest, PostDelayed) {
TaskQueue queue(kQueueName, TaskQueue::Priority::HIGH);
uint32_t start = Time();
queue.PostDelayedTask(Bind(&CheckCurrent, kQueueName, &event, &queue), 100);
queue.PostDelayedTask(Bind(&CheckCurrent, &event, &queue), 100);
EXPECT_TRUE(event.Wait(1000));
uint32_t end = Time();
// These tests are a little relaxed due to how "powerful" our test bots can
@ -152,7 +151,7 @@ TEST(TaskQueueTest, DISABLED_PostDelayedHighRes) {
TaskQueue queue(kQueueName, TaskQueue::Priority::HIGH);
uint32_t start = Time();
queue.PostDelayedTask(Bind(&CheckCurrent, kQueueName, &event, &queue), 3);
queue.PostDelayedTask(Bind(&CheckCurrent, &event, &queue), 3);
EXPECT_TRUE(event.Wait(1000));
uint32_t end = TimeMillis();
// These tests are a little relaxed due to how "powerful" our test bots can
@ -170,7 +169,7 @@ TEST(TaskQueueTest, PostMultipleDelayed) {
for (int i = 0; i < 100; ++i) {
events.push_back(std::unique_ptr<Event>(new Event(false, false)));
queue.PostDelayedTask(
Bind(&CheckCurrent, kQueueName, events.back().get(), &queue), i);
Bind(&CheckCurrent, events.back().get(), &queue), i);
}
for (const auto& e : events)
@ -182,7 +181,7 @@ TEST(TaskQueueTest, PostDelayedAfterDestruct) {
Event event(false, false);
{
TaskQueue queue(kQueueName);
queue.PostDelayedTask(Bind(&CheckCurrent, kQueueName, &event, &queue), 100);
queue.PostDelayedTask(Bind(&CheckCurrent, &event, &queue), 100);
}
EXPECT_FALSE(event.Wait(200)); // Task should not run.
}
@ -195,8 +194,8 @@ TEST(TaskQueueTest, PostAndReply) {
TaskQueue reply_queue(kReplyQueue);
post_queue.PostTaskAndReply(
Bind(&CheckCurrent, kPostQueue, nullptr, &post_queue),
Bind(&CheckCurrent, kReplyQueue, &event, &reply_queue), &reply_queue);
Bind(&CheckCurrent, nullptr, &post_queue),
Bind(&CheckCurrent, &event, &reply_queue), &reply_queue);
EXPECT_TRUE(event.Wait(1000));
}
@ -277,11 +276,10 @@ TEST(TaskQueueTest, PostAndReplyDeadlock) {
}
void TestPostTaskAndReply(TaskQueue* work_queue,
const char* work_queue_name,
Event* event) {
ASSERT_FALSE(work_queue->IsCurrent());
work_queue->PostTaskAndReply(
Bind(&CheckCurrent, work_queue_name, nullptr, work_queue),
Bind(&CheckCurrent, nullptr, work_queue),
NewClosure([event]() { event->Set(); }));
}
@ -295,7 +293,7 @@ TEST(TaskQueueTest, PostAndReply2) {
TaskQueue work_queue(kWorkQueueName);
queue.PostTask(
Bind(&TestPostTaskAndReply, &work_queue, kWorkQueueName, &event));
Bind(&TestPostTaskAndReply, &work_queue, &event));
EXPECT_TRUE(event.Wait(1000));
}

6
webrtc/rtc_base/task_queue_win.cc
View File

@ -217,12 +217,6 @@ TaskQueue* TaskQueue::Current() {
return static_cast<TaskQueue*>(::TlsGetValue(GetQueuePtrTls()));
}
// static
bool TaskQueue::IsCurrent(const char* queue_name) {
TaskQueue* current = Current();
return current && current->thread_.name().compare(queue_name) == 0;
}
bool TaskQueue::IsCurrent() const {
return IsThreadRefEqual(thread_.GetThreadRef(), CurrentThreadRef());
}