Fix cases where RunLoop is created without a MessageLoop.

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/timer/timer.h"
 
 #include <stddef.h>
 
 #include <memory>
 
@@ skipping 36 matching lines @@
  public:
   Receiver() : count_(0) {}
   void OnCalled() { count_++; }
   bool WasCalled() { return count_ > 0; }
   int TimesCalled() { return count_; }
 
  private:
   int count_;
 };
 
-class OneShotTimerTester {
+// A basic helper class that can start a one-shot timer and signal a
+// WaitableEvent when this timer fires.
+class OneShotTimerTesterBase {
+ public:
+  // |did_run|, if provided, will be signaled when Run() fires.
+  explicit OneShotTimerTesterBase(
+      WaitableEvent* did_run = nullptr,
+      const TimeDelta& delay = TimeDelta::FromMilliseconds(10))
+      : did_run_(did_run), delay_(delay) {}
+
+  virtual ~OneShotTimerTesterBase() = default;
+
+  void Start() {
+    started_time_ = TimeTicks::Now();
+    timer_->Start(FROM_HERE, delay_, this, &OneShotTimerTesterBase::Run);
+  }
+
+  bool IsRunning() { return timer_->IsRunning(); }
+
+  TimeTicks started_time() const { return started_time_; }
+  TimeDelta delay() const { return delay_; }
+
+ protected:
+  virtual void Run() {
+    if (did_run_) {
+      EXPECT_FALSE(did_run_->IsSignaled());
+      did_run_->Signal();
+    }
+  }
+
+  std::unique_ptr<OneShotTimer> timer_ = MakeUnique<OneShotTimer>();
+
+ private:
+  WaitableEvent* const did_run_;
+  const TimeDelta delay_;
+  TimeTicks started_time_;
+
+  DISALLOW_COPY_AND_ASSIGN(OneShotTimerTesterBase);
+};
+
+// Extends functionality of OneShotTimerTesterBase with the abilities to wait
+// until the timer fires and to change task runner for the timer.
+class OneShotTimerTester : public OneShotTimerTesterBase {
  public:
   // |did_run|, if provided, will be signaled when Run() fires.
   explicit OneShotTimerTester(
       WaitableEvent* did_run = nullptr,
       const TimeDelta& delay = TimeDelta::FromMilliseconds(10))
-      : quit_closure_(run_loop_.QuitClosure()),
-        did_run_(did_run),
-        delay_(delay) {}
+      : OneShotTimerTesterBase(did_run, delay),
+        quit_closure_(run_loop_.QuitClosure()) {}
 
-  virtual ~OneShotTimerTester() = default;
+  ~OneShotTimerTester() override = default;
 
   void SetTaskRunner(scoped_refptr<SingleThreadTaskRunner> task_runner) {
     timer_->SetTaskRunner(std::move(task_runner));
 
     // Run() will be invoked on |task_runner| but |run_loop_|'s QuitClosure
     // needs to run on this thread (where the MessageLoop lives).
     quit_closure_ =
         Bind(IgnoreResult(&SingleThreadTaskRunner::PostTask),
              ThreadTaskRunnerHandle::Get(), FROM_HERE, run_loop_.QuitClosure());
   }
 
-  void Start() {
-    started_time_ = TimeTicks::Now();
-    timer_->Start(FROM_HERE, delay_, this, &OneShotTimerTester::Run);
-  }
-
   // Blocks until Run() executes and confirms that Run() didn't fire before
   // |delay_| expired.
   void WaitAndConfirmTimerFiredAfterDelay() {
     run_loop_.Run();
 
-    EXPECT_NE(TimeTicks(), started_time_);
-    EXPECT_GE(TimeTicks::Now() - started_time_, delay_);
+    EXPECT_NE(TimeTicks(), started_time());
+    EXPECT_GE(TimeTicks::Now() - started_time(), delay());
   }
 
-  bool IsRunning() { return timer_->IsRunning(); }
-
  protected:
   // Overridable method to do things on Run() before signaling events/closures
   // managed by this helper.
   virtual void OnRun() {}
 
-  std::unique_ptr<OneShotTimer> timer_ = MakeUnique<OneShotTimer>();
-
  private:
-  void Run() {
+  void Run() override {
     OnRun();
-    if (did_run_) {
-      EXPECT_FALSE(did_run_->IsSignaled());
-      did_run_->Signal();
-    }
+    OneShotTimerTesterBase::Run();
     quit_closure_.Run();
   }
 
   RunLoop run_loop_;
   Closure quit_closure_;
-  WaitableEvent* const did_run_;
-
-  const TimeDelta delay_;
-  TimeTicks started_time_;
 
   DISALLOW_COPY_AND_ASSIGN(OneShotTimerTester);
 };
 
 class OneShotSelfDeletingTimerTester : public OneShotTimerTester {
  protected:
   void OnRun() override { timer_.reset(); }
 };
 
 constexpr int kNumRepeats = 10;
@@ skipping 382 matching lines @@
 }
 
 TEST(TimerTest, MessageLoopShutdown) {
   // This test is designed to verify that shutdown of the
   // message loop does not cause crashes if there were pending
   // timers not yet fired.  It may only trigger exceptions
   // if debug heap checking is enabled.
   WaitableEvent did_run(WaitableEvent::ResetPolicy::MANUAL,
                         WaitableEvent::InitialState::NOT_SIGNALED);
   {
-    OneShotTimerTester a(&did_run);
-    OneShotTimerTester b(&did_run);
-    OneShotTimerTester c(&did_run);
-    OneShotTimerTester d(&did_run);
+    OneShotTimerTesterBase a(&did_run);
+    OneShotTimerTesterBase b(&did_run);
+    OneShotTimerTesterBase c(&did_run);
+    OneShotTimerTesterBase d(&did_run);
     {
       MessageLoop loop;
       a.Start();
       b.Start();
     }  // MessageLoop destructs by falling out of scope.
   }  // OneShotTimers destruct.  SHOULD NOT CRASH, of course.
 
   EXPECT_FALSE(did_run.IsSignaled());
 }
 
@@ skipping 111 matching lines @@
                 Bind(&SetCallbackHappened1));
     timer.Reset();
     // Since Reset happened before task ran, the user_task must not be cleared:
     ASSERT_FALSE(timer.user_task().is_null());
     RunLoop().Run();
     EXPECT_TRUE(g_callback_happened1);
   }
 }
 
 }  // namespace base