Bitmap transport

base/timer_unittest.cc

 // Copyright (c) 2006-2008 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/message_loop.h"
 #include "base/scoped_ptr.h"
 #include "base/task.h"
 #include "base/timer.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::TimeDelta;
 
 namespace {
 
 class OneShotTimerTester {
  public:
-  OneShotTimerTester(bool* did_run) : did_run_(did_run) {
+  OneShotTimerTester(bool* did_run, unsigned milliseconds = 10)
+      : did_run_(did_run),
+        delay_ms_(milliseconds) {
   }
   void Start() {
-    timer_.Start(TimeDelta::FromMilliseconds(10), this,
+    timer_.Start(TimeDelta::FromMilliseconds(delay_ms_), this,
                  &OneShotTimerTester::Run);
   }
  private:
   void Run() {
     *did_run_ = true;
     MessageLoop::current()->Quit();
   }
   bool* did_run_;
   base::OneShotTimer<OneShotTimerTester> timer_;
+  const unsigned delay_ms_;
 };
 
 class OneShotSelfDeletingTimerTester {
  public:
   OneShotSelfDeletingTimerTester(bool* did_run) :
       did_run_(did_run),
       timer_(new base::OneShotTimer<OneShotSelfDeletingTimerTester>()) {
   }
   void Start() {
     timer_->Start(TimeDelta::FromMilliseconds(10), this,
@@ skipping 91 matching lines @@
   MessageLoop loop(message_loop_type);
 
   bool did_run_a = false;
   RepeatingTimerTester* a = new RepeatingTimerTester(&did_run_a);
 
   // This should run before the timer expires.
   MessageLoop::current()->DeleteSoon(FROM_HERE, a);
 
   // Now start the timer.
   a->Start();
- 
+
   bool did_run_b = false;
   RepeatingTimerTester b(&did_run_b);
   b.Start();
 
   MessageLoop::current()->Run();
 
   EXPECT_FALSE(did_run_a);
   EXPECT_TRUE(did_run_b);
 }
 
+class DelayTimerTarget {
+ public:
+  DelayTimerTarget()
+      : signaled_(false) {
+  }
+
+  bool signaled() const { return signaled_; }
+
+  void Signal() {
+    ASSERT_FALSE(signaled_);
+    signaled_ = true;
+  }
+
+ private:
+  bool signaled_;
+};
+
+void RunTest_DelayTimer_NoCall(MessageLoop::Type message_loop_type) {
+  MessageLoop loop(message_loop_type);
+
+  // If Delay is never called, the timer shouldn't go off.
+  DelayTimerTarget target;
+  base::DelayTimer<DelayTimerTarget> timer(
+      TimeDelta::FromMilliseconds(1), &target, &DelayTimerTarget::Signal);
+
+  bool did_run = false;
+  OneShotTimerTester tester(&did_run);
+  tester.Start();
+  MessageLoop::current()->Run();
+
+  ASSERT_FALSE(target.signaled());
+}
+
+void RunTest_DelayTimer_OneCall(MessageLoop::Type message_loop_type) {
+  MessageLoop loop(message_loop_type);
+
+  DelayTimerTarget target;
+  base::DelayTimer<DelayTimerTarget> timer(
+      TimeDelta::FromMilliseconds(1), &target, &DelayTimerTarget::Signal);
+  timer.Reset();
+
+  bool did_run = false;
+  OneShotTimerTester tester(&did_run, 100 /* milliseconds */);
+  tester.Start();
+  MessageLoop::current()->Run();
+
+  ASSERT_TRUE(target.signaled());
+}
+
+struct ResetHelper {
+  ResetHelper(base::DelayTimer<DelayTimerTarget>* timer,
+              DelayTimerTarget* target)
+      : timer_(timer),
+        target_(target) {
+  }
+
+  void Reset() {
+    ASSERT_FALSE(target_->signaled());
+    timer_->Reset();
+  }
+
+ private:
+  base::DelayTimer<DelayTimerTarget> *const timer_;
+  DelayTimerTarget *const target_;
+};
+
+void RunTest_DelayTimer_Reset(MessageLoop::Type message_loop_type) {
+  MessageLoop loop(message_loop_type);
+
+  // If Delay is never called, the timer shouldn't go off.
+  DelayTimerTarget target;
+  base::DelayTimer<DelayTimerTarget> timer(
+      TimeDelta::FromMilliseconds(1), &target, &DelayTimerTarget::Signal);
+  timer.Reset();
+
+  ResetHelper reset_helper(&timer, &target);
+
+  base::OneShotTimer<ResetHelper> timers[20];
+  for (size_t i = 0; i < arraysize(timers); ++i) {
+    timers[i].Start(TimeDelta::FromMilliseconds(i * 10), &reset_helper,
+                    &ResetHelper::Reset);
+  }
+
+  bool did_run = false;
+  OneShotTimerTester tester(&did_run, 300);
+  tester.Start();
+  MessageLoop::current()->Run();
+
+  ASSERT_TRUE(target.signaled());
+}
+
 }  // namespace
 
 //-----------------------------------------------------------------------------
 // Each test is run against each type of MessageLoop.  That way we are sure
 // that timers work properly in all configurations.
 
 TEST(TimerTest, OneShotTimer) {
   RunTest_OneShotTimer(MessageLoop::TYPE_DEFAULT);
   RunTest_OneShotTimer(MessageLoop::TYPE_UI);
   RunTest_OneShotTimer(MessageLoop::TYPE_IO);
@@ skipping 18 matching lines @@
   RunTest_RepeatingTimer(MessageLoop::TYPE_UI);
   RunTest_RepeatingTimer(MessageLoop::TYPE_IO);
 }
 
 TEST(TimerTest, RepeatingTimer_Cancel) {
   RunTest_RepeatingTimer_Cancel(MessageLoop::TYPE_DEFAULT);
   RunTest_RepeatingTimer_Cancel(MessageLoop::TYPE_UI);
   RunTest_RepeatingTimer_Cancel(MessageLoop::TYPE_IO);
 }
 
+TEST(TimerTest, DelayTimer_NoCall) {
+  RunTest_DelayTimer_NoCall(MessageLoop::TYPE_DEFAULT);
+  RunTest_DelayTimer_NoCall(MessageLoop::TYPE_UI);
+  RunTest_DelayTimer_NoCall(MessageLoop::TYPE_IO);
+}
+
+TEST(TimerTest, DelayTimer_OneCall) {
+  RunTest_DelayTimer_OneCall(MessageLoop::TYPE_DEFAULT);
+  RunTest_DelayTimer_OneCall(MessageLoop::TYPE_UI);
+  RunTest_DelayTimer_OneCall(MessageLoop::TYPE_IO);
+}
+
+TEST(TimerTest, DelayTimer_Reset) {
+  RunTest_DelayTimer_Reset(MessageLoop::TYPE_DEFAULT);
+  RunTest_DelayTimer_Reset(MessageLoop::TYPE_UI);
+  RunTest_DelayTimer_Reset(MessageLoop::TYPE_IO);
+}
+
 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 (or purify) is enabled.
   bool did_run = false;
   {
     OneShotTimerTester a(&did_run);
     OneShotTimerTester b(&did_run);
     OneShotTimerTester c(&did_run);
     OneShotTimerTester d(&did_run);
     {
       MessageLoop loop(MessageLoop::TYPE_DEFAULT);
       a.Start();
       b.Start();
     }  // MessageLoop destructs by falling out of scope.
   }  // OneShotTimers destruct.  SHOULD NOT CRASH, of course.
 
   EXPECT_EQ(false, did_run);
 }