--- a/editor/libeditor/EditorBase.cpp
+++ b/editor/libeditor/EditorBase.cpp
@@ -43,16 +43,17 @@
 #include "mozilla/Preferences.h"        // for Preferences
 #include "mozilla/RangeBoundary.h"      // for RawRangeBoundary, RangeBoundary
 #include "mozilla/dom/Selection.h"      // for Selection, etc.
 #include "mozilla/Services.h"           // for GetObserverService
 #include "mozilla/TextComposition.h"    // for TextComposition
 #include "mozilla/TextInputListener.h"  // for TextInputListener
 #include "mozilla/TextServicesDocument.h" // for TextServicesDocument
 #include "mozilla/TextEvents.h"
+#include "mozilla/TransactionManager.h" // for TransactionManager
 #include "mozilla/dom/CharacterData.h"  // for CharacterData
 #include "mozilla/dom/Element.h"        // for Element, nsINode::AsElement
 #include "mozilla/dom/HTMLBodyElement.h"
 #include "mozilla/dom/Text.h"
 #include "mozilla/dom/Event.h"
 #include "nsAString.h"                  // for nsAString::Length, etc.
 #include "nsCCUncollectableMarker.h"    // for nsCCUncollectableMarker
 #include "nsCaret.h"                    // for nsCaret
@@ -103,17 +104,16 @@
 #include "nsReadableUtils.h"            // for EmptyString, ToNewCString
 #include "nsString.h"                   // for nsAutoString, nsString, etc.
 #include "nsStringFwd.h"                // for nsString
 #include "nsStyleConsts.h"              // for NS_STYLE_DIRECTION_RTL, etc.
 #include "nsStyleStruct.h"              // for nsStyleDisplay, nsStyleText, etc.
 #include "nsStyleStructFwd.h"           // for nsIFrame::StyleUIReset, etc.
 #include "nsTextNode.h"                 // for nsTextNode
 #include "nsThreadUtils.h"              // for nsRunnable
-#include "nsTransactionManager.h"       // for nsTransactionManager
 #include "prtime.h"                     // for PR_Now
 
 class nsIOutputStream;
 class nsITransferable;
 
 namespace mozilla {
 
 using namespace dom;
@@ -175,30 +175,30 @@ EditorBase::~EditorBase()
              "Why PreDestroy hasn't been called?");
 
   if (mComposition) {
     mComposition->OnEditorDestroyed();
     mComposition = nullptr;
   }
   // If this editor is still hiding the caret, we need to restore it.
   HideCaret(false);
-  mTxnMgr = nullptr;
+  mTransactionManager = nullptr;
 }
 
 NS_IMPL_CYCLE_COLLECTION_CLASS(EditorBase)
 
 NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(EditorBase)
  NS_IMPL_CYCLE_COLLECTION_UNLINK(mRootElement)
  NS_IMPL_CYCLE_COLLECTION_UNLINK(mSelectionController)
  NS_IMPL_CYCLE_COLLECTION_UNLINK(mDocument)
  NS_IMPL_CYCLE_COLLECTION_UNLINK(mIMEContentObserver)
  NS_IMPL_CYCLE_COLLECTION_UNLINK(mInlineSpellChecker)
  NS_IMPL_CYCLE_COLLECTION_UNLINK(mTextServicesDocument)
  NS_IMPL_CYCLE_COLLECTION_UNLINK(mTextInputListener)
- NS_IMPL_CYCLE_COLLECTION_UNLINK(mTxnMgr)
+ NS_IMPL_CYCLE_COLLECTION_UNLINK(mTransactionManager)
  NS_IMPL_CYCLE_COLLECTION_UNLINK(mActionListeners)
  NS_IMPL_CYCLE_COLLECTION_UNLINK(mEditorObservers)
  NS_IMPL_CYCLE_COLLECTION_UNLINK(mDocStateListeners)
  NS_IMPL_CYCLE_COLLECTION_UNLINK(mEventTarget)
 
  if (tmp->mEventListener) {
    tmp->mEventListener->Disconnect();
    tmp->mEventListener = nullptr;
@@ -218,17 +218,17 @@ NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(
  }
  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mRootElement)
  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mSelectionController)
  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mDocument)
  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mIMEContentObserver)
  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mInlineSpellChecker)
  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mTextServicesDocument)
  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mTextInputListener)
- NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mTxnMgr)
+ NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mTransactionManager)
  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mActionListeners)
  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mEditorObservers)
  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mDocStateListeners)
  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mEventTarget)
  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mEventListener)
  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mPlaceholderTransaction)
  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mSavedSel);
  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mRangeUpdater);
@@ -520,19 +520,19 @@ EditorBase::PreDestroy(bool aDestroyingF
   mInlineSpellChecker = nullptr;
   mTextServicesDocument = nullptr;
   mTextInputListener = nullptr;
   mSpellcheckCheckboxState = eTriUnset;
   mRootElement = nullptr;
 
   // Transaction may grab this instance.  Therefore, they should be released
   // here for stopping the circular reference with this instance.
-  if (mTxnMgr) {
-    mTxnMgr->Clear();
-    mTxnMgr = nullptr;
+  if (mTransactionManager) {
+    mTransactionManager->Clear();
+    mTransactionManager = nullptr;
   }
 
   mDidPreDestroy = true;
   return NS_OK;
 }
 
 NS_IMETHODIMP
 EditorBase::GetFlags(uint32_t* aFlags)
@@ -741,18 +741,19 @@ EditorBase::DoTransaction(Selection* aSe
   if (mPlaceholderBatch && !mPlaceholderTransaction) {
     mPlaceholderTransaction =
       PlaceholderTransaction::Create(*this, mPlaceholderName, Move(mSelState));
     MOZ_ASSERT(mSelState.isNothing());
 
     // We will recurse, but will not hit this case in the nested call
     DoTransaction(mPlaceholderTransaction);
 
-    if (mTxnMgr) {
-      nsCOMPtr<nsITransaction> topTransaction = mTxnMgr->PeekUndoStack();
+    if (mTransactionManager) {
+      nsCOMPtr<nsITransaction> topTransaction =
+        mTransactionManager->PeekUndoStack();
       nsCOMPtr<nsIAbsorbingTransaction> topAbsorbingTransaction =
         do_QueryInterface(topTransaction);
       if (topAbsorbingTransaction) {
         RefPtr<PlaceholderTransaction> topPlaceholderTransaction =
           topAbsorbingTransaction->AsPlaceholderTransaction();
         if (topPlaceholderTransaction) {
           // there is a placeholder transaction on top of the undo stack.  It
           // is either the one we just created, or an earlier one that we are
@@ -786,19 +787,19 @@ EditorBase::DoTransaction(Selection* aSe
 
     // get the selection and start a batch change
     RefPtr<Selection> selection = aSelection ? aSelection : GetSelection();
     NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
 
     SelectionBatcher selectionBatcher(selection);
 
     nsresult rv;
-    if (mTxnMgr) {
-      RefPtr<nsTransactionManager> txnMgr = mTxnMgr;
-      rv = txnMgr->DoTransaction(aTxn);
+    if (mTransactionManager) {
+      RefPtr<TransactionManager> transactionManager(mTransactionManager);
+      rv = transactionManager->DoTransaction(aTxn);
     } else {
       rv = aTxn->DoTransaction();
     }
     if (NS_WARN_IF(NS_FAILED(rv))) {
       return rv;
     }
 
     DoAfterDoTransaction(aTxn);
@@ -806,64 +807,66 @@ EditorBase::DoTransaction(Selection* aSe
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
 EditorBase::EnableUndo(bool aEnable)
 {
   if (aEnable) {
-    if (!mTxnMgr) {
-      mTxnMgr = new nsTransactionManager();
+    if (!mTransactionManager) {
+      mTransactionManager = new TransactionManager();
     }
-    mTxnMgr->SetMaxTransactionCount(-1);
-  } else if (mTxnMgr) {
+    mTransactionManager->SetMaxTransactionCount(-1);
+  } else if (mTransactionManager) {
     // disable the transaction manager if it is enabled
-    mTxnMgr->Clear();
-    mTxnMgr->SetMaxTransactionCount(0);
+    mTransactionManager->Clear();
+    mTransactionManager->SetMaxTransactionCount(0);
   }
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
 EditorBase::GetNumberOfUndoItems(int32_t* aNumItems)
 {
   *aNumItems = NumberOfUndoItems();
   return *aNumItems >= 0 ? NS_OK : NS_ERROR_FAILURE;
 }
 
 int32_t
 EditorBase::NumberOfUndoItems() const
 {
-  if (!mTxnMgr) {
+  if (!mTransactionManager) {
     return 0;
   }
   int32_t numItems = 0;
-  if (NS_WARN_IF(NS_FAILED(mTxnMgr->GetNumberOfUndoItems(&numItems)))) {
+  nsresult rv = mTransactionManager->GetNumberOfUndoItems(&numItems);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
     return -1;
   }
   return numItems;
 }
 
 NS_IMETHODIMP
 EditorBase::GetNumberOfRedoItems(int32_t* aNumItems)
 {
   *aNumItems = NumberOfRedoItems();
   return *aNumItems >= 0 ? NS_OK : NS_ERROR_FAILURE;
 }
 
 int32_t
 EditorBase::NumberOfRedoItems() const
 {
-  if (!mTxnMgr) {
+  if (!mTransactionManager) {
     return 0;
   }
   int32_t numItems = 0;
-  if (NS_WARN_IF(NS_FAILED(mTxnMgr->GetNumberOfRedoItems(&numItems)))) {
+  nsresult rv = mTransactionManager->GetNumberOfRedoItems(&numItems);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
     return -1;
   }
   return numItems;
 }
 
 NS_IMETHODIMP
 EditorBase::GetTransactionManager(nsITransactionManager** aTxnManager)
 {
@@ -877,121 +880,121 @@ EditorBase::GetTransactionManager(nsITra
     return NS_ERROR_FAILURE;
   }
   return NS_OK;
 }
 
 already_AddRefed<nsITransactionManager>
 EditorBase::GetTransactionManager() const
 {
-  nsCOMPtr<nsITransactionManager> transactionManager = mTxnMgr.get();
+  nsCOMPtr<nsITransactionManager> transactionManager(mTransactionManager);
   return transactionManager.forget();
 }
 
 NS_IMETHODIMP
 EditorBase::Undo(uint32_t aCount)
 {
   ForceCompositionEnd();
 
-  bool hasTxnMgr, hasTransaction = false;
-  CanUndo(&hasTxnMgr, &hasTransaction);
+  bool hasTransactionManager, hasTransaction = false;
+  CanUndo(&hasTransactionManager, &hasTransaction);
   NS_ENSURE_TRUE(hasTransaction, NS_OK);
 
   AutoRules beginRulesSniffing(this, EditAction::undo, nsIEditor::eNone);
 
-  if (!mTxnMgr) {
+  if (!mTransactionManager) {
     return NS_OK;
   }
 
-  RefPtr<nsTransactionManager> txnMgr = mTxnMgr;
+  RefPtr<TransactionManager> transactionManager(mTransactionManager);
   for (uint32_t i = 0; i < aCount; ++i) {
-    nsresult rv = txnMgr->UndoTransaction();
+    nsresult rv = transactionManager->UndoTransaction();
     NS_ENSURE_SUCCESS(rv, rv);
 
     DoAfterUndoTransaction();
   }
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
 EditorBase::CanUndo(bool* aIsEnabled,
                     bool* aCanUndo)
 {
   NS_ENSURE_TRUE(aIsEnabled && aCanUndo, NS_ERROR_NULL_POINTER);
-  *aIsEnabled = !!mTxnMgr;
+  *aIsEnabled = !!mTransactionManager;
   if (*aIsEnabled) {
     int32_t numTxns = 0;
-    mTxnMgr->GetNumberOfUndoItems(&numTxns);
+    mTransactionManager->GetNumberOfUndoItems(&numTxns);
     *aCanUndo = !!numTxns;
   } else {
     *aCanUndo = false;
   }
   return NS_OK;
 }
 
 NS_IMETHODIMP
 EditorBase::Redo(uint32_t aCount)
 {
-  bool hasTxnMgr, hasTransaction = false;
-  CanRedo(&hasTxnMgr, &hasTransaction);
+  bool hasTransactionManager, hasTransaction = false;
+  CanRedo(&hasTransactionManager, &hasTransaction);
   NS_ENSURE_TRUE(hasTransaction, NS_OK);
 
   AutoRules beginRulesSniffing(this, EditAction::redo, nsIEditor::eNone);
 
-  if (!mTxnMgr) {
+  if (!mTransactionManager) {
     return NS_OK;
   }
 
-  RefPtr<nsTransactionManager> txnMgr = mTxnMgr;
+  RefPtr<TransactionManager> transactionManager(mTransactionManager);
   for (uint32_t i = 0; i < aCount; ++i) {
-    nsresult rv = txnMgr->RedoTransaction();
+    nsresult rv = transactionManager->RedoTransaction();
     NS_ENSURE_SUCCESS(rv, rv);
 
     DoAfterRedoTransaction();
   }
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
 EditorBase::CanRedo(bool* aIsEnabled, bool* aCanRedo)
 {
   NS_ENSURE_TRUE(aIsEnabled && aCanRedo, NS_ERROR_NULL_POINTER);
 
-  *aIsEnabled = !!mTxnMgr;
+  *aIsEnabled = !!mTransactionManager;
   if (*aIsEnabled) {
     int32_t numTxns = 0;
-    mTxnMgr->GetNumberOfRedoItems(&numTxns);
+    mTransactionManager->GetNumberOfRedoItems(&numTxns);
     *aCanRedo = !!numTxns;
   } else {
     *aCanRedo = false;
   }
   return NS_OK;
 }
 
 NS_IMETHODIMP
 EditorBase::BeginTransaction()
 {
   BeginUpdateViewBatch();
 
-  if (mTxnMgr) {
-    RefPtr<nsTransactionManager> txnMgr = mTxnMgr;
-    txnMgr->BeginBatch(nullptr);
+  if (mTransactionManager) {
+    RefPtr<TransactionManager> transactionManager(mTransactionManager);
+    transactionManager->BeginBatch(nullptr);
   }
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
 EditorBase::EndTransaction()
 {
-  if (mTxnMgr) {
-    RefPtr<nsTransactionManager> txnMgr = mTxnMgr;
-    txnMgr->EndBatch(false);
+  if (mTransactionManager) {
+    RefPtr<TransactionManager> transactionManager(mTransactionManager);
+    transactionManager->EndBatch(false);
   }
 
   EndUpdateViewBatch();
 
   return NS_OK;
 }
 
 void
@@ -2466,18 +2469,18 @@ EditorBase::BeginIMEComposition(WidgetCo
 
 void
 EditorBase::EndIMEComposition()
 {
   NS_ENSURE_TRUE_VOID(mComposition); // nothing to do
 
   // commit the IME transaction..we can get at it via the transaction mgr.
   // Note that this means IME won't work without an undo stack!
-  if (mTxnMgr) {
-    nsCOMPtr<nsITransaction> txn = mTxnMgr->PeekUndoStack();
+  if (mTransactionManager) {
+    nsCOMPtr<nsITransaction> txn = mTransactionManager->PeekUndoStack();
     nsCOMPtr<nsIAbsorbingTransaction> plcTxn = do_QueryInterface(txn);
     if (plcTxn) {
       DebugOnly<nsresult> rv = plcTxn->Commit();
       NS_ASSERTION(NS_SUCCEEDED(rv),
                    "nsIAbsorbingTransaction::Commit() failed");
     }
   }
 

--- a/editor/libeditor/EditorBase.h
+++ b/editor/libeditor/EditorBase.h
@@ -46,17 +46,16 @@ class nsIDocumentStateListener;
 class nsIEditActionListener;
 class nsIEditorObserver;
 class nsINode;
 class nsIPresShell;
 class nsISupports;
 class nsITransaction;
 class nsIWidget;
 class nsRange;
-class nsTransactionManager;
 
 namespace mozilla {
 class AddStyleSheetTransaction;
 class AutoRules;
 class AutoSelectionRestorer;
 class AutoTransactionsConserveSelection;
 class ChangeAttributeTransaction;
 class CompositionTransaction;
@@ -75,16 +74,17 @@ class JoinNodeTransaction;
 class PlaceholderTransaction;
 class RemoveStyleSheetTransaction;
 class SplitNodeResult;
 class SplitNodeTransaction;
 class TextComposition;
 class TextEditor;
 class TextInputListener;
 class TextServicesDocument;
+class TransactionManager;
 enum class EditAction : int32_t;
 
 namespace dom {
 class DataTransfer;
 class DragEvent;
 class Element;
 class EventTarget;
 class Text;
@@ -1508,17 +1508,17 @@ protected:
 
   // MIME type of the doc we are editing.
   nsCString mContentMIMEType;
 
   RefPtr<mozInlineSpellChecker> mInlineSpellChecker;
   // Reference to text services document for mInlineSpellChecker.
   RefPtr<TextServicesDocument> mTextServicesDocument;
 
-  RefPtr<nsTransactionManager> mTxnMgr;
+  RefPtr<TransactionManager> mTransactionManager;
   // Cached root node.
   nsCOMPtr<Element> mRootElement;
   // The form field as an event receiver.
   nsCOMPtr<dom::EventTarget> mEventTarget;
   RefPtr<EditorEventListener> mEventListener;
   // Strong reference to placeholder for begin/end batch purposes.
   RefPtr<PlaceholderTransaction> mPlaceholderTransaction;
   // Name of placeholder transaction.

rename from editor/txmgr/nsTransactionManager.cpp
rename to editor/txmgr/TransactionManager.cpp
--- a/editor/txmgr/nsTransactionManager.cpp
+++ b/editor/txmgr/TransactionManager.cpp
@@ -1,66 +1,65 @@
 /* -*- 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/mozalloc.h"
 #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 "nsTransactionManager.h"
 #include "nsTransactionStack.h"
 
-nsTransactionManager::nsTransactionManager(int32_t aMaxTransactionCount)
+namespace mozilla {
+
+TransactionManager::TransactionManager(int32_t aMaxTransactionCount)
   : mMaxTransactionCount(aMaxTransactionCount)
   , mDoStack(nsTransactionStack::FOR_UNDO)
   , mUndoStack(nsTransactionStack::FOR_UNDO)
   , mRedoStack(nsTransactionStack::FOR_REDO)
 {
 }
 
-nsTransactionManager::~nsTransactionManager()
-{
-}
+NS_IMPL_CYCLE_COLLECTION_CLASS(TransactionManager)
 
-NS_IMPL_CYCLE_COLLECTION_CLASS(nsTransactionManager)
-
-NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(nsTransactionManager)
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(TransactionManager)
   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_BEGIN(TransactionManager)
   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_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(nsTransactionManager)
-NS_IMPL_CYCLE_COLLECTING_RELEASE(nsTransactionManager)
+NS_IMPL_CYCLE_COLLECTING_ADDREF(TransactionManager)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(TransactionManager)
 
 NS_IMETHODIMP
-nsTransactionManager::DoTransaction(nsITransaction *aTransaction)
+TransactionManager::DoTransaction(nsITransaction* aTransaction)
 {
   NS_ENSURE_TRUE(aTransaction, NS_ERROR_NULL_POINTER);
 
   bool doInterrupt = false;
 
   nsresult rv = WillDoNotify(aTransaction, &doInterrupt);
   if (NS_FAILED(rv)) {
     return rv;
@@ -83,17 +82,17 @@ nsTransactionManager::DoTransaction(nsIT
   }
 
   // XXX The result of EndTransaction() or DidDoNotify() if EndTransaction()
   //     succeeded.
   return rv;
 }
 
 NS_IMETHODIMP
-nsTransactionManager::UndoTransaction()
+TransactionManager::UndoTransaction()
 {
   // 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.
   if (!mDoStack.IsEmpty()) {
     return NS_ERROR_FAILURE;
   }
 
@@ -127,17 +126,17 @@ nsTransactionManager::UndoTransaction()
   }
 
   // XXX The result of UndoTransaction() or DidUndoNotify() if UndoTransaction()
   //     succeeded.
   return rv;
 }
 
 NS_IMETHODIMP
-nsTransactionManager::RedoTransaction()
+TransactionManager::RedoTransaction()
 {
   // 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.
   if (!mDoStack.IsEmpty()) {
     return NS_ERROR_FAILURE;
   }
 
@@ -171,27 +170,27 @@ nsTransactionManager::RedoTransaction()
   }
 
   // XXX The result of RedoTransaction() or DidRedoNotify() if RedoTransaction()
   //     succeeded.
   return rv;
 }
 
 NS_IMETHODIMP
-nsTransactionManager::Clear()
+TransactionManager::Clear()
 {
   nsresult rv = ClearRedoStack();
   if (NS_FAILED(rv)) {
     return rv;
   }
   return ClearUndoStack();
 }
 
 NS_IMETHODIMP
-nsTransactionManager::BeginBatch(nsISupports* aData)
+TransactionManager::BeginBatch(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().
   bool doInterrupt = false;
   nsresult rv = WillBeginBatchNotify(&doInterrupt);
   if (NS_FAILED(rv)) {
@@ -209,17 +208,17 @@ nsTransactionManager::BeginBatch(nsISupp
   }
 
   // XXX The result of BeginTransaction() or DidBeginBatchNotify() if
   //     BeginTransaction() succeeded.
   return rv;
 }
 
 NS_IMETHODIMP
-nsTransactionManager::EndBatch(bool aAllowEmpty)
+TransactionManager::EndBatch(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
@@ -251,39 +250,39 @@ nsTransactionManager::EndBatch(bool aAll
   }
 
   // XXX The result of EndTransaction() or DidEndBatchNotify() if
   //     EndTransaction() succeeded.
   return rv;
 }
 
 NS_IMETHODIMP
-nsTransactionManager::GetNumberOfUndoItems(int32_t *aNumItems)
+TransactionManager::GetNumberOfUndoItems(int32_t* aNumItems)
 {
   *aNumItems = mUndoStack.GetSize();
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsTransactionManager::GetNumberOfRedoItems(int32_t *aNumItems)
+TransactionManager::GetNumberOfRedoItems(int32_t* aNumItems)
 {
   *aNumItems = mRedoStack.GetSize();
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsTransactionManager::GetMaxTransactionCount(int32_t *aMaxCount)
+TransactionManager::GetMaxTransactionCount(int32_t* aMaxCount)
 {
   NS_ENSURE_TRUE(aMaxCount, NS_ERROR_NULL_POINTER);
   *aMaxCount = mMaxTransactionCount;
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsTransactionManager::SetMaxTransactionCount(int32_t aMaxCount)
+TransactionManager::SetMaxTransactionCount(int32_t aMaxCount)
 {
   // 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.
   if (!mDoStack.IsEmpty()) {
     return NS_ERROR_FAILURE;
@@ -327,53 +326,53 @@ nsTransactionManager::SetMaxTransactionC
     --numRedoItems;
   }
 
   mMaxTransactionCount = aMaxCount;
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsTransactionManager::PeekUndoStack(nsITransaction **aTransaction)
+TransactionManager::PeekUndoStack(nsITransaction** aTransaction)
 {
   MOZ_ASSERT(aTransaction);
   *aTransaction = PeekUndoStack().take();
   return NS_OK;
 }
 
 already_AddRefed<nsITransaction>
-nsTransactionManager::PeekUndoStack()
+TransactionManager::PeekUndoStack()
 {
   RefPtr<nsTransactionItem> tx = mUndoStack.Peek();
   if (!tx) {
     return nullptr;
   }
   return tx->GetTransaction();
 }
 
 NS_IMETHODIMP
-nsTransactionManager::PeekRedoStack(nsITransaction** aTransaction)
+TransactionManager::PeekRedoStack(nsITransaction** aTransaction)
 {
   MOZ_ASSERT(aTransaction);
   *aTransaction = PeekRedoStack().take();
   return NS_OK;
 }
 
 already_AddRefed<nsITransaction>
-nsTransactionManager::PeekRedoStack()
+TransactionManager::PeekRedoStack()
 {
   RefPtr<nsTransactionItem> tx = mRedoStack.Peek();
   if (!tx) {
     return nullptr;
   }
   return tx->GetTransaction();
 }
 
 nsresult
-nsTransactionManager::BatchTopUndo()
+TransactionManager::BatchTopUndo()
 {
   if (mUndoStack.GetSize() < 2) {
     // Not enough transactions to merge into one batch.
     return NS_OK;
   }
 
   RefPtr<nsTransactionItem> lastUndo;
   RefPtr<nsTransactionItem> previousUndo;
@@ -391,241 +390,249 @@ nsTransactionManager::BatchTopUndo()
   nsCOMArray<nsISupports>& lastData = lastUndo->GetData();
   nsCOMArray<nsISupports>& previousData = previousUndo->GetData();
   NS_ENSURE_TRUE(previousData.AppendObjects(lastData), NS_ERROR_UNEXPECTED);
   lastData.Clear();
   return rv;
 }
 
 nsresult
-nsTransactionManager::RemoveTopUndo()
+TransactionManager::RemoveTopUndo()
 {
   if (mUndoStack.IsEmpty()) {
     return NS_OK;
   }
 
   RefPtr<nsTransactionItem> lastUndo = mUndoStack.Pop();
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsTransactionManager::AddListener(nsITransactionListener *aListener)
+TransactionManager::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)
+TransactionManager::RemoveListener(nsITransactionListener* aListener)
 {
   NS_ENSURE_TRUE(aListener, NS_ERROR_NULL_POINTER);
   return mListeners.RemoveObject(aListener) ? NS_OK : NS_ERROR_FAILURE;
 }
 
 NS_IMETHODIMP
-nsTransactionManager::ClearUndoStack()
+TransactionManager::ClearUndoStack()
 {
   mUndoStack.Clear();
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsTransactionManager::ClearRedoStack()
+TransactionManager::ClearRedoStack()
 {
   mRedoStack.Clear();
   return NS_OK;
 }
 
 nsresult
-nsTransactionManager::WillDoNotify(nsITransaction *aTransaction, bool *aInterrupt)
+TransactionManager::WillDoNotify(nsITransaction* aTransaction,
+                                 bool* aInterrupt)
 {
   for (int32_t i = 0, lcount = mListeners.Count(); i < lcount; i++) {
     nsITransactionListener* listener = mListeners[i];
     NS_ENSURE_TRUE(listener, NS_ERROR_FAILURE);
 
     nsresult rv = listener->WillDo(this, aTransaction, aInterrupt);
     if (NS_FAILED(rv) || *aInterrupt) {
       return rv;
     }
   }
   return NS_OK;
 }
 
 nsresult
-nsTransactionManager::DidDoNotify(nsITransaction *aTransaction, nsresult aDoResult)
+TransactionManager::DidDoNotify(nsITransaction* aTransaction,
+                                nsresult aDoResult)
 {
   for (int32_t i = 0, lcount = mListeners.Count(); i < lcount; i++) {
     nsITransactionListener* listener = mListeners[i];
     NS_ENSURE_TRUE(listener, NS_ERROR_FAILURE);
 
     nsresult rv = listener->DidDo(this, aTransaction, aDoResult);
     if (NS_FAILED(rv)) {
       return rv;
     }
   }
   return NS_OK;
 }
 
 nsresult
-nsTransactionManager::WillUndoNotify(nsITransaction *aTransaction, bool *aInterrupt)
+TransactionManager::WillUndoNotify(nsITransaction* aTransaction,
+                                   bool* aInterrupt)
 {
   for (int32_t i = 0, lcount = mListeners.Count(); i < lcount; i++) {
     nsITransactionListener* listener = mListeners[i];
     NS_ENSURE_TRUE(listener, NS_ERROR_FAILURE);
 
     nsresult rv = listener->WillUndo(this, aTransaction, aInterrupt);
     if (NS_FAILED(rv) || *aInterrupt) {
       return rv;
     }
   }
   return NS_OK;
 }
 
 nsresult
-nsTransactionManager::DidUndoNotify(nsITransaction *aTransaction, nsresult aUndoResult)
+TransactionManager::DidUndoNotify(nsITransaction* aTransaction,
+                                  nsresult aUndoResult)
 {
   for (int32_t i = 0, lcount = mListeners.Count(); i < lcount; i++) {
     nsITransactionListener* listener = mListeners[i];
     NS_ENSURE_TRUE(listener, NS_ERROR_FAILURE);
 
     nsresult rv = listener->DidUndo(this, aTransaction, aUndoResult);
     if (NS_FAILED(rv)) {
       return rv;
     }
   }
   return NS_OK;
 }
 
 nsresult
-nsTransactionManager::WillRedoNotify(nsITransaction *aTransaction, bool *aInterrupt)
+TransactionManager::WillRedoNotify(nsITransaction* aTransaction,
+                                   bool* aInterrupt)
 {
   for (int32_t i = 0, lcount = mListeners.Count(); i < lcount; i++) {
     nsITransactionListener* listener = mListeners[i];
     NS_ENSURE_TRUE(listener, NS_ERROR_FAILURE);
 
     nsresult rv = listener->WillRedo(this, aTransaction, aInterrupt);
     if (NS_FAILED(rv) || *aInterrupt) {
       return rv;
     }
   }
   return NS_OK;
 }
 
 nsresult
-nsTransactionManager::DidRedoNotify(nsITransaction *aTransaction, nsresult aRedoResult)
+TransactionManager::DidRedoNotify(nsITransaction* aTransaction,
+                                  nsresult aRedoResult)
 {
   for (int32_t i = 0, lcount = mListeners.Count(); i < lcount; i++) {
     nsITransactionListener* listener = mListeners[i];
     NS_ENSURE_TRUE(listener, NS_ERROR_FAILURE);
 
     nsresult rv = listener->DidRedo(this, aTransaction, aRedoResult);
     if (NS_FAILED(rv)) {
       return rv;
     }
   }
   return NS_OK;
 }
 
 nsresult
-nsTransactionManager::WillBeginBatchNotify(bool *aInterrupt)
+TransactionManager::WillBeginBatchNotify(bool* aInterrupt)
 {
   for (int32_t i = 0, lcount = mListeners.Count(); i < lcount; i++) {
     nsITransactionListener* listener = mListeners[i];
     NS_ENSURE_TRUE(listener, NS_ERROR_FAILURE);
 
     nsresult rv = listener->WillBeginBatch(this, aInterrupt);
     if (NS_FAILED(rv) || *aInterrupt) {
       return rv;
     }
   }
   return NS_OK;
 }
 
 nsresult
-nsTransactionManager::DidBeginBatchNotify(nsresult aResult)
+TransactionManager::DidBeginBatchNotify(nsresult aResult)
 {
   for (int32_t i = 0, lcount = mListeners.Count(); i < lcount; i++) {
     nsITransactionListener* listener = mListeners[i];
     NS_ENSURE_TRUE(listener, NS_ERROR_FAILURE);
 
     nsresult rv = listener->DidBeginBatch(this, aResult);
     if (NS_FAILED(rv)) {
       return rv;
     }
   }
   return NS_OK;
 }
 
 nsresult
-nsTransactionManager::WillEndBatchNotify(bool *aInterrupt)
+TransactionManager::WillEndBatchNotify(bool* aInterrupt)
 {
   for (int32_t i = 0, lcount = mListeners.Count(); i < lcount; i++) {
     nsITransactionListener* listener = mListeners[i];
     NS_ENSURE_TRUE(listener, NS_ERROR_FAILURE);
 
     nsresult rv = listener->WillEndBatch(this, aInterrupt);
     if (NS_FAILED(rv) || *aInterrupt) {
       return rv;
     }
   }
   return NS_OK;
 }
 
 nsresult
-nsTransactionManager::DidEndBatchNotify(nsresult aResult)
+TransactionManager::DidEndBatchNotify(nsresult aResult)
 {
   for (int32_t i = 0, lcount = mListeners.Count(); i < lcount; i++) {
     nsITransactionListener* listener = mListeners[i];
     NS_ENSURE_TRUE(listener, NS_ERROR_FAILURE);
 
     nsresult rv = listener->DidEndBatch(this, aResult);
     if (NS_FAILED(rv)) {
       return rv;
     }
   }
   return NS_OK;
 }
 
 nsresult
-nsTransactionManager::WillMergeNotify(nsITransaction *aTop, nsITransaction *aTransaction, bool *aInterrupt)
+TransactionManager::WillMergeNotify(nsITransaction* aTop,
+                                    nsITransaction* aTransaction,
+                                    bool* aInterrupt)
 {
   for (int32_t i = 0, lcount = mListeners.Count(); i < lcount; i++) {
     nsITransactionListener* listener = mListeners[i];
     NS_ENSURE_TRUE(listener, NS_ERROR_FAILURE);
 
     nsresult rv = listener->WillMerge(this, aTop, aTransaction, aInterrupt);
     if (NS_FAILED(rv) || *aInterrupt) {
       return rv;
     }
   }
   return NS_OK;
 }
 
 nsresult
-nsTransactionManager::DidMergeNotify(nsITransaction *aTop,
-                                     nsITransaction *aTransaction,
-                                     bool aDidMerge,
-                                     nsresult aMergeResult)
+TransactionManager::DidMergeNotify(nsITransaction* aTop,
+                                   nsITransaction* aTransaction,
+                                   bool aDidMerge,
+                                   nsresult aMergeResult)
 {
   for (int32_t i = 0, lcount = mListeners.Count(); i < lcount; i++) {
     nsITransactionListener* listener = mListeners[i];
     NS_ENSURE_TRUE(listener, NS_ERROR_FAILURE);
 
     nsresult rv =
       listener->DidMerge(this, aTop, aTransaction, aDidMerge, aMergeResult);
     if (NS_FAILED(rv)) {
       return rv;
     }
   }
   return NS_OK;
 }
 
 nsresult
-nsTransactionManager::BeginTransaction(nsITransaction *aTransaction,
-                                       nsISupports *aData)
+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;
   }
 
@@ -640,17 +647,17 @@ nsTransactionManager::BeginTransaction(n
   if (NS_FAILED(rv)) {
     tx = mDoStack.Pop();
     return rv;
   }
   return NS_OK;
 }
 
 nsresult
-nsTransactionManager::EndTransaction(bool aAllowEmpty)
+TransactionManager::EndTransaction(bool aAllowEmpty)
 {
   RefPtr<nsTransactionItem> tx = mDoStack.Pop();
   if (!tx) {
     return NS_ERROR_FAILURE;
   }
 
   nsCOMPtr<nsITransaction> tint = tx->GetTransaction();
   if (!tint && !aAllowEmpty) {
@@ -723,8 +730,10 @@ nsTransactionManager::EndTransaction(boo
   if (mMaxTransactionCount > 0 && sz >= mMaxTransactionCount) {
     RefPtr<nsTransactionItem> overflow = mUndoStack.PopBottom();
   }
 
   // Push the transaction on the undo stack:
   mUndoStack.Push(tx.forget());
   return NS_OK;
 }
+
+} // namespace mozilla

rename from editor/txmgr/nsTransactionManager.h
rename to editor/txmgr/TransactionManager.h
--- a/editor/txmgr/nsTransactionManager.h
+++ b/editor/txmgr/TransactionManager.h
@@ -1,83 +1,73 @@
 /* -*- 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 nsTransactionManager_h__
-#define nsTransactionManager_h__
+#ifndef mozilla_TransactionManager_h
+#define mozilla_TransactionManager_h
 
 #include "nsCOMArray.h"
 #include "nsCOMPtr.h"
 #include "nsCycleCollectionParticipant.h"
 #include "nsTransactionStack.h"
 #include "nsISupportsImpl.h"
 #include "nsITransactionManager.h"
 #include "nsTransactionStack.h"
 #include "nsWeakReference.h"
 #include "nscore.h"
 
 class nsITransaction;
 class nsITransactionListener;
 
-/** implementation of a transaction manager object.
- *
- */
-class nsTransactionManager final : public nsITransactionManager
-                                 , public nsSupportsWeakReference
+namespace mozilla {
+
+class TransactionManager final : public nsITransactionManager
+                               , public nsSupportsWeakReference
 {
+public:
+  explicit TransactionManager(int32_t aMaxTransactionCount = -1);
+
+  NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+  NS_DECL_CYCLE_COLLECTION_CLASS_AMBIGUOUS(TransactionManager,
+                                           nsITransactionManager)
+
+  NS_DECL_NSITRANSACTIONMANAGER
+
+  already_AddRefed<nsITransaction> PeekUndoStack();
+  already_AddRefed<nsITransaction> PeekRedoStack();
+
+  nsresult WillDoNotify(nsITransaction* aTransaction, bool* aInterrupt);
+  nsresult DidDoNotify(nsITransaction* aTransaction, nsresult aExecuteResult);
+  nsresult WillUndoNotify(nsITransaction* aTransaction, bool* aInterrupt);
+  nsresult DidUndoNotify(nsITransaction* aTransaction, nsresult aUndoResult);
+  nsresult WillRedoNotify(nsITransaction* aTransaction, bool *aInterrupt);
+  nsresult DidRedoNotify(nsITransaction* aTransaction, nsresult aRedoResult);
+  nsresult WillBeginBatchNotify(bool* aInterrupt);
+  nsresult DidBeginBatchNotify(nsresult aResult);
+  nsresult WillEndBatchNotify(bool* aInterrupt);
+  nsresult DidEndBatchNotify(nsresult aResult);
+  nsresult WillMergeNotify(nsITransaction* aTop,
+                           nsITransaction* aTransaction,
+                           bool* aInterrupt);
+  nsresult DidMergeNotify(nsITransaction* aTop,
+                          nsITransaction* aTransaction,
+                          bool aDidMerge,
+                          nsresult aMergeResult);
+
 private:
+  virtual ~TransactionManager() = default;
+
+  nsresult BeginTransaction(nsITransaction* aTransaction,
+                            nsISupports* aData);
+  nsresult EndTransaction(bool aAllowEmpty);
 
   int32_t                mMaxTransactionCount;
   nsTransactionStack     mDoStack;
   nsTransactionStack     mUndoStack;
   nsTransactionStack     mRedoStack;
   nsCOMArray<nsITransactionListener> mListeners;
-
-  /** The default destructor.
-   */
-  virtual ~nsTransactionManager();
-
-public:
-
-  /** The default constructor.
-   */
-  explicit nsTransactionManager(int32_t aMaxTransactionCount=-1);
-
-  /* Macro for AddRef(), Release(), and QueryInterface() */
-  NS_DECL_CYCLE_COLLECTING_ISUPPORTS
-  NS_DECL_CYCLE_COLLECTION_CLASS_AMBIGUOUS(nsTransactionManager,
-                                           nsITransactionManager)
-
-  /* nsITransactionManager method implementations. */
-  NS_DECL_NSITRANSACTIONMANAGER
-
-  already_AddRefed<nsITransaction> PeekUndoStack();
-  already_AddRefed<nsITransaction> PeekRedoStack();
-
-  virtual nsresult WillDoNotify(nsITransaction *aTransaction, bool *aInterrupt);
-  virtual nsresult DidDoNotify(nsITransaction *aTransaction, nsresult aExecuteResult);
-  virtual nsresult WillUndoNotify(nsITransaction *aTransaction, bool *aInterrupt);
-  virtual nsresult DidUndoNotify(nsITransaction *aTransaction, nsresult aUndoResult);
-  virtual nsresult WillRedoNotify(nsITransaction *aTransaction, bool *aInterrupt);
-  virtual nsresult DidRedoNotify(nsITransaction *aTransaction, nsresult aRedoResult);
-  virtual nsresult WillBeginBatchNotify(bool *aInterrupt);
-  virtual nsresult DidBeginBatchNotify(nsresult aResult);
-  virtual nsresult WillEndBatchNotify(bool *aInterrupt);
-  virtual nsresult DidEndBatchNotify(nsresult aResult);
-  virtual nsresult WillMergeNotify(nsITransaction *aTop,
-                                   nsITransaction *aTransaction,
-                                   bool *aInterrupt);
-  virtual nsresult DidMergeNotify(nsITransaction *aTop,
-                                  nsITransaction *aTransaction,
-                                  bool aDidMerge,
-                                  nsresult aMergeResult);
-
-private:
-
-  /* nsTransactionManager specific private methods. */
-  virtual nsresult BeginTransaction(nsITransaction *aTransaction,
-                                    nsISupports *aData);
-  virtual nsresult EndTransaction(bool aAllowEmpty);
 };
 
-#endif // nsTransactionManager_h__
+} // namespace mozilla
+
+#endif // #ifndef mozilla_TransactionManager_h

rename from editor/txmgr/nsTransactionManagerFactory.cpp
rename to editor/txmgr/TransactionManagerFactory.cpp
--- a/editor/txmgr/nsTransactionManagerFactory.cpp
+++ b/editor/txmgr/TransactionManagerFactory.cpp
@@ -2,37 +2,40 @@
 /* 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 <stddef.h>
 
 #include "mozilla/Module.h"
 #include "mozilla/ModuleUtils.h"
+#include "mozilla/TransactionManager.h"
 #include "nsID.h"
 #include "nsITransactionManager.h"
-#include "nsTransactionManager.h"
-#include "nsTransactionManagerCID.h"
+
+using mozilla::TransactionManager;
 
 ////////////////////////////////////////////////////////////////////////
 // Define the contructor function for the objects
 //
 // NOTE: This creates an instance of objects by using the default constructor
 //
-NS_GENERIC_FACTORY_CONSTRUCTOR(nsTransactionManager)
+NS_GENERIC_FACTORY_CONSTRUCTOR(TransactionManager)
 NS_DEFINE_NAMED_CID(NS_TRANSACTIONMANAGER_CID);
 
 static const mozilla::Module::CIDEntry kTxMgrCIDs[] = {
-    { &kNS_TRANSACTIONMANAGER_CID, false, nullptr, nsTransactionManagerConstructor },
-    { nullptr }
+  { &kNS_TRANSACTIONMANAGER_CID, false, nullptr,
+    TransactionManagerConstructor },
+  { nullptr }
 };
 
 static const mozilla::Module::ContractIDEntry kTxMgrContracts[] = {
-    { NS_TRANSACTIONMANAGER_CONTRACTID, &kNS_TRANSACTIONMANAGER_CID },
-    { nullptr }
+  { NS_TRANSACTIONMANAGER_CONTRACTID, &kNS_TRANSACTIONMANAGER_CID },
+  { nullptr }
 };
 
 static const mozilla::Module kTxMgrModule = {
-    mozilla::Module::kVersion,
-    kTxMgrCIDs,
-    kTxMgrContracts
+  mozilla::Module::kVersion,
+  kTxMgrCIDs,
+  kTxMgrContracts
 };
+
 NSMODULE_DEFN(nsTransactionManagerModule) = &kTxMgrModule;

--- a/editor/txmgr/moz.build
+++ b/editor/txmgr/moz.build
@@ -13,16 +13,20 @@ XPIDL_SOURCES += [
 ]
 
 XPIDL_MODULE = 'txmgr'
 
 EXPORTS += [
     'nsTransactionManagerCID.h',
 ]
 
+EXPORTS.mozilla += [
+    'TransactionManager.h',
+]
+
 UNIFIED_SOURCES += [
     'nsTransactionItem.cpp',
-    'nsTransactionManager.cpp',
-    'nsTransactionManagerFactory.cpp',
     'nsTransactionStack.cpp',
+    'TransactionManager.cpp',
+    'TransactionManagerFactory.cpp',
 ]
 
 FINAL_LIBRARY = 'xul'

--- a/editor/txmgr/nsITransactionManager.idl
+++ b/editor/txmgr/nsITransactionManager.idl
@@ -2,22 +2,16 @@
 /* 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 "nsISupports.idl"
 #include "nsITransaction.idl"
 #include "nsITransactionListener.idl"
 
-%{ C++
-
-#define NS_TRANSACTIONMANAGER_CONTRACTID "@mozilla.org/transactionmanager;1"
-
-%} C++
-
 /**
  * The nsITransactionManager interface.
  * <P>
  * This interface is implemented by an object that wants to
  * manage/track transactions.
  */
 [scriptable, builtinclass, uuid(c77763df-0fb9-41a8-8074-8e882f605755)]
 interface nsITransactionManager : nsISupports
@@ -146,8 +140,18 @@ interface nsITransactionManager : nsISup
    * Removes a listener from the transaction manager's notification list.
    * <P>
    * The listener's Release() method is called.
    * @param aListener the lister to remove.
    */
   void RemoveListener(in nsITransactionListener aListener);
 };
 
+%{ C++
+
+#define NS_TRANSACTIONMANAGER_CONTRACTID "@mozilla.org/transactionmanager;1"
+
+// 9C8F9601-801A-11d2-98BA-00805F297D89
+#define NS_TRANSACTIONMANAGER_CID                   \
+{ 0x9c8f9601, 0x801a, 0x11d2,                       \
+  { 0x98, 0xba, 0x0, 0x80, 0x5f, 0x29, 0x7d, 0x89 } }
+
+%} C++

--- a/editor/txmgr/nsTransactionItem.cpp
+++ b/editor/txmgr/nsTransactionItem.cpp
@@ -1,23 +1,26 @@
 /* -*- 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 "mozilla/mozalloc.h"
+#include "mozilla/TransactionManager.h"
 #include "nsCOMPtr.h"
 #include "nsDebug.h"
 #include "nsError.h"
 #include "nsISupportsImpl.h"
 #include "nsITransaction.h"
-#include "nsTransactionItem.h"
-#include "nsTransactionManager.h"
 #include "nsTransactionStack.h"
 
+using namespace mozilla;
+
 nsTransactionItem::nsTransactionItem(nsITransaction *aTransaction)
     : mTransaction(aTransaction), mUndoStack(0), mRedoStack(0)
 {
 }
 
 nsTransactionItem::~nsTransactionItem()
 {
   delete mRedoStack;
@@ -154,39 +157,39 @@ nsTransactionItem::DoTransaction()
 {
   if (mTransaction) {
     return mTransaction->DoTransaction();
   }
   return NS_OK;
 }
 
 nsresult
-nsTransactionItem::UndoTransaction(nsTransactionManager *aTxMgr)
+nsTransactionItem::UndoTransaction(TransactionManager* aTransactionManager)
 {
-  nsresult rv = UndoChildren(aTxMgr);
+  nsresult rv = UndoChildren(aTransactionManager);
   if (NS_FAILED(rv)) {
-    RecoverFromUndoError(aTxMgr);
+    RecoverFromUndoError(aTransactionManager);
     return rv;
   }
 
   if (!mTransaction) {
     return NS_OK;
   }
 
   rv = mTransaction->UndoTransaction();
   if (NS_FAILED(rv)) {
-    RecoverFromUndoError(aTxMgr);
+    RecoverFromUndoError(aTransactionManager);
     return rv;
   }
 
   return NS_OK;
 }
 
 nsresult
-nsTransactionItem::UndoChildren(nsTransactionManager *aTxMgr)
+nsTransactionItem::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();
@@ -195,64 +198,64 @@ nsTransactionItem::UndoChildren(nsTransa
     while (sz-- > 0) {
       RefPtr<nsTransactionItem> item = mUndoStack->Peek();
       if (!item) {
         return NS_ERROR_FAILURE;
       }
 
       nsCOMPtr<nsITransaction> t = item->GetTransaction();
       bool doInterrupt = false;
-      rv = aTxMgr->WillUndoNotify(t, &doInterrupt);
+      rv = aTransactionManager->WillUndoNotify(t, &doInterrupt);
       if (NS_FAILED(rv)) {
         return rv;
       }
       if (doInterrupt) {
         return NS_OK;
       }
 
-      rv = item->UndoTransaction(aTxMgr);
+      rv = item->UndoTransaction(aTransactionManager);
       if (NS_SUCCEEDED(rv)) {
         item = mUndoStack->Pop();
         mRedoStack->Push(item.forget());
       }
 
-      nsresult rv2 = aTxMgr->DidUndoNotify(t, rv);
+      nsresult rv2 = aTransactionManager->DidUndoNotify(t, 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(nsTransactionManager *aTxMgr)
+nsTransactionItem::RedoTransaction(TransactionManager* aTransactionManager)
 {
   nsCOMPtr<nsITransaction> transaction(mTransaction);
   if (transaction) {
     nsresult rv = transaction->RedoTransaction();
     NS_ENSURE_SUCCESS(rv, rv);
   }
 
-  nsresult rv = RedoChildren(aTxMgr);
+  nsresult rv = RedoChildren(aTransactionManager);
   if (NS_FAILED(rv)) {
-    RecoverFromRedoError(aTxMgr);
+    RecoverFromRedoError(aTransactionManager);
     return rv;
   }
 
   return NS_OK;
 }
 
 nsresult
-nsTransactionItem::RedoChildren(nsTransactionManager *aTxMgr)
+nsTransactionItem::RedoChildren(TransactionManager* aTransactionManager)
 {
   if (!mRedoStack) {
     return NS_OK;
   }
 
   /* Redo all of the transaction items children! */
   int32_t sz = mRedoStack->GetSize();
 
@@ -260,32 +263,32 @@ nsTransactionItem::RedoChildren(nsTransa
   while (sz-- > 0) {
     RefPtr<nsTransactionItem> item = mRedoStack->Peek();
     if (!item) {
       return NS_ERROR_FAILURE;
     }
 
     nsCOMPtr<nsITransaction> t = item->GetTransaction();
     bool doInterrupt = false;
-    rv = aTxMgr->WillRedoNotify(t, &doInterrupt);
+    rv = aTransactionManager->WillRedoNotify(t, &doInterrupt);
     if (NS_FAILED(rv)) {
       return rv;
     }
     if (doInterrupt) {
       return NS_OK;
     }
 
-    rv = item->RedoTransaction(aTxMgr);
+    rv = item->RedoTransaction(aTransactionManager);
     if (NS_SUCCEEDED(rv)) {
       item = mRedoStack->Pop();
       mUndoStack->Push(item.forget());
     }
 
     // XXX Shouldn't this DidRedoNotify()? (bug 1311626)
-    nsresult rv2 = aTxMgr->DidUndoNotify(t, rv);
+    nsresult rv2 = aTransactionManager->DidUndoNotify(t, 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;
@@ -315,32 +318,32 @@ nsTransactionItem::GetNumberOfRedoItems(
     return NS_OK;
   }
 
   *aNumItems = mRedoStack->GetSize();
   return *aNumItems ? NS_OK : NS_ERROR_FAILURE;
 }
 
 nsresult
-nsTransactionItem::RecoverFromUndoError(nsTransactionManager *aTxMgr)
+nsTransactionItem::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(aTxMgr);
+  return RedoChildren(aTransactionManager);
 }
 
 nsresult
-nsTransactionItem::RecoverFromRedoError(nsTransactionManager *aTxMgr)
+nsTransactionItem::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(aTxMgr);
+  nsresult rv = UndoChildren(aTransactionManager);
   if (NS_FAILED(rv)) {
     return rv;
   }
 
   if (!mTransaction) {
     return NS_OK;
   }
 

--- a/editor/txmgr/nsTransactionItem.h
+++ b/editor/txmgr/nsTransactionItem.h
@@ -8,61 +8,65 @@
 
 #include "nsCOMPtr.h"
 #include "nsCOMArray.h"
 #include "nsCycleCollectionParticipant.h"
 #include "nsISupportsImpl.h"
 #include "nscore.h"
 
 class nsITransaction;
-class nsTransactionManager;
 class nsTransactionStack;
 
+namespace mozilla {
+class TransactionManager;
+} // namespace mozilla
+
 class nsTransactionItem final
 {
   nsCOMArray<nsISupports>  mData;
   nsCOMPtr<nsITransaction> mTransaction;
   nsTransactionStack      *mUndoStack;
   nsTransactionStack      *mRedoStack;
 
 public:
-
-  explicit nsTransactionItem(nsITransaction *aTransaction);
+  explicit nsTransactionItem(nsITransaction* aTransaction);
   NS_METHOD_(MozExternalRefCountType) AddRef();
   NS_METHOD_(MozExternalRefCountType) Release();
 
   NS_DECL_CYCLE_COLLECTION_NATIVE_CLASS(nsTransactionItem)
 
-  virtual nsresult AddChild(nsTransactionItem *aTransactionItem);
+  nsresult AddChild(nsTransactionItem* aTransactionItem);
   already_AddRefed<nsITransaction> GetTransaction();
-  virtual nsresult GetIsBatch(bool *aIsBatch);
-  virtual nsresult GetNumberOfChildren(int32_t *aNumChildren);
-  virtual nsresult GetChild(int32_t aIndex, nsTransactionItem **aChild);
+  nsresult GetIsBatch(bool *aIsBatch);
+  nsresult GetNumberOfChildren(int32_t *aNumChildren);
+  nsresult GetChild(int32_t aIndex, nsTransactionItem** aChild);
 
-  virtual nsresult DoTransaction(void);
-  virtual nsresult UndoTransaction(nsTransactionManager *aTxMgr);
-  virtual nsresult RedoTransaction(nsTransactionManager *aTxMgr);
+  nsresult DoTransaction();
+  nsresult UndoTransaction(mozilla::TransactionManager* aTransactionManager);
+  nsresult RedoTransaction(mozilla::TransactionManager* aTransactionManager);
 
   nsCOMArray<nsISupports>& GetData()
   {
     return mData;
   }
 
 private:
-
-  virtual nsresult UndoChildren(nsTransactionManager *aTxMgr);
-  virtual nsresult RedoChildren(nsTransactionManager *aTxMgr);
+  nsresult UndoChildren(mozilla::TransactionManager* aTransactionManager);
+  nsresult RedoChildren(mozilla::TransactionManager* aTransactionManager);
 
-  virtual nsresult RecoverFromUndoError(nsTransactionManager *aTxMgr);
-  virtual nsresult RecoverFromRedoError(nsTransactionManager *aTxMgr);
+  nsresult
+  RecoverFromUndoError(mozilla::TransactionManager* aTransactionManager);
+  nsresult
+  RecoverFromRedoError(mozilla::TransactionManager* aTransactionManager);
 
-  virtual nsresult GetNumberOfUndoItems(int32_t *aNumItems);
-  virtual nsresult GetNumberOfRedoItems(int32_t *aNumItems);
+  nsresult GetNumberOfUndoItems(int32_t* aNumItems);
+  nsresult GetNumberOfRedoItems(int32_t* aNumItems);
 
   void CleanUp();
+
 protected:
-  virtual ~nsTransactionItem();
+  ~nsTransactionItem();
 
   nsCycleCollectingAutoRefCnt mRefCnt;
   NS_DECL_OWNINGTHREAD
 };
 
 #endif // nsTransactionItem_h__

--- a/editor/txmgr/nsTransactionManagerCID.h
+++ b/editor/txmgr/nsTransactionManagerCID.h
@@ -1,14 +1,9 @@
 /* -*- 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 nsTransactionManagerCID_h__
-#define nsTransactionManagerCID_h__
+// XXX Needs to modify mailnews/base/src/nsMsgWindow.cpp before removing this
+//     header file.
+#include "nsITransactionManager.h"
 
-#define NS_TRANSACTIONMANAGER_CID                   \
-{ /* 9C8F9601-801A-11d2-98BA-00805F297D89 */        \
-0x9c8f9601, 0x801a, 0x11d2,                         \
-{ 0x98, 0xba, 0x0, 0x80, 0x5f, 0x29, 0x7d, 0x89 } }
-
-#endif /* nsTransactionManagerCID_h__ */