The Tor Browser: toolkit/components/passwordmgr/content/passwordManagerCommon.js@129ffea94266 (annotated)

toolkit/components/passwordmgr/content/passwordManagerCommon.js@129ffea94266 (annotated)

toolkit/components/passwordmgr/content/passwordManagerCommon.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.

 // -*- Mode: Java; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
 /* 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/. */
 /*** =================== INITIALISATION CODE =================== ***/
 var kObserverService;
 // interface variables
 var passwordmanager     = null;
 // password-manager lists
 var signons             = [];
 var rejects             = [];
 var deletedSignons      = [];
 var deletedRejects      = [];
 var signonsTree;
 var rejectsTree;
 var showingPasswords = false;
 function Startup() {
   // xpconnect to password manager interfaces
   passwordmanager = Components.classes["@mozilla.org/login-manager;1"]
                         .getService(Components.interfaces.nsILoginManager);
   // be prepared to reload the display if anything changes
   kObserverService = Components.classes["@mozilla.org/observer-service;1"].getService(Components.interfaces.nsIObserverService);
   kObserverService.addObserver(signonReloadDisplay, "passwordmgr-storage-changed", false);
   signonsTree = document.getElementById("signonsTree");
   rejectsTree = document.getElementById("rejectsTree");
 }
 function Shutdown() {
   kObserverService.removeObserver(signonReloadDisplay, "passwordmgr-storage-changed");
 }
 var signonReloadDisplay = {
   observe: function(subject, topic, data) {
     if (topic == "passwordmgr-storage-changed") {
       switch (data) {
         case "addLogin":
         case "modifyLogin":
         case "removeLogin":
         case "removeAllLogins":
           if (!signonsTree) {
             return;
           }
           signons.length = 0;
           LoadSignons();
           // apply the filter if needed
           if (document.getElementById("filter") && document.getElementById("filter").value != "") {
             _filterPasswords();
           }
           break;
         case "hostSavingEnabled":
         case "hostSavingDisabled":
           if (!rejectsTree) {
             return;
           }
           rejects.length = 0;
           if (lastRejectSortColumn == "hostname") {
             lastRejectSortAscending = !lastRejectSortAscending; // prevents sort from being reversed
           }
           LoadRejects();
           break;
       }
       kObserverService.notifyObservers(null, "passwordmgr-dialog-updated", null);
     }
   }
 }
 /*** =================== GENERAL CODE =================== ***/
 function DeleteAllFromTree(tree, view, table, deletedTable, removeButton, removeAllButton) {
   // remove all items from table and place in deleted table
   for (var i=0; i<table.length; i++) {
     deletedTable[deletedTable.length] = table[i];
   }
   table.length = 0;
   // clear out selections
   view.selection.select(-1);
   // update the tree view and notify the tree
   view.rowCount = 0;
   var box = tree.treeBoxObject;
   box.rowCountChanged(0, -deletedTable.length);
   box.invalidate();
   // disable buttons
   document.getElementById(removeButton).setAttribute("disabled", "true")
   document.getElementById(removeAllButton).setAttribute("disabled","true");
 }
 function DeleteSelectedItemFromTree
     (tree, view, table, deletedTable, removeButton, removeAllButton) {
   // Turn off tree selection notifications during the deletion
   tree.view.selection.selectEventsSuppressed = true;
   // remove selected items from list (by setting them to null) and place in deleted list
   var selections = GetTreeSelections(tree);
   for (var s=selections.length-1; s>= 0; s--) {
     var i = selections[s];
     deletedTable[deletedTable.length] = table[i];
     table[i] = null;
   }
   // collapse list by removing all the null entries
   for (var j=0; j<table.length; j++) {
     if (table[j] == null) {
       var k = j;
       while ((k < table.length) && (table[k] == null)) {
         k++;
       }
       table.splice(j, k-j);
       view.rowCount -= k - j;
       tree.treeBoxObject.rowCountChanged(j, j - k);
     }
   }
   // update selection and/or buttons
   if (table.length) {
     // update selection
     var nextSelection = (selections[0] < table.length) ? selections[0] : table.length-1;
     tree.view.selection.select(nextSelection);
     tree.treeBoxObject.ensureRowIsVisible(nextSelection);
   } else {
     // disable buttons
     document.getElementById(removeButton).setAttribute("disabled", "true")
     document.getElementById(removeAllButton).setAttribute("disabled","true");
   }
   tree.view.selection.selectEventsSuppressed = false;
 }
 function GetTreeSelections(tree) {
   var selections = [];
   var select = tree.view.selection;
   if (select) {
     var count = select.getRangeCount();
     var min = new Object();
     var max = new Object();
     for (var i=0; i<count; i++) {
       select.getRangeAt(i, min, max);
       for (var k=min.value; k<=max.value; k++) {
         if (k != -1) {
           selections[selections.length] = k;
         }
       }
     }
   }
   return selections;
 }
 function SortTree(tree, view, table, column, lastSortColumn, lastSortAscending, updateSelection) {
   // remember which item was selected so we can restore it after the sort
   var selections = GetTreeSelections(tree);
   var selectedNumber = selections.length ? table[selections[0]].number : -1;
   // determine if sort is to be ascending or descending
   var ascending = (column == lastSortColumn) ? !lastSortAscending : true;
   // do the sort
   var compareFunc;
   if (ascending) {
     compareFunc = function compare(first, second) {
       return CompareLowerCase(first[column], second[column]);
     }
   } else {
     compareFunc = function compare(first, second) {
       return CompareLowerCase(second[column], first[column]);
     }
   }
   table.sort(compareFunc);
   // restore the selection
   var selectedRow = -1;
   if (selectedNumber>=0 && updateSelection) {
     for (var s=0; s<table.length; s++) {
       if (table[s].number == selectedNumber) {
         // update selection
         // note: we need to deselect before reselecting in order to trigger ...Selected()
         tree.view.selection.select(-1);
         tree.view.selection.select(s);
         selectedRow = s;
         break;
       }
     }
   }
   // display the results
   tree.treeBoxObject.invalidate();
   if (selectedRow >= 0) {
     tree.treeBoxObject.ensureRowIsVisible(selectedRow)
   }
   return ascending;
 }
 /**
  * Case insensitive string comparator.
  */
 function CompareLowerCase(first, second) {
   var firstLower, secondLower;
   // Are we sorting nsILoginInfo entries or just strings?
   if (first.hostname) {
     firstLower  = first.hostname.toLowerCase();
     secondLower = second.hostname.toLowerCase();
   } else {
     firstLower  = first.toLowerCase();
     secondLower = second.toLowerCase();
   }
   if (firstLower < secondLower) {
     return -1;
   }
   if (firstLower > secondLower) {
     return 1;
   }
   return 0;
 }