Delete static method TaskQueue::IsCurrent.

webrtc/rtc_base/task_queue_unittest.cc

 /*
  *  Copyright 2016 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 29 matching lines @@
       timeEndPeriod(1);
   }
 
  private:
   const bool enabled_;
 #endif
 };
 }
 
 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();
 }
 
 }  // namespace
 
 TEST(TaskQueueTest, Construct) {
   static const char kQueueName[] = "Construct";
   TaskQueue queue(kQueueName);
   EXPECT_FALSE(queue.IsCurrent());
 }
 
 TEST(TaskQueueTest, PostAndCheckCurrent) {
   static const char kQueueName[] = "PostAndCheckCurrent";
   Event event(false, false);
   TaskQueue queue(kQueueName);
 
   // We're not running a task, so there shouldn't be a current queue.
   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));
 }
 
 TEST(TaskQueueTest, PostCustomTask) {
   static const char kQueueName[] = "PostCustomImplementation";
   Event event(false, false);
   TaskQueue queue(kQueueName);
 
   class CustomTask : public QueuedTask {
    public:
@@ skipping 40 matching lines @@
       [&event, &queue]() { queue.PostTask([&event]() { event.Set(); }); });
   EXPECT_TRUE(event.Wait(1000));
 }
 
 TEST(TaskQueueTest, PostDelayed) {
   static const char kQueueName[] = "PostDelayed";
   Event event(false, false);
   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
   // be.  Most recently we've seen windows bots fire the callback after 94-99ms,
   // which is why we have a little bit of leeway backwards as well.
   EXPECT_GE(end - start, 90u);
   EXPECT_NEAR(end - start, 190u, 100u);  // Accept 90-290.
 }
 
 // This task needs to be run manually due to the slowness of some of our bots.
 // TODO(tommi): Can we run this on the perf bots?
 TEST(TaskQueueTest, DISABLED_PostDelayedHighRes) {
   EnableHighResTimers high_res_scope;
 
   static const char kQueueName[] = "PostDelayedHighRes";
   Event event(false, false);
   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
   // be.  Most recently we've seen windows bots fire the callback after 94-99ms,
   // which is why we have a little bit of leeway backwards as well.
   EXPECT_GE(end - start, 3u);
   EXPECT_NEAR(end - start, 3, 3u);
 }
 
 TEST(TaskQueueTest, PostMultipleDelayed) {
   static const char kQueueName[] = "PostMultipleDelayed";
   TaskQueue queue(kQueueName);
 
   std::vector<std::unique_ptr<Event>> events;
   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)
     EXPECT_TRUE(e->Wait(1000));
 }
 
 TEST(TaskQueueTest, PostDelayedAfterDestruct) {
   static const char kQueueName[] = "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.
 }
 
 TEST(TaskQueueTest, PostAndReply) {
   static const char kPostQueue[] = "PostQueue";
   static const char kReplyQueue[] = "ReplyQueue";
   Event event(false, false);
   TaskQueue post_queue(kPostQueue);
   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));
 }
 
 TEST(TaskQueueTest, PostAndReuse) {
   static const char kPostQueue[] = "PostQueue";
   static const char kReplyQueue[] = "ReplyQueue";
   Event event(false, false);
   TaskQueue post_queue(kPostQueue);
   TaskQueue reply_queue(kReplyQueue);
 
@@ skipping 60 matching lines @@
   Event event(false, false);
   TaskQueue post_queue("PostQueue");
   TaskQueue reply_queue("ReplyQueue");
 
   post_queue.PostTaskAndReply([&event]() { event.Set(); }, []() {},
                               &reply_queue);
   EXPECT_TRUE(event.Wait(1000));
 }
 
 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(); }));
 }
 
 // Does a PostTaskAndReply from within a task to post and reply to the current
 // queue.  All in all there will be 3 tasks posted and run.
 TEST(TaskQueueTest, PostAndReply2) {
   static const char kQueueName[] = "PostAndReply2";
   static const char kWorkQueueName[] = "PostAndReply2_Worker";
   Event event(false, false);
   TaskQueue queue(kQueueName);
   TaskQueue work_queue(kWorkQueueName);
 
   queue.PostTask(
-      Bind(&TestPostTaskAndReply, &work_queue, kWorkQueueName, &event));
+      Bind(&TestPostTaskAndReply, &work_queue, &event));
   EXPECT_TRUE(event.Wait(1000));
 }
 
 // Tests posting more messages than a queue can queue up.
 // In situations like that, tasks will get dropped.
 TEST(TaskQueueTest, PostALot) {
   // To destruct the event after the queue has gone out of scope.
   Event event(false, false);
 
   int tasks_executed = 0;
@@ skipping 13 matching lines @@
       queue.PostTask(NewClosure([&tasks_executed]() { ++tasks_executed; },
                                 [&tasks_cleaned_up]() { ++tasks_cleaned_up; }));
     event.Set();  // Unblock the first task.
   }
 
   EXPECT_GE(tasks_cleaned_up, tasks_executed);
   EXPECT_EQ(kTaskCount, tasks_cleaned_up);
 }
 
 }  // namespace rtc