Changeset 50591 in webkit for trunk/JavaScriptCore/wtf/DateMath.cpp

Timestamp:

Nov 5, 2009, 10:52:10 PM (16 years ago)

Author:

[email protected]

Message:

Rolled out r50590 because it doesn't build on Windows.

File:

• trunk/JavaScriptCore/wtf/DateMath.cpp (modified) (12 diffs)

trunk/JavaScriptCore/wtf/DateMath.cpp

@@ -51 +51 @@
 #include "StringExtras.h"
 
-#include "CallFrame.h"
-
 #include <algorithm>
 #include <limits.h>
@@ -64 +62 @@
 #endif
 
+#if PLATFORM(DARWIN)
+#include <notify.h>
+#endif
+
 #if PLATFORM(WINCE)
 extern "C" size_t strftime(char * const s, const size_t maxsize, const char * const format, const struct tm * const t);
@@ -80 +82 @@
 
 namespace WTF {
-
-double getCurrentUTCTime()
-{
-    return floor(getCurrentUTCTimeWithMicroseconds());
-}
-
-// Returns current time in milliseconds since 1 Jan 1970.
-double getCurrentUTCTimeWithMicroseconds()
-{
-    return currentTime() * 1000.0; 
-}
-
-void getLocalTime(const time_t* localTime, struct tm* localTM)
-{
-#if COMPILER(MSVC7) || COMPILER(MINGW) || PLATFORM(WINCE)
-    *localTM = *localtime(localTime);
-#elif COMPILER(MSVC)
-    localtime_s(localTM, localTime);
-#else
-    localtime_r(localTime, localTM);
-#endif
-}
-
-} // namespace WTF
-
-using namespace WTF;
-
-namespace JSC {
 
 /* Constants */
@@ -320 +294 @@
 }
 
+double getCurrentUTCTime()
+{
+    return floor(getCurrentUTCTimeWithMicroseconds());
+}
+
+// Returns current time in milliseconds since 1 Jan 1970.
+double getCurrentUTCTimeWithMicroseconds()
+{
+    return currentTime() * 1000.0; 
+}
+
+void getLocalTime(const time_t* localTime, struct tm* localTM)
+{
+#if COMPILER(MSVC7) || COMPILER(MINGW) || PLATFORM(WINCE)
+    *localTM = *localtime(localTime);
+#elif COMPILER(MSVC)
+    localtime_s(localTM, localTime);
+#else
+    localtime_r(localTime, localTM);
+#endif
+}
+
 // There is a hard limit at 2038 that we currently do not have a workaround
 // for (rdar://problem/5052975).
@@ -404 +400 @@
 }
 
+#if PLATFORM(DARWIN)
+static int32_t s_cachedUTCOffset; // In milliseconds. An assumption here is that access to an int32_t variable is atomic on platforms that take this code path.
+static bool s_haveCachedUTCOffset;
+static int s_notificationToken;
+#endif
+
 /*
  * Get the difference in milliseconds between this time zone and UTC (GMT)
  * NOT including DST.
  */
-double getUTCOffset(ExecState* exec)
-{
-    double utcOffset = exec->globalData().cachedUTCOffset;
-    if (!isnan(utcOffset))
-        return utcOffset;
-    exec->globalData().cachedUTCOffset = calculateUTCOffset();
-    return exec->globalData().cachedUTCOffset;
+double getUTCOffset()
+{
+#if PLATFORM(DARWIN)
+    if (s_haveCachedUTCOffset) {
+        int notified;
+        uint32_t status = notify_check(s_notificationToken, &notified);
+        if (status == NOTIFY_STATUS_OK && !notified)
+            return s_cachedUTCOffset;
+    }
+#endif
+
+    int32_t utcOffset = calculateUTCOffset();
+
+#if PLATFORM(DARWIN)
+    // Theoretically, it is possible that several threads will be executing this code at once, in which case we will have a race condition,
+    // and a newer value may be overwritten. In practice, time zones don't change that often.
+    s_cachedUTCOffset = utcOffset;
+#endif
+
+    return utcOffset;
 }
 
@@ -472 +487 @@
 }
 
-double gregorianDateTimeToMS(ExecState* exec, const GregorianDateTime& t, double milliSeconds, bool inputIsUTC)
+double gregorianDateTimeToMS(const GregorianDateTime& t, double milliSeconds, bool inputIsUTC)
 {
     int day = dateToDayInYear(t.year + 1900, t.month, t.monthDay);
@@ -479 +494 @@
 
     if (!inputIsUTC) { // convert to UTC
-        double utcOffset = getUTCOffset(exec);
+        double utcOffset = getUTCOffset();
         result -= utcOffset;
         result -= getDSTOffset(result, utcOffset);
@@ -488 +503 @@
 
 // input is UTC
-void msToGregorianDateTime(ExecState* exec, double ms, bool outputIsUTC, GregorianDateTime& tm)
+void msToGregorianDateTime(double ms, bool outputIsUTC, GregorianDateTime& tm)
 {
     double dstOff = 0.0;
     double utcOff = 0.0;
     if (!outputIsUTC) {
-        utcOff = getUTCOffset(exec);
+        utcOff = getUTCOffset();
         dstOff = getDSTOffset(ms, utcOff);
         ms += dstOff + utcOff;
@@ -520 +535 @@
 
     equivalentYearForDST(2000); // Need to call once to initialize a static used in this function.
+#if PLATFORM(DARWIN)
+    // Register for a notification whenever the time zone changes.
+    uint32_t status = notify_register_check("com.apple.system.timezone", &s_notificationToken);
+    if (status == NOTIFY_STATUS_OK) {
+        s_cachedUTCOffset = calculateUTCOffset();
+        s_haveCachedUTCOffset = true;
+    }
+#endif
 }
 
@@ -600 +623 @@
 }
 
-// Odd case where 'exec' is allowed to be 0, to accomodate a caller in WebCore.
-double parseDateFromNullTerminatedCharacters(const char* dateString, ExecState* exec)
+double parseDateFromNullTerminatedCharacters(const char* dateString)
 {
     // This parses a date in the form:
@@ -868 +890 @@
             year += 1900;
     }
-    
-    double ms = ymdhmsToSeconds(year, month + 1, day, hour, minute, second) * msPerSecond;
+
     // fall back to local timezone
     if (!haveTZ) {
-        if (exec) {
-            double utcOffset = getUTCOffset(exec);
-            double dstOffset = getDSTOffset(ms, utcOffset);
-            offset = static_cast<int>((utcOffset + dstOffset) / msPerMinute);
-        } else {
-            double utcOffset = calculateUTCOffset();
-            double dstOffset = getDSTOffset(ms, utcOffset);
-            offset = static_cast<int>((utcOffset + dstOffset) / msPerMinute);
-        }
-    }
-
-    return ms - (offset * msPerMinute);
+        GregorianDateTime t;
+        t.monthDay = day;
+        t.month = month;
+        t.year = year - 1900;
+        t.isDST = -1;
+        t.second = second;
+        t.minute = minute;
+        t.hour = hour;
+
+        // Use our gregorianDateTimeToMS() rather than mktime() as the latter can't handle the full year range.
+        return gregorianDateTimeToMS(t, 0, false);
+    }
+
+    return (ymdhmsToSeconds(year, month + 1, day, hour, minute, second) - (offset * 60.0)) * msPerSecond;
 }
 
@@ -896 +919 @@
 
 
-} // namespace JSC
+} // namespace WTF