build: Introduce GURL with shimmed ICU

.bazelrc

@@ -36,6 +36,9 @@ build --action_env=CXX
 build --action_env=LLVM_CONFIG
 build --action_env=PATH
 
+# Skip system ICU linking.
+build --@com_googlesource_googleurl//build_config:system_icu=0
+
 # Common flags for sanitizers
 build:sanitizer --define tcmalloc=disabled
 build:sanitizer --linkopt -ldl

bazel/external/googleurl.patch

@@ -0,0 +1,52 @@
+# TODO(dio): Consider to remove this patch when we solely compile the project using clang-cl.
+# Tracked in https://github.com/envoyproxy/envoy/issues/11974.
+
+diff --git a/base/compiler_specific.h b/base/compiler_specific.h
+index 0cd36dc..8c4cbd4 100644
+--- a/base/compiler_specific.h
++++ b/base/compiler_specific.h
+@@ -7,10 +7,6 @@
+
+ #include "build/build_config.h"
+
+-#if defined(COMPILER_MSVC) && !defined(__clang__)
+-#error "Only clang-cl is supported on Windows, see https://crbug.com/988071"
+-#endif
+-
+ // Annotate a variable indicating it's ok if the variable is not used.
+ // (Typically used to silence a compiler warning when the assignment
+ // is important for some other reason.)
+@@ -55,8 +51,12 @@
+ // prevent code folding, see gurl_base::debug::Alias.
+ // Use like:
+ //   void NOT_TAIL_CALLED FooBar();
+-#if defined(__clang__) && __has_attribute(not_tail_called)
++#if defined(__clang__)
++#if defined(__has_attribute)
++#if __has_attribute(not_tail_called)
+ #define NOT_TAIL_CALLED __attribute__((not_tail_called))
++#endif
++#endif
+ #else
+ #define NOT_TAIL_CALLED
+ #endif
+@@ -226,7 +226,9 @@
+ #endif
+ #endif
+
+-#if defined(__clang__) && __has_attribute(uninitialized)
++#if defined(__clang__)
++#if defined(__has_attribute)
++#if __has_attribute(uninitialized)
+ // Attribute "uninitialized" disables -ftrivial-auto-var-init=pattern for
+ // the specified variable.
+ // Library-wide alternative is
+@@ -257,6 +259,8 @@
+ // E.g. platform, bot, benchmark or test name in patch description or next to
+ // the attribute.
+ #define STACK_UNINITIALIZED __attribute__((uninitialized))
++#endif
++#endif
+ #else
+ #define STACK_UNINITIALIZED
+ #endif

bazel/repositories.bzl

@@ -155,6 +155,7 @@ def envoy_dependencies(skip_targets = []):
     _com_googlesource_chromium_v8()
     _com_googlesource_quiche()
     _com_googlesource_googleurl()
+    _org_unicode_icuuc()
     _com_lightstep_tracer_cpp()
     _io_opentracing_cpp()
     _net_zlib()
@@ -698,12 +699,21 @@ def _com_googlesource_quiche():
 def _com_googlesource_googleurl():
     external_http_archive(
         name = "com_googlesource_googleurl",
+        patches = ["@envoy//bazel/external:googleurl.patch"],
+        patch_args = ["-p1"],
     )
     native.bind(
         name = "googleurl",
         actual = "@com_googlesource_googleurl//url:url",
     )
 
+# The local repository for the shimmed ICU.
+def _org_unicode_icuuc():
+    native.local_repository(
+        name = "org_unicode_icuuc",
+        path = "third_party/icu/shim",
+    )
+
 def _org_llvm_releases_compiler_rt():
     external_http_archive(
         name = "org_llvm_releases_compiler_rt",

bazel/repository_locations.bzl

@@ -684,7 +684,7 @@ REPOSITORY_LOCATIONS_SPEC = dict(
         project_name = "Chrome URL parsing library",
         project_desc = "Chrome URL parsing library",
         project_url = "https://quiche.googlesource.com/googleurl",
-        # Static snapshot of https://quiche.googlesource.com/quiche/+archive/ef0d23689e240e6c8de4c3a5296b209128c87373.tar.gz.
+        # Static snapshot of https://quiche.googlesource.com/googleurl/+archive/ef0d23689e240e6c8de4c3a5296b209128c87373.tar.gz.
         version = "ef0d23689e240e6c8de4c3a5296b209128c87373",
         sha256 = "d769283fed1319bca68bae8bdd47fbc3a7933999329eee850eff1f1ea61ce176",
         urls = ["https://storage.googleapis.com/quiche-envoy-integration/googleurl_{version}.tar.gz"],

ci/do_ci.sh

@@ -150,7 +150,7 @@ if [[ $# -ge 1 ]]; then
 else
   # Coverage test will add QUICHE tests by itself.
   COVERAGE_TEST_TARGETS=("//test/...")
-  TEST_TARGETS=("${COVERAGE_TEST_TARGETS[@]}" "@com_googlesource_quiche//:ci_tests")
+  TEST_TARGETS=("${COVERAGE_TEST_TARGETS[@]}" "@com_googlesource_quiche//:ci_tests" "@org_unicode_icuuc//:common_test")
 fi
 
 if [[ "$CI_TARGET" == "bazel.release" ]]; then

third_party/icu/googleurl/BUILD

@@ -0,0 +1,17 @@
+load(
+    "//bazel:envoy_build_system.bzl",
+    "envoy_cc_test",
+    "envoy_package",
+)
+
+licenses(["notice"])  # Apache 2
+
+envoy_package()
+
+envoy_cc_test(
+    name = "test",
+    srcs = ["test.cc"],
+    external_deps = [
+        "googleurl",
+    ],
+)

third_party/icu/googleurl/test.cc

@@ -0,0 +1,35 @@
+#include "url/gurl.h"
+
+#include "gtest/gtest.h"
+
+namespace {
+
+// Basic smoke test to ensure that GURL (with shimmed ICU) works properly.
+TEST(GoogleUrl, SmokeTest) {
+  GURL url("https://example.org/test?foo=bar#section");
+  EXPECT_TRUE(url.is_valid());
+  EXPECT_EQ(url.scheme(), "https");
+  EXPECT_EQ(url.host(), "example.org");
+  EXPECT_EQ(url.EffectiveIntPort(), 443);
+  EXPECT_EQ(url.path(), "/test");
+  EXPECT_EQ(url.query(), "foo=bar");
+  EXPECT_EQ(url.ref(), "section");
+
+  GURL punycode("https://xn--c1yn36f.example");
+  EXPECT_TRUE(punycode.is_valid());
+
+  GURL percent_encoded_valid("https://%20.example");
+  EXPECT_TRUE(percent_encoded_valid.is_valid());
+
+  // Ensure ICU shim is functioning correctly, i.e. not crashing and resulting invalid parsed URL.
+  GURL idn_url("https://\xe5\x85\x89.example/");
+  EXPECT_FALSE(idn_url.is_valid());
+
+  GURL idn_with_percent("https://%Da%aa.example");
+  EXPECT_FALSE(idn_with_percent.is_valid());
+
+  GURL with_bracket("http://[wwww].example");
+  EXPECT_FALSE(with_bracket.is_valid());
+}
+
+} // namespace

third_party/icu/shim/BUILD

@@ -0,0 +1,22 @@
+load("@rules_cc//cc:defs.bzl", "cc_library", "cc_test")
+
+licenses(["notice"])  # Apache 2
+
+cc_library(
+    name = "common",
+    hdrs = [
+        "common/unicode/uidna.h",
+        "common/unicode/utypes.h",
+    ],
+    includes = ["common"],
+    visibility = ["//visibility:public"],
+)
+
+cc_test(
+    name = "common_test",
+    srcs = ["common_test.cc"],
+    visibility = ["//visibility:public"],
+    deps = [
+        ":common",
+    ],
+)

third_party/icu/shim/WORKSPACE

@@ -0,0 +1 @@
+workspace(name = "org_unicode_icuuc")

third_party/icu/shim/common/unicode/uidna.h

@@ -0,0 +1,45 @@
+#pragma once
+
+#include <iostream>
+#include "unicode/utypes.h"
+
+// Initialize UIDNAInfo object with UIDNA_ERROR_DISALLOWED as its errors (any non-zero value should
+// work).
+#define UIDNA_INFO_INITIALIZER                                                                     \
+  { 0x80 }
+
+// This enum is declared to satisfy uidna_openUTS46 when initializing UIDNAWrapper
+// https://quiche.googlesource.com/googleurl/+/ef0d23689e240e6c8de4c3a5296b209128c87373/url/url_idna_icu.cc#50.
+enum { UIDNA_CHECK_BIDI = 4 };
+
+// The fake UIDNA.
+struct UIDNA {};
+
+// The fake UIDNAInfo.
+struct UIDNAInfo {
+  uint32_t errors;
+};
+
+// This is called by IDNToASCII
+// (https://quiche.googlesource.com/googleurl/+/ef0d23689e240e6c8de4c3a5296b209128c87373/url/url_idna_icu.cc#85)
+// which is responsible for converting the Unicode input representing a hostname to ASCII using IDN
+// rules. In this shimmed implementation, we always set the error code to U_ILLEGAL_ARGUMENT_ERROR
+// and info errors to UIDNA_ERROR_DISALLOWED, hence the coversion always fails.
+int32_t uidna_nameToASCII(const UIDNA*, const UChar*, int32_t, UChar*, int32_t, UIDNAInfo* info,
+                          UErrorCode* error_code) {
+  *error_code = U_ILLEGAL_ARGUMENT_ERROR;
+  return 0;
+}
+
+// This is called inside the UIDNAWrapper
+// (https://quiche.googlesource.com/googleurl/+/ef0d23689e240e6c8de4c3a5296b209128c87373/url/url_idna_icu.cc#50)
+// and should be accessed only through GetUIDNA
+// (https://quiche.googlesource.com/googleurl/+/ef0d23689e240e6c8de4c3a5296b209128c87373/url/url_idna_icu.cc#66).
+// This pattern is used inside GURL to initialize a static value at first use. It returns an
+// instance of UIDNA to satisfy the check (GURL_DCHECK(uidna != nullptr);) here:
+// https://quiche.googlesource.com/googleurl/+/ef0d23689e240e6c8de4c3a5296b209128c87373/url/url_idna_icu.cc#89.
+UIDNA* uidna_openUTS46(uint32_t options, UErrorCode* error_code) { return new UIDNA; }
+
+// While this is never be called, it needs to be defined since:
+// https://quiche.googlesource.com/googleurl/+/ef0d23689e240e6c8de4c3a5296b209128c87373/url/url_idna_icu.cc#53.
+const char* u_errorName(UErrorCode) { return "U_ILLEGAL_ARGUMENT_ERROR"; }

third_party/icu/shim/common/unicode/utypes.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#include <cstdint>
+#include <iostream>
+
+using UBool = bool;
+using UChar = uint16_t;
+
+enum UErrorCode {
+  // This value is used for initializing error code in this line:
+  // https://quiche.googlesource.com/googleurl/+/ef0d23689e240e6c8de4c3a5296b209128c87373/url/url_idna_icu.cc#91.
+  U_ZERO_ERROR = 0,
+
+  // This makes info.errors in this line:
+  // https://quiche.googlesource.com/googleurl/+/ef0d23689e240e6c8de4c3a5296b209128c87373/url/url_idna_icu.cc#102
+  // to be non-zero.
+  U_ILLEGAL_ARGUMENT_ERROR = 1,
+
+  // Required in this line:
+  // https://quiche.googlesource.com/googleurl/+/ef0d23689e240e6c8de4c3a5296b209128c87373/url/url_idna_icu.cc#102.
+  U_BUFFER_OVERFLOW_ERROR = 15
+};
+
+// This is called inside IDNToASCII
+// (https://quiche.googlesource.com/googleurl/+/ef0d23689e240e6c8de4c3a5296b209128c87373/url/url_idna_icu.cc#95),
+// this should always return false.
+static inline UBool U_SUCCESS(UErrorCode) { return false; }
+
+// This is called by UIDNAWrapper constructor
+// (https://quiche.googlesource.com/googleurl/+/ef0d23689e240e6c8de4c3a5296b209128c87373/url/url_idna_icu.cc#51).
+// This should always return false, since the initialization of UIDNAWrapper should always be
+// successful.
+static inline UBool U_FAILURE(UErrorCode) { return false; }

third_party/icu/shim/common_test.cc

@@ -0,0 +1,47 @@
+// Basic smoke test to ensure that ICU shim works properly.
+
+#include <iostream>
+#include "unicode/uidna.h"
+
+#define ASSERT_EQ(v1, v2)                                                                          \
+  if ((v1) != (v2)) {                                                                              \
+    std::cerr << "Expected equality of" << std::endl                                               \
+              << "  " << #v1 << " (equal to " << (v1) << ")" << std::endl                          \
+              << "and" << std::endl                                                                \
+              << "  " << #v2 << " (equal to " << (v2) << ")" << std::endl;                         \
+    return 1;                                                                                      \
+  }
+
+int main(int argc, char** argv) {
+  {
+    UErrorCode err = U_ZERO_ERROR;
+    auto uidna = uidna_openUTS46(0, &err);
+
+    ASSERT_EQ(uidna != nullptr, true);
+    ASSERT_EQ(err, U_ZERO_ERROR);
+
+    delete uidna;
+  }
+
+  {
+    UErrorCode err = U_ZERO_ERROR;
+    UIDNAInfo info = UIDNA_INFO_INITIALIZER;
+    uidna_nameToASCII(nullptr, nullptr, 0, nullptr, 0, &info, &err);
+
+    ASSERT_EQ(info.errors, 0x80);
+    ASSERT_EQ(err, U_ILLEGAL_ARGUMENT_ERROR);
+  }
+
+  {
+    UErrorCode err = U_ZERO_ERROR;
+    UIDNAInfo info = UIDNA_INFO_INITIALIZER;
+    UChar data[] = {'1', '2', '3'};
+    UChar* src = &data[0];
+    uidna_nameToASCII(nullptr, src, 0, nullptr, *src, &info, &err);
+
+    ASSERT_EQ(info.errors, 0x80);
+    ASSERT_EQ(err, U_ILLEGAL_ARGUMENT_ERROR);
+  }
+
+  return 0;
+}