The Tor Browser: addon-sdk/source/lib/sdk/ui/toolbar/model.js@129ffea94266 (annotated)

addon-sdk/source/lib/sdk/ui/toolbar/model.js@129ffea94266 (annotated)

addon-sdk/source/lib/sdk/ui/toolbar/model.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";
 module.metadata = {
   "stability": "experimental",
   "engines": {
     "Firefox": "> 28"
   }
 };
 const { Class } = require("../../core/heritage");
 const { EventTarget } = require("../../event/target");
 const { off, setListeners, emit } = require("../../event/core");
 const { Reactor, foldp, merges, send } = require("../../event/utils");
 const { Disposable } = require("../../core/disposable");
 const { InputPort } = require("../../input/system");
 const { OutputPort } = require("../../output/system");
 const { identify } = require("../id");
 const { pairs, object, map, each } = require("../../util/sequence");
 const { patch, diff } = require("diffpatcher/index");
 const { contract } = require("../../util/contract");
 const { id: addonID } = require("../../self");
 // Input state is accumulated from the input received form the toolbar
 // view code & local output. Merging local output reflects local state
 // changes without complete roundloop.
 const input = foldp(patch, {}, new InputPort({ id: "toolbar-changed" }));
 const output = new OutputPort({ id: "toolbar-change" });
 // Takes toolbar title and normalizes is to an
 // identifier, also prefixes with add-on id.
 const titleToId = title =>
   ("toolbar-" + addonID + "-" + title).
     toLowerCase().
     replace(/\s/g, "-").
     replace(/[^A-Za-z0-9_\-]/g, "");
 const validate = contract({
   title: {
     is: ["string"],
     ok: x => x.length > 0,
     msg: "The `option.title` string must be provided"
   },
   items: {
     is:["undefined", "object", "array"],
     msg: "The `options.items` must be iterable sequence of items"
   },
   hidden: {
     is: ["boolean", "undefined"],
     msg: "The `options.hidden` must be boolean"
   }
 });
 // Toolbars is a mapping between `toolbar.id` & `toolbar` instances,
 // which is used to find intstance for dispatching events.
 let toolbars = new Map();
 const Toolbar = Class({
   extends: EventTarget,
   implements: [Disposable],
   initialize: function(params={}) {
     const options = validate(params);
     const id = titleToId(options.title);
     if (toolbars.has(id))
       throw Error("Toolbar with this id already exists: " + id);
     // Set of the items in the toolbar isn't mutable, as a matter of fact
     // it just defines desired set of items, actual set is under users
     // control. Conver test to an array and freeze to make sure users won't
     // try mess with it.
     const items = Object.freeze(options.items ? [...options.items] : []);
     const initial = {
       id: id,
       title: options.title,
       // By default toolbars are visible when add-on is installed, unless
       // add-on authors decides it should be hidden. From that point on
       // user is in control.
       collapsed: !!options.hidden,
       // In terms of state only identifiers of items matter.
       items: items.map(identify)
     };
     this.id = id;
     this.items = items;
     toolbars.set(id, this);
     setListeners(this, params);
     // Send initial state to the host so it can reflect it
     // into a user interface.
     send(output, object([id, initial]));
   },
   get title() {
     const state = reactor.value[this.id];
     return state && state.title;
   },
   get hidden() {
     const state = reactor.value[this.id];
     return state && state.collapsed;
   },
   destroy: function() {
     send(output, object([this.id, null]));
   },
   // `JSON.stringify` serializes objects based of the return
   // value of this method. For convinienc we provide this method
   // to serialize actual state data. Note: items will also be
   // serialized so they should probably implement `toJSON`.
   toJSON: function() {
     return {
       id: this.id,
       title: this.title,
       hidden: this.hidden,
       items: this.items
     };
   }
 });
 exports.Toolbar = Toolbar;
 identify.define(Toolbar, toolbar => toolbar.id);
 const dispose = toolbar => {
   toolbars.delete(toolbar.id);
   emit(toolbar, "detach");
   off(toolbar);
 };
 const reactor = new Reactor({
   onStep: (present, past) => {
     const delta = diff(past, present);
     each(([id, update]) => {
       const toolbar = toolbars.get(id);
       // Remove
       if (!update)
         dispose(toolbar);
       // Add
       else if (!past[id])
         emit(toolbar, "attach");
       // Update
       else
         emit(toolbar, update.collapsed ? "hide" : "show", toolbar);
     }, pairs(delta));
   }
 });
 reactor.run(input);