Commit Graph
94 Commits
Author SHA1 Message Date
Masayuki Nakano 97f7b2fd9a Bug 1865729 - part 0: Add logging code of AutoMoveOneLineHandler r=m_kato
The class does complicated things and has been reported some assertion failures.
For making the debug faster, let's add the logging code.

Differential Revision: https://phabricator.services.mozilla.com/D194180
2023-11-27 01:46:42 +00:00
Masayuki Nakano f84a751fe1 Bug 1839793 - Move EditorBase::FindBetterInsertionPoint into TextEditor r=m_kato
Currently it runs if the instance is a `TextEditor` or it's in the plaintext
mode of `HTMLEditor`.  However, it does not make sense to run it only in
specific mode of `HTMLEditor`, and most part does not make sense for
`HTMLEditor`.

This patch moves the method to `TextEditor`, and for
`EditorBase::InsertTextWithTransaction()` and
`AutoRangeArray::ExtendAnchorFocusRangeFor()`, adds new method to
`EditorDOMPointBase` to get a text node position if it points around
a text node.

Differential Revision: https://phabricator.services.mozilla.com/D181835
2023-06-27 04:23:09 +00:00
Masayuki Nakano 9a03a51932 Bug 1833543 - Get rid of typedefs from the editor module r=m_kato
Differential Revision: https://phabricator.services.mozilla.com/D178275
2023-05-19 02:58:53 +00:00
Emilio Cobos Álvarez c195031050 Bug 1825825 - Simplify NAC setup. r=smaug
Make all UA widgets also NAC.

Keep the UA widget flag but break at anonymous subtree boundaries, so
that only nodes inside the UA widget directly (and not NAC from those)
get the flag.

This is important because two callers depend on this difference:

 * The style system, since we still want to match content rules from
   stylesheets in the UA widget. We also match user rules, which is a
   bit sketchy, but that was the previous behavior, will file a
   follow-up for that.

 * The reflector code, since we want the scope for UA widgets to not
   include the NAC nodes inside that UA widget. nsINode::IsInUAWidget
   got it wrong.

After this patch, ChromeOnlyAccess is equivalent to
IsInNativeAnonymousSubtree, so we should probably unify the naming.
That's left for a follow-up patch because I don't have a strong
preference.

Differential Revision: https://phabricator.services.mozilla.com/D174310
2023-04-05 09:19:15 +00:00
Masayuki Nakano edd188d44c Bug 1820905 - Make HTMLEditor::SplitNodeWithTransaction return NS_ERROR_EDITOR_UNEXPECTED_DOM_TREE if split nodes have been removed from the DOM tree r=m_kato
If one of them are removed from the DOM tree, it's hard to keep handling it
since we have both split direction paths.  Therefore, let's just return error
but not throw new exception in the case.

Differential Revision: https://phabricator.services.mozilla.com/D172205
2023-03-13 18:31:00 +00:00
Masayuki Nakano 292a13ec19 Bug 1792386 - part 1: Make HTMLEditor::SetInlinePropertiesAsSubAction extend and/or shrink range smarter r=m_kato
Blink's behavior is better than Gecko.  That is, when selected range crosses
an inline element boundary, Blink shrinks selected range to select only
children, but Gecko extends selected range to cover all inline parents around
the range.  E.g., when setting `abc[<i>def]</i>ghi` to `<b>`, Chrome changes it
to `abc<i><b>def</b></i>ghi`, but Gecko changes it to `abc<b><i>def</i></b>ghi`.
The Gecko's behavior is odd especially when `abc<i>[def]</i>ghi` since user
does not select the `<i>`, but Gecko wraps it in new `<b>`.

However, if the range contains an inline element entirely, e.g.,
`abc[<i>def</i>]ghi`, Chrome changes it to `abc<b><i>def</i></b>ghi` without
shrinking the range.  This is reasonable too.

On the other hand, there is a case that browsers need to extend the range.
That is an parent inline element has the style of what we're setting a range to.
E.g., `abc<span style="background-color: red"><b>[def]</b></span>ghi`, user
wants to update the style attribute of the `<span>` element rather than wrapping
the selected text node with new `<span>` element in the `<b>`.  Therefore,
if shrunken range starts from very beginning of a node or ends at very end of
a node and the inline parents have same style, we need extend the range to wrap
it.  (Note that Gecko deletes same styles in range with
`HTMLEditor::RemoveStyleInside`.  Therefore, wrapping most distant inline
element makes Gecko works as expected.)

Finally, if the containers of range boundaries are not same one, we should
extend the range to save the number of creating element.  E.g.,
`<span>[abc</span> <span>def]</span>` should become
`<b><span>abc</span> <span>def</span>` rather than
`<span><b>abc</b></span><b> </b><span><b>def</b></span>`.

Note that the new expected failures are caused by the difference of selection
range after applying the style.  That should be fixed by the following patch.

Depends on D164521

Differential Revision: https://phabricator.services.mozilla.com/D164522
2022-12-20 00:19:41 +00:00
Masayuki Nakano 709858480c Bug 1793873 - Make HTMLEditor::DoSplitNode stop assuming that joining nodes are in same parent r=m_kato
Between splitting a node and undoing it, web apps can move split nodes anywhere.
Therefore, it shouldn't assume they are always in same parent node, and
`RangeUpdater::SelAdjJoinNodes` needs to handle it correctly.

Unfortunately, `RangeUpdater::SelAdjJoinNodes` cannot handle nested cases
correctly, e.g., right node was in `aRemovedContent` or right node was in
the container of `aStartOfRightContent.GetContainer()`.  However, it's not
a new regression, and such complicated situation breaks undoing anyway.
Therefore, I think that we don't need to care about it for now.

Differential Revision: https://phabricator.services.mozilla.com/D159230
2022-10-14 02:49:13 +00:00
Masayuki Nakano c4302cb310 Bug 1792387 - part 6: Make HTMLEditor::InsertElementWithSplittingAncestorsWithTransaction check edge case with next node of the split point r=m_kato
The check assumes that the container of `aPointToInsert` is always right node.
However, its child is moved to new node if we switch the direction, so we should
make it check the edge case with `SplitNodeResult::GetNextContent()`.

Differential Revision: https://phabricator.services.mozilla.com/D158104
2022-09-30 22:20:22 +00:00
Masayuki Nakano f1076d3f4c Bug 1782911 - part 2: Clean up unnecessary line break at block boundary while moving first line of right paragraph to left paragraph r=m_kato
This fixes bug 503838 partially.  The new utility method scans unnecessary
`<br>` with strict check as far as possible.  Then, we can delete the node or
the preformatted line break at end of the last text node.

Differential Revision: https://phabricator.services.mozilla.com/D157411
2022-09-25 12:49:43 +00:00
Masayuki Nakano 2f63891f53 Bug 1781994 - part 2: Make HTMLEditor::SplitAncestorStyledInlineElementsAtRangeEdges stop touching Selection directly r=m_kato
Depends on D154343

Differential Revision: https://phabricator.services.mozilla.com/D154344
2022-08-16 00:08:07 +00:00
Masayuki Nakano 830bd376e2 Bug 1783402 - part 3: Make result of unsafe getter methods of EditorDOMPointBase templated r=m_kato
Differential Revision: https://phabricator.services.mozilla.com/D153842
2022-08-09 01:43:24 +00:00
Masayuki Nakano eb8aafe328 Bug 1783402 - part 2: Make result of safe getter methods of EditorDOMPointBase templated r=m_kato
Similar to the previous patch, and for consistency between editor helper
classes, we should make result of getter methods of `EditorDOMPointBase` too.

Differential Revision: https://phabricator.services.mozilla.com/D153841
2022-08-09 01:43:24 +00:00
Masayuki Nakano 4aff9ebb83 Bug 1770877 - part 16: Make AutoRangeArray can be initialized with an EditorDOMRangeBase or EditorDOMPointBase r=m_kato
Differential Revision: https://phabricator.services.mozilla.com/D149080
2022-06-18 09:53:41 +00:00
Masayuki Nakano dfde4fb973 Bug 1762115 - part 10: Make HTMLEditor::InsertBRElement stop touching Selection directly r=m_kato
Differential Revision: https://phabricator.services.mozilla.com/D144653
2022-05-03 01:03:05 +00:00
Masayuki Nakano 54bb966fad Bug 1765018 - part 7: Make some methods which return an instance (not reference) of EditorDOMPointBase be template methods r=m_kato
For avoiding to use `To<EditorDOMPoint>()` etc from temporary object, such
methods should be templated.

Differential Revision: https://phabricator.services.mozilla.com/D143884
2022-04-20 23:58:04 +00:00
Masayuki Nakano cd80bdce17 Bug 1765018 - part 1: Get rid of implicit conversion between EditorDOMPointBase instances r=m_kato
The implicit copy constructors and `operator=` makes it harder to realize
that implicit conversion wastes the runtime cost.  Therefore, this patch
replaces them with a template method to convert the `EditorDOMPointBase` type.

Differential Revision: https://phabricator.services.mozilla.com/D143878
2022-04-20 22:41:02 +00:00
Masayuki Nakano 0ce8e872fd Bug 1764866 - Add "mozilla/EditorForwards.h" r=m_kato
Headers in editor module has a lot of forward declarations for avoiding the
include hell and has a lot of helper template classes.

Forward declarations of template classes is really messy and I'd want to
avoid the duplication because it blocks changing template class.  Therefore,
centralizing forward declarations makes the headers cleaner and maintaining
template classes easier.  Therefore, this patch adds a new header file which
has only forward declarations and some aliases.

It'd be better to define `enum class`es in it like `EventForwards.h` for
reducing the dependencies between headers, but currently this does not do it
for making the new file simpler as far as possible.

Removing `EditActionListener.h` is because it's unused.

Removing `AutoTopLevelEditSubActionNotifier` is because it's renamed to
`AutoEditSubActionNotifier`.
https://hg.mozilla.org/mozilla-central/rev/6de55c5b5f8d5f92389d0d244d2bced1f979ade9

Differential Revision: https://phabricator.services.mozilla.com/D143817
2022-04-20 14:46:16 +00:00
Masayuki Nakano 2bf1838410 Bug 1764684 - part 1: Make EditorDOMPointBase store Selection::InterlinePosition r=m_kato
When `HTMLEditor::CollapseSelectionTo` etc is called, interline position should
be set automatically.  Then, we can get rid of duplicated code.  Unfortunately,
this may increase the instance size, but I believe that the merit is valuable
because `EditorDOMPoint` should not be in the heap for a long time in so many
cases (perhaps, mainly in some transaction classes).

Differential Revision: https://phabricator.services.mozilla.com/D143813
2022-04-20 14:24:55 +00:00
Masayuki Nakano 6cc7b409ff Bug 1759816 - Create EditorDOMPointBase<PT, CT>::ParentPoint() for avoiding warning spam caused by no necessary checks r=m_kato
When setting a point, the child must be `nsIContent`.  However, climbing up
the tree from a point with `EditorDOMPointBase<PT, CT>`, it may reach top of
the DOM tree (fragment).  Then, we'd get a warning which wouldn't hit in
usual cases.  Therefore, we should add new API to get parent point of an
`EditorDOMPointBase<PT, CT>` instance and it should check properly before
creating new instance.

Differential Revision: https://phabricator.services.mozilla.com/D141196
2022-03-18 07:02:32 +00:00
Masayuki Nakano 25e9c8e84e Bug 1751679 - Make WhiteSpaceVisibilityKeeper::MergeFirstLineOfRightBlockElementIntoAncestorLeftBlockElement track DOM points while the DOM tree is being changed r=m_kato
The method caches a DOM point, but it is not tracked correctly.

This patch adds some validations into it and one of its callee,
`HTMLEditor::MoveOneHardLineContents`.  Additionally, making
`EditorDOMPointBase::Offset` avoid accessing `Maybe`'s storage when it's
`Nothing` in release builds as the last resort.

Differential Revision: https://phabricator.services.mozilla.com/D136994
2022-02-09 00:45:33 +00:00
Masayuki Nakano c5f1db7b0e Bug 1752914 - part 2: Make HTMLEditor sanitize selection ranges in native anonymous subtrees before handling them r=m_kato
Due to a Selection API's bug, `Selection::Modify` may move selection into
native anonymous subtree.  Although it should be fixed in the side, but
`HTMLEditor` should make range boundaries climb up to outside native anonymous
subtrees.

Depends on D137526

Differential Revision: https://phabricator.services.mozilla.com/D137527
2022-02-04 13:21:04 +00:00
Masayuki Nakano 77ecc0489a Bug 1745862 - part 2: Make IsSetAndValid of RangeBoundaryBase and EditorDOMPointBase return false when it refers a node which is being removed from parent r=smaug,mbrodesser
`IsSetAndValid` method of `RangeBoundaryBase` and `EditorDOMPointBase` should
return `false` if points a removed node.  However, while a node is being
removed, the node still keeps referring the parent, but it has already removed
from the child node chain of the parent.  In this moment, returning `true` may
not be expected by the callers because the point becomes invalid soon with
the parent being cleared.

Differential Revision: https://phabricator.services.mozilla.com/D135190
2022-01-13 13:25:16 +00:00
Masayuki Nakano 7a52e41ff0 Bug 1741148 - part 3: Make users of nsINode::ComputeIndexOf_Deprecated() use nsINode::ComputeIndexOf() if the result is not set to int32_t nor return as int32_t r=smaug
This patch fixes only the cases if the result of `ComputeIndexOf_Deprecated()`
is used as unsigned integer with implicit or explicit cast.

Differential Revision: https://phabricator.services.mozilla.com/D131336
2021-12-09 11:55:36 +00:00
Masayuki Nakano 41d6e516dc Bug 1741148 - part 1: Rename nsINode::ComputeIndexOf to ComputeIndexOf_Deprecated r=smaug
It's hard to fix some callers.  Therefore, in this bug, we should fix only
simple cases.  Therefore, we should rename existing API first.

Differential Revision: https://phabricator.services.mozilla.com/D131334
2021-12-09 08:32:30 +00:00
Masayuki Nakano 05d0e158a9 Bug 1742748 - Make HTMLEditor::JoinNodesWithTransaction() return JoinNodesResult r=m_kato
This patch implements `JoinNodesResult` class which callers of
`JoinNodesWithTransaction()` can access removed node, existing (joined) node and
joined point with logical named accessors, and makes
`JoinNodesWithTransaction()` return it.

Then, the callers don't need to change at fixing bug 1735608.

Differential Revision: https://phabricator.services.mozilla.com/D132120
2021-11-27 00:05:54 +00:00
Masayuki Nakano 2fb6b9ff2a Bug 1740416 - Make HTMLEditor::HandleInsertParagraphInParagraph() call WhiteSpaceVisibilityKeeper::PrepareToSplitBlockElement() before splitting a text node r=m_kato,smaug
It does the following things when caret is collapsed in a text node in a `<p>`
or `<div>` element.

1. Split the text node containing caret to insert `<br>` element
2. Insert `<br>` element after it
3. Split ancestor elements which inclusive descendants of the `<p>` or `<div>`
4. Delete the `<br>` element if unnecessary from the left paragraph

#3 and #4 are performed by `HTMLEditor::SplitParagraph()` and it calls
`WhiteSpaceVisibilityKeeper::PrepareToSplitBlockElement()` correctly before
splitting the block.  However, in the case (caret is at middle of a text node),
the text has already been split to 2 nodes because of #1.  Therefore, it fails
to handle to keep the white-space visibility.

So that I believe that the root cause of this bug is, the method does much
complicated things which are required, and doing the redundant things will
eat memory space due to undo transactions.  However, for now, I'd like to fix
this with a simple patch which just call the preparation method before splitting
the text node because I'd like to uplift this if it'd be approved (Note that
this is not a recent regression, the root cause was created by bug 92686 which
was fixed in 17 years ago:
<https://searchfox.org/mozilla-central/commit/2e66280faef73e9be218e00758d4eb738395ac83>,
but must be annoying bug for users who see this frequently).

The new WPTs are pass in Chrome.

Differential Revision: https://phabricator.services.mozilla.com/D130950
2021-11-12 22:13:51 +00:00
Masayuki Nakano 88560528af Bug 1740847 - part 2: Make WhiteSpaceVisibilityKeeper::InsertBRElement() track insert position in smaller block r=m_kato
And also invisible white-space range and replacing white-space position should
also be tracked too.

Depends on D131036

Differential Revision: https://phabricator.services.mozilla.com/D131037
2021-11-12 08:04:37 +00:00
Masayuki Nakano b033045157 Bug 1739545 - part 1: Get rid of mozInlineSpellChecker::DidJoinNodes() and mozInlineSpellChecker::DidSplitNode() r=m_kato
Currently, they do nothing because they specify empty range to
`SpellCheckBetweenNodes()`, and it makes the method does nothing.  This is
filed as bug 1581714.  However, they are not required because `HTMLEditor`
notifies `mozInlineSpellChecker` at ending handling the top level edit sub
action.
https://searchfox.org/mozilla-central/rev/a12c2c2e59c92d8f969d8f3f290ab16919449c9d/editor/libeditor/HTMLEditSubActionHandler.cpp#675

Therefore, these methods are not necessary anymore.

Differential Revision: https://phabricator.services.mozilla.com/D130457
2021-11-09 01:09:20 +00:00
Masayuki Nakano 11f4aec3e5 Bug 1672900 - part 3: Make ExtendOrShrinkRangeToDelete() selects all contents in all list items if a list element is selected or all list items in a list element is selected r=m_kato
When a list element has non-empty list item element, even if the list element is
selected, deleting operation should make the list element empty first (i.e.,
making the list element has only one empty list item element).  Then, another
deleting operation/command can delete it completely.  This is Blink compat
behavior in most cases except when the list has non-editable list item element
as first and/or last child of it.

Note that the new failures of the browserscpe are not compatible with the
new behavior, that is, it wants a list element is deleted when the last
list item is deleted.
https://searchfox.org/mozilla-central/rev/08c493902519265d570250c8e7ce575c8cd6f5b5/editor/libeditor/tests/browserscope/lib/richtext2/richtext2/tests/delete.py#161-164
https://searchfox.org/mozilla-central/rev/08c493902519265d570250c8e7ce575c8cd6f5b5/editor/libeditor/tests/browserscope/lib/richtext2/richtext2/tests/forwarddelete.py#146-149

Here is same test in the WPT:
https://searchfox.org/mozilla-central/rev/08c493902519265d570250c8e7ce575c8cd6f5b5/testing/web-platform/tests/input-events/input-events-get-target-ranges-deleting-in-list-items.tentative.html#386-402
And only Gecko failed in this case:
https://searchfox.org/mozilla-central/rev/08c493902519265d570250c8e7ce575c8cd6f5b5/testing/web-platform/meta/input-events/input-events-get-target-ranges-deleting-in-list-items.tentative.html.ini#1449-1450
https://searchfox.org/mozilla-central/rev/08c493902519265d570250c8e7ce575c8cd6f5b5/testing/web-platform/meta/input-events/input-events-get-target-ranges-deleting-in-list-items.tentative.html.ini#1937-1938
https://searchfox.org/mozilla-central/rev/08c493902519265d570250c8e7ce575c8cd6f5b5/testing/web-platform/meta/input-events/input-events-get-target-ranges-deleting-in-list-items.tentative.html.ini#425-426
https://searchfox.org/mozilla-central/rev/08c493902519265d570250c8e7ce575c8cd6f5b5/testing/web-platform/meta/input-events/input-events-get-target-ranges-deleting-in-list-items.tentative.html.ini#787-788

https://wpt.fyi/results/input-events/input-events-get-target-ranges-deleting-in-list-items.tentative.html%3FDelete,ol?run_id=5734231113203712&run_id=6263979761467392&run_id=5750388243300352&run_id=5090688355008512
https://wpt.fyi/results/input-events/input-events-get-target-ranges-deleting-in-list-items.tentative.html%3FDelete,ul?run_id=5734231113203712&run_id=6263979761467392&run_id=5750388243300352&run_id=5090688355008512
https://wpt.fyi/results/input-events/input-events-get-target-ranges-deleting-in-list-items.tentative.html%3FBackspace,ol?run_id=5734231113203712&run_id=6263979761467392&run_id=5750388243300352&run_id=5090688355008512
https://wpt.fyi/results/input-events/input-events-get-target-ranges-deleting-in-list-items.tentative.html%3FBackspace,ul?run_id=5734231113203712&run_id=6263979761467392&run_id=5750388243300352&run_id=5090688355008512

Therefore, the new failures are expected result.

Depends on D125029

Differential Revision: https://phabricator.services.mozilla.com/D125030
2021-09-11 07:17:38 +00:00
Masayuki Nakano f52e6f2a32 Bug 1724650 - part 3: Make GetEndOfCollapsibleASCIIWhiteSpaces and GetFirstASCIIWhiteSpacePointCollapsedTo treat preformatted linefeed characters correctly r=m_kato
If `white-space` is `pre-line`, only linefeed characters are preformatted, but
white-spaces are collapsible.  And if collapsible white-spaces follow or
are followed by a preformatted linefeed, they are removed.  Therefore,
these methods need to scan following or preceding white-spaces of first
linefeed if the caller wants to delete.  Unless doing it, the removed
white-spaces would become visible due to no linefeed character containing
sequence.

Differential Revision: https://phabricator.services.mozilla.com/D124557
2021-09-10 04:04:28 +00:00
Masayuki Nakano 27991feb1f Bug 1727844 - part 4: Add API to check whether a char is collapsible or not r=m_kato
This patch adds `EditorUtils::IsNewLinePreformatted()` to check whether a
linefeed character is collapsible or not.

Then, a lot of users of `EditorDOMPointBase::Is*CharASCIISpace()` and
`EditorDOMPointBase::Is*CharASCIISpaceOrNBSP()` should check whether the
white-space at the point is collapsible or not.  Therefore, this patch adds
`Is*CharCollapsibleASCIISpace()` and `Is*CharCollapsibleASCIISpaceOrNBSP()`
too.

Then, makes such callers use the new API instead.

Differential Revision: https://phabricator.services.mozilla.com/D123871
2021-08-31 17:37:41 +00:00
Masayuki Nakano bc5ee41c80 Bug 1726064 - part 14: Make AutoDeleteRangesHandler::ExtendRangeToIncludeInvisibleNodes() use HTMLEditUtils::GetInclusiveAncestorElement() r=m_kato
I have no idea how to test this without making unrealistic cases with legacy
mutation event listeners because now, Gecko ignores selection ranges which
crosses editing host boundaries when it tries to delete selection.
* https://searchfox.org/mozilla-central/rev/d3683dbb252506400c71256ef3994cdbdfb71ada/editor/libeditor/HTMLEditorDeleteHandler.cpp#1120
* https://searchfox.org/mozilla-central/rev/d3683dbb252506400c71256ef3994cdbdfb71ada/editor/libeditor/EditorUtils.cpp#137
* https://searchfox.org/mozilla-central/rev/d3683dbb252506400c71256ef3994cdbdfb71ada/editor/libeditor/EditorUtils.cpp#119-125

And invisible white-spaces appear end of a block or start of a block, i.e.,
both block parents in the range boundaries are always editable in normal cases.
So, such range should be ignored first.

Depends on D123067

Differential Revision: https://phabricator.services.mozilla.com/D123068
2021-08-22 21:32:21 +00:00
Masayuki Nakano 780fbf11f8 Bug 1714914 - Make editor classes treat offset in parent node as uint32_t r=m_kato
It should be treated as `uint32_t` since DOM API does so.  However, there are
some exceptions:

* Result of `nsINode::ComputeIndexOf()`
* Result of `nsAString` methods

They return `-1` as not found, and anyway, they cannot treat large integer
than `INT32_MAX`.  Therefore, this patch does not touch around them.

Differential Revision: https://phabricator.services.mozilla.com/D118933
2021-06-30 07:07:28 +00:00
Masayuki Nakano 36767edbe8 Bug 1560396 - Replace EditorBase::GetNodeAtRangeOffsetPoint() with new API in EditorDOMPointBase r=m_kato
It's a static method and called only with `EditorDOMPointBase` instances.
So, we can add new API to `EditorDOMPointBase` instead.

Note that it's changed to return container when the container is a data node
rather than a text node.  This should be better because no data node can
have children.

Depends on D117382

Differential Revision: https://phabricator.services.mozilla.com/D117490
2021-06-11 08:57:18 +00:00
Masayuki Nakano fe90868b0b Bug 1627175 - part 55: Move HTMLEditor::IsEmptyInlineNode() and HTMLEditor::IsEmptyOneHardLine() to HTMLEditUtils r=m_kato
Differential Revision: https://phabricator.services.mozilla.com/D115164
2021-05-17 08:38:55 +00:00
Masayuki Nakano adf47de4ae Bug 1697876 - part 1: Add logging code to transaction classes for making easier to debug r=m_kato
Differential Revision: https://phabricator.services.mozilla.com/D110714
2021-04-05 11:35:48 +00:00
Masayuki Nakano 89f5df2dc0 Bug 1664109 - Fix != operator of EditorDOMRangeBase r=m_kato
This is causes taking back bugs in
`WSRunScanner::GetNewInvisibleLeadingWhiteSpaceRangeIfSplittingAt()` and
`WSRunScanner::GetNewInvisibleTrailingWhiteSpaceRangeIfSplittingAt()`  (I.e.,
they were fixed by bug 1647556).  Therefore, this removes the odd `if` blocks
which are pointed with `XXX` comment for avoiding "regressions" (without them,
some WPTs for `InputEvents.getTargetRanges()` become failure).

Depends on D89582

Differential Revision: https://phabricator.services.mozilla.com/D89869
2020-09-16 02:17:33 +00:00
Masayuki Nakano 622e0d1a98 Bug 1660378 - part 9: Avoid QI for getting nsStyledElement pointer r=smaug
The editor modules does QI too many times when it sets or removes some style
with `execCommand` or XPCOM API.  Therefore, there should be an API to
retrieve `nsStyledElement` pointer from `nsINode*`.

Differential Revision: https://phabricator.services.mozilla.com/D87990
2020-08-26 05:29:06 +00:00
Masayuki Nakano 8abb67b878 Bug 1660378 - part 7: Make CSSEditUtils::SetCSSEquivalentToHTMLStyle() take nsStyledElement& instead of Element* r=m_kato
Differential Revision: https://phabricator.services.mozilla.com/D87988
2020-08-26 04:48:32 +00:00
Masayuki Nakano 6e6f6166a8 Bug 1656799 - part 3: Make WhiteSpaceVisibilityKeeper::PrepareToDeleteRange() not track EditorDOMPoints r=m_kato
It may be faster to use `AutoTrackDOMRange` directly.  Therefore, current
`WhiteSpaceVisibilityKeeper::PrepareToDeleteRange()` should be renamed to
`WhiteSpaceVisibilityKeeper::PrepareToDeleteRangeAndTrackPoints()` and
we should make `HTMLEditor::HandleDeleteNonCollapsedSelection()` track
the range by itself.

Depends on D85846

Differential Revision: https://phabricator.services.mozilla.com/D85847
2020-08-06 08:07:39 +00:00
Masayuki Nakano 48e647722f Bug 1655651 - Fix end point comparison in EditorDOMRangeBase::Contains() r=m_kato
Fortunately, nobody uses this API yet.

Differential Revision: https://phabricator.services.mozilla.com/D85108
2020-07-30 03:47:40 +00:00
Masayuki Nakano 6934bd0ac6 Bug 1644313 - part 4: Make WSRunScanner::GetRangeInTextNodesTo*From() available with non-white-space characters r=m_kato
The difference between `HTMLEditor::HandleDeleteCollapsedSelectionAtTextNode()`
and `HTMLEditor::HandleDeleteCollapsedSelectionAtWhiteSpace()` is whether
it treats surrogate pair or not.  And it's easy to handle it in `WSRunScanner`.
Therefore, they can handle all deletion in a text node.

Some new failures are caused by that we normalize preceding white-spaces of
deletion range but Blink does not to it.  These failures will be fixed by
part 5.

Depends on D84946

Differential Revision: https://phabricator.services.mozilla.com/D84947
2020-07-29 22:13:46 +00:00
Masayuki Nakano a6d61f5ef6 Bug 1644313 - part 1: Create new path to handle backspace or (forward) delete with the new normalizer r=m_kato
`InputEvent.getTargetRange()` should have actual delete range.  It means that
the range should contain the invisible leading/trailing white-spaces which
need to be removed for keep them invisible, but should not contain the range
of normalizing white-space sequence because they are not target of edit action
indicated by `InputEvent.inputType`.

So, we can use new path which uses the new white-space normalizer for
computing the value of `InputEvent.getTargetRanges()` because difference of
white-space normalizer shouldn't affect the deleting ranges (although, some
existing path calls `DeleteNodeIfInvisibleAndEditableTextNode()` later so that
the new method, `ComputeRangeInTextNodesContainingInvisibleWhiteSpaces()`, does
not exactly same thing, but the result shouldn't become different in usual
cases).  This new path can test with some WPTs under `editing/other`.

This patch creates new backspace/delete key handler when caret is at next
to a white-space as `HTMLEditor::HandleDeleteTextAroundCollapsedSelection()`
and creates helper methods of `WSRunScanner` to treat invisible leading and
trailing white-spaces.

Note that new failures are caused by the difference whether adjacent white-space
sequence at deletion is normalized or not in edge cases.  They will be fixed
by the part.5.

Depends on D84943

Differential Revision: https://phabricator.services.mozilla.com/D84944
2020-07-29 00:04:00 +00:00
Masayuki Nakano 4bd55f537d Bug 1651874 - part 10: Move GetReplaceRangeDataAtEndOfDeletionRange() and GetReplaceRangeDataAtStartOfDeletionRange() to TextFragmentData r=m_kato
With this patch, the creation cost of `TextFragmentData` is minimized, but
`MakeSureToKeepVisibleStateOfWhiteSpacesAroundDeletingRange()` can work
with the latest DOM tree information at touching start of the deleting range
even after touching end of the range.

Depends on D83228

Differential Revision: https://phabricator.services.mozilla.com/D83229
2020-07-16 16:41:00 +00:00
Masayuki Nakano a183c879a3 Bug 1651874 - part 8: Make helper methods of MakeSureToKeepVisibleStateOfWhiteSpacesAroundDeletingRange() return replace or delete data r=m_kato
For representing delete or replace data which have the range and replace string,
this patch creates `ReplaceRangeDataBase` class which is stack-only, has
`EditorDOMRange` or `EditorDOMRangeInTexts` as the range and has replace string
which can be empty string.

Then, `MakeSureToKeepVisibleStateOfWhiteSpacesAroundDeletingRange()` should
modify the DOM tree by itself.  With the following patch, the behavior is
corrected for multiple DOM tree changes.

Depends on D83224

Differential Revision: https://phabricator.services.mozilla.com/D83226
2020-07-16 12:24:21 +00:00
Masayuki Nakano 4c676b1624 Bug 1651874 - part 7: Rename ReplaceASCIIWhiteSpacesWithOneNBSP() to ReplaceTextAndRemoveEmptyTextNodes() r=m_kato
Depends on D83223

Differential Revision: https://phabricator.services.mozilla.com/D83224
2020-07-16 05:54:41 +00:00
Masayuki Nakano d78cc27c04 Bug 1647556 - part 9-2: Make WSRunObject::InsertBreak() stop using FindNearestFragment() r=m_kato
It removes some invisible leading and/or trailing white-spaces when it inserts
`<br>` element into the invisible white-space sequence.  It currently checks
whether the insertion point is in invisible leading and trailing white-spaces
or not with `FindNearestFragment()`, but we can do same thing with
comparing the insertion point with the result of
`TextFragmentData::GetInvisibleLeadingWhiteSpaceRange()` and
`TextFragmentData::GetInvisibleLeadingWhiteSpaceRange()`.  However, current
implementation does not make sense because:
- It checks trailing white-spaces with `!IsEndOfHardLine()` and
  `IsStartOfHardLine()`, but this means that it does ignores invisible
   white-spaces which are the only content in a line.
- It checks leading white-spaces with `!IsStartOfHardLine()` and
  `IsEndOfHardLine()`, so, this also ignores invisible white-spaces which
  are the only content in a line.
- The important thing of the logic is prevent that invisible leading and
  trailing white-spaces become visible with new `<br>` element, but this
  is done only for trailing white-spaces.

Differential Revision: https://phabricator.services.mozilla.com/D82283
2020-07-09 09:44:41 +00:00
Masayuki Nakano 8d395572f3 Bug 1647556 - part 3-1: Add API to WSRunScanner::TextFragmentData to get range of invisible leading or trailing white-spaces r=m_kato
One of the `WSFragment`users' purpose is, they remove invisible white-spaces
when there are.  So, `TextFragmentData` should have API to retrieve the
ranges and use them for initializing `WSFragment` which represents leading
or trailing white-spaces.  For making this patch smaller as far as possible,
these APIs implements only the case when there is no NBSP.

For result of the new API, this creates a template class, `EditorDOMRangeBase`,
whose boundary type is `EditorDOMPointBase`.  Its methods are named from
`nsRange`'s same methods.

Differential Revision: https://phabricator.services.mozilla.com/D82272
2020-07-07 05:31:34 +00:00
Masayuki Nakano 07bec00ea8 Bug 1642594 - part 5: Implement first version of new white-space normalizer which simulates Blink's one r=m_kato
This patch tries to implement Blink-compat white-space normalizer for
`HTMLEditor`.

It's difficult to list up our traditional white-space normalization rules
because `WSRunObject` touches white space sequence only when there is not
acceptable case, e.g., an ASCII white-spaces will be adjacent to another
one, and replaces only unacceptable white-space only.  Therefore, whether
white-space sequence may start with either an ASCII white-space or an NBSP.
On the other hand, Blink and WebKit makes white-space sequence always
starts with an NBSP or an ASCII white-space (unfortunately, they behave
differently!).  So, for web-compat, we should simulate Blink's behavior
because either behavior is reasonable but Blink have more market share.

This patch simply adds new white-space normalization path for the new one,
and it's switchable with a pref, and still disabled by default.

The other reason why we should do this is, our traditional white-space
normalizer touches the DOM a lot of times per edit action, and the timing
is both before and after touches the DOM tree.  Therefore, it's difficult
to compute actual deleting range for `InputEvent.getTargetRanges()` and
touching a lot of times causes running mutation event listeners a lot and
creates a lot of transaction class instances.  So, new one have a lot of
merits:

1. Improve web-compat
2. Improve the peformance
3. Improve the security
4. Improve the footprint (but this is now worse then traditional one)
5. Simplify the implementation

The new normalizer is mostly implemented with only 3 `HTMLEditor` methods.

One is `HTMLEditor::DeleteTextAndNormalizeSurroundingWhiteSpaces()`.  This is
semi-public method for the edit action handlers.  This takes a range with
2 `EditorDOMPoinInText` to delete the range simply.  This also replaces
surrounding white-space sequence if necessary.  For inserting text case,
this method also handles only white-space normalization when it's called
with collapsed range, i.e., same `EditorDOMPointInText`.  This tries to use
`RepaceTextWithTransaction()` as far as possible to reduce creation cost of
transaction classes and the footprint.

Another one is `HTMLEditor::ExtendRangeToDeleteWithNormalizingWhiteSpaces()`.
This tries to extend the given range to normalize surrounding white-spaces.
This is currently not optimized for footprint because this may include
white-spaces which do not need to be replaced.  This optimization should be
done before shipping, but for now, enabling `InputEvent.getTargetRanges()` in
Nightly channel is more important.  So that it should be done in a follow-up
bug.

The other is `HTMLEditor::GenerateWhitepaceSequence()`.  This creates
normalized white-space sequence with surrounding character information.
For keeping this method simple as far as possible, we shouldn't optimize
the range of generation even in follow-ups.

Finally, the white-space sequence is not tested in mochitests, so that we
can enable this new normalizer when we run mochitests under
`editor/libeditor/tests`.  However, WPT has some tests.  We should keep
them running with current normalizer for checking regression.  Instead,
we should enable the pref only for the new WPT added by the previous patch.

Depends on D78655

Differential Revision: https://phabricator.services.mozilla.com/D78656
2020-06-15 07:37:56 +00:00
Masayuki Nakano 336ad26cc3 Bug 1627175 - part 1: Move HTMLEditor::IsBlockNode() into HTMLEditUtils r=m_kato
`HTMLEditor::IsBlockNode()` is a virtual method derived from
`EditorBase::IsBlockNode()`.  For the performance, `EditorBase`'s one just
return false for text node and `<br>` element.  However, these check cost
is really cheap in these days.  Therefore, we can make `TextEditor` also
use rich API.

This patch moves `HTMLEditor::NodeIsBlockStatic()` and
`HTMLEditor::NodeIsInlineStatic()` to `HTMLEditUtils`, and removes the wrapper
of the fommer, `HTMLEditor::IsBlockNode()` and `WSRunScanner::IsBlockNode()`.

Differential Revision: https://phabricator.services.mozilla.com/D70874
2020-04-15 13:55:36 +00:00