The Tor Browser: editor/txmgr/src/nsTransactionManager.cpp@97036ab72558 (annotated)

editor/txmgr/src/nsTransactionManager.cpp@97036ab72558 (annotated)

editor/txmgr/src/nsTransactionManager.cpp

Tue, 06 Jan 2015 21:39:09 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Tue, 06 Jan 2015 21:39:09 +0100
branch: TOR_BUG_9701
changeset 8: 97036ab72558
permissions: -rw-r--r--

Conditionally force memory storage according to privacy.thirdparty.isolate;
This solves Tor bug #9701, complying with disk avoidance documented in
https://www.torproject.org/projects/torbrowser/design/#disk-avoidance.

 /* -*- 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/Assertions.h"
 #include "mozilla/mozalloc.h"
 #include "nsAutoPtr.h"
 #include "nsCOMPtr.h"
 #include "nsDebug.h"
 #include "nsError.h"
 #include "nsISupportsBase.h"
 #include "nsISupportsUtils.h"
 #include "nsITransaction.h"
 #include "nsITransactionList.h"
 #include "nsITransactionListener.h"
 #include "nsIWeakReference.h"
 #include "nsTransactionItem.h"
 #include "nsTransactionList.h"
 #include "nsTransactionManager.h"
 #include "nsTransactionStack.h"
 nsTransactionManager::nsTransactionManager(int32_t aMaxTransactionCount)
   : mMaxTransactionCount(aMaxTransactionCount)
   , mDoStack(nsTransactionStack::FOR_UNDO)
   , mUndoStack(nsTransactionStack::FOR_UNDO)
   , mRedoStack(nsTransactionStack::FOR_REDO)
 {
 }
 nsTransactionManager::~nsTransactionManager()
 {
 }
 NS_IMPL_CYCLE_COLLECTION_CLASS(nsTransactionManager)
 NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(nsTransactionManager)
   NS_IMPL_CYCLE_COLLECTION_UNLINK(mListeners)
   tmp->mDoStack.DoUnlink();
   tmp->mUndoStack.DoUnlink();
   tmp->mRedoStack.DoUnlink();
 NS_IMPL_CYCLE_COLLECTION_UNLINK_END
 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(nsTransactionManager)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mListeners)
   tmp->mDoStack.DoTraverse(cb);
   tmp->mUndoStack.DoTraverse(cb);
   tmp->mRedoStack.DoTraverse(cb);
 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsTransactionManager)
   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(nsTransactionManager)
 NS_IMPL_CYCLE_COLLECTING_RELEASE(nsTransactionManager)
 NS_IMETHODIMP
 nsTransactionManager::DoTransaction(nsITransaction *aTransaction)
 {
   nsresult result;
   NS_ENSURE_TRUE(aTransaction, NS_ERROR_NULL_POINTER);
   bool doInterrupt = false;
   result = WillDoNotify(aTransaction, &doInterrupt);
   if (NS_FAILED(result)) {
     return result;
   }
   if (doInterrupt) {
     return NS_OK;
   }
   result = BeginTransaction(aTransaction, nullptr);
   if (NS_FAILED(result)) {
     DidDoNotify(aTransaction, result);
     return result;
   }
   result = EndTransaction(false);
   nsresult result2 = DidDoNotify(aTransaction, result);
   if (NS_SUCCEEDED(result))
     result = result2;
   return result;
 }
 NS_IMETHODIMP
 nsTransactionManager::UndoTransaction()
 {
   nsresult result       = NS_OK;
   // It is illegal to call UndoTransaction() while the transaction manager is
   // executing a  transaction's DoTransaction() method! If this happens,
   // the UndoTransaction() request is ignored, and we return NS_ERROR_FAILURE.
   nsRefPtr<nsTransactionItem> tx = mDoStack.Peek();
   if (tx) {
     return NS_ERROR_FAILURE;
   }
   // Peek at the top of the undo stack. Don't remove the transaction
   // until it has successfully completed.
   tx = mUndoStack.Peek();
   // Bail if there's nothing on the stack.
   if (!tx) {
     return NS_OK;
   }
   nsCOMPtr<nsITransaction> t = tx->GetTransaction();
   bool doInterrupt = false;
   result = WillUndoNotify(t, &doInterrupt);
   if (NS_FAILED(result)) {
     return result;
   }
   if (doInterrupt) {
     return NS_OK;
   }
   result = tx->UndoTransaction(this);
   if (NS_SUCCEEDED(result)) {
     tx = mUndoStack.Pop();
     mRedoStack.Push(tx);
   }
   nsresult result2 = DidUndoNotify(t, result);
   if (NS_SUCCEEDED(result))
     result = result2;
   return result;
 }
 NS_IMETHODIMP
 nsTransactionManager::RedoTransaction()
 {
   nsresult result       = NS_OK;
   // It is illegal to call RedoTransaction() while the transaction manager is
   // executing a  transaction's DoTransaction() method! If this happens,
   // the RedoTransaction() request is ignored, and we return NS_ERROR_FAILURE.
   nsRefPtr<nsTransactionItem> tx = mDoStack.Peek();
   if (tx) {
     return NS_ERROR_FAILURE;
   }
   // Peek at the top of the redo stack. Don't remove the transaction
   // until it has successfully completed.
   tx = mRedoStack.Peek();
   // Bail if there's nothing on the stack.
   if (!tx) {
     return NS_OK;
   }
   nsCOMPtr<nsITransaction> t = tx->GetTransaction();
   bool doInterrupt = false;
   result = WillRedoNotify(t, &doInterrupt);
   if (NS_FAILED(result)) {
     return result;
   }
   if (doInterrupt) {
     return NS_OK;
   }
   result = tx->RedoTransaction(this);
   if (NS_SUCCEEDED(result)) {
     tx = mRedoStack.Pop();
     mUndoStack.Push(tx);
   }
   nsresult result2 = DidRedoNotify(t, result);
   if (NS_SUCCEEDED(result))
     result = result2;
   return result;
 }
 NS_IMETHODIMP
 nsTransactionManager::Clear()
 {
   nsresult result;
   result = ClearRedoStack();
   if (NS_FAILED(result)) {
     return result;
   }
   result = ClearUndoStack();
   return result;
 }
 NS_IMETHODIMP
 nsTransactionManager::BeginBatch(nsISupports* aData)
 {
   nsresult result;
   // 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().
   bool doInterrupt = false;
   result = WillBeginBatchNotify(&doInterrupt);
   if (NS_FAILED(result)) {
     return result;
   }
   if (doInterrupt) {
     return NS_OK;
   }
   result = BeginTransaction(0, aData);
   nsresult result2 = DidBeginBatchNotify(result);
   if (NS_SUCCEEDED(result))
     result = result2;
   return result;
 }
 NS_IMETHODIMP
 nsTransactionManager::EndBatch(bool aAllowEmpty)
 {
   nsCOMPtr<nsITransaction> ti;
   nsresult result;
   // 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!!!!
   nsRefPtr<nsTransactionItem> tx = mDoStack.Peek();
   if (tx) {
     ti = tx->GetTransaction();
   }
   if (!tx || ti) {
     return NS_ERROR_FAILURE;
   }
   bool doInterrupt = false;
   result = WillEndBatchNotify(&doInterrupt);
   if (NS_FAILED(result)) {
     return result;
   }
   if (doInterrupt) {
     return NS_OK;
   }
   result = EndTransaction(aAllowEmpty);
   nsresult result2 = DidEndBatchNotify(result);
   if (NS_SUCCEEDED(result))
     result = result2;
   return result;
 }
 NS_IMETHODIMP
 nsTransactionManager::GetNumberOfUndoItems(int32_t *aNumItems)
 {
   *aNumItems = mUndoStack.GetSize();
   return NS_OK;
 }
 NS_IMETHODIMP
 nsTransactionManager::GetNumberOfRedoItems(int32_t *aNumItems)
 {
   *aNumItems = mRedoStack.GetSize();
   return NS_OK;
 }
 NS_IMETHODIMP
 nsTransactionManager::GetMaxTransactionCount(int32_t *aMaxCount)
 {
   NS_ENSURE_TRUE(aMaxCount, NS_ERROR_NULL_POINTER);
   *aMaxCount = mMaxTransactionCount;
   return NS_OK;
 }
 NS_IMETHODIMP
 nsTransactionManager::SetMaxTransactionCount(int32_t aMaxCount)
 {
   int32_t numUndoItems  = 0, numRedoItems = 0, total = 0;
   // It is illegal to call SetMaxTransactionCount() while the transaction
   // manager is executing a  transaction's DoTransaction() method because
   // the undo and redo stacks might get pruned! If this happens, the
   // SetMaxTransactionCount() request is ignored, and we return
   // NS_ERROR_FAILURE.
   nsRefPtr<nsTransactionItem> tx = mDoStack.Peek();
   if (tx) {
     return NS_ERROR_FAILURE;
   }
   // If aMaxCount is less than zero, the user wants unlimited
   // levels of undo! No need to prune the undo or redo stacks!
   if (aMaxCount < 0) {
     mMaxTransactionCount = -1;
     return NS_OK;
   }
   numUndoItems = mUndoStack.GetSize();
   numRedoItems = mRedoStack.GetSize();
   total = numUndoItems + numRedoItems;
   // If aMaxCount 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!
   if (aMaxCount > total ) {
     mMaxTransactionCount = aMaxCount;
     return NS_OK;
   }
   // Try getting rid of some transactions on the undo stack! Start at
   // the bottom of the stack and pop towards the top.
   while (numUndoItems > 0 && (numRedoItems + numUndoItems) > aMaxCount) {
     tx = mUndoStack.PopBottom();
     if (!tx) {
       return NS_ERROR_FAILURE;
     }
     --numUndoItems;
   }
   // If necessary, get rid of some transactions on the redo stack! Start at
   // the bottom of the stack and pop towards the top.
   while (numRedoItems > 0 && (numRedoItems + numUndoItems) > aMaxCount) {
     tx = mRedoStack.PopBottom();
     if (!tx) {
       return NS_ERROR_FAILURE;
     }
     --numRedoItems;
   }
   mMaxTransactionCount = aMaxCount;
   return NS_OK;
 }
 NS_IMETHODIMP
 nsTransactionManager::PeekUndoStack(nsITransaction **aTransaction)
 {
   MOZ_ASSERT(aTransaction);
   *aTransaction = PeekUndoStack().take();
   return NS_OK;
 }
 already_AddRefed<nsITransaction>
 nsTransactionManager::PeekUndoStack()
 {
   nsRefPtr<nsTransactionItem> tx = mUndoStack.Peek();
   if (!tx) {
     return nullptr;
   }
   return tx->GetTransaction();
 }
 NS_IMETHODIMP
 nsTransactionManager::PeekRedoStack(nsITransaction** aTransaction)
 {
   MOZ_ASSERT(aTransaction);
   *aTransaction = PeekRedoStack().take();
   return NS_OK;
 }
 already_AddRefed<nsITransaction>
 nsTransactionManager::PeekRedoStack()
 {
   nsRefPtr<nsTransactionItem> tx = mRedoStack.Peek();
   if (!tx) {
     return nullptr;
   }
   return tx->GetTransaction();
 }
 NS_IMETHODIMP
 nsTransactionManager::GetUndoList(nsITransactionList **aTransactionList)
 {
   NS_ENSURE_TRUE(aTransactionList, NS_ERROR_NULL_POINTER);
   *aTransactionList = (nsITransactionList *)new nsTransactionList(this, &mUndoStack);
   NS_IF_ADDREF(*aTransactionList);
   return (! *aTransactionList) ? NS_ERROR_OUT_OF_MEMORY : NS_OK;
 }
 NS_IMETHODIMP
 nsTransactionManager::GetRedoList(nsITransactionList **aTransactionList)
 {
   NS_ENSURE_TRUE(aTransactionList, NS_ERROR_NULL_POINTER);
   *aTransactionList = (nsITransactionList *)new nsTransactionList(this, &mRedoStack);
   NS_IF_ADDREF(*aTransactionList);
   return (! *aTransactionList) ? NS_ERROR_OUT_OF_MEMORY : NS_OK;
 }
 nsresult
 nsTransactionManager::BatchTopUndo()
 {
   if (mUndoStack.GetSize() < 2) {
     // Not enough transactions to merge into one batch.
     return NS_OK;
   }
   nsRefPtr<nsTransactionItem> lastUndo;
   nsRefPtr<nsTransactionItem> previousUndo;
   lastUndo = mUndoStack.Pop();
   MOZ_ASSERT(lastUndo, "There should be at least two transactions.");
   previousUndo = mUndoStack.Peek();
   MOZ_ASSERT(previousUndo, "There should be at least two transactions.");
   nsresult result = previousUndo->AddChild(lastUndo);
   // 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();
   NS_ENSURE_TRUE(previousData.AppendObjects(lastData), NS_ERROR_UNEXPECTED);
   lastData.Clear();
   return result;
 }
 nsresult
 nsTransactionManager::RemoveTopUndo()
 {
   nsRefPtr<nsTransactionItem> lastUndo;
   lastUndo = mUndoStack.Peek();
   if (!lastUndo) {
     return NS_OK;
   }
   lastUndo = mUndoStack.Pop();
   return NS_OK;
 }
 NS_IMETHODIMP
 nsTransactionManager::AddListener(nsITransactionListener *aListener)
 {
   NS_ENSURE_TRUE(aListener, NS_ERROR_NULL_POINTER);
   return mListeners.AppendObject(aListener) ? NS_OK : NS_ERROR_FAILURE;
 }
 NS_IMETHODIMP
 nsTransactionManager::RemoveListener(nsITransactionListener *aListener)
 {
   NS_ENSURE_TRUE(aListener, NS_ERROR_NULL_POINTER);
   return mListeners.RemoveObject(aListener) ? NS_OK : NS_ERROR_FAILURE;
 }
 NS_IMETHODIMP
 nsTransactionManager::ClearUndoStack()
 {
   mUndoStack.Clear();
   return NS_OK;
 }
 NS_IMETHODIMP
 nsTransactionManager::ClearRedoStack()
 {
   mRedoStack.Clear();
   return NS_OK;
 }
 nsresult
 nsTransactionManager::WillDoNotify(nsITransaction *aTransaction, bool *aInterrupt)
 {
   nsresult result = NS_OK;
   for (int32_t i = 0, lcount = mListeners.Count(); i < lcount; i++)
   {
     nsITransactionListener *listener = mListeners[i];
     NS_ENSURE_TRUE(listener, NS_ERROR_FAILURE);
     result = listener->WillDo(this, aTransaction, aInterrupt);
     if (NS_FAILED(result) || *aInterrupt)
       break;
   }
   return result;
 }
 nsresult
 nsTransactionManager::DidDoNotify(nsITransaction *aTransaction, nsresult aDoResult)
 {
   nsresult result = NS_OK;
   for (int32_t i = 0, lcount = mListeners.Count(); i < lcount; i++)
   {
     nsITransactionListener *listener = mListeners[i];
     NS_ENSURE_TRUE(listener, NS_ERROR_FAILURE);
     result = listener->DidDo(this, aTransaction, aDoResult);
     if (NS_FAILED(result))
       break;
   }
   return result;
 }
 nsresult
 nsTransactionManager::WillUndoNotify(nsITransaction *aTransaction, bool *aInterrupt)
 {
   nsresult result = NS_OK;
   for (int32_t i = 0, lcount = mListeners.Count(); i < lcount; i++)
   {
     nsITransactionListener *listener = mListeners[i];
     NS_ENSURE_TRUE(listener, NS_ERROR_FAILURE);
     result = listener->WillUndo(this, aTransaction, aInterrupt);
     if (NS_FAILED(result) || *aInterrupt)
       break;
   }
   return result;
 }
 nsresult
 nsTransactionManager::DidUndoNotify(nsITransaction *aTransaction, nsresult aUndoResult)
 {
   nsresult result = NS_OK;
   for (int32_t i = 0, lcount = mListeners.Count(); i < lcount; i++)
   {
     nsITransactionListener *listener = mListeners[i];
     NS_ENSURE_TRUE(listener, NS_ERROR_FAILURE);
     result = listener->DidUndo(this, aTransaction, aUndoResult);
     if (NS_FAILED(result))
       break;
   }
   return result;
 }
 nsresult
 nsTransactionManager::WillRedoNotify(nsITransaction *aTransaction, bool *aInterrupt)
 {
   nsresult result = NS_OK;
   for (int32_t i = 0, lcount = mListeners.Count(); i < lcount; i++)
   {
     nsITransactionListener *listener = mListeners[i];
     NS_ENSURE_TRUE(listener, NS_ERROR_FAILURE);
     result = listener->WillRedo(this, aTransaction, aInterrupt);
     if (NS_FAILED(result) || *aInterrupt)
       break;
   }
   return result;
 }
 nsresult
 nsTransactionManager::DidRedoNotify(nsITransaction *aTransaction, nsresult aRedoResult)
 {
   nsresult result = NS_OK;
   for (int32_t i = 0, lcount = mListeners.Count(); i < lcount; i++)
   {
     nsITransactionListener *listener = mListeners[i];
     NS_ENSURE_TRUE(listener, NS_ERROR_FAILURE);
     result = listener->DidRedo(this, aTransaction, aRedoResult);
     if (NS_FAILED(result))
       break;
   }
   return result;
 }
 nsresult
 nsTransactionManager::WillBeginBatchNotify(bool *aInterrupt)
 {
   nsresult result = NS_OK;
   for (int32_t i = 0, lcount = mListeners.Count(); i < lcount; i++)
   {
     nsITransactionListener *listener = mListeners[i];
     NS_ENSURE_TRUE(listener, NS_ERROR_FAILURE);
     result = listener->WillBeginBatch(this, aInterrupt);
     if (NS_FAILED(result) || *aInterrupt)
       break;
   }
   return result;
 }
 nsresult
 nsTransactionManager::DidBeginBatchNotify(nsresult aResult)
 {
   nsresult result = NS_OK;
   for (int32_t i = 0, lcount = mListeners.Count(); i < lcount; i++)
   {
     nsITransactionListener *listener = mListeners[i];
     NS_ENSURE_TRUE(listener, NS_ERROR_FAILURE);
     result = listener->DidBeginBatch(this, aResult);
     if (NS_FAILED(result))
       break;
   }
   return result;
 }
 nsresult
 nsTransactionManager::WillEndBatchNotify(bool *aInterrupt)
 {
   nsresult result = NS_OK;
   for (int32_t i = 0, lcount = mListeners.Count(); i < lcount; i++)
   {
     nsITransactionListener *listener = mListeners[i];
     NS_ENSURE_TRUE(listener, NS_ERROR_FAILURE);
     result = listener->WillEndBatch(this, aInterrupt);
     if (NS_FAILED(result) || *aInterrupt)
       break;
   }
   return result;
 }
 nsresult
 nsTransactionManager::DidEndBatchNotify(nsresult aResult)
 {
   nsresult result = NS_OK;
   for (int32_t i = 0, lcount = mListeners.Count(); i < lcount; i++)
   {
     nsITransactionListener *listener = mListeners[i];
     NS_ENSURE_TRUE(listener, NS_ERROR_FAILURE);
     result = listener->DidEndBatch(this, aResult);
     if (NS_FAILED(result))
       break;
   }
   return result;
 }
 nsresult
 nsTransactionManager::WillMergeNotify(nsITransaction *aTop, nsITransaction *aTransaction, bool *aInterrupt)
 {
   nsresult result = NS_OK;
   for (int32_t i = 0, lcount = mListeners.Count(); i < lcount; i++)
   {
     nsITransactionListener *listener = mListeners[i];
     NS_ENSURE_TRUE(listener, NS_ERROR_FAILURE);
     result = listener->WillMerge(this, aTop, aTransaction, aInterrupt);
     if (NS_FAILED(result) || *aInterrupt)
       break;
   }
   return result;
 }
 nsresult
 nsTransactionManager::DidMergeNotify(nsITransaction *aTop,
                                      nsITransaction *aTransaction,
                                      bool aDidMerge,
                                      nsresult aMergeResult)
 {
   nsresult result = NS_OK;
   for (int32_t i = 0, lcount = mListeners.Count(); i < lcount; i++)
   {
     nsITransactionListener *listener = mListeners[i];
     NS_ENSURE_TRUE(listener, NS_ERROR_FAILURE);
     result = listener->DidMerge(this, aTop, aTransaction, aDidMerge, aMergeResult);
     if (NS_FAILED(result))
       break;
   }
   return result;
 }
 nsresult
 nsTransactionManager::BeginTransaction(nsITransaction *aTransaction,
                                        nsISupports *aData)
 {
   nsresult result = NS_OK;
   // XXX: POSSIBLE OPTIMIZATION
   //      We could use a factory that pre-allocates/recycles transaction items.
   nsRefPtr<nsTransactionItem> tx = new nsTransactionItem(aTransaction);
   if (aData) {
     nsCOMArray<nsISupports>& data = tx->GetData();
     data.AppendObject(aData);
   }
   if (!tx) {
     return NS_ERROR_OUT_OF_MEMORY;
   }
   mDoStack.Push(tx);
   result = tx->DoTransaction();
   if (NS_FAILED(result)) {
     tx = mDoStack.Pop();
     return result;
   }
   return NS_OK;
 }
 nsresult
 nsTransactionManager::EndTransaction(bool aAllowEmpty)
 {
   nsresult result              = NS_OK;
   nsRefPtr<nsTransactionItem> tx = mDoStack.Pop();
   if (!tx)
     return NS_ERROR_FAILURE;
   nsCOMPtr<nsITransaction> tint = tx->GetTransaction();
   if (!tint && !aAllowEmpty) {
     int32_t nc = 0;
     // If we get here, the transaction must be a dummy batch transaction
     // created by BeginBatch(). If it contains no children, get rid of it!
     tx->GetNumberOfChildren(&nc);
     if (!nc) {
       return result;
     }
   }
   // Check if the transaction is transient. If it is, there's nothing
   // more to do, just return.
   bool isTransient = false;
   if (tint)
     result = tint->GetIsTransient(&isTransient);
   if (NS_FAILED(result) || isTransient || !mMaxTransactionCount) {
     // XXX: Should we be clearing the redo stack if the transaction
     //      is transient and there is nothing on the do stack?
     return result;
   }
   // 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.
   nsRefPtr<nsTransactionItem> top = mDoStack.Peek();
   if (top) {
     result = top->AddChild(tx);
     // XXX: What do we do if this fails?
     return result;
   }
   // The transaction succeeded, so clear the redo stack.
   result = ClearRedoStack();
   if (NS_FAILED(result)) {
     // XXX: What do we do if this fails?
   }
   // Check if we can coalesce this transaction with the one at the top
   // of the undo stack.
   top = mUndoStack.Peek();
   if (tint && top) {
     bool didMerge = false;
     nsCOMPtr<nsITransaction> topTransaction = top->GetTransaction();
     if (topTransaction) {
       bool doInterrupt = false;
       result = WillMergeNotify(topTransaction, tint, &doInterrupt);
       NS_ENSURE_SUCCESS(result, result);
       if (!doInterrupt) {
         result = topTransaction->Merge(tint, &didMerge);
         nsresult result2 = DidMergeNotify(topTransaction, tint, didMerge, result);
         if (NS_SUCCEEDED(result))
           result = result2;
         if (NS_FAILED(result)) {
           // XXX: What do we do if this fails?
         }
         if (didMerge) {
           return result;
         }
       }
     }
   }
   // 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) {
     nsRefPtr<nsTransactionItem> overflow = mUndoStack.PopBottom();
   }
   // Push the transaction on the undo stack:
   mUndoStack.Push(tx);
   return NS_OK;
 }

The Tor Browser / annotate

editor/txmgr/src/nsTransactionManager.cpp@97036ab72558 (annotated)

editor/txmgr/src/nsTransactionManager.cpp