The submillisecond test was broken in at least two ways. First, the...

base/time_win_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 <windows.h>
 #include <mmsystem.h>
 #include <process.h>
 
 #include "base/platform_thread.h"
 #include "base/time.h"
@@ skipping 90 matching lines @@
       EXPECT_EQ(rv, WAIT_OBJECT_0);
     }
 
     CloseHandle(g_rollover_test_start);
 
     // Teardown
     MockTimeTicks::UninstallTicker();
   }
 }
 
-// Flaky, http://crbug.com/42850.
-TEST(TimeTicks, FLAKY_SubMillisecondTimers) {
-  // Loop for a bit getting timers quickly.  We want to
-  // see at least one case where we get a new sample in
-  // less than one millisecond.
+TEST(TimeTicks, SubMillisecondTimers) {
+  // HighResNow doesn't work on some systems.  Since the product still works
+  // even if it doesn't work, it makes this entire test questionable.
+  if (!TimeTicks::IsHighResClockWorking())
+    return;
+
+  const int kRetries = 1000;
   bool saw_submillisecond_timer = false;
-  int64 min_timer = 1000;
-  TimeTicks last_time = TimeTicks::HighResNow();
+
+  // Run kRetries attempts to see a sub-millisecond timer.

[Paweł Hajdan Jr., 2010/09/22 09:35:32]

This test has still potential for flakiness. What if we tried to gather some
samples (1000? 10000?) and see if their statistical properties match
expectations (are within limits)? I think that should make the test more solid,
but I'm not really sure. What do you think?

[Mike Belshe, 2010/09/22 21:58:48]

Unfortunately, I don't think it helps.  In this case, we run 1000 samples
looking for just *one* that clocks in sub-millisecond.  If we don't get one
within 1000 tries, we give up.  I can't think of a way that statistical sampling
would work when just needing one doesn't.

   for (int index = 0; index < 1000; index++) {
-    TimeTicks now = TimeTicks::HighResNow();
-    TimeDelta delta = now - last_time;
-    if (delta.InMicroseconds() > 0 &&
-        delta.InMicroseconds() < 1000) {
-      if (min_timer > delta.InMicroseconds())
-        min_timer = delta.InMicroseconds();
+    TimeTicks last_time = TimeTicks::HighResNow();
+    TimeDelta delta;
+    // Spin until the clock changes a little

[Paweł Hajdan Jr., 2010/09/22 09:35:32]

nit: Dot at the end, and explain why.

[Mike Belshe, 2010/09/22 21:58:48]

Done.

+    do {
+      delta = TimeTicks::HighResNow() - last_time;
+    } while (delta.InMicroseconds() == 0);
+    if (delta.InMicroseconds() < 1000) {
       saw_submillisecond_timer = true;
+      break;
     }
-    last_time = now;
   }
   EXPECT_TRUE(saw_submillisecond_timer);
-  printf("Min timer is: %ldus\n", static_cast<long>(min_timer));
 }
 
 TEST(TimeTicks, TimeGetTimeCaps) {
   // Test some basic assumptions that we expect about how timeGetDevCaps works.
 
   TIMECAPS caps;
   MMRESULT status = timeGetDevCaps(&caps, sizeof(caps));
   EXPECT_EQ(TIMERR_NOERROR, status);
   if (status != TIMERR_NOERROR) {
     printf("Could not get timeGetDevCaps\n");
@@ skipping 81 matching lines @@
     total_drift += drift_microseconds;
   }
 
   // Sanity check. We expect some time drift to occur, especially across
   // the number of iterations we do. However, if the QPC is disabled, this
   // is not measuring anything (drift is zero in that case).
   EXPECT_LT(0, total_drift);
 
   printf("average time drift in microseconds: %lld\n",
          total_drift / kIterations);
-}
+}