Arch Linux User Repository

I just compiled the 101.0.4945.0 sources using this package's PKGBUILD. If you leave nacl enabled with that version, it does not compile:

../../native_client/src/shared/platform/posix/nacl_threads.c:32:59: error: function-like macro '__sysconf' is not defined
#if !defined(__native_client__) && NACL_KERN_STACK_SIZE < PTHREAD_STACK_MIN
                                                          ^
/usr/include/bits/pthread_stack_min-dynamic.h:26:30: note: expanded from macro 'PTHREAD_STACK_MIN'
#   define PTHREAD_STACK_MIN __sysconf (__SC_THREAD_STACK_MIN_VALUE)
                             ^
../../native_client/src/shared/platform/posix/nacl_threads.c:47:18: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'long' [-Wsign-compare]
  if (stack_size < PTHREAD_STACK_MIN) {
      ~~~~~~~~~~ ^ ~~~~~~~~~~~~~~~~~
1 warning and 1 error generated.

Also, third_party/tcmalloc has to be commented out as it does not seem to be still included in 101.0.4945.0.

Due to the 101.0.4945.0 not being able to compile with nacl enabled, I for now had to disable that by setting 'enable_nacl=false'.

As a consequence, all entries in _nacl_libs have to be commented out. Finally, headless_lib.pak is not there in 101.0.4945.0 so it has to be commented out, either.

is a typo

about nacl. im still use it because https://chrome.google.com/webstore/detail/secure-shell/iodihamcpbpeioajjeobimgagajmlibd needs it

your patch provided below fix the issue using system icu AND enable nacl?

The _keeplibs variable currently reads as follows:

...
           'third_party/swiftshader/third_party/SPIRV-Headers/include/spirv/unified1'
           'third_party/tcmalloc'
           'third_party/tensorflow-text'
           'third_party/tflite'
           'third_party/tflite/src/third_party/eigen3'
           'third_party/tflite/src/third_party/fft2d'
           'third_party/tcmalloc'
...

Is there a special reason why 'third_party/tcmalloc' is included twice?

Just confirmed: Chromium 99.0.4844.9 runs with

   'enable_nacl=false'
   'enable_nacl_nonsfi=false'
   'enable_hangout_services_extension=false'
   'enable_widevine=false'

and with the system ICU. Thanks for the good work providing this package!

It is also possible to use system icu after this patch to the sources:

--- a/base/BUILD.gn 2021-08-04 18:26:08.618031942 +0200
+++ b/base/BUILD.gn 2021-08-04 18:27:08.884244626 +0200
@@ -762,7 +762,6 @@
     "third_party/cityhash/city.h",
     "third_party/cityhash_v103/src/city_v103.cc",
     "third_party/cityhash_v103/src/city_v103.h",
-    "third_party/icu/icu_utf.h",
     "third_party/nspr/prtime.cc",
     "third_party/nspr/prtime.h",
     "third_party/superfasthash/superfasthash.c",
--- a/base/files/file_path.cc   2021-08-04 18:27:50.660596514 +0200
+++ b/base/files/file_path.cc   2021-08-04 18:30:29.379400090 +0200
@@ -26,7 +26,7 @@

 #if defined(OS_APPLE)
 #include "base/mac/scoped_cftyperef.h"
-#include "base/third_party/icu/icu_utf.h"
+#include "unicode/utf.h"
 #endif

 #if defined(OS_WIN)
@@ -1186,9 +1186,9 @@
                                             int* index) {
   int codepoint = 0;
   while (*index < length && codepoint == 0) {
-    // CBU8_NEXT returns a value < 0 in error cases. For purposes of string
+    // U8_NEXT returns a value < 0 in error cases. For purposes of string
     // comparison, we just use that value and flag it with DCHECK.
-    CBU8_NEXT(string, *index, length, codepoint);
+    U8_NEXT(string, *index, length, codepoint);
     DCHECK_GT(codepoint, 0);
     if (codepoint > 0) {
       // Check if there is a subtable for this upper byte.
--- a/base/json/json_parser.cc  2021-08-04 18:35:06.730641327 +0200
+++ b/base/json/json_parser.cc  2021-08-04 18:36:54.193163718 +0200
@@ -19,7 +19,7 @@
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversion_utils.h"
 #include "base/strings/utf_string_conversions.h"
-#include "base/third_party/icu/icu_utf.h"
+#include <unicode/utf.h>
 #include "third_party/abseil-cpp/absl/types/optional.h"

 namespace base {
@@ -639,9 +639,9 @@

   // If this is a high surrogate, consume the next code unit to get the
   // low surrogate.
-  if (CBU16_IS_SURROGATE(code_unit16_high)) {
+  if (U16_IS_SURROGATE(code_unit16_high)) {
     // Make sure this is the high surrogate.
-    if (!CBU16_IS_SURROGATE_LEAD(code_unit16_high)) {
+    if (!U16_IS_SURROGATE_LEAD(code_unit16_high)) {
       if ((options_ & JSON_REPLACE_INVALID_CHARACTERS) == 0)
         return false;
       *out_code_point = kUnicodeReplacementPoint;
@@ -665,7 +665,7 @@
     if (!UnprefixedHexStringToInt(*escape_sequence, &code_unit16_low))
       return false;

-    if (!CBU16_IS_TRAIL(code_unit16_low)) {
+    if (!U16_IS_TRAIL(code_unit16_low)) {
       if ((options_ & JSON_REPLACE_INVALID_CHARACTERS) == 0)
         return false;
       *out_code_point = kUnicodeReplacementPoint;
@@ -673,12 +673,12 @@
     }

     uint32_t code_point =
-        CBU16_GET_SUPPLEMENTARY(code_unit16_high, code_unit16_low);
+        U16_GET_SUPPLEMENTARY(code_unit16_high, code_unit16_low);

     *out_code_point = code_point;
   } else {
     // Not a surrogate.
-    DCHECK(CBU16_IS_SINGLE(code_unit16_high));
+    DCHECK(U16_IS_SINGLE(code_unit16_high));

     *out_code_point = code_unit16_high;
   }
--- a/base/json/string_escape.cc    2021-08-04 17:30:48.973063734 +0200
+++ b/base/json/string_escape.cc    2021-08-04 18:46:25.742182189 +0200
@@ -14,7 +14,7 @@
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversion_utils.h"
 #include "base/strings/utf_string_conversions.h"
-#include "base/third_party/icu/icu_utf.h"
+#include <unicode/utf.h>

 namespace base {

--- a/base/strings/pattern.cc   2021-08-04 18:47:56.511496789 +0200
+++ b/base/strings/pattern.cc   2021-08-04 18:51:26.059914447 +0200
@@ -4,13 +4,13 @@

 #include "base/strings/pattern.h"

-#include "base/third_party/icu/icu_utf.h"
+#include <unicode/utf.h>

 namespace base {

 namespace {

-constexpr bool IsWildcard(base_icu::UChar32 character) {
+constexpr bool IsWildcard(UChar32 character) {
   return character == '*' || character == '?';
 }

@@ -55,9 +55,9 @@
       // Check if the chars match, if so, increment the ptrs.
       const CHAR* pattern_next = *pattern;
       const CHAR* string_next = *string;
-      base_icu::UChar32 pattern_char = next(&pattern_next, pattern_end);
+      UChar32 pattern_char = next(&pattern_next, pattern_end);
       if (pattern_char == next(&string_next, string_end) &&
-          pattern_char != CBU_SENTINEL) {
+          pattern_char != U_SENTINEL) {
         *pattern = pattern_next;
         *string = string_next;
         continue;
@@ -121,20 +121,20 @@
 }

 struct NextCharUTF8 {
-  base_icu::UChar32 operator()(const char** p, const char* end) {
-    base_icu::UChar32 c;
+  UChar32 operator()(const char** p, const char* end) {
+    UChar32 c;
     int offset = 0;
-    CBU8_NEXT(*p, offset, end - *p, c);
+    U8_NEXT(*p, offset, end - *p, c);
     *p += offset;
     return c;
   }
 };

 struct NextCharUTF16 {
-  base_icu::UChar32 operator()(const char16_t** p, const char16_t* end) {
-    base_icu::UChar32 c;
+  UChar32 operator()(const char16_t** p, const char16_t* end) {
+    UChar32 c;
     int offset = 0;
-    CBU16_NEXT(*p, offset, end - *p, c);
+    U16_NEXT(*p, offset, end - *p, c);
     *p += offset;
     return c;
   }
--- a/base/strings/string_util.cc   2021-08-04 18:53:29.892372670 +0200
+++ b/base/strings/string_util.cc   2021-08-04 18:55:34.808145957 +0200
@@ -27,7 +27,7 @@
 #include "base/strings/string_util_internal.h"
 #include "base/strings/utf_string_conversion_utils.h"
 #include "base/strings/utf_string_conversions.h"
-#include "base/third_party/icu/icu_utf.h"
+#include <unicode/utf.h>
 #include "build/build_config.h"

 namespace base {
@@ -173,19 +173,19 @@
   }
   DCHECK_LE(byte_size,
             static_cast<uint32_t>(std::numeric_limits<int32_t>::max()));
-  // Note: This cast is necessary because CBU8_NEXT uses int32_ts.
+  // Note: This cast is necessary because U8_NEXT uses int32_ts.
   int32_t truncation_length = static_cast<int32_t>(byte_size);
   int32_t char_index = truncation_length - 1;
   const char* data = input.data();

-  // Using CBU8, we will move backwards from the truncation point
+  // Using U8, we will move backwards from the truncation point
   // to the beginning of the string looking for a valid UTF8
   // character.  Once a full UTF8 character is found, we will
   // truncate the string to the end of that character.
   while (char_index >= 0) {
     int32_t prev = char_index;
-    base_icu::UChar32 code_point = 0;
-    CBU8_NEXT(data, char_index, truncation_length, code_point);
+    UChar32 code_point = 0;
+    U8_NEXT(data, char_index, truncation_length, code_point);
     if (!IsValidCharacter(code_point) ||
         !IsValidCodepoint(code_point)) {
       char_index = prev - 1;
--- a/ui/gfx/utf16_indexing.cc  2021-08-04 19:02:42.921692352 +0200
+++ b/ui/gfx/utf16_indexing.cc  2021-08-04 19:03:40.487934831 +0200
@@ -5,13 +5,13 @@
 #include "ui/gfx/utf16_indexing.h"

 #include "base/check_op.h"
-#include "base/third_party/icu/icu_utf.h"
+#include <unicode/utf.h>

 namespace gfx {

 bool IsValidCodePointIndex(const std::u16string& s, size_t index) {
   return index == 0 || index == s.length() ||
-    !(CBU16_IS_TRAIL(s[index]) && CBU16_IS_LEAD(s[index - 1]));
+    !(U16_IS_TRAIL(s[index]) && U16_IS_LEAD(s[index - 1]));
 }

 ptrdiff_t UTF16IndexToOffset(const std::u16string& s, size_t base, size_t pos) {
--- a/base/strings/utf_string_conversion_utils.cc.orig  2021-08-04 18:56:28.594425021 +0200
+++ b/base/strings/utf_string_conversion_utils.cc   2021-08-04 19:54:54.358528026 +0200
@@ -4,7 +4,7 @@

 #include "base/strings/utf_string_conversion_utils.h"

-#include "base/third_party/icu/icu_utf.h"
+#include <unicode/utf.h>
 #include "build/build_config.h"

 namespace base {
@@ -19,7 +19,7 @@
   // use a signed type for code_point.  But this function returns false
   // on error anyway, so code_point_out is unsigned.
   int32_t code_point;
-  CBU8_NEXT(src, *char_index, src_len, code_point);
+  U8_NEXT(src, *char_index, src_len, code_point);
   *code_point_out = static_cast<uint32_t>(code_point);

   // The ICU macro above moves to the next char, we want to point to the last
@@ -34,16 +34,16 @@
                           int32_t src_len,
                           int32_t* char_index,
                           uint32_t* code_point) {
-  if (CBU16_IS_SURROGATE(src[*char_index])) {
-    if (!CBU16_IS_SURROGATE_LEAD(src[*char_index]) ||
+  if (U16_IS_SURROGATE(src[*char_index])) {
+    if (!U16_IS_SURROGATE_LEAD(src[*char_index]) ||
         *char_index + 1 >= src_len ||
-        !CBU16_IS_TRAIL(src[*char_index + 1])) {
+        !U16_IS_TRAIL(src[*char_index + 1])) {
       // Invalid surrogate pair.
       return false;
     }

     // Valid surrogate pair.
-    *code_point = CBU16_GET_SUPPLEMENTARY(src[*char_index],
+    *code_point = U16_GET_SUPPLEMENTARY(src[*char_index],
                                           src[*char_index + 1]);
     (*char_index)++;
   } else {
@@ -77,30 +77,30 @@
   }


-  // CBU8_APPEND_UNSAFE can append up to 4 bytes.
+  // U8_APPEND_UNSAFE can append up to 4 bytes.
   size_t char_offset = output->length();
   size_t original_char_offset = char_offset;
-  output->resize(char_offset + CBU8_MAX_LENGTH);
+  output->resize(char_offset + U8_MAX_LENGTH);

-  CBU8_APPEND_UNSAFE(&(*output)[0], char_offset, code_point);
+  U8_APPEND_UNSAFE(&(*output)[0], char_offset, code_point);

-  // CBU8_APPEND_UNSAFE will advance our pointer past the inserted character, so
+  // U8_APPEND_UNSAFE will advance our pointer past the inserted character, so
   // it will represent the new length of the string.
   output->resize(char_offset);
   return char_offset - original_char_offset;
 }

 size_t WriteUnicodeCharacter(uint32_t code_point, std::u16string* output) {
-  if (CBU16_LENGTH(code_point) == 1) {
+  if (U16_LENGTH(code_point) == 1) {
     // Thie code point is in the Basic Multilingual Plane (BMP).
     output->push_back(static_cast<char16_t>(code_point));
     return 1;
   }
   // Non-BMP characters use a double-character encoding.
   size_t char_offset = output->length();
-  output->resize(char_offset + CBU16_MAX_LENGTH);
-  CBU16_APPEND_UNSAFE(&(*output)[0], char_offset, code_point);
-  return CBU16_MAX_LENGTH;
+  output->resize(char_offset + U16_MAX_LENGTH);
+  U16_APPEND_UNSAFE(&(*output)[0], char_offset, code_point);
+  return U16_MAX_LENGTH;
 }

 // Generalized Unicode converter -----------------------------------------------
--- a/base/json/string_escape.cc    2021-08-04 23:24:06.001124181 +0200
+++ b/base/json/string_escape.cc    2021-08-04 23:24:49.897457457 +0200
@@ -92,7 +92,7 @@
   for (int32_t i = 0; i < length; ++i) {
     uint32_t code_point;
     if (!ReadUnicodeCharacter(str.data(), length, &i, &code_point) ||
-        code_point == static_cast<decltype(code_point)>(CBU_SENTINEL) ||
+        code_point == static_cast<decltype(code_point)>(U_SENTINEL) ||
         !IsValidCodepoint(code_point)) {
       code_point = kReplacementCodePoint;
       did_replacement = true;
--- a/base/strings/string_util_internal.h   2021-08-04 23:33:49.036681262 +0200
+++ b/base/strings/string_util_internal.h   2021-08-04 23:35:06.626091464 +0200
@@ -11,7 +11,7 @@
 #include "base/notreached.h"
 #include "base/ranges/algorithm.h"
 #include "base/strings/string_piece.h"
-#include "base/third_party/icu/icu_utf.h"
+#include <unicode/utf.h>

 namespace base {

@@ -233,7 +233,7 @@

   while (char_index < src_len) {
     int32_t code_point;
-    CBU8_NEXT(src, char_index, src_len, code_point);
+    U8_NEXT(src, char_index, src_len, code_point);
     if (!Validator(code_point))
       return false;
   }
--- a/base/strings/escape.cc    2021-08-05 09:17:12.432399855 +0200
+++ b/base/strings/escape.cc    2021-08-05 09:17:54.222088806 +0200
@@ -7,7 +7,7 @@
 #include "base/strings/string_piece.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversion_utils.h"
-#include "base/third_party/icu/icu_utf.h"
+#include <unicode/utf.h>

 namespace base {

@@ -84,14 +84,14 @@
                                   std::string* unescaped_out) {
   DCHECK(unescaped_out->empty());

-  unsigned char bytes[CBU8_MAX_LENGTH];
+  unsigned char bytes[U8_MAX_LENGTH];
   if (!UnescapeUnsignedByteAtIndex(escaped_text, index, &bytes[0]))
     return false;

   size_t num_bytes = 1;

   // If this is a lead byte, need to collect trail bytes as well.
-  if (CBU8_IS_LEAD(bytes[0])) {
+  if (U8_IS_LEAD(bytes[0])) {
     // Look for the last trail byte of the UTF-8 character.  Give up once
     // reach max character length number of bytes, or hit an unescaped
     // character. No need to check length of escaped_text, as
@@ -99,7 +99,7 @@
     while (num_bytes < size(bytes) &&
            UnescapeUnsignedByteAtIndex(escaped_text, index + num_bytes * 3,
                                        &bytes[num_bytes]) &&
-           CBU8_IS_TRAIL(bytes[num_bytes])) {
+           U8_IS_TRAIL(bytes[num_bytes])) {
       ++num_bytes;
     }
   }

--- a/ui/base/ime/character_composer.cc 2021-08-05 10:22:00.819616049 +0200
+++ b/ui/base/ime/character_composer.cc 2021-08-05 10:23:03.695813471 +0200
@@ -13,7 +13,7 @@
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversion_utils.h"
 #include "base/strings/utf_string_conversions.h"
-#include "base/third_party/icu/icu_utf.h"
+#include <unicode/utf.h>
 #include "ui/events/event.h"
 #include "ui/events/keycodes/dom/dom_key.h"
 #include "ui/events/keycodes/dom/keycode_converter.h"
@@ -37,12 +37,12 @@
 bool UTF32CharacterToUTF16(uint32_t character, std::u16string* output) {
   output->clear();
   // Reject invalid character. (e.g. codepoint greater than 0x10ffff)
-  if (!CBU_IS_UNICODE_CHAR(character))
+  if (!U_IS_UNICODE_CHAR(character))
     return false;
   if (character) {
-    output->resize(CBU16_LENGTH(character));
+    output->resize(U16_LENGTH(character));
     size_t i = 0;
-    CBU16_APPEND_UNSAFE(&(*output)[0], i, character);
+    U16_APPEND_UNSAFE(&(*output)[0], i, character);
   }
   return true;
 }
--- a/components/filename_generation/filename_generation.cc 2021-08-05 10:37:39.502739983 +0200
+++ b/components/filename_generation/filename_generation.cc 2021-08-05 10:38:18.405784645 +0200
@@ -11,7 +11,7 @@
 #include "base/strings/string_util.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
-#include "base/third_party/icu/icu_utf.h"
+#include <unicode/utf.h>
 #include "build/build_config.h"
 #include "build/chromeos_buildflags.h"
 #include "components/url_formatter/url_formatter.h"
@@ -168,7 +168,7 @@
 #elif defined(OS_WIN)
   // UTF-16.
   DCHECK(name.size() > limit);
-  truncated = name.substr(0, CBU16_IS_TRAIL(name[limit]) ? limit - 1 : limit);
+  truncated = name.substr(0, U16_IS_TRAIL(name[limit]) ? limit - 1 : limit);
 #else
 // We cannot generally assume that the file name encoding is in UTF-8 (see
 // the comment for FilePath::AsUTF8Unsafe), hence no safe way to truncate.
--- a/net/cert/internal/parse_name.cc   2021-08-05 10:40:08.241635390 +0200
+++ b/net/cert/internal/parse_name.cc   2021-08-05 10:40:37.068087718 +0200
@@ -11,7 +11,7 @@
 #include "base/strings/utf_string_conversion_utils.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/sys_byteorder.h"
-#include "base/third_party/icu/icu_utf.h"
+#include <unicode/utf.h>

 namespace net {

@@ -36,7 +36,7 @@

     // BMPString only supports codepoints in the Basic Multilingual Plane;
     // surrogates are not allowed.
-    if (CBU_IS_SURROGATE(c))
+    if (U_IS_SURROGATE(c))
       return false;
   }
   return base::UTF16ToUTF8(in_16bit.data(), in_16bit.size(), out);
@@ -56,7 +56,7 @@
   for (const uint32_t c : in_32bit) {
     // UniversalString is UCS-4 in big-endian order.
     uint32_t codepoint = base::NetToHost32(c);
-    if (!CBU_IS_UNICODE_CHAR(codepoint))
+    if (!U_IS_UNICODE_CHAR(codepoint))
       return false;

     base::WriteUnicodeCharacter(codepoint, out);
--- a/net/base/escape.cc    2021-08-05 10:41:42.997597240 +0200
+++ b/net/base/escape.cc    2021-08-05 10:42:10.937389282 +0200
@@ -11,7 +11,7 @@
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversion_utils.h"
 #include "base/strings/utf_string_conversions.h"
-#include "base/third_party/icu/icu_utf.h"
+#include <unicode/utf.h>
 #include "build/build_config.h"

 namespace net {
--- a/tools/gn/src/base/third_party/icu/icu_utf.cc  2021-08-05 10:43:07.293636317 +0200
+++ b/tools/gn/src/base/third_party/icu/icu_utf.cc  2021-08-05 10:43:58.736586415 +0200
@@ -19,7 +19,7 @@
 *   that would otherwise be too long as macros.
 */

-#include "base/third_party/icu/icu_utf.h"
+#include <unicode/utf.h>

 namespace base_icu {

@@ -36,7 +36,7 @@
   } else if (strict == -3) {
     return 0xfffd;
   } else {
-    return CBU_SENTINEL;
+    return U_SENTINEL;
   }
 }

@@ -78,13 +78,13 @@
     // U8_NEXT() handles shorter valid sequences inline.
     uint8_t t1 = s[i], t2, t3;
     c &= 7;
-    if (CBU8_IS_VALID_LEAD4_AND_T1(c, t1) && ++i != length &&
+    if (U8_IS_VALID_LEAD4_AND_T1(c, t1) && ++i != length &&
         (t2 = s[i] - 0x80) <= 0x3f && ++i != length &&
         (t3 = s[i] - 0x80) <= 0x3f) {
       ++i;
       c = (c << 18) | ((t1 & 0x3f) << 12) | (t2 << 6) | t3;
       // strict: forbid non-characters like U+fffe
-      if (strict <= 0 || !CBU_IS_UNICODE_NONCHAR(c)) {
+      if (strict <= 0 || !U_IS_UNICODE_NONCHAR(c)) {
         *pi = i;
         return c;
       }
@@ -93,12 +93,12 @@
     c &= 0xf;
     if (strict != -2) {
       uint8_t t1 = s[i], t2;
-      if (CBU8_IS_VALID_LEAD3_AND_T1(c, t1) && ++i != length &&
+      if (U8_IS_VALID_LEAD3_AND_T1(c, t1) && ++i != length &&
           (t2 = s[i] - 0x80) <= 0x3f) {
         ++i;
         c = (c << 12) | ((t1 & 0x3f) << 6) | t2;
         // strict: forbid non-characters like U+fffe
-        if (strict <= 0 || !CBU_IS_UNICODE_NONCHAR(c)) {
+        if (strict <= 0 || !U_IS_UNICODE_NONCHAR(c)) {
           *pi = i;
           return c;
         }
--- a/tools/gn/src/base/files/file_path.cc  2021-08-05 10:45:22.262630525 +0200
+++ b/tools/gn/src/base/files/file_path.cc  2021-08-05 10:46:05.652306974 +0200
@@ -18,7 +18,7 @@

 #if defined(OS_MACOSX)
 #include "base/mac/scoped_cftyperef.h"
-#include "base/third_party/icu/icu_utf.h"
+#include <unicode/utf.h>
 #endif

 #if defined(OS_WIN)
--- a/tools/gn/src/base/strings/utf_string_conversion_utils.cc  2021-08-05 10:47:09.295165556 +0200
+++ b/tools/gn/src/base/strings/utf_string_conversion_utils.cc  2021-08-05 10:47:52.798174297 +0200
@@ -4,7 +4,7 @@

 #include "base/strings/utf_string_conversion_utils.h"

-#include "base/third_party/icu/icu_utf.h"
+#include <unicode/utf.h>
 #include "util/build_config.h"

 namespace base {
@@ -19,7 +19,7 @@
   // use a signed type for code_point.  But this function returns false
   // on error anyway, so code_point_out is unsigned.
   int32_t code_point;
-  CBU8_NEXT(src, *char_index, src_len, code_point);
+  U8_NEXT(src, *char_index, src_len, code_point);
   *code_point_out = static_cast<uint32_t>(code_point);

   // The ICU macro above moves to the next char, we want to point to the last
@@ -34,16 +34,16 @@
                           int32_t src_len,
                           int32_t* char_index,
                           uint32_t* code_point) {
-  if (CBU16_IS_SURROGATE(src[*char_index])) {
-    if (!CBU16_IS_SURROGATE_LEAD(src[*char_index]) ||
-        *char_index + 1 >= src_len || !CBU16_IS_TRAIL(src[*char_index + 1])) {
+  if (U16_IS_SURROGATE(src[*char_index])) {
+    if (!U16_IS_SURROGATE_LEAD(src[*char_index]) ||
+        *char_index + 1 >= src_len || !U16_IS_TRAIL(src[*char_index + 1])) {
       // Invalid surrogate pair.
       return false;
     }

     // Valid surrogate pair.
     *code_point =
-        CBU16_GET_SUPPLEMENTARY(src[*char_index], src[*char_index + 1]);
+        U16_GET_SUPPLEMENTARY(src[*char_index], src[*char_index + 1]);
     (*char_index)++;
   } else {
     // Not a surrogate, just one 16-bit word.
@@ -62,30 +62,30 @@
     return 1;
   }

-  // CBU8_APPEND_UNSAFE can append up to 4 bytes.
+  // U8_APPEND_UNSAFE can append up to 4 bytes.
   size_t char_offset = output->length();
   size_t original_char_offset = char_offset;
-  output->resize(char_offset + CBU8_MAX_LENGTH);
+  output->resize(char_offset + U8_MAX_LENGTH);

-  CBU8_APPEND_UNSAFE(&(*output)[0], char_offset, code_point);
+  U8_APPEND_UNSAFE(&(*output)[0], char_offset, code_point);

-  // CBU8_APPEND_UNSAFE will advance our pointer past the inserted character, so
+  // U8_APPEND_UNSAFE will advance our pointer past the inserted character, so
   // it will represent the new length of the string.
   output->resize(char_offset);
   return char_offset - original_char_offset;
 }

 size_t WriteUnicodeCharacter(uint32_t code_point, std::u16string* output) {
-  if (CBU16_LENGTH(code_point) == 1) {
+  if (U16_LENGTH(code_point) == 1) {
     // Thie code point is in the Basic Multilingual Plane (BMP).
     output->push_back(static_cast<char16_t>(code_point));
     return 1;
   }
   // Non-BMP characters use a double-character encoding.
   size_t char_offset = output->length();
-  output->resize(char_offset + CBU16_MAX_LENGTH);
-  CBU16_APPEND_UNSAFE(&(*output)[0], char_offset, code_point);
-  return CBU16_MAX_LENGTH;
+  output->resize(char_offset + U16_MAX_LENGTH);
+  U16_APPEND_UNSAFE(&(*output)[0], char_offset, code_point);
+  return U16_MAX_LENGTH;
 }

 // Generalized Unicode converter -----------------------------------------------
--- a/tools/gn/src/base/strings/string_util.cc  2021-08-05 10:48:59.417677129 +0200
+++ b/tools/gn/src/base/strings/string_util.cc  2021-08-05 10:49:36.237402265 +0200
@@ -25,7 +25,7 @@
 #include "base/macros.h"
 #include "base/strings/utf_string_conversion_utils.h"
 #include "base/strings/utf_string_conversions.h"
-#include "base/third_party/icu/icu_utf.h"
+#include <unicode/utf.h>
 #include "util/build_config.h"

 namespace base {
@@ -297,19 +297,19 @@
   }
   DCHECK_LE(byte_size,
             static_cast<uint32_t>(std::numeric_limits<int32_t>::max()));
-  // Note: This cast is necessary because CBU8_NEXT uses int32_ts.
+  // Note: This cast is necessary because U8_NEXT uses int32_ts.
   int32_t truncation_length = static_cast<int32_t>(byte_size);
   int32_t char_index = truncation_length - 1;
   const char* data = input.data();

-  // Using CBU8, we will move backwards from the truncation point
+  // Using U8, we will move backwards from the truncation point
   // to the beginning of the string looking for a valid UTF8
   // character.  Once a full UTF8 character is found, we will
   // truncate the string to the end of that character.
   while (char_index >= 0) {
     int32_t prev = char_index;
-    base_icu::UChar32 code_point = 0;
-    CBU8_NEXT(data, char_index, truncation_length, code_point);
+    UChar32 code_point = 0;
+    U8_NEXT(data, char_index, truncation_length, code_point);
     if (!IsValidCharacter(code_point) || !IsValidCodepoint(code_point)) {
       char_index = prev - 1;
     } else {
@@ -453,7 +453,7 @@

   while (char_index < src_len) {
     int32_t code_point;
-    CBU8_NEXT(src, char_index, src_len, code_point);
+    U8_NEXT(src, char_index, src_len, code_point);
     if (!IsValidCharacter(code_point))
       return false;
   }
--- a/tools/gn/src/base/strings/string_split.cc 2021-08-05 10:51:54.316371187 +0200
+++ b/tools/gn/src/base/strings/string_split.cc 2021-08-05 10:52:21.186170479 +0200
@@ -8,7 +8,7 @@

 #include "base/logging.h"
 #include "base/strings/string_util.h"
-#include "base/third_party/icu/icu_utf.h"
+#include <unicode/utf.h>

 namespace base {

--- a/tools/gn/src/base/json/string_escape.cc   2021-08-05 10:53:00.515876682 +0200
+++ b/tools/gn/src/base/json/string_escape.cc   2021-08-05 10:53:32.152306995 +0200
@@ -14,7 +14,7 @@
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversion_utils.h"
 #include "base/strings/utf_string_conversions.h"
-#include "base/third_party/icu/icu_utf.h"
+#include <unicode/utf.h>

 namespace base {

@@ -92,7 +92,7 @@
   for (int32_t i = 0; i < length; ++i) {
     uint32_t code_point;
     if (!ReadUnicodeCharacter(str.data(), length, &i, &code_point) ||
-        code_point == static_cast<decltype(code_point)>(CBU_SENTINEL) ||
+        code_point == static_cast<decltype(code_point)>(U_SENTINEL) ||
         !IsValidCharacter(code_point)) {
       code_point = kReplacementCodePoint;
       did_replacement = true;
--- a/tools/gn/src/base/json/json_parser.cc 2021-08-05 10:54:43.705105681 +0200
+++ b/tools/gn/src/base/json/json_parser.cc 2021-08-05 10:55:16.498193950 +0200
@@ -17,7 +17,7 @@
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversion_utils.h"
 #include "base/strings/utf_string_conversions.h"
-#include "base/third_party/icu/icu_utf.h"
+#include <unicode/utf.h>
 #include "base/values.h"

 namespace base {
@@ -569,10 +569,10 @@

   // If this is a high surrogate, consume the next code unit to get the
   // low surrogate.
-  if (CBU16_IS_SURROGATE(code_unit16_high)) {
+  if (U16_IS_SURROGATE(code_unit16_high)) {
     // Make sure this is the high surrogate. If not, it's an encoding
     // error.
-    if (!CBU16_IS_SURROGATE_LEAD(code_unit16_high))
+    if (!U16_IS_SURROGATE_LEAD(code_unit16_high))
       return false;

     // Make sure that the token has more characters to consume the
@@ -588,18 +588,18 @@
     if (!HexStringToInt(*escape_sequence, &code_unit16_low))
       return false;

-    if (!CBU16_IS_TRAIL(code_unit16_low))
+    if (!U16_IS_TRAIL(code_unit16_low))
       return false;

     uint32_t code_point =
-        CBU16_GET_SUPPLEMENTARY(code_unit16_high, code_unit16_low);
+        U16_GET_SUPPLEMENTARY(code_unit16_high, code_unit16_low);
     if (!IsValidCharacter(code_point))
       return false;

     *out_code_point = code_point;
   } else {
     // Not a surrogate.
-    DCHECK(CBU16_IS_SINGLE(code_unit16_high));
+    DCHECK(U16_IS_SINGLE(code_unit16_high));
     if (!IsValidCharacter(code_unit16_high)) {
       if ((options_ & JSON_REPLACE_INVALID_CHARACTERS) == 0) {
         return false;

--- a/tools/cfi/ignores.txt 2021-08-26 16:07:35.744982216 +0200
+++ b/tools/cfi/ignores.txt 2021-08-26 16:08:04.958072127 +0200
@@ -124,6 +124,7 @@
 type:sandbox::BrokerServices
 type:sandbox::TargetPolicy
 type:sandbox::TargetServices
+type:icu_60::*

 #############################################################################
 # Disabled indirect calls

Of course, you will then also have to include icu in the depends() and _use_system() arrays in PKGBUILD.

Additionally, the compile flags have to be amended (best place will be right below the _use_system() declaration):

  if [[ "${_use_system[*]}" =~ "icu" ]]; then
    _flags+=('icu_use_data_file=false')
  fi

Works well with 99.0.4844.9 (adjusted pkgver() in PKGBUILD).

What I found in the Chromium developer forums: To speed up the compile process and to streamline the package, you can omit certain build options by setting them to false:

# Most developers don't normally need to test Native Client capabilities and can speed up the build by disabling it.
   'enable_nacl=false'
   'enable_nacl_nonsfi=false'
# not everybody needs these
   'enable_hangout_services_extension=false'
   'enable_widevine=false'

Of course, if the Native Client is not built, the following section in PKGBUILD has to be commented out:

  # Install NaCL.
  _nacl_libs=(
             # 'nacl_helper'
             # 'nacl_helper_bootstrap'
             # 'nacl_irt_x86_64.nexe'
              )
  for i in "${_nacl_libs[@]}"; do
    install -Dm755 "${i}" "${pkgdir}/usr/lib/chromium-dev/${i}"
    case "$i" in
      nacl_irt_x86_64.nexe)
        ;;
      *)
        strip $STRIP_BINARIES "${pkgdir}/usr/lib/chromium-dev/${i}"
        ;;
    esac
  done

I am currently running 99.0.4844.0 without the Native Client and could not observe any problems so far.

Finally, it seems to make sense to set an alias like this

alias touch='echo -n >>'

before the Build all command (LC_ALL=C ninja -C out/Release -v chrome chrome_sandbox chromedriver). This also speeds up things a little bit as calling touch as an external command takes much longer than using the echo internal command.

new version (99.0.4840.0) is in build process right now

Looks like gentoo removed a patch file:

https://raw.githubusercontent.com/gentoo/gentoo/master/www-client/chromium/files/chromium-97-fix-tag-dragging-i3.patch

Compiling works if you replace the url with one pointing to a previous version of the repository (where the file still exists).

Whether or not the patch is still needed, that's up to the maintainer to determine (there's a reason why gentoo decided to delete the patch).