Fix more disabled MSVC warnings, base/ edition.

base/time/time_win_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 <windows.h>
 #include <mmsystem.h>
 #include <process.h>
 
 #include "base/threading/platform_thread.h"
 #include "base/time/time.h"
@@ skipping 103 matching lines @@
 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;
 
   // Run kRetries attempts to see a sub-millisecond timer.
-  for (int index = 0; index < 1000; index++) {
+  for (int index = 0; index < kRetries; index++) {
     TimeTicks last_time = TimeTicks::HighResNow();
     TimeDelta delta;
     // Spin until the clock has detected a change.
     do {
       delta = TimeTicks::HighResNow() - last_time;
     } while (delta.InMicroseconds() == 0);
     if (delta.InMicroseconds() < 1000) {
       saw_submillisecond_timer = true;
       break;
     }
@@ skipping 28 matching lines @@
   EXPECT_EQ(TRUE, rv);
   EXPECT_GT(frequency.QuadPart, 1000000);  // Expect at least 1MHz
   printf("QueryPerformanceFrequency is %5.2fMHz\n",
     frequency.QuadPart / 1000000.0);
 }
 
 TEST(TimeTicks, TimerPerformance) {
   // Verify that various timer mechanisms can always complete quickly.
   // Note:  This is a somewhat arbitrary test.
   const int kLoops = 10000;
-  // Due to the fact that these run on bbots, which are horribly slow,
-  // we can't really make any guarantees about minimum runtime.
-  // Really, we want these to finish in ~10ms, and that is generous.
-  const int kMaxTime = 35;  // Maximum acceptible milliseconds for test.
 
   typedef TimeTicks (*TestFunc)();
   struct TestCase {
     TestFunc func;
     const char *description;
   };
   // Cheating a bit here:  assumes sizeof(TimeTicks) == sizeof(Time)
   // in order to create a single test case list.
   COMPILE_ASSERT(sizeof(TimeTicks) == sizeof(Time),
                  test_only_works_with_same_sizes);
   TestCase cases[] = {
     { reinterpret_cast<TestFunc>(Time::Now), "Time::Now" },
     { TimeTicks::Now, "TimeTicks::Now" },
     { TimeTicks::HighResNow, "TimeTicks::HighResNow" },
     { NULL, "" }
   };
 
   int test_case = 0;
   while (cases[test_case].func) {
     TimeTicks start = TimeTicks::HighResNow();
     for (int index = 0; index < kLoops; index++)
       cases[test_case].func();
     TimeTicks stop = TimeTicks::HighResNow();
     // Turning off the check for acceptible delays.  Without this check,
     // the test really doesn't do much other than measure.  But the
     // measurements are still useful for testing timers on various platforms.
     // The reason to remove the check is because the tests run on many
     // buildbots, some of which are VMs.  These machines can run horribly
     // slow, and there is really no value for checking against a max timer.
+    //const int kMaxTime = 35;  // Maximum acceptible milliseconds for test.
     //EXPECT_LT((stop - start).InMilliseconds(), kMaxTime);
     printf("%s: %1.2fus per call\n", cases[test_case].description,
       (stop - start).InMillisecondsF() * 1000 / kLoops);
     test_case++;
   }
 }
 
 // http://crbug.com/396384
 TEST(TimeTicks, DISABLED_Drift) {
   // If QPC is disabled, this isn't measuring anything.
@@ skipping 48 matching lines @@
   EXPECT_EQ(expected_value,
             TimeTicks::FromQPCValue(qpc_value + 1));
   expected_value = TimeTicks::FromInternalValue(
     QPCValueToMicrosecondsSafely(qpc_value, ticks_per_second));
   EXPECT_EQ(expected_value,
             TimeTicks::FromQPCValue(qpc_value));
   expected_value = TimeTicks::FromInternalValue(
     QPCValueToMicrosecondsSafely(qpc_value - 1, ticks_per_second));
   EXPECT_EQ(expected_value,
             TimeTicks::FromQPCValue(qpc_value - 1));
-}
+}