Fix flakiness of message_center_unittests in mac

ui/message_center/message_center_impl_unittest.cc

 // Copyright 2013 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 "ui/message_center/message_center_impl.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/location.h"
@@ skipping 218 matching lines @@
 
 }  // namespace
 
 namespace internal {
 
 class MockPopupTimersController : public PopupTimersController {
  public:
   MockPopupTimersController(MessageCenter* message_center,
                             base::Closure quit_closure)
       : PopupTimersController(message_center),
-        timer_finished_(false),
+        timer_finished_(0),
         quit_closure_(quit_closure) {}
   ~MockPopupTimersController() override {}
 
   void TimerFinished(const std::string& id) override {
     base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, quit_closure_);
-    timer_finished_ = true;
+    timer_finished_++;
     last_id_ = id;
   }
 
-  bool timer_finished() const { return timer_finished_; }
+  int timer_finished() const { return timer_finished_; }
   const std::string& last_id() const { return last_id_; }
 
  private:
-  bool timer_finished_;
+  int timer_finished_;
   std::string last_id_;
   base::Closure quit_closure_;
 };
 
 TEST_F(MessageCenterImplTest, PopupTimersEmptyController) {
   std::unique_ptr<PopupTimersController> popup_timers_controller =
       base::MakeUnique<PopupTimersController>(message_center());
 
   // Test that all functions succed without any timers created.
   popup_timers_controller->PauseAll();
   popup_timers_controller->StartAll();
   popup_timers_controller->CancelAll();
   popup_timers_controller->TimerFinished("unknown");
   popup_timers_controller->CancelTimer("unknown");
 }
 
 TEST_F(MessageCenterImplTest, PopupTimersControllerStartTimer) {
   std::unique_ptr<MockPopupTimersController> popup_timers_controller =
       base::MakeUnique<MockPopupTimersController>(message_center(), closure());
   popup_timers_controller->StartTimer("test",
                                       base::TimeDelta::FromMilliseconds(1));
   run_loop()->Run();
-  EXPECT_TRUE(popup_timers_controller->timer_finished());
+  EXPECT_EQ(popup_timers_controller->timer_finished(), 1);
 }
 
 TEST_F(MessageCenterImplTest, PopupTimersControllerCancelTimer) {
   std::unique_ptr<MockPopupTimersController> popup_timers_controller =
       base::MakeUnique<MockPopupTimersController>(message_center(), closure());
   popup_timers_controller->StartTimer("test",
                                       base::TimeDelta::FromMilliseconds(1));
   popup_timers_controller->CancelTimer("test");
   run_loop()->RunUntilIdle();
 
-  EXPECT_FALSE(popup_timers_controller->timer_finished());
+  EXPECT_EQ(popup_timers_controller->timer_finished(), 0);
 }
 
 TEST_F(MessageCenterImplTest, PopupTimersControllerPauseAllTimers) {
   std::unique_ptr<MockPopupTimersController> popup_timers_controller =
       base::MakeUnique<MockPopupTimersController>(message_center(), closure());
   popup_timers_controller->StartTimer("test",
                                       base::TimeDelta::FromMilliseconds(1));
   popup_timers_controller->PauseAll();
   run_loop()->RunUntilIdle();
 
-  EXPECT_FALSE(popup_timers_controller->timer_finished());
+  EXPECT_EQ(popup_timers_controller->timer_finished(), 0);
 }
 
 TEST_F(MessageCenterImplTest, PopupTimersControllerStartAllTimers) {
   std::unique_ptr<MockPopupTimersController> popup_timers_controller =
       base::MakeUnique<MockPopupTimersController>(message_center(), closure());
   popup_timers_controller->StartTimer("test",
                                       base::TimeDelta::FromMilliseconds(1));
   popup_timers_controller->PauseAll();
   popup_timers_controller->StartAll();
   run_loop()->Run();
 
-  EXPECT_TRUE(popup_timers_controller->timer_finished());
+  EXPECT_EQ(popup_timers_controller->timer_finished(), 1);
 }
 
 TEST_F(MessageCenterImplTest, PopupTimersControllerStartMultipleTimers) {
   std::unique_ptr<MockPopupTimersController> popup_timers_controller =
       base::MakeUnique<MockPopupTimersController>(message_center(), closure());
-  popup_timers_controller->StartTimer("test",
-                                      base::TimeDelta::FromMilliseconds(5));
+  popup_timers_controller->StartTimer("test", base::TimeDelta::Max());
   popup_timers_controller->StartTimer("test2",
                                       base::TimeDelta::FromMilliseconds(1));

[yhanada, 2017/05/10 09:32:10]

Should this be changed to TimeDelta::FromMilliseconds(0) to ensure that this
timer finishes?

-  popup_timers_controller->StartTimer("test3",
-                                      base::TimeDelta::FromMilliseconds(3));
+  popup_timers_controller->StartTimer("test3", base::TimeDelta::Max());
   popup_timers_controller->PauseAll();
   popup_timers_controller->StartAll();
   run_loop()->Run();
 
   EXPECT_EQ(popup_timers_controller->last_id(), "test2");
-  EXPECT_TRUE(popup_timers_controller->timer_finished());
+  EXPECT_EQ(popup_timers_controller->timer_finished(), 1);
 }
 
 TEST_F(MessageCenterImplTest, PopupTimersControllerRestartOnUpdate) {
   scoped_refptr<base::SingleThreadTaskRunner> old_task_runner =
       base::ThreadTaskRunnerHandle::Get();
 
   scoped_refptr<base::TestMockTimeTaskRunner> task_runner(
       new base::TestMockTimeTaskRunner(base::Time::Now(),
                                        base::TimeTicks::Now()));
   base::MessageLoop::current()->SetTaskRunner(task_runner);
 
   NotifierId notifier_id(GURL("https://example.com"));
 
   message_center()->AddNotification(std::unique_ptr<Notification>(
       new Notification(NOTIFICATION_TYPE_SIMPLE, "id1", UTF8ToUTF16("title"),
                        UTF8ToUTF16("message"), gfx::Image() /* icon */,
                        base::string16() /* display_source */, GURL(),
                        notifier_id, RichNotificationData(), NULL)));
 
   std::unique_ptr<MockPopupTimersController> popup_timers_controller =
       base::MakeUnique<MockPopupTimersController>(message_center(), closure());
 
   popup_timers_controller->OnNotificationDisplayed("id1", DISPLAY_SOURCE_POPUP);
-  ASSERT_FALSE(popup_timers_controller->timer_finished());
+  ASSERT_EQ(popup_timers_controller->timer_finished(), 0);
 
   // Fast forward the |task_runner| by one second less than the auto-close timer
   // frequency for Web Notifications. (As set by the |notifier_id|.)
   task_runner->FastForwardBy(
       base::TimeDelta::FromSeconds(kAutocloseWebPageDelaySeconds - 1));
-  ASSERT_FALSE(popup_timers_controller->timer_finished());
+  ASSERT_EQ(popup_timers_controller->timer_finished(), 0);
 
   // Trigger a replacement of the notification in the timer controller.
   popup_timers_controller->OnNotificationUpdated("id1");
 
   // Fast forward the |task_runner| by one second less than the auto-close timer
   // frequency for Web Notifications again. It should have been reset.
   task_runner->FastForwardBy(
       base::TimeDelta::FromSeconds(kAutocloseWebPageDelaySeconds - 1));
-  ASSERT_FALSE(popup_timers_controller->timer_finished());
+  ASSERT_EQ(popup_timers_controller->timer_finished(), 0);
 
   // Now fast forward the |task_runner| by two seconds (to avoid flakiness),
   // after which the timer should have fired.
   task_runner->FastForwardBy(base::TimeDelta::FromSeconds(2));
-  ASSERT_TRUE(popup_timers_controller->timer_finished());
+  ASSERT_EQ(popup_timers_controller->timer_finished(), 1);
 
   base::MessageLoop::current()->SetTaskRunner(old_task_runner);
 }
 
 TEST_F(MessageCenterImplTest, NotificationBlocker) {
   NotifierId notifier_id(NotifierId::APPLICATION, "app1");
   // Multiple blockers to verify the case that one blocker blocks but another
   // doesn't.
   ToggledNotificationBlocker blocker1(message_center());
   ToggledNotificationBlocker blocker2(message_center());
@@ skipping 880 matching lines @@
   // Then open the message center.
   message_center()->SetVisibility(VISIBILITY_MESSAGE_CENTER);
 
   // Then update a notification; the update should have propagated.
   message_center()->RemoveNotification(id, false);
   EXPECT_FALSE(message_center()->FindVisibleNotificationById(id));
 }
 
 }  // namespace internal
 }  // namespace message_center