Implementation of SequencedTaskRunner based on SequencedWorkerPool.

base/test/sequenced_task_runner_test_template.cc

+// Copyright (c) 2012 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/test/sequenced_task_runner_test_template.h"
+
+namespace base {
+
+SeqTaskTracker::TaskStatus::TaskStatus()
+    : lock_(),
+      claimed_(false),
+      completed_(false),
+      completed_set_(false),
+      prev_completed_(false),
+      prev_completed_set_(false) {
+}
+
+SeqTaskTracker::TaskStatus::TaskStatus(const TaskStatus& ts)
+    : lock_(),
+      claimed_(ts.claimed_),
+      completed_(ts.completed_),
+      completed_set_(ts.completed_set_),
+      prev_completed_(ts.prev_completed_),
+      prev_completed_set_(ts.prev_completed_set_) {
+}
+
+SeqTaskTracker::TaskStatus& SeqTaskTracker::TaskStatus::operator=(
+    const TaskStatus& ts) {
+  if (&ts == this)
+    return *this;
+  claimed_ = ts.claimed_;
+  completed_ = ts.completed_;
+  prev_completed_ = ts.prev_completed_;
+  completed_set_ = ts.completed_set_;
+  prev_completed_set_ = ts.prev_completed_set_;
+  return *this;
+}
+
+bool SeqTaskTracker::TaskStatus::Claim() {
+  AutoLock lock(lock_);
+  if (claimed_)
+    return false;
+  claimed_ = true;
+  return true;
+}
+
+bool SeqTaskTracker::TaskStatus::Completed() const {
+  AutoLock lock(lock_);
+  return completed_;
+}
+
+// Only called after the run has completed, so locking is not required.
+bool SeqTaskTracker::TaskStatus::PrevCompletedBefore() const {
+  return prev_completed_;
+}
+
+void SeqTaskTracker::TaskStatus::SetCompleted() {
+  AutoLock lock(lock_);
+  CHECK(!completed_set_);
+  completed_ = true;
+  completed_set_ = true;
+}
+
+void SeqTaskTracker::TaskStatus::SetPrevCompletedBefore(const bool b) {
+  AutoLock lock(lock_);
+  CHECK(!prev_completed_set_);
+  prev_completed_ = b;
+  prev_completed_set_ = true;
+}
+
+bool SeqTaskTracker::TaskStatus::operator==(const TaskStatus& ts) const {
+  return (Completed() == ts.Completed() &&
+          PrevCompletedBefore() == ts.PrevCompletedBefore());
+}
+
+std::ostream& operator<<(std::ostream& os,
+                         const SeqTaskTracker::TaskStatus& ts) {
+  return os << "completed=" << std::boolalpha << ts.Completed()
+            << "; prev_completed_before=" << ts.PrevCompletedBefore();
+}
+
+SeqTaskTracker::SeqTaskTracker() {
+}
+
+SeqTaskTracker::~SeqTaskTracker() {
+}
+
+void SeqTaskTracker::SetNonNestableTaskCount(
+    const std::size_t task_count) {
+  non_nestable_statuses_.resize(task_count);
+}
+
+void SeqTaskTracker::SetNestableTaskCount(
+    const std::size_t task_count) {
+  nestable_statuses_.resize(task_count);
+}
+
+void SeqTaskTracker::FastNonNestableTask(int base_status_i) {
+  const int i = ClaimNonNestableTaskStatus(base_status_i);
+  DLOG(INFO) << "XXX FastNonNestableTask " << i << " STARTING";
+  non_nestable_statuses_[i].SetPrevCompletedBefore(
+      i > 0 ? non_nestable_statuses_[i - 1].Completed() : true);
+  non_nestable_statuses_[i].SetCompleted();
+  DLOG(INFO) << "XXX FastNonNestableTask " << i << " DONE";
+}
+
+void SeqTaskTracker::FastNestableTask(int base_status_i) {
+  const int i = ClaimNestableTaskStatus(base_status_i);
+  DLOG(INFO) << "XXX FastNestableTask " << i << " STARTING";
+  nestable_statuses_[i].SetPrevCompletedBefore(true);
+  nestable_statuses_[i].SetCompleted();
+  DLOG(INFO) << "XXX FastNestableTask " << i << " DONE";
+}
+
+void SeqTaskTracker::SlowNonNestableTask(int base_status_i) {
+  const int i = ClaimNonNestableTaskStatus(base_status_i);
+  DLOG(INFO) << "XXX SlowNonNestableTask " << i << " STARTING";
+  non_nestable_statuses_[i].SetPrevCompletedBefore(
+      i > 0 ? non_nestable_statuses_[i - 1].Completed() : true);
+  base::PlatformThread::Sleep(base::TimeDelta::FromSeconds(1));
+  non_nestable_statuses_[i].SetCompleted();
+  DLOG(INFO) << "XXX SlowNonNestableTask " << i << " DONE";
+}
+
+void SeqTaskTracker::PostFastNonNestableFromSlowNonNestable(
+    scoped_refptr<SequencedTaskRunner> tr,
+    const int base_status_i,
+    const int child_count) {
+
+  const int i = ClaimNonNestableTaskStatus(base_status_i);
+
+  DLOG(INFO) << "XXX PostFastNonNestableFromSlowNonNestable "
+             << i << " STARTING";
+
+  non_nestable_statuses_[i].SetPrevCompletedBefore(
+      i > 0 ? non_nestable_statuses_[i - 1].Completed() : true);
+
+  for (int j = 0; j < child_count; ++j) {
+    Closure task = Bind(&SeqTaskTracker::FastNonNestableTask, this, i);
+    tr->PostNonNestableTask(FROM_HERE, task);
+    DLOG(INFO) << "XXX PostFastNonNestableFromSlowNonNestable "
+               << i << " POSTED CHILD TASK " << (i + j);
+  }
+  non_nestable_statuses_[i].SetCompleted();
+
+  DLOG(INFO) << "XXX PostFastNonNestableFromSlowNonNestable " << i << " DONE";
+}
+
+void SeqTaskTracker::PostFastNestableFromSlowNonNestable(
+    scoped_refptr<SequencedTaskRunner> tr,
+    const int base_status_i,
+    const int child_count) {
+
+  const int i = ClaimNonNestableTaskStatus(base_status_i);
+
+  DLOG(INFO) << "XXX PostNestableFromSlowNonNestable " << i << " STARTING";
+
+  non_nestable_statuses_[i].SetPrevCompletedBefore(
+      i > 0 ? non_nestable_statuses_[i - 1].Completed() : true);
+
+  for (int j = 0; j < child_count; ++j) {
+    const int child_i = i * child_count + j;
+    Closure task = Bind(&SeqTaskTracker::FastNestableTask,
+                        this,
+                        child_i);
+    DLOG(INFO) << "XXX PostNestableFromSlowNonNestable " << i
+               << " POSTED CHILD " << child_i ;
+    tr->PostTask(FROM_HERE, task);
+  }
+  non_nestable_statuses_[i].SetCompleted();
+  DLOG(INFO) << "XXX PostNestableFromSlowNonNestable " << i << " DONE";
+}
+
+int SeqTaskTracker::ClaimNonNestableTaskStatus(const int search_from) {
+  const int end = static_cast<int>(non_nestable_statuses_.size());
+  for (int i = search_from; i < end; ++i) {
+    if (non_nestable_statuses_[i].Claim())
+      return i;
+  }
+  CHECK(false) << "Unable to find an unclaimed non-nestable task status slot";
+  return -1;
+}
+
+int SeqTaskTracker::ClaimNestableTaskStatus(const int search_from) {
+  const int end = static_cast<int>(nestable_statuses_.size());
+  for (int i = search_from; i < end; ++i) {
+    if (nestable_statuses_[i].Claim())
+      return i;
+  }
+  CHECK(false) << "Unable to find an unclaimed nestable task status slot";
+  return -1;
+}
+
+const SeqTaskTracker::TaskStatuses& SeqTaskTracker::GetNonNestableTaskStatuses(
+) const {
+  return non_nestable_statuses_;
+}
+
+const SeqTaskTracker::TaskStatuses& SeqTaskTracker::GetNestableTaskStatuses(
+) const {
+  return nestable_statuses_;
+}
+
+}  // namespace base