The Tor Browser: toolkit/components/places/tests/browser/head.js@6474c204b198 (annotated)

toolkit/components/places/tests/browser/head.js@6474c204b198 (annotated)

toolkit/components/places/tests/browser/head.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.

 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 const TRANSITION_LINK = Ci.nsINavHistoryService.TRANSITION_LINK;
 const TRANSITION_TYPED = Ci.nsINavHistoryService.TRANSITION_TYPED;
 const TRANSITION_BOOKMARK = Ci.nsINavHistoryService.TRANSITION_BOOKMARK;
 const TRANSITION_REDIRECT_PERMANENT = Ci.nsINavHistoryService.TRANSITION_REDIRECT_PERMANENT;
 const TRANSITION_REDIRECT_TEMPORARY = Ci.nsINavHistoryService.TRANSITION_REDIRECT_TEMPORARY;
 const TRANSITION_EMBED = Ci.nsINavHistoryService.TRANSITION_EMBED;
 const TRANSITION_FRAMED_LINK = Ci.nsINavHistoryService.TRANSITION_FRAMED_LINK;
 const TRANSITION_DOWNLOAD = Ci.nsINavHistoryService.TRANSITION_DOWNLOAD;
 Components.utils.import("resource://gre/modules/NetUtil.jsm");
 XPCOMUtils.defineLazyModuleGetter(this, "Promise",
                                   "resource://gre/modules/Promise.jsm");
 XPCOMUtils.defineLazyModuleGetter(this, "Task",
                                   "resource://gre/modules/Task.jsm");
 /**
  * Allows waiting for an observer notification once.
  *
  * @param aTopic
  *        Notification topic to observe.
  *
  * @return {Promise}
  * @resolves The array [aSubject, aData] from the observed notification.
  * @rejects Never.
  */
 function promiseTopicObserved(aTopic)
 {
   let deferred = Promise.defer();
   Services.obs.addObserver(
     function PTO_observe(aSubject, aTopic, aData) {
       Services.obs.removeObserver(PTO_observe, aTopic);
       deferred.resolve([aSubject, aData]);
     }, aTopic, false);
   return deferred.promise;
 }
 /**
  * Clears history asynchronously.
  *
  * @return {Promise}
  * @resolves When history has been cleared.
  * @rejects Never.
  */
 function promiseClearHistory() {
   let promise = promiseTopicObserved(PlacesUtils.TOPIC_EXPIRATION_FINISHED);
   PlacesUtils.bhistory.removeAllPages();
   return promise;
 }
 /**
  * Waits for all pending async statements on the default connection.
  *
  * @return {Promise}
  * @resolves When all pending async statements finished.
  * @rejects Never.
  *
  * @note The result is achieved by asynchronously executing a query requiring
  *       a write lock.  Since all statements on the same connection are
  *       serialized, the end of this write operation means that all writes are
  *       complete.  Note that WAL makes so that writers don't block readers, but
  *       this is a problem only across different connections.
  */
 function promiseAsyncUpdates()
 {
   let deferred = Promise.defer();
   let db = PlacesUtils.history.QueryInterface(Ci.nsPIPlacesDatabase)
                               .DBConnection;
   let begin = db.createAsyncStatement("BEGIN EXCLUSIVE");
   begin.executeAsync();
   begin.finalize();
   let commit = db.createAsyncStatement("COMMIT");
   commit.executeAsync({
     handleResult: function() {},
     handleError: function() {},
     handleCompletion: function(aReason)
     {
       deferred.resolve();
     }
   });
   commit.finalize();
   return deferred.promise;
 }
 /**
  * Returns a moz_places field value for a url.
  *
  * @param aURI
  *        The URI or spec to get field for.
  * param aCallback
  *        Callback function that will get the property value.
  */
 function fieldForUrl(aURI, aFieldName, aCallback)
 {
   let url = aURI instanceof Ci.nsIURI ? aURI.spec : aURI;
   let stmt = PlacesUtils.history.QueryInterface(Ci.nsPIPlacesDatabase)
                                 .DBConnection.createAsyncStatement(
     "SELECT " + aFieldName + " FROM moz_places WHERE url = :page_url"
   );
   stmt.params.page_url = url;
   stmt.executeAsync({
     _value: -1,
     handleResult: function(aResultSet) {
       let row = aResultSet.getNextRow();
       if (!row)
         ok(false, "The page should exist in the database");
       this._value = row.getResultByName(aFieldName);
     },
     handleError: function() {},
     handleCompletion: function(aReason) {
       if (aReason != Ci.mozIStorageStatementCallback.REASON_FINISHED)
          ok(false, "The statement should properly succeed");
       aCallback(this._value);
     }
   });
   stmt.finalize();
 }
 /**
  * Generic nsINavHistoryObserver that doesn't implement anything, but provides
  * dummy methods to prevent errors about an object not having a certain method.
  */
 function NavHistoryObserver() {}
 NavHistoryObserver.prototype = {
   onBeginUpdateBatch: function () {},
   onEndUpdateBatch: function () {},
   onVisit: function () {},
   onTitleChanged: function () {},
   onDeleteURI: function () {},
   onClearHistory: function () {},
   onPageChanged: function () {},
   onDeleteVisits: function () {},
   QueryInterface: XPCOMUtils.generateQI([
     Ci.nsINavHistoryObserver,
   ])
 };
 /**
  * Waits for the first OnPageChanged notification for ATTRIBUTE_FAVICON, and
  * verifies that it matches the expected page URI and associated favicon URI.
  *
  * This function also double-checks the GUID parameter of the notification.
  *
  * @param aExpectedPageURI
  *        nsIURI object of the page whose favicon should change.
  * @param aExpectedFaviconURI
  *        nsIURI object of the newly associated favicon.
  * @param aCallback
  *        This function is called after the check finished.
  */
 function waitForFaviconChanged(aExpectedPageURI, aExpectedFaviconURI, aWindow,
                                aCallback) {
   let historyObserver = {
     __proto__: NavHistoryObserver.prototype,
     onPageChanged: function WFFC_onPageChanged(aURI, aWhat, aValue, aGUID) {
       if (aWhat != Ci.nsINavHistoryObserver.ATTRIBUTE_FAVICON) {
         return;
       }
       aWindow.PlacesUtils.history.removeObserver(this);
       ok(aURI.equals(aExpectedPageURI),
         "Check URIs are equal for the page which favicon changed");
       is(aValue, aExpectedFaviconURI.spec,
         "Check changed favicon URI is the expected");
       checkGuidForURI(aURI, aGUID);
       if (aCallback) {
         aCallback();
       }
     }
   };
   aWindow.PlacesUtils.history.addObserver(historyObserver, false);
 }
 /**
  * Asynchronously adds visits to a page, invoking a callback function when done.
  *
  * @param aPlaceInfo
  *        Either an nsIURI, in such a case a single LINK visit will be added.
  *        Or can be an object describing the visit to add, or an array
  *        of these objects:
  *          { uri: nsIURI of the page,
  *            transition: one of the TRANSITION_* from nsINavHistoryService,
  *            [optional] title: title of the page,
  *            [optional] visitDate: visit date in microseconds from the epoch
  *            [optional] referrer: nsIURI of the referrer for this visit
  *          }
  * @param [optional] aCallback
  *        Function to be invoked on completion.
  * @param [optional] aStack
  *        The stack frame used to report errors.
  */
 function addVisits(aPlaceInfo, aWindow, aCallback, aStack) {
   let stack = aStack || Components.stack.caller;
   let places = [];
   if (aPlaceInfo instanceof Ci.nsIURI) {
     places.push({ uri: aPlaceInfo });
   }
   else if (Array.isArray(aPlaceInfo)) {
     places = places.concat(aPlaceInfo);
   } else {
     places.push(aPlaceInfo)
   }
   // Create mozIVisitInfo for each entry.
   let now = Date.now();
   for (let place of places) {
     if (!place.title) {
       place.title = "test visit for " + place.uri.spec;
     }
     place.visits = [{
       transitionType: place.transition === undefined ? TRANSITION_LINK
                                                      : place.transition,
       visitDate: place.visitDate || (now++) * 1000,
       referrerURI: place.referrer
     }];
   }
   aWindow.PlacesUtils.asyncHistory.updatePlaces(
     places,
     {
       handleError: function AAV_handleError() {
         throw("Unexpected error in adding visit.");
       },
       handleResult: function () {},
       handleCompletion: function UP_handleCompletion() {
         if (aCallback)
           aCallback();
       }
     }
   );
 }
 /**
  * Asynchronously adds visits to a page.
  *
  * @param aPlaceInfo
  *        Can be an nsIURI, in such a case a single LINK visit will be added.
  *        Otherwise can be an object describing the visit to add, or an array
  *        of these objects:
  *          { uri: nsIURI of the page,
  *            transition: one of the TRANSITION_* from nsINavHistoryService,
  *            [optional] title: title of the page,
  *            [optional] visitDate: visit date in microseconds from the epoch
  *            [optional] referrer: nsIURI of the referrer for this visit
  *          }
  *
  * @return {Promise}
  * @resolves When all visits have been added successfully.
  * @rejects JavaScript exception.
  */
 function promiseAddVisits(aPlaceInfo)
 {
   let deferred = Promise.defer();
   let places = [];
   if (aPlaceInfo instanceof Ci.nsIURI) {
     places.push({ uri: aPlaceInfo });
   }
   else if (Array.isArray(aPlaceInfo)) {
     places = places.concat(aPlaceInfo);
   } else {
     places.push(aPlaceInfo)
   }
   // Create mozIVisitInfo for each entry.
   let now = Date.now();
   for (let i = 0; i < places.length; i++) {
     if (!places[i].title) {
       places[i].title = "test visit for " + places[i].uri.spec;
     }
     places[i].visits = [{
       transitionType: places[i].transition === undefined ? TRANSITION_LINK
                                                          : places[i].transition,
       visitDate: places[i].visitDate || (now++) * 1000,
       referrerURI: places[i].referrer
     }];
   }
   PlacesUtils.asyncHistory.updatePlaces(
     places,
     {
       handleError: function AAV_handleError(aResultCode, aPlaceInfo) {
         let ex = new Components.Exception("Unexpected error in adding visits.",
                                           aResultCode);
         deferred.reject(ex);
       },
       handleResult: function () {},
       handleCompletion: function UP_handleCompletion() {
         deferred.resolve();
       }
     }
   );
   return deferred.promise;
 }
 /**
  * Checks that the favicon for the given page matches the provided data.
  *
  * @param aPageURI
  *        nsIURI object for the page to check.
  * @param aExpectedMimeType
  *        Expected MIME type of the icon, for example "image/png".
  * @param aExpectedData
  *        Expected icon data, expressed as an array of byte values.
  * @param aCallback
  *        This function is called after the check finished.
  */
 function checkFaviconDataForPage(aPageURI, aExpectedMimeType, aExpectedData,
   aWindow, aCallback) {
   aWindow.PlacesUtils.favicons.getFaviconDataForPage(aPageURI,
     function (aURI, aDataLen, aData, aMimeType) {
       is(aExpectedMimeType, aMimeType, "Check expected MimeType");
       is(aExpectedData.length, aData.length,
         "Check favicon data for the given page matches the provided data");
       checkGuidForURI(aPageURI);
       aCallback();
     });
 }
 /**
  * Tests that a guid was set in moz_places for a given uri.
  *
  * @param aURI
  *        The uri to check.
  * @param [optional] aGUID
  *        The expected guid in the database.
  */
 function checkGuidForURI(aURI, aGUID) {
   let guid = doGetGuidForURI(aURI);
   if (aGUID) {
     doCheckValidPlacesGuid(aGUID);
     is(guid, aGUID, "Check equal guid for URIs");
   }
 }
 /**
  * Retrieves the guid for a given uri.
  *
  * @param aURI
  *        The uri to check.
  * @return the associated the guid.
  */
 function doGetGuidForURI(aURI) {
   let stmt = DBConn().createStatement(
     "SELECT guid "
     + "FROM moz_places "
     + "WHERE url = :url "
   );
   stmt.params.url = aURI.spec;
   ok(stmt.executeStep(), "Check get guid for uri from moz_places");
   let guid = stmt.row.guid;
   stmt.finalize();
   doCheckValidPlacesGuid(guid);
   return guid;
 }
 /**
  * Tests if a given guid is valid for use in Places or not.
  *
  * @param aGuid
  *        The guid to test.
  */
 function doCheckValidPlacesGuid(aGuid) {
   ok(/^[a-zA-Z0-9\-_]{12}$/.test(aGuid), "Check guid for valid places");
 }
 /**
  * Gets the database connection.  If the Places connection is invalid it will
  * try to create a new connection.
  *
  * @param [optional] aForceNewConnection
  *        Forces creation of a new connection to the database.  When a
  *        connection is asyncClosed it cannot anymore schedule async statements,
  *        though connectionReady will keep returning true (Bug 726990).
  *
  * @return The database connection or null if unable to get one.
  */
 function DBConn(aForceNewConnection) {
   let gDBConn;
   if (!aForceNewConnection) {
     let db = PlacesUtils.history.QueryInterface(Ci.nsPIPlacesDatabase)
       .DBConnection;
     if (db.connectionReady)
       return db;
   }
   // If the Places database connection has been closed, create a new connection.
   if (!gDBConn || aForceNewConnection) {
     let file = Services.dirsvc.get('ProfD', Ci.nsIFile);
     file.append("places.sqlite");
     let dbConn = gDBConn = Services.storage.openDatabase(file);
     // Be sure to cleanly close this connection.
     Services.obs.addObserver(function DBCloseCallback(aSubject, aTopic, aData) {
       Services.obs.removeObserver(DBCloseCallback, aTopic);
       dbConn.asyncClose();
     }, "profile-before-change", false);
   }
   return gDBConn.connectionReady ? gDBConn : null;
 }
 function whenDelayedStartupFinished(aWindow, aCallback) {
   Services.obs.addObserver(function observer(aSubject, aTopic) {
     if (aWindow == aSubject) {
       Services.obs.removeObserver(observer, aTopic);
       executeSoon(function() { aCallback(aWindow); });
     }
   }, "browser-delayed-startup-finished", false);
 }
 function whenNewWindowLoaded(aOptions, aCallback) {
   let win = OpenBrowserWindow(aOptions);
   whenDelayedStartupFinished(win, aCallback);
 }
 /**
  * Asynchronously check a url is visited.
  *
  * @param aURI The URI.
  * @param aExpectedValue The expected value.
  * @return {Promise}
  * @resolves When the check has been added successfully.
  * @rejects JavaScript exception.
  */
 function promiseIsURIVisited(aURI, aExpectedValue) {
   let deferred = Promise.defer();
   PlacesUtils.asyncHistory.isURIVisited(aURI, function(aURI, aIsVisited) {
     deferred.resolve(aIsVisited);
   });
   return deferred.promise;
 }
 function waitForCondition(condition, nextTest, errorMsg) {
   let tries = 0;
   let interval = setInterval(function() {
     if (tries >= 30) {
       ok(false, errorMsg);
       moveOn();
     }
     let conditionPassed;
     try {
       conditionPassed = condition();
     } catch (e) {
       ok(false, e + "\n" + e.stack);
       conditionPassed = false;
     }
     if (conditionPassed) {
       moveOn();
     }
     tries++;
   }, 200);
   function moveOn() {
     clearInterval(interval);
     nextTest();
   };
 }