The Tor Browser: toolkit/content/widgets/remote-browser.xml@129ffea94266

Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.

     1 <?xml version="1.0"?>

     3 <!-- This Source Code Form is subject to the terms of the Mozilla Public

     4    - License, v. 2.0. If a copy of the MPL was not distributed with this

     5    - file, You can obtain one at http://mozilla.org/MPL/2.0/. -->

     7 <bindings id="firefoxBrowserBindings"

     8           xmlns="http://www.mozilla.org/xbl"

     9           xmlns:xul="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul">

    11   <binding id="remote-browser" extends="chrome://global/content/bindings/browser.xml#browser">

    13     <implementation type="application/javascript" implements="nsIObserver, nsIDOMEventListener, nsIMessageListener">

    15       <field name="_securityUI">null</field>

    17       <property name="securityUI"

    18                 readonly="true">

    19         <getter><![CDATA[

    20           if (!this._securityUI) {

    21             let jsm = "resource://gre/modules/RemoteSecurityUI.jsm";

    22             let RemoteSecurityUI = Components.utils.import(jsm, {}).RemoteSecurityUI;

    23             this._securityUI = new RemoteSecurityUI();

    24           }

    26           // We want to double-wrap the JS implemented interface, so that QI and instanceof works.

    27           var ptr = Cc["@mozilla.org/supports-interface-pointer;1"].

    28                         createInstance(Ci.nsISupportsInterfacePointer);

    29           ptr.data = this._securityUI;

    30           return ptr.data.QueryInterface(Ci.nsISecureBrowserUI);

    31         ]]></getter>

    32       </property>

    34       <method name="adjustPriority">

    35         <parameter name="adjustment"/>

    36         <body><![CDATA[

    37           this.messageManager.sendAsyncMessage("NetworkPrioritizer:AdjustPriority",

    38                                                {adjustment: adjustment});

    39         ]]></body>

    40       </method>

    42       <field name="_remoteWebNavigation">null</field>

    44       <property name="webNavigation"

    45                 onget="return this._remoteWebNavigation;"

    46                 readonly="true"/>

    48       <field name="_remoteWebProgress">null</field>

    50       <property name="webProgress" readonly="true">

    51       	<getter>

    52       	  <![CDATA[

    53             if (!this._remoteWebProgress) {

    54               let jsm = "resource://gre/modules/RemoteWebProgress.jsm";

    55               let RemoteWebProgressManager = Cu.import(jsm, {}).RemoteWebProgressManager;

    56               this._remoteWebProgressManager = new RemoteWebProgressManager(this);

    57               this._remoteWebProgress = this._remoteWebProgressManager.topLevelWebProgress;

    58             }

    59             return this._remoteWebProgress;

    60       	  ]]>

    61       	</getter>

    62       </property>

    64       <field name="_remoteFinder">null</field>

    66       <property name="finder" readonly="true">

    67         <getter><![CDATA[

    68           if (!this._remoteFinder) {

    69             let jsm = "resource://gre/modules/RemoteFinder.jsm";

    70             let RemoteFinder = Cu.import(jsm, {}).RemoteFinder;

    71             this._remoteFinder = new RemoteFinder(this);

    72           }

    73           return this._remoteFinder;

    74         ]]></getter>

    75       </property>

    77       <field name="_documentURI">null</field>

    79       <field name="_documentContentType">null</field>

    81       <!--

    82         Used by session restore to ensure that currentURI is set so

    83         that switch-to-tab works before the tab is fully

    84         restored. This function also invokes onLocationChanged

    85         listeners in tabbrowser.xml.

    86       -->

    87       <method name="_setCurrentURI">

    88         <parameter name="aURI"/>

    89         <body><![CDATA[

    90           this._remoteWebProgressManager.setCurrentURI(aURI);

    91         ]]></body>

    92       </method>

    94       <property name="documentURI"

    95                 onget="return this._documentURI;"

    96                 readonly="true"/>

    98       <property name="documentContentType"

    99                 onget="return this._documentContentType;"

   100                 readonly="true"/>

   102       <field name="_contentTitle">""</field>

   104       <property name="contentTitle"

   105                 onget="return this._contentTitle"

   106                 readonly="true"/>

   108       <field name="_characterSet">null</field>

   110       <property name="characterSet"

   111                 onget="return this._characterSet"

   112                 readonly="true"/>

   114       <field name="_contentWindow">null</field>

   116       <property name="contentWindow"

   117                 onget="return this._contentWindow"

   118                 readonly="true"/>

   120       <property name="contentDocument"

   121                 onget="return this.contentWindow ? this.contentWindow.document : null"

   122                 readonly="true"/>

   124       <field name="_syncHandler">null</field>

   126       <property name="syncHandler"

   127                 onget="return this._syncHandler"

   128                 readonly="true"/>

   130       <field name="_imageDocument">null</field>

   132       <property name="imageDocument"

   133                 onget="return this._imageDocument"

   134                 readonly="true"/>

   136       <field name="_fullZoom">1</field>

   137       <property name="fullZoom">

   138         <getter><![CDATA[

   139           return this._fullZoom;

   140         ]]></getter>

   141         <setter><![CDATA[

   142           this._fullZoom = val;

   143           this.messageManager.sendAsyncMessage("FullZoom", {value: val});

   144         ]]></setter>

   145       </property>

   147       <field name="_textZoom">1</field>

   148       <property name="textZoom">

   149         <getter><![CDATA[

   150           return this._textZoom;

   151         ]]></getter>

   152         <setter><![CDATA[

   153           this._textZoom = val;

   154           this.messageManager.sendAsyncMessage("TextZoom", {value: val});

   155         ]]></setter>

   156       </property>

   158       <field name="_isSyntheticDocument">false</field>

   159       <property name="isSyntheticDocument">

   160         <getter><![CDATA[

   161           return this._isSyntheticDocument;

   162         ]]></getter>

   163       </property>

   165       <property name="autoCompletePopup"

   166                 onget="return document.getElementById(this.getAttribute('autocompletepopup'))"

   167                 readonly="true"/>

   169       <property name="docShellIsActive">

   170         <getter>

   171           <![CDATA[

   172             throw new Error("not supported");

   173           ]]>

   174         </getter>

   175         <setter>

   176           <![CDATA[

   177             let {frameLoader} = this.QueryInterface(Ci.nsIFrameLoaderOwner);

   178             frameLoader.tabParent.setIsDocShellActive(val);

   179             return val;

   180           ]]>

   181         </setter>

   182       </property>

   184       <constructor>

   185         <![CDATA[

   186           /*

   187            * Don't try to send messages from this function. The message manager for

   188            * the <browser> element may not be initialized yet.

   189            */

   191           let jsm = "resource://gre/modules/RemoteWebNavigation.jsm";

   192           let RemoteWebNavigation = Cu.import(jsm, {}).RemoteWebNavigation;

   193           this._remoteWebNavigation = new RemoteWebNavigation(this);

   195           this.messageManager.addMessageListener("Browser:Init", this);

   196           this.messageManager.addMessageListener("DOMTitleChanged", this);

   197           this.messageManager.addMessageListener("ImageDocumentLoaded", this);

   198           this.messageManager.addMessageListener("SetSyncHandler", this);

   199           this.messageManager.addMessageListener("DocumentInserted", this);

   200           this.messageManager.addMessageListener("FullZoomChange", this);

   201           this.messageManager.addMessageListener("TextZoomChange", this);

   202           this.messageManager.loadFrameScript("chrome://global/content/browser-child.js", true);

   204           if (this.hasAttribute("selectpopup")) {

   205             this.messageManager.addMessageListener("Forms:ShowDropDown", this);

   206             this.messageManager.addMessageListener("Forms:HideDropDown", this);

   207             this.messageManager.loadFrameScript("chrome://global/content/select-child.js", true);

   208           }

   210           jsm = "resource://gre/modules/RemoteController.jsm";

   211           let RemoteController = Components.utils.import(jsm, {}).RemoteController;

   212           this._controller = new RemoteController(this);

   213           this.controllers.appendController(this._controller);

   215           jsm = "resource://gre/modules/RemoteAddonsParent.jsm";

   216           let RemoteAddonsParent = Components.utils.import(jsm, {}).RemoteAddonsParent;

   217           RemoteAddonsParent.init();

   218         ]]>

   219       </constructor>

   221       <method name="receiveMessage">

   222         <parameter name="aMessage"/>

   223         <body><![CDATA[

   224           let data = aMessage.data;

   225           switch (aMessage.name) {

   226             case "Browser:Init":

   227               let result = {};

   228               result.useGlobalHistory = !this.hasAttribute("disableglobalhistory");

   229               result.initPopup = this.autoCompletePopup;

   230               return result;

   231               break;

   232             case "DOMTitleChanged":

   233               this._contentTitle = data.title;

   234               break;

   235             case "ImageDocumentLoaded":

   236               this._imageDocument = {

   237                 width: data.width,

   238                 height: data.height

   239               };

   240               break;

   242             case "SetSyncHandler":

   243               this._syncHandler = aMessage.objects.handler;

   244               break;

   246             case "Forms:ShowDropDown": {

   247               Cu.import("resource://gre/modules/SelectParentHelper.jsm");

   248               let dropdown = document.getElementById(this.getAttribute("selectpopup"));

   249               SelectParentHelper.populate(dropdown, data.options, data.selectedIndex);

   250               SelectParentHelper.open(this, dropdown, data.rect);

   251               break;

   252             }

   254             case "DocumentInserted":

   255               this._isSyntheticDocument = data.synthetic;

   256               break;

   258             case "FullZoomChange":

   259               this._fullZoom = data.value;

   260               break;

   262             case "TextZoomChange":

   263               this._textZoom = data.value;

   264               break;

   266             case "Forms:HideDropDown": {

   267               Cu.import("resource://gre/modules/SelectParentHelper.jsm");

   268               let dropdown = document.getElementById(this.getAttribute("selectpopup"));

   269               SelectParentHelper.hide(dropdown);

   270               break;

   271             }

   273             default:

   274               // Delegate to browser.xml.

   275               return this._receiveMessage(aMessage);

   276               break;

   277           }

   278         ]]></body>

   279       </method>

   281       <!--

   282         For out-of-process code, event.screen[XY] is relative to the

   283         left/top of the content view. For in-process code,

   284         event.screen[XY] is relative to the left/top of the screen. We

   285         use this method to map screen coordinates received from a

   286         (possibly out-of-process) <browser> element to coordinates

   287         that are relative to the screen. This code handles the

   288         out-of-process case, where we need to translate by the screen

   289         position of the <browser> element.

   290       -->

   291       <method name="mapScreenCoordinatesFromContent">

   292         <parameter name="aScreenX"/>

   293         <parameter name="aScreenY"/>

   294         <body>

   295         <![CDATA[

   296           return { x: aScreenX + this.boxObject.screenX,

   297                    y: aScreenY + this.boxObject.screenY };

   298         ]]>

   299         </body>

   300       </method>

   302     </implementation>

   304   </binding>

   306 </bindings>

The Tor Browser / file revision

toolkit/content/widgets/remote-browser.xml@129ffea94266

toolkit/content/widgets/remote-browser.xml