Bug 1447924 - part 2: Rename nsTransactionItem to mozilla::TransactionItem r=m_kato

MozReview-Commit-ID: 5EmFPCaRYWm

--HG--
rename : editor/txmgr/nsTransactionItem.cpp => editor/txmgr/TransactionItem.cpp
rename : editor/txmgr/nsTransactionItem.h => editor/txmgr/TransactionItem.h
extra : rebase_source : 3d5e39b26dc077bb63f7d39542a42cb3d06b6b21

editor/txmgr/TransactionItem.cpp

@@ -3,7 +3,7 @@
  * 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 "nsTransactionItem.h"
+#include "TransactionItem.h"
 
 #include "mozilla/mozalloc.h"
 #include "mozilla/TransactionManager.h"
@@ -14,21 +14,23 @@
 #include "nsITransaction.h"
 #include "nsTransactionStack.h"
 
-using namespace mozilla;
+namespace mozilla {
 
-nsTransactionItem::nsTransactionItem(nsITransaction *aTransaction)
-    : mTransaction(aTransaction), mUndoStack(0), mRedoStack(0)
+TransactionItem::TransactionItem(nsITransaction* aTransaction)
+  : mTransaction(aTransaction)
+  , mUndoStack(0)
+  , mRedoStack(0)
 {
 }
 
-nsTransactionItem::~nsTransactionItem()
+TransactionItem::~TransactionItem()
 {
   delete mRedoStack;
   delete mUndoStack;
 }
 
 void
-nsTransactionItem::CleanUp()
+TransactionItem::CleanUp()
 {
   mData.Clear();
   mTransaction = nullptr;
@@ -40,17 +42,17 @@ nsTransactionItem::CleanUp()
   }
 }
 
-NS_IMPL_CYCLE_COLLECTING_NATIVE_ADDREF(nsTransactionItem)
-NS_IMPL_CYCLE_COLLECTING_NATIVE_RELEASE_WITH_LAST_RELEASE(nsTransactionItem,
+NS_IMPL_CYCLE_COLLECTING_NATIVE_ADDREF(TransactionItem)
+NS_IMPL_CYCLE_COLLECTING_NATIVE_RELEASE_WITH_LAST_RELEASE(TransactionItem,
                                                           CleanUp())
 
-NS_IMPL_CYCLE_COLLECTION_CLASS(nsTransactionItem)
+NS_IMPL_CYCLE_COLLECTION_CLASS(TransactionItem)
 
-NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(nsTransactionItem)
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(TransactionItem)
   tmp->CleanUp();
 NS_IMPL_CYCLE_COLLECTION_UNLINK_END
 
-NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(nsTransactionItem)
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(TransactionItem)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mData)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mTransaction)
   if (tmp->mRedoStack) {
@@ -61,11 +63,11 @@ NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(nsTransactionItem)
   }
 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
 
-NS_IMPL_CYCLE_COLLECTION_ROOT_NATIVE(nsTransactionItem, AddRef)
-NS_IMPL_CYCLE_COLLECTION_UNROOT_NATIVE(nsTransactionItem, Release)
+NS_IMPL_CYCLE_COLLECTION_ROOT_NATIVE(TransactionItem, AddRef)
+NS_IMPL_CYCLE_COLLECTION_UNROOT_NATIVE(TransactionItem, Release)
 
 nsresult
-nsTransactionItem::AddChild(nsTransactionItem *aTransactionItem)
+TransactionItem::AddChild(TransactionItem* aTransactionItem)
 {
   NS_ENSURE_TRUE(aTransactionItem, NS_ERROR_NULL_POINTER);
 
@@ -78,14 +80,14 @@ nsTransactionItem::AddChild(nsTransactionItem *aTransactionItem)
 }
 
 already_AddRefed<nsITransaction>
-nsTransactionItem::GetTransaction()
+TransactionItem::GetTransaction()
 {
   nsCOMPtr<nsITransaction> txn = mTransaction;
   return txn.forget();
 }
 
 nsresult
-nsTransactionItem::GetIsBatch(bool *aIsBatch)
+TransactionItem::GetIsBatch(bool* aIsBatch)
 {
   NS_ENSURE_TRUE(aIsBatch, NS_ERROR_NULL_POINTER);
   *aIsBatch = !mTransaction;
@@ -93,7 +95,7 @@ nsTransactionItem::GetIsBatch(bool *aIsBatch)
 }
 
 nsresult
-nsTransactionItem::GetNumberOfChildren(int32_t *aNumChildren)
+TransactionItem::GetNumberOfChildren(int32_t* aNumChildren)
 {
   NS_ENSURE_TRUE(aNumChildren, NS_ERROR_NULL_POINTER);
 
@@ -112,7 +114,8 @@ nsTransactionItem::GetNumberOfChildren(int32_t *aNumChildren)
 }
 
 nsresult
-nsTransactionItem::GetChild(int32_t aIndex, nsTransactionItem **aChild)
+TransactionItem::GetChild(int32_t aIndex,
+                          TransactionItem** aChild)
 {
   NS_ENSURE_TRUE(aChild, NS_ERROR_NULL_POINTER);
 
@@ -135,7 +138,7 @@ nsTransactionItem::GetChild(int32_t aIndex, nsTransactionItem **aChild)
   if (numItems > 0 && aIndex < numItems) {
     NS_ENSURE_TRUE(mUndoStack, NS_ERROR_FAILURE);
 
-    RefPtr<nsTransactionItem> child = mUndoStack->GetItem(aIndex);
+    RefPtr<TransactionItem> child = mUndoStack->GetItem(aIndex);
     child.forget(aChild);
     return *aChild ? NS_OK : NS_ERROR_FAILURE;
   }
@@ -147,13 +150,13 @@ nsTransactionItem::GetChild(int32_t aIndex, nsTransactionItem **aChild)
   NS_ENSURE_SUCCESS(rv, rv);
   NS_ENSURE_TRUE(mRedoStack && numItems != 0 && aIndex < numItems, NS_ERROR_FAILURE);
 
-  RefPtr<nsTransactionItem> child = mRedoStack->GetItem(aIndex);
+  RefPtr<TransactionItem> child = mRedoStack->GetItem(aIndex);
   child.forget(aChild);
   return *aChild ? NS_OK : NS_ERROR_FAILURE;
 }
 
 nsresult
-nsTransactionItem::DoTransaction()
+TransactionItem::DoTransaction()
 {
   if (mTransaction) {
     return mTransaction->DoTransaction();
@@ -162,7 +165,7 @@ nsTransactionItem::DoTransaction()
 }
 
 nsresult
-nsTransactionItem::UndoTransaction(TransactionManager* aTransactionManager)
+TransactionItem::UndoTransaction(TransactionManager* aTransactionManager)
 {
   nsresult rv = UndoChildren(aTransactionManager);
   if (NS_FAILED(rv)) {
@@ -184,7 +187,7 @@ nsTransactionItem::UndoTransaction(TransactionManager* aTransactionManager)
 }
 
 nsresult
-nsTransactionItem::UndoChildren(TransactionManager* aTransactionManager)
+TransactionItem::UndoChildren(TransactionManager* aTransactionManager)
 {
   if (mUndoStack) {
     if (!mRedoStack && mUndoStack) {
@@ -196,14 +199,14 @@ nsTransactionItem::UndoChildren(TransactionManager* aTransactionManager)
 
     nsresult rv = NS_OK;
     while (sz-- > 0) {
-      RefPtr<nsTransactionItem> item = mUndoStack->Peek();
-      if (!item) {
+      RefPtr<TransactionItem> transactionItem = mUndoStack->Peek();
+      if (!transactionItem) {
         return NS_ERROR_FAILURE;
       }
 
-      nsCOMPtr<nsITransaction> t = item->GetTransaction();
+      nsCOMPtr<nsITransaction> transaction = transactionItem->GetTransaction();
       bool doInterrupt = false;
-      rv = aTransactionManager->WillUndoNotify(t, &doInterrupt);
+      rv = aTransactionManager->WillUndoNotify(transaction, &doInterrupt);
       if (NS_FAILED(rv)) {
         return rv;
       }
@@ -211,13 +214,13 @@ nsTransactionItem::UndoChildren(TransactionManager* aTransactionManager)
         return NS_OK;
       }
 
-      rv = item->UndoTransaction(aTransactionManager);
+      rv = transactionItem->UndoTransaction(aTransactionManager);
       if (NS_SUCCEEDED(rv)) {
-        item = mUndoStack->Pop();
-        mRedoStack->Push(item.forget());
+        transactionItem = mUndoStack->Pop();
+        mRedoStack->Push(transactionItem.forget());
       }
 
-      nsresult rv2 = aTransactionManager->DidUndoNotify(t, rv);
+      nsresult rv2 = aTransactionManager->DidUndoNotify(transaction, rv);
       if (NS_SUCCEEDED(rv)) {
         rv = rv2;
       }
@@ -232,7 +235,7 @@ nsTransactionItem::UndoChildren(TransactionManager* aTransactionManager)
 }
 
 nsresult
-nsTransactionItem::RedoTransaction(TransactionManager* aTransactionManager)
+TransactionItem::RedoTransaction(TransactionManager* aTransactionManager)
 {
   nsCOMPtr<nsITransaction> transaction(mTransaction);
   if (transaction) {
@@ -250,7 +253,7 @@ nsTransactionItem::RedoTransaction(TransactionManager* aTransactionManager)
 }
 
 nsresult
-nsTransactionItem::RedoChildren(TransactionManager* aTransactionManager)
+TransactionItem::RedoChildren(TransactionManager* aTransactionManager)
 {
   if (!mRedoStack) {
     return NS_OK;
@@ -261,14 +264,14 @@ nsTransactionItem::RedoChildren(TransactionManager* aTransactionManager)
 
   nsresult rv = NS_OK;
   while (sz-- > 0) {
-    RefPtr<nsTransactionItem> item = mRedoStack->Peek();
-    if (!item) {
+    RefPtr<TransactionItem> transactionItem = mRedoStack->Peek();
+    if (!transactionItem) {
       return NS_ERROR_FAILURE;
     }
 
-    nsCOMPtr<nsITransaction> t = item->GetTransaction();
+    nsCOMPtr<nsITransaction> transaction = transactionItem->GetTransaction();
     bool doInterrupt = false;
-    rv = aTransactionManager->WillRedoNotify(t, &doInterrupt);
+    rv = aTransactionManager->WillRedoNotify(transaction, &doInterrupt);
     if (NS_FAILED(rv)) {
       return rv;
     }
@@ -276,14 +279,14 @@ nsTransactionItem::RedoChildren(TransactionManager* aTransactionManager)
       return NS_OK;
     }
 
-    rv = item->RedoTransaction(aTransactionManager);
+    rv = transactionItem->RedoTransaction(aTransactionManager);
     if (NS_SUCCEEDED(rv)) {
-      item = mRedoStack->Pop();
-      mUndoStack->Push(item.forget());
+      transactionItem = mRedoStack->Pop();
+      mUndoStack->Push(transactionItem.forget());
     }
 
     // XXX Shouldn't this DidRedoNotify()? (bug 1311626)
-    nsresult rv2 = aTransactionManager->DidUndoNotify(t, rv);
+    nsresult rv2 = aTransactionManager->DidUndoNotify(transaction, rv);
     if (NS_SUCCEEDED(rv)) {
       rv = rv2;
     }
@@ -295,7 +298,7 @@ nsTransactionItem::RedoChildren(TransactionManager* aTransactionManager)
 }
 
 nsresult
-nsTransactionItem::GetNumberOfUndoItems(int32_t *aNumItems)
+TransactionItem::GetNumberOfUndoItems(int32_t* aNumItems)
 {
   NS_ENSURE_TRUE(aNumItems, NS_ERROR_NULL_POINTER);
 
@@ -309,7 +312,7 @@ nsTransactionItem::GetNumberOfUndoItems(int32_t *aNumItems)
 }
 
 nsresult
-nsTransactionItem::GetNumberOfRedoItems(int32_t *aNumItems)
+TransactionItem::GetNumberOfRedoItems(int32_t* aNumItems)
 {
   NS_ENSURE_TRUE(aNumItems, NS_ERROR_NULL_POINTER);
 
@@ -323,7 +326,7 @@ nsTransactionItem::GetNumberOfRedoItems(int32_t *aNumItems)
 }
 
 nsresult
-nsTransactionItem::RecoverFromUndoError(TransactionManager* aTransactionManager)
+TransactionItem::RecoverFromUndoError(TransactionManager* aTransactionManager)
 {
   // If this method gets called, we never got to the point where we
   // successfully called UndoTransaction() for the transaction item itself.
@@ -332,7 +335,7 @@ nsTransactionItem::RecoverFromUndoError(TransactionManager* aTransactionManager)
 }
 
 nsresult
-nsTransactionItem::RecoverFromRedoError(TransactionManager* aTransactionManager)
+TransactionItem::RecoverFromRedoError(TransactionManager* aTransactionManager)
 {
   // If this method gets called, we already successfully called
   // RedoTransaction() for the transaction item itself. Undo all
@@ -350,3 +353,4 @@ nsTransactionItem::RecoverFromRedoError(TransactionManager* aTransactionManager)
   return mTransaction->UndoTransaction();
 }
 
+} // namespace mozilla

editor/txmgr/TransactionItem.h

@@ -3,8 +3,8 @@
  * 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/. */
 
-#ifndef nsTransactionItem_h__
-#define nsTransactionItem_h__
+#ifndef TransactionItem_h
+#define TransactionItem_h
 
 #include "nsCOMPtr.h"
 #include "nsCOMArray.h"
@@ -16,32 +16,27 @@ class nsITransaction;
 class nsTransactionStack;
 
 namespace mozilla {
+
 class TransactionManager;
-} // namespace mozilla
 
-class nsTransactionItem final
+class TransactionItem final
 {
-  nsCOMArray<nsISupports>  mData;
-  nsCOMPtr<nsITransaction> mTransaction;
-  nsTransactionStack      *mUndoStack;
-  nsTransactionStack      *mRedoStack;
-
 public:
-  explicit nsTransactionItem(nsITransaction* aTransaction);
+  explicit TransactionItem(nsITransaction* aTransaction);
   NS_METHOD_(MozExternalRefCountType) AddRef();
   NS_METHOD_(MozExternalRefCountType) Release();
 
-  NS_DECL_CYCLE_COLLECTION_NATIVE_CLASS(nsTransactionItem)
+  NS_DECL_CYCLE_COLLECTION_NATIVE_CLASS(TransactionItem)
 
-  nsresult AddChild(nsTransactionItem* aTransactionItem);
+  nsresult AddChild(TransactionItem* aTransactionItem);
   already_AddRefed<nsITransaction> GetTransaction();
   nsresult GetIsBatch(bool *aIsBatch);
   nsresult GetNumberOfChildren(int32_t *aNumChildren);
-  nsresult GetChild(int32_t aIndex, nsTransactionItem** aChild);
+  nsresult GetChild(int32_t aIndex, TransactionItem** aChild);
 
   nsresult DoTransaction();
-  nsresult UndoTransaction(mozilla::TransactionManager* aTransactionManager);
-  nsresult RedoTransaction(mozilla::TransactionManager* aTransactionManager);
+  nsresult UndoTransaction(TransactionManager* aTransactionManager);
+  nsresult RedoTransaction(TransactionManager* aTransactionManager);
 
   nsCOMArray<nsISupports>& GetData()
   {
@@ -49,24 +44,28 @@ public:
   }
 
 private:
-  nsresult UndoChildren(mozilla::TransactionManager* aTransactionManager);
-  nsresult RedoChildren(mozilla::TransactionManager* aTransactionManager);
+  nsresult UndoChildren(TransactionManager* aTransactionManager);
+  nsresult RedoChildren(TransactionManager* aTransactionManager);
 
-  nsresult
-  RecoverFromUndoError(mozilla::TransactionManager* aTransactionManager);
-  nsresult
-  RecoverFromRedoError(mozilla::TransactionManager* aTransactionManager);
+  nsresult RecoverFromUndoError(TransactionManager* aTransactionManager);
+  nsresult RecoverFromRedoError(TransactionManager* aTransactionManager);
 
   nsresult GetNumberOfUndoItems(int32_t* aNumItems);
   nsresult GetNumberOfRedoItems(int32_t* aNumItems);
 
   void CleanUp();
 
-protected:
-  ~nsTransactionItem();
+  ~TransactionItem();
 
   nsCycleCollectingAutoRefCnt mRefCnt;
   NS_DECL_OWNINGTHREAD
+
+  nsCOMArray<nsISupports> mData;
+  nsCOMPtr<nsITransaction> mTransaction;
+  nsTransactionStack* mUndoStack;
+  nsTransactionStack* mRedoStack;
 };
 
-#endif // nsTransactionItem_h__
+} // namespace mozilla
+
+#endif // #ifndef TransactionItem_h

editor/txmgr/TransactionManager.cpp

@@ -15,8 +15,8 @@
 #include "nsITransaction.h"
 #include "nsITransactionListener.h"
 #include "nsIWeakReference.h"
-#include "nsTransactionItem.h"
 #include "nsTransactionStack.h"
+#include "TransactionItem.h"
 
 namespace mozilla {
 
@@ -98,13 +98,13 @@ TransactionManager::UndoTransaction()
 
   // Peek at the top of the undo stack. Don't remove the transaction
   // until it has successfully completed.
-  RefPtr<nsTransactionItem> tx = mUndoStack.Peek();
-  if (!tx) {
+  RefPtr<TransactionItem> transactionItem = mUndoStack.Peek();
+  if (!transactionItem) {
     // Bail if there's nothing on the stack.
     return NS_OK;
   }
 
-  nsCOMPtr<nsITransaction> t = tx->GetTransaction();
+  nsCOMPtr<nsITransaction> t = transactionItem->GetTransaction();
   bool doInterrupt = false;
   nsresult rv = WillUndoNotify(t, &doInterrupt);
   if (NS_FAILED(rv)) {
@@ -114,10 +114,10 @@ TransactionManager::UndoTransaction()
     return NS_OK;
   }
 
-  rv = tx->UndoTransaction(this);
+  rv = transactionItem->UndoTransaction(this);
   if (NS_SUCCEEDED(rv)) {
-    tx = mUndoStack.Pop();
-    mRedoStack.Push(tx.forget());
+    transactionItem = mUndoStack.Pop();
+    mRedoStack.Push(transactionItem.forget());
   }
 
   nsresult rv2 = DidUndoNotify(t, rv);
@@ -142,15 +142,15 @@ TransactionManager::RedoTransaction()
 
   // Peek at the top of the redo stack. Don't remove the transaction
   // until it has successfully completed.
-  RefPtr<nsTransactionItem> tx = mRedoStack.Peek();
-  if (!tx) {
+  RefPtr<TransactionItem> transactionItem = mRedoStack.Peek();
+  if (!transactionItem) {
     // Bail if there's nothing on the stack.
     return NS_OK;
   }
 
-  nsCOMPtr<nsITransaction> t = tx->GetTransaction();
+  nsCOMPtr<nsITransaction> transaction = transactionItem->GetTransaction();
   bool doInterrupt = false;
-  nsresult rv = WillRedoNotify(t, &doInterrupt);
+  nsresult rv = WillRedoNotify(transaction, &doInterrupt);
   if (NS_FAILED(rv)) {
     return rv;
   }
@@ -158,13 +158,13 @@ TransactionManager::RedoTransaction()
     return NS_OK;
   }
 
-  rv = tx->RedoTransaction(this);
+  rv = transactionItem->RedoTransaction(this);
   if (NS_SUCCEEDED(rv)) {
-    tx = mRedoStack.Pop();
-    mUndoStack.Push(tx.forget());
+    transactionItem = mRedoStack.Pop();
+    mUndoStack.Push(transactionItem.forget());
   }
 
-  nsresult rv2 = DidRedoNotify(t, rv);
+  nsresult rv2 = DidRedoNotify(transaction, rv);
   if (NS_SUCCEEDED(rv)) {
     rv = rv2;
   }
@@ -225,12 +225,12 @@ TransactionManager::EndBatch(bool aAllowEmpty)
   //      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<nsTransactionItem> tx = mDoStack.Peek();
-  nsCOMPtr<nsITransaction> ti;
-  if (tx) {
-    ti = tx->GetTransaction();
+  RefPtr<TransactionItem> transactionItem = mDoStack.Peek();
+  if (!transactionItem) {
+    return NS_ERROR_FAILURE;
   }
-  if (!tx || ti) {
+  nsCOMPtr<nsITransaction> transaction = transactionItem->GetTransaction();
+  if (transaction) {
     return NS_ERROR_FAILURE;
   }
 
@@ -309,8 +309,8 @@ TransactionManager::SetMaxTransactionCount(int32_t aMaxCount)
   // 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) {
-    RefPtr<nsTransactionItem> tx = mUndoStack.PopBottom();
-    if (!tx) {
+    RefPtr<TransactionItem> transactionItem = mUndoStack.PopBottom();
+    if (!transactionItem) {
       return NS_ERROR_FAILURE;
     }
     --numUndoItems;
@@ -319,8 +319,8 @@ TransactionManager::SetMaxTransactionCount(int32_t aMaxCount)
   // 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) {
-    RefPtr<nsTransactionItem> tx = mRedoStack.PopBottom();
-    if (!tx) {
+    RefPtr<TransactionItem> transactionItem = mRedoStack.PopBottom();
+    if (!transactionItem) {
       return NS_ERROR_FAILURE;
     }
     --numRedoItems;
@@ -341,11 +341,11 @@ TransactionManager::PeekUndoStack(nsITransaction** aTransaction)
 already_AddRefed<nsITransaction>
 TransactionManager::PeekUndoStack()
 {
-  RefPtr<nsTransactionItem> tx = mUndoStack.Peek();
-  if (!tx) {
+  RefPtr<TransactionItem> transactionItem = mUndoStack.Peek();
+  if (!transactionItem) {
     return nullptr;
   }
-  return tx->GetTransaction();
+  return transactionItem->GetTransaction();
 }
 
 NS_IMETHODIMP
@@ -359,11 +359,11 @@ TransactionManager::PeekRedoStack(nsITransaction** aTransaction)
 already_AddRefed<nsITransaction>
 TransactionManager::PeekRedoStack()
 {
-  RefPtr<nsTransactionItem> tx = mRedoStack.Peek();
-  if (!tx) {
+  RefPtr<TransactionItem> transactionItem = mRedoStack.Peek();
+  if (!transactionItem) {
     return nullptr;
   }
-  return tx->GetTransaction();
+  return transactionItem->GetTransaction();
 }
 
 nsresult
@@ -374,13 +374,10 @@ TransactionManager::BatchTopUndo()
     return NS_OK;
   }
 
-  RefPtr<nsTransactionItem> lastUndo;
-  RefPtr<nsTransactionItem> previousUndo;
-
-  lastUndo = mUndoStack.Pop();
+  RefPtr<TransactionItem> lastUndo = mUndoStack.Pop();
   MOZ_ASSERT(lastUndo, "There should be at least two transactions.");
 
-  previousUndo = mUndoStack.Peek();
+  RefPtr<TransactionItem> previousUndo = mUndoStack.Peek();
   MOZ_ASSERT(previousUndo, "There should be at least two transactions.");
 
   nsresult rv = previousUndo->AddChild(lastUndo);
@@ -401,7 +398,7 @@ TransactionManager::RemoveTopUndo()
     return NS_OK;
   }
 
-  RefPtr<nsTransactionItem> lastUndo = mUndoStack.Pop();
+  RefPtr<TransactionItem> lastUndo = mUndoStack.Pop();
   return NS_OK;
 }
 
@@ -631,21 +628,18 @@ TransactionManager::BeginTransaction(nsITransaction* aTransaction,
 {
   // XXX: POSSIBLE OPTIMIZATION
   //      We could use a factory that pre-allocates/recycles transaction items.
-  RefPtr<nsTransactionItem> tx = new nsTransactionItem(aTransaction);
-  if (!tx) {
-    return NS_ERROR_OUT_OF_MEMORY;
-  }
+  RefPtr<TransactionItem> transactionItem = new TransactionItem(aTransaction);
 
   if (aData) {
-    nsCOMArray<nsISupports>& data = tx->GetData();
+    nsCOMArray<nsISupports>& data = transactionItem->GetData();
     data.AppendObject(aData);
   }
 
-  mDoStack.Push(tx);
+  mDoStack.Push(transactionItem);
 
-  nsresult rv = tx->DoTransaction();
+  nsresult rv = transactionItem->DoTransaction();
   if (NS_FAILED(rv)) {
-    tx = mDoStack.Pop();
+    transactionItem = mDoStack.Pop();
     return rv;
   }
   return NS_OK;
@@ -654,17 +648,17 @@ TransactionManager::BeginTransaction(nsITransaction* aTransaction,
 nsresult
 TransactionManager::EndTransaction(bool aAllowEmpty)
 {
-  RefPtr<nsTransactionItem> tx = mDoStack.Pop();
-  if (!tx) {
+  RefPtr<TransactionItem> transactionItem = mDoStack.Pop();
+  if (!transactionItem) {
     return NS_ERROR_FAILURE;
   }
 
-  nsCOMPtr<nsITransaction> tint = tx->GetTransaction();
-  if (!tint && !aAllowEmpty) {
+  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!
     int32_t nc = 0;
-    tx->GetNumberOfChildren(&nc);
+    transactionItem->GetNumberOfChildren(&nc);
     if (!nc) {
       return NS_OK;
     }
@@ -673,10 +667,7 @@ TransactionManager::EndTransaction(bool aAllowEmpty)
   // Check if the transaction is transient. If it is, there's nothing
   // more to do, just return.
   bool isTransient = false;
-  nsresult rv = NS_OK;
-  if (tint) {
-    rv = tint->GetIsTransient(&isTransient);
-  }
+  nsresult rv = transaction ? transaction->GetIsTransient(&isTransient) : NS_OK;
   if (NS_FAILED(rv) || isTransient || !mMaxTransactionCount) {
     // XXX: Should we be clearing the redo stack if the transaction
     //      is transient and there is nothing on the do stack?
@@ -686,9 +677,10 @@ TransactionManager::EndTransaction(bool aAllowEmpty)
   // 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<nsTransactionItem> top = mDoStack.Peek();
-  if (top) {
-    return top->AddChild(tx); // XXX: What do we do if this fails?
+  RefPtr<TransactionItem> topTransactionItem = mDoStack.Peek();
+  if (topTransactionItem) {
+    // XXX: What do we do if this fails?
+    return topTransactionItem->AddChild(transactionItem);
   }
 
   // The transaction succeeded, so clear the redo stack.
@@ -699,18 +691,20 @@ TransactionManager::EndTransaction(bool aAllowEmpty)
 
   // Check if we can coalesce this transaction with the one at the top
   // of the undo stack.
-  top = mUndoStack.Peek();
-  if (tint && top) {
+  topTransactionItem = mUndoStack.Peek();
+  if (transaction && topTransactionItem) {
     bool didMerge = false;
-    nsCOMPtr<nsITransaction> topTransaction = top->GetTransaction();
+    nsCOMPtr<nsITransaction> topTransaction =
+      topTransactionItem->GetTransaction();
     if (topTransaction) {
       bool doInterrupt = false;
-      rv = WillMergeNotify(topTransaction, tint, &doInterrupt);
+      rv = WillMergeNotify(topTransaction, transaction, &doInterrupt);
       NS_ENSURE_SUCCESS(rv, rv);
 
       if (!doInterrupt) {
-        rv = topTransaction->Merge(tint, &didMerge);
-        nsresult rv2 = DidMergeNotify(topTransaction, tint, didMerge, rv);
+        rv = topTransaction->Merge(transaction, &didMerge);
+        nsresult rv2 =
+          DidMergeNotify(topTransaction, transaction, didMerge, rv);
         if (NS_SUCCEEDED(rv)) {
           rv = rv2;
         }
@@ -728,11 +722,11 @@ TransactionManager::EndTransaction(bool aAllowEmpty)
   // pop the bottom transaction off the undo stack and release it!
   int32_t sz = mUndoStack.GetSize();
   if (mMaxTransactionCount > 0 && sz >= mMaxTransactionCount) {
-    RefPtr<nsTransactionItem> overflow = mUndoStack.PopBottom();
+    RefPtr<TransactionItem> overflow = mUndoStack.PopBottom();
   }
 
   // Push the transaction on the undo stack:
-  mUndoStack.Push(tx.forget());
+  mUndoStack.Push(transactionItem.forget());
   return NS_OK;
 }
 

editor/txmgr/moz.build

@@ -23,8 +23,8 @@ EXPORTS.mozilla += [
 ]
 
 UNIFIED_SOURCES += [
-    'nsTransactionItem.cpp',
     'nsTransactionStack.cpp',
+    'TransactionItem.cpp',
     'TransactionManager.cpp',
     'TransactionManagerFactory.cpp',
 ]

editor/txmgr/nsTransactionStack.cpp

@@ -3,17 +3,22 @@
  * 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 "nsTransactionStack.h"
+
 #include "nsCOMPtr.h"
 #include "nsCycleCollectionParticipant.h"
 #include "nsISupportsUtils.h"
-#include "nsTransactionItem.h"
-#include "nsTransactionStack.h"
 #include "nscore.h"
+#include "TransactionItem.h"
 
-class nsTransactionStackDeallocator : public nsDequeFunctor {
+using namespace mozilla;
+
+class nsTransactionStackDeallocator final : public nsDequeFunctor
+{
   virtual void operator()(void* aObject) override
   {
-    RefPtr<nsTransactionItem> releaseMe = dont_AddRef(static_cast<nsTransactionItem*>(aObject));
+    RefPtr<TransactionItem> releaseMe =
+      dont_AddRef(static_cast<TransactionItem*>(aObject));
   }
 };
 
@@ -29,20 +34,20 @@ nsTransactionStack::~nsTransactionStack()
 }
 
 void
-nsTransactionStack::Push(nsTransactionItem* aTransactionItem)
+nsTransactionStack::Push(TransactionItem* aTransactionItem)
 {
   if (!aTransactionItem) {
     return;
   }
 
-  RefPtr<nsTransactionItem> item(aTransactionItem);
+  RefPtr<TransactionItem> item(aTransactionItem);
   Push(item.forget());
 }
 
 void
-nsTransactionStack::Push(already_AddRefed<nsTransactionItem> aTransactionItem)
+nsTransactionStack::Push(already_AddRefed<TransactionItem> aTransactionItem)
 {
-  RefPtr<nsTransactionItem> item(aTransactionItem);
+  RefPtr<TransactionItem> item(aTransactionItem);
   if (!item) {
     return;
   }
@@ -50,38 +55,38 @@ nsTransactionStack::Push(already_AddRefed<nsTransactionItem> aTransactionItem)
   nsDeque::Push(item.forget().take());
 }
 
-already_AddRefed<nsTransactionItem>
+already_AddRefed<TransactionItem>
 nsTransactionStack::Pop()
 {
-  RefPtr<nsTransactionItem> item =
-    dont_AddRef(static_cast<nsTransactionItem*>(nsDeque::Pop()));
+  RefPtr<TransactionItem> item =
+    dont_AddRef(static_cast<TransactionItem*>(nsDeque::Pop()));
   return item.forget();
 }
 
-already_AddRefed<nsTransactionItem>
+already_AddRefed<TransactionItem>
 nsTransactionStack::PopBottom()
 {
-  RefPtr<nsTransactionItem> item =
-    dont_AddRef(static_cast<nsTransactionItem*>(nsDeque::PopFront()));
+  RefPtr<TransactionItem> item =
+    dont_AddRef(static_cast<TransactionItem*>(nsDeque::PopFront()));
   return item.forget();
 }
 
-already_AddRefed<nsTransactionItem>
+already_AddRefed<TransactionItem>
 nsTransactionStack::Peek()
 {
-  RefPtr<nsTransactionItem> item =
-    static_cast<nsTransactionItem*>(nsDeque::Peek());
+  RefPtr<TransactionItem> item =
+    static_cast<TransactionItem*>(nsDeque::Peek());
   return item.forget();
 }
 
-already_AddRefed<nsTransactionItem>
+already_AddRefed<TransactionItem>
 nsTransactionStack::GetItem(int32_t aIndex)
 {
   if (aIndex < 0 || aIndex >= static_cast<int32_t>(nsDeque::GetSize())) {
     return nullptr;
   }
-  RefPtr<nsTransactionItem> item =
-    static_cast<nsTransactionItem*>(nsDeque::ObjectAt(aIndex));
+  RefPtr<TransactionItem> item =
+    static_cast<TransactionItem*>(nsDeque::ObjectAt(aIndex));
   return item.forget();
 }
 
@@ -89,7 +94,7 @@ void
 nsTransactionStack::Clear()
 {
   while (GetSize() != 0) {
-    RefPtr<nsTransactionItem> item =
+    RefPtr<TransactionItem> item =
       mType == FOR_UNDO ? Pop() : PopBottom();
   }
 }
@@ -97,12 +102,13 @@ nsTransactionStack::Clear()
 void
 nsTransactionStack::DoTraverse(nsCycleCollectionTraversalCallback &cb)
 {
-  int32_t size = GetSize();
-  for (int32_t i = 0; i < size; ++i) {
-    nsTransactionItem* item = static_cast<nsTransactionItem*>(nsDeque::ObjectAt(i));
+  size_t size = GetSize();
+  for (size_t i = 0; i < size; ++i) {
+    TransactionItem* item = static_cast<TransactionItem*>(nsDeque::ObjectAt(i));
     if (item) {
       NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(cb, "transaction stack mDeque[i]");
-      cb.NoteNativeChild(item, NS_CYCLE_COLLECTION_PARTICIPANT(nsTransactionItem));
+      cb.NoteNativeChild(item,
+                         NS_CYCLE_COLLECTION_PARTICIPANT(TransactionItem));
     }
   }
 }

editor/txmgr/nsTransactionStack.h

@@ -9,7 +9,10 @@
 #include "nsDeque.h"
 
 class nsCycleCollectionTraversalCallback;
-class nsTransactionItem;
+
+namespace mozilla {
+class TransactionItem;
+} // namespace mozilla
 
 class nsTransactionStack : private nsDeque
 {
@@ -19,12 +22,12 @@ public:
   explicit nsTransactionStack(Type aType);
   ~nsTransactionStack();
 
-  void Push(nsTransactionItem *aTransactionItem);
-  void Push(already_AddRefed<nsTransactionItem> aTransactionItem);
-  already_AddRefed<nsTransactionItem> Pop();
-  already_AddRefed<nsTransactionItem> PopBottom();
-  already_AddRefed<nsTransactionItem> Peek();
-  already_AddRefed<nsTransactionItem> GetItem(int32_t aIndex);
+  void Push(mozilla::TransactionItem* aTransactionItem);
+  void Push(already_AddRefed<mozilla::TransactionItem> aTransactionItem);
+  already_AddRefed<mozilla::TransactionItem> Pop();
+  already_AddRefed<mozilla::TransactionItem> PopBottom();
+  already_AddRefed<mozilla::TransactionItem> Peek();
+  already_AddRefed<mozilla::TransactionItem> GetItem(int32_t aIndex);
   void Clear();
   int32_t GetSize() const { return static_cast<int32_t>(nsDeque::GetSize()); }
   bool IsEmpty() const { return GetSize() == 0; }