Adding upstream version 124.0.1.upstream/124.0.1

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

1 files changed, 1305 insertions, 0 deletions

diff --git a/editor/libeditor/CSSEditUtils.cpp b/editor/libeditor/CSSEditUtils.cpp
new file mode 100644
index 0000000000..15aec6a4ab
--- /dev/null
+++ b/editor/libeditor/CSSEditUtils.cpp
@@ -0,0 +1,1305 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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 "CSSEditUtils.h"
+
+#include "ChangeStyleTransaction.h"
+#include "HTMLEditHelpers.h"
+#include "HTMLEditor.h"
+#include "HTMLEditUtils.h"
+
+#include "mozilla/Assertions.h"
+#include "mozilla/DeclarationBlock.h"
+#include "mozilla/mozalloc.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/ServoCSSParser.h"
+#include "mozilla/StaticPrefs_editor.h"
+#include "mozilla/dom/Document.h"
+#include "mozilla/dom/Element.h"
+#include "nsAString.h"
+#include "nsCOMPtr.h"
+#include "nsCSSProps.h"
+#include "nsColor.h"
+#include "nsComputedDOMStyle.h"
+#include "nsDebug.h"
+#include "nsDependentSubstring.h"
+#include "nsError.h"
+#include "nsGkAtoms.h"
+#include "nsAtom.h"
+#include "nsIContent.h"
+#include "nsICSSDeclaration.h"
+#include "nsINode.h"
+#include "nsISupportsImpl.h"
+#include "nsISupportsUtils.h"
+#include "nsLiteralString.h"
+#include "nsPIDOMWindow.h"
+#include "nsReadableUtils.h"
+#include "nsString.h"
+#include "nsStringFwd.h"
+#include "nsStringIterator.h"
+#include "nsStyledElement.h"
+#include "nsUnicharUtils.h"
+
+namespace mozilla {
+
+using namespace dom;
+
+static void ProcessBValue(const nsAString* aInputString,
+                          nsAString& aOutputString,
+                          const char* aDefaultValueString,
+                          const char* aPrependString,
+                          const char* aAppendString) {
+  if (aInputString && aInputString->EqualsLiteral("-moz-editor-invert-value")) {
+    aOutputString.AssignLiteral("normal");
+  } else {
+    aOutputString.AssignLiteral("bold");
+  }
+}
+
+static void ProcessDefaultValue(const nsAString* aInputString,
+                                nsAString& aOutputString,
+                                const char* aDefaultValueString,
+                                const char* aPrependString,
+                                const char* aAppendString) {
+  CopyASCIItoUTF16(MakeStringSpan(aDefaultValueString), aOutputString);
+}
+
+static void ProcessSameValue(const nsAString* aInputString,
+                             nsAString& aOutputString,
+                             const char* aDefaultValueString,
+                             const char* aPrependString,
+                             const char* aAppendString) {
+  if (aInputString) {
+    aOutputString.Assign(*aInputString);
+  } else
+    aOutputString.Truncate();
+}
+
+static void ProcessExtendedValue(const nsAString* aInputString,
+                                 nsAString& aOutputString,
+                                 const char* aDefaultValueString,
+                                 const char* aPrependString,
+                                 const char* aAppendString) {
+  aOutputString.Truncate();
+  if (aInputString) {
+    if (aPrependString) {
+      AppendASCIItoUTF16(MakeStringSpan(aPrependString), aOutputString);
+    }
+    aOutputString.Append(*aInputString);
+    if (aAppendString) {
+      AppendASCIItoUTF16(MakeStringSpan(aAppendString), aOutputString);
+    }
+  }
+}
+
+static void ProcessLengthValue(const nsAString* aInputString,
+                               nsAString& aOutputString,
+                               const char* aDefaultValueString,
+                               const char* aPrependString,
+                               const char* aAppendString) {
+  aOutputString.Truncate();
+  if (aInputString) {
+    aOutputString.Append(*aInputString);
+    if (-1 == aOutputString.FindChar(char16_t('%'))) {
+      aOutputString.AppendLiteral("px");
+    }
+  }
+}
+
+static void ProcessListStyleTypeValue(const nsAString* aInputString,
+                                      nsAString& aOutputString,
+                                      const char* aDefaultValueString,
+                                      const char* aPrependString,
+                                      const char* aAppendString) {
+  aOutputString.Truncate();
+  if (aInputString) {
+    if (aInputString->EqualsLiteral("1")) {
+      aOutputString.AppendLiteral("decimal");
+    } else if (aInputString->EqualsLiteral("a")) {
+      aOutputString.AppendLiteral("lower-alpha");
+    } else if (aInputString->EqualsLiteral("A")) {
+      aOutputString.AppendLiteral("upper-alpha");
+    } else if (aInputString->EqualsLiteral("i")) {
+      aOutputString.AppendLiteral("lower-roman");
+    } else if (aInputString->EqualsLiteral("I")) {
+      aOutputString.AppendLiteral("upper-roman");
+    } else if (aInputString->EqualsLiteral("square") ||
+               aInputString->EqualsLiteral("circle") ||
+               aInputString->EqualsLiteral("disc")) {
+      aOutputString.Append(*aInputString);
+    }
+  }
+}
+
+static void ProcessMarginLeftValue(const nsAString* aInputString,
+                                   nsAString& aOutputString,
+                                   const char* aDefaultValueString,
+                                   const char* aPrependString,
+                                   const char* aAppendString) {
+  aOutputString.Truncate();
+  if (aInputString) {
+    if (aInputString->EqualsLiteral("center") ||
+        aInputString->EqualsLiteral("-moz-center")) {
+      aOutputString.AppendLiteral("auto");
+    } else if (aInputString->EqualsLiteral("right") ||
+               aInputString->EqualsLiteral("-moz-right")) {
+      aOutputString.AppendLiteral("auto");
+    } else {
+      aOutputString.AppendLiteral("0px");
+    }
+  }
+}
+
+static void ProcessMarginRightValue(const nsAString* aInputString,
+                                    nsAString& aOutputString,
+                                    const char* aDefaultValueString,
+                                    const char* aPrependString,
+                                    const char* aAppendString) {
+  aOutputString.Truncate();
+  if (aInputString) {
+    if (aInputString->EqualsLiteral("center") ||
+        aInputString->EqualsLiteral("-moz-center")) {
+      aOutputString.AppendLiteral("auto");
+    } else if (aInputString->EqualsLiteral("left") ||
+               aInputString->EqualsLiteral("-moz-left")) {
+      aOutputString.AppendLiteral("auto");
+    } else {
+      aOutputString.AppendLiteral("0px");
+    }
+  }
+}
+
+#define CSS_EQUIV_TABLE_NONE \
+  { CSSEditUtils::eCSSEditableProperty_NONE, 0 }
+
+const CSSEditUtils::CSSEquivTable boldEquivTable[] = {
+    {CSSEditUtils::eCSSEditableProperty_font_weight, true, false, ProcessBValue,
+     nullptr, nullptr, nullptr},
+    CSS_EQUIV_TABLE_NONE};
+
+const CSSEditUtils::CSSEquivTable italicEquivTable[] = {
+    {CSSEditUtils::eCSSEditableProperty_font_style, true, false,
+     ProcessDefaultValue, "italic", nullptr, nullptr},
+    CSS_EQUIV_TABLE_NONE};
+
+const CSSEditUtils::CSSEquivTable underlineEquivTable[] = {
+    {CSSEditUtils::eCSSEditableProperty_text_decoration, true, false,
+     ProcessDefaultValue, "underline", nullptr, nullptr},
+    CSS_EQUIV_TABLE_NONE};
+
+const CSSEditUtils::CSSEquivTable strikeEquivTable[] = {
+    {CSSEditUtils::eCSSEditableProperty_text_decoration, true, false,
+     ProcessDefaultValue, "line-through", nullptr, nullptr},
+    CSS_EQUIV_TABLE_NONE};
+
+const CSSEditUtils::CSSEquivTable ttEquivTable[] = {
+    {CSSEditUtils::eCSSEditableProperty_font_family, true, false,
+     ProcessDefaultValue, "monospace", nullptr, nullptr},
+    CSS_EQUIV_TABLE_NONE};
+
+const CSSEditUtils::CSSEquivTable fontColorEquivTable[] = {
+    {CSSEditUtils::eCSSEditableProperty_color, true, false, ProcessSameValue,
+     nullptr, nullptr, nullptr},
+    CSS_EQUIV_TABLE_NONE};
+
+const CSSEditUtils::CSSEquivTable fontFaceEquivTable[] = {
+    {CSSEditUtils::eCSSEditableProperty_font_family, true, false,
+     ProcessSameValue, nullptr, nullptr, nullptr},
+    CSS_EQUIV_TABLE_NONE};
+
+const CSSEditUtils::CSSEquivTable fontSizeEquivTable[] = {
+    {CSSEditUtils::eCSSEditableProperty_font_size, true, false,
+     ProcessSameValue, nullptr, nullptr, nullptr},
+    CSS_EQUIV_TABLE_NONE};
+
+const CSSEditUtils::CSSEquivTable bgcolorEquivTable[] = {
+    {CSSEditUtils::eCSSEditableProperty_background_color, true, false,
+     ProcessSameValue, nullptr, nullptr, nullptr},
+    CSS_EQUIV_TABLE_NONE};
+
+const CSSEditUtils::CSSEquivTable backgroundImageEquivTable[] = {
+    {CSSEditUtils::eCSSEditableProperty_background_image, true, true,
+     ProcessExtendedValue, nullptr, "url(", ")"},
+    CSS_EQUIV_TABLE_NONE};
+
+const CSSEditUtils::CSSEquivTable textColorEquivTable[] = {
+    {CSSEditUtils::eCSSEditableProperty_color, true, false, ProcessSameValue,
+     nullptr, nullptr, nullptr},
+    CSS_EQUIV_TABLE_NONE};
+
+const CSSEditUtils::CSSEquivTable borderEquivTable[] = {
+    {CSSEditUtils::eCSSEditableProperty_border, true, false,
+     ProcessExtendedValue, nullptr, nullptr, "px solid"},
+    CSS_EQUIV_TABLE_NONE};
+
+const CSSEditUtils::CSSEquivTable textAlignEquivTable[] = {
+    {CSSEditUtils::eCSSEditableProperty_text_align, true, false,
+     ProcessSameValue, nullptr, nullptr, nullptr},
+    CSS_EQUIV_TABLE_NONE};
+
+const CSSEditUtils::CSSEquivTable captionAlignEquivTable[] = {
+    {CSSEditUtils::eCSSEditableProperty_caption_side, true, false,
+     ProcessSameValue, nullptr, nullptr, nullptr},
+    CSS_EQUIV_TABLE_NONE};
+
+const CSSEditUtils::CSSEquivTable verticalAlignEquivTable[] = {
+    {CSSEditUtils::eCSSEditableProperty_vertical_align, true, false,
+     ProcessSameValue, nullptr, nullptr, nullptr},
+    CSS_EQUIV_TABLE_NONE};
+
+const CSSEditUtils::CSSEquivTable nowrapEquivTable[] = {
+    {CSSEditUtils::eCSSEditableProperty_whitespace, true, false,
+     ProcessDefaultValue, "nowrap", nullptr, nullptr},
+    CSS_EQUIV_TABLE_NONE};
+
+const CSSEditUtils::CSSEquivTable widthEquivTable[] = {
+    {CSSEditUtils::eCSSEditableProperty_width, true, false, ProcessLengthValue,
+     nullptr, nullptr, nullptr},
+    CSS_EQUIV_TABLE_NONE};
+
+const CSSEditUtils::CSSEquivTable heightEquivTable[] = {
+    {CSSEditUtils::eCSSEditableProperty_height, true, false, ProcessLengthValue,
+     nullptr, nullptr, nullptr},
+    CSS_EQUIV_TABLE_NONE};
+
+const CSSEditUtils::CSSEquivTable listStyleTypeEquivTable[] = {
+    {CSSEditUtils::eCSSEditableProperty_list_style_type, true, true,
+     ProcessListStyleTypeValue, nullptr, nullptr, nullptr},
+    CSS_EQUIV_TABLE_NONE};
+
+const CSSEditUtils::CSSEquivTable tableAlignEquivTable[] = {
+    {CSSEditUtils::eCSSEditableProperty_text_align, false, false,
+     ProcessDefaultValue, "left", nullptr, nullptr},
+    {CSSEditUtils::eCSSEditableProperty_margin_left, true, false,
+     ProcessMarginLeftValue, nullptr, nullptr, nullptr},
+    {CSSEditUtils::eCSSEditableProperty_margin_right, true, false,
+     ProcessMarginRightValue, nullptr, nullptr, nullptr},
+    CSS_EQUIV_TABLE_NONE};
+
+const CSSEditUtils::CSSEquivTable hrAlignEquivTable[] = {
+    {CSSEditUtils::eCSSEditableProperty_margin_left, true, false,
+     ProcessMarginLeftValue, nullptr, nullptr, nullptr},
+    {CSSEditUtils::eCSSEditableProperty_margin_right, true, false,
+     ProcessMarginRightValue, nullptr, nullptr, nullptr},
+    CSS_EQUIV_TABLE_NONE};
+
+#undef CSS_EQUIV_TABLE_NONE
+
+// static
+bool CSSEditUtils::IsCSSEditableStyle(const Element& aElement,
+                                      const EditorElementStyle& aStyle) {
+  return CSSEditUtils::IsCSSEditableStyle(*aElement.NodeInfo()->NameAtom(),
+                                          aStyle);
+}
+
+// static
+bool CSSEditUtils::IsCSSEditableStyle(const nsAtom& aTagName,
+                                      const EditorElementStyle& aStyle) {
+  nsStaticAtom* const htmlProperty =
+      aStyle.IsInlineStyle() ? aStyle.AsInlineStyle().mHTMLProperty : nullptr;
+  nsAtom* const attributeOrStyle = aStyle.IsInlineStyle()
+                                       ? aStyle.AsInlineStyle().mAttribute.get()
+                                       : aStyle.Style();
+
+  // HTML inline styles <b>, <i>, <tt> (chrome only), <u>, <strike>, <font
+  // color> and <font style>.
+  if (nsGkAtoms::b == htmlProperty || nsGkAtoms::i == htmlProperty ||
+      nsGkAtoms::tt == htmlProperty || nsGkAtoms::u == htmlProperty ||
+      nsGkAtoms::strike == htmlProperty ||
+      (nsGkAtoms::font == htmlProperty &&
+       (attributeOrStyle == nsGkAtoms::color ||
+        attributeOrStyle == nsGkAtoms::face))) {
+    return true;
+  }
+
+  // ALIGN attribute on elements supporting it
+  if (attributeOrStyle == nsGkAtoms::align &&
+      (&aTagName == nsGkAtoms::div || &aTagName == nsGkAtoms::p ||
+       &aTagName == nsGkAtoms::h1 || &aTagName == nsGkAtoms::h2 ||
+       &aTagName == nsGkAtoms::h3 || &aTagName == nsGkAtoms::h4 ||
+       &aTagName == nsGkAtoms::h5 || &aTagName == nsGkAtoms::h6 ||
+       &aTagName == nsGkAtoms::td || &aTagName == nsGkAtoms::th ||
+       &aTagName == nsGkAtoms::table || &aTagName == nsGkAtoms::hr ||
+       // For the above, why not use
+       // HTMLEditUtils::SupportsAlignAttr?
+       // It also checks for tbody, tfoot, thead.
+       // Let's add the following elements here even
+       // if "align" has a different meaning for them
+       &aTagName == nsGkAtoms::legend || &aTagName == nsGkAtoms::caption)) {
+    return true;
+  }
+
+  if (attributeOrStyle == nsGkAtoms::valign &&
+      (&aTagName == nsGkAtoms::col || &aTagName == nsGkAtoms::colgroup ||
+       &aTagName == nsGkAtoms::tbody || &aTagName == nsGkAtoms::td ||
+       &aTagName == nsGkAtoms::th || &aTagName == nsGkAtoms::tfoot ||
+       &aTagName == nsGkAtoms::thead || &aTagName == nsGkAtoms::tr)) {
+    return true;
+  }
+
+  // attributes TEXT, BACKGROUND and BGCOLOR on <body>
+  if (&aTagName == nsGkAtoms::body &&
+      (attributeOrStyle == nsGkAtoms::text ||
+       attributeOrStyle == nsGkAtoms::background ||
+       attributeOrStyle == nsGkAtoms::bgcolor)) {
+    return true;
+  }
+
+  // attribute BGCOLOR on other elements
+  if (attributeOrStyle == nsGkAtoms::bgcolor) {
+    return true;
+  }
+
+  // attributes HEIGHT, WIDTH and NOWRAP on <td> and <th>
+  if ((&aTagName == nsGkAtoms::td || &aTagName == nsGkAtoms::th) &&
+      (attributeOrStyle == nsGkAtoms::height ||
+       attributeOrStyle == nsGkAtoms::width ||
+       attributeOrStyle == nsGkAtoms::nowrap)) {
+    return true;
+  }
+
+  // attributes HEIGHT and WIDTH on <table>
+  if (&aTagName == nsGkAtoms::table && (attributeOrStyle == nsGkAtoms::height ||
+                                        attributeOrStyle == nsGkAtoms::width)) {
+    return true;
+  }
+
+  // attributes SIZE and WIDTH on <hr>
+  if (&aTagName == nsGkAtoms::hr && (attributeOrStyle == nsGkAtoms::size ||
+                                     attributeOrStyle == nsGkAtoms::width)) {
+    return true;
+  }
+
+  // attribute TYPE on <ol>, <ul> and <li>
+  if (attributeOrStyle == nsGkAtoms::type &&
+      (&aTagName == nsGkAtoms::ol || &aTagName == nsGkAtoms::ul ||
+       &aTagName == nsGkAtoms::li)) {
+    return true;
+  }
+
+  if (&aTagName == nsGkAtoms::img && (attributeOrStyle == nsGkAtoms::border ||
+                                      attributeOrStyle == nsGkAtoms::width ||
+                                      attributeOrStyle == nsGkAtoms::height)) {
+    return true;
+  }
+
+  // other elements that we can align using CSS even if they
+  // can't carry the html ALIGN attribute
+  if (attributeOrStyle == nsGkAtoms::align &&
+      (&aTagName == nsGkAtoms::ul || &aTagName == nsGkAtoms::ol ||
+       &aTagName == nsGkAtoms::dl || &aTagName == nsGkAtoms::li ||
+       &aTagName == nsGkAtoms::dd || &aTagName == nsGkAtoms::dt ||
+       &aTagName == nsGkAtoms::address || &aTagName == nsGkAtoms::pre)) {
+    return true;
+  }
+
+  return false;
+}
+
+// The lowest level above the transaction; adds the CSS declaration
+// "aProperty : aValue" to the inline styles carried by aStyledElement
+
+// static
+nsresult CSSEditUtils::SetCSSPropertyInternal(HTMLEditor& aHTMLEditor,
+                                              nsStyledElement& aStyledElement,
+                                              nsAtom& aProperty,
+                                              const nsAString& aValue,
+                                              bool aSuppressTxn) {
+  RefPtr<ChangeStyleTransaction> transaction =
+      ChangeStyleTransaction::Create(aStyledElement, aProperty, aValue);
+  if (aSuppressTxn) {
+    nsresult rv = transaction->DoTransaction();
+    NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+                         "ChangeStyleTransaction::DoTransaction() failed");
+    return rv;
+  }
+  nsresult rv = aHTMLEditor.DoTransactionInternal(transaction);
+  if (NS_WARN_IF(aHTMLEditor.Destroyed())) {
+    return NS_ERROR_EDITOR_DESTROYED;
+  }
+  NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+                       "EditorBase::DoTransactionInternal() failed");
+  return rv;
+}
+
+// static
+nsresult CSSEditUtils::SetCSSPropertyPixelsWithTransaction(
+    HTMLEditor& aHTMLEditor, nsStyledElement& aStyledElement, nsAtom& aProperty,
+    int32_t aIntValue) {
+  nsAutoString s;
+  s.AppendInt(aIntValue);
+  nsresult rv = SetCSSPropertyWithTransaction(aHTMLEditor, aStyledElement,
+                                              aProperty, s + u"px"_ns);
+  NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+                       "CSSEditUtils::SetCSSPropertyWithTransaction() failed");
+  return rv;
+}
+
+// static
+nsresult CSSEditUtils::SetCSSPropertyPixelsWithoutTransaction(
+    nsStyledElement& aStyledElement, const nsAtom& aProperty,
+    int32_t aIntValue) {
+  nsCOMPtr<nsICSSDeclaration> cssDecl = aStyledElement.Style();
+
+  nsAutoCString propertyNameString;
+  aProperty.ToUTF8String(propertyNameString);
+
+  nsAutoCString s;
+  s.AppendInt(aIntValue);
+  s.AppendLiteral("px");
+
+  ErrorResult error;
+  cssDecl->SetProperty(propertyNameString, s, EmptyCString(), error);
+  if (error.Failed()) {
+    NS_WARNING("nsICSSDeclaration::SetProperty() failed");
+    return error.StealNSResult();
+  }
+
+  return NS_OK;
+}
+
+// The lowest level above the transaction; removes the value aValue from the
+// list of values specified for the CSS property aProperty, or totally remove
+// the declaration if this property accepts only one value
+
+// static
+nsresult CSSEditUtils::RemoveCSSPropertyInternal(
+    HTMLEditor& aHTMLEditor, nsStyledElement& aStyledElement, nsAtom& aProperty,
+    const nsAString& aValue, bool aSuppressTxn) {
+  RefPtr<ChangeStyleTransaction> transaction =
+      ChangeStyleTransaction::CreateToRemove(aStyledElement, aProperty, aValue);
+  if (aSuppressTxn) {
+    nsresult rv = transaction->DoTransaction();
+    NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+                         "ChangeStyleTransaction::DoTransaction() failed");
+    return rv;
+  }
+  nsresult rv = aHTMLEditor.DoTransactionInternal(transaction);
+  if (NS_WARN_IF(aHTMLEditor.Destroyed())) {
+    return NS_ERROR_EDITOR_DESTROYED;
+  }
+  NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+                       "EditorBase::DoTransactionInternal() failed");
+  return rv;
+}
+
+// static
+nsresult CSSEditUtils::GetSpecifiedProperty(nsIContent& aContent,
+                                            nsAtom& aCSSProperty,
+                                            nsAString& aValue) {
+  nsresult rv =
+      GetSpecifiedCSSInlinePropertyBase(aContent, aCSSProperty, aValue);
+  NS_WARNING_ASSERTION(
+      NS_SUCCEEDED(rv),
+      "CSSEditUtils::GeSpecifiedCSSInlinePropertyBase() failed");
+  return rv;
+}
+
+// static
+nsresult CSSEditUtils::GetComputedProperty(nsIContent& aContent,
+                                           nsAtom& aCSSProperty,
+                                           nsAString& aValue) {
+  nsresult rv =
+      GetComputedCSSInlinePropertyBase(aContent, aCSSProperty, aValue);
+  NS_WARNING_ASSERTION(
+      NS_SUCCEEDED(rv),
+      "CSSEditUtils::GetComputedCSSInlinePropertyBase() failed");
+  return rv;
+}
+
+// static
+nsresult CSSEditUtils::GetComputedCSSInlinePropertyBase(nsIContent& aContent,
+                                                        nsAtom& aCSSProperty,
+                                                        nsAString& aValue) {
+  aValue.Truncate();
+
+  RefPtr<Element> element = aContent.GetAsElementOrParentElement();
+  if (NS_WARN_IF(!element)) {
+    return NS_ERROR_INVALID_ARG;
+  }
+
+  // Get the all the computed css styles attached to the element node
+  RefPtr<nsComputedDOMStyle> computedDOMStyle = GetComputedStyle(element);
+  if (NS_WARN_IF(!computedDOMStyle)) {
+    return NS_ERROR_INVALID_ARG;
+  }
+
+  // from these declarations, get the one we want and that one only
+  //
+  // FIXME(bug 1606994): nsAtomCString copies, we should just keep around the
+  // property id.
+  //
+  // FIXME: Maybe we can avoid copying aValue too, though it's no worse than
+  // what we used to do.
+  nsAutoCString value;
+  computedDOMStyle->GetPropertyValue(nsAtomCString(&aCSSProperty), value);
+  CopyUTF8toUTF16(value, aValue);
+  return NS_OK;
+}
+
+// static
+nsresult CSSEditUtils::GetSpecifiedCSSInlinePropertyBase(nsIContent& aContent,
+                                                         nsAtom& aCSSProperty,
+                                                         nsAString& aValue) {
+  aValue.Truncate();
+
+  RefPtr<Element> element = aContent.GetAsElementOrParentElement();
+  if (NS_WARN_IF(!element)) {
+    return NS_ERROR_INVALID_ARG;
+  }
+
+  RefPtr<DeclarationBlock> decl = element->GetInlineStyleDeclaration();
+  if (!decl) {
+    return NS_OK;
+  }
+
+  // FIXME: Same comments as above.
+  nsCSSPropertyID prop =
+      nsCSSProps::LookupProperty(nsAtomCString(&aCSSProperty));
+  MOZ_ASSERT(prop != eCSSProperty_UNKNOWN);
+
+  nsAutoCString value;
+  decl->GetPropertyValueByID(prop, value);
+  CopyUTF8toUTF16(value, aValue);
+  return NS_OK;
+}
+
+// static
+already_AddRefed<nsComputedDOMStyle> CSSEditUtils::GetComputedStyle(
+    Element* aElement) {
+  MOZ_ASSERT(aElement);
+
+  Document* document = aElement->GetComposedDoc();
+  if (NS_WARN_IF(!document)) {
+    return nullptr;
+  }
+
+  RefPtr<nsComputedDOMStyle> computedDOMStyle = NS_NewComputedDOMStyle(
+      aElement, u""_ns, document, nsComputedDOMStyle::StyleType::All,
+      IgnoreErrors());
+  return computedDOMStyle.forget();
+}
+
+// remove the CSS style "aProperty : aPropertyValue" and possibly remove the
+// whole node if it is a span and if its only attribute is _moz_dirty
+
+// static
+Result<EditorDOMPoint, nsresult>
+CSSEditUtils::RemoveCSSInlineStyleWithTransaction(
+    HTMLEditor& aHTMLEditor, nsStyledElement& aStyledElement, nsAtom* aProperty,
+    const nsAString& aPropertyValue) {
+  // remove the property from the style attribute
+  nsresult rv = RemoveCSSPropertyWithTransaction(aHTMLEditor, aStyledElement,
+                                                 *aProperty, aPropertyValue);
+  if (NS_FAILED(rv)) {
+    NS_WARNING("CSSEditUtils::RemoveCSSPropertyWithTransaction() failed");
+    return Err(rv);
+  }
+
+  if (!aStyledElement.IsHTMLElement(nsGkAtoms::span) ||
+      HTMLEditUtils::ElementHasAttribute(aStyledElement)) {
+    return EditorDOMPoint();
+  }
+
+  Result<EditorDOMPoint, nsresult> unwrapStyledElementResult =
+      aHTMLEditor.RemoveContainerWithTransaction(aStyledElement);
+  NS_WARNING_ASSERTION(unwrapStyledElementResult.isOk(),
+                       "HTMLEditor::RemoveContainerWithTransaction() failed");
+  return unwrapStyledElementResult;
+}
+
+// Get the default browser background color if we need it for
+// GetCSSBackgroundColorState
+
+// static
+void CSSEditUtils::GetDefaultBackgroundColor(nsAString& aColor) {
+  if (MOZ_UNLIKELY(StaticPrefs::editor_use_custom_colors())) {
+    nsresult rv = Preferences::GetString("editor.background_color", aColor);
+    // XXX Why don't you validate the pref value?
+    if (NS_FAILED(rv)) {
+      NS_WARNING("failed to get editor.background_color");
+      aColor.AssignLiteral("#ffffff");  // Default to white
+    }
+    return;
+  }
+
+  if (Preferences::GetBool("browser.display.use_system_colors", false)) {
+    return;
+  }
+
+  nsresult rv =
+      Preferences::GetString("browser.display.background_color", aColor);
+  // XXX Why don't you validate the pref value?
+  if (NS_FAILED(rv)) {
+    NS_WARNING("failed to get browser.display.background_color");
+    aColor.AssignLiteral("#ffffff");  // Default to white
+  }
+}
+
+// static
+void CSSEditUtils::ParseLength(const nsAString& aString, float* aValue,
+                               nsAtom** aUnit) {
+  if (aString.IsEmpty()) {
+    *aValue = 0;
+    *aUnit = NS_Atomize(aString).take();
+    return;
+  }
+
+  nsAString::const_iterator iter;
+  aString.BeginReading(iter);
+
+  float a = 10.0f, b = 1.0f, value = 0;
+  int8_t sign = 1;
+  int32_t i = 0, j = aString.Length();
+  char16_t c;
+  bool floatingPointFound = false;
+  c = *iter;
+  if (char16_t('-') == c) {
+    sign = -1;
+    iter++;
+    i++;
+  } else if (char16_t('+') == c) {
+    iter++;
+    i++;
+  }
+  while (i < j) {
+    c = *iter;
+    if ((char16_t('0') == c) || (char16_t('1') == c) || (char16_t('2') == c) ||
+        (char16_t('3') == c) || (char16_t('4') == c) || (char16_t('5') == c) ||
+        (char16_t('6') == c) || (char16_t('7') == c) || (char16_t('8') == c) ||
+        (char16_t('9') == c)) {
+      value = (value * a) + (b * (c - char16_t('0')));
+      b = b / 10 * a;
+    } else if (!floatingPointFound && (char16_t('.') == c)) {
+      floatingPointFound = true;
+      a = 1.0f;
+      b = 0.1f;
+    } else
+      break;
+    iter++;
+    i++;
+  }
+  *aValue = value * sign;
+  *aUnit = NS_Atomize(StringTail(aString, j - i)).take();
+}
+
+// static
+nsStaticAtom* CSSEditUtils::GetCSSPropertyAtom(
+    nsCSSEditableProperty aProperty) {
+  switch (aProperty) {
+    case eCSSEditableProperty_background_color:
+      return nsGkAtoms::backgroundColor;
+    case eCSSEditableProperty_background_image:
+      return nsGkAtoms::background_image;
+    case eCSSEditableProperty_border:
+      return nsGkAtoms::border;
+    case eCSSEditableProperty_caption_side:
+      return nsGkAtoms::caption_side;
+    case eCSSEditableProperty_color:
+      return nsGkAtoms::color;
+    case eCSSEditableProperty_float:
+      return nsGkAtoms::_float;
+    case eCSSEditableProperty_font_family:
+      return nsGkAtoms::font_family;
+    case eCSSEditableProperty_font_size:
+      return nsGkAtoms::font_size;
+    case eCSSEditableProperty_font_style:
+      return nsGkAtoms::font_style;
+    case eCSSEditableProperty_font_weight:
+      return nsGkAtoms::fontWeight;
+    case eCSSEditableProperty_height:
+      return nsGkAtoms::height;
+    case eCSSEditableProperty_list_style_type:
+      return nsGkAtoms::list_style_type;
+    case eCSSEditableProperty_margin_left:
+      return nsGkAtoms::marginLeft;
+    case eCSSEditableProperty_margin_right:
+      return nsGkAtoms::marginRight;
+    case eCSSEditableProperty_text_align:
+      return nsGkAtoms::textAlign;
+    case eCSSEditableProperty_text_decoration:
+      return nsGkAtoms::text_decoration;
+    case eCSSEditableProperty_vertical_align:
+      return nsGkAtoms::vertical_align;
+    case eCSSEditableProperty_whitespace:
+      return nsGkAtoms::white_space;
+    case eCSSEditableProperty_width:
+      return nsGkAtoms::width;
+    case eCSSEditableProperty_NONE:
+      // intentionally empty
+      return nullptr;
+  }
+  MOZ_ASSERT_UNREACHABLE("Got unknown property");
+  return nullptr;
+}
+
+// static
+void CSSEditUtils::GetCSSDeclarations(
+    const CSSEquivTable* aEquivTable, const nsAString* aValue,
+    HandlingFor aHandlingFor, nsTArray<CSSDeclaration>& aOutCSSDeclarations) {
+  // clear arrays
+  aOutCSSDeclarations.Clear();
+
+  // if we have an input value, let's use it
+  nsAutoString value, lowerCasedValue;
+  if (aValue) {
+    value.Assign(*aValue);
+    lowerCasedValue.Assign(*aValue);
+    ToLowerCase(lowerCasedValue);
+  }
+
+  for (size_t index = 0;; index++) {
+    const nsCSSEditableProperty cssProperty = aEquivTable[index].cssProperty;
+    if (!cssProperty) {
+      break;
+    }
+    if (aHandlingFor == HandlingFor::SettingStyle ||
+        aEquivTable[index].gettable) {
+      nsAutoString cssValue, cssPropertyString;
+      // find the equivalent css value for the index-th property in
+      // the equivalence table
+      (*aEquivTable[index].processValueFunctor)(
+          (aHandlingFor == HandlingFor::SettingStyle ||
+           aEquivTable[index].caseSensitiveValue)
+              ? &value
+              : &lowerCasedValue,
+          cssValue, aEquivTable[index].defaultValue,
+          aEquivTable[index].prependValue, aEquivTable[index].appendValue);
+      nsStaticAtom* const propertyAtom = GetCSSPropertyAtom(cssProperty);
+      if (MOZ_LIKELY(propertyAtom)) {
+        aOutCSSDeclarations.AppendElement(
+            CSSDeclaration{*propertyAtom, cssValue});
+      }
+    }
+  }
+}
+
+// static
+void CSSEditUtils::GetCSSDeclarations(
+    Element& aElement, const EditorElementStyle& aStyle,
+    const nsAString* aValue, HandlingFor aHandlingFor,
+    nsTArray<CSSDeclaration>& aOutCSSDeclarations) {
+  nsStaticAtom* const htmlProperty =
+      aStyle.IsInlineStyle() ? aStyle.AsInlineStyle().mHTMLProperty : nullptr;
+  const RefPtr<nsAtom> attributeOrStyle =
+      aStyle.IsInlineStyle() ? aStyle.AsInlineStyle().mAttribute
+                             : aStyle.Style();
+
+  const auto* equivTable = [&]() -> const CSSEditUtils::CSSEquivTable* {
+    if (nsGkAtoms::b == htmlProperty) {
+      return boldEquivTable;
+    }
+    if (nsGkAtoms::i == htmlProperty) {
+      return italicEquivTable;
+    }
+    if (nsGkAtoms::u == htmlProperty) {
+      return underlineEquivTable;
+    }
+    if (nsGkAtoms::strike == htmlProperty) {
+      return strikeEquivTable;
+    }
+    if (nsGkAtoms::tt == htmlProperty) {
+      return ttEquivTable;
+    }
+    if (!attributeOrStyle) {
+      return nullptr;
+    }
+    if (nsGkAtoms::font == htmlProperty) {
+      if (attributeOrStyle == nsGkAtoms::color) {
+        return fontColorEquivTable;
+      }
+      if (attributeOrStyle == nsGkAtoms::face) {
+        return fontFaceEquivTable;
+      }
+      if (attributeOrStyle == nsGkAtoms::size) {
+        return fontSizeEquivTable;
+      }
+      MOZ_ASSERT(attributeOrStyle == nsGkAtoms::bgcolor);
+    }
+    if (attributeOrStyle == nsGkAtoms::bgcolor) {
+      return bgcolorEquivTable;
+    }
+    if (attributeOrStyle == nsGkAtoms::background) {
+      return backgroundImageEquivTable;
+    }
+    if (attributeOrStyle == nsGkAtoms::text) {
+      return textColorEquivTable;
+    }
+    if (attributeOrStyle == nsGkAtoms::border) {
+      return borderEquivTable;
+    }
+    if (attributeOrStyle == nsGkAtoms::align) {
+      if (aElement.IsHTMLElement(nsGkAtoms::table)) {
+        return tableAlignEquivTable;
+      }
+      if (aElement.IsHTMLElement(nsGkAtoms::hr)) {
+        return hrAlignEquivTable;
+      }
+      if (aElement.IsAnyOfHTMLElements(nsGkAtoms::legend, nsGkAtoms::caption)) {
+        return captionAlignEquivTable;
+      }
+      return textAlignEquivTable;
+    }
+    if (attributeOrStyle == nsGkAtoms::valign) {
+      return verticalAlignEquivTable;
+    }
+    if (attributeOrStyle == nsGkAtoms::nowrap) {
+      return nowrapEquivTable;
+    }
+    if (attributeOrStyle == nsGkAtoms::width) {
+      return widthEquivTable;
+    }
+    if (attributeOrStyle == nsGkAtoms::height ||
+        (aElement.IsHTMLElement(nsGkAtoms::hr) &&
+         attributeOrStyle == nsGkAtoms::size)) {
+      return heightEquivTable;
+    }
+    if (attributeOrStyle == nsGkAtoms::type &&
+        aElement.IsAnyOfHTMLElements(nsGkAtoms::ol, nsGkAtoms::ul,
+                                     nsGkAtoms::li)) {
+      return listStyleTypeEquivTable;
+    }
+    return nullptr;
+  }();
+  if (equivTable) {
+    GetCSSDeclarations(equivTable, aValue, aHandlingFor, aOutCSSDeclarations);
+  }
+}
+
+// Add to aNode the CSS inline style equivalent to HTMLProperty/aAttribute/
+// aValue for the node, and return in aCount the number of CSS properties set
+// by the call.  The Element version returns aCount instead.
+Result<size_t, nsresult> CSSEditUtils::SetCSSEquivalentToStyle(
+    WithTransaction aWithTransaction, HTMLEditor& aHTMLEditor,
+    nsStyledElement& aStyledElement, const EditorElementStyle& aStyleToSet,
+    const nsAString* aValue) {
+  MOZ_DIAGNOSTIC_ASSERT(aStyleToSet.IsCSSSettable(aStyledElement));
+
+  // we can apply the styles only if the node is an element and if we have
+  // an equivalence for the requested HTML style in this implementation
+
+  // Find the CSS equivalence to the HTML style
+  AutoTArray<CSSDeclaration, 4> cssDeclarations;
+  GetCSSDeclarations(aStyledElement, aStyleToSet, aValue,
+                     HandlingFor::SettingStyle, cssDeclarations);
+
+  // set the individual CSS inline styles
+  for (const CSSDeclaration& cssDeclaration : cssDeclarations) {
+    nsresult rv = SetCSSPropertyInternal(
+        aHTMLEditor, aStyledElement, MOZ_KnownLive(cssDeclaration.mProperty),
+        cssDeclaration.mValue, aWithTransaction == WithTransaction::No);
+    if (NS_FAILED(rv)) {
+      NS_WARNING("CSSEditUtils::SetCSSPropertyInternal() failed");
+      return Err(rv);
+    }
+  }
+  return cssDeclarations.Length();
+}
+
+// static
+nsresult CSSEditUtils::RemoveCSSEquivalentToStyle(
+    WithTransaction aWithTransaction, HTMLEditor& aHTMLEditor,
+    nsStyledElement& aStyledElement, const EditorElementStyle& aStyleToRemove,
+    const nsAString* aValue) {
+  MOZ_DIAGNOSTIC_ASSERT(aStyleToRemove.IsCSSRemovable(aStyledElement));
+
+  // we can apply the styles only if the node is an element and if we have
+  // an equivalence for the requested HTML style in this implementation
+
+  // Find the CSS equivalence to the HTML style
+  AutoTArray<CSSDeclaration, 4> cssDeclarations;
+  GetCSSDeclarations(aStyledElement, aStyleToRemove, aValue,
+                     HandlingFor::RemovingStyle, cssDeclarations);
+
+  // remove the individual CSS inline styles
+  for (const CSSDeclaration& cssDeclaration : cssDeclarations) {
+    nsresult rv = RemoveCSSPropertyInternal(
+        aHTMLEditor, aStyledElement, MOZ_KnownLive(cssDeclaration.mProperty),
+        cssDeclaration.mValue, aWithTransaction == WithTransaction::No);
+    if (NS_FAILED(rv)) {
+      NS_WARNING("CSSEditUtils::RemoveCSSPropertyWithoutTransaction() failed");
+      return rv;
+    }
+  }
+  return NS_OK;
+}
+
+// static
+nsresult CSSEditUtils::GetComputedCSSEquivalentTo(
+    Element& aElement, const EditorElementStyle& aStyle, nsAString& aOutValue) {
+  return GetCSSEquivalentTo(aElement, aStyle, aOutValue, StyleType::Computed);
+}
+
+// static
+nsresult CSSEditUtils::GetCSSEquivalentTo(Element& aElement,
+                                          const EditorElementStyle& aStyle,
+                                          nsAString& aOutValue,
+                                          StyleType aStyleType) {
+  MOZ_ASSERT_IF(aStyle.IsInlineStyle(),
+                !aStyle.AsInlineStyle().IsStyleToClearAllInlineStyles());
+  MOZ_DIAGNOSTIC_ASSERT(aStyle.IsCSSSettable(aElement) ||
+                        aStyle.IsCSSRemovable(aElement));
+
+  aOutValue.Truncate();
+  AutoTArray<CSSDeclaration, 4> cssDeclarations;
+  GetCSSDeclarations(aElement, aStyle, nullptr, HandlingFor::GettingStyle,
+                     cssDeclarations);
+  nsAutoString valueString;
+  for (const CSSDeclaration& cssDeclaration : cssDeclarations) {
+    valueString.Truncate();
+    // retrieve the specified/computed value of the property
+    if (aStyleType == StyleType::Computed) {
+      nsresult rv = GetComputedCSSInlinePropertyBase(
+          aElement, MOZ_KnownLive(cssDeclaration.mProperty), valueString);
+      if (NS_FAILED(rv)) {
+        NS_WARNING("CSSEditUtils::GetComputedCSSInlinePropertyBase() failed");
+        return rv;
+      }
+    } else {
+      nsresult rv = GetSpecifiedCSSInlinePropertyBase(
+          aElement, cssDeclaration.mProperty, valueString);
+      if (NS_FAILED(rv)) {
+        NS_WARNING("CSSEditUtils::GetSpecifiedCSSInlinePropertyBase() failed");
+        return rv;
+      }
+    }
+    // append the value to aOutValue (possibly with a leading white-space)
+    if (!aOutValue.IsEmpty()) {
+      aOutValue.Append(HTMLEditUtils::kSpace);
+    }
+    aOutValue.Append(valueString);
+  }
+  return NS_OK;
+}
+
+// Does the node aContent (or its parent, if it's not an element node) have a
+// CSS style equivalent to the HTML style
+// aHTMLProperty/aAttribute/valueString? The value of aStyleType controls
+// the styles we retrieve: specified or computed. The return value aIsSet is
+// true if the CSS styles are set.
+//
+// The nsIContent variant returns aIsSet instead of using an out parameter, and
+// does not modify aValue.
+
+// static
+Result<bool, nsresult> CSSEditUtils::IsComputedCSSEquivalentTo(
+    const HTMLEditor& aHTMLEditor, nsIContent& aContent,
+    const EditorInlineStyle& aStyle, nsAString& aInOutValue) {
+  return IsCSSEquivalentTo(aHTMLEditor, aContent, aStyle, aInOutValue,
+                           StyleType::Computed);
+}
+
+// static
+Result<bool, nsresult> CSSEditUtils::IsSpecifiedCSSEquivalentTo(
+    const HTMLEditor& aHTMLEditor, nsIContent& aContent,
+    const EditorInlineStyle& aStyle, nsAString& aInOutValue) {
+  return IsCSSEquivalentTo(aHTMLEditor, aContent, aStyle, aInOutValue,
+                           StyleType::Specified);
+}
+
+// static
+Result<bool, nsresult> CSSEditUtils::IsCSSEquivalentTo(
+    const HTMLEditor& aHTMLEditor, nsIContent& aContent,
+    const EditorInlineStyle& aStyle, nsAString& aInOutValue,
+    StyleType aStyleType) {
+  MOZ_ASSERT(!aStyle.IsStyleToClearAllInlineStyles());
+
+  nsAutoString htmlValueString(aInOutValue);
+  bool isSet = false;
+  // FYI: Cannot use InclusiveAncestorsOfType here because
+  //      GetCSSEquivalentTo() may flush pending notifications.
+  for (RefPtr<Element> element = aContent.GetAsElementOrParentElement();
+       element; element = element->GetParentElement()) {
+    nsCOMPtr<nsINode> parentNode = element->GetParentNode();
+    aInOutValue.Assign(htmlValueString);
+    // get the value of the CSS equivalent styles
+    nsresult rv = GetCSSEquivalentTo(*element, aStyle, aInOutValue, aStyleType);
+    if (NS_WARN_IF(aHTMLEditor.Destroyed())) {
+      return Err(NS_ERROR_EDITOR_DESTROYED);
+    }
+    if (NS_FAILED(rv)) {
+      NS_WARNING(
+          "CSSEditUtils::GetCSSEquivalentToHTMLInlineStyleSetInternal() "
+          "failed");
+      return Err(rv);
+    }
+    if (NS_WARN_IF(parentNode != element->GetParentNode())) {
+      return Err(NS_ERROR_EDITOR_UNEXPECTED_DOM_TREE);
+    }
+
+    // early way out if we can
+    if (aInOutValue.IsEmpty()) {
+      return isSet;
+    }
+
+    if (nsGkAtoms::b == aStyle.mHTMLProperty) {
+      if (aInOutValue.EqualsLiteral("bold")) {
+        isSet = true;
+      } else if (aInOutValue.EqualsLiteral("normal")) {
+        isSet = false;
+      } else if (aInOutValue.EqualsLiteral("bolder")) {
+        isSet = true;
+        aInOutValue.AssignLiteral("bold");
+      } else {
+        int32_t weight = 0;
+        nsresult rvIgnored;
+        nsAutoString value(aInOutValue);
+        weight = value.ToInteger(&rvIgnored);
+        NS_WARNING_ASSERTION(NS_SUCCEEDED(rvIgnored),
+                             "nsAString::ToInteger() failed, but ignored");
+        if (400 < weight) {
+          isSet = true;
+          aInOutValue.AssignLiteral(u"bold");
+        } else {
+          isSet = false;
+          aInOutValue.AssignLiteral(u"normal");
+        }
+      }
+    } else if (nsGkAtoms::i == aStyle.mHTMLProperty) {
+      if (aInOutValue.EqualsLiteral(u"italic") ||
+          aInOutValue.EqualsLiteral(u"oblique")) {
+        isSet = true;
+      }
+    } else if (nsGkAtoms::u == aStyle.mHTMLProperty) {
+      isSet = ChangeStyleTransaction::ValueIncludes(
+          NS_ConvertUTF16toUTF8(aInOutValue), "underline"_ns);
+    } else if (nsGkAtoms::strike == aStyle.mHTMLProperty) {
+      isSet = ChangeStyleTransaction::ValueIncludes(
+          NS_ConvertUTF16toUTF8(aInOutValue), "line-through"_ns);
+    } else if ((nsGkAtoms::font == aStyle.mHTMLProperty &&
+                aStyle.mAttribute == nsGkAtoms::color) ||
+               aStyle.mAttribute == nsGkAtoms::bgcolor) {
+      isSet = htmlValueString.IsEmpty() ||
+              HTMLEditUtils::IsSameCSSColorValue(htmlValueString, aInOutValue);
+    } else if (nsGkAtoms::tt == aStyle.mHTMLProperty) {
+      isSet = StringBeginsWith(aInOutValue, u"monospace"_ns);
+    } else if (nsGkAtoms::font == aStyle.mHTMLProperty &&
+               aStyle.mAttribute == nsGkAtoms::face) {
+      if (!htmlValueString.IsEmpty()) {
+        const char16_t commaSpace[] = {char16_t(','), HTMLEditUtils::kSpace, 0};
+        const char16_t comma[] = {char16_t(','), 0};
+        htmlValueString.ReplaceSubstring(commaSpace, comma);
+        nsAutoString valueStringNorm(aInOutValue);
+        valueStringNorm.ReplaceSubstring(commaSpace, comma);
+        isSet = htmlValueString.Equals(valueStringNorm,
+                                       nsCaseInsensitiveStringComparator);
+      } else {
+        isSet = true;
+      }
+      return isSet;
+    } else if (aStyle.IsStyleOfFontSize()) {
+      if (htmlValueString.IsEmpty()) {
+        return true;
+      }
+      switch (nsContentUtils::ParseLegacyFontSize(htmlValueString)) {
+        case 1:
+          return aInOutValue.EqualsLiteral("x-small");
+        case 2:
+          return aInOutValue.EqualsLiteral("small");
+        case 3:
+          return aInOutValue.EqualsLiteral("medium");
+        case 4:
+          return aInOutValue.EqualsLiteral("large");
+        case 5:
+          return aInOutValue.EqualsLiteral("x-large");
+        case 6:
+          return aInOutValue.EqualsLiteral("xx-large");
+        case 7:
+          return aInOutValue.EqualsLiteral("xxx-large");
+      }
+      return false;
+    } else if (aStyle.mAttribute == nsGkAtoms::align) {
+      isSet = true;
+    } else {
+      return false;
+    }
+
+    if (!htmlValueString.IsEmpty() &&
+        htmlValueString.Equals(aInOutValue,
+                               nsCaseInsensitiveStringComparator)) {
+      isSet = true;
+    }
+
+    if (htmlValueString.EqualsLiteral(u"-moz-editor-invert-value")) {
+      isSet = !isSet;
+    }
+
+    if (isSet) {
+      return true;
+    }
+
+    if (!aStyle.IsStyleOfTextDecoration(
+            EditorInlineStyle::IgnoreSElement::Yes)) {
+      return isSet;
+    }
+
+    // Unfortunately, the value of the text-decoration property is not
+    // inherited. that means that we have to look at ancestors of node to see
+    // if they are underlined.
+  }
+  return isSet;
+}
+
+// static
+Result<bool, nsresult> CSSEditUtils::HaveComputedCSSEquivalentStyles(
+    const HTMLEditor& aHTMLEditor, nsIContent& aContent,
+    const EditorInlineStyle& aStyle) {
+  return HaveCSSEquivalentStyles(aHTMLEditor, aContent, aStyle,
+                                 StyleType::Computed);
+}
+
+// static
+Result<bool, nsresult> CSSEditUtils::HaveSpecifiedCSSEquivalentStyles(
+    const HTMLEditor& aHTMLEditor, nsIContent& aContent,
+    const EditorInlineStyle& aStyle) {
+  return HaveCSSEquivalentStyles(aHTMLEditor, aContent, aStyle,
+                                 StyleType::Specified);
+}
+
+// static
+Result<bool, nsresult> CSSEditUtils::HaveCSSEquivalentStyles(
+    const HTMLEditor& aHTMLEditor, nsIContent& aContent,
+    const EditorInlineStyle& aStyle, StyleType aStyleType) {
+  MOZ_ASSERT(!aStyle.IsStyleToClearAllInlineStyles());
+
+  // FYI: Unfortunately, we cannot use InclusiveAncestorsOfType here
+  //      because GetCSSEquivalentTo() may flush pending notifications.
+  nsAutoString valueString;
+  for (RefPtr<Element> element = aContent.GetAsElementOrParentElement();
+       element; element = element->GetParentElement()) {
+    nsCOMPtr<nsINode> parentNode = element->GetParentNode();
+    // get the value of the CSS equivalent styles
+    nsresult rv = GetCSSEquivalentTo(*element, aStyle, valueString, aStyleType);
+    if (NS_WARN_IF(aHTMLEditor.Destroyed())) {
+      return Err(NS_ERROR_EDITOR_DESTROYED);
+    }
+    if (NS_FAILED(rv)) {
+      NS_WARNING(
+          "CSSEditUtils::GetCSSEquivalentToHTMLInlineStyleSetInternal() "
+          "failed");
+      return Err(rv);
+    }
+    if (NS_WARN_IF(parentNode != element->GetParentNode())) {
+      return Err(NS_ERROR_EDITOR_UNEXPECTED_DOM_TREE);
+    }
+
+    if (!valueString.IsEmpty()) {
+      return true;
+    }
+
+    if (!aStyle.IsStyleOfTextDecoration(
+            EditorInlineStyle::IgnoreSElement::Yes)) {
+      return false;
+    }
+
+    // Unfortunately, the value of the text-decoration property is not
+    // inherited.
+    // that means that we have to look at ancestors of node to see if they
+    // are underlined.
+  }
+
+  return false;
+}
+
+// ElementsSameStyle compares two elements and checks if they have the same
+// specified CSS declarations in the STYLE attribute
+// The answer is always negative if at least one of them carries an ID or a
+// class
+
+// static
+bool CSSEditUtils::DoStyledElementsHaveSameStyle(
+    nsStyledElement& aStyledElement, nsStyledElement& aOtherStyledElement) {
+  if (aStyledElement.HasAttr(nsGkAtoms::id) ||
+      aOtherStyledElement.HasAttr(nsGkAtoms::id)) {
+    // at least one of the spans carries an ID ; suspect a CSS rule applies to
+    // it and refuse to merge the nodes
+    return false;
+  }
+
+  nsAutoString firstClass, otherClass;
+  bool isElementClassSet =
+      aStyledElement.GetAttr(nsGkAtoms::_class, firstClass);
+  bool isOtherElementClassSet = aOtherStyledElement.GetAttr(
+      kNameSpaceID_None, nsGkAtoms::_class, otherClass);
+  if (isElementClassSet && isOtherElementClassSet) {
+    // both spans carry a class, let's compare them
+    if (!firstClass.Equals(otherClass)) {
+      // WARNING : technically, the comparison just above is questionable :
+      // from a pure HTML/CSS point of view class="a b" is NOT the same than
+      // class="b a" because a CSS rule could test the exact value of the class
+      // attribute to be "a b" for instance ; from a user's point of view, a
+      // wysiwyg editor should probably NOT make any difference. CSS people
+      // need to discuss this issue before any modification.
+      return false;
+    }
+  } else if (isElementClassSet || isOtherElementClassSet) {
+    // one span only carries a class, early way out
+    return false;
+  }
+
+  // XXX If `GetPropertyValue()` won't run script, we can stop using
+  //     nsCOMPtr here.
+  nsCOMPtr<nsICSSDeclaration> firstCSSDecl = aStyledElement.Style();
+  if (!firstCSSDecl) {
+    NS_WARNING("nsStyledElement::Style() failed");
+    return false;
+  }
+  nsCOMPtr<nsICSSDeclaration> otherCSSDecl = aOtherStyledElement.Style();
+  if (!otherCSSDecl) {
+    NS_WARNING("nsStyledElement::Style() failed");
+    return false;
+  }
+
+  const uint32_t firstLength = firstCSSDecl->Length();
+  const uint32_t otherLength = otherCSSDecl->Length();
+  if (firstLength != otherLength) {
+    // early way out if we can
+    return false;
+  }
+
+  if (!firstLength) {
+    // no inline style !
+    return true;
+  }
+
+  for (uint32_t i = 0; i < firstLength; i++) {
+    nsAutoCString firstValue, otherValue;
+    nsAutoCString propertyNameString;
+    firstCSSDecl->Item(i, propertyNameString);
+    firstCSSDecl->GetPropertyValue(propertyNameString, firstValue);
+    otherCSSDecl->GetPropertyValue(propertyNameString, otherValue);
+    // FIXME: We need to handle all properties whose values are color.
+    // However, it's too expensive if we keep using string property names.
+    if (propertyNameString.EqualsLiteral("color") ||
+        propertyNameString.EqualsLiteral("background-color")) {
+      if (!HTMLEditUtils::IsSameCSSColorValue(firstValue, otherValue)) {
+        return false;
+      }
+    } else if (!firstValue.Equals(otherValue)) {
+      return false;
+    }
+  }
+  for (uint32_t i = 0; i < otherLength; i++) {
+    nsAutoCString firstValue, otherValue;
+    nsAutoCString propertyNameString;
+    otherCSSDecl->Item(i, propertyNameString);
+    otherCSSDecl->GetPropertyValue(propertyNameString, otherValue);
+    firstCSSDecl->GetPropertyValue(propertyNameString, firstValue);
+    // FIXME: We need to handle all properties whose values are color.
+    // However, it's too expensive if we keep using string property names.
+    if (propertyNameString.EqualsLiteral("color") ||
+        propertyNameString.EqualsLiteral("background-color")) {
+      if (!HTMLEditUtils::IsSameCSSColorValue(firstValue, otherValue)) {
+        return false;
+      }
+    } else if (!firstValue.Equals(otherValue)) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+}  // namespace mozilla