closure 1.1.692

data/closure-library/closure/goog/editor/plugins/undoredo.js

@@ -0,0 +1,1014 @@
+// Copyright 2005 The Closure Library Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS-IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+
+/**
+ * @fileoverview Code for handling edit history (undo/redo).
+ *
+ */
+
+
+goog.provide('goog.editor.plugins.UndoRedo');
+
+goog.require('goog.debug.Logger');
+goog.require('goog.dom');
+goog.require('goog.dom.NodeOffset');
+goog.require('goog.dom.Range');
+goog.require('goog.editor.BrowserFeature');
+goog.require('goog.editor.Command');
+goog.require('goog.editor.Field.EventType');
+goog.require('goog.editor.Plugin');
+goog.require('goog.editor.plugins.UndoRedoManager');
+goog.require('goog.editor.plugins.UndoRedoState');
+goog.require('goog.events');
+goog.require('goog.events.EventHandler');
+
+
+
+/**
+ * Encapsulates undo/redo logic using a custom undo stack (i.e. not browser
+ * built-in). Browser built-in undo stacks are too flaky (e.g. IE's gets
+ * clobbered on DOM modifications). Also, this allows interleaving non-editing
+ * commands into the undo stack via the UndoRedoManager.
+ *
+ * @param {goog.editor.plugins.UndoRedoManager=} opt_manager An undo redo
+ *    manager to be used by this plugin. If none is provided one is created.
+ * @constructor
+ * @extends {goog.editor.Plugin}
+ */
+goog.editor.plugins.UndoRedo = function(opt_manager) {
+  goog.editor.Plugin.call(this);
+
+  this.setUndoRedoManager(opt_manager ||
+      new goog.editor.plugins.UndoRedoManager());
+
+  // Map of goog.editor.Field hashcode to goog.events.EventHandler
+  this.eventHandlers_ = {};
+
+  this.currentStates_ = {};
+
+  /**
+   * @type {?string}
+   * @private
+   */
+  this.initialFieldChange_ = null;
+
+  /**
+   * A copy of {@code goog.editor.plugins.UndoRedo.restoreState} bound to this,
+   * used by undo-redo state objects to restore the state of an editable field.
+   * @type {Function}
+   * @see goog.editor.plugins.UndoRedo#restoreState
+   * @private
+   */
+  this.boundRestoreState_ = goog.bind(this.restoreState, this);
+};
+goog.inherits(goog.editor.plugins.UndoRedo, goog.editor.Plugin);
+
+
+/**
+ * The logger for this class.
+ * @type {goog.debug.Logger}
+ * @protected
+ */
+goog.editor.plugins.UndoRedo.prototype.logger =
+    goog.debug.Logger.getLogger('goog.editor.plugins.UndoRedo');
+
+
+/**
+ * The {@code UndoState_} whose change is in progress, null if an undo or redo
+ * is not in progress.
+ *
+ * @type {goog.editor.plugins.UndoRedo.UndoState_?}
+ * @private
+ */
+goog.editor.plugins.UndoRedo.prototype.inProgressUndo_ = null;
+
+
+/**
+ * The undo-redo stack manager used by this plugin.
+ * @type {goog.editor.plugins.UndoRedoManager}
+ * @private
+ */
+goog.editor.plugins.UndoRedo.prototype.undoManager_;
+
+
+/**
+ * The key for the event listener handling state change events from the
+ * undo-redo manager.
+ * @type {number}
+ * @private
+ */
+goog.editor.plugins.UndoRedo.prototype.managerStateChangeKey_;
+
+
+/**
+ * Commands implemented by this plugin.
+ * @enum {string}
+ */
+goog.editor.plugins.UndoRedo.COMMAND = {
+  UNDO: '+undo',
+  REDO: '+redo'
+};
+
+
+/**
+ * Inverse map of execCommand strings to
+ * {@link goog.editor.plugins.UndoRedo.COMMAND} constants. Used to determine
+ * whether a string corresponds to a command this plugin handles in O(1) time.
+ * @type {Object}
+ * @private
+ */
+goog.editor.plugins.UndoRedo.SUPPORTED_COMMANDS_ =
+    goog.object.transpose(goog.editor.plugins.UndoRedo.COMMAND);
+
+
+/**
+ * Set the max undo stack depth (not the real memory usage).
+ * @param {number} depth Depth of the stack.
+ */
+goog.editor.plugins.UndoRedo.prototype.setMaxUndoDepth = function(depth) {
+  this.undoManager_.setMaxUndoDepth(depth);
+};
+
+
+/**
+ * Set the undo-redo manager used by this plugin. Any state on a previous
+ * undo-redo manager is lost.
+ * @param {goog.editor.plugins.UndoRedoManager} manager The undo-redo manager.
+ */
+goog.editor.plugins.UndoRedo.prototype.setUndoRedoManager = function(manager) {
+  if (this.managerStateChangeKey_) {
+    goog.events.unlistenByKey(this.managerStateChangeKey_);
+  }
+
+  this.undoManager_ = manager;
+  this.managerStateChangeKey_ = /** @type {number} */ (
+      goog.events.listen(this.undoManager_,
+          goog.editor.plugins.UndoRedoManager.EventType.STATE_CHANGE,
+          this.dispatchCommandValueChange_,
+          false,
+          this));
+};
+
+
+/**
+ * Whether the string corresponds to a command this plugin handles.
+ * @param {string} command Command string to check.
+ * @return {boolean} Whether the string corresponds to a command
+ *     this plugin handles.
+ */
+goog.editor.plugins.UndoRedo.prototype.isSupportedCommand = function(command) {
+  return command in goog.editor.plugins.UndoRedo.SUPPORTED_COMMANDS_;
+};
+
+
+/** @inheritDoc */
+goog.editor.plugins.UndoRedo.prototype.registerFieldObject = function(
+    fieldObject) {
+  this.fieldObject = fieldObject;
+};
+
+
+/**
+ * Unregisters and disables the fieldObject with this plugin. Thie does *not*
+ * clobber the undo stack for the fieldObject though.
+ * TODO(user): For the multifield version, we really should add a way to
+ * ignore undo actions on field's that have been made uneditable.
+ * This is probably as simple as skipping over entries in the undo stack
+ * that have a hashcode of an uneditable field.
+ * @param {goog.editor.Field} fieldObject The field to register with the plugin.
+ */
+goog.editor.plugins.UndoRedo.prototype.unregisterFieldObject = function(
+    fieldObject) {
+  this.disable(fieldObject);
+  this.fieldObject = null;
+};
+
+
+/**
+ * This is so subclasses can deal with multifield undo-redo.
+ * @return {goog.editor.Field} The active field object for this field. This is
+ *     the one registered field object for the single-plugin case and the
+ *     focused field for the multi-field plugin case.
+ */
+goog.editor.plugins.UndoRedo.prototype.getCurrentFieldObject = function() {
+  return this.fieldObject;
+};
+
+
+/**
+ * This is so subclasses can deal with multifield undo-redo.
+ * @param {string} fieldHashCode The Field's hashcode.
+ * @return {goog.editor.Field} The field object with the hashcode.
+ */
+goog.editor.plugins.UndoRedo.prototype.getFieldObject = function(
+    fieldHashCode) {
+  // With single field undoredo, there's only one Field involved.
+  return this.fieldObject;
+};
+
+
+/**
+ * This is so subclasses can deal with multifield undo-redo.
+ * @return {goog.editor.Field} Target for COMMAND_VALUE_CHANGE events.
+ */
+goog.editor.plugins.UndoRedo.prototype.getCurrentEventTarget = function() {
+  return this.fieldObject;
+};
+
+
+/** @inheritDoc */
+goog.editor.plugins.UndoRedo.prototype.enable = function(fieldObject) {
+  if (this.isEnabled(fieldObject)) {
+    return;
+  }
+
+  // Don't want pending delayed changes from when undo-redo was disabled
+  // firing after undo-redo is enabled since they might cause undo-redo stack
+  // updates.
+  fieldObject.clearDelayedChange();
+
+  var eventHandler = new goog.events.EventHandler(this);
+
+  // TODO(user): From ojan during a code review:
+  // The beforechange handler is meant to be there so you can grab the cursor
+  // position *before* the change is made as that's where you want the cursor to
+  // be after an undo.
+  //
+  // It kinda looks like updateCurrentState_ doesn't do that correctly right
+  // now, but it really should be fixed to do so. The cursor position stored in
+  // the state should be the cursor position before any changes are made, not
+  // the cursor position when the change finishes.
+  //
+  // It also seems like the if check below is just a bad one. We should do this
+  // for browsers that use mutation events as well even though the beforechange
+  // happens too late...maybe not. I don't know about this.
+  if (!goog.editor.BrowserFeature.USE_MUTATION_EVENTS) {
+    // We don't listen to beforechange in mutation-event browsers because
+    // there we fire beforechange, then syncronously file change. The point
+    // of before change is to capture before the user has changed anything.
+    eventHandler.listen(fieldObject,
+        goog.editor.Field.EventType.BEFORECHANGE, this.handleBeforeChange_);
+  }
+  eventHandler.listen(fieldObject,
+      goog.editor.Field.EventType.DELAYEDCHANGE, this.handleDelayedChange_);
+  eventHandler.listen(fieldObject, goog.editor.Field.EventType.BLUR,
+      this.handleBlur_);
+
+  this.eventHandlers_[fieldObject.getHashCode()] = eventHandler;
+
+  // We want to capture the initial state of a Trogedit field before any
+  // editing has happened. This is necessary so that we can undo the first
+  // change to a field, even if we don't handle beforeChange.
+  this.updateCurrentState_(fieldObject);
+};
+
+
+/** @inheritDoc */
+goog.editor.plugins.UndoRedo.prototype.disable = function(fieldObject) {
+  // Process any pending changes so we don't lose any undo-redo states that we
+  // want prior to disabling undo-redo.
+  fieldObject.clearDelayedChange();
+
+  var eventHandler = this.eventHandlers_[fieldObject.getHashCode()];
+  if (eventHandler) {
+    eventHandler.dispose();
+    delete this.eventHandlers_[fieldObject.getHashCode()];
+  }
+
+  // We delete the current state of the field on disable. When we re-enable
+  // the state will be re-fetched. In most cases the content will be the same,
+  // but this allows us to pick up changes while not editable. That way, when
+  // undoing after starting an editable session, you can always undo to the
+  // state you started in. Given this sequence of events:
+  // Make editable
+  // Type 'anakin'
+  // Make not editable
+  // Set HTML to be 'padme'
+  // Make editable
+  // Type 'dark side'
+  // Undo
+  // Without re-snapshoting current state on enable, the undo would go from
+  // 'dark-side' -> 'anakin', rather than 'dark-side' -> 'padme'. You couldn't
+  // undo the field to the state that existed immediately after it was made
+  // editable for the second time.
+  if (this.currentStates_[fieldObject.getHashCode()]) {
+    delete this.currentStates_[fieldObject.getHashCode()];
+  }
+};
+
+
+/** @inheritDoc */
+goog.editor.plugins.UndoRedo.prototype.isEnabled = function(fieldObject) {
+  // All enabled plugins have a eventHandler so reuse that map rather than
+  // storing additional enabled state.
+  return !!this.eventHandlers_[fieldObject.getHashCode()];
+};
+
+
+/** @inheritDoc */
+goog.editor.plugins.UndoRedo.prototype.disposeInternal = function() {
+  goog.editor.plugins.UndoRedo.superClass_.disposeInternal.call(this);
+
+  for (var hashcode in this.eventHandlers_) {
+    this.eventHandlers_[hashcode].dispose();
+    delete this.eventHandlers_[hashcode];
+  }
+  this.fieldObject = null;
+
+  if (this.undoManager_) {
+    this.undoManager_.dispose();
+    delete this.undoManager_;
+  }
+};
+
+
+/** @inheritDoc */
+goog.editor.plugins.UndoRedo.prototype.getTrogClassId = function() {
+  return 'UndoRedo';
+};
+
+
+/** @inheritDoc */
+goog.editor.plugins.UndoRedo.prototype.execCommand = function(command,
+    var_args) {
+  if (command == goog.editor.plugins.UndoRedo.COMMAND.UNDO) {
+    this.undoManager_.undo();
+  } else if (command == goog.editor.plugins.UndoRedo.COMMAND.REDO) {
+    this.undoManager_.redo();
+  }
+};
+
+
+/** @inheritDoc */
+goog.editor.plugins.UndoRedo.prototype.queryCommandValue = function(command) {
+  var state = null;
+  if (command == goog.editor.plugins.UndoRedo.COMMAND.UNDO) {
+    state = this.undoManager_.hasUndoState();
+  } else if (command == goog.editor.plugins.UndoRedo.COMMAND.REDO) {
+    state = this.undoManager_.hasRedoState();
+  }
+  return state;
+};
+
+
+/**
+ * Dispatches the COMMAND_VALUE_CHANGE event on the editable field or the field
+ * manager, as appropriate.
+ * Note: Really, people using multi field mode should be listening directly
+ * to the undo-redo manager for events.
+ * @private
+ */
+goog.editor.plugins.UndoRedo.prototype.dispatchCommandValueChange_ =
+    function() {
+  var eventTarget = this.getCurrentEventTarget();
+  eventTarget.dispatchEvent({
+    type: goog.editor.Field.EventType.COMMAND_VALUE_CHANGE,
+    commands: [goog.editor.plugins.UndoRedo.COMMAND.REDO,
+      goog.editor.plugins.UndoRedo.COMMAND.UNDO]});
+};
+
+
+/**
+ * Restores the state of the editable field.
+ * @param {goog.editor.plugins.UndoRedo.UndoState_} state The state initiating
+ *    the restore.
+ * @param {string} content The content to restore.
+ * @param {goog.editor.plugins.UndoRedo.CursorPosition_?} cursorPosition
+ *     The cursor position within the content.
+ */
+goog.editor.plugins.UndoRedo.prototype.restoreState = function(
+    state, content, cursorPosition) {
+  // Fire any pending changes to get the current field state up to date and
+  // then stop listening to changes while doing the undo/redo.
+  var fieldObj = this.getFieldObject(state.fieldHashCode);
+  if (!fieldObj) {
+    return;
+  }
+
+  // Fires any pending changes, and stops the change events. Still want to
+  // dispatch before change, as a change is being made and the change event
+  // will be manually dispatched below after the new content has been restored
+  // (also restarting change events).
+  fieldObj.stopChangeEvents(true, true);
+
+  // To prevent the situation where we stop change events and then an exception
+  // happens before we can restart change events, the following code must be in
+  // a try-finally block.
+  try {
+    fieldObj.dispatchBeforeChange();
+
+    // Restore the state
+    fieldObj.execCommand(goog.editor.Command.CLEAR_LOREM, true);
+
+    // We specifically set the raw innerHTML of the field here as that's what
+    // we get from the field when we save an undo/redo state. There's
+    // no need to clean/unclean the contents in either direction.
+    fieldObj.getElement().innerHTML = content;
+
+    if (cursorPosition) {
+      cursorPosition.select();
+    }
+
+    var previousFieldObject = this.getCurrentFieldObject();
+    fieldObj.focus();
+
+    // Apps that integrate their undo-redo with Trogedit may be
+    // in a state where there is no previous field object (no field focused at
+    // the time of undo), so check for existence first.
+    if (previousFieldObject &&
+        previousFieldObject.getHashCode() != state.fieldHashCode) {
+      previousFieldObject.execCommand(goog.editor.Command.UPDATE_LOREM);
+    }
+
+    // We need to update currentState_ to reflect the change.
+    this.currentStates_[state.fieldHashCode].setUndoState(
+        content, cursorPosition);
+  } catch (e) {
+    this.logger.severe('Error while restoring undo state', e);
+  } finally {
+    // Clear the delayed change event, set flag so we know not to act on it.
+    this.inProgressUndo_ = state;
+    // Notify the editor that we've changed (fire autosave).
+    // Note that this starts up change events again, so we don't have to
+    // manually do so even though we stopped change events above.
+    fieldObj.dispatchChange();
+    fieldObj.dispatchSelectionChangeEvent();
+  }
+};
+
+
+/**
+ * @inheritDoc
+ */
+goog.editor.plugins.UndoRedo.prototype.handleKeyboardShortcut = function(e, key,
+    isModifierPressed) {
+  if (isModifierPressed) {
+    var command;
+    if (key == 'z') {
+      command = e.shiftKey ? goog.editor.plugins.UndoRedo.COMMAND.REDO :
+          goog.editor.plugins.UndoRedo.COMMAND.UNDO;
+    } else if (key == 'y') {
+      command = goog.editor.plugins.UndoRedo.COMMAND.REDO;
+    }
+
+    if (command) {
+      // In the case where Trogedit shares its undo redo stack with another
+      // application it's possible that an undo or redo will not be for an
+      // goog.editor.Field. In this case we don't want to go through the
+      // goog.editor.Field execCommand flow which stops and restarts events on
+      // the current field. Only Trogedit UndoState's have a fieldHashCode so
+      // use that to distinguish between Trogedit and other states.
+      var state = command == goog.editor.plugins.UndoRedo.COMMAND.UNDO ?
+          this.undoManager_.undoPeek() : this.undoManager_.redoPeek();
+      if (state && state.fieldHashCode) {
+        this.getCurrentFieldObject().execCommand(command);
+      } else {
+        this.execCommand(command);
+      }
+
+      return true;
+    }
+  }
+
+  return false;
+};
+
+
+/**
+ * Clear the undo/redo stack.
+ */
+goog.editor.plugins.UndoRedo.prototype.clearHistory = function() {
+  // Fire all pending change events, so that they don't come back
+  // asynchronously to fill the queue.
+  this.fieldObject.stopChangeEvents(true, true);
+  this.undoManager_.clearHistory();
+  this.fieldObject.startChangeEvents();
+};
+
+
+/**
+ * Refreshes the current state of the editable field as maintained by undo-redo,
+ * without adding any undo-redo states to the stack.
+ * @param {goog.editor.Field} fieldObject The editable field.
+ */
+goog.editor.plugins.UndoRedo.prototype.refreshCurrentState = function(
+    fieldObject) {
+  if (this.isEnabled(fieldObject)) {
+    if (this.currentStates_[fieldObject.getHashCode()]) {
+      delete this.currentStates_[fieldObject.getHashCode()];
+    }
+    this.updateCurrentState_(fieldObject);
+  }
+};
+
+
+/**
+ * Before the field changes, we want to save the state.
+ * @param {goog.events.Event} e The event.
+ * @private
+ */
+goog.editor.plugins.UndoRedo.prototype.handleBeforeChange_ = function(e) {
+  if (this.inProgressUndo_) {
+    // We are in between a previous undo and its delayed change event.
+    // Continuing here clobbers the redo stack.
+    // This does mean that if you are trying to undo/redo really quickly, it
+    // will be gated by the speed of delayed change events.
+    return;
+  }
+
+  var fieldObj = /** @type {goog.editor.Field} */ (e.target);
+  var fieldHashCode = fieldObj.getHashCode();
+
+  if (this.initialFieldChange_ != fieldHashCode) {
+    this.initialFieldChange_ = fieldHashCode;
+    this.updateCurrentState_(fieldObj);
+  }
+};
+
+
+/**
+ * After some idle time, we want to save the state.
+ * @param {goog.events.Event} e The event.
+ * @private
+ */
+goog.editor.plugins.UndoRedo.prototype.handleDelayedChange_ = function(e) {
+  // This was undo making a change, don't add it BACK into the history
+  if (this.inProgressUndo_) {
+    // Must clear this.inProgressUndo_ before dispatching event because the
+    // dispatch can cause another, queued undo that should be allowed to go
+    // through.
+    var state = this.inProgressUndo_;
+    this.inProgressUndo_ = null;
+    state.dispatchEvent(goog.editor.plugins.UndoRedoState.ACTION_COMPLETED);
+    return;
+  }
+
+  this.updateCurrentState_(/** @type {goog.editor.Field} */ (e.target));
+};
+
+
+/**
+ * When the user blurs away, we need to save the state on that field.
+ * @param {goog.events.Event} e The event.
+ * @private
+ */
+goog.editor.plugins.UndoRedo.prototype.handleBlur_ = function(e) {
+  var fieldObj = /** @type {goog.editor.Field} */ (e.target);
+  if (fieldObj) {
+    fieldObj.clearDelayedChange();
+  }
+};
+
+
+/**
+ * Returns the goog.editor.plugins.UndoRedo.CursorPosition_ for the current
+ * selection in the given Field.
+ * @param {goog.editor.Field} fieldObj The field object.
+ * @return {goog.editor.plugins.UndoRedo.CursorPosition_} The CursorPosition_ or
+ *    null if there is no valid selection.
+ * @private
+ */
+goog.editor.plugins.UndoRedo.prototype.getCursorPosition_ = function(fieldObj) {
+  var cursorPos = new goog.editor.plugins.UndoRedo.CursorPosition_(fieldObj);
+  if (!cursorPos.isValid()) {
+    return null;
+  }
+  return cursorPos;
+};
+
+
+/**
+ * Helper method for saving state.
+ * @param {goog.editor.Field} fieldObj The field object.
+ * @private
+ */
+goog.editor.plugins.UndoRedo.prototype.updateCurrentState_ = function(
+    fieldObj) {
+  var fieldHashCode = fieldObj.getHashCode();
+  // We specifically grab the raw innerHTML of the field here as that's what
+  // we would set on the field in the case of an undo/redo operation. There's
+  // no need to clean/unclean the contents in either direction. In the case of
+  // lorem ipsum being used, we want to capture the effective state (empty, no
+  // cursor position) rather than capturing the lorem html.
+  var content, cursorPos;
+  if (fieldObj.queryCommandValue(goog.editor.Command.USING_LOREM)) {
+    content = '';
+    cursorPos = null;
+  } else {
+    content = fieldObj.getElement().innerHTML;
+    cursorPos = this.getCursorPosition_(fieldObj);
+  }
+
+  var currentState = this.currentStates_[fieldHashCode];
+  if (currentState) {
+    // Don't create states if the content hasn't changed (spurious
+    // delayed change). This can happen when lorem is cleared, for example.
+    if (currentState.undoContent_ == content) {
+      return;
+    } else if (content == '' || currentState.undoContent_ == '') {
+      // If lorem ipsum is on we say the contents are the empty string. However,
+      // for an empty text shape with focus, the empty contents might not be
+      // the same, depending on plugins. We want these two empty states to be
+      // considered identical because to the user they are indistinguishable,
+      // so we use fieldObj.getInjectableContents to map between them.
+      // We cannot use getInjectableContents when first creating the undo
+      // content for a field with lorem, because on enable when this is first
+      // called we can't guarantee plugin registration order, so the
+      // injectableContents at that time might not match the final
+      // injectableContents.
+      var emptyContents = fieldObj.getInjectableContents('', {});
+      if (content == emptyContents && currentState.undoContent_ == '' ||
+          currentState.undoContent_ == emptyContents && content == '') {
+        return;
+      }
+    }
+
+    currentState.setRedoState(content, cursorPos);
+    this.undoManager_.addState(currentState);
+  }
+
+  this.currentStates_[fieldHashCode] =
+      new goog.editor.plugins.UndoRedo.UndoState_(fieldHashCode, content,
+          cursorPos, this.boundRestoreState_);
+};
+
+
+
+/**
+ * This object encapsulates the state of an editable field.
+ *
+ * @param {string} fieldHashCode String the id of the field we're saving the
+ *     content of.
+ * @param {string} content String the actual text we're saving.
+ * @param {goog.editor.plugins.UndoRedo.CursorPosition_?} cursorPosition
+ *     CursorPosLite object for the cursor position in the field.
+ * @param {Function} restore The function used to restore editable field state.
+ * @private
+ * @constructor
+ * @extends {goog.editor.plugins.UndoRedoState}
+ */
+goog.editor.plugins.UndoRedo.UndoState_ = function(fieldHashCode, content,
+    cursorPosition, restore) {
+  goog.editor.plugins.UndoRedoState.call(this, true);
+
+  /**
+   * The hash code for the field whose content is being saved.
+   * @type {string}
+   */
+  this.fieldHashCode = fieldHashCode;
+
+  /**
+   * The bound copy of {@code goog.editor.plugins.UndoRedo.restoreState} used by
+   * this state.
+   * @type {Function}
+   * @private
+   */
+  this.restore_ = restore;
+
+  this.setUndoState(content, cursorPosition);
+};
+goog.inherits(goog.editor.plugins.UndoRedo.UndoState_,
+    goog.editor.plugins.UndoRedoState);
+
+
+/**
+ * The content to restore on undo.
+ * @type {string}
+ * @private
+ */
+goog.editor.plugins.UndoRedo.UndoState_.prototype.undoContent_;
+
+
+/**
+ * The cursor position to restore on undo.
+ * @type {goog.editor.plugins.UndoRedo.CursorPosition_?}
+ * @private
+ */
+goog.editor.plugins.UndoRedo.UndoState_.prototype.undoCursorPosition_;
+
+
+/**
+ * The content to restore on redo, undefined until the state is pushed onto the
+ * undo stack.
+ * @type {string|undefined}
+ * @private
+ */
+goog.editor.plugins.UndoRedo.UndoState_.prototype.redoContent_;
+
+
+/**
+ * The cursor position to restore on redo, undefined until the state is pushed
+ * onto the undo stack.
+ * @type {goog.editor.plugins.UndoRedo.CursorPosition_|null|undefined}
+ * @private
+ */
+goog.editor.plugins.UndoRedo.UndoState_.prototype.redoCursorPosition_;
+
+
+/**
+ * Performs the undo operation represented by this state.
+ */
+goog.editor.plugins.UndoRedo.UndoState_.prototype.undo = function() {
+  this.restore_(this, this.undoContent_,
+      this.undoCursorPosition_);
+};
+
+
+/**
+ * Performs the redo operation represented by this state.
+ */
+goog.editor.plugins.UndoRedo.UndoState_.prototype.redo = function() {
+  this.restore_(this, this.redoContent_,
+      this.redoCursorPosition_);
+};
+
+
+/**
+ * Updates the undo portion of this state. Should only be used to update the
+ * current state of an editable field, which is not yet on the undo stack after
+ * an undo or redo operation. You should never be modifying states on the stack!
+ * @param {string} content The current content.
+ * @param {goog.editor.plugins.UndoRedo.CursorPosition_?} cursorPosition
+ *     The current cursor position.
+ */
+goog.editor.plugins.UndoRedo.UndoState_.prototype.setUndoState = function(
+    content, cursorPosition) {
+  this.undoContent_ = content;
+  this.undoCursorPosition_ = cursorPosition;
+};
+
+
+/**
+ * Adds redo information to this state. This method should be called before the
+ * state is added onto the undo stack.
+ *
+ * @param {string} content The content to restore on a redo.
+ * @param {goog.editor.plugins.UndoRedo.CursorPosition_?} cursorPosition
+ *     The cursor position to restore on a redo.
+ */
+goog.editor.plugins.UndoRedo.UndoState_.prototype.setRedoState = function(
+    content, cursorPosition) {
+  this.redoContent_ = content;
+  this.redoCursorPosition_ = cursorPosition;
+};
+
+
+/**
+ * Checks if the *contents* of two
+ * {@code goog.editor.plugins.UndoRedo.UndoState_}s are the same.  We don't
+ * bother checking the cursor position (that's not something we'd want to save
+ * anyway).
+ * @param {goog.editor.plugins.UndoRedo.UndoState_} rhs The state to compare.
+ * @return {boolean} Whether the contents are the same.
+ */
+goog.editor.plugins.UndoRedo.UndoState_.prototype.equals = function(rhs) {
+  return this.fieldHashCode == rhs.fieldHashCode &&
+      this.undoContent_ == rhs.undoContent_ &&
+      this.redoContent_ == rhs.redoContent_;
+};
+
+
+
+/**
+ * Stores the state of the selection in a way the survives DOM modifications
+ * that don't modify the user-interactable content (e.g. making something bold
+ * vs. typing a character).
+ *
+ * TODO(user): Completely get rid of this and use goog.dom.SavedCaretRange.
+ *
+ * @param {goog.editor.Field} field The field the selection is in.
+ * @private
+ * @constructor
+ */
+goog.editor.plugins.UndoRedo.CursorPosition_ = function(field) {
+  this.field_ = field;
+
+  var win = field.getEditableDomHelper().getWindow();
+  var range = field.getRange();
+  var isValidRange = !!range && range.isRangeInDocument() &&
+      range.getWindow() == win;
+  range = isValidRange ? range : null;
+
+  if (goog.editor.BrowserFeature.HAS_W3C_RANGES) {
+    this.initW3C_(range);
+  } else if (goog.editor.BrowserFeature.HAS_IE_RANGES) {
+    this.initIE_(range);
+  }
+};
+
+
+/**
+ * The standards compliant version keeps a list of childNode offsets.
+ * @param {goog.dom.AbstractRange?} range The range to save.
+ * @private
+ */
+goog.editor.plugins.UndoRedo.CursorPosition_.prototype.initW3C_ = function(
+    range) {
+  this.isValid_ = false;
+
+  // TODO: Check if the range is in the field before trying to save it
+  // for FF 3 contentEditable.
+  if (!range) {
+    return;
+  }
+
+  var anchorNode = range.getAnchorNode();
+  var focusNode = range.getFocusNode();
+  if (!anchorNode || !focusNode) {
+    return;
+  }
+
+  var anchorOffset = range.getAnchorOffset();
+  var anchor = new goog.dom.NodeOffset(anchorNode, this.field_.getElement());
+
+  var focusOffset = range.getFocusOffset();
+  var focus = new goog.dom.NodeOffset(focusNode, this.field_.getElement());
+
+  // Test range direction.
+  if (range.isReversed()) {
+    this.startOffset_ = focus;
+    this.startChildOffset_ = focusOffset;
+    this.endOffset_ = anchor;
+    this.endChildOffset_ = anchorOffset;
+  } else {
+    this.startOffset_ = anchor;
+    this.startChildOffset_ = anchorOffset;
+    this.endOffset_ = focus;
+    this.endChildOffset_ = focusOffset;
+  }
+
+  this.isValid_ = true;
+};
+
+
+/**
+ * In IE, we just keep track of the text offset (number of characters).
+ * @param {goog.dom.AbstractRange?} range The range to save.
+ * @private
+ */
+goog.editor.plugins.UndoRedo.CursorPosition_.prototype.initIE_ = function(
+    range) {
+  this.isValid_ = false;
+
+  if (!range) {
+    return;
+  }
+
+  var ieRange = range.getTextRange(0).getBrowserRangeObject();
+
+  if (!goog.dom.contains(this.field_.getElement(), ieRange.parentElement())) {
+    return;
+  }
+
+  // Create a range that encompasses the contentEditable region to serve
+  // as a reference to form ranges below.
+  var contentEditableRange =
+      this.field_.getEditableDomHelper().getDocument().body.createTextRange();
+  contentEditableRange.moveToElementText(this.field_.getElement());
+
+  // startMarker is a range from the start of the contentEditable node to the
+  // start of the current selection.
+  var startMarker = ieRange.duplicate();
+  startMarker.collapse(true);
+  startMarker.setEndPoint('StartToStart', contentEditableRange);
+  this.startOffset_ =
+      goog.editor.plugins.UndoRedo.CursorPosition_.computeEndOffsetIE_(
+          startMarker);
+
+  // endMarker is a range from the start of teh contentEditable node to the
+  // end of the current selection.
+  var endMarker = ieRange.duplicate();
+  endMarker.setEndPoint('StartToStart', contentEditableRange);
+  this.endOffset_ =
+      goog.editor.plugins.UndoRedo.CursorPosition_.computeEndOffsetIE_(
+          endMarker);
+
+  this.isValid_ = true;
+};
+
+
+/**
+ * @return {boolean} Whether this object is valid.
+ */
+goog.editor.plugins.UndoRedo.CursorPosition_.prototype.isValid = function() {
+  return this.isValid_;
+};
+
+
+/**
+ * @return {string} A string representation of this object.
+ */
+goog.editor.plugins.UndoRedo.CursorPosition_.prototype.toString = function() {
+  if (goog.editor.BrowserFeature.HAS_W3C_RANGES) {
+    return 'W3C:' + this.startOffset_.toString() + '\n' +
+        this.startChildOffset_ + ':' + this.endOffset_.toString() + '\n' +
+        this.endChildOffset_;
+  }
+  return 'IE:' + this.startOffset_ + ',' + this.endOffset_;
+};
+
+
+/**
+ * Makes the browser's selection match the cursor position.
+ */
+goog.editor.plugins.UndoRedo.CursorPosition_.prototype.select = function() {
+  var range = this.getRange_(this.field_.getElement());
+  if (range) {
+    if (goog.editor.BrowserFeature.HAS_IE_RANGES) {
+      this.field_.getElement().focus();
+    }
+    goog.dom.Range.createFromBrowserRange(range).select();
+  }
+};
+
+
+/**
+ * Get the range that encompases the the cursor position relative to a given
+ * base node.
+ * @param {Element} baseNode The node to get the cursor position relative to.
+ * @return {Range|TextRange|null} The browser range for this position.
+ * @private
+ */
+goog.editor.plugins.UndoRedo.CursorPosition_.prototype.getRange_ =
+    function(baseNode) {
+  if (goog.editor.BrowserFeature.HAS_W3C_RANGES) {
+    var startNode = this.startOffset_.findTargetNode(baseNode);
+    var endNode = this.endOffset_.findTargetNode(baseNode);
+    if (!startNode || !endNode) {
+      return null;
+    }
+
+    // Create range.
+    return /** @type {Range} */ (
+        goog.dom.Range.createFromNodes(startNode, this.startChildOffset_,
+            endNode, this.endChildOffset_).getBrowserRangeObject());
+  }
+
+  // Create a collapsed selection at the start of the contentEditable region,
+  // which the offsets were calculated relative to before.  Note that we force
+  // a text range here so we can use moveToElementText.
+  var sel = baseNode.ownerDocument.body.createTextRange();
+  sel.moveToElementText(baseNode);
+  sel.collapse(true);
+  sel.moveEnd('character', this.endOffset_);
+  sel.moveStart('character', this.startOffset_);
+  return sel;
+};
+
+
+/**
+ * Compute the number of characters to the end of the range in IE.
+ * @param {TextRange} range The range to compute an offset for.
+ * @return {number} The number of characters to the end of the range.
+ * @private
+ */
+goog.editor.plugins.UndoRedo.CursorPosition_.computeEndOffsetIE_ =
+    function(range) {
+  var testRange = range.duplicate();
+
+  // The number of offset characters is a little off depending on
+  // what type of block elements happen to be between the start of the
+  // textedit and the cursor position.  We fudge the offset until the
+  // two ranges match.
+  var text = range.text;
+  var guess = text.length;
+
+  testRange.collapse(true);
+  testRange.moveEnd('character', guess);
+
+  // Adjust the range until the end points match.  This doesn't quite
+  // work if we're at the end of the field so we give up after a few
+  // iterations.
+  var diff;
+  var numTries = 10;
+  while (diff = testRange.compareEndPoints('EndToEnd', range)) {
+    guess -= diff;
+    testRange.moveEnd('character', -diff);
+    --numTries;
+    if (0 == numTries) {
+      break;
+    }
+  }
+  // When we set innerHTML, blank lines become a single space, causing
+  // the cursor position to be off by one.  So we accommodate for blank
+  // lines.
+  var offset = 0;
+  var pos = text.indexOf('\n\r');
+  while (pos != -1) {
+    ++offset;
+    pos = text.indexOf('\n\r', pos + 1);
+  }
+  return guess + offset;
+};