tor-browser

local-and-session-storage.js (4933B)

---

/* 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 {
 BaseStorageActor,
 DEFAULT_VALUE,
} = require("resource://devtools/server/actors/resources/storage/index.js");
const {
 LongStringActor,
} = require("resource://devtools/server/actors/string.js");

class LocalOrSessionStorageActor extends BaseStorageActor {
 constructor(storageActor, typeName) {
   super(storageActor, typeName);

   Services.obs.addObserver(this, "dom-storage2-changed");
   Services.obs.addObserver(this, "dom-private-storage2-changed");
 }

 destroy() {
   if (this.isDestroyed()) {
     return;
   }
   Services.obs.removeObserver(this, "dom-storage2-changed");
   Services.obs.removeObserver(this, "dom-private-storage2-changed");

   super.destroy();
 }

 getNamesForHost(host) {
   const storage = this.hostVsStores.get(host);
   return storage ? Object.keys(storage) : [];
 }

 getValuesForHost(host, name) {
   const storage = this.hostVsStores.get(host);
   if (!storage) {
     return [];
   }
   if (name) {
     const value = storage ? storage.getItem(name) : null;
     return [{ name, value }];
   }
   if (!storage) {
     return [];
   }

   // local and session storage cannot be iterated over using Object.keys()
   // because it skips keys that are duplicated on the prototype
   // e.g. "key", "getKeys" so we need to gather the real keys using the
   // storage.key() function.
   const storageArray = [];
   for (let i = 0; i < storage.length; i++) {
     const key = storage.key(i);
     storageArray.push({
       name: key,
       value: storage.getItem(key),
     });
   }
   return storageArray;
 }

 // We need to override this method as populateStoresForHost expect the window object
 populateStoresForHosts() {
   this.hostVsStores = new Map();
   for (const window of this.windows) {
     const host = this.getHostName(window.location);
     if (host) {
       this.populateStoresForHost(host, window);
     }
   }
 }

 populateStoresForHost(host, window) {
   try {
     this.hostVsStores.set(host, window[this.typeName]);
   } catch (ex) {
     console.warn(
       `Failed to enumerate ${this.typeName} for host ${host}: ${ex}`
     );
   }
 }

 async getFields() {
   return [
     { name: "name", editable: true },
     { name: "value", editable: true },
   ];
 }

 async addItem(guid, host) {
   const storage = this.hostVsStores.get(host);
   if (!storage) {
     return;
   }
   storage.setItem(guid, DEFAULT_VALUE);
 }

 /**
  * Edit localStorage or sessionStorage fields.
  *
  * @param {object} data
  *        See editCookie() for format details.
  */
 async editItem({ host, field, oldValue, items }) {
   const storage = this.hostVsStores.get(host);
   if (!storage) {
     return;
   }

   if (field === "name") {
     storage.removeItem(oldValue);
   }

   storage.setItem(items.name, items.value);
 }

 async removeItem(host, name) {
   const storage = this.hostVsStores.get(host);
   if (!storage) {
     return;
   }
   storage.removeItem(name);
 }

 async removeAll(host) {
   const storage = this.hostVsStores.get(host);
   if (!storage) {
     return;
   }
   storage.clear();
 }

 observe(subject, topic, data) {
   if (
     (topic != "dom-storage2-changed" &&
       topic != "dom-private-storage2-changed") ||
     data != this.typeName
   ) {
     return null;
   }

   const host = this.getSchemaAndHost(subject.url);

   if (!this.hostVsStores.has(host)) {
     return null;
   }

   let action = "changed";
   if (subject.key == null) {
     return this.storageActor.update("cleared", this.typeName, [host]);
   } else if (subject.oldValue == null) {
     action = "added";
   } else if (subject.newValue == null) {
     action = "deleted";
   }
   const updateData = {};
   updateData[host] = [subject.key];
   return this.storageActor.update(action, this.typeName, updateData);
 }

 /**
  * Given a url, correctly determine its protocol + hostname part.
  */
 getSchemaAndHost(url) {
   const uri = Services.io.newURI(url);
   if (!uri.host) {
     return uri.spec;
   }
   return uri.scheme + "://" + uri.hostPort;
 }

 toStoreObject(item) {
   if (!item) {
     return null;
   }

   return {
     name: item.name,
     value: new LongStringActor(this.conn, item.value || ""),
   };
 }
}

class LocalStorageActor extends LocalOrSessionStorageActor {
 constructor(storageActor) {
   super(storageActor, "localStorage");
 }
}
exports.LocalStorageActor = LocalStorageActor;

class SessionStorageActor extends LocalOrSessionStorageActor {
 constructor(storageActor) {
   super(storageActor, "sessionStorage");
 }
}
exports.SessionStorageActor = SessionStorageActor;