Experimental: Remove chromium shared timers

content/renderer/scheduler/renderer_task_queue_selector_unittest.cc

 // Copyright 2014 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 "content/renderer/scheduler/renderer_task_queue_selector.h"
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/pending_task.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace content {
 
+class MockTaskQueueSelectorObserver
+    : public TaskQueueSelector::TaskQueueSelectorObserver {
+ public:
+  MockTaskQueueSelectorObserver() {}
+  virtual ~MockTaskQueueSelectorObserver() {}
+
+  MOCK_METHOD0(OnTaskQueueEnabled, void());
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(MockTaskQueueSelectorObserver);
+};
+
 class RendererTaskQueueSelectorTest : public testing::Test {
  public:
   RendererTaskQueueSelectorTest()
       : test_closure_(
             base::Bind(&RendererTaskQueueSelectorTest::TestFunction)) {}
   ~RendererTaskQueueSelectorTest() override {}
 
   std::vector<base::PendingTask> GetTasks(int count) {
     std::vector<base::PendingTask> tasks;
     for (int i = 0; i < count; i++) {
@@ skipping 71 matching lines @@
   std::vector<base::PendingTask> tasks = GetTasks(5);
   size_t queue_order[] = {0, 1, 2, 3, 4};
   PushTasks(tasks, queue_order);
   selector_.SetQueuePriority(4, RendererTaskQueueSelector::CONTROL_PRIORITY);
   EXPECT_TRUE(selector_.IsQueueEnabled(4));
   selector_.SetQueuePriority(2, RendererTaskQueueSelector::HIGH_PRIORITY);
   EXPECT_TRUE(selector_.IsQueueEnabled(2));
   EXPECT_THAT(PopTasks(), testing::ElementsAre(4, 2, 0, 1, 3));
 }
 
+TEST_F(RendererTaskQueueSelectorTest, TestDisableReturnsTrueIfQueueWasEnabled) {
+  selector_.EnableQueue(1, RendererTaskQueueSelector::NORMAL_PRIORITY);
+  EXPECT_TRUE(selector_.DisableQueue(1));
+}
+
+TEST_F(RendererTaskQueueSelectorTest,
+       TestDisableReturnsFalseIfQueueWasAlreadyDisabled) {
+  selector_.DisableQueue(1);
+  EXPECT_FALSE(selector_.DisableQueue(1));
+}
+
 TEST_F(RendererTaskQueueSelectorTest, TestDisableEnable) {
+  MockTaskQueueSelectorObserver mock_observer;
+  selector_.RegisterTaskQueueObserver(&mock_observer);
+
   std::vector<base::PendingTask> tasks = GetTasks(5);
   size_t queue_order[] = {0, 1, 2, 3, 4};
   PushTasks(tasks, queue_order);
   selector_.DisableQueue(2);
   EXPECT_FALSE(selector_.IsQueueEnabled(2));
   selector_.DisableQueue(4);
   EXPECT_FALSE(selector_.IsQueueEnabled(4));
   EXPECT_THAT(PopTasks(), testing::ElementsAre(0, 1, 3));
+
+  EXPECT_CALL(mock_observer, OnTaskQueueEnabled()).Times(2);
   selector_.EnableQueue(2, RendererTaskQueueSelector::BEST_EFFORT_PRIORITY);
   EXPECT_THAT(PopTasks(), testing::ElementsAre(2));
   selector_.EnableQueue(4, RendererTaskQueueSelector::NORMAL_PRIORITY);
   EXPECT_THAT(PopTasks(), testing::ElementsAre(4));
 }
 
 TEST_F(RendererTaskQueueSelectorTest, TestEmptyQueues) {
   size_t chosen_queue_index = 0;
   EXPECT_FALSE(selector_.SelectWorkQueueToService(&chosen_queue_index));
 
@@ skipping 73 matching lines @@
   }
   selector_.SetQueuePriority(1, RendererTaskQueueSelector::CONTROL_PRIORITY);
   for (int i = 0; i < 100; i++) {
     EXPECT_TRUE(selector_.SelectWorkQueueToService(&chosen_queue_index));
     EXPECT_EQ(1ul, chosen_queue_index);
     // Don't remove task from queue to simulate all queues still being full.
   }
 }
 
 }  // namespace content