Change explicit usage of each type of message loop in TimerTest to instead loop through an array of…

base/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.h"
 #include "base/timer.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::TimeDelta;
 
 namespace {
 
+// The message loops on which each timer should be tested.
+MessageLoop::Type testing_message_loops[] = {
+  MessageLoop::TYPE_DEFAULT,
+  MessageLoop::TYPE_IO,
+#if !defined(OS_IOS)  // iOS does not allow direct running of the UI loop.
+  MessageLoop::TYPE_UI,
+#endif  // !OS_IOS

[stuartmorgan, 2012/07/16 15:56:15]

No need for the end comment for such a short ifdef.

[leng, 2012/07/16 16:01:28]

Done.

+};
+
+const int kNumTestingMessageLoops = arraysize(testing_message_loops);
+
 class OneShotTimerTester {
  public:
   OneShotTimerTester(bool* did_run, unsigned milliseconds = 10)
       : did_run_(did_run),
         delay_ms_(milliseconds) {
   }
   void Start() {
     timer_.Start(FROM_HERE, TimeDelta::FromMilliseconds(delay_ms_), this,
                  &OneShotTimerTester::Run);
   }
@@ skipping 245 matching lines @@
   base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(100));
 }
 
 }  // 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);
+  for (int i = 0; i < kNumTestingMessageLoops; i++) {
+    RunTest_OneShotTimer(testing_message_loops[i]);
+  }
 }
 
 TEST(TimerTest, OneShotTimer_Cancel) {
-  RunTest_OneShotTimer_Cancel(MessageLoop::TYPE_DEFAULT);
-  RunTest_OneShotTimer_Cancel(MessageLoop::TYPE_UI);
-  RunTest_OneShotTimer_Cancel(MessageLoop::TYPE_IO);
+  for (int i = 0; i < kNumTestingMessageLoops; i++) {
+    RunTest_OneShotTimer_Cancel(testing_message_loops[i]);
+  }
 }
 
 // If underline timer does not handle properly, we will crash or fail
 // in full page heap environment.
 TEST(TimerTest, OneShotSelfDeletingTimer) {
-  RunTest_OneShotSelfDeletingTimer(MessageLoop::TYPE_DEFAULT);
-  RunTest_OneShotSelfDeletingTimer(MessageLoop::TYPE_UI);
-  RunTest_OneShotSelfDeletingTimer(MessageLoop::TYPE_IO);
+  for (int i = 0; i < kNumTestingMessageLoops; i++) {
+    RunTest_OneShotSelfDeletingTimer(testing_message_loops[i]);
+  }
 }
 
 TEST(TimerTest, RepeatingTimer) {
-  RunTest_RepeatingTimer(MessageLoop::TYPE_DEFAULT);
-  RunTest_RepeatingTimer(MessageLoop::TYPE_UI);
-  RunTest_RepeatingTimer(MessageLoop::TYPE_IO);
+  for (int i = 0; i < kNumTestingMessageLoops; i++) {
+    RunTest_RepeatingTimer(testing_message_loops[i]);
+  }
 }
 
 TEST(TimerTest, RepeatingTimer_Cancel) {
-  RunTest_RepeatingTimer_Cancel(MessageLoop::TYPE_DEFAULT);
-  RunTest_RepeatingTimer_Cancel(MessageLoop::TYPE_UI);
-  RunTest_RepeatingTimer_Cancel(MessageLoop::TYPE_IO);
+  for (int i = 0; i < kNumTestingMessageLoops; i++) {
+    RunTest_RepeatingTimer_Cancel(testing_message_loops[i]);
+  }
 }
 
 TEST(TimerTest, DelayTimer_NoCall) {
-  RunTest_DelayTimer_NoCall(MessageLoop::TYPE_DEFAULT);
-  RunTest_DelayTimer_NoCall(MessageLoop::TYPE_UI);
-  RunTest_DelayTimer_NoCall(MessageLoop::TYPE_IO);
+  for (int i = 0; i < kNumTestingMessageLoops; i++) {
+    RunTest_DelayTimer_NoCall(testing_message_loops[i]);
+  }
 }
 
 TEST(TimerTest, DelayTimer_OneCall) {
-  RunTest_DelayTimer_OneCall(MessageLoop::TYPE_DEFAULT);
-  RunTest_DelayTimer_OneCall(MessageLoop::TYPE_UI);
-  RunTest_DelayTimer_OneCall(MessageLoop::TYPE_IO);
+  for (int i = 0; i < kNumTestingMessageLoops; i++) {
+    RunTest_DelayTimer_OneCall(testing_message_loops[i]);
+  }
 }
 
 // It's flaky on the buildbot, http://crbug.com/25038.
 TEST(TimerTest, DISABLED_DelayTimer_Reset) {
-  RunTest_DelayTimer_Reset(MessageLoop::TYPE_DEFAULT);
-  RunTest_DelayTimer_Reset(MessageLoop::TYPE_UI);
-  RunTest_DelayTimer_Reset(MessageLoop::TYPE_IO);
+  for (int i = 0; i < kNumTestingMessageLoops; i++) {
+    RunTest_DelayTimer_Reset(testing_message_loops[i]);
+  }
 }
 
 TEST(TimerTest, DelayTimer_Deleted) {
-  RunTest_DelayTimer_Deleted(MessageLoop::TYPE_DEFAULT);
-  RunTest_DelayTimer_Deleted(MessageLoop::TYPE_UI);
-  RunTest_DelayTimer_Deleted(MessageLoop::TYPE_IO);
+  for (int i = 0; i < kNumTestingMessageLoops; i++) {
+    RunTest_DelayTimer_Deleted(testing_message_loops[i]);
+  }
 }
 
 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.
   bool did_run = false;
   {
     OneShotTimerTester a(&did_run);
@@ skipping 125 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());
     MessageLoop::current()->Run();
     EXPECT_TRUE(g_callback_happened1);
   }
 }
 
 }  // namespace