The Tor Browser: addon-sdk/source/lib/sdk/places/host/host-query.js@129ffea94266 (annotated)

addon-sdk/source/lib/sdk/places/host/host-query.js@129ffea94266 (annotated)

addon-sdk/source/lib/sdk/places/host/host-query.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": "*"
   }
 };
 const { Cc, Ci } = require('chrome');
 const { defer, all, resolve } = require('../../core/promise');
 const { safeMerge, omit } = require('../../util/object');
 const historyService = Cc['@mozilla.org/browser/nav-history-service;1']
                      .getService(Ci.nsINavHistoryService);
 const bookmarksService = Cc['@mozilla.org/browser/nav-bookmarks-service;1']
                          .getService(Ci.nsINavBookmarksService);
 const { request, response } = require('../../addon/host');
 const { newURI } = require('../../url/utils');
 const { send } = require('../../addon/events');
 const { on, emit } = require('../../event/core');
 const { filter } = require('../../event/utils');
 const ROOT_FOLDERS = [
   bookmarksService.unfiledBookmarksFolder, bookmarksService.toolbarFolder,
   bookmarksService.bookmarksMenuFolder
 ];
 const EVENT_MAP = {
   'sdk-places-query': queryReceiver
 };
 // Properties that need to be manually
 // copied into a nsINavHistoryQuery object
 const MANUAL_QUERY_PROPERTIES = [
   'uri', 'folder', 'tags', 'url', 'folder'
 ];
 const PLACES_PROPERTIES = [
   'uri', 'title', 'accessCount', 'time'
 ];
 function execute (queries, options) {
   let deferred = defer();
   let root = historyService
     .executeQueries(queries, queries.length, options).root;
   let items = collect([], root);
   deferred.resolve(items);
   return deferred.promise;
 }
 function collect (acc, node) {
   node.containerOpen = true;
   for (let i = 0; i < node.childCount; i++) {
     let child = node.getChild(i);
     acc.push(child);
     if (child.type === child.RESULT_TYPE_FOLDER) {
       let container = child.QueryInterface(Ci.nsINavHistoryContainerResultNode);
       collect(acc, container);
     }
   }
   node.containerOpen = false;
   return acc;
 }
 function query (queries, options) {
   queries = queries || [];
   options = options || {};
   let deferred = defer();
   let optionsObj, queryObjs;
   try {
     optionsObj = historyService.getNewQueryOptions();
     queryObjs = [].concat(queries).map(createQuery);
     if (!queryObjs.length) {
       queryObjs = [historyService.getNewQuery()];
     }
     safeMerge(optionsObj, options);
   } catch (e) {
     deferred.reject(e);
     return deferred.promise;
   }
   /*
    * Currently `places:` queries are not supported
    */
   optionsObj.excludeQueries = true;
   execute(queryObjs, optionsObj).then(function (results) {
     if (optionsObj.queryType === 0) {
       return results.map(normalize);
     } else if (optionsObj.queryType === 1) {
       // Formats query results into more standard
       // data structures for returning
       return all(results.map(({itemId}) =>
         send('sdk-places-bookmarks-get', { id: itemId })));
     }
   }).then(deferred.resolve, deferred.reject);
   return deferred.promise;
 }
 exports.query = query;
 function createQuery (query) {
   query = query || {};
   let queryObj = historyService.getNewQuery();
   safeMerge(queryObj, omit(query, MANUAL_QUERY_PROPERTIES));
   if (query.tags && Array.isArray(query.tags))
     queryObj.tags = query.tags;
   if (query.uri || query.url)
     queryObj.uri = newURI(query.uri || query.url);
   if (query.folder)
     queryObj.setFolders([query.folder], 1);
   return queryObj;
 }
 function queryReceiver (message) {
   let queries = message.data.queries || message.data.query;
   let options = message.data.options;
   let resData = {
     id: message.id,
     event: message.event
   };
   query(queries, options).then(results => {
     resData.data = results;
     respond(resData);
   }, reason => {
     resData.error = reason;
     respond(resData);
   });
 }
 /*
  * Converts a nsINavHistoryResultNode into a plain object
  *
  * https://developer.mozilla.org/en-US/docs/XPCOM_Interface_Reference/nsINavHistoryResultNode
  */
 function normalize (historyObj) {
   return PLACES_PROPERTIES.reduce((obj, prop) => {
     if (prop === 'uri')
       obj.url = historyObj.uri;
     else if (prop === 'time') {
       // Cast from microseconds to milliseconds
       obj.time = Math.floor(historyObj.time / 1000)
     } else if (prop === 'accessCount')
       obj.visitCount = historyObj[prop];
     else
       obj[prop] = historyObj[prop];
     return obj;
   }, {});
 }
 /*
  * Hook into host
  */
 let reqStream = filter(request, function (data) /sdk-places-query/.test(data.event));
 on(reqStream, 'data', function (e) {
   if (EVENT_MAP[e.event]) EVENT_MAP[e.event](e);
 });
 function respond (data) {
   emit(response, 'data', data);
 }