The Tor Browser: mobile/android/chrome/content/SelectionHandler.js@b8a032363ba2 (annotated)

mobile/android/chrome/content/SelectionHandler.js@b8a032363ba2 (annotated)

mobile/android/chrome/content/SelectionHandler.js

Thu, 22 Jan 2015 13:21:57 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 22 Jan 2015 13:21:57 +0100
branch: TOR_BUG_9701
changeset 15: b8a032363ba2
permissions: -rw-r--r--

Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6

 // -*- Mode: js2; tab-width: 2; indent-tabs-mode: nil; js2-basic-offset: 2; js2-skip-preprocessor-directives: t; -*-
 /* 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/. */
 "use strict";
 var SelectionHandler = {
   HANDLE_TYPE_START: "START",
   HANDLE_TYPE_MIDDLE: "MIDDLE",
   HANDLE_TYPE_END: "END",
   TYPE_NONE: 0,
   TYPE_CURSOR: 1,
   TYPE_SELECTION: 2,
   SELECT_ALL: 0,
   SELECT_AT_POINT: 1,
   // Keeps track of data about the dimensions of the selection. Coordinates
   // stored here are relative to the _contentWindow window.
   _cache: null,
   _activeType: 0, // TYPE_NONE
   _draggingHandles: false, // True while user drags text selection handles
   _ignoreCompositionChanges: false, // Persist caret during IME composition updates
   _prevHandlePositions: [], // Avoid issuing duplicate "TextSelection:Position" messages
   // TargetElement changes (text <--> no text) trigger actionbar UI update
   _prevTargetElementHasText: null,
   // The window that holds the selection (can be a sub-frame)
   get _contentWindow() {
     if (this._contentWindowRef)
       return this._contentWindowRef.get();
     return null;
   },
   set _contentWindow(aContentWindow) {
     this._contentWindowRef = Cu.getWeakReference(aContentWindow);
   },
   get _targetElement() {
     if (this._targetElementRef)
       return this._targetElementRef.get();
     return null;
   },
   set _targetElement(aTargetElement) {
     this._targetElementRef = Cu.getWeakReference(aTargetElement);
   },
   get _domWinUtils() {
     return BrowserApp.selectedBrowser.contentWindow.QueryInterface(Ci.nsIInterfaceRequestor).
                                                     getInterface(Ci.nsIDOMWindowUtils);
   },
   _isRTL: false,
   _addObservers: function sh_addObservers() {
     Services.obs.addObserver(this, "Gesture:SingleTap", false);
     Services.obs.addObserver(this, "Tab:Selected", false);
     Services.obs.addObserver(this, "after-viewport-change", false);
     Services.obs.addObserver(this, "TextSelection:Move", false);
     Services.obs.addObserver(this, "TextSelection:Position", false);
     Services.obs.addObserver(this, "TextSelection:End", false);
     Services.obs.addObserver(this, "TextSelection:Action", false);
     Services.obs.addObserver(this, "TextSelection:LayerReflow", false);
     BrowserApp.deck.addEventListener("pagehide", this, false);
     BrowserApp.deck.addEventListener("blur", this, true);
     BrowserApp.deck.addEventListener("scroll", this, true);
   },
   _removeObservers: function sh_removeObservers() {
     Services.obs.removeObserver(this, "Gesture:SingleTap");
     Services.obs.removeObserver(this, "Tab:Selected");
     Services.obs.removeObserver(this, "after-viewport-change");
     Services.obs.removeObserver(this, "TextSelection:Move");
     Services.obs.removeObserver(this, "TextSelection:Position");
     Services.obs.removeObserver(this, "TextSelection:End");
     Services.obs.removeObserver(this, "TextSelection:Action");
     Services.obs.removeObserver(this, "TextSelection:LayerReflow");
     BrowserApp.deck.removeEventListener("pagehide", this, false);
     BrowserApp.deck.removeEventListener("blur", this, true);
     BrowserApp.deck.removeEventListener("scroll", this, true);
   },
   observe: function sh_observe(aSubject, aTopic, aData) {
     switch (aTopic) {
       // Update handle/caret position on page reflow (keyboard open/close,
       // dynamic DOM changes, orientation updates, etc).
       case "TextSelection:LayerReflow": {
         if (this._activeType == this.TYPE_SELECTION) {
           this._updateCacheForSelection();
         }
         if (this._activeType != this.TYPE_NONE) {
           this._positionHandlesOnChange();
         }
         break;
       }
       // Update caret position on keyboard activity
       case "TextSelection:UpdateCaretPos":
         // Generated by IME close, autoCorrection / styling
         this._positionHandles();
         break;
       case "Gesture:SingleTap": {
         if (this._activeType == this.TYPE_SELECTION) {
           let data = JSON.parse(aData);
           if (!this._pointInSelection(data.x, data.y))
             this._closeSelection();
         } else if (this._activeType == this.TYPE_CURSOR) {
           // attachCaret() is called in the "Gesture:SingleTap" handler in BrowserEventHandler
           // We're guaranteed to call this first, because this observer was added last
           this._deactivate();
         }
         break;
       }
       case "Tab:Selected":
       case "TextSelection:End":
         this._closeSelection();
         break;
       case "TextSelection:Action":
         for (let type in this.actions) {
           if (this.actions[type].id == aData) {
             this.actions[type].action(this._targetElement);
             break;
           }
         }
         break;
       case "after-viewport-change": {
         if (this._activeType == this.TYPE_SELECTION) {
           // Update the cache after the viewport changes (e.g. panning, zooming).
           this._updateCacheForSelection();
         }
         break;
       }
       case "TextSelection:Move": {
         let data = JSON.parse(aData);
         if (this._activeType == this.TYPE_SELECTION) {
           this._startDraggingHandles();
           this._moveSelection(data.handleType == this.HANDLE_TYPE_START, data.x, data.y);
         } else if (this._activeType == this.TYPE_CURSOR) {
           this._startDraggingHandles();
           // Ignore IMM composition notifications when caret movement starts
           this._ignoreCompositionChanges = true;
           // Send a click event to the text box, which positions the caret
           this._sendMouseEvents(data.x, data.y);
           // Move the handle directly under the caret
           this._positionHandles();
         }
         break;
       }
       case "TextSelection:Position": {
         if (this._activeType == this.TYPE_SELECTION) {
           this._startDraggingHandles();
           // Check to see if the handles should be reversed.
           let isStartHandle = JSON.parse(aData).handleType == this.HANDLE_TYPE_START;
           try {
             let selectionReversed = this._updateCacheForSelection(isStartHandle);
             if (selectionReversed) {
               // Reverse the anchor and focus to correspond to the new start and end handles.
               let selection = this._getSelection();
               let anchorNode = selection.anchorNode;
               let anchorOffset = selection.anchorOffset;
               selection.collapse(selection.focusNode, selection.focusOffset);
               selection.extend(anchorNode, anchorOffset);
             }
           } catch (e) {
             // User finished handle positioning with one end off the screen
             this._closeSelection();
             break;
           }
           this._stopDraggingHandles();
           this._positionHandles();
           // Changes to handle position can affect selection context and actionbar display
           this._updateMenu();
         } else if (this._activeType == this.TYPE_CURSOR) {
           // Act on IMM composition notifications after caret movement ends
           this._ignoreCompositionChanges = false;
           this._stopDraggingHandles();
           this._positionHandles();
         } else {
           Cu.reportError("Ignored \"TextSelection:Position\" message during invalid selection status");
         }
         break;
       }
       case "TextSelection:Get":
         sendMessageToJava({
           type: "TextSelection:Data",
           requestId: aData,
           text: this._getSelectedText()
         });
         break;
     }
   },
   // Ignore selectionChange notifications during handle dragging, disable dynamic
   // IME text compositions (autoSuggest, autoCorrect, etc)
   _startDraggingHandles: function sh_startDraggingHandles() {
     if (!this._draggingHandles) {
       this._draggingHandles = true;
       sendMessageToJava({ type: "TextSelection:DraggingHandle", dragging: true });
     }
   },
   // Act on selectionChange notifications when not dragging handles, allow dynamic
   // IME text compositions (autoSuggest, autoCorrect, etc)
   _stopDraggingHandles: function sh_stopDraggingHandles() {
     if (this._draggingHandles) {
       this._draggingHandles = false;
       sendMessageToJava({ type: "TextSelection:DraggingHandle", dragging: false });
     }
   },
   handleEvent: function sh_handleEvent(aEvent) {
     switch (aEvent.type) {
       case "scroll":
         // Maintain position when top-level document is scrolled
         this._positionHandlesOnChange();
         break;
       case "pagehide":
       case "blur":
         this._closeSelection();
         break;
       // Update caret position on keyboard activity
       case "keyup":
         // Not generated by Swiftkeyboard
       case "compositionupdate":
       case "compositionend":
         // Generated by SwiftKeyboard, et. al.
         if (!this._ignoreCompositionChanges) {
           this._positionHandles();
         }
         break;
     }
   },
   /** Returns true if the provided element can be selected in text selection, false otherwise. */
   canSelect: function sh_canSelect(aElement) {
     return !(aElement instanceof Ci.nsIDOMHTMLButtonElement ||
              aElement instanceof Ci.nsIDOMHTMLEmbedElement ||
              aElement instanceof Ci.nsIDOMHTMLImageElement ||
              aElement instanceof Ci.nsIDOMHTMLMediaElement) &&
              aElement.style.MozUserSelect != 'none';
   },
   _getScrollPos: function sh_getScrollPos() {
     // Get the current display position
     let scrollX = {}, scrollY = {};
     this._contentWindow.top.QueryInterface(Ci.nsIInterfaceRequestor).
                             getInterface(Ci.nsIDOMWindowUtils).getScrollXY(false, scrollX, scrollY);
     return {
       X: scrollX.value,
       Y: scrollY.value
     };
   },
   notifySelectionChanged: function sh_notifySelectionChanged(aDocument, aSelection, aReason) {
     // Ignore selectionChange notifications during handle movements
     if (this._draggingHandles) {
       return;
     }
     // If the selection was collapsed to Start or to End, always close it
     if ((aReason & Ci.nsISelectionListener.COLLAPSETOSTART_REASON) ||
         (aReason & Ci.nsISelectionListener.COLLAPSETOEND_REASON)) {
       this._closeSelection();
       return;
     }
     // If selected text no longer exists, close
     if (!aSelection.toString()) {
       this._closeSelection();
     }
   },
   /*
    * Called from browser.js when the user long taps on text or chooses
    * the "Select Word" context menu item. Initializes SelectionHandler,
    * starts a selection, and positions the text selection handles.
    *
    * @param aOptions list of options describing how to start selection
    *                 Options include:
    *                   mode - SELECT_ALL to select everything in the target
    *                          element, or SELECT_AT_POINT to select a word.
    *                   x    - The x-coordinate for SELECT_AT_POINT.
    *                   y    - The y-coordinate for SELECT_AT_POINT.
    */
   startSelection: function sh_startSelection(aElement, aOptions = { mode: SelectionHandler.SELECT_ALL }) {
     // Clear out any existing active selection
     this._closeSelection();
     this._initTargetInfo(aElement, this.TYPE_SELECTION);
     // Clear any existing selection from the document
     this._contentWindow.getSelection().removeAllRanges();
     // Perform the appropriate selection method, if we can't determine method, or it fails, return
     if (!this._performSelection(aOptions)) {
       this._deactivate();
       return false;
     }
     // Double check results of successful selection operation
     let selection = this._getSelection();
     if (!selection || selection.rangeCount == 0 || selection.getRangeAt(0).collapsed) {
       this._deactivate();
       return false;
     }
     if (this._isPhoneNumber(selection.toString())) {
       let anchorNode = selection.anchorNode;
       let anchorOffset = selection.anchorOffset;
       let focusNode = null;
       let focusOffset = null;
       while (this._isPhoneNumber(selection.toString().trim())) {
         focusNode = selection.focusNode;
         focusOffset = selection.focusOffset;
         selection.modify("extend", "forward", "word");
         // if we hit the end of the text on the page, we can't advance the selection
         if (focusNode == selection.focusNode && focusOffset == selection.focusOffset) {
           break;
         }
       }
       // reverse selection
       selection.collapse(focusNode, focusOffset);
       selection.extend(anchorNode, anchorOffset);
       anchorNode = focusNode;
       anchorOffset = focusOffset
       while (this._isPhoneNumber(selection.toString().trim())) {
         focusNode = selection.focusNode;
         focusOffset = selection.focusOffset;
         selection.modify("extend", "backward", "word");
         // if we hit the end of the text on the page, we can't advance the selection
         if (focusNode == selection.focusNode && focusOffset == selection.focusOffset) {
           break;
         }
       }
       selection.collapse(focusNode, focusOffset);
       selection.extend(anchorNode, anchorOffset);
     }
     // Add a listener to end the selection if it's removed programatically
     selection.QueryInterface(Ci.nsISelectionPrivate).addSelectionListener(this);
     this._activeType = this.TYPE_SELECTION;
     // Initialize the cache
     this._cache = { start: {}, end: {}};
     this._updateCacheForSelection();
     let scroll = this._getScrollPos();
     // Figure out the distance between the selection and the click
     let positions = this._getHandlePositions(scroll);
     if (aOptions.mode == this.SELECT_AT_POINT && !this._selectionNearClick(scroll.X + aOptions.x,
                                                                       scroll.Y + aOptions.y,
                                                                       positions)) {
         this._closeSelection();
         return false;
     }
     // Determine position and show handles, open actionbar
     this._positionHandles(positions);
     sendMessageToJava({
       type: "TextSelection:ShowHandles",
       handles: [this.HANDLE_TYPE_START, this.HANDLE_TYPE_END]
     });
     this._updateMenu();
     return true;
   },
   /*
    * Called to perform a selection operation, given a target element, selection method, starting point etc.
    */
   _performSelection: function sh_performSelection(aOptions) {
     if (aOptions.mode == this.SELECT_AT_POINT) {
       return this._domWinUtils.selectAtPoint(aOptions.x, aOptions.y, Ci.nsIDOMWindowUtils.SELECT_WORDNOSPACE);
     }
     if (aOptions.mode != this.SELECT_ALL) {
       Cu.reportError("SelectionHandler.js: _performSelection() Invalid selection mode " + aOptions.mode);
       return false;
     }
     // HTMLPreElement is a #text node, SELECT_ALL implies entire paragraph
     if (this._targetElement instanceof HTMLPreElement)  {
       return this._domWinUtils.selectAtPoint(1, 1, Ci.nsIDOMWindowUtils.SELECT_PARAGRAPH);
     }
     // Else default to selectALL Document
     this._getSelectionController().selectAll();
     // Selection is entire HTMLHtmlElement, remove any trailing document whitespace
     let selection = this._getSelection();
     let lastNode = selection.focusNode;
     while (lastNode && lastNode.lastChild) {
       lastNode = lastNode.lastChild;
     }
     if (lastNode instanceof Text) {
       try {
         selection.extend(lastNode, lastNode.length);
       } catch (e) {
         Cu.reportError("SelectionHandler.js: _performSelection() whitespace trim fails: lastNode[" + lastNode +
           "] lastNode.length[" + lastNode.length + "]");
       }
     }
     return true;
   },
   /* Return true if the current selection (given by aPositions) is near to where the coordinates passed in */
   _selectionNearClick: function(aX, aY, aPositions) {
       let distance = 0;
       // Check if the click was in the bounding box of the selection handles
       if (aPositions[0].left < aX && aX < aPositions[1].left
           && aPositions[0].top < aY && aY < aPositions[1].top) {
         distance = 0;
       } else {
         // If it was outside, check the distance to the center of the selection
         let selectposX = (aPositions[0].left + aPositions[1].left) / 2;
         let selectposY = (aPositions[0].top + aPositions[1].top) / 2;
         let dx = Math.abs(selectposX - aX);
         let dy = Math.abs(selectposY - aY);
         distance = dx + dy;
       }
       let maxSelectionDistance = Services.prefs.getIntPref("browser.ui.selection.distance");
       return (distance < maxSelectionDistance);
   },
   /* Reads a value from an action. If the action defines the value as a function, will return the result of calling
      the function. Otherwise, will return the value itself. If the value isn't defined for this action, will return a default */
   _getValue: function(obj, name, defaultValue) {
     if (!(name in obj))
       return defaultValue;
     if (typeof obj[name] == "function")
       return obj[name](this._targetElement);
     return obj[name];
   },
   addAction: function(action) {
     if (!action.id)
       action.id = uuidgen.generateUUID().toString()
     if (this.actions[action.id])
       throw "Action with id " + action.id + " already added";
     // Update actions list and actionbar UI if active.
     this.actions[action.id] = action;
     this._updateMenu();
     return action.id;
   },
   removeAction: function(id) {
     // Update actions list and actionbar UI if active.
     delete this.actions[id];
     this._updateMenu();
   },
   _updateMenu: function() {
     if (this._activeType == this.TYPE_NONE) {
       return;
     }
     // Update actionbar UI.
     let actions = [];
     for (let type in this.actions) {
       let action = this.actions[type];
       if (action.selector.matches(this._targetElement)) {
         let a = {
           id: action.id,
           label: this._getValue(action, "label", ""),
           icon: this._getValue(action, "icon", "drawable://ic_status_logo"),
           showAsAction: this._getValue(action, "showAsAction", true),
           order: this._getValue(action, "order", 0)
         };
         actions.push(a);
       }
     }
     actions.sort((a, b) => b.order - a.order);
     sendMessageToJava({
       type: "TextSelection:Update",
       actions: actions
     });
   },
   /*
    * Actionbar methods.
    */
   actions: {
     SELECT_ALL: {
       label: Strings.browser.GetStringFromName("contextmenu.selectAll"),
       id: "selectall_action",
       icon: "drawable://ab_select_all",
       action: function(aElement) {
         SelectionHandler.startSelection(aElement);
         UITelemetry.addEvent("action.1", "actionbar", null, "select_all");
       },
       order: 5,
       selector: {
         matches: function(aElement) {
           return (aElement.textLength != 0);
         }
       }
     },
     CUT: {
       label: Strings.browser.GetStringFromName("contextmenu.cut"),
       id: "cut_action",
       icon: "drawable://ab_cut",
       action: function(aElement) {
         let start = aElement.selectionStart;
         let end   = aElement.selectionEnd;
         SelectionHandler.copySelection();
         aElement.value = aElement.value.substring(0, start) + aElement.value.substring(end)
         // copySelection closes the selection. Show a caret where we just cut the text.
         SelectionHandler.attachCaret(aElement);
         UITelemetry.addEvent("action.1", "actionbar", null, "cut");
       },
       order: 4,
       selector: {
         matches: function(aElement) {
           return SelectionHandler.isElementEditableText(aElement) ?
             SelectionHandler.isSelectionActive() : false;
         }
       }
     },
     COPY: {
       label: Strings.browser.GetStringFromName("contextmenu.copy"),
       id: "copy_action",
       icon: "drawable://ab_copy",
       action: function() {
         SelectionHandler.copySelection();
         UITelemetry.addEvent("action.1", "actionbar", null, "copy");
       },
       order: 3,
       selector: {
         matches: function(aElement) {
           // Don't include "copy" for password fields.
           // mozIsTextField(true) tests for only non-password fields.
           if (aElement instanceof Ci.nsIDOMHTMLInputElement && !aElement.mozIsTextField(true)) {
             return false;
           }
           return SelectionHandler.isSelectionActive();
         }
       }
     },
     PASTE: {
       label: Strings.browser.GetStringFromName("contextmenu.paste"),
       id: "paste_action",
       icon: "drawable://ab_paste",
       action: function(aElement) {
         if (aElement && (aElement instanceof Ci.nsIDOMNSEditableElement)) {
           let target = aElement.QueryInterface(Ci.nsIDOMNSEditableElement);
           target.editor.paste(Ci.nsIClipboard.kGlobalClipboard);
           target.focus();
           SelectionHandler._closeSelection();
           UITelemetry.addEvent("action.1", "actionbar", null, "paste");
         }
       },
       order: 2,
       selector: {
         matches: function(aElement) {
           if (SelectionHandler.isElementEditableText(aElement)) {
             let flavors = ["text/unicode"];
             return Services.clipboard.hasDataMatchingFlavors(flavors, flavors.length, Ci.nsIClipboard.kGlobalClipboard);
           }
           return false;
         }
       }
     },
     SHARE: {
       label: Strings.browser.GetStringFromName("contextmenu.share"),
       id: "share_action",
       icon: "drawable://ic_menu_share",
       action: function() {
         SelectionHandler.shareSelection();
         UITelemetry.addEvent("action.1", "actionbar", null, "share");
       },
       selector: {
         matches: function() {
           return SelectionHandler.isSelectionActive();
         }
       }
     },
     SEARCH: {
       label: function() {
         return Strings.browser.formatStringFromName("contextmenu.search", [Services.search.defaultEngine.name], 1);
       },
       id: "search_action",
       icon: "drawable://ab_search",
       action: function() {
         SelectionHandler.searchSelection();
         SelectionHandler._closeSelection();
         UITelemetry.addEvent("action.1", "actionbar", null, "search");
       },
       order: 1,
       selector: {
         matches: function() {
           return SelectionHandler.isSelectionActive();
         }
       }
     },
     CALL: {
       label: Strings.browser.GetStringFromName("contextmenu.call"),
       id: "call_action",
       icon: "drawable://phone",
       action: function() {
         SelectionHandler.callSelection();
         UITelemetry.addEvent("action.1", "actionbar", null, "call");
       },
       order: 1,
       selector: {
         matches: function () {
           return SelectionHandler._getSelectedPhoneNumber() != null;
         }
       }
     }
   },
   /*
    * Called by BrowserEventHandler when the user taps in a form input.
    * Initializes SelectionHandler and positions the caret handle.
    *
    * @param aX, aY tap location in client coordinates.
    */
   attachCaret: function sh_attachCaret(aElement) {
     // Ensure it isn't disabled, isn't handled by Android native dialog, and is editable text element
     if (aElement.disabled || InputWidgetHelper.hasInputWidget(aElement) || !this.isElementEditableText(aElement)) {
       return;
     }
     this._initTargetInfo(aElement, this.TYPE_CURSOR);
     // Caret-specific observer/listeners
     Services.obs.addObserver(this, "TextSelection:UpdateCaretPos", false);
     BrowserApp.deck.addEventListener("keyup", this, false);
     BrowserApp.deck.addEventListener("compositionupdate", this, false);
     BrowserApp.deck.addEventListener("compositionend", this, false);
     this._activeType = this.TYPE_CURSOR;
     // Determine position and show caret, open actionbar
     this._positionHandles();
     sendMessageToJava({
       type: "TextSelection:ShowHandles",
       handles: [this.HANDLE_TYPE_MIDDLE]
     });
     this._updateMenu();
   },
   // Target initialization for both TYPE_CURSOR and TYPE_SELECTION
   _initTargetInfo: function sh_initTargetInfo(aElement, aSelectionType) {
     this._targetElement = aElement;
     if (aElement instanceof Ci.nsIDOMNSEditableElement) {
       if (aSelectionType === this.TYPE_SELECTION) {
         // Blur the targetElement to force IME code to undo previous style compositions
         // (visible underlines / etc generated by autoCorrection, autoSuggestion)
         aElement.blur();
       }
       // Ensure targetElement is now focused normally
       aElement.focus();
     }
     this._stopDraggingHandles();
     this._contentWindow = aElement.ownerDocument.defaultView;
     this._isRTL = (this._contentWindow.getComputedStyle(aElement, "").direction == "rtl");
     this._addObservers();
   },
   _getSelection: function sh_getSelection() {
     if (this._targetElement instanceof Ci.nsIDOMNSEditableElement)
       return this._targetElement.QueryInterface(Ci.nsIDOMNSEditableElement).editor.selection;
     else
       return this._contentWindow.getSelection();
   },
   _getSelectedText: function sh_getSelectedText() {
     if (!this._contentWindow)
       return "";
     let selection = this._getSelection();
     if (!selection)
       return "";
     if (this._targetElement instanceof Ci.nsIDOMHTMLTextAreaElement) {
       return selection.QueryInterface(Ci.nsISelectionPrivate).
         toStringWithFormat("text/plain", Ci.nsIDocumentEncoder.OutputPreformatted | Ci.nsIDocumentEncoder.OutputRaw, 0);
     }
     return selection.toString().trim();
   },
   _getSelectionController: function sh_getSelectionController() {
     if (this._targetElement instanceof Ci.nsIDOMNSEditableElement)
       return this._targetElement.QueryInterface(Ci.nsIDOMNSEditableElement).editor.selectionController;
     else
       return this._contentWindow.QueryInterface(Ci.nsIInterfaceRequestor).
                                  getInterface(Ci.nsIWebNavigation).
                                  QueryInterface(Ci.nsIInterfaceRequestor).
                                  getInterface(Ci.nsISelectionDisplay).
                                  QueryInterface(Ci.nsISelectionController);
   },
   // Used by the contextmenu "matches" functions in ClipboardHelper
   isSelectionActive: function sh_isSelectionActive() {
     return (this._activeType == this.TYPE_SELECTION);
   },
   isElementEditableText: function (aElement) {
     return ((aElement instanceof HTMLInputElement && aElement.mozIsTextField(false)) ||
             (aElement instanceof HTMLTextAreaElement));
   },
   /*
    * Helper function for moving the selection inside an editable element.
    *
    * @param aAnchorX the stationary handle's x-coordinate in client coordinates
    * @param aX the moved handle's x-coordinate in client coordinates
    * @param aCaretPos the current position of the caret
    */
   _moveSelectionInEditable: function sh_moveSelectionInEditable(aAnchorX, aX, aCaretPos) {
     let anchorOffset = aX < aAnchorX ? this._targetElement.selectionEnd
                                      : this._targetElement.selectionStart;
     let newOffset = aCaretPos.offset;
     let [start, end] = anchorOffset <= newOffset ?
                        [anchorOffset, newOffset] :
                        [newOffset, anchorOffset];
     this._targetElement.setSelectionRange(start, end);
   },
   /*
    * Moves the selection as the user drags a selection handle.
    *
    * @param aIsStartHandle whether the user is moving the start handle (as opposed to the end handle)
    * @param aX, aY selection point in client coordinates
    */
   _moveSelection: function sh_moveSelection(aIsStartHandle, aX, aY) {
     // XXX We should be smarter about the coordinates we pass to caretPositionFromPoint, especially
     // in editable targets. We should factor out the logic that's currently in _sendMouseEvents.
     let viewOffset = this._getViewOffset();
     let caretPos = this._contentWindow.document.caretPositionFromPoint(aX - viewOffset.x, aY - viewOffset.y);
     if (!caretPos) {
       // User moves handle offscreen while positioning
       return;
     }
     // Constrain text selection within editable elements.
     let targetIsEditable = this._targetElement instanceof Ci.nsIDOMNSEditableElement;
     if (targetIsEditable && (caretPos.offsetNode != this._targetElement)) {
       return;
     }
     // Update the cache as the handle is dragged (keep the cache in client coordinates).
     if (aIsStartHandle) {
       this._cache.start.x = aX;
       this._cache.start.y = aY;
     } else {
       this._cache.end.x = aX;
       this._cache.end.y = aY;
     }
     let selection = this._getSelection();
     // The handles work the same on both LTR and RTL pages, but the anchor/focus nodes
     // are reversed, so we need to reverse the logic to extend the selection.
     if ((aIsStartHandle && !this._isRTL) || (!aIsStartHandle && this._isRTL)) {
       if (targetIsEditable) {
         let anchorX = this._isRTL ? this._cache.start.x : this._cache.end.x;
         this._moveSelectionInEditable(anchorX, aX, caretPos);
       } else {
         let focusNode = selection.focusNode;
         let focusOffset = selection.focusOffset;
         selection.collapse(caretPos.offsetNode, caretPos.offset);
         selection.extend(focusNode, focusOffset);
       }
     } else {
       if (targetIsEditable) {
         let anchorX = this._isRTL ? this._cache.end.x : this._cache.start.x;
         this._moveSelectionInEditable(anchorX, aX, caretPos);
       } else {
         selection.extend(caretPos.offsetNode, caretPos.offset);
       }
     }
   },
   _sendMouseEvents: function sh_sendMouseEvents(aX, aY, useShift) {
     // If we're positioning a cursor in an input field, make sure the handle
     // stays within the bounds of the field
     if (this._activeType == this.TYPE_CURSOR) {
       // Get rect of text inside element
       let range = document.createRange();
       range.selectNodeContents(this._targetElement.QueryInterface(Ci.nsIDOMNSEditableElement).editor.rootElement);
       let textBounds = range.getBoundingClientRect();
       // Get rect of editor
       let editorBounds = this._domWinUtils.sendQueryContentEvent(this._domWinUtils.QUERY_EDITOR_RECT, 0, 0, 0, 0,
                                                                  this._domWinUtils.QUERY_CONTENT_FLAG_USE_XP_LINE_BREAK);
       // the return value from sendQueryContentEvent is in LayoutDevice pixels and we want CSS pixels, so
       // divide by the pixel ratio
       let editorRect = new Rect(editorBounds.left / window.devicePixelRatio,
                                 editorBounds.top / window.devicePixelRatio,
                                 editorBounds.width / window.devicePixelRatio,
                                 editorBounds.height / window.devicePixelRatio);
       // Use intersection of the text rect and the editor rect
       let rect = new Rect(textBounds.left, textBounds.top, textBounds.width, textBounds.height);
       rect.restrictTo(editorRect);
       // Clamp vertically and scroll if handle is at bounds. The top and bottom
       // must be restricted by an additional pixel since clicking on the top
       // edge of an input field moves the cursor to the beginning of that
       // field's text (and clicking the bottom moves the cursor to the end).
       if (aY < rect.y + 1) {
         aY = rect.y + 1;
         this._getSelectionController().scrollLine(false);
       } else if (aY > rect.y + rect.height - 1) {
         aY = rect.y + rect.height - 1;
         this._getSelectionController().scrollLine(true);
       }
       // Clamp horizontally and scroll if handle is at bounds
       if (aX < rect.x) {
         aX = rect.x;
         this._getSelectionController().scrollCharacter(false);
       } else if (aX > rect.x + rect.width) {
         aX = rect.x + rect.width;
         this._getSelectionController().scrollCharacter(true);
       }
     } else if (this._activeType == this.TYPE_SELECTION) {
       // Send mouse event 1px too high to prevent selection from entering the line below where it should be
       aY -= 1;
     }
     this._domWinUtils.sendMouseEventToWindow("mousedown", aX, aY, 0, 0, useShift ? Ci.nsIDOMNSEvent.SHIFT_MASK : 0, true);
     this._domWinUtils.sendMouseEventToWindow("mouseup", aX, aY, 0, 0, useShift ? Ci.nsIDOMNSEvent.SHIFT_MASK : 0, true);
   },
   copySelection: function sh_copySelection() {
     let selectedText = this._getSelectedText();
     if (selectedText.length) {
       let clipboard = Cc["@mozilla.org/widget/clipboardhelper;1"].getService(Ci.nsIClipboardHelper);
       clipboard.copyString(selectedText, this._contentWindow.document);
       NativeWindow.toast.show(Strings.browser.GetStringFromName("selectionHelper.textCopied"), "short");
     }
     this._closeSelection();
   },
   shareSelection: function sh_shareSelection() {
     let selectedText = this._getSelectedText();
     if (selectedText.length) {
       sendMessageToJava({
         type: "Share:Text",
         text: selectedText
       });
     }
     this._closeSelection();
   },
   searchSelection: function sh_searchSelection() {
     let selectedText = this._getSelectedText();
     if (selectedText.length) {
       let req = Services.search.defaultEngine.getSubmission(selectedText);
       let parent = BrowserApp.selectedTab;
       let isPrivate = PrivateBrowsingUtils.isWindowPrivate(parent.browser.contentWindow);
       // Set current tab as parent of new tab, and set new tab as private if the parent is.
       BrowserApp.addTab(req.uri.spec, {parentId: parent.id,
                                        selected: true,
                                        isPrivate: isPrivate});
     }
     this._closeSelection();
   },
   _phoneRegex: /^\+?[0-9\s,-.\(\)*#pw]{1,30}$/,
   _getSelectedPhoneNumber: function sh_getSelectedPhoneNumber() {
     return this._isPhoneNumber(this._getSelectedText().trim());
   },
   _isPhoneNumber: function sh_isPhoneNumber(selectedText) {
     return (this._phoneRegex.test(selectedText) ? selectedText : null);
   },
   callSelection: function sh_callSelection() {
     let selectedText = this._getSelectedPhoneNumber();
     if (selectedText) {
       BrowserApp.loadURI("tel:" + selectedText);
     }
     this._closeSelection();
   },
   /*
    * Shuts SelectionHandler down.
    */
   _closeSelection: function sh_closeSelection() {
     // Bail if there's no active selection
     if (this._activeType == this.TYPE_NONE)
       return;
     if (this._activeType == this.TYPE_SELECTION)
       this._clearSelection();
     this._deactivate();
   },
   _clearSelection: function sh_clearSelection() {
     let selection = this._getSelection();
     if (selection) {
       // Remove our listener before we clear the selection
       selection.QueryInterface(Ci.nsISelectionPrivate).removeSelectionListener(this);
       // Clear selection without clearing the anchorNode or focusNode
       if (selection.rangeCount != 0) {
         selection.collapseToStart();
       }
     }
   },
   _deactivate: function sh_deactivate() {
     this._stopDraggingHandles();
     // Hide handle/caret, close actionbar
     sendMessageToJava({ type: "TextSelection:HideHandles" });
     this._removeObservers();
     // Only observed for caret positioning
     if (this._activeType == this.TYPE_CURSOR) {
       Services.obs.removeObserver(this, "TextSelection:UpdateCaretPos");
       BrowserApp.deck.removeEventListener("keyup", this);
       BrowserApp.deck.removeEventListener("compositionupdate", this);
       BrowserApp.deck.removeEventListener("compositionend", this);
     }
     this._contentWindow = null;
     this._targetElement = null;
     this._isRTL = false;
     this._cache = null;
     this._ignoreCompositionChanges = false;
     this._prevHandlePositions = [];
     this._prevTargetElementHasText = null;
     this._activeType = this.TYPE_NONE;
   },
   _getViewOffset: function sh_getViewOffset() {
     let offset = { x: 0, y: 0 };
     let win = this._contentWindow;
     // Recursively look through frames to compute the total position offset.
     while (win.frameElement) {
       let rect = win.frameElement.getBoundingClientRect();
       offset.x += rect.left;
       offset.y += rect.top;
       win = win.parent;
     }
     return offset;
   },
   _pointInSelection: function sh_pointInSelection(aX, aY) {
     let offset = this._getViewOffset();
     let rangeRect = this._getSelection().getRangeAt(0).getBoundingClientRect();
     let radius = ElementTouchHelper.getTouchRadius();
     return (aX - offset.x > rangeRect.left - radius.left &&
             aX - offset.x < rangeRect.right + radius.right &&
             aY - offset.y > rangeRect.top - radius.top &&
             aY - offset.y < rangeRect.bottom + radius.bottom);
   },
   // Returns true if the selection has been reversed. Takes optional aIsStartHandle
   // param to decide whether the selection has been reversed.
   _updateCacheForSelection: function sh_updateCacheForSelection(aIsStartHandle) {
     let rects = this._getSelection().getRangeAt(0).getClientRects();
     if (!rects[0]) {
       // nsISelection object exists, but there's nothing actually selected
       throw "Failed to update cache for invalid selection";
     }
     let start = { x: this._isRTL ? rects[0].right : rects[0].left, y: rects[0].bottom };
     let end = { x: this._isRTL ? rects[rects.length - 1].left : rects[rects.length - 1].right, y: rects[rects.length - 1].bottom };
     let selectionReversed = false;
     if (this._cache.start) {
       // If the end moved past the old end, but we're dragging the start handle, then that handle should become the end handle (and vice versa)
       selectionReversed = (aIsStartHandle && (end.y > this._cache.end.y || (end.y == this._cache.end.y && end.x > this._cache.end.x))) ||
                           (!aIsStartHandle && (start.y < this._cache.start.y || (start.y == this._cache.start.y && start.x < this._cache.start.x)));
     }
     this._cache.start = start;
     this._cache.end = end;
     return selectionReversed;
   },
   _getHandlePositions: function sh_getHandlePositions(scroll) {
     // the checkHidden function tests to see if the given point is hidden inside an
     // iframe/subdocument. this is so that if we select some text inside an iframe and
     // scroll the iframe so the selection is out of view, we hide the handles rather
     // than having them float on top of the main page content.
     let checkHidden = function(x, y) {
       return false;
     };
     if (this._contentWindow.frameElement) {
       let bounds = this._contentWindow.frameElement.getBoundingClientRect();
       checkHidden = function(x, y) {
         return x < 0 || y < 0 || x > bounds.width || y > bounds.height;
       };
     }
     let positions = null;
     if (this._activeType == this.TYPE_CURSOR) {
       // The left and top properties returned are relative to the client area
       // of the window, so we don't need to account for a sub-frame offset.
       let cursor = this._domWinUtils.sendQueryContentEvent(this._domWinUtils.QUERY_CARET_RECT, this._targetElement.selectionEnd, 0, 0, 0,
                                                            this._domWinUtils.QUERY_CONTENT_FLAG_USE_XP_LINE_BREAK);
       // the return value from sendQueryContentEvent is in LayoutDevice pixels and we want CSS pixels, so
       // divide by the pixel ratio
       let x = cursor.left / window.devicePixelRatio;
       let y = (cursor.top + cursor.height) / window.devicePixelRatio;
       return [{ handle: this.HANDLE_TYPE_MIDDLE,
                 left: x + scroll.X,
                 top: y + scroll.Y,
                 hidden: checkHidden(x, y) }];
     } else {
       let sx = this._cache.start.x;
       let sy = this._cache.start.y;
       let ex = this._cache.end.x;
       let ey = this._cache.end.y;
       // Translate coordinates to account for selections in sub-frames. We can't cache
       // this because the top-level page may have scrolled since selection started.
       let offset = this._getViewOffset();
       return  [{ handle: this.HANDLE_TYPE_START,
                  left: sx + offset.x + scroll.X,
                  top: sy + offset.y + scroll.Y,
                  hidden: checkHidden(sx, sy) },
                { handle: this.HANDLE_TYPE_END,
                  left: ex + offset.x + scroll.X,
                  top: ey + offset.y + scroll.Y,
                  hidden: checkHidden(ex, ey) }];
     }
   },
   // Position handles, but avoid superfluous re-positioning (helps during
   // "TextSelection:LayerReflow", "scroll" of top-level document, etc).
   _positionHandlesOnChange: function() {
     // Helper function to compare position messages
     let samePositions = function(aPrev, aCurr) {
       if (aPrev.length != aCurr.length) {
         return false;
       }
       for (let i = 0; i < aPrev.length; i++) {
         if (aPrev[i].left != aCurr[i].left ||
             aPrev[i].top != aCurr[i].top ||
             aPrev[i].hidden != aCurr[i].hidden) {
           return false;
         }
       }
       return true;
     }
     let positions = this._getHandlePositions(this._getScrollPos());
     if (!samePositions(this._prevHandlePositions, positions)) {
       this._positionHandles(positions);
     }
   },
   // Position handles, allow for re-position, in case user drags handle
   // to invalid position, then releases, we can put it back where it started
   // positions is an array of objects with data about handle positions,
   // which we get from _getHandlePositions.
   _positionHandles: function sh_positionHandles(positions) {
     if (!positions) {
       positions = this._getHandlePositions(this._getScrollPos());
     }
     sendMessageToJava({
       type: "TextSelection:PositionHandles",
       positions: positions,
       rtl: this._isRTL
     });
     this._prevHandlePositions = positions;
     // Text state transitions (text <--> no text) will affect selection context and actionbar display
     let currTargetElementHasText = (this._targetElement.textLength > 0);
     if (currTargetElementHasText != this._prevTargetElementHasText) {
       this._prevTargetElementHasText = currTargetElementHasText;
       this._updateMenu();
     }
   },
   subdocumentScrolled: function sh_subdocumentScrolled(aElement) {
     if (this._activeType == this.TYPE_NONE) {
       return;
     }
     let scrollView = aElement.ownerDocument.defaultView;
     let view = this._contentWindow;
     while (true) {
       if (view == scrollView) {
         // The selection is in a view (or sub-view) of the view that scrolled.
         // So we need to reposition the handles.
         if (this._activeType == this.TYPE_SELECTION) {
           this._updateCacheForSelection();
         }
         this._positionHandles();
         break;
       }
       if (view == view.parent) {
         break;
       }
       view = view.parent;
     }
   }
 };