Revert a commit.

1 files changed, 450 insertions, 0 deletions

diff --git a/www-client/chromium/files/chromium-125-revert-8a3bec6.patch b/www-client/chromium/files/chromium-125-revert-8a3bec6.patch
new file mode 100644
index 0000000..0f19d49
--- /dev/null
+++ b/www-client/chromium/files/chromium-125-revert-8a3bec6.patch
@@ -0,0 +1,450 @@
+diff --git a/third_party/blink/renderer/platform/BUILD.gn b/third_party/blink/renderer/platform/BUILD.gn
+index 2c079c06c5..34a844659b 100644
+--- a/third_party/blink/renderer/platform/BUILD.gn
++++ b/third_party/blink/renderer/platform/BUILD.gn
+@@ -118,10 +118,7 @@ blink_python_runner("color_data") {
+ 
+ compiled_action("character_data") {
+   tool = ":character_data_generator"
+-  outputs = [
+-    "$blink_platform_output_dir/character_property_data.cc",
+-    "$blink_platform_output_dir/text/break_iterator_data_inline_header.h",
+-  ]
++  outputs = [ "$blink_platform_output_dir/character_property_data.cc" ]
+   args = rebase_path(outputs, root_build_dir)
+ }
+ 
+diff --git a/third_party/blink/renderer/platform/runtime_enabled_features.json5 b/third_party/blink/renderer/platform/runtime_enabled_features.json5
+index 28d34020f7..45942f4e89 100644
+--- a/third_party/blink/renderer/platform/runtime_enabled_features.json5
++++ b/third_party/blink/renderer/platform/runtime_enabled_features.json5
+@@ -509,11 +509,6 @@
+       public: true,
+       status: "experimental",
+     },
+-    {
+-      // crbug.com/41485013
+-      name: "BreakIteratorDataGenerator",
+-      status: "stable",
+-    },
+     {
+       name: "BrowserVerifiedUserActivationKeyboard",
+       base_feature: "none",
+diff --git a/third_party/blink/renderer/platform/text/character_property_data_generator.cc b/third_party/blink/renderer/platform/text/character_property_data_generator.cc
+index 70101dbf76..27e6852647 100644
+--- a/third_party/blink/renderer/platform/text/character_property_data_generator.cc
++++ b/third_party/blink/renderer/platform/text/character_property_data_generator.cc
+@@ -5,19 +5,13 @@
+ #include "third_party/blink/renderer/platform/text/character_property_data.h"
+ 
+ #include <stdio.h>
+-#include <unicode/brkiter.h>
+-#include <unicode/locid.h>
+ #include <unicode/ucptrie.h>
+-#include <unicode/udata.h>
+-#include <unicode/ulocdata.h>
+ #include <unicode/umutablecptrie.h>
+ #include <unicode/uniset.h>
+ #include <unicode/unistr.h>
+ 
+ #include <cassert>
+ #include <cstring>
+-#include <filesystem>
+-#include <fstream>
+ #include <iterator>
+ #include <memory>
+ 
+@@ -31,36 +25,6 @@
+ namespace blink {
+ namespace {
+ 
+-#define CHECK_U_ERROR(error, name) \
+-  CHECK(U_SUCCESS(error)) << name << ": (" << error << ")" << u_errorName(error)
+-
+-//
+-// Load the ICU data file and set it to the ICU.
+-//
+-void InitializeIcu(const char* exec_path) {
+-  // ICU can't load the data file by itself because ICU tries to load the
+-  // versioned data file (e.g., "icudt73l.dat"), while the Chromium build system
+-  // creates the unversioned data file (e.g., "icudtl.dat").
+-  std::filesystem::path path{exec_path};
+-  path = path.parent_path() / "icudt" U_ICUDATA_TYPE_LETTER ".dat";
+-
+-  std::ifstream data_ifstream(path, std::ios_base::binary);
+-  CHECK(data_ifstream.is_open());
+-  static std::vector<uint8_t> icu_data;
+-  CHECK(icu_data.empty());
+-  std::copy(std::istreambuf_iterator<char>(data_ifstream),
+-            std::istreambuf_iterator<char>(), std::back_inserter(icu_data));
+-  UErrorCode error = U_ZERO_ERROR;
+-  udata_setCommonData(icu_data.data(), &error);
+-  CHECK_U_ERROR(error, "udata_setCommonData");
+-
+-  // Check ICU functions that need the data resources are working.
+-  // https://unicode-org.github.io/icu/userguide/icu/design.html#icu4c-initialization-and-termination
+-  UVersionInfo version;
+-  ulocdata_getCLDRVersion(version, &error);
+-  CHECK_U_ERROR(error, "ulocdata_getCLDRVersion");
+-}
+-
+ class CharacterPropertyValues {
+  public:
+   constexpr static UChar32 kMaxCodepoint = 0x10FFFF;
+@@ -255,201 +219,18 @@ static void GenerateCharacterPropertyData(FILE* fp) {
+   GenerateUTrieSerialized(fp, serialized_size, serialized);
+ }
+ 
+-//
+-// Generate a line break pair table in `break_iterator_data_inline_header.h`.
+-//
+-// See [UAX14](https://unicode.org/reports/tr14/).
+-//
+-class LineBreakData {
+- public:
+-  LineBreakData() = default;
+-
+-  static void Generate(FILE* fp) {
+-    LineBreakData data;
+-    data.FillFromIcu();
+-    data.FillAscii();
+-    data.Print(fp);
+-  }
+-
+- private:
+-  // Fill the pair table from the ICU BreakIterator.
+-  void FillFromIcu() {
+-    UErrorCode status = U_ZERO_ERROR;
+-    const icu::Locale locale("en");
+-    icu::BreakIterator* break_iterator =
+-        icu::BreakIterator::createLineInstance(locale, status);
+-    CHECK_U_ERROR(status, "createLineInstance");
+-
+-    for (UChar ch = kMinChar; ch <= kMaxChar; ++ch) {
+-      const icu::UnicodeString ch_str(ch);
+-      for (UChar ch_next = kMinChar; ch_next <= kMaxChar; ++ch_next) {
+-        const icu::UnicodeString ch_next_str(ch_next);
+-        const icu::UnicodeString str = ch_str + ch_next_str;
+-        break_iterator->setText(str);
+-        SetPairValue(ch, ch_next, break_iterator->isBoundary(1));
+-      }
+-    }
+-  }
+-
+-  // Line breaking table for printable ASCII characters. Line breaking
+-  // opportunities in this table are as below:
+-  // - before opening punctuations such as '(', '<', '[', '{' after certain
+-  //   characters (compatible with Firefox 3.6);
+-  // - after '-' and '?' (backward-compatible, and compatible with Internet
+-  //   Explorer).
+-  // Please refer to <https://bugs.webkit.org/show_bug.cgi?id=37698> for line
+-  // breaking matrixes of different browsers and the ICU standard.
+-  void FillAscii() {
+-#define ALL_CHAR '!', 0x7F
+-    SetPairValue(ALL_CHAR, ALL_CHAR, false);
+-    SetPairValue(ALL_CHAR, '(', '(', true);
+-    SetPairValue(ALL_CHAR, '<', '<', true);
+-    SetPairValue(ALL_CHAR, '[', '[', true);
+-    SetPairValue(ALL_CHAR, '{', '{', true);
+-    SetPairValue('-', '-', ALL_CHAR, true);
+-    SetPairValue('?', '?', ALL_CHAR, true);
+-    SetPairValue('-', '-', '$', '$', false);
+-    SetPairValue(ALL_CHAR, '!', '!', false);
+-    SetPairValue('?', '?', '"', '"', false);
+-    SetPairValue('?', '?', '\'', '\'', false);
+-    SetPairValue(ALL_CHAR, ')', ')', false);
+-    SetPairValue(ALL_CHAR, ',', ',', false);
+-    SetPairValue(ALL_CHAR, '.', '.', false);
+-    SetPairValue(ALL_CHAR, '/', '/', false);
+-    // Note: Between '-' and '[0-9]' is hard-coded in `ShouldBreakFast()`.
+-    SetPairValue('-', '-', '0', '9', false);
+-    SetPairValue(ALL_CHAR, ':', ':', false);
+-    SetPairValue(ALL_CHAR, ';', ';', false);
+-    SetPairValue(ALL_CHAR, '?', '?', false);
+-    SetPairValue(ALL_CHAR, ']', ']', false);
+-    SetPairValue(ALL_CHAR, '}', '}', false);
+-    SetPairValue('$', '$', ALL_CHAR, false);
+-    SetPairValue('\'', '\'', ALL_CHAR, false);
+-    SetPairValue('(', '(', ALL_CHAR, false);
+-    SetPairValue('/', '/', ALL_CHAR, false);
+-    SetPairValue('0', '9', ALL_CHAR, false);
+-    SetPairValue('<', '<', ALL_CHAR, false);
+-    SetPairValue('@', '@', ALL_CHAR, false);
+-    SetPairValue('A', 'Z', ALL_CHAR, false);
+-    SetPairValue('[', '[', ALL_CHAR, false);
+-    SetPairValue('^', '`', ALL_CHAR, false);
+-    SetPairValue('a', 'z', ALL_CHAR, false);
+-    SetPairValue('{', '{', ALL_CHAR, false);
+-    SetPairValue(0x7F, 0x7F, ALL_CHAR, false);
+-#undef ALL_CHAR
+-  }
+-
+-  // Print the C++ source code.
+-  void Print(FILE* fp) {
+-    // Print file headers.
+-    fprintf(fp,
+-            "#include <cstdint>\n"
+-            "#include "
+-            "\"third_party/blink/renderer/platform/wtf/text/wtf_uchar.h\"\n"
+-            "\nnamespace {\n\n");
+-
+-    fprintf(fp, "constexpr UChar kFastLineBreakMinChar = 0x%02X;\n", kMinChar);
+-    fprintf(fp, "constexpr UChar kFastLineBreakMaxChar = 0x%02X;\n", kMaxChar);
+-
+-    // Define macros.
+-    fprintf(fp,
+-            "\n#define B(a, b, c, d, e, f, g, h)"
+-            " ((a) | ((b) << 1) | ((c) << 2) | ((d) << 3) |"
+-            " ((e) << 4) | ((f) << 5) | ((g) << 6) | ((h) << 7))\n\n");
+-
+-    fprintf(fp, "const uint8_t kFastLineBreakTable[%d][%d] = {\n", kNumChars,
+-            kNumCharsRoundUp8 / 8);
+-
+-    // Print the column comment.
+-    fprintf(fp, "           /*");
+-    for (UChar ch = kMinChar; ch <= kMaxChar; ++ch) {
+-      if (ch != kMinChar && (ch - kMinChar) % 8 == 0) {
+-        fprintf(fp, "   ");
+-      }
+-      fprintf(fp, ch < 0x7F ? " %c" : "%02X", ch);
+-    }
+-    fprintf(fp, " */\n");
+-
+-    // Print the data array.
+-    for (int y = 0; y < kNumChars; ++y) {
+-      const UChar ch = y + kMinChar;
+-      fprintf(fp, "/* %02X %c */ {B(", ch, ch < 0x7F ? ch : ' ');
+-      const char* prefix = "";
+-      for (int x = 0; x < kNumCharsRoundUp8; ++x) {
+-        fprintf(fp, "%s%d", prefix, pair_[y][x]);
+-        prefix = (x % 8 == 7) ? "),B(" : ",";
+-      }
+-      fprintf(fp, ")},\n");
+-    }
+-    fprintf(fp,
+-            "};\n\n"
+-            "#undef B\n\n"
+-            "template <typename T>\n"
+-            "inline uint8_t GetFastLineBreak(T ch1, T ch2) {\n"
+-            "  const T i2 = ch2 - kFastLineBreakMinChar;\n"
+-            "  return kFastLineBreakTable[ch1 - kFastLineBreakMinChar]"
+-            "[i2 / 8] & (1 << (i2 %% 8));\n"
+-            "}\n\n"
+-            "}  // namespace\n");
+-  }
+-
+-  void SetPairValue(UChar ch1_min,
+-                    UChar ch1_max,
+-                    UChar ch2_min,
+-                    UChar ch2_max,
+-                    bool value) {
+-    for (UChar ch1 = ch1_min; ch1 <= ch1_max; ++ch1) {
+-      for (UChar ch2 = ch2_min; ch2 <= ch2_max; ++ch2) {
+-        SetPairValue(ch1, ch2, value);
+-      }
+-    }
+-  }
+-
+-  // Set the breakability between `ch1` and `ch2`.
+-  void SetPairValue(UChar ch1, UChar ch2, bool value) {
+-    CHECK_GE(ch1, kMinChar);
+-    CHECK_LE(ch1, kMaxChar);
+-    CHECK_GE(ch2, kMinChar);
+-    CHECK_LE(ch2, kMaxChar);
+-    pair_[ch1 - kMinChar][ch2 - kMinChar] = value;
+-  }
+-
+-  constexpr static UChar kMinChar = '!';
+-  constexpr static UChar kMaxChar = 0xFF;
+-  constexpr static int kNumChars = kMaxChar - kMinChar + 1;
+-  constexpr static int kNumCharsRoundUp8 = (kNumChars + 7) / 8 * 8;
+-  bool pair_[kNumChars][kNumCharsRoundUp8]{};
+-};
+-
+-void InvokeGenerator(int index,
+-                     int argc,
+-                     char** argv,
+-                     void (*generator)(FILE*)) {
+-  if (index >= argc) {
+-    return;
+-  }
+-  const char* path = argv[index];
+-  if (!*path) {
+-    return;
+-  }
+-
+-  if (strcmp(path, "-") == 0) {
+-    (*generator)(stdout);
+-    return;
+-  }
+-
+-  FILE* fp = fopen(path, "wb");
+-  (*generator)(fp);
+-  fclose(fp);
+-}
+-
+ }  // namespace
+ }  // namespace blink
+ 
+ int main(int argc, char** argv) {
+-  blink::InitializeIcu(argv[0]);
+-  blink::InvokeGenerator(1, argc, argv, blink::GenerateCharacterPropertyData);
+-  blink::InvokeGenerator(2, argc, argv, blink::LineBreakData::Generate);
++  // Write the serialized array to the source file.
++  if (argc <= 1) {
++    blink::GenerateCharacterPropertyData(stdout);
++  } else {
++    FILE* fp = fopen(argv[1], "wb");
++    blink::GenerateCharacterPropertyData(fp);
++    fclose(fp);
++  }
+ 
+   return 0;
+ }
+diff --git a/third_party/blink/renderer/platform/text/text_break_iterator.cc b/third_party/blink/renderer/platform/text/text_break_iterator.cc
+index 650eb760b2..14de47d9fe 100644
+--- a/third_party/blink/renderer/platform/text/text_break_iterator.cc
++++ b/third_party/blink/renderer/platform/text/text_break_iterator.cc
+@@ -26,8 +26,6 @@
+ #include <unicode/uchar.h>
+ #include <unicode/uvernum.h>
+ 
+-#include "third_party/blink/renderer/platform/runtime_enabled_features.h"
+-#include "third_party/blink/renderer/platform/text/break_iterator_data_inline_header.h"
+ #include "third_party/blink/renderer/platform/wtf/std_lib_extras.h"
+ #include "third_party/blink/renderer/platform/wtf/text/ascii_ctype.h"
+ #include "third_party/blink/renderer/platform/wtf/text/character_names.h"
+@@ -113,9 +111,6 @@ static const UChar kAsciiLineBreakTableLastChar = 127;
+ 
+ #define F 0xFF
+ 
+-// Check if the generated table match the `kAsciiLineBreakTable` table.
+-#define CHECK_ASCII_LINE_BRAEK_TABLE 0
+-
+ // Line breaking table for printable ASCII characters. Line breaking
+ // opportunities in this table are as below:
+ // - before opening punctuations such as '(', '<', '[', '{' after certain
+@@ -166,24 +161,6 @@ static const unsigned char kAsciiLineBreakTable[][(kAsciiLineBreakTableLastChar
+ };
+ // clang-format on
+ 
+-#if CHECK_ASCII_LINE_BRAEK_TABLE
+-void CheckAsciiLineBreakTable() {
+-  for (UChar ch2 = kAsciiLineBreakTableFirstChar;
+-       ch2 <= kAsciiLineBreakTableLastChar; ++ch2) {
+-    for (UChar ch1 = kAsciiLineBreakTableFirstChar;
+-         ch1 <= kAsciiLineBreakTableLastChar; ++ch1) {
+-      const UChar i2 = ch2 - kAsciiLineBreakTableFirstChar;
+-      const bool ascii =
+-          kAsciiLineBreakTable[ch1 - kAsciiLineBreakTableFirstChar][i2 / 8] &
+-          (1 << (i2 % 8));
+-      const bool fast = GetFastLineBreak(ch1, ch2);
+-      CHECK_EQ(ascii, fast)
+-          << String::Format("%02X/%02X (%c/%c)", ch1, ch2, ch1, ch2);
+-    }
+-  }
+-}
+-#endif  // CHECK_ASCII_LINE_BRAEK_TABLE
+-
+ #define BA_LB_COUNT U_LB_COUNT
+ // Line breaking table for CSS word-break: break-all. This table differs from
+ // asciiLineBreakTable in:
+@@ -298,13 +275,7 @@ static inline bool ShouldKeepAfterKeepAll(UChar last_ch,
+ }
+ 
+ inline bool NeedsLineBreakIterator(UChar ch) {
+-  if (UNLIKELY(!RuntimeEnabledFeatures::BreakIteratorDataGeneratorEnabled())) {
+-    return ch > kAsciiLineBreakTableLastChar && ch != kNoBreakSpaceCharacter;
+-  }
+-  static_assert(kFastLineBreakMaxChar >= kAsciiLineBreakTableLastChar);
+-  static_assert(kNoBreakSpaceCharacter <= kFastLineBreakMaxChar,
+-                "Include NBSP for the performance.");
+-  return ch > kFastLineBreakMaxChar;
++  return ch > kAsciiLineBreakTableLastChar && ch != kNoBreakSpaceCharacter;
+ }
+ 
+ template <typename CharacterType>
+@@ -349,61 +320,31 @@ struct LazyLineBreakIterator::Context {
+     last = current;
+   }
+ 
+-  bool ShouldBreakFast(bool disable_soft_hyphen) const {
+-#if CHECK_ASCII_LINE_BRAEK_TABLE
+-    DEFINE_STATIC_LOCAL(bool, is_check_done, (false));
+-    if (!is_check_done) {
+-      is_check_done = true;
+-      CheckAsciiLineBreakTable();
+-      LOG(INFO) << "CheckAsciiLineBreakTable() completed.";
+-    }
+-#endif  // CHECK_ASCII_LINE_BRAEK_TABLE
+-
++  bool ShouldBreakFast() const {
+     const UChar last_ch = last.ch;
+     const UChar ch = current.ch;
+-    static_assert(kFastLineBreakMinChar == kAsciiLineBreakTableFirstChar);
+-    if (UNLIKELY(last_ch < kFastLineBreakMinChar ||
+-                 ch < kFastLineBreakMinChar)) {
++    if (UNLIKELY(last_ch < kAsciiLineBreakTableFirstChar ||
++                 ch < kAsciiLineBreakTableFirstChar)) {
+       return false;
+     }
+ 
+     // Don't allow line breaking between '-' and a digit if the '-' may mean a
+     // minus sign in the context, while allow breaking in 'ABCD-1234' and
+     // '1234-5678' which may be in long URLs.
+-    static_assert('-' >= kFastLineBreakMinChar);
++    static_assert('-' >= kAsciiLineBreakTableFirstChar);
+     if (last_ch == '-' && IsASCIIDigit(ch)) {
+       return IsASCIIAlphanumeric(last_last_ch);
+     }
+ 
+-    if (UNLIKELY(
+-            !RuntimeEnabledFeatures::BreakIteratorDataGeneratorEnabled())) {
+-      // If both `last_ch` and `ch` are ASCII characters, use a lookup table for
+-      // enhanced speed and for compatibility with other browsers (see comments
+-      // for asciiLineBreakTable for details).
+-      if (last_ch <= kAsciiLineBreakTableLastChar &&
+-          ch <= kAsciiLineBreakTableLastChar) {
+-        const unsigned char* table_row =
+-            kAsciiLineBreakTable[last_ch - kAsciiLineBreakTableFirstChar];
+-        int ch_index = ch - kAsciiLineBreakTableFirstChar;
+-        return table_row[ch_index / 8] & (1 << (ch_index % 8));
+-      }
+-
+-      // Otherwise defer to the Unicode algorithm by returning false.
+-      return false;
+-    }
+-
+-    // If both characters are in the fast line break table, use it for enhanced
+-    // speed. For ASCII characters, it is also for compatibility. The table is
+-    // generated at the build time, see the `LineBreakData` class.
+-    if (last_ch <= kFastLineBreakMaxChar && ch <= kFastLineBreakMaxChar) {
+-      if (!GetFastLineBreak(last_ch, ch)) {
+-        return false;
+-      }
+-      static_assert(kSoftHyphenCharacter <= kFastLineBreakMaxChar);
+-      if (UNLIKELY(disable_soft_hyphen && last_ch == kSoftHyphenCharacter)) {
+-        return false;
+-      }
+-      return true;
++    // If both `last_ch` and `ch` are ASCII characters, use a lookup table for
++    // enhanced speed and for compatibility with other browsers (see comments
++    // for asciiLineBreakTable for details).
++    if (last_ch <= kAsciiLineBreakTableLastChar &&
++        ch <= kAsciiLineBreakTableLastChar) {
++      const unsigned char* table_row =
++          kAsciiLineBreakTable[last_ch - kAsciiLineBreakTableFirstChar];
++      int ch_index = ch - kAsciiLineBreakTableFirstChar;
++      return table_row[ch_index / 8] & (1 << (ch_index % 8));
+     }
+ 
+     // Otherwise defer to the Unicode algorithm by returning false.
+@@ -452,7 +393,7 @@ inline int LazyLineBreakIterator::NextBreakablePosition(
+         break;
+     }
+ 
+-    if (context.ShouldBreakFast(disable_soft_hyphen_)) {
++    if (context.ShouldBreakFast()) {
+       return i;
+     }
+