diff -r 000000000000 -r 6474c204b198 editor/libeditor/html/nsHTMLEditor.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/editor/libeditor/html/nsHTMLEditor.cpp	Wed Dec 31 06:09:35 2014 +0100
@@ -0,0 +1,5474 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "mozilla/DebugOnly.h"
+#include "mozilla/EventStates.h"
+#include "mozilla/TextEvents.h"
+
+#include "nsCRT.h"
+
+#include "nsUnicharUtils.h"
+
+#include "nsHTMLEditor.h"
+#include "nsHTMLEditRules.h"
+#include "nsTextEditUtils.h"
+#include "nsHTMLEditUtils.h"
+
+#include "nsHTMLEditorEventListener.h"
+#include "TypeInState.h"
+
+#include "nsHTMLURIRefObject.h"
+
+#include "nsIDOMText.h"
+#include "nsIDOMMozNamedAttrMap.h"
+#include "nsIDOMNodeList.h"
+#include "nsIDOMDocument.h"
+#include "nsIDOMAttr.h"
+#include "nsIDocumentInlines.h"
+#include "nsIDOMEventTarget.h" 
+#include "nsIDOMKeyEvent.h"
+#include "nsIDOMMouseEvent.h"
+#include "nsIDOMHTMLAnchorElement.h"
+#include "nsISelectionController.h"
+#include "nsIDOMHTMLDocument.h"
+#include "nsILinkHandler.h"
+#include "nsIInlineSpellChecker.h"
+
+#include "mozilla/css/Loader.h"
+#include "nsCSSStyleSheet.h"
+#include "nsIDOMStyleSheet.h"
+
+#include "nsIContent.h"
+#include "nsIContentIterator.h"
+#include "nsIDOMRange.h"
+#include "nsISupportsArray.h"
+#include "nsContentUtils.h"
+#include "nsIDocumentEncoder.h"
+#include "nsIDOMDocumentFragment.h"
+#include "nsIPresShell.h"
+#include "nsPresContext.h"
+#include "SetDocTitleTxn.h"
+#include "nsFocusManager.h"
+#include "nsPIDOMWindow.h"
+
+// netwerk
+#include "nsIURI.h"
+#include "nsNetUtil.h"
+
+// Transactionas
+#include "nsStyleSheetTxns.h"
+
+// Misc
+#include "TextEditorTest.h"
+#include "nsEditorUtils.h"
+#include "nsWSRunObject.h"
+#include "nsGkAtoms.h"
+#include "nsIWidget.h"
+
+#include "nsIFrame.h"
+#include "nsIParserService.h"
+#include "mozilla/dom/Selection.h"
+#include "mozilla/dom/Element.h"
+#include "mozilla/dom/EventTarget.h"
+#include "mozilla/dom/HTMLBodyElement.h"
+#include "nsTextFragment.h"
+
+using namespace mozilla;
+using namespace mozilla::dom;
+using namespace mozilla::widget;
+
+// Some utilities to handle annoying overloading of "A" tag for link and named anchor
+static char hrefText[] = "href";
+static char anchorTxt[] = "anchor";
+static char namedanchorText[] = "namedanchor";
+
+#define IsLinkTag(s) (s.EqualsIgnoreCase(hrefText))
+#define IsNamedAnchorTag(s) (s.EqualsIgnoreCase(anchorTxt) || s.EqualsIgnoreCase(namedanchorText))
+
+nsHTMLEditor::nsHTMLEditor()
+: nsPlaintextEditor()
+, mCRInParagraphCreatesParagraph(false)
+, mSelectedCellIndex(0)
+, mIsObjectResizingEnabled(true)
+, mIsResizing(false)
+, mIsAbsolutelyPositioningEnabled(true)
+, mResizedObjectIsAbsolutelyPositioned(false)
+, mGrabberClicked(false)
+, mIsMoving(false)
+, mSnapToGridEnabled(false)
+, mIsInlineTableEditingEnabled(true)
+, mInfoXIncrement(20)
+, mInfoYIncrement(20)
+, mGridSize(0)
+{
+} 
+
+nsHTMLEditor::~nsHTMLEditor()
+{
+  // remove the rules as an action listener.  Else we get a bad
+  // ownership loop later on.  it's ok if the rules aren't a listener;
+  // we ignore the error.
+  nsCOMPtr<nsIEditActionListener> mListener = do_QueryInterface(mRules);
+  RemoveEditActionListener(mListener);
+
+  //the autopointers will clear themselves up. 
+  //but we need to also remove the listeners or we have a leak
+  nsCOMPtr<nsISelection>selection;
+  nsresult result = GetSelection(getter_AddRefs(selection));
+  // if we don't get the selection, just skip this
+  if (NS_SUCCEEDED(result) && selection) 
+  {
+    nsCOMPtr<nsISelectionPrivate> selPriv(do_QueryInterface(selection));
+    nsCOMPtr<nsISelectionListener>listener;
+    listener = do_QueryInterface(mTypeInState);
+    if (listener)
+    {
+      selPriv->RemoveSelectionListener(listener); 
+    }
+    listener = do_QueryInterface(mSelectionListenerP);
+    if (listener)
+    {
+      selPriv->RemoveSelectionListener(listener); 
+    }
+  }
+
+  mTypeInState = nullptr;
+  mSelectionListenerP = nullptr;
+
+  // free any default style propItems
+  RemoveAllDefaultProperties();
+
+  if (mLinkHandler && mDocWeak)
+  {
+    nsCOMPtr<nsIPresShell> ps = GetPresShell();
+
+    if (ps && ps->GetPresContext())
+    {
+      ps->GetPresContext()->SetLinkHandler(mLinkHandler);
+    }
+  }
+
+  RemoveEventListeners();
+}
+
+void
+nsHTMLEditor::HideAnonymousEditingUIs()
+{
+  if (mAbsolutelyPositionedObject)
+    HideGrabber();
+  if (mInlineEditedCell)
+    HideInlineTableEditingUI();
+  if (mResizedObject)
+    HideResizers();
+}
+
+NS_IMPL_CYCLE_COLLECTION_CLASS(nsHTMLEditor)
+
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(nsHTMLEditor, nsPlaintextEditor)
+  NS_IMPL_CYCLE_COLLECTION_UNLINK(mTypeInState)
+  NS_IMPL_CYCLE_COLLECTION_UNLINK(mStyleSheets)
+
+  tmp->HideAnonymousEditingUIs();
+NS_IMPL_CYCLE_COLLECTION_UNLINK_END
+
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(nsHTMLEditor, nsPlaintextEditor)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mTypeInState)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mStyleSheets)
+
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mTopLeftHandle)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mTopHandle)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mTopRightHandle)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mLeftHandle)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mRightHandle)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mBottomLeftHandle)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mBottomHandle)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mBottomRightHandle)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mActivatedHandle)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mResizingShadow)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mResizingInfo)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mResizedObject)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mMouseMotionListenerP)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mSelectionListenerP)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mResizeEventListenerP)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(objectResizeEventListeners)
+
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mAbsolutelyPositionedObject)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mGrabber)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mPositioningShadow)
+
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mInlineEditedCell)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mAddColumnBeforeButton)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mRemoveColumnButton)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mAddColumnAfterButton)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mAddRowBeforeButton)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mRemoveRowButton)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mAddRowAfterButton)
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
+
+NS_IMPL_ADDREF_INHERITED(nsHTMLEditor, nsEditor)
+NS_IMPL_RELEASE_INHERITED(nsHTMLEditor, nsEditor)
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(nsHTMLEditor)
+  NS_INTERFACE_MAP_ENTRY(nsIHTMLEditor)
+  NS_INTERFACE_MAP_ENTRY(nsIHTMLObjectResizer)
+  NS_INTERFACE_MAP_ENTRY(nsIHTMLAbsPosEditor)
+  NS_INTERFACE_MAP_ENTRY(nsIHTMLInlineTableEditor)
+  NS_INTERFACE_MAP_ENTRY(nsITableEditor)
+  NS_INTERFACE_MAP_ENTRY(nsIEditorStyleSheets)
+  NS_INTERFACE_MAP_ENTRY(nsICSSLoaderObserver)
+  NS_INTERFACE_MAP_ENTRY(nsIMutationObserver)
+NS_INTERFACE_MAP_END_INHERITING(nsPlaintextEditor)
+
+
+NS_IMETHODIMP
+nsHTMLEditor::Init(nsIDOMDocument *aDoc,
+                   nsIContent *aRoot,
+                   nsISelectionController *aSelCon,
+                   uint32_t aFlags,
+                   const nsAString& aInitialValue)
+{
+  NS_PRECONDITION(aDoc && !aSelCon, "bad arg");
+  NS_ENSURE_TRUE(aDoc, NS_ERROR_NULL_POINTER);
+  MOZ_ASSERT(aInitialValue.IsEmpty(), "Non-empty initial values not supported");
+
+  nsresult result = NS_OK, rulesRes = NS_OK;
+   
+  if (1)
+  {
+    // block to scope nsAutoEditInitRulesTrigger
+    nsAutoEditInitRulesTrigger rulesTrigger(static_cast<nsPlaintextEditor*>(this), rulesRes);
+
+    // Init the plaintext editor
+    result = nsPlaintextEditor::Init(aDoc, aRoot, nullptr, aFlags, aInitialValue);
+    if (NS_FAILED(result)) { return result; }
+
+    // Init mutation observer
+    nsCOMPtr<nsINode> document = do_QueryInterface(aDoc);
+    document->AddMutationObserverUnlessExists(this);
+
+    // disable Composer-only features
+    if (IsMailEditor())
+    {
+      SetAbsolutePositioningEnabled(false);
+      SetSnapToGridEnabled(false);
+    }
+
+    // Init the HTML-CSS utils
+    mHTMLCSSUtils = new nsHTMLCSSUtils(this);
+
+    // disable links
+    nsCOMPtr<nsIPresShell> presShell = GetPresShell();
+    NS_ENSURE_TRUE(presShell, NS_ERROR_FAILURE);
+    nsPresContext *context = presShell->GetPresContext();
+    NS_ENSURE_TRUE(context, NS_ERROR_NULL_POINTER);
+    if (!IsPlaintextEditor() && !IsInteractionAllowed()) {
+      mLinkHandler = context->GetLinkHandler();
+
+      context->SetLinkHandler(nullptr);
+    }
+
+    // init the type-in state
+    mTypeInState = new TypeInState();
+
+    // init the selection listener for image resizing
+    mSelectionListenerP = new ResizerSelectionListener(this);
+
+    if (!IsInteractionAllowed()) {
+      // ignore any errors from this in case the file is missing
+      AddOverrideStyleSheet(NS_LITERAL_STRING("resource://gre/res/EditorOverride.css"));
+    }
+
+    nsCOMPtr<nsISelection>selection;
+    result = GetSelection(getter_AddRefs(selection));
+    if (NS_FAILED(result)) { return result; }
+    if (selection) 
+    {
+      nsCOMPtr<nsISelectionPrivate> selPriv(do_QueryInterface(selection));
+      nsCOMPtr<nsISelectionListener>listener;
+      listener = do_QueryInterface(mTypeInState);
+      if (listener) {
+        selPriv->AddSelectionListener(listener); 
+      }
+      listener = do_QueryInterface(mSelectionListenerP);
+      if (listener) {
+        selPriv->AddSelectionListener(listener); 
+      }
+    }
+  }
+
+  NS_ENSURE_SUCCESS(rulesRes, rulesRes);
+  return result;
+}
+
+NS_IMETHODIMP
+nsHTMLEditor::PreDestroy(bool aDestroyingFrames)
+{
+  if (mDidPreDestroy) {
+    return NS_OK;
+  }
+
+  nsCOMPtr<nsINode> document = do_QueryReferent(mDocWeak);
+  if (document) {
+    document->RemoveMutationObserver(this);
+  }
+
+  while (mStyleSheetURLs.Length())
+  {
+    RemoveOverrideStyleSheet(mStyleSheetURLs[0]);
+  }
+
+  // Clean up after our anonymous content -- we don't want these nodes to
+  // stay around (which they would, since the frames have an owning reference).
+  HideAnonymousEditingUIs();
+
+  return nsPlaintextEditor::PreDestroy(aDestroyingFrames);
+}
+
+NS_IMETHODIMP
+nsHTMLEditor::GetRootElement(nsIDOMElement **aRootElement)
+{
+  NS_ENSURE_ARG_POINTER(aRootElement);
+
+  if (mRootElement) {
+    return nsEditor::GetRootElement(aRootElement);
+  }
+
+  *aRootElement = nullptr;
+
+  // Use the HTML documents body element as the editor root if we didn't
+  // get a root element during initialization.
+
+  nsCOMPtr<nsIDOMElement> rootElement; 
+  nsCOMPtr<nsIDOMHTMLElement> bodyElement; 
+  nsresult rv = GetBodyElement(getter_AddRefs(bodyElement));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (bodyElement) {
+    rootElement = bodyElement;
+  } else {
+    // If there is no HTML body element,
+    // we should use the document root element instead.
+    nsCOMPtr<nsIDOMDocument> doc = do_QueryReferent(mDocWeak);
+    NS_ENSURE_TRUE(doc, NS_ERROR_NOT_INITIALIZED);
+
+    rv = doc->GetDocumentElement(getter_AddRefs(rootElement));
+    NS_ENSURE_SUCCESS(rv, rv);
+    // Document can have no elements
+    if (!rootElement) {
+      return NS_ERROR_NOT_AVAILABLE;
+    }
+  }
+
+  mRootElement = do_QueryInterface(rootElement);
+  rootElement.forget(aRootElement);
+
+  return NS_OK;
+}
+
+already_AddRefed<nsIContent>
+nsHTMLEditor::FindSelectionRoot(nsINode *aNode)
+{
+  NS_PRECONDITION(aNode->IsNodeOfType(nsINode::eDOCUMENT) ||
+                  aNode->IsNodeOfType(nsINode::eCONTENT),
+                  "aNode must be content or document node");
+
+  nsCOMPtr<nsIDocument> doc = aNode->GetCurrentDoc();
+  if (!doc) {
+    return nullptr;
+  }
+
+  nsCOMPtr<nsIContent> content;
+  if (doc->HasFlag(NODE_IS_EDITABLE) || !aNode->IsContent()) {
+    content = doc->GetRootElement();
+    return content.forget();
+  }
+  content = aNode->AsContent();
+
+  // XXX If we have readonly flag, shouldn't return the element which has
+  // contenteditable="true"?  However, such case isn't there without chrome
+  // permission script.
+  if (IsReadonly()) {
+    // We still want to allow selection in a readonly editor.
+    content = do_QueryInterface(GetRoot());
+    return content.forget();
+  }
+
+  if (!content->HasFlag(NODE_IS_EDITABLE)) {
+    // If the content is in read-write state but is not editable itself,
+    // return it as the selection root.
+    if (content->IsElement() &&
+        content->AsElement()->State().HasState(NS_EVENT_STATE_MOZ_READWRITE)) {
+      return content.forget();
+    }
+    return nullptr;
+  }
+
+  // For non-readonly editors we want to find the root of the editable subtree
+  // containing aContent.
+  content = content->GetEditingHost();
+  return content.forget();
+}
+
+/* virtual */
+void
+nsHTMLEditor::CreateEventListeners()
+{
+  // Don't create the handler twice
+  if (!mEventListener) {
+    mEventListener = new nsHTMLEditorEventListener();
+  }
+}
+
+nsresult
+nsHTMLEditor::InstallEventListeners()
+{
+  NS_ENSURE_TRUE(mDocWeak && mEventListener,
+                 NS_ERROR_NOT_INITIALIZED);
+
+  // NOTE: nsHTMLEditor doesn't need to initialize mEventTarget here because
+  // the target must be document node and it must be referenced as weak pointer.
+
+  nsHTMLEditorEventListener* listener =
+    reinterpret_cast<nsHTMLEditorEventListener*>(mEventListener.get());
+  return listener->Connect(this);
+}
+
+void
+nsHTMLEditor::RemoveEventListeners()
+{
+  if (!mDocWeak)
+  {
+    return;
+  }
+
+  nsCOMPtr<nsIDOMEventTarget> target = GetDOMEventTarget();
+
+  if (target)
+  {
+    // Both mMouseMotionListenerP and mResizeEventListenerP can be
+    // registerd with other targets than the DOM event receiver that
+    // we can reach from here. But nonetheless, unregister the event
+    // listeners with the DOM event reveiver (if it's registerd with
+    // other targets, it'll get unregisterd once the target goes
+    // away).
+
+    if (mMouseMotionListenerP)
+    {
+      // mMouseMotionListenerP might be registerd either as bubbling or
+      // capturing, unregister by both.
+      target->RemoveEventListener(NS_LITERAL_STRING("mousemove"),
+                                  mMouseMotionListenerP, false);
+      target->RemoveEventListener(NS_LITERAL_STRING("mousemove"),
+                                  mMouseMotionListenerP, true);
+    }
+
+    if (mResizeEventListenerP)
+    {
+      target->RemoveEventListener(NS_LITERAL_STRING("resize"),
+                                  mResizeEventListenerP, false);
+    }
+  }
+
+  mMouseMotionListenerP = nullptr;
+  mResizeEventListenerP = nullptr;
+
+  nsPlaintextEditor::RemoveEventListeners();
+}
+
+NS_IMETHODIMP 
+nsHTMLEditor::SetFlags(uint32_t aFlags)
+{
+  nsresult rv = nsPlaintextEditor::SetFlags(aFlags);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Sets mCSSAware to correspond to aFlags. This toggles whether CSS is
+  // used to style elements in the editor. Note that the editor is only CSS
+  // aware by default in Composer and in the mail editor.
+  mCSSAware = !NoCSS() && !IsMailEditor();
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsHTMLEditor::InitRules()
+{
+  if (!mRules) {
+    // instantiate the rules for the html editor
+    mRules = new nsHTMLEditRules();
+  }
+  return mRules->Init(static_cast<nsPlaintextEditor*>(this));
+}
+
+NS_IMETHODIMP
+nsHTMLEditor::BeginningOfDocument()
+{
+  if (!mDocWeak) { return NS_ERROR_NOT_INITIALIZED; }
+
+  // get the selection
+  nsCOMPtr<nsISelection> selection;
+  nsresult res = GetSelection(getter_AddRefs(selection));
+  NS_ENSURE_SUCCESS(res, res);
+  NS_ENSURE_TRUE(selection, NS_ERROR_NOT_INITIALIZED);
+
+  // Get the root element.
+  nsCOMPtr<nsIDOMElement> rootElement = do_QueryInterface(GetRoot());
+  if (!rootElement) {
+    NS_WARNING("GetRoot() returned a null pointer (mRootElement is null)");
+    return NS_OK;
+  }
+
+  // find first editable thingy
+  bool done = false;
+  nsCOMPtr<nsIDOMNode> curNode(rootElement), selNode;
+  int32_t curOffset = 0, selOffset;
+  while (!done)
+  {
+    nsWSRunObject wsObj(this, curNode, curOffset);
+    nsCOMPtr<nsIDOMNode> visNode;
+    int32_t visOffset=0;
+    WSType visType;
+    wsObj.NextVisibleNode(curNode, curOffset, address_of(visNode), &visOffset, &visType);
+    if (visType == WSType::normalWS || visType == WSType::text) {
+      selNode = visNode;
+      selOffset = visOffset;
+      done = true;
+    } else if (visType == WSType::br || visType == WSType::special) {
+      selNode = GetNodeLocation(visNode, &selOffset);
+      done = true;
+    } else if (visType == WSType::otherBlock) {
+      // By definition of nsWSRunObject, a block element terminates 
+      // a whitespace run. That is, although we are calling a method 
+      // that is named "NextVisibleNode", the node returned
+      // might not be visible/editable!
+      // If the given block does not contain any visible/editable items,
+      // we want to skip it and continue our search.
+
+      if (!IsContainer(visNode))
+      {
+        // However, we were given a block that is not a container.
+        // Since the block can not contain anything that's visible,
+        // such a block only makes sense if it is visible by itself,
+        // like a <hr>
+        // We want to place the caret in front of that block.
+
+        selNode = GetNodeLocation(visNode, &selOffset);
+        done = true;
+      }
+      else
+      {
+        bool isEmptyBlock;
+        if (NS_SUCCEEDED(IsEmptyNode(visNode, &isEmptyBlock)) &&
+            isEmptyBlock)
+        {
+          // skip the empty block
+          curNode = GetNodeLocation(visNode, &curOffset);
+          ++curOffset;
+        }
+        else
+        {
+          curNode = visNode;
+          curOffset = 0;
+        }
+        // keep looping
+      }
+    }
+    else
+    {
+      // else we found nothing useful
+      selNode = curNode;
+      selOffset = curOffset;
+      done = true;
+    }
+  }
+  return selection->Collapse(selNode, selOffset);
+}
+
+nsresult
+nsHTMLEditor::HandleKeyPressEvent(nsIDOMKeyEvent* aKeyEvent)
+{
+  // NOTE: When you change this method, you should also change:
+  //   * editor/libeditor/html/tests/test_htmleditor_keyevent_handling.html
+
+  if (IsReadonly() || IsDisabled()) {
+    // When we're not editable, the events are handled on nsEditor, so, we can
+    // bypass nsPlaintextEditor.
+    return nsEditor::HandleKeyPressEvent(aKeyEvent);
+  }
+
+  WidgetKeyboardEvent* nativeKeyEvent =
+    aKeyEvent->GetInternalNSEvent()->AsKeyboardEvent();
+  NS_ENSURE_TRUE(nativeKeyEvent, NS_ERROR_UNEXPECTED);
+  NS_ASSERTION(nativeKeyEvent->message == NS_KEY_PRESS,
+               "HandleKeyPressEvent gets non-keypress event");
+
+  switch (nativeKeyEvent->keyCode) {
+    case nsIDOMKeyEvent::DOM_VK_META:
+    case nsIDOMKeyEvent::DOM_VK_WIN:
+    case nsIDOMKeyEvent::DOM_VK_SHIFT:
+    case nsIDOMKeyEvent::DOM_VK_CONTROL:
+    case nsIDOMKeyEvent::DOM_VK_ALT:
+    case nsIDOMKeyEvent::DOM_VK_BACK_SPACE:
+    case nsIDOMKeyEvent::DOM_VK_DELETE:
+      // These keys are handled on nsEditor, so, we can bypass
+      // nsPlaintextEditor.
+      return nsEditor::HandleKeyPressEvent(aKeyEvent);
+    case nsIDOMKeyEvent::DOM_VK_TAB: {
+      if (IsPlaintextEditor()) {
+        // If this works as plain text editor, e.g., mail editor for plain
+        // text, should be handled on nsPlaintextEditor.
+        return nsPlaintextEditor::HandleKeyPressEvent(aKeyEvent);
+      }
+
+      if (IsTabbable()) {
+        return NS_OK; // let it be used for focus switching
+      }
+
+      if (nativeKeyEvent->IsControl() || nativeKeyEvent->IsAlt() ||
+          nativeKeyEvent->IsMeta() || nativeKeyEvent->IsOS()) {
+        return NS_OK;
+      }
+
+      nsCOMPtr<nsISelection> selection;
+      nsresult rv = GetSelection(getter_AddRefs(selection));
+      NS_ENSURE_SUCCESS(rv, rv);
+      int32_t offset;
+      nsCOMPtr<nsIDOMNode> node, blockParent;
+      rv = GetStartNodeAndOffset(selection, getter_AddRefs(node), &offset);
+      NS_ENSURE_SUCCESS(rv, rv);
+      NS_ENSURE_TRUE(node, NS_ERROR_FAILURE);
+
+      bool isBlock = false;
+      NodeIsBlock(node, &isBlock);
+      if (isBlock) {
+        blockParent = node;
+      } else {
+        blockParent = GetBlockNodeParent(node);
+      }
+
+      if (!blockParent) {
+        break;
+      }
+
+      bool handled = false;
+      if (nsHTMLEditUtils::IsTableElement(blockParent)) {
+        rv = TabInTable(nativeKeyEvent->IsShift(), &handled);
+        if (handled) {
+          ScrollSelectionIntoView(false);
+        }
+      } else if (nsHTMLEditUtils::IsListItem(blockParent)) {
+        rv = Indent(nativeKeyEvent->IsShift() ?
+                      NS_LITERAL_STRING("outdent") :
+                      NS_LITERAL_STRING("indent"));
+        handled = true;
+      }
+      NS_ENSURE_SUCCESS(rv, rv);
+      if (handled) {
+        return aKeyEvent->PreventDefault(); // consumed
+      }
+      if (nativeKeyEvent->IsShift()) {
+        return NS_OK; // don't type text for shift tabs
+      }
+      aKeyEvent->PreventDefault();
+      return TypedText(NS_LITERAL_STRING("\t"), eTypedText);
+    }
+    case nsIDOMKeyEvent::DOM_VK_RETURN:
+      if (nativeKeyEvent->IsControl() || nativeKeyEvent->IsAlt() ||
+          nativeKeyEvent->IsMeta() || nativeKeyEvent->IsOS()) {
+        return NS_OK;
+      }
+      aKeyEvent->PreventDefault(); // consumed
+      if (nativeKeyEvent->IsShift() && !IsPlaintextEditor()) {
+        // only inserts a br node
+        return TypedText(EmptyString(), eTypedBR);
+      }
+      // uses rules to figure out what to insert
+      return TypedText(EmptyString(), eTypedBreak);
+  }
+
+  // NOTE: On some keyboard layout, some characters are inputted with Control
+  // key or Alt key, but at that time, widget sets FALSE to these keys.
+  if (nativeKeyEvent->charCode == 0 || nativeKeyEvent->IsControl() ||
+      nativeKeyEvent->IsAlt() || nativeKeyEvent->IsMeta() ||
+      nativeKeyEvent->IsOS()) {
+    // we don't PreventDefault() here or keybindings like control-x won't work
+    return NS_OK;
+  }
+  aKeyEvent->PreventDefault();
+  nsAutoString str(nativeKeyEvent->charCode);
+  return TypedText(str, eTypedText);
+}
+
+static void
+AssertParserServiceIsCorrect(nsIAtom* aTag, bool aIsBlock)
+{
+#ifdef DEBUG
+  // Check this against what we would have said with the old code:
+  if (aTag==nsEditProperty::p          ||
+      aTag==nsEditProperty::div        ||
+      aTag==nsEditProperty::blockquote ||
+      aTag==nsEditProperty::h1         ||
+      aTag==nsEditProperty::h2         ||
+      aTag==nsEditProperty::h3         ||
+      aTag==nsEditProperty::h4         ||
+      aTag==nsEditProperty::h5         ||
+      aTag==nsEditProperty::h6         ||
+      aTag==nsEditProperty::ul         ||
+      aTag==nsEditProperty::ol         ||
+      aTag==nsEditProperty::dl         ||
+      aTag==nsEditProperty::noscript   ||
+      aTag==nsEditProperty::form       ||
+      aTag==nsEditProperty::hr         ||
+      aTag==nsEditProperty::table      ||
+      aTag==nsEditProperty::fieldset   ||
+      aTag==nsEditProperty::address    ||
+      aTag==nsEditProperty::col        ||
+      aTag==nsEditProperty::colgroup   ||
+      aTag==nsEditProperty::li         ||
+      aTag==nsEditProperty::dt         ||
+      aTag==nsEditProperty::dd         ||
+      aTag==nsEditProperty::legend     )
+  {
+    if (!aIsBlock) {
+      nsAutoString assertmsg (NS_LITERAL_STRING("Parser and editor disagree on blockness: "));
+
+      nsAutoString tagName;
+      aTag->ToString(tagName);
+      assertmsg.Append(tagName);
+      char* assertstr = ToNewCString(assertmsg);
+      NS_ASSERTION(aIsBlock, assertstr);
+      NS_Free(assertstr);
+    }
+  }
+#endif // DEBUG
+}
+
+/**
+ * Returns true if the id represents an element of block type.
+ * Can be used to determine if a new paragraph should be started.
+ */
+bool
+nsHTMLEditor::NodeIsBlockStatic(const dom::Element* aElement)
+{
+  MOZ_ASSERT(aElement);
+
+  nsIAtom* tagAtom = aElement->Tag();
+  MOZ_ASSERT(tagAtom);
+
+  // Nodes we know we want to treat as block
+  // even though the parser says they're not:
+  if (tagAtom==nsEditProperty::body       ||
+      tagAtom==nsEditProperty::head       ||
+      tagAtom==nsEditProperty::tbody      ||
+      tagAtom==nsEditProperty::thead      ||
+      tagAtom==nsEditProperty::tfoot      ||
+      tagAtom==nsEditProperty::tr         ||
+      tagAtom==nsEditProperty::th         ||
+      tagAtom==nsEditProperty::td         ||
+      tagAtom==nsEditProperty::li         ||
+      tagAtom==nsEditProperty::dt         ||
+      tagAtom==nsEditProperty::dd         ||
+      tagAtom==nsEditProperty::pre)
+  {
+    return true;
+  }
+
+  bool isBlock;
+#ifdef DEBUG
+  // XXX we can't use DebugOnly here because VC++ is stupid (bug 802884)
+  nsresult rv =
+#endif
+    nsContentUtils::GetParserService()->
+    IsBlock(nsContentUtils::GetParserService()->HTMLAtomTagToId(tagAtom),
+            isBlock);
+  MOZ_ASSERT(rv == NS_OK);
+
+  AssertParserServiceIsCorrect(tagAtom, isBlock);
+
+  return isBlock;
+}
+
+nsresult
+nsHTMLEditor::NodeIsBlockStatic(nsIDOMNode *aNode, bool *aIsBlock)
+{
+  if (!aNode || !aIsBlock) { return NS_ERROR_NULL_POINTER; }
+
+  nsCOMPtr<dom::Element> element = do_QueryInterface(aNode);
+  *aIsBlock = element && NodeIsBlockStatic(element);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsHTMLEditor::NodeIsBlock(nsIDOMNode *aNode, bool *aIsBlock)
+{
+  return NodeIsBlockStatic(aNode, aIsBlock);
+}
+
+bool
+nsHTMLEditor::IsBlockNode(nsINode *aNode)
+{
+  return aNode && aNode->IsElement() && NodeIsBlockStatic(aNode->AsElement());
+}
+
+// Non-static version for the nsIEditor interface and JavaScript
+NS_IMETHODIMP 
+nsHTMLEditor::SetDocumentTitle(const nsAString &aTitle)
+{
+  nsRefPtr<SetDocTitleTxn> txn = new SetDocTitleTxn();
+  NS_ENSURE_TRUE(txn, NS_ERROR_OUT_OF_MEMORY);
+
+  nsresult result = txn->Init(this, &aTitle);
+  NS_ENSURE_SUCCESS(result, result);
+
+  //Don't let Rules System change the selection
+  nsAutoTxnsConserveSelection dontChangeSelection(this);
+  return nsEditor::DoTransaction(txn);  
+}
+
+/* ------------ Block methods moved from nsEditor -------------- */
+///////////////////////////////////////////////////////////////////////////
+// GetBlockNodeParent: returns enclosing block level ancestor, if any
+//
+already_AddRefed<nsIDOMNode>
+nsHTMLEditor::GetBlockNodeParent(nsIDOMNode *aNode)
+{
+  if (!aNode)
+  {
+    NS_NOTREACHED("null node passed to GetBlockNodeParent()");
+    return nullptr;
+  }
+
+  nsCOMPtr<nsIDOMNode> p;
+  if (NS_FAILED(aNode->GetParentNode(getter_AddRefs(p))))  // no parent, ran off top of tree
+    return nullptr;
+
+  nsCOMPtr<nsIDOMNode> tmp;
+  while (p)
+  {
+    bool isBlock;
+    if (NS_FAILED(NodeIsBlockStatic(p, &isBlock)) || isBlock)
+      break;
+    if (NS_FAILED(p->GetParentNode(getter_AddRefs(tmp))) || !tmp) // no parent, ran off top of tree
+      break;
+
+    p = tmp;
+  }
+  return p.forget();
+}
+
+static const char16_t nbsp = 160;
+
+///////////////////////////////////////////////////////////////////////////////
+// IsNextCharInNodeWhitespace: checks the adjacent content in the same node to
+//                             see if following selection is whitespace or nbsp
+void
+nsHTMLEditor::IsNextCharInNodeWhitespace(nsIContent* aContent,
+                                         int32_t aOffset,
+                                         bool* outIsSpace,
+                                         bool* outIsNBSP,
+                                         nsIContent** outNode,
+                                         int32_t* outOffset)
+{
+  MOZ_ASSERT(aContent && outIsSpace && outIsNBSP);
+  MOZ_ASSERT((outNode && outOffset) || (!outNode && !outOffset));
+  *outIsSpace = false;
+  *outIsNBSP = false;
+  if (outNode && outOffset) {
+    *outNode = nullptr;
+    *outOffset = -1;
+  }
+
+  if (aContent->IsNodeOfType(nsINode::eTEXT) &&
+      (uint32_t)aOffset < aContent->Length()) {
+    char16_t ch = aContent->GetText()->CharAt(aOffset);
+    *outIsSpace = nsCRT::IsAsciiSpace(ch);
+    *outIsNBSP = (ch == nbsp);
+    if (outNode && outOffset) {
+      NS_IF_ADDREF(*outNode = aContent);
+      // yes, this is _past_ the character
+      *outOffset = aOffset + 1;
+    }
+  }
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+// IsPrevCharInNodeWhitespace: checks the adjacent content in the same node to
+//                             see if following selection is whitespace
+void
+nsHTMLEditor::IsPrevCharInNodeWhitespace(nsIContent* aContent,
+                                         int32_t aOffset,
+                                         bool* outIsSpace,
+                                         bool* outIsNBSP,
+                                         nsIContent** outNode,
+                                         int32_t* outOffset)
+{
+  MOZ_ASSERT(aContent && outIsSpace && outIsNBSP);
+  MOZ_ASSERT((outNode && outOffset) || (!outNode && !outOffset));
+  *outIsSpace = false;
+  *outIsNBSP = false;
+  if (outNode && outOffset) {
+    *outNode = nullptr;
+    *outOffset = -1;
+  }
+
+  if (aContent->IsNodeOfType(nsINode::eTEXT) && aOffset > 0) {
+    char16_t ch = aContent->GetText()->CharAt(aOffset - 1);
+    *outIsSpace = nsCRT::IsAsciiSpace(ch);
+    *outIsNBSP = (ch == nbsp);
+    if (outNode && outOffset) {
+      NS_IF_ADDREF(*outNode = aContent);
+      *outOffset = aOffset - 1;
+    }
+  }
+}
+
+
+
+/* ------------ End Block methods -------------- */
+
+
+bool nsHTMLEditor::IsVisBreak(nsIDOMNode *aNode)
+{
+  NS_ENSURE_TRUE(aNode, false);
+  if (!nsTextEditUtils::IsBreak(aNode)) 
+    return false;
+  // check if there is a later node in block after br
+  nsCOMPtr<nsIDOMNode> priorNode, nextNode;
+  GetPriorHTMLNode(aNode, address_of(priorNode), true); 
+  GetNextHTMLNode(aNode, address_of(nextNode), true); 
+  // if we are next to another break, we are visible
+  if (priorNode && nsTextEditUtils::IsBreak(priorNode))
+    return true;
+  if (nextNode && nsTextEditUtils::IsBreak(nextNode))
+    return true;
+  
+  // if we are right before block boundary, then br not visible
+  NS_ENSURE_TRUE(nextNode, false);  // this break is trailer in block, it's not visible
+  if (IsBlockNode(nextNode))
+    return false; // break is right before a block, it's not visible
+    
+  // sigh.  We have to use expensive whitespace calculation code to 
+  // determine what is going on
+  nsCOMPtr<nsIDOMNode> selNode, tmp;
+  int32_t selOffset;
+  selNode = GetNodeLocation(aNode, &selOffset);
+  selOffset++; // lets look after the break
+  nsWSRunObject wsObj(this, selNode, selOffset);
+  nsCOMPtr<nsIDOMNode> visNode;
+  int32_t visOffset=0;
+  WSType visType;
+  wsObj.NextVisibleNode(selNode, selOffset, address_of(visNode), &visOffset, &visType);
+  if (visType & WSType::block) {
+    return false;
+  }
+  
+  return true;
+}
+
+NS_IMETHODIMP
+nsHTMLEditor::BreakIsVisible(nsIDOMNode *aNode, bool *aIsVisible)
+{
+  NS_ENSURE_ARG_POINTER(aNode && aIsVisible);
+
+  *aIsVisible = IsVisBreak(aNode);
+
+  return NS_OK;
+}
+
+
+NS_IMETHODIMP
+nsHTMLEditor::GetIsDocumentEditable(bool *aIsDocumentEditable)
+{
+  NS_ENSURE_ARG_POINTER(aIsDocumentEditable);
+
+  nsCOMPtr<nsIDOMDocument> doc = GetDOMDocument();
+  *aIsDocumentEditable = doc && IsModifiable();
+
+  return NS_OK;
+}
+
+bool nsHTMLEditor::IsModifiable()
+{
+  return !IsReadonly();
+}
+
+NS_IMETHODIMP
+nsHTMLEditor::UpdateBaseURL()
+{
+  nsCOMPtr<nsIDOMDocument> domDoc = GetDOMDocument();
+  NS_ENSURE_TRUE(domDoc, NS_ERROR_FAILURE);
+
+  // Look for an HTML <base> tag
+  nsCOMPtr<nsIDOMNodeList> nodeList;
+  nsresult rv = domDoc->GetElementsByTagName(NS_LITERAL_STRING("base"), getter_AddRefs(nodeList));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIDOMNode> baseNode;
+  if (nodeList)
+  {
+    uint32_t count;
+    nodeList->GetLength(&count);
+    if (count >= 1)
+    {
+      rv = nodeList->Item(0, getter_AddRefs(baseNode));
+      NS_ENSURE_SUCCESS(rv, rv);
+    }
+  }
+  // If no base tag, then set baseURL to the document's URL
+  // This is very important, else relative URLs for links and images are wrong
+  if (!baseNode)
+  {
+    nsCOMPtr<nsIDocument> doc = do_QueryInterface(domDoc);
+    NS_ENSURE_TRUE(doc, NS_ERROR_FAILURE);
+
+    return doc->SetBaseURI(doc->GetDocumentURI());
+  }
+  return NS_OK;
+}
+
+/* This routine is needed to provide a bottleneck for typing for logging
+   purposes.  Can't use HandleKeyPress() (above) for that since it takes
+   a nsIDOMKeyEvent* parameter.  So instead we pass enough info through
+   to TypedText() to determine what action to take, but without passing
+   an event.
+   */
+NS_IMETHODIMP
+nsHTMLEditor::TypedText(const nsAString& aString, ETypingAction aAction)
+{
+  nsAutoPlaceHolderBatch batch(this, nsGkAtoms::TypingTxnName);
+
+  if (aAction == eTypedBR) {
+    // only inserts a br node
+    nsCOMPtr<nsIDOMNode> brNode;
+    return InsertBR(address_of(brNode));
+  }
+
+  return nsPlaintextEditor::TypedText(aString, aAction);
+}
+
+NS_IMETHODIMP nsHTMLEditor::TabInTable(bool inIsShift, bool *outHandled)
+{
+  NS_ENSURE_TRUE(outHandled, NS_ERROR_NULL_POINTER);
+  *outHandled = false;
+
+  // Find enclosing table cell from the selection (cell may be the selected element)
+  nsCOMPtr<nsIDOMElement> cellElement;
+    // can't use |NS_LITERAL_STRING| here until |GetElementOrParentByTagName| is fixed to accept readables
+  nsresult res = GetElementOrParentByTagName(NS_LITERAL_STRING("td"), nullptr, getter_AddRefs(cellElement));
+  NS_ENSURE_SUCCESS(res, res);
+  // Do nothing -- we didn't find a table cell
+  NS_ENSURE_TRUE(cellElement, NS_OK);
+
+  // find enclosing table
+  nsCOMPtr<nsIDOMNode> tbl = GetEnclosingTable(cellElement);
+  NS_ENSURE_TRUE(tbl, res);
+
+  // advance to next cell
+  // first create an iterator over the table
+  nsCOMPtr<nsIContentIterator> iter =
+      do_CreateInstance("@mozilla.org/content/post-content-iterator;1", &res);
+  NS_ENSURE_SUCCESS(res, res);
+  NS_ENSURE_TRUE(iter, NS_ERROR_NULL_POINTER);
+  nsCOMPtr<nsIContent> cTbl = do_QueryInterface(tbl);
+  nsCOMPtr<nsIContent> cBlock = do_QueryInterface(cellElement);
+  res = iter->Init(cTbl);
+  NS_ENSURE_SUCCESS(res, res);
+  // position iter at block
+  res = iter->PositionAt(cBlock);
+  NS_ENSURE_SUCCESS(res, res);
+
+  nsCOMPtr<nsIDOMNode> node;
+  do
+  {
+    if (inIsShift)
+      iter->Prev();
+    else
+      iter->Next();
+
+    node = do_QueryInterface(iter->GetCurrentNode());
+
+    if (node && nsHTMLEditUtils::IsTableCell(node) &&
+        GetEnclosingTable(node) == tbl)
+    {
+      res = CollapseSelectionToDeepestNonTableFirstChild(nullptr, node);
+      NS_ENSURE_SUCCESS(res, res);
+      *outHandled = true;
+      return NS_OK;
+    }
+  } while (!iter->IsDone());
+  
+  if (!(*outHandled) && !inIsShift)
+  {
+    // if we havent handled it yet then we must have run off the end of
+    // the table.  Insert a new row.
+    res = InsertTableRow(1, true);
+    NS_ENSURE_SUCCESS(res, res);
+    *outHandled = true;
+    // put selection in right place
+    // Use table code to get selection and index to new row...
+    nsCOMPtr<nsISelection>selection;
+    nsCOMPtr<nsIDOMElement> tblElement;
+    nsCOMPtr<nsIDOMElement> cell;
+    int32_t row;
+    res = GetCellContext(getter_AddRefs(selection), 
+                         getter_AddRefs(tblElement),
+                         getter_AddRefs(cell), 
+                         nullptr, nullptr,
+                         &row, nullptr);
+    NS_ENSURE_SUCCESS(res, res);
+    // ...so that we can ask for first cell in that row...
+    res = GetCellAt(tblElement, row, 0, getter_AddRefs(cell));
+    NS_ENSURE_SUCCESS(res, res);
+    // ...and then set selection there.
+    // (Note that normally you should use CollapseSelectionToDeepestNonTableFirstChild(),
+    //  but we know cell is an empty new cell, so this works fine)
+    node = do_QueryInterface(cell);
+    if (node) selection->Collapse(node,0);
+    return NS_OK;
+  }
+  
+  return res;
+}
+
+NS_IMETHODIMP nsHTMLEditor::CreateBR(nsIDOMNode *aNode, int32_t aOffset, nsCOMPtr<nsIDOMNode> *outBRNode, EDirection aSelect)
+{
+  nsCOMPtr<nsIDOMNode> parent = aNode;
+  int32_t offset = aOffset;
+  return CreateBRImpl(address_of(parent), &offset, outBRNode, aSelect);
+}
+
+nsresult 
+nsHTMLEditor::CollapseSelectionToDeepestNonTableFirstChild(nsISelection *aSelection, nsIDOMNode *aNode)
+{
+  NS_ENSURE_TRUE(aNode, NS_ERROR_NULL_POINTER);
+  nsresult res;
+
+  nsCOMPtr<nsISelection> selection;
+  if (aSelection)
+  {
+    selection = aSelection;
+  } else {
+    res = GetSelection(getter_AddRefs(selection));
+    NS_ENSURE_SUCCESS(res, res);
+    NS_ENSURE_TRUE(selection, NS_ERROR_FAILURE);
+  }
+  nsCOMPtr<nsIDOMNode> node = aNode;
+  nsCOMPtr<nsIDOMNode> child;
+  
+  do {
+    node->GetFirstChild(getter_AddRefs(child));
+    
+    if (child)
+    {
+      // Stop if we find a table
+      // don't want to go into nested tables
+      if (nsHTMLEditUtils::IsTable(child)) break;
+      // hey, it'g gotta be a container too!
+      if (!IsContainer(child)) break;
+      node = child;
+    }
+  }
+  while (child);
+
+  selection->Collapse(node,0);
+  return NS_OK;
+}
+
+
+// This is mostly like InsertHTMLWithCharsetAndContext, 
+//  but we can't use that because it is selection-based and 
+//  the rules code won't let us edit under the <head> node
+NS_IMETHODIMP
+nsHTMLEditor::ReplaceHeadContentsWithHTML(const nsAString& aSourceToInsert)
+{
+  nsAutoRules beginRulesSniffing(this, EditAction::ignore, nsIEditor::eNone); // don't do any post processing, rules get confused
+  nsCOMPtr<nsISelection> selection;
+  nsresult res = GetSelection(getter_AddRefs(selection));
+  NS_ENSURE_SUCCESS(res, res);
+  NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
+
+  ForceCompositionEnd();
+
+  // Do not use nsAutoRules -- rules code won't let us insert in <head>
+  // Use the head node as a parent and delete/insert directly
+  nsCOMPtr<nsIDOMDocument> doc = do_QueryReferent(mDocWeak);
+  NS_ENSURE_TRUE(doc, NS_ERROR_NOT_INITIALIZED);
+
+  nsCOMPtr<nsIDOMNodeList>nodeList; 
+  res = doc->GetElementsByTagName(NS_LITERAL_STRING("head"), getter_AddRefs(nodeList));
+  NS_ENSURE_SUCCESS(res, res);
+  NS_ENSURE_TRUE(nodeList, NS_ERROR_NULL_POINTER);
+
+  uint32_t count; 
+  nodeList->GetLength(&count);
+  if (count < 1) return NS_ERROR_FAILURE;
+
+  nsCOMPtr<nsIDOMNode> headNode;
+  res = nodeList->Item(0, getter_AddRefs(headNode)); 
+  NS_ENSURE_SUCCESS(res, res);
+  NS_ENSURE_TRUE(headNode, NS_ERROR_NULL_POINTER);
+
+  // First, make sure there are no return chars in the source.
+  // Bad things happen if you insert returns (instead of dom newlines, \n)
+  // into an editor document.
+  nsAutoString inputString (aSourceToInsert);  // hope this does copy-on-write
+ 
+  // Windows linebreaks: Map CRLF to LF:
+  inputString.ReplaceSubstring(MOZ_UTF16("\r\n"),
+                               MOZ_UTF16("\n"));
+ 
+  // Mac linebreaks: Map any remaining CR to LF:
+  inputString.ReplaceSubstring(MOZ_UTF16("\r"),
+                               MOZ_UTF16("\n"));
+
+  nsAutoEditBatch beginBatching(this);
+
+  res = GetSelection(getter_AddRefs(selection));
+  NS_ENSURE_SUCCESS(res, res);
+  NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
+
+  // Get the first range in the selection, for context:
+  nsCOMPtr<nsIDOMRange> range;
+  res = selection->GetRangeAt(0, getter_AddRefs(range));
+  NS_ENSURE_SUCCESS(res, res);
+
+  nsCOMPtr<nsIDOMDocumentFragment> docfrag;
+  res = range->CreateContextualFragment(inputString,
+                                        getter_AddRefs(docfrag));
+
+  //XXXX BUG 50965: This is not returning the text between <title> ... </title>
+  // Special code is needed in JS to handle title anyway, so it really doesn't matter!
+
+  if (NS_FAILED(res))
+  {
+#ifdef DEBUG
+    printf("Couldn't create contextual fragment: error was %X\n",
+           static_cast<uint32_t>(res));
+#endif
+    return res;
+  }
+  NS_ENSURE_TRUE(docfrag, NS_ERROR_NULL_POINTER);
+
+  nsCOMPtr<nsIDOMNode> child;
+
+  // First delete all children in head
+  do {
+    res = headNode->GetFirstChild(getter_AddRefs(child));
+    NS_ENSURE_SUCCESS(res, res);
+    if (child)
+    {
+      res = DeleteNode(child);
+      NS_ENSURE_SUCCESS(res, res);
+    }
+  } while (child);
+
+  // Now insert the new nodes
+  int32_t offsetOfNewNode = 0;
+  nsCOMPtr<nsIDOMNode> fragmentAsNode (do_QueryInterface(docfrag));
+
+  // Loop over the contents of the fragment and move into the document
+  do {
+    res = fragmentAsNode->GetFirstChild(getter_AddRefs(child));
+    NS_ENSURE_SUCCESS(res, res);
+    if (child)
+    {
+      res = InsertNode(child, headNode, offsetOfNewNode++);
+      NS_ENSURE_SUCCESS(res, res);
+    }
+  } while (child);
+
+  return res;
+}
+
+NS_IMETHODIMP
+nsHTMLEditor::RebuildDocumentFromSource(const nsAString& aSourceString)
+{
+  ForceCompositionEnd();
+
+  nsCOMPtr<nsISelection>selection;
+  nsresult res = GetSelection(getter_AddRefs(selection));
+  NS_ENSURE_SUCCESS(res, res);
+
+  nsCOMPtr<nsIDOMElement> bodyElement = do_QueryInterface(GetRoot());
+  NS_ENSURE_TRUE(bodyElement, NS_ERROR_NULL_POINTER);
+
+  // Find where the <body> tag starts.
+  nsReadingIterator<char16_t> beginbody;
+  nsReadingIterator<char16_t> endbody;
+  aSourceString.BeginReading(beginbody);
+  aSourceString.EndReading(endbody);
+  bool foundbody = CaseInsensitiveFindInReadable(NS_LITERAL_STRING("<body"),
+                                                   beginbody, endbody);
+
+  nsReadingIterator<char16_t> beginhead;
+  nsReadingIterator<char16_t> endhead;
+  aSourceString.BeginReading(beginhead);
+  aSourceString.EndReading(endhead);
+  bool foundhead = CaseInsensitiveFindInReadable(NS_LITERAL_STRING("<head"),
+                                                   beginhead, endhead);
+  // a valid head appears before the body
+  if (foundbody && beginhead.get() > beginbody.get())
+    foundhead = false;
+
+  nsReadingIterator<char16_t> beginclosehead;
+  nsReadingIterator<char16_t> endclosehead;
+  aSourceString.BeginReading(beginclosehead);
+  aSourceString.EndReading(endclosehead);
+
+  // Find the index after "<head>"
+  bool foundclosehead = CaseInsensitiveFindInReadable(
+           NS_LITERAL_STRING("</head>"), beginclosehead, endclosehead);
+  // a valid close head appears after a found head
+  if (foundhead && beginhead.get() > beginclosehead.get())
+    foundclosehead = false;
+  // a valid close head appears before a found body
+  if (foundbody && beginclosehead.get() > beginbody.get())
+    foundclosehead = false;
+  
+  // Time to change the document
+  nsAutoEditBatch beginBatching(this);
+
+  nsReadingIterator<char16_t> endtotal;
+  aSourceString.EndReading(endtotal);
+
+  if (foundhead) {
+    if (foundclosehead)
+      res = ReplaceHeadContentsWithHTML(Substring(beginhead, beginclosehead));
+    else if (foundbody)
+      res = ReplaceHeadContentsWithHTML(Substring(beginhead, beginbody));
+    else
+      // XXX Without recourse to some parser/content sink/docshell hackery
+      // we don't really know where the head ends and the body begins
+      // so we assume that there is no body
+      res = ReplaceHeadContentsWithHTML(Substring(beginhead, endtotal));
+  } else {
+    nsReadingIterator<char16_t> begintotal;
+    aSourceString.BeginReading(begintotal);
+    NS_NAMED_LITERAL_STRING(head, "<head>");
+    if (foundclosehead)
+      res = ReplaceHeadContentsWithHTML(head + Substring(begintotal, beginclosehead));
+    else if (foundbody)
+      res = ReplaceHeadContentsWithHTML(head + Substring(begintotal, beginbody));
+    else
+      // XXX Without recourse to some parser/content sink/docshell hackery
+      // we don't really know where the head ends and the body begins
+      // so we assume that there is no head
+      res = ReplaceHeadContentsWithHTML(head);
+  }
+  NS_ENSURE_SUCCESS(res, res);
+
+  res = SelectAll();
+  NS_ENSURE_SUCCESS(res, res);
+
+  if (!foundbody) {
+    NS_NAMED_LITERAL_STRING(body, "<body>");
+    // XXX Without recourse to some parser/content sink/docshell hackery
+    // we don't really know where the head ends and the body begins
+    if (foundclosehead) // assume body starts after the head ends
+      res = LoadHTML(body + Substring(endclosehead, endtotal));
+    else if (foundhead) // assume there is no body
+      res = LoadHTML(body);
+    else // assume there is no head, the entire source is body
+      res = LoadHTML(body + aSourceString);
+    NS_ENSURE_SUCCESS(res, res);
+
+    nsCOMPtr<nsIDOMElement> divElement;
+    res = CreateElementWithDefaults(NS_LITERAL_STRING("div"), getter_AddRefs(divElement));
+    NS_ENSURE_SUCCESS(res, res);
+
+    res = CloneAttributes(bodyElement, divElement);
+    NS_ENSURE_SUCCESS(res, res);
+
+    return BeginningOfDocument();
+  }
+
+  res = LoadHTML(Substring(beginbody, endtotal));
+  NS_ENSURE_SUCCESS(res, res);
+
+  // Now we must copy attributes user might have edited on the <body> tag
+  //  because InsertHTML (actually, CreateContextualFragment()) 
+  //  will never return a body node in the DOM fragment
+  
+  // We already know where "<body" begins
+  nsReadingIterator<char16_t> beginclosebody = beginbody;
+  nsReadingIterator<char16_t> endclosebody;
+  aSourceString.EndReading(endclosebody);
+  if (!FindInReadable(NS_LITERAL_STRING(">"),beginclosebody,endclosebody))
+    return NS_ERROR_FAILURE;
+
+  // Truncate at the end of the body tag
+  // Kludge of the year: fool the parser by replacing "body" with "div" so we get a node
+  nsAutoString bodyTag;
+  bodyTag.AssignLiteral("<div ");
+  bodyTag.Append(Substring(endbody, endclosebody));
+
+  nsCOMPtr<nsIDOMRange> range;
+  res = selection->GetRangeAt(0, getter_AddRefs(range));
+  NS_ENSURE_SUCCESS(res, res);
+
+  nsCOMPtr<nsIDOMDocumentFragment> docfrag;
+  res = range->CreateContextualFragment(bodyTag, getter_AddRefs(docfrag));
+  NS_ENSURE_SUCCESS(res, res);
+
+  nsCOMPtr<nsIDOMNode> fragmentAsNode (do_QueryInterface(docfrag));
+  NS_ENSURE_TRUE(fragmentAsNode, NS_ERROR_NULL_POINTER);
+  
+  nsCOMPtr<nsIDOMNode> child;
+  res = fragmentAsNode->GetFirstChild(getter_AddRefs(child));
+  NS_ENSURE_SUCCESS(res, res);
+  NS_ENSURE_TRUE(child, NS_ERROR_NULL_POINTER);
+  
+  // Copy all attributes from the div child to current body element
+  res = CloneAttributes(bodyElement, child);
+  NS_ENSURE_SUCCESS(res, res);
+  
+  // place selection at first editable content
+  return BeginningOfDocument();
+}
+
+void
+nsHTMLEditor::NormalizeEOLInsertPosition(nsIDOMNode *firstNodeToInsert,
+                                     nsCOMPtr<nsIDOMNode> *insertParentNode,
+                                     int32_t *insertOffset)
+{
+  /*
+    This function will either correct the position passed in,
+    or leave the position unchanged.
+
+    When the (first) item to insert is a block level element, 
+    and our insertion position is after the last visible item in a line, 
+    i.e. the insertion position is just before a visible line break <br>, 
+    we want to skip to the position just after the line break (see bug 68767)
+
+    However, our logic to detect whether we should skip or not
+    needs to be more clever.
+    We must not skip when the caret appears to be positioned at the beginning
+    of a block, in that case skipping the <br> would not insert the <br>
+    at the caret position, but after the current empty line.
+     
+    So we have several cases to test:
+     
+    1) We only ever want to skip, if the next visible thing after the current position is a break
+     
+    2) We do not want to skip if there is no previous visible thing at all
+       That is detected if the call to PriorVisibleNode gives us an offset of zero.
+       Because PriorVisibleNode always positions after the prior node, we would
+       see an offset > 0, if there were a prior node.
+     
+    3) We do not want to skip, if both the next and the previous visible things are breaks.
+    
+    4) We do not want to skip if the previous visible thing is in a different block
+       than the insertion position.
+  */
+
+  if (!IsBlockNode(firstNodeToInsert))
+    return;
+
+  nsWSRunObject wsObj(this, *insertParentNode, *insertOffset);
+  nsCOMPtr<nsIDOMNode> nextVisNode;
+  nsCOMPtr<nsIDOMNode> prevVisNode;
+  int32_t nextVisOffset=0;
+  WSType nextVisType;
+  int32_t prevVisOffset=0;
+  WSType prevVisType;
+
+  wsObj.NextVisibleNode(*insertParentNode, *insertOffset, address_of(nextVisNode), &nextVisOffset, &nextVisType);
+  if (!nextVisNode)
+    return;
+
+  if (!(nextVisType & WSType::br)) {
+    return;
+  }
+
+  wsObj.PriorVisibleNode(*insertParentNode, *insertOffset, address_of(prevVisNode), &prevVisOffset, &prevVisType);
+  if (!prevVisNode)
+    return;
+
+  if (prevVisType & WSType::br) {
+    return;
+  }
+
+  if (prevVisType & WSType::thisBlock) {
+    return;
+  }
+
+  int32_t brOffset=0;
+  nsCOMPtr<nsIDOMNode> brNode = GetNodeLocation(nextVisNode, &brOffset);
+
+  *insertParentNode = brNode;
+  *insertOffset = brOffset + 1;
+}
+
+NS_IMETHODIMP
+nsHTMLEditor::InsertElementAtSelection(nsIDOMElement* aElement, bool aDeleteSelection)
+{
+  // Protect the edit rules object from dying
+  nsCOMPtr<nsIEditRules> kungFuDeathGrip(mRules);
+
+  nsresult res = NS_ERROR_NOT_INITIALIZED;
+  
+  NS_ENSURE_TRUE(aElement, NS_ERROR_NULL_POINTER);
+  
+  nsCOMPtr<nsIDOMNode> node = do_QueryInterface(aElement);
+  
+  ForceCompositionEnd();
+  nsAutoEditBatch beginBatching(this);
+  nsAutoRules beginRulesSniffing(this, EditAction::insertElement, nsIEditor::eNext);
+
+  nsRefPtr<Selection> selection = GetSelection();
+  if (!selection) {
+    return NS_ERROR_FAILURE;
+  }
+
+  // hand off to the rules system, see if it has anything to say about this
+  bool cancel, handled;
+  nsTextRulesInfo ruleInfo(EditAction::insertElement);
+  ruleInfo.insertElement = aElement;
+  res = mRules->WillDoAction(selection, &ruleInfo, &cancel, &handled);
+  if (cancel || (NS_FAILED(res))) return res;
+
+  if (!handled)
+  {
+    if (aDeleteSelection)
+    {
+      if (!IsBlockNode(aElement)) {
+        // E.g., inserting an image.  In this case we don't need to delete any
+        // inline wrappers before we do the insertion.  Otherwise we let
+        // DeleteSelectionAndPrepareToCreateNode do the deletion for us, which
+        // calls DeleteSelection with aStripWrappers = eStrip.
+        res = DeleteSelection(nsIEditor::eNone, nsIEditor::eNoStrip);
+        NS_ENSURE_SUCCESS(res, res);
+      }
+
+      nsresult result = DeleteSelectionAndPrepareToCreateNode();
+      NS_ENSURE_SUCCESS(result, result);
+    }
+
+    // If deleting, selection will be collapsed.
+    // so if not, we collapse it
+    if (!aDeleteSelection)
+    {
+      // Named Anchor is a special case,
+      // We collapse to insert element BEFORE the selection
+      // For all other tags, we insert AFTER the selection
+      if (nsHTMLEditUtils::IsNamedAnchor(node))
+      {
+        selection->CollapseToStart();
+      } else {
+        selection->CollapseToEnd();
+      }
+    }
+
+    nsCOMPtr<nsIDOMNode> parentSelectedNode;
+    int32_t offsetForInsert;
+    res = selection->GetAnchorNode(getter_AddRefs(parentSelectedNode));
+    // XXX: ERROR_HANDLING bad XPCOM usage
+    if (NS_SUCCEEDED(res) && NS_SUCCEEDED(selection->GetAnchorOffset(&offsetForInsert)) && parentSelectedNode)
+    {
+#ifdef DEBUG_cmanske
+      {
+      nsAutoString name;
+      parentSelectedNode->GetNodeName(name);
+      printf("InsertElement: Anchor node of selection: ");
+      wprintf(name.get());
+      printf(" Offset: %d\n", offsetForInsert);
+      }
+#endif
+
+      // Adjust position based on the node we are going to insert.
+      NormalizeEOLInsertPosition(node, address_of(parentSelectedNode), &offsetForInsert);
+
+      res = InsertNodeAtPoint(node, address_of(parentSelectedNode), &offsetForInsert, false);
+      NS_ENSURE_SUCCESS(res, res);
+      // Set caret after element, but check for special case 
+      //  of inserting table-related elements: set in first cell instead
+      if (!SetCaretInTableCell(aElement))
+      {
+        res = SetCaretAfterElement(aElement);
+        NS_ENSURE_SUCCESS(res, res);
+      }
+      // check for inserting a whole table at the end of a block. If so insert a br after it.
+      if (nsHTMLEditUtils::IsTable(node))
+      {
+        bool isLast;
+        res = IsLastEditableChild(node, &isLast);
+        NS_ENSURE_SUCCESS(res, res);
+        if (isLast)
+        {
+          nsCOMPtr<nsIDOMNode> brNode;
+          res = CreateBR(parentSelectedNode, offsetForInsert+1, address_of(brNode));
+          NS_ENSURE_SUCCESS(res, res);
+          selection->Collapse(parentSelectedNode, offsetForInsert+1);
+        }
+      }
+    }
+  }
+  res = mRules->DidDoAction(selection, &ruleInfo, res);
+  return res;
+}
+
+
+/* 
+  InsertNodeAtPoint: attempts to insert aNode into the document, at a point specified by 
+      {*ioParent,*ioOffset}.  Checks with strict dtd to see if containment is allowed.  If not
+      allowed, will attempt to find a parent in the parent hierarchy of *ioParent that will
+      accept aNode as a child.  If such a parent is found, will split the document tree from
+      {*ioParent,*ioOffset} up to parent, and then insert aNode.  ioParent & ioOffset are then
+      adjusted to point to the actual location that aNode was inserted at.  aNoEmptyNodes
+      specifies if the splitting process is allowed to reslt in empty nodes.
+              nsIDOMNode            *aNode           node to insert
+              nsCOMPtr<nsIDOMNode>  *ioParent        insertion parent
+              int32_t               *ioOffset        insertion offset
+              bool                  aNoEmptyNodes    splitting can result in empty nodes?
+*/
+nsresult
+nsHTMLEditor::InsertNodeAtPoint(nsIDOMNode *aNode, 
+                                nsCOMPtr<nsIDOMNode> *ioParent, 
+                                int32_t *ioOffset, 
+                                bool aNoEmptyNodes)
+{
+  NS_ENSURE_TRUE(aNode, NS_ERROR_NULL_POINTER);
+  NS_ENSURE_TRUE(ioParent, NS_ERROR_NULL_POINTER);
+  NS_ENSURE_TRUE(*ioParent, NS_ERROR_NULL_POINTER);
+  NS_ENSURE_TRUE(ioOffset, NS_ERROR_NULL_POINTER);
+  
+  nsresult res = NS_OK;
+  nsCOMPtr<nsIDOMNode> parent = *ioParent;
+  nsCOMPtr<nsIDOMNode> topChild = *ioParent;
+  nsCOMPtr<nsIDOMNode> tmp;
+  int32_t offsetOfInsert = *ioOffset;
+   
+  // Search up the parent chain to find a suitable container      
+  while (!CanContain(parent, aNode)) {
+    // If the current parent is a root (body or table element)
+    // then go no further - we can't insert
+    if (nsTextEditUtils::IsBody(parent) || nsHTMLEditUtils::IsTableElement(parent))
+      return NS_ERROR_FAILURE;
+    // Get the next parent
+    parent->GetParentNode(getter_AddRefs(tmp));
+    NS_ENSURE_TRUE(tmp, NS_ERROR_FAILURE);
+    topChild = parent;
+    parent = tmp;
+  }
+  if (parent != topChild)
+  {
+    // we need to split some levels above the original selection parent
+    res = SplitNodeDeep(topChild, *ioParent, *ioOffset, &offsetOfInsert, aNoEmptyNodes);
+    NS_ENSURE_SUCCESS(res, res);
+    *ioParent = parent;
+    *ioOffset = offsetOfInsert;
+  }
+  // Now we can insert the new node
+  res = InsertNode(aNode, parent, offsetOfInsert);
+  return res;
+}
+
+NS_IMETHODIMP
+nsHTMLEditor::SelectElement(nsIDOMElement* aElement)
+{
+  nsresult res = NS_ERROR_NULL_POINTER;
+
+  // Must be sure that element is contained in the document body
+  if (IsDescendantOfEditorRoot(aElement)) {
+    nsCOMPtr<nsISelection> selection;
+    res = GetSelection(getter_AddRefs(selection));
+    NS_ENSURE_SUCCESS(res, res);
+    NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
+    nsCOMPtr<nsIDOMNode>parent;
+    res = aElement->GetParentNode(getter_AddRefs(parent));
+    if (NS_SUCCEEDED(res) && parent)
+    {
+      int32_t offsetInParent = GetChildOffset(aElement, parent);
+
+      // Collapse selection to just before desired element,
+      res = selection->Collapse(parent, offsetInParent);
+      if (NS_SUCCEEDED(res)) {
+        // then extend it to just after
+        res = selection->Extend(parent, offsetInParent + 1);
+      }
+    }
+  }
+  return res;
+}
+
+NS_IMETHODIMP
+nsHTMLEditor::SetCaretAfterElement(nsIDOMElement* aElement)
+{
+  nsresult res = NS_ERROR_NULL_POINTER;
+
+  // Be sure the element is contained in the document body
+  if (aElement && IsDescendantOfEditorRoot(aElement)) {
+    nsCOMPtr<nsISelection> selection;
+    res = GetSelection(getter_AddRefs(selection));
+    NS_ENSURE_SUCCESS(res, res);
+    NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
+    nsCOMPtr<nsIDOMNode>parent;
+    res = aElement->GetParentNode(getter_AddRefs(parent));
+    NS_ENSURE_SUCCESS(res, res);
+    NS_ENSURE_TRUE(parent, NS_ERROR_NULL_POINTER);
+    int32_t offsetInParent = GetChildOffset(aElement, parent);
+    // Collapse selection to just after desired element,
+    res = selection->Collapse(parent, offsetInParent + 1);
+  }
+  return res;
+}
+
+NS_IMETHODIMP 
+nsHTMLEditor::SetParagraphFormat(const nsAString& aParagraphFormat)
+{
+  nsAutoString tag; tag.Assign(aParagraphFormat);
+  ToLowerCase(tag);
+  if (tag.EqualsLiteral("dd") || tag.EqualsLiteral("dt"))
+    return MakeDefinitionItem(tag);
+  else
+    return InsertBasicBlock(tag);
+}
+
+NS_IMETHODIMP 
+nsHTMLEditor::GetParagraphState(bool *aMixed, nsAString &outFormat)
+{
+  if (!mRules) { return NS_ERROR_NOT_INITIALIZED; }
+  NS_ENSURE_TRUE(aMixed, NS_ERROR_NULL_POINTER);
+  nsRefPtr<nsHTMLEditRules> htmlRules = static_cast<nsHTMLEditRules*>(mRules.get());
+  
+  return htmlRules->GetParagraphState(aMixed, outFormat);
+}
+
+NS_IMETHODIMP
+nsHTMLEditor::GetBackgroundColorState(bool *aMixed, nsAString &aOutColor)
+{
+  nsresult res;
+  if (IsCSSEnabled()) {
+    // if we are in CSS mode, we have to check if the containing block defines
+    // a background color
+    res = GetCSSBackgroundColorState(aMixed, aOutColor, true);
+  }
+  else {
+    // in HTML mode, we look only at page's background
+    res = GetHTMLBackgroundColorState(aMixed, aOutColor);
+  }
+  return res;
+}
+
+NS_IMETHODIMP
+nsHTMLEditor::GetHighlightColorState(bool *aMixed, nsAString &aOutColor)
+{
+  nsresult res = NS_OK;
+  *aMixed = false;
+  aOutColor.AssignLiteral("transparent");
+  if (IsCSSEnabled()) {
+    // in CSS mode, text background can be added by the Text Highlight button
+    // we need to query the background of the selection without looking for
+    // the block container of the ranges in the selection
+    res = GetCSSBackgroundColorState(aMixed, aOutColor, false);
+  }
+  return res;
+}
+
+nsresult
+nsHTMLEditor::GetCSSBackgroundColorState(bool *aMixed, nsAString &aOutColor, bool aBlockLevel)
+{
+  NS_ENSURE_TRUE(aMixed, NS_ERROR_NULL_POINTER);
+  *aMixed = false;
+  // the default background color is transparent
+  aOutColor.AssignLiteral("transparent");
+  
+  // get selection
+  nsCOMPtr<nsISelection>selection;
+  nsresult res = GetSelection(getter_AddRefs(selection));
+  NS_ENSURE_SUCCESS(res, res);
+
+  // get selection location
+  nsCOMPtr<nsIDOMNode> parent;
+  int32_t offset;
+  res = GetStartNodeAndOffset(selection, getter_AddRefs(parent), &offset);
+  NS_ENSURE_SUCCESS(res, res);
+  NS_ENSURE_TRUE(parent, NS_ERROR_NULL_POINTER);
+
+  // is the selection collapsed?
+  nsCOMPtr<nsIDOMNode> nodeToExamine;
+  if (selection->Collapsed() || IsTextNode(parent)) {
+    // we want to look at the parent and ancestors
+    nodeToExamine = parent;
+  } else {
+    // otherwise we want to look at the first editable node after
+    // {parent,offset} and its ancestors for divs with alignment on them
+    nodeToExamine = GetChildAt(parent, offset);
+    //GetNextNode(parent, offset, true, address_of(nodeToExamine));
+  }
+  
+  NS_ENSURE_TRUE(nodeToExamine, NS_ERROR_NULL_POINTER);
+
+  // is the node to examine a block ?
+  bool isBlock;
+  res = NodeIsBlockStatic(nodeToExamine, &isBlock);
+  NS_ENSURE_SUCCESS(res, res);
+
+  nsCOMPtr<nsIDOMNode> tmp;
+
+  if (aBlockLevel) {
+    // we are querying the block background (and not the text background), let's
+    // climb to the block container
+    nsCOMPtr<nsIDOMNode> blockParent = nodeToExamine;
+    if (!isBlock) {
+      blockParent = GetBlockNodeParent(nodeToExamine);
+      NS_ENSURE_TRUE(blockParent, NS_OK);
+    }
+
+    // Make sure to not walk off onto the Document node
+    nsCOMPtr<nsIDOMElement> element;
+    do {
+      // retrieve the computed style of background-color for blockParent
+      mHTMLCSSUtils->GetComputedProperty(blockParent,
+                                         nsEditProperty::cssBackgroundColor,
+                                         aOutColor);
+      tmp.swap(blockParent);
+      res = tmp->GetParentNode(getter_AddRefs(blockParent));
+      element = do_QueryInterface(blockParent);
+      // look at parent if the queried color is transparent and if the node to
+      // examine is not the root of the document
+    } while (aOutColor.EqualsLiteral("transparent") && element);
+    if (aOutColor.EqualsLiteral("transparent")) {
+      // we have hit the root of the document and the color is still transparent !
+      // Grumble... Let's look at the default background color because that's the
+      // color we are looking for
+      mHTMLCSSUtils->GetDefaultBackgroundColor(aOutColor);
+    }
+  }
+  else {
+    // no, we are querying the text background for the Text Highlight button
+    if (IsTextNode(nodeToExamine)) {
+      // if the node of interest is a text node, let's climb a level
+      res = nodeToExamine->GetParentNode(getter_AddRefs(parent));
+      NS_ENSURE_SUCCESS(res, res);
+      nodeToExamine = parent;
+    }
+    do {
+      // is the node to examine a block ?
+      res = NodeIsBlockStatic(nodeToExamine, &isBlock);
+      NS_ENSURE_SUCCESS(res, res);
+      if (isBlock) {
+        // yes it is a block; in that case, the text background color is transparent
+        aOutColor.AssignLiteral("transparent");
+        break;
+      }
+      else {
+        // no, it's not; let's retrieve the computed style of background-color for the
+        // node to examine
+        mHTMLCSSUtils->GetComputedProperty(nodeToExamine, nsEditProperty::cssBackgroundColor,
+                            aOutColor);
+        if (!aOutColor.EqualsLiteral("transparent")) {
+          break;
+        }
+      }
+      tmp.swap(nodeToExamine);
+      res = tmp->GetParentNode(getter_AddRefs(nodeToExamine));
+      NS_ENSURE_SUCCESS(res, res);
+    } while ( aOutColor.EqualsLiteral("transparent") && nodeToExamine );
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP 
+nsHTMLEditor::GetHTMLBackgroundColorState(bool *aMixed, nsAString &aOutColor)
+{
+  //TODO: We don't handle "mixed" correctly!
+  NS_ENSURE_TRUE(aMixed, NS_ERROR_NULL_POINTER);
+  *aMixed = false;
+  aOutColor.Truncate();
+  
+  nsCOMPtr<nsIDOMElement> domElement;
+  int32_t selectedCount;
+  nsAutoString tagName;
+  nsresult res = GetSelectedOrParentTableElement(tagName,
+                                                 &selectedCount,
+                                                 getter_AddRefs(domElement));
+  NS_ENSURE_SUCCESS(res, res);
+
+  nsCOMPtr<dom::Element> element = do_QueryInterface(domElement);
+
+  while (element) {
+    // We are in a cell or selected table
+    element->GetAttr(kNameSpaceID_None, nsGkAtoms::bgcolor, aOutColor);
+
+    // Done if we have a color explicitly set
+    if (!aOutColor.IsEmpty()) {
+      return NS_OK;
+    }
+
+    // Once we hit the body, we're done
+    if (element->IsHTML(nsGkAtoms::body)) {
+      return NS_OK;
+    }
+
+    // No color is set, but we need to report visible color inherited 
+    // from nested cells/tables, so search up parent chain
+    element = element->GetParentElement();
+  }
+
+  // If no table or cell found, get page body
+  dom::Element* bodyElement = GetRoot();
+  NS_ENSURE_TRUE(bodyElement, NS_ERROR_NULL_POINTER);
+
+  bodyElement->GetAttr(kNameSpaceID_None, nsGkAtoms::bgcolor, aOutColor);
+  return NS_OK;
+}
+
+NS_IMETHODIMP 
+nsHTMLEditor::GetListState(bool *aMixed, bool *aOL, bool *aUL, bool *aDL)
+{
+  if (!mRules) { return NS_ERROR_NOT_INITIALIZED; }
+  NS_ENSURE_TRUE(aMixed && aOL && aUL && aDL, NS_ERROR_NULL_POINTER);
+  nsRefPtr<nsHTMLEditRules> htmlRules = static_cast<nsHTMLEditRules*>(mRules.get());
+  
+  return htmlRules->GetListState(aMixed, aOL, aUL, aDL);
+}
+
+NS_IMETHODIMP 
+nsHTMLEditor::GetListItemState(bool *aMixed, bool *aLI, bool *aDT, bool *aDD)
+{
+  if (!mRules) { return NS_ERROR_NOT_INITIALIZED; }
+  NS_ENSURE_TRUE(aMixed && aLI && aDT && aDD, NS_ERROR_NULL_POINTER);
+
+  nsRefPtr<nsHTMLEditRules> htmlRules = static_cast<nsHTMLEditRules*>(mRules.get());
+  
+  return htmlRules->GetListItemState(aMixed, aLI, aDT, aDD);
+}
+
+NS_IMETHODIMP
+nsHTMLEditor::GetAlignment(bool *aMixed, nsIHTMLEditor::EAlignment *aAlign)
+{
+  if (!mRules) { return NS_ERROR_NOT_INITIALIZED; }
+  NS_ENSURE_TRUE(aMixed && aAlign, NS_ERROR_NULL_POINTER);
+  nsRefPtr<nsHTMLEditRules> htmlRules = static_cast<nsHTMLEditRules*>(mRules.get());
+  
+  return htmlRules->GetAlignment(aMixed, aAlign);
+}
+
+
+NS_IMETHODIMP 
+nsHTMLEditor::GetIndentState(bool *aCanIndent, bool *aCanOutdent)
+{
+  if (!mRules) { return NS_ERROR_NOT_INITIALIZED; }
+  NS_ENSURE_TRUE(aCanIndent && aCanOutdent, NS_ERROR_NULL_POINTER);
+
+  nsRefPtr<nsHTMLEditRules> htmlRules = static_cast<nsHTMLEditRules*>(mRules.get());
+  
+  return htmlRules->GetIndentState(aCanIndent, aCanOutdent);
+}
+
+NS_IMETHODIMP
+nsHTMLEditor::MakeOrChangeList(const nsAString& aListType, bool entireList, const nsAString& aBulletType)
+{
+  nsresult res;
+  if (!mRules) { return NS_ERROR_NOT_INITIALIZED; }
+
+  // Protect the edit rules object from dying
+  nsCOMPtr<nsIEditRules> kungFuDeathGrip(mRules);
+
+  bool cancel, handled;
+
+  nsAutoEditBatch beginBatching(this);
+  nsAutoRules beginRulesSniffing(this, EditAction::makeList, nsIEditor::eNext);
+  
+  // pre-process
+  nsRefPtr<Selection> selection = GetSelection();
+  NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
+
+  nsTextRulesInfo ruleInfo(EditAction::makeList);
+  ruleInfo.blockType = &aListType;
+  ruleInfo.entireList = entireList;
+  ruleInfo.bulletType = &aBulletType;
+  res = mRules->WillDoAction(selection, &ruleInfo, &cancel, &handled);
+  if (cancel || (NS_FAILED(res))) return res;
+
+  if (!handled)
+  {
+    // Find out if the selection is collapsed:
+    bool isCollapsed = selection->Collapsed();
+
+    nsCOMPtr<nsIDOMNode> node;
+    int32_t offset;
+    res = GetStartNodeAndOffset(selection, getter_AddRefs(node), &offset);
+    if (!node) res = NS_ERROR_FAILURE;
+    NS_ENSURE_SUCCESS(res, res);
+  
+    if (isCollapsed)
+    {
+      // have to find a place to put the list
+      nsCOMPtr<nsIDOMNode> parent = node;
+      nsCOMPtr<nsIDOMNode> topChild = node;
+      nsCOMPtr<nsIDOMNode> tmp;
+    
+      nsCOMPtr<nsIAtom> listAtom = do_GetAtom(aListType);
+      while (!CanContainTag(parent, listAtom)) {
+        parent->GetParentNode(getter_AddRefs(tmp));
+        NS_ENSURE_TRUE(tmp, NS_ERROR_FAILURE);
+        topChild = parent;
+        parent = tmp;
+      }
+    
+      if (parent != node)
+      {
+        // we need to split up to the child of parent
+        res = SplitNodeDeep(topChild, node, offset, &offset);
+        NS_ENSURE_SUCCESS(res, res);
+      }
+
+      // make a list
+      nsCOMPtr<nsIDOMNode> newList;
+      res = CreateNode(aListType, parent, offset, getter_AddRefs(newList));
+      NS_ENSURE_SUCCESS(res, res);
+      // make a list item
+      nsCOMPtr<nsIDOMNode> newItem;
+      res = CreateNode(NS_LITERAL_STRING("li"), newList, 0, getter_AddRefs(newItem));
+      NS_ENSURE_SUCCESS(res, res);
+      res = selection->Collapse(newItem,0);
+      NS_ENSURE_SUCCESS(res, res);
+    }
+  }
+  
+  res = mRules->DidDoAction(selection, &ruleInfo, res);
+  return res;
+}
+
+
+NS_IMETHODIMP
+nsHTMLEditor::RemoveList(const nsAString& aListType)
+{
+  nsresult res;
+  if (!mRules) { return NS_ERROR_NOT_INITIALIZED; }
+
+  // Protect the edit rules object from dying
+  nsCOMPtr<nsIEditRules> kungFuDeathGrip(mRules);
+
+  bool cancel, handled;
+
+  nsAutoEditBatch beginBatching(this);
+  nsAutoRules beginRulesSniffing(this, EditAction::removeList, nsIEditor::eNext);
+  
+  // pre-process
+  nsRefPtr<Selection> selection = GetSelection();
+  NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
+
+  nsTextRulesInfo ruleInfo(EditAction::removeList);
+  if (aListType.LowerCaseEqualsLiteral("ol"))
+    ruleInfo.bOrdered = true;
+  else  ruleInfo.bOrdered = false;
+  res = mRules->WillDoAction(selection, &ruleInfo, &cancel, &handled);
+  if (cancel || (NS_FAILED(res))) return res;
+
+  // no default behavior for this yet.  what would it mean?
+
+  res = mRules->DidDoAction(selection, &ruleInfo, res);
+  return res;
+}
+
+nsresult
+nsHTMLEditor::MakeDefinitionItem(const nsAString& aItemType)
+{
+  nsresult res;
+  if (!mRules) { return NS_ERROR_NOT_INITIALIZED; }
+
+  // Protect the edit rules object from dying
+  nsCOMPtr<nsIEditRules> kungFuDeathGrip(mRules);
+
+  bool cancel, handled;
+
+  nsAutoEditBatch beginBatching(this);
+  nsAutoRules beginRulesSniffing(this, EditAction::makeDefListItem, nsIEditor::eNext);
+  
+  // pre-process
+  nsRefPtr<Selection> selection = GetSelection();
+  NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
+  nsTextRulesInfo ruleInfo(EditAction::makeDefListItem);
+  ruleInfo.blockType = &aItemType;
+  res = mRules->WillDoAction(selection, &ruleInfo, &cancel, &handled);
+  if (cancel || (NS_FAILED(res))) return res;
+
+  if (!handled)
+  {
+    // todo: no default for now.  we count on rules to handle it.
+  }
+
+  res = mRules->DidDoAction(selection, &ruleInfo, res);
+  return res;
+}
+
+nsresult
+nsHTMLEditor::InsertBasicBlock(const nsAString& aBlockType)
+{
+  nsresult res;
+  if (!mRules) { return NS_ERROR_NOT_INITIALIZED; }
+
+  // Protect the edit rules object from dying
+  nsCOMPtr<nsIEditRules> kungFuDeathGrip(mRules);
+
+  bool cancel, handled;
+
+  nsAutoEditBatch beginBatching(this);
+  nsAutoRules beginRulesSniffing(this, EditAction::makeBasicBlock, nsIEditor::eNext);
+  
+  // pre-process
+  nsRefPtr<Selection> selection = GetSelection();
+  NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
+  nsTextRulesInfo ruleInfo(EditAction::makeBasicBlock);
+  ruleInfo.blockType = &aBlockType;
+  res = mRules->WillDoAction(selection, &ruleInfo, &cancel, &handled);
+  if (cancel || (NS_FAILED(res))) return res;
+
+  if (!handled)
+  {
+    // Find out if the selection is collapsed:
+    bool isCollapsed = selection->Collapsed();
+
+    nsCOMPtr<nsIDOMNode> node;
+    int32_t offset;
+    res = GetStartNodeAndOffset(selection, getter_AddRefs(node), &offset);
+    if (!node) res = NS_ERROR_FAILURE;
+    NS_ENSURE_SUCCESS(res, res);
+  
+    if (isCollapsed)
+    {
+      // have to find a place to put the block
+      nsCOMPtr<nsIDOMNode> parent = node;
+      nsCOMPtr<nsIDOMNode> topChild = node;
+      nsCOMPtr<nsIDOMNode> tmp;
+    
+      nsCOMPtr<nsIAtom> blockAtom = do_GetAtom(aBlockType);
+      while (!CanContainTag(parent, blockAtom)) {
+        parent->GetParentNode(getter_AddRefs(tmp));
+        NS_ENSURE_TRUE(tmp, NS_ERROR_FAILURE);
+        topChild = parent;
+        parent = tmp;
+      }
+    
+      if (parent != node)
+      {
+        // we need to split up to the child of parent
+        res = SplitNodeDeep(topChild, node, offset, &offset);
+        NS_ENSURE_SUCCESS(res, res);
+      }
+
+      // make a block
+      nsCOMPtr<nsIDOMNode> newBlock;
+      res = CreateNode(aBlockType, parent, offset, getter_AddRefs(newBlock));
+      NS_ENSURE_SUCCESS(res, res);
+    
+      // reposition selection to inside the block
+      res = selection->Collapse(newBlock,0);
+      NS_ENSURE_SUCCESS(res, res);  
+    }
+  }
+
+  res = mRules->DidDoAction(selection, &ruleInfo, res);
+  return res;
+}
+
+NS_IMETHODIMP
+nsHTMLEditor::Indent(const nsAString& aIndent)
+{
+  nsresult res;
+  if (!mRules) { return NS_ERROR_NOT_INITIALIZED; }
+
+  // Protect the edit rules object from dying
+  nsCOMPtr<nsIEditRules> kungFuDeathGrip(mRules);
+
+  bool cancel, handled;
+  EditAction opID = EditAction::indent;
+  if (aIndent.LowerCaseEqualsLiteral("outdent"))
+  {
+    opID = EditAction::outdent;
+  }
+  nsAutoEditBatch beginBatching(this);
+  nsAutoRules beginRulesSniffing(this, opID, nsIEditor::eNext);
+  
+  // pre-process
+  nsRefPtr<Selection> selection = GetSelection();
+  NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
+
+  nsTextRulesInfo ruleInfo(opID);
+  res = mRules->WillDoAction(selection, &ruleInfo, &cancel, &handled);
+  if (cancel || (NS_FAILED(res))) return res;
+  
+  if (!handled)
+  {
+    // Do default - insert a blockquote node if selection collapsed
+    nsCOMPtr<nsIDOMNode> node;
+    int32_t offset;
+    bool isCollapsed = selection->Collapsed();
+
+    res = GetStartNodeAndOffset(selection, getter_AddRefs(node), &offset);
+    if (!node) res = NS_ERROR_FAILURE;
+    NS_ENSURE_SUCCESS(res, res);
+  
+    if (aIndent.EqualsLiteral("indent"))
+    {
+      if (isCollapsed)
+      {
+        // have to find a place to put the blockquote
+        nsCOMPtr<nsIDOMNode> parent = node;
+        nsCOMPtr<nsIDOMNode> topChild = node;
+        nsCOMPtr<nsIDOMNode> tmp;
+        while (!CanContainTag(parent, nsGkAtoms::blockquote)) {
+          parent->GetParentNode(getter_AddRefs(tmp));
+          NS_ENSURE_TRUE(tmp, NS_ERROR_FAILURE);
+          topChild = parent;
+          parent = tmp;
+        }
+    
+        if (parent != node)
+        {
+          // we need to split up to the child of parent
+          res = SplitNodeDeep(topChild, node, offset, &offset);
+          NS_ENSURE_SUCCESS(res, res);
+        }
+
+        // make a blockquote
+        nsCOMPtr<nsIDOMNode> newBQ;
+        res = CreateNode(NS_LITERAL_STRING("blockquote"), parent, offset,
+                         getter_AddRefs(newBQ));
+        NS_ENSURE_SUCCESS(res, res);
+        // put a space in it so layout will draw the list item
+        res = selection->Collapse(newBQ,0);
+        NS_ENSURE_SUCCESS(res, res);
+        res = InsertText(NS_LITERAL_STRING(" "));
+        NS_ENSURE_SUCCESS(res, res);
+        // reposition selection to before the space character
+        res = GetStartNodeAndOffset(selection, getter_AddRefs(node), &offset);
+        NS_ENSURE_SUCCESS(res, res);
+        res = selection->Collapse(node,0);
+        NS_ENSURE_SUCCESS(res, res);
+      }
+    }
+  }
+  res = mRules->DidDoAction(selection, &ruleInfo, res);
+  return res;
+}
+
+//TODO: IMPLEMENT ALIGNMENT!
+
+NS_IMETHODIMP
+nsHTMLEditor::Align(const nsAString& aAlignType)
+{
+  // Protect the edit rules object from dying
+  nsCOMPtr<nsIEditRules> kungFuDeathGrip(mRules);
+
+  nsAutoEditBatch beginBatching(this);
+  nsAutoRules beginRulesSniffing(this, EditAction::align, nsIEditor::eNext);
+
+  nsCOMPtr<nsIDOMNode> node;
+  bool cancel, handled;
+  
+  // Find out if the selection is collapsed:
+  nsRefPtr<Selection> selection = GetSelection();
+  NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
+  nsTextRulesInfo ruleInfo(EditAction::align);
+  ruleInfo.alignType = &aAlignType;
+  nsresult res = mRules->WillDoAction(selection, &ruleInfo, &cancel, &handled);
+  if (cancel || NS_FAILED(res))
+    return res;
+  
+  res = mRules->DidDoAction(selection, &ruleInfo, res);
+  return res;
+}
+
+NS_IMETHODIMP
+nsHTMLEditor::GetElementOrParentByTagName(const nsAString& aTagName, nsIDOMNode *aNode, nsIDOMElement** aReturn)
+{
+  NS_ENSURE_TRUE(!aTagName.IsEmpty(), NS_ERROR_NULL_POINTER);
+  NS_ENSURE_TRUE(aReturn, NS_ERROR_NULL_POINTER);
+
+  nsCOMPtr<nsINode> current = do_QueryInterface(aNode);
+  if (!current) {
+    // If no node supplied, get it from anchor node of current selection
+    nsRefPtr<Selection> selection = GetSelection();
+    NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
+
+    nsCOMPtr<nsINode> anchorNode = selection->GetAnchorNode();
+    NS_ENSURE_TRUE(anchorNode, NS_ERROR_FAILURE);
+
+    // Try to get the actual selected node
+    if (anchorNode->HasChildNodes() && anchorNode->IsContent()) {
+      uint32_t offset = selection->AnchorOffset();
+      current = anchorNode->GetChildAt(offset);
+    }
+    // anchor node is probably a text node - just use that
+    if (!current) {
+      current = anchorNode;
+    }
+  }
+
+  nsCOMPtr<nsIDOMNode> currentNode = current->AsDOMNode();
+
+  nsAutoString TagName(aTagName);
+  ToLowerCase(TagName);
+  bool getLink = IsLinkTag(TagName);
+  bool getNamedAnchor = IsNamedAnchorTag(TagName);
+  if ( getLink || getNamedAnchor)
+  {
+    TagName.AssignLiteral("a");  
+  }
+  bool findTableCell = TagName.EqualsLiteral("td");
+  bool findList = TagName.EqualsLiteral("list");
+
+  // default is null - no element found
+  *aReturn = nullptr;
+  
+  nsCOMPtr<nsIDOMNode> parent;
+  bool bNodeFound = false;
+
+  while (true)
+  {
+    nsAutoString currentTagName; 
+    // Test if we have a link (an anchor with href set)
+    if ( (getLink && nsHTMLEditUtils::IsLink(currentNode)) ||
+         (getNamedAnchor && nsHTMLEditUtils::IsNamedAnchor(currentNode)) )
+    {
+      bNodeFound = true;
+      break;
+    } else {
+      if (findList)
+      {
+        // Match "ol", "ul", or "dl" for lists
+        if (nsHTMLEditUtils::IsList(currentNode))
+          goto NODE_FOUND;
+
+      } else if (findTableCell)
+      {
+        // Table cells are another special case:
+        // Match either "td" or "th" for them
+        if (nsHTMLEditUtils::IsTableCell(currentNode))
+          goto NODE_FOUND;
+
+      } else {
+        currentNode->GetNodeName(currentTagName);
+        if (currentTagName.Equals(TagName, nsCaseInsensitiveStringComparator()))
+        {
+NODE_FOUND:
+          bNodeFound = true;
+          break;
+        } 
+      }
+    }
+    // Search up the parent chain
+    // We should never fail because of root test below, but lets be safe
+    // XXX: ERROR_HANDLING error return code lost
+    if (NS_FAILED(currentNode->GetParentNode(getter_AddRefs(parent))) || !parent)
+      break;
+
+    // Stop searching if parent is a body tag
+    nsAutoString parentTagName;
+    parent->GetNodeName(parentTagName);
+    // Note: Originally used IsRoot to stop at table cells,
+    //  but that's too messy when you are trying to find the parent table
+    if(parentTagName.LowerCaseEqualsLiteral("body"))
+      break;
+
+    currentNode = parent;
+  }
+
+  if (!bNodeFound) {
+    return NS_EDITOR_ELEMENT_NOT_FOUND;
+  }
+
+  nsCOMPtr<nsIDOMElement> currentElement = do_QueryInterface(currentNode);
+  currentElement.forget(aReturn);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsHTMLEditor::GetSelectedElement(const nsAString& aTagName, nsIDOMElement** aReturn)
+{
+  NS_ENSURE_TRUE(aReturn , NS_ERROR_NULL_POINTER);
+  
+  // default is null - no element found
+  *aReturn = nullptr;
+  
+  // First look for a single element in selection
+  nsCOMPtr<nsISelection>selection;
+  nsresult res = GetSelection(getter_AddRefs(selection));
+  NS_ENSURE_SUCCESS(res, res);
+  NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
+  Selection* sel = static_cast<Selection*>(selection.get());
+
+  bool bNodeFound = false;
+  bool isCollapsed = selection->Collapsed();
+
+  nsAutoString domTagName;
+  nsAutoString TagName(aTagName);
+  ToLowerCase(TagName);
+  // Empty string indicates we should match any element tag
+  bool anyTag = (TagName.IsEmpty());
+  bool isLinkTag = IsLinkTag(TagName);
+  bool isNamedAnchorTag = IsNamedAnchorTag(TagName);
+  
+  nsCOMPtr<nsIDOMElement> selectedElement;
+  nsCOMPtr<nsIDOMRange> range;
+  res = selection->GetRangeAt(0, getter_AddRefs(range));
+  NS_ENSURE_SUCCESS(res, res);
+
+  nsCOMPtr<nsIDOMNode> startParent;
+  int32_t startOffset, endOffset;
+  res = range->GetStartContainer(getter_AddRefs(startParent));
+  NS_ENSURE_SUCCESS(res, res);
+  res = range->GetStartOffset(&startOffset);
+  NS_ENSURE_SUCCESS(res, res);
+
+  nsCOMPtr<nsIDOMNode> endParent;
+  res = range->GetEndContainer(getter_AddRefs(endParent));
+  NS_ENSURE_SUCCESS(res, res);
+  res = range->GetEndOffset(&endOffset);
+  NS_ENSURE_SUCCESS(res, res);
+
+  // Optimization for a single selected element
+  if (startParent && startParent == endParent && (endOffset-startOffset) == 1)
+  {
+    nsCOMPtr<nsIDOMNode> selectedNode = GetChildAt(startParent, startOffset);
+    NS_ENSURE_SUCCESS(res, NS_OK);
+    if (selectedNode)
+    {
+      selectedNode->GetNodeName(domTagName);
+      ToLowerCase(domTagName);
+
+      // Test for appropriate node type requested
+      if (anyTag || (TagName == domTagName) ||
+          (isLinkTag && nsHTMLEditUtils::IsLink(selectedNode)) ||
+          (isNamedAnchorTag && nsHTMLEditUtils::IsNamedAnchor(selectedNode)))
+      {
+        bNodeFound = true;
+        selectedElement = do_QueryInterface(selectedNode);
+      }
+    }
+  }
+
+  if (!bNodeFound)
+  {
+    if (isLinkTag)
+    {
+      // Link tag is a special case - we return the anchor node
+      //  found for any selection that is totally within a link,
+      //  included a collapsed selection (just a caret in a link)
+      nsCOMPtr<nsIDOMNode> anchorNode;
+      res = selection->GetAnchorNode(getter_AddRefs(anchorNode));
+      NS_ENSURE_SUCCESS(res, res);
+      int32_t anchorOffset = -1;
+      if (anchorNode)
+        selection->GetAnchorOffset(&anchorOffset);
+
+      nsCOMPtr<nsIDOMNode> focusNode;
+      res = selection->GetFocusNode(getter_AddRefs(focusNode));
+      NS_ENSURE_SUCCESS(res, res);
+      int32_t focusOffset = -1;
+      if (focusNode)
+        selection->GetFocusOffset(&focusOffset);
+
+      // Link node must be the same for both ends of selection
+      if (NS_SUCCEEDED(res) && anchorNode)
+      {
+        nsCOMPtr<nsIDOMElement> parentLinkOfAnchor;
+        res = GetElementOrParentByTagName(NS_LITERAL_STRING("href"), anchorNode, getter_AddRefs(parentLinkOfAnchor));
+        // XXX: ERROR_HANDLING  can parentLinkOfAnchor be null?
+        if (NS_SUCCEEDED(res) && parentLinkOfAnchor)
+        {
+          if (isCollapsed)
+          {
+            // We have just a caret in the link
+            bNodeFound = true;
+          } else if(focusNode) 
+          {  // Link node must be the same for both ends of selection
+            nsCOMPtr<nsIDOMElement> parentLinkOfFocus;
+            res = GetElementOrParentByTagName(NS_LITERAL_STRING("href"), focusNode, getter_AddRefs(parentLinkOfFocus));
+            if (NS_SUCCEEDED(res) && parentLinkOfFocus == parentLinkOfAnchor)
+              bNodeFound = true;
+          }
+
+          // We found a link node parent
+          if (bNodeFound) {
+            // GetElementOrParentByTagName addref'd this, so we don't need to do it here
+            *aReturn = parentLinkOfAnchor;
+            NS_IF_ADDREF(*aReturn);
+            return NS_OK;
+          }
+        }
+        else if (anchorOffset >= 0)  // Check if link node is the only thing selected
+        {
+          nsCOMPtr<nsIDOMNode> anchorChild;
+          anchorChild = GetChildAt(anchorNode,anchorOffset);
+          if (anchorChild && nsHTMLEditUtils::IsLink(anchorChild) && 
+              (anchorNode == focusNode) && focusOffset == (anchorOffset+1))
+          {
+            selectedElement = do_QueryInterface(anchorChild);
+            bNodeFound = true;
+          }
+        }
+      }
+    } 
+
+    if (!isCollapsed)   // Don't bother to examine selection if it is collapsed
+    {
+      nsRefPtr<nsRange> currange = sel->GetRangeAt(0);
+      if (currange) {
+        nsCOMPtr<nsIContentIterator> iter =
+          do_CreateInstance("@mozilla.org/content/post-content-iterator;1", &res);
+        NS_ENSURE_SUCCESS(res, res);
+
+        iter->Init(currange);
+        // loop through the content iterator for each content node
+        while (!iter->IsDone())
+        {
+          // Query interface to cast nsIContent to nsIDOMNode
+          //  then get tagType to compare to  aTagName
+          // Clone node of each desired type and append it to the aDomFrag
+          selectedElement = do_QueryInterface(iter->GetCurrentNode());
+          if (selectedElement)
+          {
+            // If we already found a node, then we have another element,
+            //  thus there's not just one element selected
+            if (bNodeFound)
+            {
+              bNodeFound = false;
+              break;
+            }
+
+            selectedElement->GetNodeName(domTagName);
+            ToLowerCase(domTagName);
+
+            if (anyTag)
+            {
+              // Get name of first selected element
+              selectedElement->GetTagName(TagName);
+              ToLowerCase(TagName);
+              anyTag = false;
+            }
+
+            // The "A" tag is a pain,
+            //  used for both link(href is set) and "Named Anchor"
+            nsCOMPtr<nsIDOMNode> selectedNode = do_QueryInterface(selectedElement);
+            if ( (isLinkTag && nsHTMLEditUtils::IsLink(selectedNode)) ||
+                (isNamedAnchorTag && nsHTMLEditUtils::IsNamedAnchor(selectedNode)) )
+            {
+              bNodeFound = true;
+            } else if (TagName == domTagName) { // All other tag names are handled here
+              bNodeFound = true;
+            }
+            if (!bNodeFound)
+            {
+              // Check if node we have is really part of the selection???
+              break;
+            }
+          }
+          iter->Next();
+        }
+      } else {
+        // Should never get here?
+        isCollapsed = true;
+        NS_WARNING("isCollapsed was FALSE, but no elements found in selection\n");
+      }
+    }
+  }
+  if (bNodeFound)
+  {
+    
+    *aReturn = selectedElement;
+    if (selectedElement)
+    {  
+      // Getters must addref
+      NS_ADDREF(*aReturn);
+    }
+  } 
+  else res = NS_EDITOR_ELEMENT_NOT_FOUND;
+
+  return res;
+}
+
+NS_IMETHODIMP
+nsHTMLEditor::CreateElementWithDefaults(const nsAString& aTagName, nsIDOMElement** aReturn)
+{
+  nsresult res=NS_ERROR_NOT_INITIALIZED;
+  if (aReturn)
+    *aReturn = nullptr;
+
+//  NS_ENSURE_TRUE(aTagName && aReturn, NS_ERROR_NULL_POINTER);
+  NS_ENSURE_TRUE(!aTagName.IsEmpty() && aReturn, NS_ERROR_NULL_POINTER);
+    
+  nsAutoString TagName(aTagName);
+  ToLowerCase(TagName);
+  nsAutoString realTagName;
+
+  if (IsLinkTag(TagName) || IsNamedAnchorTag(TagName))
+  {
+    realTagName.AssignLiteral("a");
+  } else {
+    realTagName = TagName;
+  }
+  //We don't use editor's CreateElement because we don't want to 
+  //  go through the transaction system
+
+  nsCOMPtr<nsIDOMElement>newElement;
+  nsCOMPtr<dom::Element> newContent;
+  nsCOMPtr<nsIDOMDocument> doc = do_QueryReferent(mDocWeak);
+  NS_ENSURE_TRUE(doc, NS_ERROR_NOT_INITIALIZED);
+
+  //new call to use instead to get proper HTML element, bug# 39919
+  res = CreateHTMLContent(realTagName, getter_AddRefs(newContent));
+  newElement = do_QueryInterface(newContent);
+  if (NS_FAILED(res) || !newElement)
+    return NS_ERROR_FAILURE;
+
+  // Mark the new element dirty, so it will be formatted
+  newElement->SetAttribute(NS_LITERAL_STRING("_moz_dirty"), EmptyString());
+
+  // Set default values for new elements
+  if (TagName.EqualsLiteral("table")) {
+    res = newElement->SetAttribute(NS_LITERAL_STRING("cellpadding"),NS_LITERAL_STRING("2"));
+    NS_ENSURE_SUCCESS(res, res);
+    res = newElement->SetAttribute(NS_LITERAL_STRING("cellspacing"),NS_LITERAL_STRING("2"));
+    NS_ENSURE_SUCCESS(res, res);
+    res = newElement->SetAttribute(NS_LITERAL_STRING("border"),NS_LITERAL_STRING("1"));
+  } else if (TagName.EqualsLiteral("td"))
+  {
+    res = SetAttributeOrEquivalent(newElement, NS_LITERAL_STRING("valign"),
+                                   NS_LITERAL_STRING("top"), true);
+  }
+  // ADD OTHER TAGS HERE
+
+  if (NS_SUCCEEDED(res))
+  {
+    *aReturn = newElement;
+    // Getters must addref
+    NS_ADDREF(*aReturn);
+  }
+
+  return res;
+}
+
+NS_IMETHODIMP
+nsHTMLEditor::InsertLinkAroundSelection(nsIDOMElement* aAnchorElement)
+{
+  NS_ENSURE_TRUE(aAnchorElement, NS_ERROR_NULL_POINTER);
+
+  // We must have a real selection
+  nsCOMPtr<nsISelection> selection;
+  nsresult res = GetSelection(getter_AddRefs(selection));
+  if (!selection)
+  {
+    res = NS_ERROR_NULL_POINTER;
+  }
+  NS_ENSURE_SUCCESS(res, res);
+  NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
+
+  if (selection->Collapsed()) {
+    NS_WARNING("InsertLinkAroundSelection called but there is no selection!!!");
+    return NS_OK;
+  }
+
+  // Be sure we were given an anchor element
+  nsCOMPtr<nsIDOMHTMLAnchorElement> anchor = do_QueryInterface(aAnchorElement);
+  if (!anchor) {
+    return NS_OK;
+  }
+
+  nsAutoString href;
+  res = anchor->GetHref(href);
+  NS_ENSURE_SUCCESS(res, res);
+  if (href.IsEmpty()) {
+    return NS_OK;
+  }
+
+  nsAutoEditBatch beginBatching(this);
+
+  // Set all attributes found on the supplied anchor element
+  nsCOMPtr<nsIDOMMozNamedAttrMap> attrMap;
+  aAnchorElement->GetAttributes(getter_AddRefs(attrMap));
+  NS_ENSURE_TRUE(attrMap, NS_ERROR_FAILURE);
+
+  uint32_t count;
+  attrMap->GetLength(&count);
+  nsAutoString name, value;
+
+  for (uint32_t i = 0; i < count; ++i) {
+    nsCOMPtr<nsIDOMAttr> attribute;
+    res = attrMap->Item(i, getter_AddRefs(attribute));
+    NS_ENSURE_SUCCESS(res, res);
+
+    if (attribute) {
+      // We must clear the string buffers
+      //   because GetName, GetValue appends to previous string!
+      name.Truncate();
+      value.Truncate();
+
+      res = attribute->GetName(name);
+      NS_ENSURE_SUCCESS(res, res);
+
+      res = attribute->GetValue(value);
+      NS_ENSURE_SUCCESS(res, res);
+
+      res = SetInlineProperty(nsEditProperty::a, name, value);
+      NS_ENSURE_SUCCESS(res, res);
+    }
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsHTMLEditor::SetHTMLBackgroundColor(const nsAString& aColor)
+{
+  NS_PRECONDITION(mDocWeak, "Missing Editor DOM Document");
+  
+  // Find a selected or enclosing table element to set background on
+  nsCOMPtr<nsIDOMElement> element;
+  int32_t selectedCount;
+  nsAutoString tagName;
+  nsresult res = GetSelectedOrParentTableElement(tagName, &selectedCount,
+                                                 getter_AddRefs(element));
+  NS_ENSURE_SUCCESS(res, res);
+
+  bool setColor = !aColor.IsEmpty();
+
+  NS_NAMED_LITERAL_STRING(bgcolor, "bgcolor");
+  if (element)
+  {
+    if (selectedCount > 0)
+    {
+      // Traverse all selected cells
+      nsCOMPtr<nsIDOMElement> cell;
+      res = GetFirstSelectedCell(nullptr, getter_AddRefs(cell));
+      if (NS_SUCCEEDED(res) && cell)
+      {
+        while(cell)
+        {
+          if (setColor)
+            res = SetAttribute(cell, bgcolor, aColor);
+          else
+            res = RemoveAttribute(cell, bgcolor);
+          if (NS_FAILED(res)) break;
+
+          GetNextSelectedCell(nullptr, getter_AddRefs(cell));
+        };
+        return res;
+      }
+    }
+    // If we failed to find a cell, fall through to use originally-found element
+  } else {
+    // No table element -- set the background color on the body tag
+    element = do_QueryInterface(GetRoot());
+    NS_ENSURE_TRUE(element, NS_ERROR_NULL_POINTER);
+  }
+  // Use the editor method that goes through the transaction system
+  if (setColor)
+    res = SetAttribute(element, bgcolor, aColor);
+  else
+    res = RemoveAttribute(element, bgcolor);
+
+  return res;
+}
+
+NS_IMETHODIMP nsHTMLEditor::SetBodyAttribute(const nsAString& aAttribute, const nsAString& aValue)
+{
+  // TODO: Check selection for Cell, Row, Column or table and do color on appropriate level
+
+  NS_ASSERTION(mDocWeak, "Missing Editor DOM Document");
+  
+  // Set the background color attribute on the body tag
+  nsCOMPtr<nsIDOMElement> bodyElement = do_QueryInterface(GetRoot());
+  NS_ENSURE_TRUE(bodyElement, NS_ERROR_NULL_POINTER);
+
+  // Use the editor method that goes through the transaction system
+  return SetAttribute(bodyElement, aAttribute, aValue);
+}
+
+NS_IMETHODIMP
+nsHTMLEditor::GetLinkedObjects(nsISupportsArray** aNodeList)
+{
+  NS_ENSURE_TRUE(aNodeList, NS_ERROR_NULL_POINTER);
+
+  nsresult res;
+
+  res = NS_NewISupportsArray(aNodeList);
+  NS_ENSURE_SUCCESS(res, res);
+  NS_ENSURE_TRUE(*aNodeList, NS_ERROR_NULL_POINTER);
+
+  nsCOMPtr<nsIContentIterator> iter =
+       do_CreateInstance("@mozilla.org/content/post-content-iterator;1", &res);
+  NS_ENSURE_TRUE(iter, NS_ERROR_NULL_POINTER);
+  if ((NS_SUCCEEDED(res)))
+  {
+    nsCOMPtr<nsIDocument> doc = GetDocument();
+    NS_ENSURE_TRUE(doc, NS_ERROR_UNEXPECTED);
+
+    iter->Init(doc->GetRootElement());
+
+    // loop through the content iterator for each content node
+    while (!iter->IsDone())
+    {
+      nsCOMPtr<nsIDOMNode> node (do_QueryInterface(iter->GetCurrentNode()));
+      if (node)
+      {
+        // Let nsURIRefObject make the hard decisions:
+        nsCOMPtr<nsIURIRefObject> refObject;
+        res = NS_NewHTMLURIRefObject(getter_AddRefs(refObject), node);
+        if (NS_SUCCEEDED(res))
+        {
+          nsCOMPtr<nsISupports> isupp (do_QueryInterface(refObject));
+
+          (*aNodeList)->AppendElement(isupp);
+        }
+      }
+      iter->Next();
+    }
+  }
+
+  return NS_OK;
+}
+
+
+NS_IMETHODIMP
+nsHTMLEditor::AddStyleSheet(const nsAString &aURL)
+{
+  // Enable existing sheet if already loaded.
+  if (EnableExistingStyleSheet(aURL))
+    return NS_OK;
+
+  // Lose the previously-loaded sheet so there's nothing to replace
+  // This pattern is different from Override methods because
+  //  we must wait to remove mLastStyleSheetURL and add new sheet
+  //  at the same time (in StyleSheetLoaded callback) so they are undoable together
+  mLastStyleSheetURL.Truncate();
+  return ReplaceStyleSheet(aURL);
+}
+
+NS_IMETHODIMP
+nsHTMLEditor::ReplaceStyleSheet(const nsAString& aURL)
+{
+  // Enable existing sheet if already loaded.
+  if (EnableExistingStyleSheet(aURL))
+  {
+    // Disable last sheet if not the same as new one
+    if (!mLastStyleSheetURL.IsEmpty() && !mLastStyleSheetURL.Equals(aURL))
+      return EnableStyleSheet(mLastStyleSheetURL, false);
+
+    return NS_OK;
+  }
+
+  // Make sure the pres shell doesn't disappear during the load.
+  NS_ENSURE_TRUE(mDocWeak, NS_ERROR_NOT_INITIALIZED);
+  nsCOMPtr<nsIPresShell> ps = GetPresShell();
+  NS_ENSURE_TRUE(ps, NS_ERROR_NOT_INITIALIZED);
+
+  nsCOMPtr<nsIURI> uaURI;
+  nsresult rv = NS_NewURI(getter_AddRefs(uaURI), aURL);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return ps->GetDocument()->CSSLoader()->
+    LoadSheet(uaURI, nullptr, EmptyCString(), this);
+}
+
+NS_IMETHODIMP
+nsHTMLEditor::RemoveStyleSheet(const nsAString &aURL)
+{
+  nsRefPtr<nsCSSStyleSheet> sheet;
+  nsresult rv = GetStyleSheetForURL(aURL, getter_AddRefs(sheet));
+  NS_ENSURE_SUCCESS(rv, rv);
+  NS_ENSURE_TRUE(sheet, NS_ERROR_UNEXPECTED);
+
+  nsRefPtr<RemoveStyleSheetTxn> txn;
+  rv = CreateTxnForRemoveStyleSheet(sheet, getter_AddRefs(txn));
+  if (!txn) rv = NS_ERROR_NULL_POINTER;
+  if (NS_SUCCEEDED(rv))
+  {
+    rv = DoTransaction(txn);
+    if (NS_SUCCEEDED(rv))
+      mLastStyleSheetURL.Truncate();        // forget it
+
+    // Remove it from our internal list
+    rv = RemoveStyleSheetFromList(aURL);
+  }
+  
+  return rv;
+}
+
+
+NS_IMETHODIMP
+nsHTMLEditor::AddOverrideStyleSheet(const nsAString& aURL)
+{
+  // Enable existing sheet if already loaded.
+  if (EnableExistingStyleSheet(aURL))
+    return NS_OK;
+
+  // Make sure the pres shell doesn't disappear during the load.
+  nsCOMPtr<nsIPresShell> ps = GetPresShell();
+  NS_ENSURE_TRUE(ps, NS_ERROR_NOT_INITIALIZED);
+
+  nsCOMPtr<nsIURI> uaURI;
+  nsresult rv = NS_NewURI(getter_AddRefs(uaURI), aURL);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // We MUST ONLY load synchronous local files (no @import)
+  // XXXbz Except this will actually try to load remote files
+  // synchronously, of course..
+  nsRefPtr<nsCSSStyleSheet> sheet;
+  // Editor override style sheets may want to style Gecko anonymous boxes
+  rv = ps->GetDocument()->CSSLoader()->
+    LoadSheetSync(uaURI, true, true, getter_AddRefs(sheet));
+
+  // Synchronous loads should ALWAYS return completed
+  NS_ENSURE_TRUE(sheet, NS_ERROR_NULL_POINTER);
+
+  // Add the override style sheet
+  // (This checks if already exists)
+  ps->AddOverrideStyleSheet(sheet);
+
+  ps->ReconstructStyleData();
+
+  // Save as the last-loaded sheet
+  mLastOverrideStyleSheetURL = aURL;
+
+  //Add URL and style sheet to our lists
+  return AddNewStyleSheetToList(aURL, sheet);
+}
+
+NS_IMETHODIMP
+nsHTMLEditor::ReplaceOverrideStyleSheet(const nsAString& aURL)
+{
+  // Enable existing sheet if already loaded.
+  if (EnableExistingStyleSheet(aURL))
+  {
+    // Disable last sheet if not the same as new one
+    if (!mLastOverrideStyleSheetURL.IsEmpty() && !mLastOverrideStyleSheetURL.Equals(aURL))
+      return EnableStyleSheet(mLastOverrideStyleSheetURL, false);
+
+    return NS_OK;
+  }
+  // Remove the previous sheet
+  if (!mLastOverrideStyleSheetURL.IsEmpty())
+    RemoveOverrideStyleSheet(mLastOverrideStyleSheetURL);
+
+  return AddOverrideStyleSheet(aURL);
+}
+
+// Do NOT use transaction system for override style sheets
+NS_IMETHODIMP
+nsHTMLEditor::RemoveOverrideStyleSheet(const nsAString &aURL)
+{
+  nsRefPtr<nsCSSStyleSheet> sheet;
+  GetStyleSheetForURL(aURL, getter_AddRefs(sheet));
+
+  // Make sure we remove the stylesheet from our internal list in all
+  // cases.
+  nsresult rv = RemoveStyleSheetFromList(aURL);
+
+  NS_ENSURE_TRUE(sheet, NS_OK); /// Don't fail if sheet not found
+
+  NS_ENSURE_TRUE(mDocWeak, NS_ERROR_NOT_INITIALIZED);
+  nsCOMPtr<nsIPresShell> ps = GetPresShell();
+  NS_ENSURE_TRUE(ps, NS_ERROR_NOT_INITIALIZED);
+
+  ps->RemoveOverrideStyleSheet(sheet);
+  ps->ReconstructStyleData();
+
+  // Remove it from our internal list
+  return rv;
+}
+
+NS_IMETHODIMP
+nsHTMLEditor::EnableStyleSheet(const nsAString &aURL, bool aEnable)
+{
+  nsRefPtr<nsCSSStyleSheet> sheet;
+  nsresult rv = GetStyleSheetForURL(aURL, getter_AddRefs(sheet));
+  NS_ENSURE_SUCCESS(rv, rv);
+  NS_ENSURE_TRUE(sheet, NS_OK); // Don't fail if sheet not found
+
+  // Ensure the style sheet is owned by our document.
+  nsCOMPtr<nsIDocument> doc = do_QueryReferent(mDocWeak);
+  sheet->SetOwningDocument(doc);
+
+  return sheet->SetDisabled(!aEnable);
+}
+
+bool
+nsHTMLEditor::EnableExistingStyleSheet(const nsAString &aURL)
+{
+  nsRefPtr<nsCSSStyleSheet> sheet;
+  nsresult rv = GetStyleSheetForURL(aURL, getter_AddRefs(sheet));
+  NS_ENSURE_SUCCESS(rv, false);
+
+  // Enable sheet if already loaded.
+  if (sheet)
+  {
+    // Ensure the style sheet is owned by our document.
+    nsCOMPtr<nsIDocument> doc = do_QueryReferent(mDocWeak);
+    sheet->SetOwningDocument(doc);
+
+    sheet->SetDisabled(false);
+    return true;
+  }
+  return false;
+}
+
+nsresult
+nsHTMLEditor::AddNewStyleSheetToList(const nsAString &aURL,
+                                     nsCSSStyleSheet *aStyleSheet)
+{
+  uint32_t countSS = mStyleSheets.Length();
+  uint32_t countU = mStyleSheetURLs.Length();
+
+  if (countSS != countU)
+    return NS_ERROR_UNEXPECTED;
+
+  if (!mStyleSheetURLs.AppendElement(aURL))
+    return NS_ERROR_UNEXPECTED;
+
+  return mStyleSheets.AppendElement(aStyleSheet) ? NS_OK : NS_ERROR_UNEXPECTED;
+}
+
+nsresult
+nsHTMLEditor::RemoveStyleSheetFromList(const nsAString &aURL)
+{
+  // is it already in the list?
+  uint32_t foundIndex;
+  foundIndex = mStyleSheetURLs.IndexOf(aURL);
+  if (foundIndex == mStyleSheetURLs.NoIndex)
+    return NS_ERROR_FAILURE;
+
+  // Attempt both removals; if one fails there's not much we can do.
+  mStyleSheets.RemoveElementAt(foundIndex);
+  mStyleSheetURLs.RemoveElementAt(foundIndex);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsHTMLEditor::GetStyleSheetForURL(const nsAString &aURL,
+                                  nsCSSStyleSheet **aStyleSheet)
+{
+  NS_ENSURE_ARG_POINTER(aStyleSheet);
+  *aStyleSheet = 0;
+
+  // is it already in the list?
+  uint32_t foundIndex;
+  foundIndex = mStyleSheetURLs.IndexOf(aURL);
+  if (foundIndex == mStyleSheetURLs.NoIndex)
+    return NS_OK; //No sheet -- don't fail!
+
+  *aStyleSheet = mStyleSheets[foundIndex];
+  NS_ENSURE_TRUE(*aStyleSheet, NS_ERROR_FAILURE);
+
+  NS_ADDREF(*aStyleSheet);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsHTMLEditor::GetURLForStyleSheet(nsCSSStyleSheet *aStyleSheet,
+                                  nsAString &aURL)
+{
+  // is it already in the list?
+  int32_t foundIndex = mStyleSheets.IndexOf(aStyleSheet);
+
+  // Don't fail if we don't find it in our list
+  // Note: mStyleSheets is nsCOMArray, so its IndexOf() method
+  // returns -1 on failure.
+  if (foundIndex == -1)
+    return NS_OK;
+
+  // Found it in the list!
+  aURL = mStyleSheetURLs[foundIndex];
+  return NS_OK;
+}
+
+/*
+ * nsIEditorMailSupport methods
+ */
+
+NS_IMETHODIMP
+nsHTMLEditor::GetEmbeddedObjects(nsISupportsArray** aNodeList)
+{
+  NS_ENSURE_TRUE(aNodeList, NS_ERROR_NULL_POINTER);
+
+  nsresult rv = NS_NewISupportsArray(aNodeList);
+  NS_ENSURE_SUCCESS(rv, rv);
+  NS_ENSURE_TRUE(*aNodeList, NS_ERROR_NULL_POINTER);
+
+  nsCOMPtr<nsIContentIterator> iter =
+      do_CreateInstance("@mozilla.org/content/post-content-iterator;1", &rv);
+  NS_ENSURE_TRUE(iter, NS_ERROR_NULL_POINTER);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIDocument> doc = GetDocument();
+  NS_ENSURE_TRUE(doc, NS_ERROR_UNEXPECTED);
+
+  iter->Init(doc->GetRootElement());
+
+  // Loop through the content iterator for each content node.
+  while (!iter->IsDone()) {
+    nsINode* node = iter->GetCurrentNode();
+    if (node->IsElement()) {
+      dom::Element* element = node->AsElement();
+
+      // See if it's an image or an embed and also include all links.
+      // Let mail decide which link to send or not
+      if (element->IsHTML(nsGkAtoms::img) ||
+          element->IsHTML(nsGkAtoms::embed) ||
+          element->IsHTML(nsGkAtoms::a) ||
+          (element->IsHTML(nsGkAtoms::body) &&
+           element->HasAttr(kNameSpaceID_None, nsGkAtoms::background))) {
+        nsCOMPtr<nsIDOMNode> domNode = do_QueryInterface(node);
+        (*aNodeList)->AppendElement(domNode);
+      }
+    }
+    iter->Next();
+  }
+
+  return rv;
+}
+
+
+NS_IMETHODIMP
+nsHTMLEditor::DeleteSelectionImpl(EDirection aAction,
+                                  EStripWrappers aStripWrappers)
+{
+  MOZ_ASSERT(aStripWrappers == eStrip || aStripWrappers == eNoStrip);
+
+  nsresult res = nsEditor::DeleteSelectionImpl(aAction, aStripWrappers);
+  NS_ENSURE_SUCCESS(res, res);
+
+  // If we weren't asked to strip any wrappers, we're done.
+  if (aStripWrappers == eNoStrip) {
+    return NS_OK;
+  }
+
+  nsRefPtr<Selection> selection = GetSelection();
+  // Just checking that the selection itself is collapsed doesn't seem to work
+  // right in the multi-range case
+  NS_ENSURE_STATE(selection);
+  NS_ENSURE_STATE(selection->GetAnchorFocusRange());
+  NS_ENSURE_STATE(selection->GetAnchorFocusRange()->Collapsed());
+
+  NS_ENSURE_STATE(selection->GetAnchorNode()->IsContent());
+  nsCOMPtr<nsIContent> content = selection->GetAnchorNode()->AsContent();
+
+  // Don't strip wrappers if this is the only wrapper in the block.  Then we'll
+  // add a <br> later, so it won't be an empty wrapper in the end.
+  nsCOMPtr<nsIContent> blockParent = content;
+  while (blockParent && !IsBlockNode(blockParent)) {
+    blockParent = blockParent->GetParent();
+  }
+  if (!blockParent) {
+    return NS_OK;
+  }
+  bool emptyBlockParent;
+  res = IsEmptyNode(blockParent, &emptyBlockParent);
+  NS_ENSURE_SUCCESS(res, res);
+  if (emptyBlockParent) {
+    return NS_OK;
+  }
+
+  if (content && !IsBlockNode(content) && !content->Length() &&
+      content->IsEditable() && content != content->GetEditingHost()) {
+    while (content->GetParent() && !IsBlockNode(content->GetParent()) &&
+           content->GetParent()->Length() == 1 &&
+           content->GetParent()->IsEditable() &&
+           content->GetParent() != content->GetEditingHost()) {
+      content = content->GetParent();
+    }
+    res = DeleteNode(content);
+    NS_ENSURE_SUCCESS(res, res);
+  }
+
+  return NS_OK;
+}
+
+
+nsresult
+nsHTMLEditor::DeleteNode(nsINode* aNode)
+{
+  nsCOMPtr<nsIDOMNode> node = do_QueryInterface(aNode);
+  return DeleteNode(node);
+}
+
+NS_IMETHODIMP
+nsHTMLEditor::DeleteNode(nsIDOMNode* aNode)
+{
+  // do nothing if the node is read-only
+  nsCOMPtr<nsIContent> content = do_QueryInterface(aNode);
+  if (!IsModifiableNode(aNode) && !IsMozEditorBogusNode(content)) {
+    return NS_ERROR_FAILURE;
+  }
+
+  return nsEditor::DeleteNode(aNode);
+}
+
+NS_IMETHODIMP nsHTMLEditor::DeleteText(nsIDOMCharacterData *aTextNode,
+                                       uint32_t             aOffset,
+                                       uint32_t             aLength)
+{
+  // do nothing if the node is read-only
+  if (!IsModifiableNode(aTextNode)) {
+    return NS_ERROR_FAILURE;
+  }
+
+  return nsEditor::DeleteText(aTextNode, aOffset, aLength);
+}
+
+NS_IMETHODIMP nsHTMLEditor::InsertTextImpl(const nsAString& aStringToInsert, 
+                                           nsCOMPtr<nsIDOMNode> *aInOutNode, 
+                                           int32_t *aInOutOffset,
+                                           nsIDOMDocument *aDoc)
+{
+  // do nothing if the node is read-only
+  if (!IsModifiableNode(*aInOutNode)) {
+    return NS_ERROR_FAILURE;
+  }
+
+  return nsEditor::InsertTextImpl(aStringToInsert, aInOutNode, aInOutOffset, aDoc);
+}
+
+void
+nsHTMLEditor::ContentAppended(nsIDocument *aDocument, nsIContent* aContainer,
+                              nsIContent* aFirstNewContent,
+                              int32_t aIndexInContainer)
+{
+  DoContentInserted(aDocument, aContainer, aFirstNewContent, aIndexInContainer,
+                    eAppended);
+}
+
+void
+nsHTMLEditor::ContentInserted(nsIDocument *aDocument, nsIContent* aContainer,
+                              nsIContent* aChild, int32_t aIndexInContainer)
+{
+  DoContentInserted(aDocument, aContainer, aChild, aIndexInContainer,
+                    eInserted);
+}
+
+void
+nsHTMLEditor::DoContentInserted(nsIDocument* aDocument, nsIContent* aContainer,
+                                nsIContent* aChild, int32_t aIndexInContainer,
+                                InsertedOrAppended aInsertedOrAppended)
+{
+  if (!aChild) {
+    return;
+  }
+
+  nsCOMPtr<nsIHTMLEditor> kungFuDeathGrip(this);
+
+  if (ShouldReplaceRootElement()) {
+    nsContentUtils::AddScriptRunner(NS_NewRunnableMethod(
+      this, &nsHTMLEditor::ResetRootElementAndEventTarget));
+  }
+  // We don't need to handle our own modifications
+  else if (!mAction && (aContainer ? aContainer->IsEditable() : aDocument->IsEditable())) {
+    if (IsMozEditorBogusNode(aChild)) {
+      // Ignore insertion of the bogus node
+      return;
+    }
+    // Protect the edit rules object from dying
+    nsCOMPtr<nsIEditRules> kungFuDeathGrip(mRules);
+    mRules->DocumentModified();
+
+    // Update spellcheck for only the newly-inserted node (bug 743819)
+    if (mInlineSpellChecker) {
+      nsRefPtr<nsRange> range = new nsRange(aChild);
+      int32_t endIndex = aIndexInContainer + 1;
+      if (aInsertedOrAppended == eAppended) {
+        // Count all the appended nodes
+        nsIContent* sibling = aChild->GetNextSibling();
+        while (sibling) {
+          endIndex++;
+          sibling = sibling->GetNextSibling();
+        }
+      }
+      nsresult res = range->Set(aContainer, aIndexInContainer,
+                                aContainer, endIndex);
+      if (NS_SUCCEEDED(res)) {
+        mInlineSpellChecker->SpellCheckRange(range);
+      }
+    }
+  }
+}
+
+void
+nsHTMLEditor::ContentRemoved(nsIDocument *aDocument, nsIContent* aContainer,
+                             nsIContent* aChild, int32_t aIndexInContainer,
+                             nsIContent* aPreviousSibling)
+{
+  nsCOMPtr<nsIHTMLEditor> kungFuDeathGrip(this);
+
+  if (SameCOMIdentity(aChild, mRootElement)) {
+    nsContentUtils::AddScriptRunner(NS_NewRunnableMethod(
+      this, &nsHTMLEditor::ResetRootElementAndEventTarget));
+  }
+  // We don't need to handle our own modifications
+  else if (!mAction && (aContainer ? aContainer->IsEditable() : aDocument->IsEditable())) {
+    if (aChild && IsMozEditorBogusNode(aChild)) {
+      // Ignore removal of the bogus node
+      return;
+    }
+    // Protect the edit rules object from dying
+    nsCOMPtr<nsIEditRules> kungFuDeathGrip(mRules);
+    mRules->DocumentModified();
+  }
+}
+
+NS_IMETHODIMP_(bool)
+nsHTMLEditor::IsModifiableNode(nsIDOMNode *aNode)
+{
+  nsCOMPtr<nsINode> node = do_QueryInterface(aNode);
+  return IsModifiableNode(node);
+}
+
+bool
+nsHTMLEditor::IsModifiableNode(nsINode *aNode)
+{
+  return !aNode || aNode->IsEditable();
+}
+
+NS_IMETHODIMP
+nsHTMLEditor::GetIsSelectionEditable(bool* aIsSelectionEditable)
+{
+  MOZ_ASSERT(aIsSelectionEditable);
+
+  nsRefPtr<Selection> selection = GetSelection();
+  NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
+
+  // Per the editing spec as of June 2012: we have to have a selection whose
+  // start and end nodes are editable, and which share an ancestor editing
+  // host.  (Bug 766387.)
+  *aIsSelectionEditable = selection->GetRangeCount() &&
+                          selection->GetAnchorNode()->IsEditable() &&
+                          selection->GetFocusNode()->IsEditable();
+
+  if (*aIsSelectionEditable) {
+    nsINode* commonAncestor =
+      selection->GetAnchorFocusRange()->GetCommonAncestor();
+    while (commonAncestor && !commonAncestor->IsEditable()) {
+      commonAncestor = commonAncestor->GetParentNode();
+    }
+    if (!commonAncestor) {
+      // No editable common ancestor
+      *aIsSelectionEditable = false;
+    }
+  }
+
+  return NS_OK;
+}
+
+static nsresult
+SetSelectionAroundHeadChildren(nsISelection* aSelection,
+                               nsIWeakReference* aDocWeak)
+{
+  // Set selection around <head> node
+  nsCOMPtr<nsIDocument> doc = do_QueryReferent(aDocWeak);
+  NS_ENSURE_TRUE(doc, NS_ERROR_NOT_INITIALIZED);
+
+  dom::Element* headNode = doc->GetHeadElement();
+  NS_ENSURE_STATE(headNode);
+
+  // Collapse selection to before first child of the head,
+  nsresult rv = aSelection->CollapseNative(headNode, 0);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Then extend it to just after.
+  uint32_t childCount = headNode->GetChildCount();
+  return aSelection->ExtendNative(headNode, childCount + 1);
+}
+
+NS_IMETHODIMP
+nsHTMLEditor::GetHeadContentsAsHTML(nsAString& aOutputString)
+{
+  nsRefPtr<Selection> selection = GetSelection();
+  NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
+
+  // Save current selection
+  nsAutoSelectionReset selectionResetter(selection, this);
+
+  nsresult res = SetSelectionAroundHeadChildren(selection, mDocWeak);
+  NS_ENSURE_SUCCESS(res, res);
+
+  res = OutputToString(NS_LITERAL_STRING("text/html"),
+                       nsIDocumentEncoder::OutputSelectionOnly,
+                       aOutputString);
+  if (NS_SUCCEEDED(res))
+  {
+    // Selection always includes <body></body>,
+    //  so terminate there
+    nsReadingIterator<char16_t> findIter,endFindIter;
+    aOutputString.BeginReading(findIter);
+    aOutputString.EndReading(endFindIter);
+    //counting on our parser to always lower case!!!
+    if (CaseInsensitiveFindInReadable(NS_LITERAL_STRING("<body"),
+                                      findIter, endFindIter))
+    {
+      nsReadingIterator<char16_t> beginIter;
+      aOutputString.BeginReading(beginIter);
+      int32_t offset = Distance(beginIter, findIter);//get the distance
+
+      nsWritingIterator<char16_t> writeIter;
+      aOutputString.BeginWriting(writeIter);
+      // Ensure the string ends in a newline
+      char16_t newline ('\n');
+      findIter.advance(-1);
+      if (offset ==0 || (offset >0 &&  (*findIter) != newline)) //check for 0
+      {
+        writeIter.advance(offset);
+        *writeIter = newline;
+        aOutputString.Truncate(offset+1);
+      }
+    }
+  }
+  return res;
+}
+
+NS_IMETHODIMP
+nsHTMLEditor::DebugUnitTests(int32_t *outNumTests, int32_t *outNumTestsFailed)
+{
+#ifdef DEBUG
+  NS_ENSURE_TRUE(outNumTests && outNumTestsFailed, NS_ERROR_NULL_POINTER);
+
+  TextEditorTest *tester = new TextEditorTest();
+  NS_ENSURE_TRUE(tester, NS_ERROR_OUT_OF_MEMORY);
+   
+  tester->Run(this, outNumTests, outNumTestsFailed);
+  delete tester;
+  return NS_OK;
+#else
+  return NS_ERROR_NOT_IMPLEMENTED;
+#endif
+}
+
+
+NS_IMETHODIMP 
+nsHTMLEditor::StyleSheetLoaded(nsCSSStyleSheet* aSheet, bool aWasAlternate,
+                               nsresult aStatus)
+{
+  nsresult rv = NS_OK;
+  nsAutoEditBatch batchIt(this);
+
+  if (!mLastStyleSheetURL.IsEmpty())
+    RemoveStyleSheet(mLastStyleSheetURL);
+
+  nsRefPtr<AddStyleSheetTxn> txn;
+  rv = CreateTxnForAddStyleSheet(aSheet, getter_AddRefs(txn));
+  if (!txn) rv = NS_ERROR_NULL_POINTER;
+  if (NS_SUCCEEDED(rv))
+  {
+    rv = DoTransaction(txn);
+    if (NS_SUCCEEDED(rv))
+    {
+      // Get the URI, then url spec from the sheet
+      nsAutoCString spec;
+      rv = aSheet->GetSheetURI()->GetSpec(spec);
+
+      if (NS_SUCCEEDED(rv))
+      {
+        // Save it so we can remove before applying the next one
+        mLastStyleSheetURL.AssignWithConversion(spec.get());
+
+        // Also save in our arrays of urls and sheets
+        AddNewStyleSheetToList(mLastStyleSheetURL, aSheet);
+      }
+    }
+  }
+
+  return NS_OK;
+}
+
+
+/** All editor operations which alter the doc should be prefaced
+ *  with a call to StartOperation, naming the action and direction */
+NS_IMETHODIMP
+nsHTMLEditor::StartOperation(EditAction opID,
+                             nsIEditor::EDirection aDirection)
+{
+  // Protect the edit rules object from dying
+  nsCOMPtr<nsIEditRules> kungFuDeathGrip(mRules);
+
+  nsEditor::StartOperation(opID, aDirection);  // will set mAction, mDirection
+  if (mRules) return mRules->BeforeEdit(mAction, mDirection);
+  return NS_OK;
+}
+
+
+/** All editor operations which alter the doc should be followed
+ *  with a call to EndOperation */
+NS_IMETHODIMP
+nsHTMLEditor::EndOperation()
+{
+  // Protect the edit rules object from dying
+  nsCOMPtr<nsIEditRules> kungFuDeathGrip(mRules);
+
+  // post processing
+  nsresult res = NS_OK;
+  if (mRules) res = mRules->AfterEdit(mAction, mDirection);
+  nsEditor::EndOperation();  // will clear mAction, mDirection
+  return res;
+}  
+
+bool 
+nsHTMLEditor::TagCanContainTag(nsIAtom* aParentTag, nsIAtom* aChildTag)
+{
+  MOZ_ASSERT(aParentTag && aChildTag);
+
+  nsIParserService* parserService = nsContentUtils::GetParserService();
+
+  int32_t childTagEnum;
+  // XXX Should this handle #cdata-section too?
+  if (aChildTag == nsGkAtoms::textTagName) {
+    childTagEnum = eHTMLTag_text;
+  } else {
+    childTagEnum = parserService->HTMLAtomTagToId(aChildTag);
+  }
+
+  int32_t parentTagEnum = parserService->HTMLAtomTagToId(aParentTag);
+  return nsHTMLEditUtils::CanContain(parentTagEnum, childTagEnum);
+}
+
+bool
+nsHTMLEditor::IsContainer(nsIDOMNode *aNode)
+{
+  if (!aNode) {
+    return false;
+  }
+
+  nsAutoString stringTag;
+
+  nsresult rv = aNode->GetNodeName(stringTag);
+  NS_ENSURE_SUCCESS(rv, false);
+
+  int32_t tagEnum;
+  // XXX Should this handle #cdata-section too?
+  if (stringTag.EqualsLiteral("#text")) {
+    tagEnum = eHTMLTag_text;
+  }
+  else {
+    tagEnum = nsContentUtils::GetParserService()->HTMLStringTagToId(stringTag);
+  }
+
+  return nsHTMLEditUtils::IsContainer(tagEnum);
+}
+
+
+NS_IMETHODIMP 
+nsHTMLEditor::SelectEntireDocument(nsISelection *aSelection)
+{
+  if (!aSelection || !mRules) { return NS_ERROR_NULL_POINTER; }
+  
+  // Protect the edit rules object from dying
+  nsCOMPtr<nsIEditRules> kungFuDeathGrip(mRules);
+
+  // get editor root node
+  nsCOMPtr<nsIDOMElement> rootElement = do_QueryInterface(GetRoot());
+  
+  // is doc empty?
+  bool bDocIsEmpty;
+  nsresult res = mRules->DocumentIsEmpty(&bDocIsEmpty);
+  NS_ENSURE_SUCCESS(res, res);
+    
+  if (bDocIsEmpty)
+  {
+    // if its empty dont select entire doc - that would select the bogus node
+    return aSelection->Collapse(rootElement, 0);
+  }
+
+  return nsEditor::SelectEntireDocument(aSelection);
+}
+
+NS_IMETHODIMP
+nsHTMLEditor::SelectAll()
+{
+  ForceCompositionEnd();
+
+  nsresult rv;
+  nsCOMPtr<nsISelectionController> selCon;
+  rv = GetSelectionController(getter_AddRefs(selCon));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsISelection> selection;
+  rv = selCon->GetSelection(nsISelectionController::SELECTION_NORMAL,
+                            getter_AddRefs(selection));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIDOMNode> anchorNode;
+  rv = selection->GetAnchorNode(getter_AddRefs(anchorNode));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIContent> anchorContent = do_QueryInterface(anchorNode, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  
+  // If the anchor content has independent selection, we never need to explicitly
+  // select its children.
+  if (anchorContent->HasIndependentSelection()) {
+    nsCOMPtr<nsISelectionPrivate> selPriv = do_QueryInterface(selection);
+    NS_ENSURE_TRUE(selPriv, NS_ERROR_UNEXPECTED);
+    rv = selPriv->SetAncestorLimiter(nullptr);
+    NS_ENSURE_SUCCESS(rv, rv);
+    nsCOMPtr<nsIDOMNode> rootElement = do_QueryInterface(mRootElement, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    return selection->SelectAllChildren(rootElement);
+  }
+
+  nsCOMPtr<nsIPresShell> ps = GetPresShell();
+  nsIContent *rootContent = anchorContent->GetSelectionRootContent(ps);
+  NS_ENSURE_TRUE(rootContent, NS_ERROR_UNEXPECTED);
+
+  nsCOMPtr<nsIDOMNode> rootElement = do_QueryInterface(rootContent, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return selection->SelectAllChildren(rootElement);
+}
+
+
+// this will NOT find aAttribute unless aAttribute has a non-null value
+// so singleton attributes like <Table border> will not be matched!
+bool nsHTMLEditor::IsTextPropertySetByContent(nsIContent*      aContent,
+                                              nsIAtom*         aProperty,
+                                              const nsAString* aAttribute,
+                                              const nsAString* aValue,
+                                              nsAString*       outValue)
+{
+  MOZ_ASSERT(aContent && aProperty);
+  MOZ_ASSERT_IF(aAttribute, aValue);
+  bool isSet;
+  IsTextPropertySetByContent(aContent->AsDOMNode(), aProperty, aAttribute,
+                             aValue, isSet, outValue);
+  return isSet;
+}
+
+void nsHTMLEditor::IsTextPropertySetByContent(nsIDOMNode        *aNode,
+                                              nsIAtom           *aProperty, 
+                                              const nsAString   *aAttribute, 
+                                              const nsAString   *aValue, 
+                                              bool              &aIsSet,
+                                              nsAString *outValue)
+{
+  nsresult result;
+  aIsSet = false;  // must be initialized to false for code below to work
+  nsAutoString propName;
+  aProperty->ToString(propName);
+  nsCOMPtr<nsIDOMNode>node = aNode;
+
+  while (node)
+  {
+    nsCOMPtr<nsIDOMElement>element;
+    element = do_QueryInterface(node);
+    if (element)
+    {
+      nsAutoString tag, value;
+      element->GetTagName(tag);
+      if (propName.Equals(tag, nsCaseInsensitiveStringComparator()))
+      {
+        bool found = false;
+        if (aAttribute && 0!=aAttribute->Length())
+        {
+          element->GetAttribute(*aAttribute, value);
+          if (outValue) *outValue = value;
+          if (!value.IsEmpty())
+          {
+            if (!aValue) {
+              found = true;
+            }
+            else
+            {
+              nsString tString(*aValue);
+              if (tString.Equals(value, nsCaseInsensitiveStringComparator())) {
+                found = true;
+              }
+              else {  // we found the prop with the attribute, but the value doesn't match
+                break;
+              }
+            }
+          }
+        }
+        else { 
+          found = true;
+        }
+        if (found)
+        {
+          aIsSet = true;
+          break;
+        }
+      }
+    }
+    nsCOMPtr<nsIDOMNode>temp;
+    result = node->GetParentNode(getter_AddRefs(temp));
+    if (NS_SUCCEEDED(result) && temp) {
+      node = temp;
+    }
+    else {
+      node = nullptr;
+    }
+  }
+}
+
+
+//================================================================
+// HTML Editor methods
+//
+// Note: Table Editing methods are implemented in nsTableEditor.cpp
+//
+
+
+bool
+nsHTMLEditor::SetCaretInTableCell(nsIDOMElement* aElement)
+{
+  nsCOMPtr<dom::Element> element = do_QueryInterface(aElement);
+  if (!element || !element->IsHTML() ||
+      !nsHTMLEditUtils::IsTableElement(element) ||
+      !IsDescendantOfEditorRoot(element)) {
+    return false;
+  }
+
+  nsIContent* node = element;
+  while (node->HasChildren()) {
+    node = node->GetFirstChild();
+  }
+
+  // Set selection at beginning of the found node
+  nsCOMPtr<nsISelection> selection;
+  nsresult rv = GetSelection(getter_AddRefs(selection));
+  NS_ENSURE_SUCCESS(rv, false);
+  NS_ENSURE_TRUE(selection, false);
+
+  return NS_SUCCEEDED(selection->CollapseNative(node, 0));
+}            
+
+///////////////////////////////////////////////////////////////////////////
+// GetEnclosingTable: find ancestor who is a table, if any
+//                  
+nsCOMPtr<nsIDOMNode> 
+nsHTMLEditor::GetEnclosingTable(nsIDOMNode *aNode)
+{
+  NS_PRECONDITION(aNode, "null node passed to nsHTMLEditor::GetEnclosingTable");
+  nsCOMPtr<nsIDOMNode> tbl, tmp, node = aNode;
+
+  while (!tbl)
+  {
+    tmp = GetBlockNodeParent(node);
+    if (!tmp) break;
+    if (nsHTMLEditUtils::IsTable(tmp)) tbl = tmp;
+    node = tmp;
+  }
+  return tbl;
+}
+
+
+/* this method scans the selection for adjacent text nodes
+ * and collapses them into a single text node.
+ * "adjacent" means literally adjacent siblings of the same parent.
+ * Uses nsEditor::JoinNodes so action is undoable. 
+ * Should be called within the context of a batch transaction.
+ */
+NS_IMETHODIMP
+nsHTMLEditor::CollapseAdjacentTextNodes(nsIDOMRange *aInRange)
+{
+  NS_ENSURE_TRUE(aInRange, NS_ERROR_NULL_POINTER);
+  nsAutoTxnsConserveSelection dontSpazMySelection(this);
+  nsTArray<nsCOMPtr<nsIDOMNode> > textNodes;
+  // we can't actually do anything during iteration, so store the text nodes in an array
+  // don't bother ref counting them because we know we can hold them for the 
+  // lifetime of this method
+
+
+  // build a list of editable text nodes
+  nsresult result;
+  nsCOMPtr<nsIContentIterator> iter =
+    do_CreateInstance("@mozilla.org/content/subtree-content-iterator;1", &result);
+  NS_ENSURE_SUCCESS(result, result);
+
+  iter->Init(aInRange);
+
+  while (!iter->IsDone())
+  {
+    nsINode* node = iter->GetCurrentNode();
+    if (node->NodeType() == nsIDOMNode::TEXT_NODE &&
+        IsEditable(static_cast<nsIContent*>(node))) {
+      nsCOMPtr<nsIDOMNode> domNode = do_QueryInterface(node);
+      textNodes.AppendElement(domNode);
+    }
+
+    iter->Next();
+  }
+
+  // now that I have a list of text nodes, collapse adjacent text nodes
+  // NOTE: assumption that JoinNodes keeps the righthand node
+  while (textNodes.Length() > 1)
+  {
+    // we assume a textNodes entry can't be nullptr
+    nsIDOMNode *leftTextNode = textNodes[0];
+    nsIDOMNode *rightTextNode = textNodes[1];
+    NS_ASSERTION(leftTextNode && rightTextNode,"left or rightTextNode null in CollapseAdjacentTextNodes");
+
+    // get the prev sibling of the right node, and see if its leftTextNode
+    nsCOMPtr<nsIDOMNode> prevSibOfRightNode;
+    result =
+      rightTextNode->GetPreviousSibling(getter_AddRefs(prevSibOfRightNode));
+    NS_ENSURE_SUCCESS(result, result);
+    if (prevSibOfRightNode && (prevSibOfRightNode == leftTextNode))
+    {
+      nsCOMPtr<nsIDOMNode> parent;
+      result = rightTextNode->GetParentNode(getter_AddRefs(parent));
+      NS_ENSURE_SUCCESS(result, result);
+      NS_ENSURE_TRUE(parent, NS_ERROR_NULL_POINTER);
+      result = JoinNodes(leftTextNode, rightTextNode, parent);
+      NS_ENSURE_SUCCESS(result, result);
+    }
+
+    textNodes.RemoveElementAt(0); // remove the leftmost text node from the list
+  }
+
+  return result;
+}
+
+NS_IMETHODIMP 
+nsHTMLEditor::SetSelectionAtDocumentStart(nsISelection *aSelection)
+{
+  dom::Element* rootElement = GetRoot();
+  NS_ENSURE_TRUE(rootElement, NS_ERROR_NULL_POINTER);
+
+  return aSelection->CollapseNative(rootElement, 0);
+}
+
+
+///////////////////////////////////////////////////////////////////////////
+// RemoveBlockContainer: remove inNode, reparenting its children into their
+//                  the parent of inNode.  In addition, INSERT ANY BR's NEEDED
+//                  TO PRESERVE IDENTITY OF REMOVED BLOCK.
+//
+nsresult
+nsHTMLEditor::RemoveBlockContainer(nsIDOMNode *inNode)
+{
+  NS_ENSURE_TRUE(inNode, NS_ERROR_NULL_POINTER);
+  nsresult res;
+  nsCOMPtr<nsIDOMNode> sibling, child, unused;
+  
+  // Two possibilities: the container cold be empty of editable content.
+  // If that is the case, we need to compare what is before and after inNode
+  // to determine if we need a br.
+  // Or it could not be empty, in which case we have to compare previous
+  // sibling and first child to determine if we need a leading br,
+  // and compare following sibling and last child to determine if we need a
+  // trailing br.
+  
+  res = GetFirstEditableChild(inNode, address_of(child));
+  NS_ENSURE_SUCCESS(res, res);
+  
+  if (child)  // the case of inNode not being empty
+  {
+    // we need a br at start unless:
+    // 1) previous sibling of inNode is a block, OR
+    // 2) previous sibling of inNode is a br, OR
+    // 3) first child of inNode is a block OR
+    // 4) either is null
+    
+    res = GetPriorHTMLSibling(inNode, address_of(sibling));
+    NS_ENSURE_SUCCESS(res, res);
+    if (sibling && !IsBlockNode(sibling) && !nsTextEditUtils::IsBreak(sibling))
+    {
+      res = GetFirstEditableChild(inNode, address_of(child));
+      NS_ENSURE_SUCCESS(res, res);
+      if (child && !IsBlockNode(child))
+      {
+        // insert br node
+        res = CreateBR(inNode, 0, address_of(unused));
+        NS_ENSURE_SUCCESS(res, res);
+      }
+    }
+    
+    // we need a br at end unless:
+    // 1) following sibling of inNode is a block, OR
+    // 2) last child of inNode is a block, OR
+    // 3) last child of inNode is a block OR
+    // 4) either is null
+
+    res = GetNextHTMLSibling(inNode, address_of(sibling));
+    NS_ENSURE_SUCCESS(res, res);
+    if (sibling && !IsBlockNode(sibling))
+    {
+      res = GetLastEditableChild(inNode, address_of(child));
+      NS_ENSURE_SUCCESS(res, res);
+      if (child && !IsBlockNode(child) && !nsTextEditUtils::IsBreak(child))
+      {
+        // insert br node
+        uint32_t len;
+        res = GetLengthOfDOMNode(inNode, len);
+        NS_ENSURE_SUCCESS(res, res);
+        res = CreateBR(inNode, (int32_t)len, address_of(unused));
+        NS_ENSURE_SUCCESS(res, res);
+      }
+    }
+  }
+  else  // the case of inNode being empty
+  {
+    // we need a br at start unless:
+    // 1) previous sibling of inNode is a block, OR
+    // 2) previous sibling of inNode is a br, OR
+    // 3) following sibling of inNode is a block, OR
+    // 4) following sibling of inNode is a br OR
+    // 5) either is null
+    res = GetPriorHTMLSibling(inNode, address_of(sibling));
+    NS_ENSURE_SUCCESS(res, res);
+    if (sibling && !IsBlockNode(sibling) && !nsTextEditUtils::IsBreak(sibling))
+    {
+      res = GetNextHTMLSibling(inNode, address_of(sibling));
+      NS_ENSURE_SUCCESS(res, res);
+      if (sibling && !IsBlockNode(sibling) && !nsTextEditUtils::IsBreak(sibling))
+      {
+        // insert br node
+        res = CreateBR(inNode, 0, address_of(unused));
+        NS_ENSURE_SUCCESS(res, res);
+      }
+    }
+  }
+    
+  // now remove container
+  return RemoveContainer(inNode);
+}
+
+
+///////////////////////////////////////////////////////////////////////////
+// GetPriorHTMLSibling: returns the previous editable sibling, if there is
+//                   one within the parent
+//                       
+nsIContent*
+nsHTMLEditor::GetPriorHTMLSibling(nsINode* aNode)
+{
+  MOZ_ASSERT(aNode);
+
+  nsIContent* node = aNode->GetPreviousSibling();
+  while (node && !IsEditable(node)) {
+    node = node->GetPreviousSibling();
+  }
+
+  return node;
+}
+
+nsresult
+nsHTMLEditor::GetPriorHTMLSibling(nsIDOMNode *inNode, nsCOMPtr<nsIDOMNode> *outNode)
+{
+  NS_ENSURE_TRUE(outNode, NS_ERROR_NULL_POINTER);
+  *outNode = nullptr;
+
+  nsCOMPtr<nsINode> node = do_QueryInterface(inNode);
+  NS_ENSURE_TRUE(node, NS_ERROR_NULL_POINTER);
+
+  *outNode = do_QueryInterface(GetPriorHTMLSibling(node));
+  return NS_OK;
+}
+
+
+
+///////////////////////////////////////////////////////////////////////////
+// GetPriorHTMLSibling: returns the previous editable sibling, if there is
+//                   one within the parent.  just like above routine but
+//                   takes a parent/offset instead of a node.
+//                       
+nsIContent*
+nsHTMLEditor::GetPriorHTMLSibling(nsINode* aParent, int32_t aOffset)
+{
+  MOZ_ASSERT(aParent);
+
+  nsIContent* node = aParent->GetChildAt(aOffset - 1);
+  if (!node || IsEditable(node)) {
+    return node;
+  }
+
+  return GetPriorHTMLSibling(node);
+}
+
+nsresult
+nsHTMLEditor::GetPriorHTMLSibling(nsIDOMNode *inParent, int32_t inOffset, nsCOMPtr<nsIDOMNode> *outNode)
+{
+  NS_ENSURE_TRUE(outNode, NS_ERROR_NULL_POINTER);
+  *outNode = nullptr;
+
+  nsCOMPtr<nsINode> parent = do_QueryInterface(inParent);
+  NS_ENSURE_TRUE(parent, NS_ERROR_NULL_POINTER);
+
+  *outNode = do_QueryInterface(GetPriorHTMLSibling(parent, inOffset));
+  return NS_OK;
+}
+
+
+
+///////////////////////////////////////////////////////////////////////////
+// GetNextHTMLSibling: returns the next editable sibling, if there is
+//                   one within the parent
+//                       
+nsIContent*
+nsHTMLEditor::GetNextHTMLSibling(nsINode* aNode)
+{
+  MOZ_ASSERT(aNode);
+
+  nsIContent* node = aNode->GetNextSibling();
+  while (node && !IsEditable(node)) {
+    node = node->GetNextSibling();
+  }
+
+  return node;
+}
+
+nsresult
+nsHTMLEditor::GetNextHTMLSibling(nsIDOMNode *inNode, nsCOMPtr<nsIDOMNode> *outNode)
+{
+  NS_ENSURE_TRUE(outNode, NS_ERROR_NULL_POINTER);
+  *outNode = nullptr;
+
+  nsCOMPtr<nsINode> node = do_QueryInterface(inNode);
+  NS_ENSURE_TRUE(node, NS_ERROR_NULL_POINTER);
+  
+  *outNode = do_QueryInterface(GetNextHTMLSibling(node));
+  return NS_OK;
+}
+
+
+
+///////////////////////////////////////////////////////////////////////////
+// GetNextHTMLSibling: returns the next editable sibling, if there is
+//                   one within the parent.  just like above routine but
+//                   takes a parent/offset instead of a node.
+nsIContent*
+nsHTMLEditor::GetNextHTMLSibling(nsINode* aParent, int32_t aOffset)
+{
+  MOZ_ASSERT(aParent);
+
+  nsIContent* node = aParent->GetChildAt(aOffset + 1);
+  if (!node || IsEditable(node)) {
+    return node;
+  }
+
+  return GetNextHTMLSibling(node);
+}
+
+nsresult
+nsHTMLEditor::GetNextHTMLSibling(nsIDOMNode *inParent, int32_t inOffset, nsCOMPtr<nsIDOMNode> *outNode)
+{
+  NS_ENSURE_TRUE(outNode, NS_ERROR_NULL_POINTER);
+  *outNode = nullptr;
+
+  nsCOMPtr<nsINode> parent = do_QueryInterface(inParent);
+  NS_ENSURE_TRUE(parent, NS_ERROR_NULL_POINTER);
+
+  *outNode = do_QueryInterface(GetNextHTMLSibling(parent, inOffset));
+  return NS_OK;
+}
+
+
+
+///////////////////////////////////////////////////////////////////////////
+// GetPriorHTMLNode: returns the previous editable leaf node, if there is
+//                   one within the <body>
+//
+nsIContent*
+nsHTMLEditor::GetPriorHTMLNode(nsINode* aNode, bool aNoBlockCrossing)
+{
+  MOZ_ASSERT(aNode);
+
+  if (!GetActiveEditingHost()) {
+    return nullptr;
+  }
+
+  return GetPriorNode(aNode, true, aNoBlockCrossing);
+}
+
+nsresult
+nsHTMLEditor::GetPriorHTMLNode(nsIDOMNode* aNode,
+                               nsCOMPtr<nsIDOMNode>* aResultNode,
+                               bool aNoBlockCrossing)
+{
+  NS_ENSURE_TRUE(aResultNode, NS_ERROR_NULL_POINTER);
+
+  nsCOMPtr<nsINode> node = do_QueryInterface(aNode);
+  NS_ENSURE_TRUE(node, NS_ERROR_NULL_POINTER);
+
+  *aResultNode = do_QueryInterface(GetPriorHTMLNode(node, aNoBlockCrossing));
+  return NS_OK;
+}
+
+
+///////////////////////////////////////////////////////////////////////////
+// GetPriorHTMLNode: same as above but takes {parent,offset} instead of node
+//
+nsIContent*
+nsHTMLEditor::GetPriorHTMLNode(nsINode* aParent, int32_t aOffset,
+                               bool aNoBlockCrossing)
+{
+  MOZ_ASSERT(aParent);
+
+  if (!GetActiveEditingHost()) {
+    return nullptr;
+  }
+
+  return GetPriorNode(aParent, aOffset, true, aNoBlockCrossing);
+}
+
+nsresult
+nsHTMLEditor::GetPriorHTMLNode(nsIDOMNode* aNode, int32_t aOffset,
+                               nsCOMPtr<nsIDOMNode>* aResultNode,
+                               bool aNoBlockCrossing)
+{
+  NS_ENSURE_TRUE(aResultNode, NS_ERROR_NULL_POINTER);
+
+  nsCOMPtr<nsINode> node = do_QueryInterface(aNode);
+  NS_ENSURE_TRUE(node, NS_ERROR_NULL_POINTER);
+
+  *aResultNode = do_QueryInterface(GetPriorHTMLNode(node, aOffset,
+                                                    aNoBlockCrossing));
+  return NS_OK;
+}
+
+
+///////////////////////////////////////////////////////////////////////////
+// GetNextHTMLNode: returns the next editable leaf node, if there is
+//                   one within the <body>
+//                       
+nsIContent*
+nsHTMLEditor::GetNextHTMLNode(nsINode* aNode, bool aNoBlockCrossing)
+{
+  MOZ_ASSERT(aNode);
+
+  nsIContent* result = GetNextNode(aNode, true, aNoBlockCrossing);
+
+  if (result && !IsDescendantOfEditorRoot(result)) {
+    return nullptr;
+  }
+
+  return result;
+}
+
+nsresult
+nsHTMLEditor::GetNextHTMLNode(nsIDOMNode* aNode,
+                              nsCOMPtr<nsIDOMNode>* aResultNode,
+                              bool aNoBlockCrossing)
+{
+  NS_ENSURE_TRUE(aResultNode, NS_ERROR_NULL_POINTER);
+
+  nsCOMPtr<nsINode> node = do_QueryInterface(aNode);
+  NS_ENSURE_TRUE(node, NS_ERROR_NULL_POINTER);
+
+  *aResultNode = do_QueryInterface(GetNextHTMLNode(node, aNoBlockCrossing));
+  return NS_OK;
+}
+
+
+///////////////////////////////////////////////////////////////////////////
+// GetNextHTMLNode: same as above but takes {parent,offset} instead of node
+//                       
+nsIContent*
+nsHTMLEditor::GetNextHTMLNode(nsINode* aParent, int32_t aOffset,
+                              bool aNoBlockCrossing)
+{
+  nsIContent* content = GetNextNode(aParent, aOffset, true, aNoBlockCrossing);
+  if (content && !IsDescendantOfEditorRoot(content)) {
+    return nullptr;
+  }
+  return content;
+}
+
+nsresult
+nsHTMLEditor::GetNextHTMLNode(nsIDOMNode* aNode, int32_t aOffset,
+                              nsCOMPtr<nsIDOMNode>* aResultNode,
+                              bool aNoBlockCrossing)
+{
+  NS_ENSURE_TRUE(aResultNode, NS_ERROR_NULL_POINTER);
+
+  nsCOMPtr<nsINode> node = do_QueryInterface(aNode);
+  NS_ENSURE_TRUE(node, NS_ERROR_NULL_POINTER);
+
+  *aResultNode = do_QueryInterface(GetNextHTMLNode(node, aOffset,
+                                                   aNoBlockCrossing));
+  return NS_OK;
+}
+
+
+nsresult 
+nsHTMLEditor::IsFirstEditableChild( nsIDOMNode *aNode, bool *aOutIsFirst)
+{
+  // check parms
+  NS_ENSURE_TRUE(aOutIsFirst && aNode, NS_ERROR_NULL_POINTER);
+  
+  // init out parms
+  *aOutIsFirst = false;
+  
+  // find first editable child and compare it to aNode
+  nsCOMPtr<nsIDOMNode> parent, firstChild;
+  nsresult res = aNode->GetParentNode(getter_AddRefs(parent));
+  NS_ENSURE_SUCCESS(res, res);
+  NS_ENSURE_TRUE(parent, NS_ERROR_FAILURE);
+  res = GetFirstEditableChild(parent, address_of(firstChild));
+  NS_ENSURE_SUCCESS(res, res);
+  
+  *aOutIsFirst = (firstChild.get() == aNode);
+  return res;
+}
+
+
+nsresult 
+nsHTMLEditor::IsLastEditableChild( nsIDOMNode *aNode, bool *aOutIsLast)
+{
+  // check parms
+  NS_ENSURE_TRUE(aOutIsLast && aNode, NS_ERROR_NULL_POINTER);
+  
+  // init out parms
+  *aOutIsLast = false;
+  
+  // find last editable child and compare it to aNode
+  nsCOMPtr<nsIDOMNode> parent, lastChild;
+  nsresult res = aNode->GetParentNode(getter_AddRefs(parent));
+  NS_ENSURE_SUCCESS(res, res);
+  NS_ENSURE_TRUE(parent, NS_ERROR_FAILURE);
+  res = GetLastEditableChild(parent, address_of(lastChild));
+  NS_ENSURE_SUCCESS(res, res);
+  
+  *aOutIsLast = (lastChild.get() == aNode);
+  return res;
+}
+
+
+nsresult 
+nsHTMLEditor::GetFirstEditableChild( nsIDOMNode *aNode, nsCOMPtr<nsIDOMNode> *aOutFirstChild)
+{
+  // check parms
+  NS_ENSURE_TRUE(aOutFirstChild && aNode, NS_ERROR_NULL_POINTER);
+  
+  // init out parms
+  *aOutFirstChild = nullptr;
+  
+  // find first editable child
+  nsCOMPtr<nsIDOMNode> child;
+  nsresult res = aNode->GetFirstChild(getter_AddRefs(child));
+  NS_ENSURE_SUCCESS(res, res);
+  
+  while (child && !IsEditable(child))
+  {
+    nsCOMPtr<nsIDOMNode> tmp;
+    res = child->GetNextSibling(getter_AddRefs(tmp));
+    NS_ENSURE_SUCCESS(res, res);
+    NS_ENSURE_TRUE(tmp, NS_ERROR_FAILURE);
+    child = tmp;
+  }
+  
+  *aOutFirstChild = child;
+  return res;
+}
+
+
+nsresult 
+nsHTMLEditor::GetLastEditableChild( nsIDOMNode *aNode, nsCOMPtr<nsIDOMNode> *aOutLastChild)
+{
+  // check parms
+  NS_ENSURE_TRUE(aOutLastChild && aNode, NS_ERROR_NULL_POINTER);
+  
+  // init out parms
+  *aOutLastChild = aNode;
+  
+  // find last editable child
+  nsCOMPtr<nsIDOMNode> child;
+  nsresult res = aNode->GetLastChild(getter_AddRefs(child));
+  NS_ENSURE_SUCCESS(res, res);
+  
+  while (child && !IsEditable(child))
+  {
+    nsCOMPtr<nsIDOMNode> tmp;
+    res = child->GetPreviousSibling(getter_AddRefs(tmp));
+    NS_ENSURE_SUCCESS(res, res);
+    NS_ENSURE_TRUE(tmp, NS_ERROR_FAILURE);
+    child = tmp;
+  }
+  
+  *aOutLastChild = child;
+  return res;
+}
+
+nsresult 
+nsHTMLEditor::GetFirstEditableLeaf( nsIDOMNode *aNode, nsCOMPtr<nsIDOMNode> *aOutFirstLeaf)
+{
+  // check parms
+  NS_ENSURE_TRUE(aOutFirstLeaf && aNode, NS_ERROR_NULL_POINTER);
+  
+  // init out parms
+  *aOutFirstLeaf = aNode;
+  
+  // find leftmost leaf
+  nsCOMPtr<nsIDOMNode> child;
+  nsresult res = NS_OK;
+  child = GetLeftmostChild(aNode);  
+  while (child && (!IsEditable(child) || !nsEditorUtils::IsLeafNode(child)))
+  {
+    nsCOMPtr<nsIDOMNode> tmp;
+    res = GetNextHTMLNode(child, address_of(tmp));
+    NS_ENSURE_SUCCESS(res, res);
+    NS_ENSURE_TRUE(tmp, NS_ERROR_FAILURE);
+    
+    // only accept nodes that are descendants of aNode
+    if (nsEditorUtils::IsDescendantOf(tmp, aNode))
+      child = tmp;
+    else
+    {
+      child = nullptr;  // this will abort the loop
+    }
+  }
+  
+  *aOutFirstLeaf = child;
+  return res;
+}
+
+
+nsresult 
+nsHTMLEditor::GetLastEditableLeaf(nsIDOMNode *aNode, nsCOMPtr<nsIDOMNode> *aOutLastLeaf)
+{
+  // check parms
+  NS_ENSURE_TRUE(aOutLastLeaf && aNode, NS_ERROR_NULL_POINTER);
+  
+  // init out parms
+  *aOutLastLeaf = nullptr;
+  
+  // find rightmost leaf
+  nsCOMPtr<nsIDOMNode> child = GetRightmostChild(aNode, false);
+  nsresult res = NS_OK;
+  while (child && (!IsEditable(child) || !nsEditorUtils::IsLeafNode(child)))
+  {
+    nsCOMPtr<nsIDOMNode> tmp;
+    res = GetPriorHTMLNode(child, address_of(tmp));
+    NS_ENSURE_SUCCESS(res, res);
+    NS_ENSURE_TRUE(tmp, NS_ERROR_FAILURE);
+    
+    // only accept nodes that are descendants of aNode
+    if (nsEditorUtils::IsDescendantOf(tmp, aNode))
+      child = tmp;
+    else
+    {
+      child = nullptr;
+    }
+  }
+  
+  *aOutLastLeaf = child;
+  return res;
+}
+
+
+///////////////////////////////////////////////////////////////////////////
+// IsVisTextNode: figure out if textnode aTextNode has any visible content.
+//                  
+nsresult
+nsHTMLEditor::IsVisTextNode(nsIContent* aNode,
+                            bool* outIsEmptyNode,
+                            bool aSafeToAskFrames)
+{
+  MOZ_ASSERT(aNode);
+  MOZ_ASSERT(aNode->NodeType() == nsIDOMNode::TEXT_NODE);
+  MOZ_ASSERT(outIsEmptyNode);
+
+  *outIsEmptyNode = true;
+
+  uint32_t length = aNode->TextLength();
+  if (aSafeToAskFrames)
+  {
+    nsCOMPtr<nsISelectionController> selCon;
+    nsresult res = GetSelectionController(getter_AddRefs(selCon));
+    NS_ENSURE_SUCCESS(res, res);
+    NS_ENSURE_TRUE(selCon, NS_ERROR_FAILURE);
+    bool isVisible = false;
+    // ask the selection controller for information about whether any
+    // of the data in the node is really rendered.  This is really
+    // something that frames know about, but we aren't supposed to talk to frames.
+    // So we put a call in the selection controller interface, since it's already
+    // in bed with frames anyway.  (this is a fix for bug 22227, and a
+    // partial fix for bug 46209)
+    res = selCon->CheckVisibilityContent(aNode, 0, length, &isVisible);
+    NS_ENSURE_SUCCESS(res, res);
+    if (isVisible) 
+    {
+      *outIsEmptyNode = false;
+    }
+  }
+  else if (length)
+  {
+    if (aNode->TextIsOnlyWhitespace())
+    {
+      nsCOMPtr<nsIDOMNode> node = do_QueryInterface(aNode);
+      nsWSRunObject wsRunObj(this, node, 0);
+      nsCOMPtr<nsIDOMNode> visNode;
+      int32_t outVisOffset=0;
+      WSType visType;
+      wsRunObj.NextVisibleNode(node, 0, address_of(visNode),
+                               &outVisOffset, &visType);
+      if (visType == WSType::normalWS || visType == WSType::text) {
+        *outIsEmptyNode = (node != visNode);
+      }
+    }
+    else
+    {
+      *outIsEmptyNode = false;
+    }
+  }
+  return NS_OK;  
+}
+  
+
+///////////////////////////////////////////////////////////////////////////
+// IsEmptyNode: figure out if aNode is an empty node.
+//               A block can have children and still be considered empty,
+//               if the children are empty or non-editable.
+//                  
+nsresult
+nsHTMLEditor::IsEmptyNode( nsIDOMNode *aNode, 
+                           bool *outIsEmptyNode, 
+                           bool aSingleBRDoesntCount,
+                           bool aListOrCellNotEmpty,
+                           bool aSafeToAskFrames)
+{
+  nsCOMPtr<nsINode> node = do_QueryInterface(aNode);
+  return IsEmptyNode(node, outIsEmptyNode, aSingleBRDoesntCount,
+                     aListOrCellNotEmpty, aSafeToAskFrames);
+}
+
+nsresult
+nsHTMLEditor::IsEmptyNode(nsINode* aNode,
+                          bool* outIsEmptyNode,
+                          bool aSingleBRDoesntCount,
+                          bool aListOrCellNotEmpty,
+                          bool aSafeToAskFrames)
+{
+  NS_ENSURE_TRUE(aNode && outIsEmptyNode, NS_ERROR_NULL_POINTER);
+  *outIsEmptyNode = true;
+  bool seenBR = false;
+  return IsEmptyNodeImpl(aNode, outIsEmptyNode, aSingleBRDoesntCount,
+                         aListOrCellNotEmpty, aSafeToAskFrames, &seenBR);
+}
+
+///////////////////////////////////////////////////////////////////////////
+// IsEmptyNodeImpl: workhorse for IsEmptyNode.
+//                  
+nsresult
+nsHTMLEditor::IsEmptyNodeImpl(nsINode* aNode,
+                              bool *outIsEmptyNode,
+                              bool aSingleBRDoesntCount,
+                              bool aListOrCellNotEmpty,
+                              bool aSafeToAskFrames,
+                              bool *aSeenBR)
+{
+  NS_ENSURE_TRUE(aNode && outIsEmptyNode && aSeenBR, NS_ERROR_NULL_POINTER);
+
+  if (aNode->NodeType() == nsIDOMNode::TEXT_NODE) {
+    return IsVisTextNode(static_cast<nsIContent*>(aNode), outIsEmptyNode, aSafeToAskFrames);
+  }
+
+  // if it's not a text node (handled above) and it's not a container,
+  // then we don't call it empty (it's an <hr>, or <br>, etc).
+  // Also, if it's an anchor then don't treat it as empty - even though
+  // anchors are containers, named anchors are "empty" but we don't
+  // want to treat them as such.  Also, don't call ListItems or table
+  // cells empty if caller desires.  Form Widgets not empty.
+  if (!IsContainer(aNode->AsDOMNode())                      ||
+      (nsHTMLEditUtils::IsNamedAnchor(aNode) ||
+       nsHTMLEditUtils::IsFormWidget(aNode) ||
+       (aListOrCellNotEmpty &&
+        (nsHTMLEditUtils::IsListItem(aNode) ||
+         nsHTMLEditUtils::IsTableCell(aNode))))) {
+    *outIsEmptyNode = false;
+    return NS_OK;
+  }
+    
+  // need this for later
+  bool isListItemOrCell = nsHTMLEditUtils::IsListItem(aNode) ||
+                          nsHTMLEditUtils::IsTableCell(aNode);
+       
+  // loop over children of node. if no children, or all children are either 
+  // empty text nodes or non-editable, then node qualifies as empty
+  for (nsCOMPtr<nsIContent> child = aNode->GetFirstChild();
+       child;
+       child = child->GetNextSibling()) {
+    // Is the child editable and non-empty?  if so, return false
+    if (nsEditor::IsEditable(child)) {
+      if (child->NodeType() == nsIDOMNode::TEXT_NODE) {
+        nsresult rv = IsVisTextNode(child, outIsEmptyNode, aSafeToAskFrames);
+        NS_ENSURE_SUCCESS(rv, rv);
+        // break out if we find we aren't emtpy
+        if (!*outIsEmptyNode) {
+          return NS_OK;
+        }
+      } else {
+        // An editable, non-text node. We need to check its content.
+        // Is it the node we are iterating over?
+        if (child == aNode) {
+          break;
+        }
+
+        if (aSingleBRDoesntCount && !*aSeenBR && child->IsHTML(nsGkAtoms::br)) {
+          // the first br in a block doesn't count if the caller so indicated
+          *aSeenBR = true;
+        } else {
+          // is it an empty node of some sort?
+          // note: list items or table cells are not considered empty
+          // if they contain other lists or tables
+          if (child->IsElement()) {
+            if (isListItemOrCell) {
+              if (nsHTMLEditUtils::IsList(child) ||
+                  child->IsHTML(nsGkAtoms::table)) {
+                // break out if we find we aren't empty
+                *outIsEmptyNode = false;
+                return NS_OK;
+              }
+            } else if (nsHTMLEditUtils::IsFormWidget(child)) {
+              // is it a form widget?
+              // break out if we find we aren't empty
+              *outIsEmptyNode = false;
+              return NS_OK;
+            }
+          }
+
+          bool isEmptyNode = true;
+          nsresult rv = IsEmptyNodeImpl(child, &isEmptyNode,
+                                        aSingleBRDoesntCount,
+                                        aListOrCellNotEmpty, aSafeToAskFrames,
+                                        aSeenBR);
+          NS_ENSURE_SUCCESS(rv, rv);
+          if (!isEmptyNode) {
+            // otherwise it ain't empty
+            *outIsEmptyNode = false;
+            return NS_OK;
+          }
+        }
+      }
+    }
+  }
+  
+  return NS_OK;
+}
+
+// add to aElement the CSS inline styles corresponding to the HTML attribute
+// aAttribute with its value aValue
+nsresult
+nsHTMLEditor::SetAttributeOrEquivalent(nsIDOMElement * aElement,
+                                       const nsAString & aAttribute,
+                                       const nsAString & aValue,
+                                       bool aSuppressTransaction)
+{
+  nsAutoScriptBlocker scriptBlocker;
+
+  nsresult res = NS_OK;
+  if (IsCSSEnabled() && mHTMLCSSUtils) {
+    int32_t count;
+    res = mHTMLCSSUtils->SetCSSEquivalentToHTMLStyle(aElement, nullptr, &aAttribute, &aValue, &count,
+                                                     aSuppressTransaction);
+    NS_ENSURE_SUCCESS(res, res);
+    if (count) {
+      // we found an equivalence ; let's remove the HTML attribute itself if it is set
+      nsAutoString existingValue;
+      bool wasSet = false;
+      res = GetAttributeValue(aElement, aAttribute, existingValue, &wasSet);
+      NS_ENSURE_SUCCESS(res, res);
+      if (wasSet) {
+        if (aSuppressTransaction)
+          res = aElement->RemoveAttribute(aAttribute);
+        else
+          res = RemoveAttribute(aElement, aAttribute);
+      }
+    }
+    else {
+      // count is an integer that represents the number of CSS declarations applied to the
+      // element. If it is zero, we found no equivalence in this implementation for the
+      // attribute
+      if (aAttribute.EqualsLiteral("style")) {
+        // if it is the style attribute, just add the new value to the existing style
+        // attribute's value
+        nsAutoString existingValue;
+        bool wasSet = false;
+        res = GetAttributeValue(aElement, NS_LITERAL_STRING("style"), existingValue, &wasSet);
+        NS_ENSURE_SUCCESS(res, res);
+        existingValue.AppendLiteral(" ");
+        existingValue.Append(aValue);
+        if (aSuppressTransaction)
+          res = aElement->SetAttribute(aAttribute, existingValue);
+        else
+          res = SetAttribute(aElement, aAttribute, existingValue);
+      }
+      else {
+        // we have no CSS equivalence for this attribute and it is not the style
+        // attribute; let's set it the good'n'old HTML way
+        if (aSuppressTransaction)
+          res = aElement->SetAttribute(aAttribute, aValue);
+        else
+          res = SetAttribute(aElement, aAttribute, aValue);
+      }
+    }
+  }
+  else {
+    // we are not in an HTML+CSS editor; let's set the attribute the HTML way
+    if (aSuppressTransaction)
+      res = aElement->SetAttribute(aAttribute, aValue);
+    else
+      res = SetAttribute(aElement, aAttribute, aValue);
+  }  
+  return res;
+}
+
+nsresult
+nsHTMLEditor::RemoveAttributeOrEquivalent(nsIDOMElement* aElement,
+                                          const nsAString& aAttribute,
+                                          bool aSuppressTransaction)
+{
+  nsCOMPtr<dom::Element> element = do_QueryInterface(aElement);
+  NS_ENSURE_TRUE(element, NS_OK);
+
+  nsCOMPtr<nsIAtom> attribute = do_GetAtom(aAttribute);
+  MOZ_ASSERT(attribute);
+
+  nsresult res = NS_OK;
+  if (IsCSSEnabled() && mHTMLCSSUtils) {
+    res = mHTMLCSSUtils->RemoveCSSEquivalentToHTMLStyle(
+        element, nullptr, &aAttribute, nullptr, aSuppressTransaction);
+    NS_ENSURE_SUCCESS(res, res);
+  }
+
+  if (element->HasAttr(kNameSpaceID_None, attribute)) {
+    if (aSuppressTransaction) {
+      res = element->UnsetAttr(kNameSpaceID_None, attribute,
+                               /* aNotify = */ true);
+    } else {
+      res = RemoveAttribute(aElement, aAttribute);
+    }
+  }
+  return res;
+}
+
+nsresult
+nsHTMLEditor::SetIsCSSEnabled(bool aIsCSSPrefChecked)
+{
+  if (!mHTMLCSSUtils) {
+    return NS_ERROR_NOT_INITIALIZED;
+  }
+
+  mHTMLCSSUtils->SetCSSEnabled(aIsCSSPrefChecked);
+
+  // Disable the eEditorNoCSSMask flag if we're enabling StyleWithCSS.
+  uint32_t flags = mFlags;
+  if (aIsCSSPrefChecked) {
+    // Turn off NoCSS as we're enabling CSS
+    flags &= ~eEditorNoCSSMask;
+  } else {
+    // Turn on NoCSS, as we're disabling CSS.
+    flags |= eEditorNoCSSMask;
+  }
+
+  return SetFlags(flags);
+}
+
+// Set the block background color
+NS_IMETHODIMP
+nsHTMLEditor::SetCSSBackgroundColor(const nsAString& aColor)
+{
+  if (!mRules) { return NS_ERROR_NOT_INITIALIZED; }
+  ForceCompositionEnd();
+
+  // Protect the edit rules object from dying
+  nsCOMPtr<nsIEditRules> kungFuDeathGrip(mRules);
+
+  nsRefPtr<Selection> selection = GetSelection();
+
+  bool isCollapsed = selection->Collapsed();
+
+  nsAutoEditBatch batchIt(this);
+  nsAutoRules beginRulesSniffing(this, EditAction::insertElement, nsIEditor::eNext);
+  nsAutoSelectionReset selectionResetter(selection, this);
+  nsAutoTxnsConserveSelection dontSpazMySelection(this);
+  
+  bool cancel, handled;
+  nsTextRulesInfo ruleInfo(EditAction::setTextProperty);
+  nsresult res = mRules->WillDoAction(selection, &ruleInfo, &cancel, &handled);
+  NS_ENSURE_SUCCESS(res, res);
+  if (!cancel && !handled)
+  {
+    // loop thru the ranges in the selection
+    nsAutoString bgcolor; bgcolor.AssignLiteral("bgcolor");
+    uint32_t rangeCount = selection->GetRangeCount();
+    for (uint32_t rangeIdx = 0; rangeIdx < rangeCount; ++rangeIdx) {
+      nsCOMPtr<nsIDOMNode> cachedBlockParent = nullptr;
+      nsRefPtr<nsRange> range = selection->GetRangeAt(rangeIdx);
+      NS_ENSURE_TRUE(range, NS_ERROR_FAILURE);
+      
+      // check for easy case: both range endpoints in same text node
+      nsCOMPtr<nsIDOMNode> startNode, endNode;
+      int32_t startOffset, endOffset;
+      res = range->GetStartContainer(getter_AddRefs(startNode));
+      NS_ENSURE_SUCCESS(res, res);
+      res = range->GetEndContainer(getter_AddRefs(endNode));
+      NS_ENSURE_SUCCESS(res, res);
+      res = range->GetStartOffset(&startOffset);
+      NS_ENSURE_SUCCESS(res, res);
+      res = range->GetEndOffset(&endOffset);
+      NS_ENSURE_SUCCESS(res, res);
+      if ((startNode == endNode) && IsTextNode(startNode))
+      {
+        // let's find the block container of the text node
+        nsCOMPtr<nsIDOMNode> blockParent;
+        blockParent = GetBlockNodeParent(startNode);
+        // and apply the background color to that block container
+        if (cachedBlockParent != blockParent)
+        {
+          cachedBlockParent = blockParent;
+          nsCOMPtr<nsIDOMElement> element = do_QueryInterface(blockParent);
+          int32_t count;
+          res = mHTMLCSSUtils->SetCSSEquivalentToHTMLStyle(element, nullptr, &bgcolor, &aColor, &count, false);
+          NS_ENSURE_SUCCESS(res, res);
+        }
+      }
+      else if ((startNode == endNode) && nsTextEditUtils::IsBody(startNode) && isCollapsed)
+      {
+        // we have no block in the document, let's apply the background to the body 
+        nsCOMPtr<nsIDOMElement> element = do_QueryInterface(startNode);
+        int32_t count;
+        res = mHTMLCSSUtils->SetCSSEquivalentToHTMLStyle(element, nullptr, &bgcolor, &aColor, &count, false);
+        NS_ENSURE_SUCCESS(res, res);
+      }
+      else if ((startNode == endNode) && (((endOffset-startOffset) == 1) || (!startOffset && !endOffset)))
+      {
+        // a unique node is selected, let's also apply the background color
+        // to the containing block, possibly the node itself
+        nsCOMPtr<nsIDOMNode> selectedNode = GetChildAt(startNode, startOffset);
+        bool isBlock =false;
+        res = NodeIsBlockStatic(selectedNode, &isBlock);
+        NS_ENSURE_SUCCESS(res, res);
+        nsCOMPtr<nsIDOMNode> blockParent = selectedNode;
+        if (!isBlock) {
+          blockParent = GetBlockNodeParent(selectedNode);
+        }
+        if (cachedBlockParent != blockParent)
+        {
+          cachedBlockParent = blockParent;
+          nsCOMPtr<nsIDOMElement> element = do_QueryInterface(blockParent);
+          int32_t count;
+          res = mHTMLCSSUtils->SetCSSEquivalentToHTMLStyle(element, nullptr, &bgcolor, &aColor, &count, false);
+          NS_ENSURE_SUCCESS(res, res);
+        }
+      }
+      else
+      {
+        // not the easy case.  range not contained in single text node. 
+        // there are up to three phases here.  There are all the nodes
+        // reported by the subtree iterator to be processed.  And there
+        // are potentially a starting textnode and an ending textnode
+        // which are only partially contained by the range.
+        
+        // lets handle the nodes reported by the iterator.  These nodes
+        // are entirely contained in the selection range.  We build up
+        // a list of them (since doing operations on the document during
+        // iteration would perturb the iterator).
+
+        nsCOMPtr<nsIContentIterator> iter =
+          do_CreateInstance("@mozilla.org/content/subtree-content-iterator;1", &res);
+        NS_ENSURE_SUCCESS(res, res);
+        NS_ENSURE_TRUE(iter, NS_ERROR_FAILURE);
+
+        nsCOMArray<nsIDOMNode> arrayOfNodes;
+        nsCOMPtr<nsIDOMNode> node;
+                
+        // iterate range and build up array
+        res = iter->Init(range);
+        // init returns an error if no nodes in range.
+        // this can easily happen with the subtree 
+        // iterator if the selection doesn't contain
+        // any *whole* nodes.
+        if (NS_SUCCEEDED(res))
+        {
+          while (!iter->IsDone())
+          {
+            node = do_QueryInterface(iter->GetCurrentNode());
+            NS_ENSURE_TRUE(node, NS_ERROR_FAILURE);
+
+            if (IsEditable(node))
+            {
+              arrayOfNodes.AppendObject(node);
+            }
+
+            iter->Next();
+          }
+        }
+        // first check the start parent of the range to see if it needs to 
+        // be separately handled (it does if it's a text node, due to how the
+        // subtree iterator works - it will not have reported it).
+        if (IsTextNode(startNode) && IsEditable(startNode))
+        {
+          nsCOMPtr<nsIDOMNode> blockParent;
+          blockParent = GetBlockNodeParent(startNode);
+          if (cachedBlockParent != blockParent)
+          {
+            cachedBlockParent = blockParent;
+            nsCOMPtr<nsIDOMElement> element = do_QueryInterface(blockParent);
+            int32_t count;
+            res = mHTMLCSSUtils->SetCSSEquivalentToHTMLStyle(element, nullptr, &bgcolor, &aColor, &count, false);
+            NS_ENSURE_SUCCESS(res, res);
+          }
+        }
+        
+        // then loop through the list, set the property on each node
+        int32_t listCount = arrayOfNodes.Count();
+        int32_t j;
+        for (j = 0; j < listCount; j++)
+        {
+          node = arrayOfNodes[j];
+          // do we have a block here ?
+          bool isBlock =false;
+          res = NodeIsBlockStatic(node, &isBlock);
+          NS_ENSURE_SUCCESS(res, res);
+          nsCOMPtr<nsIDOMNode> blockParent = node;
+          if (!isBlock) {
+            // no we don't, let's find the block ancestor
+            blockParent = GetBlockNodeParent(node);
+          }
+          if (cachedBlockParent != blockParent)
+          {
+            cachedBlockParent = blockParent;
+            nsCOMPtr<nsIDOMElement> element = do_QueryInterface(blockParent);
+            int32_t count;
+            // and set the property on it
+            res = mHTMLCSSUtils->SetCSSEquivalentToHTMLStyle(element, nullptr, &bgcolor, &aColor, &count, false);
+            NS_ENSURE_SUCCESS(res, res);
+          }
+        }
+        arrayOfNodes.Clear();
+        
+        // last check the end parent of the range to see if it needs to 
+        // be separately handled (it does if it's a text node, due to how the
+        // subtree iterator works - it will not have reported it).
+        if (IsTextNode(endNode) && IsEditable(endNode))
+        {
+          nsCOMPtr<nsIDOMNode> blockParent;
+          blockParent = GetBlockNodeParent(endNode);
+          if (cachedBlockParent != blockParent)
+          {
+            cachedBlockParent = blockParent;
+            nsCOMPtr<nsIDOMElement> element = do_QueryInterface(blockParent);
+            int32_t count;
+            res = mHTMLCSSUtils->SetCSSEquivalentToHTMLStyle(element, nullptr, &bgcolor, &aColor, &count, false);
+            NS_ENSURE_SUCCESS(res, res);
+          }
+        }
+      }
+    }
+  }
+  if (!cancel)
+  {
+    // post-process
+    res = mRules->DidDoAction(selection, &ruleInfo, res);
+  }
+  return res;
+}
+
+NS_IMETHODIMP
+nsHTMLEditor::SetBackgroundColor(const nsAString& aColor)
+{
+  nsresult res;
+  if (IsCSSEnabled()) {
+    // if we are in CSS mode, we have to apply the background color to the
+    // containing block (or the body if we have no block-level element in
+    // the document)
+    res = SetCSSBackgroundColor(aColor);
+  }
+  else {
+    // but in HTML mode, we can only set the document's background color
+    res = SetHTMLBackgroundColor(aColor);
+  }
+  return res;
+}
+
+///////////////////////////////////////////////////////////////////////////
+// NodesSameType: do these nodes have the same tag?
+//                    
+/* virtual */
+bool
+nsHTMLEditor::AreNodesSameType(nsIContent* aNode1, nsIContent* aNode2)
+{
+  MOZ_ASSERT(aNode1);
+  MOZ_ASSERT(aNode2);
+
+  if (aNode1->Tag() != aNode2->Tag()) {
+    return false;
+  }
+
+  if (!IsCSSEnabled() || !aNode1->IsHTML(nsGkAtoms::span)) {
+    return true;
+  }
+
+  // If CSS is enabled, we are stricter about span nodes.
+  return mHTMLCSSUtils->ElementsSameStyle(aNode1->AsDOMNode(),
+                                          aNode2->AsDOMNode());
+}
+
+NS_IMETHODIMP
+nsHTMLEditor::CopyLastEditableChildStyles(nsIDOMNode * aPreviousBlock, nsIDOMNode * aNewBlock,
+                                          nsIDOMNode **aOutBrNode)
+{
+  *aOutBrNode = nullptr;
+  nsCOMPtr<nsIDOMNode> child, tmp;
+  nsresult res;
+  // first, clear out aNewBlock.  Contract is that we want only the styles from previousBlock.
+  res = aNewBlock->GetFirstChild(getter_AddRefs(child));
+  while (NS_SUCCEEDED(res) && child)
+  {
+    res = DeleteNode(child);
+    NS_ENSURE_SUCCESS(res, res);
+    res = aNewBlock->GetFirstChild(getter_AddRefs(child));
+  }
+  // now find and clone the styles
+  child = aPreviousBlock;
+  tmp = aPreviousBlock;
+  while (tmp) {
+    child = tmp;
+    res = GetLastEditableChild(child, address_of(tmp));
+    NS_ENSURE_SUCCESS(res, res);
+  }
+  while (child && nsTextEditUtils::IsBreak(child)) {
+    nsCOMPtr<nsIDOMNode> priorNode;
+    res = GetPriorHTMLNode(child, address_of(priorNode));
+    NS_ENSURE_SUCCESS(res, res);
+    child = priorNode;
+  }
+  nsCOMPtr<nsIDOMNode> newStyles = nullptr, deepestStyle = nullptr;
+  while (child && (child != aPreviousBlock)) {
+    if (nsHTMLEditUtils::IsInlineStyle(child) ||
+        nsEditor::NodeIsType(child, nsEditProperty::span)) {
+      nsAutoString domTagName;
+      child->GetNodeName(domTagName);
+      ToLowerCase(domTagName);
+      if (newStyles) {
+        nsCOMPtr<nsIDOMNode> newContainer;
+        res = InsertContainerAbove(newStyles, address_of(newContainer), domTagName);
+        NS_ENSURE_SUCCESS(res, res);
+        newStyles = newContainer;
+      }
+      else {
+        res = CreateNode(domTagName, aNewBlock, 0, getter_AddRefs(newStyles));
+        NS_ENSURE_SUCCESS(res, res);
+        deepestStyle = newStyles;
+      }
+      res = CloneAttributes(newStyles, child);
+      NS_ENSURE_SUCCESS(res, res);
+    }
+    nsCOMPtr<nsIDOMNode> tmp;
+    res = child->GetParentNode(getter_AddRefs(tmp));
+    NS_ENSURE_SUCCESS(res, res);
+    child = tmp;
+  }
+  if (deepestStyle) {
+    nsCOMPtr<nsIDOMNode> outBRNode;
+    res = CreateBR(deepestStyle, 0, address_of(outBRNode));
+    NS_ENSURE_SUCCESS(res, res);
+    // Getters must addref
+    outBRNode.forget(aOutBrNode);
+  }
+  return NS_OK;
+}
+
+nsresult
+nsHTMLEditor::GetElementOrigin(nsIDOMElement * aElement, int32_t & aX, int32_t & aY)
+{
+  aX = 0;
+  aY = 0;
+
+  NS_ENSURE_TRUE(mDocWeak, NS_ERROR_NOT_INITIALIZED);
+  nsCOMPtr<nsIPresShell> ps = GetPresShell();
+  NS_ENSURE_TRUE(ps, NS_ERROR_NOT_INITIALIZED);
+
+  nsCOMPtr<nsIContent> content = do_QueryInterface(aElement);
+  nsIFrame *frame = content->GetPrimaryFrame();
+  NS_ENSURE_TRUE(frame, NS_OK);
+
+  nsIFrame *container = ps->GetAbsoluteContainingBlock(frame);
+  NS_ENSURE_TRUE(container, NS_OK);
+  nsPoint off = frame->GetOffsetTo(container);
+  aX = nsPresContext::AppUnitsToIntCSSPixels(off.x);
+  aY = nsPresContext::AppUnitsToIntCSSPixels(off.y);
+
+  return NS_OK;
+}
+
+nsresult
+nsHTMLEditor::EndUpdateViewBatch()
+{
+  nsresult res = nsEditor::EndUpdateViewBatch();
+  NS_ENSURE_SUCCESS(res, res);
+
+  // We may need to show resizing handles or update existing ones after
+  // all transactions are done. This way of doing is preferred to DOM
+  // mutation events listeners because all the changes the user can apply
+  // to a document may result in multiple events, some of them quite hard
+  // to listen too (in particular when an ancestor of the selection is
+  // changed but the selection itself is not changed).
+  if (mUpdateCount == 0) {
+    nsCOMPtr<nsISelection> selection;
+    res = GetSelection(getter_AddRefs(selection));
+    NS_ENSURE_SUCCESS(res, res);
+    NS_ENSURE_TRUE(selection, NS_ERROR_NOT_INITIALIZED);
+    res = CheckSelectionStateForAnonymousButtons(selection);
+  }
+  return res;
+}
+
+NS_IMETHODIMP
+nsHTMLEditor::GetSelectionContainer(nsIDOMElement ** aReturn)
+{
+  nsCOMPtr<nsISelection>selection;
+  nsresult res = GetSelection(getter_AddRefs(selection));
+  // if we don't get the selection, just skip this
+  if (NS_FAILED(res) || !selection) return res;
+
+  nsCOMPtr<nsIDOMNode> focusNode;
+
+  if (selection->Collapsed()) {
+    res = selection->GetFocusNode(getter_AddRefs(focusNode));
+    NS_ENSURE_SUCCESS(res, res);
+  } else {
+
+    int32_t rangeCount;
+    res = selection->GetRangeCount(&rangeCount);
+    NS_ENSURE_SUCCESS(res, res);
+
+    if (rangeCount == 1) {
+
+      nsCOMPtr<nsIDOMRange> range;
+      res = selection->GetRangeAt(0, getter_AddRefs(range));
+      NS_ENSURE_SUCCESS(res, res);
+      NS_ENSURE_TRUE(range, NS_ERROR_NULL_POINTER);
+
+      nsCOMPtr<nsIDOMNode> startContainer, endContainer;
+      res = range->GetStartContainer(getter_AddRefs(startContainer));
+      NS_ENSURE_SUCCESS(res, res);
+      res = range->GetEndContainer(getter_AddRefs(endContainer));
+      NS_ENSURE_SUCCESS(res, res);
+      int32_t startOffset, endOffset;
+      res = range->GetStartOffset(&startOffset);
+      NS_ENSURE_SUCCESS(res, res);
+      res = range->GetEndOffset(&endOffset);
+      NS_ENSURE_SUCCESS(res, res);
+
+      nsCOMPtr<nsIDOMElement> focusElement;
+      if (startContainer == endContainer && startOffset + 1 == endOffset) {
+        res = GetSelectedElement(EmptyString(), getter_AddRefs(focusElement));
+        NS_ENSURE_SUCCESS(res, res);
+        if (focusElement)
+          focusNode = do_QueryInterface(focusElement);
+      }
+      if (!focusNode) {
+        res = range->GetCommonAncestorContainer(getter_AddRefs(focusNode));
+        NS_ENSURE_SUCCESS(res, res);
+      }
+    }
+    else {
+      int32_t i;
+      nsCOMPtr<nsIDOMRange> range;
+      for (i = 0; i < rangeCount; i++)
+      {
+        res = selection->GetRangeAt(i, getter_AddRefs(range));
+        NS_ENSURE_SUCCESS(res, res);
+        nsCOMPtr<nsIDOMNode> startContainer;
+        res = range->GetStartContainer(getter_AddRefs(startContainer));
+        if (NS_FAILED(res)) continue;
+        if (!focusNode)
+          focusNode = startContainer;
+        else if (focusNode != startContainer) {
+          res = startContainer->GetParentNode(getter_AddRefs(focusNode));
+          NS_ENSURE_SUCCESS(res, res);
+          break;
+        }
+      }
+    }
+  }
+
+  if (focusNode) {
+    uint16_t nodeType;
+    focusNode->GetNodeType(&nodeType);
+    if (nsIDOMNode::TEXT_NODE == nodeType) {
+      nsCOMPtr<nsIDOMNode> parent;
+      res = focusNode->GetParentNode(getter_AddRefs(parent));
+      NS_ENSURE_SUCCESS(res, res);
+      focusNode = parent;
+    }
+  }
+
+  nsCOMPtr<nsIDOMElement> focusElement = do_QueryInterface(focusNode);
+  focusElement.forget(aReturn);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsHTMLEditor::IsAnonymousElement(nsIDOMElement * aElement, bool * aReturn)
+{
+  NS_ENSURE_TRUE(aElement, NS_ERROR_NULL_POINTER);
+  nsCOMPtr<nsIContent> content = do_QueryInterface(aElement);
+  *aReturn = content->IsRootOfNativeAnonymousSubtree();
+  return NS_OK;
+}
+
+nsresult
+nsHTMLEditor::SetReturnInParagraphCreatesNewParagraph(bool aCreatesNewParagraph)
+{
+  mCRInParagraphCreatesParagraph = aCreatesNewParagraph;
+  return NS_OK;
+}
+
+bool
+nsHTMLEditor::GetReturnInParagraphCreatesNewParagraph()
+{
+  return mCRInParagraphCreatesParagraph;
+}
+
+nsresult
+nsHTMLEditor::GetReturnInParagraphCreatesNewParagraph(bool *aCreatesNewParagraph)
+{
+  *aCreatesNewParagraph = mCRInParagraphCreatesParagraph;
+  return NS_OK;
+}
+
+already_AddRefed<nsIContent>
+nsHTMLEditor::GetFocusedContent()
+{
+  NS_ENSURE_TRUE(mDocWeak, nullptr);
+
+  nsFocusManager* fm = nsFocusManager::GetFocusManager();
+  NS_ENSURE_TRUE(fm, nullptr);
+
+  nsCOMPtr<nsIContent> focusedContent = fm->GetFocusedContent();
+
+  nsCOMPtr<nsIDocument> doc = do_QueryReferent(mDocWeak);
+  bool inDesignMode = doc->HasFlag(NODE_IS_EDITABLE);
+  if (!focusedContent) {
+    // in designMode, nobody gets focus in most cases.
+    if (inDesignMode && OurWindowHasFocus()) {
+      nsCOMPtr<nsIContent> docRoot = doc->GetRootElement();
+      return docRoot.forget();
+    }
+    return nullptr;
+  }
+
+  if (inDesignMode) {
+    return OurWindowHasFocus() &&
+      nsContentUtils::ContentIsDescendantOf(focusedContent, doc) ?
+      focusedContent.forget() : nullptr;
+  }
+
+  // We're HTML editor for contenteditable
+
+  // If the focused content isn't editable, or it has independent selection,
+  // we don't have focus.
+  if (!focusedContent->HasFlag(NODE_IS_EDITABLE) ||
+      focusedContent->HasIndependentSelection()) {
+    return nullptr;
+  }
+  // If our window is focused, we're focused.
+  return OurWindowHasFocus() ? focusedContent.forget() : nullptr;
+}
+
+already_AddRefed<nsIContent>
+nsHTMLEditor::GetFocusedContentForIME()
+{
+  nsCOMPtr<nsIContent> focusedContent = GetFocusedContent();
+  if (!focusedContent) {
+    return nullptr;
+  }
+
+  nsCOMPtr<nsIDocument> doc = do_QueryReferent(mDocWeak);
+  NS_ENSURE_TRUE(doc, nullptr);
+  return doc->HasFlag(NODE_IS_EDITABLE) ? nullptr : focusedContent.forget();
+}
+
+bool
+nsHTMLEditor::IsActiveInDOMWindow()
+{
+  NS_ENSURE_TRUE(mDocWeak, false);
+
+  nsFocusManager* fm = nsFocusManager::GetFocusManager();
+  NS_ENSURE_TRUE(fm, false);
+
+  nsCOMPtr<nsIDocument> doc = do_QueryReferent(mDocWeak);
+  bool inDesignMode = doc->HasFlag(NODE_IS_EDITABLE);
+
+  // If we're in designMode, we're always active in the DOM window.
+  if (inDesignMode) {
+    return true;
+  }
+
+  nsPIDOMWindow* ourWindow = doc->GetWindow();
+  nsCOMPtr<nsPIDOMWindow> win;
+  nsIContent* content =
+    nsFocusManager::GetFocusedDescendant(ourWindow, false,
+                                         getter_AddRefs(win));
+  if (!content) {
+    return false;
+  }
+
+  // We're HTML editor for contenteditable
+
+  // If the active content isn't editable, or it has independent selection,
+  // we're not active).
+  if (!content->HasFlag(NODE_IS_EDITABLE) ||
+      content->HasIndependentSelection()) {
+    return false;
+  }
+  return true;
+}
+
+dom::Element*
+nsHTMLEditor::GetActiveEditingHost()
+{
+  NS_ENSURE_TRUE(mDocWeak, nullptr);
+
+  nsCOMPtr<nsIDocument> doc = do_QueryReferent(mDocWeak);
+  NS_ENSURE_TRUE(doc, nullptr);
+  if (doc->HasFlag(NODE_IS_EDITABLE)) {
+    return doc->GetBodyElement();
+  }
+
+  // We're HTML editor for contenteditable
+  nsCOMPtr<nsISelection> selection;
+  nsresult rv = GetSelection(getter_AddRefs(selection));
+  NS_ENSURE_SUCCESS(rv, nullptr);
+  nsCOMPtr<nsIDOMNode> focusNode;
+  rv = selection->GetFocusNode(getter_AddRefs(focusNode));
+  NS_ENSURE_SUCCESS(rv, nullptr);
+  nsCOMPtr<nsIContent> content = do_QueryInterface(focusNode);
+  if (!content) {
+    return nullptr;
+  }
+
+  // If the active content isn't editable, or it has independent selection,
+  // we're not active.
+  if (!content->HasFlag(NODE_IS_EDITABLE) ||
+      content->HasIndependentSelection()) {
+    return nullptr;
+  }
+  return content->GetEditingHost();
+}
+
+already_AddRefed<mozilla::dom::EventTarget>
+nsHTMLEditor::GetDOMEventTarget()
+{
+  // Don't use getDocument here, because we have no way of knowing
+  // whether Init() was ever called.  So we need to get the document
+  // ourselves, if it exists.
+  NS_PRECONDITION(mDocWeak, "This editor has not been initialized yet");
+  nsCOMPtr<mozilla::dom::EventTarget> target = do_QueryReferent(mDocWeak);
+  return target.forget();
+}
+
+bool
+nsHTMLEditor::ShouldReplaceRootElement()
+{
+  if (!mRootElement) {
+    // If we don't know what is our root element, we should find our root.
+    return true;
+  }
+
+  // If we temporary set document root element to mRootElement, but there is
+  // body element now, we should replace the root element by the body element.
+  nsCOMPtr<nsIDOMHTMLElement> docBody;
+  GetBodyElement(getter_AddRefs(docBody));
+  return !SameCOMIdentity(docBody, mRootElement);
+}
+
+void
+nsHTMLEditor::ResetRootElementAndEventTarget()
+{
+  nsCOMPtr<nsIMutationObserver> kungFuDeathGrip(this);
+
+  // Need to remove the event listeners first because BeginningOfDocument
+  // could set a new root (and event target is set by InstallEventListeners())
+  // and we won't be able to remove them from the old event target then.
+  RemoveEventListeners();
+  mRootElement = nullptr;
+  nsresult rv = InstallEventListeners();
+  if (NS_FAILED(rv)) {
+    return;
+  }
+
+  // We must have mRootElement now.
+  nsCOMPtr<nsIDOMElement> root;
+  rv = GetRootElement(getter_AddRefs(root));
+  if (NS_FAILED(rv) || !mRootElement) {
+    return;
+  }
+
+  rv = BeginningOfDocument();
+  if (NS_FAILED(rv)) {
+    return;
+  }
+
+  // When this editor has focus, we need to reset the selection limiter to
+  // new root.  Otherwise, that is going to be done when this gets focus.
+  nsCOMPtr<nsINode> node = GetFocusedNode();
+  nsCOMPtr<nsIDOMEventTarget> target = do_QueryInterface(node);
+  if (target) {
+    InitializeSelection(target);
+  }
+
+  SyncRealTimeSpell();
+}
+
+nsresult
+nsHTMLEditor::GetBodyElement(nsIDOMHTMLElement** aBody)
+{
+  NS_PRECONDITION(mDocWeak, "bad state, null mDocWeak");
+  nsCOMPtr<nsIDOMHTMLDocument> htmlDoc = do_QueryReferent(mDocWeak);
+  if (!htmlDoc) {
+    return NS_ERROR_NOT_INITIALIZED;
+  }
+  return htmlDoc->GetBody(aBody);
+}
+
+already_AddRefed<nsINode>
+nsHTMLEditor::GetFocusedNode()
+{
+  nsCOMPtr<nsIContent> focusedContent = GetFocusedContent();
+  if (!focusedContent) {
+    return nullptr;
+  }
+
+  nsIFocusManager* fm = nsFocusManager::GetFocusManager();
+  NS_ASSERTION(fm, "Focus manager is null");
+  nsCOMPtr<nsIDOMElement> focusedElement;
+  fm->GetFocusedElement(getter_AddRefs(focusedElement));
+  if (focusedElement) {
+    nsCOMPtr<nsINode> node = do_QueryInterface(focusedElement);
+    return node.forget();
+  }
+
+  nsCOMPtr<nsIDocument> doc = do_QueryReferent(mDocWeak);
+  return doc.forget();
+}
+
+bool
+nsHTMLEditor::OurWindowHasFocus()
+{
+  NS_ENSURE_TRUE(mDocWeak, false);
+  nsIFocusManager* fm = nsFocusManager::GetFocusManager();
+  NS_ENSURE_TRUE(fm, false);
+  nsCOMPtr<nsIDOMWindow> focusedWindow;
+  fm->GetFocusedWindow(getter_AddRefs(focusedWindow));
+  if (!focusedWindow) {
+    return false;
+  }
+  nsCOMPtr<nsIDocument> doc = do_QueryReferent(mDocWeak);
+  nsCOMPtr<nsIDOMWindow> ourWindow = do_QueryInterface(doc->GetWindow());
+  return ourWindow == focusedWindow;
+}
+
+bool
+nsHTMLEditor::IsAcceptableInputEvent(nsIDOMEvent* aEvent)
+{
+  if (!nsEditor::IsAcceptableInputEvent(aEvent)) {
+    return false;
+  }
+
+  NS_ENSURE_TRUE(mDocWeak, false);
+
+  nsCOMPtr<nsIDOMEventTarget> target;
+  aEvent->GetTarget(getter_AddRefs(target));
+  NS_ENSURE_TRUE(target, false);
+
+  nsCOMPtr<nsIDocument> document = do_QueryReferent(mDocWeak);
+  if (document->HasFlag(NODE_IS_EDITABLE)) {
+    // If this editor is in designMode and the event target is the document,
+    // the event is for this editor.
+    nsCOMPtr<nsIDocument> targetDocument = do_QueryInterface(target);
+    if (targetDocument) {
+      return targetDocument == document;
+    }
+    // Otherwise, check whether the event target is in this document or not.
+    nsCOMPtr<nsIContent> targetContent = do_QueryInterface(target);
+    NS_ENSURE_TRUE(targetContent, false);
+    return document == targetContent->GetCurrentDoc();
+  }
+
+  // This HTML editor is for contenteditable.  We need to check the validity of
+  // the target.
+  nsCOMPtr<nsIContent> targetContent = do_QueryInterface(target);
+  NS_ENSURE_TRUE(targetContent, false);
+
+  // If the event is a mouse event, we need to check if the target content is
+  // the focused editing host or its descendant.
+  nsCOMPtr<nsIDOMMouseEvent> mouseEvent = do_QueryInterface(aEvent);
+  if (mouseEvent) {
+    nsIContent* editingHost = GetActiveEditingHost();
+    // If there is no active editing host, we cannot handle the mouse event
+    // correctly.
+    if (!editingHost) {
+      return false;
+    }
+    // If clicked on non-editable root element but the body element is the
+    // active editing host, we should assume that the click event is targetted.
+    if (targetContent == document->GetRootElement() &&
+        !targetContent->HasFlag(NODE_IS_EDITABLE) &&
+        editingHost == document->GetBodyElement()) {
+      targetContent = editingHost;
+    }
+    // If the target element is neither the active editing host nor a descendant
+    // of it, we may not be able to handle the event.
+    if (!nsContentUtils::ContentIsDescendantOf(targetContent, editingHost)) {
+      return false;
+    }
+    // If the clicked element has an independent selection, we shouldn't
+    // handle this click event.
+    if (targetContent->HasIndependentSelection()) {
+      return false;
+    }
+    // If the target content is editable, we should handle this event.
+    return targetContent->HasFlag(NODE_IS_EDITABLE);
+  }
+
+  // If the target of the other events which target focused element isn't
+  // editable or has an independent selection, this editor shouldn't handle the
+  // event.
+  if (!targetContent->HasFlag(NODE_IS_EDITABLE) ||
+      targetContent->HasIndependentSelection()) {
+    return false;
+  }
+
+  // Finally, check whether we're actually focused or not.  When we're not
+  // focused, we should ignore the dispatched event by script (or something)
+  // because content editable element needs selection in itself for editing.
+  // However, when we're not focused, it's not guaranteed.
+  return IsActiveInDOMWindow();
+}
+
+NS_IMETHODIMP
+nsHTMLEditor::GetPreferredIMEState(IMEState *aState)
+{
+  // HTML editor don't prefer the CSS ime-mode because IE didn't do so too.
+  aState->mOpen = IMEState::DONT_CHANGE_OPEN_STATE;
+  if (IsReadonly() || IsDisabled()) {
+    aState->mEnabled = IMEState::DISABLED;
+  } else {
+    aState->mEnabled = IMEState::ENABLED;
+  }
+  return NS_OK;
+}
+
+already_AddRefed<nsIContent>
+nsHTMLEditor::GetInputEventTargetContent()
+{
+  nsCOMPtr<nsIContent> target = GetActiveEditingHost();
+  return target.forget();
+}
+
+bool
+nsHTMLEditor::IsEditable(nsIContent* aNode) {
+  if (!nsPlaintextEditor::IsEditable(aNode)) {
+    return false;
+  }
+  if (aNode->IsElement()) {
+    // If we're dealing with an element, then ask it whether it's editable.
+    return aNode->IsEditable();
+  }
+  // We might be dealing with a text node for example, which we always consider
+  // to be editable.
+  return true;
+}
+
+// virtual MOZ_OVERRIDE
+dom::Element*
+nsHTMLEditor::GetEditorRoot()
+{
+  return GetActiveEditingHost();
+}