The Tor Browser: browser/metro/base/content/contenthandlers/ContextMenuHandler.js@b8a032363ba2 (annotated)

browser/metro/base/content/contenthandlers/ContextMenuHandler.js@b8a032363ba2 (annotated)

browser/metro/base/content/contenthandlers/ContextMenuHandler.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

 /* 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/. */
 let Ci = Components.interfaces;
 let Cc = Components.classes;
 this.kXLinkNamespace = "http://www.w3.org/1999/xlink";
 dump("### ContextMenuHandler.js loaded\n");
 var ContextMenuHandler = {
   _types: [],
   _previousState: null,
   init: function ch_init() {
     // Events we catch from content during the bubbling phase
     addEventListener("contextmenu", this, false);
     addEventListener("pagehide", this, false);
     // Messages we receive from browser
     // Command sent over from browser that only we can handle.
     addMessageListener("Browser:ContextCommand", this, false);
     this.popupNode = null;
   },
   handleEvent: function ch_handleEvent(aEvent) {
     switch (aEvent.type) {
       case "contextmenu":
         this._onContentContextMenu(aEvent);
         break;
       case "pagehide":
         this.reset();
         break;
     }
   },
   receiveMessage: function ch_receiveMessage(aMessage) {
     switch (aMessage.name) {
       case "Browser:ContextCommand":
         this._onContextCommand(aMessage);
       break;
     }
   },
   /*
    * Handler for commands send over from browser's ContextCommands.js
    * in response to certain context menu actions only we can handle.
    */
   _onContextCommand: function _onContextCommand(aMessage) {
     let node = this.popupNode;
     let command = aMessage.json.command;
     switch (command) {
       case "cut":
         this._onCut();
         break;
       case "copy":
         this._onCopy();
         break;
       case "paste":
         this._onPaste();
         break;
       case "select-all":
         this._onSelectAll();
         break;
       case "copy-image-contents":
         this._onCopyImage();
         break;
     }
   },
   /******************************************************
    * Event handlers
    */
   reset: function ch_reset() {
     this.popupNode = null;
     this._target = null;
   },
   // content contextmenu handler
   _onContentContextMenu: function _onContentContextMenu(aEvent) {
     if (aEvent.defaultPrevented)
       return;
     // Don't let these bubble up to input.js
     aEvent.stopPropagation();
     aEvent.preventDefault();
     this._processPopupNode(aEvent.originalTarget, aEvent.clientX,
                            aEvent.clientY, aEvent.mozInputSource);
   },
   /******************************************************
    * ContextCommand handlers
    */
   _onSelectAll: function _onSelectAll() {
     if (Util.isTextInput(this._target)) {
       // select all text in the input control
       this._target.select();
     } else if (Util.isEditableContent(this._target)) {
       this._target.ownerDocument.execCommand("selectAll", false);
     } else {
       // select the entire document
       content.getSelection().selectAllChildren(content.document);
     }
     this.reset();
   },
   _onPaste: function _onPaste() {
     // paste text if this is an input control
     if (Util.isTextInput(this._target)) {
       let edit = this._target.QueryInterface(Ci.nsIDOMNSEditableElement);
       if (edit) {
         edit.editor.paste(Ci.nsIClipboard.kGlobalClipboard);
       } else {
         Util.dumpLn("error: target element does not support nsIDOMNSEditableElement");
       }
     } else if (Util.isEditableContent(this._target)) {
       try {
         this._target.ownerDocument.execCommand("paste",
                                                false,
                                                Ci.nsIClipboard.kGlobalClipboard);
       } catch (ex) {
         dump("ContextMenuHandler: exception pasting into contentEditable: " + ex.message + "\n");
       }
     }
     this.reset();
   },
   _onCopyImage: function _onCopyImage() {
     Util.copyImageToClipboard(this._target);
   },
   _onCut: function _onCut() {
     if (Util.isTextInput(this._target)) {
       let edit = this._target.QueryInterface(Ci.nsIDOMNSEditableElement);
       if (edit) {
         edit.editor.cut();
       } else {
         Util.dumpLn("error: target element does not support nsIDOMNSEditableElement");
       }
     } else if (Util.isEditableContent(this._target)) {
       try {
         this._target.ownerDocument.execCommand("cut", false);
       } catch (ex) {
         dump("ContextMenuHandler: exception cutting from contentEditable: " + ex.message + "\n");
       }
     }
     this.reset();
   },
   _onCopy: function _onCopy() {
     if (Util.isTextInput(this._target)) {
       let edit = this._target.QueryInterface(Ci.nsIDOMNSEditableElement);
       if (edit) {
         edit.editor.copy();
       } else {
         Util.dumpLn("error: target element does not support nsIDOMNSEditableElement");
       }
     } else if (Util.isEditableContent(this._target)) {
       try {
         this._target.ownerDocument.execCommand("copy", false);
       } catch (ex) {
         dump("ContextMenuHandler: exception copying from contentEditable: " +
           ex.message + "\n");
       }
     } else {
       let selectionText = this._previousState.string;
       Cc["@mozilla.org/widget/clipboardhelper;1"]
         .getService(Ci.nsIClipboardHelper).copyString(selectionText);
     }
     this.reset();
   },
   /******************************************************
    * Utility routines
    */
   /*
    * _processPopupNode - Generate and send a Content:ContextMenu message
    * to browser detailing the underlying content types at this.popupNode.
    * Note the event we receive targets the sub frame (if there is one) of
    * the page.
    */
   _processPopupNode: function _processPopupNode(aPopupNode, aX, aY, aInputSrc) {
     if (!aPopupNode)
       return;
     let { targetWindow: targetWindow,
           offsetX: offsetX,
           offsetY: offsetY } =
       Util.translateToTopLevelWindow(aPopupNode);
     let popupNode = this.popupNode = aPopupNode;
     let imageUrl = "";
     let state = {
       types: [],
       label: "",
       linkURL: "",
       linkTitle: "",
       linkProtocol: null,
       mediaURL: "",
       contentType: "",
       contentDisposition: "",
       string: "",
     };
     let uniqueStateTypes = new Set();
     // Do checks for nodes that never have children.
     if (popupNode.nodeType == Ci.nsIDOMNode.ELEMENT_NODE) {
       // See if the user clicked on an image.
       if (popupNode instanceof Ci.nsIImageLoadingContent && popupNode.currentURI) {
         uniqueStateTypes.add("image");
         state.label = state.mediaURL = popupNode.currentURI.spec;
         imageUrl = state.mediaURL;
         this._target = popupNode;
         // Retrieve the type of image from the cache since the url can fail to
         // provide valuable informations
         try {
           let imageCache = Cc["@mozilla.org/image/cache;1"].getService(Ci.imgICache);
           let props = imageCache.findEntryProperties(popupNode.currentURI,
                                                      content.document.characterSet);
           if (props) {
             state.contentType = String(props.get("type", Ci.nsISupportsCString));
             state.contentDisposition = String(props.get("content-disposition",
                                                         Ci.nsISupportsCString));
           }
         } catch (ex) {
           Util.dumpLn(ex.message);
           // Failure to get type and content-disposition off the image is non-fatal
         }
       }
     }
     let elem = popupNode;
     let isText = false;
     let isEditableText = false;
     while (elem) {
       if (elem.nodeType == Ci.nsIDOMNode.ELEMENT_NODE) {
         // is the target a link or a descendant of a link?
         if (Util.isLink(elem)) {
           // If this is an image that links to itself, don't include both link and
           // image otpions.
           if (imageUrl == this._getLinkURL(elem)) {
             elem = elem.parentNode;
             continue;
           }
           uniqueStateTypes.add("link");
           state.label = state.linkURL = this._getLinkURL(elem);
           linkUrl = state.linkURL;
           state.linkTitle = popupNode.textContent || popupNode.title;
           state.linkProtocol = this._getProtocol(this._getURI(state.linkURL));
           // mark as text so we can pickup on selection below
           isText = true;
           break;
         }
         // is the target contentEditable (not just inheriting contentEditable)
         // or the entire document in designer mode.
         else if (elem.contentEditable == "true" ||
                  Util.isOwnerDocumentInDesignMode(elem)) {
           this._target = elem;
           isEditableText = true;
           isText = true;
           uniqueStateTypes.add("input-text");
           if (elem.textContent.length) {
             uniqueStateTypes.add("selectable");
           } else {
             uniqueStateTypes.add("input-empty");
           }
           break;
         }
         // is the target a text input
         else if (Util.isTextInput(elem)) {
           this._target = elem;
           isEditableText = true;
           uniqueStateTypes.add("input-text");
           let selectionStart = elem.selectionStart;
           let selectionEnd = elem.selectionEnd;
           // Don't include "copy" for password fields.
           if (!(elem instanceof Ci.nsIDOMHTMLInputElement) || elem.mozIsTextField(true)) {
             // If there is a selection add cut and copy
             if (selectionStart != selectionEnd) {
               uniqueStateTypes.add("cut");
               uniqueStateTypes.add("copy");
               state.string = elem.value.slice(selectionStart, selectionEnd);
             } else if (elem.value && elem.textLength) {
               // There is text and it is not selected so add selectable items
               uniqueStateTypes.add("selectable");
               state.string = elem.value;
             }
           }
           if (!elem.textLength) {
             uniqueStateTypes.add("input-empty");
           }
           break;
         }
         // is the target an element containing text content
         else if (Util.isText(elem)) {
           isText = true;
         }
         // is the target a media element
         else if (elem instanceof Ci.nsIDOMHTMLMediaElement ||
                    elem instanceof Ci.nsIDOMHTMLVideoElement) {
           state.label = state.mediaURL = (elem.currentSrc || elem.src);
           uniqueStateTypes.add((elem.paused || elem.ended) ?
             "media-paused" : "media-playing");
           if (elem instanceof Ci.nsIDOMHTMLVideoElement) {
             uniqueStateTypes.add("video");
           }
         }
       }
       elem = elem.parentNode;
     }
     // Over arching text tests
     if (isText) {
       // If this is text and has a selection, we want to bring
       // up the copy option on the context menu.
       let selection = targetWindow.getSelection();
       if (selection && this._tapInSelection(selection, aX, aY)) {
         state.string = targetWindow.getSelection().toString();
         uniqueStateTypes.add("copy");
         uniqueStateTypes.add("selected-text");
         if (isEditableText) {
           uniqueStateTypes.add("cut");
         }
       } else {
         // Add general content text if this isn't anything specific
         if (!(
             uniqueStateTypes.has("image") ||
             uniqueStateTypes.has("media") ||
             uniqueStateTypes.has("video") ||
             uniqueStateTypes.has("link") ||
             uniqueStateTypes.has("input-text")
         )) {
           uniqueStateTypes.add("content-text");
         }
       }
     }
     // Is paste applicable here?
     if (isEditableText) {
       let flavors = ["text/unicode"];
       let cb = Cc["@mozilla.org/widget/clipboard;1"].getService(Ci.nsIClipboard);
       let hasData = cb.hasDataMatchingFlavors(flavors,
                                               flavors.length,
                                               Ci.nsIClipboard.kGlobalClipboard);
       // add paste if there's data
       if (hasData && !elem.readOnly) {
         uniqueStateTypes.add("paste");
       }
     }
     // populate position and event source
     state.xPos = offsetX + aX;
     state.yPos = offsetY + aY;
     state.source = aInputSrc;
     for (let i = 0; i < this._types.length; i++)
       if (this._types[i].handler(state, popupNode))
         uniqueStateTypes.add(this._types[i].name);
     state.types = [type for (type of uniqueStateTypes)];
     this._previousState = state;
     sendAsyncMessage("Content:ContextMenu", state);
   },
   _tapInSelection: function (aSelection, aX, aY) {
     if (!aSelection || !aSelection.rangeCount) {
       return false;
     }
     for (let idx = 0; idx < aSelection.rangeCount; idx++) {
       let range = aSelection.getRangeAt(idx);
       let rect = range.getBoundingClientRect();
       if (Util.pointWithinDOMRect(aX, aY, rect)) {
         return true;
       }
     }
     return false;
   },
   _getLinkURL: function ch_getLinkURL(aLink) {
     let href = aLink.href;
     if (href)
       return href;
     href = aLink.getAttributeNS(kXLinkNamespace, "href");
     if (!href || !href.match(/\S/)) {
       // Without this we try to save as the current doc,
       // for example, HTML case also throws if empty
       throw "Empty href";
     }
     return Util.makeURLAbsolute(aLink.baseURI, href);
   },
   _getURI: function ch_getURI(aURL) {
     try {
       return Util.makeURI(aURL);
     } catch (ex) { }
     return null;
   },
   _getProtocol: function ch_getProtocol(aURI) {
     if (aURI)
       return aURI.scheme;
     return null;
   },
   /**
    * For add-ons to add new types and data to the ContextMenu message.
    *
    * @param aName A string to identify the new type.
    * @param aHandler A function that takes a state object and a target element.
    *    If aHandler returns true, then aName will be added to the list of types.
    *    The function may also modify the state object.
    */
   registerType: function registerType(aName, aHandler) {
     this._types.push({name: aName, handler: aHandler});
   },
   /** Remove all handlers registered for a given type. */
   unregisterType: function unregisterType(aName) {
     this._types = this._types.filter(function(type) type.name != aName);
   }
 };
 this.ContextMenuHandler = ContextMenuHandler;
 ContextMenuHandler.init();