Adding upstream version 124.0.1.upstream/124.0.1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 639 insertions, 0 deletions

diff --git a/dom/base/nsLineBreaker.cpp b/dom/base/nsLineBreaker.cpp
new file mode 100644
index 0000000000..ffc224fc27
--- /dev/null
+++ b/dom/base/nsLineBreaker.cpp
@@ -0,0 +1,639 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsLineBreaker.h"
+#include "nsContentUtils.h"
+#include "gfxTextRun.h"  // for the gfxTextRun::CompressedGlyph::FLAG_BREAK_TYPE_* values
+#include "nsHyphenationManager.h"
+#include "nsHyphenator.h"
+#include "mozilla/AutoRestore.h"
+#include "mozilla/ClearOnShutdown.h"
+#include "mozilla/gfx/2D.h"
+#include "mozilla/intl/LineBreaker.h"  // for LineBreaker::ComputeBreakPositions
+#include "mozilla/intl/Locale.h"
+#include "mozilla/intl/UnicodeProperties.h"
+#include "mozilla/StaticPrefs_intl.h"
+
+using mozilla::AutoRestore;
+using mozilla::intl::LineBreaker;
+using mozilla::intl::LineBreakRule;
+using mozilla::intl::Locale;
+using mozilla::intl::LocaleParser;
+using mozilla::intl::UnicodeProperties;
+using mozilla::intl::WordBreakRule;
+
+// There is no break opportunity between any pair of characters that has line
+// break class of either AL (Alphabetic), IS (Infix Numeric Separator), NU
+// (Numeric), or QU (Quotation). See
+// https://www.unicode.org/Public/UCD/latest/ucd/LineBreak.txt for Unicode code
+// point and line break class mapping.
+static constexpr uint8_t kNonBreakableASCII[] = {
+    // clang-format off
+// 0x20-0x2f
+0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 0, 1, 0,
+// 0x30-0x3f
+1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
+// 0x40-0x4f
+1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+// 0x50-0x5f
+1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1,
+// 0x60-0x6f
+1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+// 0x70-0x7f
+1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0,
+    // clang-format on
+};
+
+template <typename T>
+static constexpr bool IsNonBreakableChar(T aChar, bool aLegacyBehavior) {
+  if (aLegacyBehavior) {
+    // If not using ICU4X, line break rules aren't compatible with UAX#14. Use
+    // old way.
+    return (0x0030 <= aChar && aChar <= 0x0039) ||
+           (0x0041 <= aChar && aChar <= 0x005A) ||
+           (0x0061 <= aChar && aChar <= 0x007A) || (0x000a == aChar);
+  }
+  if (aChar < 0x20 || aChar > 0x7f) {
+    return false;
+  }
+  return !!kNonBreakableASCII[aChar - 0x20];
+}
+
+nsLineBreaker::nsLineBreaker()
+    : mCurrentWordLanguage(nullptr),
+      mCurrentWordContainsMixedLang(false),
+      mScriptIsChineseOrJapanese(false),
+      mAfterBreakableSpace(false),
+      mBreakHere(false),
+      mWordBreak(WordBreakRule::Normal),
+      mLineBreak(LineBreakRule::Auto),
+      mWordContinuation(false),
+      mLegacyBehavior(!mozilla::StaticPrefs::intl_icu4x_segmenter_enabled()) {}
+
+nsLineBreaker::~nsLineBreaker() {
+  NS_ASSERTION(mCurrentWord.Length() == 0,
+               "Should have Reset() before destruction!");
+}
+
+static void SetupCapitalization(const char16_t* aWord, uint32_t aLength,
+                                bool* aCapitalization) {
+  // Capitalize the first alphanumeric character after a space or punctuation.
+  using mozilla::intl::GeneralCategory;
+  bool capitalizeNextChar = true;
+  for (uint32_t i = 0; i < aLength; ++i) {
+    uint32_t ch = aWord[i];
+    if (i + 1 < aLength && NS_IS_SURROGATE_PAIR(ch, aWord[i + 1])) {
+      ch = SURROGATE_TO_UCS4(ch, aWord[i + 1]);
+    }
+    auto category = UnicodeProperties::CharType(ch);
+    switch (category) {
+      case GeneralCategory::Uppercase_Letter:
+      case GeneralCategory::Lowercase_Letter:
+      case GeneralCategory::Titlecase_Letter:
+      case GeneralCategory::Modifier_Letter:
+      case GeneralCategory::Other_Letter:
+      case GeneralCategory::Decimal_Number:
+      case GeneralCategory::Letter_Number:
+      case GeneralCategory::Other_Number:
+        if (capitalizeNextChar) {
+          aCapitalization[i] = true;
+          capitalizeNextChar = false;
+        }
+        break;
+      case GeneralCategory::Space_Separator:
+      case GeneralCategory::Line_Separator:
+      case GeneralCategory::Paragraph_Separator:
+      case GeneralCategory::Dash_Punctuation:
+      case GeneralCategory::Initial_Punctuation:
+        /* These punctuation categories are excluded, for examples like
+         *   "what colo[u]r" -> "What Colo[u]r?" (rather than "What Colo[U]R?")
+         * and
+         *   "snake_case" -> "Snake_case" (to match word selection behavior)
+        case GeneralCategory::Open_Punctuation:
+        case GeneralCategory::Close_Punctuation:
+        case GeneralCategory::Connector_Punctuation:
+         */
+        capitalizeNextChar = true;
+        break;
+      case GeneralCategory::Final_Punctuation:
+        /* Special-case: exclude Unicode single-close-quote/apostrophe,
+           for examples like "Lowe’s" etc. */
+        if (ch != 0x2019) {
+          capitalizeNextChar = true;
+        }
+        break;
+      case GeneralCategory::Other_Punctuation:
+        /* Special-case: exclude ASCII apostrophe, for "Lowe's" etc.,
+           and MIDDLE DOT, for Catalan "l·l". */
+        if (ch != '\'' && ch != 0x00B7) {
+          capitalizeNextChar = true;
+        }
+        break;
+      default:
+        break;
+    }
+    if (!IS_IN_BMP(ch)) {
+      ++i;
+    }
+  }
+}
+
+nsresult nsLineBreaker::FlushCurrentWord() {
+  uint32_t length = mCurrentWord.Length();
+  AutoTArray<uint8_t, 4000> breakState;
+  if (!breakState.AppendElements(length, mozilla::fallible)) {
+    return NS_ERROR_OUT_OF_MEMORY;
+  }
+
+  if (mLineBreak == LineBreakRule::Anywhere) {
+    memset(breakState.Elements(),
+           gfxTextRun::CompressedGlyph::FLAG_BREAK_TYPE_NORMAL,
+           length * sizeof(uint8_t));
+  } else if (!mCurrentWordMightBeBreakable &&
+             mWordBreak != WordBreakRule::BreakAll) {
+    // word-break: normal or keep-all has no break opportunity if the word
+    // is non-breakable. (See the comment of kNonBreakableASCII).
+    memset(breakState.Elements(),
+           gfxTextRun::CompressedGlyph::FLAG_BREAK_TYPE_NONE,
+           length * sizeof(uint8_t));
+  } else {
+    LineBreaker::ComputeBreakPositions(
+        mCurrentWord.Elements(), length, mWordBreak, mLineBreak,
+        mScriptIsChineseOrJapanese, breakState.Elements());
+  }
+
+  bool autoHyphenate = mCurrentWordLanguage && !mCurrentWordContainsMixedLang;
+  uint32_t i;
+  for (i = 0; autoHyphenate && i < mTextItems.Length(); ++i) {
+    TextItem* ti = &mTextItems[i];
+    if (!(ti->mFlags & BREAK_USE_AUTO_HYPHENATION)) {
+      autoHyphenate = false;
+    }
+  }
+  if (autoHyphenate) {
+    RefPtr<nsHyphenator> hyphenator =
+        nsHyphenationManager::Instance()->GetHyphenator(mCurrentWordLanguage);
+    if (hyphenator) {
+      FindHyphenationPoints(hyphenator, mCurrentWord.Elements(),
+                            mCurrentWord.Elements() + length,
+                            breakState.Elements());
+    }
+  }
+
+  nsTArray<bool> capitalizationState;
+  uint32_t offset = 0;
+  for (i = 0; i < mTextItems.Length(); ++i) {
+    TextItem* ti = &mTextItems[i];
+    NS_ASSERTION(ti->mLength > 0, "Zero length word contribution?");
+
+    if ((ti->mFlags & BREAK_SUPPRESS_INITIAL) && ti->mSinkOffset == 0) {
+      breakState[offset] = gfxTextRun::CompressedGlyph::FLAG_BREAK_TYPE_NONE;
+    }
+    if (ti->mFlags & BREAK_SUPPRESS_INSIDE) {
+      uint32_t exclude = ti->mSinkOffset == 0 ? 1 : 0;
+      memset(breakState.Elements() + offset + exclude,
+             gfxTextRun::CompressedGlyph::FLAG_BREAK_TYPE_NONE,
+             (ti->mLength - exclude) * sizeof(uint8_t));
+    }
+
+    // Don't set the break state for the first character of the word, because
+    // it was already set correctly earlier and we don't know what the true
+    // value should be.
+    uint32_t skipSet = i == 0 ? 1 : 0;
+    if (ti->mSink) {
+      ti->mSink->SetBreaks(ti->mSinkOffset + skipSet, ti->mLength - skipSet,
+                           breakState.Elements() + offset + skipSet);
+
+      if (!mWordContinuation && (ti->mFlags & BREAK_NEED_CAPITALIZATION)) {
+        if (capitalizationState.Length() == 0) {
+          if (!capitalizationState.AppendElements(length, mozilla::fallible)) {
+            return NS_ERROR_OUT_OF_MEMORY;
+          }
+          memset(capitalizationState.Elements(), false, length * sizeof(bool));
+          SetupCapitalization(mCurrentWord.Elements(), length,
+                              capitalizationState.Elements());
+        }
+        ti->mSink->SetCapitalization(ti->mSinkOffset, ti->mLength,
+                                     capitalizationState.Elements() + offset);
+      }
+    }
+
+    offset += ti->mLength;
+  }
+
+  mCurrentWord.Clear();
+  mTextItems.Clear();
+  mCurrentWordMightBeBreakable = false;
+  mCurrentWordContainsMixedLang = false;
+  mCurrentWordLanguage = nullptr;
+  mWordContinuation = false;
+  return NS_OK;
+}
+
+// If the aFlags parameter to AppendText has all these bits set,
+// then we don't need to worry about finding break opportunities
+// in the appended text.
+#define NO_BREAKS_NEEDED_FLAGS                      \
+  (BREAK_SUPPRESS_INITIAL | BREAK_SUPPRESS_INSIDE | \
+   BREAK_SKIP_SETTING_NO_BREAKS)
+
+nsresult nsLineBreaker::AppendText(nsAtom* aHyphenationLanguage,
+                                   const char16_t* aText, uint32_t aLength,
+                                   uint32_t aFlags, nsILineBreakSink* aSink) {
+  NS_ASSERTION(aLength > 0, "Appending empty text...");
+
+  uint32_t offset = 0;
+
+  // Continue the current word
+  if (mCurrentWord.Length() > 0) {
+    NS_ASSERTION(!mAfterBreakableSpace && !mBreakHere,
+                 "These should not be set");
+
+    while (offset < aLength && !IsSegmentSpace(aText[offset])) {
+      mCurrentWord.AppendElement(aText[offset]);
+      if (!mCurrentWordMightBeBreakable &&
+          !IsNonBreakableChar<char16_t>(aText[offset], mLegacyBehavior)) {
+        mCurrentWordMightBeBreakable = true;
+      }
+      UpdateCurrentWordLanguage(aHyphenationLanguage);
+      ++offset;
+    }
+
+    if (offset > 0) {
+      mTextItems.AppendElement(TextItem(aSink, 0, offset, aFlags));
+    }
+
+    if (offset == aLength) {
+      return NS_OK;
+    }
+
+    // We encountered whitespace, so we're done with this word
+    nsresult rv = FlushCurrentWord();
+    if (NS_FAILED(rv)) {
+      return rv;
+    }
+  }
+
+  AutoTArray<uint8_t, 4000> breakState;
+  if (aSink) {
+    if (!breakState.AppendElements(aLength, mozilla::fallible)) {
+      return NS_ERROR_OUT_OF_MEMORY;
+    }
+  }
+
+  bool noCapitalizationNeeded = true;
+  nsTArray<bool> capitalizationState;
+  if (aSink && (aFlags & BREAK_NEED_CAPITALIZATION)) {
+    if (!capitalizationState.AppendElements(aLength, mozilla::fallible)) {
+      return NS_ERROR_OUT_OF_MEMORY;
+    }
+    memset(capitalizationState.Elements(), false, aLength * sizeof(bool));
+    noCapitalizationNeeded = false;
+  }
+
+  uint32_t start = offset;
+  bool noBreaksNeeded =
+      !aSink || ((aFlags & NO_BREAKS_NEEDED_FLAGS) == NO_BREAKS_NEEDED_FLAGS &&
+                 !mBreakHere && !mAfterBreakableSpace);
+  if (noBreaksNeeded && noCapitalizationNeeded) {
+    // Skip to the space before the last word, since either the break data
+    // here is not needed, or no breaks are set in the sink and there cannot
+    // be any breaks in this chunk; and we don't need to do word-initial
+    // capitalization. All we need is the context for the next chunk (if any).
+    offset = aLength;
+    while (offset > start) {
+      --offset;
+      if (IsSegmentSpace(aText[offset])) {
+        break;
+      }
+    }
+  }
+  uint32_t wordStart = offset;
+  bool wordMightBeBreakable = false;
+
+  RefPtr<nsHyphenator> hyphenator;
+  if ((aFlags & BREAK_USE_AUTO_HYPHENATION) &&
+      !(aFlags & BREAK_SUPPRESS_INSIDE) && aHyphenationLanguage) {
+    hyphenator =
+        nsHyphenationManager::Instance()->GetHyphenator(aHyphenationLanguage);
+  }
+
+  for (;;) {
+    char16_t ch = aText[offset];
+    bool isSpace = IsSegmentSpace(ch);
+    bool isBreakableSpace = isSpace && !(aFlags & BREAK_SUPPRESS_INSIDE);
+
+    if (aSink && !noBreaksNeeded) {
+      breakState[offset] =
+          mBreakHere || (mAfterBreakableSpace && !isBreakableSpace) ||
+                  mWordBreak == WordBreakRule::BreakAll ||
+                  mLineBreak == LineBreakRule::Anywhere
+              ? gfxTextRun::CompressedGlyph::FLAG_BREAK_TYPE_NORMAL
+              : gfxTextRun::CompressedGlyph::FLAG_BREAK_TYPE_NONE;
+    }
+    mBreakHere = false;
+    mAfterBreakableSpace = isBreakableSpace;
+
+    if (isSpace || ch == '\n') {
+      if (offset > wordStart && aSink) {
+        if (!(aFlags & BREAK_SUPPRESS_INSIDE)) {
+          if (mLineBreak == LineBreakRule::Anywhere) {
+            memset(breakState.Elements() + wordStart,
+                   gfxTextRun::CompressedGlyph::FLAG_BREAK_TYPE_NORMAL,
+                   offset - wordStart);
+          } else if (wordMightBeBreakable) {
+            // Save current start-of-word state because ComputeBreakPositions()
+            // will set it to false.
+            AutoRestore<uint8_t> saveWordStartBreakState(breakState[wordStart]);
+            LineBreaker::ComputeBreakPositions(
+                aText + wordStart, offset - wordStart, mWordBreak, mLineBreak,
+                mScriptIsChineseOrJapanese, breakState.Elements() + wordStart);
+          }
+          if (hyphenator) {
+            FindHyphenationPoints(hyphenator, aText + wordStart, aText + offset,
+                                  breakState.Elements() + wordStart);
+          }
+        }
+        if (!mWordContinuation && !noCapitalizationNeeded) {
+          SetupCapitalization(aText + wordStart, offset - wordStart,
+                              capitalizationState.Elements() + wordStart);
+        }
+      }
+      wordMightBeBreakable = false;
+      mWordContinuation = false;
+      ++offset;
+      if (offset >= aLength) {
+        break;
+      }
+      wordStart = offset;
+      continue;
+    }
+
+    if (!wordMightBeBreakable &&
+        !IsNonBreakableChar<char16_t>(ch, mLegacyBehavior)) {
+      wordMightBeBreakable = true;
+    }
+    ++offset;
+    if (offset >= aLength) {
+      // Save this word
+      mCurrentWordMightBeBreakable = wordMightBeBreakable;
+      uint32_t len = offset - wordStart;
+      char16_t* elems = mCurrentWord.AppendElements(len, mozilla::fallible);
+      if (!elems) {
+        return NS_ERROR_OUT_OF_MEMORY;
+      }
+      memcpy(elems, aText + wordStart, sizeof(char16_t) * len);
+      mTextItems.AppendElement(TextItem(aSink, wordStart, len, aFlags));
+      // Ensure that the break-before for this word is written out
+      offset = wordStart + 1;
+      UpdateCurrentWordLanguage(aHyphenationLanguage);
+      break;
+    }
+  }
+
+  if (aSink) {
+    if (!noBreaksNeeded) {
+      aSink->SetBreaks(start, offset - start, breakState.Elements() + start);
+    }
+    if (!noCapitalizationNeeded) {
+      aSink->SetCapitalization(start, offset - start,
+                               capitalizationState.Elements() + start);
+    }
+  }
+  return NS_OK;
+}
+
+void nsLineBreaker::FindHyphenationPoints(nsHyphenator* aHyphenator,
+                                          const char16_t* aTextStart,
+                                          const char16_t* aTextLimit,
+                                          uint8_t* aBreakState) {
+  nsDependentSubstring string(aTextStart, aTextLimit);
+  AutoTArray<bool, 200> hyphens;
+  if (NS_SUCCEEDED(aHyphenator->Hyphenate(string, hyphens))) {
+    for (uint32_t i = 0; i + 1 < string.Length(); ++i) {
+      if (hyphens[i]) {
+        aBreakState[i + 1] =
+            gfxTextRun::CompressedGlyph::FLAG_BREAK_TYPE_HYPHEN;
+      }
+    }
+  }
+}
+
+nsresult nsLineBreaker::AppendText(nsAtom* aHyphenationLanguage,
+                                   const uint8_t* aText, uint32_t aLength,
+                                   uint32_t aFlags, nsILineBreakSink* aSink) {
+  NS_ASSERTION(aLength > 0, "Appending empty text...");
+
+  if (aFlags & (BREAK_NEED_CAPITALIZATION | BREAK_USE_AUTO_HYPHENATION)) {
+    // Defer to the Unicode path if capitalization or hyphenation is required
+    nsAutoString str;
+    const char* cp = reinterpret_cast<const char*>(aText);
+    CopyASCIItoUTF16(nsDependentCSubstring(cp, cp + aLength), str);
+    return AppendText(aHyphenationLanguage, str.get(), aLength, aFlags, aSink);
+  }
+
+  uint32_t offset = 0;
+
+  // Continue the current word
+  if (mCurrentWord.Length() > 0) {
+    NS_ASSERTION(!mAfterBreakableSpace && !mBreakHere,
+                 "These should not be set");
+
+    while (offset < aLength && !IsSegmentSpace(aText[offset])) {
+      mCurrentWord.AppendElement(aText[offset]);
+      if (!mCurrentWordMightBeBreakable &&
+          !IsNonBreakableChar<uint8_t>(aText[offset], mLegacyBehavior)) {
+        mCurrentWordMightBeBreakable = true;
+      }
+      ++offset;
+    }
+
+    if (offset > 0) {
+      mTextItems.AppendElement(TextItem(aSink, 0, offset, aFlags));
+    }
+
+    if (offset == aLength) {
+      // We did not encounter whitespace so the word hasn't finished yet.
+      return NS_OK;
+    }
+
+    // We encountered whitespace, so we're done with this word
+    nsresult rv = FlushCurrentWord();
+    if (NS_FAILED(rv)) {
+      return rv;
+    }
+  }
+
+  AutoTArray<uint8_t, 4000> breakState;
+  if (aSink) {
+    if (!breakState.AppendElements(aLength, mozilla::fallible)) {
+      return NS_ERROR_OUT_OF_MEMORY;
+    }
+  }
+
+  uint32_t start = offset;
+  bool noBreaksNeeded =
+      !aSink || ((aFlags & NO_BREAKS_NEEDED_FLAGS) == NO_BREAKS_NEEDED_FLAGS &&
+                 !mBreakHere && !mAfterBreakableSpace);
+  if (noBreaksNeeded) {
+    // Skip to the space before the last word, since either the break data
+    // here is not needed, or no breaks are set in the sink and there cannot
+    // be any breaks in this chunk; all we need is the context for the next
+    // chunk (if any)
+    offset = aLength;
+    while (offset > start) {
+      --offset;
+      if (IsSegmentSpace(aText[offset])) {
+        break;
+      }
+    }
+  }
+  uint32_t wordStart = offset;
+  bool wordMightBeBreakable = false;
+
+  for (;;) {
+    uint8_t ch = aText[offset];
+    bool isSpace = IsSegmentSpace(ch);
+    bool isBreakableSpace = isSpace && !(aFlags & BREAK_SUPPRESS_INSIDE);
+
+    if (aSink) {
+      // Consider word-break style.  Since the break position of CJK scripts
+      // will be set by nsILineBreaker, we don't consider CJK at this point.
+      breakState[offset] =
+          mBreakHere || (mAfterBreakableSpace && !isBreakableSpace) ||
+                  mWordBreak == WordBreakRule::BreakAll ||
+                  mLineBreak == LineBreakRule::Anywhere
+              ? gfxTextRun::CompressedGlyph::FLAG_BREAK_TYPE_NORMAL
+              : gfxTextRun::CompressedGlyph::FLAG_BREAK_TYPE_NONE;
+    }
+    mBreakHere = false;
+    mAfterBreakableSpace = isBreakableSpace;
+
+    if (isSpace) {
+      if (offset > wordStart && aSink && !(aFlags & BREAK_SUPPRESS_INSIDE)) {
+        if (mLineBreak == LineBreakRule::Anywhere) {
+          memset(breakState.Elements() + wordStart,
+                 gfxTextRun::CompressedGlyph::FLAG_BREAK_TYPE_NORMAL,
+                 offset - wordStart);
+        } else if (wordMightBeBreakable) {
+          // Save current start-of-word state because ComputeBreakPositions()
+          // will set it to false.
+          AutoRestore<uint8_t> saveWordStartBreakState(breakState[wordStart]);
+          LineBreaker::ComputeBreakPositions(
+              aText + wordStart, offset - wordStart, mWordBreak, mLineBreak,
+              mScriptIsChineseOrJapanese, breakState.Elements() + wordStart);
+        }
+      }
+
+      wordMightBeBreakable = false;
+      mWordContinuation = false;
+      ++offset;
+      if (offset >= aLength) {
+        break;
+      }
+      wordStart = offset;
+      continue;
+    }
+
+    if (!wordMightBeBreakable &&
+        !IsNonBreakableChar<uint8_t>(ch, mLegacyBehavior)) {
+      wordMightBeBreakable = true;
+    }
+    ++offset;
+    if (offset >= aLength) {
+      // Save this word
+      mCurrentWordMightBeBreakable = wordMightBeBreakable;
+      uint32_t len = offset - wordStart;
+      char16_t* elems = mCurrentWord.AppendElements(len, mozilla::fallible);
+      if (!elems) {
+        return NS_ERROR_OUT_OF_MEMORY;
+      }
+      uint32_t i;
+      for (i = wordStart; i < offset; ++i) {
+        elems[i - wordStart] = aText[i];
+      }
+      mTextItems.AppendElement(TextItem(aSink, wordStart, len, aFlags));
+      // Ensure that the break-before for this word is written out
+      offset = wordStart + 1;
+      break;
+    }
+  }
+
+  if (!noBreaksNeeded) {
+    aSink->SetBreaks(start, offset - start, breakState.Elements() + start);
+  }
+  return NS_OK;
+}
+
+void nsLineBreaker::UpdateCurrentWordLanguage(nsAtom* aHyphenationLanguage) {
+  if (mCurrentWordLanguage && mCurrentWordLanguage != aHyphenationLanguage) {
+    mCurrentWordContainsMixedLang = true;
+    mScriptIsChineseOrJapanese = false;
+    return;
+  }
+
+  if (aHyphenationLanguage && !mCurrentWordLanguage) {
+    static mozilla::StaticRefPtr<nsAtom> sLastHyphenationLanguage;
+    static bool sLastScriptIsChineseOrJapanese = false;
+    static bool sInit = false;
+
+    if (!sInit) {
+      mozilla::ClearOnShutdown(&sLastHyphenationLanguage);
+      sInit = true;
+    }
+
+    if (sLastHyphenationLanguage == aHyphenationLanguage) {
+      MOZ_ASSERT(nsAtomString(sLastHyphenationLanguage)
+                     .Equals(nsAtomString(aHyphenationLanguage)));
+      mScriptIsChineseOrJapanese = sLastScriptIsChineseOrJapanese;
+    } else {
+      Locale loc;
+      auto result =
+          LocaleParser::TryParse(nsAtomCString(aHyphenationLanguage), loc);
+
+      if (result.isErr()) {
+        return;
+      }
+      if (loc.Script().Missing() && loc.AddLikelySubtags().isErr()) {
+        return;
+      }
+      mScriptIsChineseOrJapanese =
+          loc.Script().EqualTo("Hans") || loc.Script().EqualTo("Hant") ||
+          loc.Script().EqualTo("Jpan") || loc.Script().EqualTo("Hrkt");
+
+      sLastHyphenationLanguage = aHyphenationLanguage;
+      sLastScriptIsChineseOrJapanese = mScriptIsChineseOrJapanese;
+    }
+  }
+  mCurrentWordLanguage = aHyphenationLanguage;
+}
+
+nsresult nsLineBreaker::AppendInvisibleWhitespace(uint32_t aFlags) {
+  nsresult rv = FlushCurrentWord();
+  if (NS_FAILED(rv)) {
+    return rv;
+  }
+
+  bool isBreakableSpace = !(aFlags & BREAK_SUPPRESS_INSIDE);
+  if (mAfterBreakableSpace && !isBreakableSpace) {
+    mBreakHere = true;
+  }
+  mAfterBreakableSpace = isBreakableSpace;
+  mWordContinuation = false;
+  return NS_OK;
+}
+
+nsresult nsLineBreaker::Reset(bool* aTrailingBreak) {
+  nsresult rv = FlushCurrentWord();
+  if (NS_FAILED(rv)) {
+    return rv;
+  }
+
+  *aTrailingBreak = mBreakHere || mAfterBreakableSpace;
+  mBreakHere = false;
+  mAfterBreakableSpace = false;
+  return NS_OK;
+}