document.lastModified should consider user's local time zone

Source/wtf/DateMath.cpp

 /*
  * Copyright (C) 1999-2000 Harri Porten (porten@kde.org)
  * Copyright (C) 2006, 2007 Apple Inc. All rights reserved.
  * Copyright (C) 2009 Google Inc. All rights reserved.
  * Copyright (C) 2007-2009 Torch Mobile, Inc.
  * Copyright (C) 2010 &yet, LLC. (nate@andyet.net)
  *
  * The Original Code is Mozilla Communicator client code, released
  * March 31, 1998.
  *
@@ skipping 85 matching lines @@
 #endif
 
 using namespace WTF;
 
 namespace WTF {
 
 /* Constants */
 
 static const double hoursPerDay = 24.0;
 static const double secondsPerDay = 24.0 * 60.0 * 60.0;
-static const double secondsPerHour = 60.0 * 60.0;
 
 static const double maxUnixTime = 2145859200.0; // 12/31/2037
 
 // Day of year for the first day of each month, where index 0 is January, and day 0 is January 1.
 // First for non-leap years, then for leap years.
 static const int firstDayOfMonth[2][12] = {
     {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334},
     {0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335}
 };
 
@@ skipping 71 matching lines @@
 }
 
 static inline double msToMilliseconds(double ms)
 {
     double result = fmod(ms, msPerDay);
     if (result < 0)
         result += msPerDay;
     return result;
 }
 
-static int msToMinutes(double ms)
-{
-    double result = fmod(floor(ms / msPerMinute), minutesPerHour);
-    if (result < 0)
-        result += minutesPerHour;
-    return static_cast<int>(result);
-}
-
-static int msToHours(double ms)
-{
-    double result = fmod(floor(ms/msPerHour), hoursPerDay);
-    if (result < 0)
-        result += hoursPerDay;
-    return static_cast<int>(result);
-}
-
 int monthFromDayInYear(int dayInYear, bool leapYear)
 {
     const int d = dayInYear;
     int step;
 
     if (d < (step = 31))
         return 0;
     step += (leapYear ? 29 : 28);
     if (d < step)
         return 1;
@@ skipping 127 matching lines @@
         return year;
 
     int quotient = difference / 28;
     int product = (quotient) * 28;
 
     year += product;
     ASSERT((year >= minYear && year <= maxYear) || (product - year == static_cast<int>(std::numeric_limits<double>::quiet_NaN())));
     return year;
 }
 
-int32_t calculateUTCOffset()
+static double calculateUTCOffset()
 {
 #if OS(WIN)
     TIME_ZONE_INFORMATION timeZoneInformation;
     GetTimeZoneInformation(&timeZoneInformation);
     int32_t bias = timeZoneInformation.Bias + timeZoneInformation.StandardBias;
     return -bias * 60 * 1000;
 #else
     time_t localTime = time(0);
     tm localt;
     getLocalTime(&localTime, &localt);
 
-    // Get the difference between this time zone and UTC on the 1st of January of this year.
-    localt.tm_sec = 0;
-    localt.tm_min = 0;
-    localt.tm_hour = 0;
-    localt.tm_mday = 1;
-    localt.tm_mon = 0;
-    // Not setting localt.tm_year!
-    localt.tm_wday = 0;
-    localt.tm_yday = 0;
-    localt.tm_isdst = 0;
-#if HAVE(TM_GMTOFF)
-    localt.tm_gmtoff = 0;
-#endif
-#if HAVE(TM_ZONE)
-    localt.tm_zone = 0;
-#endif
-
-#if HAVE(TIMEGM)
-    time_t utcOffset = timegm(&localt) - mktime(&localt);
-#else
-    // Using a canned date of 01/01/2009 on platforms with weaker date-handling foo.
-    localt.tm_year = 109;
-    time_t utcOffset = 1230768000 - mktime(&localt);
-#endif
-
-    return static_cast<int32_t>(utcOffset * 1000);
+    // tm_gmtoff includes any daylight savings offset, so subtract it.
+    return static_cast<double>(localt.tm_gmtoff * msPerSecond - (localt.tm_isdst > 0 ? msPerHour : 0));
 #endif
 }
 
 /*
  * Get the DST offset for the time passed in.
  */
 static double calculateDSTOffsetSimple(double localTimeSeconds, double utcOffset)
 {
     if (localTimeSeconds > maxUnixTime)
         localTimeSeconds = maxUnixTime;
     else if (localTimeSeconds < 0) // Go ahead a day to make localtime work (does not work with 0)
         localTimeSeconds += secondsPerDay;
 
-    //input is UTC so we have to shift back to local time to determine DST thus the + getUTCOffset()
-    double offsetTime = (localTimeSeconds * msPerSecond) + utcOffset;
-
-    // Offset from UTC but doesn't include DST obviously
-    int offsetHour =  msToHours(offsetTime);
-    int offsetMinute =  msToMinutes(offsetTime);
-
     // FIXME: time_t has a potential problem in 2038
     time_t localTime = static_cast<time_t>(localTimeSeconds);
 
     tm localTM;
     getLocalTime(&localTime, &localTM);
 
-    double diff = ((localTM.tm_hour - offsetHour) * secondsPerHour) + ((localTM.tm_min - offsetMinute) * 60);
-
-    if (diff < 0)
-        diff += secondsPerDay;
-
-    return (diff * msPerSecond);
+    return localTM.tm_isdst > 0 ? msPerHour : 0;
 }
 
 // Get the DST offset, given a time in UTC
-double calculateDSTOffset(double ms, double utcOffset)
+static double calculateDSTOffset(double ms, double utcOffset)
 {
     // On Mac OS X, the call to localtime (see calculateDSTOffsetSimple) will return historically accurate
     // DST information (e.g. New Zealand did not have DST from 1946 to 1974) however the JavaScript
     // standard explicitly dictates that historical information should not be considered when
     // determining DST. For this reason we shift away from years that localtime can handle but would
     // return historically accurate information.
     int year = msToYear(ms);
     int equivalentYear = equivalentYearForDST(year);
     if (year != equivalentYear) {
         bool leapYear = isLeapYear(year);
@@ skipping 429 matching lines @@
     stringBuilder.append(' ');
 
     stringBuilder.append(utcOffset > 0 ? '+' : '-');
     int absoluteUTCOffset = abs(utcOffset);
     stringBuilder.append(twoDigitStringFromNumber(absoluteUTCOffset / 60));
     stringBuilder.append(twoDigitStringFromNumber(absoluteUTCOffset % 60));
 
     return stringBuilder.toString();
 }
 
+double convertToLocalTime(double ms)
+{
+    double utcOffset = calculateUTCOffset();
+    double dstOffset = calculateDSTOffset(ms, utcOffset);
+    return (ms + utcOffset + dstOffset);
+}
+
 } // namespace WTF