The Tor Browser: addon-sdk/source/lib/sdk/windows/tabs-fennec.js@129ffea94266 (annotated)

addon-sdk/source/lib/sdk/windows/tabs-fennec.js@129ffea94266 (annotated)

addon-sdk/source/lib/sdk/windows/tabs-fennec.js

Sat, 03 Jan 2015 20:18:00 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Sat, 03 Jan 2015 20:18:00 +0100
branch: TOR_BUG_3246
changeset 7: 129ffea94266
permissions: -rw-r--r--

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.

 /* 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';
 const { Class } = require('../core/heritage');
 const { Tab } = require('../tabs/tab');
 const { browserWindows } = require('./fennec');
 const { windowNS } = require('../window/namespace');
 const { tabsNS, tabNS } = require('../tabs/namespace');
 const { openTab, getTabs, getSelectedTab, getTabForBrowser: getRawTabForBrowser,
         getTabContentWindow } = require('../tabs/utils');
 const { Options } = require('../tabs/common');
 const { getTabForBrowser, getTabForRawTab } = require('../tabs/helpers');
 const { on, once, off, emit } = require('../event/core');
 const { method } = require('../lang/functional');
 const { EVENTS } = require('../tabs/events');
 const { EventTarget } = require('../event/target');
 const { when: unload } = require('../system/unload');
 const { windowIterator } = require('../deprecated/window-utils');
 const { List, addListItem, removeListItem } = require('../util/list');
 const { isPrivateBrowsingSupported } = require('../self');
 const { isTabPBSupported, ignoreWindow } = require('../private-browsing/utils');
 const mainWindow = windowNS(browserWindows.activeWindow).window;
 const ERR_FENNEC_MSG = 'This method is not yet supported by Fennec';
 const supportPrivateTabs = isPrivateBrowsingSupported && isTabPBSupported;
 const Tabs = Class({
   implements: [ List ],
   extends: EventTarget,
   initialize: function initialize(options) {
     let tabsInternals = tabsNS(this);
     let window = tabsNS(this).window = options.window || mainWindow;
     EventTarget.prototype.initialize.call(this, options);
     List.prototype.initialize.apply(this, getTabs(window).map(Tab));
     // TabOpen event
     window.BrowserApp.deck.addEventListener(EVENTS.open.dom, onTabOpen, false);
     // TabSelect
     window.BrowserApp.deck.addEventListener(EVENTS.activate.dom, onTabSelect, false);
   },
   get activeTab() {
     return getTabForRawTab(getSelectedTab(tabsNS(this).window));
   },
   open: function(options) {
     options = Options(options);
     let activeWin = browserWindows.activeWindow;
     if (options.isPinned) {
       console.error(ERR_FENNEC_MSG); // TODO
     }
     let rawTab = openTab(windowNS(activeWin).window, options.url, {
       inBackground: options.inBackground,
       isPrivate: supportPrivateTabs && options.isPrivate
     });
     // by now the tab has been created
     let tab = getTabForRawTab(rawTab);
     if (options.onClose)
       tab.on('close', options.onClose);
     if (options.onOpen) {
       // NOTE: on Fennec this will be true
       if (tabNS(tab).opened)
         options.onOpen(tab);
       tab.on('open', options.onOpen);
     }
     if (options.onReady)
       tab.on('ready', options.onReady);
     if (options.onLoad)
       tab.on('load', options.onLoad);
     if (options.onPageShow)
       tab.on('pageshow', options.onPageShow);
     if (options.onActivate)
       tab.on('activate', options.onActivate);
     return tab;
   }
 });
 let gTabs = exports.tabs = Tabs(mainWindow);
 function tabsUnloader(event, window) {
   window = window || (event && event.target);
   if (!(window && window.BrowserApp))
     return;
   window.BrowserApp.deck.removeEventListener(EVENTS.open.dom, onTabOpen, false);
   window.BrowserApp.deck.removeEventListener(EVENTS.activate.dom, onTabSelect, false);
 }
 // unload handler
 unload(function() {
   for (let window in windowIterator()) {
     tabsUnloader(null, window);
   }
 });
 function addTab(tab) {
   addListItem(gTabs, tab);
   return tab;
 }
 function removeTab(tab) {
   removeListItem(gTabs, tab);
   return tab;
 }
 // TabOpen
 function onTabOpen(event) {
   let browser = event.target;
   // Eventually ignore private tabs
   if (ignoreWindow(browser.contentWindow))
     return;
   let tab = getTabForBrowser(browser);
   if (tab === null) {
     let rawTab = getRawTabForBrowser(browser);
     // create a Tab instance for this new tab
     tab = addTab(Tab(rawTab));
   }
   tabNS(tab).opened = true;
   tab.on('ready', function() emit(gTabs, 'ready', tab));
   tab.once('close', onTabClose);
   tab.on('pageshow', function(_tab, persisted)
     emit(gTabs, 'pageshow', tab, persisted));
   emit(tab, 'open', tab);
   emit(gTabs, 'open', tab);
 }
 // TabSelect
 function onTabSelect(event) {
   let browser = event.target;
   // Eventually ignore private tabs
   if (ignoreWindow(browser.contentWindow))
     return;
   // Set value whenever new tab becomes active.
   let tab = getTabForBrowser(browser);
   emit(tab, 'activate', tab);
   emit(gTabs, 'activate', tab);
   for each (let t in gTabs) {
     if (t === tab) continue;
     emit(t, 'deactivate', t);
     emit(gTabs, 'deactivate', t);
   }
 }
 // TabClose
 function onTabClose(tab) {
   removeTab(tab);
   emit(gTabs, EVENTS.close.name, tab);
 }