TaskScheduler [3/9] Task and Sequence

base/task_scheduler/sequence.cc

+// Copyright 2016 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 "base/task_scheduler/sequence.h"
+
+#include <utility>
+
+#include "base/logging.h"
+
+namespace base {
+namespace internal {
+
+Sequence::Sequence() = default;
+
+bool Sequence::PushTask(scoped_ptr<Task> task) {
+  AutoSchedulerLock auto_lock(lock_);
+
+  const TaskPriorityUnderlyingType index_priority =

[gab, 2016/02/19 16:50:47]

s/index_priority/priority_index/ ? (reads better to me..)

[fdoray, 2016/02/19 22:28:30]

Done.

+      static_cast<TaskPriorityUnderlyingType>(task->traits.priority());
+  ++num_tasks_per_priority_[index_priority];
+
+  queue_.push(std::move(task));
+
+  // Return true if the sequence was empty before the push.
+  return queue_.size() == 1;
+}
+
+const Task* Sequence::PeekTask() const {
+  AutoSchedulerLock auto_lock(lock_);
+
+  if (queue_.empty())
+    return nullptr;
+
+  return queue_.front().get();
+}
+
+bool Sequence::PopTask() {
+  AutoSchedulerLock auto_lock(lock_);
+  CHECK(!queue_.empty());
+
+  const TaskPriorityUnderlyingType index_priority =
+      static_cast<TaskPriorityUnderlyingType>(
+          queue_.front()->traits.priority());
+  --num_tasks_per_priority_[index_priority];
+
+  queue_.pop();
+  return queue_.empty();
+}
+
+SequenceSortKey Sequence::GetSortKey() const {
+  AutoSchedulerLock auto_lock(lock_);
+  CHECK(!queue_.empty());
+
+  // Find the highest task priority in the sequence.
+  static_assert(static_cast<TaskPriorityUnderlyingType>(
+                    TaskPriority::HIGHEST) == kNumTaskPriorities - 1,
+                "");

[gab, 2016/02/19 16:50:47]

"Unexpected priority range." or something?

Well actually, do we really need to static_assert that this is equal to its
exact definition?

They're both in internal namespace, you'd sure hope anyone modifying its
definition would look for its very few use cases...

[fdoray, 2016/02/19 22:28:30]

Removed the static_assert.

+  TaskPriority priority = TaskPriority::LOWEST;
+  for (size_t i =

[gab, 2016/02/19 16:50:47]

s/size_t/TaskPriorityUnderlyingType/ now that we're starting with one and
comparing against one.

[fdoray, 2016/02/19 22:28:30]

Done.

+           static_cast<TaskPriorityUnderlyingType>(TaskPriority::HIGHEST);
+       i > static_cast<TaskPriorityUnderlyingType>(TaskPriority::LOWEST); --i) {
+    if (num_tasks_per_priority_[i] > 0) {
+      priority = static_cast<TaskPriority>(i);
+      break;
+    }
+  }
+
+  return SequenceSortKey(priority, queue_.front()->sequenced_time);
+}
+
+Sequence::~Sequence() = default;
+
+}  // namespace internal
+}  // namespace base