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

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

browser/metro/base/content/contenthandlers/Content.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/. */
 // This stays here because otherwise it's hard to tell if there's a parsing error
 dump("### Content.js loaded\n");
 let Cc = Components.classes;
 let Ci = Components.interfaces;
 let Cu = Components.utils;
 let Cr = Components.results;
 Cu.import("resource://gre/modules/XPCOMUtils.jsm");
 XPCOMUtils.defineLazyGetter(this, "Services", function() {
   Cu.import("resource://gre/modules/Services.jsm");
   return Services;
 });
 XPCOMUtils.defineLazyGetter(this, "Rect", function() {
   Cu.import("resource://gre/modules/Geometry.jsm");
   return Rect;
 });
 XPCOMUtils.defineLazyGetter(this, "Point", function() {
   Cu.import("resource://gre/modules/Geometry.jsm");
   return Point;
 });
 XPCOMUtils.defineLazyModuleGetter(this, "LoginManagerContent",
   "resource://gre/modules/LoginManagerContent.jsm");
 XPCOMUtils.defineLazyServiceGetter(this, "gFocusManager",
   "@mozilla.org/focus-manager;1", "nsIFocusManager");
 XPCOMUtils.defineLazyServiceGetter(this, "gDOMUtils",
   "@mozilla.org/inspector/dom-utils;1", "inIDOMUtils");
 this.XULDocument = Ci.nsIDOMXULDocument;
 this.HTMLHtmlElement = Ci.nsIDOMHTMLHtmlElement;
 this.HTMLIFrameElement = Ci.nsIDOMHTMLIFrameElement;
 this.HTMLFrameElement = Ci.nsIDOMHTMLFrameElement;
 this.HTMLFrameSetElement = Ci.nsIDOMHTMLFrameSetElement;
 this.HTMLSelectElement = Ci.nsIDOMHTMLSelectElement;
 this.HTMLOptionElement = Ci.nsIDOMHTMLOptionElement;
 const kReferenceDpi = 240; // standard "pixel" size used in some preferences
 const kStateActive = 0x00000001; // :active pseudoclass for elements
 const kZoomToElementMargin = 16; // in px
 /*
  * getBoundingContentRect
  *
  * @param aElement
  * @return Bounding content rect adjusted for scroll and frame offsets.
  */
 function getBoundingContentRect(aElement) {
   if (!aElement)
     return new Rect(0, 0, 0, 0);
   let document = aElement.ownerDocument;
   while(document.defaultView.frameElement)
     document = document.defaultView.frameElement.ownerDocument;
   let offset = ContentScroll.getScrollOffset(content);
   offset = new Point(offset.x, offset.y);
   let r = aElement.getBoundingClientRect();
   // step out of iframes and frames, offsetting scroll values
   let view = aElement.ownerDocument.defaultView;
   for (let frame = view; frame != content; frame = frame.parent) {
     // adjust client coordinates' origin to be top left of iframe viewport
     let rect = frame.frameElement.getBoundingClientRect();
     let left = frame.getComputedStyle(frame.frameElement, "").borderLeftWidth;
     let top = frame.getComputedStyle(frame.frameElement, "").borderTopWidth;
     offset.add(rect.left + parseInt(left), rect.top + parseInt(top));
   }
   return new Rect(r.left + offset.x, r.top + offset.y, r.width, r.height);
 }
 this.getBoundingContentRect = getBoundingContentRect;
 /*
  * getOverflowContentBoundingRect
  *
  * @param aElement
  * @return Bounding content rect adjusted for scroll and frame offsets.
  */
 function getOverflowContentBoundingRect(aElement) {
   let r = getBoundingContentRect(aElement);
   // If the overflow is hidden don't bother calculating it
   let computedStyle = aElement.ownerDocument.defaultView.getComputedStyle(aElement);
   let blockDisplays = ["block", "inline-block", "list-item"];
   if ((blockDisplays.indexOf(computedStyle.getPropertyValue("display")) != -1 &&
        computedStyle.getPropertyValue("overflow") == "hidden") ||
       aElement instanceof HTMLSelectElement) {
     return r;
   }
   for (let i = 0; i < aElement.childElementCount; i++) {
     r = r.union(getBoundingContentRect(aElement.children[i]));
   }
   return r;
 }
 this.getOverflowContentBoundingRect = getOverflowContentBoundingRect;
 /*
  * Content
  *
  * Browser event receiver for content.
  */
 let Content = {
   _debugEvents: false,
   get formAssistant() {
     delete this.formAssistant;
     return this.formAssistant = new FormAssistant();
   },
   init: function init() {
     // Asyncronous messages sent from the browser
     addMessageListener("Browser:Blur", this);
     addMessageListener("Browser:SaveAs", this);
     addMessageListener("Browser:MozApplicationCache:Fetch", this);
     addMessageListener("Browser:SetCharset", this);
     addMessageListener("Browser:CanUnload", this);
     addMessageListener("Browser:PanBegin", this);
     addMessageListener("Gesture:SingleTap", this);
     addMessageListener("Gesture:DoubleTap", this);
     addEventListener("touchstart", this, false);
     addEventListener("click", this, true);
     addEventListener("keydown", this);
     addEventListener("keyup", this);
     // Synchronous events caught during the bubbling phase
     addEventListener("MozApplicationManifest", this, false);
     addEventListener("DOMContentLoaded", this, false);
     addEventListener("DOMAutoComplete", this, false);
     addEventListener("DOMFormHasPassword", this, false);
     addEventListener("blur", this, false);
     // Attach a listener to watch for "click" events bubbling up from error
     // pages and other similar page. This lets us fix bugs like 401575 which
     // require error page UI to do privileged things, without letting error
     // pages have any privilege themselves.
     addEventListener("click", this, false);
     docShell.useGlobalHistory = true;
   },
   /*******************************************
    * Events
    */
   handleEvent: function handleEvent(aEvent) {
     if (this._debugEvents) Util.dumpLn("Content:", aEvent.type);
     switch (aEvent.type) {
       case "MozApplicationManifest": {
         let doc = aEvent.originalTarget;
         sendAsyncMessage("Browser:MozApplicationManifest", {
           location: doc.documentURIObject.spec,
           manifest: doc.documentElement.getAttribute("manifest"),
           charset: doc.characterSet
         });
         break;
       }
       case "keyup":
         // If after a key is pressed we still have no input, then close
         // the autocomplete. Perhaps the user used backspace or delete.
         // Allow down arrow to trigger autofill popup on empty input.
         if ((!aEvent.target.value && aEvent.keyCode != aEvent.DOM_VK_DOWN)
           || aEvent.keyCode == aEvent.DOM_VK_ESCAPE)
           this.formAssistant.close();
         else
           this.formAssistant.open(aEvent.target, aEvent);
         break;
       case "click":
         // Workaround for bug 925457: we sometimes don't recognize the
         // correct tap target or are unable to identify if it's editable.
         // Instead always save tap co-ordinates for the keyboard to look for
         // when it is up.
         SelectionHandler.onClickCoords(aEvent.clientX, aEvent.clientY);
         if (aEvent.eventPhase == aEvent.BUBBLING_PHASE)
           this._onClickBubble(aEvent);
         else
           this._onClickCapture(aEvent);
         break;
       case "DOMFormHasPassword":
         LoginManagerContent.onFormPassword(aEvent);
         break;
       case "DOMContentLoaded":
         this._maybeNotifyErrorPage();
         break;
       case "DOMAutoComplete":
       case "blur":
         LoginManagerContent.onUsernameInput(aEvent);
         break;
       case "touchstart":
         this._onTouchStart(aEvent);
         break;
     }
   },
   receiveMessage: function receiveMessage(aMessage) {
     if (this._debugEvents) Util.dumpLn("Content:", aMessage.name);
     let json = aMessage.json;
     let x = json.x;
     let y = json.y;
     switch (aMessage.name) {
       case "Browser:Blur":
         gFocusManager.clearFocus(content);
         break;
       case "Browser:CanUnload":
         let canUnload = docShell.contentViewer.permitUnload();
         sendSyncMessage("Browser:CanUnload:Return", { permit: canUnload });
         break;
       case "Browser:SaveAs":
         break;
       case "Browser:MozApplicationCache:Fetch": {
         let currentURI = Services.io.newURI(json.location, json.charset, null);
         let manifestURI = Services.io.newURI(json.manifest, json.charset, currentURI);
         let updateService = Cc["@mozilla.org/offlinecacheupdate-service;1"]
                             .getService(Ci.nsIOfflineCacheUpdateService);
         updateService.scheduleUpdate(manifestURI, currentURI, content);
         break;
       }
       case "Browser:SetCharset": {
         docShell.gatherCharsetMenuTelemetry();
         docShell.charset = json.charset;
         let webNav = docShell.QueryInterface(Ci.nsIWebNavigation);
         webNav.reload(Ci.nsIWebNavigation.LOAD_FLAGS_CHARSET_CHANGE);
         break;
       }
       case "Browser:PanBegin":
         this._cancelTapHighlight();
         break;
       case "Gesture:SingleTap":
         this._onSingleTap(json.x, json.y, json.modifiers);
         break;
       case "Gesture:DoubleTap":
         this._onDoubleTap(json.x, json.y);
         break;
     }
   },
   /******************************************************
    * Event handlers
    */
   _onTouchStart: function _onTouchStart(aEvent) {
     let element = aEvent.target;
     // There is no need to have a feedback for disabled element
     let isDisabled = element instanceof HTMLOptionElement ?
       (element.disabled || element.parentNode.disabled) : element.disabled;
     if (isDisabled)
       return;
     // Set the target element to active
     this._doTapHighlight(element);
   },
   _onClickCapture: function _onClickCapture(aEvent) {
     let element = aEvent.target;
     ContextMenuHandler.reset();
     // Only show autocomplete after the item is clicked
     if (!this.lastClickElement || this.lastClickElement != element) {
       this.lastClickElement = element;
       if (aEvent.mozInputSource == Ci.nsIDOMMouseEvent.MOZ_SOURCE_MOUSE &&
           !(element instanceof HTMLSelectElement)) {
         return;
       }
     }
     this.formAssistant.focusSync = true;
     this.formAssistant.open(element, aEvent);
     this._cancelTapHighlight();
     this.formAssistant.focusSync = false;
     // A tap on a form input triggers touch input caret selection
     if (Util.isEditable(element) &&
         aEvent.mozInputSource == Ci.nsIDOMMouseEvent.MOZ_SOURCE_TOUCH) {
       let { offsetX, offsetY } = Util.translateToTopLevelWindow(element);
       sendAsyncMessage("Content:SelectionCaret", {
         xPos: aEvent.clientX + offsetX,
         yPos: aEvent.clientY + offsetY
       });
     } else {
       SelectionHandler.closeSelection();
     }
   },
   // Checks clicks we care about - events bubbling up from about pages.
   _onClickBubble: function _onClickBubble(aEvent) {
     // Don't trust synthetic events
     if (!aEvent.isTrusted)
       return;
     let ot = aEvent.originalTarget;
     let errorDoc = ot.ownerDocument;
     if (!errorDoc)
       return;
     // If the event came from an ssl error page, it is probably either
     // "Add Exception…" or "Get me out of here!" button.
     if (/^about:certerror\?e=nssBadCert/.test(errorDoc.documentURI)) {
       let perm = errorDoc.getElementById("permanentExceptionButton");
       let temp = errorDoc.getElementById("temporaryExceptionButton");
       if (ot == temp || ot == perm) {
         let action = (ot == perm ? "permanent" : "temporary");
         sendAsyncMessage("Browser:CertException",
                          { url: errorDoc.location.href, action: action });
       } else if (ot == errorDoc.getElementById("getMeOutOfHereButton")) {
         sendAsyncMessage("Browser:CertException",
                          { url: errorDoc.location.href, action: "leave" });
       }
     } else if (/^about:blocked/.test(errorDoc.documentURI)) {
       // The event came from a button on a malware/phishing block page
       // First check whether it's malware or phishing, so that we can
       // use the right strings/links.
       let isMalware = /e=malwareBlocked/.test(errorDoc.documentURI);
       if (ot == errorDoc.getElementById("getMeOutButton")) {
         sendAsyncMessage("Browser:BlockedSite",
                          { url: errorDoc.location.href, action: "leave" });
       } else if (ot == errorDoc.getElementById("reportButton")) {
         // This is the "Why is this site blocked" button.  For malware,
         // we can fetch a site-specific report, for phishing, we redirect
         // to the generic page describing phishing protection.
         let action = isMalware ? "report-malware" : "report-phishing";
         sendAsyncMessage("Browser:BlockedSite",
                          { url: errorDoc.location.href, action: action });
       } else if (ot == errorDoc.getElementById("ignoreWarningButton")) {
         // Allow users to override and continue through to the site,
         // but add a notify bar as a reminder, so that they don't lose
         // track after, e.g., tab switching.
         let webNav = docShell.QueryInterface(Ci.nsIWebNavigation);
         webNav.loadURI(content.location,
                        Ci.nsIWebNavigation.LOAD_FLAGS_BYPASS_CLASSIFIER,
                        null, null, null);
       }
     }
   },
   _onSingleTap: function (aX, aY, aModifiers) {
     let utils = Util.getWindowUtils(content);
     for (let type of ["mousemove", "mousedown", "mouseup"]) {
       utils.sendMouseEventToWindow(type, aX, aY, 0, 1, aModifiers, true, 1.0,
           Ci.nsIDOMMouseEvent.MOZ_SOURCE_TOUCH);
     }
   },
   _onDoubleTap: function (aX, aY) {
     let { element } = Content.getCurrentWindowAndOffset(aX, aY);
     while (element && !this._shouldZoomToElement(element)) {
       element = element.parentNode;
     }
     if (!element) {
       this._zoomOut();
     } else {
       this._zoomToElement(element);
     }
   },
   /******************************************************
    * Zoom utilities
    */
   _zoomOut: function() {
     let rect = new Rect(0,0,0,0);
     this._zoomToRect(rect);
   },
   _zoomToElement: function(aElement) {
     let rect = getBoundingContentRect(aElement);
     this._inflateRect(rect, kZoomToElementMargin);
     this._zoomToRect(rect);
   },
   _inflateRect: function(aRect, aMargin) {
     aRect.left -= aMargin;
     aRect.top -= aMargin;
     aRect.bottom += aMargin;
     aRect.right += aMargin;
   },
   _zoomToRect: function (aRect) {
     let utils = Util.getWindowUtils(content);
     let viewId = utils.getViewId(content.document.documentElement);
     let presShellId = {};
     utils.getPresShellId(presShellId);
     sendAsyncMessage("Content:ZoomToRect", {
       rect: aRect,
       presShellId: presShellId.value,
       viewId: viewId,
     });
   },
   _shouldZoomToElement: function(aElement) {
     let win = aElement.ownerDocument.defaultView;
     if (win.getComputedStyle(aElement, null).display == "inline") {
       return false;
     }
     else if (aElement instanceof Ci.nsIDOMHTMLLIElement) {
       return false;
     }
     else if (aElement instanceof Ci.nsIDOMHTMLQuoteElement) {
       return false;
     }
     else {
       return true;
     }
   },
   /******************************************************
    * General utilities
    */
   /*
    * Retrieve the total offset from the window's origin to the sub frame
    * element including frame and scroll offsets. The resulting offset is
    * such that:
    * sub frame coords + offset = root frame position
    */
   getCurrentWindowAndOffset: function(x, y) {
     // If the element at the given point belongs to another document (such
     // as an iframe's subdocument), the element in the calling document's
     // DOM (e.g. the iframe) is returned.
     let utils = Util.getWindowUtils(content);
     let element = utils.elementFromPoint(x, y, true, false);
     let offset = { x:0, y:0 };
     while (element && (element instanceof HTMLIFrameElement ||
                        element instanceof HTMLFrameElement)) {
       // get the child frame position in client coordinates
       let rect = element.getBoundingClientRect();
       // calculate offsets for digging down into sub frames
       // using elementFromPoint:
       // Get the content scroll offset in the child frame
       scrollOffset = ContentScroll.getScrollOffset(element.contentDocument.defaultView);
       // subtract frame and scroll offset from our elementFromPoint coordinates
       x -= rect.left + scrollOffset.x;
       y -= rect.top + scrollOffset.y;
       // calculate offsets we'll use to translate to client coords:
       // add frame client offset to our total offset result
       offset.x += rect.left;
       offset.y += rect.top;
       // get the frame's nsIDOMWindowUtils
       utils = element.contentDocument
                      .defaultView
                      .QueryInterface(Ci.nsIInterfaceRequestor)
                      .getInterface(Ci.nsIDOMWindowUtils);
       // retrieve the target element in the sub frame at x, y
       element = utils.elementFromPoint(x, y, true, false);
     }
     if (!element)
       return {};
     return {
       element: element,
       contentWindow: element.ownerDocument.defaultView,
       offset: offset,
       utils: utils
     };
   },
   _maybeNotifyErrorPage: function _maybeNotifyErrorPage() {
     // Notify browser that an error page is being shown instead
     // of the target location. Necessary to get proper thumbnail
     // updates on chrome for error pages.
     if (content.location.href !== content.document.documentURI)
       sendAsyncMessage("Browser:ErrorPage", null);
   },
   _highlightElement: null,
   _doTapHighlight: function _doTapHighlight(aElement) {
     gDOMUtils.setContentState(aElement, kStateActive);
     this._highlightElement = aElement;
   },
   _cancelTapHighlight: function _cancelTapHighlight(aElement) {
     gDOMUtils.setContentState(content.document.documentElement, kStateActive);
     this._highlightElement = null;
   },
 };
 Content.init();
 var FormSubmitObserver = {
   init: function init(){
     addMessageListener("Browser:TabOpen", this);
     addMessageListener("Browser:TabClose", this);
     addEventListener("pageshow", this, false);
     Services.obs.addObserver(this, "invalidformsubmit", false);
   },
   handleEvent: function handleEvent(aEvent) {
     let target = aEvent.originalTarget;
     let isRootDocument = (target == content.document || target.ownerDocument == content.document);
     if (!isRootDocument)
       return;
     // Reset invalid submit state on each pageshow
     if (aEvent.type == "pageshow")
       Content.formAssistant.invalidSubmit = false;
   },
   receiveMessage: function receiveMessage(aMessage) {
     let json = aMessage.json;
     switch (aMessage.name) {
       case "Browser:TabOpen":
         Services.obs.addObserver(this, "formsubmit", false);
         break;
       case "Browser:TabClose":
         Services.obs.removeObserver(this, "formsubmit");
         break;
     }
   },
   notify: function notify(aFormElement, aWindow, aActionURI, aCancelSubmit) {
     // Do not notify unless this is the window where the submit occurred
     if (aWindow == content)
       // We don't need to send any data along
       sendAsyncMessage("Browser:FormSubmit", {});
   },
   notifyInvalidSubmit: function notifyInvalidSubmit(aFormElement, aInvalidElements) {
     if (!aInvalidElements.length)
       return;
     let element = aInvalidElements.queryElementAt(0, Ci.nsISupports);
     if (!(element instanceof HTMLInputElement ||
           element instanceof HTMLTextAreaElement ||
           element instanceof HTMLSelectElement ||
           element instanceof HTMLButtonElement)) {
       return;
     }
     Content.formAssistant.invalidSubmit = true;
     Content.formAssistant.open(element);
   },
   QueryInterface : function(aIID) {
     if (!aIID.equals(Ci.nsIFormSubmitObserver) &&
         !aIID.equals(Ci.nsISupportsWeakReference) &&
         !aIID.equals(Ci.nsISupports))
       throw Cr.NS_ERROR_NO_INTERFACE;
     return this;
   }
 };
 this.Content = Content;
 FormSubmitObserver.init();