Use TimedWait everywhere to prevent hangs.

chrome/browser/sync/engine/syncer_thread_unittest.cc

 // Copyright (c) 2009 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 <list>
 #include <map>
 #include <set>
 
 #include "base/scoped_ptr.h"
 #include "base/time.h"
@@ skipping 27 matching lines @@
 
 class ListenerMock : public ChannelEventHandler<SyncerEvent> {
  public:
   MOCK_METHOD1(HandleChannelEvent, void(const SyncerEvent&));
 };
 
 class SyncerThreadWithSyncerTest : public testing::Test,
                                    public ModelSafeWorkerRegistrar,
                                    public ChannelEventHandler<SyncerEvent> {
  public:
-  SyncerThreadWithSyncerTest() : sync_cycle_ended_event_(false, false) {}
+  SyncerThreadWithSyncerTest()
+      : max_wait_time_(TimeDelta::FromSeconds(10)),
+        sync_cycle_ended_event_(false, false) {}
   virtual void SetUp() {
     metadb_.SetUp();
     connection_.reset(new MockConnectionManager(metadb_.manager(),
                                                 metadb_.name()));
     allstatus_.reset(new AllStatus());
     worker_ = new ModelSafeWorker();
     SyncSessionContext* context = new SyncSessionContext(connection_.get(),
         NULL, metadb_.manager(), this);
     syncer_thread_ = new SyncerThread(context, allstatus_.get());
     syncer_event_hookup_.reset(
@@ skipping 22 matching lines @@
     // the SyncerThread.
     (*out)[syncable::BOOKMARKS] = GROUP_PASSIVE;
   }
 
   ManuallyOpenedTestDirectorySetterUpper* metadb() { return &metadb_; }
   MockConnectionManager* connection() { return connection_.get(); }
   SyncerThread* syncer_thread() { return syncer_thread_; }
 
   // Waits an indefinite amount of sync cycles for the syncer thread to become
   // throttled.  Only call this if a throttle is supposed to occur!
-  void WaitForThrottle() {
-    while (!syncer_thread()->IsSyncingCurrentlySilenced())
-      sync_cycle_ended_event_.Wait();
+  bool WaitForThrottle() {
+    int max_cycles = 5;
+    while (max_cycles && !syncer_thread()->IsSyncingCurrentlySilenced()) {
+      sync_cycle_ended_event_.TimedWait(max_wait_time_);
+      max_cycles--;
+    }
+
+    return syncer_thread()->IsSyncingCurrentlySilenced();
   }
 
   void WaitForDisconnect() {
     // Wait for the SyncerThread to detect loss of connection, up to a max of
     // 10 seconds to timeout the test.
     AutoLock lock(syncer_thread()->lock_);
     TimeTicks start = TimeTicks::Now();
     TimeDelta ten_seconds = TimeDelta::FromSeconds(10);
     while (syncer_thread()->vault_.connected_) {
       syncer_thread()->vault_field_changed_.TimedWait(ten_seconds);
       if (TimeTicks::Now() - start > ten_seconds)
         break;
     }
     EXPECT_FALSE(syncer_thread()->vault_.connected_);
   }
 
   bool Pause(ListenerMock* listener) {
     WaitableEvent event(false, false);
     EXPECT_CALL(*listener, HandleChannelEvent(
         Field(&SyncerEvent::what_happened, SyncerEvent::PAUSED))).
         WillOnce(SignalEvent(&event));
     if (!syncer_thread()->RequestPause())
       return false;
-    event.Wait();
-    return true;
+    return event.TimedWait(max_wait_time_);
   }
 
   bool Resume(ListenerMock* listener) {
     WaitableEvent event(false, false);
     EXPECT_CALL(*listener, HandleChannelEvent(
         Field(&SyncerEvent::what_happened, SyncerEvent::RESUMED))).
         WillOnce(SignalEvent(&event));
     if (!syncer_thread()->RequestResume())
       return false;
-    event.Wait();
-    return true;
+    return event.TimedWait(max_wait_time_);
   }
 
   void PreventThreadFromPolling() {
     const TimeDelta poll_interval = TimeDelta::FromMinutes(5);
     syncer_thread()->SetSyncerShortPollInterval(poll_interval);
   }
 
  private:
 
   void HandleChannelEvent(const SyncerEvent& event) {
     if (event.what_happened == SyncerEvent::SYNC_CYCLE_ENDED)
       sync_cycle_ended_event_.Signal();
   }
 
+ protected:
+  TimeDelta max_wait_time_;
+
+ private:
   ManuallyOpenedTestDirectorySetterUpper metadb_;
   scoped_ptr<MockConnectionManager> connection_;
   scoped_ptr<AllStatus> allstatus_;
   scoped_refptr<SyncerThread> syncer_thread_;
   scoped_refptr<ModelSafeWorker> worker_;
   scoped_ptr<ChannelHookup<SyncerEvent> > syncer_event_hookup_;
   base::WaitableEvent sync_cycle_ended_event_;
   DISALLOW_COPY_AND_ASSIGN(SyncerThreadWithSyncerTest);
 };
 
@@ skipping 540 matching lines @@
   // mode and fail on multiple requests.
   connection()->ThrottleNextRequest(&interceptor);
 
   // Try to trigger a sync (we have a really short poll interval already).
   syncer_thread()->NudgeSyncer(0, SyncerThread::kUnknown);
   syncer_thread()->NudgeSyncer(0, SyncerThread::kUnknown);
 
   // Wait until the syncer thread reports that it is throttled.  Any further
   // sync share interceptions will result in failure.  If things are broken,
   // we may never halt.
-  WaitForThrottle();
+  ASSERT_TRUE(WaitForThrottle());
   EXPECT_TRUE(syncer_thread()->IsSyncingCurrentlySilenced());
 
   EXPECT_TRUE(syncer_thread()->Stop(2000));
 }
 
 TEST_F(SyncerThreadWithSyncerTest, AuthInvalid) {
   SyncShareIntercept interceptor;
   connection()->SetMidCommitObserver(&interceptor);
   const TimeDelta poll_interval = TimeDelta::FromMilliseconds(1);
 
@@ skipping 27 matching lines @@
                              HttpResponse::SERVER_CONNECTION_OK,
                              true};
   connection()->channel()->NotifyListeners(e);
 
   interceptor.WaitForSyncShare(1, TimeDelta::FromSeconds(10));
   EXPECT_FALSE(interceptor.times_sync_occured().empty());
 
   EXPECT_TRUE(syncer_thread()->Stop(2000));
 }
 
-// Timesout http:://crbug.com/39070
-TEST_F(SyncerThreadWithSyncerTest, DISABLED_Pause) {
+// TODO(skrul): The "Pause" and "PauseWhenNotConnected" tests are
+// marked FLAKY because they sometimes fail on the Windows buildbots.
+// I have been unable to reproduce this hang after extensive testing
+// on a local Windows machine so these tests will remain flaky in
+// order to help diagnose the problem.
+//
+// This issue is tracked at http://crbug.com/39070.
+TEST_F(SyncerThreadWithSyncerTest, FLAKY_Pause) {
   WaitableEvent sync_cycle_ended_event(false, false);
   WaitableEvent paused_event(false, false);
   WaitableEvent resumed_event(false, false);
   PreventThreadFromPolling();
 
   ListenerMock listener;
   scoped_ptr<ChannelHookup<SyncerEvent> > hookup;
   hookup.reset(syncer_thread()->relay_channel()->AddObserver(&listener));
 
   EXPECT_CALL(listener, HandleChannelEvent(
       Field(&SyncerEvent::what_happened, SyncerEvent::STATUS_CHANGED))).
       Times(AnyNumber());
 
   // Wait for the initial sync to complete.
   EXPECT_CALL(listener, HandleChannelEvent(
       Field(&SyncerEvent::what_happened, SyncerEvent::SYNC_CYCLE_ENDED))).
       WillOnce(SignalEvent(&sync_cycle_ended_event));
   ASSERT_TRUE(syncer_thread()->Start());
   metadb()->Open();
-  sync_cycle_ended_event.Wait();
+  ASSERT_TRUE(sync_cycle_ended_event.TimedWait(max_wait_time_));
 
   // Request a pause.
   ASSERT_TRUE(Pause(&listener));
 
   // Resuming the pause.
   ASSERT_TRUE(Resume(&listener));
 
   // Not paused, should fail.
   EXPECT_FALSE(syncer_thread()->RequestResume());
 
   // Request a pause.
   ASSERT_TRUE(Pause(&listener));
 
   // Nudge the syncer, this should do nothing while we are paused.
   syncer_thread()->NudgeSyncer(0, SyncerThread::kUnknown);
 
   // Resuming will cause the nudge to be processed and a sync cycle to run.
   EXPECT_CALL(listener, HandleChannelEvent(
       Field(&SyncerEvent::what_happened, SyncerEvent::SYNC_CYCLE_ENDED))).
       WillOnce(SignalEvent(&sync_cycle_ended_event));
   ASSERT_TRUE(Resume(&listener));
-  sync_cycle_ended_event.Wait();
+  ASSERT_TRUE(sync_cycle_ended_event.TimedWait(max_wait_time_));
 
   EXPECT_TRUE(syncer_thread()->Stop(2000));
 }
 
 TEST_F(SyncerThreadWithSyncerTest, StartWhenNotConnected) {
   WaitableEvent sync_cycle_ended_event(false, false);
   WaitableEvent event(false, false);
   ListenerMock listener;
   scoped_ptr<ChannelHookup<SyncerEvent> > hookup;
   hookup.reset(syncer_thread()->relay_channel()->AddObserver(&listener));
   PreventThreadFromPolling();
 
   EXPECT_CALL(listener, HandleChannelEvent(
       Field(&SyncerEvent::what_happened, SyncerEvent::STATUS_CHANGED))).
       Times(AnyNumber());
 
   connection()->SetServerNotReachable();
   metadb()->Open();
 
   // Syncer thread will always go through once cycle at the start,
   // then it will wait for a connection.
   EXPECT_CALL(listener, HandleChannelEvent(
       Field(&SyncerEvent::what_happened, SyncerEvent::SYNC_CYCLE_ENDED))).
       WillOnce(SignalEvent(&sync_cycle_ended_event));
   EXPECT_CALL(listener, HandleChannelEvent(
       Field(&SyncerEvent::what_happened, SyncerEvent::WAITING_FOR_CONNECTION))).
       WillOnce(SignalEvent(&event));
   ASSERT_TRUE(syncer_thread()->Start());
-  sync_cycle_ended_event.Wait();
-  event.Wait();
+  ASSERT_TRUE(sync_cycle_ended_event.TimedWait(max_wait_time_));
+  ASSERT_TRUE(event.TimedWait(max_wait_time_));
 
   // Connect, will put the syncer thread into its usually poll wait.
   EXPECT_CALL(listener, HandleChannelEvent(
       Field(&SyncerEvent::what_happened, SyncerEvent::CONNECTED))).
       WillOnce(SignalEvent(&event));
   connection()->SetServerReachable();
-  event.Wait();
+  ASSERT_TRUE(event.TimedWait(max_wait_time_));
 
   // Nudge the syncer to complete a cycle.
   EXPECT_CALL(listener, HandleChannelEvent(
       Field(&SyncerEvent::what_happened, SyncerEvent::SYNC_CYCLE_ENDED))).
       WillOnce(SignalEvent(&sync_cycle_ended_event));
   syncer_thread()->NudgeSyncer(0, SyncerThread::kUnknown);
-  sync_cycle_ended_event.Wait();
+  ASSERT_TRUE(sync_cycle_ended_event.TimedWait(max_wait_time_));
 
   EXPECT_TRUE(syncer_thread()->Stop(2000));
 }
 
-// See bug 39070.
+// TODO(skrul): See TODO comment on the "Pause" test above for an
+// explanation of the usage of FLAKY here.
 TEST_F(SyncerThreadWithSyncerTest, FLAKY_PauseWhenNotConnected) {
   WaitableEvent sync_cycle_ended_event(false, false);
   WaitableEvent event(false, false);
   ListenerMock listener;
   scoped_ptr<ChannelHookup<SyncerEvent> > hookup;
   hookup.reset(syncer_thread()->relay_channel()->AddObserver(&listener));
   PreventThreadFromPolling();
 
   EXPECT_CALL(listener, HandleChannelEvent(
       Field(&SyncerEvent::what_happened, SyncerEvent::STATUS_CHANGED))).
       Times(AnyNumber());
 
   // Put the thread into a "waiting for connection" state.
   connection()->SetServerNotReachable();
   EXPECT_CALL(listener, HandleChannelEvent(
       Field(&SyncerEvent::what_happened, SyncerEvent::SYNC_CYCLE_ENDED))).
       WillOnce(SignalEvent(&sync_cycle_ended_event));
   EXPECT_CALL(listener, HandleChannelEvent(
       Field(&SyncerEvent::what_happened, SyncerEvent::WAITING_FOR_CONNECTION))).
       WillOnce(SignalEvent(&event));
   metadb()->Open();
   ASSERT_TRUE(syncer_thread()->Start());
-  sync_cycle_ended_event.Wait();
-  event.Wait();
+  ASSERT_TRUE(sync_cycle_ended_event.TimedWait(max_wait_time_));
+  ASSERT_TRUE(event.TimedWait(max_wait_time_));
 
   // Pause and resume the thread while waiting for a connection.
   ASSERT_TRUE(Pause(&listener));
   ASSERT_TRUE(Resume(&listener));
 
   // Make a connection and let the syncer cycle.
   EXPECT_CALL(listener, HandleChannelEvent(
       Field(&SyncerEvent::what_happened, SyncerEvent::SYNC_CYCLE_ENDED))).
       WillOnce(SignalEvent(&sync_cycle_ended_event));
   EXPECT_CALL(listener, HandleChannelEvent(
       Field(&SyncerEvent::what_happened, SyncerEvent::CONNECTED))).
       WillOnce(SignalEvent(&event));
   connection()->SetServerReachable();
-  event.Wait();
+  ASSERT_TRUE(event.TimedWait(max_wait_time_));
   syncer_thread()->NudgeSyncer(0, SyncerThread::kUnknown);
-  sync_cycle_ended_event.Wait();
+  ASSERT_TRUE(sync_cycle_ended_event.TimedWait(max_wait_time_));
 
   // Disconnect and get into the waiting for a connection state.
   EXPECT_CALL(listener, HandleChannelEvent(
       Field(&SyncerEvent::what_happened, SyncerEvent::WAITING_FOR_CONNECTION))).
       WillOnce(SignalEvent(&event));
   connection()->SetServerNotReachable();
-  event.Wait();
+  ASSERT_TRUE(event.TimedWait(max_wait_time_));
 
   // Pause so we can test getting a connection while paused.
   ASSERT_TRUE(Pause(&listener));
 
   // Get a connection then resume.
   EXPECT_CALL(listener, HandleChannelEvent(
       Field(&SyncerEvent::what_happened, SyncerEvent::CONNECTED))).
       WillOnce(SignalEvent(&event));
   connection()->SetServerReachable();
-  event.Wait();
+  ASSERT_TRUE(event.TimedWait(max_wait_time_));
 
   ASSERT_TRUE(Resume(&listener));
 
   // Cycle the syncer to show we are not longer paused.
   EXPECT_CALL(listener, HandleChannelEvent(
       Field(&SyncerEvent::what_happened, SyncerEvent::SYNC_CYCLE_ENDED))).
       WillOnce(SignalEvent(&sync_cycle_ended_event));
   syncer_thread()->NudgeSyncer(0, SyncerThread::kUnknown);
-  sync_cycle_ended_event.Wait();
+  ASSERT_TRUE(sync_cycle_ended_event.TimedWait(max_wait_time_));
 
   EXPECT_TRUE(syncer_thread()->Stop(2000));
 }
 
 TEST_F(SyncerThreadWithSyncerTest, PauseResumeWhenNotRunning) {
   WaitableEvent sync_cycle_ended_event(false, false);
   WaitableEvent event(false, false);
   ListenerMock listener;
   scoped_ptr<ChannelHookup<SyncerEvent> > hookup;
   hookup.reset(syncer_thread()->relay_channel()->AddObserver(&listener));
@@ skipping 10 matching lines @@
   // Pause the thread then start the syncer.
   ASSERT_TRUE(Pause(&listener));
   metadb()->Open();
   ASSERT_TRUE(syncer_thread()->Start());
 
   // Resume and let the syncer cycle.
   EXPECT_CALL(listener, HandleChannelEvent(
       Field(&SyncerEvent::what_happened, SyncerEvent::SYNC_CYCLE_ENDED))).
       WillOnce(SignalEvent(&sync_cycle_ended_event));
   ASSERT_TRUE(Resume(&listener));
-  sync_cycle_ended_event.Wait();
+  ASSERT_TRUE(sync_cycle_ended_event.TimedWait(max_wait_time_));
 
   EXPECT_TRUE(syncer_thread()->Stop(2000));
 }
 
 }  // namespace browser_sync