Adding upstream version 115.7.0esr.upstream/115.7.0esrupstream

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

1 files changed, 503 insertions, 0 deletions

diff --git a/editor/libeditor/PendingStyles.cpp b/editor/libeditor/PendingStyles.cpp
new file mode 100644
index 0000000000..12666c5289
--- /dev/null
+++ b/editor/libeditor/PendingStyles.cpp
@@ -0,0 +1,503 @@
+/* -*- 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 "PendingStyles.h"
+
+#include <stddef.h>
+
+#include "EditAction.h"
+#include "EditorBase.h"
+#include "HTMLEditHelpers.h"  // for EditorInlineStyle, EditorInlineStyleAndValue
+#include "HTMLEditor.h"
+#include "HTMLEditUtils.h"
+
+#include "mozilla/mozalloc.h"
+#include "mozilla/dom/AncestorIterator.h"
+#include "mozilla/dom/MouseEvent.h"
+#include "mozilla/dom/Selection.h"
+
+#include "nsDebug.h"
+#include "nsError.h"
+#include "nsGkAtoms.h"
+#include "nsINode.h"
+#include "nsISupports.h"
+#include "nsISupportsImpl.h"
+#include "nsReadableUtils.h"
+#include "nsString.h"
+#include "nsTArray.h"
+
+namespace mozilla {
+
+using namespace dom;
+
+/********************************************************************
+ * mozilla::PendingStyle
+ *******************************************************************/
+
+EditorInlineStyle PendingStyle::ToInlineStyle() const {
+  return mTag ? EditorInlineStyle(*mTag, mAttribute)
+              : EditorInlineStyle::RemoveAllStyles();
+}
+
+EditorInlineStyleAndValue PendingStyle::ToInlineStyleAndValue() const {
+  MOZ_ASSERT(mTag);
+  return mAttribute ? EditorInlineStyleAndValue(*mTag, *mAttribute,
+                                                mAttributeValueOrCSSValue)
+                    : EditorInlineStyleAndValue(*mTag);
+}
+
+/********************************************************************
+ * mozilla::PendingStyleCache
+ *******************************************************************/
+
+EditorInlineStyle PendingStyleCache::ToInlineStyle() const {
+  return EditorInlineStyle(mTag, mAttribute);
+}
+
+/********************************************************************
+ * mozilla::PendingStyles
+ *******************************************************************/
+
+NS_IMPL_CYCLE_COLLECTION_CLASS(PendingStyles)
+
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(PendingStyles)
+  NS_IMPL_CYCLE_COLLECTION_UNLINK(mLastSelectionPoint)
+NS_IMPL_CYCLE_COLLECTION_UNLINK_END
+
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(PendingStyles)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mLastSelectionPoint)
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
+
+nsresult PendingStyles::UpdateSelState(const HTMLEditor& aHTMLEditor) {
+  if (!aHTMLEditor.SelectionRef().IsCollapsed()) {
+    return NS_OK;
+  }
+
+  mLastSelectionPoint =
+      aHTMLEditor.GetFirstSelectionStartPoint<EditorDOMPoint>();
+  if (!mLastSelectionPoint.IsSet()) {
+    return NS_ERROR_FAILURE;
+  }
+  // We need to store only offset because referring child may be removed by
+  // we'll check the point later.
+  AutoEditorDOMPointChildInvalidator saveOnlyOffset(mLastSelectionPoint);
+  return NS_OK;
+}
+
+void PendingStyles::PreHandleMouseEvent(const MouseEvent& aMouseDownOrUpEvent) {
+  MOZ_ASSERT(aMouseDownOrUpEvent.WidgetEventPtr()->mMessage == eMouseDown ||
+             aMouseDownOrUpEvent.WidgetEventPtr()->mMessage == eMouseUp);
+  bool& eventFiredInLinkElement =
+      aMouseDownOrUpEvent.WidgetEventPtr()->mMessage == eMouseDown
+          ? mMouseDownFiredInLinkElement
+          : mMouseUpFiredInLinkElement;
+  eventFiredInLinkElement = false;
+  if (aMouseDownOrUpEvent.DefaultPrevented()) {
+    return;
+  }
+  // If mouse button is down or up in a link element, we shouldn't unlink
+  // it when we get a notification of selection change.
+  EventTarget* target = aMouseDownOrUpEvent.GetExplicitOriginalTarget();
+  if (NS_WARN_IF(!target)) {
+    return;
+  }
+  nsIContent* targetContent = nsIContent::FromEventTarget(target);
+  if (NS_WARN_IF(!targetContent)) {
+    return;
+  }
+  eventFiredInLinkElement =
+      HTMLEditUtils::IsContentInclusiveDescendantOfLink(*targetContent);
+}
+
+void PendingStyles::PreHandleSelectionChangeCommand(Command aCommand) {
+  mLastSelectionCommand = aCommand;
+}
+
+void PendingStyles::PostHandleSelectionChangeCommand(
+    const HTMLEditor& aHTMLEditor, Command aCommand) {
+  if (mLastSelectionCommand != aCommand) {
+    return;
+  }
+
+  // If `OnSelectionChange()` hasn't been called for `mLastSelectionCommand`,
+  // it means that it didn't cause selection change.
+  if (!aHTMLEditor.SelectionRef().IsCollapsed() ||
+      !aHTMLEditor.SelectionRef().RangeCount()) {
+    return;
+  }
+
+  const auto caretPoint =
+      aHTMLEditor.GetFirstSelectionStartPoint<EditorRawDOMPoint>();
+  if (NS_WARN_IF(!caretPoint.IsSet())) {
+    return;
+  }
+
+  if (!HTMLEditUtils::IsPointAtEdgeOfLink(caretPoint)) {
+    return;
+  }
+
+  // If all styles are cleared or link style is explicitly set, we
+  // shouldn't reset them without caret move.
+  if (AreAllStylesCleared() || IsLinkStyleSet()) {
+    return;
+  }
+  // And if non-link styles are cleared or some styles are set, we
+  // shouldn't reset them too, but we may need to change the link
+  // style.
+  if (AreSomeStylesSet() ||
+      (AreSomeStylesCleared() && !IsOnlyLinkStyleCleared())) {
+    ClearLinkAndItsSpecifiedStyle();
+    return;
+  }
+
+  Reset();
+  ClearLinkAndItsSpecifiedStyle();
+}
+
+void PendingStyles::OnSelectionChange(const HTMLEditor& aHTMLEditor,
+                                      int16_t aReason) {
+  // XXX: Selection currently generates bogus selection changed notifications
+  // XXX: (bug 140303). It can notify us when the selection hasn't actually
+  // XXX: changed, and it notifies us more than once for the same change.
+  // XXX:
+  // XXX: The following code attempts to work around the bogus notifications,
+  // XXX: and should probably be removed once bug 140303 is fixed.
+  // XXX:
+  // XXX: This code temporarily fixes the problem where clicking the mouse in
+  // XXX: the same location clears the type-in-state.
+
+  const bool causedByFrameSelectionMoveCaret =
+      (aReason & (nsISelectionListener::KEYPRESS_REASON |
+                  nsISelectionListener::COLLAPSETOSTART_REASON |
+                  nsISelectionListener::COLLAPSETOEND_REASON)) &&
+      !(aReason & nsISelectionListener::JS_REASON);
+
+  Command lastSelectionCommand = mLastSelectionCommand;
+  if (causedByFrameSelectionMoveCaret) {
+    mLastSelectionCommand = Command::DoNothing;
+  }
+
+  bool mouseEventFiredInLinkElement = false;
+  if (aReason & (nsISelectionListener::MOUSEDOWN_REASON |
+                 nsISelectionListener::MOUSEUP_REASON)) {
+    MOZ_ASSERT((aReason & (nsISelectionListener::MOUSEDOWN_REASON |
+                           nsISelectionListener::MOUSEUP_REASON)) !=
+               (nsISelectionListener::MOUSEDOWN_REASON |
+                nsISelectionListener::MOUSEUP_REASON));
+    bool& eventFiredInLinkElement =
+        aReason & nsISelectionListener::MOUSEDOWN_REASON
+            ? mMouseDownFiredInLinkElement
+            : mMouseUpFiredInLinkElement;
+    mouseEventFiredInLinkElement = eventFiredInLinkElement;
+    eventFiredInLinkElement = false;
+  }
+
+  bool unlink = false;
+  bool resetAllStyles = true;
+  if (aHTMLEditor.SelectionRef().IsCollapsed() &&
+      aHTMLEditor.SelectionRef().RangeCount()) {
+    const auto selectionStartPoint =
+        aHTMLEditor.GetFirstSelectionStartPoint<EditorDOMPoint>();
+    if (MOZ_UNLIKELY(NS_WARN_IF(!selectionStartPoint.IsSet()))) {
+      return;
+    }
+
+    if (mLastSelectionPoint == selectionStartPoint) {
+      // If all styles are cleared or link style is explicitly set, we
+      // shouldn't reset them without caret move.
+      if (AreAllStylesCleared() || IsLinkStyleSet()) {
+        return;
+      }
+      // And if non-link styles are cleared or some styles are set, we
+      // shouldn't reset them too, but we may need to change the link
+      // style.
+      if (AreSomeStylesSet() ||
+          (AreSomeStylesCleared() && !IsOnlyLinkStyleCleared())) {
+        resetAllStyles = false;
+      }
+    }
+
+    RefPtr<Element> linkElement;
+    if (HTMLEditUtils::IsPointAtEdgeOfLink(selectionStartPoint,
+                                           getter_AddRefs(linkElement))) {
+      // If caret comes from outside of <a href> element, we should clear "link"
+      // style after reset.
+      if (causedByFrameSelectionMoveCaret) {
+        MOZ_ASSERT(!(aReason & (nsISelectionListener::MOUSEDOWN_REASON |
+                                nsISelectionListener::MOUSEUP_REASON)));
+        // If caret is moves in a link per character, we should keep inserting
+        // new text to the link because user may want to keep extending the link
+        // text.  Otherwise, e.g., using `End` or `Home` key. we should insert
+        // new text outside the link because it should be possible to user
+        // choose it, and this is similar to the other browsers.
+        switch (lastSelectionCommand) {
+          case Command::CharNext:
+          case Command::CharPrevious:
+          case Command::MoveLeft:
+          case Command::MoveLeft2:
+          case Command::MoveRight:
+          case Command::MoveRight2:
+            // If selection becomes collapsed, we should unlink new text.
+            if (!mLastSelectionPoint.IsSet()) {
+              unlink = true;
+              break;
+            }
+            // Special case, if selection isn't moved, it means that caret is
+            // positioned at start or end of an editing host.  In this case,
+            // we can unlink it even with arrow key press.
+            // TODO: This does not work as expected for `ArrowLeft` key press
+            //       at start of an editing host.
+            if (mLastSelectionPoint == selectionStartPoint) {
+              unlink = true;
+              break;
+            }
+            // Otherwise, if selection is moved in a link element, we should
+            // keep inserting new text into the link.  Note that this is our
+            // traditional behavior, but different from the other browsers.
+            // If this breaks some web apps, we should change our behavior,
+            // but let's wait a report because our traditional behavior allows
+            // user to type text into start/end of a link only when user
+            // moves caret inside the link with arrow keys.
+            unlink =
+                !mLastSelectionPoint.GetContainer()->IsInclusiveDescendantOf(
+                    linkElement);
+            break;
+          default:
+            // If selection is moved without arrow keys, e.g., `Home` and
+            // `End`, we should not insert new text into the link element.
+            // This is important for web-compat especially when the link is
+            // the last content in the block.
+            unlink = true;
+            break;
+        }
+      } else if (aReason & (nsISelectionListener::MOUSEDOWN_REASON |
+                            nsISelectionListener::MOUSEUP_REASON)) {
+        // If the corresponding mouse event is fired in a link element,
+        // we should keep treating inputting content as content in the link,
+        // but otherwise, i.e., clicked outside the link, we should stop
+        // treating inputting content as content in the link.
+        unlink = !mouseEventFiredInLinkElement;
+      } else if (aReason & nsISelectionListener::JS_REASON) {
+        // If this is caused by a call of Selection API or something similar
+        // API, we should not contain new inserting content to the link.
+        unlink = true;
+      } else {
+        switch (aHTMLEditor.GetEditAction()) {
+          case EditAction::eDeleteBackward:
+          case EditAction::eDeleteForward:
+          case EditAction::eDeleteSelection:
+          case EditAction::eDeleteToBeginningOfSoftLine:
+          case EditAction::eDeleteToEndOfSoftLine:
+          case EditAction::eDeleteWordBackward:
+          case EditAction::eDeleteWordForward:
+            // This selection change is caused by the editor and the edit
+            // action is deleting content at edge of a link, we shouldn't
+            // keep the link style for new inserted content.
+            unlink = true;
+            break;
+          default:
+            break;
+        }
+      }
+    } else if (mLastSelectionPoint == selectionStartPoint) {
+      return;
+    }
+
+    mLastSelectionPoint = selectionStartPoint;
+    // We need to store only offset because referring child may be removed by
+    // we'll check the point later.
+    AutoEditorDOMPointChildInvalidator saveOnlyOffset(mLastSelectionPoint);
+  } else {
+    if (aHTMLEditor.SelectionRef().RangeCount()) {
+      // If selection starts from a link, we shouldn't preserve the link style
+      // unless the range is entirely in the link.
+      EditorRawDOMRange firstRange(*aHTMLEditor.SelectionRef().GetRangeAt(0));
+      if (firstRange.StartRef().IsInContentNode() &&
+          HTMLEditUtils::IsContentInclusiveDescendantOfLink(
+              *firstRange.StartRef().ContainerAs<nsIContent>())) {
+        unlink = !HTMLEditUtils::IsRangeEntirelyInLink(firstRange);
+      }
+    }
+    mLastSelectionPoint.Clear();
+  }
+
+  if (resetAllStyles) {
+    Reset();
+    if (unlink) {
+      ClearLinkAndItsSpecifiedStyle();
+    }
+    return;
+  }
+
+  if (unlink == IsExplicitlyLinkStyleCleared()) {
+    return;
+  }
+
+  // Even if we shouldn't touch existing style, we need to set/clear only link
+  // style in some cases.
+  if (unlink) {
+    ClearLinkAndItsSpecifiedStyle();
+    return;
+  }
+  CancelClearingStyle(*nsGkAtoms::a, nullptr);
+}
+
+void PendingStyles::PreserveStyles(
+    const nsTArray<EditorInlineStyleAndValue>& aStylesToPreserve) {
+  for (const EditorInlineStyleAndValue& styleToPreserve : aStylesToPreserve) {
+    PreserveStyle(styleToPreserve.HTMLPropertyRef(), styleToPreserve.mAttribute,
+                  styleToPreserve.mAttributeValue);
+  }
+}
+
+void PendingStyles::PreserveStyle(nsStaticAtom& aHTMLProperty,
+                                  nsAtom* aAttribute,
+                                  const nsAString& aAttributeValueOrCSSValue) {
+  // special case for big/small, these nest
+  if (nsGkAtoms::big == &aHTMLProperty) {
+    mRelativeFontSize++;
+    return;
+  }
+  if (nsGkAtoms::small == &aHTMLProperty) {
+    mRelativeFontSize--;
+    return;
+  }
+
+  Maybe<size_t> index = IndexOfPreservingStyle(aHTMLProperty, aAttribute);
+  if (index.isSome()) {
+    // If it's already set, update the value
+    mPreservingStyles[index.value()]->UpdateAttributeValueOrCSSValue(
+        aAttributeValueOrCSSValue);
+    return;
+  }
+
+  // font-size and font-family need to be applied outer-most because height of
+  // outer inline elements of them are computed without these styles.  E.g.,
+  // background-color may be applied bottom-half of the text.  Therefore, we
+  // need to apply the font styles first.
+  UniquePtr<PendingStyle> style = MakeUnique<PendingStyle>(
+      &aHTMLProperty, aAttribute, aAttributeValueOrCSSValue);
+  if (&aHTMLProperty == nsGkAtoms::font && aAttribute != nsGkAtoms::bgcolor) {
+    MOZ_ASSERT(aAttribute == nsGkAtoms::color ||
+               aAttribute == nsGkAtoms::face || aAttribute == nsGkAtoms::size);
+    mPreservingStyles.InsertElementAt(0, std::move(style));
+  } else {
+    mPreservingStyles.AppendElement(std::move(style));
+  }
+
+  CancelClearingStyle(aHTMLProperty, aAttribute);
+}
+
+void PendingStyles::ClearStyles(
+    const nsTArray<EditorInlineStyle>& aStylesToClear) {
+  for (const EditorInlineStyle& styleToClear : aStylesToClear) {
+    if (styleToClear.IsStyleToClearAllInlineStyles()) {
+      ClearAllStyles();
+      return;
+    }
+    if (styleToClear.mHTMLProperty == nsGkAtoms::href ||
+        styleToClear.mHTMLProperty == nsGkAtoms::name) {
+      ClearStyleInternal(nsGkAtoms::a, nullptr);
+    } else {
+      ClearStyleInternal(styleToClear.mHTMLProperty, styleToClear.mAttribute);
+    }
+  }
+}
+
+void PendingStyles::ClearStyleInternal(
+    nsStaticAtom* aHTMLProperty, nsAtom* aAttribute,
+    SpecifiedStyle aSpecifiedStyle /* = SpecifiedStyle::Preserve */) {
+  if (IsStyleCleared(aHTMLProperty, aAttribute)) {
+    return;
+  }
+
+  CancelPreservingStyle(aHTMLProperty, aAttribute);
+
+  mClearingStyles.AppendElement(MakeUnique<PendingStyle>(
+      aHTMLProperty, aAttribute, u""_ns, aSpecifiedStyle));
+}
+
+void PendingStyles::TakeAllPreservedStyles(
+    nsTArray<EditorInlineStyleAndValue>& aOutStylesAndValues) {
+  aOutStylesAndValues.SetCapacity(aOutStylesAndValues.Length() +
+                                  mPreservingStyles.Length());
+  for (const UniquePtr<PendingStyle>& preservedStyle : mPreservingStyles) {
+    aOutStylesAndValues.AppendElement(
+        preservedStyle->GetAttribute()
+            ? EditorInlineStyleAndValue(
+                  *preservedStyle->GetTag(), *preservedStyle->GetAttribute(),
+                  preservedStyle->AttributeValueOrCSSValueRef())
+            : EditorInlineStyleAndValue(*preservedStyle->GetTag()));
+  }
+  mPreservingStyles.Clear();
+}
+
+/**
+ * TakeRelativeFontSize() hands back relative font value, which is then
+ * cleared out.
+ */
+int32_t PendingStyles::TakeRelativeFontSize() {
+  int32_t relSize = mRelativeFontSize;
+  mRelativeFontSize = 0;
+  return relSize;
+}
+
+PendingStyleState PendingStyles::GetStyleState(
+    nsStaticAtom& aHTMLProperty, nsAtom* aAttribute /* = nullptr */,
+    nsString* aOutNewAttributeValueOrCSSValue /* = nullptr */) const {
+  if (IndexOfPreservingStyle(aHTMLProperty, aAttribute,
+                             aOutNewAttributeValueOrCSSValue)
+          .isSome()) {
+    return PendingStyleState::BeingPreserved;
+  }
+
+  if (IsStyleCleared(&aHTMLProperty, aAttribute)) {
+    return PendingStyleState::BeingCleared;
+  }
+
+  return PendingStyleState::NotUpdated;
+}
+
+void PendingStyles::CancelPreservingStyle(nsStaticAtom* aHTMLProperty,
+                                          nsAtom* aAttribute) {
+  if (!aHTMLProperty) {
+    mPreservingStyles.Clear();
+    mRelativeFontSize = 0;
+    return;
+  }
+  Maybe<size_t> index = IndexOfPreservingStyle(*aHTMLProperty, aAttribute);
+  if (index.isSome()) {
+    mPreservingStyles.RemoveElementAt(index.value());
+  }
+}
+
+void PendingStyles::CancelClearingStyle(nsStaticAtom& aHTMLProperty,
+                                        nsAtom* aAttribute) {
+  Maybe<size_t> index =
+      IndexOfStyleInArray(&aHTMLProperty, aAttribute, nullptr, mClearingStyles);
+  if (index.isSome()) {
+    mClearingStyles.RemoveElementAt(index.value());
+  }
+}
+
+Maybe<size_t> PendingStyles::IndexOfStyleInArray(
+    nsStaticAtom* aHTMLProperty, nsAtom* aAttribute, nsAString* aOutValue,
+    const nsTArray<UniquePtr<PendingStyle>>& aArray) {
+  if (aAttribute == nsGkAtoms::_empty) {
+    aAttribute = nullptr;
+  }
+  for (size_t i : IntegerRange(aArray.Length())) {
+    const UniquePtr<PendingStyle>& item = aArray[i];
+    if (item->GetTag() == aHTMLProperty && item->GetAttribute() == aAttribute) {
+      if (aOutValue) {
+        *aOutValue = item->AttributeValueOrCSSValueRef();
+      }
+      return Some(i);
+    }
+  }
+  return Nothing();
+}
+
+}  // namespace mozilla