--- a/editor/composer/nsComposeTxtSrvFilter.h
+++ b/editor/composer/nsComposeTxtSrvFilter.h
@@ -19,37 +19,37 @@
 class nsComposeTxtSrvFilter final : public nsITextServicesFilter
 {
 public:
   nsComposeTxtSrvFilter();
 
   // nsISupports interface...
   NS_DECL_ISUPPORTS
 
-  // nsITextServicesFilter 
+  // nsITextServicesFilter
   NS_DECL_NSITEXTSERVICESFILTER
 
   // Helper - Intializer
   void Init(bool aIsForMail) { mIsForMail = aIsForMail; }
 
 private:
   ~nsComposeTxtSrvFilter() {}
 
   bool              mIsForMail;
 };
 
 #define NS_COMPOSERTXTSRVFILTER_CID \
 {/* {171E72DB-0F8A-412a-8461-E4C927A3A2AC}*/ \
 0x171e72db, 0xf8a, 0x412a, \
-{ 0x84, 0x61, 0xe4, 0xc9, 0x27, 0xa3, 0xa2, 0xac} } 
+{ 0x84, 0x61, 0xe4, 0xc9, 0x27, 0xa3, 0xa2, 0xac} }
 
 #define NS_COMPOSERTXTSRVFILTERMAIL_CID \
 {/* {7FBD2146-5FF4-4674-B069-A7BBCE66E773}*/ \
 0x7fbd2146, 0x5ff4, 0x4674, \
-{ 0xb0, 0x69, 0xa7, 0xbb, 0xce, 0x66, 0xe7, 0x73} } 
+{ 0xb0, 0x69, 0xa7, 0xbb, 0xce, 0x66, 0xe7, 0x73} }
 
 // Generic for the editor
 #define COMPOSER_TXTSRVFILTER_CONTRACTID     "@mozilla.org/editor/txtsrvfilter;1"
 
 // This is the same but includes "cite" typed blocked quotes
 #define COMPOSER_TXTSRVFILTERMAIL_CONTRACTID "@mozilla.org/editor/txtsrvfiltermail;1"
 
 #endif

--- a/editor/composer/nsComposerCommands.cpp
+++ b/editor/composer/nsComposerCommands.cpp
@@ -96,37 +96,37 @@ NS_IMETHODIMP
 nsBaseStateUpdatingCommand::DoCommandParams(const char *aCommandName,
                                             nsICommandParams *aParams,
                                             nsISupports *refCon)
 {
   return DoCommand(aCommandName, refCon);
 }
 
 NS_IMETHODIMP
-nsBaseStateUpdatingCommand::GetCommandStateParams(const char *aCommandName, 
+nsBaseStateUpdatingCommand::GetCommandStateParams(const char *aCommandName,
                                                   nsICommandParams *aParams,
                                                   nsISupports *refCon)
 {
   nsCOMPtr<nsIEditor> editor = do_QueryInterface(refCon);
   if (editor)
     return GetCurrentState(editor, aParams);
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsPasteNoFormattingCommand::IsCommandEnabled(const char * aCommandName, 
-                                             nsISupports *refCon, 
+nsPasteNoFormattingCommand::IsCommandEnabled(const char * aCommandName,
+                                             nsISupports *refCon,
                                              bool *outCmdEnabled)
 {
   NS_ENSURE_ARG_POINTER(outCmdEnabled);
   *outCmdEnabled = false;
 
   // This command is only implemented by nsIHTMLEditor, since
-  //  pasting in a plaintext editor automatically only supplies 
+  //  pasting in a plaintext editor automatically only supplies
   //  "unformatted" text
   nsCOMPtr<nsIHTMLEditor> htmlEditor = do_QueryInterface(refCon);
   NS_ENSURE_TRUE(htmlEditor, NS_ERROR_NOT_IMPLEMENTED);
 
   nsCOMPtr<nsIEditor> editor = do_QueryInterface(htmlEditor);
   NS_ENSURE_TRUE(editor, NS_ERROR_INVALID_ARG);
 
   return editor->CanPaste(nsIClipboard::kGlobalClipboard, outCmdEnabled);
@@ -140,17 +140,17 @@ nsPasteNoFormattingCommand::DoCommand(co
   nsCOMPtr<nsIHTMLEditor> htmlEditor = do_QueryInterface(refCon);
   NS_ENSURE_TRUE(htmlEditor, NS_ERROR_NOT_IMPLEMENTED);
 
   return htmlEditor->PasteNoFormatting(nsIClipboard::kGlobalClipboard);
 }
 
 NS_IMETHODIMP
 nsPasteNoFormattingCommand::DoCommandParams(const char *aCommandName,
-                                            nsICommandParams *aParams, 
+                                            nsICommandParams *aParams,
                                             nsISupports *refCon)
 {
   return DoCommand(aCommandName, refCon);
 }
 
 NS_IMETHODIMP
 nsPasteNoFormattingCommand::GetCommandStateParams(const char *aCommandName,
                                                   nsICommandParams *aParams,
@@ -166,23 +166,23 @@ nsPasteNoFormattingCommand::GetCommandSt
 }
 
 nsStyleUpdatingCommand::nsStyleUpdatingCommand(nsIAtom* aTagName)
 : nsBaseStateUpdatingCommand(aTagName)
 {
 }
 
 nsresult
-nsStyleUpdatingCommand::GetCurrentState(nsIEditor *aEditor, 
+nsStyleUpdatingCommand::GetCurrentState(nsIEditor *aEditor,
                                         nsICommandParams *aParams)
 {
   NS_ASSERTION(aEditor, "Need editor here");
   nsCOMPtr<nsIHTMLEditor> htmlEditor = do_QueryInterface(aEditor);
   NS_ENSURE_TRUE(htmlEditor, NS_ERROR_NOT_INITIALIZED);
-  
+
   bool firstOfSelectionHasProp = false;
   bool anyOfSelectionHasProp = false;
   bool allOfSelectionHasProp = false;
 
   nsresult rv = htmlEditor->GetInlineProperty(mTagName, EmptyString(),
                                               EmptyString(),
                                               &firstOfSelectionHasProp,
                                               &anyOfSelectionHasProp,
@@ -206,17 +206,17 @@ nsStyleUpdatingCommand::ToggleState(nsIE
 
   //create some params now...
   nsresult rv;
   nsCOMPtr<nsICommandParams> params =
       do_CreateInstance(NS_COMMAND_PARAMS_CONTRACTID,&rv);
   if (NS_FAILED(rv) || !params)
     return rv;
 
-  // tags "href" and "name" are special cases in the core editor 
+  // tags "href" and "name" are special cases in the core editor
   // they are used to remove named anchor/link and shouldn't be used for insertion
   bool doTagRemoval;
   if (mTagName == nsGkAtoms::href || mTagName == nsGkAtoms::name) {
     doTagRemoval = true;
   } else {
     // check current selection; set doTagRemoval if formatting should be removed
     rv = GetCurrentState(aEditor, params);
     NS_ENSURE_SUCCESS(rv, rv);
@@ -295,21 +295,21 @@ nsListCommand::ToggleState(nsIEditor *aE
   NS_ENSURE_SUCCESS(rv, rv);
 
   bool inList;
   rv = params->GetBooleanValue(STATE_ALL,&inList);
   NS_ENSURE_SUCCESS(rv, rv);
 
   nsDependentAtomString listType(mTagName);
   if (inList) {
-    rv = editor->RemoveList(listType);    
+    rv = editor->RemoveList(listType);
   } else {
     rv = editor->MakeOrChangeList(listType, false, EmptyString());
   }
-  
+
   return rv;
 }
 
 nsListItemCommand::nsListItemCommand(nsIAtom* aTagName)
 : nsBaseStateUpdatingCommand(aTagName)
 {
 }
 
@@ -357,23 +357,23 @@ nsListItemCommand::ToggleState(nsIEditor
   nsCOMPtr<nsICommandParams> params =
       do_CreateInstance(NS_COMMAND_PARAMS_CONTRACTID,&rv);
   if (NS_FAILED(rv) || !params)
     return rv;
   rv = GetCurrentState(aEditor, params);
   rv = params->GetBooleanValue(STATE_ALL,&inList);
   NS_ENSURE_SUCCESS(rv, rv);
   NS_ENSURE_SUCCESS(rv, rv);
-  
+
   if (inList) {
     // To remove a list, first get what kind of list we're in
     bool bMixed;
     nsAutoString localName;
     rv = GetListState(htmlEditor, &bMixed, localName);
-    NS_ENSURE_SUCCESS(rv, rv); 
+    NS_ENSURE_SUCCESS(rv, rv);
     if (localName.IsEmpty() || bMixed) {
       return rv;
     }
     return htmlEditor->RemoveList(localName);
   }
 
   // Set to the requested paragraph type
   //XXX Note: This actually doesn't work for "LI",
@@ -419,30 +419,30 @@ nsRemoveListCommand::DoCommand(const cha
 
   nsresult rv = NS_OK;
   if (editor)
   {
     // This removes any list type
     rv = editor->RemoveList(EmptyString());
   }
 
-  return rv;  
+  return rv;
 }
 
 NS_IMETHODIMP
-nsRemoveListCommand::DoCommandParams(const char *aCommandName, 
+nsRemoveListCommand::DoCommandParams(const char *aCommandName,
                                      nsICommandParams *aParams,
                                      nsISupports *refCon)
 {
   return DoCommand(aCommandName, refCon);
 }
 
 NS_IMETHODIMP
 nsRemoveListCommand::GetCommandStateParams(const char *aCommandName,
-                                           nsICommandParams *aParams, 
+                                           nsICommandParams *aParams,
                                            nsISupports *refCon)
 {
   bool outCmdEnabled = false;
   IsCommandEnabled(aCommandName, refCon, &outCmdEnabled);
   return aParams->SetBooleanValue(STATE_ENABLED,outCmdEnabled);
 }
 
 NS_IMETHODIMP
@@ -463,26 +463,26 @@ nsIndentCommand::DoCommand(const char *a
 {
   nsCOMPtr<nsIHTMLEditor> editor = do_QueryInterface(refCon);
 
   nsresult rv = NS_OK;
   if (editor)
   {
     rv = editor->Indent(NS_LITERAL_STRING("indent"));
   }
-  
-  return rv;  
+
+  return rv;
 }
 
 NS_IMETHODIMP
 nsIndentCommand::DoCommandParams(const char *aCommandName,
                                  nsICommandParams *aParams,
                                  nsISupports *refCon)
 {
-  return DoCommand(aCommandName, refCon);  
+  return DoCommand(aCommandName, refCon);
 }
 
 NS_IMETHODIMP
 nsIndentCommand::GetCommandStateParams(const char *aCommandName,
                                        nsICommandParams *aParams,
                                        nsISupports *refCon)
 {
   bool outCmdEnabled = false;
@@ -511,26 +511,26 @@ nsOutdentCommand::IsCommandEnabled(const
 
 
 NS_IMETHODIMP
 nsOutdentCommand::DoCommand(const char *aCommandName, nsISupports *refCon)
 {
   nsCOMPtr<nsIHTMLEditor> htmlEditor = do_QueryInterface(refCon);
   if (htmlEditor)
     return htmlEditor->Indent(NS_LITERAL_STRING("outdent"));
-  
-  return NS_OK;  
+
+  return NS_OK;
 }
 
 NS_IMETHODIMP
 nsOutdentCommand::DoCommandParams(const char *aCommandName,
-                                  nsICommandParams *aParams, 
+                                  nsICommandParams *aParams,
                                   nsISupports *refCon)
 {
-  return DoCommand(aCommandName, refCon);  
+  return DoCommand(aCommandName, refCon);
 }
 
 NS_IMETHODIMP
 nsOutdentCommand::GetCommandStateParams(const char *aCommandName,
                                         nsICommandParams *aParams,
                                         nsISupports *refCon)
 {
   bool outCmdEnabled = false;
@@ -555,29 +555,29 @@ nsMultiStateCommand::IsCommandEnabled(co
                                       bool *outCmdEnabled)
 {
   nsCOMPtr<nsIEditor> editor = do_QueryInterface(refCon);
   // should be disabled sometimes, like if the current selection is an image
   if (editor)
     return editor->GetIsSelectionEditable(outCmdEnabled);
 
   *outCmdEnabled = false;
-  return NS_OK; 
+  return NS_OK;
 }
 
 
 NS_IMETHODIMP
 nsMultiStateCommand::DoCommand(const char *aCommandName, nsISupports *refCon)
 {
 #ifdef DEBUG
   printf("who is calling nsMultiStateCommand::DoCommand \
           (no implementation)? %s\n", aCommandName);
 #endif
-  
-  return NS_OK;  
+
+  return NS_OK;
 }
 
 NS_IMETHODIMP
 nsMultiStateCommand::DoCommandParams(const char *aCommandName,
                                      nsICommandParams *aParams,
                                      nsISupports *refCon)
 {
   nsCOMPtr<nsIEditor> editor = do_QueryInterface(refCon);
@@ -593,18 +593,18 @@ nsMultiStateCommand::DoCommandParams(con
         if (NS_SUCCEEDED(rv))
           tString.AssignWithConversion(s);
         else
           rv = aParams->GetStringValue(STATE_ATTRIBUTE, tString);
       }
 
       rv = SetState(editor, tString);
   }
-  
-  return rv;  
+
+  return rv;
 }
 
 NS_IMETHODIMP
 nsMultiStateCommand::GetCommandStateParams(const char *aCommandName,
                                            nsICommandParams *aParams,
                                            nsISupports *refCon)
 {
   nsCOMPtr<nsIEditor> editor = do_QueryInterface(refCon);
@@ -621,17 +621,17 @@ nsParagraphStateCommand::nsParagraphStat
 {
 }
 
 nsresult
 nsParagraphStateCommand::GetCurrentState(nsIEditor *aEditor,
                                          nsICommandParams *aParams)
 {
   NS_ASSERTION(aEditor, "Need an editor here");
-  
+
   nsCOMPtr<nsIHTMLEditor> htmlEditor = do_QueryInterface(aEditor);
   NS_ENSURE_TRUE(htmlEditor, NS_ERROR_FAILURE);
 
   bool outMixed;
   nsAutoString outStateString;
   nsresult rv = htmlEditor->GetParagraphState(&outMixed, outStateString);
   if (NS_SUCCEEDED(rv))
   {
@@ -680,17 +680,17 @@ nsFontFaceStateCommand::GetCurrentState(
 
 
 nsresult
 nsFontFaceStateCommand::SetState(nsIEditor *aEditor, nsString& newState)
 {
   NS_ASSERTION(aEditor, "Need an editor here");
   nsCOMPtr<nsIHTMLEditor> htmlEditor = do_QueryInterface(aEditor);
   NS_ENSURE_TRUE(htmlEditor, NS_ERROR_FAILURE);
-  
+
   if (newState.EqualsLiteral("tt")) {
     // The old "teletype" attribute
     nsresult rv = htmlEditor->SetInlineProperty(nsGkAtoms::tt, EmptyString(),
                                                 EmptyString());
     NS_ENSURE_SUCCESS(rv, rv);
     // Clear existing font face
     return htmlEditor->RemoveInlineProperty(nsGkAtoms::font,
                                             NS_LITERAL_STRING("face"));
@@ -783,17 +783,17 @@ nsFontColorStateCommand::nsFontColorStat
 {
 }
 
 nsresult
 nsFontColorStateCommand::GetCurrentState(nsIEditor *aEditor,
                                          nsICommandParams *aParams)
 {
   NS_ASSERTION(aEditor, "Need an editor here");
-  
+
   nsCOMPtr<nsIHTMLEditor> htmlEditor = do_QueryInterface(aEditor);
   NS_ENSURE_TRUE(htmlEditor, NS_ERROR_FAILURE);
 
   bool outMixed;
   nsAutoString outStateString;
   nsresult rv = htmlEditor->GetFontColorState(&outMixed, outStateString);
   NS_ENSURE_SUCCESS(rv, rv);
 
@@ -805,22 +805,22 @@ nsFontColorStateCommand::GetCurrentState
 }
 
 nsresult
 nsFontColorStateCommand::SetState(nsIEditor *aEditor, nsString& newState)
 {
   NS_ASSERTION(aEditor, "Need an editor here");
   nsCOMPtr<nsIHTMLEditor> htmlEditor = do_QueryInterface(aEditor);
   NS_ENSURE_TRUE(htmlEditor, NS_ERROR_FAILURE);
-  
+
   if (newState.IsEmpty() || newState.EqualsLiteral("normal")) {
     return htmlEditor->RemoveInlineProperty(nsGkAtoms::font,
                                             NS_LITERAL_STRING("color"));
   }
-  
+
   return htmlEditor->SetInlineProperty(nsGkAtoms::font,
                                        NS_LITERAL_STRING("color"), newState);
 }
 
 nsHighlightColorStateCommand::nsHighlightColorStateCommand()
 : nsMultiStateCommand()
 {
 }
@@ -881,17 +881,17 @@ nsBackgroundColorStateCommand::nsBackgro
 {
 }
 
 nsresult
 nsBackgroundColorStateCommand::GetCurrentState(nsIEditor *aEditor,
                                                nsICommandParams *aParams)
 {
   NS_ASSERTION(aEditor, "Need an editor here");
-  
+
   nsCOMPtr<nsIHTMLEditor> htmlEditor = do_QueryInterface(aEditor);
   NS_ENSURE_TRUE(htmlEditor, NS_ERROR_FAILURE);
 
   bool outMixed;
   nsAutoString outStateString;
   nsresult rv =  htmlEditor->GetBackgroundColorState(&outMixed, outStateString);
   NS_ENSURE_SUCCESS(rv, rv);
 
@@ -901,54 +901,54 @@ nsBackgroundColorStateCommand::GetCurren
   aParams->SetCStringValue(STATE_ATTRIBUTE, tOutStateString.get());
   return NS_OK;
 }
 
 nsresult
 nsBackgroundColorStateCommand::SetState(nsIEditor *aEditor, nsString& newState)
 {
   NS_ASSERTION(aEditor, "Need an editor here");
-  
+
   nsCOMPtr<nsIHTMLEditor> htmlEditor = do_QueryInterface(aEditor);
   NS_ENSURE_TRUE(htmlEditor, NS_ERROR_FAILURE);
 
   return htmlEditor->SetBackgroundColor(newState);
 }
 
 nsAlignCommand::nsAlignCommand()
 : nsMultiStateCommand()
 {
 }
 
 nsresult
 nsAlignCommand::GetCurrentState(nsIEditor *aEditor, nsICommandParams *aParams)
 {
   NS_ASSERTION(aEditor, "Need an editor here");
-  
+
   nsCOMPtr<nsIHTMLEditor> htmlEditor = do_QueryInterface(aEditor);
   NS_ENSURE_TRUE(htmlEditor, NS_ERROR_FAILURE);
- 
+
   nsIHTMLEditor::EAlignment firstAlign;
   bool outMixed;
   nsresult rv = htmlEditor->GetAlignment(&outMixed, &firstAlign);
-  
+
   NS_ENSURE_SUCCESS(rv, rv);
-  
+
   nsAutoString outStateString;
   switch (firstAlign)
   {
     default:
     case nsIHTMLEditor::eLeft:
       outStateString.AssignLiteral("left");
       break;
-      
+
     case nsIHTMLEditor::eCenter:
       outStateString.AssignLiteral("center");
       break;
-      
+
     case nsIHTMLEditor::eRight:
       outStateString.AssignLiteral("right");
       break;
 
     case nsIHTMLEditor::eJustify:
       outStateString.AssignLiteral("justify");
       break;
   }
@@ -958,17 +958,17 @@ nsAlignCommand::GetCurrentState(nsIEdito
   aParams->SetCStringValue(STATE_ATTRIBUTE, tOutStateString.get());
   return NS_OK;
 }
 
 nsresult
 nsAlignCommand::SetState(nsIEditor *aEditor, nsString& newState)
 {
   NS_ASSERTION(aEditor, "Need an editor here");
-  
+
   nsCOMPtr<nsIHTMLEditor> htmlEditor = do_QueryInterface(aEditor);
   NS_ENSURE_TRUE(htmlEditor, NS_ERROR_FAILURE);
 
   return htmlEditor->Align(newState);
 }
 
 nsAbsolutePositioningCommand::nsAbsolutePositioningCommand()
 : nsBaseStateUpdatingCommand(nsGkAtoms::_empty)
@@ -994,17 +994,17 @@ nsAbsolutePositioningCommand::IsCommandE
   *outCmdEnabled = false;
   return NS_OK;
 }
 
 nsresult
 nsAbsolutePositioningCommand::GetCurrentState(nsIEditor *aEditor, nsICommandParams *aParams)
 {
   NS_ASSERTION(aEditor, "Need an editor here");
-  
+
   nsCOMPtr<nsIHTMLAbsPosEditor> htmlEditor = do_QueryInterface(aEditor);
   NS_ENSURE_TRUE(htmlEditor, NS_ERROR_FAILURE);
 
   bool isEnabled;
   htmlEditor->GetAbsolutePositioningEnabled(&isEnabled);
   if (!isEnabled) {
     aParams->SetBooleanValue(STATE_MIXED,false);
     aParams->SetCStringValue(STATE_ATTRIBUTE, "");
@@ -1023,17 +1023,17 @@ nsAbsolutePositioningCommand::GetCurrent
   aParams->SetCStringValue(STATE_ATTRIBUTE, NS_ConvertUTF16toUTF8(outStateString).get());
   return NS_OK;
 }
 
 nsresult
 nsAbsolutePositioningCommand::ToggleState(nsIEditor *aEditor)
 {
   NS_ASSERTION(aEditor, "Need an editor here");
-  
+
   nsCOMPtr<nsIHTMLAbsPosEditor> htmlEditor = do_QueryInterface(aEditor);
   NS_ENSURE_TRUE(htmlEditor, NS_ERROR_FAILURE);
 
   nsCOMPtr<nsIDOMElement> elt;
   nsresult rv = htmlEditor->GetAbsolutelyPositionedSelectionContainer(getter_AddRefs(elt));
   NS_ENSURE_SUCCESS(rv, rv);
 
   return htmlEditor->AbsolutePositionSelection(!elt);
@@ -1072,17 +1072,17 @@ nsDecreaseZIndexCommand::DoCommand(const
   nsCOMPtr<nsIHTMLAbsPosEditor> htmlEditor = do_QueryInterface(refCon);
   NS_ENSURE_TRUE(htmlEditor, NS_ERROR_NOT_IMPLEMENTED);
 
   return htmlEditor->RelativeChangeZIndex(-1);
 }
 
 NS_IMETHODIMP
 nsDecreaseZIndexCommand::DoCommandParams(const char *aCommandName,
-                                         nsICommandParams *aParams, 
+                                         nsICommandParams *aParams,
                                          nsISupports *refCon)
 {
   return DoCommand(aCommandName, refCon);
 }
 
 NS_IMETHODIMP
 nsDecreaseZIndexCommand::GetCommandStateParams(const char *aCommandName,
                                                nsICommandParams *aParams,
@@ -1122,17 +1122,17 @@ nsIncreaseZIndexCommand::DoCommand(const
   nsCOMPtr<nsIHTMLAbsPosEditor> htmlEditor = do_QueryInterface(refCon);
   NS_ENSURE_TRUE(htmlEditor, NS_ERROR_NOT_IMPLEMENTED);
 
   return htmlEditor->RelativeChangeZIndex(1);
 }
 
 NS_IMETHODIMP
 nsIncreaseZIndexCommand::DoCommandParams(const char *aCommandName,
-                                         nsICommandParams *aParams, 
+                                         nsICommandParams *aParams,
                                          nsISupports *refCon)
 {
   return DoCommand(aCommandName, refCon);
 }
 
 NS_IMETHODIMP
 nsIncreaseZIndexCommand::GetCommandStateParams(const char *aCommandName,
                                                nsICommandParams *aParams,
@@ -1170,18 +1170,18 @@ nsRemoveStylesCommand::DoCommand(const c
 {
   nsCOMPtr<nsIHTMLEditor> editor = do_QueryInterface(refCon);
 
   nsresult rv = NS_OK;
   if (editor)
   {
     rv = editor->RemoveAllInlineProperties();
   }
-  
-  return rv;  
+
+  return rv;
 }
 
 NS_IMETHODIMP
 nsRemoveStylesCommand::DoCommandParams(const char *aCommandName,
                                        nsICommandParams *aParams,
                                        nsISupports *refCon)
 {
   return DoCommand(aCommandName, refCon);
@@ -1218,18 +1218,18 @@ nsIncreaseFontSizeCommand::DoCommand(con
 {
   nsCOMPtr<nsIHTMLEditor> editor = do_QueryInterface(refCon);
 
   nsresult rv = NS_OK;
   if (editor)
   {
     rv = editor->IncreaseFontSize();
   }
-  
-  return rv;  
+
+  return rv;
 }
 
 NS_IMETHODIMP
 nsIncreaseFontSizeCommand::DoCommandParams(const char *aCommandName,
                                            nsICommandParams *aParams,
                                            nsISupports *refCon)
 {
   return DoCommand(aCommandName, refCon);
@@ -1266,18 +1266,18 @@ nsDecreaseFontSizeCommand::DoCommand(con
 {
   nsCOMPtr<nsIHTMLEditor> editor = do_QueryInterface(refCon);
 
   nsresult rv = NS_OK;
   if (editor)
   {
     rv = editor->DecreaseFontSize();
   }
-  
-  return rv;  
+
+  return rv;
 }
 
 NS_IMETHODIMP
 nsDecreaseFontSizeCommand::DoCommandParams(const char *aCommandName,
                                            nsICommandParams *aParams,
                                            nsISupports *refCon)
 {
   return DoCommand(aCommandName, refCon);
@@ -1377,17 +1377,17 @@ nsInsertTagCommand::IsCommandEnabled(con
   if (editor)
     return editor->GetIsSelectionEditable(outCmdEnabled);
 
   *outCmdEnabled = false;
   return NS_OK;
 }
 
 
-// corresponding STATE_ATTRIBUTE is: src (img) and href (a) 
+// corresponding STATE_ATTRIBUTE is: src (img) and href (a)
 NS_IMETHODIMP
 nsInsertTagCommand::DoCommand(const char *aCmdName, nsISupports *refCon)
 {
   NS_ENSURE_TRUE(mTagName == nsGkAtoms::hr, NS_ERROR_NOT_IMPLEMENTED);
 
   nsCOMPtr<nsIHTMLEditor> editor = do_QueryInterface(refCon);
   NS_ENSURE_TRUE(editor, NS_ERROR_NOT_IMPLEMENTED);
 
@@ -1513,17 +1513,17 @@ RemoveOneProperty(nsIHTMLEditor* aEditor
 nsresult
 RemoveTextProperty(nsIHTMLEditor* aEditor, const nsAString& aProp)
 {
   MOZ_ASSERT(aEditor);
 
   if (aProp.LowerCaseEqualsLiteral("all")) {
     return aEditor->RemoveAllInlineProperties();
   }
-  
+
   return RemoveOneProperty(aEditor, aProp);
 }
 
 // the name of the attribute here should be the contents of the appropriate
 // tag, e.g. 'b' for bold, 'i' for italics.
 nsresult
 SetTextProperty(nsIHTMLEditor* aEditor, const nsAString& aProp)
 {

--- a/editor/composer/nsComposerCommands.h
+++ b/editor/composer/nsComposerCommands.h
@@ -61,47 +61,47 @@ public:
 
   NS_DECL_NSICONTROLLERCOMMAND
 
 protected:
   virtual ~nsBaseStateUpdatingCommand();
 
   // get the current state (on or off) for this style or block format
   virtual nsresult  GetCurrentState(nsIEditor* aEditor, nsICommandParams* aParams) = 0;
-  
+
   // add/remove the style
   virtual nsresult  ToggleState(nsIEditor* aEditor) = 0;
 
 protected:
   nsIAtom* mTagName;
 };
 
 
 // Shared class for the various style updating commands like bold, italics etc.
 // Suitable for commands whose state is either 'on' or 'off'.
 class nsStyleUpdatingCommand : public nsBaseStateUpdatingCommand
 {
 public:
   explicit nsStyleUpdatingCommand(nsIAtom* aTagName);
-           
+
 protected:
 
   // get the current state (on or off) for this style or block format
   virtual nsresult  GetCurrentState(nsIEditor* aEditor, nsICommandParams* aParams);
-  
+
   // add/remove the style
   virtual nsresult  ToggleState(nsIEditor* aEditor);
 };
 
 
 class nsInsertTagCommand : public nsBaseComposerCommand
 {
 public:
   explicit nsInsertTagCommand(nsIAtom* aTagName);
-    
+
   NS_DECL_ISUPPORTS_INHERITED
 
   NS_DECL_NSICONTROLLERCOMMAND
 
 protected:
   virtual ~nsInsertTagCommand();
 
   nsIAtom* mTagName;
@@ -112,51 +112,51 @@ class nsListCommand : public nsBaseState
 {
 public:
   explicit nsListCommand(nsIAtom* aTagName);
 
 protected:
 
   // get the current state (on or off) for this style or block format
   virtual nsresult  GetCurrentState(nsIEditor* aEditor, nsICommandParams* aParams);
-  
+
   // add/remove the style
   virtual nsresult  ToggleState(nsIEditor* aEditor);
 };
 
 class nsListItemCommand : public nsBaseStateUpdatingCommand
 {
 public:
   explicit nsListItemCommand(nsIAtom* aTagName);
 
 protected:
 
   // get the current state (on or off) for this style or block format
   virtual nsresult  GetCurrentState(nsIEditor* aEditor, nsICommandParams* aParams);
-  
+
   // add/remove the style
   virtual nsresult  ToggleState(nsIEditor* aEditor);
 };
 
 // Base class for commands whose state consists of a string (e.g. para format)
 class nsMultiStateCommand : public nsBaseComposerCommand
 {
 public:
-  
+
   nsMultiStateCommand();
-  
+
   NS_DECL_ISUPPORTS_INHERITED
   NS_DECL_NSICONTROLLERCOMMAND
 
 protected:
   virtual ~nsMultiStateCommand();
 
   virtual nsresult GetCurrentState(nsIEditor *aEditor, nsICommandParams* aParams) =0;
   virtual nsresult SetState(nsIEditor *aEditor, nsString& newState) = 0;
-  
+
 };
 
 
 class nsParagraphStateCommand : public nsMultiStateCommand
 {
 public:
                    nsParagraphStateCommand();
 

--- a/editor/composer/nsComposerCommandsUpdater.cpp
+++ b/editor/composer/nsComposerCommandsUpdater.cpp
@@ -59,17 +59,17 @@ NS_IMETHODIMP
 nsComposerCommandsUpdater::NotifyDocumentWillBeDestroyed()
 {
   // cancel any outstanding update timer
   if (mUpdateTimer)
   {
     mUpdateTimer->Cancel();
     mUpdateTimer = nullptr;
   }
-  
+
   // We can't call this right now; it is too late in some cases and the window
   // is already partially destructed (e.g. JS objects may be gone).
 #if 0
   // Trigger an nsIObserve notification that the document will be destroyed
   UpdateOneCommand("obs_documentWillBeDestroyed");
 #endif
   return NS_OK;
 }
@@ -109,21 +109,21 @@ nsComposerCommandsUpdater::DidDo(nsITran
   int32_t undoCount;
   aManager->GetNumberOfUndoItems(&undoCount);
   if (undoCount == 1)
   {
     if (mFirstDoOfFirstUndo)
       UpdateCommandGroup(NS_LITERAL_STRING("undo"));
     mFirstDoOfFirstUndo = false;
   }
-	
+
   return NS_OK;
 }
 
-NS_IMETHODIMP 
+NS_IMETHODIMP
 nsComposerCommandsUpdater::WillUndo(nsITransactionManager *aManager,
                                     nsITransaction *aTransaction,
                                     bool *aInterrupt)
 {
   *aInterrupt = false;
   return NS_OK;
 }
 
@@ -146,17 +146,17 @@ nsComposerCommandsUpdater::WillRedo(nsIT
                                     nsITransaction *aTransaction,
                                     bool *aInterrupt)
 {
   *aInterrupt = false;
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsComposerCommandsUpdater::DidRedo(nsITransactionManager *aManager,  
+nsComposerCommandsUpdater::DidRedo(nsITransactionManager *aManager,
                                    nsITransaction *aTransaction,
                                    nsresult aRedoResult)
 {
   UpdateCommandGroup(NS_LITERAL_STRING("undo"));
   return NS_OK;
 }
 
 NS_IMETHODIMP
@@ -178,17 +178,17 @@ NS_IMETHODIMP
 nsComposerCommandsUpdater::WillEndBatch(nsITransactionManager *aManager,
                                         bool *aInterrupt)
 {
   *aInterrupt = false;
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsComposerCommandsUpdater::DidEndBatch(nsITransactionManager *aManager, 
+nsComposerCommandsUpdater::DidEndBatch(nsITransactionManager *aManager,
                                        nsresult aResult)
 {
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsComposerCommandsUpdater::WillMerge(nsITransactionManager *aManager,
                                      nsITransaction *aTopTransaction,
@@ -272,17 +272,17 @@ nsComposerCommandsUpdater::UpdateDirtySt
 }
 
 nsresult
 nsComposerCommandsUpdater::UpdateCommandGroup(const nsAString& aCommandGroup)
 {
   nsCOMPtr<nsPICommandUpdater> commandUpdater = GetCommandUpdater();
   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");
   }
   else if (aCommandGroup.EqualsLiteral("select") ||
@@ -301,44 +301,44 @@ nsComposerCommandsUpdater::UpdateCommand
     commandUpdater->CommandStatusChanged("cmd_em");
     commandUpdater->CommandStatusChanged("cmd_strong");
     commandUpdater->CommandStatusChanged("cmd_cite");
     commandUpdater->CommandStatusChanged("cmd_abbr");
     commandUpdater->CommandStatusChanged("cmd_acronym");
     commandUpdater->CommandStatusChanged("cmd_code");
     commandUpdater->CommandStatusChanged("cmd_samp");
     commandUpdater->CommandStatusChanged("cmd_var");
-   
+
     commandUpdater->CommandStatusChanged("cmd_increaseFont");
     commandUpdater->CommandStatusChanged("cmd_decreaseFont");
 
     commandUpdater->CommandStatusChanged("cmd_paragraphState");
     commandUpdater->CommandStatusChanged("cmd_fontFace");
     commandUpdater->CommandStatusChanged("cmd_fontColor");
     commandUpdater->CommandStatusChanged("cmd_backgroundColor");
     commandUpdater->CommandStatusChanged("cmd_highlight");
-  }  
+  }
   else if (aCommandGroup.EqualsLiteral("save"))
   {
     // save commands (most are not in C++)
     commandUpdater->CommandStatusChanged("cmd_setDocumentModified");
     commandUpdater->CommandStatusChanged("cmd_save");
   }
-  return NS_OK;  
+  return NS_OK;
 }
 
 nsresult
 nsComposerCommandsUpdater::UpdateOneCommand(const char *aCommand)
 {
   nsCOMPtr<nsPICommandUpdater> commandUpdater = GetCommandUpdater();
   NS_ENSURE_TRUE(commandUpdater, NS_ERROR_FAILURE);
 
   commandUpdater->CommandStatusChanged(aCommand);
 
-  return NS_OK;  
+  return NS_OK;
 }
 
 bool
 nsComposerCommandsUpdater::SelectionIsCollapsed()
 {
   nsCOMPtr<nsIDOMWindow> domWindow = do_QueryReferent(mDOMWindow);
   NS_ENSURE_TRUE(domWindow, true);
 

--- a/editor/composer/nsComposerCommandsUpdater.h
+++ b/editor/composer/nsComposerCommandsUpdater.h
@@ -30,28 +30,28 @@ class nsComposerCommandsUpdater : public
                                   public nsITimerCallback
 {
 public:
 
                                   nsComposerCommandsUpdater();
 
   // nsISupports
   NS_DECL_ISUPPORTS
-  
+
   // nsISelectionListener
   NS_DECL_NSISELECTIONLISTENER
-  
+
   // nsIDocumentStateListener
   NS_DECL_NSIDOCUMENTSTATELISTENER
 
   // nsITimerCallback interfaces
   NS_DECL_NSITIMERCALLBACK
 
   /** nsITransactionListener interfaces
-    */  
+    */
   NS_IMETHOD WillDo(nsITransactionManager *aManager, nsITransaction *aTransaction, bool *aInterrupt) override;
   NS_IMETHOD DidDo(nsITransactionManager *aManager, nsITransaction *aTransaction, nsresult aDoResult) override;
   NS_IMETHOD WillUndo(nsITransactionManager *aManager, nsITransaction *aTransaction, bool *aInterrupt) override;
   NS_IMETHOD DidUndo(nsITransactionManager *aManager, nsITransaction *aTransaction, nsresult aUndoResult) override;
   NS_IMETHOD WillRedo(nsITransactionManager *aManager, nsITransaction *aTransaction, bool *aInterrupt) override;
   NS_IMETHOD DidRedo(nsITransactionManager *aManager, nsITransaction *aTransaction, nsresult aRedoResult) override;
   NS_IMETHOD WillBeginBatch(nsITransactionManager *aManager, bool *aInterrupt) override;
   NS_IMETHOD DidBeginBatch(nsITransactionManager *aManager, nsresult aResult) override;
@@ -70,33 +70,33 @@ protected:
 
   virtual ~nsComposerCommandsUpdater();
 
   enum {
     eStateUninitialized   = -1,
     eStateOff             = false,
     eStateOn              = true
   };
-  
+
   bool          SelectionIsCollapsed();
-  nsresult      UpdateDirtyState(bool aNowDirty);  
+  nsresult      UpdateDirtyState(bool aNowDirty);
   nsresult      UpdateOneCommand(const char* aCommand);
   nsresult      UpdateCommandGroup(const nsAString& aCommandGroup);
 
   already_AddRefed<nsPICommandUpdater> GetCommandUpdater();
-  
+
   nsresult      PrimeUpdateTimer();
   void          TimerCallback();
   nsCOMPtr<nsITimer>  mUpdateTimer;
 
   nsWeakPtr     mDOMWindow;
   nsWeakPtr     mDocShell;
-  int8_t        mDirtyState;  
-  int8_t        mSelectionCollapsed;  
+  int8_t        mDirtyState;
+  int8_t        mSelectionCollapsed;
   bool          mFirstDoOfFirstUndo;
-    
+
 
 };
 
 extern "C" nsresult NS_NewComposerCommandsUpdater(nsISelectionListener** aInstancePtrResult);
 
 
 #endif // nsComposerCommandsUpdater_h__

--- a/editor/composer/nsComposerController.cpp
+++ b/editor/composer/nsComposerController.cpp
@@ -35,24 +35,24 @@ class nsIControllerCommand;
   }
 
 #define NS_REGISTER_STYLE_COMMAND(_cmdClass, _cmdName, _styleTag)       \
   {                                                                     \
     _cmdClass* theCmd = new _cmdClass(_styleTag);                       \
     inCommandTable->RegisterCommand(_cmdName,                           \
                        static_cast<nsIControllerCommand *>(theCmd));    \
   }
-  
+
 #define NS_REGISTER_TAG_COMMAND(_cmdClass, _cmdName, _tagName)          \
   {                                                                     \
     _cmdClass* theCmd = new _cmdClass(_tagName);                        \
     inCommandTable->RegisterCommand(_cmdName,                           \
                        static_cast<nsIControllerCommand *>(theCmd));    \
   }
-  
+
 
 // static
 nsresult
 nsComposerController::RegisterEditorDocStateCommands(
                         nsIControllerCommandTable *inCommandTable)
 {
   // observer commands for document state
   NS_REGISTER_FIRST_COMMAND(nsDocumentStateCommand, "obs_documentCreated")

--- a/editor/composer/nsComposerController.h
+++ b/editor/composer/nsComposerController.h
@@ -9,17 +9,17 @@
 
 #include "nscore.h"                     // for nsresult
 
 class nsIControllerCommandTable;
 
 
 // The plaintext editor controller is used for basic text editing and html editing
 // commands in composer
-// The refCon that gets passed to its commands is initially nsIEditingSession, 
+// The refCon that gets passed to its commands is initially nsIEditingSession,
 //   and after successfule editor creation it is changed to nsIEditor.
 #define NS_EDITORDOCSTATECONTROLLER_CID \
  { 0x50e95301, 0x17a8, 0x11d4, { 0x9f, 0x7e, 0xdd, 0x53, 0x0d, 0x5f, 0x05, 0x7c } }
 
 // The HTMLEditor controller is used only for HTML editors and takes nsIEditor as refCon
 #define NS_HTMLEDITORCONTROLLER_CID \
  { 0x62db0002, 0xdbb6, 0x43f4, { 0x8f, 0xb7, 0x9d, 0x25, 0x38, 0xbc, 0x57, 0x47 } }
 

--- a/editor/composer/nsComposerDocumentCommands.cpp
+++ b/editor/composer/nsComposerDocumentCommands.cpp
@@ -87,26 +87,26 @@ nsSetDocumentOptionsCommand::DoCommandPa
   nsCOMPtr<nsIEditor> editor = do_QueryInterface(refCon);
   NS_ENSURE_TRUE(editor, NS_ERROR_INVALID_ARG);
 
   nsRefPtr<nsPresContext> presContext;
   nsresult rv = GetPresContextFromEditor(editor, getter_AddRefs(presContext));
   NS_ENSURE_SUCCESS(rv, rv);
   NS_ENSURE_TRUE(presContext, NS_ERROR_FAILURE);
 
-  int32_t animationMode; 
+  int32_t animationMode;
   rv = aParams->GetLongValue("imageAnimation", &animationMode);
   if (NS_SUCCEEDED(rv))
   {
     // for possible values of animation mode, see:
     // http://lxr.mozilla.org/seamonkey/source/image/public/imgIContainer.idl
     presContext->SetImageAnimationMode(animationMode);
   }
 
-  bool allowPlugins; 
+  bool allowPlugins;
   rv = aParams->GetBooleanValue("plugins", &allowPlugins);
   if (NS_SUCCEEDED(rv))
   {
     nsCOMPtr<nsIDocShell> docShell(presContext->GetDocShell());
     NS_ENSURE_TRUE(docShell, NS_ERROR_FAILURE);
 
     rv = docShell->SetAllowPlugins(allowPlugins);
     NS_ENSURE_SUCCESS(rv, rv);
@@ -145,17 +145,17 @@ nsSetDocumentOptionsCommand::GetCommandS
   {
     // for possible values of animation mode, see
     // http://lxr.mozilla.org/seamonkey/source/image/public/imgIContainer.idl
     rv = aParams->SetLongValue("imageAnimation",
                                presContext->ImageAnimationMode());
     NS_ENSURE_SUCCESS(rv, rv);
   }
 
-  bool allowPlugins = false; 
+  bool allowPlugins = false;
   rv = aParams->GetBooleanValue("plugins", &allowPlugins);
   if (NS_SUCCEEDED(rv))
   {
     nsCOMPtr<nsIDocShell> docShell(presContext->GetDocShell());
     NS_ENSURE_TRUE(docShell, NS_ERROR_FAILURE);
 
     allowPlugins = docShell->PluginsAllowedInCurrentDoc();
 
@@ -200,33 +200,33 @@ nsSetDocumentStateCommand::DoCommandPara
 {
   nsCOMPtr<nsIEditor> editor = do_QueryInterface(refCon);
   NS_ENSURE_TRUE(editor, NS_ERROR_INVALID_ARG);
 
   if (!nsCRT::strcmp(aCommandName, "cmd_setDocumentModified"))
   {
     NS_ENSURE_ARG_POINTER(aParams);
 
-    bool modified; 
+    bool modified;
     nsresult rv = aParams->GetBooleanValue(STATE_ATTRIBUTE, &modified);
 
     // Should we fail if this param wasn't set?
     // I'm not sure we should be that strict
     NS_ENSURE_SUCCESS(rv, rv);
 
     if (modified)
       return editor->IncrementModificationCount(1);
 
     return editor->ResetModificationCount();
   }
 
   if (!nsCRT::strcmp(aCommandName, "cmd_setDocumentReadOnly"))
   {
     NS_ENSURE_ARG_POINTER(aParams);
-    bool isReadOnly; 
+    bool isReadOnly;
     nsresult rvRO = aParams->GetBooleanValue(STATE_ATTRIBUTE, &isReadOnly);
     NS_ENSURE_SUCCESS(rvRO, rvRO);
 
     uint32_t flags;
     editor->GetFlags(&flags);
     if (isReadOnly)
       flags |= nsIPlaintextEditor::eEditorReadonlyMask;
     else
@@ -371,48 +371,48 @@ nsSetDocumentStateCommand::GetCommandSta
     editor->GetInlineTableEditingEnabled(&enabled);
     return aParams->SetBooleanValue(STATE_ATTRIBUTE, enabled);
   }
 
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 /**
- * Commands just for state notification 
+ * Commands just for state notification
  *  As of 11/21/02, possible commands are:
  *    "obs_documentCreated"
  *    "obs_documentWillBeDestroyed"
  *    "obs_documentLocationChanged"
  *  Note that you can use the same command class, nsDocumentStateCommand
  *    for these or future observer commands.
  *    We check the input command param for different behavior
  *
  *  How to use:
  *  1. Get the nsICommandManager for the current editor
  *  2. Implement an nsIObserve object, e.g:
  *
- *    void Observe( 
+ *    void Observe(
  *        in nsISupports aSubject, // The nsICommandManager calling this Observer
  *        in string      aTopic,   // command name, e.g.:"obs_documentCreated"
  *                                 //    or "obs_documentWillBeDestroyed"
           in wstring     aData );  // ignored (set to "command_status_changed")
  *
  *  3. Add the observer by:
  *       commandManager.addObserver(observeobject, obs_documentCreated);
- *  4. In the appropriate location in editorSession, editor, or commands code, 
+ *  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);
  *  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 
+ *     e.g., any creation state codes when creating an editor are
+ *     supplied for "obs_documentCreated" command in the
  *     "state_data" param's value
  *
  */
 
 NS_IMETHODIMP
 nsDocumentStateCommand::IsCommandEnabled(const char* aCommandName,
                                          nsISupports *refCon,
                                          bool *outCmdEnabled)
@@ -452,46 +452,46 @@ nsDocumentStateCommand::GetCommandStateP
     uint32_t editorStatus = nsIEditingSession::eEditorErrorUnknown;
 
     nsCOMPtr<nsIEditingSession> editingSession = do_QueryInterface(refCon);
     if (editingSession)
     {
       // refCon is initially set to nsIEditingSession until editor
       //  is successfully created and source doc is loaded
       // Embedder gets error status if this fails
-      // If called before startup is finished, 
+      // If called before startup is finished,
       //    status = eEditorCreationInProgress
       rv = editingSession->GetEditorStatus(&editorStatus);
       NS_ENSURE_SUCCESS(rv, rv);
     }
     else
     {
       // If refCon is an editor, then everything started up OK!
       nsCOMPtr<nsIEditor> editor = do_QueryInterface(refCon);
       if (editor)
         editorStatus = nsIEditingSession::eEditorOK;
     }
 
     // Note that if refCon is not-null, but is neither
     // an nsIEditingSession or nsIEditor, we return "eEditorErrorUnknown"
     aParams->SetLongValue(STATE_DATA, editorStatus);
     return NS_OK;
-  }  
+  }
   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);
       NS_ENSURE_TRUE(doc, NS_ERROR_FAILURE);
 
       nsIURI *uri = doc->GetDocumentURI();
       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/nsComposerRegistration.cpp
+++ b/editor/composer/nsComposerRegistration.cpp
@@ -42,96 +42,96 @@ static NS_DEFINE_CID(kHTMLEditorDocState
 // Define the contructor function for the objects
 //
 // NOTE: This creates an instance of objects by using the default constructor
 //
 
 NS_GENERIC_FACTORY_CONSTRUCTOR(nsEditingSession)
 NS_GENERIC_FACTORY_CONSTRUCTOR(nsEditorSpellCheck)
 
-// There are no macros that enable us to have 2 constructors 
+// There are no macros that enable us to have 2 constructors
 // for the same object
 //
 // Here we are creating the same object with two different contract IDs
 // and then initializing it different.
 // Basically, we need to tell the filter whether it is doing mail or not
 static nsresult
 nsComposeTxtSrvFilterConstructor(nsISupports *aOuter, REFNSIID aIID,
                                  void **aResult, bool aIsForMail)
 {
     *aResult = nullptr;
-    if (nullptr != aOuter) 
+    if (nullptr != aOuter)
     {
         return NS_ERROR_NO_AGGREGATION;
     }
     nsComposeTxtSrvFilter * inst = new nsComposeTxtSrvFilter();
-    if (nullptr == inst) 
+    if (nullptr == inst)
     {
         return NS_ERROR_OUT_OF_MEMORY;
     }
     NS_ADDREF(inst);
 	  inst->Init(aIsForMail);
     nsresult rv = inst->QueryInterface(aIID, aResult);
     NS_RELEASE(inst);
     return rv;
 }
 
 static nsresult
-nsComposeTxtSrvFilterConstructorForComposer(nsISupports *aOuter, 
+nsComposeTxtSrvFilterConstructorForComposer(nsISupports *aOuter,
                                             REFNSIID aIID,
                                             void **aResult)
 {
     return nsComposeTxtSrvFilterConstructor(aOuter, aIID, aResult, false);
 }
 
 static nsresult
-nsComposeTxtSrvFilterConstructorForMail(nsISupports *aOuter, 
+nsComposeTxtSrvFilterConstructorForMail(nsISupports *aOuter,
                                         REFNSIID aIID,
                                         void **aResult)
 {
     return nsComposeTxtSrvFilterConstructor(aOuter, aIID, aResult, true);
 }
 
 
 // Constructor for a controller set up with a command table specified
 // by the CID passed in. This function uses do_GetService to get the
 // command table, so that every controller shares a single command
 // table, for space-efficiency.
-// 
+//
 // The only reason to go via the service manager for the command table
 // is that it holds onto the singleton for us, avoiding static variables here.
 static nsresult
 CreateControllerWithSingletonCommandTable(const nsCID& inCommandTableCID, nsIController **aResult)
 {
   nsresult rv;
   nsCOMPtr<nsIController> controller = do_CreateInstance("@mozilla.org/embedcomp/base-command-controller;1", &rv);
   NS_ENSURE_SUCCESS(rv, rv);
 
   nsCOMPtr<nsIControllerCommandTable> composerCommandTable = do_GetService(inCommandTableCID, &rv);
   NS_ENSURE_SUCCESS(rv, rv);
-  
+
   // this guy is a singleton, so make it immutable
   composerCommandTable->MakeImmutable();
-  
+
   nsCOMPtr<nsIControllerContext> controllerContext = do_QueryInterface(controller, &rv);
   NS_ENSURE_SUCCESS(rv, rv);
-  
+
   rv = controllerContext->Init(composerCommandTable);
   NS_ENSURE_SUCCESS(rv, rv);
-  
+
   *aResult = controller;
   NS_ADDREF(*aResult);
   return NS_OK;
 }
 
 
 // Here we make an instance of the controller that holds doc state commands.
 // We set it up with a singleton command table.
 static nsresult
-nsHTMLEditorDocStateControllerConstructor(nsISupports *aOuter, REFNSIID aIID, 
+nsHTMLEditorDocStateControllerConstructor(nsISupports *aOuter, REFNSIID aIID,
                                               void **aResult)
 {
   nsCOMPtr<nsIController> controller;
   nsresult rv = CreateControllerWithSingletonCommandTable(kHTMLEditorDocStateCommandTableCID, getter_AddRefs(controller));
   NS_ENSURE_SUCCESS(rv, rv);
 
   return controller->QueryInterface(aIID, aResult);
 }
@@ -145,50 +145,50 @@ nsHTMLEditorControllerConstructor(nsISup
   nsresult rv = CreateControllerWithSingletonCommandTable(kHTMLEditorCommandTableCID, getter_AddRefs(controller));
   NS_ENSURE_SUCCESS(rv, rv);
 
   return controller->QueryInterface(aIID, aResult);
 }
 
 // Constructor for a command table that is pref-filled with HTML editor commands
 static nsresult
-nsHTMLEditorCommandTableConstructor(nsISupports *aOuter, REFNSIID aIID, 
+nsHTMLEditorCommandTableConstructor(nsISupports *aOuter, REFNSIID aIID,
                                               void **aResult)
 {
   nsresult rv;
   nsCOMPtr<nsIControllerCommandTable> commandTable =
       do_CreateInstance(NS_CONTROLLERCOMMANDTABLE_CONTRACTID, &rv);
   NS_ENSURE_SUCCESS(rv, rv);
-  
+
   rv = nsComposerController::RegisterHTMLEditorCommands(commandTable);
   NS_ENSURE_SUCCESS(rv, rv);
-  
+
   // we don't know here whether we're being created as an instance,
   // or a service, so we can't become immutable
-  
+
   return commandTable->QueryInterface(aIID, aResult);
 }
 
 
 // Constructor for a command table that is pref-filled with HTML editor doc state commands
 static nsresult
-nsHTMLEditorDocStateCommandTableConstructor(nsISupports *aOuter, REFNSIID aIID, 
+nsHTMLEditorDocStateCommandTableConstructor(nsISupports *aOuter, REFNSIID aIID,
                                               void **aResult)
 {
   nsresult rv;
   nsCOMPtr<nsIControllerCommandTable> commandTable =
       do_CreateInstance(NS_CONTROLLERCOMMANDTABLE_CONTRACTID, &rv);
   NS_ENSURE_SUCCESS(rv, rv);
-  
+
   rv = nsComposerController::RegisterEditorDocStateCommands(commandTable);
   NS_ENSURE_SUCCESS(rv, rv);
-  
+
   // we don't know here whether we're being created as an instance,
   // or a service, so we can't become immutable
-  
+
   return commandTable->QueryInterface(aIID, aResult);
 }
 
 NS_DEFINE_NAMED_CID(NS_HTMLEDITORCONTROLLER_CID);
 NS_DEFINE_NAMED_CID(NS_EDITORDOCSTATECONTROLLER_CID);
 NS_DEFINE_NAMED_CID(NS_HTMLEDITOR_COMMANDTABLE_CID);
 NS_DEFINE_NAMED_CID(NS_HTMLEDITOR_DOCSTATE_COMMANDTABLE_CID);
 NS_DEFINE_NAMED_CID(NS_EDITINGSESSION_CID);

--- a/editor/composer/nsEditingSession.cpp
+++ b/editor/composer/nsEditingSession.cpp
@@ -82,34 +82,34 @@ nsEditingSession::nsEditingSession()
 ----------------------------------------------------------------------------*/
 nsEditingSession::~nsEditingSession()
 {
   // Must cancel previous timer?
   if (mLoadBlankDocTimer)
     mLoadBlankDocTimer->Cancel();
 }
 
-NS_IMPL_ISUPPORTS(nsEditingSession, nsIEditingSession, nsIWebProgressListener, 
+NS_IMPL_ISUPPORTS(nsEditingSession, nsIEditingSession, nsIWebProgressListener,
                   nsISupportsWeakReference)
 
 /*---------------------------------------------------------------------------
 
   MakeWindowEditable
 
   aEditorType string, "html" "htmlsimple" "text" "textsimple"
-  void makeWindowEditable(in nsIDOMWindow aWindow, in string aEditorType, 
+  void makeWindowEditable(in nsIDOMWindow aWindow, in string aEditorType,
                           in boolean aDoAfterUriLoad,
                           in boolean aMakeWholeDocumentEditable,
                           in boolean aInteractive);
 ----------------------------------------------------------------------------*/
 #define DEFAULT_EDITOR_TYPE "html"
 
 NS_IMETHODIMP
 nsEditingSession::MakeWindowEditable(nsIDOMWindow *aWindow,
-                                     const char *aEditorType, 
+                                     const char *aEditorType,
                                      bool aDoAfterUriLoad,
                                      bool aMakeWholeDocumentEditable,
                                      bool aInteractive)
 {
   mEditorType.Truncate();
   mEditorFlags = 0;
 
   // disable plugins
@@ -123,33 +123,33 @@ nsEditingSession::MakeWindowEditable(nsI
   nsresult rv;
   if (!mInteractive) {
     rv = DisableJSAndPlugins(aWindow);
     NS_ENSURE_SUCCESS(rv, rv);
   }
 
   // Always remove existing editor
   TearDownEditorOnWindow(aWindow);
-  
+
   // Tells embedder that startup is in progress
   mEditorStatus = eEditorCreationInProgress;
 
   //temporary to set editor type here. we will need different classes soon.
   if (!aEditorType)
     aEditorType = DEFAULT_EDITOR_TYPE;
   mEditorType = aEditorType;
 
-  // if all this does is setup listeners and I don't need listeners, 
+  // if all this does is setup listeners and I don't need listeners,
   // can't this step be ignored?? (based on aDoAfterURILoad)
   rv = PrepareForEditing(aWindow);
-  NS_ENSURE_SUCCESS(rv, rv);  
-  
+  NS_ENSURE_SUCCESS(rv, rv);
+
   // set the flag on the docShell to say that it's editable
   rv = docShell->MakeEditable(aDoAfterUriLoad);
-  NS_ENSURE_SUCCESS(rv, rv);  
+  NS_ENSURE_SUCCESS(rv, rv);
 
   // Setup commands common to plaintext and html editors,
   //  including the document creation observers
   // the first is an editing controller
   rv = SetupEditorCommandController("@mozilla.org/editor/editingcontroller;1",
                                     aWindow,
                                     static_cast<nsIEditingSession*>(this),
                                     &mBaseCommandControllerId);
@@ -242,17 +242,17 @@ nsEditingSession::WindowIsEditable(nsIDO
 
   return docShell->GetEditable(outIsEditable);
 }
 
 
 // These are MIME types that are automatically parsed as "text/plain"
 //   and thus we can edit them as plaintext
 // Note: in older versions, we attempted to convert the mimetype of
-//   the network channel for these and "text/xml" to "text/plain", 
+//   the network channel for these and "text/xml" to "text/plain",
 //   but further investigation reveals that strategy doesn't work
 const char* const gSupportedTextTypes[] = {
   "text/plain",
   "text/css",
   "text/rdf",
   "text/xsl",
   "text/javascript",           // obsolete type
   "text/ecmascript",           // obsolete type
@@ -274,17 +274,17 @@ IsSupportedTextType(const char* aMIMETyp
   {
     if (strcmp(gSupportedTextTypes[i], aMIMEType) == 0)
     {
       return true;
     }
 
     i ++;
   }
-  
+
   return false;
 }
 
 /*---------------------------------------------------------------------------
 
   SetupEditorOnWindow
 
   nsIEditor setupEditorOnWindow (in nsIDOMWindow aWindow);
@@ -341,34 +341,34 @@ nsEditingSession::SetupEditorOnWindow(ns
       }
     }
   }
   bool needHTMLController = false;
 
   const char *classString = "@mozilla.org/editor/htmleditor;1";
   if (mEditorType.EqualsLiteral("textmail"))
   {
-    mEditorFlags = nsIPlaintextEditor::eEditorPlaintextMask | 
-                   nsIPlaintextEditor::eEditorEnableWrapHackMask | 
+    mEditorFlags = nsIPlaintextEditor::eEditorPlaintextMask |
+                   nsIPlaintextEditor::eEditorEnableWrapHackMask |
                    nsIPlaintextEditor::eEditorMailMask;
   }
   else if (mEditorType.EqualsLiteral("text"))
   {
-    mEditorFlags = nsIPlaintextEditor::eEditorPlaintextMask | 
+    mEditorFlags = nsIPlaintextEditor::eEditorPlaintextMask |
                    nsIPlaintextEditor::eEditorEnableWrapHackMask;
   }
   else if (mEditorType.EqualsLiteral("htmlmail"))
   {
     if (mimeCType.EqualsLiteral("text/html"))
     {
       needHTMLController = true;
       mEditorFlags = nsIPlaintextEditor::eEditorMailMask;
     }
     else //set the flags back to textplain.
-      mEditorFlags = nsIPlaintextEditor::eEditorPlaintextMask | 
+      mEditorFlags = nsIPlaintextEditor::eEditorPlaintextMask |
                      nsIPlaintextEditor::eEditorEnableWrapHackMask;
   }
   else // Defaulted to html
   {
     needHTMLController = true;
   }
 
   if (mInteractive) {
@@ -385,20 +385,20 @@ nsEditingSession::SetupEditorOnWindow(ns
   NS_ENSURE_SUCCESS(rv, rv);
 
   if (mEditorStatus != eEditorCreationInProgress)
   {
     mStateMaintainer->NotifyDocumentCreated();
     return NS_ERROR_FAILURE;
   }
 
-  // Create editor and do other things 
+  // Create editor and do other things
   //  only if we haven't found some error above,
   nsCOMPtr<nsIDocShell> docShell = GetDocShellFromWindow(aWindow);
-  NS_ENSURE_TRUE(docShell, NS_ERROR_FAILURE);  
+  NS_ENSURE_TRUE(docShell, NS_ERROR_FAILURE);
 
   if (!mInteractive) {
     // Disable animation of images in this document:
     nsCOMPtr<nsIPresShell> presShell = docShell->GetPresShell();
     NS_ENSURE_TRUE(presShell, NS_ERROR_FAILURE);
     nsPresContext* presContext = presShell->GetPresContext();
     NS_ENSURE_TRUE(presContext, NS_ERROR_FAILURE);
 
@@ -434,17 +434,17 @@ nsEditingSession::SetupEditorOnWindow(ns
   rv = editor->SetContentsMIMEType(mimeCType.get());
   NS_ENSURE_SUCCESS(rv, rv);
 
   nsCOMPtr<nsIContentViewer> contentViewer;
   rv = docShell->GetContentViewer(getter_AddRefs(contentViewer));
   NS_ENSURE_SUCCESS(rv, rv);
   NS_ENSURE_TRUE(contentViewer, NS_ERROR_FAILURE);
 
-  nsCOMPtr<nsIDOMDocument> domDoc;  
+  nsCOMPtr<nsIDOMDocument> domDoc;
   rv = contentViewer->GetDOMDocument(getter_AddRefs(domDoc));
   NS_ENSURE_SUCCESS(rv, rv);
   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);
@@ -516,17 +516,17 @@ nsEditingSession::TearDownEditorOnWindow
 {
   if (!mDoneSetup) {
     return NS_OK;
   }
 
   NS_ENSURE_TRUE(aWindow, NS_ERROR_NULL_POINTER);
 
   nsresult rv;
-  
+
   // Kill any existing reload timer
   if (mLoadBlankDocTimer)
   {
     mLoadBlankDocTimer->Cancel();
     mLoadBlankDocTimer = nullptr;
   }
 
   mDoneSetup = false;
@@ -536,27 +536,27 @@ nsEditingSession::TearDownEditorOnWindow
   aWindow->GetDocument(getter_AddRefs(domDoc));
   nsCOMPtr<nsIHTMLDocument> htmlDoc = do_QueryInterface(domDoc);
   bool stopEditing = htmlDoc && htmlDoc->IsEditingOn();
   if (stopEditing)
     RemoveWebProgressListener(aWindow);
 
   nsCOMPtr<nsIDocShell> docShell = GetDocShellFromWindow(aWindow);
   NS_ENSURE_STATE(docShell);
-  
+
   nsCOMPtr<nsIEditor> editor;
   rv = docShell->GetEditor(getter_AddRefs(editor));
   NS_ENSURE_SUCCESS(rv, rv);
 
   if (stopEditing)
     htmlDoc->TearingDownEditor(editor);
 
   if (mStateMaintainer && editor)
   {
-    // Null out the editor on the controllers first to prevent their weak 
+    // Null out the editor on the controllers first to prevent their weak
     // references from pointing to a destroyed editor.
     SetEditorOnControllers(aWindow, nullptr);
   }
 
   // Null out the editor on the docShell to trigger PreDestroy which
   // needs to happen before document state listeners are removed below.
   docShell->SetEditor(nullptr);
 
@@ -585,23 +585,23 @@ nsEditingSession::TearDownEditorOnWindow
 }
 
 /*---------------------------------------------------------------------------
 
   GetEditorForFrame
 
   nsIEditor getEditorForFrame (in nsIDOMWindow aWindow);
 ----------------------------------------------------------------------------*/
-NS_IMETHODIMP 
+NS_IMETHODIMP
 nsEditingSession::GetEditorForWindow(nsIDOMWindow *aWindow,
                                      nsIEditor **outEditor)
 {
   nsCOMPtr<nsIDocShell> docShell = GetDocShellFromWindow(aWindow);
   NS_ENSURE_STATE(aWindow);
-  
+
   return docShell->GetEditor(outEditor);
 }
 
 /*---------------------------------------------------------------------------
 
   OnStateChange
 
 ----------------------------------------------------------------------------*/
@@ -785,17 +785,17 @@ nsEditingSession::OnProgressChange(nsIWe
 }
 
 /*---------------------------------------------------------------------------
 
   OnLocationChange
 
 ----------------------------------------------------------------------------*/
 NS_IMETHODIMP
-nsEditingSession::OnLocationChange(nsIWebProgress *aWebProgress, 
+nsEditingSession::OnLocationChange(nsIWebProgress *aWebProgress,
                                    nsIRequest *aRequest, nsIURI *aURI,
                                    uint32_t aFlags)
 {
   nsCOMPtr<nsIDOMWindow> domWindow;
   nsresult rv = aWebProgress->GetDOMWindow(getter_AddRefs(domWindow));
   NS_ENSURE_SUCCESS(rv, rv);
 
   nsCOMPtr<nsIDOMDocument> domDoc;
@@ -863,18 +863,18 @@ nsEditingSession::IsProgressForTargetDoc
   return editedWebProgress == aWebProgress;
 }
 
 
 /*---------------------------------------------------------------------------
 
   GetEditorStatus
 
-  Called during GetCommandStateParams("obs_documentCreated"...) 
-  to determine if editor was created and document 
+  Called during GetCommandStateParams("obs_documentCreated"...)
+  to determine if editor was created and document
   was loaded successfully
 ----------------------------------------------------------------------------*/
 NS_IMETHODIMP
 nsEditingSession::GetEditorStatus(uint32_t *aStatus)
 {
   NS_ENSURE_ARG_POINTER(aStatus);
   *aStatus = mEditorStatus;
   return NS_OK;
@@ -882,36 +882,36 @@ nsEditingSession::GetEditorStatus(uint32
 
 /*---------------------------------------------------------------------------
 
   StartDocumentLoad
 
   Called on start of load in a single frame
 ----------------------------------------------------------------------------*/
 nsresult
-nsEditingSession::StartDocumentLoad(nsIWebProgress *aWebProgress, 
+nsEditingSession::StartDocumentLoad(nsIWebProgress *aWebProgress,
                                     bool aIsToBeMadeEditable)
 {
 #ifdef NOISY_DOC_LOADING
   printf("======= StartDocumentLoad ========\n");
 #endif
 
   NS_ENSURE_ARG_POINTER(aWebProgress);
-  
+
   // 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);
     NS_ENSURE_TRUE(docShell, NS_ERROR_FAILURE);
     docShell->DetachEditorFromWindow();
   }
-    
+
   if (aIsToBeMadeEditable)
     mEditorStatus = eEditorCreationInProgress;
 
   return NS_OK;
 }
 
 /*---------------------------------------------------------------------------
 
@@ -920,37 +920,37 @@ nsEditingSession::StartDocumentLoad(nsIW
   Called on end of load in a single frame
 ----------------------------------------------------------------------------*/
 nsresult
 nsEditingSession::EndDocumentLoad(nsIWebProgress *aWebProgress,
                                   nsIChannel* aChannel, nsresult aStatus,
                                   bool aIsToBeMadeEditable)
 {
   NS_ENSURE_ARG_POINTER(aWebProgress);
-  
+
 #ifdef NOISY_DOC_LOADING
   printf("======= EndDocumentLoad ========\n");
   printf("with status %d, ", aStatus);
   nsCOMPtr<nsIURI> uri;
   nsXPIDLCString spec;
   if (NS_SUCCEEDED(aChannel->GetURI(getter_AddRefs(uri)))) {
     uri->GetSpec(spec);
     printf(" uri %s\n", spec.get());
   }
 #endif
 
   // We want to call the base class EndDocumentLoad,
   // but avoid some of the stuff
   // that nsDocShell does (need to refactor).
-  
+
   // OK, time to make an editor on this document
   nsCOMPtr<nsIDOMWindow> domWindow;
   aWebProgress->GetDOMWindow(getter_AddRefs(domWindow));
-  
-  // Set the error state -- we will create an editor 
+
+  // 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);
   NS_ENSURE_TRUE(docShell, NS_ERROR_FAILURE);       // better error handling?
@@ -964,17 +964,17 @@ nsEditingSession::EndDocumentLoad(nsIWeb
 
   nsresult rv = NS_OK;
 
   // did someone set the flag to make this shell editable?
   if (aIsToBeMadeEditable && mCanCreateEditor)
   {
     bool    makeEditable;
     docShell->GetEditable(&makeEditable);
-  
+
     if (makeEditable)
     {
       // To keep pre Gecko 1.9 behavior, setup editor always when
       // mMakeWholeDocumentEditable.
       bool needsSetup = false;
       if (mMakeWholeDocumentEditable) {
         needsSetup = true;
       } else {
@@ -994,17 +994,17 @@ nsEditingSession::EndDocumentLoad(nsIWeb
         {
           // If we had an error, setup timer to load a blank page later
           if (mLoadBlankDocTimer)
           {
             // Must cancel previous timer?
             mLoadBlankDocTimer->Cancel();
             mLoadBlankDocTimer = nullptr;
           }
-  
+
           mLoadBlankDocTimer = do_CreateInstance("@mozilla.org/timer;1", &rv);
           NS_ENSURE_SUCCESS(rv, rv);
 
           mEditorStatus = eEditorCreationInProgress;
           mLoadBlankDocTimer->InitWithFuncCallback(
                                           nsEditingSession::TimerCallback,
                                           static_cast<void*> (mDocShell.get()),
                                           10, nsITimer::TYPE_ONE_SHOT);
@@ -1058,25 +1058,25 @@ nsEditingSession::EndPageLoad(nsIWebProg
   printf("======= EndPageLoad ========\n");
   printf("  with status %d, ", aStatus);
   nsCOMPtr<nsIURI> uri;
   nsXPIDLCString spec;
   if (NS_SUCCEEDED(aChannel->GetURI(getter_AddRefs(uri)))) {
     uri->GetSpec(spec);
     printf("uri %s\n", spec.get());
   }
- 
+
   nsAutoCString contentType;
   aChannel->GetContentType(contentType);
   if (!contentType.IsEmpty())
-    printf("   flags = %d, status = %d, MIMETYPE = %s\n", 
+    printf("   flags = %d, status = %d, MIMETYPE = %s\n",
                mEditorFlags, mEditorStatus, contentType.get());
 #endif
 
-  // Set the error state -- we will create an editor anyway 
+  // Set the error state -- we will create an editor anyway
   // 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);
@@ -1118,26 +1118,26 @@ nsEditingSession::GetDocShellFromWindow(
 
   Set up this editing session for one or more editors
 ----------------------------------------------------------------------------*/
 nsresult
 nsEditingSession::PrepareForEditing(nsIDOMWindow *aWindow)
 {
   if (mProgressListenerRegistered)
     return NS_OK;
-    
+
   nsIDocShell *docShell = GetDocShellFromWindow(aWindow);
-  
+
   // register callback
   nsCOMPtr<nsIWebProgress> webProgress = do_GetInterface(docShell);
   NS_ENSURE_TRUE(webProgress, NS_ERROR_FAILURE);
 
   nsresult rv =
     webProgress->AddProgressListener(this,
-                                     (nsIWebProgress::NOTIFY_STATE_NETWORK  | 
+                                     (nsIWebProgress::NOTIFY_STATE_NETWORK  |
                                       nsIWebProgress::NOTIFY_STATE_DOCUMENT |
                                       nsIWebProgress::NOTIFY_LOCATION));
 
   mProgressListenerRegistered = NS_SUCCEEDED(rv);
 
   return rv;
 }
 
@@ -1154,57 +1154,57 @@ nsEditingSession::SetupEditorCommandCont
                                   nsIDOMWindow *aWindow,
                                   nsISupports *aContext,
                                   uint32_t *aControllerId)
 {
   NS_ENSURE_ARG_POINTER(aControllerClassName);
   NS_ENSURE_ARG_POINTER(aWindow);
   NS_ENSURE_ARG_POINTER(aContext);
   NS_ENSURE_ARG_POINTER(aControllerId);
-  
-  nsCOMPtr<nsIControllers> controllers;      
+
+  nsCOMPtr<nsIControllers> controllers;
   nsresult rv = aWindow->GetControllers(getter_AddRefs(controllers));
   NS_ENSURE_SUCCESS(rv, rv);
 
   // We only have to create each singleton controller once
   // We know this has happened once we have a controllerId value
   if (!*aControllerId)
   {
     nsCOMPtr<nsIController> controller;
     controller = do_CreateInstance(aControllerClassName, &rv);
-    NS_ENSURE_SUCCESS(rv, rv);  
+    NS_ENSURE_SUCCESS(rv, rv);
 
     // We must insert at head of the list to be sure our
     //   controller is found before other implementations
     //   (e.g., not-implemented versions by browser)
     rv = controllers->InsertControllerAt(0, controller);
-    NS_ENSURE_SUCCESS(rv, rv);  
+    NS_ENSURE_SUCCESS(rv, rv);
 
     // Remember the ID for the controller
     rv = controllers->GetControllerId(controller, aControllerId);
-    NS_ENSURE_SUCCESS(rv, rv);  
-  }  
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
 
   // Set the context
   return SetContextOnControllerById(controllers, aContext, *aControllerId);
 }
 
 /*---------------------------------------------------------------------------
 
   SetEditorOnControllers
 
   Set the editor on the controller(s) for this window
 ----------------------------------------------------------------------------*/
 NS_IMETHODIMP
 nsEditingSession::SetEditorOnControllers(nsIDOMWindow *aWindow,
                                          nsIEditor* aEditor)
 {
   NS_ENSURE_TRUE(aWindow, NS_ERROR_NULL_POINTER);
-  
-  nsCOMPtr<nsIControllers> controllers;      
+
+  nsCOMPtr<nsIControllers> controllers;
   nsresult rv = aWindow->GetControllers(getter_AddRefs(controllers));
   NS_ENSURE_SUCCESS(rv, rv);
 
   nsCOMPtr<nsISupports> editorAsISupports = do_QueryInterface(aEditor);
   if (mBaseCommandControllerId)
   {
     rv = SetContextOnControllerById(controllers, editorAsISupports,
                                     mBaseCommandControllerId);
@@ -1228,31 +1228,31 @@ nsEditingSession::SetEditorOnControllers
 nsresult
 nsEditingSession::SetContextOnControllerById(nsIControllers* aControllers,
                                              nsISupports* aContext,
                                              uint32_t aID)
 {
   NS_ENSURE_ARG_POINTER(aControllers);
 
   // aContext can be null (when destroying editor)
-  nsCOMPtr<nsIController> controller;    
+  nsCOMPtr<nsIController> controller;
   aControllers->GetControllerById(aID, getter_AddRefs(controller));
-  
+
   // ok with nil controller
   nsCOMPtr<nsIControllerContext> editorController =
                                        do_QueryInterface(controller);
   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 
+  // Remove editor controllers from the aWindow, call when we're
   // tearing down/detaching editor.
 
   nsCOMPtr<nsIControllers> controllers;
   if (aWindow)
     aWindow->GetControllers(getter_AddRefs(controllers));
 
   if (controllers)
   {

--- a/editor/composer/nsEditingSession.h
+++ b/editor/composer/nsEditingSession.h
@@ -51,66 +51,66 @@ public:
 
   nsEditingSession();
 
   // nsISupports
   NS_DECL_ISUPPORTS
 
   // nsIWebProgressListener
   NS_DECL_NSIWEBPROGRESSLISTENER
-  
+
   // nsIEditingSession
   NS_DECL_NSIEDITINGSESSION
 
 protected:
   virtual         ~nsEditingSession();
 
   nsIDocShell *   GetDocShellFromWindow(nsIDOMWindow *aWindow);
-  
+
   nsresult        SetupEditorCommandController(const char *aControllerClassName,
                                                nsIDOMWindow *aWindow,
                                                nsISupports *aContext,
                                                uint32_t *aControllerId);
 
-  nsresult        SetContextOnControllerById(nsIControllers* aControllers, 
+  nsresult        SetContextOnControllerById(nsIControllers* aControllers,
                                             nsISupports* aContext,
                                             uint32_t aID);
 
   nsresult        PrepareForEditing(nsIDOMWindow *aWindow);
 
   static void     TimerCallback(nsITimer *aTimer, void *aClosure);
   nsCOMPtr<nsITimer>  mLoadBlankDocTimer;
-  
+
   // progress load stuff
   nsresult        StartDocumentLoad(nsIWebProgress *aWebProgress,
                                     bool isToBeMadeEditable);
-  nsresult        EndDocumentLoad(nsIWebProgress *aWebProgress, 
+  nsresult        EndDocumentLoad(nsIWebProgress *aWebProgress,
                                   nsIChannel* aChannel, nsresult aStatus,
                                   bool isToBeMadeEditable);
   nsresult        StartPageLoad(nsIChannel *aChannel);
-  nsresult        EndPageLoad(nsIWebProgress *aWebProgress, 
+  nsresult        EndPageLoad(nsIWebProgress *aWebProgress,
                               nsIChannel* aChannel, nsresult aStatus);
-  
+
   bool            IsProgressForTargetDocument(nsIWebProgress *aWebProgress);
 
   void            RemoveEditorControllers(nsIDOMWindow *aWindow);
   void            RemoveWebProgressListener(nsIDOMWindow *aWindow);
   void            RestoreAnimationMode(nsIDOMWindow *aWindow);
   void            RemoveListenersAndControllers(nsIDOMWindow *aWindow,
                                                 nsIEditor *aEditor);
 
 protected:
 
   bool            mDoneSetup;    // have we prepared for editing yet?
 
   // Used to prevent double creation of editor because nsIWebProgressListener
-  //  receives a STATE_STOP notification before the STATE_START 
-  //  for our document, so we wait for the STATE_START, then STATE_STOP 
+  //  receives a STATE_STOP notification before the STATE_START
+  //  for our document, so we wait for the STATE_START, then STATE_STOP
   //  before creating an editor
-  bool            mCanCreateEditor; 
+  bool            mCanCreateEditor;
 
   bool            mInteractive;
   bool            mMakeWholeDocumentEditable;
 
   bool            mDisabledJSAndPlugins;
 
   // True if scripts were enabled before the editor turned scripts
   // off, otherwise false.
@@ -123,19 +123,19 @@ protected:
   bool            mProgressListenerRegistered;
 
   // The image animation mode before it was turned off.
   uint16_t        mImageAnimationMode;
 
   // THE REMAINING MEMBER VARIABLES WILL BECOME A SET WHEN WE EDIT
   // MORE THAN ONE EDITOR PER EDITING SESSION
   nsRefPtr<nsComposerCommandsUpdater> mStateMaintainer;
-  
+
   // Save the editor type so we can create the editor after loading uri
-  nsCString       mEditorType; 
+  nsCString       mEditorType;
   uint32_t        mEditorFlags;
   uint32_t        mEditorStatus;
   uint32_t        mBaseCommandControllerId;
   uint32_t        mDocStateControllerId;
   uint32_t        mHTMLCommandControllerId;
 
   // Make sure the docshell we use is safe
   nsWeakPtr       mDocShell;

--- a/editor/composer/nsEditorSpellCheck.cpp
+++ b/editor/composer/nsEditorSpellCheck.cpp
@@ -316,17 +316,17 @@ public:
     }
     return NS_OK;
   }
 
 private:
   nsCOMPtr<nsIEditorSpellCheckCallback> mCallback;
 };
 
-NS_IMETHODIMP    
+NS_IMETHODIMP
 nsEditorSpellCheck::InitSpellChecker(nsIEditor* aEditor, bool aEnableSelectionChecking, nsIEditorSpellCheckCallback* aCallback)
 {
   NS_ENSURE_TRUE(aEditor, NS_ERROR_NULL_POINTER);
   mEditor = aEditor;
 
   nsresult rv;
 
   // We can spell check with any editor type
@@ -403,131 +403,131 @@ nsEditorSpellCheck::InitSpellChecker(nsI
     NS_ENSURE_STATE(caller);
     rv = NS_DispatchToMainThread(caller);
     NS_ENSURE_SUCCESS(rv, rv);
   }
 
   return NS_OK;
 }
 
-NS_IMETHODIMP    
+NS_IMETHODIMP
 nsEditorSpellCheck::GetNextMisspelledWord(char16_t **aNextMisspelledWord)
 {
   NS_ENSURE_TRUE(mSpellChecker, NS_ERROR_NOT_INITIALIZED);
 
   nsAutoString nextMisspelledWord;
-  
+
   DeleteSuggestedWordList();
   // Beware! This may flush notifications via synchronous
   // ScrollSelectionIntoView.
   nsresult rv = mSpellChecker->NextMisspelledWord(nextMisspelledWord,
                                                   &mSuggestedWordList);
 
   *aNextMisspelledWord = ToNewUnicode(nextMisspelledWord);
   return rv;
 }
 
-NS_IMETHODIMP    
+NS_IMETHODIMP
 nsEditorSpellCheck::GetSuggestedWord(char16_t **aSuggestedWord)
 {
   nsAutoString word;
   if ( mSuggestedWordIndex < int32_t(mSuggestedWordList.Length()))
   {
     *aSuggestedWord = ToNewUnicode(mSuggestedWordList[mSuggestedWordIndex]);
     mSuggestedWordIndex++;
   } else {
     // A blank string signals that there are no more strings
     *aSuggestedWord = ToNewUnicode(EmptyString());
   }
   return NS_OK;
 }
 
-NS_IMETHODIMP    
+NS_IMETHODIMP
 nsEditorSpellCheck::CheckCurrentWord(const char16_t *aSuggestedWord,
                                      bool *aIsMisspelled)
 {
   NS_ENSURE_TRUE(mSpellChecker, NS_ERROR_NOT_INITIALIZED);
 
   DeleteSuggestedWordList();
   return mSpellChecker->CheckWord(nsDependentString(aSuggestedWord),
                                   aIsMisspelled, &mSuggestedWordList);
 }
 
-NS_IMETHODIMP    
+NS_IMETHODIMP
 nsEditorSpellCheck::CheckCurrentWordNoSuggest(const char16_t *aSuggestedWord,
                                               bool *aIsMisspelled)
 {
   NS_ENSURE_TRUE(mSpellChecker, NS_ERROR_NOT_INITIALIZED);
 
   return mSpellChecker->CheckWord(nsDependentString(aSuggestedWord),
                                   aIsMisspelled, nullptr);
 }
 
-NS_IMETHODIMP    
+NS_IMETHODIMP
 nsEditorSpellCheck::ReplaceWord(const char16_t *aMisspelledWord,
                                 const char16_t *aReplaceWord,
                                 bool             allOccurrences)
 {
   NS_ENSURE_TRUE(mSpellChecker, NS_ERROR_NOT_INITIALIZED);
 
   return mSpellChecker->Replace(nsDependentString(aMisspelledWord),
                                 nsDependentString(aReplaceWord), allOccurrences);
 }
 
-NS_IMETHODIMP    
+NS_IMETHODIMP
 nsEditorSpellCheck::IgnoreWordAllOccurrences(const char16_t *aWord)
 {
   NS_ENSURE_TRUE(mSpellChecker, NS_ERROR_NOT_INITIALIZED);
 
   return mSpellChecker->IgnoreAll(nsDependentString(aWord));
 }
 
-NS_IMETHODIMP    
+NS_IMETHODIMP
 nsEditorSpellCheck::GetPersonalDictionary()
 {
   NS_ENSURE_TRUE(mSpellChecker, NS_ERROR_NOT_INITIALIZED);
 
    // We can spell check with any editor type
   mDictionaryList.Clear();
   mDictionaryIndex = 0;
   return mSpellChecker->GetPersonalDictionary(&mDictionaryList);
 }
 
-NS_IMETHODIMP    
+NS_IMETHODIMP
 nsEditorSpellCheck::GetPersonalDictionaryWord(char16_t **aDictionaryWord)
 {
   if ( mDictionaryIndex < int32_t( mDictionaryList.Length()))
   {
     *aDictionaryWord = ToNewUnicode(mDictionaryList[mDictionaryIndex]);
     mDictionaryIndex++;
   } else {
     // A blank string signals that there are no more strings
     *aDictionaryWord = ToNewUnicode(EmptyString());
   }
 
   return NS_OK;
 }
 
-NS_IMETHODIMP    
+NS_IMETHODIMP
 nsEditorSpellCheck::AddWordToDictionary(const char16_t *aWord)
 {
   NS_ENSURE_TRUE(mSpellChecker, NS_ERROR_NOT_INITIALIZED);
 
   return mSpellChecker->AddWordToPersonalDictionary(nsDependentString(aWord));
 }
 
-NS_IMETHODIMP    
+NS_IMETHODIMP
 nsEditorSpellCheck::RemoveWordFromDictionary(const char16_t *aWord)
 {
   NS_ENSURE_TRUE(mSpellChecker, NS_ERROR_NOT_INITIALIZED);
 
   return mSpellChecker->RemoveWordFromPersonalDictionary(nsDependentString(aWord));
 }
 
-NS_IMETHODIMP    
+NS_IMETHODIMP
 nsEditorSpellCheck::GetDictionaryList(char16_t ***aDictionaryList, uint32_t *aCount)
 {
   NS_ENSURE_TRUE(mSpellChecker, NS_ERROR_NOT_INITIALIZED);
 
   NS_ENSURE_TRUE(aDictionaryList && aCount, NS_ERROR_NULL_POINTER);
 
   *aDictionaryList = 0;
   *aCount          = 0;
@@ -568,25 +568,25 @@ nsEditorSpellCheck::GetDictionaryList(ch
   for (i = 0; i < *aCount; i++)
   {
     tmpPtr[i] = ToNewUnicode(dictList[i]);
   }
 
   return rv;
 }
 
-NS_IMETHODIMP    
+NS_IMETHODIMP
 nsEditorSpellCheck::GetCurrentDictionary(nsAString& aDictionary)
 {
   NS_ENSURE_TRUE(mSpellChecker, NS_ERROR_NOT_INITIALIZED);
 
   return mSpellChecker->GetCurrentDictionary(aDictionary);
 }
 
-NS_IMETHODIMP    
+NS_IMETHODIMP
 nsEditorSpellCheck::SetCurrentDictionary(const nsAString& aDictionary)
 {
   NS_ENSURE_TRUE(mSpellChecker, NS_ERROR_NOT_INITIALIZED);
 
   nsRefPtr<nsEditorSpellCheck> kungFuDeathGrip = this;
 
   // The purpose of mUpdateDictionaryRunning is to avoid doing all of this if
   // UpdateCurrentDictionary's helper method DictionaryFetched, which calls us,
@@ -647,39 +647,39 @@ nsEditorSpellCheck::CheckCurrentDictiona
   if (dictList.Length() > 0) {
     rv = SetCurrentDictionary(dictList[0]);
     NS_ENSURE_SUCCESS(rv, rv);
   }
 
   return NS_OK;
 }
 
-NS_IMETHODIMP    
+NS_IMETHODIMP
 nsEditorSpellCheck::UninitSpellChecker()
 {
   NS_ENSURE_TRUE(mSpellChecker, NS_ERROR_NOT_INITIALIZED);
 
   // Cleanup - kill the spell checker
   DeleteSuggestedWordList();
   mDictionaryList.Clear();
   mDictionaryIndex = 0;
   mSpellChecker = 0;
   return NS_OK;
 }
 
 
 /* void setFilter (in nsITextServicesFilter filter); */
-NS_IMETHODIMP 
+NS_IMETHODIMP
 nsEditorSpellCheck::SetFilter(nsITextServicesFilter *filter)
 {
   mTxtSrvFilter = filter;
   return NS_OK;
 }
 
-nsresult    
+nsresult
 nsEditorSpellCheck::DeleteSuggestedWordList()
 {
   mSuggestedWordList.Clear();
   mSuggestedWordIndex = 0;
   return NS_OK;
 }
 
 NS_IMETHODIMP
@@ -793,17 +793,17 @@ nsEditorSpellCheck::DictionaryFetched(Di
       AppendUTF8toUTF16(utf8DictName, dictName);
     }
   }
 
   if (NS_SUCCEEDED(rv) && !dictName.IsEmpty()) {
     rv = SetCurrentDictionary(dictName);
     if (NS_FAILED(rv)) {
       // required dictionary was not available. Try to get a dictionary
-      // matching at least language part of dictName: 
+      // matching at least language part of dictName:
 
       nsAutoString langCode;
       int32_t dashIdx = dictName.FindChar('-');
       if (dashIdx != -1) {
         langCode.Assign(Substring(dictName, 0, dashIdx));
       } else {
         langCode.Assign(dictName);
       }

--- a/editor/composer/nsIEditingSession.idl
+++ b/editor/composer/nsIEditingSession.idl
@@ -38,37 +38,37 @@ interface nsIEditingSession : nsISupport
    *                                    embedder who should make the document
    *                                    (or part of it) editable.
    *  @param aInteractive if PR_FALSE turn off scripting and plugins
    */
   void makeWindowEditable(in nsIDOMWindow window, in string aEditorType,
                           in boolean doAfterUriLoad,
                           in boolean aMakeWholeDocumentEditable,
                           in boolean aInteractive);
-  
+
   /**
    *  Test whether a specific window has had its editable flag set; it may have an editor
    *  now, or will get one after the uri load.
-   *  
+   *
    *  Use this, passing the content root window, to test if we've set up editing
    *  for this content.
    */
   boolean windowIsEditable(in nsIDOMWindow window);
-  
+
   /**
    *  Get the editor for this window. May return null
    */
-	nsIEditor getEditorForWindow(in nsIDOMWindow window);	
+	nsIEditor getEditorForWindow(in nsIDOMWindow window);
 
-  /** 
+  /**
    *  Setup editor and related support objects
    */
   void setupEditorOnWindow(in nsIDOMWindow window);
 
-  /** 
+  /**
    *   Destroy editor and related support objects
    */
   void tearDownEditorOnWindow(in nsIDOMWindow window);
 
   void setEditorOnControllers(in nsIDOMWindow aWindow,
                               in nsIEditor aEditor);
 
   /**

--- a/editor/libeditor/InsertTextTxn.h
+++ b/editor/libeditor/InsertTextTxn.h
@@ -39,17 +39,17 @@ public:
     * @param aString  the new text to insert
     * @param aPresShell used to get and set the selection
     */
   InsertTextTxn(Text& aTextNode, uint32_t aOffset, const nsAString& aString,
                 nsEditor& aEditor);
 
   NS_DECL_ISUPPORTS_INHERITED
   NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(InsertTextTxn, EditTxn)
-	
+
   NS_DECL_EDITTXN
 
   NS_IMETHOD Merge(nsITransaction* aTransaction, bool* aDidMerge) override;
 
   /** Return the string data associated with this transaction */
   void GetData(nsString& aResult);
 
 private:

--- a/editor/libeditor/PlaceholderTxn.cpp
+++ b/editor/libeditor/PlaceholderTxn.cpp
@@ -8,18 +8,18 @@
 #include "IMETextTxn.h"
 #include "nsGkAtoms.h"
 #include "mozilla/dom/Selection.h"
 #include "nsQueryObject.h"
 
 using namespace mozilla;
 using namespace mozilla::dom;
 
-PlaceholderTxn::PlaceholderTxn() :  EditAggregateTxn(), 
-                                    mAbsorb(true), 
+PlaceholderTxn::PlaceholderTxn() :  EditAggregateTxn(),
+                                    mAbsorb(true),
                                     mForwarding(nullptr),
                                     mIMETextTxn(nullptr),
                                     mCommitted(false),
                                     mStartSel(nullptr),
                                     mEndSel(),
                                     mEditor(nullptr)
 {
 }
@@ -67,47 +67,47 @@ NS_IMETHODIMP PlaceholderTxn::DoTransact
   return NS_OK;
 }
 
 NS_IMETHODIMP PlaceholderTxn::UndoTransaction(void)
 {
   // undo txns
   nsresult res = EditAggregateTxn::UndoTransaction();
   NS_ENSURE_SUCCESS(res, res);
-  
+
   NS_ENSURE_TRUE(mStartSel, NS_ERROR_NULL_POINTER);
 
   // now restore selection
   nsRefPtr<Selection> selection = mEditor->GetSelection();
   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
   nsRefPtr<Selection> selection = mEditor->GetSelection();
   NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
   return mEndSel.RestoreSelection(selection);
 }
 
 
 NS_IMETHODIMP PlaceholderTxn::Merge(nsITransaction *aTransaction, bool *aDidMerge)
 {
   NS_ENSURE_TRUE(aDidMerge && aTransaction, NS_ERROR_NULL_POINTER);
 
   // set out param default value
   *aDidMerge=false;
-    
-  if (mForwarding) 
+
+  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
@@ -117,28 +117,28 @@ NS_IMETHODIMP PlaceholderTxn::Merge(nsIT
   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_QueryObject(editTxn);
 
   // we are absorbing all txn's if mAbsorb is lit.
   if (mAbsorb)
-  { 
+  {
     nsRefPtr<IMETextTxn> otherTxn = do_QueryObject(aTransaction);
     if (otherTxn) {
       // special handling for IMETextTxn's: they need to merge with any previous
       // IMETextTxn in this placeholder, if possible.
-      if (!mIMETextTxn) 
+      if (!mIMETextTxn)
       {
         // this is the first IME txn in the placeholder
         mIMETextTxn =otherTxn;
         AppendChild(editTxn);
       }
-      else  
+      else
       {
         bool didMerge;
         mIMETextTxn->Merge(otherTxn, &didMerge);
         if (!didMerge)
         {
           // it wouldn't merge.  Earlier IME txn is already committed and will
           // not absorb further IME txns.  So just stack this one after it
           // and remember it as a candidate for further merges.
@@ -148,26 +148,26 @@ NS_IMETHODIMP PlaceholderTxn::Merge(nsIT
       }
     }
     else if (!plcTxn)  // see bug 171243: just drop incoming placeholders on the floor.
     {                  // their children will be swallowed by this preexisting one.
       AppendChild(editTxn);
     }
     *aDidMerge = true;
 //  RememberEndingSelection();
-//  efficiency hack: no need to remember selection here, as we haven't yet 
+//  efficiency hack: no need to remember selection here, as we haven't yet
 //  finished the initial batch and we know we will be told when the batch ends.
 //  we can remeber the selection then.
   }
   else
   { // merge typing or IME or deletion transactions if the selection matches
     if (((mName.get() == nsGkAtoms::TypingTxnName) ||
          (mName.get() == nsGkAtoms::IMETxnName)    ||
-         (mName.get() == nsGkAtoms::DeleteTxnName)) 
-         && !mCommitted ) 
+         (mName.get() == nsGkAtoms::DeleteTxnName))
+         && !mCommitted )
     {
       nsCOMPtr<nsIAbsorbingTransaction> plcTxn = do_QueryObject(editTxn);
       if (plcTxn) {
         nsCOMPtr<nsIAtom> atom;
         plcTxn->GetTxnName(getter_AddRefs(atom));
         if (atom && (atom == mName))
         {
           // check if start selection of next placeholder matches
@@ -224,29 +224,29 @@ NS_IMETHODIMP PlaceholderTxn::StartSelec
   }
   *aResult = mStartSel->IsEqual(aSelState);
   return NS_OK;
 }
 
 NS_IMETHODIMP PlaceholderTxn::EndPlaceHolderBatch()
 {
   mAbsorb = false;
-  
-  if (mForwarding) 
+
+  if (mForwarding)
   {
     nsCOMPtr<nsIAbsorbingTransaction> plcTxn = do_QueryReferent(mForwarding);
     if (plcTxn) plcTxn->EndPlaceHolderBatch();
   }
-  
+
   // remember our selection state.
   return RememberEndingSelection();
 }
 
 NS_IMETHODIMP PlaceholderTxn::ForwardEndBatchTo(nsIAbsorbingTransaction *aForwardingAddress)
-{   
+{
   mForwarding = do_GetWeakReference(aForwardingAddress);
   return NS_OK;
 }
 
 NS_IMETHODIMP PlaceholderTxn::Commit()
 {
   mCommitted = true;
   return NS_OK;

--- a/editor/libeditor/PlaceholderTxn.h
+++ b/editor/libeditor/PlaceholderTxn.h
@@ -22,41 +22,41 @@ class IMETextTxn;
 }
 
 /**
  * An aggregate transaction that knows how to absorb all subsequent
  * transactions with the same name.  This transaction does not "Do" anything.
  * But it absorbs other transactions via merge, and can undo/redo the
  * transactions it has absorbed.
  */
- 
-class PlaceholderTxn : public EditAggregateTxn, 
-                       public nsIAbsorbingTransaction, 
+
+class PlaceholderTxn : public EditAggregateTxn,
+                       public nsIAbsorbingTransaction,
                        public nsSupportsWeakReference
 {
 public:
-  NS_DECL_ISUPPORTS_INHERITED  
-  
+  NS_DECL_ISUPPORTS_INHERITED
+
   PlaceholderTxn();
 
   NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(PlaceholderTxn, EditAggregateTxn)
 // ------------ EditAggregateTxn -----------------------
 
   NS_DECL_EDITTXN
 
   NS_IMETHOD RedoTransaction() override;
   NS_IMETHOD Merge(nsITransaction *aTransaction, bool *aDidMerge) override;
 
 // ------------ nsIAbsorbingTransaction -----------------------
 
   NS_IMETHOD Init(nsIAtom* aName, nsSelectionState* aSelState,
                   nsEditor* aEditor) override;
-  
+
   NS_IMETHOD GetTxnName(nsIAtom **aName) override;
-  
+
   NS_IMETHOD StartSelectionEquals(nsSelectionState *aSelState, bool *aResult) override;
 
   NS_IMETHOD EndPlaceHolderBatch() override;
 
   NS_IMETHOD ForwardEndBatchTo(nsIAbsorbingTransaction *aForwardingAddress) override;
 
   NS_IMETHOD Commit() override;
 
@@ -66,17 +66,17 @@ protected:
   virtual ~PlaceholderTxn();
 
   /** the presentation shell, which we'll need to get the selection */
   bool        mAbsorb;          // do we auto absorb any and all transaction?
   nsWeakPtr   mForwarding;
   mozilla::dom::IMETextTxn *mIMETextTxn;      // first IME txn in this placeholder - used for IME merging
                                 // non-owning for now - can't nsCOMPtr it due to broken transaction interfaces
   bool        mCommitted;       // do we stop auto absorbing any matching placeholder txns?
-  // these next two members store the state of the selection in a safe way. 
+  // these next two members store the state of the selection in a safe way.
   // selection at the start of the txn is stored, as is the selection at the end.
   // This is so that UndoTransaction() and RedoTransaction() can restore the
   // selection properly.
   nsAutoPtr<nsSelectionState> mStartSel; // use a pointer because this is constructed before we exist
   nsSelectionState  mEndSel;
   nsEditor*         mEditor;   /** the editor for this transaction */
 };
 

--- a/editor/libeditor/SetDocTitleTxn.cpp
+++ b/editor/libeditor/SetDocTitleTxn.cpp
@@ -144,18 +144,18 @@ nsresult SetDocTitleTxn::SetDomTitle(con
     nsCOMPtr<nsIDOMNode> newNode = do_QueryInterface(textNode);
     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 
+    }
+    else
     {
       // This is an undoable transaction
       res = editor->InsertNode(newNode, titleNode, 0);
     }
     NS_ENSURE_SUCCESS(res, res);
   }
 
   if (newTitleNode)
@@ -170,13 +170,13 @@ NS_IMETHODIMP SetDocTitleTxn::GetTxnDesc
 {
   aString.AssignLiteral("SetDocTitleTxn: ");
   aString += mValue;
   return NS_OK;
 }
 
 NS_IMETHODIMP SetDocTitleTxn::GetIsTransient(bool *aIsTransient)
 {
-  NS_ENSURE_TRUE(aIsTransient, NS_ERROR_NULL_POINTER);  
+  NS_ENSURE_TRUE(aIsTransient, NS_ERROR_NULL_POINTER);
   *aIsTransient = mIsTransient;
   return NS_OK;
 }
 

--- a/editor/libeditor/SetDocTitleTxn.h
+++ b/editor/libeditor/SetDocTitleTxn.h
@@ -35,17 +35,17 @@ public:
 
   NS_IMETHOD RedoTransaction() override;
   NS_IMETHOD GetIsTransient(bool *aIsTransient) override;
 
 protected:
 
   /** the editor that created this transaction */
   nsIHTMLEditor*  mEditor;
-  
+
   /** The new title string */
   nsString    mValue;
 
   /** The previous title string to use for undo */
   nsString    mUndoValue;
 
   /** Set true if we dont' really change the title during Do() */
   bool mIsTransient;

--- a/editor/libeditor/TextEditorTest.cpp
+++ b/editor/libeditor/TextEditorTest.cpp
@@ -44,33 +44,33 @@ void TextEditorTest::Run(nsIEditor *aEdi
   mTextEditor = do_QueryInterface(aEditor);
   mEditor = do_QueryInterface(aEditor);
   RunUnitTest(outNumTests, outNumTestsFailed);
 }
 
 nsresult TextEditorTest::RunUnitTest(int32_t *outNumTests, int32_t *outNumTestsFailed)
 {
   nsresult result;
-  
+
   NS_ENSURE_TRUE(outNumTests && outNumTestsFailed, NS_ERROR_NULL_POINTER);
-  
+
   *outNumTests = 0;
   *outNumTestsFailed = 0;
-  
+
   result = InitDoc();
   TEST_RESULT(result);
   // shouldn't we just bail on error here?
-  
+
   // insert some simple text
   result = mTextEditor->InsertText(NS_LITERAL_STRING("1234567890abcdefghij1234567890"));
   TEST_RESULT(result);
   (*outNumTests)++;
   if (NS_FAILED(result))
     ++(*outNumTestsFailed);
-  
+
   // insert some more text
   result = mTextEditor->InsertText(NS_LITERAL_STRING("Moreover, I am cognizant of the interrelatedness of all communities and states.  I cannot sit idly by in Atlanta and not be concerned about what happens in Birmingham.  Injustice anywhere is a threat to justice everywhere"));
   TEST_RESULT(result);
   (*outNumTests)++;
   if (NS_FAILED(result))
     ++(*outNumTestsFailed);
 
   result = TestInsertBreak();
@@ -118,17 +118,17 @@ nsresult TextEditorTest::TestInsertBreak
   TEST_RESULT(result);
   mEditor->DebugDumpContent();
 
   // insert a second break adjacent to the first
   printf("inserting a second break\n");
   result = mTextEditor->InsertLineBreak();
   TEST_RESULT(result);
   mEditor->DebugDumpContent();
-    
+
   return result;
 }
 
 nsresult TextEditorTest::TestTextProperties()
 {
   nsCOMPtr<nsIDOMDocument>doc;
   nsresult result = mEditor->GetDocument(getter_AddRefs(doc));
   TEST_RESULT(result);

--- a/editor/libeditor/TypeInState.cpp
+++ b/editor/libeditor/TypeInState.cpp
@@ -22,31 +22,31 @@
 
 class nsIAtom;
 class nsIDOMDocument;
 
 using namespace mozilla;
 using namespace mozilla::dom;
 
 /********************************************************************
- *                     XPCOM cruft 
+ *                     XPCOM cruft
  *******************************************************************/
 
 NS_IMPL_CYCLE_COLLECTION(TypeInState, mLastSelectionContainer)
 NS_IMPL_CYCLE_COLLECTING_ADDREF(TypeInState)
 NS_IMPL_CYCLE_COLLECTING_RELEASE(TypeInState)
 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(TypeInState)
   NS_INTERFACE_MAP_ENTRY(nsISelectionListener)
   NS_INTERFACE_MAP_ENTRY(nsISupports)
 NS_INTERFACE_MAP_END
 
 /********************************************************************
  *                   public methods
  *******************************************************************/
- 
+
 TypeInState::TypeInState() :
  mSetArray()
 ,mClearedArray()
 ,mRelativeFontSize(0)
 ,mLastSelectionOffset(0)
 {
   Reset();
 }
@@ -58,17 +58,17 @@ TypeInState::~TypeInState()
 
   Reset();
 }
 
 nsresult
 TypeInState::UpdateSelState(Selection* aSelection)
 {
   NS_ENSURE_TRUE(aSelection, NS_ERROR_NULL_POINTER);
-  
+
   if (!aSelection->Collapsed()) {
     return NS_OK;
   }
 
   return nsEditor::GetStartNodeAndOffset(aSelection, getter_AddRefs(mLastSelectionContainer), &mLastSelectionOffset);
 }
 
 
@@ -109,17 +109,17 @@ NS_IMETHODIMP TypeInState::NotifySelecti
     }
     else
     {
       mLastSelectionContainer = nullptr;
       mLastSelectionOffset = 0;
     }
   }
 
-  Reset(); 
+  Reset();
   return NS_OK;
 }
 
 void TypeInState::Reset()
 {
   for(uint32_t i = 0, n = mClearedArray.Length(); i < n; i++) {
     delete mClearedArray[i];
   }
@@ -184,17 +184,17 @@ TypeInState::ClearProp(nsIAtom* aProp, c
   // add it to the list of cleared properties
   mClearedArray.AppendElement(item);
 }
 
 
 /***************************************************************************
  *    TakeClearProperty: hands back next property item on the clear list.
  *                       caller assumes ownership of PropItem and must delete it.
- */  
+ */
 PropItem*
 TypeInState::TakeClearProperty()
 {
   uint32_t count = mClearedArray.Length();
   if (!count) {
     return nullptr;
   }
 
@@ -202,17 +202,17 @@ TypeInState::TakeClearProperty()
   PropItem* propItem = mClearedArray[count];
   mClearedArray.RemoveElementAt(count);
   return propItem;
 }
 
 /***************************************************************************
  *    TakeSetProperty: hands back next poroperty item on the set list.
  *                     caller assumes ownership of PropItem and must delete it.
- */  
+ */
 PropItem*
 TypeInState::TakeSetProperty()
 {
   uint32_t count = mSetArray.Length();
   if (!count) {
     return nullptr;
   }
   count--; // indices are zero based
@@ -261,17 +261,17 @@ TypeInState::GetTypingState(bool &isSet,
   }
 }
 
 
 
 /********************************************************************
  *                   protected methods
  *******************************************************************/
- 
+
 void
 TypeInState::RemovePropFromSetList(nsIAtom* aProp, const nsAString& aAttr)
 {
   int32_t index;
   if (!aProp)
   {
     // clear _all_ props
     for(uint32_t i = 0, n = mSetArray.Length(); i < n; i++) {
@@ -349,45 +349,45 @@ bool TypeInState::IsPropCleared(nsIAtom*
   {
     // special case for all props cleared
     outIndex = -1;
     return true;
   }
   return false;
 }
 
-bool TypeInState::FindPropInList(nsIAtom *aProp, 
+bool TypeInState::FindPropInList(nsIAtom *aProp,
                                    const nsAString &aAttr,
                                    nsAString *outValue,
                                    nsTArray<PropItem*> &aList,
                                    int32_t &outIndex)
 {
   // linear search.  list should be short.
   uint32_t i, count = aList.Length();
   for (i=0; i<count; i++)
   {
     PropItem *item = aList[i];
     if ( (item->tag == aProp) &&
-         (item->attr == aAttr) ) 
+         (item->attr == aAttr) )
     {
       if (outValue) *outValue = item->value;
       outIndex = i;
       return true;
     }
   }
   return false;
 }
 
 
 
 /********************************************************************
  *    PropItem: helper struct for TypeInState
  *******************************************************************/
 
-PropItem::PropItem() : 
+PropItem::PropItem() :
  tag(nullptr)
 ,attr()
 ,value()
 {
   MOZ_COUNT_CTOR(PropItem);
 }
 
 PropItem::PropItem(nsIAtom *aTag, const nsAString &aAttr, const nsAString &aValue) :

--- a/editor/libeditor/TypeInState.h
+++ b/editor/libeditor/TypeInState.h
@@ -22,17 +22,17 @@ class Selection;
 }
 }
 
 struct PropItem
 {
   nsIAtom *tag;
   nsString attr;
   nsString value;
-  
+
   PropItem();
   PropItem(nsIAtom *aTag, const nsAString &aAttr, const nsAString &aValue);
   ~PropItem();
 };
 
 class TypeInState : public nsISelectionListener
 {
 public:
@@ -47,17 +47,17 @@ public:
 
   // nsISelectionListener
   NS_DECL_NSISELECTIONLISTENER
 
   void SetProp(nsIAtom* aProp, const nsAString& aAttr, const nsAString& aValue);
 
   void ClearAllProps();
   void ClearProp(nsIAtom* aProp, const nsAString& aAttr);
-  
+
   //**************************************************************************
   //    TakeClearProperty: hands back next property item on the clear list.
   //                       caller assumes ownership of PropItem and must delete it.
   PropItem* TakeClearProperty();
 
   //**************************************************************************
   //    TakeSetProperty: hands back next property item on the set list.
   //                     caller assumes ownership of PropItem and must delete it.
@@ -84,16 +84,16 @@ protected:
   bool IsPropCleared(nsIAtom* aProp, const nsAString& aAttr);
   bool IsPropCleared(nsIAtom* aProp, const nsAString& aAttr, int32_t& outIndex);
 
   nsTArray<PropItem*> mSetArray;
   nsTArray<PropItem*> mClearedArray;
   int32_t mRelativeFontSize;
   nsCOMPtr<nsIDOMNode> mLastSelectionContainer;
   int32_t mLastSelectionOffset;
-  
+
   friend class nsHTMLEditRules;
 };
 
 
 
 #endif  // TypeInState_h__
 

--- a/editor/libeditor/nsEditRules.h
+++ b/editor/libeditor/nsEditRules.h
@@ -21,32 +21,32 @@ class Selection;
 
 /***************************************************************************
  * base for an object to encapsulate any additional info needed to be passed
  * to rules system by the editor
  */
 class nsRulesInfo
 {
   public:
-  
+
   explicit nsRulesInfo(EditAction aAction) : action(aAction) {}
   virtual ~nsRulesInfo() {}
-  
+
   EditAction action;
 };
 
 /***************************************************************************
  * Interface of editing rules.
- *  
+ *
  */
 class nsIEditRules : public nsISupports
 {
 public:
   NS_DECLARE_STATIC_IID_ACCESSOR(NS_IEDITRULES_IID)
-  
+
 //Interfaces for addref and release and queryinterface
 //NOTE: Use   NS_DECL_ISUPPORTS_INHERITED in any class inherited from nsIEditRules
 
   NS_IMETHOD Init(nsPlaintextEditor *aEditor)=0;
   NS_IMETHOD SetInitialValue(const nsAString& aValue) = 0;
   NS_IMETHOD DetachEditor()=0;
   NS_IMETHOD BeforeEdit(EditAction action,
                         nsIEditor::EDirection aDirection) = 0;

--- a/editor/libeditor/nsEditor.cpp
+++ b/editor/libeditor/nsEditor.cpp
@@ -230,17 +230,17 @@ nsEditor::Init(nsIDOMDocument *aDoc, nsI
     mSelConWeak = do_GetWeakReference(aSelCon);   // weak reference to selectioncontroller
     selCon = aSelCon;
   } else {
     nsCOMPtr<nsIPresShell> presShell = GetPresShell();
     selCon = do_QueryInterface(presShell);
   }
   NS_ASSERTION(selCon, "Selection controller should be available at this point");
 
-  //set up root element if we are passed one.  
+  //set up root element if we are passed one.
   if (aRoot)
     mRootElement = do_QueryInterface(aRoot);
 
   mUpdateCount=0;
 
   /* initialize IME stuff */
   mIMETextNode = nullptr;
   mIMETextOffset = 0;
@@ -542,17 +542,17 @@ nsEditor::GetDocument()
 already_AddRefed<nsIDOMDocument>
 nsEditor::GetDOMDocument()
 {
   NS_PRECONDITION(mDocWeak, "bad state, mDocWeak weak pointer not initialized");
   nsCOMPtr<nsIDOMDocument> doc = do_QueryReferent(mDocWeak);
   return doc.forget();
 }
 
-NS_IMETHODIMP 
+NS_IMETHODIMP
 nsEditor::GetDocument(nsIDOMDocument **aDoc)
 {
   *aDoc = GetDOMDocument().take();
   return *aDoc ? NS_OK : NS_ERROR_NOT_INITIALIZED;
 }
 
 already_AddRefed<nsIPresShell>
 nsEditor::GetPresShell()
@@ -753,17 +753,17 @@ nsEditor::GetNumberOfRedoItems(int32_t* 
   *aNumItems = 0;
   return mTxnMgr ? mTxnMgr->GetNumberOfRedoItems(aNumItems) : NS_OK;
 }
 
 NS_IMETHODIMP
 nsEditor::GetTransactionManager(nsITransactionManager* *aTxnManager)
 {
   NS_ENSURE_ARG_POINTER(aTxnManager);
-  
+
   *aTxnManager = nullptr;
   NS_ENSURE_TRUE(mTxnMgr, NS_ERROR_FAILURE);
 
   NS_ADDREF(*aTxnManager = mTxnMgr);
   return NS_OK;
 }
 
 NS_IMETHODIMP
@@ -771,17 +771,17 @@ nsEditor::SetTransactionManager(nsITrans
 {
   NS_ENSURE_TRUE(aTxnManager, NS_ERROR_FAILURE);
 
   // nsITransactionManager is builtinclass, so this is safe
   mTxnMgr = static_cast<nsTransactionManager*>(aTxnManager);
   return NS_OK;
 }
 
-NS_IMETHODIMP 
+NS_IMETHODIMP
 nsEditor::Undo(uint32_t aCount)
 {
   ForceCompositionEnd();
 
   bool hasTxnMgr, hasTransaction = false;
   CanUndo(&hasTxnMgr, &hasTransaction);
   NS_ENSURE_TRUE(hasTransaction, NS_OK);
 
@@ -812,17 +812,17 @@ NS_IMETHODIMP nsEditor::CanUndo(bool *aI
     *aCanUndo = !!numTxns;
   } else {
     *aCanUndo = false;
   }
   return NS_OK;
 }
 
 
-NS_IMETHODIMP 
+NS_IMETHODIMP
 nsEditor::Redo(uint32_t aCount)
 {
   bool hasTxnMgr, hasTransaction = false;
   CanRedo(&hasTxnMgr, &hasTransaction);
   NS_ENSURE_TRUE(hasTransaction, NS_OK);
 
   nsAutoRules beginRulesSniffing(this, EditAction::redo, nsIEditor::eNone);
 
@@ -852,29 +852,29 @@ NS_IMETHODIMP nsEditor::CanRedo(bool *aI
     *aCanRedo = !!numTxns;
   } else {
     *aCanRedo = false;
   }
   return NS_OK;
 }
 
 
-NS_IMETHODIMP 
+NS_IMETHODIMP
 nsEditor::BeginTransaction()
 {
   BeginUpdateViewBatch();
 
   if (mTxnMgr) {
     mTxnMgr->BeginBatch(nullptr);
   }
 
   return NS_OK;
 }
 
-NS_IMETHODIMP 
+NS_IMETHODIMP
 nsEditor::EndTransaction()
 {
   if (mTxnMgr) {
     mTxnMgr->EndBatch(false);
   }
 
   EndUpdateViewBatch();
 
@@ -884,17 +884,17 @@ nsEditor::EndTransaction()
 
 // These two routines are similar to the above, but do not use
 // the transaction managers batching feature.  Instead we use
 // a placeholder transaction to wrap up any further transaction
 // while the batch is open.  The advantage of this is that
 // placeholder transactions can later merge, if needed.  Merging
 // is unavailable between transaction manager batches.
 
-NS_IMETHODIMP 
+NS_IMETHODIMP
 nsEditor::BeginPlaceHolderTransaction(nsIAtom *aName)
 {
   NS_PRECONDITION(mPlaceHolderBatch >= 0, "negative placeholder batch count!");
   if (!mPlaceHolderBatch)
   {
     NotifyEditorObservers(eNotifyEditorObserversOfBefore);
     // time to turn on the batch
     BeginUpdateViewBatch();
@@ -906,17 +906,17 @@ nsEditor::BeginPlaceHolderTransaction(ns
       mSelState->SaveSelection(selection);
     }
   }
   mPlaceHolderBatch++;
 
   return NS_OK;
 }
 
-NS_IMETHODIMP 
+NS_IMETHODIMP
 nsEditor::EndPlaceHolderTransaction()
 {
   NS_PRECONDITION(mPlaceHolderBatch > 0, "zero or negative placeholder batch count when ending batch!");
   if (mPlaceHolderBatch == 1)
   {
     nsRefPtr<Selection> selection = GetSelection();
 
     // By making the assumption that no reflow happens during the calls
@@ -949,70 +949,70 @@ nsEditor::EndPlaceHolderTransaction()
 
     // cached for frame offset are Not available now
     if (selection) {
       selection->SetCanCacheFrameOffset(false);
     }
 
     if (mSelState)
     {
-      // we saved the selection state, but never got to hand it to placeholder 
+      // we saved the selection state, but never got to hand it to placeholder
       // (else we ould have nulled out this pointer), so destroy it to prevent leaks.
       delete mSelState;
       mSelState = nullptr;
     }
     if (mPlaceHolderTxn)  // we might have never made a placeholder if no action took place
     {
       nsCOMPtr<nsIAbsorbingTransaction> plcTxn = do_QueryReferent(mPlaceHolderTxn);
-      if (plcTxn) 
+      if (plcTxn)
       {
         plcTxn->EndPlaceHolderBatch();
       }
-      else  
+      else
       {
         // in the future we will check to make sure undo is off here,
         // since that is the only known case where the placeholdertxn would disappear on us.
         // For now just removing the assert.
       }
       // notify editor observers of action but if composing, it's done by
       // compositionchange event handler.
       if (!mComposition) {
         NotifyEditorObservers(eNotifyEditorObserversOfEnd);
       }
     } else {
       NotifyEditorObservers(eNotifyEditorObserversOfCancel);
     }
   }
   mPlaceHolderBatch--;
-  
+
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsEditor::ShouldTxnSetSelection(bool *aResult)
 {
   NS_ENSURE_TRUE(aResult, NS_ERROR_NULL_POINTER);
   *aResult = mShouldTxnSetSelection;
   return NS_OK;
 }
 
-NS_IMETHODIMP  
+NS_IMETHODIMP
 nsEditor::SetShouldTxnSetSelection(bool aShould)
 {
   mShouldTxnSetSelection = aShould;
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsEditor::GetDocumentIsEmpty(bool *aDocumentIsEmpty)
 {
   *aDocumentIsEmpty = true;
 
   dom::Element* root = GetRoot();
-  NS_ENSURE_TRUE(root, NS_ERROR_NULL_POINTER); 
+  NS_ENSURE_TRUE(root, NS_ERROR_NULL_POINTER);
 
   *aDocumentIsEmpty = !root->HasChildren();
   return NS_OK;
 }
 
 
 // XXX: the rule system should tell us which node to select all on (ie, the root, or the body)
 NS_IMETHODIMP nsEditor::SelectAll()
@@ -1027,21 +1027,21 @@ NS_IMETHODIMP nsEditor::SelectAll()
 
 NS_IMETHODIMP nsEditor::BeginningOfDocument()
 {
   if (!mDocWeak) { return NS_ERROR_NOT_INITIALIZED; }
 
   // get the selection
   nsRefPtr<Selection> selection = GetSelection();
   NS_ENSURE_TRUE(selection, NS_ERROR_NOT_INITIALIZED);
-    
-  // get the root element 
+
+  // get the root element
   dom::Element* rootElement = GetRoot();
-  NS_ENSURE_TRUE(rootElement, NS_ERROR_NULL_POINTER); 
-  
+  NS_ENSURE_TRUE(rootElement, NS_ERROR_NULL_POINTER);
+
   // find first editable thingy
   nsCOMPtr<nsINode> firstNode = GetFirstEditableNode(rootElement);
   if (!firstNode) {
     // just the root node, set selection to inside the root
     return selection->CollapseNative(rootElement, 0);
   }
 
   if (firstNode->NodeType() == nsIDOMNode::TEXT_NODE) {
@@ -1056,37 +1056,37 @@ NS_IMETHODIMP nsEditor::BeginningOfDocum
   }
 
   int32_t offsetInParent = parent->IndexOf(firstNode);
   return selection->CollapseNative(parent, offsetInParent);
 }
 
 NS_IMETHODIMP
 nsEditor::EndOfDocument()
-{ 
+{
   NS_ENSURE_TRUE(mDocWeak, NS_ERROR_NOT_INITIALIZED);
 
-  // get selection 
-  nsRefPtr<Selection> selection = GetSelection(); 
-  NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER); 
-  
-  // get the root element 
+  // get selection
+  nsRefPtr<Selection> selection = GetSelection();
+  NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
+
+  // get the root element
   nsINode* node = GetRoot();
-  NS_ENSURE_TRUE(node, NS_ERROR_NULL_POINTER); 
+  NS_ENSURE_TRUE(node, NS_ERROR_NULL_POINTER);
   nsINode* child = node->GetLastChild();
 
   while (child && IsContainer(child->AsDOMNode())) {
     node = child;
     child = node->GetLastChild();
   }
 
   uint32_t length = node->Length();
   return selection->CollapseNative(node, int32_t(length));
-} 
-  
+}
+
 NS_IMETHODIMP
 nsEditor::GetDocumentModified(bool *outDocModified)
 {
   NS_ENSURE_TRUE(outDocModified, NS_ERROR_NULL_POINTER);
 
   int32_t  modCount = 0;
   GetModificationCount(&modCount);
 
@@ -1112,84 +1112,84 @@ nsEditor::SetDocumentCharacterSet(const 
 
   doc->SetDocumentCharacterSet(characterSet);
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsEditor::Cut()
 {
-  return NS_ERROR_NOT_IMPLEMENTED; 
+  return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
 nsEditor::CanCut(bool *aCanCut)
 {
-  return NS_ERROR_NOT_IMPLEMENTED; 
+  return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
 nsEditor::Copy()
 {
-  return NS_ERROR_NOT_IMPLEMENTED; 
+  return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
 nsEditor::CanCopy(bool *aCanCut)
 {
-  return NS_ERROR_NOT_IMPLEMENTED; 
+  return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
 nsEditor::CanDelete(bool *aCanDelete)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
 nsEditor::Paste(int32_t aSelectionType)
 {
-  return NS_ERROR_NOT_IMPLEMENTED; 
+  return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
 nsEditor::PasteTransferable(nsITransferable *aTransferable)
 {
-  return NS_ERROR_NOT_IMPLEMENTED; 
+  return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
 nsEditor::CanPaste(int32_t aSelectionType, bool *aCanPaste)
 {
-  return NS_ERROR_NOT_IMPLEMENTED; 
+  return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
 nsEditor::CanPasteTransferable(nsITransferable *aTransferable, bool *aCanPaste)
 {
-  return NS_ERROR_NOT_IMPLEMENTED; 
+  return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
 nsEditor::SetAttribute(nsIDOMElement* aElement, const nsAString& aAttribute,
                        const nsAString& aValue)
 {
   nsCOMPtr<Element> element = do_QueryInterface(aElement);
   NS_ENSURE_TRUE(element, NS_ERROR_NULL_POINTER);
   nsCOMPtr<nsIAtom> attribute = do_GetAtom(aAttribute);
 
   nsRefPtr<ChangeAttributeTxn> txn =
     CreateTxnForSetAttribute(*element, *attribute, aValue);
   return DoTransaction(txn);
 }
 
-NS_IMETHODIMP 
-nsEditor::GetAttributeValue(nsIDOMElement *aElement, 
-                            const nsAString & aAttribute, 
-                            nsAString & aResultValue, 
+NS_IMETHODIMP
+nsEditor::GetAttributeValue(nsIDOMElement *aElement,
+                            const nsAString & aAttribute,
+                            nsAString & aResultValue,
                             bool *aResultIsSet)
 {
   NS_ENSURE_TRUE(aResultIsSet, NS_ERROR_NULL_POINTER);
   *aResultIsSet = false;
   if (!aElement) {
     return NS_OK;
   }
   nsAutoString value;
@@ -1222,17 +1222,17 @@ nsEditor::OutputsMozDirty()
   // (eEditorMailMask), but false for webpages.
   return !(mFlags & nsIPlaintextEditor::eEditorAllowInteraction) ||
           (mFlags & nsIPlaintextEditor::eEditorMailMask);
 }
 
 
 NS_IMETHODIMP
 nsEditor::MarkNodeDirty(nsIDOMNode* aNode)
-{  
+{
   // Mark the node dirty, but not for webpages (bug 599983)
   if (!OutputsMozDirty()) {
     return NS_OK;
   }
   nsCOMPtr<dom::Element> element = do_QueryInterface(aNode);
   if (element) {
     element->SetAttr(kNameSpaceID_None, nsGkAtoms::mozdirty,
                      EmptyString(), false);
@@ -1535,19 +1535,19 @@ nsEditor::DeleteNode(nsINode* aNode)
     listener->DidDeleteNode(aNode->AsDOMNode(), res);
   }
 
   NS_ENSURE_SUCCESS(res, res);
   return NS_OK;
 }
 
 ///////////////////////////////////////////////////////////////////////////
-// ReplaceContainer: replace inNode with a new node (outNode) which is contructed 
+// ReplaceContainer: replace inNode with a new node (outNode) which is contructed
 //                   to be of type aNodeType.  Put inNodes children into outNode.
-//                   Callers responsibility to make sure inNode's children can 
+//                   Callers responsibility to make sure inNode's children can
 //                   go in outNode.
 already_AddRefed<Element>
 nsEditor::ReplaceContainer(Element* aOldContainer,
                            nsIAtom* aNodeType,
                            nsIAtom* aAttribute,
                            const nsAString* aValue,
                            ECloneAttributes aCloneAttributes)
 {
@@ -1566,17 +1566,17 @@ nsEditor::ReplaceContainer(Element* aOld
   nsresult res;
   if (aAttribute && aValue && aAttribute != nsGkAtoms::_empty) {
     res = ret->SetAttr(kNameSpaceID_None, aAttribute, *aValue, true);
     NS_ENSURE_SUCCESS(res, nullptr);
   }
   if (aCloneAttributes == eCloneAttributes) {
     CloneAttributes(ret, aOldContainer);
   }
-  
+
   // notify our internal selection state listener
   // (Note: A nsAutoSelectionReset object must be created
   //  before calling this to initialize mRangeUpdater)
   AutoReplaceContainerSelNotify selStateNotify(mRangeUpdater, aOldContainer,
                                                ret);
   {
     nsAutoTxnsConserveSelection conserveSelection(this);
     while (aOldContainer->HasChildren()) {
@@ -1588,17 +1588,17 @@ nsEditor::ReplaceContainer(Element* aOld
       res = InsertNode(*child, *ret, -1);
       NS_ENSURE_SUCCESS(res, nullptr);
     }
   }
 
   // insert new container into tree
   res = InsertNode(*ret, *parent, offset);
   NS_ENSURE_SUCCESS(res, nullptr);
-  
+
   // delete old container
   res = DeleteNode(aOldContainer);
   NS_ENSURE_SUCCESS(res, nullptr);
 
   return ret.forget();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -1728,17 +1728,17 @@ nsEditor::MoveNode(nsIContent* aNode, ns
 }
 
 
 NS_IMETHODIMP
 nsEditor::AddEditorObserver(nsIEditorObserver *aObserver)
 {
   // we don't keep ownership of the observers.  They must
   // remove themselves as observers before they are destroyed.
-  
+
   NS_ENSURE_TRUE(aObserver, NS_ERROR_NULL_POINTER);
 
   // Make sure the listener isn't already on the list
   if (!mEditorObservers.Contains(aObserver)) {
     mEditorObservers.AppendElement(*aObserver);
   }
 
   return NS_OK;
@@ -1959,39 +1959,39 @@ nsEditor::DebugUnitTests(int32_t *outNum
 {
 #ifdef DEBUG
   NS_NOTREACHED("This should never get called. Overridden by subclasses");
 #endif
   return NS_OK;
 }
 
 
-bool     
+bool
 nsEditor::ArePreservingSelection()
 {
   return !(mSavedSel.IsEmpty());
 }
 
 void
 nsEditor::PreserveSelectionAcrossActions(Selection* aSel)
 {
   mSavedSel.SaveSelection(aSel);
   mRangeUpdater.RegisterSelectionState(mSavedSel);
 }
 
-nsresult 
+nsresult
 nsEditor::RestorePreservedSelection(Selection* aSel)
 {
   if (mSavedSel.IsEmpty()) return NS_ERROR_FAILURE;
   mSavedSel.RestoreSelection(aSel);
   StopPreservingSelection();
   return NS_OK;
 }
 
-void     
+void
 nsEditor::StopPreservingSelection()
 {
   mRangeUpdater.DropSelectionState(mSavedSel);
   mSavedSel.MakeEmpty();
 }
 
 void
 nsEditor::EnsureComposition(mozilla::WidgetGUIEvent* aEvent)
@@ -2456,31 +2456,31 @@ nsEditor::GetFirstEditableNode(nsINode* 
 
 NS_IMETHODIMP
 nsEditor::NotifyDocumentListeners(TDocumentListenerNotification aNotificationType)
 {
   if (!mDocStateListeners.Length()) {
     // Maybe there just aren't any.
     return NS_OK;
   }
- 
+
   nsTArray<OwningNonNull<nsIDocumentStateListener>>
     listeners(mDocStateListeners);
   nsresult rv = NS_OK;
 
   switch (aNotificationType)
   {
     case eDocumentCreated:
       for (auto& listener : listeners) {
         rv = listener->NotifyDocumentCreated();
         if (NS_FAILED(rv))
           break;
       }
       break;
-      
+
     case eDocumentToBeDestroyed:
       for (auto& listener : listeners) {
         rv = listener->NotifyDocumentWillBeDestroyed();
         if (NS_FAILED(rv))
           break;
       }
       break;
 
@@ -2497,17 +2497,17 @@ nsEditor::NotifyDocumentListeners(TDocum
 
         for (auto& listener : listeners) {
           rv = listener->NotifyDocumentStateChanged(mDocDirtyState);
           if (NS_FAILED(rv))
             break;
         }
       }
       break;
-    
+
     default:
       NS_NOTREACHED("Unknown notification");
   }
 
   return rv;
 }
 
 
@@ -2927,20 +2927,20 @@ nsEditor::GetNodeLocation(nsINode* aChil
     *aOffset = parent->IndexOf(aChild);
     MOZ_ASSERT(*aOffset != -1);
   } else {
     *aOffset = -1;
   }
   return parent;
 }
 
-// returns the number of things inside aNode.  
+// returns the number of things inside aNode.
 // If aNode is text, returns number of characters. If not, returns number of children nodes.
 nsresult
-nsEditor::GetLengthOfDOMNode(nsIDOMNode *aNode, uint32_t &aCount) 
+nsEditor::GetLengthOfDOMNode(nsIDOMNode *aNode, uint32_t &aCount)
 {
   aCount = 0;
   nsCOMPtr<nsINode> node = do_QueryInterface(aNode);
   NS_ENSURE_TRUE(node, NS_ERROR_NULL_POINTER);
   aCount = node->Length();
   return NS_OK;
 }
 
@@ -3014,17 +3014,17 @@ nsEditor::GetNextNode(nsINode* aParentNo
 
     if (!aEditableNode || IsEditable(resultNode)) {
       return resultNode;
     }
 
     // restart the search from the non-editable node we just found
     return GetNextNode(resultNode, aEditableNode, aNoBlockCrossing);
   }
-    
+
   // unless there isn't one, in which case we are at the end of the node
   // and want the next one.
   if (aNoBlockCrossing && IsBlockNode(aParentNode)) {
     // don't cross out of parent block
     return nullptr;
   }
 
   return GetNextNode(aParentNode, aEditableNode, aNoBlockCrossing);
@@ -3040,17 +3040,17 @@ nsEditor::GetPriorNode(nsINode* aCurrent
   if (!IsDescendantOfEditorRoot(aCurrentNode)) {
     return nullptr;
   }
 
   return FindNode(aCurrentNode, false, aEditableNode, aNoBlockCrossing);
 }
 
 nsIContent*
-nsEditor::FindNextLeafNode(nsINode  *aCurrentNode, 
+nsEditor::FindNextLeafNode(nsINode  *aCurrentNode,
                            bool      aGoForward,
                            bool      bNoBlockCrossing)
 {
   // called only by GetPriorNode so we don't need to check params.
   NS_PRECONDITION(IsDescendantOfEditorRoot(aCurrentNode) &&
                   !IsEditorRoot(aCurrentNode),
                   "Bogus arguments");
 
@@ -3063,17 +3063,17 @@ nsEditor::FindNextLeafNode(nsINode  *aCu
     if (sibling) {
       if (bNoBlockCrossing && IsBlockNode(sibling)) {
         // don't look inside prevsib, since it is a block
         return sibling;
       }
       nsIContent *leaf =
         aGoForward ? GetLeftmostChild(sibling, bNoBlockCrossing) :
                      GetRightmostChild(sibling, bNoBlockCrossing);
-      if (!leaf) { 
+      if (!leaf) {
         return sibling;
       }
 
       return leaf;
     }
 
     nsINode *parent = cur->GetParentNode();
     if (!parent) {
@@ -3121,17 +3121,17 @@ nsEditor::FindNode(nsINode *aCurrentNode
     // prevent us from accidentally editing browser content
     // when the editor is in a text widget.
 
     return nullptr;
   }
 
   nsCOMPtr<nsIContent> candidate =
     FindNextLeafNode(aCurrentNode, aGoForward, bNoBlockCrossing);
-  
+
   if (!candidate) {
     return nullptr;
   }
 
   if (!aEditableNode || IsEditable(candidate)) {
     return candidate;
   }
 
@@ -3220,45 +3220,45 @@ nsEditor::CanContainTag(nsINode& aParent
   switch (aParent.NodeType()) {
   case nsIDOMNode::ELEMENT_NODE:
   case nsIDOMNode::DOCUMENT_FRAGMENT_NODE:
     return TagCanContainTag(*aParent.NodeInfo()->NameAtom(), aChildTag);
   }
   return false;
 }
 
-bool 
+bool
 nsEditor::TagCanContain(nsIAtom& aParentTag, nsIContent& aChild)
 {
   switch (aChild.NodeType()) {
   case nsIDOMNode::TEXT_NODE:
   case nsIDOMNode::ELEMENT_NODE:
   case nsIDOMNode::DOCUMENT_FRAGMENT_NODE:
     return TagCanContainTag(aParentTag, *aChild.NodeInfo()->NameAtom());
   }
   return false;
 }
 
-bool 
+bool
 nsEditor::TagCanContainTag(nsIAtom& aParentTag, nsIAtom& aChildTag)
 {
   return true;
 }
 
 bool
 nsEditor::IsRoot(nsIDOMNode* inNode)
 {
   NS_ENSURE_TRUE(inNode, false);
 
   nsCOMPtr<nsIDOMNode> rootNode = do_QueryInterface(GetRoot());
 
   return inNode == rootNode;
 }
 
-bool 
+bool
 nsEditor::IsRoot(nsINode* inNode)
 {
   NS_ENSURE_TRUE(inNode, false);
 
   nsCOMPtr<nsINode> rootNode = GetRoot();
 
   return inNode == rootNode;
 }
@@ -3266,17 +3266,17 @@ nsEditor::IsRoot(nsINode* inNode)
 bool
 nsEditor::IsEditorRoot(nsINode* aNode)
 {
   NS_ENSURE_TRUE(aNode, false);
   nsCOMPtr<nsINode> rootNode = GetEditorRoot();
   return aNode == rootNode;
 }
 
-bool 
+bool
 nsEditor::IsDescendantOfRoot(nsIDOMNode* inNode)
 {
   nsCOMPtr<nsINode> node = do_QueryInterface(inNode);
   return IsDescendantOfRoot(node);
 }
 
 bool
 nsEditor::IsDescendantOfRoot(nsINode* inNode)
@@ -3370,17 +3370,17 @@ IsElementVisible(dom::Element* aElement)
     nsComputedDOMStyle::GetStyleContextForElementNoFlush(aElement,
                                                          nullptr, nullptr);
   if (styleContext) {
     return styleContext->StyleDisplay()->mDisplay != NS_STYLE_DISPLAY_NONE;
   }
   return false;
 }
 
-bool 
+bool
 nsEditor::IsEditable(nsIDOMNode *aNode)
 {
   nsCOMPtr<nsIContent> content = do_QueryInterface(aNode);
   return IsEditable(content);
 }
 
 bool
 nsEditor::IsEditable(nsINode* aNode)
@@ -3475,54 +3475,54 @@ NS_IMETHODIMP nsEditor::ResetModificatio
 ///////////////////////////////////////////////////////////////////////////
 // GetTag: digs out the atom for the tag of this node
 //
 nsIAtom *
 nsEditor::GetTag(nsIDOMNode *aNode)
 {
   nsCOMPtr<nsIContent> content = do_QueryInterface(aNode);
 
-  if (!content) 
+  if (!content)
   {
     NS_ASSERTION(aNode, "null node passed to nsEditor::GetTag()");
 
     return nullptr;
   }
-  
+
   return content->NodeInfo()->NameAtom();
 }
 
 
 ///////////////////////////////////////////////////////////////////////////
 // GetTagString: digs out string for the tag of this node
-//                    
-nsresult 
+//
+nsresult
 nsEditor::GetTagString(nsIDOMNode *aNode, nsAString& outString)
 {
-  if (!aNode) 
+  if (!aNode)
   {
     NS_NOTREACHED("null node passed to nsEditor::GetTagString()");
     return NS_ERROR_NULL_POINTER;
   }
-  
+
   nsIAtom *atom = GetTag(aNode);
   if (!atom)
   {
     return NS_ERROR_FAILURE;
   }
 
   atom->ToString(outString);
   return NS_OK;
 }
 
 
 ///////////////////////////////////////////////////////////////////////////
 // NodesSameType: do these nodes have the same tag?
-//                    
-bool 
+//
+bool
 nsEditor::NodesSameType(nsIDOMNode *aNode1, nsIDOMNode *aNode2)
 {
   if (!aNode1 || !aNode2) {
     NS_NOTREACHED("null node passed to nsEditor::NodesSameType()");
     return false;
   }
 
   nsCOMPtr<nsIContent> content1 = do_QueryInterface(aNode1);
@@ -3541,45 +3541,45 @@ nsEditor::AreNodesSameType(nsIContent* a
   MOZ_ASSERT(aNode1);
   MOZ_ASSERT(aNode2);
   return aNode1->NodeInfo()->NameAtom() == aNode2->NodeInfo()->NameAtom();
 }
 
 
 ///////////////////////////////////////////////////////////////////////////
 // IsTextNode: true if node of dom type text
-//               
+//
 bool
 nsEditor::IsTextNode(nsIDOMNode *aNode)
 {
   if (!aNode)
   {
     NS_NOTREACHED("null node passed to IsTextNode()");
     return false;
   }
-  
+
   uint16_t nodeType;
   aNode->GetNodeType(&nodeType);
   return (nodeType == nsIDOMNode::TEXT_NODE);
 }
 
 bool
 nsEditor::IsTextNode(nsINode *aNode)
 {
   return aNode->NodeType() == nsIDOMNode::TEXT_NODE;
 }
 
 ///////////////////////////////////////////////////////////////////////////
 // GetChildAt: returns the node at this position index in the parent
 //
-nsCOMPtr<nsIDOMNode> 
+nsCOMPtr<nsIDOMNode>
 nsEditor::GetChildAt(nsIDOMNode *aParent, int32_t aOffset)
 {
   nsCOMPtr<nsIDOMNode> resultNode;
-  
+
   nsCOMPtr<nsIContent> parent = do_QueryInterface(aParent);
 
   NS_ENSURE_TRUE(parent, resultNode);
 
   resultNode = do_QueryInterface(parent->GetChildAt(aOffset));
 
   return resultNode;
 }
@@ -3595,19 +3595,19 @@ nsEditor::GetNodeAtRangeOffsetPoint(nsID
   if (IsTextNode(aParentOrNode)) {
     return aParentOrNode;
   }
   return GetChildAt(aParentOrNode, aOffset);
 }
 
 
 ///////////////////////////////////////////////////////////////////////////
-// GetStartNodeAndOffset: returns whatever the start parent & offset is of 
+// GetStartNodeAndOffset: returns whatever the start parent & offset is of
 //                        the first range in the selection.
-nsresult 
+nsresult
 nsEditor::GetStartNodeAndOffset(Selection* aSelection,
                                        nsIDOMNode **outStartNode,
                                        int32_t *outStartOffset)
 {
   NS_ENSURE_TRUE(outStartNode && outStartOffset && aSelection, NS_ERROR_NULL_POINTER);
 
   nsCOMPtr<nsINode> startNode;
   nsresult rv = GetStartNodeAndOffset(aSelection, getter_AddRefs(startNode),
@@ -3642,19 +3642,19 @@ nsEditor::GetStartNodeAndOffset(Selectio
 
   NS_IF_ADDREF(*aStartNode = range->GetStartParent());
   *aStartOffset = range->StartOffset();
   return NS_OK;
 }
 
 
 ///////////////////////////////////////////////////////////////////////////
-// GetEndNodeAndOffset: returns whatever the end parent & offset is of 
+// GetEndNodeAndOffset: returns whatever the end parent & offset is of
 //                        the first range in the selection.
-nsresult 
+nsresult
 nsEditor::GetEndNodeAndOffset(Selection* aSelection,
                                        nsIDOMNode **outEndNode,
                                        int32_t *outEndOffset)
 {
   NS_ENSURE_TRUE(outEndNode && outEndOffset && aSelection, NS_ERROR_NULL_POINTER);
 
   nsCOMPtr<nsINode> endNode;
   nsresult rv = GetEndNodeAndOffset(aSelection, getter_AddRefs(endNode),
@@ -3691,23 +3691,23 @@ nsEditor::GetEndNodeAndOffset(Selection*
   *aEndOffset = range->EndOffset();
   return NS_OK;
 }
 
 
 ///////////////////////////////////////////////////////////////////////////
 // IsPreformatted: checks the style info for the node for the preformatted
 //                 text style.
-nsresult 
+nsresult
 nsEditor::IsPreformatted(nsIDOMNode *aNode, bool *aResult)
 {
   nsCOMPtr<nsIContent> content = do_QueryInterface(aNode);
-  
+
   NS_ENSURE_TRUE(aResult && content, NS_ERROR_NULL_POINTER);
-  
+
   nsCOMPtr<nsIPresShell> ps = GetPresShell();
   NS_ENSURE_TRUE(ps, NS_ERROR_NOT_INITIALIZED);
 
   // Look at the node (and its parent if it's not an element), and grab its style context
   nsRefPtr<nsStyleContext> elementStyle;
   if (!content->IsElement()) {
     content = content->GetParent();
   }
@@ -3729,28 +3729,28 @@ nsEditor::IsPreformatted(nsIDOMNode *aNo
   const nsStyleText* styleText = elementStyle->StyleText();
 
   *aResult = styleText->WhiteSpaceIsSignificant();
   return NS_OK;
 }
 
 
 ///////////////////////////////////////////////////////////////////////////
-// SplitNodeDeep: this splits a node "deeply", splitting children as 
+// SplitNodeDeep: this splits a node "deeply", splitting children as
 //                appropriate.  The place to split is represented by
 //                a dom point at {splitPointParent, splitPointOffset}.
-//                That dom point must be inside aNode, which is the node to 
+//                That dom point must be inside aNode, which is the node to
 //                split.  outOffset is set to the offset in the parent of aNode where
-//                the split terminates - where you would want to insert 
-//                a new element, for instance, if that's why you were splitting 
+//                the split terminates - where you would want to insert
+//                a new element, for instance, if that's why you were splitting
 //                the node.
 //
 nsresult
-nsEditor::SplitNodeDeep(nsIDOMNode *aNode, 
-                        nsIDOMNode *aSplitPointParent, 
+nsEditor::SplitNodeDeep(nsIDOMNode *aNode,
+                        nsIDOMNode *aSplitPointParent,
                         int32_t aSplitPointOffset,
                         int32_t *outOffset,
                         bool    aNoEmptyContainers,
                         nsCOMPtr<nsIDOMNode> *outLeftNode,
                         nsCOMPtr<nsIDOMNode> *outRightNode)
 {
   nsCOMPtr<nsINode> node = do_QueryInterface(aNode);
   NS_ENSURE_TRUE(node && aSplitPointParent && outOffset, NS_ERROR_NULL_POINTER);
@@ -3761,21 +3761,21 @@ nsEditor::SplitNodeDeep(nsIDOMNode *aNod
 
   nsCOMPtr<nsINode> nodeToSplit = do_QueryInterface(aSplitPointParent);
   while (nodeToSplit) {
     // need to insert rules code call here to do things like
     // not split a list if you are after the last <li> or before the first, etc.
     // for now we just have some smarts about unneccessarily splitting
     // textnodes, which should be universal enough to put straight in
     // this nsEditor routine.
-    
+
     nsCOMPtr<nsIDOMCharacterData> nodeAsText = do_QueryInterface(nodeToSplit);
     uint32_t len = nodeToSplit->Length();
     bool bDoSplit = false;
-    
+
     if (!(aNoEmptyContainers || nodeAsText) || (offset && (offset != (int32_t)len)))
     {
       bDoSplit = true;
       nsCOMPtr<nsIDOMNode> tempNode;
       nsresult rv = SplitNode(nodeToSplit->AsDOMNode(), offset,
                               getter_AddRefs(tempNode));
       NS_ENSURE_SUCCESS(rv, rv);
 
@@ -3896,17 +3896,17 @@ nsEditor::BeginUpdateViewBatch()
 
   mUpdateCount++;
 }
 
 
 nsresult nsEditor::EndUpdateViewBatch()
 {
   NS_PRECONDITION(mUpdateCount > 0, "bad state");
-  
+
   if (mUpdateCount <= 0)
   {
     mUpdateCount = 0;
     return NS_ERROR_FAILURE;
   }
 
   mUpdateCount--;
 
@@ -3918,41 +3918,41 @@ nsresult nsEditor::EndUpdateViewBatch()
     if (selection) {
       selection->EndBatchChanges();
     }
   }
 
   return NS_OK;
 }
 
-bool 
+bool
 nsEditor::GetShouldTxnSetSelection()
 {
   return mShouldTxnSetSelection;
 }
 
 
-NS_IMETHODIMP 
+NS_IMETHODIMP
 nsEditor::DeleteSelectionImpl(EDirection aAction,
                               EStripWrappers aStripWrappers)
 {
   MOZ_ASSERT(aStripWrappers == eStrip || aStripWrappers == eNoStrip);
 
   nsRefPtr<Selection> selection = GetSelection();
   NS_ENSURE_STATE(selection);
   nsRefPtr<EditAggregateTxn> txn;
   nsCOMPtr<nsINode> deleteNode;
   int32_t deleteCharOffset = 0, deleteCharLength = 0;
   nsresult res = CreateTxnForDeleteSelection(aAction, getter_AddRefs(txn),
                                              getter_AddRefs(deleteNode),
                                              &deleteCharOffset,
                                              &deleteCharLength);
   nsCOMPtr<nsIDOMCharacterData> deleteCharData(do_QueryInterface(deleteNode));
 
-  if (NS_SUCCEEDED(res))  
+  if (NS_SUCCEEDED(res))
   {
     nsAutoRules beginRulesSniffing(this, EditAction::deleteSelection, aAction);
     // Notify nsIEditActionListener::WillDelete[Selection|Text|Node]
     if (!deleteNode) {
       for (auto& listener : mActionListeners) {
         listener->WillDeleteSelection(selection);
       }
     } else if (deleteCharData) {
@@ -3961,17 +3961,17 @@ nsEditor::DeleteSelectionImpl(EDirection
       }
     } else {
       for (auto& listener : mActionListeners) {
         listener->WillDeleteNode(deleteNode->AsDOMNode());
       }
     }
 
     // Delete the specified amount
-    res = DoTransaction(txn);  
+    res = DoTransaction(txn);
 
     // Notify nsIEditActionListener::DidDelete[Selection|Text|Node]
     if (!deleteNode) {
       for (auto& listener : mActionListeners) {
         listener->DidDeleteSelection(selection);
       }
     } else if (deleteCharData) {
       for (auto& listener : mActionListeners) {
@@ -4079,28 +4079,28 @@ nsEditor::DeleteSelectionAndPrepareToCre
 
 
 void
 nsEditor::DoAfterDoTransaction(nsITransaction *aTxn)
 {
   bool isTransientTransaction;
   MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
     aTxn->GetIsTransient(&isTransientTransaction)));
-  
+
   if (!isTransientTransaction)
   {
     // we need to deal here with the case where the user saved after some
     // edits, then undid one or more times. Then, the undo count is -ve,
     // but we can't let a do take it back to zero. So we flip it up to
     // a +ve number.
     int32_t modCount;
     GetModificationCount(&modCount);
     if (modCount < 0)
       modCount = -modCount;
-        
+
     // don't count transient transactions
     MOZ_ALWAYS_TRUE(NS_SUCCEEDED(
       IncrementModificationCount(1)));
   }
 }
 
 
 void
@@ -4184,33 +4184,33 @@ nsEditor::CreateTxnForIMEText(const nsAS
   nsRefPtr<IMETextTxn> txn = new IMETextTxn(*mIMETextNode, mIMETextOffset,
                                             mComposition->String().Length(),
                                             mComposition->GetRanges(),
                                             aStringToInsert, *this);
   return txn.forget();
 }
 
 
-NS_IMETHODIMP 
+NS_IMETHODIMP
 nsEditor::CreateTxnForAddStyleSheet(CSSStyleSheet* aSheet, AddStyleSheetTxn* *aTxn)
 {
   nsRefPtr<AddStyleSheetTxn> txn = new AddStyleSheetTxn();
 
   nsresult rv = txn->Init(this, aSheet);
   if (NS_SUCCEEDED(rv))
   {
     txn.forget(aTxn);
   }
 
   return rv;
 }
 
 
 
-NS_IMETHODIMP 
+NS_IMETHODIMP
 nsEditor::CreateTxnForRemoveStyleSheet(CSSStyleSheet* aSheet, RemoveStyleSheetTxn* *aTxn)
 {
   nsRefPtr<RemoveStyleSheetTxn> txn = new RemoveStyleSheetTxn();
 
   nsresult rv = txn->Init(this, aSheet);
   if (NS_SUCCEEDED(rv))
   {
     txn.forget(aTxn);
@@ -4460,52 +4460,52 @@ nsEditor::CreateTxnForDeleteInsertionPoi
     }
 
     NS_ADDREF(*aNode = selectedNode);
   }
 
   return NS_OK;
 }
 
-nsresult 
+nsresult
 nsEditor::CreateRange(nsIDOMNode *aStartParent, int32_t aStartOffset,
                       nsIDOMNode *aEndParent, int32_t aEndOffset,
                       nsRange** aRange)
 {
   return nsRange::CreateRange(aStartParent, aStartOffset, aEndParent,
                               aEndOffset, aRange);
 }
 
-nsresult 
+nsresult
 nsEditor::AppendNodeToSelectionAsRange(nsIDOMNode *aNode)
 {
   NS_ENSURE_TRUE(aNode, NS_ERROR_NULL_POINTER);
   nsRefPtr<Selection> selection = GetSelection();
   NS_ENSURE_TRUE(selection, NS_ERROR_FAILURE);
 
   nsCOMPtr<nsIDOMNode> parentNode;
   nsresult res = aNode->GetParentNode(getter_AddRefs(parentNode));
   NS_ENSURE_SUCCESS(res, res);
   NS_ENSURE_TRUE(parentNode, NS_ERROR_NULL_POINTER);
-  
+
   int32_t offset = GetChildOffset(aNode, parentNode);
-  
+
   nsRefPtr<nsRange> range;
   res = CreateRange(parentNode, offset, parentNode, offset+1, getter_AddRefs(range));
   NS_ENSURE_SUCCESS(res, res);
   NS_ENSURE_TRUE(range, NS_ERROR_NULL_POINTER);
 
   return selection->AddRange(range);
 }
 
 nsresult nsEditor::ClearSelection()
 {
   nsRefPtr<Selection> selection = GetSelection();
   NS_ENSURE_TRUE(selection, NS_ERROR_FAILURE);
-  return selection->RemoveAllRanges();  
+  return selection->RemoveAllRanges();
 }
 
 already_AddRefed<Element>
 nsEditor::CreateHTMLContent(nsIAtom* aTag)
 {
   MOZ_ASSERT(aTag);
 
   nsCOMPtr<nsIDocument> doc = GetDocument();
@@ -4593,17 +4593,17 @@ nsEditor::HandleKeyPressEvent(nsIDOMKeyE
       // bailing here to allow the keybindings to do the cut.
       if (nativeKeyEvent->IsShift() || nativeKeyEvent->IsControl() ||
           nativeKeyEvent->IsAlt() || nativeKeyEvent->IsMeta() ||
           nativeKeyEvent->IsOS()) {
         return NS_OK;
       }
       DeleteSelection(nsIEditor::eNext, nsIEditor::eStrip);
       aKeyEvent->PreventDefault(); // consumed
-      return NS_OK; 
+      return NS_OK;
   }
   return NS_OK;
 }
 
 nsresult
 nsEditor::HandleInlineSpellCheck(EditAction action,
                                    Selection* aSelection,
                                    nsIDOMNode *previousSelectedNode,
@@ -4864,22 +4864,22 @@ nsEditor::SwitchTextDirectionTo(uint32_t
 
 #if DEBUG_JOE
 void
 nsEditor::DumpNode(nsIDOMNode *aNode, int32_t indent)
 {
   int32_t i;
   for (i=0; i<indent; i++)
     printf("  ");
-  
+
   nsCOMPtr<nsIDOMElement> element = do_QueryInterface(aNode);
   nsCOMPtr<nsIDOMDocumentFragment> docfrag = do_QueryInterface(aNode);
-  
+
   if (element || docfrag)
-  { 
+  {
     if (element)
     {
       nsAutoString tag;
       element->GetTagName(tag);
       printf("<%s>\n", NS_LossyConvertUTF16toASCII(tag).get());
     }
     else
     {