Reimplement GetWindowsLocalTimeZone without icu.h

This commit reimplements my previous commits [1][2], which removed the
dependency on WinRT on Windows by using system "icu.dll" (#315) when
<icu.h> is available in the build environment.

Here are major improvements:

 * The relevant code is extracted into separate source files
   "src/icu_win.{cc,h}". This is also a preparation for implementing
   TimeZoneIf with Windows time APIs (#328), where one more ICU API
   needs to be dynamically imported.

 * The dependency on <icu.h> is removed by locally defining required
   constants and API prototypes. This should make it possible to build
   CCTZ with the MinGW toolchain, where <icu.h> is not yet available.

 * On Windows 11 or later, a newer and more straightforward ICU API
   "ucal_getHostTimeZone" is used. If it is not available, then the
   previous approach ("GetDynamicTimeZoneInformation" +
   "ucal_getTimeZoneIDForWindowsID") continues to be used as a fallback.

 * LoadLibraryExW(L"icu.dll", nullptr, LOAD_LIBRARY_SEARCH_SYSTEM32) is
   replaced with LoadLibraryW with the full path to "icu.dll" in the
   System32 directory, because LOAD_LIBRARY_SEARCH_SYSTEM32 can be
   ignored when "icu.dll" is already loaded from a non-System32
   directory. Let's stick to the system "icu.dll" in favor of
   predictability.

Other than the above improvements, the overall logic remains unchanged.

 [1]: 2ebbe0d
 [2]: f8e494f

Author: yukawa

BUILD

@@ -58,7 +58,13 @@ cc_library(
         "src/time_zone_posix.h",
         "src/tzfile.h",
         "src/zone_info_source.cc",
-    ],
+    ] + select({
+        "@platforms//os:windows": [
+            "src/icu_win.cc",
+            "src/icu_win.h",
+        ],
+        "//conditions:default": [],
+    }),
     hdrs = [
         "include/cctz/time_zone.h",
         "include/cctz/zone_info_source.h",

CMakeLists.txt

@@ -85,6 +85,8 @@ add_library(cctz
   src/time_zone_posix.h
   src/tzfile.h
   src/zone_info_source.cc
+  $<IF:$<BOOL:WIN32>,src/icu_win.cc,>
+  $<IF:$<BOOL:WIN32>,src/icu_win.h,>
   ${CCTZ_HDRS}
   )
 cctz_target_set_cxx_standard(cctz)

src/icu_win.cc

@@ -0,0 +1,242 @@
+// Copyright 2025 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//   https://www.apache.org/licenses/LICENSE-2.0
+//
+//   Unless required by applicable law or agreed to in writing, software
+//   distributed under the License is distributed on an "AS IS" BASIS,
+//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//   See the License for the specific language governing permissions and
+//   limitations under the License.
+
+#include "icu_win.h"
+
+#if defined(_WIN32)
+
+#if !defined(NOMINMAX)
+#define NOMINMAX
+#endif  // !defined(NOMINMAX)
+#include <windows.h>
+
+#include <atomic>
+#include <cstdint>
+#include <limits>
+#include <memory>
+#include <string>
+#include <type_traits>
+#include <utility>
+
+namespace cctz {
+namespace icu {
+namespace {
+
+// UChar is defined as char16_t in ICU by default, but it is also safe to assume
+// wchar_t and char16_t are equivalent on Windows.
+using UChar = wchar_t;
+
+enum UErrorCode : std::int32_t {
+  U_ZERO_ERROR = 0,
+  U_BUFFER_OVERFLOW_ERROR = 15,
+};
+
+bool U_SUCCESS(UErrorCode error) { return error <= U_ZERO_ERROR; }
+
+// ICU function signatures
+using ucal_getHostTimeZone_func = std::int32_t(__cdecl*)(
+    UChar* result, std::int32_t result_capacity, UErrorCode* status);
+using ucal_getTimeZoneIDForWindowsID_func = std::int32_t(__cdecl*)(
+    const UChar* winid, std::int32_t len, const char* region, UChar* id,
+    std::int32_t id_capacity, UErrorCode* status);
+
+std::atomic<bool> g_unavailable;
+std::atomic<ucal_getHostTimeZone_func> g_ucal_getHostTimeZone;
+std::atomic<ucal_getTimeZoneIDForWindowsID_func>
+    g_ucal_getTimeZoneIDForWindowsID;
+
+struct IcuFunctions {
+  const bool available;
+  const ucal_getHostTimeZone_func ucal_getHostTimeZone;
+  const ucal_getTimeZoneIDForWindowsID_func ucal_getTimeZoneIDForWindowsID;
+};
+
+IcuFunctions Unavailable() { return {false, nullptr, nullptr}; }
+
+template <typename T>
+static T AsProcAddress(HMODULE module, const char* name) {
+  static_assert(
+      std::is_pointer<T>::value &&
+          std::is_function<typename std::remove_pointer<T>::type>::value,
+      "T must be a function pointer type");
+  const auto proc_address = ::GetProcAddress(module, name);
+  return reinterpret_cast<T>(reinterpret_cast<void*>(proc_address));
+}
+
+std::wstring GetSystem32Dir() {
+  size_t dynamic_buffer_size = 0;
+  {
+    // Fast-path. Usually it's "C:\Windows\System32", which is 19 characters.
+    const size_t buffer_size = 32;
+    wchar_t buffer[buffer_size];
+    UINT result = ::GetSystemDirectoryW(buffer, buffer_size);
+    // If successful, the return value is the length of the string without NUL.
+    if (result <= buffer_size) {
+      return std::wstring(buffer, result);
+    }
+    // Otherwise, the return value is the required length + 1 for NUL.
+    dynamic_buffer_size = result;
+  }
+  // Slow-path. Allocate a buffer of the required size.
+  std::unique_ptr<wchar_t[]> buffer(new wchar_t[dynamic_buffer_size]);
+  const UINT length = ::GetSystemDirectoryW(buffer.get(), dynamic_buffer_size);
+  if (length <= dynamic_buffer_size) {
+    return std::wstring(buffer.get(), length);
+  }
+  return std::wstring();
+}
+
+IcuFunctions GetIcuFunctions() {
+  if (g_unavailable.load(std::memory_order_relaxed)) {
+    return Unavailable();
+  }
+
+  // Check if already loaded
+  {
+    const auto ucal_getHostTimeZoneRef =
+        g_ucal_getHostTimeZone.load(std::memory_order_relaxed);
+    const auto ucal_getTimeZoneIDForWindowsIDRef =
+        g_ucal_getTimeZoneIDForWindowsID.load(std::memory_order_relaxed);
+
+    // Note: ucal_getHostTimeZone can be unavailable on older Windows.
+    if (ucal_getTimeZoneIDForWindowsIDRef != nullptr) {
+      return {true, ucal_getHostTimeZoneRef, ucal_getTimeZoneIDForWindowsIDRef};
+    }
+  }
+
+  // Our goal here is to load the ICU DLL from the system directory, even when
+  // the current process has loaded "icu.dll" from somewhere other than the
+  // system directory. To do so we must use the full path here.
+  const std::wstring icu_dll_path = GetSystem32Dir() + L"\\icu.dll";
+
+  // CAVEAT: LoadLibraryExW with LOAD_LIBRARY_SEARCH_SYSTEM32 is not
+  // sufficient when "icu.dll" is already loaded from somewhere other than
+  // the system directory. This is why we must pass a full path here.
+  const HMODULE icu_dll = ::LoadLibraryW(icu_dll_path.c_str());
+  if (icu_dll == nullptr) {
+    g_unavailable.store(true, std::memory_order_relaxed);
+    return Unavailable();
+  }
+
+  const auto ucal_getHostTimeZoneRef =
+      AsProcAddress<ucal_getHostTimeZone_func>(icu_dll, "ucal_getHostTimeZone");
+  const auto ucal_getTimeZoneIDForWindowsIDRef =
+      AsProcAddress<ucal_getTimeZoneIDForWindowsID_func>(
+          icu_dll, "ucal_getTimeZoneIDForWindowsID");
+
+  // Note: ucal_getHostTimeZone can be unavailable on older Windows.
+  if (!ucal_getTimeZoneIDForWindowsIDRef) {
+    g_unavailable.store(true, std::memory_order_relaxed);
+    return Unavailable();
+  }
+
+  // Store the function pointers
+  g_ucal_getHostTimeZone.store(ucal_getHostTimeZoneRef,
+                               std::memory_order_relaxed);
+  g_ucal_getTimeZoneIDForWindowsID.store(ucal_getTimeZoneIDForWindowsIDRef,
+                                         std::memory_order_relaxed);
+
+  return {true, ucal_getHostTimeZoneRef, ucal_getTimeZoneIDForWindowsIDRef};
+}
+
+// Convert wchar_t array (UTF-16) to UTF-8 string
+std::string Utf16ToUtf8(const wchar_t* ptr, size_t size) {
+  if (size > std::numeric_limits<int>::max()) {
+    return std::string();
+  }
+  const int chars_len = static_cast<int>(size);
+  int num_bytes_in_utf8 = 0;
+  {
+    const int buffer_size = 32;
+    char buffer[buffer_size];
+    num_bytes_in_utf8 =
+        ::WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS, ptr, chars_len,
+                              buffer, buffer_size, nullptr, nullptr);
+    if (num_bytes_in_utf8 <= buffer_size) {
+      return std::string(buffer, num_bytes_in_utf8);
+    }
+  }
+  auto buffer = std::unique_ptr<char[]>(new char[num_bytes_in_utf8]);
+  const int num_written_bytes =
+      ::WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS, ptr, chars_len,
+                            buffer.get(), num_bytes_in_utf8, nullptr, nullptr);
+  if (num_written_bytes != num_bytes_in_utf8) {
+    return std::string();
+  }
+  return std::string(buffer.get(), num_written_bytes);
+}
+
+}  // namespace
+
+std::string GetWindowsLocalTimeZone() {
+  const auto icu = GetIcuFunctions();
+  if (!icu.available) {
+    return std::string();
+  }
+
+  std::int32_t length = 0;
+
+  UErrorCode status = U_ZERO_ERROR;
+
+  // Try ucal_getHostTimeZone first (available on Windows 11+)
+  if (icu.ucal_getHostTimeZone != nullptr) {
+    const int buffer_size = 32;
+    UChar buffer[buffer_size];
+    length = icu.ucal_getHostTimeZone(buffer, buffer_size, &status);
+    if (U_SUCCESS(status) && length >= 0) {
+      return Utf16ToUtf8(buffer, length);
+    }
+    if (status == U_BUFFER_OVERFLOW_ERROR && length > 0) {
+      const int buffer_size = length + 1;  // +1 for null terminator
+      auto buffer = std::unique_ptr<UChar[]>(new UChar[buffer_size]);
+      status = U_ZERO_ERROR;
+      length = icu.ucal_getHostTimeZone(buffer.get(), buffer_size, &status);
+      if (U_SUCCESS(status) && length >= 0) {
+        return Utf16ToUtf8(buffer.get(), length);
+      }
+    }
+  }
+
+  DYNAMIC_TIME_ZONE_INFORMATION info = {};
+  if (::GetDynamicTimeZoneInformation(&info) == TIME_ZONE_ID_INVALID) {
+    return std::string();
+  }
+  {
+    const int buffer_size = 32;
+    UChar buffer[buffer_size];
+    status = U_ZERO_ERROR;
+    length = icu.ucal_getTimeZoneIDForWindowsID(
+        info.TimeZoneKeyName, -1, nullptr, buffer, buffer_size, &status);
+    if (U_SUCCESS(status) && length >= 0) {
+      return Utf16ToUtf8(buffer, length);
+    }
+    if (status != U_BUFFER_OVERFLOW_ERROR || length <= 0) {
+      return std::string();
+    }
+  }
+  const int buffer_size = length + 1;  // +1 for null terminator
+  auto buffer = std::unique_ptr<UChar[]>(new UChar[buffer_size]);
+  status = U_ZERO_ERROR;
+  length = icu.ucal_getTimeZoneIDForWindowsID(
+      info.TimeZoneKeyName, -1, nullptr, buffer.get(), buffer_size, &status);
+  if (U_SUCCESS(status) && length >= 0) {
+    return Utf16ToUtf8(buffer.get(), length);
+  }
+  return std::string();
+}
+
+}  // namespace icu
+}  // namespace cctz
+
+#endif

src/icu_win.h

@@ -0,0 +1,30 @@
+// Copyright 2025 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//   https://www.apache.org/licenses/LICENSE-2.0
+//
+//   Unless required by applicable law or agreed to in writing, software
+//   distributed under the License is distributed on an "AS IS" BASIS,
+//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//   See the License for the specific language governing permissions and
+//   limitations under the License.
+
+#ifndef CCTZ_ICU_WIN_H_
+#define CCTZ_ICU_WIN_H_
+
+#if defined(_WIN32)
+#include <string>
+
+namespace cctz {
+namespace icu {
+
+std::string GetWindowsLocalTimeZone();
+
+}  // namespace icu
+}  // namespace cctz
+
+#endif  // defined(_WIN32)
+#endif  // CCTZ_ICU_WIN_H_