Deleted OS_WIN and all Windows specific files from base.

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 <cmath>
-#include <limits>
-#include <vector>
-
-#include "base/threading/platform_thread.h"
-#include "base/time/time.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-using base::Time;
-using base::TimeDelta;
-using base::TimeTicks;
-using base::TraceTicks;
-
-namespace {
-
-class MockTimeTicks : public TimeTicks {
- public:
-  static DWORD Ticker() {
-    return static_cast<int>(InterlockedIncrement(&ticker_));
-  }
-
-  static void InstallTicker() {
-    old_tick_function_ = SetMockTickFunction(&Ticker);
-    ticker_ = -5;
-  }
-
-  static void UninstallTicker() {
-    SetMockTickFunction(old_tick_function_);
-  }
-
- private:
-  static volatile LONG ticker_;
-  static TickFunctionType old_tick_function_;
-};
-
-volatile LONG MockTimeTicks::ticker_;
-MockTimeTicks::TickFunctionType MockTimeTicks::old_tick_function_;
-
-HANDLE g_rollover_test_start;
-
-unsigned __stdcall RolloverTestThreadMain(void* param) {
-  int64 counter = reinterpret_cast<int64>(param);
-  DWORD rv = WaitForSingleObject(g_rollover_test_start, INFINITE);
-  EXPECT_EQ(rv, WAIT_OBJECT_0);
-
-  TimeTicks last = TimeTicks::Now();
-  for (int index = 0; index < counter; index++) {
-    TimeTicks now = TimeTicks::Now();
-    int64 milliseconds = (now - last).InMilliseconds();
-    // This is a tight loop; we could have looped faster than our
-    // measurements, so the time might be 0 millis.
-    EXPECT_GE(milliseconds, 0);
-    EXPECT_LT(milliseconds, 250);
-    last = now;
-  }
-  return 0;
-}
-
-}  // namespace
-
-TEST(TimeTicks, WinRollover) {
-  // The internal counter rolls over at ~49days.  We'll use a mock
-  // timer to test this case.
-  // Basic test algorithm:
-  //   1) Set clock to rollover - N
-  //   2) Create N threads
-  //   3) Start the threads
-  //   4) Each thread loops through TimeTicks() N times
-  //   5) Each thread verifies integrity of result.
-
-  const int kThreads = 8;
-  // Use int64 so we can cast into a void* without a compiler warning.
-  const int64 kChecks = 10;
-
-  // It takes a lot of iterations to reproduce the bug!
-  // (See bug 1081395)
-  for (int loop = 0; loop < 4096; loop++) {
-    // Setup
-    MockTimeTicks::InstallTicker();
-    g_rollover_test_start = CreateEvent(0, TRUE, FALSE, 0);
-    HANDLE threads[kThreads];
-
-    for (int index = 0; index < kThreads; index++) {
-      void* argument = reinterpret_cast<void*>(kChecks);
-      unsigned thread_id;
-      threads[index] = reinterpret_cast<HANDLE>(
-        _beginthreadex(NULL, 0, RolloverTestThreadMain, argument, 0,
-          &thread_id));
-      EXPECT_NE((HANDLE)NULL, threads[index]);
-    }
-
-    // Start!
-    SetEvent(g_rollover_test_start);
-
-    // Wait for threads to finish
-    for (int index = 0; index < kThreads; index++) {
-      DWORD rv = WaitForSingleObject(threads[index], INFINITE);
-      EXPECT_EQ(rv, WAIT_OBJECT_0);
-      // Since using _beginthreadex() (as opposed to _beginthread),
-      // an explicit CloseHandle() is supposed to be called.
-      CloseHandle(threads[index]);
-    }
-
-    CloseHandle(g_rollover_test_start);
-
-    // Teardown
-    MockTimeTicks::UninstallTicker();
-  }
-}
-
-TEST(TimeTicks, SubMillisecondTimers) {
-  // IsHighResolution() is false on some systems.  Since the product still works
-  // even if it's false, it makes this entire test questionable.
-  if (!TimeTicks::IsHighResolution())
-    return;
-
-  const int kRetries = 1000;
-  bool saw_submillisecond_timer = false;
-
-  // Run kRetries attempts to see a sub-millisecond timer.
-  for (int index = 0; index < kRetries; index++) {
-    TimeTicks last_time = TimeTicks::Now();
-    TimeDelta delta;
-    // Spin until the clock has detected a change.
-    do {
-      delta = TimeTicks::Now() - last_time;
-    } while (delta.InMicroseconds() == 0);
-    if (delta.InMicroseconds() < 1000) {
-      saw_submillisecond_timer = true;
-      break;
-    }
-  }
-  EXPECT_TRUE(saw_submillisecond_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");
-    return;
-  }
-
-  EXPECT_GE(static_cast<int>(caps.wPeriodMin), 1);
-  EXPECT_GT(static_cast<int>(caps.wPeriodMax), 1);
-  EXPECT_GE(static_cast<int>(caps.wPeriodMin), 1);
-  EXPECT_GT(static_cast<int>(caps.wPeriodMax), 1);
-  printf("timeGetTime range is %d to %dms\n", caps.wPeriodMin,
-    caps.wPeriodMax);
-}
-
-TEST(TimeTicks, QueryPerformanceFrequency) {
-  // Test some basic assumptions that we expect about QPC.
-
-  LARGE_INTEGER frequency;
-  BOOL rv = QueryPerformanceFrequency(&frequency);
-  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;
-
-  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" },
-    { reinterpret_cast<TestFunc>(&TraceTicks::Now), "TraceTicks::Now" },
-    { NULL, "" }
-  };
-
-  int test_case = 0;
-  while (cases[test_case].func) {
-    TimeTicks start = TimeTicks::Now();
-    for (int index = 0; index < kLoops; index++)
-      cases[test_case].func();
-    TimeTicks stop = TimeTicks::Now();
-    // 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++;
-  }
-}
-
-TEST(TimeTicks, FromQPCValue) {
-  if (!TimeTicks::IsHighResolution())
-    return;
-
-  LARGE_INTEGER frequency;
-  ASSERT_TRUE(QueryPerformanceFrequency(&frequency));
-  const int64 ticks_per_second = frequency.QuadPart;
-  ASSERT_GT(ticks_per_second, 0);
-
-  // Generate the tick values to convert, advancing the tick count by varying
-  // amounts.  These values will ensure that both the fast and overflow-safe
-  // conversion logic in FromQPCValue() is tested, and across the entire range
-  // of possible QPC tick values.
-  std::vector<int64> test_cases;
-  test_cases.push_back(0);
-  const int kNumAdvancements = 100;
-  int64 ticks = 0;
-  int64 ticks_increment = 10;
-  for (int i = 0; i < kNumAdvancements; ++i) {
-    test_cases.push_back(ticks);
-    ticks += ticks_increment;
-    ticks_increment = ticks_increment * 6 / 5;
-  }
-  test_cases.push_back(Time::kQPCOverflowThreshold - 1);
-  test_cases.push_back(Time::kQPCOverflowThreshold);
-  test_cases.push_back(Time::kQPCOverflowThreshold + 1);
-  ticks = Time::kQPCOverflowThreshold + 10;
-  ticks_increment = 10;
-  for (int i = 0; i < kNumAdvancements; ++i) {
-    test_cases.push_back(ticks);
-    ticks += ticks_increment;
-    ticks_increment = ticks_increment * 6 / 5;
-  }
-  test_cases.push_back(std::numeric_limits<int64>::max());
-
-  // Test that the conversions using FromQPCValue() match those computed here
-  // using simple floating-point arithmetic.  The floating-point math provides
-  // enough precision to confirm the implementation is correct to the
-  // microsecond for all |test_cases| (though it would be insufficient to
-  // confirm many "very large" tick values which are not being tested here).
-  for (int64 ticks : test_cases) {
-    const double expected_microseconds_since_origin =
-        (static_cast<double>(ticks) * Time::kMicrosecondsPerSecond) /
-            ticks_per_second;
-    const TimeTicks converted_value = TimeTicks::FromQPCValue(ticks);
-    const double converted_microseconds_since_origin =
-        static_cast<double>((converted_value - TimeTicks()).InMicroseconds());
-    EXPECT_NEAR(expected_microseconds_since_origin,
-                converted_microseconds_since_origin,
-                1.0)
-        << "ticks=" << ticks << ", to be converted via logic path: "
-        << (ticks < Time::kQPCOverflowThreshold ? "FAST" : "SAFE");
-  }
-}