Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-10-17 15:25:52 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Bug 1430021 - part 2: Make HTMLEditRules not derived from nsIEditActionListener r=m_kato

Browse Source 
HTMLEditRules implements only some of nsIEditActionListener and this is always
first edit action listener.  So, if we make EditorBase treat HTMLEditRules
directly before notifying edit action listeners, we can save a lot of runtime
cost (virtual calls especially unnecessary, copying array of edit action
listeners with strong pointer, redundant QIs), although the code becomes not
beautiful.

Perhaps, we should do same thing to nsTextServicesDocument and
mozInlineSpellChecker in other bugs.

MozReview-Commit-ID: Eveaxj398f2

--HG--
extra : rebase_source : 0b7b66ba1002e08591e8d95ef68b216e7ce1f93b
This commit is contained in:
Masayuki Nakano 2018-01-13 00:21:17 +09:00
parent b2a3e52b16
commit 31d493d9fa
5 changed files with 194 additions and 235 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

122
editor/libeditor/EditorBase.cpp
View File

@ -19,6 +19,7 @@
#include "DeleteTextTransaction.h" // for DeleteTextTransaction
#include "EditAggregateTransaction.h" // for EditAggregateTransaction
#include "EditorEventListener.h" // for EditorEventListener
#include "HTMLEditRules.h" // for HTMLEditRules
#include "InsertNodeTransaction.h" // for InsertNodeTransaction
#include "InsertTextTransaction.h" // for InsertTextTransaction
#include "JoinNodeTransaction.h" // for JoinNodeTransaction
@ -1429,7 +1430,7 @@ EditorBase::CreateNode(nsAtom* aTag,
AutoRules beginRulesSniffing(this, EditAction::createNode, nsIEditor::eNext);
{
if (!mActionListeners.IsEmpty()) {
AutoActionListenerArray listeners(mActionListeners);
for (auto& listener : listeners) {
listener->WillCreateNode(nsDependentAtomString(aTag),
@ -1453,7 +1454,12 @@ EditorBase::CreateNode(nsAtom* aTag,
mRangeUpdater.SelAdjCreateNode(pointToInsert.AsRaw());
{
if (mRules && mRules->AsHTMLEditRules()) {
RefPtr<HTMLEditRules> htmlEditRules = mRules->AsHTMLEditRules();
htmlEditRules->DidCreateNode(ret);
}
if (!mActionListeners.IsEmpty()) {
AutoActionListenerArray listeners(mActionListeners);
for (auto& listener : listeners) {
listener->DidCreateNode(nsDependentAtomString(aTag),
@ -1494,7 +1500,7 @@ EditorBase::InsertNode(nsIContent& aContentToInsert,
AutoRules beginRulesSniffing(this, EditAction::insertNode, nsIEditor::eNext);
{
if (!mActionListeners.IsEmpty()) {
AutoActionListenerArray listeners(mActionListeners);
for (auto& listener : listeners) {
listener->WillInsertNode(
@ -1509,7 +1515,12 @@ EditorBase::InsertNode(nsIContent& aContentToInsert,
mRangeUpdater.SelAdjInsertNode(aPointToInsert.AsRaw());
{
if (mRules && mRules->AsHTMLEditRules()) {
RefPtr<HTMLEditRules> htmlEditRules = mRules->AsHTMLEditRules();
htmlEditRules->DidInsertNode(aContentToInsert);
}
if (!mActionListeners.IsEmpty()) {
AutoActionListenerArray listeners(mActionListeners);
for (auto& listener : listeners) {
listener->DidInsertNode(aContentToInsert.AsDOMNode(), rv);
@ -1557,7 +1568,7 @@ EditorBase::SplitNode(const EditorRawDOMPoint& aStartOfRightNode,
// Different from CreateNode(), we need offset at start of right node only
// for WillSplitNode() since the offset is always same as the length of new
// left node.
{
if (!mActionListeners.IsEmpty()) {
AutoActionListenerArray listeners(mActionListeners);
for (auto& listener : listeners) {
// XXX Unfortunately, we need to compute offset here because the container
@ -1566,6 +1577,11 @@ EditorBase::SplitNode(const EditorRawDOMPoint& aStartOfRightNode,
listener->WillSplitNode(aStartOfRightNode.GetContainerAsDOMNode(),
aStartOfRightNode.Offset());
}
} else {
// XXX Unfortunately, storing offset of the split point in
// SplitNodeTransaction is necessary for now. We should fix this
// in a follow up bug.
Unused << aStartOfRightNode.Offset();
}
RefPtr<SplitNodeTransaction> transaction =
@ -1580,7 +1596,12 @@ EditorBase::SplitNode(const EditorRawDOMPoint& aStartOfRightNode,
mRangeUpdater.SelAdjSplitNode(*aStartOfRightNode.GetContainerAsContent(),
newNode);
{
if (mRules && mRules->AsHTMLEditRules()) {
RefPtr<HTMLEditRules> htmlEditRules = mRules->AsHTMLEditRules();
htmlEditRules->DidSplitNode(aStartOfRightNode.GetContainer(), newNode);
}
if (!mActionListeners.IsEmpty()) {
AutoActionListenerArray listeners(mActionListeners);
for (auto& listener : listeners) {
listener->DidSplitNode(aStartOfRightNode.GetContainerAsDOMNode(),
@ -1622,7 +1643,12 @@ EditorBase::JoinNodes(nsINode& aLeftNode,
// Find the number of children of the lefthand node
uint32_t oldLeftNodeLen = aLeftNode.Length();
{
if (mRules && mRules->AsHTMLEditRules()) {
RefPtr<HTMLEditRules> htmlEditRules = mRules->AsHTMLEditRules();
htmlEditRules->WillJoinNodes(aLeftNode, aRightNode);
}
if (!mActionListeners.IsEmpty()) {
AutoActionListenerArray listeners(mActionListeners);
for (auto& listener : listeners) {
listener->WillJoinNodes(aLeftNode.AsDOMNode(), aRightNode.AsDOMNode(),
@ -1642,7 +1668,12 @@ EditorBase::JoinNodes(nsINode& aLeftNode,
mRangeUpdater.SelAdjJoinNodes(aLeftNode, aRightNode, *parent, offset,
(int32_t)oldLeftNodeLen);
{
if (mRules && mRules->AsHTMLEditRules()) {
RefPtr<HTMLEditRules> htmlEditRules = mRules->AsHTMLEditRules();
htmlEditRules->DidJoinNodes(aLeftNode, aRightNode);
}
if (!mActionListeners.IsEmpty()) {
AutoActionListenerArray listeners(mActionListeners);
for (auto& listener : listeners) {
listener->DidJoinNodes(aLeftNode.AsDOMNode(), aRightNode.AsDOMNode(),
@ -1671,8 +1702,13 @@ EditorBase::DeleteNode(nsINode* aNode)
AutoRules beginRulesSniffing(this, EditAction::createNode,
nsIEditor::ePrevious);
if (mRules && mRules->AsHTMLEditRules()) {
RefPtr<HTMLEditRules> htmlEditRules = mRules->AsHTMLEditRules();
htmlEditRules->WillDeleteNode(aNode);
}
// save node location for selection updating code.
{
if (!mActionListeners.IsEmpty()) {
AutoActionListenerArray listeners(mActionListeners);
for (auto& listener : listeners) {
listener->WillDeleteNode(aNode->AsDOMNode());
@ -1684,7 +1720,7 @@ EditorBase::DeleteNode(nsINode* aNode)
nsresult rv = deleteNodeTransaction ? DoTransaction(deleteNodeTransaction) :
NS_ERROR_FAILURE;
{
if (!mActionListeners.IsEmpty()) {
AutoActionListenerArray listeners(mActionListeners);
for (auto& listener : listeners) {
listener->DidDeleteNode(aNode->AsDOMNode(), rv);
@ -2810,7 +2846,7 @@ EditorBase::InsertTextIntoTextNodeImpl(const nsAString& aStringToInsert,
}
// Let listeners know what's up
{
if (!mActionListeners.IsEmpty()) {
AutoActionListenerArray listeners(mActionListeners);
for (auto& listener : listeners) {
listener->WillInsertText(
@ -2825,8 +2861,14 @@ EditorBase::InsertTextIntoTextNodeImpl(const nsAString& aStringToInsert,
nsresult rv = DoTransaction(transaction);
EndUpdateViewBatch();
if (mRules && mRules->AsHTMLEditRules()) {
RefPtr<HTMLEditRules> htmlEditRules = mRules->AsHTMLEditRules();
htmlEditRules->DidInsertText(insertedTextNode, insertedOffset,
aStringToInsert);
}
// let listeners know what happened
{
if (!mActionListeners.IsEmpty()) {
AutoActionListenerArray listeners(mActionListeners);
for (auto& listener : listeners) {
listener->DidInsertText(
@ -2954,7 +2996,7 @@ EditorBase::SetTextImpl(Selection& aSelection, const nsAString& aString,
nsIEditor::eNext);
// Let listeners know what's up
{
if (!mActionListeners.IsEmpty()) {
AutoActionListenerArray listeners(mActionListeners);
for (auto& listener : listeners) {
if (length) {
@ -2989,8 +3031,18 @@ EditorBase::SetTextImpl(Selection& aSelection, const nsAString& aString,
mRangeUpdater.SelAdjDeleteText(&aCharData, 0, length);
mRangeUpdater.SelAdjInsertText(aCharData, 0, aString);
if (mRules && mRules->AsHTMLEditRules()) {
RefPtr<HTMLEditRules> htmlEditRules = mRules->AsHTMLEditRules();
if (length) {
htmlEditRules->DidDeleteText(&aCharData, 0, length);
}
if (!aString.IsEmpty()) {
htmlEditRules->DidInsertText(&aCharData, 0, aString);
}
}
// Let listeners know what happened
{
if (!mActionListeners.IsEmpty()) {
AutoActionListenerArray listeners(mActionListeners);
for (auto& listener : listeners) {
if (length) {
@ -3024,7 +3076,7 @@ EditorBase::DeleteText(nsGenericDOMDataNode& aCharData,
nsIEditor::ePrevious);
// Let listeners know what's up
{
if (!mActionListeners.IsEmpty()) {
AutoActionListenerArray listeners(mActionListeners);
for (auto& listener : listeners) {
listener->WillDeleteText(
@ -3035,8 +3087,13 @@ EditorBase::DeleteText(nsGenericDOMDataNode& aCharData,
nsresult rv = DoTransaction(transaction);
if (mRules && mRules->AsHTMLEditRules()) {
RefPtr<HTMLEditRules> htmlEditRules = mRules->AsHTMLEditRules();
htmlEditRules->DidDeleteText(&aCharData, aOffset, aLength);
}
// Let listeners know what happened
{
if (!mActionListeners.IsEmpty()) {
AutoActionListenerArray listeners(mActionListeners);
for (auto& listener : listeners) {
listener->DidDeleteText(
@ -3458,21 +3515,6 @@ EditorBase::GetNodeLocation(nsINode* aChild,
return parent;
}
/**
* Returns the number of things inside aNode. If aNode is text, returns number
* of characters. If not, returns number of children nodes.
*/
nsresult
EditorBase::GetLengthOfDOMNode(nsIDOMNode* aNode,
uint32_t& aCount)
{
aCount = 0;
nsCOMPtr<nsINode> node = do_QueryInterface(aNode);
NS_ENSURE_TRUE(node, NS_ERROR_NULL_POINTER);
aCount = node->Length();
return NS_OK;
}
nsIContent*
EditorBase::GetPreviousNodeInternal(nsINode& aNode,
bool aFindEditableNode,
@ -4381,8 +4423,19 @@ EditorBase::DeleteSelectionImpl(EDirection aAction,
nsCOMPtr<nsIDOMCharacterData> deleteCharData(do_QueryInterface(deleteNode));
AutoRules beginRulesSniffing(this, EditAction::deleteSelection, aAction);
if (mRules && mRules->AsHTMLEditRules()) {
if (!deleteNode) {
RefPtr<HTMLEditRules> htmlEditRules = mRules->AsHTMLEditRules();
htmlEditRules->WillDeleteSelection(selection);
} else if (!deleteCharData) {
RefPtr<HTMLEditRules> htmlEditRules = mRules->AsHTMLEditRules();
htmlEditRules->WillDeleteNode(deleteNode);
}
}
// Notify nsIEditActionListener::WillDelete[Selection|Text|Node]
{
if (!mActionListeners.IsEmpty()) {
AutoActionListenerArray listeners(mActionListeners);
if (!deleteNode) {
for (auto& listener : listeners) {
@ -4402,6 +4455,11 @@ EditorBase::DeleteSelectionImpl(EDirection aAction,
// Delete the specified amount
nsresult rv = DoTransaction(deleteSelectionTransaction);
if (mRules && mRules->AsHTMLEditRules() && deleteCharData) {
RefPtr<HTMLEditRules> htmlEditRules = mRules->AsHTMLEditRules();
htmlEditRules->DidDeleteText(deleteNode, deleteCharOffset, 1);
}
// Notify nsIEditActionListener::DidDelete[Selection|Text|Node]
{
AutoActionListenerArray listeners(mActionListeners);

9
editor/libeditor/EditorBase.h
View File

@ -755,15 +755,6 @@ public:
int32_t* outOffset);
static nsINode* GetNodeLocation(nsINode* aChild, int32_t* aOffset);
/**
* Returns the number of things inside aNode in the out-param aCount.
* @param aNode is the node to get the length of.
* If aNode is text, returns number of characters.
* If not, returns number of children nodes.
* @param aCount [OUT] the result of the above calculation.
*/
static nsresult GetLengthOfDOMNode(nsIDOMNode *aNode, uint32_t &aCount);
/**
* Get the previous node.
*/

245
editor/libeditor/HTMLEditRules.cpp
View File

@ -199,7 +199,6 @@ HTMLEditRules::InitFields()
{
mHTMLEditor = nullptr;
mDocChangeRange = nullptr;
mListenerEnabled = true;
mReturnInEmptyLIKillsList = true;
mDidDeleteSelection = false;
mDidRangedDelete = false;
@ -238,19 +237,9 @@ HTMLEditRules::InitStyleCacheArray(StyleCache aStyleCache[SIZE_STYLE_TABLE])
HTMLEditRules::~HTMLEditRules()
{
// remove ourselves as a listener to edit actions
// In some cases, we have already been removed by
// ~HTMLEditor, in which case we will get a null pointer here
// which we ignore. But this allows us to add the ability to
// switch rule sets on the fly if we want.
if (mHTMLEditor) {
mHTMLEditor->RemoveEditActionListener(this);
}
}
NS_IMPL_ISUPPORTS_CYCLE_COLLECTION_INHERITED(HTMLEditRules,
TextEditRules,
nsIEditActionListener)
NS_IMPL_ISUPPORTS_CYCLE_COLLECTION_INHERITED_0(HTMLEditRules, TextEditRules)
NS_IMPL_CYCLE_COLLECTION_INHERITED(HTMLEditRules, TextEditRules,
mDocChangeRange, mUtilRange, mNewBlock,
@ -308,16 +297,15 @@ HTMLEditRules::Init(TextEditor* aTextEditor)
AdjustSpecialBreaks();
}
// add ourselves as a listener to edit actions
return mHTMLEditor->AddEditActionListener(this);
StartToListenToEditActions();
return NS_OK;
}
nsresult
HTMLEditRules::DetachEditor()
{
if (mHTMLEditor) {
mHTMLEditor->RemoveEditActionListener(this);
}
EndListeningToEditActions();
mHTMLEditor = nullptr;
return TextEditRules::DetachEditor();
}
@ -8803,207 +8791,150 @@ HTMLEditRules::InsertBRIfNeededInternal(nsINode& aNode,
return NS_OK;
}
NS_IMETHODIMP
HTMLEditRules::WillCreateNode(const nsAString& aTag,
nsIDOMNode* aNextSiblingOfNewNode)
{
return NS_OK;
}
NS_IMETHODIMP
HTMLEditRules::DidCreateNode(const nsAString& aTag,
nsIDOMNode* aNewNode,
nsresult aResult)
void
HTMLEditRules::DidCreateNode(Element* aNewElement)
{
if (!mListenerEnabled) {
return NS_OK;
return;
}
if (NS_WARN_IF(!aNewElement)) {
return;
}
// assumption that Join keeps the righthand node
nsresult rv = mUtilRange->SelectNode(aNewNode);
NS_ENSURE_SUCCESS(rv, rv);
return UpdateDocChangeRange(mUtilRange);
IgnoredErrorResult error;
mUtilRange->SelectNode(*aNewElement, error);
if (NS_WARN_IF(error.Failed())) {
return;
}
UpdateDocChangeRange(mUtilRange);
}
NS_IMETHODIMP
HTMLEditRules::WillInsertNode(nsIDOMNode* aNode,
nsIDOMNode* aNextSiblingOfNewNode)
{
return NS_OK;
}
NS_IMETHODIMP
HTMLEditRules::DidInsertNode(nsIDOMNode* aNode,
nsresult aResult)
void
HTMLEditRules::DidInsertNode(nsIContent& aContent)
{
if (!mListenerEnabled) {
return NS_OK;
return;
}
nsresult rv = mUtilRange->SelectNode(aNode);
NS_ENSURE_SUCCESS(rv, rv);
return UpdateDocChangeRange(mUtilRange);
IgnoredErrorResult error;
mUtilRange->SelectNode(aContent, error);
if (NS_WARN_IF(error.Failed())) {
return;
}
UpdateDocChangeRange(mUtilRange);
}
NS_IMETHODIMP
HTMLEditRules::WillDeleteNode(nsIDOMNode* aChild)
void
HTMLEditRules::WillDeleteNode(nsINode* aChild)
{
if (!mListenerEnabled) {
return NS_OK;
return;
}
nsresult rv = mUtilRange->SelectNode(aChild);
NS_ENSURE_SUCCESS(rv, rv);
return UpdateDocChangeRange(mUtilRange);
if (NS_WARN_IF(!aChild)) {
return;
}
IgnoredErrorResult error;
mUtilRange->SelectNode(*aChild, error);
if (NS_WARN_IF(error.Failed())) {
return;
}
UpdateDocChangeRange(mUtilRange);
}
NS_IMETHODIMP
HTMLEditRules::DidDeleteNode(nsIDOMNode* aChild,
nsresult aResult)
{
return NS_OK;
}
NS_IMETHODIMP
HTMLEditRules::WillSplitNode(nsIDOMNode* aExistingRightNode,
int32_t aOffset)
{
return NS_OK;
}
NS_IMETHODIMP
HTMLEditRules::DidSplitNode(nsIDOMNode* aExistingRightNode,
nsIDOMNode* aNewLeftNode)
void
HTMLEditRules::DidSplitNode(nsINode* aExistingRightNode,
nsINode* aNewLeftNode)
{
if (!mListenerEnabled) {
return NS_OK;
return;
}
nsCOMPtr<nsINode> newLeftNode = do_QueryInterface(aNewLeftNode);
nsCOMPtr<nsINode> existingRightNode = do_QueryInterface(aExistingRightNode);
nsresult rv = mUtilRange->SetStartAndEnd(newLeftNode, 0,
existingRightNode, 0);
nsresult rv = mUtilRange->SetStartAndEnd(aNewLeftNode, 0,
aExistingRightNode, 0);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
return;
}
return UpdateDocChangeRange(mUtilRange);
UpdateDocChangeRange(mUtilRange);
}
NS_IMETHODIMP
HTMLEditRules::WillJoinNodes(nsIDOMNode* aLeftNode,
nsIDOMNode* aRightNode,
nsIDOMNode* aParent)
void
HTMLEditRules::WillJoinNodes(nsINode& aLeftNode,
nsINode& aRightNode)
{
if (!mListenerEnabled) {
return NS_OK;
return;
}
// remember split point
return EditorBase::GetLengthOfDOMNode(aLeftNode, mJoinOffset);
mJoinOffset = aLeftNode.Length();
}
NS_IMETHODIMP
HTMLEditRules::DidJoinNodes(nsIDOMNode* aLeftNode,
nsIDOMNode* aRightNode,
nsIDOMNode* aParent,
nsresult aResult)
void
HTMLEditRules::DidJoinNodes(nsINode& aLeftNode,
nsINode& aRightNode)
{
if (!mListenerEnabled) {
return NS_OK;
return;
}
nsCOMPtr<nsINode> rightNode = do_QueryInterface(aRightNode);
// assumption that Join keeps the righthand node
nsresult rv = mUtilRange->CollapseTo(rightNode, mJoinOffset);
nsresult rv = mUtilRange->CollapseTo(&aRightNode, mJoinOffset);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
return;
}
return UpdateDocChangeRange(mUtilRange);
UpdateDocChangeRange(mUtilRange);
}
NS_IMETHODIMP
HTMLEditRules::WillInsertText(nsIDOMCharacterData* aTextNode,
int32_t aOffset,
const nsAString& aString)
{
return NS_OK;
}
NS_IMETHODIMP
HTMLEditRules::DidInsertText(nsIDOMCharacterData* aTextNode,
void
HTMLEditRules::DidInsertText(nsINode* aTextNode,
int32_t aOffset,
const nsAString& aString,
nsresult aResult)
const nsAString& aString)
{
if (!mListenerEnabled) {
return NS_OK;
return;
}
int32_t length = aString.Length();
nsCOMPtr<nsINode> theNode = do_QueryInterface(aTextNode);
nsresult rv = mUtilRange->SetStartAndEnd(theNode, aOffset,
theNode, aOffset + length);
nsresult rv = mUtilRange->SetStartAndEnd(aTextNode, aOffset,
aTextNode, aOffset + length);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
return;
}
return UpdateDocChangeRange(mUtilRange);
UpdateDocChangeRange(mUtilRange);
}
NS_IMETHODIMP
HTMLEditRules::WillDeleteText(nsIDOMCharacterData* aTextNode,
int32_t aOffset,
int32_t aLength)
{
return NS_OK;
}
NS_IMETHODIMP
HTMLEditRules::DidDeleteText(nsIDOMCharacterData* aTextNode,
void
HTMLEditRules::DidDeleteText(nsINode* aTextNode,
int32_t aOffset,
int32_t aLength,
nsresult aResult)
int32_t aLength)
{
if (!mListenerEnabled) {
return NS_OK;
return;
}
nsCOMPtr<nsINode> theNode = do_QueryInterface(aTextNode);
nsresult rv = mUtilRange->CollapseTo(theNode, aOffset);
nsresult rv = mUtilRange->CollapseTo(aTextNode, aOffset);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
return;
}
return UpdateDocChangeRange(mUtilRange);
UpdateDocChangeRange(mUtilRange);
}
NS_IMETHODIMP
HTMLEditRules::WillDeleteSelection(nsISelection* aSelection)
void
HTMLEditRules::WillDeleteSelection(Selection* aSelection)
{
if (!mListenerEnabled) {
return NS_OK;
return;
}
if (NS_WARN_IF(!aSelection)) {
return NS_ERROR_INVALID_ARG;
return;
}
RefPtr<Selection> selection = aSelection->AsSelection();
// get the (collapsed) selection location
nsCOMPtr<nsINode> startNode;
int32_t startOffset;
nsresult rv =
EditorBase::GetStartNodeAndOffset(selection,
getter_AddRefs(startNode), &startOffset);
EditorRawDOMPoint startPoint = EditorBase::GetStartPoint(aSelection);
if (NS_WARN_IF(!startPoint.IsSet())) {
return;
}
EditorRawDOMPoint endPoint = EditorBase::GetEndPoint(aSelection);
if (NS_WARN_IF(!endPoint.IsSet())) {
return;
}
nsresult rv = mUtilRange->SetStartAndEnd(startPoint, endPoint);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
return;
}
nsCOMPtr<nsINode> endNode;
int32_t endOffset;
rv = EditorBase::GetEndNodeAndOffset(selection,
getter_AddRefs(endNode), &endOffset);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
rv = mUtilRange->SetStartAndEnd(startNode, startOffset, endNode, endOffset);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
return UpdateDocChangeRange(mUtilRange);
}
NS_IMETHODIMP
HTMLEditRules::DidDeleteSelection(nsISelection *aSelection)
{
return NS_OK;
UpdateDocChangeRange(mUtilRange);
}
// Let's remove all alignment hints in the children of aNode; it can

44
editor/libeditor/HTMLEditRules.h
View File

@ -11,7 +11,6 @@
#include "mozilla/SelectionState.h"
#include "mozilla/TextEditRules.h"
#include "nsCOMPtr.h"
#include "nsIEditActionListener.h"
#include "nsIEditor.h"
#include "nsIHTMLEditor.h"
#include "nsISupportsImpl.h"
@ -78,7 +77,6 @@ struct StyleCache final : public PropItem
#define SIZE_STYLE_TABLE 19
class HTMLEditRules : public TextEditRules
, public nsIEditActionListener
{
public:
NS_DECL_ISUPPORTS_INHERITED
@ -110,37 +108,23 @@ public:
nsresult GetParagraphState(bool* aMixed, nsAString& outFormat);
nsresult MakeSureElemStartsOrEndsOnCR(nsINode& aNode);
// nsIEditActionListener methods
void DidCreateNode(Element* aNewElement);
void DidInsertNode(nsIContent& aNode);
void WillDeleteNode(nsINode* aChild);
void DidSplitNode(nsINode* aExistingRightNode,
nsINode* aNewLeftNode);
void WillJoinNodes(nsINode& aLeftNode, nsINode& aRightNode);
void DidJoinNodes(nsINode& aLeftNode, nsINode& aRightNode);
void DidInsertText(nsINode* aTextNode, int32_t aOffset,
const nsAString& aString);
void DidDeleteText(nsINode* aTextNode, int32_t aOffset, int32_t aLength);
void WillDeleteSelection(Selection* aSelection);
NS_IMETHOD WillCreateNode(const nsAString& aTag,
nsIDOMNode* aNextSiblingOfNewNode) override;
NS_IMETHOD DidCreateNode(const nsAString& aTag, nsIDOMNode* aNewNode,
nsresult aResult) override;
NS_IMETHOD WillInsertNode(nsIDOMNode* aNode,
nsIDOMNode* aNextSiblingOfNewNode) override;
NS_IMETHOD DidInsertNode(nsIDOMNode* aNode, nsresult aResult) override;
NS_IMETHOD WillDeleteNode(nsIDOMNode* aChild) override;
NS_IMETHOD DidDeleteNode(nsIDOMNode* aChild, nsresult aResult) override;
NS_IMETHOD WillSplitNode(nsIDOMNode* aExistingRightNode,
int32_t aOffset) override;
NS_IMETHOD DidSplitNode(nsIDOMNode* aExistingRightNode,
nsIDOMNode* aNewLeftNode) override;
NS_IMETHOD WillJoinNodes(nsIDOMNode* aLeftNode, nsIDOMNode* aRightNode,
nsIDOMNode* aParent) override;
NS_IMETHOD DidJoinNodes(nsIDOMNode* aLeftNode, nsIDOMNode* aRightNode,
nsIDOMNode* aParent, nsresult aResult) override;
NS_IMETHOD WillInsertText(nsIDOMCharacterData* aTextNode, int32_t aOffset,
const nsAString &aString) override;
NS_IMETHOD DidInsertText(nsIDOMCharacterData* aTextNode, int32_t aOffset,
const nsAString &aString, nsresult aResult) override;
NS_IMETHOD WillDeleteText(nsIDOMCharacterData* aTextNode, int32_t aOffset,
int32_t aLength) override;
NS_IMETHOD DidDeleteText(nsIDOMCharacterData* aTextNode, int32_t aOffset,
int32_t aLength, nsresult aResult) override;
NS_IMETHOD WillDeleteSelection(nsISelection* aSelection) override;
NS_IMETHOD DidDeleteSelection(nsISelection* aSelection) override;
void DeleteNodeIfCollapsedText(nsINode& aNode);
void StartToListenToEditActions() { mListenerEnabled = true; }
void EndListeningToEditActions() { mListenerEnabled = false; }
protected:
virtual ~HTMLEditRules();

9
editor/libeditor/HTMLEditor.cpp
View File

@ -135,13 +135,8 @@ HTMLEditor::HTMLEditor()
HTMLEditor::~HTMLEditor()
{
// remove the rules as an action listener. Else we get a bad
// ownership loop later on. it's ok if the rules aren't a listener;
// we ignore the error.
if (mRules) {
nsCOMPtr<nsIEditActionListener> listener =
static_cast<nsIEditActionListener*>(mRules->AsHTMLEditRules());
RemoveEditActionListener(listener);
if (mRules && mRules->AsHTMLEditRules()) {
mRules->AsHTMLEditRules()->EndListeningToEditActions();
}
//the autopointers will clear themselves up.