The Tor Browser: addon-sdk/source/lib/sdk/places/bookmarks.js@6474c204b198 (annotated)

addon-sdk/source/lib/sdk/places/bookmarks.js@6474c204b198 (annotated)

addon-sdk/source/lib/sdk/places/bookmarks.js

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /* 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": "unstable",
   "engines": {
     "Firefox": "*"
   }
 };
 /*
  * Requiring hosts so they can subscribe to client messages
  */
 require('./host/host-bookmarks');
 require('./host/host-tags');
 require('./host/host-query');
 const { Cc, Ci } = require('chrome');
 const { Class } = require('../core/heritage');
 const { send } = require('../addon/events');
 const { defer, reject, all, resolve, promised } = require('../core/promise');
 const { EventTarget } = require('../event/target');
 const { emit } = require('../event/core');
 const { identity, defer:async } = require('../lang/functional');
 const { extend, merge } = require('../util/object');
 const { fromIterator } = require('../util/array');
 const {
   constructTree, fetchItem, createQuery,
   isRootGroup, createQueryOptions
 } = require('./utils');
 const {
   bookmarkContract, groupContract, separatorContract
 } = require('./contract');
 const bmsrv = Cc["@mozilla.org/browser/nav-bookmarks-service;1"].
                 getService(Ci.nsINavBookmarksService);
 /*
  * Mapping of uncreated bookmarks with their created
  * counterparts
  */
 const itemMap = new WeakMap();
 /*
  * Constant used by nsIHistoryQuery; 1 is a bookmark query
  * https://developer.mozilla.org/en-US/docs/XPCOM_Interface_Reference/nsINavHistoryQueryOptions
  */
 const BOOKMARK_QUERY = 1;
 /*
  * Bookmark Item classes
  */
 const Bookmark = Class({
   extends: [
     bookmarkContract.properties(identity)
   ],
   initialize: function initialize (options) {
     merge(this, bookmarkContract(extend(defaults, options)));
   },
   type: 'bookmark',
   toString: function () '[object Bookmark]'
 });
 exports.Bookmark = Bookmark;
 const Group = Class({
   extends: [
     groupContract.properties(identity)
   ],
   initialize: function initialize (options) {
     // Don't validate if root group
     if (isRootGroup(options))
       merge(this, options);
     else
       merge(this, groupContract(extend(defaults, options)));
   },
   type: 'group',
   toString: function () '[object Group]'
 });
 exports.Group = Group;
 const Separator = Class({
   extends: [
     separatorContract.properties(identity)
   ],
   initialize: function initialize (options) {
     merge(this, separatorContract(extend(defaults, options)));
   },
   type: 'separator',
   toString: function () '[object Separator]'
 });
 exports.Separator = Separator;
 /*
  * Functions
  */
 function save (items, options) {
   items = [].concat(items);
   options = options || {};
   let emitter = EventTarget();
   let results = [];
   let errors = [];
   let root = constructTree(items);
   let cache = new Map();
   let isExplicitSave = item => !!~items.indexOf(item);
   // `walk` returns an aggregate promise indicating the completion
   // of the `commitItem` on each node, not whether or not that
   // commit was successful
   // Force this to be async, as if a ducktype fails validation,
   // the promise implementation will fire an error event, which will
   // not trigger the handler as it's not yet bound
   //
   // Can remove after `Promise.jsm` is implemented in Bug 881047,
   // which will guarantee next tick execution
   async(() => root.walk(preCommitItem).then(commitComplete))();
   function preCommitItem ({value:item}) {
     // Do nothing if tree root, default group (unsavable),
     // or if it's a dependency and not explicitly saved (in the list
     // of items to be saved), and not needed to be saved
     if (item === null || // node is the tree root
         isRootGroup(item) ||
         (getId(item) && !isExplicitSave(item)))
       return;
     return promised(validate)(item)
       .then(() => commitItem(item, options))
       .then(data => construct(data, cache))
       .then(savedItem => {
         // If item was just created, make a map between
         // the creation object and created object,
         // so we can reference the item that doesn't have an id
         if (!getId(item))
           saveId(item, savedItem.id);
         // Emit both the processed item, and original item
         // so a mapping can be understood in handler
         emit(emitter, 'data', savedItem, item);
         // Push to results iff item was explicitly saved
         if (isExplicitSave(item))
           results[items.indexOf(item)] = savedItem;
       }, reason => {
         // Force reason to be a string for consistency
         reason = reason + '';
         // Emit both the reason, and original item
         // so a mapping can be understood in handler
         emit(emitter, 'error', reason + '', item);
         // Store unsaved item in results list
         results[items.indexOf(item)] = item;
         errors.push(reason);
       });
   }
   // Called when traversal of the node tree is completed and all
   // items have been committed
   function commitComplete () {
     emit(emitter, 'end', results);
   }
   return emitter;
 }
 exports.save = save;
 function search (queries, options) {
   queries = [].concat(queries);
   let emitter = EventTarget();
   let cache = new Map();
   let queryObjs = queries.map(createQuery.bind(null, BOOKMARK_QUERY));
   let optionsObj = createQueryOptions(BOOKMARK_QUERY, options);
   // Can remove after `Promise.jsm` is implemented in Bug 881047,
   // which will guarantee next tick execution
   async(() => {
     send('sdk-places-query', { queries: queryObjs, options: optionsObj })
       .then(handleQueryResponse);
   })();
   function handleQueryResponse (data) {
     let deferreds = data.map(item => {
       return construct(item, cache).then(bookmark => {
         emit(emitter, 'data', bookmark);
         return bookmark;
       }, reason => {
         emit(emitter, 'error', reason);
         errors.push(reason);
       });
     });
     all(deferreds).then(data => {
       emit(emitter, 'end', data);
     }, () => emit(emitter, 'end', []));
   }
   return emitter;
 }
 exports.search = search;
 function remove (items) {
   return [].concat(items).map(item => {
     item.remove = true;
     return item;
   });
 }
 exports.remove = remove;
 /*
  * Internal Utilities
  */
 function commitItem (item, options) {
   // Get the item's ID, or getId it's saved version if it exists
   let id = getId(item);
   let data = normalize(item);
   let promise;
   data.id = id;
   if (!id) {
     promise = send('sdk-places-bookmarks-create', data);
   } else if (item.remove) {
     promise = send('sdk-places-bookmarks-remove', { id: id });
   } else {
     promise = send('sdk-places-bookmarks-last-updated', {
       id: id
     }).then(function (updated) {
       // If attempting to save an item that is not the
       // latest snapshot of a bookmark item, execute
       // the resolution function
       if (updated !== item.updated && options.resolve)
         return fetchItem(id)
           .then(options.resolve.bind(null, data));
       else
         return data;
     }).then(send.bind(null, 'sdk-places-bookmarks-save'));
   }
   return promise;
 }
 /*
  * Turns a bookmark item into a plain object,
  * converts `tags` from Set to Array, group instance to an id
  */
 function normalize (item) {
   let data = merge({}, item);
   // Circumvent prototype property of `type`
   delete data.type;
   data.type = item.type;
   data.tags = [];
   if (item.tags) {
     data.tags = fromIterator(item.tags);
   }
   data.group = getId(data.group) || exports.UNSORTED.id;
   return data;
 }
 /*
  * Takes a data object and constructs a BookmarkItem instance
  * of it, recursively generating parent instances as well.
  *
  * Pass in a `cache` Map to reuse instances of
  * bookmark items to reduce overhead;
  * The cache object is a map of id to a deferred with a
  * promise that resolves to the bookmark item.
  */
 function construct (object, cache, forced) {
   let item = instantiate(object);
   let deferred = defer();
   // Item could not be instantiated
   if (!item)
     return resolve(null);
   // Return promise for item if found in the cache,
   // and not `forced`. `forced` indicates that this is the construct
   // call that should not read from cache, but should actually perform
   // the construction, as it was set before several async calls
   if (cache.has(item.id) && !forced)
     return cache.get(item.id).promise;
   else if (cache.has(item.id))
     deferred = cache.get(item.id);
   else
     cache.set(item.id, deferred);
   // When parent group is found in cache, use
   // the same deferred value
   if (item.group && cache.has(item.group)) {
     cache.get(item.group).promise.then(group => {
       item.group = group;
       deferred.resolve(item);
     });
   // If not in the cache, and a root group, return
   // the premade instance
   } else if (rootGroups.get(item.group)) {
     item.group = rootGroups.get(item.group);
     deferred.resolve(item);
   // If not in the cache or a root group, fetch the parent
   } else {
     cache.set(item.group, defer());
     fetchItem(item.group).then(group => {
       return construct(group, cache, true);
     }).then(group => {
       item.group = group;
       deferred.resolve(item);
     }, deferred.reject);
   }
   return deferred.promise;
 }
 function instantiate (object) {
   if (object.type === 'bookmark')
     return Bookmark(object);
   if (object.type === 'group')
     return Group(object);
   if (object.type === 'separator')
     return Separator(object);
   return null;
 }
 /**
  * Validates a bookmark item; will throw an error if ininvalid,
  * to be used with `promised`. As bookmark items check on their class,
  * this only checks ducktypes
  */
 function validate (object) {
   if (!isDuckType(object)) return true;
   let contract = object.type === 'bookmark' ? bookmarkContract :
                  object.type === 'group' ? groupContract :
                  object.type === 'separator' ? separatorContract :
                  null;
   if (!contract) {
     throw Error('No type specified');
   }
   // If object has a property set, and undefined,
   // manually override with default as it'll fail otherwise
   let withDefaults = Object.keys(defaults).reduce((obj, prop) => {
     if (obj[prop] == null) obj[prop] = defaults[prop];
     return obj;
   }, extend(object));
   contract(withDefaults);
 }
 function isDuckType (item) {
   return !(item instanceof Bookmark) &&
     !(item instanceof Group) &&
     !(item instanceof Separator);
 }
 function saveId (unsaved, id) {
   itemMap.set(unsaved, id);
 }
 // Fetches an item's ID from itself, or from the mapped items
 function getId (item) {
   return typeof item === 'number' ? item :
     item ? item.id || itemMap.get(item) :
     null;
 }
 /*
  * Set up the default, root groups
  */
 let defaultGroupMap = {
   MENU: bmsrv.bookmarksMenuFolder,
   TOOLBAR: bmsrv.toolbarFolder,
   UNSORTED: bmsrv.unfiledBookmarksFolder
 };
 let rootGroups = new Map();
 for (let i in defaultGroupMap) {
   let group = Object.freeze(Group({ title: i, id: defaultGroupMap[i] }));
   rootGroups.set(defaultGroupMap[i], group);
   exports[i] = group;
 }
 let defaults = {
   group: exports.UNSORTED,
   index: -1
 };