--- a/editor/composer/src/nsComposerCommands.cpp
+++ b/editor/composer/src/nsComposerCommands.cpp
@@ -114,17 +114,17 @@ nsBaseStateUpdatingCommand::IsCommandEna
 }
 
 
 NS_IMETHODIMP
 nsBaseStateUpdatingCommand::DoCommand(const char *aCommandName,
                                       nsISupports *refCon)
 {
   nsCOMPtr<nsIEditor> editor = do_QueryInterface(refCon);
-  if (!editor) return NS_ERROR_NOT_INITIALIZED;
+  NS_ENSURE_TRUE(editor, NS_ERROR_NOT_INITIALIZED);
 
   return ToggleState(editor, mTagName);
 }
 
 NS_IMETHODIMP
 nsBaseStateUpdatingCommand::DoCommandParams(const char *aCommandName,
                                             nsICommandParams *aParams,
                                             nsISupports *refCon)
@@ -211,17 +211,17 @@ nsStyleUpdatingCommand::nsStyleUpdatingC
 
 nsresult
 nsStyleUpdatingCommand::GetCurrentState(nsIEditor *aEditor, 
                                         const char* aTagName,
                                         nsICommandParams *aParams)
 {
   NS_ASSERTION(aEditor, "Need editor here");
   nsCOMPtr<nsIHTMLEditor> htmlEditor = do_QueryInterface(aEditor);
-  if (!htmlEditor) return NS_ERROR_NOT_INITIALIZED;
+  NS_ENSURE_TRUE(htmlEditor, NS_ERROR_NOT_INITIALIZED);
   
   nsresult rv = NS_OK;
 
   PRBool firstOfSelectionHasProp = PR_FALSE;
   PRBool anyOfSelectionHasProp = PR_FALSE;
   PRBool allOfSelectionHasProp = PR_FALSE;
 
   nsCOMPtr<nsIAtom> styleAtom = do_GetAtom(aTagName);
@@ -396,17 +396,17 @@ nsListItemCommand::GetCurrentState(nsIEd
   return NS_OK;
 }
 
 nsresult
 nsListItemCommand::ToggleState(nsIEditor *aEditor, const char* aTagName)
 {
   NS_ASSERTION(aEditor, "Need editor here");
   nsCOMPtr<nsIHTMLEditor> htmlEditor = do_QueryInterface(aEditor);
-  if (!htmlEditor) return NS_ERROR_NOT_INITIALIZED;
+  NS_ENSURE_TRUE(htmlEditor, NS_ERROR_NOT_INITIALIZED);
 
   PRBool inList;
   // Need to use mTagName????
   nsresult rv;
   nsCOMPtr<nsICommandParams> params =
       do_CreateInstance(NS_COMMAND_PARAMS_CONTRACTID,&rv);
   if (NS_FAILED(rv) || !params)
     return rv;
@@ -694,17 +694,17 @@ nsParagraphStateCommand::nsParagraphStat
 
 nsresult
 nsParagraphStateCommand::GetCurrentState(nsIEditor *aEditor,
                                          nsICommandParams *aParams)
 {
   NS_ASSERTION(aEditor, "Need an editor here");
   
   nsCOMPtr<nsIHTMLEditor> htmlEditor = do_QueryInterface(aEditor);
-  if (!htmlEditor) return NS_ERROR_FAILURE;
+  NS_ENSURE_TRUE(htmlEditor, NS_ERROR_FAILURE);
 
   PRBool outMixed;
   nsAutoString outStateString;
   nsresult rv = htmlEditor->GetParagraphState(&outMixed, outStateString);
   if (NS_SUCCEEDED(rv))
   {
     nsCAutoString tOutStateString;
     tOutStateString.AssignWithConversion(outStateString);
@@ -715,17 +715,17 @@ nsParagraphStateCommand::GetCurrentState
 }
 
 
 nsresult
 nsParagraphStateCommand::SetState(nsIEditor *aEditor, nsString& newState)
 {
   NS_ASSERTION(aEditor, "Need an editor here");
   nsCOMPtr<nsIHTMLEditor> htmlEditor = do_QueryInterface(aEditor);
-  if (!htmlEditor) return NS_ERROR_FAILURE;
+  NS_ENSURE_TRUE(htmlEditor, NS_ERROR_FAILURE);
 
   return htmlEditor->SetParagraphFormat(newState);
 }
 
 #ifdef XP_MAC
 #pragma mark -
 #endif
 
@@ -735,17 +735,17 @@ nsFontFaceStateCommand::nsFontFaceStateC
 }
 
 nsresult
 nsFontFaceStateCommand::GetCurrentState(nsIEditor *aEditor,
                                         nsICommandParams *aParams)
 {
   NS_ASSERTION(aEditor, "Need an editor here");
   nsCOMPtr<nsIHTMLEditor> htmlEditor = do_QueryInterface(aEditor);
-  if (!htmlEditor) return NS_ERROR_FAILURE;
+  NS_ENSURE_TRUE(htmlEditor, NS_ERROR_FAILURE);
 
   nsAutoString outStateString;
   PRBool outMixed;
   nsresult rv = htmlEditor->GetFontFaceState(&outMixed, outStateString);
   if (NS_SUCCEEDED(rv))
   {
     aParams->SetBooleanValue(STATE_MIXED,outMixed);
     aParams->SetCStringValue(STATE_ATTRIBUTE, NS_ConvertUTF16toUTF8(outStateString).get());
@@ -754,17 +754,17 @@ nsFontFaceStateCommand::GetCurrentState(
 }
 
 
 nsresult
 nsFontFaceStateCommand::SetState(nsIEditor *aEditor, nsString& newState)
 {
   NS_ASSERTION(aEditor, "Need an editor here");
   nsCOMPtr<nsIHTMLEditor> htmlEditor = do_QueryInterface(aEditor);
-  if (!htmlEditor) return NS_ERROR_FAILURE;
+  NS_ENSURE_TRUE(htmlEditor, NS_ERROR_FAILURE);
   
   nsresult rv;
   nsCOMPtr<nsIAtom> ttAtom = do_GetAtom("tt");
   nsCOMPtr<nsIAtom> fontAtom = do_GetAtom("font");
 
   if (newState.EqualsLiteral("tt"))
   {
     // The old "teletype" attribute  
@@ -801,17 +801,17 @@ nsFontSizeStateCommand::nsFontSizeStateC
 //  nsCAutoString tOutStateString;
 //  tOutStateString.AssignWithConversion(outStateString);
 nsresult
 nsFontSizeStateCommand::GetCurrentState(nsIEditor *aEditor,
                                         nsICommandParams *aParams)
 {
   NS_ASSERTION(aEditor, "Need an editor here");
   nsCOMPtr<nsIHTMLEditor> htmlEditor = do_QueryInterface(aEditor);
-  if (!htmlEditor) return NS_ERROR_INVALID_ARG;
+  NS_ENSURE_TRUE(htmlEditor, NS_ERROR_INVALID_ARG);
 
   nsAutoString outStateString;
   nsCOMPtr<nsIAtom> fontAtom = do_GetAtom("font");
   PRBool firstHas, anyHas, allHas;
   nsresult rv = htmlEditor->GetInlinePropertyWithAttrValue(fontAtom,
                                          NS_LITERAL_STRING("size"),
                                          EmptyString(),
                                          &firstHas, &anyHas, &allHas,
@@ -837,17 +837,17 @@ nsFontSizeStateCommand::GetCurrentState(
 //   +3
 //   medium
 //   normal
 nsresult
 nsFontSizeStateCommand::SetState(nsIEditor *aEditor, nsString& newState)
 {
   NS_ASSERTION(aEditor, "Need an editor here");
   nsCOMPtr<nsIHTMLEditor> htmlEditor = do_QueryInterface(aEditor);
-  if (!htmlEditor) return NS_ERROR_INVALID_ARG;
+  NS_ENSURE_TRUE(htmlEditor, NS_ERROR_INVALID_ARG);
 
   nsresult rv;
   nsCOMPtr<nsIAtom> fontAtom = do_GetAtom("font");
   if (newState.IsEmpty() || 
       newState.EqualsLiteral("normal") ||
       newState.EqualsLiteral("medium")) {
     // remove any existing font size, big or small
     rv = htmlEditor->RemoveInlineProperty(fontAtom, NS_LITERAL_STRING("size"));  
@@ -879,17 +879,17 @@ nsFontColorStateCommand::nsFontColorStat
 
 nsresult
 nsFontColorStateCommand::GetCurrentState(nsIEditor *aEditor,
                                          nsICommandParams *aParams)
 {
   NS_ASSERTION(aEditor, "Need an editor here");
   
   nsCOMPtr<nsIHTMLEditor> htmlEditor = do_QueryInterface(aEditor);
-  if (!htmlEditor) return NS_ERROR_FAILURE;
+  NS_ENSURE_TRUE(htmlEditor, NS_ERROR_FAILURE);
 
   PRBool outMixed;
   nsAutoString outStateString;
   nsresult rv = htmlEditor->GetFontColorState(&outMixed, outStateString);
   if (NS_SUCCEEDED(rv))
   {
     nsCAutoString tOutStateString;
     tOutStateString.AssignWithConversion(outStateString);
@@ -899,17 +899,17 @@ nsFontColorStateCommand::GetCurrentState
   return rv;
 }
 
 nsresult
 nsFontColorStateCommand::SetState(nsIEditor *aEditor, nsString& newState)
 {
   NS_ASSERTION(aEditor, "Need an editor here");
   nsCOMPtr<nsIHTMLEditor> htmlEditor = do_QueryInterface(aEditor);
-  if (!htmlEditor) return NS_ERROR_FAILURE;
+  NS_ENSURE_TRUE(htmlEditor, NS_ERROR_FAILURE);
   
   nsresult rv;
   nsCOMPtr<nsIAtom> fontAtom = do_GetAtom("font");
 
   if (newState.IsEmpty() || newState.EqualsLiteral("normal")) {
     rv = htmlEditor->RemoveInlineProperty(fontAtom, NS_LITERAL_STRING("color"));
   } else {
     rv = htmlEditor->SetInlineProperty(fontAtom, NS_LITERAL_STRING("color"), 
@@ -929,17 +929,17 @@ nsHighlightColorStateCommand::nsHighligh
 }
 
 nsresult
 nsHighlightColorStateCommand::GetCurrentState(nsIEditor *aEditor,
                                               nsICommandParams *aParams)
 {
   NS_ASSERTION(aEditor, "Need an editor here");
   nsCOMPtr<nsIHTMLEditor> htmlEditor = do_QueryInterface(aEditor);
-  if (!htmlEditor) return NS_ERROR_FAILURE;
+  NS_ENSURE_TRUE(htmlEditor, NS_ERROR_FAILURE);
 
   PRBool outMixed;
   nsAutoString outStateString;
   nsresult rv = htmlEditor->GetHighlightColorState(&outMixed, outStateString);
   if (NS_SUCCEEDED(rv))
   {
     nsCAutoString tOutStateString;
     tOutStateString.AssignWithConversion(outStateString);
@@ -949,17 +949,17 @@ nsHighlightColorStateCommand::GetCurrent
   return rv;
 }
 
 nsresult
 nsHighlightColorStateCommand::SetState(nsIEditor *aEditor, nsString& newState)
 {
   NS_ASSERTION(aEditor, "Need an editor here");
   nsCOMPtr<nsIHTMLEditor> htmlEditor = do_QueryInterface(aEditor);
-  if (!htmlEditor) return NS_ERROR_FAILURE;
+  NS_ENSURE_TRUE(htmlEditor, NS_ERROR_FAILURE);
 
   nsresult rv;
   nsCOMPtr<nsIAtom> fontAtom = do_GetAtom("font");
 
   if (newState.IsEmpty() || newState.EqualsLiteral("normal")) {
 //    rv = RemoveOneProperty(htmlEditor, NS_LITERAL_STRING("font"), NS_LITERAL_STRING("bgcolor"));
     rv = htmlEditor->RemoveInlineProperty(fontAtom, NS_LITERAL_STRING("bgcolor"));
   } else {
@@ -992,17 +992,17 @@ nsBackgroundColorStateCommand::nsBackgro
 
 nsresult
 nsBackgroundColorStateCommand::GetCurrentState(nsIEditor *aEditor,
                                                nsICommandParams *aParams)
 {
   NS_ASSERTION(aEditor, "Need an editor here");
   
   nsCOMPtr<nsIHTMLEditor> htmlEditor = do_QueryInterface(aEditor);
-  if (!htmlEditor) return NS_ERROR_FAILURE;
+  NS_ENSURE_TRUE(htmlEditor, NS_ERROR_FAILURE);
 
   PRBool outMixed;
   nsAutoString outStateString;
   nsresult rv =  htmlEditor->GetBackgroundColorState(&outMixed, outStateString);
   if (NS_SUCCEEDED(rv))
   {
     nsCAutoString tOutStateString;
     tOutStateString.AssignWithConversion(outStateString);
@@ -1013,17 +1013,17 @@ nsBackgroundColorStateCommand::GetCurren
 }
 
 nsresult
 nsBackgroundColorStateCommand::SetState(nsIEditor *aEditor, nsString& newState)
 {
   NS_ASSERTION(aEditor, "Need an editor here");
   
   nsCOMPtr<nsIHTMLEditor> htmlEditor = do_QueryInterface(aEditor);
-  if (!htmlEditor) return NS_ERROR_FAILURE;
+  NS_ENSURE_TRUE(htmlEditor, NS_ERROR_FAILURE);
 
   return htmlEditor->SetBackgroundColor(newState);
 }
 
 #ifdef XP_MAC
 #pragma mark -
 #endif
 
@@ -1033,17 +1033,17 @@ nsAlignCommand::nsAlignCommand()
 }
 
 nsresult
 nsAlignCommand::GetCurrentState(nsIEditor *aEditor, nsICommandParams *aParams)
 {
   NS_ASSERTION(aEditor, "Need an editor here");
   
   nsCOMPtr<nsIHTMLEditor> htmlEditor = do_QueryInterface(aEditor);
-  if (!htmlEditor) return NS_ERROR_FAILURE;
+  NS_ENSURE_TRUE(htmlEditor, NS_ERROR_FAILURE);
  
   nsIHTMLEditor::EAlignment firstAlign;
   PRBool outMixed;
   nsresult rv = htmlEditor->GetAlignment(&outMixed, &firstAlign);
   
   if (NS_FAILED(rv)) 
     return rv;
   
@@ -1075,17 +1075,17 @@ nsAlignCommand::GetCurrentState(nsIEdito
 }
 
 nsresult
 nsAlignCommand::SetState(nsIEditor *aEditor, nsString& newState)
 {
   NS_ASSERTION(aEditor, "Need an editor here");
   
   nsCOMPtr<nsIHTMLEditor> htmlEditor = do_QueryInterface(aEditor);
-  if (!htmlEditor) return NS_ERROR_FAILURE;
+  NS_ENSURE_TRUE(htmlEditor, NS_ERROR_FAILURE);
 
   return htmlEditor->Align(newState);
 }
 
 
 #ifdef XP_MAC
 #pragma mark -
 #endif
@@ -1099,29 +1099,29 @@ nsAbsolutePositioningCommand::nsAbsolute
 NS_IMETHODIMP
 nsAbsolutePositioningCommand::IsCommandEnabled(const char * aCommandName,
                                                nsISupports *aCommandRefCon,
                                                PRBool *_retval)
 {
   NS_ASSERTION(aCommandRefCon, "Need an editor here");
   
   nsCOMPtr<nsIHTMLAbsPosEditor> htmlEditor = do_QueryInterface(aCommandRefCon);
-  if (!htmlEditor) return NS_ERROR_FAILURE;
+  NS_ENSURE_TRUE(htmlEditor, NS_ERROR_FAILURE);
 
   htmlEditor->GetAbsolutePositioningEnabled(_retval);
   return NS_OK;
 }
 
 nsresult
 nsAbsolutePositioningCommand::GetCurrentState(nsIEditor *aEditor, const char* aTagName, nsICommandParams *aParams)
 {
   NS_ASSERTION(aEditor, "Need an editor here");
   
   nsCOMPtr<nsIHTMLAbsPosEditor> htmlEditor = do_QueryInterface(aEditor);
-  if (!htmlEditor) return NS_ERROR_FAILURE;
+  NS_ENSURE_TRUE(htmlEditor, NS_ERROR_FAILURE);
 
   PRBool isEnabled;
   htmlEditor->GetAbsolutePositioningEnabled(&isEnabled);
   if (!isEnabled) {
     aParams->SetBooleanValue(STATE_MIXED,PR_FALSE);
     aParams->SetCStringValue(STATE_ATTRIBUTE, "");
     return NS_OK;
   }
@@ -1141,17 +1141,17 @@ nsAbsolutePositioningCommand::GetCurrent
 }
 
 nsresult
 nsAbsolutePositioningCommand::ToggleState(nsIEditor *aEditor, const char* aTagName)
 {
   NS_ASSERTION(aEditor, "Need an editor here");
   
   nsCOMPtr<nsIHTMLAbsPosEditor> htmlEditor = do_QueryInterface(aEditor);
-  if (!htmlEditor) return NS_ERROR_FAILURE;
+  NS_ENSURE_TRUE(htmlEditor, NS_ERROR_FAILURE);
 
   nsCOMPtr<nsIDOMElement>  elt;
   nsresult rv = htmlEditor->GetAbsolutelyPositionedSelectionContainer(getter_AddRefs(elt));
   NS_ENSURE_SUCCESS(rv, rv);
 
   if (elt) {
     // we have to remove positioning on an element
     rv = htmlEditor->AbsolutePositionSelection(PR_FALSE);
@@ -1168,17 +1168,17 @@ nsAbsolutePositioningCommand::ToggleStat
 #endif
 
 NS_IMETHODIMP
 nsDecreaseZIndexCommand::IsCommandEnabled(const char * aCommandName,
                                           nsISupports *refCon,
                                           PRBool *outCmdEnabled)
 {
   nsCOMPtr<nsIHTMLAbsPosEditor> htmlEditor = do_QueryInterface(refCon);
-  if (!htmlEditor) return NS_ERROR_FAILURE;
+  NS_ENSURE_TRUE(htmlEditor, NS_ERROR_FAILURE);
 
   htmlEditor->GetAbsolutePositioningEnabled(outCmdEnabled);
   if (!(*outCmdEnabled))
     return NS_OK;
 
   nsCOMPtr<nsIDOMElement> positionedElement;
   htmlEditor->GetPositionedElement(getter_AddRefs(positionedElement));
   *outCmdEnabled = PR_FALSE;
@@ -1230,17 +1230,17 @@ nsDecreaseZIndexCommand::GetCommandState
 #endif
 
 NS_IMETHODIMP
 nsIncreaseZIndexCommand::IsCommandEnabled(const char * aCommandName,
                                           nsISupports *refCon,
                                           PRBool *outCmdEnabled)
 {
   nsCOMPtr<nsIHTMLAbsPosEditor> htmlEditor = do_QueryInterface(refCon);
-  if (!htmlEditor) return NS_ERROR_FAILURE;
+  NS_ENSURE_TRUE(htmlEditor, NS_ERROR_FAILURE);
 
   htmlEditor->GetAbsolutePositioningEnabled(outCmdEnabled);
   if (!(*outCmdEnabled))
     return NS_OK;
 
   nsCOMPtr<nsIDOMElement> positionedElement;
   htmlEditor->GetPositionedElement(getter_AddRefs(positionedElement));
   *outCmdEnabled = (nsnull != positionedElement);

--- a/editor/composer/src/nsComposerCommandsUpdater.cpp
+++ b/editor/composer/src/nsComposerCommandsUpdater.cpp
@@ -299,17 +299,17 @@ nsComposerCommandsUpdater::UpdateDirtySt
   
   return NS_OK;  
 }
 
 nsresult
 nsComposerCommandsUpdater::UpdateCommandGroup(const nsAString& aCommandGroup)
 {
   nsCOMPtr<nsPICommandUpdater> commandUpdater = GetCommandUpdater();
-  if (!commandUpdater) return NS_ERROR_FAILURE;
+  NS_ENSURE_TRUE(commandUpdater, NS_ERROR_FAILURE);
 
   
   // This hardcoded list of commands is temporary.
   // This code should use nsIControllerCommandGroup.
   if (aCommandGroup.EqualsLiteral("undo"))
   {
     commandUpdater->CommandStatusChanged("cmd_undo");
     commandUpdater->CommandStatusChanged("cmd_redo");
@@ -353,17 +353,17 @@ nsComposerCommandsUpdater::UpdateCommand
   }
   return NS_OK;  
 }
 
 nsresult
 nsComposerCommandsUpdater::UpdateOneCommand(const char *aCommand)
 {
   nsCOMPtr<nsPICommandUpdater> commandUpdater = GetCommandUpdater();
-  if (!commandUpdater) return NS_ERROR_FAILURE;
+  NS_ENSURE_TRUE(commandUpdater, NS_ERROR_FAILURE);
 
   commandUpdater->CommandStatusChanged(aCommand);
 
   return NS_OK;  
 }
 
 PRBool
 nsComposerCommandsUpdater::SelectionIsCollapsed()

--- a/editor/composer/src/nsComposerController.cpp
+++ b/editor/composer/src/nsComposerController.cpp
@@ -41,50 +41,50 @@
 #include "nsIControllerCommandTable.h"
 #include "nsComposerController.h"
 #include "nsComposerCommands.h"
 
 #define NS_REGISTER_ONE_COMMAND(_cmdClass, _cmdName)                    \
   {                                                                     \
     _cmdClass* theCmd;                                                  \
     NS_NEWXPCOM(theCmd, _cmdClass);                                     \
-    if (!theCmd) return NS_ERROR_OUT_OF_MEMORY;                         \
+    NS_ENSURE_TRUE(theCmd, NS_ERROR_OUT_OF_MEMORY);                         \
     rv = inCommandTable->RegisterCommand(_cmdName,                      \
                        static_cast<nsIControllerCommand *>(theCmd));    \
   }
 
 #define NS_REGISTER_FIRST_COMMAND(_cmdClass, _cmdName)                  \
   {                                                                     \
     _cmdClass* theCmd;                                                  \
     NS_NEWXPCOM(theCmd, _cmdClass);                                     \
-    if (!theCmd) return NS_ERROR_OUT_OF_MEMORY;                         \
+    NS_ENSURE_TRUE(theCmd, NS_ERROR_OUT_OF_MEMORY);                         \
     rv = inCommandTable->RegisterCommand(_cmdName,                      \
                        static_cast<nsIControllerCommand *>(theCmd));
 
 #define NS_REGISTER_NEXT_COMMAND(_cmdClass, _cmdName)                   \
     rv = inCommandTable->RegisterCommand(_cmdName,                      \
                         static_cast<nsIControllerCommand *>(theCmd));
 
 #define NS_REGISTER_LAST_COMMAND(_cmdClass, _cmdName)                   \
     rv = inCommandTable->RegisterCommand(_cmdName,                      \
                        static_cast<nsIControllerCommand *>(theCmd));    \
   }
 
 #define NS_REGISTER_STYLE_COMMAND(_cmdClass, _cmdName, _styleTag)       \
   {                                                                     \
     _cmdClass* theCmd = new _cmdClass(_styleTag);                       \
-    if (!theCmd) return NS_ERROR_OUT_OF_MEMORY;                         \
+    NS_ENSURE_TRUE(theCmd, NS_ERROR_OUT_OF_MEMORY);                         \
     rv = inCommandTable->RegisterCommand(_cmdName,                      \
                        static_cast<nsIControllerCommand *>(theCmd));    \
   }
   
 #define NS_REGISTER_TAG_COMMAND(_cmdClass, _cmdName, _tagName)          \
   {                                                                     \
     _cmdClass* theCmd = new _cmdClass(_tagName);                        \
-    if (!theCmd) return NS_ERROR_OUT_OF_MEMORY;                         \
+    NS_ENSURE_TRUE(theCmd, NS_ERROR_OUT_OF_MEMORY);                         \
     rv = inCommandTable->RegisterCommand(_cmdName,                      \
                        static_cast<nsIControllerCommand *>(theCmd));    \
   }
   
 
 // static
 nsresult
 nsComposerController::RegisterEditorDocStateCommands(

--- a/editor/composer/src/nsComposerDocumentCommands.cpp
+++ b/editor/composer/src/nsComposerDocumentCommands.cpp
@@ -72,20 +72,20 @@ GetPresContextFromEditor(nsIEditor *aEdi
 {
   NS_ENSURE_ARG_POINTER(aResult);
   *aResult = nsnull;
   NS_ENSURE_ARG_POINTER(aEditor);
 
   nsCOMPtr<nsISelectionController> selCon;
   nsresult rv = aEditor->GetSelectionController(getter_AddRefs(selCon));
   NS_ENSURE_SUCCESS(rv, rv);
-  if (!selCon) return NS_ERROR_FAILURE;
+  NS_ENSURE_TRUE(selCon, NS_ERROR_FAILURE);
 
   nsCOMPtr<nsIPresShell> presShell = do_QueryInterface(selCon);
-  if (!presShell) return NS_ERROR_FAILURE;
+  NS_ENSURE_TRUE(presShell, NS_ERROR_FAILURE);
 
   NS_IF_ADDREF(*aResult = presShell->GetPresContext());
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsSetDocumentOptionsCommand::IsCommandEnabled(const char * aCommandName,
                                               nsISupports *refCon,
@@ -107,42 +107,42 @@ nsSetDocumentOptionsCommand::DoCommand(c
 NS_IMETHODIMP
 nsSetDocumentOptionsCommand::DoCommandParams(const char *aCommandName,
                                              nsICommandParams *aParams,
                                              nsISupports *refCon)
 {
   NS_ENSURE_ARG_POINTER(aParams);
 
   nsCOMPtr<nsIEditor> editor = do_QueryInterface(refCon);
-  if (!editor) return NS_ERROR_INVALID_ARG;
+  NS_ENSURE_TRUE(editor, NS_ERROR_INVALID_ARG);
 
   nsRefPtr<nsPresContext> presContext;
   nsresult rv = GetPresContextFromEditor(editor, getter_AddRefs(presContext));
   NS_ENSURE_SUCCESS(rv, rv);
-  if (!presContext) return NS_ERROR_FAILURE;
+  NS_ENSURE_TRUE(presContext, NS_ERROR_FAILURE);
 
   PRInt32 animationMode; 
   rv = aParams->GetLongValue("imageAnimation", &animationMode);
   if (NS_SUCCEEDED(rv))
   {
     // for possible values of animation mode, see:
     // http://lxr.mozilla.org/seamonkey/source/modules/libpr0n/public/imgIContainer.idl
     presContext->SetImageAnimationMode(animationMode);
   }
 
   PRBool allowPlugins; 
   rv = aParams->GetBooleanValue("plugins", &allowPlugins);
   if (NS_SUCCEEDED(rv))
   {
     nsCOMPtr<nsISupports> container = presContext->GetContainer();
-    if (!container) return NS_ERROR_FAILURE;
+    NS_ENSURE_TRUE(container, NS_ERROR_FAILURE);
 
     nsCOMPtr<nsIDocShell> docShell(do_QueryInterface(container, &rv));
     NS_ENSURE_SUCCESS(rv, rv);
-    if (!docShell) return NS_ERROR_FAILURE;
+    NS_ENSURE_TRUE(docShell, NS_ERROR_FAILURE);
 
     rv = docShell->SetAllowPlugins(allowPlugins);
     NS_ENSURE_SUCCESS(rv, rv);
   }
 
   return NS_OK;
 }
 
@@ -151,29 +151,29 @@ nsSetDocumentOptionsCommand::GetCommandS
                                                    nsICommandParams *aParams,
                                                    nsISupports *refCon)
 {
   NS_ENSURE_ARG_POINTER(aParams);
   NS_ENSURE_ARG_POINTER(refCon);
 
   // The base editor owns most state info
   nsCOMPtr<nsIEditor> editor = do_QueryInterface(refCon);
-  if (!editor) return NS_ERROR_INVALID_ARG;
+  NS_ENSURE_TRUE(editor, NS_ERROR_INVALID_ARG);
 
   // Always get the enabled state
   PRBool outCmdEnabled = PR_FALSE;
   IsCommandEnabled(aCommandName, refCon, &outCmdEnabled);
   nsresult rv = aParams->SetBooleanValue(STATE_ENABLED, outCmdEnabled);
   NS_ENSURE_SUCCESS(rv, rv);
 
   // get pres context
   nsRefPtr<nsPresContext> presContext;
   rv = GetPresContextFromEditor(editor, getter_AddRefs(presContext));
   NS_ENSURE_SUCCESS(rv, rv);
-  if (!presContext) return NS_ERROR_FAILURE;
+  NS_ENSURE_TRUE(presContext, NS_ERROR_FAILURE);
 
   PRInt32 animationMode;
   rv = aParams->GetLongValue("imageAnimation", &animationMode);
   if (NS_SUCCEEDED(rv))
   {
     // for possible values of animation mode, see
     // http://lxr.mozilla.org/seamonkey/source/modules/libpr0n/public/imgIContainer.idl
     rv = aParams->SetLongValue("imageAnimation",
@@ -181,21 +181,21 @@ nsSetDocumentOptionsCommand::GetCommandS
     NS_ENSURE_SUCCESS(rv, rv);
   }
 
   PRBool allowPlugins; 
   rv = aParams->GetBooleanValue("plugins", &allowPlugins);
   if (NS_SUCCEEDED(rv))
   {
     nsCOMPtr<nsISupports> container = presContext->GetContainer();
-    if (!container) return NS_ERROR_FAILURE;
+    NS_ENSURE_TRUE(container, NS_ERROR_FAILURE);
 
     nsCOMPtr<nsIDocShell> docShell(do_QueryInterface(container, &rv));
     NS_ENSURE_SUCCESS(rv, rv);
-    if (!docShell) return NS_ERROR_FAILURE;
+    NS_ENSURE_TRUE(docShell, NS_ERROR_FAILURE);
 
     rv = docShell->GetAllowPlugins(&allowPlugins);
     NS_ENSURE_SUCCESS(rv, rv);
 
     rv = aParams->SetBooleanValue("plugins", allowPlugins);
     NS_ENSURE_SUCCESS(rv, rv);
   }
 
@@ -449,17 +449,17 @@ nsSetDocumentStateCommand::GetCommandSta
  *
  *  3. Add the observer by:
  *       commandManager.addObserver(observeobject, obs_documentCreated);
  *  4. In the appropriate location in editorSession, editor, or commands code, 
  *     trigger the notification of this observer by something like:
  *
  *  nsCOMPtr<nsICommandManager> commandManager = do_GetInterface(mDocShell);
  *  nsCOMPtr<nsPICommandUpdater> commandUpdater = do_QueryInterface(commandManager);
- *  if (!commandUpdater) return NS_ERROR_FAILURE;
+ *  NS_ENSURE_TRUE(commandUpdater, NS_ERROR_FAILURE);
  *    commandUpdater->CommandStatusChanged(obs_documentCreated);
  *
  *  5. Use GetCommandStateParams() to obtain state information
  *     e.g., any creation state codes when creating an editor are 
  *     supplied for "obs_documentCreated" command in the 
  *     "state_data" param's value
  *
  */
@@ -534,20 +534,20 @@ nsDocumentStateCommand::GetCommandStateP
   else if (!nsCRT::strcmp(aCommandName, "obs_documentLocationChanged"))
   {
     nsCOMPtr<nsIEditor> editor = do_QueryInterface(refCon);
     if (editor)
     {
       nsCOMPtr<nsIDOMDocument> domDoc;
       editor->GetDocument(getter_AddRefs(domDoc));
       nsCOMPtr<nsIDocument> doc = do_QueryInterface(domDoc);
-      if (!doc) return NS_ERROR_FAILURE;
+      NS_ENSURE_TRUE(doc, NS_ERROR_FAILURE);
 
       nsIURI *uri = doc->GetDocumentURI();
-      if (!uri) return NS_ERROR_FAILURE;
+      NS_ENSURE_TRUE(uri, NS_ERROR_FAILURE);
 
       return aParams->SetISupportsValue(STATE_DATA, (nsISupports*)uri);
     }
     return NS_OK;
   }  
 
   return NS_ERROR_NOT_IMPLEMENTED;
 }

--- a/editor/composer/src/nsEditingSession.cpp
+++ b/editor/composer/src/nsEditingSession.cpp
@@ -144,17 +144,17 @@ nsEditingSession::MakeWindowEditable(nsI
                                      PRBool aInteractive)
 {
   mEditorType.Truncate();
   mEditorFlags = 0;
   mWindowToBeEdited = do_GetWeakReference(aWindow);
 
   // disable plugins
   nsIDocShell *docShell = GetDocShellFromWindow(aWindow);
-  if (!docShell) return NS_ERROR_FAILURE;
+  NS_ENSURE_TRUE(docShell, NS_ERROR_FAILURE);
 
   mInteractive = aInteractive;
   mMakeWholeDocumentEditable = aMakeWholeDocumentEditable;
 
   nsresult rv;
   if (!mInteractive) {
     rv = DisableJSAndPlugins(aWindow);
     NS_ENSURE_SUCCESS(rv, rv);
@@ -214,17 +214,17 @@ nsEditingSession::MakeWindowEditable(nsI
   }
   return rv;
 }
 
 NS_IMETHODIMP
 nsEditingSession::DisableJSAndPlugins(nsIDOMWindow *aWindow)
 {
   nsIDocShell *docShell = GetDocShellFromWindow(aWindow);
-  if (!docShell) return NS_ERROR_FAILURE;
+  NS_ENSURE_TRUE(docShell, NS_ERROR_FAILURE);
 
   PRBool tmp;
   nsresult rv = docShell->GetAllowJavascript(&tmp);
   NS_ENSURE_SUCCESS(rv, rv);
 
   mScriptsEnabled = tmp;
 
   rv = docShell->SetAllowJavascript(PR_FALSE);
@@ -248,17 +248,17 @@ NS_IMETHODIMP
 nsEditingSession::RestoreJSAndPlugins(nsIDOMWindow *aWindow)
 {
   if (!mDisabledJSAndPlugins)
     return NS_OK;
 
   mDisabledJSAndPlugins = PR_FALSE;
 
   nsIDocShell *docShell = GetDocShellFromWindow(aWindow);
-  if (!docShell) return NS_ERROR_FAILURE;
+  NS_ENSURE_TRUE(docShell, NS_ERROR_FAILURE);
 
   nsresult rv = docShell->SetAllowJavascript(mScriptsEnabled);
   NS_ENSURE_SUCCESS(rv, rv);
 
   // Disable plugins in this document:
   return docShell->SetAllowPlugins(mPluginsEnabled);
 }
 
@@ -424,22 +424,22 @@ nsEditingSession::SetupEditorOnWindow(ns
   {
     mStateMaintainer->NotifyDocumentCreated();
     return NS_ERROR_FAILURE;
   }
 
   // Create editor and do other things 
   //  only if we haven't found some error above,
   nsIDocShell *docShell = GetDocShellFromWindow(aWindow);
-  if (!docShell) return NS_ERROR_FAILURE;  
+  NS_ENSURE_TRUE(docShell, NS_ERROR_FAILURE);  
 
   if (!mInteractive) {
     // Disable animation of images in this document:
     nsCOMPtr<nsIDOMWindowUtils> utils(do_GetInterface(aWindow));
-    if (!utils) return NS_ERROR_FAILURE;
+    NS_ENSURE_TRUE(utils, NS_ERROR_FAILURE);
 
     rv = utils->GetImageAnimationMode(&mImageAnimationMode);
     NS_ENSURE_SUCCESS(rv, rv);
     utils->SetImageAnimationMode(imgIContainer::kDontAnimMode);
   }
 
   // create and set editor
   nsCOMPtr<nsIEditorDocShell> editorDocShell = do_QueryInterface(docShell, &rv);
@@ -463,43 +463,43 @@ nsEditingSession::SetupEditorOnWindow(ns
 
   // Set mimetype on editor
   rv = editor->SetContentsMIMEType(mimeCType.get());
   NS_ENSURE_SUCCESS(rv, rv);
 
   nsCOMPtr<nsIContentViewer> contentViewer;
   rv = docShell->GetContentViewer(getter_AddRefs(contentViewer));
   NS_ENSURE_SUCCESS(rv, rv);
-  if (!contentViewer) return NS_ERROR_FAILURE;
+  NS_ENSURE_TRUE(contentViewer, NS_ERROR_FAILURE);
 
   nsCOMPtr<nsIDOMDocument> domDoc;  
   rv = contentViewer->GetDOMDocument(getter_AddRefs(domDoc));
   NS_ENSURE_SUCCESS(rv, rv);
-  if (!domDoc) return NS_ERROR_FAILURE;
+  NS_ENSURE_TRUE(domDoc, NS_ERROR_FAILURE);
 
   // Set up as a doc state listener
   // Important! We must have this to broadcast the "obs_documentCreated" message
   rv = editor->AddDocumentStateListener(mStateMaintainer);
   NS_ENSURE_SUCCESS(rv, rv);
 
   // XXXbz we really shouldn't need a presShell here!
   nsCOMPtr<nsIPresShell> presShell;
   rv = docShell->GetPresShell(getter_AddRefs(presShell));
   NS_ENSURE_SUCCESS(rv, rv);
-  if (!presShell) return NS_ERROR_FAILURE;
+  NS_ENSURE_TRUE(presShell, NS_ERROR_FAILURE);
 
   nsCOMPtr<nsISelectionController> selCon = do_QueryInterface(presShell);
   rv = editor->Init(domDoc, presShell, nsnull /* root content */,
                     selCon, mEditorFlags);
   NS_ENSURE_SUCCESS(rv, rv);
 
   nsCOMPtr<nsISelection> selection;
   editor->GetSelection(getter_AddRefs(selection));
   nsCOMPtr<nsISelectionPrivate> selPriv = do_QueryInterface(selection);
-  if (!selPriv) return NS_ERROR_FAILURE;
+  NS_ENSURE_TRUE(selPriv, NS_ERROR_FAILURE);
 
   rv = selPriv->AddSelectionListener(mStateMaintainer);
   NS_ENSURE_SUCCESS(rv, rv);
 
   // and as a transaction listener
   nsCOMPtr<nsITransactionManager> txnMgr;
   editor->GetTransactionManager(getter_AddRefs(txnMgr));
   if (txnMgr)
@@ -839,29 +839,29 @@ nsEditingSession::OnLocationChange(nsIWe
   nsresult rv = aWebProgress->GetDOMWindow(getter_AddRefs(domWindow));
   NS_ENSURE_SUCCESS(rv, rv);
 
   nsCOMPtr<nsIDOMDocument> domDoc;
   rv = domWindow->GetDocument(getter_AddRefs(domDoc));
   NS_ENSURE_SUCCESS(rv, rv);
 
   nsCOMPtr<nsIDocument> doc = do_QueryInterface(domDoc);
-  if (!doc) return NS_ERROR_FAILURE;
+  NS_ENSURE_TRUE(doc, NS_ERROR_FAILURE);
 
   doc->SetDocumentURI(aURI);
 
   // Notify the location-changed observer that
   //  the document URL has changed
   nsIDocShell *docShell = GetDocShellFromWindow(domWindow);
-  if (!docShell) return NS_ERROR_FAILURE;
+  NS_ENSURE_TRUE(docShell, NS_ERROR_FAILURE);
 
   nsCOMPtr<nsICommandManager> commandManager = do_GetInterface(docShell);
   nsCOMPtr<nsPICommandUpdater> commandUpdater =
                                   do_QueryInterface(commandManager);
-  if (!commandUpdater) return NS_ERROR_FAILURE;
+  NS_ENSURE_TRUE(commandUpdater, NS_ERROR_FAILURE);
 
   return commandUpdater->CommandStatusChanged("obs_documentLocationChanged");
 }
 
 /*---------------------------------------------------------------------------
 
   OnStatusChange
 
@@ -948,17 +948,17 @@ nsEditingSession::StartDocumentLoad(nsIW
   
   // If we have an editor here, then we got a reload after making the editor.
   // We need to blow it away and make a new one at the end of the load.
   nsCOMPtr<nsIDOMWindow> domWindow;
   aWebProgress->GetDOMWindow(getter_AddRefs(domWindow));
   if (domWindow)
   {
     nsIDocShell *docShell = GetDocShellFromWindow(domWindow);
-    if (!docShell) return NS_ERROR_FAILURE;
+    NS_ENSURE_TRUE(docShell, NS_ERROR_FAILURE);
     docShell->DetachEditorFromWindow();
   }
     
   if (aIsToBeMadeEditable)
     mEditorStatus = eEditorCreationInProgress;
 
   return NS_OK;
 }
@@ -998,17 +998,17 @@ nsEditingSession::EndDocumentLoad(nsIWeb
   // Set the error state -- we will create an editor 
   // anyway and load empty doc later
   if (aIsToBeMadeEditable) {
     if (aStatus == NS_ERROR_FILE_NOT_FOUND)
       mEditorStatus = eEditorErrorFileNotFound;
   }
 
   nsIDocShell *docShell = GetDocShellFromWindow(domWindow);
-  if (!docShell) return NS_ERROR_FAILURE;       // better error handling?
+  NS_ENSURE_TRUE(docShell, NS_ERROR_FAILURE);       // better error handling?
 
   // cancel refresh from meta tags
   // we need to make sure that all pages in editor (whether editable or not)
   // can't refresh contents being edited
   nsCOMPtr<nsIRefreshURI> refreshURI = do_QueryInterface(docShell);
   if (refreshURI)
     refreshURI->CancelRefreshURITimers();
 
@@ -1129,17 +1129,17 @@ nsEditingSession::EndPageLoad(nsIWebProg
   // and load empty doc later
   if (aStatus == NS_ERROR_FILE_NOT_FOUND)
     mEditorStatus = eEditorErrorFileNotFound;
 
   nsCOMPtr<nsIDOMWindow> domWindow;
   aWebProgress->GetDOMWindow(getter_AddRefs(domWindow));
 
   nsIDocShell *docShell = GetDocShellFromWindow(domWindow);
-  if (!docShell) return NS_ERROR_FAILURE;
+  NS_ENSURE_TRUE(docShell, NS_ERROR_FAILURE);
 
   // cancel refresh from meta tags
   // we need to make sure that all pages in editor (whether editable or not)
   // can't refresh contents being edited
   nsCOMPtr<nsIRefreshURI> refreshURI = do_QueryInterface(docShell);
   if (refreshURI)
     refreshURI->CancelRefreshURITimers();
 
@@ -1179,17 +1179,17 @@ nsEditingSession::GetDocShellFromWindow(
   Utility method. This will always return an error if no docShell
   is returned.
 ----------------------------------------------------------------------------*/
 nsresult
 nsEditingSession::GetEditorDocShellFromWindow(nsIDOMWindow *aWindow,
                                               nsIEditorDocShell** outDocShell)
 {
   nsIDocShell *docShell = GetDocShellFromWindow(aWindow);
-  if (!docShell) return NS_ERROR_FAILURE;
+  NS_ENSURE_TRUE(docShell, NS_ERROR_FAILURE);
   
   return docShell->QueryInterface(NS_GET_IID(nsIEditorDocShell), 
                                   (void **)outDocShell);
 }
 
 /*---------------------------------------------------------------------------
 
   PrepareForEditing
@@ -1201,17 +1201,17 @@ nsEditingSession::PrepareForEditing(nsID
 {
   if (mProgressListenerRegistered)
     return NS_OK;
     
   nsIDocShell *docShell = GetDocShellFromWindow(aWindow);
   
   // register callback
   nsCOMPtr<nsIWebProgress> webProgress = do_GetInterface(docShell);
-  if (!webProgress) return NS_ERROR_FAILURE;
+  NS_ENSURE_TRUE(webProgress, NS_ERROR_FAILURE);
 
   nsresult rv =
     webProgress->AddProgressListener(this,
                                      (nsIWebProgress::NOTIFY_STATE_NETWORK  | 
                                       nsIWebProgress::NOTIFY_STATE_DOCUMENT |
                                       nsIWebProgress::NOTIFY_LOCATION));
 
   mProgressListenerRegistered = NS_SUCCEEDED(rv);
@@ -1323,17 +1323,17 @@ nsEditingSession::SetContextOnController
 
   // aContext can be null (when destroying editor)
   nsCOMPtr<nsIController> controller;    
   aControllers->GetControllerById(aID, getter_AddRefs(controller));
   
   // ok with nil controller
   nsCOMPtr<nsIControllerContext> editorController =
                                        do_QueryInterface(controller);
-  if (!editorController) return NS_ERROR_FAILURE;
+  NS_ENSURE_TRUE(editorController, NS_ERROR_FAILURE);
 
   return editorController->SetCommandContext(aContext);
 }
 
 void
 nsEditingSession::RemoveEditorControllers(nsIDOMWindow *aWindow)
 {
   // Remove editor controllers from the aWindow, call when we're 
@@ -1479,17 +1479,17 @@ nsEditingSession::ReattachToWindow(nsIDO
   rv = GetEditorForWindow(aWindow, getter_AddRefs(editor));
   if (!editor)
     return NS_ERROR_FAILURE;
 
   if (!mInteractive)
   {
     // Disable animation of images in this document:
     nsCOMPtr<nsIDOMWindowUtils> utils(do_GetInterface(aWindow));
-    if (!utils) return NS_ERROR_FAILURE;
+    NS_ENSURE_TRUE(utils, NS_ERROR_FAILURE);
 
     rv = utils->GetImageAnimationMode(&mImageAnimationMode);
     NS_ENSURE_SUCCESS(rv, rv);
     utils->SetImageAnimationMode(imgIContainer::kDontAnimMode);
   }
 
   // The third controller takes an nsIEditor as the context
   rv = SetupEditorCommandController("@mozilla.org/editor/htmleditorcontroller;1",

--- a/editor/libeditor/base/ChangeCSSInlineStyleTxn.cpp
+++ b/editor/libeditor/base/ChangeCSSInlineStyleTxn.cpp
@@ -171,22 +171,22 @@ NS_IMETHODIMP ChangeCSSInlineStyleTxn::I
 }
 
 NS_IMETHODIMP ChangeCSSInlineStyleTxn::DoTransaction(void)
 {
   NS_ASSERTION(mEditor && mElement, "bad state");
   if (!mEditor || !mElement) { return NS_ERROR_NOT_INITIALIZED; }
 
   nsCOMPtr<nsIDOMElementCSSInlineStyle> inlineStyles = do_QueryInterface(mElement);
-  if (!inlineStyles) return NS_ERROR_NULL_POINTER;
+  NS_ENSURE_TRUE(inlineStyles, NS_ERROR_NULL_POINTER);
 
   nsCOMPtr<nsIDOMCSSStyleDeclaration> cssDecl;
   nsresult result = inlineStyles->GetStyle(getter_AddRefs(cssDecl));
   NS_ENSURE_SUCCESS(result, result);
-  if (!cssDecl) return NS_ERROR_NULL_POINTER;
+  NS_ENSURE_TRUE(cssDecl, NS_ERROR_NULL_POINTER);
 
   nsAutoString propertyNameString;
   mProperty->ToString(propertyNameString);
 
   NS_NAMED_LITERAL_STRING(styleAttr, "style");
   result = mElement->HasAttribute(styleAttr, &mUndoAttributeWasSet);
   NS_ENSURE_SUCCESS(result, result);
 
@@ -268,21 +268,21 @@ nsresult ChangeCSSInlineStyleTxn::SetSty
 
   nsresult result;
   if (aAttributeWasSet) {
     // the style attribute was set and not empty, let's recreate the declaration
     nsAutoString propertyNameString;
     mProperty->ToString(propertyNameString);
 
     nsCOMPtr<nsIDOMElementCSSInlineStyle> inlineStyles = do_QueryInterface(mElement);
-    if (!inlineStyles) return NS_ERROR_NULL_POINTER;
+    NS_ENSURE_TRUE(inlineStyles, NS_ERROR_NULL_POINTER);
     nsCOMPtr<nsIDOMCSSStyleDeclaration> cssDecl;
     result = inlineStyles->GetStyle(getter_AddRefs(cssDecl));
     NS_ENSURE_SUCCESS(result, result);
-    if (!cssDecl) return NS_ERROR_NULL_POINTER;
+    NS_ENSURE_TRUE(cssDecl, NS_ERROR_NULL_POINTER);
 
     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

--- a/editor/libeditor/base/CreateElementTxn.cpp
+++ b/editor/libeditor/base/CreateElementTxn.cpp
@@ -104,31 +104,31 @@ NS_IMETHODIMP CreateElementTxn::DoTransa
     char* nodename = ToNewCString(mTag);
     printf("Do Create Element parent = %p <%s>, offset = %d\n", 
            static_cast<void*>(mParent.get()), nodename, mOffsetInParent);
     nsMemory::Free(nodename);
   }
 #endif
 
   NS_ASSERTION(mEditor && mParent, "bad state");
-  if (!mEditor || !mParent) return NS_ERROR_NOT_INITIALIZED;
+  NS_ENSURE_TRUE(mEditor && mParent, NS_ERROR_NOT_INITIALIZED);
 
   nsCOMPtr<nsIContent> newContent;
  
   //new call to use instead to get proper HTML element, bug# 39919
   nsresult result = mEditor->CreateHTMLContent(mTag, getter_AddRefs(newContent));
   NS_ENSURE_SUCCESS(result, result);
   nsCOMPtr<nsIDOMElement>newElement = do_QueryInterface(newContent);
-  if (!newElement) return NS_ERROR_NULL_POINTER;
+  NS_ENSURE_TRUE(newElement, NS_ERROR_NULL_POINTER);
   mNewNode = do_QueryInterface(newElement);
   // Try to insert formatting whitespace for the new node:
   mEditor->MarkNodeDirty(mNewNode);
  
   NS_ASSERTION(((NS_SUCCEEDED(result)) && (mNewNode)), "could not create element.");
-  if (!mNewNode) return NS_ERROR_NULL_POINTER;
+  NS_ENSURE_TRUE(mNewNode, NS_ERROR_NULL_POINTER);
 
 #ifdef NS_DEBUG
   if (gNoisy)
   {
     printf("  newNode = %p\n", static_cast<void*>(mNewNode.get()));
   }
 #endif
 
@@ -157,17 +157,17 @@ NS_IMETHODIMP CreateElementTxn::DoTransa
       // only set selection to insertion point if editor gives permission
       PRBool bAdjustSelection;
       mEditor->ShouldTxnSetSelection(&bAdjustSelection);
       if (bAdjustSelection)
       {
         nsCOMPtr<nsISelection> selection;
         result = mEditor->GetSelection(getter_AddRefs(selection));
         NS_ENSURE_SUCCESS(result, result);
-        if (!selection) return NS_ERROR_NULL_POINTER;
+        NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
 
         PRInt32 offset=0;
         result = nsEditor::GetChildOffset(mNewNode, mParent, offset);
         NS_ENSURE_SUCCESS(result, result);
 
         result = selection->Collapse(mParent, offset+1);
         NS_ASSERTION((NS_SUCCEEDED(result)), "selection could not be collapsed after insert.");
        }
@@ -187,30 +187,30 @@ NS_IMETHODIMP CreateElementTxn::UndoTran
   {
     printf("Undo Create Element, mParent = %p, node = %p\n",
            static_cast<void*>(mParent.get()),
            static_cast<void*>(mNewNode.get()));
   }
 #endif
 
   NS_ASSERTION(mEditor && mParent, "bad state");
-  if (!mEditor || !mParent) return NS_ERROR_NOT_INITIALIZED;
+  NS_ENSURE_TRUE(mEditor && mParent, NS_ERROR_NOT_INITIALIZED);
 
   nsCOMPtr<nsIDOMNode> resultNode;
   return mParent->RemoveChild(mNewNode, getter_AddRefs(resultNode));
 }
 
 NS_IMETHODIMP CreateElementTxn::RedoTransaction(void)
 {
 #ifdef NS_DEBUG
   if (gNoisy) { printf("Redo Create Element\n"); }
 #endif
 
   NS_ASSERTION(mEditor && mParent, "bad state");
-  if (!mEditor || !mParent) return NS_ERROR_NOT_INITIALIZED;
+  NS_ENSURE_TRUE(mEditor && mParent, NS_ERROR_NOT_INITIALIZED);
 
   // first, reset mNewNode so it has no attributes or content
   nsCOMPtr<nsIDOMCharacterData>nodeAsText = do_QueryInterface(mNewNode);
   if (nodeAsText)
   {
     nodeAsText->SetData(EmptyString());
   }
   

--- a/editor/libeditor/base/DeleteElementTxn.cpp
+++ b/editor/libeditor/base/DeleteElementTxn.cpp
@@ -74,17 +74,17 @@ NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
 
 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(DeleteElementTxn)
 NS_INTERFACE_MAP_END_INHERITING(EditTxn)
 
 NS_IMETHODIMP DeleteElementTxn::Init(nsIEditor *aEditor,
                                      nsIDOMNode *aElement,
                                      nsRangeUpdater *aRangeUpdater)
 {
-  if (!aEditor || !aElement) return NS_ERROR_NULL_POINTER;
+  NS_ENSURE_TRUE(aEditor && aElement, NS_ERROR_NULL_POINTER);
   mEditor = aEditor;
   mElement = do_QueryInterface(aElement);
   nsresult result = mElement->GetParentNode(getter_AddRefs(mParent));
   if (NS_FAILED(result)) { return result; }
 
   // do nothing if the parent is read-only
   if (mParent && !mEditor->IsModifiableNode(mParent)) {
     return NS_ERROR_FAILURE;
@@ -101,17 +101,17 @@ NS_IMETHODIMP DeleteElementTxn::DoTransa
   if (gNoisy)
   {
     printf("%p Do Delete Element element = %p\n",
            static_cast<void*>(this),
            static_cast<void*>(mElement.get()));
   }
 #endif
 
-  if (!mElement) return NS_ERROR_NOT_INITIALIZED;
+  NS_ENSURE_TRUE(mElement, NS_ERROR_NOT_INITIALIZED);
 
   if (!mParent) { return NS_OK; }  // this is a no-op, there's no parent to delete mElement from
 
 #ifdef NS_DEBUG
   // begin debug output
   nsCOMPtr<nsIDOMElement> element = do_QueryInterface(mElement);
   nsAutoString elementTag(NS_LITERAL_STRING("text node"));
   if (element)

--- a/editor/libeditor/base/DeleteRangeTxn.cpp
+++ b/editor/libeditor/base/DeleteRangeTxn.cpp
@@ -201,17 +201,17 @@ NS_IMETHODIMP DeleteRangeTxn::DoTransact
   // only set selection to deletion point if editor gives permission
   PRBool bAdjustSelection;
   mEditor->ShouldTxnSetSelection(&bAdjustSelection);
   if (bAdjustSelection)
   {
     nsCOMPtr<nsISelection> selection;
     result = mEditor->GetSelection(getter_AddRefs(selection));
     NS_ENSURE_SUCCESS(result, result);
-    if (!selection) return NS_ERROR_NULL_POINTER;
+    NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
     result = selection->Collapse(mStartParent, mStartOffset);
   }
   else
   {
     // do nothing - dom range gravity will adjust selection
   }
 
   return result;
@@ -270,30 +270,30 @@ DeleteRangeTxn::CreateTxnsToDeleteBetwee
     if (NS_SUCCEEDED(result))
       AppendChild(txn);
   }
   else
   {
     nsCOMPtr<nsIDOMNodeList> children;
     result = aStartParent->GetChildNodes(getter_AddRefs(children));
     NS_ENSURE_SUCCESS(result, result);
-    if (!children) return NS_ERROR_NULL_POINTER;
+    NS_ENSURE_TRUE(children, NS_ERROR_NULL_POINTER);
 
 #ifdef DEBUG
     PRUint32 childCount;
     children->GetLength(&childCount);
     NS_ASSERTION(aEndOffset<=childCount, "bad aEndOffset");
 #endif
     PRUint32 i;
     for (i=aStartOffset; i<aEndOffset; i++)
     {
       nsCOMPtr<nsIDOMNode> child;
       result = children->Item(i, getter_AddRefs(child));
       NS_ENSURE_SUCCESS(result, result);
-      if (!child) return NS_ERROR_NULL_POINTER;
+      NS_ENSURE_TRUE(child, NS_ERROR_NULL_POINTER);
 
       nsRefPtr<DeleteElementTxn> txn = new DeleteElementTxn();
       if (!txn)
         return NS_ERROR_OUT_OF_MEMORY;
 
       result = txn->Init(mEditor, child, mRangeUpdater);
       if (NS_SUCCEEDED(result))
         AppendChild(txn);
@@ -337,17 +337,17 @@ NS_IMETHODIMP DeleteRangeTxn::CreateTxns
   }
 
   return result;
 }
 
 NS_IMETHODIMP DeleteRangeTxn::CreateTxnsToDeleteNodesBetween()
 {
   nsCOMPtr<nsIContentIterator> iter = do_CreateInstance("@mozilla.org/content/subtree-content-iterator;1");
-  if (!iter) return NS_ERROR_NULL_POINTER;
+  NS_ENSURE_TRUE(iter, NS_ERROR_NULL_POINTER);
 
   nsresult result = iter->Init(mRange);
   NS_ENSURE_SUCCESS(result, result);
 
   while (!iter->IsDone() && NS_SUCCEEDED(result))
   {
     nsCOMPtr<nsIDOMNode> node = do_QueryInterface(iter->GetCurrentNode());
     if (!node)

--- a/editor/libeditor/base/DeleteTextTxn.cpp
+++ b/editor/libeditor/base/DeleteTextTxn.cpp
@@ -115,17 +115,17 @@ NS_IMETHODIMP DeleteTextTxn::DoTransacti
   // only set selection to deletion point if editor gives permission
   PRBool bAdjustSelection;
   mEditor->ShouldTxnSetSelection(&bAdjustSelection);
   if (bAdjustSelection)
   {
     nsCOMPtr<nsISelection> selection;
     result = mEditor->GetSelection(getter_AddRefs(selection));
     NS_ENSURE_SUCCESS(result, result);
-    if (!selection) return NS_ERROR_NULL_POINTER;
+    NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
     result = selection->Collapse(mElement, mOffset);
     NS_ASSERTION((NS_SUCCEEDED(result)), "selection could not be collapsed after undo of deletetext.");
   }
   else
   {
     // do nothing - dom range gravity will adjust selection
   }
   return result;

--- a/editor/libeditor/base/IMETextTxn.cpp
+++ b/editor/libeditor/base/IMETextTxn.cpp
@@ -96,17 +96,17 @@ NS_IMETHODIMP IMETextTxn::Init(nsIDOMCha
 NS_IMETHODIMP IMETextTxn::DoTransaction(void)
 {
 
 #ifdef DEBUG_IMETXN
   printf("Do IME Text element = %p replace = %d len = %d\n", mElement.get(), mReplaceLength, mStringToInsert.Length());
 #endif
 
   nsCOMPtr<nsISelectionController> selCon = do_QueryReferent(mSelConWeak);
-  if (!selCon) return NS_ERROR_NOT_INITIALIZED;
+  NS_ENSURE_TRUE(selCon, NS_ERROR_NOT_INITIALIZED);
 
   // advance caret: This requires the presentation shell to get the selection.
   nsresult result;
   if (mReplaceLength == 0) {
     result = mElement->InsertData(mOffset, mStringToInsert);
   } else {
     result = mElement->ReplaceData(mOffset, mReplaceLength, mStringToInsert);
   }
@@ -119,17 +119,17 @@ NS_IMETHODIMP IMETextTxn::DoTransaction(
 
 NS_IMETHODIMP IMETextTxn::UndoTransaction(void)
 {
 #ifdef DEBUG_IMETXN
   printf("Undo IME Text element = %p\n", mElement.get());
 #endif
 
   nsCOMPtr<nsISelectionController> selCon = do_QueryReferent(mSelConWeak);
-  if (!selCon) return NS_ERROR_NOT_INITIALIZED;
+  NS_ENSURE_TRUE(selCon, NS_ERROR_NOT_INITIALIZED);
 
   nsresult result = mElement->DeleteData(mOffset, mStringToInsert.Length());
   if (NS_SUCCEEDED(result))
   { // set the selection to the insertion point where the string was removed
     nsCOMPtr<nsISelection> selection;
     result = selCon->GetSelection(nsISelectionController::SELECTION_NORMAL, getter_AddRefs(selection));
     if (NS_SUCCEEDED(result) && selection) {
       result = selection->Collapse(mElement, mOffset);
@@ -262,17 +262,17 @@ NS_IMETHODIMP IMETextTxn::CollapseTextSe
       else printf("unknown constant\n");
     }
 #endif
         
     //
     // run through the text range list, if any
     //
     nsCOMPtr<nsISelectionController> selCon = do_QueryReferent(mSelConWeak);
-    if (!selCon) return NS_ERROR_NOT_INITIALIZED;
+    NS_ENSURE_TRUE(selCon, NS_ERROR_NOT_INITIALIZED);
 
     PRUint16      textRangeListLength,selectionStart,selectionEnd,
                   textRangeType;
     
     textRangeListLength = mRangeList->GetLength();
     nsCOMPtr<nsISelection> selection;
     result = selCon->GetSelection(nsISelectionController::SELECTION_NORMAL, getter_AddRefs(selection));
     if(NS_SUCCEEDED(result))

--- a/editor/libeditor/base/InsertElementTxn.cpp
+++ b/editor/libeditor/base/InsertElementTxn.cpp
@@ -100,17 +100,17 @@ NS_IMETHODIMP InsertElementTxn::DoTransa
            static_cast<void*>(nodeAsContent.get()),
            nodename,
            static_cast<void*>(parentAsContent.get()),
            mOffset); 
     nsMemory::Free(nodename);
   }
 #endif
 
-  if (!mNode || !mParent) return NS_ERROR_NOT_INITIALIZED;
+  NS_ENSURE_TRUE(mNode && mParent, NS_ERROR_NOT_INITIALIZED);
 
   nsCOMPtr<nsIDOMNodeList> childNodes;
   nsresult result = mParent->GetChildNodes(getter_AddRefs(childNodes));
   NS_ENSURE_SUCCESS(result, result);
   nsCOMPtr<nsIDOMNode>refNode;
   if (childNodes)
   {
     PRUint32 count;
@@ -123,27 +123,27 @@ NS_IMETHODIMP InsertElementTxn::DoTransa
     // note, it's ok for mRefNode to be null.  that means append
   }
 
   mEditor->MarkNodeDirty(mNode);
 
   nsCOMPtr<nsIDOMNode> resultNode;
   result = mParent->InsertBefore(mNode, refNode, getter_AddRefs(resultNode));
   NS_ENSURE_SUCCESS(result, result);
-  if (!resultNode) return NS_ERROR_NULL_POINTER;
+  NS_ENSURE_TRUE(resultNode, NS_ERROR_NULL_POINTER);
 
   // only set selection to insertion point if editor gives permission
   PRBool bAdjustSelection;
   mEditor->ShouldTxnSetSelection(&bAdjustSelection);
   if (bAdjustSelection)
   {
     nsCOMPtr<nsISelection> selection;
     result = mEditor->GetSelection(getter_AddRefs(selection));
     NS_ENSURE_SUCCESS(result, result);
-    if (!selection) return NS_ERROR_NULL_POINTER;
+    NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
     // place the selection just after the inserted element
     selection->Collapse(mParent, mOffset+1);
   }
   else
   {
     // do nothing - dom range gravity will adjust selection
   }
   return result;
@@ -157,17 +157,17 @@ NS_IMETHODIMP InsertElementTxn::UndoTran
     printf("%p Undo Insert Element of %p into parent %p at offset %d\n",
            static_cast<void*>(this),
            static_cast<void*>(mNode.get()),
            static_cast<void*>(mParent.get()),
            mOffset);
   }
 #endif
 
-  if (!mNode || !mParent) return NS_ERROR_NOT_INITIALIZED;
+  NS_ENSURE_TRUE(mNode && mParent, NS_ERROR_NOT_INITIALIZED);
 
   nsCOMPtr<nsIDOMNode> resultNode;
   return mParent->RemoveChild(mNode, getter_AddRefs(resultNode));
 }
 
 NS_IMETHODIMP InsertElementTxn::GetTxnDescription(nsAString& aString)
 {
   aString.AssignLiteral("InsertElementTxn");

--- a/editor/libeditor/base/InsertTextTxn.cpp
+++ b/editor/libeditor/base/InsertTextTxn.cpp
@@ -76,17 +76,17 @@ NS_IMETHODIMP InsertTextTxn::Init(nsIDOM
       nsAutoString text;
       aElement->GetData(text);
       printf("InsertTextTxn: Offset to insert at = %d. Text of the node to insert into:\n", aOffset);
       wprintf(text.get());
       printf("\n");
 #endif
 
   NS_ASSERTION(aElement && aEditor, "bad args");
-  if (!aElement || !aEditor) return NS_ERROR_NULL_POINTER;
+  NS_ENSURE_TRUE(aElement && aEditor, NS_ERROR_NULL_POINTER);
 
   mElement = do_QueryInterface(aElement);
   mOffset = aOffset;
   mStringToInsert = aStringToInsert;
   mEditor = aEditor;
   return NS_OK;
 }
 
@@ -109,17 +109,17 @@ NS_IMETHODIMP InsertTextTxn::DoTransacti
   // only set selection to insertion point if editor gives permission
   PRBool bAdjustSelection;
   mEditor->ShouldTxnSetSelection(&bAdjustSelection);
   if (bAdjustSelection)
   {
     nsCOMPtr<nsISelection> selection;
     result = mEditor->GetSelection(getter_AddRefs(selection));
     NS_ENSURE_SUCCESS(result, result);
-    if (!selection) return NS_ERROR_NULL_POINTER;
+    NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
     result = selection->Collapse(mElement, mOffset+mStringToInsert.Length());
     NS_ASSERTION((NS_SUCCEEDED(result)), "selection could not be collapsed after insert.");
   }
   else
   {
     // do nothing - dom range gravity will adjust selection
   }
 

--- a/editor/libeditor/base/JoinElementTxn.cpp
+++ b/editor/libeditor/base/JoinElementTxn.cpp
@@ -100,23 +100,23 @@ NS_IMETHODIMP JoinElementTxn::DoTransact
 
   NS_PRECONDITION((mEditor && mLeftNode && mRightNode), "null arg");
   if (!mEditor || !mLeftNode || !mRightNode) { return NS_ERROR_NOT_INITIALIZED; }
 
   // get the parent node
   nsCOMPtr<nsIDOMNode>leftParent;
   nsresult result = mLeftNode->GetParentNode(getter_AddRefs(leftParent));
   NS_ENSURE_SUCCESS(result, result);
-  if (!leftParent) return NS_ERROR_NULL_POINTER;
+  NS_ENSURE_TRUE(leftParent, NS_ERROR_NULL_POINTER);
 
   // verify that mLeftNode and mRightNode have the same parent
   nsCOMPtr<nsIDOMNode>rightParent;
   result = mRightNode->GetParentNode(getter_AddRefs(rightParent));
   NS_ENSURE_SUCCESS(result, result);
-  if (!rightParent) return NS_ERROR_NULL_POINTER;
+  NS_ENSURE_TRUE(rightParent, NS_ERROR_NULL_POINTER);
 
   if (leftParent==rightParent)
   {
     mParent= do_QueryInterface(leftParent); // set this instance mParent. 
                                             // Other methods will see a non-null mParent and know all is well
     nsCOMPtr<nsIDOMCharacterData> leftNodeAsText = do_QueryInterface(mLeftNode);
     if (leftNodeAsText) 
     {

--- a/editor/libeditor/base/PlaceholderTxn.cpp
+++ b/editor/libeditor/base/PlaceholderTxn.cpp
@@ -71,17 +71,17 @@ NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(
   NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)
 NS_INTERFACE_MAP_END_INHERITING(EditAggregateTxn)
 
 NS_IMPL_ADDREF_INHERITED(PlaceholderTxn, EditAggregateTxn)
 NS_IMPL_RELEASE_INHERITED(PlaceholderTxn, EditAggregateTxn)
 
 NS_IMETHODIMP PlaceholderTxn::Init(nsIAtom *aName, nsSelectionState *aSelState, nsIEditor *aEditor)
 {
-  if (!aEditor || !aSelState) return NS_ERROR_NULL_POINTER;
+  NS_ENSURE_TRUE(aEditor && aSelState, NS_ERROR_NULL_POINTER);
 
   mName = aName;
   mStartSel = aSelState;
   mEditor = aEditor;
   return NS_OK;
 }
 
 NS_IMETHODIMP PlaceholderTxn::DoTransaction(void)
@@ -90,62 +90,62 @@ NS_IMETHODIMP PlaceholderTxn::DoTransact
 }
 
 NS_IMETHODIMP PlaceholderTxn::UndoTransaction(void)
 {
   // undo txns
   nsresult res = EditAggregateTxn::UndoTransaction();
   NS_ENSURE_SUCCESS(res, res);
   
-  if (!mStartSel) return NS_ERROR_NULL_POINTER;
+  NS_ENSURE_TRUE(mStartSel, NS_ERROR_NULL_POINTER);
 
   // now restore selection
   nsCOMPtr<nsISelection> selection;
   res = mEditor->GetSelection(getter_AddRefs(selection));
   NS_ENSURE_SUCCESS(res, res);
-  if (!selection) return NS_ERROR_NULL_POINTER;
+  NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
   return mStartSel->RestoreSelection(selection);
 }
 
 
 NS_IMETHODIMP PlaceholderTxn::RedoTransaction(void)
 {
   // redo txns
   nsresult res = EditAggregateTxn::RedoTransaction();
   NS_ENSURE_SUCCESS(res, res);
   
   // now restore selection
   nsCOMPtr<nsISelection> selection;
   res = mEditor->GetSelection(getter_AddRefs(selection));
   NS_ENSURE_SUCCESS(res, res);
-  if (!selection) return NS_ERROR_NULL_POINTER;
+  NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
   return mEndSel.RestoreSelection(selection);
 }
 
 
 NS_IMETHODIMP PlaceholderTxn::Merge(nsITransaction *aTransaction, PRBool *aDidMerge)
 {
-  if (!aDidMerge || !aTransaction) return NS_ERROR_NULL_POINTER;
+  NS_ENSURE_TRUE(aDidMerge && aTransaction, NS_ERROR_NULL_POINTER);
 
   // set out param default value
   *aDidMerge=PR_FALSE;
     
   if (mForwarding) 
   {
     NS_NOTREACHED("tried to merge into a placeholder that was in forwarding mode!");
     return NS_ERROR_FAILURE;
   }
 
   // check to see if aTransaction is one of the editor's
   // private transactions. If not, we want to avoid merging
   // the foreign transaction into our placeholder since we
   // don't know what it does.
 
   nsCOMPtr<nsPIEditorTransaction> pTxn = do_QueryInterface(aTransaction);
-  if (!pTxn) return NS_OK; // it's foreign so just bail!
+  NS_ENSURE_TRUE(pTxn, NS_OK); // it's foreign so just bail!
 
   EditTxn *editTxn = (EditTxn*)aTransaction;  //XXX: hack, not safe!  need nsIEditTransaction!
   // determine if this incoming txn is a placeholder txn
   nsCOMPtr<nsIAbsorbingTransaction> plcTxn;// = do_QueryInterface(editTxn);
   // can't do_QueryInterface() above due to our broken transaction interfaces.
   // instead have to brute it below. ugh. 
   editTxn->QueryInterface(NS_GET_IID(nsIAbsorbingTransaction), getter_AddRefs(plcTxn));
 
@@ -245,17 +245,17 @@ NS_IMETHODIMP PlaceholderTxn::GetTxnName
 {
   return GetName(aName);
 }
 
 NS_IMETHODIMP PlaceholderTxn::StartSelectionEquals(nsSelectionState *aSelState, PRBool *aResult)
 {
   // determine if starting selection matches the given selection state.
   // note that we only care about collapsed selections.
-  if (!aResult || !aSelState) return NS_ERROR_NULL_POINTER;
+  NS_ENSURE_TRUE(aResult && aSelState, NS_ERROR_NULL_POINTER);
   if (!mStartSel->IsCollapsed() || !aSelState->IsCollapsed())
   {
     *aResult = PR_FALSE;
     return NS_OK;
   }
   *aResult = mStartSel->IsEqual(aSelState);
   return NS_OK;
 }
@@ -286,12 +286,12 @@ NS_IMETHODIMP PlaceholderTxn::Commit()
   return NS_OK;
 }
 
 NS_IMETHODIMP PlaceholderTxn::RememberEndingSelection()
 {
   nsCOMPtr<nsISelection> selection;
   nsresult res = mEditor->GetSelection(getter_AddRefs(selection));
   NS_ENSURE_SUCCESS(res, res);
-  if (!selection) return NS_ERROR_NULL_POINTER;
+  NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
   return mEndSel.SaveSelection(selection);
 }
 

--- a/editor/libeditor/base/SetDocTitleTxn.cpp
+++ b/editor/libeditor/base/SetDocTitleTxn.cpp
@@ -79,20 +79,20 @@ NS_IMETHODIMP SetDocTitleTxn::RedoTransa
 {
   // No extra work required; the DOM changes alone are enough
   return NS_OK;
 }
 
 nsresult SetDocTitleTxn::SetDomTitle(const nsAString& aTitle)
 {
   nsCOMPtr<nsIEditor> editor = do_QueryInterface(mEditor);
-  if (!editor) return NS_ERROR_FAILURE;
+  NS_ENSURE_TRUE(editor, NS_ERROR_FAILURE);
   nsCOMPtr<nsIDOMDocument> domDoc;
   nsresult res = editor->GetDocument(getter_AddRefs(domDoc));
-  if (!domDoc) return NS_ERROR_FAILURE;
+  NS_ENSURE_TRUE(domDoc, NS_ERROR_FAILURE);
 
   nsCOMPtr<nsIDOMNodeList> titleList;
   res = domDoc->GetElementsByTagName(NS_LITERAL_STRING("title"), getter_AddRefs(titleList));
   NS_ENSURE_SUCCESS(res, res);
 
   // First assume we will NOT really do anything
   // (transaction will not be pushed on stack)
   mIsTransient = PR_TRUE;
@@ -130,32 +130,32 @@ nsresult SetDocTitleTxn::SetDomTitle(con
 
   // We didn't return above, thus we really will be changing the title
   mIsTransient = PR_FALSE;
 
   // Get the <HEAD> node, create a <TITLE> and insert it under the HEAD
   nsCOMPtr<nsIDOMNodeList> headList;
   res = domDoc->GetElementsByTagName(NS_LITERAL_STRING("head"),getter_AddRefs(headList));
   NS_ENSURE_SUCCESS(res, res);
-  if (!headList) return NS_ERROR_FAILURE;
+  NS_ENSURE_TRUE(headList, NS_ERROR_FAILURE);
   
   nsCOMPtr<nsIDOMNode>headNode;
   headList->Item(0, getter_AddRefs(headNode));
-  if (!headNode) return NS_ERROR_FAILURE;
+  NS_ENSURE_TRUE(headNode, NS_ERROR_FAILURE);
 
   PRBool   newTitleNode = PR_FALSE;
   PRUint32 newTitleIndex = 0;
 
   if (!titleNode)
   {
     // Didn't find one above: Create a new one
     nsCOMPtr<nsIDOMElement>titleElement;
     res = domDoc->CreateElement(NS_LITERAL_STRING("title"), getter_AddRefs(titleElement));
     NS_ENSURE_SUCCESS(res, res);
-    if (!titleElement) return NS_ERROR_FAILURE;
+    NS_ENSURE_TRUE(titleElement, NS_ERROR_FAILURE);
 
     titleNode = do_QueryInterface(titleElement);
     newTitleNode = PR_TRUE;
 
     // Get index so we append new title node 
     // after all existing HEAD children
     nsCOMPtr<nsIDOMNodeList> children;
     res = headNode->GetChildNodes(getter_AddRefs(children));
@@ -167,17 +167,17 @@ nsresult SetDocTitleTxn::SetDomTitle(con
   // Append a text node under the TITLE
   //  only if the title text isn't empty
   if (titleNode && !aTitle.IsEmpty())
   {
     nsCOMPtr<nsIDOMText> textNode;
     res = domDoc->CreateTextNode(aTitle, getter_AddRefs(textNode));
     NS_ENSURE_SUCCESS(res, res);
     nsCOMPtr<nsIDOMNode> newNode = do_QueryInterface(textNode);
-    if (!newNode) return NS_ERROR_FAILURE;
+    NS_ENSURE_TRUE(newNode, NS_ERROR_FAILURE);
 
     if (newTitleNode)
     {
       // Not undoable: We will insert newTitleNode below
       nsCOMPtr<nsIDOMNode> resultNode;
       res = titleNode->AppendChild(newNode, getter_AddRefs(resultNode));
     } 
     else 
@@ -200,13 +200,13 @@ NS_IMETHODIMP SetDocTitleTxn::GetTxnDesc
 {
   aString.AssignLiteral("SetDocTitleTxn: ");
   aString += mValue;
   return NS_OK;
 }
 
 NS_IMETHODIMP SetDocTitleTxn::GetIsTransient(PRBool *aIsTransient)
 {
-  if (!aIsTransient) return NS_ERROR_NULL_POINTER;  
+  NS_ENSURE_TRUE(aIsTransient, NS_ERROR_NULL_POINTER);  
   *aIsTransient = mIsTransient;
   return NS_OK;
 }
 

--- a/editor/libeditor/base/SplitElementTxn.cpp
+++ b/editor/libeditor/base/SplitElementTxn.cpp
@@ -94,40 +94,40 @@ NS_IMETHODIMP SplitElementTxn::DoTransac
 
   NS_ASSERTION(mExistingRightNode && mEditor, "bad state");
   if (!mExistingRightNode || !mEditor) { return NS_ERROR_NOT_INITIALIZED; }
 
   // create a new node
   nsresult result = mExistingRightNode->CloneNode(PR_FALSE, getter_AddRefs(mNewLeftNode));
   NS_ASSERTION(((NS_SUCCEEDED(result)) && (mNewLeftNode)), "could not create element.");
   NS_ENSURE_SUCCESS(result, result);
-  if (!mNewLeftNode) return NS_ERROR_NULL_POINTER;
+  NS_ENSURE_TRUE(mNewLeftNode, NS_ERROR_NULL_POINTER);
   mEditor->MarkNodeDirty(mExistingRightNode);
 
 #ifdef NS_DEBUG
   if (gNoisy)
   {
     printf("  created left node = %p\n",
            static_cast<void*>(mNewLeftNode.get()));
   }
 #endif
 
   // get the parent node
   result = mExistingRightNode->GetParentNode(getter_AddRefs(mParent));
   NS_ENSURE_SUCCESS(result, result);
-  if (!mParent) return NS_ERROR_NULL_POINTER;
+  NS_ENSURE_TRUE(mParent, NS_ERROR_NULL_POINTER);
 
   // insert the new node
   result = mEditor->SplitNodeImpl(mExistingRightNode, mOffset, mNewLeftNode, mParent);
   if (NS_SUCCEEDED(result) && mNewLeftNode)
   {
     nsCOMPtr<nsISelection>selection;
     mEditor->GetSelection(getter_AddRefs(selection));
     NS_ENSURE_SUCCESS(result, result);
-    if (!selection) return NS_ERROR_NULL_POINTER;
+    NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
     result = selection->Collapse(mNewLeftNode, mOffset);
   }
   else {
     result = NS_ERROR_NOT_IMPLEMENTED;
   }
   return result;
 }
 

--- a/editor/libeditor/base/nsEditor.cpp
+++ b/editor/libeditor/base/nsEditor.cpp
@@ -231,17 +231,17 @@ nsEditor::Init(nsIDOMDocument *aDoc, nsI
   nsresult rv = SetFlags(aFlags);
   NS_ASSERTION(NS_SUCCEEDED(rv), "SetFlags() failed");
 
   mDocWeak = do_GetWeakReference(aDoc);  // weak reference to doc
   mPresShellWeak = do_GetWeakReference(aPresShell);   // weak reference to pres shell
   mSelConWeak = do_GetWeakReference(aSelCon);   // weak reference to selectioncontroller
 
   nsCOMPtr<nsIPresShell> ps = do_QueryReferent(mPresShellWeak);
-  if (!ps) return NS_ERROR_NOT_INITIALIZED;
+  NS_ENSURE_TRUE(ps, NS_ERROR_NOT_INITIALIZED);
   
   //set up root element if we are passed one.  
   if (aRoot)
     mRootElement = do_QueryInterface(aRoot);
 
   mUpdateCount=0;
 
   /* initialize IME stuff */
@@ -485,31 +485,31 @@ nsEditor::GetIsDocumentEditable(PRBool *
 NS_IMETHODIMP 
 nsEditor::GetDocument(nsIDOMDocument **aDoc)
 {
   if (!aDoc)
     return NS_ERROR_NULL_POINTER;
   *aDoc = nsnull; // init out param
   NS_PRECONDITION(mDocWeak, "bad state, mDocWeak weak pointer not initialized");
   nsCOMPtr<nsIDOMDocument> doc = do_QueryReferent(mDocWeak);
-  if (!doc) return NS_ERROR_NOT_INITIALIZED;
+  NS_ENSURE_TRUE(doc, NS_ERROR_NOT_INITIALIZED);
   NS_ADDREF(*aDoc = doc);
   return NS_OK;
 }
 
 
 nsresult 
 nsEditor::GetPresShell(nsIPresShell **aPS)
 {
   if (!aPS)
     return NS_ERROR_NULL_POINTER;
   *aPS = nsnull; // init out param
   NS_PRECONDITION(mPresShellWeak, "bad state, null mPresShellWeak");
   nsCOMPtr<nsIPresShell> ps = do_QueryReferent(mPresShellWeak);
-  if (!ps) return NS_ERROR_NOT_INITIALIZED;
+  NS_ENSURE_TRUE(ps, NS_ERROR_NOT_INITIALIZED);
   NS_ADDREF(*aPS = ps);
   return NS_OK;
 }
 
 
 /* attribute string contentsMIMEType; */
 NS_IMETHODIMP
 nsEditor::GetContentsMIMEType(char * *aContentsMIMEType)
@@ -529,17 +529,17 @@ nsEditor::SetContentsMIMEType(const char
 NS_IMETHODIMP
 nsEditor::GetSelectionController(nsISelectionController **aSel)
 {
   if (!aSel)
     return NS_ERROR_NULL_POINTER;
   *aSel = nsnull; // init out param
   NS_PRECONDITION(mSelConWeak, "bad state, null mSelConWeak");
   nsCOMPtr<nsISelectionController> selCon = do_QueryReferent(mSelConWeak);
-  if (!selCon) return NS_ERROR_NOT_INITIALIZED;
+  NS_ENSURE_TRUE(selCon, NS_ERROR_NOT_INITIALIZED);
   NS_ADDREF(*aSel = selCon);
   return NS_OK;
 }
 
 
 NS_IMETHODIMP
 nsEditor::DeleteSelection(EDirection aAction)
 {
@@ -550,17 +550,17 @@ nsEditor::DeleteSelection(EDirection aAc
 
 NS_IMETHODIMP
 nsEditor::GetSelection(nsISelection **aSelection)
 {
   if (!aSelection)
     return NS_ERROR_NULL_POINTER;
   *aSelection = nsnull;
   nsCOMPtr<nsISelectionController> selcon = do_QueryReferent(mSelConWeak);
-  if (!selcon) return NS_ERROR_NOT_INITIALIZED;
+  NS_ENSURE_TRUE(selcon, NS_ERROR_NOT_INITIALIZED);
   return selcon->GetSelection(nsISelectionController::SELECTION_NORMAL, aSelection);  // does an addref
 }
 
 NS_IMETHODIMP 
 nsEditor::DoTransaction(nsITransaction *aTxn)
 {
 #ifdef NS_DEBUG_EDITOR
   if (gNoisy) { printf("Editor::DoTransaction ----------\n"); }
@@ -941,17 +941,17 @@ nsEditor::EndPlaceHolderTransaction()
   mPlaceHolderBatch--;
   
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsEditor::ShouldTxnSetSelection(PRBool *aResult)
 {
-  if (!aResult) return NS_ERROR_NULL_POINTER;
+  NS_ENSURE_TRUE(aResult, NS_ERROR_NULL_POINTER);
   *aResult = mShouldTxnSetSelection;
   return NS_OK;
 }
 
 NS_IMETHODIMP  
 nsEditor::SetShouldTxnSetSelection(PRBool aShould)
 {
   mShouldTxnSetSelection = aShould;
@@ -978,17 +978,17 @@ nsEditor::GetDocumentIsEmpty(PRBool *aDo
 
 // XXX: the rule system should tell us which node to select all on (ie, the root, or the body)
 NS_IMETHODIMP nsEditor::SelectAll()
 {
   if (!mDocWeak || !mPresShellWeak) { return NS_ERROR_NOT_INITIALIZED; }
   ForceCompositionEnd();
 
   nsCOMPtr<nsISelectionController> selCon = do_QueryReferent(mSelConWeak);
-  if (!selCon) return NS_ERROR_NOT_INITIALIZED;
+  NS_ENSURE_TRUE(selCon, NS_ERROR_NOT_INITIALIZED);
   nsCOMPtr<nsISelection> selection;
   nsresult result = selCon->GetSelection(nsISelectionController::SELECTION_NORMAL, getter_AddRefs(selection));
   if (NS_SUCCEEDED(result) && selection)
   {
     result = SelectEntireDocument(selection);
   }
   return result;
 }
@@ -1045,17 +1045,17 @@ nsEditor::EndOfDocument()
 { 
   if (!mDocWeak || !mPresShellWeak) { return NS_ERROR_NOT_INITIALIZED; } 
   nsresult res; 
 
   // get selection 
   nsCOMPtr<nsISelection> selection; 
   res = GetSelection(getter_AddRefs(selection)); 
   NS_ENSURE_SUCCESS(res, res); 
-  if (!selection)   return NS_ERROR_NULL_POINTER; 
+  NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER); 
   
   // get the root element 
   nsIDOMElement *rootElement = GetRoot(); 
   if (!rootElement)
     return NS_ERROR_NULL_POINTER; 
 
   // get the length of the rot element 
   PRUint32 len; 
@@ -1545,17 +1545,17 @@ nsEditor::RemoveContainer(nsIDOMNode *in
   
   // loop through the child nodes of inNode and promote them
   // into inNode's parent.
   PRBool bHasMoreChildren;
   inNode->HasChildNodes(&bHasMoreChildren);
   nsCOMPtr<nsIDOMNodeList> nodeList;
   res = inNode->GetChildNodes(getter_AddRefs(nodeList));
   NS_ENSURE_SUCCESS(res, res);
-  if (!nodeList) return NS_ERROR_NULL_POINTER;
+  NS_ENSURE_TRUE(nodeList, NS_ERROR_NULL_POINTER);
   PRUint32 nodeOrigLen;
   nodeList->GetLength(&nodeOrigLen);
 
   // notify our internal selection state listener
   nsAutoRemoveContainerSelNotify selNotify(mRangeUpdater, inNode, parent, offset, nodeOrigLen);
                                    
   nsCOMPtr<nsIDOMNode> child;
   while (bHasMoreChildren)
@@ -1814,17 +1814,17 @@ nsEditor::DumpContentTree()
 }
 
 
 NS_IMETHODIMP
 nsEditor::DebugDumpContent()
 {
 #ifdef DEBUG
   nsCOMPtr<nsIDOMHTMLDocument> doc = do_QueryReferent(mDocWeak);
-  if (!doc) return NS_ERROR_NOT_INITIALIZED;
+  NS_ENSURE_TRUE(doc, NS_ERROR_NOT_INITIALIZED);
 
   nsCOMPtr<nsIDOMHTMLElement>bodyElem;
   doc->GetBody(getter_AddRefs(bodyElem));
   nsCOMPtr<nsIContent> content = do_QueryInterface(bodyElem);
   if (content)
     content->List();
 #endif
   return NS_OK;
@@ -1897,17 +1897,17 @@ nsEditor::BeginComposition()
     mPhonetic->Truncate(0);
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsEditor::EndComposition(void)
 {
-  if (!mInIMEMode) return NS_OK; // nothing to do
+  NS_ENSURE_TRUE(mInIMEMode, NS_OK); // nothing to do
   
   nsresult result = NS_OK;
 
   // commit the IME transaction..we can get at it via the transaction mgr.
   // Note that this means IME won't work without an undo stack!
   if (mTxnMgr) 
   {
     nsCOMPtr<nsITransaction> txn;
@@ -2295,29 +2295,29 @@ NS_IMETHODIMP nsEditor::InsertTextImpl(c
                                           nsCOMPtr<nsIDOMNode> *aInOutNode, 
                                           PRInt32 *aInOutOffset,
                                           nsIDOMDocument *aDoc)
 {
   // NOTE: caller *must* have already used nsAutoTxnsConserveSelection stack-based
   // class to turn off txn selection updating.  Caller also turned on rules sniffing
   // if desired.
   
-  if (!aInOutNode || !*aInOutNode || !aInOutOffset || !aDoc) return NS_ERROR_NULL_POINTER;
+  NS_ENSURE_TRUE(aInOutNode && *aInOutNode && aInOutOffset && aDoc, NS_ERROR_NULL_POINTER);
   if (!mInIMEMode && aStringToInsert.IsEmpty()) return NS_OK;
   nsCOMPtr<nsIDOMText> nodeAsText = do_QueryInterface(*aInOutNode);
   PRInt32 offset = *aInOutOffset;
   nsresult res;
   if (mInIMEMode)
   {
     if (!nodeAsText)
     {
       // create a text node
       res = aDoc->CreateTextNode(EmptyString(), getter_AddRefs(nodeAsText));
       NS_ENSURE_SUCCESS(res, res);
-      if (!nodeAsText) return NS_ERROR_NULL_POINTER;
+      NS_ENSURE_TRUE(nodeAsText, NS_ERROR_NULL_POINTER);
       nsCOMPtr<nsIDOMNode> newNode = do_QueryInterface(nodeAsText);
       // then we insert it into the dom tree
       res = InsertNode(newNode, *aInOutNode, offset);
       NS_ENSURE_SUCCESS(res, res);
       offset = 0;
     }
     res = InsertTextIntoTextNodeImpl(aStringToInsert, nodeAsText, offset);
     NS_ENSURE_SUCCESS(res, res);
@@ -2332,17 +2332,17 @@ NS_IMETHODIMP nsEditor::InsertTextImpl(c
       *aInOutOffset += aStringToInsert.Length();
     }
     else
     {
       // we are inserting text into a non-text node
       // first we have to create a textnode (this also populates it with the text)
       res = aDoc->CreateTextNode(aStringToInsert, getter_AddRefs(nodeAsText));
       NS_ENSURE_SUCCESS(res, res);
-      if (!nodeAsText) return NS_ERROR_NULL_POINTER;
+      NS_ENSURE_TRUE(nodeAsText, NS_ERROR_NULL_POINTER);
       nsCOMPtr<nsIDOMNode> newNode = do_QueryInterface(nodeAsText);
       // then we insert it into the dom tree
       res = InsertNode(newNode, *aInOutNode, offset);
       NS_ENSURE_SUCCESS(res, res);
       *aInOutNode = newNode;
       *aInOutOffset = aStringToInsert.Length();
     }
   }
@@ -2469,17 +2469,17 @@ NS_IMETHODIMP nsEditor::SelectEntireDocu
   if (!rootElement) { return NS_ERROR_NOT_INITIALIZED; }
 
   return aSelection->SelectAllChildren(rootElement);
 }
 
 
 nsresult nsEditor::GetFirstEditableNode(nsIDOMNode *aRoot, nsCOMPtr<nsIDOMNode> *outFirstNode)
 {
-  if (!aRoot || !outFirstNode) return NS_ERROR_NULL_POINTER;
+  NS_ENSURE_TRUE(aRoot && outFirstNode, NS_ERROR_NULL_POINTER);
   nsresult rv = NS_OK;
   *outFirstNode = nsnull;
 
   nsCOMPtr<nsIDOMNode> node = GetLeftmostChild(aRoot);
   if (node && !IsEditable(node))
   {
     nsCOMPtr<nsIDOMNode> next;
     rv = GetNextNode(node, PR_TRUE, address_of(next));
@@ -2491,17 +2491,17 @@ nsresult nsEditor::GetFirstEditableNode(
 
   return rv;
 }
 
 #ifdef XXX_DEAD_CODE
 // jfrancis wants to keep this method around for reference
 nsresult nsEditor::GetLastEditableNode(nsIDOMNode *aRoot, nsCOMPtr<nsIDOMNode> *outLastNode)
 {
-  if (!aRoot || !outLastNode) return NS_ERROR_NULL_POINTER;
+  NS_ENSURE_TRUE(aRoot && outLastNode, NS_ERROR_NULL_POINTER);
   nsresult rv = NS_OK;
   *outLastNode = nsnull;
 
   nsCOMPtr<nsIDOMNode> node = GetRightmostChild(aRoot);
   if (node && !IsEditable(node))
   {
     nsCOMPtr<nsIDOMNode> next;
     rv = GetPriorNode(node, PR_TRUE, address_of(next));
@@ -2575,21 +2575,21 @@ nsEditor::NotifyDocumentListeners(TDocum
 }
 
 
 NS_IMETHODIMP nsEditor::CreateTxnForInsertText(const nsAString & aStringToInsert,
                                                nsIDOMCharacterData *aTextNode,
                                                PRInt32 aOffset,
                                                InsertTextTxn ** aTxn)
 {
-  if (!aTextNode || !aTxn) return NS_ERROR_NULL_POINTER;
+  NS_ENSURE_TRUE(aTextNode && aTxn, NS_ERROR_NULL_POINTER);
   nsresult result;
 
   *aTxn = new InsertTextTxn();
-  if (!*aTxn) return NS_ERROR_OUT_OF_MEMORY;
+  NS_ENSURE_TRUE(*aTxn, NS_ERROR_OUT_OF_MEMORY);
   NS_ADDREF(*aTxn);
   result = (*aTxn)->Init(aTextNode, aOffset, aStringToInsert, this);
   return result;
 }
 
 
 NS_IMETHODIMP nsEditor::DeleteText(nsIDOMCharacterData *aElement,
                               PRUint32             aOffset,
@@ -2693,17 +2693,17 @@ nsEditor::SplitNodeImpl(nsIDOMNode * aEx
   if ((nsnull!=aExistingRightNode) &&
       (nsnull!=aNewLeftNode) &&
       (nsnull!=aParent))
   {
     // get selection
     nsCOMPtr<nsISelection> selection;
     result = GetSelection(getter_AddRefs(selection));
     NS_ENSURE_SUCCESS(result, result);
-    if (!selection) return NS_ERROR_NULL_POINTER;
+    NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
 
     // remember some selection points
     nsCOMPtr<nsIDOMNode> selStartNode, selEndNode;
     PRInt32 selStartOffset, selEndOffset;
     result = GetStartNodeAndOffset(selection, getter_AddRefs(selStartNode), &selStartOffset);
     if (NS_FAILED(result)) selStartNode = nsnull;  // if selection is cleared, remember that
     result = GetEndNodeAndOffset(selection, getter_AddRefs(selEndNode), &selEndOffset);
     if (NS_FAILED(result)) selStartNode = nsnull;  // if selection is cleared, remember that
@@ -2814,17 +2814,17 @@ nsEditor::JoinNodesImpl(nsIDOMNode * aNo
 {
   NS_ASSERTION(aNodeToKeep && aNodeToJoin && aParent, "null arg");
   nsresult result;
   if (aNodeToKeep && aNodeToJoin && aParent)
   {
     // get selection
     nsCOMPtr<nsISelection> selection;
     GetSelection(getter_AddRefs(selection));
-    if (!selection) return NS_ERROR_NULL_POINTER;
+    NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
 
     // remember some selection points
     nsCOMPtr<nsIDOMNode> selStartNode, selEndNode;
     PRInt32 selStartOffset, selEndOffset, joinOffset, keepOffset;
     result = GetStartNodeAndOffset(selection, getter_AddRefs(selStartNode), &selStartOffset);
     if (NS_FAILED(result)) selStartNode = nsnull;
     result = GetEndNodeAndOffset(selection, getter_AddRefs(selEndNode), &selEndOffset);
     // Joe or Kin should comment here on why the following line is not a copy/paste error
@@ -3401,17 +3401,17 @@ nsEditor::GetNextNodeImpl(nsIDOMNode  *a
   return result;
 }
 
 
 nsCOMPtr<nsIDOMNode>
 nsEditor::GetRightmostChild(nsIDOMNode *aCurrentNode, 
                             PRBool bNoBlockCrossing)
 {
-  if (!aCurrentNode) return nsnull;
+  NS_ENSURE_TRUE(aCurrentNode, nsnull);
   nsCOMPtr<nsIDOMNode> resultNode, temp=aCurrentNode;
   PRBool hasChildren;
   aCurrentNode->HasChildNodes(&hasChildren);
   while (hasChildren)
   {
     temp->GetLastChild(getter_AddRefs(resultNode));
     if (resultNode)
     {
@@ -3426,17 +3426,17 @@ nsEditor::GetRightmostChild(nsIDOMNode *
 
   return resultNode;
 }
 
 nsCOMPtr<nsIDOMNode>
 nsEditor::GetLeftmostChild(nsIDOMNode *aCurrentNode,
                            PRBool bNoBlockCrossing)
 {
-  if (!aCurrentNode) return nsnull;
+  NS_ENSURE_TRUE(aCurrentNode, nsnull);
   nsCOMPtr<nsIDOMNode> resultNode, temp=aCurrentNode;
   PRBool hasChildren;
   aCurrentNode->HasChildNodes(&hasChildren);
   while (hasChildren)
   {
     temp->GetFirstChild(getter_AddRefs(resultNode));
     if (resultNode)
     {
@@ -3461,17 +3461,17 @@ nsEditor::IsBlockNode(nsIDOMNode *aNode)
   // across both nsEditor/nsHTMLEditor.  
   return PR_FALSE;
 }
 
 PRBool 
 nsEditor::CanContainTag(nsIDOMNode* aParent, const nsAString &aChildTag)
 {
   nsCOMPtr<nsIDOMElement> parentElement = do_QueryInterface(aParent);
-  if (!parentElement) return PR_FALSE;
+  NS_ENSURE_TRUE(parentElement, PR_FALSE);
   
   nsAutoString parentStringTag;
   parentElement->GetTagName(parentStringTag);
   return TagCanContainTag(parentStringTag, aChildTag);
 }
 
 PRBool 
 nsEditor::TagCanContain(const nsAString &aParentTag, nsIDOMNode* aChild)
@@ -3480,17 +3480,17 @@ nsEditor::TagCanContain(const nsAString 
   
   if (IsTextNode(aChild)) 
   {
     childStringTag.AssignLiteral("#text");
   }
   else
   {
     nsCOMPtr<nsIDOMElement> childElement = do_QueryInterface(aChild);
-    if (!childElement) return PR_FALSE;
+    NS_ENSURE_TRUE(childElement, PR_FALSE);
     childElement->GetTagName(childStringTag);
   }
   return TagCanContainTag(aParentTag, childStringTag);
 }
 
 PRBool 
 nsEditor::TagCanContainTag(const nsAString &aParentTag, const nsAString &aChildTag)
 {
@@ -3508,19 +3508,19 @@ nsEditor::IsRootNode(nsIDOMNode *inNode)
   nsCOMPtr<nsIDOMNode> rootNode = do_QueryInterface(rootElement);
 
   return inNode == rootNode;
 }
 
 PRBool 
 nsEditor::IsDescendantOfBody(nsIDOMNode *inNode) 
 {
-  if (!inNode) return PR_FALSE;
+  NS_ENSURE_TRUE(inNode, PR_FALSE);
   nsIDOMElement *rootElement = GetRoot();
-  if (!rootElement) return PR_FALSE;
+  NS_ENSURE_TRUE(rootElement, PR_FALSE);
   nsCOMPtr<nsIDOMNode> root = do_QueryInterface(rootElement);
 
   if (inNode == root.get()) return PR_TRUE;
   
   nsCOMPtr<nsIDOMNode> parent, node = do_QueryInterface(inNode);
   
   do
   {
@@ -3547,17 +3547,17 @@ nsEditor::IsTextInDirtyFrameVisible(nsID
   // the best we can do is to assume it's visible.
 
   return PR_TRUE;
 }
 
 PRBool 
 nsEditor::IsEditable(nsIDOMNode *aNode)
 {
-  if (!aNode) return PR_FALSE;
+  NS_ENSURE_TRUE(aNode, PR_FALSE);
 
   if (IsMozEditorBogusNode(aNode) || !IsModifiableNode(aNode)) return PR_FALSE;
 
   // see if it has a frame.  If so, we'll edit it.
   // special case for textnodes: frame must have width.
   nsCOMPtr<nsIContent> content = do_QueryInterface(aNode);
   if (content)
   {
@@ -3887,20 +3887,20 @@ nsEditor::GetEndNodeAndOffset(nsISelecti
 ///////////////////////////////////////////////////////////////////////////
 // IsPreformatted: checks the style info for the node for the preformatted
 //                 text style.
 nsresult 
 nsEditor::IsPreformatted(nsIDOMNode *aNode, PRBool *aResult)
 {
   nsCOMPtr<nsIContent> content = do_QueryInterface(aNode);
   
-  if (!aResult || !content) return NS_ERROR_NULL_POINTER;
+  NS_ENSURE_TRUE(aResult && content, NS_ERROR_NULL_POINTER);
   
   nsCOMPtr<nsIPresShell> ps = do_QueryReferent(mPresShellWeak);
-  if (!ps) return NS_ERROR_NOT_INITIALIZED;
+  NS_ENSURE_TRUE(ps, NS_ERROR_NOT_INITIALIZED);
 
   nsRefPtr<nsStyleContext> elementStyle;
   if (content->IsElement()) {
     elementStyle = nsComputedDOMStyle::GetStyleContextForElement(content->AsElement(),
                                                                  nsnull,
                                                                  ps);
   }
 
@@ -3934,17 +3934,17 @@ nsresult
 nsEditor::SplitNodeDeep(nsIDOMNode *aNode, 
                         nsIDOMNode *aSplitPointParent, 
                         PRInt32 aSplitPointOffset,
                         PRInt32 *outOffset,
                         PRBool  aNoEmptyContainers,
                         nsCOMPtr<nsIDOMNode> *outLeftNode,
                         nsCOMPtr<nsIDOMNode> *outRightNode)
 {
-  if (!aNode || !aSplitPointParent || !outOffset) return NS_ERROR_NULL_POINTER;
+  NS_ENSURE_TRUE(aNode && aSplitPointParent && outOffset, NS_ERROR_NULL_POINTER);
   nsCOMPtr<nsIDOMNode> tempNode, parentNode;  
   PRInt32 offset = aSplitPointOffset;
   nsresult res;
   
   if (outLeftNode)  *outLeftNode  = nsnull;
   if (outRightNode) *outRightNode = nsnull;
   
   nsCOMPtr<nsIDOMNode> nodeToSplit = do_QueryInterface(aSplitPointParent);
@@ -3968,17 +3968,17 @@ nsEditor::SplitNodeDeep(nsIDOMNode *aNod
       res = SplitNode(nodeToSplit, offset, getter_AddRefs(tempNode));
       NS_ENSURE_SUCCESS(res, res);
       if (outRightNode) *outRightNode = nodeToSplit;
       if (outLeftNode)  *outLeftNode  = tempNode;
     }
 
     res = nodeToSplit->GetParentNode(getter_AddRefs(parentNode));
     NS_ENSURE_SUCCESS(res, res);
-    if (!parentNode) return NS_ERROR_FAILURE;
+    NS_ENSURE_TRUE(parentNode, NS_ERROR_FAILURE);
 
     if (!bDoSplit && offset)  // must be "end of text node" case, we didn't split it, just move past it
     {
       offset = GetIndexOf(parentNode, nodeToSplit) +1;
       if (outLeftNode)  *outLeftNode  = nodeToSplit;
     }
     else
     {
@@ -4008,17 +4008,17 @@ nsEditor::SplitNodeDeep(nsIDOMNode *aNod
 // JoinNodeDeep:  this joins two like nodes "deeply", joining children as 
 //                appropriate.  
 nsresult
 nsEditor::JoinNodeDeep(nsIDOMNode *aLeftNode, 
                        nsIDOMNode *aRightNode,
                        nsCOMPtr<nsIDOMNode> *aOutJoinNode, 
                        PRInt32 *outOffset)
 {
-  if (!aLeftNode || !aRightNode || !aOutJoinNode || !outOffset) return NS_ERROR_NULL_POINTER;
+  NS_ENSURE_TRUE(aLeftNode && aRightNode && aOutJoinNode && outOffset, NS_ERROR_NULL_POINTER);
 
   // while the rightmost children and their descendants of the left node 
   // match the leftmost children and their descendants of the right node
   // join them up.  Can you say that three times fast?
   
   nsCOMPtr<nsIDOMNode> leftNodeToJoin = do_QueryInterface(aLeftNode);
   nsCOMPtr<nsIDOMNode> rightNodeToJoin = do_QueryInterface(aRightNode);
   nsCOMPtr<nsIDOMNode> parentNode,tmp;
@@ -4261,17 +4261,17 @@ nsEditor::DeleteSelectionAndCreateNode(c
   // XXX: ERROR_HANDLING  check result, and make sure aNewNode is set correctly in success/failure cases
   *aNewNode = newNode;
   NS_IF_ADDREF(*aNewNode);
 
   // we want the selection to be just after the new node
   nsCOMPtr<nsISelection> selection;
   result = GetSelection(getter_AddRefs(selection));
   NS_ENSURE_SUCCESS(result, result);
-  if (!selection) return NS_ERROR_NULL_POINTER;
+  NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
   return selection->Collapse(parentSelectedNode, offsetOfNewNode+1);
 }
 
 
 /* Non-interface, protected methods */
 
 nsresult
 nsEditor::GetIMEBufferLength(PRInt32* length)
@@ -4317,17 +4317,17 @@ nsEditor::IsIMEComposing() {
 
 NS_IMETHODIMP
 nsEditor::DeleteSelectionAndPrepareToCreateNode(nsCOMPtr<nsIDOMNode> &parentSelectedNode, PRInt32& offsetOfNewNode)
 {
   nsresult result=NS_ERROR_NOT_INITIALIZED;
   nsCOMPtr<nsISelection> selection;
   result = GetSelection(getter_AddRefs(selection));
   NS_ENSURE_SUCCESS(result, result);
-  if (!selection) return NS_ERROR_NULL_POINTER;
+  NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
 
   PRBool collapsed;
   result = selection->GetIsCollapsed(&collapsed);
   if (NS_SUCCEEDED(result) && !collapsed) 
   {
     result = DeleteSelection(nsIEditor::eNone);
     if (NS_FAILED(result)) {
       return result;
@@ -4579,17 +4579,17 @@ nsEditor::CreateTxnForDeleteSelection(ns
                                       PRInt32 *aOffset,
                                       PRInt32 *aLength)
 {
   if (!aTxn)
     return NS_ERROR_NULL_POINTER;
   *aTxn = nsnull;
 
   nsCOMPtr<nsISelectionController> selCon = do_QueryReferent(mSelConWeak);
-  if (!selCon) return NS_ERROR_NOT_INITIALIZED;
+  NS_ENSURE_TRUE(selCon, NS_ERROR_NOT_INITIALIZED);
   nsCOMPtr<nsISelection> selection;
   nsresult result = selCon->GetSelection(nsISelectionController::SELECTION_NORMAL,
                                          getter_AddRefs(selection));
   if ((NS_SUCCEEDED(result)) && selection)
   {
     // Check whether the selection is collapsed and we should do nothing:
     PRBool isCollapsed;
     result = (selection->GetIsCollapsed(&isCollapsed));
@@ -4897,45 +4897,45 @@ nsEditor::CreateRange(nsIDOMNode *aStart
     *aRange = 0;
   }
   return result;
 }
 
 nsresult 
 nsEditor::AppendNodeToSelectionAsRange(nsIDOMNode *aNode)
 {
-  if (!aNode) return NS_ERROR_NULL_POINTER;
+  NS_ENSURE_TRUE(aNode, NS_ERROR_NULL_POINTER);
   nsCOMPtr<nsISelection> selection;
   nsresult res = GetSelection(getter_AddRefs(selection));
   NS_ENSURE_SUCCESS(res, res);
   if(!selection) return NS_ERROR_FAILURE;
 
   nsCOMPtr<nsIDOMNode> parentNode;
   res = aNode->GetParentNode(getter_AddRefs(parentNode));
   NS_ENSURE_SUCCESS(res, res);
-  if (!parentNode) return NS_ERROR_NULL_POINTER;
+  NS_ENSURE_TRUE(parentNode, NS_ERROR_NULL_POINTER);
   
   PRInt32 offset;
   res = GetChildOffset(aNode, parentNode, offset);
   NS_ENSURE_SUCCESS(res, res);
   
   nsCOMPtr<nsIDOMRange> range;
   res = CreateRange(parentNode, offset, parentNode, offset+1, getter_AddRefs(range));
   NS_ENSURE_SUCCESS(res, res);
-  if (!range) return NS_ERROR_NULL_POINTER;
+  NS_ENSURE_TRUE(range, NS_ERROR_NULL_POINTER);
 
   return selection->AddRange(range);
 }
 
 nsresult nsEditor::ClearSelection()
 {
   nsCOMPtr<nsISelection> selection;
   nsresult res = nsEditor::GetSelection(getter_AddRefs(selection));
   NS_ENSURE_SUCCESS(res, res);
-  if (!selection) return NS_ERROR_FAILURE;
+  NS_ENSURE_TRUE(selection, NS_ERROR_FAILURE);
   return selection->RemoveAllRanges();  
 }
 
 nsresult
 nsEditor::CreateHTMLContent(const nsAString& aTag, nsIContent** aContent)
 {
   nsCOMPtr<nsIDOMDocument> tempDoc;
   GetDocument(getter_AddRefs(tempDoc));
@@ -5181,17 +5181,17 @@ nsEditor::DumpNode(nsIDOMNode *aNode, PR
       printf("<%s>\n", NS_LossyConvertUTF16toASCII(tag).get());
     }
     else
     {
       printf("<document fragment>\n");
     }
     nsCOMPtr<nsIDOMNodeList> childList;
     aNode->GetChildNodes(getter_AddRefs(childList));
-    if (!childList) return NS_ERROR_NULL_POINTER;
+    NS_ENSURE_TRUE(childList, NS_ERROR_NULL_POINTER);
     PRUint32 numChildren;
     childList->GetLength(&numChildren);
     nsCOMPtr<nsIDOMNode> child, tmp;
     aNode->GetFirstChild(getter_AddRefs(child));
     for (i=0; i<numChildren; i++)
     {
       DumpNode(child, indent+1);
       child->GetNextSibling(getter_AddRefs(tmp));

--- a/editor/libeditor/base/nsEditorCommands.cpp
+++ b/editor/libeditor/base/nsEditorCommands.cpp
@@ -167,17 +167,17 @@ nsClearUndoCommand::IsCommandEnabled(con
   return NS_OK;
 }
   
 
 NS_IMETHODIMP
 nsClearUndoCommand::DoCommand(const char *aCommandName, nsISupports *refCon)
 { 
   nsCOMPtr<nsIEditor> editor = do_QueryInterface(refCon);
-  if (!editor) return NS_ERROR_NOT_IMPLEMENTED;
+  NS_ENSURE_TRUE(editor, NS_ERROR_NOT_IMPLEMENTED);
   
   editor->EnableUndo(PR_FALSE);  // Turning off undo clears undo/redo stacks.
   editor->EnableUndo(PR_TRUE);   // This re-enables undo/redo.
   
   return NS_OK;
 }
                                   
 NS_IMETHODIMP                       

--- a/editor/libeditor/base/nsEditorController.cpp
+++ b/editor/libeditor/base/nsEditorController.cpp
@@ -44,26 +44,26 @@
 #include "nsIControllerCommandTable.h"
 
 
 
 #define NS_REGISTER_ONE_COMMAND(_cmdClass, _cmdName)                                      \
   {                                                                                       \
     _cmdClass* theCmd;                                                                    \
     NS_NEWXPCOM(theCmd, _cmdClass);                                                       \
-    if (!theCmd) return NS_ERROR_OUT_OF_MEMORY;                                           \
+    NS_ENSURE_TRUE(theCmd, NS_ERROR_OUT_OF_MEMORY);                                           \
     rv = inCommandTable->RegisterCommand(_cmdName,                                        \
                                    static_cast<nsIControllerCommand *>(theCmd));          \
   }
 
 #define NS_REGISTER_FIRST_COMMAND(_cmdClass, _cmdName)                                    \
   {                                                                                       \
     _cmdClass* theCmd;                                                                    \
     NS_NEWXPCOM(theCmd, _cmdClass);                                                       \
-    if (!theCmd) return NS_ERROR_OUT_OF_MEMORY;                                           \
+    NS_ENSURE_TRUE(theCmd, NS_ERROR_OUT_OF_MEMORY);                                           \
     rv = inCommandTable->RegisterCommand(_cmdName,                                        \
                                    static_cast<nsIControllerCommand *>(theCmd));
 
 #define NS_REGISTER_NEXT_COMMAND(_cmdClass, _cmdName)                                     \
     rv = inCommandTable->RegisterCommand(_cmdName,                                        \
                                    static_cast<nsIControllerCommand *>(theCmd));
 
 #define NS_REGISTER_LAST_COMMAND(_cmdClass, _cmdName)                                     \

--- a/editor/libeditor/base/nsEditorEventListener.cpp
+++ b/editor/libeditor/base/nsEditorEventListener.cpp
@@ -736,17 +736,17 @@ nsEditorEventListener::CanDrop(nsIDOMDra
     PRBool isCollapsed;
     rv = selection->GetIsCollapsed(&isCollapsed);
     NS_ENSURE_SUCCESS(rv, PR_FALSE);
   
     // Don't bother if collapsed - can always drop
     if (!isCollapsed)
     {
       nsCOMPtr<nsIDOMNSUIEvent> nsuiEvent (do_QueryInterface(aEvent));
-      if (!nsuiEvent) return PR_FALSE;
+      NS_ENSURE_TRUE(nsuiEvent, PR_FALSE);
 
       nsCOMPtr<nsIDOMNode> parent;
       rv = nsuiEvent->GetRangeParent(getter_AddRefs(parent));
       if (NS_FAILED(rv) || !parent) return PR_FALSE;
 
       PRInt32 offset = 0;
       rv = nsuiEvent->GetRangeOffset(&offset);
       NS_ENSURE_SUCCESS(rv, PR_FALSE);

--- a/editor/libeditor/base/nsEditorUtils.cpp
+++ b/editor/libeditor/base/nsEditorUtils.cpp
@@ -101,27 +101,27 @@ nsDOMIterator::~nsDOMIterator()
 }
     
 nsresult
 nsDOMIterator::Init(nsIDOMRange* aRange)
 {
   nsresult res;
   mIter = do_CreateInstance("@mozilla.org/content/post-content-iterator;1", &res);
   NS_ENSURE_SUCCESS(res, res);
-  if (!mIter) return NS_ERROR_FAILURE;
+  NS_ENSURE_TRUE(mIter, NS_ERROR_FAILURE);
   return mIter->Init(aRange);
 }
 
 nsresult
 nsDOMIterator::Init(nsIDOMNode* aNode)
 {
   nsresult res;
   mIter = do_CreateInstance("@mozilla.org/content/post-content-iterator;1", &res);
   NS_ENSURE_SUCCESS(res, res);
-  if (!mIter) return NS_ERROR_FAILURE;
+  NS_ENSURE_TRUE(mIter, NS_ERROR_FAILURE);
   nsCOMPtr<nsIContent> content = do_QueryInterface(aNode);
   return mIter->Init(content);
 }
 
 void
 nsDOMIterator::ForEach(nsDomIterFunctor& functor) const
 {
   nsCOMPtr<nsIDOMNode> node;
@@ -169,39 +169,39 @@ nsDOMSubtreeIterator::~nsDOMSubtreeItera
 }
     
 nsresult
 nsDOMSubtreeIterator::Init(nsIDOMRange* aRange)
 {
   nsresult res;
   mIter = do_CreateInstance("@mozilla.org/content/subtree-content-iterator;1", &res);
   NS_ENSURE_SUCCESS(res, res);
-  if (!mIter) return NS_ERROR_FAILURE;
+  NS_ENSURE_TRUE(mIter, NS_ERROR_FAILURE);
   return mIter->Init(aRange);
 }
 
 nsresult
 nsDOMSubtreeIterator::Init(nsIDOMNode* aNode)
 {
   nsresult res;
   mIter = do_CreateInstance("@mozilla.org/content/subtree-content-iterator;1", &res);
   NS_ENSURE_SUCCESS(res, res);
-  if (!mIter) return NS_ERROR_FAILURE;
+  NS_ENSURE_TRUE(mIter, NS_ERROR_FAILURE);
   nsCOMPtr<nsIContent> content = do_QueryInterface(aNode);
   return mIter->Init(content);
 }
 
 /******************************************************************************
  * some general purpose editor utils
  *****************************************************************************/
 
 PRBool 
 nsEditorUtils::IsDescendantOf(nsIDOMNode *aNode, nsIDOMNode *aParent, PRInt32 *aOffset) 
 {
-  if (!aNode && !aParent) return PR_FALSE;
+  NS_ENSURE_TRUE(aNode || aParent, PR_FALSE);
   if (aNode == aParent) return PR_FALSE;
   
   nsCOMPtr<nsIDOMNode> parent, node = do_QueryInterface(aNode);
   nsresult res;
   
   do
   {
     res = node->GetParentNode(getter_AddRefs(parent));
@@ -238,22 +238,22 @@ nsEditorUtils::IsLeafNode(nsIDOMNode *aN
  * utility methods for drag/drop/copy/paste hooks
  *****************************************************************************/
 
 nsresult
 nsEditorHookUtils::GetHookEnumeratorFromDocument(nsIDOMDocument *aDoc,
                                                  nsISimpleEnumerator **aResult)
 {
   nsCOMPtr<nsIDocument> doc = do_QueryInterface(aDoc);
-  if (!doc) return NS_ERROR_FAILURE;
+  NS_ENSURE_TRUE(doc, NS_ERROR_FAILURE);
 
   nsCOMPtr<nsISupports> container = doc->GetContainer();
   nsCOMPtr<nsIDocShell> docShell = do_QueryInterface(container);
   nsCOMPtr<nsIClipboardDragDropHookList> hookObj = do_GetInterface(docShell);
-  if (!hookObj) return NS_ERROR_FAILURE;
+  NS_ENSURE_TRUE(hookObj, NS_ERROR_FAILURE);
 
   return hookObj->GetHookEnumerator(aResult);
 }
 
 PRBool
 nsEditorHookUtils::DoInsertionHook(nsIDOMDocument *aDoc, nsIDOMEvent *aDropEvent,  
                                    nsITransferable *aTrans)
 {

--- a/editor/libeditor/base/nsSelectionState.cpp
+++ b/editor/libeditor/base/nsSelectionState.cpp
@@ -69,17 +69,17 @@ nsSelectionState::DoTraverse(nsCycleColl
                                        "selection state mArray[i].endNode");
     cb.NoteXPCOMChild(item.endNode);
   }
 }
 
 nsresult  
 nsSelectionState::SaveSelection(nsISelection *aSel)
 {
-  if (!aSel) return NS_ERROR_NULL_POINTER;
+  NS_ENSURE_TRUE(aSel, NS_ERROR_NULL_POINTER);
   PRInt32 i,rangeCount, arrayCount = mArray.Length();
   aSel->GetRangeCount(&rangeCount);
   
   // if we need more items in the array, new them
   if (arrayCount<rangeCount)
   {
     PRInt32 count = rangeCount-arrayCount;
     for (i=0; i<count; i++)
@@ -107,63 +107,63 @@ nsSelectionState::SaveSelection(nsISelec
   }
   
   return res;
 }
 
 nsresult  
 nsSelectionState::RestoreSelection(nsISelection *aSel)
 {
-  if (!aSel) return NS_ERROR_NULL_POINTER;
+  NS_ENSURE_TRUE(aSel, NS_ERROR_NULL_POINTER);
   nsresult res;
   PRUint32 i, arrayCount = mArray.Length();
 
   // clear out selection
   aSel->RemoveAllRanges();
   
   // set the selection ranges anew
   for (i=0; i<arrayCount; i++)
   {
     nsCOMPtr<nsIDOMRange> range;
     mArray[i].GetRange(address_of(range));
-    if (!range) return NS_ERROR_UNEXPECTED;
+    NS_ENSURE_TRUE(range, NS_ERROR_UNEXPECTED);
    
     res = aSel->AddRange(range);
     if(NS_FAILED(res)) return res;
 
   }
   return NS_OK;
 }
 
 PRBool
 nsSelectionState::IsCollapsed()
 {
   if (1 != mArray.Length()) return PR_FALSE;
   nsCOMPtr<nsIDOMRange> range;
   mArray[0].GetRange(address_of(range));
-  if (!range) return PR_FALSE;
+  NS_ENSURE_TRUE(range, PR_FALSE);
   PRBool bIsCollapsed;
   range->GetCollapsed(&bIsCollapsed);
   return bIsCollapsed;
 }
 
 PRBool
 nsSelectionState::IsEqual(nsSelectionState *aSelState)
 {
-  if (!aSelState) return NS_ERROR_NULL_POINTER;
+  NS_ENSURE_TRUE(aSelState, NS_ERROR_NULL_POINTER);
   PRUint32 i, myCount = mArray.Length(), itsCount = aSelState->mArray.Length();
   if (myCount != itsCount) return PR_FALSE;
   if (myCount < 1) return PR_FALSE;
 
   for (i=0; i<myCount; i++)
   {
     nsCOMPtr<nsIDOMRange> myRange, itsRange;
     mArray[i].GetRange(address_of(myRange));
     aSelState->mArray[i].GetRange(address_of(itsRange));
-    if (!myRange || !itsRange) return PR_FALSE;
+    NS_ENSURE_TRUE(myRange && itsRange, PR_FALSE);
   
     PRInt16 compResult;
     myRange->CompareBoundaryPoints(nsIDOMRange::START_TO_START, itsRange, &compResult);
     if (compResult) return PR_FALSE;
     myRange->CompareBoundaryPoints(nsIDOMRange::END_TO_END, itsRange, &compResult);
     if (compResult) return PR_FALSE;
   }
   // if we got here, they are equal
@@ -242,26 +242,26 @@ nsRangeUpdater::DropSelectionState(nsSel
 }
 
 // gravity methods:
 
 nsresult
 nsRangeUpdater::SelAdjCreateNode(nsIDOMNode *aParent, PRInt32 aPosition)
 {
   if (mLock) return NS_OK;  // lock set by Will/DidReplaceParent, etc...
-  if (!aParent) return NS_ERROR_NULL_POINTER;
+  NS_ENSURE_TRUE(aParent, NS_ERROR_NULL_POINTER);
   PRUint32 i, count = mArray.Length();
-  if (!count) return NS_OK;
+  NS_ENSURE_TRUE(count, NS_OK);
 
   nsRangeStore *item;
   
   for (i=0; i<count; i++)
   {
     item = mArray[i];
-    if (!item) return NS_ERROR_NULL_POINTER;
+    NS_ENSURE_TRUE(item, NS_ERROR_NULL_POINTER);
     
     if ((item->startNode.get() == aParent) && (item->startOffset > aPosition))
       item->startOffset++;
     if ((item->endNode.get() == aParent) && (item->endOffset > aPosition))
       item->endOffset++;
   }
   return NS_OK;
 }
@@ -272,32 +272,32 @@ nsRangeUpdater::SelAdjInsertNode(nsIDOMN
   return SelAdjCreateNode(aParent, aPosition);
 }
 
 
 nsresult
 nsRangeUpdater::SelAdjDeleteNode(nsIDOMNode *aNode)
 {
   if (mLock) return NS_OK;  // lock set by Will/DidReplaceParent, etc...
-  if (!aNode) return NS_ERROR_NULL_POINTER;
+  NS_ENSURE_TRUE(aNode, NS_ERROR_NULL_POINTER);
   PRUint32 i, count = mArray.Length();
-  if (!count) return NS_OK;
+  NS_ENSURE_TRUE(count, NS_OK);
 
   nsCOMPtr<nsIDOMNode> parent;
   PRInt32 offset = 0;
   
   nsresult res = nsEditor::GetNodeLocation(aNode, address_of(parent), &offset);
   NS_ENSURE_SUCCESS(res, res);
   
   // check for range endpoints that are after aNode and in the same parent
   nsRangeStore *item;
   for (i=0; i<count; i++)
   {
     item = mArray[i];
-    if (!item) return NS_ERROR_NULL_POINTER;
+    NS_ENSURE_TRUE(item, NS_ERROR_NULL_POINTER);
     
     if ((item->startNode.get() == parent) && (item->startOffset > offset))
       item->startOffset--;
     if ((item->endNode.get() == parent) && (item->endOffset > offset))
       item->endOffset--;
       
     // check for range endpoints that are in aNode
     if (item->startNode == aNode)
@@ -330,36 +330,36 @@ nsRangeUpdater::SelAdjDeleteNode(nsIDOMN
   return NS_OK;
 }
 
 
 nsresult
 nsRangeUpdater::SelAdjSplitNode(nsIDOMNode *aOldRightNode, PRInt32 aOffset, nsIDOMNode *aNewLeftNode)
 {
   if (mLock) return NS_OK;  // lock set by Will/DidReplaceParent, etc...
-  if (!aOldRightNode || !aNewLeftNode) return NS_ERROR_NULL_POINTER;
+  NS_ENSURE_TRUE(aOldRightNode && aNewLeftNode, NS_ERROR_NULL_POINTER);
   PRUint32 i, count = mArray.Length();
-  if (!count) return NS_OK;
+  NS_ENSURE_TRUE(count, NS_OK);
 
   nsCOMPtr<nsIDOMNode> parent;
   PRInt32 offset;
   nsresult result = nsEditor::GetNodeLocation(aOldRightNode, address_of(parent), &offset);
   NS_ENSURE_SUCCESS(result, result);
   
   // first part is same as inserting aNewLeftnode
   result = SelAdjInsertNode(parent,offset-1);
   NS_ENSURE_SUCCESS(result, result);
 
   // next step is to check for range enpoints inside aOldRightNode
   nsRangeStore *item;
   
   for (i=0; i<count; i++)
   {
     item = mArray[i];
-    if (!item) return NS_ERROR_NULL_POINTER;
+    NS_ENSURE_TRUE(item, NS_ERROR_NULL_POINTER);
     
     if (item->startNode.get() == aOldRightNode)
     {
       if (item->startOffset > aOffset)
       {
         item->startOffset -= aOffset;
       }
       else
@@ -386,26 +386,26 @@ nsRangeUpdater::SelAdjSplitNode(nsIDOMNo
 nsresult
 nsRangeUpdater::SelAdjJoinNodes(nsIDOMNode *aLeftNode, 
                                   nsIDOMNode *aRightNode, 
                                   nsIDOMNode *aParent, 
                                   PRInt32 aOffset,
                                   PRInt32 aOldLeftNodeLength)
 {
   if (mLock) return NS_OK;  // lock set by Will/DidReplaceParent, etc...
-  if (!aLeftNode || !aRightNode || !aParent) return NS_ERROR_NULL_POINTER;
+  NS_ENSURE_TRUE(aLeftNode && aRightNode && aParent, NS_ERROR_NULL_POINTER);
   PRUint32 i, count = mArray.Length();
-  if (!count) return NS_OK;
+  NS_ENSURE_TRUE(count, NS_OK);
 
   nsRangeStore *item;
 
   for (i=0; i<count; i++)
   {
     item = mArray[i];
-    if (!item) return NS_ERROR_NULL_POINTER;
+    NS_ENSURE_TRUE(item, NS_ERROR_NULL_POINTER);
     
     if (item->startNode.get() == aParent)
     {
       // adjust start point in aParent
       if (item->startOffset > aOffset)
       {
         item->startOffset--;
       }
@@ -458,51 +458,51 @@ nsRangeUpdater::SelAdjJoinNodes(nsIDOMNo
 
 
 nsresult
 nsRangeUpdater::SelAdjInsertText(nsIDOMCharacterData *aTextNode, PRInt32 aOffset, const nsAString &aString)
 {
   if (mLock) return NS_OK;  // lock set by Will/DidReplaceParent, etc...
 
   PRUint32 count = mArray.Length();
-  if (!count) return NS_OK;
+  NS_ENSURE_TRUE(count, NS_OK);
   nsCOMPtr<nsIDOMNode> node(do_QueryInterface(aTextNode));
-  if (!node) return NS_ERROR_NULL_POINTER;
+  NS_ENSURE_TRUE(node, NS_ERROR_NULL_POINTER);
   
   PRUint32 len=aString.Length(), i;
   nsRangeStore *item;
   for (i=0; i<count; i++)
   {
     item = mArray[i];
-    if (!item) return NS_ERROR_NULL_POINTER;
+    NS_ENSURE_TRUE(item, NS_ERROR_NULL_POINTER);
     
     if ((item->startNode.get() == node) && (item->startOffset > aOffset))
       item->startOffset += len;
     if ((item->endNode.get() == node) && (item->endOffset > aOffset))
       item->endOffset += len;
   }
   return NS_OK;
 }
 
 
 nsresult
 nsRangeUpdater::SelAdjDeleteText(nsIDOMCharacterData *aTextNode, PRInt32 aOffset, PRInt32 aLength)
 {
   if (mLock) return NS_OK;  // lock set by Will/DidReplaceParent, etc...
 
   PRUint32 i, count = mArray.Length();
-  if (!count) return NS_OK;
+  NS_ENSURE_TRUE(count, NS_OK);
   nsRangeStore *item;
   nsCOMPtr<nsIDOMNode> node(do_QueryInterface(aTextNode));
-  if (!node) return NS_ERROR_NULL_POINTER;
+  NS_ENSURE_TRUE(node, NS_ERROR_NULL_POINTER);
   
   for (i=0; i<count; i++)
   {
     item = mArray[i];
-    if (!item) return NS_ERROR_NULL_POINTER;
+    NS_ENSURE_TRUE(item, NS_ERROR_NULL_POINTER);
     
     if ((item->startNode.get() == node) && (item->startOffset > aOffset))
     {
       item->startOffset -= aLength;
       if (item->startOffset < 0) item->startOffset = 0;
     }
     if ((item->endNode.get() == node) && (item->endOffset > aOffset))
     {
@@ -521,29 +521,29 @@ nsRangeUpdater::WillReplaceContainer()
   mLock = PR_TRUE;
   return NS_OK;
 }
 
 
 nsresult
 nsRangeUpdater::DidReplaceContainer(nsIDOMNode *aOriginalNode, nsIDOMNode *aNewNode)
 {
-  if (!mLock) return NS_ERROR_UNEXPECTED;  
+  NS_ENSURE_TRUE(mLock, NS_ERROR_UNEXPECTED);  
   mLock = PR_FALSE;
 
-  if (!aOriginalNode || !aNewNode) return NS_ERROR_NULL_POINTER;
+  NS_ENSURE_TRUE(aOriginalNode && aNewNode, NS_ERROR_NULL_POINTER);
   PRUint32 i, count = mArray.Length();
-  if (!count) return NS_OK;
+  NS_ENSURE_TRUE(count, NS_OK);
 
   nsRangeStore *item;
   
   for (i=0; i<count; i++)
   {
     item = mArray[i];
-    if (!item) return NS_ERROR_NULL_POINTER;
+    NS_ENSURE_TRUE(item, NS_ERROR_NULL_POINTER);
     
     if (item->startNode.get() == aOriginalNode)
       item->startNode = aNewNode;
     if (item->endNode.get() == aOriginalNode)
       item->endNode = aNewNode;
   }
   return NS_OK;
 }
@@ -556,29 +556,29 @@ nsRangeUpdater::WillRemoveContainer()
   mLock = PR_TRUE;
   return NS_OK;
 }
 
 
 nsresult
 nsRangeUpdater::DidRemoveContainer(nsIDOMNode *aNode, nsIDOMNode *aParent, PRInt32 aOffset, PRUint32 aNodeOrigLen)
 {
-  if (!mLock) return NS_ERROR_UNEXPECTED;  
+  NS_ENSURE_TRUE(mLock, NS_ERROR_UNEXPECTED);  
   mLock = PR_FALSE;
 
-  if (!aNode || !aParent) return NS_ERROR_NULL_POINTER;
+  NS_ENSURE_TRUE(aNode && aParent, NS_ERROR_NULL_POINTER);
   PRUint32 i, count = mArray.Length();
-  if (!count) return NS_OK;
+  NS_ENSURE_TRUE(count, NS_OK);
 
   nsRangeStore *item;
   
   for (i=0; i<count; i++)
   {
     item = mArray[i];
-    if (!item) return NS_ERROR_NULL_POINTER;
+    NS_ENSURE_TRUE(item, NS_ERROR_NULL_POINTER);
     
     if (item->startNode.get() == aNode)
     {
       item->startNode = aParent;
       item->startOffset += aOffset;
     }
     else if ((item->startNode.get() == aParent) && (item->startOffset > aOffset))
       item->startOffset += (PRInt32)aNodeOrigLen-1;
@@ -602,17 +602,17 @@ nsRangeUpdater::WillInsertContainer()
   mLock = PR_TRUE;
   return NS_OK;
 }
 
 
 nsresult
 nsRangeUpdater::DidInsertContainer()
 {
-  if (!mLock) return NS_ERROR_UNEXPECTED;  
+  NS_ENSURE_TRUE(mLock, NS_ERROR_UNEXPECTED);  
   mLock = PR_FALSE;
   return NS_OK;
 }
 
 
 nsresult
 nsRangeUpdater::WillMoveNode()
 {
@@ -620,29 +620,29 @@ nsRangeUpdater::WillMoveNode()
   mLock = PR_TRUE;
   return NS_OK;
 }
 
 
 nsresult
 nsRangeUpdater::DidMoveNode(nsIDOMNode *aOldParent, PRInt32 aOldOffset, nsIDOMNode *aNewParent, PRInt32 aNewOffset)
 {
-  if (!mLock) return NS_ERROR_UNEXPECTED;  
+  NS_ENSURE_TRUE(mLock, NS_ERROR_UNEXPECTED);  
   mLock = PR_FALSE;
 
-  if (!aOldParent || !aNewParent) return NS_ERROR_NULL_POINTER;
+  NS_ENSURE_TRUE(aOldParent && aNewParent, NS_ERROR_NULL_POINTER);
   PRUint32 i, count = mArray.Length();
-  if (!count) return NS_OK;
+  NS_ENSURE_TRUE(count, NS_OK);
 
   nsRangeStore *item;
   
   for (i=0; i<count; i++)
   {
     item = mArray[i];
-    if (!item) return NS_ERROR_NULL_POINTER;
+    NS_ENSURE_TRUE(item, NS_ERROR_NULL_POINTER);
     
     // like a delete in aOldParent
     if ((item->startNode.get() == aOldParent) && (item->startOffset > aOldOffset))
       item->startOffset--;
     if ((item->endNode.get() == aOldParent) && (item->endOffset > aOldOffset))
       item->endOffset--;
       
     // and like an insert in aNewParent
@@ -668,27 +668,27 @@ nsRangeStore::nsRangeStore()
 }
 nsRangeStore::~nsRangeStore()
 {
   // DEBUG: n--;  printf("range store alloc count=%d\n", n); 
 }
 
 nsresult nsRangeStore::StoreRange(nsIDOMRange *aRange)
 {
-  if (!aRange) return NS_ERROR_NULL_POINTER;
+  NS_ENSURE_TRUE(aRange, NS_ERROR_NULL_POINTER);
   aRange->GetStartContainer(getter_AddRefs(startNode));
   aRange->GetEndContainer(getter_AddRefs(endNode));
   aRange->GetStartOffset(&startOffset);
   aRange->GetEndOffset(&endOffset);
   return NS_OK;
 }
 
 nsresult nsRangeStore::GetRange(nsCOMPtr<nsIDOMRange> *outRange)
 {
-  if (!outRange) return NS_ERROR_NULL_POINTER;
+  NS_ENSURE_TRUE(outRange, NS_ERROR_NULL_POINTER);
   nsresult res;
   *outRange = do_CreateInstance("@mozilla.org/content/range;1", &res);
   if(NS_FAILED(res)) return res;
 
   res = (*outRange)->SetStart(startNode, startOffset);
   if(NS_FAILED(res)) return res;
 
   res = (*outRange)->SetEnd(endNode, endOffset);

--- a/editor/libeditor/html/TypeInState.cpp
+++ b/editor/libeditor/html/TypeInState.cpp
@@ -64,17 +64,17 @@ TypeInState::~TypeInState()
   // Call Reset() to release any data that may be in
   // mClearedArray and mSetArray.
 
   Reset();
 }
 
 nsresult TypeInState::UpdateSelState(nsISelection *aSelection)
 {
-  if (!aSelection) return NS_ERROR_NULL_POINTER;
+  NS_ENSURE_TRUE(aSelection, NS_ERROR_NULL_POINTER);
   
   PRBool isCollapsed = PR_FALSE;
   nsresult result = aSelection->GetIsCollapsed(&isCollapsed);
 
   NS_ENSURE_SUCCESS(result, result);
 
   if (isCollapsed)
   {
@@ -177,17 +177,17 @@ nsresult TypeInState::SetProp(nsIAtom *a
     // if it's already set, update the value
     item = mSetArray[index];
     item->value = aValue;
   }
   else 
   {
     // make a new propitem
     item = new PropItem(aProp,aAttr,aValue);
-    if (!item) return NS_ERROR_OUT_OF_MEMORY;
+    NS_ENSURE_TRUE(item, NS_ERROR_OUT_OF_MEMORY);
     
     // add it to the list of set properties
     mSetArray.AppendElement(item);
     
     // remove it from the list of cleared properties, if we have a match
     RemovePropFromClearedList(aProp,aAttr);  
   }
     
@@ -208,17 +208,17 @@ nsresult TypeInState::ClearProp(nsIAtom 
 
 nsresult TypeInState::ClearProp(nsIAtom *aProp, const nsString &aAttr)
 {
   // if it's already cleared we are done
   if (IsPropCleared(aProp,aAttr)) return NS_OK;
   
   // make a new propitem
   PropItem *item = new PropItem(aProp,aAttr,EmptyString());
-  if (!item) return NS_ERROR_OUT_OF_MEMORY;
+  NS_ENSURE_TRUE(item, NS_ERROR_OUT_OF_MEMORY);
   
   // remove it from the list of set properties, if we have a match
   RemovePropFromSetList(aProp,aAttr);
   
   // add it to the list of cleared properties
   mClearedArray.AppendElement(item);
   
   return NS_OK;
@@ -226,17 +226,17 @@ nsresult TypeInState::ClearProp(nsIAtom 
 
 
 /***************************************************************************
  *    TakeClearProperty: hands back next property item on the clear list.
  *                       caller assumes ownership of PropItem and must delete it.
  */  
 nsresult TypeInState::TakeClearProperty(PropItem **outPropItem)
 {
-  if (!outPropItem) return NS_ERROR_NULL_POINTER;
+  NS_ENSURE_TRUE(outPropItem, NS_ERROR_NULL_POINTER);
   *outPropItem = nsnull;
   PRUint32 count = mClearedArray.Length();
   if (count)
   {
     count--; // indizes are zero based
     *outPropItem = mClearedArray[count];
     mClearedArray.RemoveElementAt(count);
   }
@@ -244,34 +244,34 @@ nsresult TypeInState::TakeClearProperty(
 }
 
 /***************************************************************************
  *    TakeSetProperty: hands back next poroperty item on the set list.
  *                     caller assumes ownership of PropItem and must delete it.
  */  
 nsresult TypeInState::TakeSetProperty(PropItem **outPropItem)
 {
-  if (!outPropItem) return NS_ERROR_NULL_POINTER;
+  NS_ENSURE_TRUE(outPropItem, NS_ERROR_NULL_POINTER);
   *outPropItem = nsnull;
   PRUint32 count = mSetArray.Length();
   if (count)
   {
     count--; // indizes are zero based
     *outPropItem = mSetArray[count];
     mSetArray.RemoveElementAt(count);
   }
   return NS_OK;
 }
 
 //**************************************************************************
 //    TakeRelativeFontSize: hands back relative font value, which is then
 //                          cleared out.
 nsresult TypeInState::TakeRelativeFontSize(PRInt32 *outRelSize)
 {
-  if (!outRelSize) return NS_ERROR_NULL_POINTER;
+  NS_ENSURE_TRUE(outRelSize, NS_ERROR_NULL_POINTER);
   *outRelSize = mRelativeFontSize;
   mRelativeFontSize = 0;
   return NS_OK;
 }
 
 nsresult TypeInState::GetTypingState(PRBool &isSet, PRBool &theSetting, nsIAtom *aProp)
 {
   return GetTypingState(isSet, theSetting, aProp, EmptyString(), nsnull);

--- a/editor/libeditor/html/nsHTMLAbsPosition.cpp
+++ b/editor/libeditor/html/nsHTMLAbsPosition.cpp
@@ -77,17 +77,17 @@ nsHTMLEditor::AbsolutePositionSelection(
                                             kOpRemoveAbsolutePosition,
                                  nsIEditor::eNext);
   
   // the line below does not match the code; should it be removed?
   // Find out if the selection is collapsed:
   nsCOMPtr<nsISelection> selection;
   nsresult res = GetSelection(getter_AddRefs(selection));
   NS_ENSURE_SUCCESS(res, res);
-  if (!selection) return NS_ERROR_NULL_POINTER;
+  NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
 
   nsTextRulesInfo ruleInfo(aEnabled ?
                            nsTextEditRules::kSetAbsolutePosition :
                            nsTextEditRules::kRemoveAbsolutePosition);
   PRBool cancel, handled;
   res = mRules->WillDoAction(selection, &ruleInfo, &cancel, &handled);
   if (NS_FAILED(res) || cancel)
     return res;
@@ -193,17 +193,17 @@ nsHTMLEditor::RelativeChangeZIndex(PRInt
                                                  kOpIncreaseZIndex,
                                  nsIEditor::eNext);
   
   // brade: can we get rid of this comment?
   // Find out if the selection is collapsed:
   nsCOMPtr<nsISelection> selection;
   nsresult res = GetSelection(getter_AddRefs(selection));
   NS_ENSURE_SUCCESS(res, res);
-  if (!selection) return NS_ERROR_NULL_POINTER;
+  NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
   nsTextRulesInfo ruleInfo((aChange < 0) ? nsTextEditRules::kDecreaseZIndex:
                                            nsTextEditRules::kIncreaseZIndex);
   PRBool cancel, handled;
   res = mRules->WillDoAction(selection, &ruleInfo, &cancel, &handled);
   if (cancel || NS_FAILED(res))
     return res;
   
   return mRules->DidDoAction(selection, &ruleInfo, res);
@@ -317,17 +317,17 @@ nsHTMLEditor::HideGrabber()
   // are no document observers to notify, but we still want to
   // UnbindFromTree.
 
   nsCOMPtr<nsIDOMNode> parentNode;
   res = mGrabber->GetParentNode(getter_AddRefs(parentNode));
   NS_ENSURE_SUCCESS(res, res);
 
   nsCOMPtr<nsIContent> parentContent = do_QueryInterface(parentNode);
-  if (!parentContent) return NS_ERROR_NULL_POINTER;
+  NS_ENSURE_TRUE(parentContent, NS_ERROR_NULL_POINTER);
 
   DeleteRefToAnonymousNode(mGrabber, parentContent, ps);
   mGrabber = nsnull;
   DeleteRefToAnonymousNode(mPositioningShadow, parentContent, ps);
   mPositioningShadow = nsnull;
 
   return NS_OK;
 }
@@ -424,24 +424,24 @@ nsHTMLEditor::GrabberClicked()
   return res;
 }
 
 nsresult
 nsHTMLEditor::EndMoving()
 {
   if (mPositioningShadow) {
     nsCOMPtr<nsIPresShell> ps = do_QueryReferent(mPresShellWeak);
-    if (!ps) return NS_ERROR_NOT_INITIALIZED;
+    NS_ENSURE_TRUE(ps, NS_ERROR_NOT_INITIALIZED);
 
     nsCOMPtr<nsIDOMNode> parentNode;
     nsresult res = mGrabber->GetParentNode(getter_AddRefs(parentNode));
     NS_ENSURE_SUCCESS(res, res);
 
     nsCOMPtr<nsIContent> parentContent( do_QueryInterface(parentNode) );
-    if (!parentContent) return NS_ERROR_FAILURE;
+    NS_ENSURE_TRUE(parentContent, NS_ERROR_FAILURE);
 
     DeleteRefToAnonymousNode(mPositioningShadow, parentContent, ps);
 
     mPositioningShadow = nsnull;
   }
   nsCOMPtr<nsPIDOMEventTarget> piTarget = GetPIDOMEventTarget();
 
   if (piTarget && mMouseMotionListenerP) {
@@ -552,17 +552,17 @@ nsHTMLEditor::AbsolutelyPositionElement(
     // container
     nsCOMPtr<nsIDOMNode> parentNode;
     res = aElement->GetParentNode(getter_AddRefs(parentNode));
     NS_ENSURE_SUCCESS(res, res);
 
     nsCOMPtr<nsIDOMNodeList> childNodes;
     res = parentNode->GetChildNodes(getter_AddRefs(childNodes));
     NS_ENSURE_SUCCESS(res, res);
-    if (!childNodes) return NS_ERROR_NULL_POINTER;
+    NS_ENSURE_TRUE(childNodes, NS_ERROR_NULL_POINTER);
     PRUint32 childCount;
     res = childNodes->GetLength(&childCount);
     NS_ENSURE_SUCCESS(res, res);
 
     if (childCount == 1) {
       nsCOMPtr<nsIDOMNode> brNode;
       res = CreateBR(parentNode, 0, address_of(brNode));
     }
@@ -590,17 +590,17 @@ nsHTMLEditor::AbsolutelyPositionElement(
                                        EmptyString(), PR_FALSE);
     }
 
     PRBool hasStyleOrIdOrClass;
     res = HasStyleOrIdOrClass(aElement, &hasStyleOrIdOrClass);
     NS_ENSURE_SUCCESS(res, res);
     if (!hasStyleOrIdOrClass && nsHTMLEditUtils::IsDiv(aElement)) {
       nsCOMPtr<nsIHTMLEditRules> htmlRules = do_QueryInterface(mRules);
-      if (!htmlRules) return NS_ERROR_FAILURE;
+      NS_ENSURE_TRUE(htmlRules, NS_ERROR_FAILURE);
       res = htmlRules->MakeSureElemStartsOrEndsOnCR(aElement);
       NS_ENSURE_SUCCESS(res, res);
       res = RemoveContainer(aElement);
     }
   }
   return res;
 }
 

--- a/editor/libeditor/html/nsHTMLAnonymousUtils.cpp
+++ b/editor/libeditor/html/nsHTMLAnonymousUtils.cpp
@@ -149,21 +149,21 @@ nsHTMLEditor::CreateAnonymousElement(con
   nsCOMPtr<nsIContent> parentContent( do_QueryInterface(aParentNode) );
   if (!parentContent)
     return NS_OK;
 
   // Get the document
   nsCOMPtr<nsIDOMDocument> domDoc;
   GetDocument(getter_AddRefs(domDoc));
   nsCOMPtr<nsIDocument> doc = do_QueryInterface(domDoc);
-  if (!doc) return NS_ERROR_NULL_POINTER;
+  NS_ENSURE_TRUE(doc, NS_ERROR_NULL_POINTER);
 
   // Get the pres shell
   nsCOMPtr<nsIPresShell> ps = do_QueryReferent(mPresShellWeak);
-  if (!ps) return NS_ERROR_NOT_INITIALIZED;
+  NS_ENSURE_TRUE(ps, NS_ERROR_NOT_INITIALIZED);
 
   // Create a new node through the element factory
   nsCOMPtr<nsIContent> newContent;
   nsresult res = CreateHTMLContent(aTag, getter_AddRefs(newContent));
   NS_ENSURE_SUCCESS(res, res);
 
   nsCOMPtr<nsIDOMElement> newElement = do_QueryInterface(newContent);
   if (!newElement)
@@ -287,17 +287,17 @@ nsHTMLEditor::CheckSelectionStateForAnon
   // Don't change selection state if we're moving.
   if (mIsMoving) {
     return NS_OK;
   }
 
   nsCOMPtr<nsIDOMElement> focusElement;
   // let's get the containing element of the selection
   nsresult res  = GetSelectionContainer(getter_AddRefs(focusElement));
-  if (!focusElement) return NS_OK;
+  NS_ENSURE_TRUE(focusElement, NS_OK);
   NS_ENSURE_SUCCESS(res, res);
 
   // what's its tag?
   nsAutoString focusTagName;
   res = focusElement->GetTagName(focusTagName);
   NS_ENSURE_SUCCESS(res, res);
   ToLowerCase(focusTagName);
   nsCOMPtr<nsIAtom> focusTagAtom = do_GetAtom(focusTagName);
@@ -428,17 +428,17 @@ nsHTMLEditor::GetPositionAndDimensions(n
   }
 
   if (isPositioned) {
     // Yes, it is absolutely positioned
     mResizedObjectIsAbsolutelyPositioned = PR_TRUE;
 
     nsCOMPtr<nsIDOMViewCSS> viewCSS;
     res = mHTMLCSSUtils->GetDefaultViewCSS(aElement, getter_AddRefs(viewCSS));
-    if (!viewCSS) return NS_ERROR_FAILURE;
+    NS_ENSURE_TRUE(viewCSS, NS_ERROR_FAILURE);
 
     nsCOMPtr<nsIDOMCSSStyleDeclaration> cssDecl;
     // Get the all the computed css styles attached to the element node
     res = viewCSS->GetComputedStyle(aElement, EmptyString(), getter_AddRefs(cssDecl));
     NS_ENSURE_SUCCESS(res, res);
 
     aBorderLeft = GetCSSFloatValue(cssDecl, NS_LITERAL_STRING("border-left-width"));
     aBorderTop  = GetCSSFloatValue(cssDecl, NS_LITERAL_STRING("border-top-width"));

--- a/editor/libeditor/html/nsHTMLCSSUtils.cpp
+++ b/editor/libeditor/html/nsHTMLCSSUtils.cpp
@@ -332,17 +332,17 @@ nsHTMLCSSUtils::IsCSSEditableProperty(ns
   NS_ASSERTION(aNode, "Shouldn't you pass aNode? - Bug 214025");
 
   nsCOMPtr<nsIDOMNode> node = aNode;
   // we need an element node here
   if (mHTMLEditor->IsTextNode(aNode)) {
     aNode->GetParentNode(getter_AddRefs(node));
   }
   nsCOMPtr<nsIContent> content = do_QueryInterface(node);
-  if (!content) return PR_FALSE;
+  NS_ENSURE_TRUE(content, PR_FALSE);
 
   nsIAtom *tagName = content->Tag();
   // brade: should the above use nsEditor::GetTag(aNode)?
   // brade: shouldn't some of the above go below the next block?
 
   // html inline styles B I TT U STRIKE and COLOR/FACE on FONT
   if (nsEditProperty::b == aProperty
       || nsEditProperty::i == aProperty
@@ -1378,20 +1378,20 @@ nsHTMLCSSUtils::ElementsSameStyle(nsIDOM
   return PR_TRUE;
 }
 
 nsresult
 nsHTMLCSSUtils::GetInlineStyles(nsIDOMElement *aElement,
                                 nsIDOMCSSStyleDeclaration **aCssDecl,
                                 PRUint32 *aLength)
 {
-  if (!aElement || !aLength) return NS_ERROR_NULL_POINTER;
+  NS_ENSURE_TRUE(aElement && aLength, NS_ERROR_NULL_POINTER);
   *aLength = 0;
   nsCOMPtr<nsIDOMElementCSSInlineStyle> inlineStyles = do_QueryInterface(aElement);
-  if (!inlineStyles) return NS_ERROR_NULL_POINTER;
+  NS_ENSURE_TRUE(inlineStyles, NS_ERROR_NULL_POINTER);
   nsresult res = inlineStyles->GetStyle(aCssDecl);
   if (NS_FAILED(res) || !aCssDecl) return NS_ERROR_NULL_POINTER;
   (*aCssDecl)->GetLength(aLength);
   return NS_OK;
 }
 
 nsresult
 nsHTMLCSSUtils::GetElementContainerOrSelf(nsIDOMNode * aNode, nsIDOMElement ** aElement)

--- a/editor/libeditor/html/nsHTMLDataTransfer.cpp
+++ b/editor/libeditor/html/nsHTMLDataTransfer.cpp
@@ -140,46 +140,46 @@ static NS_DEFINE_CID(kCParserCID,     NS
 // some little helpers
 static PRInt32 FindPositiveIntegerAfterString(const char *aLeadingString, nsCString &aCStr);
 static nsresult RemoveFragComments(nsCString &theStr);
 static void RemoveBodyAndHead(nsIDOMNode *aNode);
 static nsresult FindTargetNode(nsIDOMNode *aStart, nsCOMPtr<nsIDOMNode> &aResult);
 
 static nsCOMPtr<nsIDOMNode> GetListParent(nsIDOMNode* aNode)
 {
-  if (!aNode) return nsnull;
+  NS_ENSURE_TRUE(aNode, nsnull);
   nsCOMPtr<nsIDOMNode> parent, tmp;
   aNode->GetParentNode(getter_AddRefs(parent));
   while (parent)
   {
     if (nsHTMLEditUtils::IsList(parent)) return parent;
     parent->GetParentNode(getter_AddRefs(tmp));
     parent = tmp;
   }
   return nsnull;
 }
 
 static nsCOMPtr<nsIDOMNode> GetTableParent(nsIDOMNode* aNode)
 {
-  if (!aNode) return nsnull;
+  NS_ENSURE_TRUE(aNode, nsnull);
   nsCOMPtr<nsIDOMNode> parent, tmp;
   aNode->GetParentNode(getter_AddRefs(parent));
   while (parent)
   {
     if (nsHTMLEditUtils::IsTable(parent)) return parent;
     parent->GetParentNode(getter_AddRefs(tmp));
     parent = tmp;
   }
   return nsnull;
 }
 
 
 NS_IMETHODIMP nsHTMLEditor::LoadHTML(const nsAString & aInputString)
 {
-  if (!mRules) return NS_ERROR_NOT_INITIALIZED;
+  NS_ENSURE_TRUE(mRules, NS_ERROR_NOT_INITIALIZED);
 
   // force IME commit; set up rules sniffing and batching
   ForceCompositionEnd();
   nsAutoEditBatch beginBatching(this);
   nsAutoRules beginRulesSniffing(this, kOpLoadHTML, nsIEditor::eNext);
   
   // Get selection
   nsCOMPtr<nsISelection>selection;
@@ -258,17 +258,17 @@ nsHTMLEditor::InsertHTMLWithContext(cons
                                     const nsAString & aContextStr,
                                     const nsAString & aInfoStr,
                                     const nsAString & aFlavor,
                                     nsIDOMDocument *aSourceDoc,
                                     nsIDOMNode *aDestNode,
                                     PRInt32 aDestOffset,
                                     PRBool aDeleteSelection)
 {
-  if (!mRules) return NS_ERROR_NOT_INITIALIZED;
+  NS_ENSURE_TRUE(mRules, NS_ERROR_NOT_INITIALIZED);
 
   // force IME commit; set up rules sniffing and batching
   ForceCompositionEnd();
   nsAutoEditBatch beginBatching(this);
   nsAutoRules beginRulesSniffing(this, kOpHTMLPaste, nsIEditor::eNext);
   
   // Get selection
   nsresult res;
@@ -884,17 +884,17 @@ nsHTMLEditor::RelativizeURIForNode(nsIDO
   nsAutoString attributeToModify;
   GetAttributeToModifyOnNode(aNode, attributeToModify);
   if (attributeToModify.IsEmpty())
     return NS_OK;
 
   nsCOMPtr<nsIDOMNamedNodeMap> attrMap;
   nsresult rv = aNode->GetAttributes(getter_AddRefs(attrMap));
   NS_ENSURE_SUCCESS(rv, NS_OK);
-  if (!attrMap) return NS_OK; // assume errors here shouldn't cancel insertion
+  NS_ENSURE_TRUE(attrMap, NS_OK); // assume errors here shouldn't cancel insertion
 
   nsCOMPtr<nsIDOMNode> attrNode;
   rv = attrMap->GetNamedItem(attributeToModify, getter_AddRefs(attrNode));
   NS_ENSURE_SUCCESS(rv, NS_OK); // assume errors here shouldn't cancel insertion
 
   if (attrNode)
   {
     nsAutoString oldValue;
@@ -925,20 +925,20 @@ nsHTMLEditor::RelativizeURIInFragmentLis
                                           const nsAString &aFlavor,
                                           nsIDOMDocument *aSourceDoc,
                                           nsIDOMNode *aTargetNode)
 {
   // determine destination URL
   nsCOMPtr<nsIDOMDocument> domDoc;
   GetDocument(getter_AddRefs(domDoc));
   nsCOMPtr<nsIDocument> destDoc = do_QueryInterface(domDoc);
-  if (!destDoc) return NS_ERROR_FAILURE;
+  NS_ENSURE_TRUE(destDoc, NS_ERROR_FAILURE);
 
   nsCOMPtr<nsIURL> destURL = do_QueryInterface(destDoc->GetDocumentURI());
-  if (!destURL) return NS_ERROR_FAILURE;
+  NS_ENSURE_TRUE(destURL, NS_ERROR_FAILURE);
 
   // brade: eventually should look for a base url in the document if present
 
   nsresult rv;
   nsCOMPtr<nsIDOMDocumentTraversal> trav = do_QueryInterface(domDoc, &rv);
   NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
 
   PRInt32 listCount = aNodeList.Count();
@@ -1484,33 +1484,33 @@ NS_IMETHODIMP nsHTMLEditor::InsertFromDr
   
   nsresult rv;
   nsCOMPtr<nsIDragService> dragService = 
            do_GetService("@mozilla.org/widget/dragservice;1", &rv);
   NS_ENSURE_SUCCESS(rv, rv);
 
   nsCOMPtr<nsIDragSession> dragSession;
   dragService->GetCurrentSession(getter_AddRefs(dragSession)); 
-  if (!dragSession) return NS_OK;
+  NS_ENSURE_TRUE(dragSession, NS_OK);
 
   // transferable hooks here
   nsCOMPtr<nsIDOMDocument> domdoc;
   GetDocument(getter_AddRefs(domdoc));
 
   // find out if we have our internal html flavor on the clipboard.  We don't want to mess
   // around with cfhtml if we do.
   PRBool bHavePrivateHTMLFlavor = PR_FALSE;
   rv = dragSession->IsDataFlavorSupported(kHTMLContext, &bHavePrivateHTMLFlavor);
   NS_ENSURE_SUCCESS(rv, rv);
   
   // Get the nsITransferable interface for getting the data from the drop
   nsCOMPtr<nsITransferable> trans;
   rv = PrepareHTMLTransferable(getter_AddRefs(trans), bHavePrivateHTMLFlavor);
   NS_ENSURE_SUCCESS(rv, rv);
-  if (!trans) return NS_OK;  // NS_ERROR_FAILURE; SHOULD WE FAIL?
+  NS_ENSURE_TRUE(trans, NS_OK);  // NS_ERROR_FAILURE; SHOULD WE FAIL?
 
   PRUint32 numItems = 0; 
   rv = dragSession->GetNumDropItems(&numItems);
   NS_ENSURE_SUCCESS(rv, rv);
 
   // Combine any deletion and drop insertion into one transaction
   nsAutoEditBatch beginBatching(this);
 
@@ -1525,17 +1525,17 @@ NS_IMETHODIMP nsHTMLEditor::InsertFromDr
   NS_ENSURE_SUCCESS(rv, rv);
 
   PRUint32 i; 
   PRBool doPlaceCaret = PR_TRUE;
   for (i = 0; i < numItems; ++i)
   {
     rv = dragSession->GetData(trans, i);
     NS_ENSURE_SUCCESS(rv, rv);
-    if (!trans) return NS_OK; // NS_ERROR_FAILURE; Should we fail?
+    NS_ENSURE_TRUE(trans, NS_OK); // NS_ERROR_FAILURE; Should we fail?
 
     // get additional html copy hints, if present
     nsAutoString contextStr, infoStr;
     nsCOMPtr<nsISupports> contextDataObj, infoDataObj;
     PRUint32 contextLen, infoLen;
     nsCOMPtr<nsISupportsString> textDataObj;
     
     nsCOMPtr<nsITransferable> contextTrans =
@@ -1572,17 +1572,17 @@ NS_IMETHODIMP nsHTMLEditor::InsertFromDr
 
     if (doPlaceCaret)
     {
       // check if the user pressed the key to force a copy rather than a move
       // if we run into problems here, we'll just assume the user doesn't want a copy
       PRBool userWantsCopy = PR_FALSE;
 
       nsCOMPtr<nsIDOMNSUIEvent> nsuiEvent(do_QueryInterface(aDropEvent));
-      if (!nsuiEvent) return NS_ERROR_FAILURE;
+      NS_ENSURE_TRUE(nsuiEvent, NS_ERROR_FAILURE);
 
       nsCOMPtr<nsIDOMMouseEvent> mouseEvent(do_QueryInterface(aDropEvent));
       if (mouseEvent)
 
 #if defined(XP_MAC) || defined(XP_MACOSX)
         mouseEvent->GetAltKey(&userWantsCopy);
 #else
         mouseEvent->GetCtrlKey(&userWantsCopy);
@@ -1591,26 +1591,26 @@ NS_IMETHODIMP nsHTMLEditor::InsertFromDr
       // Current doc is destination
       nsCOMPtr<nsIDOMDocument>destdomdoc; 
       rv = GetDocument(getter_AddRefs(destdomdoc)); 
       NS_ENSURE_SUCCESS(rv, rv);
 
       nsCOMPtr<nsISelection> selection;
       rv = GetSelection(getter_AddRefs(selection));
       NS_ENSURE_SUCCESS(rv, rv);
-      if (!selection) return NS_ERROR_FAILURE;
+      NS_ENSURE_TRUE(selection, NS_ERROR_FAILURE);
 
       PRBool isCollapsed;
       rv = selection->GetIsCollapsed(&isCollapsed);
       NS_ENSURE_SUCCESS(rv, rv);
       
       // Parent and offset under the mouse cursor
       rv = nsuiEvent->GetRangeParent(getter_AddRefs(newSelectionParent));
       NS_ENSURE_SUCCESS(rv, rv);
-      if (!newSelectionParent) return NS_ERROR_FAILURE;
+      NS_ENSURE_TRUE(newSelectionParent, NS_ERROR_FAILURE);
 
       rv = nsuiEvent->GetRangeOffset(&newSelectionOffset);
       NS_ENSURE_SUCCESS(rv, rv);
 
       // XXX: This userSelectNode code is a workaround for bug 195957.
       //
       // Check to see if newSelectionParent is part of a "-moz-user-select: all"
       // subtree. If it is, we need to make sure we don't drop into it!
@@ -1627,17 +1627,17 @@ NS_IMETHODIMP nsHTMLEditor::InsertFromDr
         //      current behavior when dropping on top of an image.
         //      The decision for dropping before or after the
         //      subtree should really be done based on coordinates.
 
         rv = GetNodeLocation(userSelectNode, address_of(newSelectionParent),
                              &newSelectionOffset);
 
         NS_ENSURE_SUCCESS(rv, rv);
-        if (!newSelectionParent) return NS_ERROR_FAILURE;
+        NS_ENSURE_TRUE(newSelectionParent, NS_ERROR_FAILURE);
       }
 
       // We never have to delete if selection is already collapsed
       PRBool cursorIsInSelection = PR_FALSE;
 
       // Check if mouse is in the selection
       if (!isCollapsed)
       {
@@ -1821,17 +1821,17 @@ NS_IMETHODIMP nsHTMLEditor::DoDrag(nsIDO
   return nsPlaintextEditor::DoDrag(aDragEvent);
 }
 
 PRBool nsHTMLEditor::HavePrivateHTMLFlavor(nsIClipboard *aClipboard)
 {
   // check the clipboard for our special kHTMLContext flavor.  If that is there, we know
   // we have our own internal html format on clipboard.
   
-  if (!aClipboard) return PR_FALSE;
+  NS_ENSURE_TRUE(aClipboard, PR_FALSE);
   PRBool bHavePrivateHTMLFlavor = PR_FALSE;
   
   const char* flavArray[] = { kHTMLContext };
   
   if (NS_SUCCEEDED(aClipboard->HasDataMatchingFlavors(flavArray,
     NS_ARRAY_LENGTH(flavArray), nsIClipboard::kGlobalClipboard,
     &bHavePrivateHTMLFlavor )))
     return bHavePrivateHTMLFlavor;
@@ -2076,30 +2076,30 @@ NS_IMETHODIMP nsHTMLEditor::PasteAsCited
 {
   nsAutoEditBatch beginBatching(this);
   nsAutoRules beginRulesSniffing(this, kOpInsertQuotation, nsIEditor::eNext);
 
   // get selection
   nsCOMPtr<nsISelection> selection;
   nsresult res = GetSelection(getter_AddRefs(selection));
   NS_ENSURE_SUCCESS(res, res);
-  if (!selection) return NS_ERROR_NULL_POINTER;
+  NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
 
   // give rules a chance to handle or cancel
   nsTextRulesInfo ruleInfo(nsTextEditRules::kInsertElement);
   PRBool cancel, handled;
   res = mRules->WillDoAction(selection, &ruleInfo, &cancel, &handled);
   NS_ENSURE_SUCCESS(res, res);
   if (cancel) return NS_OK; // rules canceled the operation
   if (!handled)
   {
     nsCOMPtr<nsIDOMNode> newNode;
     res = DeleteSelectionAndCreateNode(NS_LITERAL_STRING("blockquote"), getter_AddRefs(newNode));
     NS_ENSURE_SUCCESS(res, res);
-    if (!newNode) return NS_ERROR_NULL_POINTER;
+    NS_ENSURE_TRUE(newNode, NS_ERROR_NULL_POINTER);
 
     // Try to set type=cite.  Ignore it if this fails.
     nsCOMPtr<nsIDOMElement> newElement (do_QueryInterface(newNode));
     if (newElement)
     {
       newElement->SetAttribute(NS_LITERAL_STRING("type"), NS_LITERAL_STRING("cite"));
     }
 
@@ -2300,17 +2300,20 @@ nsHTMLEditor::InsertAsPlaintextQuotation
   if (NS_SUCCEEDED(rv) && prefBranch)
     prefBranch->GetBoolPref("editor.quotesPreformatted", &quotesInPre);
 
   nsCOMPtr<nsIDOMNode> preNode;
   // get selection
   nsCOMPtr<nsISelection> selection;
   rv = GetSelection(getter_AddRefs(selection));
   NS_ENSURE_SUCCESS(rv, rv);
-  if (!selection) return NS_ERROR_NULL_POINTER;
+  if (!selection)
+  {
+    NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
+  }
   else
   {
     nsAutoEditBatch beginBatching(this);
     nsAutoRules beginRulesSniffing(this, kOpInsertQuotation, nsIEditor::eNext);
 
     // give rules a chance to handle or cancel
     nsTextRulesInfo ruleInfo(nsTextEditRules::kInsertElement);
     PRBool cancel, handled;
@@ -2413,33 +2416,36 @@ nsHTMLEditor::InsertAsCitedQuotation(con
 
   nsCOMPtr<nsIDOMNode> newNode;
   nsresult res = NS_OK;
 
   // get selection
   nsCOMPtr<nsISelection> selection;
   res = GetSelection(getter_AddRefs(selection));
   NS_ENSURE_SUCCESS(res, res);
-  if (!selection) return NS_ERROR_NULL_POINTER;
+  if (!selection)
+  {
+    NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
+  }
   else
   {
     nsAutoEditBatch beginBatching(this);
     nsAutoRules beginRulesSniffing(this, kOpInsertQuotation, nsIEditor::eNext);
 
     // give rules a chance to handle or cancel
     nsTextRulesInfo ruleInfo(nsTextEditRules::kInsertElement);
     PRBool cancel, handled;
     res = mRules->WillDoAction(selection, &ruleInfo, &cancel, &handled);
     NS_ENSURE_SUCCESS(res, res);
     if (cancel) return NS_OK; // rules canceled the operation
     if (!handled)
     {
       res = DeleteSelectionAndCreateNode(NS_LITERAL_STRING("blockquote"), getter_AddRefs(newNode));
       NS_ENSURE_SUCCESS(res, res);
-      if (!newNode) return NS_ERROR_NULL_POINTER;
+      NS_ENSURE_TRUE(newNode, NS_ERROR_NULL_POINTER);
 
       // Try to set type=cite.  Ignore it if this fails.
       nsCOMPtr<nsIDOMElement> newElement (do_QueryInterface(newNode));
       if (newElement)
       {
         NS_NAMED_LITERAL_STRING(citestr, "cite");
         newElement->SetAttribute(NS_LITERAL_STRING("type"), citestr);
 
@@ -2796,17 +2802,17 @@ nsresult nsHTMLEditor::CreateListOfNodes
     aStartNode = aFragmentAsNode;
     aStartOffset = 0;
     aEndNode = aFragmentAsNode;
     aEndOffset = fragLen;
   }
 
   nsCOMPtr<nsIDOMRange> docFragRange =
                           do_CreateInstance("@mozilla.org/content/range;1");
-  if (!docFragRange) return NS_ERROR_OUT_OF_MEMORY;
+  NS_ENSURE_TRUE(docFragRange, NS_ERROR_OUT_OF_MEMORY);
 
   res = docFragRange->SetStart(aStartNode, aStartOffset);
   NS_ENSURE_SUCCESS(res, res);
   res = docFragRange->SetEnd(aEndNode, aEndOffset);
   NS_ENSURE_SUCCESS(res, res);
 
   // now use a subtree iterator over the range to create a list of nodes
   nsTrivialFunctor functor;