[Reland] Make canceling Timers fast.

third_party/WebKit/Source/platform/scheduler/base/work_queue_unittest.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "platform/scheduler/base/work_queue.h"
 
 #include <stddef.h>
 
+#include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "platform/scheduler/base/real_time_domain.h"
 #include "platform/scheduler/base/task_queue_impl.h"
 #include "platform/scheduler/base/work_queue_sets.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 namespace blink {
 namespace scheduler {
 namespace internal {
+namespace {
+void NopTask() {}
+}
 
 class WorkQueueTest : public testing::Test {
  public:
   void SetUp() override {
     time_domain_.reset(new RealTimeDomain(""));
     task_queue_ = make_scoped_refptr(new TaskQueueImpl(
         nullptr, time_domain_.get(), TaskQueue::Spec("fake"), "", ""));
 
-    work_queue_.reset(
-        new WorkQueue(task_queue_.get(), "test",
-                      TaskQueueImpl::Task::EnqueueOrderComparatorFn));
+    work_queue_.reset(new WorkQueue(task_queue_.get(), "test"));
     work_queue_sets_.reset(new WorkQueueSets(1, "test"));
     work_queue_sets_->AddQueue(work_queue_.get(), 0);
 
-    incoming_queue_.reset(new TaskQueueImpl::ComparatorQueue(
-        TaskQueueImpl::Task::EnqueueOrderComparatorFn));
+    incoming_queue_.reset(new std::queue<TaskQueueImpl::Task>());
   }
 
   void TearDown() override { work_queue_sets_->RemoveQueue(work_queue_.get()); }
 
  protected:
   TaskQueueImpl::Task FakeTaskWithEnqueueOrder(int enqueue_order) {
-    TaskQueueImpl::Task fake_task(FROM_HERE, base::Closure(), base::TimeTicks(),
-                                  0, true);
+    TaskQueueImpl::Task fake_task(FROM_HERE, base::Bind(&NopTask),
+                                  base::TimeTicks(), 0, true);
     fake_task.set_enqueue_order(enqueue_order);
     return fake_task;
   }
 
   std::unique_ptr<RealTimeDomain> time_domain_;
   scoped_refptr<TaskQueueImpl> task_queue_;
   std::unique_ptr<WorkQueue> work_queue_;
   std::unique_ptr<WorkQueueSets> work_queue_sets_;
-  std::unique_ptr<TaskQueueImpl::ComparatorQueue> incoming_queue_;
+  std::unique_ptr<std::queue<TaskQueueImpl::Task>> incoming_queue_;
 };
 
 TEST_F(WorkQueueTest, Empty) {
   EXPECT_TRUE(work_queue_->Empty());
   work_queue_->Push(FakeTaskWithEnqueueOrder(1));
   EXPECT_FALSE(work_queue_->Empty());
 }
 
 TEST_F(WorkQueueTest, Empty_IgnoresFences) {
   work_queue_->Push(FakeTaskWithEnqueueOrder(1));
@@ skipping 54 matching lines @@
 TEST_F(WorkQueueTest, PushAfterFenceHit) {
   work_queue_->InsertFence(1);
   WorkQueue* work_queue;
   EXPECT_FALSE(work_queue_sets_->GetOldestQueueInSet(0, &work_queue));
 
   work_queue_->Push(FakeTaskWithEnqueueOrder(2));
   EXPECT_FALSE(work_queue_sets_->GetOldestQueueInSet(0, &work_queue));
 }
 
 TEST_F(WorkQueueTest, SwapLocked) {
-  incoming_queue_->insert(FakeTaskWithEnqueueOrder(2));
-  incoming_queue_->insert(FakeTaskWithEnqueueOrder(3));
-  incoming_queue_->insert(FakeTaskWithEnqueueOrder(4));
+  incoming_queue_->push(FakeTaskWithEnqueueOrder(2));
+  incoming_queue_->push(FakeTaskWithEnqueueOrder(3));
+  incoming_queue_->push(FakeTaskWithEnqueueOrder(4));
 
   WorkQueue* work_queue;
   EXPECT_FALSE(work_queue_sets_->GetOldestQueueInSet(0, &work_queue));
   EXPECT_TRUE(work_queue_->Empty());
   work_queue_->SwapLocked(*incoming_queue_.get());
 
   EXPECT_TRUE(work_queue_sets_->GetOldestQueueInSet(0, &work_queue));
   EXPECT_FALSE(work_queue_->Empty());
   EXPECT_TRUE(incoming_queue_->empty());
 
   ASSERT_NE(nullptr, work_queue_->GetFrontTask());
   EXPECT_EQ(2ull, work_queue_->GetFrontTask()->enqueue_order());
 
   ASSERT_NE(nullptr, work_queue_->GetBackTask());
   EXPECT_EQ(4ull, work_queue_->GetBackTask()->enqueue_order());
 }
 
 TEST_F(WorkQueueTest, SwapLockedAfterFenceHit) {
   work_queue_->InsertFence(1);
-  incoming_queue_->insert(FakeTaskWithEnqueueOrder(2));
-  incoming_queue_->insert(FakeTaskWithEnqueueOrder(3));
-  incoming_queue_->insert(FakeTaskWithEnqueueOrder(4));
+  incoming_queue_->push(FakeTaskWithEnqueueOrder(2));
+  incoming_queue_->push(FakeTaskWithEnqueueOrder(3));
+  incoming_queue_->push(FakeTaskWithEnqueueOrder(4));
 
   WorkQueue* work_queue;
   EXPECT_FALSE(work_queue_sets_->GetOldestQueueInSet(0, &work_queue));
   EXPECT_TRUE(work_queue_->Empty());
   work_queue_->SwapLocked(*incoming_queue_.get());
 
   EXPECT_FALSE(work_queue_sets_->GetOldestQueueInSet(0, &work_queue));
   EXPECT_FALSE(work_queue_->Empty());
   EXPECT_TRUE(incoming_queue_->empty());
 
@@ skipping 193 matching lines @@
   EXPECT_EQ(1ull, work_queue_->TakeTaskFromWorkQueue().enqueue_order());
   EXPECT_TRUE(work_queue_->BlockedByFence());
 
   EXPECT_TRUE(work_queue_->InsertFence(4));
   EXPECT_FALSE(work_queue_->BlockedByFence());
 }
 
 }  // namespace internal
 }  // namespace scheduler
 }  // namespace blink