Revert of Adds TimeDomains to the TaskQueueManager

components/scheduler/base/task_queue_selector_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 "components/scheduler/base/task_queue_selector.h"
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/pending_task.h"
 #include "components/scheduler/base/task_queue_impl.h"
 #include "components/scheduler/base/task_queue_sets.h"
-#include "components/scheduler/base/virtual_time_domain.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::_;
 
 namespace scheduler {
 namespace internal {
 
 class MockObserver : public TaskQueueSelector::Observer {
  public:
@@ skipping 45 matching lines @@
       chosen_queue->PopTaskFromWorkQueueForTest();
       selector_.GetTaskQueueSets()->OnPopQueue(chosen_queue);
     }
     return order;
   }
 
   static void TestFunction() {}
 
  protected:
   void SetUp() final {
-    virtual_time_domain_ = make_scoped_refptr<VirtualTimeDomain>(
-        new VirtualTimeDomain(base::TimeTicks()));
     for (size_t i = 0; i < kTaskQueueCount; i++) {
-      scoped_refptr<TaskQueueImpl> task_queue = make_scoped_refptr(
-          new TaskQueueImpl(nullptr, virtual_time_domain_,
-                            TaskQueue::Spec("test queue"), "test", "test"));
+      scoped_refptr<TaskQueueImpl> task_queue =
+          make_scoped_refptr(new TaskQueueImpl(
+              nullptr, TaskQueue::Spec("test queue"), "test", "test"));
       selector_.AddQueue(task_queue.get());
       task_queues_.push_back(task_queue);
     }
     for (size_t i = 0; i < kTaskQueueCount; i++) {
       EXPECT_TRUE(selector_.IsQueueEnabled(task_queues_[i].get())) << i;
       queue_to_index_map_.insert(std::make_pair(task_queues_[i].get(), i));
     }
   }
 
   const size_t kTaskQueueCount = 5;
   base::Closure test_closure_;
   TaskQueueSelector selector_;
-  scoped_refptr<VirtualTimeDomain> virtual_time_domain_;
   std::vector<scoped_refptr<TaskQueueImpl>> task_queues_;
   std::map<TaskQueueImpl*, size_t> queue_to_index_map_;
 };
 
 TEST_F(TaskQueueSelectorTest, TestDefaultPriority) {
   std::vector<TaskQueueImpl::Task> tasks = GetTasks(5);
   size_t queue_order[] = {4, 3, 2, 1, 0};
   PushTasks(tasks, queue_order);
   EXPECT_THAT(PopTasks(), testing::ElementsAre(4, 3, 2, 1, 0));
 }
@@ skipping 171 matching lines @@
   size_t queue_order[] = {0, 1};
   PushTasks(tasks, queue_order);
 
   EXPECT_FALSE(selector_.EnabledWorkQueuesEmpty());
   PopTasks();
   EXPECT_TRUE(selector_.EnabledWorkQueuesEmpty());
 }
 
 }  // namespace internal
 }  // namespace scheduler