summaryrefslogtreecommitdiffstats
path: root/editor/txmgr/TransactionManager.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'editor/txmgr/TransactionManager.cpp')
-rw-r--r--editor/txmgr/TransactionManager.cpp509
1 files changed, 509 insertions, 0 deletions
diff --git a/editor/txmgr/TransactionManager.cpp b/editor/txmgr/TransactionManager.cpp
new file mode 100644
index 0000000000..ad4d641d56
--- /dev/null
+++ b/editor/txmgr/TransactionManager.cpp
@@ -0,0 +1,509 @@
+/* -*- 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/TransactionManager.h"
+
+#include "mozilla/Assertions.h"
+#include "mozilla/DebugOnly.h"
+#include "mozilla/HTMLEditor.h"
+#include "mozilla/mozalloc.h"
+#include "mozilla/TransactionStack.h"
+#include "nsCOMPtr.h"
+#include "nsDebug.h"
+#include "nsError.h"
+#include "nsISupports.h"
+#include "nsISupportsUtils.h"
+#include "nsITransaction.h"
+#include "nsIWeakReference.h"
+#include "TransactionItem.h"
+
+namespace mozilla {
+
+TransactionManager::TransactionManager(int32_t aMaxTransactionCount)
+ : mMaxTransactionCount(aMaxTransactionCount),
+ mDoStack(TransactionStack::FOR_UNDO),
+ mUndoStack(TransactionStack::FOR_UNDO),
+ mRedoStack(TransactionStack::FOR_REDO) {}
+
+NS_IMPL_CYCLE_COLLECTION_CLASS(TransactionManager)
+
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(TransactionManager)
+ NS_IMPL_CYCLE_COLLECTION_UNLINK(mHTMLEditor)
+ tmp->mDoStack.DoUnlink();
+ tmp->mUndoStack.DoUnlink();
+ tmp->mRedoStack.DoUnlink();
+ NS_IMPL_CYCLE_COLLECTION_UNLINK_WEAK_REFERENCE
+NS_IMPL_CYCLE_COLLECTION_UNLINK_END
+
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(TransactionManager)
+ NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mHTMLEditor)
+ tmp->mDoStack.DoTraverse(cb);
+ tmp->mUndoStack.DoTraverse(cb);
+ tmp->mRedoStack.DoTraverse(cb);
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(TransactionManager)
+ NS_INTERFACE_MAP_ENTRY(nsITransactionManager)
+ NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)
+ NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsITransactionManager)
+NS_INTERFACE_MAP_END
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(TransactionManager)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(TransactionManager)
+
+void TransactionManager::Attach(HTMLEditor& aHTMLEditor) {
+ mHTMLEditor = &aHTMLEditor;
+}
+
+void TransactionManager::Detach(const HTMLEditor& aHTMLEditor) {
+ MOZ_DIAGNOSTIC_ASSERT_IF(mHTMLEditor, &aHTMLEditor == mHTMLEditor);
+ if (mHTMLEditor == &aHTMLEditor) {
+ mHTMLEditor = nullptr;
+ }
+}
+
+MOZ_CAN_RUN_SCRIPT_BOUNDARY NS_IMETHODIMP
+TransactionManager::DoTransaction(nsITransaction* aTransaction) {
+ if (NS_WARN_IF(!aTransaction)) {
+ return NS_ERROR_INVALID_ARG;
+ }
+ OwningNonNull<nsITransaction> transaction = *aTransaction;
+
+ nsresult rv = BeginTransaction(transaction, nullptr);
+ if (NS_FAILED(rv)) {
+ NS_WARNING("TransactionManager::BeginTransaction() failed");
+ DidDoNotify(transaction, rv);
+ return rv;
+ }
+
+ rv = EndTransaction(false);
+ NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+ "TransactionManager::EndTransaction() failed");
+
+ DidDoNotify(transaction, rv);
+ return rv;
+}
+
+MOZ_CAN_RUN_SCRIPT NS_IMETHODIMP TransactionManager::UndoTransaction() {
+ return Undo();
+}
+
+nsresult TransactionManager::Undo() {
+ // It's possible to be called Undo() again while the transaction manager is
+ // executing a transaction's DoTransaction() method. If this happens,
+ // the Undo() request is ignored, and we return NS_ERROR_FAILURE. This
+ // may occur if a mutation event listener calls document.execCommand("undo").
+ if (NS_WARN_IF(!mDoStack.IsEmpty())) {
+ return NS_ERROR_FAILURE;
+ }
+
+ // Peek at the top of the undo stack. Don't remove the transaction
+ // until it has successfully completed.
+ RefPtr<TransactionItem> transactionItem = mUndoStack.Peek();
+ if (!transactionItem) {
+ // Bail if there's nothing on the stack.
+ return NS_OK;
+ }
+
+ nsCOMPtr<nsITransaction> transaction = transactionItem->GetTransaction();
+ nsresult rv = transactionItem->UndoTransaction(this);
+ NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+ "TransactionItem::UndoTransaction() failed");
+ if (NS_SUCCEEDED(rv)) {
+ transactionItem = mUndoStack.Pop();
+ mRedoStack.Push(transactionItem.forget());
+ }
+
+ if (transaction) {
+ DidUndoNotify(*transaction, rv);
+ }
+ return rv;
+}
+
+MOZ_CAN_RUN_SCRIPT_BOUNDARY NS_IMETHODIMP
+TransactionManager::RedoTransaction() {
+ return Redo();
+}
+
+nsresult TransactionManager::Redo() {
+ // It's possible to be called Redo() again while the transaction manager is
+ // executing a transaction's DoTransaction() method. If this happens,
+ // the Redo() request is ignored, and we return NS_ERROR_FAILURE. This
+ // may occur if a mutation event listener calls document.execCommand("redo").
+ if (NS_WARN_IF(!mDoStack.IsEmpty())) {
+ return NS_ERROR_FAILURE;
+ }
+
+ // Peek at the top of the redo stack. Don't remove the transaction
+ // until it has successfully completed.
+ RefPtr<TransactionItem> transactionItem = mRedoStack.Peek();
+ if (!transactionItem) {
+ // Bail if there's nothing on the stack.
+ return NS_OK;
+ }
+
+ nsCOMPtr<nsITransaction> transaction = transactionItem->GetTransaction();
+ nsresult rv = transactionItem->RedoTransaction(this);
+ NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+ "TransactionItem::RedoTransaction() failed");
+ if (NS_SUCCEEDED(rv)) {
+ transactionItem = mRedoStack.Pop();
+ mUndoStack.Push(transactionItem.forget());
+ }
+
+ if (transaction) {
+ DidRedoNotify(*transaction, rv);
+ }
+ return rv;
+}
+
+NS_IMETHODIMP TransactionManager::Clear() {
+ return NS_WARN_IF(!ClearUndoRedo()) ? NS_ERROR_FAILURE : NS_OK;
+}
+
+NS_IMETHODIMP TransactionManager::BeginBatch(nsISupports* aData) {
+ nsresult rv = BeginBatchInternal(aData);
+ NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+ "TransactionManager::BeginBatchInternal() failed");
+ return rv;
+}
+
+nsresult TransactionManager::BeginBatchInternal(nsISupports* aData) {
+ // We can batch independent transactions together by simply pushing
+ // a dummy transaction item on the do stack. This dummy transaction item
+ // will be popped off the do stack, and then pushed on the undo stack
+ // in EndBatch().
+ nsresult rv = BeginTransaction(nullptr, aData);
+ NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+ "TransactionManager::BeginTransaction() failed");
+ return rv;
+}
+
+NS_IMETHODIMP TransactionManager::EndBatch(bool aAllowEmpty) {
+ nsresult rv = EndBatchInternal(aAllowEmpty);
+ NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+ "TransactionManager::EndBatchInternal() failed");
+ return rv;
+}
+
+nsresult TransactionManager::EndBatchInternal(bool aAllowEmpty) {
+ // XXX: Need to add some mechanism to detect the case where the transaction
+ // at the top of the do stack isn't the dummy transaction, so we can
+ // throw an error!! This can happen if someone calls EndBatch() within
+ // the DoTransaction() method of a transaction.
+ //
+ // For now, we can detect this case by checking the value of the
+ // dummy transaction's mTransaction field. If it is our dummy
+ // transaction, it should be nullptr. This may not be true in the
+ // future when we allow users to execute a transaction when beginning
+ // a batch!!!!
+ RefPtr<TransactionItem> transactionItem = mDoStack.Peek();
+ if (NS_WARN_IF(!transactionItem)) {
+ return NS_ERROR_FAILURE;
+ }
+ nsCOMPtr<nsITransaction> transaction = transactionItem->GetTransaction();
+ if (NS_WARN_IF(transaction)) {
+ return NS_ERROR_FAILURE;
+ }
+
+ nsresult rv = EndTransaction(aAllowEmpty);
+ NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+ "TransactionManager::EndTransaction() failed");
+ return rv;
+}
+
+NS_IMETHODIMP TransactionManager::GetNumberOfUndoItems(int32_t* aNumItems) {
+ *aNumItems = static_cast<int32_t>(NumberOfUndoItems());
+ MOZ_ASSERT(*aNumItems >= 0);
+ return NS_OK;
+}
+
+NS_IMETHODIMP TransactionManager::GetNumberOfRedoItems(int32_t* aNumItems) {
+ *aNumItems = static_cast<int32_t>(NumberOfRedoItems());
+ MOZ_ASSERT(*aNumItems >= 0);
+ return NS_OK;
+}
+
+NS_IMETHODIMP TransactionManager::GetMaxTransactionCount(int32_t* aMaxCount) {
+ if (NS_WARN_IF(!aMaxCount)) {
+ return NS_ERROR_INVALID_ARG;
+ }
+ *aMaxCount = mMaxTransactionCount;
+ return NS_OK;
+}
+
+NS_IMETHODIMP TransactionManager::SetMaxTransactionCount(int32_t aMaxCount) {
+ return NS_WARN_IF(!EnableUndoRedo(aMaxCount)) ? NS_ERROR_FAILURE : NS_OK;
+}
+
+bool TransactionManager::EnableUndoRedo(int32_t aMaxTransactionCount) {
+ // It is illegal to call EnableUndoRedo() while the transaction manager is
+ // executing a transaction's DoTransaction() method because the undo and redo
+ // stacks might get pruned. If this happens, the EnableUndoRedo() request is
+ // ignored, and we return false.
+ if (NS_WARN_IF(!mDoStack.IsEmpty())) {
+ return false;
+ }
+
+ // If aMaxTransactionCount is 0, it means to disable undo/redo.
+ if (!aMaxTransactionCount) {
+ mUndoStack.Clear();
+ mRedoStack.Clear();
+ mMaxTransactionCount = 0;
+ return true;
+ }
+
+ // If aMaxTransactionCount is less than zero, the user wants unlimited
+ // levels of undo! No need to prune the undo or redo stacks.
+ if (aMaxTransactionCount < 0) {
+ mMaxTransactionCount = -1;
+ return true;
+ }
+
+ // If new max transaction count is greater than or equal to current max
+ // transaction count, we don't need to remove any transactions.
+ if (mMaxTransactionCount >= 0 &&
+ mMaxTransactionCount <= aMaxTransactionCount) {
+ mMaxTransactionCount = aMaxTransactionCount;
+ return true;
+ }
+
+ // If aMaxTransactionCount is greater than the number of transactions that
+ // currently exist on the undo and redo stack, there is no need to prune the
+ // undo or redo stacks.
+ size_t numUndoItems = NumberOfUndoItems();
+ size_t numRedoItems = NumberOfRedoItems();
+ size_t total = numUndoItems + numRedoItems;
+ size_t newMaxTransactionCount = static_cast<size_t>(aMaxTransactionCount);
+ if (newMaxTransactionCount > total) {
+ mMaxTransactionCount = aMaxTransactionCount;
+ return true;
+ }
+
+ // Try getting rid of some transactions on the undo stack! Start at
+ // the bottom of the stack and pop towards the top.
+ for (; numUndoItems && (numRedoItems + numUndoItems) > newMaxTransactionCount;
+ numUndoItems--) {
+ RefPtr<TransactionItem> transactionItem = mUndoStack.PopBottom();
+ MOZ_ASSERT(transactionItem);
+ }
+
+ // If necessary, get rid of some transactions on the redo stack! Start at
+ // the bottom of the stack and pop towards the top.
+ for (; numRedoItems && (numRedoItems + numUndoItems) > newMaxTransactionCount;
+ numRedoItems--) {
+ RefPtr<TransactionItem> transactionItem = mRedoStack.PopBottom();
+ MOZ_ASSERT(transactionItem);
+ }
+
+ mMaxTransactionCount = aMaxTransactionCount;
+ return true;
+}
+
+NS_IMETHODIMP TransactionManager::PeekUndoStack(nsITransaction** aTransaction) {
+ MOZ_ASSERT(aTransaction);
+ *aTransaction = PeekUndoStack().take();
+ return NS_OK;
+}
+
+already_AddRefed<nsITransaction> TransactionManager::PeekUndoStack() {
+ RefPtr<TransactionItem> transactionItem = mUndoStack.Peek();
+ if (!transactionItem) {
+ return nullptr;
+ }
+ return transactionItem->GetTransaction();
+}
+
+NS_IMETHODIMP TransactionManager::PeekRedoStack(nsITransaction** aTransaction) {
+ MOZ_ASSERT(aTransaction);
+ *aTransaction = PeekRedoStack().take();
+ return NS_OK;
+}
+
+already_AddRefed<nsITransaction> TransactionManager::PeekRedoStack() {
+ RefPtr<TransactionItem> transactionItem = mRedoStack.Peek();
+ if (!transactionItem) {
+ return nullptr;
+ }
+ return transactionItem->GetTransaction();
+}
+
+nsresult TransactionManager::BatchTopUndo() {
+ if (mUndoStack.GetSize() < 2) {
+ // Not enough transactions to merge into one batch.
+ return NS_OK;
+ }
+
+ RefPtr<TransactionItem> lastUndo = mUndoStack.Pop();
+ MOZ_ASSERT(lastUndo, "There should be at least two transactions.");
+
+ RefPtr<TransactionItem> previousUndo = mUndoStack.Peek();
+ MOZ_ASSERT(previousUndo, "There should be at least two transactions.");
+
+ nsresult rv = previousUndo->AddChild(*lastUndo);
+ NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "TransactionItem::AddChild() failed");
+
+ // Transfer data from the transactions that is going to be
+ // merged to the transaction that it is being merged with.
+ nsCOMArray<nsISupports>& lastData = lastUndo->GetData();
+ nsCOMArray<nsISupports>& previousData = previousUndo->GetData();
+ if (!previousData.AppendObjects(lastData)) {
+ NS_WARNING("nsISupports::AppendObjects() failed");
+ return NS_ERROR_FAILURE;
+ }
+ lastData.Clear();
+ return rv;
+}
+
+nsresult TransactionManager::RemoveTopUndo() {
+ if (mUndoStack.IsEmpty()) {
+ return NS_OK;
+ }
+
+ RefPtr<TransactionItem> lastUndo = mUndoStack.Pop();
+ return NS_OK;
+}
+
+NS_IMETHODIMP TransactionManager::ClearUndoStack() {
+ if (NS_WARN_IF(!mDoStack.IsEmpty())) {
+ return NS_ERROR_FAILURE;
+ }
+ mUndoStack.Clear();
+ return NS_OK;
+}
+
+NS_IMETHODIMP TransactionManager::ClearRedoStack() {
+ if (NS_WARN_IF(!mDoStack.IsEmpty())) {
+ return NS_ERROR_FAILURE;
+ }
+ mRedoStack.Clear();
+ return NS_OK;
+}
+
+void TransactionManager::DidDoNotify(nsITransaction& aTransaction,
+ nsresult aDoResult) {
+ if (mHTMLEditor) {
+ RefPtr<HTMLEditor> htmlEditor(mHTMLEditor);
+ htmlEditor->DidDoTransaction(*this, aTransaction, aDoResult);
+ }
+}
+
+void TransactionManager::DidUndoNotify(nsITransaction& aTransaction,
+ nsresult aUndoResult) {
+ if (mHTMLEditor) {
+ RefPtr<HTMLEditor> htmlEditor(mHTMLEditor);
+ htmlEditor->DidUndoTransaction(*this, aTransaction, aUndoResult);
+ }
+}
+
+void TransactionManager::DidRedoNotify(nsITransaction& aTransaction,
+ nsresult aRedoResult) {
+ if (mHTMLEditor) {
+ RefPtr<HTMLEditor> htmlEditor(mHTMLEditor);
+ htmlEditor->DidRedoTransaction(*this, aTransaction, aRedoResult);
+ }
+}
+
+nsresult TransactionManager::BeginTransaction(nsITransaction* aTransaction,
+ nsISupports* aData) {
+ // XXX: POSSIBLE OPTIMIZATION
+ // We could use a factory that pre-allocates/recycles transaction items.
+ RefPtr<TransactionItem> transactionItem = new TransactionItem(aTransaction);
+
+ if (aData) {
+ nsCOMArray<nsISupports>& data = transactionItem->GetData();
+ data.AppendObject(aData);
+ }
+
+ mDoStack.Push(transactionItem);
+
+ nsresult rv = transactionItem->DoTransaction();
+ if (NS_FAILED(rv)) {
+ NS_WARNING("TransactionItem::DoTransaction() failed");
+ transactionItem = mDoStack.Pop();
+ }
+ return rv;
+}
+
+nsresult TransactionManager::EndTransaction(bool aAllowEmpty) {
+ RefPtr<TransactionItem> transactionItem = mDoStack.Pop();
+ if (NS_WARN_IF(!transactionItem)) {
+ return NS_ERROR_FAILURE;
+ }
+
+ nsCOMPtr<nsITransaction> transaction = transactionItem->GetTransaction();
+ if (!transaction && !aAllowEmpty) {
+ // If we get here, the transaction must be a dummy batch transaction
+ // created by BeginBatch(). If it contains no children, get rid of it!
+ if (!transactionItem->NumberOfChildren()) {
+ return NS_OK;
+ }
+ }
+
+ // Check if the transaction is transient. If it is, there's nothing
+ // more to do, just return.
+ if (transaction) {
+ bool isTransient = false;
+ nsresult rv = transaction->GetIsTransient(&isTransient);
+ if (NS_FAILED(rv)) {
+ NS_WARNING("nsITransaction::GetIsTransient() failed");
+ return rv;
+ }
+ // XXX: Should we be clearing the redo stack if the transaction
+ // is transient and there is nothing on the do stack?
+ if (isTransient) {
+ return NS_OK;
+ }
+ }
+
+ if (!mMaxTransactionCount) {
+ return NS_OK;
+ }
+
+ // Check if there is a transaction on the do stack. If there is,
+ // the current transaction is a "sub" transaction, and should
+ // be added to the transaction at the top of the do stack.
+ RefPtr<TransactionItem> topTransactionItem = mDoStack.Peek();
+ if (topTransactionItem) {
+ // XXX: What do we do if this fails?
+ nsresult rv = topTransactionItem->AddChild(*transactionItem);
+ NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+ "TransactionItem::AddChild() failed");
+ return rv;
+ }
+
+ // The transaction succeeded, so clear the redo stack.
+ mRedoStack.Clear();
+
+ // Check if we can coalesce this transaction with the one at the top
+ // of the undo stack.
+ topTransactionItem = mUndoStack.Peek();
+ if (transaction && topTransactionItem) {
+ bool didMerge = false;
+ nsCOMPtr<nsITransaction> topTransaction =
+ topTransactionItem->GetTransaction();
+ if (topTransaction) {
+ nsresult rv = topTransaction->Merge(transaction, &didMerge);
+ if (didMerge) {
+ return rv;
+ }
+ NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
+ "nsITransaction::Merge() failed, but ignored");
+ }
+ }
+
+ // Check to see if we've hit the max level of undo. If so,
+ // pop the bottom transaction off the undo stack and release it!
+ int32_t sz = mUndoStack.GetSize();
+ if (mMaxTransactionCount > 0 && sz >= mMaxTransactionCount) {
+ RefPtr<TransactionItem> overflow = mUndoStack.PopBottom();
+ }
+
+ // Push the transaction on the undo stack:
+ mUndoStack.Push(transactionItem.forget());
+ return NS_OK;
+}
+
+} // namespace mozilla