Add support to base::Timer for custom task runners.

base/timer/timer_unittest.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/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
+#include "base/test/test_simple_task_runner.h"
 #include "base/timer/timer.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::TimeDelta;
+using base::SingleThreadTaskRunner;
 
 namespace {
 
 // The message loops on which each timer should be tested.
 const base::MessageLoop::Type testing_message_loops[] = {
   base::MessageLoop::TYPE_DEFAULT,
   base::MessageLoop::TYPE_IO,
 #if !defined(OS_IOS)  // iOS does not allow direct running of the UI loop.
   base::MessageLoop::TYPE_UI,
 #endif
 };
 
 const int kNumTestingMessageLoops = arraysize(testing_message_loops);
 
 class OneShotTimerTester {
  public:
   explicit OneShotTimerTester(bool* did_run, unsigned milliseconds = 10)
       : did_run_(did_run),
-        delay_ms_(milliseconds) {
+        delay_ms_(milliseconds),
+        quit_message_loop_(true) {
   }
   void Start() {
     timer_.Start(FROM_HERE, TimeDelta::FromMilliseconds(delay_ms_), this,
                  &OneShotTimerTester::Run);
   }
+  void SetTaskRunner(scoped_refptr<SingleThreadTaskRunner> task_runner) {
+    quit_message_loop_ = false;
+    timer_.SetTaskRunner(task_runner);
+  }
  private:
   void Run() {
     *did_run_ = true;
-    base::MessageLoop::current()->QuitWhenIdle();
+    if (quit_message_loop_) {
+      base::MessageLoop::current()->QuitWhenIdle();
+    }
   }
   bool* did_run_;
   base::OneShotTimer<OneShotTimerTester> timer_;
   const unsigned delay_ms_;
+  bool quit_message_loop_;
 };
 
 class OneShotSelfDeletingTimerTester {
  public:
   explicit OneShotSelfDeletingTimerTester(bool* did_run) :
       did_run_(did_run),
       timer_(new base::OneShotTimer<OneShotSelfDeletingTimerTester>()) {
   }
   void Start() {
     timer_->Start(FROM_HERE, TimeDelta::FromMilliseconds(10), this,
@@ skipping 72 matching lines @@
 
   bool did_run = false;
   OneShotSelfDeletingTimerTester f(&did_run);
   f.Start();
 
   base::MessageLoop::current()->Run();
 
   EXPECT_TRUE(did_run);
 }
 
+void RunTest_OneShotTimer_CustomTaskRunner(
+    base::MessageLoop::Type message_loop_type) {
+  base::MessageLoop loop(message_loop_type);
+  scoped_refptr<base::TestSimpleTaskRunner> task_runner =
+      new base::TestSimpleTaskRunner();
+
+  // Create three timers. While the second one uses the message loop (default
+  // behavior), the first and third one use the task runner.
+  bool did_run1 = false;
+  bool did_run2 = false;
+  bool did_run3 = false;
+  OneShotTimerTester f1(&did_run1);
+  OneShotTimerTester f2(&did_run2);
+  OneShotTimerTester f3(&did_run3);
+  f1.SetTaskRunner(task_runner);
+  f3.SetTaskRunner(task_runner);
+
+  // Start the first and second timer and run the task runner. Only the first
+  // timer should go off.
+  f1.Start();

[danakj, 2014/10/16 17:14:59]

I think this test could be a bit more simple and also comprehensive. I'd picture
something like

f1.Start();
current()->Run();
// The timer task didn't run yet, it was not posted to the current loop.
EXPECT_FALSE(..)

task_runner->Run();
// The timer task ran now.
EXPECT_TRUE(..)

I'm not sure what the f2 and f3 in this test are testing? Are you checking for
ordering? I don't see anything about ordering in this CL?

[petrcermak, 2014/10/17 15:43:15]

My point was to check that the main loop and the task runner run their timers
independently (i.e. that running the main loop doesn't trigger timers on other
task runners and vice versa). If you think that this is unnecessary, I will
change it as you suggested.

[danakj, 2014/10/18 18:59:59]

I think you just need to test where the task gets posted to, not that the two
message loops act independently. That's a test for the MessageLoop class.

[petrcermak, 2014/10/20 12:42:41]

Done.

+  f2.Start();
+  task_runner->RunUntilIdle();
+
+  EXPECT_TRUE(did_run1);
+  EXPECT_FALSE(did_run2);
+  EXPECT_FALSE(did_run3);
+  did_run1 = false;
+
+  // Start the third timer and run the message loop. The second timer should
+  // go off this time.
+  f3.Start();
+  base::MessageLoop::current()->Run();
+
+  EXPECT_FALSE(did_run1);
+  EXPECT_TRUE(did_run2);
+  EXPECT_FALSE(did_run3);
+  did_run2 = false;
+
+  // Run the task runner again. Finally, the third timer should go off.
+  task_runner->RunUntilIdle();
+
+  EXPECT_FALSE(did_run1);
+  EXPECT_FALSE(did_run2);
+  EXPECT_TRUE(did_run3);
+}
+
 void RunTest_RepeatingTimer(base::MessageLoop::Type message_loop_type,
                             const TimeDelta& delay) {
   base::MessageLoop loop(message_loop_type);
 
   bool did_run = false;
   RepeatingTimerTester f(&did_run, delay);
   f.Start();
 
   base::MessageLoop::current()->Run();
 
@@ skipping 158 matching lines @@
 }
 
 // If underline timer does not handle properly, we will crash or fail
 // in full page heap environment.
 TEST(TimerTest, OneShotSelfDeletingTimer) {
   for (int i = 0; i < kNumTestingMessageLoops; i++) {
     RunTest_OneShotSelfDeletingTimer(testing_message_loops[i]);
   }
 }
 
+TEST(TimerTest, RunTest_OneShotTimer_CustomTaskRunner) {

[Avi (use Gerrit), 2014/10/16 18:02:55]

Drop "RunTest_" from the test name.

[petrcermak, 2014/10/17 15:43:15]

Done.

+  for (int i = 0; i < kNumTestingMessageLoops; i++) {

[Avi (use Gerrit), 2014/10/16 18:02:55]

Completely optional, but we have for ( : ) now if you want to use it here and
elsewhere.

[petrcermak, 2014/10/17 15:43:15]

Acknowledged. I kept the original for loop for consistency within the file.

+    RunTest_OneShotTimer_CustomTaskRunner(testing_message_loops[i]);
+  }
+}
+
 TEST(TimerTest, RepeatingTimer) {
   for (int i = 0; i < kNumTestingMessageLoops; i++) {
     RunTest_RepeatingTimer(testing_message_loops[i],
                            TimeDelta::FromMilliseconds(10));
   }
 }
 
 TEST(TimerTest, RepeatingTimer_Cancel) {
   for (int i = 0; i < kNumTestingMessageLoops; i++) {
     RunTest_RepeatingTimer_Cancel(testing_message_loops[i],
@@ skipping 176 matching lines @@
                 base::Bind(&SetCallbackHappened1));
     timer.Reset();
     // Since Reset happened before task ran, the user_task must not be cleared:
     ASSERT_FALSE(timer.user_task().is_null());
     base::MessageLoop::current()->Run();
     EXPECT_TRUE(g_callback_happened1);
   }
 }
 
 }  // namespace