--- a/editor/libeditor/ChangeStyleTransaction.cpp
+++ b/editor/libeditor/ChangeStyleTransaction.cpp
@@ -145,108 +145,101 @@ ChangeStyleTransaction::DoTransaction()
  
   nsAutoString propertyNameString;
   mProperty->ToString(propertyNameString);
 
   mUndoAttributeWasSet = mElement->HasAttr(kNameSpaceID_None,
                                            nsGkAtoms::style);
 
   nsAutoString values;
-  nsresult result = cssDecl->GetPropertyValue(propertyNameString, values);
-  NS_ENSURE_SUCCESS(result, result);
+  nsresult rv = cssDecl->GetPropertyValue(propertyNameString, values);
+  NS_ENSURE_SUCCESS(rv, rv);
   mUndoValue.Assign(values);
 
   // Does this property accept more than one value? (bug 62682)
   bool multiple = AcceptsMoreThanOneValue(*mProperty);
 
   if (mRemoveProperty) {
     nsAutoString returnString;
     if (multiple) {
       // Let's remove only the value we have to remove and not the others
 
       // The two lines below are a workaround because
       // nsDOMCSSDeclaration::GetPropertyCSSValue is not yet implemented (bug
       // 62682)
       RemoveValueFromListOfValues(values, NS_LITERAL_STRING("none"));
       RemoveValueFromListOfValues(values, mValue);
       if (values.IsEmpty()) {
-        result = cssDecl->RemoveProperty(propertyNameString, returnString);
-        NS_ENSURE_SUCCESS(result, result);
+        rv = cssDecl->RemoveProperty(propertyNameString, returnString);
+        NS_ENSURE_SUCCESS(rv, rv);
       } else {
         nsAutoString priority;
         cssDecl->GetPropertyPriority(propertyNameString, priority);
-        result = cssDecl->SetProperty(propertyNameString, values,
-                                      priority);
-        NS_ENSURE_SUCCESS(result, result);
+        rv = cssDecl->SetProperty(propertyNameString, values, priority);
+        NS_ENSURE_SUCCESS(rv, rv);
       }
     } else {
-      result = cssDecl->RemoveProperty(propertyNameString, returnString);
-      NS_ENSURE_SUCCESS(result, result);
+      rv = cssDecl->RemoveProperty(propertyNameString, returnString);
+      NS_ENSURE_SUCCESS(rv, rv);
     }
   } else {
     nsAutoString priority;
     cssDecl->GetPropertyPriority(propertyNameString, priority);
     if (multiple) {
       // Let's add the value we have to add to the others
 
       // The line below is a workaround because
       // nsDOMCSSDeclaration::GetPropertyCSSValue is not yet implemented (bug
       // 62682)
       AddValueToMultivalueProperty(values, mValue);
     } else {
       values.Assign(mValue);
     }
-    result = cssDecl->SetProperty(propertyNameString, values,
-                                  priority);
-    NS_ENSURE_SUCCESS(result, result);
+    rv = cssDecl->SetProperty(propertyNameString, values, priority);
+    NS_ENSURE_SUCCESS(rv, rv);
   }
 
   // Let's be sure we don't keep an empty style attribute
   uint32_t length;
-  result = cssDecl->GetLength(&length);
-  NS_ENSURE_SUCCESS(result, result);
+  rv = cssDecl->GetLength(&length);
+  NS_ENSURE_SUCCESS(rv, rv);
   if (!length) {
-    result = mElement->UnsetAttr(kNameSpaceID_None, nsGkAtoms::style, true);
-    NS_ENSURE_SUCCESS(result, result);
+    rv = mElement->UnsetAttr(kNameSpaceID_None, nsGkAtoms::style, true);
+    NS_ENSURE_SUCCESS(rv, rv);
   } else {
     mRedoAttributeWasSet = true;
   }
 
   return cssDecl->GetPropertyValue(propertyNameString, mRedoValue);
 }
 
 nsresult
 ChangeStyleTransaction::SetStyle(bool aAttributeWasSet,
                                  nsAString& aValue)
 {
-  nsresult result = NS_OK;
   if (aAttributeWasSet) {
     // The style attribute was not empty, let's recreate the declaration
     nsAutoString propertyNameString;
     mProperty->ToString(propertyNameString);
 
     nsCOMPtr<nsStyledElement> inlineStyles = do_QueryInterface(mElement);
     NS_ENSURE_TRUE(inlineStyles, NS_ERROR_NULL_POINTER);
     nsCOMPtr<nsICSSDeclaration> cssDecl = inlineStyles->Style();
 
     if (aValue.IsEmpty()) {
       // An empty value means we have to remove the property
       nsAutoString returnString;
-      result = cssDecl->RemoveProperty(propertyNameString, returnString);
-    } else {
-      // Let's recreate the declaration as it was
-      nsAutoString priority;
-      cssDecl->GetPropertyPriority(propertyNameString, priority);
-      result = cssDecl->SetProperty(propertyNameString, aValue, priority);
+      return cssDecl->RemoveProperty(propertyNameString, returnString);
     }
-  } else {
-    result = mElement->UnsetAttr(kNameSpaceID_None, nsGkAtoms::style, true);
+    // Let's recreate the declaration as it was
+    nsAutoString priority;
+    cssDecl->GetPropertyPriority(propertyNameString, priority);
+    return cssDecl->SetProperty(propertyNameString, aValue, priority);
   }
-
-  return result;
+  return mElement->UnsetAttr(kNameSpaceID_None, nsGkAtoms::style, true);
 }
 
 NS_IMETHODIMP
 ChangeStyleTransaction::UndoTransaction()
 {
   return SetStyle(mUndoAttributeWasSet, mUndoValue);
 }
 

--- a/editor/libeditor/EditAggregateTransaction.cpp
+++ b/editor/libeditor/EditAggregateTransaction.cpp
@@ -28,63 +28,63 @@ NS_IMPL_CYCLE_COLLECTION_INHERITED(EditA
 NS_IMPL_ADDREF_INHERITED(EditAggregateTransaction, EditTransactionBase)
 NS_IMPL_RELEASE_INHERITED(EditAggregateTransaction, EditTransactionBase)
 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(EditAggregateTransaction)
 NS_INTERFACE_MAP_END_INHERITING(EditTransactionBase)
 
 NS_IMETHODIMP
 EditAggregateTransaction::DoTransaction()
 {
-  nsresult result=NS_OK;  // it's legal (but not very useful) to have an empty child list
+  // FYI: It's legal (but not very useful) to have an empty child list.
   for (uint32_t i = 0, length = mChildren.Length(); i < length; ++i) {
     nsITransaction *txn = mChildren[i];
     if (!txn) {
       return NS_ERROR_NULL_POINTER;
     }
-    result = txn->DoTransaction();
-    if (NS_FAILED(result)) {
-      break;
+    nsresult rv = txn->DoTransaction();
+    if (NS_FAILED(rv)) {
+      return rv;
     }
   }
-  return result;
+  return NS_OK;
 }
 
 NS_IMETHODIMP
 EditAggregateTransaction::UndoTransaction()
 {
-  nsresult result=NS_OK;  // it's legal (but not very useful) to have an empty child list
-  // undo goes through children backwards
+  // FYI: It's legal (but not very useful) to have an empty child list.
+  // Undo goes through children backwards.
   for (uint32_t i = mChildren.Length(); i--; ) {
     nsITransaction *txn = mChildren[i];
     if (!txn) {
       return NS_ERROR_NULL_POINTER;
     }
-    result = txn->UndoTransaction();
-    if (NS_FAILED(result)) {
-      break;
+    nsresult rv = txn->UndoTransaction();
+    if (NS_FAILED(rv)) {
+      return rv;
     }
   }
-  return result;
+  return NS_OK;
 }
 
 NS_IMETHODIMP
 EditAggregateTransaction::RedoTransaction()
 {
-  nsresult result=NS_OK;  // it's legal (but not very useful) to have an empty child list
+  // It's legal (but not very useful) to have an empty child list.
   for (uint32_t i = 0, length = mChildren.Length(); i < length; ++i) {
     nsITransaction *txn = mChildren[i];
     if (!txn) {
       return NS_ERROR_NULL_POINTER;
     }
-    result = txn->RedoTransaction();
-    if (NS_FAILED(result)) {
-      break;
+    nsresult rv = txn->RedoTransaction();
+    if (NS_FAILED(rv)) {
+      return rv;
     }
   }
-  return result;
+  return NS_OK;
 }
 
 NS_IMETHODIMP
 EditAggregateTransaction::Merge(nsITransaction* aTransaction,
                                 bool* aDidMerge)
 {
   if (aDidMerge) {
     *aDidMerge = false;

--- a/editor/libeditor/EditorBase.cpp
+++ b/editor/libeditor/EditorBase.cpp
@@ -1446,24 +1446,24 @@ EditorBase::SplitNode(nsIContent& aNode,
     CreateTxnForSplitNode(aNode, aOffset);
   aResult = DoTransaction(transaction);
 
   nsCOMPtr<nsIContent> newNode = aResult.Failed() ? nullptr
                                                   : transaction->GetNewNode();
 
   mRangeUpdater.SelAdjSplitNode(aNode, aOffset, newNode);
 
-  nsresult result = aResult.StealNSResult();
+  nsresult rv = aResult.StealNSResult();
   for (auto& listener : mActionListeners) {
     listener->DidSplitNode(aNode.AsDOMNode(), aOffset, GetAsDOMNode(newNode),
-                           result);
+                           rv);
   }
   // Note: result might be a success code, so we can't use Throw() to
   // set it on aResult.
-  aResult = result;
+  aResult = rv;
 
   return newNode;
 }
 
 NS_IMETHODIMP
 EditorBase::JoinNodes(nsIDOMNode* aLeftNode,
                       nsIDOMNode* aRightNode,
                       nsIDOMNode*)
@@ -1490,32 +1490,32 @@ EditorBase::JoinNodes(nsINode& aLeftNode
   // Find the number of children of the lefthand node
   uint32_t oldLeftNodeLen = aLeftNode.Length();
 
   for (auto& listener : mActionListeners) {
     listener->WillJoinNodes(aLeftNode.AsDOMNode(), aRightNode.AsDOMNode(),
                             parent->AsDOMNode());
   }
 
-  nsresult result = NS_OK;
+  nsresult rv = NS_OK;
   RefPtr<JoinNodeTransaction> transaction =
     CreateTxnForJoinNode(aLeftNode, aRightNode);
   if (transaction)  {
-    result = DoTransaction(transaction);
+    rv = DoTransaction(transaction);
   }
 
   mRangeUpdater.SelAdjJoinNodes(aLeftNode, aRightNode, *parent, offset,
                                 (int32_t)oldLeftNodeLen);
 
   for (auto& listener : mActionListeners) {
     listener->DidJoinNodes(aLeftNode.AsDOMNode(), aRightNode.AsDOMNode(),
-                           parent->AsDOMNode(), result);
-  }
-
-  return result;
+                           parent->AsDOMNode(), rv);
+  }
+
+  return rv;
 }
 
 NS_IMETHODIMP
 EditorBase::DeleteNode(nsIDOMNode* aNode)
 {
   nsCOMPtr<nsINode> node = do_QueryInterface(aNode);
   NS_ENSURE_STATE(node);
   return DeleteNode(node);

--- a/editor/libeditor/HTMLEditor.cpp
+++ b/editor/libeditor/HTMLEditor.cpp
@@ -253,26 +253,26 @@ HTMLEditor::Init(nsIDOMDocument* aDoc,
                  nsISelectionController* aSelCon,
                  uint32_t aFlags,
                  const nsAString& aInitialValue)
 {
   NS_PRECONDITION(aDoc && !aSelCon, "bad arg");
   NS_ENSURE_TRUE(aDoc, NS_ERROR_NULL_POINTER);
   MOZ_ASSERT(aInitialValue.IsEmpty(), "Non-empty initial values not supported");
 
-  nsresult result = NS_OK, rulesRes = NS_OK;
+  nsresult rulesRv = NS_OK;
 
   {
     // block to scope AutoEditInitRulesTrigger
-    AutoEditInitRulesTrigger rulesTrigger(this, rulesRes);
+    AutoEditInitRulesTrigger rulesTrigger(this, rulesRv);
 
     // Init the plaintext editor
-    result = TextEditor::Init(aDoc, aRoot, nullptr, aFlags, aInitialValue);
-    if (NS_FAILED(result)) {
-      return result;
+    nsresult rv = TextEditor::Init(aDoc, aRoot, nullptr, aFlags, aInitialValue);
+    if (NS_FAILED(rv)) {
+      return rv;
     }
 
     // Init mutation observer
     nsCOMPtr<nsINode> document = do_QueryInterface(aDoc);
     document->AddMutationObserverUnlessExists(this);
 
     // disable Composer-only features
     if (IsMailEditor()) {
@@ -312,19 +312,19 @@ HTMLEditor::Init(nsIDOMDocument* aDoc,
         selection->AddSelectionListener(listener);
       }
       listener = do_QueryInterface(mSelectionListenerP);
       if (listener) {
         selection->AddSelectionListener(listener);
       }
     }
   }
-
-  NS_ENSURE_SUCCESS(rulesRes, rulesRes);
-  return result;
+  NS_ENSURE_SUCCESS(rulesRv, rulesRv);
+
+  return NS_OK;
 }
 
 NS_IMETHODIMP
 HTMLEditor::PreDestroy(bool aDestroyingFrames)
 {
   if (mDidPreDestroy) {
     return NS_OK;
   }
@@ -1548,18 +1548,18 @@ HTMLEditor::InsertElementAtSelection(nsI
         // E.g., inserting an image.  In this case we don't need to delete any
         // inline wrappers before we do the insertion.  Otherwise we let
         // DeleteSelectionAndPrepareToCreateNode do the deletion for us, which
         // calls DeleteSelection with aStripWrappers = eStrip.
         rv = DeleteSelection(nsIEditor::eNone, nsIEditor::eNoStrip);
         NS_ENSURE_SUCCESS(rv, rv);
       }
 
-      nsresult result = DeleteSelectionAndPrepareToCreateNode();
-      NS_ENSURE_SUCCESS(result, result);
+      nsresult rv = DeleteSelectionAndPrepareToCreateNode();
+      NS_ENSURE_SUCCESS(rv, rv);
     }
 
     // If deleting, selection will be collapsed.
     // so if not, we collapse it
     if (!aDeleteSelection) {
       // Named Anchor is a special case,
       // We collapse to insert element BEFORE the selection
       // For all other tags, we insert AFTER the selection
@@ -3632,17 +3632,16 @@ HTMLEditor::IsTextPropertySetByContent(n
 void
 HTMLEditor::IsTextPropertySetByContent(nsIDOMNode* aNode,
                                        nsIAtom* aProperty,
                                        const nsAString* aAttribute,
                                        const nsAString* aValue,
                                        bool& aIsSet,
                                        nsAString* outValue)
 {
-  nsresult result;
   aIsSet = false;  // must be initialized to false for code below to work
   nsAutoString propName;
   aProperty->ToString(propName);
   nsCOMPtr<nsIDOMNode>node = aNode;
 
   while (node) {
     nsCOMPtr<nsIDOMElement>element;
     element = do_QueryInterface(node);
@@ -3675,18 +3674,17 @@ HTMLEditor::IsTextPropertySetByContent(n
         }
         if (found) {
           aIsSet = true;
           break;
         }
       }
     }
     nsCOMPtr<nsIDOMNode>temp;
-    result = node->GetParentNode(getter_AddRefs(temp));
-    if (NS_SUCCEEDED(result) && temp) {
+    if (NS_SUCCEEDED(node->GetParentNode(getter_AddRefs(temp))) && temp) {
       node = temp;
     } else {
       node = nullptr;
     }
   }
 }
 
 bool
@@ -3755,20 +3753,20 @@ HTMLEditor::CollapseAdjacentTextNodes(ns
   AutoTransactionsConserveSelection dontSpazMySelection(this);
   nsTArray<nsCOMPtr<nsIDOMNode> > textNodes;
   // we can't actually do anything during iteration, so store the text nodes in an array
   // don't bother ref counting them because we know we can hold them for the
   // lifetime of this method
 
 
   // build a list of editable text nodes
-  nsresult result;
+  nsresult rv = NS_ERROR_UNEXPECTED;
   nsCOMPtr<nsIContentIterator> iter =
-    do_CreateInstance("@mozilla.org/content/subtree-content-iterator;1", &result);
-  NS_ENSURE_SUCCESS(result, result);
+    do_CreateInstance("@mozilla.org/content/subtree-content-iterator;1", &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
 
   iter->Init(aInRange);
 
   while (!iter->IsDone()) {
     nsINode* node = iter->GetCurrentNode();
     if (node->NodeType() == nsIDOMNode::TEXT_NODE &&
         IsEditable(static_cast<nsIContent*>(node))) {
       nsCOMPtr<nsIDOMNode> domNode = do_QueryInterface(node);
@@ -3783,32 +3781,31 @@ HTMLEditor::CollapseAdjacentTextNodes(ns
   while (textNodes.Length() > 1) {
     // we assume a textNodes entry can't be nullptr
     nsIDOMNode *leftTextNode = textNodes[0];
     nsIDOMNode *rightTextNode = textNodes[1];
     NS_ASSERTION(leftTextNode && rightTextNode,"left or rightTextNode null in CollapseAdjacentTextNodes");
 
     // get the prev sibling of the right node, and see if its leftTextNode
     nsCOMPtr<nsIDOMNode> prevSibOfRightNode;
-    result =
-      rightTextNode->GetPreviousSibling(getter_AddRefs(prevSibOfRightNode));
-    NS_ENSURE_SUCCESS(result, result);
+    rv = rightTextNode->GetPreviousSibling(getter_AddRefs(prevSibOfRightNode));
+    NS_ENSURE_SUCCESS(rv, rv);
     if (prevSibOfRightNode && prevSibOfRightNode == leftTextNode) {
       nsCOMPtr<nsIDOMNode> parent;
-      result = rightTextNode->GetParentNode(getter_AddRefs(parent));
-      NS_ENSURE_SUCCESS(result, result);
+      rv = rightTextNode->GetParentNode(getter_AddRefs(parent));
+      NS_ENSURE_SUCCESS(rv, rv);
       NS_ENSURE_TRUE(parent, NS_ERROR_NULL_POINTER);
-      result = JoinNodes(leftTextNode, rightTextNode, parent);
-      NS_ENSURE_SUCCESS(result, result);
+      rv = JoinNodes(leftTextNode, rightTextNode, parent);
+      NS_ENSURE_SUCCESS(rv, rv);
     }
 
     textNodes.RemoveElementAt(0); // remove the leftmost text node from the list
   }
 
-  return result;
+  return NS_OK;
 }
 
 nsresult
 HTMLEditor::SetSelectionAtDocumentStart(Selection* aSelection)
 {
   dom::Element* rootElement = GetRoot();
   NS_ENSURE_TRUE(rootElement, NS_ERROR_NULL_POINTER);
 

--- a/editor/libeditor/SelectionState.cpp
+++ b/editor/libeditor/SelectionState.cpp
@@ -341,18 +341,18 @@ RangeUpdater::SelAdjSplitNode(nsIContent
   if (!count) {
     return NS_OK;
   }
 
   nsCOMPtr<nsINode> parent = aOldRightNode.GetParentNode();
   int32_t offset = parent ? parent->IndexOf(&aOldRightNode) : -1;
 
   // first part is same as inserting aNewLeftnode
-  nsresult result = SelAdjInsertNode(parent, offset - 1);
-  NS_ENSURE_SUCCESS(result, result);
+  nsresult rv = SelAdjInsertNode(parent, offset - 1);
+  NS_ENSURE_SUCCESS(rv, rv);
 
   // next step is to check for range enpoints inside aOldRightNode
   for (size_t i = 0; i < count; i++) {
     RangeItem* item = mArray[i];
     NS_ENSURE_TRUE(item, NS_ERROR_NULL_POINTER);
 
     if (item->startNode == &aOldRightNode) {
       if (item->startOffset > aOffset) {

--- a/editor/libeditor/TextEditor.cpp
+++ b/editor/libeditor/TextEditor.cpp
@@ -560,110 +560,108 @@ TextEditor::InsertBR(nsCOMPtr<nsIDOMNode
   selection->SetInterlinePosition(true);
   return selection->Collapse(selNode, selOffset+1);
 }
 
 nsresult
 TextEditor::ExtendSelectionForDelete(Selection* aSelection,
                                      nsIEditor::EDirection* aAction)
 {
-  nsresult result = NS_OK;
-
   bool bCollapsed = aSelection->Collapsed();
 
   if (*aAction == eNextWord ||
       *aAction == ePreviousWord ||
       (*aAction == eNext && bCollapsed) ||
       (*aAction == ePrevious && bCollapsed) ||
       *aAction == eToBeginningOfLine ||
       *aAction == eToEndOfLine) {
     nsCOMPtr<nsISelectionController> selCont;
     GetSelectionController(getter_AddRefs(selCont));
     NS_ENSURE_TRUE(selCont, NS_ERROR_NO_INTERFACE);
 
+    nsresult rv;
     switch (*aAction) {
       case eNextWord:
-        result = selCont->WordExtendForDelete(true);
+        rv = selCont->WordExtendForDelete(true);
         // DeleteSelectionImpl doesn't handle these actions
         // because it's inside batching, so don't confuse it:
         *aAction = eNone;
         break;
       case ePreviousWord:
-        result = selCont->WordExtendForDelete(false);
+        rv = selCont->WordExtendForDelete(false);
         *aAction = eNone;
         break;
       case eNext:
-        result = selCont->CharacterExtendForDelete();
+        rv = selCont->CharacterExtendForDelete();
         // Don't set aAction to eNone (see Bug 502259)
         break;
       case ePrevious: {
         // Only extend the selection where the selection is after a UTF-16
         // surrogate pair or a variation selector.
         // For other cases we don't want to do that, in order
         // to make sure that pressing backspace will only delete the last
         // typed character.
         nsCOMPtr<nsIDOMNode> node;
         int32_t offset;
-        result = GetStartNodeAndOffset(aSelection, getter_AddRefs(node), &offset);
-        NS_ENSURE_SUCCESS(result, result);
+        rv = GetStartNodeAndOffset(aSelection, getter_AddRefs(node), &offset);
+        NS_ENSURE_SUCCESS(rv, rv);
         NS_ENSURE_TRUE(node, NS_ERROR_FAILURE);
 
         // node might be anonymous DIV, so we find better text node
         FindBetterInsertionPoint(node, offset);
 
         if (IsTextNode(node)) {
           nsCOMPtr<nsIDOMCharacterData> charData = do_QueryInterface(node);
           if (charData) {
             nsAutoString data;
-            result = charData->GetData(data);
-            NS_ENSURE_SUCCESS(result, result);
+            rv = charData->GetData(data);
+            NS_ENSURE_SUCCESS(rv, rv);
 
             if ((offset > 1 &&
                  NS_IS_LOW_SURROGATE(data[offset - 1]) &&
                  NS_IS_HIGH_SURROGATE(data[offset - 2])) ||
                 (offset > 0 &&
                  gfxFontUtils::IsVarSelector(data[offset - 1]))) {
-              result = selCont->CharacterExtendForBackspace();
+              rv = selCont->CharacterExtendForBackspace();
             }
           }
         }
         break;
       }
       case eToBeginningOfLine:
         selCont->IntraLineMove(true, false);          // try to move to end
-        result = selCont->IntraLineMove(false, true); // select to beginning
+        rv = selCont->IntraLineMove(false, true); // select to beginning
         *aAction = eNone;
         break;
       case eToEndOfLine:
-        result = selCont->IntraLineMove(true, true);
+        rv = selCont->IntraLineMove(true, true);
         *aAction = eNext;
         break;
       default:       // avoid several compiler warnings
-        result = NS_OK;
+        rv = NS_OK;
         break;
     }
+    return rv;
   }
-  return result;
+  return NS_OK;
 }
 
 nsresult
 TextEditor::DeleteSelection(EDirection aAction,
                             EStripWrappers aStripWrappers)
 {
   MOZ_ASSERT(aStripWrappers == eStrip || aStripWrappers == eNoStrip);
 
   if (!mRules) {
     return NS_ERROR_NOT_INITIALIZED;
   }
 
   // Protect the edit rules object from dying
   nsCOMPtr<nsIEditRules> rules(mRules);
 
-  nsresult result;
-
   // delete placeholder txns merge.
   AutoPlaceHolderBatch batch(this, nsGkAtoms::DeleteTxnName);
   AutoRules beginRulesSniffing(this, EditAction::deleteSelection, aAction);
 
   // pre-process
   RefPtr<Selection> selection = GetSelection();
   NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
 
@@ -671,38 +669,37 @@ TextEditor::DeleteSelection(EDirection a
   //  platforms that use "caret-style" caret positioning collapse the
   //  selection to the  start and then create a new selection.
   //  Platforms that use "selection-style" caret positioning just delete the
   //  existing selection without extending it.
   if (!selection->Collapsed() &&
       (aAction == eNextWord || aAction == ePreviousWord ||
        aAction == eToBeginningOfLine || aAction == eToEndOfLine)) {
     if (mCaretStyle == 1) {
-      result = selection->CollapseToStart();
-      NS_ENSURE_SUCCESS(result, result);
+      nsresult rv = selection->CollapseToStart();
+      NS_ENSURE_SUCCESS(rv, rv);
     } else {
       aAction = eNone;
     }
   }
 
   TextRulesInfo ruleInfo(EditAction::deleteSelection);
   ruleInfo.collapsedAction = aAction;
   ruleInfo.stripWrappers = aStripWrappers;
   bool cancel, handled;
-  result = rules->WillDoAction(selection, &ruleInfo, &cancel, &handled);
-  NS_ENSURE_SUCCESS(result, result);
+  nsresult rv = rules->WillDoAction(selection, &ruleInfo, &cancel, &handled);
+  NS_ENSURE_SUCCESS(rv, rv);
   if (!cancel && !handled) {
-    result = DeleteSelectionImpl(aAction, aStripWrappers);
+    rv = DeleteSelectionImpl(aAction, aStripWrappers);
   }
   if (!cancel) {
     // post-process
-    result = rules->DidDoAction(selection, &ruleInfo, result);
+    rv = rules->DidDoAction(selection, &ruleInfo, rv);
   }
-
-  return result;
+  return rv;
 }
 
 NS_IMETHODIMP
 TextEditor::InsertText(const nsAString& aStringToInsert)
 {
   if (!mRules) {
     return NS_ERROR_NOT_INITIALIZED;
   }
@@ -1086,25 +1083,25 @@ TextEditor::Undo(uint32_t aCount)
 
   NotifyEditorObservers(eNotifyEditorObserversOfBefore);
 
   AutoRules beginRulesSniffing(this, EditAction::undo, nsIEditor::eNone);
 
   TextRulesInfo ruleInfo(EditAction::undo);
   RefPtr<Selection> selection = GetSelection();
   bool cancel, handled;
-  nsresult result = rules->WillDoAction(selection, &ruleInfo, &cancel, &handled);
+  nsresult rv = rules->WillDoAction(selection, &ruleInfo, &cancel, &handled);
 
-  if (!cancel && NS_SUCCEEDED(result)) {
-    result = EditorBase::Undo(aCount);
-    result = rules->DidDoAction(selection, &ruleInfo, result);
+  if (!cancel && NS_SUCCEEDED(rv)) {
+    rv = EditorBase::Undo(aCount);
+    rv = rules->DidDoAction(selection, &ruleInfo, rv);
   }
 
   NotifyEditorObservers(eNotifyEditorObserversOfEnd);
-  return result;
+  return rv;
 }
 
 NS_IMETHODIMP
 TextEditor::Redo(uint32_t aCount)
 {
   // Protect the edit rules object from dying
   nsCOMPtr<nsIEditRules> rules(mRules);
 
@@ -1114,25 +1111,25 @@ TextEditor::Redo(uint32_t aCount)
 
   NotifyEditorObservers(eNotifyEditorObserversOfBefore);
 
   AutoRules beginRulesSniffing(this, EditAction::redo, nsIEditor::eNone);
 
   TextRulesInfo ruleInfo(EditAction::redo);
   RefPtr<Selection> selection = GetSelection();
   bool cancel, handled;
-  nsresult result = rules->WillDoAction(selection, &ruleInfo, &cancel, &handled);
+  nsresult rv = rules->WillDoAction(selection, &ruleInfo, &cancel, &handled);
 
-  if (!cancel && NS_SUCCEEDED(result)) {
-    result = EditorBase::Redo(aCount);
-    result = rules->DidDoAction(selection, &ruleInfo, result);
+  if (!cancel && NS_SUCCEEDED(rv)) {
+    rv = EditorBase::Redo(aCount);
+    rv = rules->DidDoAction(selection, &ruleInfo, rv);
   }
 
   NotifyEditorObservers(eNotifyEditorObserversOfEnd);
-  return result;
+  return rv;
 }
 
 bool
 TextEditor::CanCutOrCopy(PasswordFieldAllowed aPasswordFieldAllowed)
 {
   RefPtr<Selection> selection = GetSelection();
   if (!selection) {
     return false;

--- a/editor/libeditor/TextEditorTest.cpp
+++ b/editor/libeditor/TextEditorTest.cpp
@@ -43,120 +43,122 @@ void TextEditorTest::Run(nsIEditor *aEdi
   if (!aEditor) return;
   mTextEditor = do_QueryInterface(aEditor);
   mEditor = do_QueryInterface(aEditor);
   RunUnitTest(outNumTests, outNumTestsFailed);
 }
 
 nsresult TextEditorTest::RunUnitTest(int32_t *outNumTests, int32_t *outNumTestsFailed)
 {
-  nsresult result;
-
   NS_ENSURE_TRUE(outNumTests && outNumTestsFailed, NS_ERROR_NULL_POINTER);
 
   *outNumTests = 0;
   *outNumTestsFailed = 0;
 
-  result = InitDoc();
-  TEST_RESULT(result);
+  nsresult rv = InitDoc();
+  TEST_RESULT(rv);
   // shouldn't we just bail on error here?
 
   // insert some simple text
-  result = mTextEditor->InsertText(NS_LITERAL_STRING("1234567890abcdefghij1234567890"));
-  TEST_RESULT(result);
+  rv = mTextEditor->InsertText(NS_LITERAL_STRING("1234567890abcdefghij1234567890"));
+  TEST_RESULT(rv);
   (*outNumTests)++;
-  if (NS_FAILED(result))
+  if (NS_FAILED(rv)) {
     ++(*outNumTestsFailed);
+  }
 
   // insert some more text
-  result = mTextEditor->InsertText(NS_LITERAL_STRING("Moreover, I am cognizant of the interrelatedness of all communities and states.  I cannot sit idly by in Atlanta and not be concerned about what happens in Birmingham.  Injustice anywhere is a threat to justice everywhere"));
-  TEST_RESULT(result);
+  rv = mTextEditor->InsertText(NS_LITERAL_STRING("Moreover, I am cognizant of the interrelatedness of all communities and states.  I cannot sit idly by in Atlanta and not be concerned about what happens in Birmingham.  Injustice anywhere is a threat to justice everywhere"));
+  TEST_RESULT(rv);
   (*outNumTests)++;
-  if (NS_FAILED(result))
+  if (NS_FAILED(rv)) {
     ++(*outNumTestsFailed);
+  }
 
-  result = TestInsertBreak();
-  TEST_RESULT(result);
+  rv = TestInsertBreak();
+  TEST_RESULT(rv);
   (*outNumTests)++;
-  if (NS_FAILED(result))
+  if (NS_FAILED(rv)) {
     ++(*outNumTestsFailed);
+  }
 
-  result = TestTextProperties();
-  TEST_RESULT(result);
+  rv = TestTextProperties();
+  TEST_RESULT(rv);
   (*outNumTests)++;
-  if (NS_FAILED(result))
+  if (NS_FAILED(rv)) {
     ++(*outNumTestsFailed);
+  }
 
   // get us back to the original document
-  result = mEditor->Undo(12);
-  TEST_RESULT(result);
+  rv = mEditor->Undo(12);
+  TEST_RESULT(rv);
 
-  return result;
+  return rv;
 }
 
 nsresult TextEditorTest::InitDoc()
 {
-  nsresult result = mEditor->SelectAll();
-  TEST_RESULT(result);
-  result = mEditor->DeleteSelection(nsIEditor::eNext, nsIEditor::eStrip);
-  TEST_RESULT(result);
-  return result;
+  nsresult rv = mEditor->SelectAll();
+  TEST_RESULT(rv);
+  rv = mEditor->DeleteSelection(nsIEditor::eNext, nsIEditor::eStrip);
+  TEST_RESULT(rv);
+  return rv;
 }
 
 nsresult TextEditorTest::TestInsertBreak()
 {
   nsCOMPtr<nsISelection>selection;
-  nsresult result = mEditor->GetSelection(getter_AddRefs(selection));
-  TEST_RESULT(result);
+  nsresult rv = mEditor->GetSelection(getter_AddRefs(selection));
+  TEST_RESULT(rv);
   TEST_POINTER(selection.get());
   nsCOMPtr<nsIDOMNode>anchor;
-  result = selection->GetAnchorNode(getter_AddRefs(anchor));
-  TEST_RESULT(result);
+  rv = selection->GetAnchorNode(getter_AddRefs(anchor));
+  TEST_RESULT(rv);
   TEST_POINTER(anchor.get());
   selection->Collapse(anchor, 0);
   // insert one break
   printf("inserting a break\n");
-  result = mTextEditor->InsertLineBreak();
-  TEST_RESULT(result);
+  rv = mTextEditor->InsertLineBreak();
+  TEST_RESULT(rv);
   mEditor->DebugDumpContent();
 
   // insert a second break adjacent to the first
   printf("inserting a second break\n");
-  result = mTextEditor->InsertLineBreak();
-  TEST_RESULT(result);
+  rv = mTextEditor->InsertLineBreak();
+  TEST_RESULT(rv);
   mEditor->DebugDumpContent();
 
-  return result;
+  return rv;
 }
 
 nsresult TextEditorTest::TestTextProperties()
 {
   nsCOMPtr<nsIDOMDocument>doc;
-  nsresult result = mEditor->GetDocument(getter_AddRefs(doc));
-  TEST_RESULT(result);
+  nsresult rv = mEditor->GetDocument(getter_AddRefs(doc));
+  TEST_RESULT(rv);
   TEST_POINTER(doc.get());
   nsCOMPtr<nsIDOMNodeList>nodeList;
   // XXX This is broken, text nodes are not elements.
   nsAutoString textTag(NS_LITERAL_STRING("#text"));
-  result = doc->GetElementsByTagName(textTag, getter_AddRefs(nodeList));
-  TEST_RESULT(result);
+  rv = doc->GetElementsByTagName(textTag, getter_AddRefs(nodeList));
+  TEST_RESULT(rv);
   TEST_POINTER(nodeList.get());
   uint32_t count;
   nodeList->GetLength(&count);
   NS_ASSERTION(0!=count, "there are no text nodes in the document!");
   nsCOMPtr<nsIDOMNode>textNode;
-  result = nodeList->Item(count-1, getter_AddRefs(textNode));
-  TEST_RESULT(result);
+  rv = nodeList->Item(count - 1, getter_AddRefs(textNode));
+  TEST_RESULT(rv);
   TEST_POINTER(textNode.get());
 
   // set the whole text node to bold
   printf("set the whole first text node to bold\n");
   nsCOMPtr<nsISelection>selection;
-  result = mEditor->GetSelection(getter_AddRefs(selection));
-  TEST_RESULT(result);
+  rv = mEditor->GetSelection(getter_AddRefs(selection));
+  TEST_RESULT(rv);
   TEST_POINTER(selection.get());
   nsCOMPtr<nsIDOMCharacterData>textData;
   textData = do_QueryInterface(textNode);
   uint32_t length;
   textData->GetLength(&length);
   selection->Collapse(textNode, 0);
   selection->Extend(textNode, length);
 
@@ -164,98 +166,94 @@ nsresult TextEditorTest::TestTextPropert
   NS_ENSURE_TRUE(htmlEditor, NS_ERROR_FAILURE);
 
   bool any = false;
   bool all = false;
   bool first=false;
 
   const nsAFlatString& empty = EmptyString();
 
-  result = htmlEditor->GetInlineProperty(nsGkAtoms::b, empty, empty, &first,
-                                         &any, &all);
-  TEST_RESULT(result);
+  rv = htmlEditor->GetInlineProperty(nsGkAtoms::b, empty, empty, &first,
+                                     &any, &all);
+  TEST_RESULT(rv);
   NS_ASSERTION(false==first, "first should be false");
   NS_ASSERTION(false==any, "any should be false");
   NS_ASSERTION(false==all, "all should be false");
-  result = htmlEditor->SetInlineProperty(nsGkAtoms::b, empty, empty);
-  TEST_RESULT(result);
-  result = htmlEditor->GetInlineProperty(nsGkAtoms::b, empty, empty, &first,
-                                         &any, &all);
-  TEST_RESULT(result);
+  rv = htmlEditor->SetInlineProperty(nsGkAtoms::b, empty, empty);
+  TEST_RESULT(rv);
+  rv = htmlEditor->GetInlineProperty(nsGkAtoms::b, empty, empty, &first,
+                                     &any, &all);
+  TEST_RESULT(rv);
   NS_ASSERTION(true==first, "first should be true");
   NS_ASSERTION(true==any, "any should be true");
   NS_ASSERTION(true==all, "all should be true");
   mEditor->DebugDumpContent();
 
   // remove the bold we just set
   printf("set the whole first text node to not bold\n");
-  result = htmlEditor->RemoveInlineProperty(nsGkAtoms::b, empty);
-  TEST_RESULT(result);
-  result = htmlEditor->GetInlineProperty(nsGkAtoms::b, empty, empty, &first,
-                                         &any, &all);
-  TEST_RESULT(result);
+  rv = htmlEditor->RemoveInlineProperty(nsGkAtoms::b, empty);
+  TEST_RESULT(rv);
+  rv = htmlEditor->GetInlineProperty(nsGkAtoms::b, empty, empty, &first,
+                                     &any, &all);
+  TEST_RESULT(rv);
   NS_ASSERTION(false==first, "first should be false");
   NS_ASSERTION(false==any, "any should be false");
   NS_ASSERTION(false==all, "all should be false");
   mEditor->DebugDumpContent();
 
   // set all but the first and last character to bold
   printf("set the first text node (1, length-1) to bold and italic, and (2, length-1) to underline.\n");
   selection->Collapse(textNode, 1);
   selection->Extend(textNode, length-1);
-  result = htmlEditor->SetInlineProperty(nsGkAtoms::b, empty, empty);
-  TEST_RESULT(result);
-  result = htmlEditor->GetInlineProperty(nsGkAtoms::b, empty, empty, &first,
-                                         &any, &all);
-  TEST_RESULT(result);
+  rv = htmlEditor->SetInlineProperty(nsGkAtoms::b, empty, empty);
+  TEST_RESULT(rv);
+  rv = htmlEditor->GetInlineProperty(nsGkAtoms::b, empty, empty, &first,
+                                     &any, &all);
+  TEST_RESULT(rv);
   NS_ASSERTION(true==first, "first should be true");
   NS_ASSERTION(true==any, "any should be true");
   NS_ASSERTION(true==all, "all should be true");
   mEditor->DebugDumpContent();
   // make all that same text italic
-  result = htmlEditor->SetInlineProperty(nsGkAtoms::i, empty, empty);
-  TEST_RESULT(result);
-  result = htmlEditor->GetInlineProperty(nsGkAtoms::i, empty, empty, &first,
-                                         &any, &all);
-  TEST_RESULT(result);
+  rv = htmlEditor->SetInlineProperty(nsGkAtoms::i, empty, empty);
+  TEST_RESULT(rv);
+  rv = htmlEditor->GetInlineProperty(nsGkAtoms::i, empty, empty, &first,
+                                     &any, &all);
+  TEST_RESULT(rv);
   NS_ASSERTION(true==first, "first should be true");
   NS_ASSERTION(true==any, "any should be true");
   NS_ASSERTION(true==all, "all should be true");
-  result = htmlEditor->GetInlineProperty(nsGkAtoms::b, empty, empty, &first,
-                                         &any, &all);
-  TEST_RESULT(result);
+  rv = htmlEditor->GetInlineProperty(nsGkAtoms::b, empty, empty, &first,
+                                     &any, &all);
+  TEST_RESULT(rv);
   NS_ASSERTION(true==first, "first should be true");
   NS_ASSERTION(true==any, "any should be true");
   NS_ASSERTION(true==all, "all should be true");
   mEditor->DebugDumpContent();
 
   // make all the text underlined, except for the first 2 and last 2 characters
-  result = doc->GetElementsByTagName(textTag, getter_AddRefs(nodeList));
-  TEST_RESULT(result);
+  rv = doc->GetElementsByTagName(textTag, getter_AddRefs(nodeList));
+  TEST_RESULT(rv);
   TEST_POINTER(nodeList.get());
   nodeList->GetLength(&count);
   NS_ASSERTION(0!=count, "there are no text nodes in the document!");
-  result = nodeList->Item(count-2, getter_AddRefs(textNode));
-  TEST_RESULT(result);
+  rv = nodeList->Item(count-2, getter_AddRefs(textNode));
+  TEST_RESULT(rv);
   TEST_POINTER(textNode.get());
   textData = do_QueryInterface(textNode);
   textData->GetLength(&length);
   NS_ASSERTION(length==915, "wrong text node");
   selection->Collapse(textNode, 1);
   selection->Extend(textNode, length-2);
-  result = htmlEditor->SetInlineProperty(nsGkAtoms::u, empty, empty);
-  TEST_RESULT(result);
-  result = htmlEditor->GetInlineProperty(nsGkAtoms::u, empty, empty, &first,
-                                         &any, &all);
-  TEST_RESULT(result);
+  rv = htmlEditor->SetInlineProperty(nsGkAtoms::u, empty, empty);
+  TEST_RESULT(rv);
+  rv = htmlEditor->GetInlineProperty(nsGkAtoms::u, empty, empty, &first,
+                                     &any, &all);
+  TEST_RESULT(rv);
   NS_ASSERTION(true==first, "first should be true");
   NS_ASSERTION(true==any, "any should be true");
   NS_ASSERTION(true==all, "all should be true");
   mEditor->DebugDumpContent();
 
-  return result;
+  return rv;
 }
 
-
-
 #endif
-
-

--- a/editor/libeditor/TypeInState.cpp
+++ b/editor/libeditor/TypeInState.cpp
@@ -88,21 +88,21 @@ TypeInState::NotifySelectionChanged(nsID
 
   if (aSelection) {
     int32_t rangeCount = selection->RangeCount();
 
     if (selection->Collapsed() && rangeCount) {
       nsCOMPtr<nsIDOMNode> selNode;
       int32_t selOffset = 0;
 
-      nsresult result =
+      nsresult rv =
         EditorBase::GetStartNodeAndOffset(selection, getter_AddRefs(selNode),
                                           &selOffset);
 
-      NS_ENSURE_SUCCESS(result, result);
+      NS_ENSURE_SUCCESS(rv, rv);
 
       if (selNode &&
           selNode == mLastSelectionContainer &&
           selOffset == mLastSelectionOffset) {
         // We got a bogus selection changed notification!
         return NS_OK;
       }
 

--- a/editor/txmgr/nsTransactionItem.cpp
+++ b/editor/txmgr/nsTransactionItem.cpp
@@ -91,240 +91,247 @@ nsTransactionItem::GetIsBatch(bool *aIsB
   *aIsBatch = !mTransaction;
 
   return NS_OK;
 }
 
 nsresult
 nsTransactionItem::GetNumberOfChildren(int32_t *aNumChildren)
 {
-  nsresult result;
-
   NS_ENSURE_TRUE(aNumChildren, NS_ERROR_NULL_POINTER);
 
   *aNumChildren = 0;
 
   int32_t ui = 0;
   int32_t ri = 0;
 
-  result = GetNumberOfUndoItems(&ui);
+  nsresult rv = GetNumberOfUndoItems(&ui);
 
-  NS_ENSURE_SUCCESS(result, result);
+  NS_ENSURE_SUCCESS(rv, rv);
 
-  result = GetNumberOfRedoItems(&ri);
+  rv = GetNumberOfRedoItems(&ri);
 
-  NS_ENSURE_SUCCESS(result, result);
+  NS_ENSURE_SUCCESS(rv, rv);
 
   *aNumChildren = ui + ri;
 
   return NS_OK;
 }
 
 nsresult
 nsTransactionItem::GetChild(int32_t aIndex, nsTransactionItem **aChild)
 {
   NS_ENSURE_TRUE(aChild, NS_ERROR_NULL_POINTER);
 
   *aChild = 0;
 
   int32_t numItems = 0;
-  nsresult result = GetNumberOfChildren(&numItems);
+  nsresult rv = GetNumberOfChildren(&numItems);
+
+  NS_ENSURE_SUCCESS(rv, rv);
 
-  NS_ENSURE_SUCCESS(result, result);
-
-  if (aIndex < 0 || aIndex >= numItems)
+  if (aIndex < 0 || aIndex >= numItems) {
     return NS_ERROR_FAILURE;
+  }
 
   // Children are expected to be in the order they were added,
   // so the child first added would be at the bottom of the undo
   // stack, or if there are no items on the undo stack, it would
   // be at the top of the redo stack.
 
-  result = GetNumberOfUndoItems(&numItems);
+  rv = GetNumberOfUndoItems(&numItems);
 
-  NS_ENSURE_SUCCESS(result, result);
+  NS_ENSURE_SUCCESS(rv, rv);
 
   if (numItems > 0 && aIndex < numItems) {
     NS_ENSURE_TRUE(mUndoStack, NS_ERROR_FAILURE);
 
     RefPtr<nsTransactionItem> child = mUndoStack->GetItem(aIndex);
     child.forget(aChild);
     return *aChild ? NS_OK : NS_ERROR_FAILURE;
   }
 
   // Adjust the index for the redo stack:
 
   aIndex -=  numItems;
 
-  result = GetNumberOfRedoItems(&numItems);
+  rv = GetNumberOfRedoItems(&numItems);
 
-  NS_ENSURE_SUCCESS(result, result);
+  NS_ENSURE_SUCCESS(rv, rv);
 
   NS_ENSURE_TRUE(mRedoStack && numItems != 0 && aIndex < numItems, NS_ERROR_FAILURE);
 
   RefPtr<nsTransactionItem> child = mRedoStack->GetItem(aIndex);
   child.forget(aChild);
   return *aChild ? NS_OK : NS_ERROR_FAILURE;
 }
 
 nsresult
 nsTransactionItem::DoTransaction()
 {
-  if (mTransaction)
+  if (mTransaction) {
     return mTransaction->DoTransaction();
+  }
   return NS_OK;
 }
 
 nsresult
 nsTransactionItem::UndoTransaction(nsTransactionManager *aTxMgr)
 {
-  nsresult result = UndoChildren(aTxMgr);
+  nsresult rv = UndoChildren(aTxMgr);
 
-  if (NS_FAILED(result)) {
+  if (NS_FAILED(rv)) {
     RecoverFromUndoError(aTxMgr);
-    return result;
+    return rv;
   }
 
-  if (!mTransaction)
+  if (!mTransaction) {
     return NS_OK;
+  }
 
-  result = mTransaction->UndoTransaction();
+  rv = mTransaction->UndoTransaction();
 
-  if (NS_FAILED(result)) {
+  if (NS_FAILED(rv)) {
     RecoverFromUndoError(aTxMgr);
-    return result;
+    return rv;
   }
 
   return NS_OK;
 }
 
 nsresult
 nsTransactionItem::UndoChildren(nsTransactionManager *aTxMgr)
 {
   RefPtr<nsTransactionItem> item;
-  nsresult result = NS_OK;
   int32_t sz = 0;
 
   if (mUndoStack) {
     if (!mRedoStack && mUndoStack) {
       mRedoStack = new nsTransactionStack(nsTransactionStack::FOR_REDO);
     }
 
     /* Undo all of the transaction items children! */
     sz = mUndoStack->GetSize();
 
+    nsresult rv = NS_OK;
     while (sz-- > 0) {
       item = mUndoStack->Peek();
 
       if (!item) {
         return NS_ERROR_FAILURE;
       }
 
       nsCOMPtr<nsITransaction> t = item->GetTransaction();
 
       bool doInterrupt = false;
 
-      result = aTxMgr->WillUndoNotify(t, &doInterrupt);
+      rv = aTxMgr->WillUndoNotify(t, &doInterrupt);
 
-      if (NS_FAILED(result)) {
-        return result;
+      if (NS_FAILED(rv)) {
+        return rv;
       }
 
       if (doInterrupt) {
         return NS_OK;
       }
 
-      result = item->UndoTransaction(aTxMgr);
+      rv = item->UndoTransaction(aTxMgr);
 
-      if (NS_SUCCEEDED(result)) {
+      if (NS_SUCCEEDED(rv)) {
         item = mUndoStack->Pop();
         mRedoStack->Push(item.forget());
       }
 
-      nsresult result2 = aTxMgr->DidUndoNotify(t, result);
+      nsresult rv2 = aTxMgr->DidUndoNotify(t, rv);
 
-      if (NS_SUCCEEDED(result)) {
-        result = result2;
+      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 result;
+  return NS_OK;
 }
 
 nsresult
 nsTransactionItem::RedoTransaction(nsTransactionManager *aTxMgr)
 {
-  nsresult result;
-
   nsCOMPtr<nsITransaction> transaction(mTransaction);
   if (transaction) {
-    result = transaction->RedoTransaction();
+    nsresult rv = transaction->RedoTransaction();
 
-    NS_ENSURE_SUCCESS(result, result);
+    NS_ENSURE_SUCCESS(rv, rv);
   }
 
-  result = RedoChildren(aTxMgr);
+  nsresult rv = RedoChildren(aTxMgr);
 
-  if (NS_FAILED(result)) {
+  if (NS_FAILED(rv)) {
     RecoverFromRedoError(aTxMgr);
-    return result;
+    return rv;
   }
 
   return NS_OK;
 }
 
 nsresult
 nsTransactionItem::RedoChildren(nsTransactionManager *aTxMgr)
 {
   RefPtr<nsTransactionItem> item;
-  nsresult result = NS_OK;
 
-  if (!mRedoStack)
+  if (!mRedoStack) {
     return NS_OK;
+  }
 
   /* Redo all of the transaction items children! */
   int32_t sz = mRedoStack->GetSize();
 
+  nsresult rv = NS_OK;
   while (sz-- > 0) {
     item = mRedoStack->Peek();
 
     if (!item) {
       return NS_ERROR_FAILURE;
     }
 
     nsCOMPtr<nsITransaction> t = item->GetTransaction();
 
     bool doInterrupt = false;
 
-    result = aTxMgr->WillRedoNotify(t, &doInterrupt);
+    rv = aTxMgr->WillRedoNotify(t, &doInterrupt);
 
-    if (NS_FAILED(result)) {
-      return result;
+    if (NS_FAILED(rv)) {
+      return rv;
     }
 
     if (doInterrupt) {
       return NS_OK;
     }
 
-    result = item->RedoTransaction(aTxMgr);
+    rv = item->RedoTransaction(aTxMgr);
 
-    if (NS_SUCCEEDED(result)) {
+    if (NS_SUCCEEDED(rv)) {
       item = mRedoStack->Pop();
       mUndoStack->Push(item.forget());
     }
 
-    nsresult result2 = aTxMgr->DidUndoNotify(t, result);
+    // XXX Shouldn't this DidRedoNotify()? (bug 1311626)
+    nsresult rv2 = aTxMgr->DidUndoNotify(t, rv);
 
-    if (NS_SUCCEEDED(result)) {
-      result = result2;
+    if (NS_SUCCEEDED(rv)) {
+      rv = rv2;
     }
   }
-
-  return result;
+  // 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)
 {
   NS_ENSURE_TRUE(aNumItems, NS_ERROR_NULL_POINTER);
 
   if (!mUndoStack) {
@@ -366,22 +373,21 @@ nsTransactionItem::RecoverFromRedoError(
 {
   //
   // 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 result;
+  nsresult rv = UndoChildren(aTxMgr);
 
-  result = UndoChildren(aTxMgr);
-
-  if (NS_FAILED(result)) {
-    return result;
+  if (NS_FAILED(rv)) {
+    return rv;
   }
 
-  if (!mTransaction)
+  if (!mTransaction) {
     return NS_OK;
+  }
 
   return mTransaction->UndoTransaction();
 }
 

--- a/editor/txmgr/nsTransactionList.cpp
+++ b/editor/txmgr/nsTransactionList.cpp
@@ -44,46 +44,43 @@ NS_IMETHODIMP nsTransactionList::GetNumI
   NS_ENSURE_TRUE(aNumItems, NS_ERROR_NULL_POINTER);
 
   *aNumItems = 0;
 
   nsCOMPtr<nsITransactionManager> txMgr = do_QueryReferent(mTxnMgr);
 
   NS_ENSURE_TRUE(txMgr, NS_ERROR_FAILURE);
 
-  nsresult result = NS_OK;
-
-  if (mTxnStack)
+  if (mTxnStack) {
     *aNumItems = mTxnStack->GetSize();
-  else if (mTxnItem)
-    result = mTxnItem->GetNumberOfChildren(aNumItems);
+  } else if (mTxnItem) {
+    return mTxnItem->GetNumberOfChildren(aNumItems);
+  }
 
-  return result;
+  return NS_OK;
 }
 
 NS_IMETHODIMP nsTransactionList::ItemIsBatch(int32_t aIndex, bool *aIsBatch)
 {
   NS_ENSURE_TRUE(aIsBatch, NS_ERROR_NULL_POINTER);
 
   *aIsBatch = false;
 
   nsCOMPtr<nsITransactionManager> txMgr = do_QueryReferent(mTxnMgr);
 
   NS_ENSURE_TRUE(txMgr, NS_ERROR_FAILURE);
 
   RefPtr<nsTransactionItem> item;
 
-  nsresult result = NS_OK;
-
-  if (mTxnStack)
+  if (mTxnStack) {
     item = mTxnStack->GetItem(aIndex);
-  else if (mTxnItem)
-    result = mTxnItem->GetChild(aIndex, getter_AddRefs(item));
-
-  NS_ENSURE_SUCCESS(result, result);
+  } else if (mTxnItem) {
+    nsresult rv = mTxnItem->GetChild(aIndex, getter_AddRefs(item));
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
 
   NS_ENSURE_TRUE(item, NS_ERROR_FAILURE);
 
   return item->GetIsBatch(aIsBatch);
 }
 
 NS_IMETHODIMP nsTransactionList::GetData(int32_t aIndex,
                                          uint32_t *aLength,
@@ -93,18 +90,18 @@ NS_IMETHODIMP nsTransactionList::GetData
 
   NS_ENSURE_TRUE(txMgr, NS_ERROR_FAILURE);
 
   RefPtr<nsTransactionItem> item;
 
   if (mTxnStack) {
     item = mTxnStack->GetItem(aIndex);
   } else if (mTxnItem) {
-    nsresult result = mTxnItem->GetChild(aIndex, getter_AddRefs(item));
-    NS_ENSURE_SUCCESS(result, result);
+    nsresult rv = mTxnItem->GetChild(aIndex, getter_AddRefs(item));
+    NS_ENSURE_SUCCESS(rv, rv);
   }
 
   nsCOMArray<nsISupports>& data = item->GetData();
 
   nsISupports** ret = static_cast<nsISupports**>(moz_xmalloc(data.Count() *
     sizeof(nsISupports*)));
 
   for (int32_t i = 0; i < data.Count(); i++) {
@@ -124,24 +121,22 @@ NS_IMETHODIMP nsTransactionList::GetItem
   *aItem = 0;
 
   nsCOMPtr<nsITransactionManager> txMgr = do_QueryReferent(mTxnMgr);
 
   NS_ENSURE_TRUE(txMgr, NS_ERROR_FAILURE);
 
   RefPtr<nsTransactionItem> item;
 
-  nsresult result = NS_OK;
-
-  if (mTxnStack)
+  if (mTxnStack) {
     item = mTxnStack->GetItem(aIndex);
-  else if (mTxnItem)
-    result = mTxnItem->GetChild(aIndex, getter_AddRefs(item));
-
-  NS_ENSURE_SUCCESS(result, result);
+  } else if (mTxnItem) {
+    nsresult rv = mTxnItem->GetChild(aIndex, getter_AddRefs(item));
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
 
   NS_ENSURE_TRUE(item, NS_ERROR_FAILURE);
 
   *aItem = item->GetTransaction().take();
 
   return NS_OK;
 }
 
@@ -152,24 +147,22 @@ NS_IMETHODIMP nsTransactionList::GetNumC
   *aNumChildren = 0;
 
   nsCOMPtr<nsITransactionManager> txMgr = do_QueryReferent(mTxnMgr);
 
   NS_ENSURE_TRUE(txMgr, NS_ERROR_FAILURE);
 
   RefPtr<nsTransactionItem> item;
 
-  nsresult result = NS_OK;
-
-  if (mTxnStack)
+  if (mTxnStack) {
     item = mTxnStack->GetItem(aIndex);
-  else if (mTxnItem)
-    result = mTxnItem->GetChild(aIndex, getter_AddRefs(item));
-
-  NS_ENSURE_SUCCESS(result, result);
+  } else if (mTxnItem) {
+    nsresult rv = mTxnItem->GetChild(aIndex, getter_AddRefs(item));
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
 
   NS_ENSURE_TRUE(item, NS_ERROR_FAILURE);
 
   return item->GetNumberOfChildren(aNumChildren);
 }
 
 NS_IMETHODIMP nsTransactionList::GetChildListForItem(int32_t aIndex, nsITransactionList **aTxnList)
 {
@@ -178,28 +171,25 @@ NS_IMETHODIMP nsTransactionList::GetChil
   *aTxnList = 0;
 
   nsCOMPtr<nsITransactionManager> txMgr = do_QueryReferent(mTxnMgr);
 
   NS_ENSURE_TRUE(txMgr, NS_ERROR_FAILURE);
 
   RefPtr<nsTransactionItem> item;
 
-  nsresult result = NS_OK;
-
-  if (mTxnStack)
+  if (mTxnStack) {
     item = mTxnStack->GetItem(aIndex);
-  else if (mTxnItem)
-    result = mTxnItem->GetChild(aIndex, getter_AddRefs(item));
-
-  NS_ENSURE_SUCCESS(result, result);
+  } else if (mTxnItem) {
+    nsresult rv = mTxnItem->GetChild(aIndex, getter_AddRefs(item));
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
 
   NS_ENSURE_TRUE(item, NS_ERROR_FAILURE);
 
   *aTxnList = (nsITransactionList *)new nsTransactionList(txMgr, item);
 
   NS_ENSURE_TRUE(*aTxnList, NS_ERROR_OUT_OF_MEMORY);
 
   NS_ADDREF(*aTxnList);
 
   return NS_OK;
 }
-

--- a/editor/txmgr/nsTransactionManager.cpp
+++ b/editor/txmgr/nsTransactionManager.cpp
@@ -54,55 +54,53 @@ NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(
 NS_INTERFACE_MAP_END
 
 NS_IMPL_CYCLE_COLLECTING_ADDREF(nsTransactionManager)
 NS_IMPL_CYCLE_COLLECTING_RELEASE(nsTransactionManager)
 
 NS_IMETHODIMP
 nsTransactionManager::DoTransaction(nsITransaction *aTransaction)
 {
-  nsresult result;
-
   NS_ENSURE_TRUE(aTransaction, NS_ERROR_NULL_POINTER);
 
   bool doInterrupt = false;
 
-  result = WillDoNotify(aTransaction, &doInterrupt);
+  nsresult rv = WillDoNotify(aTransaction, &doInterrupt);
 
-  if (NS_FAILED(result)) {
-    return result;
+  if (NS_FAILED(rv)) {
+    return rv;
   }
 
   if (doInterrupt) {
     return NS_OK;
   }
 
-  result = BeginTransaction(aTransaction, nullptr);
+  rv = BeginTransaction(aTransaction, nullptr);
 
-  if (NS_FAILED(result)) {
-    DidDoNotify(aTransaction, result);
-    return result;
+  if (NS_FAILED(rv)) {
+    DidDoNotify(aTransaction, rv);
+    return rv;
   }
 
-  result = EndTransaction(false);
+  rv = EndTransaction(false);
 
-  nsresult result2 = DidDoNotify(aTransaction, result);
+  nsresult rv2 = DidDoNotify(aTransaction, rv);
 
-  if (NS_SUCCEEDED(result)) {
-    result = result2;
+  if (NS_SUCCEEDED(rv)) {
+    rv = rv2;
   }
 
-  return result;
+  // XXX The result of EndTransaction() or DidDoNotify() if EndTransaction()
+  //     succeeded.
+  return rv;
 }
 
 NS_IMETHODIMP
 nsTransactionManager::UndoTransaction()
 {
-  nsresult result       = NS_OK;
-
   // It is illegal to call UndoTransaction() while the transaction manager is
   // executing a  transaction's DoTransaction() method! If this happens,
   // the UndoTransaction() request is ignored, and we return NS_ERROR_FAILURE.
 
   if (!mDoStack.IsEmpty()) {
     return NS_ERROR_FAILURE;
   }
 
@@ -114,47 +112,47 @@ nsTransactionManager::UndoTransaction()
   if (!tx) {
     return NS_OK;
   }
 
   nsCOMPtr<nsITransaction> t = tx->GetTransaction();
 
   bool doInterrupt = false;
 
-  result = WillUndoNotify(t, &doInterrupt);
+  nsresult rv = WillUndoNotify(t, &doInterrupt);
 
-  if (NS_FAILED(result)) {
-    return result;
+  if (NS_FAILED(rv)) {
+    return rv;
   }
 
   if (doInterrupt) {
     return NS_OK;
   }
 
-  result = tx->UndoTransaction(this);
+  rv = tx->UndoTransaction(this);
 
-  if (NS_SUCCEEDED(result)) {
+  if (NS_SUCCEEDED(rv)) {
     tx = mUndoStack.Pop();
     mRedoStack.Push(tx.forget());
   }
 
-  nsresult result2 = DidUndoNotify(t, result);
+  nsresult rv2 = DidUndoNotify(t, rv);
 
-  if (NS_SUCCEEDED(result)) {
-    result = result2;
+  if (NS_SUCCEEDED(rv)) {
+    rv = rv2;
   }
 
-  return result;
+  // XXX The result of UndoTransaction() or DidUndoNotify() if UndoTransaction()
+  //     succeeded.
+  return rv;
 }
 
 NS_IMETHODIMP
 nsTransactionManager::RedoTransaction()
 {
-  nsresult result       = NS_OK;
-
   // It is illegal to call RedoTransaction() while the transaction manager is
   // executing a  transaction's DoTransaction() method! If this happens,
   // the RedoTransaction() request is ignored, and we return NS_ERROR_FAILURE.
 
   if (!mDoStack.IsEmpty()) {
     return NS_ERROR_FAILURE;
   }
 
@@ -166,139 +164,137 @@ nsTransactionManager::RedoTransaction()
   if (!tx) {
     return NS_OK;
   }
 
   nsCOMPtr<nsITransaction> t = tx->GetTransaction();
 
   bool doInterrupt = false;
 
-  result = WillRedoNotify(t, &doInterrupt);
+  nsresult rv = WillRedoNotify(t, &doInterrupt);
 
-  if (NS_FAILED(result)) {
-    return result;
+  if (NS_FAILED(rv)) {
+    return rv;
   }
 
   if (doInterrupt) {
     return NS_OK;
   }
 
-  result = tx->RedoTransaction(this);
+  rv = tx->RedoTransaction(this);
 
-  if (NS_SUCCEEDED(result)) {
+  if (NS_SUCCEEDED(rv)) {
     tx = mRedoStack.Pop();
     mUndoStack.Push(tx.forget());
   }
 
-  nsresult result2 = DidRedoNotify(t, result);
+  nsresult rv2 = DidRedoNotify(t, rv);
 
-  if (NS_SUCCEEDED(result)) {
-    result = result2;
+  if (NS_SUCCEEDED(rv)) {
+    rv = rv2;
   }
 
-  return result;
+  // XXX The result of RedoTransaction() or DidRedoNotify() if RedoTransaction()
+  //     succeeded.
+  return rv;
 }
 
 NS_IMETHODIMP
 nsTransactionManager::Clear()
 {
-  nsresult result;
+  nsresult rv = ClearRedoStack();
 
-  result = ClearRedoStack();
-
-  if (NS_FAILED(result)) {
-    return result;
+  if (NS_FAILED(rv)) {
+    return rv;
   }
 
-  result = ClearUndoStack();
-
-  return result;
+  return ClearUndoStack();
 }
 
 NS_IMETHODIMP
 nsTransactionManager::BeginBatch(nsISupports* aData)
 {
-  nsresult result;
-
   // We can batch independent transactions together by simply pushing
   // a dummy transaction item on the do stack. This dummy transaction item
   // will be popped off the do stack, and then pushed on the undo stack
   // in EndBatch().
 
   bool doInterrupt = false;
 
-  result = WillBeginBatchNotify(&doInterrupt);
+  nsresult rv = WillBeginBatchNotify(&doInterrupt);
 
-  if (NS_FAILED(result)) {
-    return result;
+  if (NS_FAILED(rv)) {
+    return rv;
   }
 
   if (doInterrupt) {
     return NS_OK;
   }
 
-  result = BeginTransaction(0, aData);
+  rv = BeginTransaction(0, aData);
 
-  nsresult result2 = DidBeginBatchNotify(result);
+  nsresult rv2 = DidBeginBatchNotify(rv);
 
-  if (NS_SUCCEEDED(result)) {
-    result = result2;
+  if (NS_SUCCEEDED(rv)) {
+    rv = rv2;
   }
 
-  return result;
+  // XXX The result of BeginTransaction() or DidBeginBatchNotify() if
+  //     BeginTransaction() succeeded.
+  return rv;
 }
 
 NS_IMETHODIMP
 nsTransactionManager::EndBatch(bool aAllowEmpty)
 {
-  nsCOMPtr<nsITransaction> ti;
-  nsresult result;
-
   // XXX: Need to add some mechanism to detect the case where the transaction
   //      at the top of the do stack isn't the dummy transaction, so we can
   //      throw an error!! This can happen if someone calls EndBatch() within
   //      the DoTransaction() method of a transaction.
   //
   //      For now, we can detect this case by checking the value of the
   //      dummy transaction's mTransaction field. If it is our dummy
   //      transaction, it should be nullptr. This may not be true in the
   //      future when we allow users to execute a transaction when beginning
   //      a batch!!!!
 
   RefPtr<nsTransactionItem> tx = mDoStack.Peek();
 
+  nsCOMPtr<nsITransaction> ti;
   if (tx) {
     ti = tx->GetTransaction();
   }
 
   if (!tx || ti) {
     return NS_ERROR_FAILURE;
   }
 
   bool doInterrupt = false;
 
-  result = WillEndBatchNotify(&doInterrupt);
+  nsresult rv = WillEndBatchNotify(&doInterrupt);
 
-  if (NS_FAILED(result)) {
-    return result;
+  if (NS_FAILED(rv)) {
+    return rv;
   }
 
   if (doInterrupt) {
     return NS_OK;
   }
 
-  result = EndTransaction(aAllowEmpty);
+  rv = EndTransaction(aAllowEmpty);
 
-  nsresult result2 = DidEndBatchNotify(result);
+  nsresult rv2 = DidEndBatchNotify(rv);
 
-  if (NS_SUCCEEDED(result)) {
-    result = result2;
+  if (NS_SUCCEEDED(rv)) {
+    rv = rv2;
   }
 
-  return result;
+  // XXX The result of EndTransaction() or DidEndBatchNotify() if
+  //     EndTransaction() succeeded.
+  return rv;
 }
 
 NS_IMETHODIMP
 nsTransactionManager::GetNumberOfUndoItems(int32_t *aNumItems)
 {
   *aNumItems = mUndoStack.GetSize();
   return NS_OK;
 }
@@ -465,26 +461,26 @@ nsTransactionManager::BatchTopUndo()
   RefPtr<nsTransactionItem> previousUndo;
 
   lastUndo = mUndoStack.Pop();
   MOZ_ASSERT(lastUndo, "There should be at least two transactions.");
 
   previousUndo = mUndoStack.Peek();
   MOZ_ASSERT(previousUndo, "There should be at least two transactions.");
 
-  nsresult result = previousUndo->AddChild(lastUndo);
+  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();
   NS_ENSURE_TRUE(previousData.AppendObjects(lastData), NS_ERROR_UNEXPECTED);
   lastData.Clear();
 
-  return result;
+  return rv;
 }
 
 nsresult
 nsTransactionManager::RemoveTopUndo()
 {
   if (mUndoStack.IsEmpty()) {
     return NS_OK;
   }
@@ -521,280 +517,265 @@ nsTransactionManager::ClearRedoStack()
 {
   mRedoStack.Clear();
   return NS_OK;
 }
 
 nsresult
 nsTransactionManager::WillDoNotify(nsITransaction *aTransaction, bool *aInterrupt)
 {
-  nsresult result = NS_OK;
   for (int32_t i = 0, lcount = mListeners.Count(); i < lcount; i++) {
-    nsITransactionListener *listener = mListeners[i];
+    nsITransactionListener* listener = mListeners[i];
 
     NS_ENSURE_TRUE(listener, NS_ERROR_FAILURE);
 
-    result = listener->WillDo(this, aTransaction, aInterrupt);
+    nsresult rv = listener->WillDo(this, aTransaction, aInterrupt);
 
-    if (NS_FAILED(result) || *aInterrupt) {
-      break;
+    if (NS_FAILED(rv) || *aInterrupt) {
+      return rv;
     }
   }
 
-  return result;
+  return NS_OK;
 }
 
 nsresult
 nsTransactionManager::DidDoNotify(nsITransaction *aTransaction, nsresult aDoResult)
 {
-  nsresult result = NS_OK;
   for (int32_t i = 0, lcount = mListeners.Count(); i < lcount; i++) {
-    nsITransactionListener *listener = mListeners[i];
+    nsITransactionListener* listener = mListeners[i];
 
     NS_ENSURE_TRUE(listener, NS_ERROR_FAILURE);
 
-    result = listener->DidDo(this, aTransaction, aDoResult);
+    nsresult rv = listener->DidDo(this, aTransaction, aDoResult);
 
-    if (NS_FAILED(result)) {
-      break;
+    if (NS_FAILED(rv)) {
+      return rv;
     }
   }
 
-  return result;
+  return NS_OK;
 }
 
 nsresult
 nsTransactionManager::WillUndoNotify(nsITransaction *aTransaction, bool *aInterrupt)
 {
-  nsresult result = NS_OK;
   for (int32_t i = 0, lcount = mListeners.Count(); i < lcount; i++) {
-    nsITransactionListener *listener = mListeners[i];
+    nsITransactionListener* listener = mListeners[i];
 
     NS_ENSURE_TRUE(listener, NS_ERROR_FAILURE);
 
-    result = listener->WillUndo(this, aTransaction, aInterrupt);
+    nsresult rv = listener->WillUndo(this, aTransaction, aInterrupt);
 
-    if (NS_FAILED(result) || *aInterrupt) {
-      break;
+    if (NS_FAILED(rv) || *aInterrupt) {
+      return rv;
     }
   }
 
-  return result;
+  return NS_OK;
 }
 
 nsresult
 nsTransactionManager::DidUndoNotify(nsITransaction *aTransaction, nsresult aUndoResult)
 {
-  nsresult result = NS_OK;
   for (int32_t i = 0, lcount = mListeners.Count(); i < lcount; i++) {
-    nsITransactionListener *listener = mListeners[i];
+    nsITransactionListener* listener = mListeners[i];
 
     NS_ENSURE_TRUE(listener, NS_ERROR_FAILURE);
 
-    result = listener->DidUndo(this, aTransaction, aUndoResult);
+    nsresult rv = listener->DidUndo(this, aTransaction, aUndoResult);
 
-    if (NS_FAILED(result)) {
-      break;
+    if (NS_FAILED(rv)) {
+      return rv;
     }
   }
 
-  return result;
+  return NS_OK;
 }
 
 nsresult
 nsTransactionManager::WillRedoNotify(nsITransaction *aTransaction, bool *aInterrupt)
 {
-  nsresult result = NS_OK;
   for (int32_t i = 0, lcount = mListeners.Count(); i < lcount; i++) {
-    nsITransactionListener *listener = mListeners[i];
+    nsITransactionListener* listener = mListeners[i];
 
     NS_ENSURE_TRUE(listener, NS_ERROR_FAILURE);
 
-    result = listener->WillRedo(this, aTransaction, aInterrupt);
+    nsresult rv = listener->WillRedo(this, aTransaction, aInterrupt);
 
-    if (NS_FAILED(result) || *aInterrupt) {
-      break;
+    if (NS_FAILED(rv) || *aInterrupt) {
+      return rv;
     }
   }
 
-  return result;
+  return NS_OK;
 }
 
 nsresult
 nsTransactionManager::DidRedoNotify(nsITransaction *aTransaction, nsresult aRedoResult)
 {
-  nsresult result = NS_OK;
   for (int32_t i = 0, lcount = mListeners.Count(); i < lcount; i++) {
-    nsITransactionListener *listener = mListeners[i];
+    nsITransactionListener* listener = mListeners[i];
 
     NS_ENSURE_TRUE(listener, NS_ERROR_FAILURE);
 
-    result = listener->DidRedo(this, aTransaction, aRedoResult);
+    nsresult rv = listener->DidRedo(this, aTransaction, aRedoResult);
 
-    if (NS_FAILED(result)) {
-      break;
+    if (NS_FAILED(rv)) {
+      return rv;
     }
   }
 
-  return result;
+  return NS_OK;
 }
 
 nsresult
 nsTransactionManager::WillBeginBatchNotify(bool *aInterrupt)
 {
-  nsresult result = NS_OK;
   for (int32_t i = 0, lcount = mListeners.Count(); i < lcount; i++) {
-    nsITransactionListener *listener = mListeners[i];
+    nsITransactionListener* listener = mListeners[i];
 
     NS_ENSURE_TRUE(listener, NS_ERROR_FAILURE);
 
-    result = listener->WillBeginBatch(this, aInterrupt);
+    nsresult rv = listener->WillBeginBatch(this, aInterrupt);
 
-    if (NS_FAILED(result) || *aInterrupt) {
-      break;
+    if (NS_FAILED(rv) || *aInterrupt) {
+      return rv;
     }
   }
 
-  return result;
+  return NS_OK;
 }
 
 nsresult
 nsTransactionManager::DidBeginBatchNotify(nsresult aResult)
 {
-  nsresult result = NS_OK;
   for (int32_t i = 0, lcount = mListeners.Count(); i < lcount; i++) {
-    nsITransactionListener *listener = mListeners[i];
+    nsITransactionListener* listener = mListeners[i];
 
     NS_ENSURE_TRUE(listener, NS_ERROR_FAILURE);
 
-    result = listener->DidBeginBatch(this, aResult);
+    nsresult rv = listener->DidBeginBatch(this, aResult);
 
-    if (NS_FAILED(result)) {
-      break;
+    if (NS_FAILED(rv)) {
+      return rv;
     }
   }
 
-  return result;
+  return NS_OK;
 }
 
 nsresult
 nsTransactionManager::WillEndBatchNotify(bool *aInterrupt)
 {
-  nsresult result = NS_OK;
   for (int32_t i = 0, lcount = mListeners.Count(); i < lcount; i++) {
-    nsITransactionListener *listener = mListeners[i];
+    nsITransactionListener* listener = mListeners[i];
 
     NS_ENSURE_TRUE(listener, NS_ERROR_FAILURE);
 
-    result = listener->WillEndBatch(this, aInterrupt);
+    nsresult rv = listener->WillEndBatch(this, aInterrupt);
 
-    if (NS_FAILED(result) || *aInterrupt) {
-      break;
+    if (NS_FAILED(rv) || *aInterrupt) {
+      return rv;
     }
   }
 
-  return result;
+  return NS_OK;
 }
 
 nsresult
 nsTransactionManager::DidEndBatchNotify(nsresult aResult)
 {
-  nsresult result = NS_OK;
   for (int32_t i = 0, lcount = mListeners.Count(); i < lcount; i++) {
-    nsITransactionListener *listener = mListeners[i];
+    nsITransactionListener* listener = mListeners[i];
 
     NS_ENSURE_TRUE(listener, NS_ERROR_FAILURE);
 
-    result = listener->DidEndBatch(this, aResult);
+    nsresult rv = listener->DidEndBatch(this, aResult);
 
-    if (NS_FAILED(result)) {
-      break;
+    if (NS_FAILED(rv)) {
+      return rv;
     }
   }
 
-  return result;
+  return NS_OK;
 }
 
 nsresult
 nsTransactionManager::WillMergeNotify(nsITransaction *aTop, nsITransaction *aTransaction, bool *aInterrupt)
 {
-  nsresult result = NS_OK;
   for (int32_t i = 0, lcount = mListeners.Count(); i < lcount; i++) {
-    nsITransactionListener *listener = mListeners[i];
+    nsITransactionListener* listener = mListeners[i];
 
     NS_ENSURE_TRUE(listener, NS_ERROR_FAILURE);
 
-    result = listener->WillMerge(this, aTop, aTransaction, aInterrupt);
+    nsresult rv = listener->WillMerge(this, aTop, aTransaction, aInterrupt);
 
-    if (NS_FAILED(result) || *aInterrupt) {
-      break;
+    if (NS_FAILED(rv) || *aInterrupt) {
+      return rv;
     }
   }
 
-  return result;
+  return NS_OK;
 }
 
 nsresult
 nsTransactionManager::DidMergeNotify(nsITransaction *aTop,
                                      nsITransaction *aTransaction,
                                      bool aDidMerge,
                                      nsresult aMergeResult)
 {
-  nsresult result = NS_OK;
   for (int32_t i = 0, lcount = mListeners.Count(); i < lcount; i++) {
-    nsITransactionListener *listener = mListeners[i];
+    nsITransactionListener* listener = mListeners[i];
 
     NS_ENSURE_TRUE(listener, NS_ERROR_FAILURE);
 
-    result = listener->DidMerge(this, aTop, aTransaction, aDidMerge, aMergeResult);
+    nsresult rv =
+      listener->DidMerge(this, aTop, aTransaction, aDidMerge, aMergeResult);
 
-    if (NS_FAILED(result)) {
-      break;
+    if (NS_FAILED(rv)) {
+      return rv;
     }
   }
 
-  return result;
+  return NS_OK;
 }
 
 nsresult
 nsTransactionManager::BeginTransaction(nsITransaction *aTransaction,
                                        nsISupports *aData)
 {
-  nsresult result = NS_OK;
-
   // XXX: POSSIBLE OPTIMIZATION
   //      We could use a factory that pre-allocates/recycles transaction items.
   RefPtr<nsTransactionItem> tx = new nsTransactionItem(aTransaction);
 
   if (aData) {
     nsCOMArray<nsISupports>& data = tx->GetData();
     data.AppendObject(aData);
   }
 
   if (!tx) {
     return NS_ERROR_OUT_OF_MEMORY;
   }
 
   mDoStack.Push(tx);
 
-  result = tx->DoTransaction();
+  nsresult rv = tx->DoTransaction();
 
-  if (NS_FAILED(result)) {
+  if (NS_FAILED(rv)) {
     tx = mDoStack.Pop();
-    return result;
+    return rv;
   }
 
   return NS_OK;
 }
 
 nsresult
 nsTransactionManager::EndTransaction(bool aAllowEmpty)
 {
-  nsresult result              = NS_OK;
-
   RefPtr<nsTransactionItem> tx = mDoStack.Pop();
 
   if (!tx) {
     return NS_ERROR_FAILURE;
   }
 
   nsCOMPtr<nsITransaction> tint = tx->GetTransaction();
 
@@ -802,88 +783,84 @@ nsTransactionManager::EndTransaction(boo
     int32_t nc = 0;
 
     // If we get here, the transaction must be a dummy batch transaction
     // created by BeginBatch(). If it contains no children, get rid of it!
 
     tx->GetNumberOfChildren(&nc);
 
     if (!nc) {
-      return result;
+      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) {
-    result = tint->GetIsTransient(&isTransient);
+    rv = tint->GetIsTransient(&isTransient);
   }
 
-  if (NS_FAILED(result) || isTransient || !mMaxTransactionCount) {
+  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 result;
+    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) {
-    result = top->AddChild(tx);
-
-    // XXX: What do we do if this fails?
-
-    return result;
+    return top->AddChild(tx); // XXX: What do we do if this fails?
   }
 
   // The transaction succeeded, so clear the redo stack.
 
-  result = ClearRedoStack();
+  rv = ClearRedoStack();
 
-  if (NS_FAILED(result)) {
+  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) {
     bool didMerge = false;
     nsCOMPtr<nsITransaction> topTransaction = top->GetTransaction();
 
     if (topTransaction) {
 
       bool doInterrupt = false;
 
-      result = WillMergeNotify(topTransaction, tint, &doInterrupt);
+      rv = WillMergeNotify(topTransaction, tint, &doInterrupt);
 
-      NS_ENSURE_SUCCESS(result, result);
+      NS_ENSURE_SUCCESS(rv, rv);
 
       if (!doInterrupt) {
-        result = topTransaction->Merge(tint, &didMerge);
+        rv = topTransaction->Merge(tint, &didMerge);
 
-        nsresult result2 = DidMergeNotify(topTransaction, tint, didMerge, result);
+        nsresult rv2 = DidMergeNotify(topTransaction, tint, didMerge, rv);
 
-        if (NS_SUCCEEDED(result)) {
-          result = result2;
+        if (NS_SUCCEEDED(rv)) {
+          rv = rv2;
         }
 
-        if (NS_FAILED(result)) {
+        if (NS_FAILED(rv)) {
           // XXX: What do we do if this fails?
         }
 
         if (didMerge) {
-          return result;
+          return rv;
         }
       }
     }
   }
 
   // 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!
 
@@ -894,9 +871,8 @@ nsTransactionManager::EndTransaction(boo
   }
 
   // Push the transaction on the undo stack:
 
   mUndoStack.Push(tx.forget());
 
   return NS_OK;
 }
-

--- a/editor/txmgr/tests/TestTXMgr.cpp
+++ b/editor/txmgr/tests/TestTXMgr.cpp
@@ -601,31 +601,31 @@ public:
 
   NS_IMETHOD DoTransaction()
   {
     if (mLevel >= mMaxLevel) {
       // Only leaf nodes can throw errors!
       mFlags |= mErrorFlags;
     }
 
-    nsresult result = SimpleTransaction::DoTransaction();
-
-    if (NS_FAILED(result)) {
+    nsresult rv = SimpleTransaction::DoTransaction();
+    if (NS_FAILED(rv)) {
       // fail("QueryInterface() failed for transaction level %d. (%d)\n",
-      //      mLevel, result);
-      return result;
+      //      mLevel, rv);
+      return rv;
     }
 
-    if (mLevel >= mMaxLevel)
+    if (mLevel >= mMaxLevel) {
       return NS_OK;
+    }
 
     if (mFlags & BATCH_FLAG) {
-      result = mTXMgr->BeginBatch(nullptr);
-      if (NS_FAILED(result)) {
-        return result;
+      rv = mTXMgr->BeginBatch(nullptr);
+      if (NS_FAILED(rv)) {
+        return rv;
       }
     }
 
     int32_t cLevel = mLevel + 1;
 
     for (int i = 1; i <= mNumChildrenPerNode; i++) {
       int32_t flags = mErrorFlags & THROWS_DO_ERROR_FLAG;
 
@@ -642,57 +642,54 @@ public:
       flags |= mFlags & BATCH_FLAG;
 
       AggregateTransaction *tximpl =
               new AggregateTransaction(mTXMgr, cLevel, i, mMaxLevel,
                                        mNumChildrenPerNode, flags);
 
       if (!tximpl) {
         fail("Failed to allocate AggregateTransaction %d, level %d. (%d)\n",
-             i, mLevel, result);
+             i, mLevel, rv);
 
         if (mFlags & BATCH_FLAG) {
           mTXMgr->EndBatch(false);
         }
 
         return NS_ERROR_OUT_OF_MEMORY;
       }
 
       nsITransaction *tx = 0;
-      result = tximpl->QueryInterface(NS_GET_IID(nsITransaction), (void **)&tx);
-      if (NS_FAILED(result)) {
+      rv = tximpl->QueryInterface(NS_GET_IID(nsITransaction), (void **)&tx);
+      if (NS_FAILED(rv)) {
         fail("QueryInterface() failed for transaction %d, level %d. (%d)\n",
-             i, mLevel, result);
+             i, mLevel, rv);
 
         if (mFlags & BATCH_FLAG) {
           mTXMgr->EndBatch(false);
         }
-        return result;
+        return rv;
       }
 
-      result = mTXMgr->DoTransaction(tx);
-
-      if (NS_FAILED(result)) {
+      rv = mTXMgr->DoTransaction(tx);
+      if (NS_FAILED(rv)) {
         // fail("Failed to execute transaction %d, level %d. (%d)\n",
-        //      i, mLevel, result);
+        //      i, mLevel, rv);
         tx->Release();
-
         if (mFlags & BATCH_FLAG) {
           mTXMgr->EndBatch(false);
         }
-        return result;
+        return rv;
       }
-
       tx->Release();
     }
 
     if (mFlags & BATCH_FLAG) {
       mTXMgr->EndBatch(false);
     }
-    return result;
+    return rv;
   }
 };
 
 class TestTransactionFactory
 {
 public:
   virtual TestTransaction *create(nsITransactionManager *txmgr, int32_t flags) = 0;
 };
@@ -751,257 +748,246 @@ reset_globals()
 }
 
 /**
  * Test behaviors in non-batch mode.
  **/
 nsresult
 quick_test(TestTransactionFactory *factory)
 {
-  nsresult result;
-
   /*******************************************************************
    *
    * Create a transaction manager implementation:
    *
    *******************************************************************/
 
+  nsresult rv;
   nsCOMPtr<nsITransactionManager> mgr =
-    do_CreateInstance(NS_TRANSACTIONMANAGER_CONTRACTID, &result);
-  if (NS_FAILED(result) || !mgr) {
+    do_CreateInstance(NS_TRANSACTIONMANAGER_CONTRACTID, &rv);
+  if (NS_FAILED(rv) || !mgr) {
     fail("Failed to create Transaction Manager instance.\n");
     return NS_ERROR_OUT_OF_MEMORY;
   }
 
   passed("Create transaction manager instance");
 
   /*******************************************************************
    *
    * Call DoTransaction() with a null transaction:
    *
    *******************************************************************/
 
-  result = mgr->DoTransaction(0);
-
-  if (result != NS_ERROR_NULL_POINTER) {
-    fail("DoTransaction() returned unexpected error. (%d)\n", result);
-    return result;
+  rv = mgr->DoTransaction(0);
+  if (rv != NS_ERROR_NULL_POINTER) {
+    fail("DoTransaction() returned unexpected error. (%d)\n", rv);
+    return rv;
   }
 
   passed("Call DoTransaction() with null transaction");
 
   /*******************************************************************
    *
    * Call UndoTransaction() with an empty undo stack:
    *
    *******************************************************************/
 
-  result = mgr->UndoTransaction();
-
-  if (NS_FAILED(result)) {
-    fail("Undo on empty undo stack failed. (%d)\n", result);
-    return result;
+  rv = mgr->UndoTransaction();
+  if (NS_FAILED(rv)) {
+    fail("Undo on empty undo stack failed. (%d)\n", rv);
+    return rv;
   }
 
   passed("Call UndoTransaction() with empty undo stack");
 
   /*******************************************************************
    *
    * Call RedoTransaction() with an empty redo stack:
    *
    *******************************************************************/
 
-  result = mgr->RedoTransaction();
-
-  if (NS_FAILED(result)) {
-    fail("Redo on empty redo stack failed. (%d)\n", result);
-    return result;
+  rv = mgr->RedoTransaction();
+  if (NS_FAILED(rv)) {
+    fail("Redo on empty redo stack failed. (%d)\n", rv);
+    return rv;
   }
 
   passed("Call RedoTransaction() with empty redo stack");
 
   /*******************************************************************
    *
    * Call SetMaxTransactionCount(-1) with empty undo and redo stacks:
    *
    *******************************************************************/
 
-  result = mgr->SetMaxTransactionCount(-1);
-
-  if (NS_FAILED(result)) {
-    fail("SetMaxTransactionCount(-1) failed. (%d)\n", result);
-    return result;
+  rv = mgr->SetMaxTransactionCount(-1);
+  if (NS_FAILED(rv)) {
+    fail("SetMaxTransactionCount(-1) failed. (%d)\n", rv);
+    return rv;
   }
 
   passed("Call SetMaxTransactionCount(-1) with empty undo and redo stacks");
 
   /*******************************************************************
    *
    * Call SetMaxTransactionCount(0) with empty undo and redo stacks:
    *
    *******************************************************************/
 
-  result = mgr->SetMaxTransactionCount(0);
-
-  if (NS_FAILED(result)) {
-    fail("SetMaxTransactionCount(0) failed. (%d)\n", result);
-    return result;
+  rv = mgr->SetMaxTransactionCount(0);
+  if (NS_FAILED(rv)) {
+    fail("SetMaxTransactionCount(0) failed. (%d)\n", rv);
+    return rv;
   }
 
   passed("Call SetMaxTransactionCount(0) with empty undo and redo stacks");
 
   /*******************************************************************
    *
    * Call SetMaxTransactionCount(10) with empty undo and redo stacks:
    *
    *******************************************************************/
 
-  result = mgr->SetMaxTransactionCount(10);
-
-  if (NS_FAILED(result)) {
-    fail("SetMaxTransactionCount(10) failed. (%d)\n", result);
-    return result;
+  rv = mgr->SetMaxTransactionCount(10);
+  if (NS_FAILED(rv)) {
+    fail("SetMaxTransactionCount(10) failed. (%d)\n", rv);
+    return rv;
   }
 
   passed("Call SetMaxTransactionCount(10) with empty undo and redo stacks");
 
   /*******************************************************************
    *
    * Call Clear() with empty undo and redo stacks:
    *
    *******************************************************************/
 
-  result = mgr->Clear();
-  if (NS_FAILED(result)) {
-    fail("Clear on empty undo and redo stack failed. (%d)\n", result);
-    return result;
+  rv = mgr->Clear();
+  if (NS_FAILED(rv)) {
+    fail("Clear on empty undo and redo stack failed. (%d)\n", rv);
+    return rv;
   }
 
   passed("Call Clear() with empty undo and redo stack");
 
   int32_t numitems;
 
   /*******************************************************************
    *
    * Call GetNumberOfUndoItems() with an empty undo stack:
    *
    *******************************************************************/
 
-  result = mgr->GetNumberOfUndoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->GetNumberOfUndoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfUndoItems() on empty undo stack failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems) {
     fail("GetNumberOfUndoItems() expected 0 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
   passed("Call GetNumberOfUndoItems() with empty undo stack");
 
   /*******************************************************************
    *
    * Call GetNumberOfRedoItems() with an empty redo stack:
    *
    *******************************************************************/
 
-  result = mgr->GetNumberOfRedoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->GetNumberOfRedoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfRedoItems() on empty redo stack failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems) {
     fail("GetNumberOfRedoItems() expected 0 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
   passed("Call GetNumberOfRedoItems() with empty redo stack");
 
   nsITransaction *tx;
 
   /*******************************************************************
    *
    * Call PeekUndoStack() with an empty undo stack:
    *
    *******************************************************************/
 
   tx = 0;
-  result = mgr->PeekUndoStack(&tx);
+  rv = mgr->PeekUndoStack(&tx);
 
   TEST_TXMGR_IF_RELEASE(tx); // Don't hold onto any references!
 
-  if (NS_FAILED(result)) {
-    fail("PeekUndoStack() on empty undo stack failed. (%d)\n", result);
-    return result;
+  if (NS_FAILED(rv)) {
+    fail("PeekUndoStack() on empty undo stack failed. (%d)\n", rv);
+    return rv;
   }
 
   if (tx) {
-    fail("PeekUndoStack() on empty undo stack failed. (%d)\n", result);
+    fail("PeekUndoStack() on empty undo stack failed. (%d)\n", rv);
     return NS_ERROR_FAILURE;
   }
 
   passed("Call PeekUndoStack() with empty undo stack");
 
   /*******************************************************************
    *
    * Call PeekRedoStack() with an empty undo stack:
    *
    *******************************************************************/
 
   tx = 0;
-  result = mgr->PeekRedoStack(&tx);
+  rv = mgr->PeekRedoStack(&tx);
 
   TEST_TXMGR_IF_RELEASE(tx); // Don't hold onto any references!
 
-  if (NS_FAILED(result)) {
-    fail("PeekRedoStack() on empty redo stack failed. (%d)\n", result);
-    return result;
+  if (NS_FAILED(rv)) {
+    fail("PeekRedoStack() on empty redo stack failed. (%d)\n", rv);
+    return rv;
   }
 
   if (tx) {
-    fail("PeekRedoStack() on empty redo stack failed. (%d)\n", result);
+    fail("PeekRedoStack() on empty redo stack failed. (%d)\n", rv);
     return NS_ERROR_FAILURE;
   }
 
   passed("Call PeekRedoStack() with empty undo stack");
 
   /*******************************************************************
    *
    * Call AddListener() with a null listener pointer:
    *
    *******************************************************************/
 
-  result = mgr->AddListener(0);
-
-  if (result != NS_ERROR_NULL_POINTER) {
-    fail("AddListener() returned unexpected error. (%d)\n", result);
-    return result;
+  rv = mgr->AddListener(0);
+  if (rv != NS_ERROR_NULL_POINTER) {
+    fail("AddListener() returned unexpected error. (%d)\n", rv);
+    return rv;
   }
 
   passed("Call AddListener() with null listener");
 
   /*******************************************************************
    *
    * Call RemoveListener() with a null listener pointer:
    *
    *******************************************************************/
 
-  result = mgr->RemoveListener(0);
-
-  if (result != NS_ERROR_NULL_POINTER) {
-    fail("RemoveListener() returned unexpected error. (%d)\n", result);
-    return result;
+  rv = mgr->RemoveListener(0);
+  if (rv != NS_ERROR_NULL_POINTER) {
+    fail("RemoveListener() returned unexpected error. (%d)\n", rv);
+    return rv;
   }
 
   passed("Call RemoveListener() with null listener");
 
   int32_t i;
   TestTransaction *tximpl;
   nsITransaction *u1, *u2;
   nsITransaction *r1, *r2;
@@ -1010,160 +996,155 @@ quick_test(TestTransactionFactory *facto
    *
    * Test coalescing by executing a transaction that can merge any
    * command into itself. Then execute 20 transaction. Afterwards,
    * we should still have the first transaction sitting on the undo
    * stack. Then clear the undo and redo stacks.
    *
    *******************************************************************/
 
-  result = mgr->SetMaxTransactionCount(10);
-
-  if (NS_FAILED(result)) {
-    fail("SetMaxTransactionCount(10) failed. (%d)\n", result);
-    return result;
+  rv = mgr->SetMaxTransactionCount(10);
+  if (NS_FAILED(rv)) {
+    fail("SetMaxTransactionCount(10) failed. (%d)\n", rv);
+    return rv;
   }
 
 
   tximpl = factory->create(mgr, MERGE_FLAG);
 
   if (!tximpl) {
     fail("Failed to allocate initial transaction.\n");
     return NS_ERROR_OUT_OF_MEMORY;
   }
 
   tx = 0;
 
-  result = tximpl->QueryInterface(NS_GET_IID(nsITransaction), (void **)&tx);
-
-  if (NS_FAILED(result)) {
+  rv = tximpl->QueryInterface(NS_GET_IID(nsITransaction), (void **)&tx);
+  if (NS_FAILED(rv)) {
     fail("QueryInterface() failed for initial transaction. (%d)\n",
-         result);
-    return result;
-  }
-
-  result = mgr->DoTransaction(tx);
-
-  if (NS_FAILED(result)) {
-    fail("Failed to execute initial transaction. (%d)\n", result);
-    return result;
+         rv);
+    return rv;
+  }
+
+  rv = mgr->DoTransaction(tx);
+  if (NS_FAILED(rv)) {
+    fail("Failed to execute initial transaction. (%d)\n", rv);
+    return rv;
   }
 
   tx->Release();
 
   u1 = u2 = r1 = r2 = 0;
 
-  result = mgr->PeekUndoStack(&u1);
+  rv = mgr->PeekUndoStack(&u1);
 
   TEST_TXMGR_IF_RELEASE(u1); // Don't hold onto any references!
 
-  if (NS_FAILED(result)) {
-    fail("Initial PeekUndoStack() failed. (%d)\n", result);
-    return result;
+  if (NS_FAILED(rv)) {
+    fail("Initial PeekUndoStack() failed. (%d)\n", rv);
+    return rv;
   }
 
   if (u1 != tx) {
-    fail("Top of undo stack is different!. (%d)\n", result);
+    fail("Top of undo stack is different!. (%d)\n", rv);
     return NS_ERROR_FAILURE;
   }
 
-  result = mgr->PeekRedoStack(&r1);
+  rv = mgr->PeekRedoStack(&r1);
 
   TEST_TXMGR_IF_RELEASE(r1); // Don't hold onto any references!
 
-  if (NS_FAILED(result)) {
-    fail("Initial PeekRedoStack() failed. (%d)\n", result);
-    return result;
+  if (NS_FAILED(rv)) {
+    fail("Initial PeekRedoStack() failed. (%d)\n", rv);
+    return rv;
   }
 
   for (i = 1; i <= 20; i++) {
     tximpl = factory->create(mgr, NONE_FLAG);
 
     if (!tximpl) {
       fail("Failed to allocate transaction %d.\n", i);
       return NS_ERROR_OUT_OF_MEMORY;
     }
 
     tx = 0;
-    result = tximpl->QueryInterface(NS_GET_IID(nsITransaction), (void **)&tx);
-    if (NS_FAILED(result)) {
+    rv = tximpl->QueryInterface(NS_GET_IID(nsITransaction), (void **)&tx);
+    if (NS_FAILED(rv)) {
       fail("QueryInterface() failed for transaction %d. (%d)\n",
-           i, result);
-      return result;
+           i, rv);
+      return rv;
     }
 
-    result = mgr->DoTransaction(tx);
-    if (NS_FAILED(result)) {
-      fail("Failed to execute transaction %d. (%d)\n", i, result);
-      return result;
+    rv = mgr->DoTransaction(tx);
+    if (NS_FAILED(rv)) {
+      fail("Failed to execute transaction %d. (%d)\n", i, rv);
+      return rv;
     }
 
     tx->Release();
   }
 
-  result = mgr->PeekUndoStack(&u2);
+  rv = mgr->PeekUndoStack(&u2);
 
   TEST_TXMGR_IF_RELEASE(u2); // Don't hold onto any references!
 
-  if (NS_FAILED(result)) {
-    fail("Second PeekUndoStack() failed. (%d)\n", result);
-    return result;
+  if (NS_FAILED(rv)) {
+    fail("Second PeekUndoStack() failed. (%d)\n", rv);
+    return rv;
   }
 
   if (u1 != u2) {
-    fail("Top of undo stack changed. (%d)\n", result);
+    fail("Top of undo stack changed. (%d)\n", rv);
     return NS_ERROR_FAILURE;
   }
 
-  result = mgr->PeekRedoStack(&r2);
+  rv = mgr->PeekRedoStack(&r2);
 
   TEST_TXMGR_IF_RELEASE(r2); // Don't hold onto any references!
 
-  if (NS_FAILED(result)) {
-    fail("Second PeekRedoStack() failed. (%d)\n", result);
-    return result;
+  if (NS_FAILED(rv)) {
+    fail("Second PeekRedoStack() failed. (%d)\n", rv);
+    return rv;
   }
 
   if (r1 != r2) {
-    fail("Top of redo stack changed. (%d)\n", result);
+    fail("Top of redo stack changed. (%d)\n", rv);
     return NS_ERROR_FAILURE;
   }
 
-  result = mgr->GetNumberOfUndoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->GetNumberOfUndoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfUndoItems() on undo stack with 1 item failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems != 1) {
     fail("GetNumberOfUndoItems() expected 1 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
-  result = mgr->GetNumberOfRedoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->GetNumberOfRedoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfRedoItems() on empty redo stack failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems) {
     fail("GetNumberOfRedoItems() expected 0 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
-  result = mgr->Clear();
-  if (NS_FAILED(result)) {
-    fail("Clear() failed. (%d)\n", result);
-    return result;
+  rv = mgr->Clear();
+  if (NS_FAILED(rv)) {
+    fail("Clear() failed. (%d)\n", rv);
+    return rv;
   }
 
   passed("Test coalescing of transactions");
 
   /*******************************************************************
    *
    * Execute 20 transactions. Afterwards, we should have 10
    * transactions on the undo stack:
@@ -1174,257 +1155,250 @@ quick_test(TestTransactionFactory *facto
     tximpl = factory->create(mgr, NONE_FLAG);
 
     if (!tximpl) {
       fail("Failed to allocate transaction %d.\n", i);
       return NS_ERROR_OUT_OF_MEMORY;
     }
 
     tx = 0;
-    result = tximpl->QueryInterface(NS_GET_IID(nsITransaction), (void **)&tx);
-    if (NS_FAILED(result)) {
+    rv = tximpl->QueryInterface(NS_GET_IID(nsITransaction), (void **)&tx);
+    if (NS_FAILED(rv)) {
       fail("QueryInterface() failed for transaction %d. (%d)\n",
-           i, result);
-      return result;
+           i, rv);
+      return rv;
     }
 
-    result = mgr->DoTransaction(tx);
-    if (NS_FAILED(result)) {
-      fail("Failed to execute transaction %d. (%d)\n", i, result);
-      return result;
+    rv = mgr->DoTransaction(tx);
+    if (NS_FAILED(rv)) {
+      fail("Failed to execute transaction %d. (%d)\n", i, rv);
+      return rv;
     }
 
     tx->Release();
   }
 
-  result = mgr->GetNumberOfUndoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->GetNumberOfUndoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfUndoItems() on undo stack with 10 items failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems != 10) {
     fail("GetNumberOfUndoItems() expected 10 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
-  result = mgr->GetNumberOfRedoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->GetNumberOfRedoItems(&numitems);
+
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfRedoItems() on empty redo stack failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems) {
     fail("GetNumberOfRedoItems() expected 0 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
   passed("Execute 20 transactions");
 
   /*******************************************************************
    *
    * Execute 20 transient transactions. Afterwards, we should still
    * have the same 10 transactions on the undo stack:
    *
    *******************************************************************/
 
   u1 = u2 = r1 = r2 = 0;
 
-  result = mgr->PeekUndoStack(&u1);
+  rv = mgr->PeekUndoStack(&u1);
 
   TEST_TXMGR_IF_RELEASE(u1); // Don't hold onto any references!
 
-  if (NS_FAILED(result)) {
-    fail("Initial PeekUndoStack() failed. (%d)\n", result);
-    return result;
-  }
-
-  result = mgr->PeekRedoStack(&r1);
+  if (NS_FAILED(rv)) {
+    fail("Initial PeekUndoStack() failed. (%d)\n", rv);
+    return rv;
+  }
+
+  rv = mgr->PeekRedoStack(&r1);
 
   TEST_TXMGR_IF_RELEASE(r1); // Don't hold onto any references!
 
-  if (NS_FAILED(result)) {
-    fail("Initial PeekRedoStack() failed. (%d)\n", result);
-    return result;
+  if (NS_FAILED(rv)) {
+    fail("Initial PeekRedoStack() failed. (%d)\n", rv);
+    return rv;
   }
 
   for (i = 1; i <= 20; i++) {
     tximpl = factory->create(mgr, TRANSIENT_FLAG);
 
     if (!tximpl) {
       fail("Failed to allocate transaction %d.\n", i);
       return NS_ERROR_OUT_OF_MEMORY;
     }
 
     tx = 0;
-    result = tximpl->QueryInterface(NS_GET_IID(nsITransaction), (void **)&tx);
-    if (NS_FAILED(result)) {
+    rv = tximpl->QueryInterface(NS_GET_IID(nsITransaction), (void **)&tx);
+    if (NS_FAILED(rv)) {
       fail("QueryInterface() failed for transaction %d. (%d)\n",
-           i, result);
-      return result;
+           i, rv);
+      return rv;
     }
 
-    result = mgr->DoTransaction(tx);
-    if (NS_FAILED(result)) {
-      fail("Failed to execute transaction %d. (%d)\n", i, result);
-      return result;
+    rv = mgr->DoTransaction(tx);
+    if (NS_FAILED(rv)) {
+      fail("Failed to execute transaction %d. (%d)\n", i, rv);
+      return rv;
     }
 
     tx->Release();
   }
 
-  result = mgr->PeekUndoStack(&u2);
+  rv = mgr->PeekUndoStack(&u2);
 
   TEST_TXMGR_IF_RELEASE(u2); // Don't hold onto any references!
 
-  if (NS_FAILED(result)) {
-    fail("Second PeekUndoStack() failed. (%d)\n", result);
-    return result;
+  if (NS_FAILED(rv)) {
+    fail("Second PeekUndoStack() failed. (%d)\n", rv);
+    return rv;
   }
 
   if (u1 != u2) {
-    fail("Top of undo stack changed. (%d)\n", result);
+    fail("Top of undo stack changed. (%d)\n", rv);
     return NS_ERROR_FAILURE;
   }
 
-  result = mgr->PeekRedoStack(&r2);
+  rv = mgr->PeekRedoStack(&r2);
 
   TEST_TXMGR_IF_RELEASE(r2); // Don't hold onto any references!
 
-  if (NS_FAILED(result)) {
-    fail("Second PeekRedoStack() failed. (%d)\n", result);
-    return result;
+  if (NS_FAILED(rv)) {
+    fail("Second PeekRedoStack() failed. (%d)\n", rv);
+    return rv;
   }
 
   if (r1 != r2) {
-    fail("Top of redo stack changed. (%d)\n", result);
+    fail("Top of redo stack changed. (%d)\n", rv);
     return NS_ERROR_FAILURE;
   }
 
-  result = mgr->GetNumberOfUndoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->GetNumberOfUndoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfUndoItems() on undo stack with 10 items failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems != 10) {
     fail("GetNumberOfUndoItems() expected 10 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
-  result = mgr->GetNumberOfRedoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->GetNumberOfRedoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfRedoItems() on empty redo stack failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems) {
     fail("GetNumberOfRedoItems() expected 0 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
   passed("Execute 20 transient transactions");
 
   /*******************************************************************
    *
    * Undo 4 transactions. Afterwards, we should have 6 transactions
    * on the undo stack, and 4 on the redo stack:
    *
    *******************************************************************/
 
   for (i = 1; i <= 4; i++) {
-    result = mgr->UndoTransaction();
-    if (NS_FAILED(result)) {
-      fail("Failed to undo transaction %d. (%d)\n", i, result);
-      return result;
+    rv = mgr->UndoTransaction();
+    if (NS_FAILED(rv)) {
+      fail("Failed to undo transaction %d. (%d)\n", i, rv);
+      return rv;
     }
   }
 
-  result = mgr->GetNumberOfUndoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->GetNumberOfUndoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfUndoItems() on undo stack with 6 items failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems != 6) {
     fail("GetNumberOfUndoItems() expected 6 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
-  result = mgr->GetNumberOfRedoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->GetNumberOfRedoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfRedoItems() on redo stack with 4 items failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems != 4) {
     fail("GetNumberOfRedoItems() expected 4 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
   passed("Undo 4 transactions");
 
   /*******************************************************************
    *
    * Redo 2 transactions. Afterwards, we should have 8 transactions
    * on the undo stack, and 2 on the redo stack:
    *
    *******************************************************************/
 
   for (i = 1; i <= 2; ++i) {
-    result = mgr->RedoTransaction();
-    if (NS_FAILED(result)) {
-      fail("Failed to redo transaction %d. (%d)\n", i, result);
-      return result;
+    rv = mgr->RedoTransaction();
+    if (NS_FAILED(rv)) {
+      fail("Failed to redo transaction %d. (%d)\n", i, rv);
+      return rv;
     }
   }
 
-  result = mgr->GetNumberOfUndoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->GetNumberOfUndoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfUndoItems() on undo stack with 8 items failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems != 8) {
     fail("GetNumberOfUndoItems() expected 8 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
-  result = mgr->GetNumberOfRedoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->GetNumberOfRedoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfRedoItems() on redo stack with 2 items failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems != 2) {
     fail("GetNumberOfRedoItems() expected 2 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
   passed("Redo 2 transactions");
 
   /*******************************************************************
    *
    * Execute a new transaction. The redo stack should get pruned!
@@ -1435,134 +1409,127 @@ quick_test(TestTransactionFactory *facto
 
   if (!tximpl) {
     fail("Failed to allocate transaction.\n");
     return NS_ERROR_OUT_OF_MEMORY;
   }
 
   tx = 0;
 
-  result = tximpl->QueryInterface(NS_GET_IID(nsITransaction), (void **)&tx);
-
-  if (NS_FAILED(result)) {
-    fail("QueryInterface() failed for transaction. (%d)\n", result);
-    return result;
-  }
-
-  result = mgr->DoTransaction(tx);
-  if (NS_FAILED(result)) {
-    fail("Failed to execute transaction. (%d)\n", result);
-    return result;
+  rv = tximpl->QueryInterface(NS_GET_IID(nsITransaction), (void **)&tx);
+  if (NS_FAILED(rv)) {
+    fail("QueryInterface() failed for transaction. (%d)\n", rv);
+    return rv;
+  }
+
+  rv = mgr->DoTransaction(tx);
+  if (NS_FAILED(rv)) {
+    fail("Failed to execute transaction. (%d)\n", rv);
+    return rv;
   }
 
   tx->Release();
 
-  result = mgr->GetNumberOfUndoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->GetNumberOfUndoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfUndoItems() on undo stack with 9 items failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems != 9) {
     fail("GetNumberOfUndoItems() expected 9 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
-  result = mgr->GetNumberOfRedoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->GetNumberOfRedoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfRedoItems() on empty redo stack failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems) {
     fail("GetNumberOfRedoItems() expected 0 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
   passed("Check if new transactions prune the redo stack");
 
   /*******************************************************************
    *
    * Undo 4 transactions then clear the undo and redo stacks.
    *
    *******************************************************************/
 
   for (i = 1; i <= 4; ++i) {
-    result = mgr->UndoTransaction();
-    if (NS_FAILED(result)) {
-      fail("Failed to undo transaction %d. (%d)\n", i, result);
-      return result;
+    rv = mgr->UndoTransaction();
+    if (NS_FAILED(rv)) {
+      fail("Failed to undo transaction %d. (%d)\n", i, rv);
+      return rv;
     }
   }
 
-  result = mgr->GetNumberOfUndoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->GetNumberOfUndoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfUndoItems() on undo stack with 5 items failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems != 5) {
     fail("GetNumberOfUndoItems() expected 5 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
-  result = mgr->GetNumberOfRedoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->GetNumberOfRedoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfRedoItems() on redo stack with 4 items failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems != 4) {
     fail("GetNumberOfRedoItems() expected 4 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
-  result = mgr->Clear();
-  if (NS_FAILED(result)) {
-    fail("Clear() failed. (%d)\n", result);
-    return result;
-  }
-
-  result = mgr->GetNumberOfUndoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->Clear();
+  if (NS_FAILED(rv)) {
+    fail("Clear() failed. (%d)\n", rv);
+    return rv;
+  }
+
+  rv = mgr->GetNumberOfUndoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfUndoItems() on cleared undo stack failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems) {
     fail("GetNumberOfUndoItems() expected 0 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
-  result = mgr->GetNumberOfRedoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->GetNumberOfRedoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfRedoItems() on cleared redo stack failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems) {
     fail("GetNumberOfRedoItems() expected 0 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
   passed("Undo 4 transactions then clear the undo and redo stacks");
 
   /*******************************************************************
    *
    * Execute 5 transactions.
@@ -1573,57 +1540,55 @@ quick_test(TestTransactionFactory *facto
     tximpl = factory->create(mgr, NONE_FLAG);
 
     if (!tximpl) {
       fail("Failed to allocate transaction %d.\n", i);
       return NS_ERROR_OUT_OF_MEMORY;
     }
 
     tx = 0;
-    result = tximpl->QueryInterface(NS_GET_IID(nsITransaction), (void **)&tx);
-    if (NS_FAILED(result)) {
+    rv = tximpl->QueryInterface(NS_GET_IID(nsITransaction), (void **)&tx);
+    if (NS_FAILED(rv)) {
       fail("QueryInterface() failed for transaction %d. (%d)\n",
-           i, result);
-      return result;
+           i, rv);
+      return rv;
     }
 
-    result = mgr->DoTransaction(tx);
-    if (NS_FAILED(result)) {
-      fail("Failed to execute transaction %d. (%d)\n", i, result);
-      return result;
+    rv = mgr->DoTransaction(tx);
+    if (NS_FAILED(rv)) {
+      fail("Failed to execute transaction %d. (%d)\n", i, rv);
+      return rv;
     }
 
     tx->Release();
   }
 
-  result = mgr->GetNumberOfUndoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->GetNumberOfUndoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfUndoItems() on undo stack with 5 items failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems != 5) {
     fail("GetNumberOfUndoItems() expected 5 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
-  result = mgr->GetNumberOfRedoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->GetNumberOfRedoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfRedoItems() on empty redo stack failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems) {
     fail("GetNumberOfRedoItems() expected 0 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
   passed("Execute 5 transactions");
 
   /*******************************************************************
    *
    * Test transaction DoTransaction() error:
@@ -1634,105 +1599,102 @@ quick_test(TestTransactionFactory *facto
 
   if (!tximpl) {
     fail("Failed to allocate transaction.\n");
     return NS_ERROR_OUT_OF_MEMORY;
   }
 
   tx = 0;
 
-  result = tximpl->QueryInterface(NS_GET_IID(nsITransaction), (void **)&tx);
-
-  if (NS_FAILED(result)) {
-    fail("QueryInterface() failed for transaction. (%d)\n", result);
-    return result;
+  rv = tximpl->QueryInterface(NS_GET_IID(nsITransaction), (void **)&tx);
+  if (NS_FAILED(rv)) {
+    fail("QueryInterface() failed for transaction. (%d)\n", rv);
+    return rv;
   }
 
   u1 = u2 = r1 = r2 = 0;
 
-  result = mgr->PeekUndoStack(&u1);
+  rv = mgr->PeekUndoStack(&u1);
 
   TEST_TXMGR_IF_RELEASE(u1); // Don't hold onto any references!
 
-  if (NS_FAILED(result)) {
-    fail("Initial PeekUndoStack() failed. (%d)\n", result);
-    return result;
-  }
-
-  result = mgr->PeekRedoStack(&r1);
+  if (NS_FAILED(rv)) {
+    fail("Initial PeekUndoStack() failed. (%d)\n", rv);
+    return rv;
+  }
+
+  rv = mgr->PeekRedoStack(&r1);
 
   TEST_TXMGR_IF_RELEASE(r1); // Don't hold onto any references!
 
-  if (NS_FAILED(result)) {
-    fail("Initial PeekRedoStack() failed. (%d)\n", result);
-    return result;
-  }
-
-  result = mgr->DoTransaction(tx);
-
-  if (result != NS_ERROR_FAILURE) {
-    fail("DoTransaction() returned unexpected error. (%d)\n", result);
-    return result;
+  if (NS_FAILED(rv)) {
+    fail("Initial PeekRedoStack() failed. (%d)\n", rv);
+    return rv;
+  }
+
+  rv = mgr->DoTransaction(tx);
+  if (rv != NS_ERROR_FAILURE) {
+    fail("DoTransaction() returned unexpected error. (%d)\n", rv);
+    return rv;
   }
 
   tx->Release();
 
-  result = mgr->PeekUndoStack(&u2);
+  rv = mgr->PeekUndoStack(&u2);
 
   TEST_TXMGR_IF_RELEASE(u2); // Don't hold onto any references!
 
-  if (NS_FAILED(result)) {
-    fail("Second PeekUndoStack() failed. (%d)\n", result);
-    return result;
+  if (NS_FAILED(rv)) {
+    fail("Second PeekUndoStack() failed. (%d)\n", rv);
+    return rv;
   }
 
   if (u1 != u2) {
-    fail("Top of undo stack changed. (%d)\n", result);
+    fail("Top of undo stack changed. (%d)\n", rv);
     return NS_ERROR_FAILURE;
   }
 
-  result = mgr->PeekRedoStack(&r2);
+  rv = mgr->PeekRedoStack(&r2);
 
   TEST_TXMGR_IF_RELEASE(r2); // Don't hold onto any references!
 
-  if (NS_FAILED(result)) {
-    fail("Second PeekRedoStack() failed. (%d)\n", result);
-    return result;
+  if (NS_FAILED(rv)) {
+    fail("Second PeekRedoStack() failed. (%d)\n", rv);
+    return rv;
   }
 
   if (r1 != r2) {
-    fail("Top of redo stack changed. (%d)\n", result);
+    fail("Top of redo stack changed. (%d)\n", rv);
     return NS_ERROR_FAILURE;
   }
 
-  result = mgr->GetNumberOfUndoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->GetNumberOfUndoItems(&numitems);
+
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfUndoItems() on undo stack with 5 items failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems != 5) {
     fail("GetNumberOfUndoItems() expected 5 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
-  result = mgr->GetNumberOfRedoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->GetNumberOfRedoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfRedoItems() on empty redo stack. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems) {
     fail("GetNumberOfRedoItems() expected 0 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
   passed("Test transaction DoTransaction() error");
 
   /*******************************************************************
    *
    * Test transaction UndoTransaction() error:
@@ -1743,112 +1705,107 @@ quick_test(TestTransactionFactory *facto
 
   if (!tximpl) {
     fail("Failed to allocate transaction.\n");
     return NS_ERROR_OUT_OF_MEMORY;
   }
 
   tx = 0;
 
-  result = tximpl->QueryInterface(NS_GET_IID(nsITransaction), (void **)&tx);
-
-  if (NS_FAILED(result)) {
-    fail("QueryInterface() failed for transaction. (%d)\n", result);
-    return result;
-  }
-
-  result = mgr->DoTransaction(tx);
-
-  if (NS_FAILED(result)) {
-    fail("DoTransaction() returned unexpected error. (%d)\n", result);
-    return result;
+  rv = tximpl->QueryInterface(NS_GET_IID(nsITransaction), (void **)&tx);
+  if (NS_FAILED(rv)) {
+    fail("QueryInterface() failed for transaction. (%d)\n", rv);
+    return rv;
+  }
+
+  rv = mgr->DoTransaction(tx);
+  if (NS_FAILED(rv)) {
+    fail("DoTransaction() returned unexpected error. (%d)\n", rv);
+    return rv;
   }
 
   tx->Release();
 
   u1 = u2 = r1 = r2 = 0;
 
-  result = mgr->PeekUndoStack(&u1);
+  rv = mgr->PeekUndoStack(&u1);
 
   TEST_TXMGR_IF_RELEASE(u1); // Don't hold onto any references!
 
-  if (NS_FAILED(result)) {
-    fail("Initial PeekUndoStack() failed. (%d)\n", result);
-    return result;
-  }
-
-  result = mgr->PeekRedoStack(&r1);
+  if (NS_FAILED(rv)) {
+    fail("Initial PeekUndoStack() failed. (%d)\n", rv);
+    return rv;
+  }
+
+  rv = mgr->PeekRedoStack(&r1);
 
   TEST_TXMGR_IF_RELEASE(r1); // Don't hold onto any references!
 
-  if (NS_FAILED(result)) {
-    fail("Initial PeekRedoStack() failed. (%d)\n", result);
-    return result;
-  }
-
-  result = mgr->UndoTransaction();
-
-  if (result != NS_ERROR_FAILURE) {
-    fail("UndoTransaction() returned unexpected error. (%d)\n", result);
-    return result;
-  }
-
-  result = mgr->PeekUndoStack(&u2);
+  if (NS_FAILED(rv)) {
+    fail("Initial PeekRedoStack() failed. (%d)\n", rv);
+    return rv;
+  }
+
+  rv = mgr->UndoTransaction();
+  if (rv != NS_ERROR_FAILURE) {
+    fail("UndoTransaction() returned unexpected error. (%d)\n", rv);
+    return rv;
+  }
+
+  rv = mgr->PeekUndoStack(&u2);
 
   TEST_TXMGR_IF_RELEASE(u2); // Don't hold onto any references!
 
-  if (NS_FAILED(result)) {
-    fail("Second PeekUndoStack() failed. (%d)\n", result);
-    return result;
+  if (NS_FAILED(rv)) {
+    fail("Second PeekUndoStack() failed. (%d)\n", rv);
+    return rv;
   }
 
   if (u1 != u2) {
-    fail("Top of undo stack changed. (%d)\n", result);
+    fail("Top of undo stack changed. (%d)\n", rv);
     return NS_ERROR_FAILURE;
   }
 
-  result = mgr->PeekRedoStack(&r2);
+  rv = mgr->PeekRedoStack(&r2);
 
   TEST_TXMGR_IF_RELEASE(r2); // Don't hold onto any references!
 
-  if (NS_FAILED(result)) {
-    fail("Second PeekRedoStack() failed. (%d)\n", result);
-    return result;
+  if (NS_FAILED(rv)) {
+    fail("Second PeekRedoStack() failed. (%d)\n", rv);
+    return rv;
   }
 
   if (r1 != r2) {
-    fail("Top of redo stack changed. (%d)\n", result);
+    fail("Top of redo stack changed. (%d)\n", rv);
     return NS_ERROR_FAILURE;
   }
 
-  result = mgr->GetNumberOfUndoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->GetNumberOfUndoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfUndoItems() on undo stack with 6 items failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems != 6) {
     fail("GetNumberOfUndoItems() expected 6 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
-  result = mgr->GetNumberOfRedoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->GetNumberOfRedoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfRedoItems() on empty redo stack. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems) {
     fail("GetNumberOfRedoItems() expected 0 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
   passed("Test transaction UndoTransaction() error");
 
   /*******************************************************************
    *
    * Test transaction RedoTransaction() error:
@@ -1859,29 +1816,28 @@ quick_test(TestTransactionFactory *facto
 
   if (!tximpl) {
     fail("Failed to allocate transaction.\n");
     return NS_ERROR_OUT_OF_MEMORY;
   }
 
   tx = 0;
 
-  result = tximpl->QueryInterface(NS_GET_IID(nsITransaction), (void **)&tx);
-
-  if (NS_FAILED(result)) {
+  rv = tximpl->QueryInterface(NS_GET_IID(nsITransaction), (void **)&tx);
+  if (NS_FAILED(rv)) {
     fail("QueryInterface() failed for RedoErrorTransaction. (%d)\n",
-         result);
-    return result;
-  }
-
-  result = mgr->DoTransaction(tx);
-
-  if (NS_FAILED(result)) {
-    fail("DoTransaction() returned unexpected error. (%d)\n", result);
-    return result;
+         rv);
+    return rv;
+  }
+
+  rv = mgr->DoTransaction(tx);
+
+  if (NS_FAILED(rv)) {
+    fail("DoTransaction() returned unexpected error. (%d)\n", rv);
+    return rv;
   }
 
   tx->Release();
 
   //
   // Execute a normal transaction to be used in a later test:
   //
 
@@ -1889,717 +1845,687 @@ quick_test(TestTransactionFactory *facto
 
   if (!tximpl) {
     fail("Failed to allocate transaction.\n");
     return NS_ERROR_OUT_OF_MEMORY;
   }
 
   tx = 0;
 
-  result = tximpl->QueryInterface(NS_GET_IID(nsITransaction), (void **)&tx);
-
-  if (NS_FAILED(result)) {
-    fail("QueryInterface() failed for transaction. (%d)\n", result);
-    return result;
-  }
-
-  result = mgr->DoTransaction(tx);
-
-  if (NS_FAILED(result)) {
-    fail("DoTransaction() returned unexpected error. (%d)\n", result);
-    return result;
+  rv = tximpl->QueryInterface(NS_GET_IID(nsITransaction), (void **)&tx);
+  if (NS_FAILED(rv)) {
+    fail("QueryInterface() failed for transaction. (%d)\n", rv);
+    return rv;
+  }
+
+  rv = mgr->DoTransaction(tx);
+  if (NS_FAILED(rv)) {
+    fail("DoTransaction() returned unexpected error. (%d)\n", rv);
+    return rv;
   }
 
   tx->Release();
 
   //
   // Undo the 2 transactions just executed.
   //
 
   for (i = 1; i <= 2; ++i) {
-    result = mgr->UndoTransaction();
-    if (NS_FAILED(result)) {
-      fail("Failed to undo transaction %d. (%d)\n", i, result);
-      return result;
+    rv = mgr->UndoTransaction();
+    if (NS_FAILED(rv)) {
+      fail("Failed to undo transaction %d. (%d)\n", i, rv);
+      return rv;
     }
   }
 
   //
   // The RedoErrorTransaction should now be at the top of the redo stack!
   //
 
   u1 = u2 = r1 = r2 = 0;
 
-  result = mgr->PeekUndoStack(&u1);
+  rv = mgr->PeekUndoStack(&u1);
 
   TEST_TXMGR_IF_RELEASE(u1); // Don't hold onto any references!
 
-  if (NS_FAILED(result)) {
-    fail("Initial PeekUndoStack() failed. (%d)\n", result);
-    return result;
-  }
-
-  result = mgr->PeekRedoStack(&r1);
+  if (NS_FAILED(rv)) {
+    fail("Initial PeekUndoStack() failed. (%d)\n", rv);
+    return rv;
+  }
+
+  rv = mgr->PeekRedoStack(&r1);
 
   TEST_TXMGR_IF_RELEASE(r1); // Don't hold onto any references!
 
-  if (NS_FAILED(result)) {
-    fail("Initial PeekRedoStack() failed. (%d)\n", result);
-    return result;
-  }
-
-  result = mgr->RedoTransaction();
-
-  if (result != NS_ERROR_FAILURE) {
-    fail("RedoTransaction() returned unexpected error. (%d)\n", result);
-    return result;
-  }
-
-  result = mgr->PeekUndoStack(&u2);
+  if (NS_FAILED(rv)) {
+    fail("Initial PeekRedoStack() failed. (%d)\n", rv);
+    return rv;
+  }
+
+  rv = mgr->RedoTransaction();
+  if (rv != NS_ERROR_FAILURE) {
+    fail("RedoTransaction() returned unexpected error. (%d)\n", rv);
+    return rv;
+  }
+
+  rv = mgr->PeekUndoStack(&u2);
 
   TEST_TXMGR_IF_RELEASE(u2); // Don't hold onto any references!
 
-  if (NS_FAILED(result)) {
-    fail("Second PeekUndoStack() failed. (%d)\n", result);
-    return result;
+  if (NS_FAILED(rv)) {
+    fail("Second PeekUndoStack() failed. (%d)\n", rv);
+    return rv;
   }
 
   if (u1 != u2) {
-    fail("Top of undo stack changed. (%d)\n", result);
+    fail("Top of undo stack changed. (%d)\n", rv);
     return NS_ERROR_FAILURE;
   }
 
-  result = mgr->PeekRedoStack(&r2);
+  rv = mgr->PeekRedoStack(&r2);
 
   TEST_TXMGR_IF_RELEASE(r2); // Don't hold onto any references!
 
-  if (NS_FAILED(result)) {
-    fail("Second PeekRedoStack() failed. (%d)\n", result);
-    return result;
+  if (NS_FAILED(rv)) {
+    fail("Second PeekRedoStack() failed. (%d)\n", rv);
+    return rv;
   }
 
   if (r1 != r2) {
-    fail("Top of redo stack changed. (%d)\n", result);
+    fail("Top of redo stack changed. (%d)\n", rv);
     return NS_ERROR_FAILURE;
   }
 
-  result = mgr->GetNumberOfUndoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->GetNumberOfUndoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfUndoItems() on undo stack with 6 items failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems != 6) {
     fail("GetNumberOfUndoItems() expected 6 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
-  result = mgr->GetNumberOfRedoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->GetNumberOfRedoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfRedoItems() on redo stack with 2 items failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems != 2) {
     fail("GetNumberOfRedoItems() expected 2 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
   passed("Test transaction RedoTransaction() error");
 
   /*******************************************************************
    *
    * Make sure that setting the transaction manager's max transaction
    * count to zero, clears both the undo and redo stacks, and executes
    * all new commands without pushing them on the undo stack!
    *
    *******************************************************************/
 
-  result = mgr->SetMaxTransactionCount(0);
-
-  if (NS_FAILED(result)) {
-    fail("SetMaxTransactionCount(0) failed. (%d)\n", result);
-    return result;
-  }
-
-  result = mgr->GetNumberOfUndoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->SetMaxTransactionCount(0);
+  if (NS_FAILED(rv)) {
+    fail("SetMaxTransactionCount(0) failed. (%d)\n", rv);
+    return rv;
+  }
+
+  rv = mgr->GetNumberOfUndoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfUndoItems() on empty undo stack failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems) {
     fail("GetNumberOfUndoItems() expected 0 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
-  result = mgr->GetNumberOfRedoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->GetNumberOfRedoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfRedoItems() on empty redo stack failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems) {
     fail("GetNumberOfRedoItems() expected 0 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
   for (i = 1; i <= 20; i++) {
     tximpl = factory->create(mgr, NONE_FLAG);
 
     if (!tximpl) {
       fail("Failed to allocate transaction %d.\n", i);
       return NS_ERROR_OUT_OF_MEMORY;
     }
 
     tx = 0;
-    result = tximpl->QueryInterface(NS_GET_IID(nsITransaction), (void **)&tx);
-    if (NS_FAILED(result)) {
+    rv = tximpl->QueryInterface(NS_GET_IID(nsITransaction), (void **)&tx);
+    if (NS_FAILED(rv)) {
       fail("QueryInterface() failed for transaction %d. (%d)\n",
-           i, result);
-      return result;
+           i, rv);
+      return rv;
     }
 
-    result = mgr->DoTransaction(tx);
-    if (NS_FAILED(result)) {
-      fail("Failed to execute transaction %d. (%d)\n", i, result);
-      return result;
+    rv = mgr->DoTransaction(tx);
+    if (NS_FAILED(rv)) {
+      fail("Failed to execute transaction %d. (%d)\n", i, rv);
+      return rv;
     }
 
     tx->Release();
 
-    result = mgr->GetNumberOfUndoItems(&numitems);
-
-    if (NS_FAILED(result)) {
+    rv = mgr->GetNumberOfUndoItems(&numitems);
+    if (NS_FAILED(rv)) {
       fail("GetNumberOfUndoItems() on empty undo stack failed. (%d)\n",
-           result);
-      return result;
+           rv);
+      return rv;
     }
 
     if (numitems) {
       fail("GetNumberOfUndoItems() expected 0 got %d. (%d)\n",
-           numitems, result);
+           numitems, rv);
       return NS_ERROR_FAILURE;
     }
 
-    result = mgr->GetNumberOfRedoItems(&numitems);
-
-    if (NS_FAILED(result)) {
+    rv = mgr->GetNumberOfRedoItems(&numitems);
+    if (NS_FAILED(rv)) {
       fail("GetNumberOfRedoItems() on empty redo stack failed. (%d)\n",
-           result);
-      return result;
+           rv);
+      return rv;
     }
 
     if (numitems) {
       fail("GetNumberOfRedoItems() expected 0 got %d. (%d)\n",
-           numitems, result);
+           numitems, rv);
       return NS_ERROR_FAILURE;
     }
   }
 
   passed("Test max transaction count of zero");
 
   /*******************************************************************
    *
    * Make sure that setting the transaction manager's max transaction
    * count to something greater than the number of transactions on
    * both the undo and redo stacks causes no pruning of the stacks:
    *
    *******************************************************************/
 
-  result = mgr->SetMaxTransactionCount(-1);
-
-  if (NS_FAILED(result)) {
-    fail("SetMaxTransactionCount(-1) failed. (%d)\n", result);
-    return result;
+  rv = mgr->SetMaxTransactionCount(-1);
+  if (NS_FAILED(rv)) {
+    fail("SetMaxTransactionCount(-1) failed. (%d)\n", rv);
+    return rv;
   }
 
   // Push 20 transactions on the undo stack:
 
   for (i = 1; i <= 20; i++) {
     tximpl = factory->create(mgr, NONE_FLAG);
 
     if (!tximpl) {
       fail("Failed to allocate transaction %d.\n", i);
       return NS_ERROR_OUT_OF_MEMORY;
     }
 
     tx = 0;
-    result = tximpl->QueryInterface(NS_GET_IID(nsITransaction), (void **)&tx);
-    if (NS_FAILED(result)) {
+    rv = tximpl->QueryInterface(NS_GET_IID(nsITransaction), (void **)&tx);
+    if (NS_FAILED(rv)) {
       fail("QueryInterface() failed for transaction %d. (%d)\n",
-           i, result);
-      return result;
+           i, rv);
+      return rv;
     }
 
-    result = mgr->DoTransaction(tx);
-    if (NS_FAILED(result)) {
-      fail("Failed to execute transaction %d. (%d)\n", i, result);
-      return result;
+    rv = mgr->DoTransaction(tx);
+    if (NS_FAILED(rv)) {
+      fail("Failed to execute transaction %d. (%d)\n", i, rv);
+      return rv;
     }
 
     tx->Release();
 
-    result = mgr->GetNumberOfUndoItems(&numitems);
-
-    if (NS_FAILED(result)) {
+    rv = mgr->GetNumberOfUndoItems(&numitems);
+    if (NS_FAILED(rv)) {
       fail("GetNumberOfUndoItems() on undo stack with %d items failed. (%d)\n",
-           i, result);
-      return result;
+           i, rv);
+      return rv;
     }
 
     if (numitems != i) {
       fail("GetNumberOfUndoItems() expected %d got %d. (%d)\n",
-           i, numitems, result);
+           i, numitems, rv);
       return NS_ERROR_FAILURE;
     }
 
-    result = mgr->GetNumberOfRedoItems(&numitems);
-
-    if (NS_FAILED(result)) {
+    rv = mgr->GetNumberOfRedoItems(&numitems);
+    if (NS_FAILED(rv)) {
       fail("GetNumberOfRedoItems() on empty redo stack failed. (%d)\n",
-           result);
-      return result;
+           rv);
+      return rv;
     }
 
     if (numitems) {
       fail("GetNumberOfRedoItems() expected 0 got %d. (%d)\n",
-           numitems, result);
+           numitems, rv);
       return NS_ERROR_FAILURE;
     }
   }
 
   for (i = 1; i <= 10; i++) {
-
-    result = mgr->UndoTransaction();
-    if (NS_FAILED(result)) {
-      fail("Failed to undo transaction %d. (%d)\n", i, result);
-      return result;
+    rv = mgr->UndoTransaction();
+    if (NS_FAILED(rv)) {
+      fail("Failed to undo transaction %d. (%d)\n", i, rv);
+      return rv;
     }
   }
-  result = mgr->GetNumberOfUndoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->GetNumberOfUndoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfUndoItems() on empty undo stack with 10 items failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems != 10) {
     fail("GetNumberOfUndoItems() expected 10 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
-  result = mgr->GetNumberOfRedoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->GetNumberOfRedoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfRedoItems() on redo stack with 10 items failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems != 10) {
     fail("GetNumberOfRedoItems() expected 10 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
   u1 = u2 = r1 = r2 = 0;
 
-  result = mgr->PeekUndoStack(&u1);
+  rv = mgr->PeekUndoStack(&u1);
 
   TEST_TXMGR_IF_RELEASE(u1); // Don't hold onto any references!
 
-  if (NS_FAILED(result)) {
-    fail("Initial PeekUndoStack() failed. (%d)\n", result);
-    return result;
-  }
-
-  result = mgr->PeekRedoStack(&r1);
+  if (NS_FAILED(rv)) {
+    fail("Initial PeekUndoStack() failed. (%d)\n", rv);
+    return rv;
+  }
+
+  rv = mgr->PeekRedoStack(&r1);
 
   TEST_TXMGR_IF_RELEASE(r1); // Don't hold onto any references!
 
-  if (NS_FAILED(result)) {
-    fail("Initial PeekRedoStack() failed. (%d)\n", result);
-    return result;
-  }
-
-  result = mgr->SetMaxTransactionCount(25);
-
-  if (NS_FAILED(result)) {
-    fail("SetMaxTransactionCount(25) failed. (%d)\n", result);
-    return result;
-  }
-
-  result = mgr->PeekUndoStack(&u2);
+  if (NS_FAILED(rv)) {
+    fail("Initial PeekRedoStack() failed. (%d)\n", rv);
+    return rv;
+  }
+
+  rv = mgr->SetMaxTransactionCount(25);
+  if (NS_FAILED(rv)) {
+    fail("SetMaxTransactionCount(25) failed. (%d)\n", rv);
+    return rv;
+  }
+
+  rv = mgr->PeekUndoStack(&u2);
 
   TEST_TXMGR_IF_RELEASE(u2); // Don't hold onto any references!
 
-  if (NS_FAILED(result)) {
-    fail("Second PeekUndoStack() failed. (%d)\n", result);
-    return result;
+  if (NS_FAILED(rv)) {
+    fail("Second PeekUndoStack() failed. (%d)\n", rv);
+    return rv;
   }
 
   if (u1 != u2) {
-    fail("Top of undo stack changed. (%d)\n", result);
+    fail("Top of undo stack changed. (%d)\n", rv);
     return NS_ERROR_FAILURE;
   }
 
-  result = mgr->PeekRedoStack(&r2);
+  rv = mgr->PeekRedoStack(&r2);
 
   TEST_TXMGR_IF_RELEASE(r2); // Don't hold onto any references!
 
-  if (NS_FAILED(result)) {
-    fail("Second PeekRedoStack() failed. (%d)\n", result);
-    return result;
+  if (NS_FAILED(rv)) {
+    fail("Second PeekRedoStack() failed. (%d)\n", rv);
+    return rv;
   }
 
   if (r1 != r2) {
-    fail("Top of redo stack changed. (%d)\n", result);
+    fail("Top of redo stack changed. (%d)\n", rv);
     return NS_ERROR_FAILURE;
   }
 
-  result = mgr->GetNumberOfUndoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->GetNumberOfUndoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfUndoItems() on undo stack with 10 items failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems != 10) {
     fail("GetNumberOfUndoItems() expected 10 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
-  result = mgr->GetNumberOfRedoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->GetNumberOfRedoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfRedoItems() on redo stack with 10 items failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems != 10) {
     fail("GetNumberOfRedoItems() expected 10 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
   passed("Test SetMaxTransactionCount() greater than num stack items");
 
   /*******************************************************************
    *
    * Test undo stack pruning by setting the transaction
    * manager's max transaction count to a number lower than the
    * number of transactions on both the undo and redo stacks:
    *
    *******************************************************************/
 
   u1 = u2 = r1 = r2 = 0;
 
-  result = mgr->PeekUndoStack(&u1);
+  rv = mgr->PeekUndoStack(&u1);
 
   TEST_TXMGR_IF_RELEASE(u1); // Don't hold onto any references!
 
-  if (NS_FAILED(result)) {
-    fail("Initial PeekUndoStack() failed. (%d)\n", result);
-    return result;
-  }
-
-  result = mgr->PeekRedoStack(&r1);
+  if (NS_FAILED(rv)) {
+    fail("Initial PeekUndoStack() failed. (%d)\n", rv);
+    return rv;
+  }
+
+  rv = mgr->PeekRedoStack(&r1);
 
   TEST_TXMGR_IF_RELEASE(r1); // Don't hold onto any references!
 
-  if (NS_FAILED(result)) {
-    fail("Initial PeekRedoStack() failed. (%d)\n", result);
-    return result;
-  }
-
-  result = mgr->SetMaxTransactionCount(15);
-
-  if (NS_FAILED(result)) {
-    fail("SetMaxTransactionCount(15) failed. (%d)\n", result);
-    return result;
-  }
-
-  result = mgr->PeekUndoStack(&u2);
+  if (NS_FAILED(rv)) {
+    fail("Initial PeekRedoStack() failed. (%d)\n", rv);
+    return rv;
+  }
+
+  rv = mgr->SetMaxTransactionCount(15);
+  if (NS_FAILED(rv)) {
+    fail("SetMaxTransactionCount(15) failed. (%d)\n", rv);
+    return rv;
+  }
+
+  rv = mgr->PeekUndoStack(&u2);
 
   TEST_TXMGR_IF_RELEASE(u2); // Don't hold onto any references!
 
-  if (NS_FAILED(result)) {
-    fail("Second PeekUndoStack() failed. (%d)\n", result);
-    return result;
+  if (NS_FAILED(rv)) {
+    fail("Second PeekUndoStack() failed. (%d)\n", rv);
+    return rv;
   }
 
   if (u1 != u2) {
-    fail("Top of undo stack changed. (%d)\n", result);
+    fail("Top of undo stack changed. (%d)\n", rv);
     return NS_ERROR_FAILURE;
   }
 
-  result = mgr->PeekRedoStack(&r2);
+  rv = mgr->PeekRedoStack(&r2);
 
   TEST_TXMGR_IF_RELEASE(r2); // Don't hold onto any references!
 
-  if (NS_FAILED(result)) {
-    fail("Second PeekRedoStack() failed. (%d)\n", result);
-    return result;
+  if (NS_FAILED(rv)) {
+    fail("Second PeekRedoStack() failed. (%d)\n", rv);
+    return rv;
   }
 
   if (r1 != r2) {
-    fail("Top of redo stack changed. (%d)\n", result);
+    fail("Top of redo stack changed. (%d)\n", rv);
     return NS_ERROR_FAILURE;
   }
 
-  result = mgr->GetNumberOfUndoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->GetNumberOfUndoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfUndoItems() on undo stack with 5 items failed. (%d)\n",
-           result);
-    return result;
+           rv);
+    return rv;
   }
 
   if (numitems != 5) {
     fail("GetNumberOfUndoItems() expected 5 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
-  result = mgr->GetNumberOfRedoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->GetNumberOfRedoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfRedoItems() on redo stack with 10 items failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems != 10) {
     fail("GetNumberOfRedoItems() expected 10 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
   passed("Test SetMaxTransactionCount() pruning undo stack");
 
   /*******************************************************************
    *
    * Test redo stack pruning by setting the transaction
    * manager's max transaction count to a number lower than the
    * number of transactions on both the undo and redo stacks:
    *
    *******************************************************************/
 
   u1 = u2 = r1 = r2 = 0;
 
-  result = mgr->PeekUndoStack(&u1);
+  rv = mgr->PeekUndoStack(&u1);
 
   TEST_TXMGR_IF_RELEASE(u1); // Don't hold onto any references!
 
-  if (NS_FAILED(result)) {
-    fail("Initial PeekUndoStack() failed. (%d)\n", result);
-    return result;
-  }
-
-  result = mgr->PeekRedoStack(&r1);
+  if (NS_FAILED(rv)) {
+    fail("Initial PeekUndoStack() failed. (%d)\n", rv);
+    return rv;
+  }
+
+  rv = mgr->PeekRedoStack(&r1);
 
   TEST_TXMGR_IF_RELEASE(r1); // Don't hold onto any references!
 
-  if (NS_FAILED(result)) {
-    fail("Initial PeekRedoStack() failed. (%d)\n", result);
-    return result;
-  }
-
-  result = mgr->SetMaxTransactionCount(5);
-
-  if (NS_FAILED(result)) {
-    fail("SetMaxTransactionCount(5) failed. (%d)\n", result);
-    return result;
-  }
-
-  result = mgr->PeekUndoStack(&u2);
+  if (NS_FAILED(rv)) {
+    fail("Initial PeekRedoStack() failed. (%d)\n", rv);
+    return rv;
+  }
+
+  rv = mgr->SetMaxTransactionCount(5);
+  if (NS_FAILED(rv)) {
+    fail("SetMaxTransactionCount(5) failed. (%d)\n", rv);
+    return rv;
+  }
+
+  rv = mgr->PeekUndoStack(&u2);
 
   TEST_TXMGR_IF_RELEASE(u2); // Don't hold onto any references!
 
-  if (NS_FAILED(result)) {
-    fail("Second PeekUndoStack() failed. (%d)\n", result);
-    return result;
+  if (NS_FAILED(rv)) {
+    fail("Second PeekUndoStack() failed. (%d)\n", rv);
+    return rv;
   }
 
   if (u2) {
-    fail("Unexpected item at top of undo stack. (%d)\n", result);
+    fail("Unexpected item at top of undo stack. (%d)\n", rv);
     return NS_ERROR_FAILURE;
   }
 
-  result = mgr->PeekRedoStack(&r2);
+  rv = mgr->PeekRedoStack(&r2);
 
   TEST_TXMGR_IF_RELEASE(r2); // Don't hold onto any references!
 
-  if (NS_FAILED(result)) {
-    fail("Second PeekRedoStack() failed. (%d)\n", result);
-    return result;
+  if (NS_FAILED(rv)) {
+    fail("Second PeekRedoStack() failed. (%d)\n", rv);
+    return rv;
   }
 
   if (r1 != r2) {
-    fail("Top of redo stack changed. (%d)\n", result);
+    fail("Top of redo stack changed. (%d)\n", rv);
     return NS_ERROR_FAILURE;
   }
 
-  result = mgr->GetNumberOfUndoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->GetNumberOfUndoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfUndoItems() on empty undo stack failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems != 0) {
     fail("GetNumberOfUndoItems() expected 0 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
-  result = mgr->GetNumberOfRedoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->GetNumberOfRedoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfRedoItems() on redo stack with 5 items failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems != 5) {
     fail("GetNumberOfRedoItems() expected 5 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
   passed("Test SetMaxTransactionCount() pruning redo stack");
 
   /*******************************************************************
    *
    * Release the transaction manager. Any transactions on the undo
    * and redo stack should automatically be released:
    *
    *******************************************************************/
 
-  result = mgr->SetMaxTransactionCount(-1);
-
-  if (NS_FAILED(result)) {
-    fail("SetMaxTransactionCount(-1) failed. (%d)\n", result);
-    return result;
+  rv = mgr->SetMaxTransactionCount(-1);
+  if (NS_FAILED(rv)) {
+    fail("SetMaxTransactionCount(-1) failed. (%d)\n", rv);
+    return rv;
   }
 
   // Push 20 transactions on the undo stack:
 
   for (i = 1; i <= 20; i++) {
     tximpl = factory->create(mgr, NONE_FLAG);
 
     if (!tximpl) {
       fail("Failed to allocate transaction %d.\n", i);
       return NS_ERROR_OUT_OF_MEMORY;
     }
 
     tx = 0;
-    result = tximpl->QueryInterface(NS_GET_IID(nsITransaction), (void **)&tx);
-    if (NS_FAILED(result)) {
+    rv = tximpl->QueryInterface(NS_GET_IID(nsITransaction), (void **)&tx);
+    if (NS_FAILED(rv)) {
       fail("QueryInterface() failed for transaction %d. (%d)\n",
-           i, result);
-      return result;
+           i, rv);
+      return rv;
     }
 
-    result = mgr->DoTransaction(tx);
-    if (NS_FAILED(result)) {
-      fail("Failed to execute transaction %d. (%d)\n", i, result);
-      return result;
+    rv = mgr->DoTransaction(tx);
+    if (NS_FAILED(rv)) {
+      fail("Failed to execute transaction %d. (%d)\n", i, rv);
+      return rv;
     }
 
     tx->Release();
 
-    result = mgr->GetNumberOfUndoItems(&numitems);
-
-    if (NS_FAILED(result)) {
+    rv = mgr->GetNumberOfUndoItems(&numitems);
+    if (NS_FAILED(rv)) {
       fail("GetNumberOfUndoItems() on undo stack with %d items failed. (%d)\n",
-           i, result);
-      return result;
+           i, rv);
+      return rv;
     }
 
     if (numitems != i) {
       fail("GetNumberOfUndoItems() expected %d got %d. (%d)\n",
-           i, numitems, result);
+           i, numitems, rv);
       return NS_ERROR_FAILURE;
     }
 
-    result = mgr->GetNumberOfRedoItems(&numitems);
-
-    if (NS_FAILED(result)) {
+    rv = mgr->GetNumberOfRedoItems(&numitems);
+    if (NS_FAILED(rv)) {
       fail("GetNumberOfRedoItems() on empty redo stack failed. (%d)\n",
-           result);
-      return result;
+           rv);
+      return rv;
     }
 
     if (numitems) {
       fail("GetNumberOfRedoItems() expected 0 got %d. (%d)\n",
-           numitems, result);
+           numitems, rv);
       return NS_ERROR_FAILURE;
     }
   }
 
   for (i = 1; i <= 10; i++) {
-
-    result = mgr->UndoTransaction();
-    if (NS_FAILED(result)) {
-      fail("Failed to undo transaction %d. (%d)\n", i, result);
-      return result;
+    rv = mgr->UndoTransaction();
+    if (NS_FAILED(rv)) {
+      fail("Failed to undo transaction %d. (%d)\n", i, rv);
+      return rv;
     }
   }
-  result = mgr->GetNumberOfUndoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+
+  rv = mgr->GetNumberOfUndoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfUndoItems() on undo stack with 10 items failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems != 10) {
     fail("GetNumberOfUndoItems() expected 10 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
-  result = mgr->GetNumberOfRedoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->GetNumberOfRedoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfRedoItems() on redo stack with 10 items failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems != 10) {
     fail("GetNumberOfRedoItems() expected 10 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
-  result = mgr->Clear();
-  if (NS_FAILED(result)) {
-    fail("Clear() failed. (%d)\n", result);
-    return result;
+  rv = mgr->Clear();
+  if (NS_FAILED(rv)) {
+    fail("Clear() failed. (%d)\n", rv);
+    return rv;
   }
 
   passed("Release the transaction manager");
 
   /*******************************************************************
    *
    * Make sure number of transactions created matches number of
    * transactions destroyed!
@@ -2680,219 +2606,206 @@ aggregation_test()
 }
 
 /**
  * Test behaviors in batch mode.
  **/
 nsresult
 quick_batch_test(TestTransactionFactory *factory)
 {
-  nsresult result;
-
   /*******************************************************************
    *
    * Create a transaction manager implementation:
    *
    *******************************************************************/
 
+  nsresult rv;
   nsCOMPtr<nsITransactionManager> mgr =
-    do_CreateInstance(NS_TRANSACTIONMANAGER_CONTRACTID, &result);
-  if (NS_FAILED(result) || !mgr) {
+    do_CreateInstance(NS_TRANSACTIONMANAGER_CONTRACTID, &rv);
+  if (NS_FAILED(rv) || !mgr) {
     fail("Failed to create Transaction Manager instance.\n");
     return NS_ERROR_OUT_OF_MEMORY;
   }
 
   passed("Create transaction manager instance");
 
   int32_t numitems;
 
   /*******************************************************************
    *
    * Make sure an unbalanced call to EndBatch(false) with empty undo stack
    * throws an error!
    *
    *******************************************************************/
 
-  result = mgr->GetNumberOfUndoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->GetNumberOfUndoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfUndoItems() on empty undo stack failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems) {
     fail("GetNumberOfUndoItems() expected 0 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
-  result = mgr->EndBatch(false);
-
-  if (result != NS_ERROR_FAILURE) {
-    fail("EndBatch(false) returned unexpected status. (%d)\n", result);
-    return result;
-  }
-
-  result = mgr->GetNumberOfUndoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->EndBatch(false);
+  if (rv != NS_ERROR_FAILURE) {
+    fail("EndBatch(false) returned unexpected status. (%d)\n", rv);
+    return rv;
+  }
+
+  rv = mgr->GetNumberOfUndoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfUndoItems() on empty undo stack failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems) {
     fail("GetNumberOfUndoItems() expected 0 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
   passed("Test unbalanced EndBatch(false) with empty undo stack");
 
   /*******************************************************************
    *
    * Make sure that an empty batch is not added to the undo stack
    * when it is closed.
    *
    *******************************************************************/
 
-  result = mgr->GetNumberOfUndoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->GetNumberOfUndoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfUndoItems() on empty undo stack failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems) {
     fail("GetNumberOfUndoItems() expected 0 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
-  result = mgr->BeginBatch(nullptr);
-
-  if (NS_FAILED(result)) {
-    fail("BeginBatch(nullptr) failed. (%d)\n", result);
-    return result;
-  }
-
-  result = mgr->GetNumberOfUndoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->BeginBatch(nullptr);
+  if (NS_FAILED(rv)) {
+    fail("BeginBatch(nullptr) failed. (%d)\n", rv);
+    return rv;
+  }
+
+  rv = mgr->GetNumberOfUndoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfUndoItems() on empty undo stack failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems) {
     fail("GetNumberOfUndoItems() expected 0 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
-  result = mgr->EndBatch(false);
-
-  if (NS_FAILED(result)) {
-    fail("EndBatch(false) failed. (%d)\n", result);
-    return result;
-  }
-
-  result = mgr->GetNumberOfUndoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->EndBatch(false);
+  if (NS_FAILED(rv)) {
+    fail("EndBatch(false) failed. (%d)\n", rv);
+    return rv;
+  }
+
+  rv = mgr->GetNumberOfUndoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfUndoItems() on empty undo stack failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems) {
     fail("GetNumberOfUndoItems() expected 0 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
   passed("Test empty batch");
 
   int32_t i;
   TestTransaction *tximpl;
   nsITransaction *tx;
 
   /*******************************************************************
    *
    * Execute 20 transactions. Afterwards, we should have 1
    * transaction on the undo stack:
    *
    *******************************************************************/
 
-  result = mgr->BeginBatch(nullptr);
-
-  if (NS_FAILED(result)) {
-    fail("BeginBatch(nullptr) failed. (%d)\n", result);
-    return result;
+  rv = mgr->BeginBatch(nullptr);
+  if (NS_FAILED(rv)) {
+    fail("BeginBatch(nullptr) failed. (%d)\n", rv);
+    return rv;
   }
 
   for (i = 1; i <= 20; i++) {
     tximpl = factory->create(mgr, NONE_FLAG);
 
     if (!tximpl) {
       fail("Failed to allocate transaction %d.\n", i);
       return NS_ERROR_OUT_OF_MEMORY;
     }
 
     tx = 0;
-    result = tximpl->QueryInterface(NS_GET_IID(nsITransaction), (void **)&tx);
-    if (NS_FAILED(result)) {
+    rv = tximpl->QueryInterface(NS_GET_IID(nsITransaction), (void **)&tx);
+    if (NS_FAILED(rv)) {
       fail("QueryInterface() failed for transaction %d. (%d)\n",
-           i, result);
-      return result;
+           i, rv);
+      return rv;
     }
 
-    result = mgr->DoTransaction(tx);
-    if (NS_FAILED(result)) {
-      fail("Failed to execute transaction %d. (%d)\n", i, result);
-      return result;
+    rv = mgr->DoTransaction(tx);
+    if (NS_FAILED(rv)) {
+      fail("Failed to execute transaction %d. (%d)\n", i, rv);
+      return rv;
     }
 
     tx->Release();
   }
 
-  result = mgr->GetNumberOfUndoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->GetNumberOfUndoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfUndoItems() on empty undo stack failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems != 0) {
     fail("GetNumberOfUndoItems() expected 0 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
-  result = mgr->EndBatch(false);
-
-  if (NS_FAILED(result)) {
-    fail("EndBatch(false) failed. (%d)\n", result);
-    return result;
-  }
-
-  result = mgr->GetNumberOfUndoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->EndBatch(false);
+  if (NS_FAILED(rv)) {
+    fail("EndBatch(false) failed. (%d)\n", rv);
+    return rv;
+  }
+
+  rv = mgr->GetNumberOfUndoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfUndoItems() on undo stack with 1 item failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems != 1) {
     fail("GetNumberOfUndoItems() expected 1 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
   passed("Execute 20 batched transactions");
 
   nsITransaction *u1, *u2;
   nsITransaction *r1, *r2;
 
@@ -2900,706 +2813,669 @@ quick_batch_test(TestTransactionFactory 
    *
    * Execute 20 transient transactions. Afterwards, we should still
    * have the same transaction on the undo stack:
    *
    *******************************************************************/
 
   u1 = u2 = r1 = r2 = 0;
 
-  result = mgr->PeekUndoStack(&u1);
+  rv = mgr->PeekUndoStack(&u1);
 
   TEST_TXMGR_IF_RELEASE(u1); // Don't hold onto any references!
 
-  if (NS_FAILED(result)) {
-    fail("Initial PeekUndoStack() failed. (%d)\n", result);
-    return result;
-  }
-
-  result = mgr->PeekRedoStack(&r1);
+  if (NS_FAILED(rv)) {
+    fail("Initial PeekUndoStack() failed. (%d)\n", rv);
+    return rv;
+  }
+
+  rv = mgr->PeekRedoStack(&r1);
 
   TEST_TXMGR_IF_RELEASE(r1); // Don't hold onto any references!
 
-  if (NS_FAILED(result)) {
-    fail("Initial PeekRedoStack() failed. (%d)\n", result);
-    return result;
-  }
-
-  result = mgr->BeginBatch(nullptr);
-
-  if (NS_FAILED(result)) {
-    fail("BeginBatch(nullptr) failed. (%d)\n", result);
-    return result;
+  if (NS_FAILED(rv)) {
+    fail("Initial PeekRedoStack() failed. (%d)\n", rv);
+    return rv;
+  }
+
+  rv = mgr->BeginBatch(nullptr);
+  if (NS_FAILED(rv)) {
+    fail("BeginBatch(nullptr) failed. (%d)\n", rv);
+    return rv;
   }
 
   for (i = 1; i <= 20; i++) {
     tximpl = factory->create(mgr, TRANSIENT_FLAG);
 
     if (!tximpl) {
       fail("Failed to allocate transaction %d.\n", i);
       return NS_ERROR_OUT_OF_MEMORY;
     }
 
     tx = 0;
-    result = tximpl->QueryInterface(NS_GET_IID(nsITransaction), (void **)&tx);
-    if (NS_FAILED(result)) {
+    rv = tximpl->QueryInterface(NS_GET_IID(nsITransaction), (void **)&tx);
+    if (NS_FAILED(rv)) {
       fail("QueryInterface() failed for transaction %d. (%d)\n",
-           i, result);
-      return result;
+           i, rv);
+      return rv;
     }
 
-    result = mgr->DoTransaction(tx);
-    if (NS_FAILED(result)) {
-      fail("Failed to execute transaction %d. (%d)\n", i, result);
-      return result;
+    rv = mgr->DoTransaction(tx);
+    if (NS_FAILED(rv)) {
+      fail("Failed to execute transaction %d. (%d)\n", i, rv);
+      return rv;
     }
 
     tx->Release();
   }
 
-  result = mgr->EndBatch(false);
-
-  if (NS_FAILED(result)) {
-    fail("EndBatch(false) failed. (%d)\n", result);
-    return result;
-  }
-
-  result = mgr->PeekUndoStack(&u2);
+  rv = mgr->EndBatch(false);
+  if (NS_FAILED(rv)) {
+    fail("EndBatch(false) failed. (%d)\n", rv);
+    return rv;
+  }
+
+  rv = mgr->PeekUndoStack(&u2);
 
   TEST_TXMGR_IF_RELEASE(u2); // Don't hold onto any references!
 
-  if (NS_FAILED(result)) {
-    fail("Second PeekUndoStack() failed. (%d)\n", result);
-    return result;
+  if (NS_FAILED(rv)) {
+    fail("Second PeekUndoStack() failed. (%d)\n", rv);
+    return rv;
   }
 
   if (u1 != u2) {
-    fail("Top of undo stack changed. (%d)\n", result);
+    fail("Top of undo stack changed. (%d)\n", rv);
     return NS_ERROR_FAILURE;
   }
 
-  result = mgr->PeekRedoStack(&r2);
+  rv = mgr->PeekRedoStack(&r2);
 
   TEST_TXMGR_IF_RELEASE(r2); // Don't hold onto any references!
 
-  if (NS_FAILED(result)) {
-    fail("Second PeekRedoStack() failed. (%d)\n", result);
-    return result;
+  if (NS_FAILED(rv)) {
+    fail("Second PeekRedoStack() failed. (%d)\n", rv);
+    return rv;
   }
 
   if (r1 != r2) {
-    fail("Top of redo stack changed. (%d)\n", result);
+    fail("Top of redo stack changed. (%d)\n", rv);
     return NS_ERROR_FAILURE;
   }
 
-  result = mgr->GetNumberOfUndoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->GetNumberOfUndoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfUndoItems() on undo stack with 1 item failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems != 1) {
     fail("GetNumberOfUndoItems() expected 1 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
-  result = mgr->GetNumberOfRedoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->GetNumberOfRedoItems(&numitems);
+
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfRedoItems() on empty redo stack failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems) {
     fail("GetNumberOfRedoItems() expected 0 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
   passed("Execute 20 batched transient transactions");
 
   /*******************************************************************
    *
    * Test nested batching. Afterwards, we should have 2 transactions
    * on the undo stack:
    *
    *******************************************************************/
 
-  result = mgr->BeginBatch(nullptr);
-
-  if (NS_FAILED(result)) {
-    fail("BeginBatch(nullptr) failed. (%d)\n", result);
-    return result;
+  rv = mgr->BeginBatch(nullptr);
+  if (NS_FAILED(rv)) {
+    fail("BeginBatch(nullptr) failed. (%d)\n", rv);
+    return rv;
   }
 
   tximpl = factory->create(mgr, NONE_FLAG);
 
   if (!tximpl) {
     fail("Failed to allocate transaction.\n");
     return NS_ERROR_OUT_OF_MEMORY;
   }
 
   tx = 0;
-  result = tximpl->QueryInterface(NS_GET_IID(nsITransaction), (void **)&tx);
-  if (NS_FAILED(result)) {
-    fail("QueryInterface() failed for transaction. (%d)\n", result);
-    return result;
-  }
-
-  result = mgr->DoTransaction(tx);
-  if (NS_FAILED(result)) {
-    fail("Failed to execute transaction. (%d)\n", result);
-    return result;
+  rv = tximpl->QueryInterface(NS_GET_IID(nsITransaction), (void **)&tx);
+  if (NS_FAILED(rv)) {
+    fail("QueryInterface() failed for transaction. (%d)\n", rv);
+    return rv;
+  }
+
+  rv = mgr->DoTransaction(tx);
+  if (NS_FAILED(rv)) {
+    fail("Failed to execute transaction. (%d)\n", rv);
+    return rv;
   }
 
   tx->Release();
 
-  result = mgr->GetNumberOfUndoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->GetNumberOfUndoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfUndoItems() on undo stack with 1 item failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems != 1) {
     fail("GetNumberOfUndoItems() expected 1 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
-  result = mgr->BeginBatch(nullptr);
-
-  if (NS_FAILED(result)) {
-    fail("BeginBatch(nullptr) failed. (%d)\n", result);
-    return result;
+  rv = mgr->BeginBatch(nullptr);
+  if (NS_FAILED(rv)) {
+    fail("BeginBatch(nullptr) failed. (%d)\n", rv);
+    return rv;
   }
 
   tximpl = factory->create(mgr, NONE_FLAG);
 
   if (!tximpl) {
     fail("Failed to allocate transaction.\n");
     return NS_ERROR_OUT_OF_MEMORY;
   }
 
   tx = 0;
-  result = tximpl->QueryInterface(NS_GET_IID(nsITransaction), (void **)&tx);
-  if (NS_FAILED(result)) {
-    fail("QueryInterface() failed for transaction. (%d)\n", result);
-    return result;
-  }
-
-  result = mgr->DoTransaction(tx);
-  if (NS_FAILED(result)) {
-    fail("Failed to execute transaction. (%d)\n", result);
-    return result;
+  rv = tximpl->QueryInterface(NS_GET_IID(nsITransaction), (void **)&tx);
+  if (NS_FAILED(rv)) {
+    fail("QueryInterface() failed for transaction. (%d)\n", rv);
+    return rv;
+  }
+
+  rv = mgr->DoTransaction(tx);
+  if (NS_FAILED(rv)) {
+    fail("Failed to execute transaction. (%d)\n", rv);
+    return rv;
   }
 
   tx->Release();
 
-  result = mgr->GetNumberOfUndoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->GetNumberOfUndoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfUndoItems() on undo stack with 1 item failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems != 1) {
     fail("GetNumberOfUndoItems() expected 1 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
-  result = mgr->BeginBatch(nullptr);
-
-  if (NS_FAILED(result)) {
-    fail("BeginBatch(nullptr) failed. (%d)\n", result);
-    return result;
+  rv = mgr->BeginBatch(nullptr);
+  if (NS_FAILED(rv)) {
+    fail("BeginBatch(nullptr) failed. (%d)\n", rv);
+    return rv;
   }
 
   tximpl = factory->create(mgr, NONE_FLAG);
 
   if (!tximpl) {
     fail("Failed to allocate transaction.\n");
     return NS_ERROR_OUT_OF_MEMORY;
   }
 
   tx = 0;
-  result = tximpl->QueryInterface(NS_GET_IID(nsITransaction), (void **)&tx);
-  if (NS_FAILED(result)) {
-    fail("QueryInterface() failed for transaction. (%d)\n", result);
-    return result;
-  }
-
-  result = mgr->DoTransaction(tx);
-  if (NS_FAILED(result)) {
-    fail("Failed to execute transaction. (%d)\n", result);
-    return result;
+  rv = tximpl->QueryInterface(NS_GET_IID(nsITransaction), (void **)&tx);
+  if (NS_FAILED(rv)) {
+    fail("QueryInterface() failed for transaction. (%d)\n", rv);
+    return rv;
+  }
+
+  rv = mgr->DoTransaction(tx);
+  if (NS_FAILED(rv)) {
+    fail("Failed to execute transaction. (%d)\n", rv);
+    return rv;
   }
 
   tx->Release();
 
-  result = mgr->GetNumberOfUndoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->GetNumberOfUndoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfUndoItems() on undo stack with 1 item failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems != 1) {
     fail("GetNumberOfUndoItems() expected 1 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
-  result = mgr->EndBatch(false);
-
-  if (NS_FAILED(result)) {
-    fail("EndBatch(false) failed. (%d)\n", result);
-    return result;
-  }
-
-  result = mgr->EndBatch(false);
-
-  if (NS_FAILED(result)) {
-    fail("EndBatch(false) failed. (%d)\n", result);
-    return result;
-  }
-
-  result = mgr->EndBatch(false);
-
-  if (NS_FAILED(result)) {
-    fail("EndBatch(false) failed. (%d)\n", result);
-    return result;
-  }
-
-  result = mgr->GetNumberOfUndoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->EndBatch(false);
+  if (NS_FAILED(rv)) {
+    fail("EndBatch(false) failed. (%d)\n", rv);
+    return rv;
+  }
+
+  rv = mgr->EndBatch(false);
+  if (NS_FAILED(rv)) {
+    fail("EndBatch(false) failed. (%d)\n", rv);
+    return rv;
+  }
+
+  rv = mgr->EndBatch(false);
+  if (NS_FAILED(rv)) {
+    fail("EndBatch(false) failed. (%d)\n", rv);
+    return rv;
+  }
+
+  rv = mgr->GetNumberOfUndoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfUndoItems() on undo stack with 2 items failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems != 2) {
     fail("GetNumberOfUndoItems() expected 2 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
   passed("Test nested batched transactions");
 
   /*******************************************************************
    *
    * Undo 2 batch transactions. Afterwards, we should have 0
    * transactions on the undo stack and 2 on the redo stack.
    *
    *******************************************************************/
 
   for (i = 1; i <= 2; ++i) {
-    result = mgr->UndoTransaction();
-    if (NS_FAILED(result)) {
-      fail("Failed to undo transaction %d. (%d)\n", i, result);
-      return result;
+    rv = mgr->UndoTransaction();
+    if (NS_FAILED(rv)) {
+      fail("Failed to undo transaction %d. (%d)\n", i, rv);
+      return rv;
     }
   }
 
-  result = mgr->GetNumberOfUndoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->GetNumberOfUndoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfUndoItems() on empty undo stack failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems) {
     fail("GetNumberOfUndoItems() expected 0 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
-  result = mgr->GetNumberOfRedoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->GetNumberOfRedoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfRedoItems() on redo stack with 2 items failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems != 2) {
     fail("GetNumberOfRedoItems() expected 2 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
   passed("Undo 2 batch transactions");
 
   /*******************************************************************
    *
    * Redo 2 batch transactions. Afterwards, we should have 2
    * transactions on the undo stack and 0 on the redo stack.
    *
    *******************************************************************/
 
   for (i = 1; i <= 2; ++i) {
-    result = mgr->RedoTransaction();
-    if (NS_FAILED(result)) {
-      fail("Failed to undo transaction %d. (%d)\n", i, result);
-      return result;
+    rv = mgr->RedoTransaction();
+    if (NS_FAILED(rv)) {
+      fail("Failed to undo transaction %d. (%d)\n", i, rv);
+      return rv;
     }
   }
 
-  result = mgr->GetNumberOfUndoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->GetNumberOfUndoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfUndoItems() on undo stack with 2 items failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems != 2) {
     fail("GetNumberOfUndoItems() expected 2 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
-  result = mgr->GetNumberOfRedoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->GetNumberOfRedoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfRedoItems() on empty redo stack failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems) {
     fail("GetNumberOfRedoItems() expected 0 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
   passed("Redo 2 batch transactions");
 
   /*******************************************************************
    *
    * Call undo. Afterwards, we should have 1 transaction
    * on the undo stack, and 1 on the redo stack:
    *
    *******************************************************************/
 
-  result = mgr->UndoTransaction();
-
-  if (NS_FAILED(result)) {
-    fail("Failed to undo transaction. (%d)\n", result);
-    return result;
-  }
-
-  result = mgr->GetNumberOfUndoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->UndoTransaction();
+  if (NS_FAILED(rv)) {
+    fail("Failed to undo transaction. (%d)\n", rv);
+    return rv;
+  }
+
+  rv = mgr->GetNumberOfUndoItems(&numitems);
+
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfUndoItems() on undo stack with 1 item failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems != 1) {
     fail("GetNumberOfUndoItems() expected 1 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
-  result = mgr->GetNumberOfRedoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->GetNumberOfRedoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfRedoItems() on stack with 1 item failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems != 1) {
     fail("GetNumberOfRedoItems() expected 1 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
   passed("Undo a batched transaction that was redone");
 
   /*******************************************************************
    *
    * Make sure an unbalanced call to EndBatch(false) throws an error and
    * doesn't affect the undo and redo stacks!
    *
    *******************************************************************/
 
-  result = mgr->EndBatch(false);
-
-  if (result != NS_ERROR_FAILURE) {
-    fail("EndBatch(false) returned unexpected status. (%d)\n", result);
-    return result;
-  }
-
-  result = mgr->GetNumberOfUndoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->EndBatch(false);
+  if (rv != NS_ERROR_FAILURE) {
+    fail("EndBatch(false) returned unexpected status. (%d)\n", rv);
+    return rv;
+  }
+
+  rv = mgr->GetNumberOfUndoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfUndoItems() on undo stack with 1 item failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems != 1) {
     fail("GetNumberOfUndoItems() expected 1 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
-  result = mgr->GetNumberOfRedoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->GetNumberOfRedoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfRedoItems() on stack with 1 item failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems != 1) {
     fail("GetNumberOfRedoItems() expected 1 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
   passed("Test effect of unbalanced EndBatch(false) on undo and redo stacks");
 
   /*******************************************************************
    *
    * Make sure that an empty batch is not added to the undo stack
    * when it is closed, and that it does not affect the undo and redo
    * stacks.
    *
    *******************************************************************/
 
-  result = mgr->BeginBatch(nullptr);
-
-  if (NS_FAILED(result)) {
-    fail("BeginBatch(nullptr) failed. (%d)\n", result);
-    return result;
-  }
-
-  result = mgr->GetNumberOfUndoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->BeginBatch(nullptr);
+  if (NS_FAILED(rv)) {
+    fail("BeginBatch(nullptr) failed. (%d)\n", rv);
+    return rv;
+  }
+
+  rv = mgr->GetNumberOfUndoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfUndoItems() on undo stack with 1 item failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems != 1) {
     fail("GetNumberOfUndoItems() expected 1 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
-  result = mgr->GetNumberOfRedoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->GetNumberOfRedoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfRedoItems() on stack with 1 item failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems != 1) {
     fail("GetNumberOfRedoItems() expected 1 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
-  result = mgr->EndBatch(false);
-
-  if (NS_FAILED(result)) {
-    fail("EndBatch(false) failed. (%d)\n", result);
-    return result;
-  }
-
-  result = mgr->GetNumberOfUndoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->EndBatch(false);
+  if (NS_FAILED(rv)) {
+    fail("EndBatch(false) failed. (%d)\n", rv);
+    return rv;
+  }
+
+  rv = mgr->GetNumberOfUndoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfUndoItems() on undo stack with 1 item failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems != 1) {
     fail("GetNumberOfUndoItems() expected 1 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
-  result = mgr->GetNumberOfRedoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->GetNumberOfRedoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfRedoItems() on stack with 1 item failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems != 1) {
     fail("GetNumberOfRedoItems() expected 1 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
   passed("Test effect of empty batch on undo and redo stacks");
 
   /*******************************************************************
    *
    * Execute a new transaction. The redo stack should get pruned!
    *
    *******************************************************************/
 
-  result = mgr->BeginBatch(nullptr);
-
-  if (NS_FAILED(result)) {
-    fail("BeginBatch(nullptr) failed. (%d)\n", result);
-    return result;
+  rv = mgr->BeginBatch(nullptr);
+  if (NS_FAILED(rv)) {
+    fail("BeginBatch(nullptr) failed. (%d)\n", rv);
+    return rv;
   }
 
   for (i = 1; i <= 20; i++) {
     tximpl = factory->create(mgr, NONE_FLAG);
 
     if (!tximpl) {
       fail("Failed to allocate transaction %d.\n", i);
       return NS_ERROR_OUT_OF_MEMORY;
     }
 
     tx = 0;
-    result = tximpl->QueryInterface(NS_GET_IID(nsITransaction), (void **)&tx);
-    if (NS_FAILED(result)) {
+    rv = tximpl->QueryInterface(NS_GET_IID(nsITransaction), (void **)&tx);
+    if (NS_FAILED(rv)) {
       fail("QueryInterface() failed for transaction %d. (%d)\n",
-           i, result);
-      return result;
+           i, rv);
+      return rv;
     }
 
-    result = mgr->DoTransaction(tx);
-    if (NS_FAILED(result)) {
-      fail("Failed to execute transaction %d. (%d)\n", i, result);
-      return result;
+    rv = mgr->DoTransaction(tx);
+    if (NS_FAILED(rv)) {
+      fail("Failed to execute transaction %d. (%d)\n", i, rv);
+      return rv;
     }
 
     tx->Release();
   }
 
-  result = mgr->GetNumberOfUndoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->GetNumberOfUndoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfUndoItems() on undo stack with 1 item failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems != 1) {
     fail("GetNumberOfUndoItems() expected 1 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
-  result = mgr->GetNumberOfRedoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->GetNumberOfRedoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfRedoItems() on redo stack with 1 item failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems != 1) {
     fail("GetNumberOfRedoItems() expected 1 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
-  result = mgr->EndBatch(false);
-
-  if (NS_FAILED(result)) {
-    fail("EndBatch(false) failed. (%d)\n", result);
-    return result;
-  }
-
-  result = mgr->GetNumberOfUndoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->EndBatch(false);
+  if (NS_FAILED(rv)) {
+    fail("EndBatch(false) failed. (%d)\n", rv);
+    return rv;
+  }
+
+  rv = mgr->GetNumberOfUndoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfUndoItems() on undo stack with 2 items failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems != 2) {
     fail("GetNumberOfUndoItems() expected 2 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
-  result = mgr->GetNumberOfRedoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->GetNumberOfRedoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfRedoItems() on empty redo stack failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems) {
     fail("GetNumberOfRedoItems() expected 0 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
   passed("Check if new batched transactions prune the redo stack");
 
   /*******************************************************************
    *
    * Call undo.
    *
    *******************************************************************/
 
   // Move a transaction over to the redo stack, so that we have one
   // transaction on the undo stack, and one on the redo stack!
 
-  result = mgr->UndoTransaction();
-
-  if (NS_FAILED(result)) {
-    fail("Failed to undo transaction. (%d)\n", result);
-    return result;
-  }
-
-  result = mgr->GetNumberOfUndoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->UndoTransaction();
+  if (NS_FAILED(rv)) {
+    fail("Failed to undo transaction. (%d)\n", rv);
+    return rv;
+  }
+
+  rv = mgr->GetNumberOfUndoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfUndoItems() on undo stack with 1 item failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems != 1) {
     fail("GetNumberOfUndoItems() expected 1 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
-  result = mgr->GetNumberOfRedoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->GetNumberOfRedoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfRedoItems() on redo stack with 1 item failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems != 1) {
     fail("GetNumberOfRedoItems() expected 1 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
   passed("Call undo");
 
   /*******************************************************************
    *
    * Test transaction DoTransaction() error:
@@ -3610,119 +3486,113 @@ quick_batch_test(TestTransactionFactory 
 
   if (!tximpl) {
     fail("Failed to allocate transaction.\n");
     return NS_ERROR_OUT_OF_MEMORY;
   }
 
   tx     = 0;
 
-  result = tximpl->QueryInterface(NS_GET_IID(nsITransaction), (void **)&tx);
-
-  if (NS_FAILED(result)) {
-    fail("QueryInterface() failed for transaction. (%d)\n", result);
-    return result;
+  rv = tximpl->QueryInterface(NS_GET_IID(nsITransaction), (void **)&tx);
+  if (NS_FAILED(rv)) {
+    fail("QueryInterface() failed for transaction. (%d)\n", rv);
+    return rv;
   }
 
   u1 = u2 = r1 = r2 = 0;
 
-  result = mgr->PeekUndoStack(&u1);
+  rv = mgr->PeekUndoStack(&u1);
 
   TEST_TXMGR_IF_RELEASE(u1); // Don't hold onto any references!
 
-  if (NS_FAILED(result)) {
-    fail("Initial PeekUndoStack() failed. (%d)\n", result);
-    return result;
-  }
-
-  result = mgr->PeekRedoStack(&r1);
+  if (NS_FAILED(rv)) {
+    fail("Initial PeekUndoStack() failed. (%d)\n", rv);
+    return rv;
+  }
+
+  rv = mgr->PeekRedoStack(&r1);
 
   TEST_TXMGR_IF_RELEASE(r1); // Don't hold onto any references!
 
-  if (NS_FAILED(result)) {
-    fail("Initial PeekRedoStack() failed. (%d)\n", result);
-    return result;
-  }
-
-  result = mgr->BeginBatch(nullptr);
-
-  if (NS_FAILED(result)) {
-    fail("BeginBatch(nullptr) failed. (%d)\n", result);
-    return result;
-  }
-
-  result = mgr->DoTransaction(tx);
-
-  if (result != NS_ERROR_FAILURE) {
-    fail("DoTransaction() returned unexpected error. (%d)\n", result);
-    return result;
+  if (NS_FAILED(rv)) {
+    fail("Initial PeekRedoStack() failed. (%d)\n", rv);
+    return rv;
+  }
+
+  rv = mgr->BeginBatch(nullptr);
+  if (NS_FAILED(rv)) {
+    fail("BeginBatch(nullptr) failed. (%d)\n", rv);
+    return rv;
+  }
+
+  rv = mgr->DoTransaction(tx);
+  if (rv != NS_ERROR_FAILURE) {
+    fail("DoTransaction() returned unexpected error. (%d)\n", rv);
+    return rv;
   }
 
   tx->Release();
 
-  result = mgr->EndBatch(false);
-
-  if (NS_FAILED(result)) {
-    fail("EndBatch(false) failed. (%d)\n", result);
-    return result;
-  }
-
-  result = mgr->PeekUndoStack(&u2);
+  rv = mgr->EndBatch(false);
+  if (NS_FAILED(rv)) {
+    fail("EndBatch(false) failed. (%d)\n", rv);
+    return rv;
+  }
+
+  rv = mgr->PeekUndoStack(&u2);
 
   TEST_TXMGR_IF_RELEASE(u2); // Don't hold onto any references!
 
-  if (NS_FAILED(result)) {
-    fail("Second PeekUndoStack() failed. (%d)\n", result);
-    return result;
+  if (NS_FAILED(rv)) {
+    fail("Second PeekUndoStack() failed. (%d)\n", rv);
+    return rv;
   }
 
   if (u1 != u2) {
-    fail("Top of undo stack changed. (%d)\n", result);
+    fail("Top of undo stack changed. (%d)\n", rv);
     return NS_ERROR_FAILURE;
   }
 
-  result = mgr->PeekRedoStack(&r2);
+  rv = mgr->PeekRedoStack(&r2);
 
   TEST_TXMGR_IF_RELEASE(r2); // Don't hold onto any references!
 
-  if (NS_FAILED(result)) {
-    fail("Second PeekRedoStack() failed. (%d)\n", result);
-    return result;
+  if (NS_FAILED(rv)) {
+    fail("Second PeekRedoStack() failed. (%d)\n", rv);
+    return rv;
   }
 
   if (r1 != r2) {
-    fail("Top of redo stack changed. (%d)\n", result);
+    fail("Top of redo stack changed. (%d)\n", rv);
     return NS_ERROR_FAILURE;
   }
 
-  result = mgr->GetNumberOfUndoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->GetNumberOfUndoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfUndoItems() on undo stack with 1 item failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems != 1) {
     fail("GetNumberOfUndoItems() expected 1 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
-  result = mgr->GetNumberOfRedoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->GetNumberOfRedoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfRedoItems() on redo stack with 1 item failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems != 1) {
     fail("GetNumberOfRedoItems() expected 1 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
   passed("Test transaction DoTransaction() error");
 
   /*******************************************************************
    *
    * Test transaction UndoTransaction() error:
@@ -3733,126 +3603,119 @@ quick_batch_test(TestTransactionFactory 
 
   if (!tximpl) {
     fail("Failed to allocate transaction.\n");
     return NS_ERROR_OUT_OF_MEMORY;
   }
 
   tx     = 0;
 
-  result = tximpl->QueryInterface(NS_GET_IID(nsITransaction), (void **)&tx);
-
-  if (NS_FAILED(result)) {
-    fail("QueryInterface() failed for transaction. (%d)\n", result);
-    return result;
-  }
-
-  result = mgr->BeginBatch(nullptr);
-
-  if (NS_FAILED(result)) {
-    fail("BeginBatch(nullptr) failed. (%d)\n", result);
-    return result;
-  }
-
-  result = mgr->DoTransaction(tx);
-
-  if (NS_FAILED(result)) {
-    fail("DoTransaction() returned unexpected error. (%d)\n", result);
-    return result;
+  rv = tximpl->QueryInterface(NS_GET_IID(nsITransaction), (void **)&tx);
+  if (NS_FAILED(rv)) {
+    fail("QueryInterface() failed for transaction. (%d)\n", rv);
+    return rv;
+  }
+
+  rv = mgr->BeginBatch(nullptr);
+  if (NS_FAILED(rv)) {
+    fail("BeginBatch(nullptr) failed. (%d)\n", rv);
+    return rv;
+  }
+
+  rv = mgr->DoTransaction(tx);
+  if (NS_FAILED(rv)) {
+    fail("DoTransaction() returned unexpected error. (%d)\n", rv);
+    return rv;
   }
 
   tx->Release();
 
-  result = mgr->EndBatch(false);
-
-  if (NS_FAILED(result)) {
-    fail("EndBatch(false) failed. (%d)\n", result);
-    return result;
+  rv = mgr->EndBatch(false);
+  if (NS_FAILED(rv)) {
+    fail("EndBatch(false) failed. (%d)\n", rv);
+    return rv;
   }
 
   u1 = u2 = r1 = r2 = 0;
 
-  result = mgr->PeekUndoStack(&u1);
+  rv = mgr->PeekUndoStack(&u1);
 
   TEST_TXMGR_IF_RELEASE(u1); // Don't hold onto any references!
 
-  if (NS_FAILED(result)) {
-    fail("Initial PeekUndoStack() failed. (%d)\n", result);
-    return result;
-  }
-
-  result = mgr->PeekRedoStack(&r1);
+  if (NS_FAILED(rv)) {
+    fail("Initial PeekUndoStack() failed. (%d)\n", rv);
+    return rv;
+  }
+
+  rv = mgr->PeekRedoStack(&r1);
 
   TEST_TXMGR_IF_RELEASE(r1); // Don't hold onto any references!
 
-  if (NS_FAILED(result)) {
-    fail("Initial PeekRedoStack() failed. (%d)\n", result);
-    return result;
-  }
-
-  result = mgr->UndoTransaction();
-
-  if (result != NS_ERROR_FAILURE) {
-    fail("UndoTransaction() returned unexpected error. (%d)\n", result);
-    return result;
-  }
-
-  result = mgr->PeekUndoStack(&u2);
+  if (NS_FAILED(rv)) {
+    fail("Initial PeekRedoStack() failed. (%d)\n", rv);
+    return rv;
+  }
+
+  rv = mgr->UndoTransaction();
+  if (rv != NS_ERROR_FAILURE) {
+    fail("UndoTransaction() returned unexpected error. (%d)\n", rv);
+    return rv;
+  }
+
+  rv = mgr->PeekUndoStack(&u2);
 
   TEST_TXMGR_IF_RELEASE(u2); // Don't hold onto any references!
 
-  if (NS_FAILED(result)) {
-    fail("Second PeekUndoStack() failed. (%d)\n", result);
-    return result;
+  if (NS_FAILED(rv)) {
+    fail("Second PeekUndoStack() failed. (%d)\n", rv);
+    return rv;
   }
 
   if (u1 != u2) {
-    fail("Top of undo stack changed. (%d)\n", result);
+    fail("Top of undo stack changed. (%d)\n", rv);
     return NS_ERROR_FAILURE;
   }
 
-  result = mgr->PeekRedoStack(&r2);
+  rv = mgr->PeekRedoStack(&r2);
 
   TEST_TXMGR_IF_RELEASE(r2); // Don't hold onto any references!
 
-  if (NS_FAILED(result)) {
-    fail("Second PeekRedoStack() failed. (%d)\n", result);
-    return result;
+  if (NS_FAILED(rv)) {
+    fail("Second PeekRedoStack() failed. (%d)\n", rv);
+    return rv;
   }
 
   if (r1 != r2) {
-    fail("Top of redo stack changed. (%d)\n", result);
+    fail("Top of redo stack changed. (%d)\n", rv);
     return NS_ERROR_FAILURE;
   }
 
-  result = mgr->GetNumberOfUndoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->GetNumberOfUndoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfUndoItems() on undo stack with 2 items failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems != 2) {
     fail("GetNumberOfUndoItems() expected 2 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
-  result = mgr->GetNumberOfRedoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->GetNumberOfRedoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfRedoItems() on empty redo stack. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems) {
     fail("GetNumberOfRedoItems() expected 0 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
   passed("Test transaction UndoTransaction() error");
 
   /*******************************************************************
    *
    * Test transaction RedoTransaction() error:
@@ -3863,412 +3726,389 @@ quick_batch_test(TestTransactionFactory 
 
   if (!tximpl) {
     fail("Failed to allocate transaction.\n");
     return NS_ERROR_OUT_OF_MEMORY;
   }
 
   tx     = 0;
 
-  result = tximpl->QueryInterface(NS_GET_IID(nsITransaction), (void **)&tx);
-
-  if (NS_FAILED(result)) {
+  rv = tximpl->QueryInterface(NS_GET_IID(nsITransaction), (void **)&tx);
+  if (NS_FAILED(rv)) {
     fail("QueryInterface() failed for RedoErrorTransaction. (%d)\n",
-         result);
-    return result;
-  }
-
-  result = mgr->BeginBatch(nullptr);
-
-  if (NS_FAILED(result)) {
-    fail("BeginBatch(nullptr) failed. (%d)\n", result);
-    return result;
-  }
-
-  result = mgr->DoTransaction(tx);
-
-  if (NS_FAILED(result)) {
-    fail("DoTransaction() returned unexpected error. (%d)\n", result);
-    return result;
+         rv);
+    return rv;
+  }
+
+  rv = mgr->BeginBatch(nullptr);
+  if (NS_FAILED(rv)) {
+    fail("BeginBatch(nullptr) failed. (%d)\n", rv);
+    return rv;
+  }
+
+  rv = mgr->DoTransaction(tx);
+  if (NS_FAILED(rv)) {
+    fail("DoTransaction() returned unexpected error. (%d)\n", rv);
+    return rv;
   }
 
   tx->Release();
 
-  result = mgr->EndBatch(false);
-
-  if (NS_FAILED(result)) {
-    fail("EndBatch(false) failed. (%d)\n", result);
-    return result;
+  rv = mgr->EndBatch(false);
+  if (NS_FAILED(rv)) {
+    fail("EndBatch(false) failed. (%d)\n", rv);
+    return rv;
   }
 
   //
   // Execute a normal transaction to be used in a later test:
   //
 
   tximpl = factory->create(mgr, NONE_FLAG);
 
   if (!tximpl) {
     fail("Failed to allocate transaction.\n");
     return NS_ERROR_OUT_OF_MEMORY;
   }
 
   tx     = 0;
 
-  result = tximpl->QueryInterface(NS_GET_IID(nsITransaction), (void **)&tx);
-
-  if (NS_FAILED(result)) {
-    fail("QueryInterface() failed for transaction. (%d)\n", result);
-    return result;
-  }
-
-  result = mgr->DoTransaction(tx);
-
-  if (NS_FAILED(result)) {
-    fail("DoTransaction() returned unexpected error. (%d)\n", result);
-    return result;
+  rv = tximpl->QueryInterface(NS_GET_IID(nsITransaction), (void **)&tx);
+  if (NS_FAILED(rv)) {
+    fail("QueryInterface() failed for transaction. (%d)\n", rv);
+    return rv;
+  }
+
+  rv = mgr->DoTransaction(tx);
+  if (NS_FAILED(rv)) {
+    fail("DoTransaction() returned unexpected error. (%d)\n", rv);
+    return rv;
   }
 
   tx->Release();
 
   //
   // Undo the 2 transactions just executed.
   //
 
   for (i = 1; i <= 2; ++i) {
-    result = mgr->UndoTransaction();
-    if (NS_FAILED(result)) {
-      fail("Failed to undo transaction %d. (%d)\n", i, result);
-      return result;
+    rv = mgr->UndoTransaction();
+    if (NS_FAILED(rv)) {
+      fail("Failed to undo transaction %d. (%d)\n", i, rv);
+      return rv;
     }
   }
 
   //
   // The RedoErrorTransaction should now be at the top of the redo stack!
   //
 
   u1 = u2 = r1 = r2 = 0;
 
-  result = mgr->PeekUndoStack(&u1);
+  rv = mgr->PeekUndoStack(&u1);
 
   TEST_TXMGR_IF_RELEASE(u1); // Don't hold onto any references!
 
-  if (NS_FAILED(result)) {
-    fail("Initial PeekUndoStack() failed. (%d)\n", result);
-    return result;
-  }
-
-  result = mgr->PeekRedoStack(&r1);
+  if (NS_FAILED(rv)) {
+    fail("Initial PeekUndoStack() failed. (%d)\n", rv);
+    return rv;
+  }
+
+  rv = mgr->PeekRedoStack(&r1);
 
   TEST_TXMGR_IF_RELEASE(r1); // Don't hold onto any references!
 
-  if (NS_FAILED(result)) {
-    fail("Initial PeekRedoStack() failed. (%d)\n", result);
-    return result;
-  }
-
-  result = mgr->RedoTransaction();
-
-  if (result != NS_ERROR_FAILURE) {
-    fail("RedoTransaction() returned unexpected error. (%d)\n", result);
-    return result;
-  }
-
-  result = mgr->PeekUndoStack(&u2);
+  if (NS_FAILED(rv)) {
+    fail("Initial PeekRedoStack() failed. (%d)\n", rv);
+    return rv;
+  }
+
+  rv = mgr->RedoTransaction();
+  if (rv != NS_ERROR_FAILURE) {
+    fail("RedoTransaction() returned unexpected error. (%d)\n", rv);
+    return rv;
+  }
+
+  rv = mgr->PeekUndoStack(&u2);
 
   TEST_TXMGR_IF_RELEASE(u2); // Don't hold onto any references!
 
-  if (NS_FAILED(result)) {
-    fail("Second PeekUndoStack() failed. (%d)\n", result);
-    return result;
+  if (NS_FAILED(rv)) {
+    fail("Second PeekUndoStack() failed. (%d)\n", rv);
+    return rv;
   }
 
   if (u1 != u2) {
-    fail("Top of undo stack changed. (%d)\n", result);
+    fail("Top of undo stack changed. (%d)\n", rv);
     return NS_ERROR_FAILURE;
   }
 
-  result = mgr->PeekRedoStack(&r2);
+  rv = mgr->PeekRedoStack(&r2);
 
   TEST_TXMGR_IF_RELEASE(r2); // Don't hold onto any references!
 
-  if (NS_FAILED(result)) {
-    fail("Second PeekRedoStack() failed. (%d)\n", result);
-    return result;
+  if (NS_FAILED(rv)) {
+    fail("Second PeekRedoStack() failed. (%d)\n", rv);
+    return rv;
   }
 
   if (r1 != r2) {
-    fail("Top of redo stack changed. (%d)\n", result);
+    fail("Top of redo stack changed. (%d)\n", rv);
     return NS_ERROR_FAILURE;
   }
 
-  result = mgr->GetNumberOfUndoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->GetNumberOfUndoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfUndoItems() on undo stack with 2 items failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems != 2) {
     fail("GetNumberOfUndoItems() expected 2 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
-  result = mgr->GetNumberOfRedoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->GetNumberOfRedoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfRedoItems() on redo stack with 2 items failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems != 2) {
     fail("GetNumberOfRedoItems() expected 2 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
   passed("Test transaction RedoTransaction() error");
 
   /*******************************************************************
    *
    * Make sure that setting the transaction manager's max transaction
    * count to zero, clears both the undo and redo stacks, and executes
    * all new commands without pushing them on the undo stack!
    *
    *******************************************************************/
 
-  result = mgr->SetMaxTransactionCount(0);
-
-  if (NS_FAILED(result)) {
-    fail("SetMaxTransactionCount(0) failed. (%d)\n", result);
-    return result;
-  }
-
-  result = mgr->GetNumberOfUndoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->SetMaxTransactionCount(0);
+  if (NS_FAILED(rv)) {
+    fail("SetMaxTransactionCount(0) failed. (%d)\n", rv);
+    return rv;
+  }
+
+  rv = mgr->GetNumberOfUndoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfUndoItems() on empty undo stack failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems) {
     fail("GetNumberOfUndoItems() expected 0 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
-  result = mgr->GetNumberOfRedoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->GetNumberOfRedoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfRedoItems() on empty redo stack failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems) {
     fail("GetNumberOfRedoItems() expected 0 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
   for (i = 1; i <= 20; i++) {
     tximpl = factory->create(mgr, NONE_FLAG);
 
     if (!tximpl) {
       fail("Failed to allocate transaction %d.\n", i);
       return NS_ERROR_OUT_OF_MEMORY;
     }
 
     tx = 0;
-    result = tximpl->QueryInterface(NS_GET_IID(nsITransaction), (void **)&tx);
-    if (NS_FAILED(result)) {
+    rv = tximpl->QueryInterface(NS_GET_IID(nsITransaction), (void **)&tx);
+    if (NS_FAILED(rv)) {
       fail("QueryInterface() failed for transaction %d. (%d)\n",
-           i, result);
-      return result;
+           i, rv);
+      return rv;
     }
 
-    result = mgr->BeginBatch(nullptr);
-
-    if (NS_FAILED(result)) {
-      fail("BeginBatch(nullptr) failed. (%d)\n", result);
-      return result;
+    rv = mgr->BeginBatch(nullptr);
+    if (NS_FAILED(rv)) {
+      fail("BeginBatch(nullptr) failed. (%d)\n", rv);
+      return rv;
     }
 
-    result = mgr->DoTransaction(tx);
-    if (NS_FAILED(result)) {
-      fail("Failed to execute transaction %d. (%d)\n", i, result);
-      return result;
+    rv = mgr->DoTransaction(tx);
+    if (NS_FAILED(rv)) {
+      fail("Failed to execute transaction %d. (%d)\n", i, rv);
+      return rv;
     }
 
     tx->Release();
 
-    result = mgr->EndBatch(false);
-
-    if (NS_FAILED(result)) {
-      fail("EndBatch(false) failed. (%d)\n", result);
-      return result;
+    rv = mgr->EndBatch(false);
+    if (NS_FAILED(rv)) {
+      fail("EndBatch(false) failed. (%d)\n", rv);
+      return rv;
     }
 
-    result = mgr->GetNumberOfUndoItems(&numitems);
-
-    if (NS_FAILED(result)) {
+    rv = mgr->GetNumberOfUndoItems(&numitems);
+    if (NS_FAILED(rv)) {
       fail("GetNumberOfUndoItems() on empty undo stack failed. (%d)\n",
-           result);
-      return result;
+           rv);
+      return rv;
     }
 
     if (numitems) {
       fail("GetNumberOfUndoItems() expected 0 got %d. (%d)\n",
-           numitems, result);
+           numitems, rv);
       return NS_ERROR_FAILURE;
     }
 
-    result = mgr->GetNumberOfRedoItems(&numitems);
-
-    if (NS_FAILED(result)) {
+    rv = mgr->GetNumberOfRedoItems(&numitems);
+    if (NS_FAILED(rv)) {
       fail("GetNumberOfRedoItems() on empty redo stack failed. (%d)\n",
-           result);
-      return result;
+           rv);
+      return rv;
     }
 
     if (numitems) {
       fail("GetNumberOfRedoItems() expected 0 got %d. (%d)\n",
-           numitems, result);
+           numitems, rv);
       return NS_ERROR_FAILURE;
     }
   }
 
   passed("Test max transaction count of zero");
 
   /*******************************************************************
    *
    * Release the transaction manager. Any transactions on the undo
    * and redo stack should automatically be released:
    *
    *******************************************************************/
 
-  result = mgr->SetMaxTransactionCount(-1);
-
-  if (NS_FAILED(result)) {
-    fail("SetMaxTransactionCount(0) failed. (%d)\n", result);
-    return result;
+  rv = mgr->SetMaxTransactionCount(-1);
+  if (NS_FAILED(rv)) {
+    fail("SetMaxTransactionCount(0) failed. (%d)\n", rv);
+    return rv;
   }
 
   // Push 20 transactions on the undo stack:
 
   for (i = 1; i <= 20; i++) {
     tximpl = factory->create(mgr, NONE_FLAG);
 
     if (!tximpl) {
       fail("Failed to allocate transaction %d.\n", i);
       return NS_ERROR_OUT_OF_MEMORY;
     }
 
     tx = 0;
-    result = tximpl->QueryInterface(NS_GET_IID(nsITransaction), (void **)&tx);
-    if (NS_FAILED(result)) {
+    rv = tximpl->QueryInterface(NS_GET_IID(nsITransaction), (void **)&tx);
+    if (NS_FAILED(rv)) {
       fail("QueryInterface() failed for transaction %d. (%d)\n",
-           i, result);
-      return result;
+           i, rv);
+      return rv;
     }
 
-    result = mgr->BeginBatch(nullptr);
-
-    if (NS_FAILED(result)) {
-      fail("BeginBatch(nullptr) failed. (%d)\n", result);
-      return result;
+    rv = mgr->BeginBatch(nullptr);
+    if (NS_FAILED(rv)) {
+      fail("BeginBatch(nullptr) failed. (%d)\n", rv);
+      return rv;
     }
 
-    result = mgr->DoTransaction(tx);
-    if (NS_FAILED(result)) {
-      fail("Failed to execute transaction %d. (%d)\n", i, result);
-      return result;
+    rv = mgr->DoTransaction(tx);
+    if (NS_FAILED(rv)) {
+      fail("Failed to execute transaction %d. (%d)\n", i, rv);
+      return rv;
     }
 
     tx->Release();
 
-    result = mgr->EndBatch(false);
-
-    if (NS_FAILED(result)) {
-      fail("EndBatch(false) failed. (%d)\n", result);
-      return result;
+    rv = mgr->EndBatch(false);
+    if (NS_FAILED(rv)) {
+      fail("EndBatch(false) failed. (%d)\n", rv);
+      return rv;
     }
 
-    result = mgr->GetNumberOfUndoItems(&numitems);
-
-    if (NS_FAILED(result)) {
+    rv = mgr->GetNumberOfUndoItems(&numitems);
+    if (NS_FAILED(rv)) {
       fail("GetNumberOfUndoItems() on undo stack with %d items failed. (%d)\n",
-           i, result);
-      return result;
+           i, rv);
+      return rv;
     }
 
     if (numitems != i) {
       fail("GetNumberOfUndoItems() expected %d got %d. (%d)\n",
-           i, numitems, result);
+           i, numitems, rv);
       return NS_ERROR_FAILURE;
     }
 
-    result = mgr->GetNumberOfRedoItems(&numitems);
-
-    if (NS_FAILED(result)) {
+    rv = mgr->GetNumberOfRedoItems(&numitems);
+    if (NS_FAILED(rv)) {
       fail("GetNumberOfRedoItems() on empty redo stack failed. (%d)\n",
-           result);
-      return result;
+           rv);
+      return rv;
     }
 
     if (numitems) {
       fail("GetNumberOfRedoItems() expected 0 got %d. (%d)\n",
-           numitems, result);
+           numitems, rv);
       return NS_ERROR_FAILURE;
     }
   }
 
   for (i = 1; i <= 10; i++) {
-
-    result = mgr->UndoTransaction();
-    if (NS_FAILED(result)) {
-      fail("Failed to undo transaction %d. (%d)\n", i, result);
-      return result;
+    rv = mgr->UndoTransaction();
+    if (NS_FAILED(rv)) {
+      fail("Failed to undo transaction %d. (%d)\n", i, rv);
+      return rv;
     }
   }
-  result = mgr->GetNumberOfUndoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+
+  rv = mgr->GetNumberOfUndoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfUndoItems() on empty undo stack with 10 items failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems != 10) {
     fail("GetNumberOfUndoItems() expected 10 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
-  result = mgr->GetNumberOfRedoItems(&numitems);
-
-  if (NS_FAILED(result)) {
+  rv = mgr->GetNumberOfRedoItems(&numitems);
+  if (NS_FAILED(rv)) {
     fail("GetNumberOfRedoItems() on redo stack with 10 items failed. (%d)\n",
-         result);
-    return result;
+         rv);
+    return rv;
   }
 
   if (numitems != 10) {
     fail("GetNumberOfRedoItems() expected 10 got %d. (%d)\n",
-         numitems, result);
+         numitems, rv);
     return NS_ERROR_FAILURE;
   }
 
-  result = mgr->Clear();
-  if (NS_FAILED(result)) {
-    fail("Clear() failed. (%d)\n", result);
-    return result;
+  rv = mgr->Clear();
+  if (NS_FAILED(rv)) {
+    fail("Clear() failed. (%d)\n", rv);
+    return rv;
   }
 
   passed("Release the transaction manager");
 
   /*******************************************************************
    *
    * Make sure number of transactions created matches number of
    * transactions destroyed!
@@ -4354,27 +4194,26 @@ aggregation_batch_test()
  * do/undo/redo/undo them.
  **/
 nsresult
 stress_test(TestTransactionFactory *factory, int32_t iterations)
 {
   printf("Stress test of %i iterations (may take a while) ... ", iterations);
   fflush(stdout);
 
-  nsresult result;
-
   /*******************************************************************
    *
    * Create a transaction manager:
    *
    *******************************************************************/
 
+  nsresult rv;
   nsCOMPtr<nsITransactionManager> mgr =
-    do_CreateInstance(NS_TRANSACTIONMANAGER_CONTRACTID, &result);
-  if (NS_FAILED(result) || !mgr) {
+    do_CreateInstance(NS_TRANSACTIONMANAGER_CONTRACTID, &rv);
+  if (NS_FAILED(rv) || !mgr) {
     fail("Failed to create Transaction Manager instance.\n");
     return NS_ERROR_OUT_OF_MEMORY;
   }
 
   int32_t i, j;
   nsITransaction *tx;
 
   for (i = 1; i <= iterations; i++) {
@@ -4388,89 +4227,89 @@ stress_test(TestTransactionFactory *fact
       TestTransaction *tximpl = factory->create(mgr, NONE_FLAG);
 
       if (!tximpl) {
         fail("Failed to allocate transaction %d-%d.\n", i, j);
         return NS_ERROR_OUT_OF_MEMORY;
       }
 
       tx = 0;
-      result = tximpl->QueryInterface(NS_GET_IID(nsITransaction), (void **)&tx);
-      if (NS_FAILED(result)) {
+      rv = tximpl->QueryInterface(NS_GET_IID(nsITransaction), (void **)&tx);
+      if (NS_FAILED(rv)) {
         fail("QueryInterface() failed for transaction %d-%d. (%d)\n",
-             i, j, result);
-        return result;
+             i, j, rv);
+        return rv;
       }
 
-      result = mgr->DoTransaction(tx);
-      if (NS_FAILED(result)) {
+      rv = mgr->DoTransaction(tx);
+      if (NS_FAILED(rv)) {
         fail("Failed to execute transaction %d-%d. (%d)\n",
-             i, j, result);
-        return result;
+             i, j, rv);
+        return rv;
       }
 
       tx->Release();
     }
 
     /*******************************************************************
      *
      * Undo all the transactions:
      *
      *******************************************************************/
 
     for (j = 1; j <= i; j++) {
-      result = mgr->UndoTransaction();
-      if (NS_FAILED(result)) {
-        fail("Failed to undo transaction %d-%d. (%d)\n", i, j, result);
-        return result;
+      rv = mgr->UndoTransaction();
+      if (NS_FAILED(rv)) {
+        fail("Failed to undo transaction %d-%d. (%d)\n", i, j, rv);
+        return rv;
       }
     }
 
     /*******************************************************************
      *
      * Redo all the transactions:
      *
      *******************************************************************/
 
     for (j = 1; j <= i; j++) {
-      result = mgr->RedoTransaction();
-      if (NS_FAILED(result)) {
-        fail("Failed to redo transaction %d-%d. (%d)\n", i, j, result);
-        return result;
+      rv = mgr->RedoTransaction();
+      if (NS_FAILED(rv)) {
+        fail("Failed to redo transaction %d-%d. (%d)\n", i, j, rv);
+        return rv;
       }
     }
 
     /*******************************************************************
      *
      * Undo all the transactions again so that they all end up on
      * the redo stack for pruning the next time we execute a new
      * transaction
      *
      *******************************************************************/
 
     for (j = 1; j <= i; j++) {
-      result = mgr->UndoTransaction();
-      if (NS_FAILED(result)) {
-        fail("Failed to undo transaction %d-%d. (%d)\n", i, j, result);
-        return result;
+      rv = mgr->UndoTransaction();
+      if (NS_FAILED(rv)) {
+        fail("Failed to undo transaction %d-%d. (%d)\n", i, j, rv);
+        return rv;
       }
     }
 
     // Trivial feedback not to let the user think the test is stuck.
     if (MOZ_UNLIKELY(j % 100 == 0)) {
       printf("%i ", j);
     }
   } // for, iterations.
 
   printf("passed\n");
 
-  result = mgr->Clear();
-  if (NS_FAILED(result)) {
-    fail("Clear() failed. (%d)\n", result);
-    return result;
+  rv = mgr->Clear();
+  if (NS_FAILED(rv)) {
+    fail("Clear() failed. (%d)\n", rv);
+    return rv;
   }
 
   /* Disabled because the current cycle collector doesn't delete
      cycle collectable objects synchronously.
   if (sConstructorCount != sDestructorCount) {
     fail("Transaction constructor count (%d) != destructor count (%d).\n",
          sConstructorCount, sDestructorCount);
     return NS_ERROR_FAILURE;
@@ -4597,45 +4436,43 @@ aggregation_batch_stress_test()
 int
 main (int argc, char *argv[])
 {
   ScopedXPCOM xpcom("nsITransactionManager");
   if (xpcom.failed()) {
     return 1;
   }
 
-  nsresult result;
-
   //
   // quick_test() part:
   //
 
-  result = simple_test();
-  NS_ENSURE_SUCCESS(result, 1);
-
-  result = aggregation_test();
-  NS_ENSURE_SUCCESS(result, 1);
+  nsresult rv = simple_test();
+  NS_ENSURE_SUCCESS(rv, 1);
+
+  rv = aggregation_test();
+  NS_ENSURE_SUCCESS(rv, 1);
 
   //
   // quick_batch_test() part:
   //
 
-  result = simple_batch_test();
-  NS_ENSURE_SUCCESS(result, 1);
-
-  result = aggregation_batch_test();
-  NS_ENSURE_SUCCESS(result, 1);
+  rv = simple_batch_test();
+  NS_ENSURE_SUCCESS(rv, 1);
+
+  rv = aggregation_batch_test();
+  NS_ENSURE_SUCCESS(rv, 1);
 
   //
   // stress_test() part:
   //
 
-  result = simple_stress_test();
-  NS_ENSURE_SUCCESS(result, 1);
-
-  result = aggregation_stress_test();
-  NS_ENSURE_SUCCESS(result, 1);
-
-  result = aggregation_batch_stress_test();
-  NS_ENSURE_SUCCESS(result, 1);
+  rv = simple_stress_test();
+  NS_ENSURE_SUCCESS(rv, 1);
+
+  rv = aggregation_stress_test();
+  NS_ENSURE_SUCCESS(rv, 1);
+
+  rv = aggregation_batch_stress_test();
+  NS_ENSURE_SUCCESS(rv, 1);
 
   return 0;
 }