grpc 1.84.0 → 1.85.0.pre1

data/third_party/abseil-cpp/absl/time/internal/cctz/src/time_zone_format.cc

@@ -13,12 +13,14 @@
 //   limitations under the License.
 
 #if !defined(HAS_STRPTIME)
-#if !defined(_MSC_VER) && !defined(__MINGW32__) && !defined(__VXWORKS__)
+#if defined(_MSC_VER) || defined(__MINGW32__) || defined(__VXWORKS__)
+#define HAS_STRPTIME 0
+#else
 #define HAS_STRPTIME 1  // Assume everyone else has strptime().
 #endif
 #endif
 
-#if defined(HAS_STRPTIME) && HAS_STRPTIME
+#if HAS_STRPTIME
 #if !defined(_XOPEN_SOURCE) && !defined(__FreeBSD__) && !defined(__OpenBSD__)
 #define _XOPEN_SOURCE 500  // Exposes definitions for SUSv2 (UNIX 98).
 #endif
@@ -39,7 +41,6 @@
 #include <ctime>
 #include <limits>
 #include <string>
-#include <vector>
 #if !HAS_STRPTIME
 #include <iomanip>
 #include <sstream>
@@ -117,7 +118,7 @@ std::tm ToTM(const time_zone::absolute_lookup& al) {
   tm.tm_mday = al.cs.day();
   tm.tm_mon = al.cs.month() - 1;
 
-  // Saturate tm.tm_year is cases of over/underflow.
+  // Saturate tm.tm_year in cases of over/underflow.
   if (al.cs.year() < std::numeric_limits<int>::min() + 1900) {
     tm.tm_year = std::numeric_limits<int>::min();
   } else if (al.cs.year() - 1900 > std::numeric_limits<int>::max()) {
@@ -213,19 +214,15 @@ char* FormatOffset(char* ep, int offset, const char* mode) {
 
 // Formats a std::tm using strftime(3).
 void FormatTM(std::string* out, const std::string& fmt, const std::tm& tm) {
-  // strftime(3) returns the number of characters placed in the output
-  // array (which may be 0 characters).  It also returns 0 to indicate
-  // an error, like the array wasn't large enough.  To accommodate this,
-  // the following code grows the buffer size from 2x the format string
-  // length up to 32x.
-  for (std::size_t i = 2; i != 32; i *= 2) {
-    std::size_t buf_size = fmt.size() * i;
-    std::vector<char> buf(buf_size);
-    if (std::size_t len = strftime(&buf[0], buf_size, fmt.c_str(), &tm)) {
-      out->append(&buf[0], len);
-      return;
-    }
-  }
+  // We assume that 16 times the length of the format string will
+  // be sufficient to store the result.  The extreme case appears
+  // to be "%c" (2 chars), which, in the POSIX locale, produces
+  // "Thu Jan 1 00:00:00 1970" (24 chars).
+  auto out_size = out->size();
+  auto buf_size = (16 * fmt.size()) + 1;
+  out->resize(out_size + buf_size);
+  auto len = strftime(&(*out)[out_size], buf_size, fmt.c_str(), &tm);
+  out->resize(out_size + len);
 }
 
 // Used for %E#S/%E#f specifiers and for data values in parse().
@@ -333,12 +330,12 @@ const std::int_fast64_t kExp10[kDigits10_64 + 1] = {
 std::string format(const std::string& format, const time_point<seconds>& tp,
                    const detail::femtoseconds& fs, const time_zone& tz) {
   std::string result;
-  result.reserve(format.size());  // A reasonable guess for the result size.
+  result.reserve(2 * format.size());  // A guess for the result size.
   const time_zone::absolute_lookup al = tz.lookup(tp);
   const std::tm tm = ToTM(al);
 
   // Scratch buffer for internal conversions.
-  char buf[3 + kDigits10_64];  // enough for longest conversion
+  char buf[6 + (kDigits10_64 + 2)];  // enough for longest conversion (%F)
   char* const ep = buf + sizeof(buf);
   char* bp;  // works back from ep
 
@@ -347,23 +344,29 @@ std::string format(const std::string& format, const time_point<seconds>& tp,
   //   [pending ... cur) : formatting pending, but no special cases
   //   [cur ... format.end()) : unexamined
   // Initially, everything is in the unexamined part.
-  const char* pending = format.c_str();  // NUL terminated
+  const char* pending = format.data();
   const char* cur = pending;
-  const char* end = pending + format.length();
+  const char* const end = pending + format.size();
 
   while (cur != end) {  // while something is unexamined
     // Moves cur to the next percent sign.
     const char* start = cur;
-    while (cur != end && *cur != '%') ++cur;
+    while (cur != end && *cur != '%') {
+      if (*cur == '\0' && pending != start) {
+        FormatTM(&result, std::string(pending, cur), tm);
+        pending = start = cur;
+      }
+      ++cur;
+    }
 
     // If the new pending text is all ordinary, copy it out.
     if (cur != start && pending == start) {
-      result.append(pending, static_cast<std::size_t>(cur - pending));
+      result.append(pending, cur);
       pending = start = cur;
     }
 
     // Span the sequential percent signs.
-    const char* percent = cur;
+    const char* const percent = cur;
     while (cur != end && *cur == '%') ++cur;
 
     // If the new pending text is all percents, copy out one
@@ -382,65 +385,87 @@ std::string format(const std::string& format, const time_point<seconds>& tp,
     if (cur == end || (cur - percent) % 2 == 0) continue;
 
     // Simple specifiers that we handle ourselves.
-    if (strchr("YmdeUuWwHMSzZs%", *cur)) {
-      if (cur - 1 != pending) {
-        FormatTM(&result, std::string(pending, cur - 1), tm);
-      }
+    if (*cur == '\0' || strchr("YmdeFUuWwHMSTzZs%", *cur)) {
+      FormatTM(&result, std::string(pending, cur - 1), tm);
       switch (*cur) {
+        case '\0':
+          // Because we allow NULs in the format string, we must give
+          // some meaning to the "%\0" specifier.  We choose the common
+          // (but undefined) strftime() behavior of echoing unknown
+          // specifiers.
+          result.push_back('%');
+          result.push_back('\0');
+          break;
         case 'Y':
           // This avoids the tm.tm_year overflow problem for %Y, however
           // tm.tm_year will still be used by other specifiers like %D.
           bp = Format64(ep, 0, al.cs.year());
-          result.append(bp, static_cast<std::size_t>(ep - bp));
+          result.append(bp, ep);
           break;
         case 'm':
           bp = Format02d(ep, al.cs.month());
-          result.append(bp, static_cast<std::size_t>(ep - bp));
+          result.append(bp, ep);
           break;
         case 'd':
         case 'e':
           bp = Format02d(ep, al.cs.day());
           if (*cur == 'e' && *bp == '0') *bp = ' ';  // for Windows
-          result.append(bp, static_cast<std::size_t>(ep - bp));
+          result.append(bp, ep);
+          break;
+        case 'F':
+          bp = Format02d(ep, al.cs.day());
+          *--bp = '-';
+          bp = Format02d(bp, al.cs.month());
+          *--bp = '-';
+          bp = Format64(bp, 0, al.cs.year());
+          result.append(bp, ep);
           break;
         case 'U':
           bp = Format02d(ep, ToWeek(civil_day(al.cs), weekday::sunday));
-          result.append(bp, static_cast<std::size_t>(ep - bp));
+          result.append(bp, ep);
           break;
         case 'u':
           bp = Format64(ep, 0, tm.tm_wday ? tm.tm_wday : 7);
-          result.append(bp, static_cast<std::size_t>(ep - bp));
+          result.append(bp, ep);
           break;
         case 'W':
           bp = Format02d(ep, ToWeek(civil_day(al.cs), weekday::monday));
-          result.append(bp, static_cast<std::size_t>(ep - bp));
+          result.append(bp, ep);
           break;
         case 'w':
           bp = Format64(ep, 0, tm.tm_wday);
-          result.append(bp, static_cast<std::size_t>(ep - bp));
+          result.append(bp, ep);
           break;
         case 'H':
           bp = Format02d(ep, al.cs.hour());
-          result.append(bp, static_cast<std::size_t>(ep - bp));
+          result.append(bp, ep);
           break;
         case 'M':
           bp = Format02d(ep, al.cs.minute());
-          result.append(bp, static_cast<std::size_t>(ep - bp));
+          result.append(bp, ep);
           break;
         case 'S':
           bp = Format02d(ep, al.cs.second());
-          result.append(bp, static_cast<std::size_t>(ep - bp));
+          result.append(bp, ep);
+          break;
+        case 'T':
+          bp = Format02d(ep, al.cs.second());
+          *--bp = ':';
+          bp = Format02d(bp, al.cs.minute());
+          *--bp = ':';
+          bp = Format02d(bp, al.cs.hour());
+          result.append(bp, ep);
           break;
         case 'z':
           bp = FormatOffset(ep, al.offset, "");
-          result.append(bp, static_cast<std::size_t>(ep - bp));
+          result.append(bp, ep);
           break;
         case 'Z':
           result.append(al.abbr);
           break;
         case 's':
           bp = Format64(ep, 0, ToUnixSeconds(tp));
-          result.append(bp, static_cast<std::size_t>(ep - bp));
+          result.append(bp, ep);
           break;
         case '%':
           result.push_back('%');
@@ -454,33 +479,27 @@ std::string format(const std::string& format, const time_point<seconds>& tp,
     if (*cur == ':' && cur + 1 != end) {
       if (*(cur + 1) == 'z') {
         // Formats %:z.
-        if (cur - 1 != pending) {
-          FormatTM(&result, std::string(pending, cur - 1), tm);
-        }
+        FormatTM(&result, std::string(pending, cur - 1), tm);
         bp = FormatOffset(ep, al.offset, ":");
-        result.append(bp, static_cast<std::size_t>(ep - bp));
+        result.append(bp, ep);
         pending = cur += 2;
         continue;
       }
       if (*(cur + 1) == ':' && cur + 2 != end) {
         if (*(cur + 2) == 'z') {
           // Formats %::z.
-          if (cur - 1 != pending) {
-            FormatTM(&result, std::string(pending, cur - 1), tm);
-          }
+          FormatTM(&result, std::string(pending, cur - 1), tm);
           bp = FormatOffset(ep, al.offset, ":*");
-          result.append(bp, static_cast<std::size_t>(ep - bp));
+          result.append(bp, ep);
           pending = cur += 3;
           continue;
         }
         if (*(cur + 2) == ':' && cur + 3 != end) {
           if (*(cur + 3) == 'z') {
             // Formats %:::z.
-            if (cur - 1 != pending) {
-              FormatTM(&result, std::string(pending, cur - 1), tm);
-            }
+            FormatTM(&result, std::string(pending, cur - 1), tm);
             bp = FormatOffset(ep, al.offset, ":*:");
-            result.append(bp, static_cast<std::size_t>(ep - bp));
+            result.append(bp, ep);
             pending = cur += 4;
             continue;
           }
@@ -494,33 +513,25 @@ std::string format(const std::string& format, const time_point<seconds>& tp,
     // Format our extensions.
     if (*cur == 'T') {
       // Formats %ET.
-      if (cur - 2 != pending) {
-        FormatTM(&result, std::string(pending, cur - 2), tm);
-      }
+      FormatTM(&result, std::string(pending, cur - 2), tm);
       result.append("T");
       pending = ++cur;
     } else if (*cur == 'z') {
       // Formats %Ez.
-      if (cur - 2 != pending) {
-        FormatTM(&result, std::string(pending, cur - 2), tm);
-      }
+      FormatTM(&result, std::string(pending, cur - 2), tm);
       bp = FormatOffset(ep, al.offset, ":");
-      result.append(bp, static_cast<std::size_t>(ep - bp));
+      result.append(bp, ep);
       pending = ++cur;
     } else if (*cur == '*' && cur + 1 != end && *(cur + 1) == 'z') {
       // Formats %E*z.
-      if (cur - 2 != pending) {
-        FormatTM(&result, std::string(pending, cur - 2), tm);
-      }
+      FormatTM(&result, std::string(pending, cur - 2), tm);
       bp = FormatOffset(ep, al.offset, ":*");
-      result.append(bp, static_cast<std::size_t>(ep - bp));
+      result.append(bp, ep);
       pending = cur += 2;
     } else if (*cur == '*' && cur + 1 != end &&
                (*(cur + 1) == 'S' || *(cur + 1) == 'f')) {
       // Formats %E*S or %E*F.
-      if (cur - 2 != pending) {
-        FormatTM(&result, std::string(pending, cur - 2), tm);
-      }
+      FormatTM(&result, std::string(pending, cur - 2), tm);
       char* cp = ep;
       bp = Format64(cp, 15, fs.count());
       while (cp != bp && cp[-1] == '0') --cp;
@@ -533,15 +544,13 @@ std::string format(const std::string& format, const time_point<seconds>& tp,
           if (cp == bp) *--bp = '0';
           break;
       }
-      result.append(bp, static_cast<std::size_t>(cp - bp));
+      result.append(bp, cp);
       pending = cur += 2;
     } else if (*cur == '4' && cur + 1 != end && *(cur + 1) == 'Y') {
       // Formats %E4Y.
-      if (cur - 2 != pending) {
-        FormatTM(&result, std::string(pending, cur - 2), tm);
-      }
+      FormatTM(&result, std::string(pending, cur - 2), tm);
       bp = Format64(ep, 4, al.cs.year());
-      result.append(bp, static_cast<std::size_t>(ep - bp));
+      result.append(bp, ep);
       pending = cur += 2;
     } else if (std::isdigit(*cur)) {
       // Possibly found %E#S or %E#f.
@@ -549,9 +558,7 @@ std::string format(const std::string& format, const time_point<seconds>& tp,
       if (const char* np = ParseInt(cur, 0, 0, 1024, &n)) {
         if (*np == 'S' || *np == 'f') {
           // Formats %E#S or %E#f.
-          if (cur - 2 != pending) {
-            FormatTM(&result, std::string(pending, cur - 2), tm);
-          }
+          FormatTM(&result, std::string(pending, cur - 2), tm);
           bp = ep;
           if (n > 0) {
             if (n > kDigits10_64) n = kDigits10_64;
@@ -561,7 +568,7 @@ std::string format(const std::string& format, const time_point<seconds>& tp,
             if (*np == 'S') *--bp = '.';
           }
           if (*np == 'S') bp = Format02d(bp, al.cs.second());
-          result.append(bp, static_cast<std::size_t>(ep - bp));
+          result.append(bp, ep);
           pending = cur = ++np;
         }
       }
@@ -569,9 +576,7 @@ std::string format(const std::string& format, const time_point<seconds>& tp,
   }
 
   // Formats any remaining data.
-  if (end != pending) {
-    FormatTM(&result, std::string(pending, end), tm);
-  }
+  FormatTM(&result, std::string(pending, end), tm);
 
   return result;
 }
@@ -692,8 +697,12 @@ bool FromWeek(int week_num, weekday week_start, year_t* year, std::tm* tm) {
 bool parse(const std::string& format, const std::string& input,
            const time_zone& tz, time_point<seconds>* sec,
            detail::femtoseconds* fs, std::string* err) {
-  // The unparsed input.
+  // The unparsed input.  Even though we allow NULs in input, and
+  // match them against corresponding NULs in format, we depend on
+  // *edata being a NUL so that we can call strptime().  This also
+  // makes our handling of input easier.
   const char* data = input.c_str();  // NUL terminated
+  const char* const edata = data + input.size();
 
   // Skips leading whitespace.
   while (std::isspace(*data)) ++data;
@@ -719,7 +728,11 @@ bool parse(const std::string& format, const std::string& input,
   int offset = 0;  // No offset from passed tz.
   std::string zone = "UTC";
 
+  // Even though we allow NULs in format, and match them against
+  // corresponding NULs in input, we simplify its handling by also
+  // ensuring that *efmt is a NUL.
   const char* fmt = format.c_str();  // NUL terminated
+  const char* const efmt = fmt + format.size();
   bool twelve_hour = false;
   bool afternoon = false;
   int week_num = -1;
@@ -729,7 +742,7 @@ bool parse(const std::string& format, const std::string& input,
   std::int_fast64_t percent_s = 0;
 
   // Steps through format, one specifier at a time.
-  while (data != nullptr && *fmt != '\0') {
+  while (data != nullptr && fmt != efmt) {
     if (std::isspace(*fmt)) {
       while (std::isspace(*data)) ++data;
       while (std::isspace(*++fmt)) continue;
@@ -737,7 +750,7 @@ bool parse(const std::string& format, const std::string& input,
     }
 
     if (*fmt != '%') {
-      if (*data == *fmt) {
+      if (data != edata && *data == *fmt) {
         ++data;
         ++fmt;
       } else {
@@ -746,14 +759,21 @@ bool parse(const std::string& format, const std::string& input,
       continue;
     }
 
-    const char* percent = fmt;
-    if (*++fmt == '\0') {
+    const char* const percent = fmt;
+    if (++fmt == efmt) {
       data = nullptr;
       continue;
     }
     switch (*fmt++) {
+      case '\0':
+        // Because we allow NULs in the format string, we must give
+        // some meaning to the "%\0" specifier.  We choose the common
+        // (but undefined) strptime() behavior of failing on unknown
+        // specifiers.
+        data = nullptr;
+        continue;
       case 'Y':
-        // Symmetrically with FormatTime(), directly handing %Y avoids the
+        // Symmetrically with format(), directly handing %Y avoids the
         // tm.tm_year overflow problem.  However, tm.tm_year will still be
         // used by other specifiers like %D.
         data = ParseInt(data, 0, kyearmin, kyearmax, &year);
@@ -769,6 +789,20 @@ bool parse(const std::string& format, const std::string& input,
         data = ParseInt(data, 2, 1, 31, &tm.tm_mday);
         week_num = -1;
         continue;
+      case 'F':
+        data = ParseInt(data, 0, kyearmin, kyearmax, &year);
+        if (data != nullptr) {
+          saw_year = true;
+          data = (*data == '-' ? data + 1 : nullptr);
+        }
+        data = ParseInt(data, 2, 1, 12, &tm.tm_mon);
+        if (data != nullptr) {
+          tm.tm_mon -= 1;
+          data = (*data == '-' ? data + 1 : nullptr);
+        }
+        data = ParseInt(data, 2, 1, 31, &tm.tm_mday);
+        week_num = -1;
+        continue;
       case 'U':
         data = ParseInt(data, 0, 0, 53, &week_num);
         week_start = weekday::sunday;
@@ -794,13 +828,20 @@ bool parse(const std::string& format, const std::string& input,
       case 'S':
         data = ParseInt(data, 2, 0, 60, &tm.tm_sec);
         continue;
+      case 'T':
+        data = ParseInt(data, 2, 0, 23, &tm.tm_hour);
+        twelve_hour = false;
+        data = (data != nullptr && *data == ':' ? data + 1 : nullptr);
+        data = ParseInt(data, 2, 0, 59, &tm.tm_min);
+        data = (data != nullptr && *data == ':' ? data + 1 : nullptr);
+        data = ParseInt(data, 2, 0, 60, &tm.tm_sec);
+        continue;
       case 'I':
       case 'l':
       case 'r':  // probably uses %I
         twelve_hour = true;
         break;
       case 'R':  // uses %H
-      case 'T':  // uses %H
       case 'c':  // probably uses %H
       case 'X':  // probably uses %H
         twelve_hour = false;
@@ -907,8 +948,8 @@ bool parse(const std::string& format, const std::string& input,
     }
 
     // Parses the current specifier.
-    const char* orig_data = data;
-    std::string spec(percent, static_cast<std::size_t>(fmt - percent));
+    const char* const orig_data = data;
+    std::string spec(percent, fmt);
     data = ParseTM(data, spec.c_str(), &tm);
 
     // If we successfully parsed %p we need to remember whether the result
@@ -917,10 +958,9 @@ bool parse(const std::string& format, const std::string& input,
     // to a PM hour.
     if (spec == "%p" && data != nullptr) {
       std::string test_input = "1";
-      test_input.append(orig_data, static_cast<std::size_t>(data - orig_data));
-      const char* test_data = test_input.c_str();
+      test_input.append(orig_data, data);
       std::tm tmp{};
-      ParseTM(test_data, "%I%p", &tmp);
+      ParseTM(test_input.c_str(), "%I%p", &tmp);
       afternoon = (tmp.tm_hour == 13);
     }
   }
@@ -939,7 +979,7 @@ bool parse(const std::string& format, const std::string& input,
   while (std::isspace(*data)) ++data;
 
   // parse() must consume the entire input string.
-  if (*data != '\0') {
+  if (data != edata) {
     if (err != nullptr) *err = "Illegal trailing data in input string";
     return false;
   }

data/third_party/abseil-cpp/absl/time/internal/cctz/src/time_zone_lookup.cc

@@ -32,31 +32,6 @@
 #include <zircon/types.h>
 #endif
 
-#if defined(_WIN32)
-// Include only when <icu.h> is available.
-// https://learn.microsoft.com/en-us/windows/win32/intl/international-components-for-unicode--icu-
-// https://devblogs.microsoft.com/oldnewthing/20210527-00/?p=105255
-#if defined(__has_include)
-#if __has_include(<icu.h>)
-#define USE_WIN32_LOCAL_TIME_ZONE
-#include <windows.h>
-#pragma push_macro("_WIN32_WINNT")
-#pragma push_macro("NTDDI_VERSION")
-// Minimum _WIN32_WINNT and NTDDI_VERSION to use ucal_getTimeZoneIDForWindowsID
-#undef _WIN32_WINNT
-#define _WIN32_WINNT 0x0A00  // == _WIN32_WINNT_WIN10
-#undef NTDDI_VERSION
-#define NTDDI_VERSION 0x0A000004  // == NTDDI_WIN10_RS3
-#include <icu.h>
-#pragma pop_macro("NTDDI_VERSION")
-#pragma pop_macro("_WIN32_WINNT")
-#include <timezoneapi.h>
-
-#include <atomic>
-#endif  // __has_include(<icu.h>)
-#endif  // __has_include
-#endif  // _WIN32
-
 #include <array>
 #include <cstdint>
 #include <cstdlib>
@@ -66,87 +41,15 @@
 #include "absl/time/internal/cctz/src/time_zone_fixed.h"
 #include "absl/time/internal/cctz/src/time_zone_impl.h"
 
+#if defined(_WIN32)
+#include "absl/time/internal/cctz/src/time_zone_name_win.h"
+#endif  // _WIN32
+
 namespace absl {
 ABSL_NAMESPACE_BEGIN
 namespace time_internal {
 namespace cctz {
 
-namespace {
-#if defined(USE_WIN32_LOCAL_TIME_ZONE)
-// True if we have already failed to load the API.
-static std::atomic_bool g_ucal_getTimeZoneIDForWindowsIDUnavailable;
-static std::atomic<decltype(ucal_getTimeZoneIDForWindowsID)*>
-    g_ucal_getTimeZoneIDForWindowsIDRef;
-
-std::string win32_local_time_zone() {
-  // If we have already failed to load the API, then just give up.
-  if (g_ucal_getTimeZoneIDForWindowsIDUnavailable.load()) {
-    return "";
-  }
-
-  auto ucal_getTimeZoneIDForWindowsIDFunc =
-      g_ucal_getTimeZoneIDForWindowsIDRef.load();
-  if (ucal_getTimeZoneIDForWindowsIDFunc == nullptr) {
-    // If we have already failed to load the API, then just give up.
-    if (g_ucal_getTimeZoneIDForWindowsIDUnavailable.load()) {
-      return "";
-    }
-
-    const HMODULE icudll =
-        ::LoadLibraryExW(L"icu.dll", nullptr, LOAD_LIBRARY_SEARCH_SYSTEM32);
-
-    if (icudll == nullptr) {
-      g_ucal_getTimeZoneIDForWindowsIDUnavailable.store(true);
-      return "";
-    }
-
-    ucal_getTimeZoneIDForWindowsIDFunc =
-        reinterpret_cast<decltype(ucal_getTimeZoneIDForWindowsID)*>(
-            ::GetProcAddress(icudll, "ucal_getTimeZoneIDForWindowsID"));
-
-    if (ucal_getTimeZoneIDForWindowsIDFunc == nullptr) {
-      g_ucal_getTimeZoneIDForWindowsIDUnavailable.store(true);
-      return "";
-    }
-    // store-race is not a problem here, because ::GetProcAddress() returns the
-    // same address for the same function in the same DLL.
-    g_ucal_getTimeZoneIDForWindowsIDRef.store(
-        ucal_getTimeZoneIDForWindowsIDFunc);
-
-    // We intentionally do not call ::FreeLibrary() here to avoid frequent DLL
-    // loadings and unloading. As "icu.dll" is a system library, keeping it on
-    // memory is supposed to have no major drawback.
-  }
-
-  DYNAMIC_TIME_ZONE_INFORMATION info = {};
-  if (::GetDynamicTimeZoneInformation(&info) == TIME_ZONE_ID_INVALID) {
-    return "";
-  }
-
-  std::array<UChar, 128> buffer;
-  UErrorCode status = U_ZERO_ERROR;
-  const auto num_chars_in_buffer = ucal_getTimeZoneIDForWindowsIDFunc(
-      reinterpret_cast<const UChar*>(info.TimeZoneKeyName), -1, nullptr,
-      buffer.data(), static_cast<int32_t>(buffer.size()), &status);
-  if (status != U_ZERO_ERROR || num_chars_in_buffer <= 0 ||
-      num_chars_in_buffer > static_cast<int32_t>(buffer.size())) {
-    return "";
-  }
-
-  const int num_bytes_in_utf8 = ::WideCharToMultiByte(
-      CP_UTF8, 0, reinterpret_cast<const wchar_t*>(buffer.data()),
-      static_cast<int>(num_chars_in_buffer), nullptr, 0, nullptr, nullptr);
-  std::string local_time_str;
-  local_time_str.resize(static_cast<size_t>(num_bytes_in_utf8));
-  ::WideCharToMultiByte(
-       CP_UTF8, 0, reinterpret_cast<const wchar_t*>(buffer.data()),
-       static_cast<int>(num_chars_in_buffer), &local_time_str[0],
-       num_bytes_in_utf8, nullptr, nullptr);
-  return local_time_str;
-}
-#endif  // USE_WIN32_LOCAL_TIME_ZONE
-}  // namespace
-
 std::string time_zone::name() const { return effective_impl().Name(); }
 
 time_zone::absolute_lookup time_zone::lookup(
@@ -261,8 +164,8 @@ time_zone local_time_zone() {
     zone = primary_tz.c_str();
   }
 #endif
-#if defined(USE_WIN32_LOCAL_TIME_ZONE)
-  std::string win32_tz = win32_local_time_zone();
+#if defined(_WIN32)
+  std::string win32_tz = GetWindowsLocalTimeZone();
   if (!win32_tz.empty()) {
     zone = win32_tz.c_str();
   }