Add m-esr52 at 52.6.0

1 files changed, 1264 insertions, 0 deletions

diff --git a/dom/base/nsGlobalWindowCommands.cpp b/dom/base/nsGlobalWindowCommands.cpp
new file mode 100644
index 000000000..3ab2566b8
--- /dev/null
+++ b/dom/base/nsGlobalWindowCommands.cpp
@@ -0,0 +1,1264 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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 "nsGlobalWindowCommands.h"
+
+#include "nsIComponentManager.h"
+#include "nsIDOMElement.h"
+#include "nsIInterfaceRequestor.h"
+#include "nsIInterfaceRequestorUtils.h"
+#include "nsCRT.h"
+#include "nsString.h"
+#include "mozilla/ArrayUtils.h"
+#include "mozilla/Preferences.h"
+
+#include "nsIControllerCommandTable.h"
+#include "nsICommandParams.h"
+
+#include "nsPIDOMWindow.h"
+#include "nsIPresShell.h"
+#include "nsIDocShell.h"
+#include "nsISelectionController.h"
+#include "nsIWebNavigation.h"
+#include "nsIContentViewerEdit.h"
+#include "nsIContentViewer.h"
+#include "nsFocusManager.h"
+#include "nsCopySupport.h"
+#include "nsIClipboard.h"
+#include "ContentEventHandler.h"
+#include "nsContentUtils.h"
+#include "nsIWordBreaker.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/BasicEvents.h"
+#include "mozilla/TextEvents.h"
+#include "mozilla/dom/Selection.h"
+
+#include "nsIClipboardDragDropHooks.h"
+#include "nsIClipboardDragDropHookList.h"
+
+using namespace mozilla;
+
+const char * const sSelectAllString = "cmd_selectAll";
+const char * const sSelectNoneString = "cmd_selectNone";
+const char * const sCopyImageLocationString = "cmd_copyImageLocation";
+const char * const sCopyImageContentsString = "cmd_copyImageContents";
+const char * const sCopyImageString = "cmd_copyImage";
+
+const char * const sScrollTopString = "cmd_scrollTop";
+const char * const sScrollBottomString = "cmd_scrollBottom";
+const char * const sScrollPageUpString = "cmd_scrollPageUp";
+const char * const sScrollPageDownString = "cmd_scrollPageDown";
+const char * const sScrollLineUpString = "cmd_scrollLineUp";
+const char * const sScrollLineDownString = "cmd_scrollLineDown";
+const char * const sScrollLeftString = "cmd_scrollLeft";
+const char * const sScrollRightString = "cmd_scrollRight";
+const char * const sMoveTopString = "cmd_moveTop";
+const char * const sMoveBottomString = "cmd_moveBottom";
+const char * const sMovePageUpString = "cmd_movePageUp";
+const char * const sMovePageDownString = "cmd_movePageDown";
+const char * const sLinePreviousString = "cmd_linePrevious";
+const char * const sLineNextString = "cmd_lineNext";
+const char * const sCharPreviousString = "cmd_charPrevious";
+const char * const sCharNextString = "cmd_charNext";
+
+// These are so the browser can use editor navigation key bindings
+// helps with accessibility (boolean pref accessibility.browsewithcaret)
+
+const char * const sSelectCharPreviousString = "cmd_selectCharPrevious";
+const char * const sSelectCharNextString = "cmd_selectCharNext";
+
+const char * const sWordPreviousString = "cmd_wordPrevious";
+const char * const sWordNextString = "cmd_wordNext";
+const char * const sSelectWordPreviousString = "cmd_selectWordPrevious";
+const char * const sSelectWordNextString = "cmd_selectWordNext";
+
+const char * const sBeginLineString = "cmd_beginLine";
+const char * const sEndLineString = "cmd_endLine";
+const char * const sSelectBeginLineString = "cmd_selectBeginLine";
+const char * const sSelectEndLineString = "cmd_selectEndLine";
+
+const char * const sSelectLinePreviousString = "cmd_selectLinePrevious";
+const char * const sSelectLineNextString = "cmd_selectLineNext";
+
+const char * const sSelectPageUpString = "cmd_selectPageUp";
+const char * const sSelectPageDownString = "cmd_selectPageDown";
+
+const char * const sSelectTopString = "cmd_selectTop";
+const char * const sSelectBottomString = "cmd_selectBottom";
+
+// Physical-direction movement and selection commands
+const char * const sMoveLeftString = "cmd_moveLeft";
+const char * const sMoveRightString = "cmd_moveRight";
+const char * const sMoveUpString = "cmd_moveUp";
+const char * const sMoveDownString = "cmd_moveDown";
+const char * const sMoveLeft2String = "cmd_moveLeft2";
+const char * const sMoveRight2String = "cmd_moveRight2";
+const char * const sMoveUp2String = "cmd_moveUp2";
+const char * const sMoveDown2String = "cmd_moveDown2";
+
+const char * const sSelectLeftString = "cmd_selectLeft";
+const char * const sSelectRightString = "cmd_selectRight";
+const char * const sSelectUpString = "cmd_selectUp";
+const char * const sSelectDownString = "cmd_selectDown";
+const char * const sSelectLeft2String = "cmd_selectLeft2";
+const char * const sSelectRight2String = "cmd_selectRight2";
+const char * const sSelectUp2String = "cmd_selectUp2";
+const char * const sSelectDown2String = "cmd_selectDown2";
+
+#if 0
+#pragma mark -
+#endif
+
+// a base class for selection-related commands, for code sharing
+class nsSelectionCommandsBase : public nsIControllerCommand
+{
+public:
+  NS_DECL_ISUPPORTS
+  NS_IMETHOD IsCommandEnabled(const char* aCommandName, nsISupports* aCommandContext, bool* _retval) override;
+  NS_IMETHOD GetCommandStateParams(const char* aCommandName, nsICommandParams* aParams, nsISupports* aCommandContext) override;
+  NS_IMETHOD DoCommandParams(const char* aCommandName, nsICommandParams* aParams, nsISupports* aCommandContext) override;
+
+protected:
+  virtual ~nsSelectionCommandsBase() {}
+
+  static nsresult  GetPresShellFromWindow(nsPIDOMWindowOuter *aWindow, nsIPresShell **aPresShell);
+  static nsresult  GetSelectionControllerFromWindow(nsPIDOMWindowOuter *aWindow, nsISelectionController **aSelCon);
+
+  // no member variables, please, we're stateless!
+};
+
+// this class implements commands whose behavior depends on the 'browse with caret' setting
+class nsSelectMoveScrollCommand : public nsSelectionCommandsBase
+{
+public:
+
+  NS_IMETHOD DoCommand(const char * aCommandName, nsISupports *aCommandContext);
+
+  // no member variables, please, we're stateless!
+};
+
+// this class implements physical-movement versions of the above
+class nsPhysicalSelectMoveScrollCommand : public nsSelectionCommandsBase
+{
+public:
+
+  NS_IMETHOD DoCommand(const char * aCommandName, nsISupports *aCommandContext);
+
+  // no member variables, please, we're stateless!
+};
+
+// this class implements other selection commands
+class nsSelectCommand : public nsSelectionCommandsBase
+{
+public:
+
+  NS_IMETHOD DoCommand(const char * aCommandName, nsISupports *aCommandContext);
+
+  // no member variables, please, we're stateless!
+};
+
+// this class implements physical-movement versions of selection commands
+class nsPhysicalSelectCommand : public nsSelectionCommandsBase
+{
+public:
+
+  NS_IMETHOD DoCommand(const char * aCommandName, nsISupports *aCommandContext);
+
+  // no member variables, please, we're stateless!
+};
+
+#if 0
+#pragma mark -
+#endif
+
+
+NS_IMPL_ISUPPORTS(nsSelectionCommandsBase, nsIControllerCommand)
+
+NS_IMETHODIMP
+nsSelectionCommandsBase::IsCommandEnabled(const char * aCommandName,
+                                      nsISupports *aCommandContext,
+                                      bool *outCmdEnabled)
+{
+  // XXX this needs fixing. e.g. you can't scroll up if you're already at the top of
+  // the document.
+  *outCmdEnabled = true;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSelectionCommandsBase::GetCommandStateParams(const char *aCommandName,
+                                            nsICommandParams *aParams, nsISupports *aCommandContext)
+{
+  // XXX we should probably return the enabled state
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+nsSelectionCommandsBase::DoCommandParams(const char *aCommandName,
+                                       nsICommandParams *aParams, nsISupports *aCommandContext)
+{
+  return DoCommand(aCommandName, aCommandContext);
+}
+
+// protected methods
+
+nsresult
+nsSelectionCommandsBase::GetPresShellFromWindow(nsPIDOMWindowOuter *aWindow, nsIPresShell **aPresShell)
+{
+  *aPresShell = nullptr;
+  NS_ENSURE_TRUE(aWindow, NS_ERROR_FAILURE);
+
+  nsIDocShell *docShell = aWindow->GetDocShell();
+  NS_ENSURE_TRUE(docShell, NS_ERROR_FAILURE);
+
+  NS_IF_ADDREF(*aPresShell = docShell->GetPresShell());
+  return NS_OK;
+}
+
+nsresult
+nsSelectionCommandsBase::GetSelectionControllerFromWindow(nsPIDOMWindowOuter *aWindow, nsISelectionController **aSelCon)
+{
+  *aSelCon = nullptr;
+
+  nsCOMPtr<nsIPresShell> presShell;
+  GetPresShellFromWindow(aWindow, getter_AddRefs(presShell));
+  if (presShell)
+    return CallQueryInterface(presShell, aSelCon);
+
+  return NS_ERROR_FAILURE;
+}
+
+#if 0
+#pragma mark -
+#endif
+
+// Helpers for nsSelectMoveScrollCommand and nsPhysicalSelectMoveScrollCommand
+static void
+AdjustFocusAfterCaretMove(nsPIDOMWindowOuter* aWindow)
+{
+  // adjust the focus to the new caret position
+  nsIFocusManager* fm = nsFocusManager::GetFocusManager();
+  if (fm) {
+    nsCOMPtr<nsIDOMElement> result;
+    fm->MoveFocus(aWindow, nullptr, nsIFocusManager::MOVEFOCUS_CARET,
+                  nsIFocusManager::FLAG_NOSCROLL, getter_AddRefs(result));
+  }
+}
+
+static bool
+IsCaretOnInWindow(nsPIDOMWindowOuter* aWindow, nsISelectionController* aSelCont)
+{
+  // We allow the caret to be moved with arrow keys on any window for which
+  // the caret is enabled. In particular, this includes caret-browsing mode
+  // in non-chrome documents.
+  bool caretOn = false;
+  aSelCont->GetCaretEnabled(&caretOn);
+  if (!caretOn) {
+    caretOn = Preferences::GetBool("accessibility.browsewithcaret");
+    if (caretOn) {
+      nsCOMPtr<nsIDocShell> docShell = aWindow->GetDocShell();
+      if (docShell && docShell->ItemType() == nsIDocShellTreeItem::typeChrome) {
+        caretOn = false;
+      }
+    }
+  }
+  return caretOn;
+}
+
+static const struct BrowseCommand {
+  const char *reverse, *forward;
+  nsresult (NS_STDCALL nsISelectionController::*scroll)(bool);
+  nsresult (NS_STDCALL nsISelectionController::*move)(bool, bool);
+} browseCommands[] = {
+ { sScrollTopString, sScrollBottomString,
+   &nsISelectionController::CompleteScroll },
+ { sScrollPageUpString, sScrollPageDownString,
+   &nsISelectionController::ScrollPage },
+ { sScrollLineUpString, sScrollLineDownString,
+   &nsISelectionController::ScrollLine },
+ { sScrollLeftString, sScrollRightString,
+   &nsISelectionController::ScrollCharacter },
+ { sMoveTopString, sMoveBottomString,
+   &nsISelectionController::CompleteScroll,
+   &nsISelectionController::CompleteMove },
+ { sMovePageUpString, sMovePageDownString,
+   &nsISelectionController::ScrollPage,
+   &nsISelectionController::PageMove },
+ { sLinePreviousString, sLineNextString,
+   &nsISelectionController::ScrollLine,
+   &nsISelectionController::LineMove },
+ { sWordPreviousString, sWordNextString,
+   &nsISelectionController::ScrollCharacter,
+   &nsISelectionController::WordMove },
+ { sCharPreviousString, sCharNextString,
+   &nsISelectionController::ScrollCharacter,
+   &nsISelectionController::CharacterMove },
+ { sBeginLineString, sEndLineString,
+   &nsISelectionController::CompleteScroll,
+   &nsISelectionController::IntraLineMove }
+};
+
+nsresult
+nsSelectMoveScrollCommand::DoCommand(const char *aCommandName, nsISupports *aCommandContext)
+{
+  nsCOMPtr<nsPIDOMWindowOuter> piWindow(do_QueryInterface(aCommandContext));
+  nsCOMPtr<nsISelectionController> selCont;
+  GetSelectionControllerFromWindow(piWindow, getter_AddRefs(selCont));
+  NS_ENSURE_TRUE(selCont, NS_ERROR_NOT_INITIALIZED);       
+
+  bool caretOn = IsCaretOnInWindow(piWindow, selCont);
+
+  for (size_t i = 0; i < ArrayLength(browseCommands); i++) {
+    bool forward = !strcmp(aCommandName, browseCommands[i].forward);
+    if (forward || !strcmp(aCommandName, browseCommands[i].reverse)) {
+      if (caretOn && browseCommands[i].move &&
+          NS_SUCCEEDED((selCont->*(browseCommands[i].move))(forward, false))) {
+        AdjustFocusAfterCaretMove(piWindow);
+        return NS_OK;
+      }
+      return (selCont->*(browseCommands[i].scroll))(forward);
+    }
+  }
+
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+// XXX It's not clear to me yet how we should handle the "scroll" option
+// for these commands; for now, I'm mapping them back to ScrollCharacter,
+// ScrollLine, etc., as if for horizontal-mode content, but this may need
+// to be reconsidered once we have more experience with vertical content.
+static const struct PhysicalBrowseCommand {
+  const char *command;
+  int16_t direction, amount;
+  nsresult (NS_STDCALL nsISelectionController::*scroll)(bool);
+} physicalBrowseCommands[] = {
+ { sMoveLeftString, nsISelectionController::MOVE_LEFT, 0,
+   &nsISelectionController::ScrollCharacter },
+ { sMoveRightString, nsISelectionController::MOVE_RIGHT, 0,
+   &nsISelectionController::ScrollCharacter },
+ { sMoveUpString, nsISelectionController::MOVE_UP, 0,
+   &nsISelectionController::ScrollLine },
+ { sMoveDownString, nsISelectionController::MOVE_DOWN, 0,
+   &nsISelectionController::ScrollLine },
+ { sMoveLeft2String, nsISelectionController::MOVE_LEFT, 1,
+   &nsISelectionController::ScrollCharacter },
+ { sMoveRight2String, nsISelectionController::MOVE_RIGHT, 1,
+   &nsISelectionController::ScrollCharacter },
+ { sMoveUp2String, nsISelectionController::MOVE_UP, 1,
+   &nsISelectionController::CompleteScroll },
+ { sMoveDown2String, nsISelectionController::MOVE_DOWN, 1,
+   &nsISelectionController::CompleteScroll },
+};
+
+nsresult
+nsPhysicalSelectMoveScrollCommand::DoCommand(const char *aCommandName,
+                                             nsISupports *aCommandContext)
+{
+  nsCOMPtr<nsPIDOMWindowOuter> piWindow(do_QueryInterface(aCommandContext));
+  nsCOMPtr<nsISelectionController> selCont;
+  GetSelectionControllerFromWindow(piWindow, getter_AddRefs(selCont));
+  NS_ENSURE_TRUE(selCont, NS_ERROR_NOT_INITIALIZED);       
+
+  bool caretOn = IsCaretOnInWindow(piWindow, selCont);
+
+  for (size_t i = 0; i < ArrayLength(physicalBrowseCommands); i++) {
+    const PhysicalBrowseCommand& cmd = physicalBrowseCommands[i];
+    if (!strcmp(aCommandName, cmd.command)) {
+      int16_t dir = cmd.direction;
+      if (caretOn &&
+          NS_SUCCEEDED(selCont->PhysicalMove(dir, cmd.amount, false))) {
+        AdjustFocusAfterCaretMove(piWindow);
+        return NS_OK;
+      }
+
+      bool forward = (dir == nsISelectionController::MOVE_RIGHT ||
+                      dir == nsISelectionController::MOVE_DOWN);
+      return (selCont->*(cmd.scroll))(forward);
+    }
+  }
+
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+#if 0
+#pragma mark -
+#endif
+
+static const struct SelectCommand {
+  const char *reverse, *forward;
+  nsresult (NS_STDCALL nsISelectionController::*select)(bool, bool);
+} selectCommands[] = {
+ { sSelectCharPreviousString, sSelectCharNextString,
+   &nsISelectionController::CharacterMove },
+ { sSelectWordPreviousString, sSelectWordNextString,
+   &nsISelectionController::WordMove },
+ { sSelectBeginLineString, sSelectEndLineString,
+   &nsISelectionController::IntraLineMove },
+ { sSelectLinePreviousString, sSelectLineNextString,
+   &nsISelectionController::LineMove },
+ { sSelectPageUpString, sSelectPageDownString,
+   &nsISelectionController::PageMove },
+ { sSelectTopString, sSelectBottomString,
+   &nsISelectionController::CompleteMove }
+};
+
+nsresult
+nsSelectCommand::DoCommand(const char *aCommandName,
+                           nsISupports *aCommandContext)
+{
+  nsCOMPtr<nsPIDOMWindowOuter> piWindow(do_QueryInterface(aCommandContext));
+  nsCOMPtr<nsISelectionController> selCont;
+  GetSelectionControllerFromWindow(piWindow, getter_AddRefs(selCont));
+  NS_ENSURE_TRUE(selCont, NS_ERROR_NOT_INITIALIZED);       
+
+  // These commands are so the browser can use caret navigation key bindings -
+  // Helps with accessibility - aaronl@netscape.com
+  for (size_t i = 0; i < ArrayLength(selectCommands); i++) {
+    bool forward = !strcmp(aCommandName, selectCommands[i].forward);
+    if (forward || !strcmp(aCommandName, selectCommands[i].reverse)) {
+      return (selCont->*(selectCommands[i].select))(forward, true);
+    }
+  }
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+#if 0
+#pragma mark -
+#endif
+
+static const struct PhysicalSelectCommand {
+  const char *command;
+  int16_t direction, amount;
+} physicalSelectCommands[] = {
+ { sSelectLeftString, nsISelectionController::MOVE_LEFT, 0 },
+ { sSelectRightString, nsISelectionController::MOVE_RIGHT, 0 },
+ { sSelectUpString, nsISelectionController::MOVE_UP, 0 },
+ { sSelectDownString, nsISelectionController::MOVE_DOWN, 0 },
+ { sSelectLeft2String, nsISelectionController::MOVE_LEFT, 1 },
+ { sSelectRight2String, nsISelectionController::MOVE_RIGHT, 1 },
+ { sSelectUp2String, nsISelectionController::MOVE_UP, 1 },
+ { sSelectDown2String, nsISelectionController::MOVE_DOWN, 1 }
+};
+
+nsresult
+nsPhysicalSelectCommand::DoCommand(const char *aCommandName,
+                                   nsISupports *aCommandContext)
+{
+  nsCOMPtr<nsPIDOMWindowOuter> piWindow(do_QueryInterface(aCommandContext));
+  nsCOMPtr<nsISelectionController> selCont;
+  GetSelectionControllerFromWindow(piWindow, getter_AddRefs(selCont));
+  NS_ENSURE_TRUE(selCont, NS_ERROR_NOT_INITIALIZED);       
+
+  for (size_t i = 0; i < ArrayLength(physicalSelectCommands); i++) {
+    if (!strcmp(aCommandName, physicalSelectCommands[i].command)) {
+      return selCont->PhysicalMove(physicalSelectCommands[i].direction,
+                                   physicalSelectCommands[i].amount,
+                                   true);
+    }
+  }
+
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+#if 0
+#pragma mark -
+#endif
+
+class nsClipboardCommand final : public nsIControllerCommand
+{
+  ~nsClipboardCommand() {}
+
+public:
+
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSICONTROLLERCOMMAND
+};
+
+NS_IMPL_ISUPPORTS(nsClipboardCommand, nsIControllerCommand)
+
+nsresult
+nsClipboardCommand::IsCommandEnabled(const char* aCommandName, nsISupports *aContext, bool *outCmdEnabled)
+{
+  NS_ENSURE_ARG_POINTER(outCmdEnabled);
+  *outCmdEnabled = false;
+
+  if (strcmp(aCommandName, "cmd_copy") &&
+      strcmp(aCommandName, "cmd_copyAndCollapseToEnd") &&
+      strcmp(aCommandName, "cmd_cut") &&
+      strcmp(aCommandName, "cmd_paste"))
+    return NS_OK;
+
+  nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryInterface(aContext);
+  NS_ENSURE_TRUE(window, NS_ERROR_FAILURE);
+
+  nsCOMPtr<nsIDocument> doc = window->GetExtantDoc();
+  if (doc->IsHTMLOrXHTML()) {
+    // In HTML and XHTML documents, we always want the cut, copy and paste
+    // commands to be enabled.
+    *outCmdEnabled = true;
+  } else {
+    // Cut isn't enabled in xul documents which use nsClipboardCommand
+    if (strcmp(aCommandName, "cmd_copy") == 0 ||
+        strcmp(aCommandName, "cmd_copyAndCollapseToEnd") == 0) {
+      *outCmdEnabled = nsCopySupport::CanCopy(doc);
+    }
+  }
+  return NS_OK;
+}
+
+nsresult
+nsClipboardCommand::DoCommand(const char *aCommandName, nsISupports *aContext)
+{
+  if (strcmp(aCommandName, "cmd_cut") &&
+      strcmp(aCommandName, "cmd_copy") &&
+      strcmp(aCommandName, "cmd_copyAndCollapseToEnd") &&
+      strcmp(aCommandName, "cmd_paste"))
+    return NS_OK;
+
+  nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryInterface(aContext);
+  NS_ENSURE_TRUE(window, NS_ERROR_FAILURE);
+
+  nsIDocShell *docShell = window->GetDocShell();
+  NS_ENSURE_TRUE(docShell, NS_ERROR_FAILURE);
+
+  nsCOMPtr<nsIPresShell> presShell = docShell->GetPresShell();
+  NS_ENSURE_TRUE(presShell, NS_ERROR_FAILURE);
+
+  EventMessage eventMessage = eCopy;
+  if (strcmp(aCommandName, "cmd_cut") == 0) {
+    eventMessage = eCut;
+  } else if (strcmp(aCommandName, "cmd_paste") == 0) {
+    eventMessage = ePaste;
+  }
+
+  bool actionTaken = false;
+  bool notCancelled =
+    nsCopySupport::FireClipboardEvent(eventMessage,
+                                      nsIClipboard::kGlobalClipboard,
+                                      presShell, nullptr, &actionTaken);
+
+  if (notCancelled && !strcmp(aCommandName, "cmd_copyAndCollapseToEnd")) {
+    dom::Selection *sel =
+      presShell->GetCurrentSelection(SelectionType::eNormal);
+    NS_ENSURE_TRUE(sel, NS_ERROR_FAILURE);
+    sel->CollapseToEnd();
+  }
+
+  if (actionTaken) {
+    return NS_OK;
+  }
+  return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP
+nsClipboardCommand::GetCommandStateParams(const char *aCommandName,
+                                              nsICommandParams *aParams, nsISupports *aCommandContext)
+{
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+nsresult
+nsClipboardCommand::DoCommandParams(const char *aCommandName, nsICommandParams* aParams, nsISupports *aContext)
+{
+  return DoCommand(aCommandName, aContext);
+}
+
+#if 0
+#pragma mark -
+#endif
+
+class nsSelectionCommand : public nsIControllerCommand
+{
+public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSICONTROLLERCOMMAND
+
+protected:
+  virtual ~nsSelectionCommand() {}
+
+  virtual nsresult    IsClipboardCommandEnabled(const char * aCommandName, nsIContentViewerEdit* aEdit, bool *outCmdEnabled) = 0;
+  virtual nsresult    DoClipboardCommand(const char *aCommandName, nsIContentViewerEdit* aEdit, nsICommandParams* aParams) = 0;
+  
+  static nsresult     GetContentViewerEditFromContext(nsISupports *aContext, nsIContentViewerEdit **aEditInterface);
+  
+  // no member variables, please, we're stateless!
+};
+
+
+NS_IMPL_ISUPPORTS(nsSelectionCommand, nsIControllerCommand)
+
+
+/*---------------------------------------------------------------------------
+
+  nsSelectionCommand
+
+----------------------------------------------------------------------------*/
+
+NS_IMETHODIMP
+nsSelectionCommand::IsCommandEnabled(const char * aCommandName,
+                                     nsISupports *aCommandContext,
+                                     bool *outCmdEnabled)
+{
+  NS_ENSURE_ARG_POINTER(outCmdEnabled);
+  *outCmdEnabled = false;
+
+  nsCOMPtr<nsIContentViewerEdit> contentEdit;
+  GetContentViewerEditFromContext(aCommandContext,  getter_AddRefs(contentEdit));
+  NS_ENSURE_TRUE(contentEdit, NS_ERROR_NOT_INITIALIZED);
+
+  return IsClipboardCommandEnabled(aCommandName, contentEdit, outCmdEnabled);
+}
+
+NS_IMETHODIMP
+nsSelectionCommand::DoCommand(const char *aCommandName,
+                              nsISupports *aCommandContext)
+{
+  nsCOMPtr<nsIContentViewerEdit> contentEdit;
+  GetContentViewerEditFromContext(aCommandContext,  getter_AddRefs(contentEdit));
+  NS_ENSURE_TRUE(contentEdit, NS_ERROR_NOT_INITIALIZED);
+
+  return DoClipboardCommand(aCommandName, contentEdit, nullptr);
+}
+
+NS_IMETHODIMP
+nsSelectionCommand::GetCommandStateParams(const char *aCommandName,
+                                          nsICommandParams *aParams,
+                                          nsISupports *aCommandContext)
+{
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+nsSelectionCommand::DoCommandParams(const char *aCommandName,
+                                    nsICommandParams *aParams,
+                                    nsISupports *aCommandContext)
+{
+  nsCOMPtr<nsIContentViewerEdit> contentEdit;
+  GetContentViewerEditFromContext(aCommandContext,  getter_AddRefs(contentEdit));
+  NS_ENSURE_TRUE(contentEdit, NS_ERROR_NOT_INITIALIZED);
+
+  return DoClipboardCommand(aCommandName, contentEdit, aParams);
+}
+
+nsresult
+nsSelectionCommand::GetContentViewerEditFromContext(nsISupports *aContext,
+                                                    nsIContentViewerEdit **aEditInterface)
+{
+  NS_ENSURE_ARG(aEditInterface);
+  *aEditInterface = nullptr;
+
+  nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryInterface(aContext);
+  NS_ENSURE_TRUE(window, NS_ERROR_INVALID_ARG);
+
+  nsIDocShell *docShell = window->GetDocShell();
+  NS_ENSURE_TRUE(docShell, NS_ERROR_FAILURE);
+
+  nsCOMPtr<nsIContentViewer> viewer;
+  docShell->GetContentViewer(getter_AddRefs(viewer));
+  nsCOMPtr<nsIContentViewerEdit> edit(do_QueryInterface(viewer));
+  NS_ENSURE_TRUE(edit, NS_ERROR_FAILURE);
+
+  edit.forget(aEditInterface);
+  return NS_OK;
+}
+
+#if 0
+#pragma mark -
+#endif
+
+#define NS_DECL_CLIPBOARD_COMMAND(_cmd)                                                     \
+class _cmd : public nsSelectionCommand                                                      \
+{                                                                                           \
+protected:                                                                                  \
+                                                                                            \
+  virtual nsresult    IsClipboardCommandEnabled(const char* aCommandName,                   \
+                                  nsIContentViewerEdit* aEdit, bool *outCmdEnabled);        \
+  virtual nsresult    DoClipboardCommand(const char* aCommandName,                          \
+                                  nsIContentViewerEdit* aEdit, nsICommandParams* aParams);  \
+  /* no member variables, please, we're stateless! */                                       \
+};
+
+NS_DECL_CLIPBOARD_COMMAND(nsClipboardCopyLinkCommand)
+NS_DECL_CLIPBOARD_COMMAND(nsClipboardImageCommands)
+NS_DECL_CLIPBOARD_COMMAND(nsClipboardSelectAllNoneCommands)
+NS_DECL_CLIPBOARD_COMMAND(nsClipboardGetContentsCommand)
+
+nsresult
+nsClipboardCopyLinkCommand::IsClipboardCommandEnabled(const char* aCommandName, nsIContentViewerEdit* aEdit, bool *outCmdEnabled)
+{
+  return aEdit->GetInLink(outCmdEnabled);
+}
+
+nsresult
+nsClipboardCopyLinkCommand::DoClipboardCommand(const char *aCommandName, nsIContentViewerEdit* aEdit, nsICommandParams* aParams)
+{
+  return aEdit->CopyLinkLocation();
+}
+
+#if 0
+#pragma mark -
+#endif
+
+nsresult
+nsClipboardImageCommands::IsClipboardCommandEnabled(const char* aCommandName, nsIContentViewerEdit* aEdit, bool *outCmdEnabled)
+{
+  return aEdit->GetInImage(outCmdEnabled);
+}
+
+nsresult
+nsClipboardImageCommands::DoClipboardCommand(const char *aCommandName, nsIContentViewerEdit* aEdit, nsICommandParams* aParams)
+{
+  if (!nsCRT::strcmp(sCopyImageLocationString, aCommandName))
+    return aEdit->CopyImage(nsIContentViewerEdit::COPY_IMAGE_TEXT);
+  if (!nsCRT::strcmp(sCopyImageContentsString, aCommandName))
+    return aEdit->CopyImage(nsIContentViewerEdit::COPY_IMAGE_DATA);
+  int32_t copyFlags = nsIContentViewerEdit::COPY_IMAGE_DATA | 
+                      nsIContentViewerEdit::COPY_IMAGE_HTML;
+  if (aParams)
+    aParams->GetLongValue("imageCopy", &copyFlags);
+  return aEdit->CopyImage(copyFlags);
+}
+
+#if 0
+#pragma mark -
+#endif
+
+nsresult
+nsClipboardSelectAllNoneCommands::IsClipboardCommandEnabled(const char* aCommandName, nsIContentViewerEdit* aEdit, bool *outCmdEnabled)
+{
+  *outCmdEnabled = true;
+  return NS_OK;
+}
+
+nsresult
+nsClipboardSelectAllNoneCommands::DoClipboardCommand(const char *aCommandName, nsIContentViewerEdit* aEdit, nsICommandParams* aParams)
+{
+  if (!nsCRT::strcmp(sSelectAllString, aCommandName))
+    return aEdit->SelectAll();
+
+  return aEdit->ClearSelection();
+}
+
+
+#if 0
+#pragma mark -
+#endif
+
+nsresult
+nsClipboardGetContentsCommand::IsClipboardCommandEnabled(const char* aCommandName, nsIContentViewerEdit* aEdit, bool *outCmdEnabled)
+{
+  return aEdit->GetCanGetContents(outCmdEnabled);
+}
+
+nsresult
+nsClipboardGetContentsCommand::DoClipboardCommand(const char *aCommandName, nsIContentViewerEdit* aEdit, nsICommandParams* aParams)
+{
+  NS_ENSURE_ARG(aParams);
+
+  nsAutoCString mimeType("text/plain");
+
+  nsXPIDLCString format;    // nsICommandParams needs to use nsACString
+  if (NS_SUCCEEDED(aParams->GetCStringValue("format", getter_Copies(format))))
+    mimeType.Assign(format);
+  
+  bool selectionOnly = false;
+  aParams->GetBooleanValue("selection_only", &selectionOnly);
+  
+  nsAutoString contents;
+  nsresult rv = aEdit->GetContents(mimeType.get(), selectionOnly, contents);
+  if (NS_FAILED(rv))
+    return rv;
+    
+  return aParams->SetStringValue("result", contents);
+}
+
+#if 0   // Remove unless needed again, bug 204777
+class nsWebNavigationBaseCommand : public nsIControllerCommand
+{
+public:
+  virtual ~nsWebNavigationBaseCommand() {}
+
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSICONTROLLERCOMMAND
+
+protected:
+
+  virtual nsresult    IsWebNavCommandEnabled(const char * aCommandName, nsIWebNavigation* aWebNavigation, bool *outCmdEnabled) = 0;
+  virtual nsresult    DoWebNavCommand(const char *aCommandName, nsIWebNavigation* aWebNavigation) = 0;
+  
+  static nsresult     GetWebNavigationFromContext(nsISupports *aContext, nsIWebNavigation **aWebNavigation);
+  
+  // no member variables, please, we're stateless!
+};
+
+class nsGoForwardCommand : public nsWebNavigationBaseCommand
+{
+protected:
+
+  virtual nsresult    IsWebNavCommandEnabled(const char * aCommandName, nsIWebNavigation* aWebNavigation, bool *outCmdEnabled);
+  virtual nsresult    DoWebNavCommand(const char *aCommandName, nsIWebNavigation* aWebNavigation);
+  // no member variables, please, we're stateless!
+};
+
+class nsGoBackCommand : public nsWebNavigationBaseCommand
+{
+protected:
+
+  virtual nsresult    IsWebNavCommandEnabled(const char * aCommandName, nsIWebNavigation* aWebNavigation, bool *outCmdEnabled);
+  virtual nsresult    DoWebNavCommand(const char *aCommandName, nsIWebNavigation* aWebNavigation);
+  // no member variables, please, we're stateless!
+};
+
+/*---------------------------------------------------------------------------
+
+  nsWebNavigationCommands
+     no params
+----------------------------------------------------------------------------*/
+
+NS_IMPL_ISUPPORTS(nsWebNavigationBaseCommand, nsIControllerCommand)
+
+NS_IMETHODIMP
+nsWebNavigationBaseCommand::IsCommandEnabled(const char * aCommandName,
+                                          nsISupports *aCommandContext,
+                                          bool *outCmdEnabled)
+{
+  NS_ENSURE_ARG_POINTER(outCmdEnabled);
+  *outCmdEnabled = false;
+
+  nsCOMPtr<nsIWebNavigation> webNav;
+  GetWebNavigationFromContext(aCommandContext, getter_AddRefs(webNav));
+  NS_ENSURE_TRUE(webNav, NS_ERROR_INVALID_ARG);
+  
+  return IsCommandEnabled(aCommandName, webNav, outCmdEnabled);
+}
+
+NS_IMETHODIMP
+nsWebNavigationBaseCommand::GetCommandStateParams(const char *aCommandName,
+                                            nsICommandParams *aParams, nsISupports *aCommandContext)
+{
+  // XXX we should probably return the enabled state
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+nsWebNavigationBaseCommand::DoCommand(const char *aCommandName,
+                                   nsISupports *aCommandContext)
+{
+  nsCOMPtr<nsIWebNavigation> webNav;
+  GetWebNavigationFromContext(aCommandContext, getter_AddRefs(webNav));
+  NS_ENSURE_TRUE(webNav, NS_ERROR_INVALID_ARG);
+  
+  return DoWebNavCommand(aCommandName, webNav);
+}
+
+NS_IMETHODIMP
+nsWebNavigationBaseCommand::DoCommandParams(const char *aCommandName,
+                                       nsICommandParams *aParams, nsISupports *aCommandContext)
+{
+  return DoCommand(aCommandName, aCommandContext);
+}
+
+nsresult
+nsWebNavigationBaseCommand::GetWebNavigationFromContext(nsISupports *aContext, nsIWebNavigation **aWebNavigation)
+{
+  nsCOMPtr<nsIInterfaceRequestor> windowReq = do_QueryInterface(aContext);
+  CallGetInterface(windowReq.get(), aWebNavigation);
+  return (*aWebNavigation) ? NS_OK : NS_ERROR_FAILURE;
+}
+
+nsresult
+nsGoForwardCommand::IsWebNavCommandEnabled(const char * aCommandName, nsIWebNavigation* aWebNavigation, bool *outCmdEnabled)
+{
+  return aWebNavigation->GetCanGoForward(outCmdEnabled);
+}
+
+nsresult
+nsGoForwardCommand::DoWebNavCommand(const char *aCommandName, nsIWebNavigation* aWebNavigation)
+{
+  return aWebNavigation->GoForward();
+}
+
+nsresult
+nsGoBackCommand::IsWebNavCommandEnabled(const char * aCommandName, nsIWebNavigation* aWebNavigation, bool *outCmdEnabled)
+{
+  return aWebNavigation->GetCanGoBack(outCmdEnabled);
+}
+
+nsresult
+nsGoBackCommand::DoWebNavCommand(const char *aCommandName, nsIWebNavigation* aWebNavigation)
+{
+  return aWebNavigation->GoBack();
+}
+#endif
+
+/*---------------------------------------------------------------------------
+
+  nsClipboardDragDropHookCommand
+      params        value type   possible values
+      "addhook"     isupports    nsIClipboardDragDropHooks as nsISupports
+      "removehook"  isupports    nsIClipboardDragDropHooks as nsISupports
+
+----------------------------------------------------------------------------*/
+
+class nsClipboardDragDropHookCommand final : public nsIControllerCommand
+{
+  ~nsClipboardDragDropHookCommand() {}
+
+public:
+
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSICONTROLLERCOMMAND
+
+protected:                                                                                   
+  // no member variables, please, we're stateless!
+};
+
+
+NS_IMPL_ISUPPORTS(nsClipboardDragDropHookCommand, nsIControllerCommand)
+
+NS_IMETHODIMP
+nsClipboardDragDropHookCommand::IsCommandEnabled(const char * aCommandName,
+                                                 nsISupports *aCommandContext,
+                                                 bool *outCmdEnabled)
+{
+  *outCmdEnabled = true;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsClipboardDragDropHookCommand::DoCommand(const char *aCommandName,
+                                          nsISupports *aCommandContext)
+{
+  return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP
+nsClipboardDragDropHookCommand::DoCommandParams(const char *aCommandName,
+                                                nsICommandParams *aParams,
+                                                nsISupports *aCommandContext)
+{
+  NS_ENSURE_ARG(aParams);
+
+  nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryInterface(aCommandContext);
+  NS_ENSURE_TRUE(window, NS_ERROR_FAILURE);
+
+  nsIDocShell *docShell = window->GetDocShell();
+
+  nsCOMPtr<nsIClipboardDragDropHookList> obj = do_GetInterface(docShell);
+  if (!obj) return NS_ERROR_INVALID_ARG;
+
+  nsCOMPtr<nsISupports> isuppHook;
+
+  nsresult returnValue = NS_OK;
+  nsresult rv = aParams->GetISupportsValue("addhook", getter_AddRefs(isuppHook));
+  if (NS_SUCCEEDED(rv))
+  {
+    nsCOMPtr<nsIClipboardDragDropHooks> hook = do_QueryInterface(isuppHook);
+    if (hook)
+      returnValue = obj->AddClipboardDragDropHooks(hook);
+    else
+      returnValue = NS_ERROR_INVALID_ARG;
+  }
+
+  rv = aParams->GetISupportsValue("removehook", getter_AddRefs(isuppHook));
+  if (NS_SUCCEEDED(rv))
+  {
+    nsCOMPtr<nsIClipboardDragDropHooks> hook = do_QueryInterface(isuppHook);
+    if (hook)
+    {
+      rv = obj->RemoveClipboardDragDropHooks(hook);
+      if (NS_FAILED(rv) && NS_SUCCEEDED(returnValue))
+        returnValue = rv;
+    }
+    else
+      returnValue = NS_ERROR_INVALID_ARG;
+  }
+
+  return returnValue;
+}
+
+NS_IMETHODIMP
+nsClipboardDragDropHookCommand::GetCommandStateParams(const char *aCommandName,
+                                                      nsICommandParams *aParams,
+                                                      nsISupports *aCommandContext)
+{
+  NS_ENSURE_ARG_POINTER(aParams);
+  return aParams->SetBooleanValue("state_enabled", true);
+}
+
+class nsLookUpDictionaryCommand final : public nsIControllerCommand
+{
+public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSICONTROLLERCOMMAND
+
+private:
+  virtual ~nsLookUpDictionaryCommand()
+  {
+  }
+};
+
+NS_IMPL_ISUPPORTS(nsLookUpDictionaryCommand, nsIControllerCommand)
+
+NS_IMETHODIMP
+nsLookUpDictionaryCommand::IsCommandEnabled(
+                             const char* aCommandName,
+                             nsISupports* aCommandContext,
+                             bool* aRetval)
+{
+  *aRetval = true;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsLookUpDictionaryCommand::GetCommandStateParams(const char* aCommandName,
+                                                 nsICommandParams* aParams,
+                                                 nsISupports* aCommandContext)
+{
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+nsLookUpDictionaryCommand::DoCommand(const char* aCommandName,
+                                     nsISupports *aCommandContext)
+{
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+nsLookUpDictionaryCommand::DoCommandParams(const char* aCommandName,
+                                           nsICommandParams* aParams,
+                                           nsISupports* aCommandContext)
+{
+  if (NS_WARN_IF(!nsContentUtils::IsSafeToRunScript())) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  int32_t x;
+  int32_t y;
+
+  nsresult rv = aParams->GetLongValue("x", &x);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = aParams->GetLongValue("y", &y);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  LayoutDeviceIntPoint point(x, y);
+
+  nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryInterface(aCommandContext);
+  if (NS_WARN_IF(!window)) {
+    return NS_ERROR_FAILURE;
+  }
+
+  nsIDocShell* docShell = window->GetDocShell();
+  if (NS_WARN_IF(!docShell)) {
+    return NS_ERROR_FAILURE;
+  }
+
+  nsCOMPtr<nsIPresShell> presShell = docShell->GetPresShell();
+  if (NS_WARN_IF(!presShell)) {
+    return NS_ERROR_FAILURE;
+  }
+
+  nsPresContext* presContext = presShell->GetPresContext();
+  if (NS_WARN_IF(!presContext)) {
+    return NS_ERROR_FAILURE;
+  }
+
+  nsCOMPtr<nsIWidget> widget = presContext->GetRootWidget();
+  if (NS_WARN_IF(!widget)) {
+    return NS_ERROR_FAILURE;
+  }
+
+  WidgetQueryContentEvent charAt(true, eQueryCharacterAtPoint, widget);
+  charAt.mRefPoint.x = x;
+  charAt.mRefPoint.y = y;
+  ContentEventHandler handler(presContext);
+  handler.OnQueryCharacterAtPoint(&charAt);
+
+  if (NS_WARN_IF(!charAt.mSucceeded) ||
+      charAt.mReply.mOffset == WidgetQueryContentEvent::NOT_FOUND) {
+    return NS_ERROR_FAILURE;
+  }
+
+  WidgetQueryContentEvent textContent(true, eQueryTextContent, widget);
+  // OSX 10.7 queries 50 characters before/after current point.  So we fetch
+  // same length.
+  uint32_t offset = charAt.mReply.mOffset;
+  if (offset > 50) {
+    offset -= 50;
+  } else {
+    offset = 0;
+  }
+  textContent.InitForQueryTextContent(offset, 100);
+  handler.OnQueryTextContent(&textContent);
+  if (NS_WARN_IF(!textContent.mSucceeded ||
+                 textContent.mReply.mString.IsEmpty())) {
+    return NS_ERROR_FAILURE;
+  }
+
+  // XXX nsIWordBreaker doesn't use contextual breaker.
+  // If OS provides it, widget should use it if contextual breaker is needed.
+  nsCOMPtr<nsIWordBreaker> wordBreaker = nsContentUtils::WordBreaker();
+  if (NS_WARN_IF(!wordBreaker)) {
+    return NS_ERROR_FAILURE;
+  }
+
+  nsWordRange range =
+    wordBreaker->FindWord(textContent.mReply.mString.get(),
+                          textContent.mReply.mString.Length(),
+                          charAt.mReply.mOffset - offset);
+  if (range.mEnd == range.mBegin) {
+    return NS_ERROR_FAILURE;
+  }
+  range.mBegin += offset;
+  range.mEnd += offset;
+
+  WidgetQueryContentEvent lookUpContent(true, eQueryTextContent, widget);
+  lookUpContent.InitForQueryTextContent(range.mBegin,
+                                        range.mEnd - range.mBegin);
+  lookUpContent.RequestFontRanges();
+  handler.OnQueryTextContent(&lookUpContent);
+  if (NS_WARN_IF(!lookUpContent.mSucceeded ||
+                 lookUpContent.mReply.mString.IsEmpty())) {
+    return NS_ERROR_FAILURE;
+  }
+
+  WidgetQueryContentEvent charRect(true, eQueryTextRect, widget);
+  charRect.InitForQueryTextRect(range.mBegin, range.mEnd - range.mBegin);
+  handler.OnQueryTextRect(&charRect);
+  if (NS_WARN_IF(!charRect.mSucceeded)) {
+    return NS_ERROR_FAILURE;
+  }
+
+  widget->LookUpDictionary(lookUpContent.mReply.mString,
+                           lookUpContent.mReply.mFontRanges,
+                           charRect.mReply.mWritingMode.IsVertical(),
+                           charRect.mReply.mRect.TopLeft());
+
+  return NS_OK;
+}
+
+/*---------------------------------------------------------------------------
+
+  RegisterWindowCommands
+
+----------------------------------------------------------------------------*/
+
+#define NS_REGISTER_ONE_COMMAND(_cmdClass, _cmdName)                \
+  {                                                                 \
+    _cmdClass* theCmd = new _cmdClass();                            \
+    rv = inCommandTable->RegisterCommand(_cmdName,                  \
+                   static_cast<nsIControllerCommand *>(theCmd));    \
+  }
+
+#define NS_REGISTER_FIRST_COMMAND(_cmdClass, _cmdName)              \
+  {                                                                 \
+    _cmdClass* theCmd = new _cmdClass();                            \
+    rv = inCommandTable->RegisterCommand(_cmdName,                  \
+                   static_cast<nsIControllerCommand *>(theCmd));
+
+#define NS_REGISTER_NEXT_COMMAND(_cmdClass, _cmdName)               \
+    rv = inCommandTable->RegisterCommand(_cmdName,                  \
+                   static_cast<nsIControllerCommand *>(theCmd));
+
+#define NS_REGISTER_LAST_COMMAND(_cmdClass, _cmdName)               \
+    rv = inCommandTable->RegisterCommand(_cmdName,                  \
+                   static_cast<nsIControllerCommand *>(theCmd));    \
+  }
+
+
+// static
+nsresult
+nsWindowCommandRegistration::RegisterWindowCommands(
+                               nsIControllerCommandTable *inCommandTable)
+{
+  nsresult rv;
+
+  // XXX rework the macros to use a loop is possible, reducing code size
+  
+  // this set of commands is affected by the 'browse with caret' setting
+  NS_REGISTER_FIRST_COMMAND(nsSelectMoveScrollCommand, sScrollTopString);
+  NS_REGISTER_NEXT_COMMAND(nsSelectMoveScrollCommand, sScrollBottomString);
+  NS_REGISTER_NEXT_COMMAND(nsSelectMoveScrollCommand, sScrollPageUpString);
+  NS_REGISTER_NEXT_COMMAND(nsSelectMoveScrollCommand, sScrollPageDownString);
+  NS_REGISTER_NEXT_COMMAND(nsSelectMoveScrollCommand, sScrollLineUpString);
+  NS_REGISTER_NEXT_COMMAND(nsSelectMoveScrollCommand, sScrollLineDownString);
+  NS_REGISTER_NEXT_COMMAND(nsSelectMoveScrollCommand, sScrollLeftString);
+  NS_REGISTER_NEXT_COMMAND(nsSelectMoveScrollCommand, sScrollRightString);
+  NS_REGISTER_NEXT_COMMAND(nsSelectMoveScrollCommand, sMoveTopString);
+  NS_REGISTER_NEXT_COMMAND(nsSelectMoveScrollCommand, sMoveBottomString);
+  NS_REGISTER_NEXT_COMMAND(nsSelectMoveScrollCommand, sWordPreviousString);
+  NS_REGISTER_NEXT_COMMAND(nsSelectMoveScrollCommand, sWordNextString);
+  NS_REGISTER_NEXT_COMMAND(nsSelectMoveScrollCommand, sBeginLineString);
+  NS_REGISTER_NEXT_COMMAND(nsSelectMoveScrollCommand, sEndLineString);
+  NS_REGISTER_NEXT_COMMAND(nsSelectMoveScrollCommand, sMovePageUpString);
+  NS_REGISTER_NEXT_COMMAND(nsSelectMoveScrollCommand, sMovePageDownString);
+  NS_REGISTER_NEXT_COMMAND(nsSelectMoveScrollCommand, sLinePreviousString);
+  NS_REGISTER_NEXT_COMMAND(nsSelectMoveScrollCommand, sLineNextString);
+  NS_REGISTER_NEXT_COMMAND(nsSelectMoveScrollCommand, sCharPreviousString);
+  NS_REGISTER_LAST_COMMAND(nsSelectMoveScrollCommand, sCharNextString);
+
+  NS_REGISTER_FIRST_COMMAND(nsPhysicalSelectMoveScrollCommand, sMoveLeftString);
+  NS_REGISTER_NEXT_COMMAND(nsPhysicalSelectMoveScrollCommand, sMoveRightString);
+  NS_REGISTER_NEXT_COMMAND(nsPhysicalSelectMoveScrollCommand, sMoveUpString);
+  NS_REGISTER_NEXT_COMMAND(nsPhysicalSelectMoveScrollCommand, sMoveDownString);
+  NS_REGISTER_NEXT_COMMAND(nsPhysicalSelectMoveScrollCommand, sMoveLeft2String);
+  NS_REGISTER_NEXT_COMMAND(nsPhysicalSelectMoveScrollCommand, sMoveRight2String);
+  NS_REGISTER_NEXT_COMMAND(nsPhysicalSelectMoveScrollCommand, sMoveUp2String);
+  NS_REGISTER_LAST_COMMAND(nsPhysicalSelectMoveScrollCommand, sMoveDown2String);
+
+  NS_REGISTER_FIRST_COMMAND(nsSelectCommand, sSelectCharPreviousString);
+  NS_REGISTER_NEXT_COMMAND(nsSelectCommand, sSelectCharNextString);
+  NS_REGISTER_NEXT_COMMAND(nsSelectCommand, sSelectWordPreviousString);
+  NS_REGISTER_NEXT_COMMAND(nsSelectCommand, sSelectWordNextString);
+  NS_REGISTER_NEXT_COMMAND(nsSelectCommand, sSelectBeginLineString);
+  NS_REGISTER_NEXT_COMMAND(nsSelectCommand, sSelectEndLineString);
+  NS_REGISTER_NEXT_COMMAND(nsSelectCommand, sSelectLinePreviousString);
+  NS_REGISTER_NEXT_COMMAND(nsSelectCommand, sSelectLineNextString);
+  NS_REGISTER_NEXT_COMMAND(nsSelectCommand, sSelectPageUpString);
+  NS_REGISTER_NEXT_COMMAND(nsSelectCommand, sSelectPageDownString);
+  NS_REGISTER_NEXT_COMMAND(nsSelectCommand, sSelectTopString);
+  NS_REGISTER_LAST_COMMAND(nsSelectCommand, sSelectBottomString);
+
+  NS_REGISTER_FIRST_COMMAND(nsPhysicalSelectCommand, sSelectLeftString);
+  NS_REGISTER_NEXT_COMMAND(nsPhysicalSelectCommand, sSelectRightString);
+  NS_REGISTER_NEXT_COMMAND(nsPhysicalSelectCommand, sSelectUpString);
+  NS_REGISTER_NEXT_COMMAND(nsPhysicalSelectCommand, sSelectDownString);
+  NS_REGISTER_NEXT_COMMAND(nsPhysicalSelectCommand, sSelectLeft2String);
+  NS_REGISTER_NEXT_COMMAND(nsPhysicalSelectCommand, sSelectRight2String);
+  NS_REGISTER_NEXT_COMMAND(nsPhysicalSelectCommand, sSelectUp2String);
+  NS_REGISTER_LAST_COMMAND(nsPhysicalSelectCommand, sSelectDown2String);
+
+  NS_REGISTER_ONE_COMMAND(nsClipboardCommand, "cmd_cut");
+  NS_REGISTER_ONE_COMMAND(nsClipboardCommand, "cmd_copy");
+  NS_REGISTER_ONE_COMMAND(nsClipboardCommand, "cmd_copyAndCollapseToEnd");
+  NS_REGISTER_ONE_COMMAND(nsClipboardCommand, "cmd_paste");
+  NS_REGISTER_ONE_COMMAND(nsClipboardCopyLinkCommand, "cmd_copyLink");
+  NS_REGISTER_FIRST_COMMAND(nsClipboardImageCommands, sCopyImageLocationString);
+  NS_REGISTER_NEXT_COMMAND(nsClipboardImageCommands, sCopyImageContentsString);
+  NS_REGISTER_LAST_COMMAND(nsClipboardImageCommands, sCopyImageString);
+  NS_REGISTER_FIRST_COMMAND(nsClipboardSelectAllNoneCommands, sSelectAllString);
+  NS_REGISTER_LAST_COMMAND(nsClipboardSelectAllNoneCommands, sSelectNoneString);
+
+  NS_REGISTER_ONE_COMMAND(nsClipboardGetContentsCommand, "cmd_getContents");
+
+#if 0   // Remove unless needed again, bug 204777
+  NS_REGISTER_ONE_COMMAND(nsGoBackCommand, "cmd_browserBack");
+  NS_REGISTER_ONE_COMMAND(nsGoForwardCommand, "cmd_browserForward");
+#endif
+
+  NS_REGISTER_ONE_COMMAND(nsClipboardDragDropHookCommand, "cmd_clipboardDragDropHook");
+
+  NS_REGISTER_ONE_COMMAND(nsLookUpDictionaryCommand, "cmd_lookUpDictionary");
+
+  return rv;
+}