The Tor Browser: browser/base/content/sync/quota.js@8bccb770b82d (annotated)

browser/base/content/sync/quota.js@8bccb770b82d (annotated)

browser/base/content/sync/quota.js

Wed, 31 Dec 2014 13:27:57 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 13:27:57 +0100
branch: TOR_BUG_3246
changeset 6: 8bccb770b82d
permissions: -rw-r--r--

Ignore runtime configuration files generated during quality assurance.

 /* 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/. */
 const Ci = Components.interfaces;
 const Cc = Components.classes;
 const Cr = Components.results;
 const Cu = Components.utils;
 Cu.import("resource://services-sync/main.js");
 Cu.import("resource://gre/modules/DownloadUtils.jsm");
 let gSyncQuota = {
   init: function init() {
     this.bundle = document.getElementById("quotaStrings");
     let caption = document.getElementById("treeCaption");
     caption.firstChild.nodeValue = this.bundle.getString("quota.treeCaption.label");
     gUsageTreeView.init();
     this.tree = document.getElementById("usageTree");
     this.tree.view = gUsageTreeView;
     this.loadData();
   },
   loadData: function loadData() {
     this._usage_req = Weave.Service.getStorageInfo(Weave.INFO_COLLECTION_USAGE,
                                                    function (error, usage) {
       delete gSyncQuota._usage_req;
       // displayUsageData handles null values, so no need to check 'error'.
       gUsageTreeView.displayUsageData(usage);
     });
     let usageLabel = document.getElementById("usageLabel");
     let bundle = this.bundle;
     this._quota_req = Weave.Service.getStorageInfo(Weave.INFO_QUOTA,
                                                    function (error, quota) {
       delete gSyncQuota._quota_req;
       if (error) {
         usageLabel.value = bundle.getString("quota.usageError.label");
         return;
       }
       let used = gSyncQuota.convertKB(quota[0]);
       if (!quota[1]) {
         // No quota on the server.
         usageLabel.value = bundle.getFormattedString(
           "quota.usageNoQuota.label", used);
         return;
       }
       let percent = Math.round(100 * quota[0] / quota[1]);
       let total = gSyncQuota.convertKB(quota[1]);
       usageLabel.value = bundle.getFormattedString(
         "quota.usagePercentage.label", [percent].concat(used).concat(total));
     });
   },
   onCancel: function onCancel() {
     if (this._usage_req) {
       this._usage_req.abort();
     }
     if (this._quota_req) {
       this._quota_req.abort();
     }
     return true;
   },
   onAccept: function onAccept() {
     let engines = gUsageTreeView.getEnginesToDisable();
     for each (let engine in engines) {
       Weave.Service.engineManager.get(engine).enabled = false;
     }
     if (engines.length) {
       // The 'Weave' object will disappear once the window closes.
       let Service = Weave.Service;
       Weave.Utils.nextTick(function() { Service.sync(); });
     }
     return this.onCancel();
   },
   convertKB: function convertKB(value) {
     return DownloadUtils.convertByteUnits(value * 1024);
   }
 };
 let gUsageTreeView = {
   _ignored: {keys: true,
              meta: true,
              clients: true},
   /*
    * Internal data structures underlaying the tree.
    */
   _collections: [],
   _byname: {},
   init: function init() {
     let retrievingLabel = gSyncQuota.bundle.getString("quota.retrieving.label");
     for each (let engine in Weave.Service.engineManager.getEnabled()) {
       if (this._ignored[engine.name])
         continue;
       // Some engines use the same pref, which means they can only be turned on
       // and off together. We need to combine them here as well.
       let existing = this._byname[engine.prefName];
       if (existing) {
         existing.engines.push(engine.name);
         continue;
       }
       let obj = {name: engine.prefName,
                  title: this._collectionTitle(engine),
                  engines: [engine.name],
                  enabled: true,
                  sizeLabel: retrievingLabel};
       this._collections.push(obj);
       this._byname[engine.prefName] = obj;
     }
   },
   _collectionTitle: function _collectionTitle(engine) {
     try {
       return gSyncQuota.bundle.getString(
         "collection." + engine.prefName + ".label");
     } catch (ex) {
       return engine.Name;
     }
   },
   /*
    * Process the quota information as returned by info/collection_usage.
    */
   displayUsageData: function displayUsageData(data) {
     for each (let coll in this._collections) {
       coll.size = 0;
       // If we couldn't retrieve any data, just blank out the label.
       if (!data) {
         coll.sizeLabel = "";
         continue;
       }
       for each (let engineName in coll.engines)
         coll.size += data[engineName] || 0;
       let sizeLabel = "";
       sizeLabel = gSyncQuota.bundle.getFormattedString(
         "quota.sizeValueUnit.label", gSyncQuota.convertKB(coll.size));
       coll.sizeLabel = sizeLabel;
     }
     let sizeColumn = this.treeBox.columns.getNamedColumn("size");
     this.treeBox.invalidateColumn(sizeColumn);
   },
   /*
    * Handle click events on the tree.
    */
   onTreeClick: function onTreeClick(event) {
     if (event.button == 2)
       return;
     let row = {}, col = {};
     this.treeBox.getCellAt(event.clientX, event.clientY, row, col, {});
     if (col.value && col.value.id == "enabled")
       this.toggle(row.value);
   },
   /*
    * Toggle enabled state of an engine.
    */
   toggle: function toggle(row) {
     // Update the tree
     let collection = this._collections[row];
     collection.enabled = !collection.enabled;
     this.treeBox.invalidateRow(row);
     // Display which ones will be removed
     let freeup = 0;
     let toremove = [];
     for each (collection in this._collections) {
       if (collection.enabled)
         continue;
       toremove.push(collection.name);
       freeup += collection.size;
     }
     let caption = document.getElementById("treeCaption");
     if (!toremove.length) {
       caption.className = "";
       caption.firstChild.nodeValue = gSyncQuota.bundle.getString(
         "quota.treeCaption.label");
       return;
     }
     toremove = [this._byname[coll].title for each (coll in toremove)];
     toremove = toremove.join(gSyncQuota.bundle.getString("quota.list.separator"));
     caption.firstChild.nodeValue = gSyncQuota.bundle.getFormattedString(
       "quota.removal.label", [toremove]);
     if (freeup)
       caption.firstChild.nodeValue += gSyncQuota.bundle.getFormattedString(
         "quota.freeup.label", gSyncQuota.convertKB(freeup));
     caption.className = "captionWarning";
   },
   /*
    * Return a list of engines (or rather their pref names) that should be
    * disabled.
    */
   getEnginesToDisable: function getEnginesToDisable() {
     return [coll.name for each (coll in this._collections) if (!coll.enabled)];
   },
   // nsITreeView
   get rowCount() {
     return this._collections.length;
   },
   getRowProperties: function(index) { return ""; },
   getCellProperties: function(row, col) { return ""; },
   getColumnProperties: function(col) { return ""; },
   isContainer: function(index) { return false; },
   isContainerOpen: function(index) { return false; },
   isContainerEmpty: function(index) { return false; },
   isSeparator: function(index) { return false; },
   isSorted: function() { return false; },
   canDrop: function(index, orientation, dataTransfer) { return false; },
   drop: function(row, orientation, dataTransfer) {},
   getParentIndex: function(rowIndex) {},
   hasNextSibling: function(rowIndex, afterIndex) { return false; },
   getLevel: function(index) { return 0; },
   getImageSrc: function(row, col) {},
   getCellValue: function(row, col) {
     return this._collections[row].enabled;
   },
   getCellText: function getCellText(row, col) {
     let collection = this._collections[row];
     switch (col.id) {
       case "collection":
         return collection.title;
       case "size":
         return collection.sizeLabel;
       default:
         return "";
     }
   },
   setTree: function setTree(tree) {
     this.treeBox = tree;
   },
   toggleOpenState: function(index) {},
   cycleHeader: function(col) {},
   selectionChanged: function() {},
   cycleCell: function(row, col) {},
   isEditable: function(row, col) { return false; },
   isSelectable: function (row, col) { return false; },
   setCellValue: function(row, col, value) {},
   setCellText: function(row, col, value) {},
   performAction: function(action) {},
   performActionOnRow: function(action, row) {},
   performActionOnCell: function(action, row, col) {}
 };