v8::base::Win32Time Class Reference

Collaboration diagram for v8::base::Win32Time:

Classes
union	TimeStamp

Public Member Functions
	Win32Time ()
	Win32Time (double jstime)
	Win32Time (int year, int mon, int day, int hour, int min, int sec)
double	ToJSTime ()
void	SetToCurrentTime ()
int64_t	LocalOffset (TimezoneCache *cache)
int64_t	DaylightSavingsOffset (TimezoneCache *cache)
char *	LocalTimezone (TimezoneCache *cache)

Private Member Functions
bool	InDST (TimezoneCache *cache)
FILETIME &	ft ()
int64_t &	t ()

Private Attributes
TimeStamp	time_

Static Private Attributes
static const int64_t	kTimeEpoc = 116444736000000000LL
static const int64_t	kTimeScaler = 10000
static const int64_t	kMsPerMinute = 60000
static const bool	kShortTzNames = false

Detailed Description

Definition at line 214 of file platform-win32.cc.

Constructor & Destructor Documentation

Win32Time() [1/3]

v8::base::Win32Time::Win32Time

(

)

Definition at line 274 of file platform-win32.cc.

                     {
  t() = 0;
}

References t().

Here is the call graph for this function:

Win32Time() [2/3]

v8::base::Win32Time::Win32Time ( double  jstime )

explicit

Definition at line 280 of file platform-win32.cc.

                                  {
  t() = static_cast<int64_t>(jstime) * kTimeScaler + kTimeEpoc;
}

References kTimeEpoc, kTimeScaler, and t().

Here is the call graph for this function:

Win32Time() [3/3]

v8::base::Win32Time::Win32Time	(	int	year,
		int	mon,
		int	day,
		int	hour,
		int	min,
		int	sec
	)

Definition at line 286 of file platform-win32.cc.

                                                                           {
  SYSTEMTIME st;
  st.wYear = year;
  st.wMonth = mon;
  st.wDay = day;
  st.wHour = hour;
  st.wMinute = min;
  st.wSecond = sec;
  st.wMilliseconds = 0;
  SystemTimeToFileTime(&st, &ft());
}

References ft(), and v8::internal::min().

Here is the call graph for this function:

Member Function Documentation

DaylightSavingsOffset()

int64_t v8::base::Win32Time::DaylightSavingsOffset

(

TimezoneCache *

cache

)

Definition at line 425 of file platform-win32.cc.

                                                             {
  return InDST(cache) ? 60 * kMsPerMinute : 0;
}

References InDST(), and kMsPerMinute.

Here is the call graph for this function:

ft()

FILETIME& v8::base::Win32Time::ft ( )

inlineprivate

Definition at line 254 of file platform-win32.cc.

{ return time_.ft_; }

References v8::base::Win32Time::TimeStamp::ft_, and time_.

Referenced by Win32Time().

Here is the caller graph for this function:

InDST()

bool v8::base::Win32Time::InDST ( TimezoneCache *  cache )

private

Definition at line 400 of file platform-win32.cc.

                                          {
  cache->InitializeIfNeeded();
 
  // Determine if DST is in effect at the specified time.
  bool in_dst = false;
  if (cache->tzinfo_.StandardDate.wMonth != 0 ||
      cache->tzinfo_.DaylightDate.wMonth != 0) {
    // Get the local timezone offset for the timestamp in milliseconds.
    int64_t offset = LocalOffset(cache);
 
    // Compute the offset for DST. The bias parameters in the timezone info
    // are specified in minutes. These must be converted to milliseconds.
    int64_t dstofs =
        -(cache->tzinfo_.Bias + cache->tzinfo_.DaylightBias) * kMsPerMinute;
 
    // If the local time offset equals the timezone bias plus the daylight
    // bias then DST is in effect.
    in_dst = offset == dstofs;
  }
 
  return in_dst;
}

References v8::base::TimezoneCache::InitializeIfNeeded(), kMsPerMinute, LocalOffset(), and v8::base::TimezoneCache::tzinfo_.

Referenced by DaylightSavingsOffset(), and LocalTimezone().

Here is the call graph for this function:

Here is the caller graph for this function:

LocalOffset()

int64_t v8::base::Win32Time::LocalOffset

(

TimezoneCache *

cache

)

Definition at line 366 of file platform-win32.cc.

                                                   {
  cache->InitializeIfNeeded();
 
  Win32Time rounded_to_second(*this);
  rounded_to_second.t() = rounded_to_second.t() / 1000 / kTimeScaler *
      1000 * kTimeScaler;
  // Convert to local time using POSIX localtime function.
  // Windows XP Service Pack 3 made SystemTimeToTzSpecificLocalTime()
  // very slow.  Other browsers use localtime().
 
  // Convert from JavaScript milliseconds past 1/1/1970 0:00:00 to
  // POSIX seconds past 1/1/1970 0:00:00.
  double unchecked_posix_time = rounded_to_second.ToJSTime() / 1000;
  if (unchecked_posix_time > INT_MAX || unchecked_posix_time < 0) {
    return 0;
  }
  // Because _USE_32BIT_TIME_T is defined, time_t is a 32-bit int.
  time_t posix_time = static_cast<time_t>(unchecked_posix_time);
 
  // Convert to local time, as struct with fields for day, hour, year, etc.
  tm posix_local_time_struct;
  if (localtime_s(&posix_local_time_struct, &posix_time)) return 0;
 
  if (posix_local_time_struct.tm_isdst > 0) {
    return (cache->tzinfo_.Bias + cache->tzinfo_.DaylightBias) * -kMsPerMinute;
  } else if (posix_local_time_struct.tm_isdst == 0) {
    return (cache->tzinfo_.Bias + cache->tzinfo_.StandardBias) * -kMsPerMinute;
  } else {
    return cache->tzinfo_.Bias * -kMsPerMinute;
  }
}

References v8::base::TimezoneCache::InitializeIfNeeded(), kMsPerMinute, kTimeScaler, t(), ToJSTime(), and v8::base::TimezoneCache::tzinfo_.

Referenced by InDST().

Here is the call graph for this function:

Here is the caller graph for this function:

LocalTimezone()

char * v8::base::Win32Time::LocalTimezone

(

TimezoneCache *

cache

)

Definition at line 432 of file platform-win32.cc.

                                                   {
  // Return the standard or DST time zone name based on whether daylight
  // saving is in effect at the given time.
  return InDST(cache) ? cache->dst_tz_name_ : cache->std_tz_name_;
}

References v8::base::TimezoneCache::dst_tz_name_, InDST(), and v8::base::TimezoneCache::std_tz_name_.

Here is the call graph for this function:

SetToCurrentTime()

void v8::base::Win32Time::SetToCurrentTime

(

)

Definition at line 306 of file platform-win32.cc.

                                 {
  // The default GetSystemTimeAsFileTime has a ~15.5ms resolution.
  // Because we're fast, we like fast timers which have at least a
  // 1ms resolution.
  //
  // timeGetTime() provides 1ms granularity when combined with
  // timeBeginPeriod().  If the host application for v8 wants fast
  // timers, it can use timeBeginPeriod to increase the resolution.
  //
  // Using timeGetTime() has a drawback because it is a 32bit value
  // and hence rolls-over every ~49days.
  //
  // To use the clock, we use GetSystemTimeAsFileTime as our base;
  // and then use timeGetTime to extrapolate current time from the
  // start time.  To deal with rollovers, we resync the clock
  // any time when more than kMaxClockElapsedTime has passed or
  // whenever timeGetTime creates a rollover.
 
  static bool initialized = false;
  static TimeStamp init_time;
  static DWORD init_ticks;
  static const int64_t kHundredNanosecondsPerSecond = 10000000;
  static const int64_t kMaxClockElapsedTime =
      60*kHundredNanosecondsPerSecond;  // 1 minute
 
  // If we are uninitialized, we need to resync the clock.
  bool needs_resync = !initialized;
 
  // Get the current time.
  TimeStamp time_now;
  GetSystemTimeAsFileTime(&time_now.ft_);
  DWORD ticks_now = timeGetTime();
 
  // Check if we need to resync due to clock rollover.
  needs_resync |= ticks_now < init_ticks;
 
  // Check if we need to resync due to elapsed time.
  needs_resync |= (time_now.t_ - init_time.t_) > kMaxClockElapsedTime;
 
  // Check if we need to resync due to backwards time change.
  needs_resync |= time_now.t_ < init_time.t_;
 
  // Resync the clock if necessary.
  if (needs_resync) {
    GetSystemTimeAsFileTime(&init_time.ft_);
    init_ticks = ticks_now = timeGetTime();
    initialized = true;
  }
 
  // Finally, compute the actual time.  Why is this so hard.
  DWORD elapsed = ticks_now - init_ticks;
  this->time_.t_ = init_time.t_ + (static_cast<int64_t>(elapsed) * 10000);
}

References v8::base::DWORD(), v8::base::Win32Time::TimeStamp::ft_, v8::base::Win32Time::TimeStamp::t_, and time_.

Here is the call graph for this function:

t()

int64_t& v8::base::Win32Time::t ( )

inlineprivate

Definition at line 257 of file platform-win32.cc.

{ return time_.t_; }

References v8::base::Win32Time::TimeStamp::t_, and time_.

Referenced by LocalOffset(), ToJSTime(), and Win32Time().

Here is the caller graph for this function:

ToJSTime()

double v8::base::Win32Time::ToJSTime

(

)

Definition at line 300 of file platform-win32.cc.

                           {
  return static_cast<double>((t() - kTimeEpoc) / kTimeScaler);
}

References kTimeEpoc, kTimeScaler, and t().

Referenced by LocalOffset().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

kMsPerMinute

const int64_t v8::base::Win32Time::kMsPerMinute = 60000

staticprivate

Definition at line 245 of file platform-win32.cc.

Referenced by DaylightSavingsOffset(), InDST(), and LocalOffset().

kShortTzNames

const bool v8::base::Win32Time::kShortTzNames = false

staticprivate

Definition at line 248 of file platform-win32.cc.

kTimeEpoc

const int64_t v8::base::Win32Time::kTimeEpoc = 116444736000000000LL

staticprivate

Definition at line 243 of file platform-win32.cc.

Referenced by ToJSTime(), and Win32Time().

kTimeScaler

const int64_t v8::base::Win32Time::kTimeScaler = 10000

staticprivate

Definition at line 244 of file platform-win32.cc.

Referenced by LocalOffset(), ToJSTime(), and Win32Time().

time_

TimeStamp v8::base::Win32Time::time_

private

Definition at line 269 of file platform-win32.cc.

Referenced by ft(), SetToCurrentTime(), and t().

---

The documentation for this class was generated from the following file:

• /mnt/V8SourceCode/src/base/platform/platform-win32.cc