Add m-esr52 at 52.6.0

1 files changed, 1752 insertions, 0 deletions

diff --git a/editor/libeditor/HTMLStyleEditor.cpp b/editor/libeditor/HTMLStyleEditor.cpp
new file mode 100644
index 000000000..bc7141ad3
--- /dev/null
+++ b/editor/libeditor/HTMLStyleEditor.cpp
@@ -0,0 +1,1752 @@
+/* -*- 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 "mozilla/HTMLEditor.h"
+
+#include "HTMLEditUtils.h"
+#include "TextEditUtils.h"
+#include "TypeInState.h"
+#include "mozilla/Assertions.h"
+#include "mozilla/EditorUtils.h"
+#include "mozilla/SelectionState.h"
+#include "mozilla/dom/Selection.h"
+#include "mozilla/dom/Element.h"
+#include "mozilla/mozalloc.h"
+#include "nsAString.h"
+#include "nsAttrName.h"
+#include "nsCOMPtr.h"
+#include "nsCaseTreatment.h"
+#include "nsComponentManagerUtils.h"
+#include "nsDebug.h"
+#include "nsError.h"
+#include "nsGkAtoms.h"
+#include "nsIAtom.h"
+#include "nsIContent.h"
+#include "nsIContentIterator.h"
+#include "nsIDOMElement.h"
+#include "nsIEditor.h"
+#include "nsIEditorIMESupport.h"
+#include "nsIEditRules.h"
+#include "nsNameSpaceManager.h"
+#include "nsINode.h"
+#include "nsISupportsImpl.h"
+#include "nsLiteralString.h"
+#include "nsRange.h"
+#include "nsReadableUtils.h"
+#include "nsString.h"
+#include "nsStringFwd.h"
+#include "nsTArray.h"
+#include "nsUnicharUtils.h"
+#include "nscore.h"
+
+class nsISupports;
+
+namespace mozilla {
+
+using namespace dom;
+
+static bool
+IsEmptyTextNode(HTMLEditor* aThis, nsINode* aNode)
+{
+  bool isEmptyTextNode = false;
+  return EditorBase::IsTextNode(aNode) &&
+         NS_SUCCEEDED(aThis->IsEmptyNode(aNode, &isEmptyTextNode)) &&
+         isEmptyTextNode;
+}
+
+NS_IMETHODIMP
+HTMLEditor::AddDefaultProperty(nsIAtom* aProperty,
+                               const nsAString& aAttribute,
+                               const nsAString& aValue)
+{
+  nsString outValue;
+  int32_t index;
+  nsString attr(aAttribute);
+  if (TypeInState::FindPropInList(aProperty, attr, &outValue,
+                                  mDefaultStyles, index)) {
+    PropItem *item = mDefaultStyles[index];
+    item->value = aValue;
+  } else {
+    nsString value(aValue);
+    PropItem *propItem = new PropItem(aProperty, attr, value);
+    mDefaultStyles.AppendElement(propItem);
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+HTMLEditor::RemoveDefaultProperty(nsIAtom* aProperty,
+                                  const nsAString& aAttribute,
+                                  const nsAString& aValue)
+{
+  nsString outValue;
+  int32_t index;
+  nsString attr(aAttribute);
+  if (TypeInState::FindPropInList(aProperty, attr, &outValue,
+                                  mDefaultStyles, index)) {
+    delete mDefaultStyles[index];
+    mDefaultStyles.RemoveElementAt(index);
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+HTMLEditor::RemoveAllDefaultProperties()
+{
+  size_t defcon = mDefaultStyles.Length();
+  for (size_t j = 0; j < defcon; j++) {
+    delete mDefaultStyles[j];
+  }
+  mDefaultStyles.Clear();
+  return NS_OK;
+}
+
+
+NS_IMETHODIMP
+HTMLEditor::SetInlineProperty(nsIAtom* aProperty,
+                              const nsAString& aAttribute,
+                              const nsAString& aValue)
+{
+  NS_ENSURE_TRUE(aProperty, NS_ERROR_NULL_POINTER);
+  NS_ENSURE_TRUE(mRules, NS_ERROR_NOT_INITIALIZED);
+  nsCOMPtr<nsIEditRules> rules(mRules);
+  ForceCompositionEnd();
+
+  RefPtr<Selection> selection = GetSelection();
+  NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
+
+  if (selection->Collapsed()) {
+    // Manipulating text attributes on a collapsed selection only sets state
+    // for the next text insertion
+    mTypeInState->SetProp(aProperty, aAttribute, aValue);
+    return NS_OK;
+  }
+
+  AutoEditBatch batchIt(this);
+  AutoRules beginRulesSniffing(this, EditAction::insertElement,
+                               nsIEditor::eNext);
+  AutoSelectionRestorer selectionRestorer(selection, this);
+  AutoTransactionsConserveSelection dontSpazMySelection(this);
+
+  bool cancel, handled;
+  TextRulesInfo ruleInfo(EditAction::setTextProperty);
+  // Protect the edit rules object from dying
+  nsresult rv = rules->WillDoAction(selection, &ruleInfo, &cancel, &handled);
+  NS_ENSURE_SUCCESS(rv, rv);
+  if (!cancel && !handled) {
+    // Loop through the ranges in the selection
+    uint32_t rangeCount = selection->RangeCount();
+    for (uint32_t rangeIdx = 0; rangeIdx < rangeCount; rangeIdx++) {
+      RefPtr<nsRange> range = selection->GetRangeAt(rangeIdx);
+
+      // Adjust range to include any ancestors whose children are entirely
+      // selected
+      rv = PromoteInlineRange(*range);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      // Check for easy case: both range endpoints in same text node
+      nsCOMPtr<nsINode> startNode = range->GetStartParent();
+      nsCOMPtr<nsINode> endNode = range->GetEndParent();
+      if (startNode && startNode == endNode && startNode->GetAsText()) {
+        rv = SetInlinePropertyOnTextNode(*startNode->GetAsText(),
+                                         range->StartOffset(),
+                                         range->EndOffset(),
+                                         *aProperty, &aAttribute, aValue);
+        NS_ENSURE_SUCCESS(rv, rv);
+        continue;
+      }
+
+      // Not the easy case.  Range not contained in single text node.  There
+      // are up to three phases here.  There are all the nodes reported by the
+      // subtree iterator to be processed.  And there are potentially a
+      // starting textnode and an ending textnode which are only partially
+      // contained by the range.
+
+      // Let's handle the nodes reported by the iterator.  These nodes are
+      // entirely contained in the selection range.  We build up a list of them
+      // (since doing operations on the document during iteration would perturb
+      // the iterator).
+
+      OwningNonNull<nsIContentIterator> iter = NS_NewContentSubtreeIterator();
+
+      nsTArray<OwningNonNull<nsIContent>> arrayOfNodes;
+
+      // Iterate range and build up array
+      rv = iter->Init(range);
+      // Init returns an error if there are no nodes in range.  This can easily
+      // happen with the subtree iterator if the selection doesn't contain any
+      // *whole* nodes.
+      if (NS_SUCCEEDED(rv)) {
+        for (; !iter->IsDone(); iter->Next()) {
+          OwningNonNull<nsINode> node = *iter->GetCurrentNode();
+
+          if (node->IsContent() && IsEditable(node)) {
+            arrayOfNodes.AppendElement(*node->AsContent());
+          }
+        }
+      }
+      // First check the start parent of the range to see if it needs to be
+      // separately handled (it does if it's a text node, due to how the
+      // subtree iterator works - it will not have reported it).
+      if (startNode && startNode->GetAsText() && IsEditable(startNode)) {
+        rv = SetInlinePropertyOnTextNode(*startNode->GetAsText(),
+                                         range->StartOffset(),
+                                         startNode->Length(), *aProperty,
+                                         &aAttribute, aValue);
+        NS_ENSURE_SUCCESS(rv, rv);
+      }
+
+      // Then loop through the list, set the property on each node
+      for (auto& node : arrayOfNodes) {
+        rv = SetInlinePropertyOnNode(*node, *aProperty, &aAttribute, aValue);
+        NS_ENSURE_SUCCESS(rv, rv);
+      }
+
+      // Last check the end parent of the range to see if it needs to be
+      // separately handled (it does if it's a text node, due to how the
+      // subtree iterator works - it will not have reported it).
+      if (endNode && endNode->GetAsText() && IsEditable(endNode)) {
+        rv = SetInlinePropertyOnTextNode(*endNode->GetAsText(), 0,
+                                          range->EndOffset(), *aProperty,
+                                          &aAttribute, aValue);
+        NS_ENSURE_SUCCESS(rv, rv);
+      }
+    }
+  }
+  if (!cancel) {
+    // Post-process
+    return rules->DidDoAction(selection, &ruleInfo, rv);
+  }
+  return NS_OK;
+}
+
+// Helper function for SetInlinePropertyOn*: is aNode a simple old <b>, <font>,
+// <span style="">, etc. that we can reuse instead of creating a new one?
+bool
+HTMLEditor::IsSimpleModifiableNode(nsIContent* aContent,
+                                   nsIAtom* aProperty,
+                                   const nsAString* aAttribute,
+                                   const nsAString* aValue)
+{
+  // aContent can be null, in which case we'll return false in a few lines
+  MOZ_ASSERT(aProperty);
+  MOZ_ASSERT_IF(aAttribute, aValue);
+
+  nsCOMPtr<dom::Element> element = do_QueryInterface(aContent);
+  if (!element) {
+    return false;
+  }
+
+  // First check for <b>, <i>, etc.
+  if (element->IsHTMLElement(aProperty) && !element->GetAttrCount() &&
+      (!aAttribute || aAttribute->IsEmpty())) {
+    return true;
+  }
+
+  // Special cases for various equivalencies: <strong>, <em>, <s>
+  if (!element->GetAttrCount() &&
+      ((aProperty == nsGkAtoms::b &&
+        element->IsHTMLElement(nsGkAtoms::strong)) ||
+       (aProperty == nsGkAtoms::i &&
+        element->IsHTMLElement(nsGkAtoms::em)) ||
+       (aProperty == nsGkAtoms::strike &&
+        element->IsHTMLElement(nsGkAtoms::s)))) {
+    return true;
+  }
+
+  // Now look for things like <font>
+  if (aAttribute && !aAttribute->IsEmpty()) {
+    nsCOMPtr<nsIAtom> atom = NS_Atomize(*aAttribute);
+    MOZ_ASSERT(atom);
+
+    nsString attrValue;
+    if (element->IsHTMLElement(aProperty) &&
+        IsOnlyAttribute(element, *aAttribute) &&
+        element->GetAttr(kNameSpaceID_None, atom, attrValue) &&
+        attrValue.Equals(*aValue, nsCaseInsensitiveStringComparator())) {
+      // This is not quite correct, because it excludes cases like
+      // <font face=000> being the same as <font face=#000000>.
+      // Property-specific handling is needed (bug 760211).
+      return true;
+    }
+  }
+
+  // No luck so far.  Now we check for a <span> with a single style=""
+  // attribute that sets only the style we're looking for, if this type of
+  // style supports it
+  if (!mCSSEditUtils->IsCSSEditableProperty(element, aProperty, aAttribute) ||
+      !element->IsHTMLElement(nsGkAtoms::span) ||
+      element->GetAttrCount() != 1 ||
+      !element->HasAttr(kNameSpaceID_None, nsGkAtoms::style)) {
+    return false;
+  }
+
+  // Some CSS styles are not so simple.  For instance, underline is
+  // "text-decoration: underline", which decomposes into four different text-*
+  // properties.  So for now, we just create a span, add the desired style, and
+  // see if it matches.
+  nsCOMPtr<Element> newSpan = CreateHTMLContent(nsGkAtoms::span);
+  NS_ASSERTION(newSpan, "CreateHTMLContent failed");
+  NS_ENSURE_TRUE(newSpan, false);
+  mCSSEditUtils->SetCSSEquivalentToHTMLStyle(newSpan, aProperty,
+                                             aAttribute, aValue,
+                                             /*suppress transaction*/ true);
+
+  return mCSSEditUtils->ElementsSameStyle(newSpan, element);
+}
+
+nsresult
+HTMLEditor::SetInlinePropertyOnTextNode(Text& aText,
+                                        int32_t aStartOffset,
+                                        int32_t aEndOffset,
+                                        nsIAtom& aProperty,
+                                        const nsAString* aAttribute,
+                                        const nsAString& aValue)
+{
+  if (!aText.GetParentNode() ||
+      !CanContainTag(*aText.GetParentNode(), aProperty)) {
+    return NS_OK;
+  }
+
+  // Don't need to do anything if no characters actually selected
+  if (aStartOffset == aEndOffset) {
+    return NS_OK;
+  }
+
+  // Don't need to do anything if property already set on node
+  if (mCSSEditUtils->IsCSSEditableProperty(&aText, &aProperty, aAttribute)) {
+    // The HTML styles defined by aProperty/aAttribute have a CSS equivalence
+    // for node; let's check if it carries those CSS styles
+    if (mCSSEditUtils->IsCSSEquivalentToHTMLInlineStyleSet(&aText, &aProperty,
+          aAttribute, aValue, CSSEditUtils::eComputed)) {
+      return NS_OK;
+    }
+  } else if (IsTextPropertySetByContent(&aText, &aProperty, aAttribute,
+                                        &aValue)) {
+    return NS_OK;
+  }
+
+  // Do we need to split the text node?
+  ErrorResult rv;
+  RefPtr<Text> text = &aText;
+  if (uint32_t(aEndOffset) != aText.Length()) {
+    // We need to split off back of text node
+    text = SplitNode(aText, aEndOffset, rv)->GetAsText();
+    NS_ENSURE_TRUE(!rv.Failed(), rv.StealNSResult());
+  }
+
+  if (aStartOffset) {
+    // We need to split off front of text node
+    SplitNode(*text, aStartOffset, rv);
+    NS_ENSURE_TRUE(!rv.Failed(), rv.StealNSResult());
+  }
+
+  if (aAttribute) {
+    // Look for siblings that are correct type of node
+    nsIContent* sibling = GetPriorHTMLSibling(text);
+    if (IsSimpleModifiableNode(sibling, &aProperty, aAttribute, &aValue)) {
+      // Previous sib is already right kind of inline node; slide this over
+      return MoveNode(text, sibling, -1);
+    }
+    sibling = GetNextHTMLSibling(text);
+    if (IsSimpleModifiableNode(sibling, &aProperty, aAttribute, &aValue)) {
+      // Following sib is already right kind of inline node; slide this over
+      return MoveNode(text, sibling, 0);
+    }
+  }
+
+  // Reparent the node inside inline node with appropriate {attribute,value}
+  return SetInlinePropertyOnNode(*text, aProperty, aAttribute, aValue);
+}
+
+nsresult
+HTMLEditor::SetInlinePropertyOnNodeImpl(nsIContent& aNode,
+                                        nsIAtom& aProperty,
+                                        const nsAString* aAttribute,
+                                        const nsAString& aValue)
+{
+  nsCOMPtr<nsIAtom> attrAtom = aAttribute ? NS_Atomize(*aAttribute) : nullptr;
+
+  // If this is an element that can't be contained in a span, we have to
+  // recurse to its children.
+  if (!TagCanContain(*nsGkAtoms::span, aNode)) {
+    if (aNode.HasChildren()) {
+      nsTArray<OwningNonNull<nsIContent>> arrayOfNodes;
+
+      // Populate the list.
+      for (nsCOMPtr<nsIContent> child = aNode.GetFirstChild();
+           child;
+           child = child->GetNextSibling()) {
+        if (IsEditable(child) && !IsEmptyTextNode(this, child)) {
+          arrayOfNodes.AppendElement(*child);
+        }
+      }
+
+      // Then loop through the list, set the property on each node.
+      for (auto& node : arrayOfNodes) {
+        nsresult rv = SetInlinePropertyOnNode(node, aProperty, aAttribute,
+                                              aValue);
+        NS_ENSURE_SUCCESS(rv, rv);
+      }
+    }
+    return NS_OK;
+  }
+
+  // First check if there's an adjacent sibling we can put our node into.
+  nsCOMPtr<nsIContent> previousSibling = GetPriorHTMLSibling(&aNode);
+  nsCOMPtr<nsIContent> nextSibling = GetNextHTMLSibling(&aNode);
+  if (IsSimpleModifiableNode(previousSibling, &aProperty, aAttribute, &aValue)) {
+    nsresult rv = MoveNode(&aNode, previousSibling, -1);
+    NS_ENSURE_SUCCESS(rv, rv);
+    if (IsSimpleModifiableNode(nextSibling, &aProperty, aAttribute, &aValue)) {
+      rv = JoinNodes(*previousSibling, *nextSibling);
+      NS_ENSURE_SUCCESS(rv, rv);
+    }
+    return NS_OK;
+  }
+  if (IsSimpleModifiableNode(nextSibling, &aProperty, aAttribute, &aValue)) {
+    nsresult rv = MoveNode(&aNode, nextSibling, 0);
+    NS_ENSURE_SUCCESS(rv, rv);
+    return NS_OK;
+  }
+
+  // Don't need to do anything if property already set on node
+  if (mCSSEditUtils->IsCSSEditableProperty(&aNode, &aProperty, aAttribute)) {
+    if (mCSSEditUtils->IsCSSEquivalentToHTMLInlineStyleSet(
+          &aNode, &aProperty, aAttribute, aValue, CSSEditUtils::eComputed)) {
+      return NS_OK;
+    }
+  } else if (IsTextPropertySetByContent(&aNode, &aProperty,
+                                        aAttribute, &aValue)) {
+    return NS_OK;
+  }
+
+  bool useCSS = (IsCSSEnabled() &&
+                 mCSSEditUtils->IsCSSEditableProperty(&aNode, &aProperty,
+                                                      aAttribute)) ||
+                // bgcolor is always done using CSS
+                aAttribute->EqualsLiteral("bgcolor");
+
+  if (useCSS) {
+    nsCOMPtr<dom::Element> tmp;
+    // We only add style="" to <span>s with no attributes (bug 746515).  If we
+    // don't have one, we need to make one.
+    if (aNode.IsHTMLElement(nsGkAtoms::span) &&
+        !aNode.AsElement()->GetAttrCount()) {
+      tmp = aNode.AsElement();
+    } else {
+      tmp = InsertContainerAbove(&aNode, nsGkAtoms::span);
+      NS_ENSURE_STATE(tmp);
+    }
+
+    // Add the CSS styles corresponding to the HTML style request
+    int32_t count;
+    nsresult rv =
+      mCSSEditUtils->SetCSSEquivalentToHTMLStyle(tmp->AsDOMNode(),
+                                                 &aProperty, aAttribute,
+                                                 &aValue, &count, false);
+    NS_ENSURE_SUCCESS(rv, rv);
+    return NS_OK;
+  }
+
+  // is it already the right kind of node, but with wrong attribute?
+  if (aNode.IsHTMLElement(&aProperty)) {
+    // Just set the attribute on it.
+    nsCOMPtr<nsIDOMElement> elem = do_QueryInterface(&aNode);
+    return SetAttribute(elem, *aAttribute, aValue);
+  }
+
+  // ok, chuck it in its very own container
+  nsCOMPtr<Element> tmp = InsertContainerAbove(&aNode, &aProperty, attrAtom,
+                                               &aValue);
+  NS_ENSURE_STATE(tmp);
+
+  return NS_OK;
+}
+
+nsresult
+HTMLEditor::SetInlinePropertyOnNode(nsIContent& aNode,
+                                    nsIAtom& aProperty,
+                                    const nsAString* aAttribute,
+                                    const nsAString& aValue)
+{
+  nsCOMPtr<nsIContent> previousSibling = aNode.GetPreviousSibling(),
+                       nextSibling = aNode.GetNextSibling();
+  NS_ENSURE_STATE(aNode.GetParentNode());
+  OwningNonNull<nsINode> parent = *aNode.GetParentNode();
+
+  nsresult rv = RemoveStyleInside(aNode, &aProperty, aAttribute);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (aNode.GetParentNode()) {
+    // The node is still where it was
+    return SetInlinePropertyOnNodeImpl(aNode, aProperty,
+                                       aAttribute, aValue);
+  }
+
+  // It's vanished.  Use the old siblings for reference to construct a
+  // list.  But first, verify that the previous/next siblings are still
+  // where we expect them; otherwise we have to give up.
+  if ((previousSibling && previousSibling->GetParentNode() != parent) ||
+      (nextSibling && nextSibling->GetParentNode() != parent)) {
+    return NS_ERROR_UNEXPECTED;
+  }
+  nsTArray<OwningNonNull<nsIContent>> nodesToSet;
+  nsCOMPtr<nsIContent> cur = previousSibling
+    ? previousSibling->GetNextSibling() : parent->GetFirstChild();
+  for (; cur && cur != nextSibling; cur = cur->GetNextSibling()) {
+    if (IsEditable(cur)) {
+      nodesToSet.AppendElement(*cur);
+    }
+  }
+
+  for (auto& node : nodesToSet) {
+    rv = SetInlinePropertyOnNodeImpl(node, aProperty, aAttribute, aValue);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  return NS_OK;
+}
+
+nsresult
+HTMLEditor::SplitStyleAboveRange(nsRange* inRange,
+                                 nsIAtom* aProperty,
+                                 const nsAString* aAttribute)
+{
+  NS_ENSURE_TRUE(inRange, NS_ERROR_NULL_POINTER);
+
+  nsCOMPtr<nsINode> startNode = inRange->GetStartParent();
+  int32_t startOffset = inRange->StartOffset();
+  nsCOMPtr<nsINode> endNode = inRange->GetEndParent();
+  int32_t endOffset = inRange->EndOffset();
+
+  nsCOMPtr<nsINode> origStartNode = startNode;
+
+  // split any matching style nodes above the start of range
+  {
+    AutoTrackDOMPoint tracker(mRangeUpdater, address_of(endNode), &endOffset);
+    nsresult rv =
+      SplitStyleAbovePoint(address_of(startNode), &startOffset, aProperty,
+                           aAttribute);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  // second verse, same as the first...
+  nsresult rv =
+    SplitStyleAbovePoint(address_of(endNode), &endOffset, aProperty,
+                         aAttribute);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // reset the range
+  rv = inRange->SetStart(startNode, startOffset);
+  NS_ENSURE_SUCCESS(rv, rv);
+  return inRange->SetEnd(endNode, endOffset);
+}
+
+nsresult
+HTMLEditor::SplitStyleAbovePoint(nsCOMPtr<nsINode>* aNode,
+                                 int32_t* aOffset,
+                                 // null here means we split all properties
+                                 nsIAtom* aProperty,
+                                 const nsAString* aAttribute,
+                                 nsIContent** aOutLeftNode,
+                                 nsIContent** aOutRightNode)
+{
+  NS_ENSURE_TRUE(aNode && *aNode && aOffset, NS_ERROR_NULL_POINTER);
+  NS_ENSURE_TRUE((*aNode)->IsContent(), NS_OK);
+
+  // Split any matching style nodes above the node/offset
+  OwningNonNull<nsIContent> node = *(*aNode)->AsContent();
+
+  bool useCSS = IsCSSEnabled();
+
+  bool isSet;
+  while (!IsBlockNode(node) && node->GetParent() &&
+         IsEditable(node->GetParent())) {
+    isSet = false;
+    if (useCSS && mCSSEditUtils->IsCSSEditableProperty(node, aProperty,
+                                                       aAttribute)) {
+      // The HTML style defined by aProperty/aAttribute has a CSS equivalence
+      // in this implementation for the node; let's check if it carries those
+      // CSS styles
+      nsAutoString firstValue;
+      mCSSEditUtils->IsCSSEquivalentToHTMLInlineStyleSet(GetAsDOMNode(node),
+        aProperty, aAttribute, isSet, firstValue, CSSEditUtils::eSpecified);
+    }
+    if (// node is the correct inline prop
+        (aProperty && node->IsHTMLElement(aProperty)) ||
+        // node is href - test if really <a href=...
+        (aProperty == nsGkAtoms::href && HTMLEditUtils::IsLink(node)) ||
+        // or node is any prop, and we asked to split them all
+        (!aProperty && NodeIsProperty(node)) ||
+        // or the style is specified in the style attribute
+        isSet) {
+      // Found a style node we need to split
+      int32_t offset = SplitNodeDeep(*node, *(*aNode)->AsContent(), *aOffset,
+                                     EmptyContainers::yes, aOutLeftNode,
+                                     aOutRightNode);
+      NS_ENSURE_TRUE(offset != -1, NS_ERROR_FAILURE);
+      // reset startNode/startOffset
+      *aNode = node->GetParent();
+      *aOffset = offset;
+    }
+    node = node->GetParent();
+  }
+
+  return NS_OK;
+}
+
+nsresult
+HTMLEditor::ClearStyle(nsCOMPtr<nsINode>* aNode,
+                       int32_t* aOffset,
+                       nsIAtom* aProperty,
+                       const nsAString* aAttribute)
+{
+  nsCOMPtr<nsIContent> leftNode, rightNode;
+  nsresult rv = SplitStyleAbovePoint(aNode, aOffset, aProperty,
+                                     aAttribute, getter_AddRefs(leftNode),
+                                     getter_AddRefs(rightNode));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (leftNode) {
+    bool bIsEmptyNode;
+    IsEmptyNode(leftNode, &bIsEmptyNode, false, true);
+    if (bIsEmptyNode) {
+      // delete leftNode if it became empty
+      rv = DeleteNode(leftNode);
+      NS_ENSURE_SUCCESS(rv, rv);
+    }
+  }
+  if (rightNode) {
+    nsCOMPtr<nsINode> secondSplitParent = GetLeftmostChild(rightNode);
+    // don't try to split non-containers (br's, images, hr's, etc.)
+    if (!secondSplitParent) {
+      secondSplitParent = rightNode;
+    }
+    nsCOMPtr<Element> savedBR;
+    if (!IsContainer(secondSplitParent)) {
+      if (TextEditUtils::IsBreak(secondSplitParent)) {
+        savedBR = do_QueryInterface(secondSplitParent);
+        NS_ENSURE_STATE(savedBR);
+      }
+
+      secondSplitParent = secondSplitParent->GetParentNode();
+    }
+    *aOffset = 0;
+    rv = SplitStyleAbovePoint(address_of(secondSplitParent),
+                              aOffset, aProperty, aAttribute,
+                              getter_AddRefs(leftNode),
+                              getter_AddRefs(rightNode));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    if (rightNode) {
+      bool bIsEmptyNode;
+      IsEmptyNode(rightNode, &bIsEmptyNode, false, true);
+      if (bIsEmptyNode) {
+        // delete rightNode if it became empty
+        rv = DeleteNode(rightNode);
+        NS_ENSURE_SUCCESS(rv, rv);
+      }
+    }
+
+    if (!leftNode) {
+      return NS_OK;
+    }
+
+    // should be impossible to not get a new leftnode here
+    nsCOMPtr<nsINode> newSelParent = GetLeftmostChild(leftNode);
+    if (!newSelParent) {
+      newSelParent = leftNode;
+    }
+    // If rightNode starts with a br, suck it out of right node and into
+    // leftNode.  This is so we you don't revert back to the previous style
+    // if you happen to click at the end of a line.
+    if (savedBR) {
+      rv = MoveNode(savedBR, newSelParent, 0);
+      NS_ENSURE_SUCCESS(rv, rv);
+    }
+    // remove the style on this new hierarchy
+    int32_t newSelOffset = 0;
+    {
+      // Track the point at the new hierarchy.  This is so we can know where
+      // to put the selection after we call RemoveStyleInside().
+      // RemoveStyleInside() could remove any and all of those nodes, so I
+      // have to use the range tracking system to find the right spot to put
+      // selection.
+      AutoTrackDOMPoint tracker(mRangeUpdater,
+                                address_of(newSelParent), &newSelOffset);
+      rv = RemoveStyleInside(*leftNode, aProperty, aAttribute);
+      NS_ENSURE_SUCCESS(rv, rv);
+    }
+    // reset our node offset values to the resulting new sel point
+    *aNode = newSelParent;
+    *aOffset = newSelOffset;
+  }
+
+  return NS_OK;
+}
+
+bool
+HTMLEditor::NodeIsProperty(nsINode& aNode)
+{
+  return IsContainer(&aNode) && IsEditable(&aNode) && !IsBlockNode(&aNode) &&
+         !aNode.IsHTMLElement(nsGkAtoms::a);
+}
+
+nsresult
+HTMLEditor::ApplyDefaultProperties()
+{
+  size_t defcon = mDefaultStyles.Length();
+  for (size_t j = 0; j < defcon; j++) {
+    PropItem *propItem = mDefaultStyles[j];
+    NS_ENSURE_TRUE(propItem, NS_ERROR_NULL_POINTER);
+    nsresult rv =
+      SetInlineProperty(propItem->tag, propItem->attr, propItem->value);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+  return NS_OK;
+}
+
+nsresult
+HTMLEditor::RemoveStyleInside(nsIContent& aNode,
+                              nsIAtom* aProperty,
+                              const nsAString* aAttribute,
+                              const bool aChildrenOnly /* = false */)
+{
+  if (aNode.GetAsText()) {
+    return NS_OK;
+  }
+
+  // first process the children
+  RefPtr<nsIContent> child = aNode.GetFirstChild();
+  while (child) {
+    // cache next sibling since we might remove child
+    nsCOMPtr<nsIContent> next = child->GetNextSibling();
+    nsresult rv = RemoveStyleInside(*child, aProperty, aAttribute);
+    NS_ENSURE_SUCCESS(rv, rv);
+    child = next.forget();
+  }
+
+  // then process the node itself
+  if (!aChildrenOnly &&
+       // node is prop we asked for
+      ((aProperty && aNode.NodeInfo()->NameAtom() == aProperty) ||
+       // but check for link (<a href=...)
+       (aProperty == nsGkAtoms::href && HTMLEditUtils::IsLink(&aNode)) ||
+       // and for named anchors
+       (aProperty == nsGkAtoms::name && HTMLEditUtils::IsNamedAnchor(&aNode)) ||
+       // or node is any prop and we asked for that
+       (!aProperty && NodeIsProperty(aNode)))) {
+    // if we weren't passed an attribute, then we want to
+    // remove any matching inlinestyles entirely
+    if (!aAttribute || aAttribute->IsEmpty()) {
+      NS_NAMED_LITERAL_STRING(styleAttr, "style");
+      NS_NAMED_LITERAL_STRING(classAttr, "class");
+
+      bool hasStyleAttr = aNode.HasAttr(kNameSpaceID_None, nsGkAtoms::style);
+      bool hasClassAttr = aNode.HasAttr(kNameSpaceID_None, nsGkAtoms::_class);
+      if (aProperty && (hasStyleAttr || hasClassAttr)) {
+        // aNode carries inline styles or a class attribute so we can't
+        // just remove the element... We need to create above the element
+        // a span that will carry those styles or class, then we can delete
+        // the node.
+        nsCOMPtr<Element> spanNode =
+          InsertContainerAbove(&aNode, nsGkAtoms::span);
+        NS_ENSURE_STATE(spanNode);
+        nsresult rv =
+          CloneAttribute(styleAttr, spanNode->AsDOMNode(), aNode.AsDOMNode());
+        NS_ENSURE_SUCCESS(rv, rv);
+        rv =
+          CloneAttribute(classAttr, spanNode->AsDOMNode(), aNode.AsDOMNode());
+        NS_ENSURE_SUCCESS(rv, rv);
+      }
+      nsresult rv = RemoveContainer(&aNode);
+      NS_ENSURE_SUCCESS(rv, rv);
+    } else {
+      // otherwise we just want to eliminate the attribute
+      nsCOMPtr<nsIAtom> attribute = NS_Atomize(*aAttribute);
+      if (aNode.HasAttr(kNameSpaceID_None, attribute)) {
+        // if this matching attribute is the ONLY one on the node,
+        // then remove the whole node.  Otherwise just nix the attribute.
+        if (IsOnlyAttribute(&aNode, *aAttribute)) {
+          nsresult rv = RemoveContainer(&aNode);
+          if (NS_WARN_IF(NS_FAILED(rv))) {
+            return rv;
+          }
+        } else {
+          nsCOMPtr<nsIDOMElement> elem = do_QueryInterface(&aNode);
+          NS_ENSURE_TRUE(elem, NS_ERROR_NULL_POINTER);
+          nsresult rv = RemoveAttribute(elem, *aAttribute);
+          if (NS_WARN_IF(NS_FAILED(rv))) {
+            return rv;
+          }
+        }
+      }
+    }
+  }
+
+  if (!aChildrenOnly &&
+      mCSSEditUtils->IsCSSEditableProperty(&aNode, aProperty, aAttribute)) {
+    // the HTML style defined by aProperty/aAttribute has a CSS equivalence in
+    // this implementation for the node aNode; let's check if it carries those
+    // css styles
+    nsAutoString propertyValue;
+    bool isSet = mCSSEditUtils->IsCSSEquivalentToHTMLInlineStyleSet(&aNode,
+      aProperty, aAttribute, propertyValue, CSSEditUtils::eSpecified);
+    if (isSet && aNode.IsElement()) {
+      // yes, tmp has the corresponding css declarations in its style attribute
+      // let's remove them
+      mCSSEditUtils->RemoveCSSEquivalentToHTMLStyle(aNode.AsElement(),
+                                                    aProperty,
+                                                    aAttribute,
+                                                    &propertyValue,
+                                                    false);
+      // remove the node if it is a span or font, if its style attribute is
+      // empty or absent, and if it does not have a class nor an id
+      RemoveElementIfNoStyleOrIdOrClass(*aNode.AsElement());
+    }
+  }
+
+  // Or node is big or small and we are setting font size
+  if (aChildrenOnly) {
+    return NS_OK;
+  }
+  if (aProperty == nsGkAtoms::font &&
+      (aNode.IsHTMLElement(nsGkAtoms::big) ||
+       aNode.IsHTMLElement(nsGkAtoms::small)) &&
+      aAttribute && aAttribute->LowerCaseEqualsLiteral("size")) {
+    // if we are setting font size, remove any nested bigs and smalls
+    return RemoveContainer(&aNode);
+  }
+  return NS_OK;
+}
+
+bool
+HTMLEditor::IsOnlyAttribute(const nsIContent* aContent,
+                            const nsAString& aAttribute)
+{
+  MOZ_ASSERT(aContent);
+
+  uint32_t attrCount = aContent->GetAttrCount();
+  for (uint32_t i = 0; i < attrCount; ++i) {
+    const nsAttrName* name = aContent->GetAttrNameAt(i);
+    if (!name->NamespaceEquals(kNameSpaceID_None)) {
+      return false;
+    }
+
+    nsAutoString attrString;
+    name->LocalName()->ToString(attrString);
+    // if it's the attribute we know about, or a special _moz attribute,
+    // keep looking
+    if (!attrString.Equals(aAttribute, nsCaseInsensitiveStringComparator()) &&
+        !StringBeginsWith(attrString, NS_LITERAL_STRING("_moz"))) {
+      return false;
+    }
+  }
+  // if we made it through all of them without finding a real attribute
+  // other than aAttribute, then return true
+  return true;
+}
+
+nsresult
+HTMLEditor::PromoteRangeIfStartsOrEndsInNamedAnchor(nsRange& aRange)
+{
+  // We assume that <a> is not nested.
+  nsCOMPtr<nsINode> startNode = aRange.GetStartParent();
+  int32_t startOffset = aRange.StartOffset();
+  nsCOMPtr<nsINode> endNode = aRange.GetEndParent();
+  int32_t endOffset = aRange.EndOffset();
+
+  nsCOMPtr<nsINode> parent = startNode;
+
+  while (parent && !parent->IsHTMLElement(nsGkAtoms::body) &&
+         !HTMLEditUtils::IsNamedAnchor(parent)) {
+    parent = parent->GetParentNode();
+  }
+  NS_ENSURE_TRUE(parent, NS_ERROR_NULL_POINTER);
+
+  if (HTMLEditUtils::IsNamedAnchor(parent)) {
+    startNode = parent->GetParentNode();
+    startOffset = startNode ? startNode->IndexOf(parent) : -1;
+  }
+
+  parent = endNode;
+  while (parent && !parent->IsHTMLElement(nsGkAtoms::body) &&
+         !HTMLEditUtils::IsNamedAnchor(parent)) {
+    parent = parent->GetParentNode();
+  }
+  NS_ENSURE_TRUE(parent, NS_ERROR_NULL_POINTER);
+
+  if (HTMLEditUtils::IsNamedAnchor(parent)) {
+    endNode = parent->GetParentNode();
+    endOffset = endNode ? endNode->IndexOf(parent) + 1 : 0;
+  }
+
+  nsresult rv = aRange.SetStart(startNode, startOffset);
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = aRange.SetEnd(endNode, endOffset);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return NS_OK;
+}
+
+nsresult
+HTMLEditor::PromoteInlineRange(nsRange& aRange)
+{
+  nsCOMPtr<nsINode> startNode = aRange.GetStartParent();
+  int32_t startOffset = aRange.StartOffset();
+  nsCOMPtr<nsINode> endNode = aRange.GetEndParent();
+  int32_t endOffset = aRange.EndOffset();
+
+  while (startNode && !startNode->IsHTMLElement(nsGkAtoms::body) &&
+         IsEditable(startNode) && IsAtFrontOfNode(*startNode, startOffset)) {
+    nsCOMPtr<nsINode> parent = startNode->GetParentNode();
+    NS_ENSURE_TRUE(parent, NS_ERROR_NULL_POINTER);
+    startOffset = parent->IndexOf(startNode);
+    startNode = parent;
+  }
+
+  while (endNode && !endNode->IsHTMLElement(nsGkAtoms::body) &&
+         IsEditable(endNode) && IsAtEndOfNode(*endNode, endOffset)) {
+    nsCOMPtr<nsINode> parent = endNode->GetParentNode();
+    NS_ENSURE_TRUE(parent, NS_ERROR_NULL_POINTER);
+    // We are AFTER this node
+    endOffset = 1 + parent->IndexOf(endNode);
+    endNode = parent;
+  }
+
+  nsresult rv = aRange.SetStart(startNode, startOffset);
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = aRange.SetEnd(endNode, endOffset);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return NS_OK;
+}
+
+bool
+HTMLEditor::IsAtFrontOfNode(nsINode& aNode,
+                            int32_t aOffset)
+{
+  if (!aOffset) {
+    return true;
+  }
+
+  if (IsTextNode(&aNode)) {
+    return false;
+  }
+
+  nsCOMPtr<nsIContent> firstNode = GetFirstEditableChild(aNode);
+  NS_ENSURE_TRUE(firstNode, true);
+  if (aNode.IndexOf(firstNode) < aOffset) {
+    return false;
+  }
+  return true;
+}
+
+bool
+HTMLEditor::IsAtEndOfNode(nsINode& aNode,
+                          int32_t aOffset)
+{
+  if (aOffset == (int32_t)aNode.Length()) {
+    return true;
+  }
+
+  if (IsTextNode(&aNode)) {
+    return false;
+  }
+
+  nsCOMPtr<nsIContent> lastNode = GetLastEditableChild(aNode);
+  NS_ENSURE_TRUE(lastNode, true);
+  if (aNode.IndexOf(lastNode) < aOffset) {
+    return true;
+  }
+  return false;
+}
+
+
+nsresult
+HTMLEditor::GetInlinePropertyBase(nsIAtom& aProperty,
+                                  const nsAString* aAttribute,
+                                  const nsAString* aValue,
+                                  bool* aFirst,
+                                  bool* aAny,
+                                  bool* aAll,
+                                  nsAString* outValue,
+                                  bool aCheckDefaults)
+{
+  *aAny = false;
+  *aAll = true;
+  *aFirst = false;
+  bool first = true;
+
+  RefPtr<Selection> selection = GetSelection();
+  NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
+
+  bool isCollapsed = selection->Collapsed();
+  RefPtr<nsRange> range = selection->GetRangeAt(0);
+  // XXX: Should be a while loop, to get each separate range
+  // XXX: ERROR_HANDLING can currentItem be null?
+  if (range) {
+    // For each range, set a flag
+    bool firstNodeInRange = true;
+
+    if (isCollapsed) {
+      nsCOMPtr<nsINode> collapsedNode = range->GetStartParent();
+      NS_ENSURE_TRUE(collapsedNode, NS_ERROR_FAILURE);
+      bool isSet, theSetting;
+      nsString tOutString;
+      if (aAttribute) {
+        nsString tString(*aAttribute);
+        mTypeInState->GetTypingState(isSet, theSetting, &aProperty, tString,
+                                     &tOutString);
+        if (outValue) {
+          outValue->Assign(tOutString);
+        }
+      } else {
+        mTypeInState->GetTypingState(isSet, theSetting, &aProperty);
+      }
+      if (isSet) {
+        *aFirst = *aAny = *aAll = theSetting;
+        return NS_OK;
+      }
+
+      if (mCSSEditUtils->IsCSSEditableProperty(collapsedNode, &aProperty,
+                                               aAttribute)) {
+        if (aValue) {
+          tOutString.Assign(*aValue);
+        }
+        *aFirst = *aAny = *aAll =
+          mCSSEditUtils->IsCSSEquivalentToHTMLInlineStyleSet(collapsedNode,
+              &aProperty, aAttribute, tOutString, CSSEditUtils::eComputed);
+        if (outValue) {
+          outValue->Assign(tOutString);
+        }
+        return NS_OK;
+      }
+
+      isSet = IsTextPropertySetByContent(collapsedNode, &aProperty,
+                                         aAttribute, aValue, outValue);
+      *aFirst = *aAny = *aAll = isSet;
+
+      if (!isSet && aCheckDefaults) {
+        // Style not set, but if it is a default then it will appear if content
+        // is inserted, so we should report it as set (analogous to
+        // TypeInState).
+        int32_t index;
+        if (aAttribute && TypeInState::FindPropInList(&aProperty, *aAttribute,
+                                                      outValue, mDefaultStyles,
+                                                      index)) {
+          *aFirst = *aAny = *aAll = true;
+          if (outValue) {
+            outValue->Assign(mDefaultStyles[index]->value);
+          }
+        }
+      }
+      return NS_OK;
+    }
+
+    // Non-collapsed selection
+    nsCOMPtr<nsIContentIterator> iter = NS_NewContentIterator();
+
+    nsAutoString firstValue, theValue;
+
+    nsCOMPtr<nsINode> endNode = range->GetEndParent();
+    int32_t endOffset = range->EndOffset();
+
+    for (iter->Init(range); !iter->IsDone(); iter->Next()) {
+      if (!iter->GetCurrentNode()->IsContent()) {
+        continue;
+      }
+      nsCOMPtr<nsIContent> content = iter->GetCurrentNode()->AsContent();
+
+      if (content->IsHTMLElement(nsGkAtoms::body)) {
+        break;
+      }
+
+      // just ignore any non-editable nodes
+      if (content->GetAsText() && (!IsEditable(content) ||
+                                   IsEmptyTextNode(this, content))) {
+        continue;
+      }
+      if (content->GetAsText()) {
+        if (!isCollapsed && first && firstNodeInRange) {
+          firstNodeInRange = false;
+          if (range->StartOffset() == (int32_t)content->Length()) {
+            continue;
+          }
+        } else if (content == endNode && !endOffset) {
+          continue;
+        }
+      } else if (content->IsElement()) {
+        // handle non-text leaf nodes here
+        continue;
+      }
+
+      bool isSet = false;
+      if (first) {
+        if (mCSSEditUtils->IsCSSEditableProperty(content, &aProperty,
+                                                 aAttribute)) {
+          // The HTML styles defined by aProperty/aAttribute have a CSS
+          // equivalence in this implementation for node; let's check if it
+          // carries those CSS styles
+          if (aValue) {
+            firstValue.Assign(*aValue);
+          }
+          isSet = mCSSEditUtils->IsCSSEquivalentToHTMLInlineStyleSet(content,
+              &aProperty, aAttribute, firstValue, CSSEditUtils::eComputed);
+        } else {
+          isSet = IsTextPropertySetByContent(content, &aProperty, aAttribute,
+                                             aValue, &firstValue);
+        }
+        *aFirst = isSet;
+        first = false;
+        if (outValue) {
+          *outValue = firstValue;
+        }
+      } else {
+        if (mCSSEditUtils->IsCSSEditableProperty(content, &aProperty,
+                                                 aAttribute)) {
+          // The HTML styles defined by aProperty/aAttribute have a CSS
+          // equivalence in this implementation for node; let's check if it
+          // carries those CSS styles
+          if (aValue) {
+            theValue.Assign(*aValue);
+          }
+          isSet = mCSSEditUtils->IsCSSEquivalentToHTMLInlineStyleSet(content,
+              &aProperty, aAttribute, theValue, CSSEditUtils::eComputed);
+        } else {
+          isSet = IsTextPropertySetByContent(content, &aProperty, aAttribute,
+                                             aValue, &theValue);
+        }
+        if (firstValue != theValue) {
+          *aAll = false;
+        }
+      }
+
+      if (isSet) {
+        *aAny = true;
+      } else {
+        *aAll = false;
+      }
+    }
+  }
+  if (!*aAny) {
+    // make sure that if none of the selection is set, we don't report all is
+    // set
+    *aAll = false;
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+HTMLEditor::GetInlineProperty(nsIAtom* aProperty,
+                              const nsAString& aAttribute,
+                              const nsAString& aValue,
+                              bool* aFirst,
+                              bool* aAny,
+                              bool* aAll)
+{
+  NS_ENSURE_TRUE(aProperty && aFirst && aAny && aAll, NS_ERROR_NULL_POINTER);
+  const nsAString *att = nullptr;
+  if (!aAttribute.IsEmpty())
+    att = &aAttribute;
+  const nsAString *val = nullptr;
+  if (!aValue.IsEmpty())
+    val = &aValue;
+  return GetInlinePropertyBase(*aProperty, att, val, aFirst, aAny, aAll, nullptr);
+}
+
+NS_IMETHODIMP
+HTMLEditor::GetInlinePropertyWithAttrValue(nsIAtom* aProperty,
+                                           const nsAString& aAttribute,
+                                           const nsAString& aValue,
+                                           bool* aFirst,
+                                           bool* aAny,
+                                           bool* aAll,
+                                           nsAString& outValue)
+{
+  NS_ENSURE_TRUE(aProperty && aFirst && aAny && aAll, NS_ERROR_NULL_POINTER);
+  const nsAString *att = nullptr;
+  if (!aAttribute.IsEmpty())
+    att = &aAttribute;
+  const nsAString *val = nullptr;
+  if (!aValue.IsEmpty())
+    val = &aValue;
+  return GetInlinePropertyBase(*aProperty, att, val, aFirst, aAny, aAll, &outValue);
+}
+
+NS_IMETHODIMP
+HTMLEditor::RemoveAllInlineProperties()
+{
+  AutoEditBatch batchIt(this);
+  AutoRules beginRulesSniffing(this, EditAction::resetTextProperties,
+                               nsIEditor::eNext);
+
+  nsresult rv = RemoveInlinePropertyImpl(nullptr, nullptr);
+  NS_ENSURE_SUCCESS(rv, rv);
+  return ApplyDefaultProperties();
+}
+
+NS_IMETHODIMP
+HTMLEditor::RemoveInlineProperty(nsIAtom* aProperty,
+                                 const nsAString& aAttribute)
+{
+  return RemoveInlinePropertyImpl(aProperty, &aAttribute);
+}
+
+nsresult
+HTMLEditor::RemoveInlinePropertyImpl(nsIAtom* aProperty,
+                                     const nsAString* aAttribute)
+{
+  MOZ_ASSERT_IF(aProperty, aAttribute);
+  NS_ENSURE_TRUE(mRules, NS_ERROR_NOT_INITIALIZED);
+  ForceCompositionEnd();
+
+  RefPtr<Selection> selection = GetSelection();
+  NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
+
+  if (selection->Collapsed()) {
+    // Manipulating text attributes on a collapsed selection only sets state
+    // for the next text insertion
+
+    // For links, aProperty uses "href", use "a" instead
+    if (aProperty == nsGkAtoms::href || aProperty == nsGkAtoms::name) {
+      aProperty = nsGkAtoms::a;
+    }
+
+    if (aProperty) {
+      mTypeInState->ClearProp(aProperty, *aAttribute);
+    } else {
+      mTypeInState->ClearAllProps();
+    }
+    return NS_OK;
+  }
+
+  AutoEditBatch batchIt(this);
+  AutoRules beginRulesSniffing(this, EditAction::removeTextProperty,
+                               nsIEditor::eNext);
+  AutoSelectionRestorer selectionRestorer(selection, this);
+  AutoTransactionsConserveSelection dontSpazMySelection(this);
+
+  bool cancel, handled;
+  TextRulesInfo ruleInfo(EditAction::removeTextProperty);
+  // Protect the edit rules object from dying
+  nsCOMPtr<nsIEditRules> rules(mRules);
+  nsresult rv = rules->WillDoAction(selection, &ruleInfo, &cancel, &handled);
+  NS_ENSURE_SUCCESS(rv, rv);
+  if (!cancel && !handled) {
+    // Loop through the ranges in the selection
+    uint32_t rangeCount = selection->RangeCount();
+    // Since ranges might be modified by SplitStyleAboveRange, we need hold
+    // current ranges
+    AutoTArray<OwningNonNull<nsRange>, 8> arrayOfRanges;
+    for (uint32_t rangeIdx = 0; rangeIdx < rangeCount; ++rangeIdx) {
+      arrayOfRanges.AppendElement(*selection->GetRangeAt(rangeIdx));
+    }
+    for (auto& range : arrayOfRanges) {
+      if (aProperty == nsGkAtoms::name) {
+        // Promote range if it starts or end in a named anchor and we want to
+        // remove named anchors
+        rv = PromoteRangeIfStartsOrEndsInNamedAnchor(range);
+        if (NS_WARN_IF(NS_FAILED(rv))) {
+          return rv;
+        }
+      } else {
+        // Adjust range to include any ancestors whose children are entirely
+        // selected
+        rv = PromoteInlineRange(range);
+        if (NS_WARN_IF(NS_FAILED(rv))) {
+          return rv;
+        }
+      }
+
+      // Remove this style from ancestors of our range endpoints, splitting
+      // them as appropriate
+      rv = SplitStyleAboveRange(range, aProperty, aAttribute);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      // Check for easy case: both range endpoints in same text node
+      nsCOMPtr<nsINode> startNode = range->GetStartParent();
+      nsCOMPtr<nsINode> endNode = range->GetEndParent();
+      if (startNode && startNode == endNode && startNode->GetAsText()) {
+        // We're done with this range!
+        if (IsCSSEnabled() &&
+            mCSSEditUtils->IsCSSEditableProperty(startNode, aProperty,
+                                                 aAttribute)) {
+          // The HTML style defined by aProperty/aAttribute has a CSS
+          // equivalence in this implementation for startNode
+          if (mCSSEditUtils->IsCSSEquivalentToHTMLInlineStyleSet(startNode,
+                aProperty, aAttribute, EmptyString(),
+                CSSEditUtils::eComputed)) {
+            // startNode's computed style indicates the CSS equivalence to the
+            // HTML style to remove is applied; but we found no element in the
+            // ancestors of startNode carrying specified styles; assume it
+            // comes from a rule and try to insert a span "inverting" the style
+            if (mCSSEditUtils->IsCSSInvertible(*aProperty, aAttribute)) {
+              NS_NAMED_LITERAL_STRING(value, "-moz-editor-invert-value");
+              SetInlinePropertyOnTextNode(*startNode->GetAsText(),
+                                          range->StartOffset(),
+                                          range->EndOffset(), *aProperty,
+                                          aAttribute, value);
+            }
+          }
+        }
+      } else {
+        // Not the easy case.  Range not contained in single text node.
+        nsCOMPtr<nsIContentIterator> iter = NS_NewContentSubtreeIterator();
+
+        nsTArray<OwningNonNull<nsIContent>> arrayOfNodes;
+
+        // Iterate range and build up array
+        for (iter->Init(range); !iter->IsDone(); iter->Next()) {
+          nsCOMPtr<nsINode> node = iter->GetCurrentNode();
+          NS_ENSURE_TRUE(node, NS_ERROR_FAILURE);
+
+          if (IsEditable(node) && node->IsContent()) {
+            arrayOfNodes.AppendElement(*node->AsContent());
+          }
+        }
+
+        // Loop through the list, remove the property on each node
+        for (auto& node : arrayOfNodes) {
+          rv = RemoveStyleInside(node, aProperty, aAttribute);
+          NS_ENSURE_SUCCESS(rv, rv);
+          if (IsCSSEnabled() &&
+              mCSSEditUtils->IsCSSEditableProperty(node, aProperty,
+                                                   aAttribute) &&
+              mCSSEditUtils->IsCSSEquivalentToHTMLInlineStyleSet(node,
+                  aProperty, aAttribute, EmptyString(),
+                  CSSEditUtils::eComputed) &&
+              // startNode's computed style indicates the CSS equivalence to
+              // the HTML style to remove is applied; but we found no element
+              // in the ancestors of startNode carrying specified styles;
+              // assume it comes from a rule and let's try to insert a span
+              // "inverting" the style
+              mCSSEditUtils->IsCSSInvertible(*aProperty, aAttribute)) {
+            NS_NAMED_LITERAL_STRING(value, "-moz-editor-invert-value");
+            SetInlinePropertyOnNode(node, *aProperty, aAttribute, value);
+          }
+        }
+      }
+    }
+  }
+  if (!cancel) {
+    // Post-process
+    rv = rules->DidDoAction(selection, &ruleInfo, rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+HTMLEditor::IncreaseFontSize()
+{
+  return RelativeFontChange(FontSize::incr);
+}
+
+NS_IMETHODIMP
+HTMLEditor::DecreaseFontSize()
+{
+  return RelativeFontChange(FontSize::decr);
+}
+
+nsresult
+HTMLEditor::RelativeFontChange(FontSize aDir)
+{
+  ForceCompositionEnd();
+
+  // Get the selection
+  RefPtr<Selection> selection = GetSelection();
+  NS_ENSURE_TRUE(selection, NS_ERROR_FAILURE);
+  // If selection is collapsed, set typing state
+  if (selection->Collapsed()) {
+    nsIAtom& atom = aDir == FontSize::incr ? *nsGkAtoms::big :
+                                             *nsGkAtoms::small;
+
+    // Let's see in what kind of element the selection is
+    NS_ENSURE_TRUE(selection->RangeCount() &&
+                   selection->GetRangeAt(0)->GetStartParent(), NS_OK);
+    OwningNonNull<nsINode> selectedNode =
+      *selection->GetRangeAt(0)->GetStartParent();
+    if (IsTextNode(selectedNode)) {
+      NS_ENSURE_TRUE(selectedNode->GetParentNode(), NS_OK);
+      selectedNode = *selectedNode->GetParentNode();
+    }
+    if (!CanContainTag(selectedNode, atom)) {
+      return NS_OK;
+    }
+
+    // Manipulating text attributes on a collapsed selection only sets state
+    // for the next text insertion
+    mTypeInState->SetProp(&atom, EmptyString(), EmptyString());
+    return NS_OK;
+  }
+
+  // Wrap with txn batching, rules sniffing, and selection preservation code
+  AutoEditBatch batchIt(this);
+  AutoRules beginRulesSniffing(this, EditAction::setTextProperty,
+                               nsIEditor::eNext);
+  AutoSelectionRestorer selectionRestorer(selection, this);
+  AutoTransactionsConserveSelection dontSpazMySelection(this);
+
+  // Loop through the ranges in the selection
+  uint32_t rangeCount = selection->RangeCount();
+  for (uint32_t rangeIdx = 0; rangeIdx < rangeCount; ++rangeIdx) {
+    RefPtr<nsRange> range = selection->GetRangeAt(rangeIdx);
+
+    // Adjust range to include any ancestors with entirely selected children
+    nsresult rv = PromoteInlineRange(*range);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    // Check for easy case: both range endpoints in same text node
+    nsCOMPtr<nsINode> startNode = range->GetStartParent();
+    nsCOMPtr<nsINode> endNode = range->GetEndParent();
+    if (startNode == endNode && IsTextNode(startNode)) {
+      rv = RelativeFontChangeOnTextNode(aDir, *startNode->GetAsText(),
+                                        range->StartOffset(),
+                                        range->EndOffset());
+      NS_ENSURE_SUCCESS(rv, rv);
+    } else {
+      // Not the easy case.  Range not contained in single text node.  There
+      // are up to three phases here.  There are all the nodes reported by the
+      // subtree iterator to be processed.  And there are potentially a
+      // starting textnode and an ending textnode which are only partially
+      // contained by the range.
+
+      // Let's handle the nodes reported by the iterator.  These nodes are
+      // entirely contained in the selection range.  We build up a list of them
+      // (since doing operations on the document during iteration would perturb
+      // the iterator).
+
+      OwningNonNull<nsIContentIterator> iter = NS_NewContentSubtreeIterator();
+
+      // Iterate range and build up array
+      rv = iter->Init(range);
+      if (NS_SUCCEEDED(rv)) {
+        nsTArray<OwningNonNull<nsIContent>> arrayOfNodes;
+        for (; !iter->IsDone(); iter->Next()) {
+          NS_ENSURE_TRUE(iter->GetCurrentNode()->IsContent(), NS_ERROR_FAILURE);
+          OwningNonNull<nsIContent> node = *iter->GetCurrentNode()->AsContent();
+
+          if (IsEditable(node)) {
+            arrayOfNodes.AppendElement(node);
+          }
+        }
+
+        // Now that we have the list, do the font size change on each node
+        for (auto& node : arrayOfNodes) {
+          rv = RelativeFontChangeOnNode(aDir == FontSize::incr ? +1 : -1, node);
+          NS_ENSURE_SUCCESS(rv, rv);
+        }
+      }
+      // Now check the start and end parents of the range to see if they need
+      // to be separately handled (they do if they are text nodes, due to how
+      // the subtree iterator works - it will not have reported them).
+      if (IsTextNode(startNode) && IsEditable(startNode)) {
+        rv = RelativeFontChangeOnTextNode(aDir, *startNode->GetAsText(),
+                                          range->StartOffset(),
+                                          startNode->Length());
+        NS_ENSURE_SUCCESS(rv, rv);
+      }
+      if (IsTextNode(endNode) && IsEditable(endNode)) {
+        rv = RelativeFontChangeOnTextNode(aDir, *endNode->GetAsText(), 0,
+                                          range->EndOffset());
+        NS_ENSURE_SUCCESS(rv, rv);
+      }
+    }
+  }
+
+  return NS_OK;
+}
+
+nsresult
+HTMLEditor::RelativeFontChangeOnTextNode(FontSize aDir,
+                                         Text& aTextNode,
+                                         int32_t aStartOffset,
+                                         int32_t aEndOffset)
+{
+  // Don't need to do anything if no characters actually selected
+  if (aStartOffset == aEndOffset) {
+    return NS_OK;
+  }
+
+  if (!aTextNode.GetParentNode() ||
+      !CanContainTag(*aTextNode.GetParentNode(), *nsGkAtoms::big)) {
+    return NS_OK;
+  }
+
+  OwningNonNull<nsIContent> node = aTextNode;
+
+  // Do we need to split the text node?
+
+  // -1 is a magic value meaning to the end of node
+  if (aEndOffset == -1) {
+    aEndOffset = aTextNode.Length();
+  }
+
+  ErrorResult rv;
+  if ((uint32_t)aEndOffset != aTextNode.Length()) {
+    // We need to split off back of text node
+    node = SplitNode(node, aEndOffset, rv);
+    NS_ENSURE_TRUE(!rv.Failed(), rv.StealNSResult());
+  }
+  if (aStartOffset) {
+    // We need to split off front of text node
+    SplitNode(node, aStartOffset, rv);
+    NS_ENSURE_TRUE(!rv.Failed(), rv.StealNSResult());
+  }
+
+  // Look for siblings that are correct type of node
+  nsIAtom* nodeType = aDir == FontSize::incr ? nsGkAtoms::big
+                                             : nsGkAtoms::small;
+  nsCOMPtr<nsIContent> sibling = GetPriorHTMLSibling(node);
+  if (sibling && sibling->IsHTMLElement(nodeType)) {
+    // Previous sib is already right kind of inline node; slide this over
+    nsresult rv = MoveNode(node, sibling, -1);
+    NS_ENSURE_SUCCESS(rv, rv);
+    return NS_OK;
+  }
+  sibling = GetNextHTMLSibling(node);
+  if (sibling && sibling->IsHTMLElement(nodeType)) {
+    // Following sib is already right kind of inline node; slide this over
+    nsresult rv = MoveNode(node, sibling, 0);
+    NS_ENSURE_SUCCESS(rv, rv);
+    return NS_OK;
+  }
+
+  // Else reparent the node inside font node with appropriate relative size
+  nsCOMPtr<Element> newElement = InsertContainerAbove(node, nodeType);
+  NS_ENSURE_STATE(newElement);
+
+  return NS_OK;
+}
+
+nsresult
+HTMLEditor::RelativeFontChangeHelper(int32_t aSizeChange,
+                                     nsINode* aNode)
+{
+  MOZ_ASSERT(aNode);
+
+  /*  This routine looks for all the font nodes in the tree rooted by aNode,
+      including aNode itself, looking for font nodes that have the size attr
+      set.  Any such nodes need to have big or small put inside them, since
+      they override any big/small that are above them.
+  */
+
+  // Can only change font size by + or - 1
+  if (aSizeChange != 1 && aSizeChange != -1) {
+    return NS_ERROR_ILLEGAL_VALUE;
+  }
+
+  // If this is a font node with size, put big/small inside it.
+  if (aNode->IsHTMLElement(nsGkAtoms::font) &&
+      aNode->AsElement()->HasAttr(kNameSpaceID_None, nsGkAtoms::size)) {
+    // Cycle through children and adjust relative font size.
+    for (uint32_t i = aNode->GetChildCount(); i--; ) {
+      nsresult rv = RelativeFontChangeOnNode(aSizeChange, aNode->GetChildAt(i));
+      NS_ENSURE_SUCCESS(rv, rv);
+    }
+
+    // RelativeFontChangeOnNode already calls us recursively,
+    // so we don't need to check our children again.
+    return NS_OK;
+  }
+
+  // Otherwise cycle through the children.
+  for (uint32_t i = aNode->GetChildCount(); i--; ) {
+    nsresult rv = RelativeFontChangeHelper(aSizeChange, aNode->GetChildAt(i));
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  return NS_OK;
+}
+
+nsresult
+HTMLEditor::RelativeFontChangeOnNode(int32_t aSizeChange,
+                                     nsIContent* aNode)
+{
+  MOZ_ASSERT(aNode);
+  // Can only change font size by + or - 1
+  if (aSizeChange != 1 && aSizeChange != -1) {
+    return NS_ERROR_ILLEGAL_VALUE;
+  }
+
+  nsIAtom* atom;
+  if (aSizeChange == 1) {
+    atom = nsGkAtoms::big;
+  } else {
+    atom = nsGkAtoms::small;
+  }
+
+  // Is it the opposite of what we want?
+  if ((aSizeChange == 1 && aNode->IsHTMLElement(nsGkAtoms::small)) ||
+       (aSizeChange == -1 && aNode->IsHTMLElement(nsGkAtoms::big))) {
+    // first populate any nested font tags that have the size attr set
+    nsresult rv = RelativeFontChangeHelper(aSizeChange, aNode);
+    NS_ENSURE_SUCCESS(rv, rv);
+    // in that case, just remove this node and pull up the children
+    return RemoveContainer(aNode);
+  }
+
+  // can it be put inside a "big" or "small"?
+  if (TagCanContain(*atom, *aNode)) {
+    // first populate any nested font tags that have the size attr set
+    nsresult rv = RelativeFontChangeHelper(aSizeChange, aNode);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    // ok, chuck it in.
+    // first look at siblings of aNode for matching bigs or smalls.
+    // if we find one, move aNode into it.
+    nsIContent* sibling = GetPriorHTMLSibling(aNode);
+    if (sibling && sibling->IsHTMLElement(atom)) {
+      // previous sib is already right kind of inline node; slide this over into it
+      return MoveNode(aNode, sibling, -1);
+    }
+
+    sibling = GetNextHTMLSibling(aNode);
+    if (sibling && sibling->IsHTMLElement(atom)) {
+      // following sib is already right kind of inline node; slide this over into it
+      return MoveNode(aNode, sibling, 0);
+    }
+
+    // else insert it above aNode
+    nsCOMPtr<Element> newElement = InsertContainerAbove(aNode, atom);
+    NS_ENSURE_STATE(newElement);
+
+    return NS_OK;
+  }
+
+  // none of the above?  then cycle through the children.
+  // MOOSE: we should group the children together if possible
+  // into a single "big" or "small".  For the moment they are
+  // each getting their own.
+  for (uint32_t i = aNode->GetChildCount(); i--; ) {
+    nsresult rv = RelativeFontChangeOnNode(aSizeChange, aNode->GetChildAt(i));
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+HTMLEditor::GetFontFaceState(bool* aMixed,
+                             nsAString& outFace)
+{
+  NS_ENSURE_TRUE(aMixed, NS_ERROR_FAILURE);
+  *aMixed = true;
+  outFace.Truncate();
+
+  bool first, any, all;
+
+  NS_NAMED_LITERAL_STRING(attr, "face");
+  nsresult rv =
+    GetInlinePropertyBase(*nsGkAtoms::font, &attr, nullptr, &first, &any,
+                          &all, &outFace);
+  NS_ENSURE_SUCCESS(rv, rv);
+  if (any && !all) {
+    return NS_OK; // mixed
+  }
+  if (all) {
+    *aMixed = false;
+    return NS_OK;
+  }
+
+  // if there is no font face, check for tt
+  rv = GetInlinePropertyBase(*nsGkAtoms::tt, nullptr, nullptr, &first, &any,
+                             &all,nullptr);
+  NS_ENSURE_SUCCESS(rv, rv);
+  if (any && !all) {
+    return rv; // mixed
+  }
+  if (all) {
+    *aMixed = false;
+    outFace.AssignLiteral("tt");
+  }
+
+  if (!any) {
+    // there was no font face attrs of any kind.  We are in normal font.
+    outFace.Truncate();
+    *aMixed = false;
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+HTMLEditor::GetFontColorState(bool* aMixed,
+                              nsAString& aOutColor)
+{
+  NS_ENSURE_TRUE(aMixed, NS_ERROR_NULL_POINTER);
+  *aMixed = true;
+  aOutColor.Truncate();
+
+  NS_NAMED_LITERAL_STRING(colorStr, "color");
+  bool first, any, all;
+
+  nsresult rv =
+    GetInlinePropertyBase(*nsGkAtoms::font, &colorStr, nullptr, &first,
+                          &any, &all, &aOutColor);
+  NS_ENSURE_SUCCESS(rv, rv);
+  if (any && !all) {
+    return NS_OK; // mixed
+  }
+  if (all) {
+    *aMixed = false;
+    return NS_OK;
+  }
+
+  if (!any) {
+    // there was no font color attrs of any kind..
+    aOutColor.Truncate();
+    *aMixed = false;
+  }
+  return NS_OK;
+}
+
+// the return value is true only if the instance of the HTML editor we created
+// can handle CSS styles (for instance, Composer can, Messenger can't) and if
+// the CSS preference is checked
+nsresult
+HTMLEditor::GetIsCSSEnabled(bool* aIsCSSEnabled)
+{
+  *aIsCSSEnabled = IsCSSEnabled();
+  return NS_OK;
+}
+
+static bool
+HasNonEmptyAttribute(Element* aElement,
+                     nsIAtom* aName)
+{
+  MOZ_ASSERT(aElement);
+
+  nsAutoString value;
+  return aElement->GetAttr(kNameSpaceID_None, aName, value) && !value.IsEmpty();
+}
+
+bool
+HTMLEditor::HasStyleOrIdOrClass(Element* aElement)
+{
+  MOZ_ASSERT(aElement);
+
+  // remove the node if its style attribute is empty or absent,
+  // and if it does not have a class nor an id
+  return HasNonEmptyAttribute(aElement, nsGkAtoms::style) ||
+         HasNonEmptyAttribute(aElement, nsGkAtoms::_class) ||
+         HasNonEmptyAttribute(aElement, nsGkAtoms::id);
+}
+
+nsresult
+HTMLEditor::RemoveElementIfNoStyleOrIdOrClass(Element& aElement)
+{
+  // early way out if node is not the right kind of element
+  if ((!aElement.IsHTMLElement(nsGkAtoms::span) &&
+       !aElement.IsHTMLElement(nsGkAtoms::font)) ||
+      HasStyleOrIdOrClass(&aElement)) {
+    return NS_OK;
+  }
+
+  return RemoveContainer(&aElement);
+}
+
+} // namespace mozilla