Threading: Remove TaskRunnerHandlesNonZeroDelays from TaskRunnerTestDelegate

base/test/sequenced_task_runner_test_template.h

 // 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.
 
 // This class defines tests that implementations of SequencedTaskRunner should
 // pass in order to be conformant. See task_runner_test_template.h for a
 // description of how to use the constructs in this file; these work the same.
 
 #ifndef BASE_SEQUENCED_TASK_RUNNER_TEST_TEMPLATE_H_
 #define BASE_SEQUENCED_TASK_RUNNER_TEST_TEMPLATE_H_
@@ skipping 160 matching lines @@
   this->delegate_.StopTaskRunner();
 
   EXPECT_TRUE(CheckNonNestableInvariants(this->task_tracker_->GetTaskEvents(),
                                          kTaskCount));
 }
 
 // This test posts non-nestable tasks in order of increasing delay, and checks
 // that that the tasks are run in FIFO order and that there is no execution
 // overlap whatsoever between any two tasks.
 TYPED_TEST_P(SequencedTaskRunnerTest, SequentialDelayedNonNestable) {
-  // TODO(akalin): Remove this check (http://crbug.com/149144).
-  if (!this->delegate_.TaskRunnerHandlesNonZeroDelays()) {
-    DLOG(INFO) << "This SequencedTaskRunner doesn't handle "
-        "non-zero delays; skipping";
-    return;
-  }
-
   const int kTaskCount = 20;
   const int kDelayIncrementMs = 50;
 
   this->delegate_.StartTaskRunner();
   const scoped_refptr<SequencedTaskRunner> task_runner =
       this->delegate_.GetTaskRunner();
 
   for (int i = 0; i < kTaskCount; ++i) {
     this->task_tracker_->PostWrappedDelayedNonNestableTask(
         task_runner,
@@ skipping 31 matching lines @@
   this->delegate_.StopTaskRunner();
 
   EXPECT_TRUE(CheckNonNestableInvariants(
       this->task_tracker_->GetTaskEvents(),
       kParentCount * (kChildrenPerParent + 1)));
 }
 
 // This test posts a delayed task, and checks that the task is run later than
 // the specified time.
 TYPED_TEST_P(SequencedTaskRunnerTest, DelayedTaskBasic) {
-  // TODO(akalin): Remove this check (http://crbug.com/149144).
-  if (!this->delegate_.TaskRunnerHandlesNonZeroDelays()) {
-    DLOG(INFO) << "This SequencedTaskRunner doesn't handle "
-        "non-zero delays; skipping";
-    return;
-  }
-
   const int kTaskCount = 1;
   const TimeDelta kDelay = TimeDelta::FromMilliseconds(100);
 
   this->delegate_.StartTaskRunner();
   const scoped_refptr<SequencedTaskRunner> task_runner =
       this->delegate_.GetTaskRunner();
 
   Time time_before_run = Time::Now();
   this->task_tracker_->PostWrappedDelayedNonNestableTask(
       task_runner, Closure(), kDelay);
   this->task_tracker_->WaitForCompletedTasks(kTaskCount);
   this->delegate_.StopTaskRunner();
   Time time_after_run = Time::Now();
 
   EXPECT_TRUE(CheckNonNestableInvariants(this->task_tracker_->GetTaskEvents(),
                                          kTaskCount));
   EXPECT_LE(kDelay, time_after_run - time_before_run);
 }
 
 // This test posts two tasks with the same delay, and checks that the tasks are
 // run in the order in which they were posted.
 //
 // NOTE: This is actually an approximate test since the API only takes a
 // "delay" parameter, so we are not exactly simulating two tasks that get
 // posted at the exact same time. It would be nice if the API allowed us to
 // specify the desired run time.
 TYPED_TEST_P(SequencedTaskRunnerTest, DelayedTasksSameDelay) {
-  // TODO(akalin): Remove this check (http://crbug.com/149144).
-  if (!this->delegate_.TaskRunnerHandlesNonZeroDelays()) {
-    DLOG(INFO) << "This SequencedTaskRunner doesn't handle "
-        "non-zero delays; skipping";
-    return;
-  }
-
   const int kTaskCount = 2;
   const TimeDelta kDelay = TimeDelta::FromMilliseconds(100);
 
   this->delegate_.StartTaskRunner();
   const scoped_refptr<SequencedTaskRunner> task_runner =
       this->delegate_.GetTaskRunner();
 
   this->task_tracker_->PostWrappedDelayedNonNestableTask(
       task_runner, Closure(), kDelay);
   this->task_tracker_->PostWrappedDelayedNonNestableTask(
       task_runner, Closure(), kDelay);
   this->task_tracker_->WaitForCompletedTasks(kTaskCount);
   this->delegate_.StopTaskRunner();
 
   EXPECT_TRUE(CheckNonNestableInvariants(this->task_tracker_->GetTaskEvents(),
                                          kTaskCount));
 }
 
 // This test posts a normal task and a delayed task, and checks that the
 // delayed task runs after the normal task even if the normal task takes
 // a long time to run.
 TYPED_TEST_P(SequencedTaskRunnerTest, DelayedTaskAfterLongTask) {
-  // TODO(akalin): Remove this check (http://crbug.com/149144).
-  if (!this->delegate_.TaskRunnerHandlesNonZeroDelays()) {
-    DLOG(INFO) << "This SequencedTaskRunner doesn't handle "
-        "non-zero delays; skipping";
-    return;
-  }
-
   const int kTaskCount = 2;
 
   this->delegate_.StartTaskRunner();
   const scoped_refptr<SequencedTaskRunner> task_runner =
       this->delegate_.GetTaskRunner();
 
   this->task_tracker_->PostWrappedNonNestableTask(
       task_runner, base::Bind(&PlatformThread::Sleep,
                               TimeDelta::FromMilliseconds(50)));
   this->task_tracker_->PostWrappedDelayedNonNestableTask(
       task_runner, Closure(), TimeDelta::FromMilliseconds(10));
   this->task_tracker_->WaitForCompletedTasks(kTaskCount);
   this->delegate_.StopTaskRunner();
 
   EXPECT_TRUE(CheckNonNestableInvariants(this->task_tracker_->GetTaskEvents(),
                                          kTaskCount));
 }
 
 // Test that a pile of normal tasks and a delayed task run in the
 // time-to-run order.
 TYPED_TEST_P(SequencedTaskRunnerTest, DelayedTaskAfterManyLongTasks) {
-  // TODO(akalin): Remove this check (http://crbug.com/149144).
-  if (!this->delegate_.TaskRunnerHandlesNonZeroDelays()) {
-    DLOG(INFO) << "This SequencedTaskRunner doesn't handle "
-        "non-zero delays; skipping";
-    return;
-  }
-
   const int kTaskCount = 11;
 
   this->delegate_.StartTaskRunner();
   const scoped_refptr<SequencedTaskRunner> task_runner =
       this->delegate_.GetTaskRunner();
 
   for (int i = 0; i < kTaskCount - 1; i++) {
     this->task_tracker_->PostWrappedNonNestableTask(
         task_runner, base::Bind(&PlatformThread::Sleep,
                                 TimeDelta::FromMilliseconds(50)));
@@ skipping 20 matching lines @@
                            SequentialDelayedNonNestable,
                            NonNestablePostFromNonNestableTask,
                            DelayedTaskBasic,
                            DelayedTasksSameDelay,
                            DelayedTaskAfterLongTask,
                            DelayedTaskAfterManyLongTasks);
 
 }  // namespace base
 
 #endif  // BASE_TASK_RUNNER_TEST_TEMPLATE_H_