rename from editor/txmgr/nsTransactionItem.cpp
rename to editor/txmgr/TransactionItem.cpp
--- a/editor/txmgr/nsTransactionItem.cpp
+++ b/editor/txmgr/TransactionItem.cpp
@@ -1,104 +1,106 @@
 /* -*- 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 "nsTransactionItem.h"
+#include "TransactionItem.h"
 
 #include "mozilla/mozalloc.h"
 #include "mozilla/TransactionManager.h"
 #include "nsCOMPtr.h"
 #include "nsDebug.h"
 #include "nsError.h"
 #include "nsISupportsImpl.h"
 #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;
   if (mRedoStack) {
     mRedoStack->DoUnlink();
   }
   if (mUndoStack) {
     mUndoStack->DoUnlink();
   }
 }
 
-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) {
     tmp->mRedoStack->DoTraverse(cb);
   }
   if (tmp->mUndoStack) {
     tmp->mUndoStack->DoTraverse(cb);
   }
 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);
 
   if (!mUndoStack) {
     mUndoStack = new nsTransactionStack(nsTransactionStack::FOR_UNDO);
   }
 
   mUndoStack->Push(aTransactionItem);
   return NS_OK;
 }
 
 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;
   return NS_OK;
 }
 
 nsresult
-nsTransactionItem::GetNumberOfChildren(int32_t *aNumChildren)
+TransactionItem::GetNumberOfChildren(int32_t* aNumChildren)
 {
   NS_ENSURE_TRUE(aNumChildren, NS_ERROR_NULL_POINTER);
 
   *aNumChildren = 0;
 
   int32_t ui = 0;
   nsresult rv = GetNumberOfUndoItems(&ui);
   NS_ENSURE_SUCCESS(rv, rv);
@@ -107,17 +109,18 @@ nsTransactionItem::GetNumberOfChildren(i
   rv = GetNumberOfRedoItems(&ri);
   NS_ENSURE_SUCCESS(rv, rv);
 
   *aNumChildren = ui + ri;
   return NS_OK;
 }
 
 nsresult
-nsTransactionItem::GetChild(int32_t aIndex, nsTransactionItem **aChild)
+TransactionItem::GetChild(int32_t aIndex,
+                          TransactionItem** aChild)
 {
   NS_ENSURE_TRUE(aChild, NS_ERROR_NULL_POINTER);
 
   *aChild = 0;
 
   int32_t numItems = 0;
   nsresult rv = GetNumberOfChildren(&numItems);
   NS_ENSURE_SUCCESS(rv, rv);
@@ -130,44 +133,44 @@ nsTransactionItem::GetChild(int32_t aInd
   // stack, or if there are no items on the undo stack, it would
   // be at the top of the redo stack.
   rv = GetNumberOfUndoItems(&numItems);
   NS_ENSURE_SUCCESS(rv, rv);
 
   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;
   }
 
   // Adjust the index for the redo stack:
   aIndex -=  numItems;
 
   rv = GetNumberOfRedoItems(&numItems);
   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();
   }
   return NS_OK;
 }
 
 nsresult
-nsTransactionItem::UndoTransaction(TransactionManager* aTransactionManager)
+TransactionItem::UndoTransaction(TransactionManager* aTransactionManager)
 {
   nsresult rv = UndoChildren(aTransactionManager);
   if (NS_FAILED(rv)) {
     RecoverFromUndoError(aTransactionManager);
     return rv;
   }
 
   if (!mTransaction) {
@@ -179,65 +182,65 @@ nsTransactionItem::UndoTransaction(Trans
     RecoverFromUndoError(aTransactionManager);
     return rv;
   }
 
   return NS_OK;
 }
 
 nsresult
-nsTransactionItem::UndoChildren(TransactionManager* aTransactionManager)
+TransactionItem::UndoChildren(TransactionManager* aTransactionManager)
 {
   if (mUndoStack) {
     if (!mRedoStack && mUndoStack) {
       mRedoStack = new nsTransactionStack(nsTransactionStack::FOR_REDO);
     }
 
     /* Undo all of the transaction items children! */
     int32_t sz = mUndoStack->GetSize();
 
     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;
       }
       if (doInterrupt) {
         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;
       }
     }
     // XXX NS_OK if there is no Undo items or all methods work fine, otherwise,
     //     the result of the last item's UndoTransaction() or
     //     DidUndoNotify() if UndoTransaction() succeeded.
     return rv;
   }
 
   return NS_OK;
 }
 
 nsresult
-nsTransactionItem::RedoTransaction(TransactionManager* aTransactionManager)
+TransactionItem::RedoTransaction(TransactionManager* aTransactionManager)
 {
   nsCOMPtr<nsITransaction> transaction(mTransaction);
   if (transaction) {
     nsresult rv = transaction->RedoTransaction();
     NS_ENSURE_SUCCESS(rv, rv);
   }
 
   nsresult rv = RedoChildren(aTransactionManager);
@@ -245,99 +248,99 @@ nsTransactionItem::RedoTransaction(Trans
     RecoverFromRedoError(aTransactionManager);
     return rv;
   }
 
   return NS_OK;
 }
 
 nsresult
-nsTransactionItem::RedoChildren(TransactionManager* aTransactionManager)
+TransactionItem::RedoChildren(TransactionManager* aTransactionManager)
 {
   if (!mRedoStack) {
     return NS_OK;
   }
 
   /* Redo all of the transaction items children! */
   int32_t sz = mRedoStack->GetSize();
 
   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;
     }
     if (doInterrupt) {
       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;
     }
   }
   // XXX NS_OK if there is no Redo items or all methods work fine, otherwise,
   //     the result of the last item's RedoTransaction() or
   //     DidUndoNotify() if UndoTransaction() succeeded.
   return rv;
 }
 
 nsresult
-nsTransactionItem::GetNumberOfUndoItems(int32_t *aNumItems)
+TransactionItem::GetNumberOfUndoItems(int32_t* aNumItems)
 {
   NS_ENSURE_TRUE(aNumItems, NS_ERROR_NULL_POINTER);
 
   if (!mUndoStack) {
     *aNumItems = 0;
     return NS_OK;
   }
 
   *aNumItems = mUndoStack->GetSize();
   return *aNumItems ? NS_OK : NS_ERROR_FAILURE;
 }
 
 nsresult
-nsTransactionItem::GetNumberOfRedoItems(int32_t *aNumItems)
+TransactionItem::GetNumberOfRedoItems(int32_t* aNumItems)
 {
   NS_ENSURE_TRUE(aNumItems, NS_ERROR_NULL_POINTER);
 
   if (!mRedoStack) {
     *aNumItems = 0;
     return NS_OK;
   }
 
   *aNumItems = mRedoStack->GetSize();
   return *aNumItems ? NS_OK : NS_ERROR_FAILURE;
 }
 
 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.
   // Just redo any children that successfully called undo!
   return RedoChildren(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
   // the children that successfully called RedoTransaction(),
   // then undo the transaction item itself.
   nsresult rv = UndoChildren(aTransactionManager);
   if (NS_FAILED(rv)) {
     return rv;
@@ -345,8 +348,9 @@ nsTransactionItem::RecoverFromRedoError(
 
   if (!mTransaction) {
     return NS_OK;
   }
 
   return mTransaction->UndoTransaction();
 }
 
+} // namespace mozilla

rename from editor/txmgr/nsTransactionItem.h
rename to editor/txmgr/TransactionItem.h
--- a/editor/txmgr/nsTransactionItem.h
+++ b/editor/txmgr/TransactionItem.h
@@ -1,72 +1,71 @@
 /* -*- 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/. */
 
-#ifndef nsTransactionItem_h__
-#define nsTransactionItem_h__
+#ifndef TransactionItem_h
+#define TransactionItem_h
 
 #include "nsCOMPtr.h"
 #include "nsCOMArray.h"
 #include "nsCycleCollectionParticipant.h"
 #include "nsISupportsImpl.h"
 #include "nscore.h"
 
 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()
   {
     return mData;
   }
 
 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

--- a/editor/txmgr/TransactionManager.cpp
+++ b/editor/txmgr/TransactionManager.cpp
@@ -10,18 +10,18 @@
 #include "nsCOMPtr.h"
 #include "nsDebug.h"
 #include "nsError.h"
 #include "nsISupportsBase.h"
 #include "nsISupportsUtils.h"
 #include "nsITransaction.h"
 #include "nsITransactionListener.h"
 #include "nsIWeakReference.h"
-#include "nsTransactionItem.h"
 #include "nsTransactionStack.h"
+#include "TransactionItem.h"
 
 namespace mozilla {
 
 TransactionManager::TransactionManager(int32_t aMaxTransactionCount)
   : mMaxTransactionCount(aMaxTransactionCount)
   , mDoStack(nsTransactionStack::FOR_UNDO)
   , mUndoStack(nsTransactionStack::FOR_UNDO)
   , mRedoStack(nsTransactionStack::FOR_REDO)
@@ -93,36 +93,36 @@ TransactionManager::UndoTransaction()
   // executing a  transaction's DoTransaction() method! If this happens,
   // the UndoTransaction() request is ignored, and we return NS_ERROR_FAILURE.
   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<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)) {
     return rv;
   }
   if (doInterrupt) {
     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);
   if (NS_SUCCEEDED(rv)) {
     rv = rv2;
   }
 
   // XXX The result of UndoTransaction() or DidUndoNotify() if UndoTransaction()
@@ -137,39 +137,39 @@ TransactionManager::RedoTransaction()
   // executing a  transaction's DoTransaction() method! If this happens,
   // the RedoTransaction() request is ignored, and we return NS_ERROR_FAILURE.
   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<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;
   }
   if (doInterrupt) {
     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;
   }
 
   // XXX The result of RedoTransaction() or DidRedoNotify() if RedoTransaction()
   //     succeeded.
   return rv;
 }
@@ -220,22 +220,22 @@ TransactionManager::EndBatch(bool aAllow
   //      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<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;
   }
 
   bool doInterrupt = false;
   nsresult rv = WillEndBatchNotify(&doInterrupt);
   if (NS_FAILED(rv)) {
     return rv;
   }
@@ -304,28 +304,28 @@ TransactionManager::SetMaxTransactionCou
   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) {
-    RefPtr<nsTransactionItem> tx = mUndoStack.PopBottom();
-    if (!tx) {
+    RefPtr<TransactionItem> transactionItem = mUndoStack.PopBottom();
+    if (!transactionItem) {
       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) {
-    RefPtr<nsTransactionItem> tx = mRedoStack.PopBottom();
-    if (!tx) {
+    RefPtr<TransactionItem> transactionItem = mRedoStack.PopBottom();
+    if (!transactionItem) {
       return NS_ERROR_FAILURE;
     }
     --numRedoItems;
   }
 
   mMaxTransactionCount = aMaxCount;
   return NS_OK;
 }
@@ -336,56 +336,53 @@ TransactionManager::PeekUndoStack(nsITra
   MOZ_ASSERT(aTransaction);
   *aTransaction = PeekUndoStack().take();
   return NS_OK;
 }
 
 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
 TransactionManager::PeekRedoStack(nsITransaction** aTransaction)
 {
   MOZ_ASSERT(aTransaction);
   *aTransaction = PeekRedoStack().take();
   return NS_OK;
 }
 
 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
 TransactionManager::BatchTopUndo()
 {
   if (mUndoStack.GetSize() < 2) {
     // Not enough transactions to merge into one batch.
     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);
 
   // 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();
@@ -396,17 +393,17 @@ TransactionManager::BatchTopUndo()
 
 nsresult
 TransactionManager::RemoveTopUndo()
 {
   if (mUndoStack.IsEmpty()) {
     return NS_OK;
   }
 
-  RefPtr<nsTransactionItem> lastUndo = mUndoStack.Pop();
+  RefPtr<TransactionItem> lastUndo = mUndoStack.Pop();
   return NS_OK;
 }
 
 NS_IMETHODIMP
 TransactionManager::AddListener(nsITransactionListener* aListener)
 {
   NS_ENSURE_TRUE(aListener, NS_ERROR_NULL_POINTER);
   return mListeners.AppendObject(aListener) ? NS_OK : NS_ERROR_FAILURE;
@@ -626,96 +623,93 @@ TransactionManager::DidMergeNotify(nsITr
 }
 
 nsresult
 TransactionManager::BeginTransaction(nsITransaction* aTransaction,
                                      nsISupports* aData)
 {
   // 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;
 }
 
 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;
     }
   }
 
   // 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?
     return rv;
   }
 
   // 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.
   rv = ClearRedoStack();
   if (NS_FAILED(rv)) {
     // 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) {
+  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;
         }
         if (NS_FAILED(rv)) {
           // XXX: What do we do if this fails?
         }
         if (didMerge) {
           return rv;
@@ -723,17 +717,17 @@ TransactionManager::EndTransaction(bool 
       }
     }
   }
 
   // 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<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;
 }
 
 } // namespace mozilla

--- a/editor/txmgr/moz.build
+++ b/editor/txmgr/moz.build
@@ -18,15 +18,15 @@ EXPORTS += [
     'nsTransactionManagerCID.h',
 ]
 
 EXPORTS.mozilla += [
     'TransactionManager.h',
 ]
 
 UNIFIED_SOURCES += [
-    'nsTransactionItem.cpp',
     'nsTransactionStack.cpp',
+    'TransactionItem.cpp',
     'TransactionManager.cpp',
     'TransactionManagerFactory.cpp',
 ]
 
 FINAL_LIBRARY = 'xul'

--- a/editor/txmgr/nsTransactionStack.cpp
+++ b/editor/txmgr/nsTransactionStack.cpp
@@ -1,108 +1,114 @@
 /* -*- 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 "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));
   }
 };
 
 nsTransactionStack::nsTransactionStack(Type aType)
   : nsDeque(new nsTransactionStackDeallocator())
   , mType(aType)
 {
 }
 
 nsTransactionStack::~nsTransactionStack()
 {
   Clear();
 }
 
 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;
   }
 
   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();
 }
 
 void
 nsTransactionStack::Clear()
 {
   while (GetSize() != 0) {
-    RefPtr<nsTransactionItem> item =
+    RefPtr<TransactionItem> item =
       mType == FOR_UNDO ? Pop() : PopBottom();
   }
 }
 
 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));
     }
   }
 }

--- a/editor/txmgr/nsTransactionStack.h
+++ b/editor/txmgr/nsTransactionStack.h
@@ -4,32 +4,35 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef nsTransactionStack_h__
 #define nsTransactionStack_h__
 
 #include "nsDeque.h"
 
 class nsCycleCollectionTraversalCallback;
-class nsTransactionItem;
+
+namespace mozilla {
+class TransactionItem;
+} // namespace mozilla
 
 class nsTransactionStack : private nsDeque
 {
 public:
   enum Type { FOR_UNDO, FOR_REDO };
 
   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; }
 
   void DoUnlink() { Clear(); }
   void DoTraverse(nsCycleCollectionTraversalCallback &cb);
 
 private: