TaskScheduler [10] SchedulerWorkerThreadStack

base/task_scheduler/scheduler_unique_stack.h

Index: base/task_scheduler/scheduler_unique_stack.h
diff --git a/base/task_scheduler/scheduler_unique_stack.h b/base/task_scheduler/scheduler_unique_stack.h
new file mode 100644
index 0000000000000000000000000000000000000000..4f9ce14a50892b8f84024fa1fae331c6cb6d3a68
--- /dev/null
+++ b/base/task_scheduler/scheduler_unique_stack.h
@@ -0,0 +1,91 @@
+// 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.
+
+#ifndef BASE_TASK_SCHEDULER_SCHEDULER_UNIQUE_STACK_H_
+#define BASE_TASK_SCHEDULER_SCHEDULER_UNIQUE_STACK_H_
+
+#include <stddef.h>

[gab, 2016/04/22 17:07:04]

Was that for int64 or is it still required?

[fdoray, 2016/04/22 18:11:44]

It's required for size_t. http://en.cppreference.com/w/cpp/types/size_t

+
+#include <algorithm>
+#include <vector>
+
+#include "base/logging.h"
+#include "base/macros.h"
+
+namespace base {
+namespace internal {
+
+// A stack that supports removal of arbitrary values and doesn't allow multiple
+// insertions of the same value. This class is NOT thread-safe.

[gab, 2016/04/22 17:07:04]

Expand this comment to explain the performance characteristics of this stack.

[gab, 2016/04/22 17:07:04]

"doesn't allow multiple insertions of the same value" makes it sound like adding
the same value twice will be ignored whereas it's a mere DCHECK+proceed.

So the "unique" property of the stack is not algorithmic, it's merely a
contract, can this comment reflect that better?

[fdoray, 2016/04/22 18:11:44]

Done.

[fdoray, 2016/04/22 18:11:44]

Done.

+template <typename T>
+class SchedulerUniqueStack {
+ public:
+  SchedulerUniqueStack();
+  ~SchedulerUniqueStack();
+
+  // Inserts |val| at the top of the stack. |val| must not already be on the
+  // stack.
+  void Push(const T& val);
+
+  // Removes the top value from the stack and returns it. Cannot be called on an
+  // empty stack.
+  T Pop();
+
+  // Removes |val| from the stack.
+  void Remove(const T& val);
+
+  // Returns the number of values on the stack.
+  size_t Size() const;
+
+  // Returns true if the stack is empty.
+  bool Empty() const;
+
+ private:
+  std::vector<T> stack_;
+
+  DISALLOW_COPY_AND_ASSIGN(SchedulerUniqueStack);
+};
+
+template <typename T>
+SchedulerUniqueStack<T>::SchedulerUniqueStack() = default;
+
+template <typename T>
+SchedulerUniqueStack<T>::~SchedulerUniqueStack() = default;
+
+template <typename T>
+void SchedulerUniqueStack<T>::Push(const T& val) {
+  DCHECK(std::find(stack_.begin(), stack_.end(), val) == stack_.end())
+      << "Value already on stack";
+  stack_.push_back(val);
+}
+
+template <typename T>
+T SchedulerUniqueStack<T>::Pop() {
+  DCHECK(!stack_.empty());
+  const T val = stack_.back();
+  stack_.pop_back();
+  return val;
+}
+
+template <typename T>
+void SchedulerUniqueStack<T>::Remove(const T& val) {
+  auto it = std::find(stack_.begin(), stack_.end(), val);
+  if (it != stack_.end())
+    stack_.erase(it);
+}
+
+template <typename T>
+size_t SchedulerUniqueStack<T>::Size() const {
+  return stack_.size();
+}
+
+template <typename T>
+bool SchedulerUniqueStack<T>::Empty() const {
+  return stack_.empty();
+}
+
+}  // namespace internal
+}  // namespace base
+
+#endif  // BASE_TASK_SCHEDULER_SCHEDULER_UNIQUE_STACK_H_