Revert of Delete unused TaskRunner abstraction.

webrtc/base/task_unittest.cc

+/*
+ *  Copyright 2004 The WebRTC Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#if defined(WEBRTC_POSIX)
+#include <sys/time.h>
+#endif  // WEBRTC_POSIX
+
+// TODO: Remove this once the cause of sporadic failures in these
+// tests is tracked down.
+#include <iostream>
+
+#if defined(WEBRTC_WIN)
+#include "webrtc/base/win32.h"
+#endif  // WEBRTC_WIN
+
+#include "webrtc/base/arraysize.h"
+#include "webrtc/base/constructormagic.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/task.h"
+#include "webrtc/base/taskrunner.h"
+#include "webrtc/base/thread.h"
+#include "webrtc/base/timeutils.h"
+
+namespace rtc {
+
+static int64_t GetCurrentTime() {
+  return TimeMillis() * 10000;
+}
+
+// feel free to change these numbers.  Note that '0' won't work, though
+#define STUCK_TASK_COUNT 5
+#define HAPPY_TASK_COUNT 20
+
+// this is a generic timeout task which, when it signals timeout, will
+// include the unique ID of the task in the signal (we don't use this
+// in production code because we haven't yet had occasion to generate
+// an array of the same types of task)
+
+class IdTimeoutTask : public Task, public sigslot::has_slots<> {
+ public:
+  explicit IdTimeoutTask(TaskParent *parent) : Task(parent) {
+    SignalTimeout.connect(this, &IdTimeoutTask::OnLocalTimeout);
+  }
+
+  sigslot::signal1<const int> SignalTimeoutId;
+  sigslot::signal1<const int> SignalDoneId;
+
+  virtual int ProcessStart() {
+    return STATE_RESPONSE;
+  }
+
+  void OnLocalTimeout() {
+    SignalTimeoutId(unique_id());
+  }
+
+ protected:
+  virtual void Stop() {
+    SignalDoneId(unique_id());
+    Task::Stop();
+  }
+};
+
+class StuckTask : public IdTimeoutTask {
+ public:
+  explicit StuckTask(TaskParent *parent) : IdTimeoutTask(parent) {}
+  virtual int ProcessStart() {
+    return STATE_BLOCKED;
+  }
+};
+
+class HappyTask : public IdTimeoutTask {
+ public:
+  explicit HappyTask(TaskParent *parent) : IdTimeoutTask(parent) {
+    time_to_perform_ = rand() % (STUCK_TASK_COUNT / 2);
+  }
+  virtual int ProcessStart() {
+    if (ElapsedTime() > (time_to_perform_ * 1000 * 10000))
+      return STATE_RESPONSE;
+    else
+      return STATE_BLOCKED;
+  }
+
+ private:
+  int time_to_perform_;
+};
+
+// simple implementation of a task runner which uses Windows'
+// GetSystemTimeAsFileTime() to get the current clock ticks
+
+class MyTaskRunner : public TaskRunner {
+ public:
+  virtual void WakeTasks() { RunTasks(); }
+  virtual int64_t CurrentTime() { return GetCurrentTime(); }
+
+  bool timeout_change() const {
+    return timeout_change_;
+  }
+
+  void clear_timeout_change() {
+    timeout_change_ = false;
+  }
+ protected:
+  virtual void OnTimeoutChange() {
+    timeout_change_ = true;
+  }
+  bool timeout_change_;
+};
+
+//
+// this unit test is primarily concerned (for now) with the timeout
+// functionality in tasks.  It works as follows:
+//
+//   * Create a bunch of tasks, some "stuck" (ie., guaranteed to timeout)
+//     and some "happy" (will immediately finish).
+//   * Set the timeout on the "stuck" tasks to some number of seconds between
+//     1 and the number of stuck tasks
+//   * Start all the stuck & happy tasks in random order
+//   * Wait "number of stuck tasks" seconds and make sure everything timed out
+
+class TaskTest : public sigslot::has_slots<> {
+ public:
+  TaskTest() {}
+
+  // no need to delete any tasks; the task runner owns them
+  ~TaskTest() {}
+
+  void Start() {
+    // create and configure tasks
+    for (int i = 0; i < STUCK_TASK_COUNT; ++i) {
+      stuck_[i].task_ = new StuckTask(&task_runner_);
+      stuck_[i].task_->SignalTimeoutId.connect(this,
+                                               &TaskTest::OnTimeoutStuck);
+      stuck_[i].timed_out_ = false;
+      stuck_[i].xlat_ = stuck_[i].task_->unique_id();
+      stuck_[i].task_->set_timeout_seconds(i + 1);
+      LOG(LS_INFO) << "Task " << stuck_[i].xlat_ << " created with timeout "
+                   << stuck_[i].task_->timeout_seconds();
+    }
+
+    for (int i = 0; i < HAPPY_TASK_COUNT; ++i) {
+      happy_[i].task_ = new HappyTask(&task_runner_);
+      happy_[i].task_->SignalTimeoutId.connect(this,
+                                               &TaskTest::OnTimeoutHappy);
+      happy_[i].task_->SignalDoneId.connect(this,
+                                            &TaskTest::OnDoneHappy);
+      happy_[i].timed_out_ = false;
+      happy_[i].xlat_ = happy_[i].task_->unique_id();
+    }
+
+    // start all the tasks in random order
+    int stuck_index = 0;
+    int happy_index = 0;
+    for (int i = 0; i < STUCK_TASK_COUNT + HAPPY_TASK_COUNT; ++i) {
+      if ((stuck_index < STUCK_TASK_COUNT) &&
+          (happy_index < HAPPY_TASK_COUNT)) {
+        if (rand() % 2 == 1) {
+          stuck_[stuck_index++].task_->Start();
+        } else {
+          happy_[happy_index++].task_->Start();
+        }
+      } else if (stuck_index < STUCK_TASK_COUNT) {
+        stuck_[stuck_index++].task_->Start();
+      } else {
+        happy_[happy_index++].task_->Start();
+      }
+    }
+
+    for (int i = 0; i < STUCK_TASK_COUNT; ++i) {
+      std::cout << "Stuck task #" << i << " timeout is " <<
+          stuck_[i].task_->timeout_seconds() << " at " <<
+          stuck_[i].task_->timeout_time() << std::endl;
+    }
+
+    // just a little self-check to make sure we started all the tasks
+    ASSERT_EQ(STUCK_TASK_COUNT, stuck_index);
+    ASSERT_EQ(HAPPY_TASK_COUNT, happy_index);
+
+    // run the unblocked tasks
+    LOG(LS_INFO) << "Running tasks";
+    task_runner_.RunTasks();
+
+    std::cout << "Start time is " << GetCurrentTime() << std::endl;
+
+    // give all the stuck tasks time to timeout
+    for (int i = 0; !task_runner_.AllChildrenDone() && i < STUCK_TASK_COUNT;
+         ++i) {
+      Thread::Current()->ProcessMessages(1000);
+      for (int j = 0; j < HAPPY_TASK_COUNT; ++j) {
+        if (happy_[j].task_) {
+          happy_[j].task_->Wake();
+        }
+      }
+      LOG(LS_INFO) << "Polling tasks";
+      task_runner_.PollTasks();
+    }
+
+    // We see occasional test failures here due to the stuck tasks not having
+    // timed-out yet, which seems like it should be impossible. To help track
+    // this down we have added logging of the timing information, which we send
+    // directly to stdout so that we get it in opt builds too.
+    std::cout << "End time is " << GetCurrentTime() << std::endl;
+  }
+
+  void OnTimeoutStuck(const int id) {
+    LOG(LS_INFO) << "Timed out task " << id;
+
+    int i;
+    for (i = 0; i < STUCK_TASK_COUNT; ++i) {
+      if (stuck_[i].xlat_ == id) {
+        stuck_[i].timed_out_ = true;
+        stuck_[i].task_ = NULL;
+        break;
+      }
+    }
+
+    // getting a bad ID here is a failure, but let's continue
+    // running to see what else might go wrong
+    EXPECT_LT(i, STUCK_TASK_COUNT);
+  }
+
+  void OnTimeoutHappy(const int id) {
+    int i;
+    for (i = 0; i < HAPPY_TASK_COUNT; ++i) {
+      if (happy_[i].xlat_ == id) {
+        happy_[i].timed_out_ = true;
+        happy_[i].task_ = NULL;
+        break;
+      }
+    }
+
+    // getting a bad ID here is a failure, but let's continue
+    // running to see what else might go wrong
+    EXPECT_LT(i, HAPPY_TASK_COUNT);
+  }
+
+  void OnDoneHappy(const int id) {
+    int i;
+    for (i = 0; i < HAPPY_TASK_COUNT; ++i) {
+      if (happy_[i].xlat_ == id) {
+        happy_[i].task_ = NULL;
+        break;
+      }
+    }
+
+    // getting a bad ID here is a failure, but let's continue
+    // running to see what else might go wrong
+    EXPECT_LT(i, HAPPY_TASK_COUNT);
+  }
+
+  void check_passed() {
+    EXPECT_TRUE(task_runner_.AllChildrenDone());
+
+    // make sure none of our happy tasks timed out
+    for (int i = 0; i < HAPPY_TASK_COUNT; ++i) {
+      EXPECT_FALSE(happy_[i].timed_out_);
+    }
+
+    // make sure all of our stuck tasks timed out
+    for (int i = 0; i < STUCK_TASK_COUNT; ++i) {
+      EXPECT_TRUE(stuck_[i].timed_out_);
+      if (!stuck_[i].timed_out_) {
+        std::cout << "Stuck task #" << i << " timeout is at "
+                  << stuck_[i].task_->timeout_time() << std::endl;
+      }
+    }
+
+    std::cout.flush();
+  }
+
+ private:
+  struct TaskInfo {
+    IdTimeoutTask *task_;
+    bool timed_out_;
+    int xlat_;
+  };
+
+  MyTaskRunner task_runner_;
+  TaskInfo stuck_[STUCK_TASK_COUNT];
+  TaskInfo happy_[HAPPY_TASK_COUNT];
+};
+
+TEST(start_task_test, Timeout) {
+  TaskTest task_test;
+  task_test.Start();
+  task_test.check_passed();
+}
+
+// Test for aborting the task while it is running
+
+class AbortTask : public Task {
+ public:
+  explicit AbortTask(TaskParent *parent) : Task(parent) {
+    set_timeout_seconds(1);
+  }
+
+  virtual int ProcessStart() {
+    Abort();
+    return STATE_NEXT;
+  }
+ private:
+  RTC_DISALLOW_COPY_AND_ASSIGN(AbortTask);
+};
+
+class TaskAbortTest : public sigslot::has_slots<> {
+ public:
+  TaskAbortTest() {}
+
+  // no need to delete any tasks; the task runner owns them
+  ~TaskAbortTest() {}
+
+  void Start() {
+    Task *abort_task = new AbortTask(&task_runner_);
+    abort_task->SignalTimeout.connect(this, &TaskAbortTest::OnTimeout);
+    abort_task->Start();
+
+    // run the task
+    task_runner_.RunTasks();
+  }
+
+ private:
+  void OnTimeout() {
+    FAIL() << "Task timed out instead of aborting.";
+  }
+
+  MyTaskRunner task_runner_;
+  RTC_DISALLOW_COPY_AND_ASSIGN(TaskAbortTest);
+};
+
+TEST(start_task_test, Abort) {
+  TaskAbortTest abort_test;
+  abort_test.Start();
+}
+
+// Test for aborting a task to verify that it does the Wake operation
+// which gets it deleted.
+
+class SetBoolOnDeleteTask : public Task {
+ public:
+  SetBoolOnDeleteTask(TaskParent *parent, bool *set_when_deleted)
+    : Task(parent),
+      set_when_deleted_(set_when_deleted) {
+    EXPECT_TRUE(NULL != set_when_deleted);
+    EXPECT_FALSE(*set_when_deleted);
+  }
+
+  virtual ~SetBoolOnDeleteTask() {
+    *set_when_deleted_ = true;
+  }
+
+  virtual int ProcessStart() {
+    return STATE_BLOCKED;
+  }
+
+ private:
+  bool* set_when_deleted_;
+  RTC_DISALLOW_COPY_AND_ASSIGN(SetBoolOnDeleteTask);
+};
+
+class AbortShouldWakeTest : public sigslot::has_slots<> {
+ public:
+  AbortShouldWakeTest() {}
+
+  // no need to delete any tasks; the task runner owns them
+  ~AbortShouldWakeTest() {}
+
+  void Start() {
+    bool task_deleted = false;
+    Task *task_to_abort = new SetBoolOnDeleteTask(&task_runner_, &task_deleted);
+    task_to_abort->Start();
+
+    // Task::Abort() should call TaskRunner::WakeTasks(). WakeTasks calls
+    // TaskRunner::RunTasks() immediately which should delete the task.
+    task_to_abort->Abort();
+    EXPECT_TRUE(task_deleted);
+
+    if (!task_deleted) {
+      // avoid a crash (due to referencing a local variable)
+      // if the test fails.
+      task_runner_.RunTasks();
+    }
+  }
+
+ private:
+  void OnTimeout() {
+    FAIL() << "Task timed out instead of aborting.";
+  }
+
+  MyTaskRunner task_runner_;
+  RTC_DISALLOW_COPY_AND_ASSIGN(AbortShouldWakeTest);
+};
+
+TEST(start_task_test, AbortShouldWake) {
+  AbortShouldWakeTest abort_should_wake_test;
+  abort_should_wake_test.Start();
+}
+
+// Validate that TaskRunner's OnTimeoutChange gets called appropriately
+//  * When a task calls UpdateTaskTimeout
+//  * When the next timeout task time, times out
+class TimeoutChangeTest : public sigslot::has_slots<> {
+ public:
+  TimeoutChangeTest()
+    : task_count_(arraysize(stuck_tasks_)) {}
+
+  // no need to delete any tasks; the task runner owns them
+  ~TimeoutChangeTest() {}
+
+  void Start() {
+    for (int i = 0; i < task_count_; ++i) {
+      stuck_tasks_[i] = new StuckTask(&task_runner_);
+      stuck_tasks_[i]->set_timeout_seconds(i + 2);
+      stuck_tasks_[i]->SignalTimeoutId.connect(this,
+                                               &TimeoutChangeTest::OnTimeoutId);
+    }
+
+    for (int i = task_count_ - 1; i >= 0; --i) {
+      stuck_tasks_[i]->Start();
+    }
+    task_runner_.clear_timeout_change();
+
+    // At this point, our timeouts are set as follows
+    // task[0] is 2 seconds, task[1] at 3 seconds, etc.
+
+    stuck_tasks_[0]->set_timeout_seconds(2);
+    // Now, task[0] is 2 seconds, task[1] at 3 seconds...
+    // so timeout change shouldn't be called.
+    EXPECT_FALSE(task_runner_.timeout_change());
+    task_runner_.clear_timeout_change();
+
+    stuck_tasks_[0]->set_timeout_seconds(1);
+    // task[0] is 1 seconds, task[1] at 3 seconds...
+    // The smallest timeout got smaller so timeout change be called.
+    EXPECT_TRUE(task_runner_.timeout_change());
+    task_runner_.clear_timeout_change();
+
+    stuck_tasks_[1]->set_timeout_seconds(2);
+    // task[0] is 1 seconds, task[1] at 2 seconds...
+    // The smallest timeout is still 1 second so no timeout change.
+    EXPECT_FALSE(task_runner_.timeout_change());
+    task_runner_.clear_timeout_change();
+
+    while (task_count_ > 0) {
+      int previous_count = task_count_;
+      task_runner_.PollTasks();
+      if (previous_count != task_count_) {
+        // We only get here when a task times out.  When that
+        // happens, the timeout change should get called because
+        // the smallest timeout is now in the past.
+        EXPECT_TRUE(task_runner_.timeout_change());
+        task_runner_.clear_timeout_change();
+      }
+      Thread::Current()->socketserver()->Wait(500, false);
+    }
+  }
+
+ private:
+  void OnTimeoutId(const int id) {
+    for (size_t i = 0; i < arraysize(stuck_tasks_); ++i) {
+      if (stuck_tasks_[i] && stuck_tasks_[i]->unique_id() == id) {
+        task_count_--;
+        stuck_tasks_[i] = NULL;
+        break;
+      }
+    }
+  }
+
+  MyTaskRunner task_runner_;
+  StuckTask* (stuck_tasks_[3]);
+  int task_count_;
+  RTC_DISALLOW_COPY_AND_ASSIGN(TimeoutChangeTest);
+};
+
+TEST(start_task_test, TimeoutChange) {
+  TimeoutChangeTest timeout_change_test;
+  timeout_change_test.Start();
+}
+
+class DeleteTestTaskRunner : public TaskRunner {
+ public:
+  DeleteTestTaskRunner() {
+  }
+  virtual void WakeTasks() { }
+  virtual int64_t CurrentTime() { return GetCurrentTime(); }
+ private:
+  RTC_DISALLOW_COPY_AND_ASSIGN(DeleteTestTaskRunner);
+};
+
+TEST(unstarted_task_test, DeleteTask) {
+  // This test ensures that we don't
+  // crash if a task is deleted without running it.
+  DeleteTestTaskRunner task_runner;
+  HappyTask* happy_task = new HappyTask(&task_runner);
+  happy_task->Start();
+
+  // try deleting the task directly
+  HappyTask* child_happy_task = new HappyTask(happy_task);
+  delete child_happy_task;
+
+  // run the unblocked tasks
+  task_runner.RunTasks();
+}
+
+TEST(unstarted_task_test, DoNotDeleteTask1) {
+  // This test ensures that we don't
+  // crash if a task runner is deleted without
+  // running a certain task.
+  DeleteTestTaskRunner task_runner;
+  HappyTask* happy_task = new HappyTask(&task_runner);
+  happy_task->Start();
+
+  HappyTask* child_happy_task = new HappyTask(happy_task);
+  child_happy_task->Start();
+
+  // Never run the tasks
+}
+
+TEST(unstarted_task_test, DoNotDeleteTask2) {
+  // This test ensures that we don't
+  // crash if a taskrunner is delete with a
+  // task that has never been started.
+  DeleteTestTaskRunner task_runner;
+  HappyTask* happy_task = new HappyTask(&task_runner);
+  happy_task->Start();
+
+  // Do not start the task.
+  // Note: this leaks memory, so don't do this.
+  // Instead, always run your tasks or delete them.
+  new HappyTask(happy_task);
+
+  // run the unblocked tasks
+  task_runner.RunTasks();
+}
+
+}  // namespace rtc