components/timers/alarm_timer_unittest.cc - chromium/src.git - Git at Google

 // Copyright 2014 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 <sys/timerfd.h>

 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/threading/platform_thread.h"
 #include "base/time/time.h"
 #include "components/timers/alarm_timer_chromeos.h"
 #include "testing/gtest/include/gtest/gtest.h"

 // Most of these tests have been lifted right out of timer_unittest.cc with only
 // cosmetic changes (like replacing calls to MessageLoop::current()->Run() with
 // a RunLoop).  We want the AlarmTimer to be a drop-in replacement for the
 // regular Timer so it should pass the same tests as the Timer class.
 //
 // The only new tests are the .*ConcurrentResetAndTimerFired tests, which test
 // that race conditions that can come up in the AlarmTimer::Delegate are
 // properly handled.
 namespace timers {
 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);
 const base::TimeDelta kTenMilliseconds = base::TimeDelta::FromMilliseconds(10);

 class OneShotAlarmTimerTester {
  public:
   OneShotAlarmTimerTester(bool* did_run, base::TimeDelta delay)
       : did_run_(did_run),
         delay_(delay),
         timer_(new timers::OneShotAlarmTimer()) {}
   void Start() {
     timer_->Start(FROM_HERE, delay_, base::Bind(&OneShotAlarmTimerTester::Run,
                                                 base::Unretained(this)));
   }

  private:
   void Run() {
     *did_run_ = true;

     base::MessageLoop::current()->PostTask(
         FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
   }

   bool* did_run_;
   const base::TimeDelta delay_;
   scoped_ptr<timers::OneShotAlarmTimer> timer_;

   DISALLOW_COPY_AND_ASSIGN(OneShotAlarmTimerTester);
 };

 class OneShotSelfDeletingAlarmTimerTester {
  public:
   OneShotSelfDeletingAlarmTimerTester(bool* did_run, base::TimeDelta delay)
       : did_run_(did_run),
         delay_(delay),
         timer_(new timers::OneShotAlarmTimer()) {}
   void Start() {
     timer_->Start(FROM_HERE, delay_,
                   base::Bind(&OneShotSelfDeletingAlarmTimerTester::Run,
                              base::Unretained(this)));
   }

  private:
   void Run() {
     *did_run_ = true;
     timer_.reset();

     base::MessageLoop::current()->PostTask(
         FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
   }

   bool* did_run_;
   const base::TimeDelta delay_;
   scoped_ptr<timers::OneShotAlarmTimer> timer_;

   DISALLOW_COPY_AND_ASSIGN(OneShotSelfDeletingAlarmTimerTester);
 };

 class RepeatingAlarmTimerTester {
  public:
   RepeatingAlarmTimerTester(bool* did_run, base::TimeDelta delay)
       : did_run_(did_run),
         delay_(delay),
         counter_(10),
         timer_(new timers::RepeatingAlarmTimer()) {}
   void Start() {
     timer_->Start(FROM_HERE, delay_, base::Bind(&RepeatingAlarmTimerTester::Run,
                                                 base::Unretained(this)));
   }

  private:
   void Run() {
     if (--counter_ == 0) {
       *did_run_ = true;
       timer_->Stop();

       base::MessageLoop::current()->PostTask(
           FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
     }
   }

   bool* did_run_;
   const base::TimeDelta delay_;
   int counter_;
   scoped_ptr<timers::RepeatingAlarmTimer> timer_;

   DISALLOW_COPY_AND_ASSIGN(RepeatingAlarmTimerTester);
 };

 }  // namespace

 //-----------------------------------------------------------------------------
 // Each test is run against each type of MessageLoop.  That way we are sure
 // that timers work properly in all configurations.

 TEST(AlarmTimerTest, OneShotAlarmTimer) {
   for (int i = 0; i < kNumTestingMessageLoops; i++) {
     base::MessageLoop loop(testing_message_loops[i]);

     bool did_run = false;
     OneShotAlarmTimerTester f(&did_run, kTenMilliseconds);
     f.Start();

     base::RunLoop().Run();

     EXPECT_TRUE(did_run);
   }
 }

 TEST(AlarmTimerTest, OneShotAlarmTimer_Cancel) {
   for (int i = 0; i < kNumTestingMessageLoops; i++) {
     base::MessageLoop loop(testing_message_loops[i]);

     bool did_run_a = false;
     OneShotAlarmTimerTester* a =
         new OneShotAlarmTimerTester(&did_run_a, kTenMilliseconds);

     // This should run before the timer expires.
     base::MessageLoop::current()->DeleteSoon(FROM_HERE, a);

     // Now start the timer.
     a->Start();

     bool did_run_b = false;
     OneShotAlarmTimerTester b(&did_run_b, kTenMilliseconds);
     b.Start();

     base::RunLoop().Run();

     EXPECT_FALSE(did_run_a);
     EXPECT_TRUE(did_run_b);
   }
 }

 // If underlying timer does not handle this properly, we will crash or fail
 // in full page heap environment.
 TEST(AlarmTimerTest, OneShotSelfDeletingAlarmTimer) {
   for (int i = 0; i < kNumTestingMessageLoops; i++) {
     base::MessageLoop loop(testing_message_loops[i]);

     bool did_run = false;
     OneShotSelfDeletingAlarmTimerTester f(&did_run, kTenMilliseconds);
     f.Start();

     base::RunLoop().Run();

     EXPECT_TRUE(did_run);
   }
 }

 TEST(AlarmTimerTest, RepeatingAlarmTimer) {
   for (int i = 0; i < kNumTestingMessageLoops; i++) {
     base::MessageLoop loop(testing_message_loops[i]);

     bool did_run = false;
     RepeatingAlarmTimerTester f(&did_run, kTenMilliseconds);
     f.Start();

     base::RunLoop().Run();

     EXPECT_TRUE(did_run);
   }
 }

 TEST(AlarmTimerTest, RepeatingAlarmTimer_Cancel) {
   for (int i = 0; i < kNumTestingMessageLoops; i++) {
     base::MessageLoop loop(testing_message_loops[i]);

     bool did_run_a = false;
     RepeatingAlarmTimerTester* a =
         new RepeatingAlarmTimerTester(&did_run_a, kTenMilliseconds);

     // This should run before the timer expires.
     base::MessageLoop::current()->DeleteSoon(FROM_HERE, a);

     // Now start the timer.
     a->Start();

     bool did_run_b = false;
     RepeatingAlarmTimerTester b(&did_run_b, kTenMilliseconds);
     b.Start();

     base::RunLoop().Run();

     EXPECT_FALSE(did_run_a);
     EXPECT_TRUE(did_run_b);
   }
 }

 TEST(AlarmTimerTest, RepeatingAlarmTimerZeroDelay) {
   for (int i = 0; i < kNumTestingMessageLoops; i++) {
     base::MessageLoop loop(testing_message_loops[i]);

     bool did_run = false;
     RepeatingAlarmTimerTester f(&did_run, base::TimeDelta());
     f.Start();

     base::RunLoop().Run();

     EXPECT_TRUE(did_run);
   }
 }

 TEST(AlarmTimerTest, RepeatingAlarmTimerZeroDelay_Cancel) {
   for (int i = 0; i < kNumTestingMessageLoops; i++) {
     base::MessageLoop loop(testing_message_loops[i]);

     bool did_run_a = false;
     RepeatingAlarmTimerTester* a =
         new RepeatingAlarmTimerTester(&did_run_a, base::TimeDelta());

     // This should run before the timer expires.
     base::MessageLoop::current()->DeleteSoon(FROM_HERE, a);

     // Now start the timer.
     a->Start();

     bool did_run_b = false;
     RepeatingAlarmTimerTester b(&did_run_b, base::TimeDelta());
     b.Start();

     base::RunLoop().Run();

     EXPECT_FALSE(did_run_a);
     EXPECT_TRUE(did_run_b);
   }
 }

 TEST(AlarmTimerTest, 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.
   bool did_run = false;
   {
     OneShotAlarmTimerTester a(&did_run, kTenMilliseconds);
     OneShotAlarmTimerTester b(&did_run, kTenMilliseconds);
     OneShotAlarmTimerTester c(&did_run, kTenMilliseconds);
     OneShotAlarmTimerTester d(&did_run, kTenMilliseconds);
     {
       base::MessageLoop loop;
       a.Start();
       b.Start();
     }  // MessageLoop destructs by falling out of scope.
   }    // OneShotTimers destruct.  SHOULD NOT CRASH, of course.

   EXPECT_FALSE(did_run);
 }

 TEST(AlarmTimerTest, NonRepeatIsRunning) {
   {
     base::MessageLoop loop;
     timers::OneShotAlarmTimer timer;
     EXPECT_FALSE(timer.IsRunning());
     timer.Start(FROM_HERE, base::TimeDelta::FromDays(1),
                 base::Bind(&base::DoNothing));
     EXPECT_TRUE(timer.IsRunning());
     timer.Stop();
     EXPECT_FALSE(timer.IsRunning());
     EXPECT_TRUE(timer.user_task().is_null());
   }

   {
     timers::SimpleAlarmTimer timer;
     base::MessageLoop loop;
     EXPECT_FALSE(timer.IsRunning());
     timer.Start(FROM_HERE, base::TimeDelta::FromDays(1),
                 base::Bind(&base::DoNothing));
     EXPECT_TRUE(timer.IsRunning());
     timer.Stop();
     EXPECT_FALSE(timer.IsRunning());
     ASSERT_FALSE(timer.user_task().is_null());
     timer.Reset();
     EXPECT_TRUE(timer.IsRunning());
   }
 }

 TEST(AlarmTimerTest, NonRepeatMessageLoopDeath) {
   timers::OneShotAlarmTimer timer;
   {
     base::MessageLoop loop;
     EXPECT_FALSE(timer.IsRunning());
     timer.Start(FROM_HERE, base::TimeDelta::FromDays(1),
                 base::Bind(&base::DoNothing));
     EXPECT_TRUE(timer.IsRunning());
   }
   EXPECT_FALSE(timer.IsRunning());
   EXPECT_TRUE(timer.user_task().is_null());
 }

 TEST(AlarmTimerTest, RetainRepeatIsRunning) {
   base::MessageLoop loop;
   timers::RepeatingAlarmTimer timer(FROM_HERE, base::TimeDelta::FromDays(1),
                                     base::Bind(&base::DoNothing));
   EXPECT_FALSE(timer.IsRunning());
   timer.Reset();
   EXPECT_TRUE(timer.IsRunning());
   timer.Stop();
   EXPECT_FALSE(timer.IsRunning());
   timer.Reset();
   EXPECT_TRUE(timer.IsRunning());
 }

 TEST(AlarmTimerTest, RetainNonRepeatIsRunning) {
   base::MessageLoop loop;
   timers::SimpleAlarmTimer timer(FROM_HERE, base::TimeDelta::FromDays(1),
                                  base::Bind(&base::DoNothing));
   EXPECT_FALSE(timer.IsRunning());
   timer.Reset();
   EXPECT_TRUE(timer.IsRunning());
   timer.Stop();
   EXPECT_FALSE(timer.IsRunning());
   timer.Reset();
   EXPECT_TRUE(timer.IsRunning());
 }

 namespace {

 bool g_callback_happened1 = false;
 bool g_callback_happened2 = false;

 void ClearAllCallbackHappened() {
   g_callback_happened1 = false;
   g_callback_happened2 = false;
 }

 void SetCallbackHappened1() {
   g_callback_happened1 = true;
   base::MessageLoop::current()->PostTask(
       FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
 }

 void SetCallbackHappened2() {
   g_callback_happened2 = true;
   base::MessageLoop::current()->PostTask(
       FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
 }

 TEST(AlarmTimerTest, ContinuationStopStart) {
   {
     ClearAllCallbackHappened();
     base::MessageLoop loop;
     timers::OneShotAlarmTimer timer;
     timer.Start(FROM_HERE, base::TimeDelta::FromMilliseconds(10),
                 base::Bind(&SetCallbackHappened1));
     timer.Stop();
     timer.Start(FROM_HERE, base::TimeDelta::FromMilliseconds(40),
                 base::Bind(&SetCallbackHappened2));
     base::RunLoop().Run();
     EXPECT_FALSE(g_callback_happened1);
     EXPECT_TRUE(g_callback_happened2);
   }
 }

 TEST(AlarmTimerTest, ContinuationReset) {
   {
     ClearAllCallbackHappened();
     base::MessageLoop loop;
     timers::OneShotAlarmTimer timer;
     timer.Start(FROM_HERE, base::TimeDelta::FromMilliseconds(10),
                 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::RunLoop().Run();
     EXPECT_TRUE(g_callback_happened1);
   }
 }

 }  // namespace

 namespace {
 void TimerRanCallback(bool* did_run) {
   *did_run = true;

   base::MessageLoop::current()->PostTask(
       FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
 }

 bool IsAlarmTimerSupported() {
   int fd = timerfd_create(CLOCK_REALTIME_ALARM, 0);

   if (fd == -1) {
     LOG(WARNING) << "CLOCK_REALTIME_ALARM is not supported on this system.  "
                  << "Skipping test.  Upgrade to at least linux version 3.11 to "
                  << "support this timer.";
     return false;
   }

   close(fd);
   return true;
 }

 TEST(AlarmTimerTest, OneShotTimerConcurrentResetAndTimerFired) {
   // The "Linux ChromiumOS .*" bots are still running Ubuntu 12.04, which
   // doesn't have a linux version high enough to support the AlarmTimer.  Since
   // this test depends on SetTimerFiredCallbackForTest(), which is specific to
   // the AlarmTimer, we have to just skip the test to stop it from failing.
   if (!IsAlarmTimerSupported())
     return;

   for (int i = 0; i < kNumTestingMessageLoops; i++) {
     base::MessageLoop loop(testing_message_loops[i]);

     timers::OneShotAlarmTimer timer;
     bool did_run = false;

     base::RunLoop run_loop;

     timer.SetTimerFiredCallbackForTest(run_loop.QuitClosure());
     timer.Start(FROM_HERE, kTenMilliseconds,
                 base::Bind(&TimerRanCallback, &did_run));

     // Wait until the timer has fired and a task has been queue in the
     // MessageLoop.
     run_loop.Run();

     // Now reset the timer.  This is attempting to simulate the timer firing and
     // being reset at the same time.  The previously queued task should be
     // removed.
     timer.Reset();

     base::RunLoop().RunUntilIdle();
     EXPECT_FALSE(did_run);

     // If the previous check failed, running the message loop again will hang
     // the test so we only do it if the callback has not run yet.
     if (!did_run) {
       base::RunLoop().Run();
       EXPECT_TRUE(did_run);
     }
   }
 }

 TEST(AlarmTimerTest, RepeatingTimerConcurrentResetAndTimerFired) {
   // The "Linux ChromiumOS .*" bots are still running Ubuntu 12.04, which
   // doesn't have a linux version high enough to support the AlarmTimer.  Since
   // this test depends on SetTimerFiredCallbackForTest(), which is specific to
   // the AlarmTimer, we have to just skip the test to stop it from failing.
   if (!IsAlarmTimerSupported())
     return;

   for (int i = 0; i < kNumTestingMessageLoops; i++) {
     base::MessageLoop loop(testing_message_loops[i]);

     timers::RepeatingAlarmTimer timer;
     bool did_run = false;

     base::RunLoop run_loop;

     timer.SetTimerFiredCallbackForTest(run_loop.QuitClosure());
     timer.Start(FROM_HERE, kTenMilliseconds,
                 base::Bind(&TimerRanCallback, &did_run));

     // Wait until the timer has fired and a task has been queue in the
     // MessageLoop.
     run_loop.Run();

     // Now reset the timer.  This is attempting to simulate the timer firing and
     // being reset at the same time.  The previously queued task should be
     // removed.
     timer.Reset();

     base::RunLoop().RunUntilIdle();
     EXPECT_FALSE(did_run);

     // If the previous check failed, running the message loop again will hang
     // the test so we only do it if the callback has not run yet.
     if (!did_run) {
       base::RunLoop().Run();
       EXPECT_TRUE(did_run);
     }
   }
 }

 }  // namespace

 }  // namespace timers
	// Copyright 2014 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 <sys/timerfd.h>

	#include "base/bind.h"
	#include "base/bind_helpers.h"
	#include "base/macros.h"
	#include "base/message_loop/message_loop.h"
	#include "base/run_loop.h"
	#include "base/threading/platform_thread.h"
	#include "base/time/time.h"
	#include "components/timers/alarm_timer_chromeos.h"
	#include "testing/gtest/include/gtest/gtest.h"

	// Most of these tests have been lifted right out of timer_unittest.cc with only
	// cosmetic changes (like replacing calls to MessageLoop::current()->Run() with
	// a RunLoop). We want the AlarmTimer to be a drop-in replacement for the
	// regular Timer so it should pass the same tests as the Timer class.
	//
	// The only new tests are the .*ConcurrentResetAndTimerFired tests, which test
	// that race conditions that can come up in the AlarmTimer::Delegate are
	// properly handled.
	namespace timers {
	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);
	const base::TimeDelta kTenMilliseconds = base::TimeDelta::FromMilliseconds(10);

	class OneShotAlarmTimerTester {
	public:
	OneShotAlarmTimerTester(bool* did_run, base::TimeDelta delay)
	: did_run_(did_run),
	delay_(delay),
	timer_(new timers::OneShotAlarmTimer()) {}
	void Start() {
	timer_->Start(FROM_HERE, delay_, base::Bind(&OneShotAlarmTimerTester::Run,
	base::Unretained(this)));
	}

	private:
	void Run() {
	*did_run_ = true;

	base::MessageLoop::current()->PostTask(
	FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
	}

	bool* did_run_;
	const base::TimeDelta delay_;
	scoped_ptr<timers::OneShotAlarmTimer> timer_;

	DISALLOW_COPY_AND_ASSIGN(OneShotAlarmTimerTester);
	};

	class OneShotSelfDeletingAlarmTimerTester {
	public:
	OneShotSelfDeletingAlarmTimerTester(bool* did_run, base::TimeDelta delay)
	: did_run_(did_run),
	delay_(delay),
	timer_(new timers::OneShotAlarmTimer()) {}
	void Start() {
	timer_->Start(FROM_HERE, delay_,
	base::Bind(&OneShotSelfDeletingAlarmTimerTester::Run,
	base::Unretained(this)));
	}

	private:
	void Run() {
	*did_run_ = true;
	timer_.reset();

	base::MessageLoop::current()->PostTask(
	FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
	}

	bool* did_run_;
	const base::TimeDelta delay_;
	scoped_ptr<timers::OneShotAlarmTimer> timer_;

	DISALLOW_COPY_AND_ASSIGN(OneShotSelfDeletingAlarmTimerTester);
	};

	class RepeatingAlarmTimerTester {
	public:
	RepeatingAlarmTimerTester(bool* did_run, base::TimeDelta delay)
	: did_run_(did_run),
	delay_(delay),
	counter_(10),
	timer_(new timers::RepeatingAlarmTimer()) {}
	void Start() {
	timer_->Start(FROM_HERE, delay_, base::Bind(&RepeatingAlarmTimerTester::Run,
	base::Unretained(this)));
	}

	private:
	void Run() {
	if (--counter_ == 0) {
	*did_run_ = true;
	timer_->Stop();

	base::MessageLoop::current()->PostTask(
	FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
	}
	}

	bool* did_run_;
	const base::TimeDelta delay_;
	int counter_;
	scoped_ptr<timers::RepeatingAlarmTimer> timer_;

	DISALLOW_COPY_AND_ASSIGN(RepeatingAlarmTimerTester);
	};

	} // namespace

	//-----------------------------------------------------------------------------
	// Each test is run against each type of MessageLoop. That way we are sure
	// that timers work properly in all configurations.

	TEST(AlarmTimerTest, OneShotAlarmTimer) {
	for (int i = 0; i < kNumTestingMessageLoops; i++) {
	base::MessageLoop loop(testing_message_loops[i]);

	bool did_run = false;
	OneShotAlarmTimerTester f(&did_run, kTenMilliseconds);
	f.Start();

	base::RunLoop().Run();

	EXPECT_TRUE(did_run);
	}
	}

	TEST(AlarmTimerTest, OneShotAlarmTimer_Cancel) {
	for (int i = 0; i < kNumTestingMessageLoops; i++) {
	base::MessageLoop loop(testing_message_loops[i]);

	bool did_run_a = false;
	OneShotAlarmTimerTester* a =
	new OneShotAlarmTimerTester(&did_run_a, kTenMilliseconds);

	// This should run before the timer expires.
	base::MessageLoop::current()->DeleteSoon(FROM_HERE, a);

	// Now start the timer.
	a->Start();

	bool did_run_b = false;
	OneShotAlarmTimerTester b(&did_run_b, kTenMilliseconds);
	b.Start();

	base::RunLoop().Run();

	EXPECT_FALSE(did_run_a);
	EXPECT_TRUE(did_run_b);
	}
	}

	// If underlying timer does not handle this properly, we will crash or fail
	// in full page heap environment.
	TEST(AlarmTimerTest, OneShotSelfDeletingAlarmTimer) {
	for (int i = 0; i < kNumTestingMessageLoops; i++) {
	base::MessageLoop loop(testing_message_loops[i]);

	bool did_run = false;
	OneShotSelfDeletingAlarmTimerTester f(&did_run, kTenMilliseconds);
	f.Start();

	base::RunLoop().Run();

	EXPECT_TRUE(did_run);
	}
	}

	TEST(AlarmTimerTest, RepeatingAlarmTimer) {
	for (int i = 0; i < kNumTestingMessageLoops; i++) {
	base::MessageLoop loop(testing_message_loops[i]);

	bool did_run = false;
	RepeatingAlarmTimerTester f(&did_run, kTenMilliseconds);
	f.Start();

	base::RunLoop().Run();

	EXPECT_TRUE(did_run);
	}
	}

	TEST(AlarmTimerTest, RepeatingAlarmTimer_Cancel) {
	for (int i = 0; i < kNumTestingMessageLoops; i++) {
	base::MessageLoop loop(testing_message_loops[i]);

	bool did_run_a = false;
	RepeatingAlarmTimerTester* a =
	new RepeatingAlarmTimerTester(&did_run_a, kTenMilliseconds);

	// This should run before the timer expires.
	base::MessageLoop::current()->DeleteSoon(FROM_HERE, a);

	// Now start the timer.
	a->Start();

	bool did_run_b = false;
	RepeatingAlarmTimerTester b(&did_run_b, kTenMilliseconds);
	b.Start();

	base::RunLoop().Run();

	EXPECT_FALSE(did_run_a);
	EXPECT_TRUE(did_run_b);
	}
	}

	TEST(AlarmTimerTest, RepeatingAlarmTimerZeroDelay) {
	for (int i = 0; i < kNumTestingMessageLoops; i++) {
	base::MessageLoop loop(testing_message_loops[i]);

	bool did_run = false;
	RepeatingAlarmTimerTester f(&did_run, base::TimeDelta());
	f.Start();

	base::RunLoop().Run();

	EXPECT_TRUE(did_run);
	}
	}

	TEST(AlarmTimerTest, RepeatingAlarmTimerZeroDelay_Cancel) {
	for (int i = 0; i < kNumTestingMessageLoops; i++) {
	base::MessageLoop loop(testing_message_loops[i]);

	bool did_run_a = false;
	RepeatingAlarmTimerTester* a =
	new RepeatingAlarmTimerTester(&did_run_a, base::TimeDelta());

	// This should run before the timer expires.
	base::MessageLoop::current()->DeleteSoon(FROM_HERE, a);

	// Now start the timer.
	a->Start();

	bool did_run_b = false;
	RepeatingAlarmTimerTester b(&did_run_b, base::TimeDelta());
	b.Start();

	base::RunLoop().Run();

	EXPECT_FALSE(did_run_a);
	EXPECT_TRUE(did_run_b);
	}
	}

	TEST(AlarmTimerTest, 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.
	bool did_run = false;
	{
	OneShotAlarmTimerTester a(&did_run, kTenMilliseconds);
	OneShotAlarmTimerTester b(&did_run, kTenMilliseconds);
	OneShotAlarmTimerTester c(&did_run, kTenMilliseconds);
	OneShotAlarmTimerTester d(&did_run, kTenMilliseconds);
	{
	base::MessageLoop loop;
	a.Start();
	b.Start();
	} // MessageLoop destructs by falling out of scope.
	} // OneShotTimers destruct. SHOULD NOT CRASH, of course.

	EXPECT_FALSE(did_run);
	}

	TEST(AlarmTimerTest, NonRepeatIsRunning) {
	{
	base::MessageLoop loop;
	timers::OneShotAlarmTimer timer;
	EXPECT_FALSE(timer.IsRunning());
	timer.Start(FROM_HERE, base::TimeDelta::FromDays(1),
	base::Bind(&base::DoNothing));
	EXPECT_TRUE(timer.IsRunning());
	timer.Stop();
	EXPECT_FALSE(timer.IsRunning());
	EXPECT_TRUE(timer.user_task().is_null());
	}

	{
	timers::SimpleAlarmTimer timer;
	base::MessageLoop loop;
	EXPECT_FALSE(timer.IsRunning());
	timer.Start(FROM_HERE, base::TimeDelta::FromDays(1),
	base::Bind(&base::DoNothing));
	EXPECT_TRUE(timer.IsRunning());
	timer.Stop();
	EXPECT_FALSE(timer.IsRunning());
	ASSERT_FALSE(timer.user_task().is_null());
	timer.Reset();
	EXPECT_TRUE(timer.IsRunning());
	}
	}

	TEST(AlarmTimerTest, NonRepeatMessageLoopDeath) {
	timers::OneShotAlarmTimer timer;
	{
	base::MessageLoop loop;
	EXPECT_FALSE(timer.IsRunning());
	timer.Start(FROM_HERE, base::TimeDelta::FromDays(1),
	base::Bind(&base::DoNothing));
	EXPECT_TRUE(timer.IsRunning());
	}
	EXPECT_FALSE(timer.IsRunning());
	EXPECT_TRUE(timer.user_task().is_null());
	}

	TEST(AlarmTimerTest, RetainRepeatIsRunning) {
	base::MessageLoop loop;
	timers::RepeatingAlarmTimer timer(FROM_HERE, base::TimeDelta::FromDays(1),
	base::Bind(&base::DoNothing));
	EXPECT_FALSE(timer.IsRunning());
	timer.Reset();
	EXPECT_TRUE(timer.IsRunning());
	timer.Stop();
	EXPECT_FALSE(timer.IsRunning());
	timer.Reset();
	EXPECT_TRUE(timer.IsRunning());
	}

	TEST(AlarmTimerTest, RetainNonRepeatIsRunning) {
	base::MessageLoop loop;
	timers::SimpleAlarmTimer timer(FROM_HERE, base::TimeDelta::FromDays(1),
	base::Bind(&base::DoNothing));
	EXPECT_FALSE(timer.IsRunning());
	timer.Reset();
	EXPECT_TRUE(timer.IsRunning());
	timer.Stop();
	EXPECT_FALSE(timer.IsRunning());
	timer.Reset();
	EXPECT_TRUE(timer.IsRunning());
	}

	namespace {

	bool g_callback_happened1 = false;
	bool g_callback_happened2 = false;

	void ClearAllCallbackHappened() {
	g_callback_happened1 = false;
	g_callback_happened2 = false;
	}

	void SetCallbackHappened1() {
	g_callback_happened1 = true;
	base::MessageLoop::current()->PostTask(
	FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
	}

	void SetCallbackHappened2() {
	g_callback_happened2 = true;
	base::MessageLoop::current()->PostTask(
	FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
	}

	TEST(AlarmTimerTest, ContinuationStopStart) {
	{
	ClearAllCallbackHappened();
	base::MessageLoop loop;
	timers::OneShotAlarmTimer timer;
	timer.Start(FROM_HERE, base::TimeDelta::FromMilliseconds(10),
	base::Bind(&SetCallbackHappened1));
	timer.Stop();
	timer.Start(FROM_HERE, base::TimeDelta::FromMilliseconds(40),
	base::Bind(&SetCallbackHappened2));
	base::RunLoop().Run();
	EXPECT_FALSE(g_callback_happened1);
	EXPECT_TRUE(g_callback_happened2);
	}
	}

	TEST(AlarmTimerTest, ContinuationReset) {
	{
	ClearAllCallbackHappened();
	base::MessageLoop loop;
	timers::OneShotAlarmTimer timer;
	timer.Start(FROM_HERE, base::TimeDelta::FromMilliseconds(10),
	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::RunLoop().Run();
	EXPECT_TRUE(g_callback_happened1);
	}
	}

	} // namespace

	namespace {
	void TimerRanCallback(bool* did_run) {
	*did_run = true;

	base::MessageLoop::current()->PostTask(
	FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
	}

	bool IsAlarmTimerSupported() {
	int fd = timerfd_create(CLOCK_REALTIME_ALARM, 0);

	if (fd == -1) {
	LOG(WARNING) << "CLOCK_REALTIME_ALARM is not supported on this system. "
	<< "Skipping test. Upgrade to at least linux version 3.11 to "
	<< "support this timer.";
	return false;
	}

	close(fd);
	return true;
	}

	TEST(AlarmTimerTest, OneShotTimerConcurrentResetAndTimerFired) {
	// The "Linux ChromiumOS .*" bots are still running Ubuntu 12.04, which
	// doesn't have a linux version high enough to support the AlarmTimer. Since
	// this test depends on SetTimerFiredCallbackForTest(), which is specific to
	// the AlarmTimer, we have to just skip the test to stop it from failing.
	if (!IsAlarmTimerSupported())
	return;

	for (int i = 0; i < kNumTestingMessageLoops; i++) {
	base::MessageLoop loop(testing_message_loops[i]);

	timers::OneShotAlarmTimer timer;
	bool did_run = false;

	base::RunLoop run_loop;

	timer.SetTimerFiredCallbackForTest(run_loop.QuitClosure());
	timer.Start(FROM_HERE, kTenMilliseconds,
	base::Bind(&TimerRanCallback, &did_run));

	// Wait until the timer has fired and a task has been queue in the
	// MessageLoop.
	run_loop.Run();

	// Now reset the timer. This is attempting to simulate the timer firing and
	// being reset at the same time. The previously queued task should be
	// removed.
	timer.Reset();

	base::RunLoop().RunUntilIdle();
	EXPECT_FALSE(did_run);

	// If the previous check failed, running the message loop again will hang
	// the test so we only do it if the callback has not run yet.
	if (!did_run) {
	base::RunLoop().Run();
	EXPECT_TRUE(did_run);
	}
	}
	}

	TEST(AlarmTimerTest, RepeatingTimerConcurrentResetAndTimerFired) {
	// The "Linux ChromiumOS .*" bots are still running Ubuntu 12.04, which
	// doesn't have a linux version high enough to support the AlarmTimer. Since
	// this test depends on SetTimerFiredCallbackForTest(), which is specific to
	// the AlarmTimer, we have to just skip the test to stop it from failing.
	if (!IsAlarmTimerSupported())
	return;

	for (int i = 0; i < kNumTestingMessageLoops; i++) {
	base::MessageLoop loop(testing_message_loops[i]);

	timers::RepeatingAlarmTimer timer;
	bool did_run = false;

	base::RunLoop run_loop;

	timer.SetTimerFiredCallbackForTest(run_loop.QuitClosure());
	timer.Start(FROM_HERE, kTenMilliseconds,
	base::Bind(&TimerRanCallback, &did_run));

	// Wait until the timer has fired and a task has been queue in the
	// MessageLoop.
	run_loop.Run();

	// Now reset the timer. This is attempting to simulate the timer firing and
	// being reset at the same time. The previously queued task should be
	// removed.
	timer.Reset();

	base::RunLoop().RunUntilIdle();
	EXPECT_FALSE(did_run);

	// If the previous check failed, running the message loop again will hang
	// the test so we only do it if the callback has not run yet.
	if (!did_run) {
	base::RunLoop().Run();
	EXPECT_TRUE(did_run);
	}
	}
	}

	} // namespace

	} // namespace timers