The Tor Browser: comparison security/sandbox/chromium/base/time/time

--1:000000000000
+:9ed47bdea9cf
+// 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.
+// Windows Timer Primer
+//
+// A good article:  http://www.ddj.com/windows/184416651
+// A good mozilla bug:  http://bugzilla.mozilla.org/show_bug.cgi?id=363258
+//
+// The default windows timer, GetSystemTimeAsFileTime is not very precise.
+// It is only good to ~15.5ms.
+//
+// QueryPerformanceCounter is the logical choice for a high-precision timer.
+// However, it is known to be buggy on some hardware.  Specifically, it can
+// sometimes "jump".  On laptops, QPC can also be very expensive to call.
+// It's 3-4x slower than timeGetTime() on desktops, but can be 10x slower
+// on laptops.  A unittest exists which will show the relative cost of various
+// timers on any system.
+//
+// The next logical choice is timeGetTime().  timeGetTime has a precision of
+// 1ms, but only if you call APIs (timeBeginPeriod()) which affect all other
+// applications on the system.  By default, precision is only 15.5ms.
+// Unfortunately, we don't want to call timeBeginPeriod because we don't
+// want to affect other applications.  Further, on mobile platforms, use of
+// faster multimedia timers can hurt battery life.  See the intel
+// article about this here:
+// http://softwarecommunity.intel.com/articles/eng/1086.htm
+//
+// To work around all this, we're going to generally use timeGetTime().  We
+// will only increase the system-wide timer if we're not running on battery
+// power.  Using timeBeginPeriod(1) is a requirement in order to make our
+// message loop waits have the same resolution that our time measurements
+// do.  Otherwise, WaitForSingleObject(..., 1) will no less than 15ms when
+// there is nothing else to waken the Wait.
+#include "base/time/time.h"
+#pragma comment(lib, "winmm.lib")
+#include <windows.h>
+#include <mmsystem.h>
+#include "base/basictypes.h"
+#include "base/cpu.h"
+#include "base/logging.h"
+#include "base/memory/singleton.h"
+#include "base/synchronization/lock.h"
+using base::Time;
+using base::TimeDelta;
+using base::TimeTicks;
+namespace {
+// From MSDN, FILETIME "Contains a 64-bit value representing the number of
+// 100-nanosecond intervals since January 1, 1601 (UTC)."
+int64 FileTimeToMicroseconds(const FILETIME& ft) {
+// Need to bit_cast to fix alignment, then divide by 10 to convert
+// 100-nanoseconds to milliseconds. This only works on little-endian
+// machines.
+return bit_cast<int64, FILETIME>(ft) / 10;
+}
+void MicrosecondsToFileTime(int64 us, FILETIME* ft) {
+DCHECK_GE(us, 0LL) << "Time is less than 0, negative values are not "
+"representable in FILETIME";
+// Multiply by 10 to convert milliseconds to 100-nanoseconds. Bit_cast will
+// handle alignment problems. This only works on little-endian machines.
+*ft = bit_cast<FILETIME, int64>(us * 10);
+}
+int64 CurrentWallclockMicroseconds() {
+FILETIME ft;
+::GetSystemTimeAsFileTime(&ft);
+return FileTimeToMicroseconds(ft);
+}
+// Time between resampling the un-granular clock for this API.  60 seconds.
+const int kMaxMillisecondsToAvoidDrift = 60 * Time::kMillisecondsPerSecond;
+int64 initial_time = 0;
+TimeTicks initial_ticks;
+void InitializeClock() {
+initial_ticks = TimeTicks::Now();
+initial_time = CurrentWallclockMicroseconds();
+}
+}  // namespace
+// Time -----------------------------------------------------------------------
+// The internal representation of Time uses FILETIME, whose epoch is 1601-01-01
+// 00:00:00 UTC.  ((1970-1601)*365+89)*24*60*60*1000*1000, where 89 is the
+// number of leap year days between 1601 and 1970: (1970-1601)/4 excluding
+// 1700, 1800, and 1900.
+// static
+const int64 Time::kTimeTToMicrosecondsOffset = GG_INT64_C(11644473600000000);
+bool Time::high_resolution_timer_enabled_ = false;
+int Time::high_resolution_timer_activated_ = 0;
+// static
+Time Time::Now() {
+if (initial_time == 0)
+InitializeClock();
+// We implement time using the high-resolution timers so that we can get
+// timeouts which are smaller than 10-15ms.  If we just used
+// CurrentWallclockMicroseconds(), we'd have the less-granular timer.
+//
+// To make this work, we initialize the clock (initial_time) and the
+// counter (initial_ctr).  To compute the initial time, we can check
+// the number of ticks that have elapsed, and compute the delta.
+//
+// To avoid any drift, we periodically resync the counters to the system
+// clock.
+while (true) {
+TimeTicks ticks = TimeTicks::Now();
+// Calculate the time elapsed since we started our timer
+TimeDelta elapsed = ticks - initial_ticks;
+// Check if enough time has elapsed that we need to resync the clock.
+if (elapsed.InMilliseconds() > kMaxMillisecondsToAvoidDrift) {
+InitializeClock();
+continue;
+}
+return Time(elapsed + Time(initial_time));
+}
+}
+// static
+Time Time::NowFromSystemTime() {
+// Force resync.
+InitializeClock();
+return Time(initial_time);
+}
+// static
+Time Time::FromFileTime(FILETIME ft) {
+if (bit_cast<int64, FILETIME>(ft) == 0)
+return Time();
+if (ft.dwHighDateTime == std::numeric_limits<DWORD>::max() &&
+ft.dwLowDateTime == std::numeric_limits<DWORD>::max())
+return Max();
+return Time(FileTimeToMicroseconds(ft));
+}
+FILETIME Time::ToFileTime() const {
+if (is_null())
+return bit_cast<FILETIME, int64>(0);
+if (is_max()) {
+FILETIME result;
+result.dwHighDateTime = std::numeric_limits<DWORD>::max();
+result.dwLowDateTime = std::numeric_limits<DWORD>::max();
+return result;
+}
+FILETIME utc_ft;
+MicrosecondsToFileTime(us_, &utc_ft);
+return utc_ft;
+}
+// static
+void Time::EnableHighResolutionTimer(bool enable) {
+// Test for single-threaded access.
+static PlatformThreadId my_thread = PlatformThread::CurrentId();
+DCHECK(PlatformThread::CurrentId() == my_thread);
+if (high_resolution_timer_enabled_ == enable)
+return;
+high_resolution_timer_enabled_ = enable;
+}
+// static
+bool Time::ActivateHighResolutionTimer(bool activating) {
+if (!high_resolution_timer_enabled_ && activating)
+return false;
+// Using anything other than 1ms makes timers granular
+// to that interval.
+const int kMinTimerIntervalMs = 1;
+MMRESULT result;
+if (activating) {
+result = timeBeginPeriod(kMinTimerIntervalMs);
+high_resolution_timer_activated_++;
+} else {
+result = timeEndPeriod(kMinTimerIntervalMs);
+high_resolution_timer_activated_--;
+}
+return result == TIMERR_NOERROR;
+}
+// static
+bool Time::IsHighResolutionTimerInUse() {
+// Note:  we should track the high_resolution_timer_activated_ value
+// under a lock if we want it to be accurate in a system with multiple
+// message loops.  We don't do that - because we don't want to take the
+// expense of a lock for this.  We *only* track this value so that unit
+// tests can see if the high resolution timer is on or off.
+return high_resolution_timer_enabled_ &&
+high_resolution_timer_activated_ > 0;
+}
+// static
+Time Time::FromExploded(bool is_local, const Exploded& exploded) {
+// Create the system struct representing our exploded time. It will either be
+// in local time or UTC.
+SYSTEMTIME st;
+st.wYear = exploded.year;
+st.wMonth = exploded.month;
+st.wDayOfWeek = exploded.day_of_week;
+st.wDay = exploded.day_of_month;
+st.wHour = exploded.hour;
+st.wMinute = exploded.minute;
+st.wSecond = exploded.second;
+st.wMilliseconds = exploded.millisecond;
+FILETIME ft;
+bool success = true;
+// Ensure that it's in UTC.
+if (is_local) {
+SYSTEMTIME utc_st;
+success = TzSpecificLocalTimeToSystemTime(NULL, &st, &utc_st) &&
+SystemTimeToFileTime(&utc_st, &ft);
+} else {
+success = !!SystemTimeToFileTime(&st, &ft);
+}
+if (!success) {
+NOTREACHED() << "Unable to convert time";
+return Time(0);
+}
+return Time(FileTimeToMicroseconds(ft));
+}
+void Time::Explode(bool is_local, Exploded* exploded) const {
+if (us_ < 0LL) {
+// We are not able to convert it to FILETIME.
+ZeroMemory(exploded, sizeof(*exploded));
+return;
+}
+// FILETIME in UTC.
+FILETIME utc_ft;
+MicrosecondsToFileTime(us_, &utc_ft);
+// FILETIME in local time if necessary.
+bool success = true;
+// FILETIME in SYSTEMTIME (exploded).
+SYSTEMTIME st;
+if (is_local) {
+SYSTEMTIME utc_st;
+// We don't use FileTimeToLocalFileTime here, since it uses the current
+// settings for the time zone and daylight saving time. Therefore, if it is
+// daylight saving time, it will take daylight saving time into account,
+// even if the time you are converting is in standard time.
+success = FileTimeToSystemTime(&utc_ft, &utc_st) &&
+SystemTimeToTzSpecificLocalTime(NULL, &utc_st, &st);
+} else {
+success = !!FileTimeToSystemTime(&utc_ft, &st);
+}
+if (!success) {
+NOTREACHED() << "Unable to convert time, don't know why";
+ZeroMemory(exploded, sizeof(*exploded));
+return;
+}
+exploded->year = st.wYear;
+exploded->month = st.wMonth;
+exploded->day_of_week = st.wDayOfWeek;
+exploded->day_of_month = st.wDay;
+exploded->hour = st.wHour;
+exploded->minute = st.wMinute;
+exploded->second = st.wSecond;
+exploded->millisecond = st.wMilliseconds;
+}
+// TimeTicks ------------------------------------------------------------------
+namespace {
+// We define a wrapper to adapt between the __stdcall and __cdecl call of the
+// mock function, and to avoid a static constructor.  Assigning an import to a
+// function pointer directly would require setup code to fetch from the IAT.
+DWORD timeGetTimeWrapper() {
+return timeGetTime();
+}
+DWORD (*tick_function)(void) = &timeGetTimeWrapper;
+// Accumulation of time lost due to rollover (in milliseconds).
+int64 rollover_ms = 0;
+// The last timeGetTime value we saw, to detect rollover.
+DWORD last_seen_now = 0;
+// Lock protecting rollover_ms and last_seen_now.
+// Note: this is a global object, and we usually avoid these. However, the time
+// code is low-level, and we don't want to use Singletons here (it would be too
+// easy to use a Singleton without even knowing it, and that may lead to many
+// gotchas). Its impact on startup time should be negligible due to low-level
+// nature of time code.
+base::Lock rollover_lock;
+// We use timeGetTime() to implement TimeTicks::Now().  This can be problematic
+// because it returns the number of milliseconds since Windows has started,
+// which will roll over the 32-bit value every ~49 days.  We try to track
+// rollover ourselves, which works if TimeTicks::Now() is called at least every
+// 49 days.
+TimeDelta RolloverProtectedNow() {
+base::AutoLock locked(rollover_lock);
+// We should hold the lock while calling tick_function to make sure that
+// we keep last_seen_now stay correctly in sync.
+DWORD now = tick_function();
+if (now < last_seen_now)
+rollover_ms += 0x100000000I64;  // ~49.7 days.
+last_seen_now = now;
+return TimeDelta::FromMilliseconds(now + rollover_ms);
+}
+bool IsBuggyAthlon(const base::CPU& cpu) {
+// On Athlon X2 CPUs (e.g. model 15) QueryPerformanceCounter is
+// unreliable.  Fallback to low-res clock.
+return cpu.vendor_name() == "AuthenticAMD" && cpu.family() == 15;
+}
+// Overview of time counters:
+// (1) CPU cycle counter. (Retrieved via RDTSC)
+// The CPU counter provides the highest resolution time stamp and is the least
+// expensive to retrieve. However, the CPU counter is unreliable and should not
+// be used in production. Its biggest issue is that it is per processor and it
+// is not synchronized between processors. Also, on some computers, the counters
+// will change frequency due to thermal and power changes, and stop in some
+// states.
+//
+// (2) QueryPerformanceCounter (QPC). The QPC counter provides a high-
+// resolution (100 nanoseconds) time stamp but is comparatively more expensive
+// to retrieve. What QueryPerformanceCounter actually does is up to the HAL.
+// (with some help from ACPI).
+// According to http://blogs.msdn.com/oldnewthing/archive/2005/09/02/459952.aspx
+// in the worst case, it gets the counter from the rollover interrupt on the
+// programmable interrupt timer. In best cases, the HAL may conclude that the
+// RDTSC counter runs at a constant frequency, then it uses that instead. On
+// multiprocessor machines, it will try to verify the values returned from
+// RDTSC on each processor are consistent with each other, and apply a handful
+// of workarounds for known buggy hardware. In other words, QPC is supposed to
+// give consistent result on a multiprocessor computer, but it is unreliable in
+// reality due to bugs in BIOS or HAL on some, especially old computers.
+// With recent updates on HAL and newer BIOS, QPC is getting more reliable but
+// it should be used with caution.
+//
+// (3) System time. The system time provides a low-resolution (typically 10ms
+// to 55 milliseconds) time stamp but is comparatively less expensive to
+// retrieve and more reliable.
+class HighResNowSingleton {
+public:
+static HighResNowSingleton* GetInstance() {
+return Singleton<HighResNowSingleton>::get();
+}
+bool IsUsingHighResClock() {
+return ticks_per_second_ != 0.0;
+}
+void DisableHighResClock() {
+ticks_per_second_ = 0.0;
+}
+TimeDelta Now() {
+if (IsUsingHighResClock())
+return TimeDelta::FromMicroseconds(UnreliableNow());
+// Just fallback to the slower clock.
+return RolloverProtectedNow();
+}
+int64 GetQPCDriftMicroseconds() {
+if (!IsUsingHighResClock())
+return 0;
+return abs((UnreliableNow() - ReliableNow()) - skew_);
+}
+int64 QPCValueToMicroseconds(LONGLONG qpc_value) {
+if (!ticks_per_second_)
+return 0;
+// Intentionally calculate microseconds in a round about manner to avoid
+// overflow and precision issues. Think twice before simplifying!
+int64 whole_seconds = qpc_value / ticks_per_second_;
+int64 leftover_ticks = qpc_value % ticks_per_second_;
+int64 microseconds = (whole_seconds * Time::kMicrosecondsPerSecond) +
+((leftover_ticks * Time::kMicrosecondsPerSecond) /
+ticks_per_second_);
+return microseconds;
+}
+private:
+HighResNowSingleton()
+: ticks_per_second_(0),
+skew_(0) {
+InitializeClock();
+base::CPU cpu;
+if (IsBuggyAthlon(cpu))
+DisableHighResClock();
+}
+// Synchronize the QPC clock with GetSystemTimeAsFileTime.
+void InitializeClock() {
+LARGE_INTEGER ticks_per_sec = {0};
+if (!QueryPerformanceFrequency(&ticks_per_sec))
+return;  // Broken, we don't guarantee this function works.
+ticks_per_second_ = ticks_per_sec.QuadPart;
+skew_ = UnreliableNow() - ReliableNow();
+}
+// Get the number of microseconds since boot in an unreliable fashion.
+int64 UnreliableNow() {
+LARGE_INTEGER now;
+QueryPerformanceCounter(&now);
+return QPCValueToMicroseconds(now.QuadPart);
+}
+// Get the number of microseconds since boot in a reliable fashion.
+int64 ReliableNow() {
+return RolloverProtectedNow().InMicroseconds();
+}
+int64 ticks_per_second_;  // 0 indicates QPF failed and we're broken.
+int64 skew_;  // Skew between lo-res and hi-res clocks (for debugging).
+friend struct DefaultSingletonTraits<HighResNowSingleton>;
+};
+TimeDelta HighResNowWrapper() {
+return HighResNowSingleton::GetInstance()->Now();
+}
+typedef TimeDelta (*NowFunction)(void);
+NowFunction now_function = RolloverProtectedNow;
+bool CPUReliablySupportsHighResTime() {
+base::CPU cpu;
+if (!cpu.has_non_stop_time_stamp_counter())
+return false;
+if (IsBuggyAthlon(cpu))
+return false;
+return true;
+}
+}  // namespace
+// static
+TimeTicks::TickFunctionType TimeTicks::SetMockTickFunction(
+TickFunctionType ticker) {
+base::AutoLock locked(rollover_lock);
+TickFunctionType old = tick_function;
+tick_function = ticker;
+rollover_ms = 0;
+last_seen_now = 0;
+return old;
+}
+// static
+bool TimeTicks::SetNowIsHighResNowIfSupported() {
+if (!CPUReliablySupportsHighResTime()) {
+return false;
+}
+now_function = HighResNowWrapper;
+return true;
+}
+// static
+TimeTicks TimeTicks::Now() {
+return TimeTicks() + now_function();
+}
+// static
+TimeTicks TimeTicks::HighResNow() {
+return TimeTicks() + HighResNowSingleton::GetInstance()->Now();
+}
+// static
+TimeTicks TimeTicks::ThreadNow() {
+NOTREACHED();
+return TimeTicks();
+}
+// static
+TimeTicks TimeTicks::NowFromSystemTraceTime() {
+return HighResNow();
+}
+// static
+int64 TimeTicks::GetQPCDriftMicroseconds() {
+return HighResNowSingleton::GetInstance()->GetQPCDriftMicroseconds();
+}
+// static
+TimeTicks TimeTicks::FromQPCValue(LONGLONG qpc_value) {
+return TimeTicks(
+HighResNowSingleton::GetInstance()->QPCValueToMicroseconds(qpc_value));
+}
+// static
+bool TimeTicks::IsHighResClockWorking() {
+return HighResNowSingleton::GetInstance()->IsUsingHighResClock();
+}
+TimeTicks TimeTicks::UnprotectedNow() {
+if (now_function == HighResNowWrapper) {
+return Now();
+} else {
+return TimeTicks() + TimeDelta::FromMilliseconds(timeGetTime());
+}
+}
+// TimeDelta ------------------------------------------------------------------
+// static
+TimeDelta TimeDelta::FromQPCValue(LONGLONG qpc_value) {
+return TimeDelta(
+HighResNowSingleton::GetInstance()->QPCValueToMicroseconds(qpc_value));
+}

The Tor Browser / file comparison

comparison: security/sandbox/chromium/base/time/time_win.cc

security/sandbox/chromium/base/time/time_win.cc