tor-browser

browser_sanitize-timespans_v2.js (33157B)

---

requestLongerTimeout(2);

const { PlacesTestUtils } = ChromeUtils.importESModule(
 "resource://testing-common/PlacesTestUtils.sys.mjs"
);

// Bug 453440 - Test the timespan-based logic of the sanitizer code
var now_mSec = Date.now();
var now_uSec = now_mSec * 1000;

const kMsecPerMin = 60 * 1000;
const kUsecPerMin = 60 * 1000000;

function promiseFormHistoryRemoved() {
 return new Promise(resolve => {
   Services.obs.addObserver(function onfh() {
     Services.obs.removeObserver(onfh, "satchel-storage-changed");
     resolve();
   }, "satchel-storage-changed");
 });
}

function promiseDownloadRemoved(list) {
 return new Promise(resolve => {
   let view = {
     onDownloadRemoved() {
       list.removeView(view);
       resolve();
     },
   };

   list.addView(view);
 });
}

add_task(async function test() {
 await setupDownloads();
 await setupFormHistory();
 await setupHistory();
 await onHistoryReady();
});

async function countEntries(name, message, check) {
 var obj = {};
 if (name !== null) {
   obj.fieldname = name;
 }
 let count = await FormHistory.count(obj);
 check(count, message);
}

async function onHistoryReady() {
 var hoursSinceMidnight = new Date().getHours();
 var minutesSinceMidnight = hoursSinceMidnight * 60 + new Date().getMinutes();

 // Should test cookies here, but nsICookieManager/nsICookieService
 // doesn't let us fake creation times.  bug 463127

 await SpecialPowers.pushPrefEnv({
   set: [["privacy.sanitize.useOldClearHistoryDialog", false]],
 });

 let itemsToClear = ["historyAndFormData", "downloads"];

 let publicList = await Downloads.getList(Downloads.PUBLIC);
 let downloadPromise = promiseDownloadRemoved(publicList);
 let formHistoryPromise = promiseFormHistoryRemoved();

 // Clear 10 minutes ago
 let range = [now_uSec - 10 * 60 * 1000000, now_uSec];
 await Sanitizer.sanitize(itemsToClear, { range, ignoreTimespan: false });

 await formHistoryPromise;
 await downloadPromise;

 ok(
   !(await PlacesUtils.history.hasVisits("https://10minutes.com")),
   "Pretend visit to 10minutes.com should now be deleted"
 );
 ok(
   await PlacesUtils.history.hasVisits("https://1hour.com"),
   "Pretend visit to 1hour.com should should still exist"
 );
 ok(
   await PlacesUtils.history.hasVisits("https://1hour10minutes.com"),
   "Pretend visit to 1hour10minutes.com should should still exist"
 );
 ok(
   await PlacesUtils.history.hasVisits("https://2hour.com"),
   "Pretend visit to 2hour.com should should still exist"
 );
 ok(
   await PlacesUtils.history.hasVisits("https://2hour10minutes.com"),
   "Pretend visit to 2hour10minutes.com should should still exist"
 );
 ok(
   await PlacesUtils.history.hasVisits("https://4hour.com"),
   "Pretend visit to 4hour.com should should still exist"
 );
 ok(
   await PlacesUtils.history.hasVisits("https://4hour10minutes.com"),
   "Pretend visit to 4hour10minutes.com should should still exist"
 );
 if (minutesSinceMidnight > 10) {
   ok(
     await PlacesUtils.history.hasVisits("https://today.com"),
     "Pretend visit to today.com should still exist"
   );
 }
 ok(
   await PlacesUtils.history.hasVisits("https://before-today.com"),
   "Pretend visit to before-today.com should still exist"
 );

 let checkZero = function (num, message) {
   is(num, 0, message);
 };
 let checkOne = function (num, message) {
   is(num, 1, message);
 };

 await countEntries(
   "10minutes",
   "10minutes form entry should be deleted",
   checkZero
 );
 await countEntries("1hour", "1hour form entry should still exist", checkOne);
 await countEntries(
   "1hour10minutes",
   "1hour10minutes form entry should still exist",
   checkOne
 );
 await countEntries("2hour", "2hour form entry should still exist", checkOne);
 await countEntries(
   "2hour10minutes",
   "2hour10minutes form entry should still exist",
   checkOne
 );
 await countEntries("4hour", "4hour form entry should still exist", checkOne);
 await countEntries(
   "4hour10minutes",
   "4hour10minutes form entry should still exist",
   checkOne
 );
 if (minutesSinceMidnight > 10) {
   await countEntries(
     "today",
     "today form entry should still exist",
     checkOne
   );
 }
 await countEntries(
   "b4today",
   "b4today form entry should still exist",
   checkOne
 );

 ok(
   !(await downloadExists(publicList, "fakefile-10-minutes")),
   "10 minute download should now be deleted"
 );
 ok(
   await downloadExists(publicList, "fakefile-1-hour"),
   "<1 hour download should still be present"
 );
 ok(
   await downloadExists(publicList, "fakefile-1-hour-10-minutes"),
   "1 hour 10 minute download should still be present"
 );
 ok(
   await downloadExists(publicList, "fakefile-old"),
   "Year old download should still be present"
 );
 ok(
   await downloadExists(publicList, "fakefile-2-hour"),
   "<2 hour old download should still be present"
 );
 ok(
   await downloadExists(publicList, "fakefile-2-hour-10-minutes"),
   "2 hour 10 minute download should still be present"
 );
 ok(
   await downloadExists(publicList, "fakefile-4-hour"),
   "<4 hour old download should still be present"
 );
 ok(
   await downloadExists(publicList, "fakefile-4-hour-10-minutes"),
   "4 hour 10 minute download should still be present"
 );

 if (minutesSinceMidnight > 10) {
   ok(
     await downloadExists(publicList, "fakefile-today"),
     "'Today' download should still be present"
   );
 }

 downloadPromise = promiseDownloadRemoved(publicList);
 formHistoryPromise = promiseFormHistoryRemoved();

 // Clear 1 hour
 Services.prefs.setIntPref(Sanitizer.PREF_TIMESPAN, 1);
 await Sanitizer.sanitize(itemsToClear, { ignoreTimespan: false });

 await formHistoryPromise;
 await downloadPromise;

 ok(
   !(await PlacesUtils.history.hasVisits("https://1hour.com")),
   "Pretend visit to 1hour.com should now be deleted"
 );
 ok(
   await PlacesUtils.history.hasVisits("https://1hour10minutes.com"),
   "Pretend visit to 1hour10minutes.com should should still exist"
 );
 ok(
   await PlacesUtils.history.hasVisits("https://2hour.com"),
   "Pretend visit to 2hour.com should should still exist"
 );
 ok(
   await PlacesUtils.history.hasVisits("https://2hour10minutes.com"),
   "Pretend visit to 2hour10minutes.com should should still exist"
 );
 ok(
   await PlacesUtils.history.hasVisits("https://4hour.com"),
   "Pretend visit to 4hour.com should should still exist"
 );
 ok(
   await PlacesUtils.history.hasVisits("https://4hour10minutes.com"),
   "Pretend visit to 4hour10minutes.com should should still exist"
 );
 if (hoursSinceMidnight > 1) {
   ok(
     await PlacesUtils.history.hasVisits("https://today.com"),
     "Pretend visit to today.com should still exist"
   );
 }
 ok(
   await PlacesUtils.history.hasVisits("https://before-today.com"),
   "Pretend visit to before-today.com should still exist"
 );

 await countEntries("1hour", "1hour form entry should be deleted", checkZero);
 await countEntries(
   "1hour10minutes",
   "1hour10minutes form entry should still exist",
   checkOne
 );
 await countEntries("2hour", "2hour form entry should still exist", checkOne);
 await countEntries(
   "2hour10minutes",
   "2hour10minutes form entry should still exist",
   checkOne
 );
 await countEntries("4hour", "4hour form entry should still exist", checkOne);
 await countEntries(
   "4hour10minutes",
   "4hour10minutes form entry should still exist",
   checkOne
 );
 if (hoursSinceMidnight > 1) {
   await countEntries(
     "today",
     "today form entry should still exist",
     checkOne
   );
 }
 await countEntries(
   "b4today",
   "b4today form entry should still exist",
   checkOne
 );

 ok(
   !(await downloadExists(publicList, "fakefile-1-hour")),
   "<1 hour download should now be deleted"
 );
 ok(
   await downloadExists(publicList, "fakefile-1-hour-10-minutes"),
   "1 hour 10 minute download should still be present"
 );
 ok(
   await downloadExists(publicList, "fakefile-old"),
   "Year old download should still be present"
 );
 ok(
   await downloadExists(publicList, "fakefile-2-hour"),
   "<2 hour old download should still be present"
 );
 ok(
   await downloadExists(publicList, "fakefile-2-hour-10-minutes"),
   "2 hour 10 minute download should still be present"
 );
 ok(
   await downloadExists(publicList, "fakefile-4-hour"),
   "<4 hour old download should still be present"
 );
 ok(
   await downloadExists(publicList, "fakefile-4-hour-10-minutes"),
   "4 hour 10 minute download should still be present"
 );

 if (hoursSinceMidnight > 1) {
   ok(
     await downloadExists(publicList, "fakefile-today"),
     "'Today' download should still be present"
   );
 }

 downloadPromise = promiseDownloadRemoved(publicList);
 formHistoryPromise = promiseFormHistoryRemoved();

 // Clear 1 hour 10 minutes
 range = [now_uSec - 70 * 60 * 1000000, now_uSec];
 await Sanitizer.sanitize(itemsToClear, { range, ignoreTimespan: false });

 await formHistoryPromise;
 await downloadPromise;

 ok(
   !(await PlacesUtils.history.hasVisits("https://1hour10minutes.com")),
   "Pretend visit to 1hour10minutes.com should now be deleted"
 );
 ok(
   await PlacesUtils.history.hasVisits("https://2hour.com"),
   "Pretend visit to 2hour.com should should still exist"
 );
 ok(
   await PlacesUtils.history.hasVisits("https://2hour10minutes.com"),
   "Pretend visit to 2hour10minutes.com should should still exist"
 );
 ok(
   await PlacesUtils.history.hasVisits("https://4hour.com"),
   "Pretend visit to 4hour.com should should still exist"
 );
 ok(
   await PlacesUtils.history.hasVisits("https://4hour10minutes.com"),
   "Pretend visit to 4hour10minutes.com should should still exist"
 );
 if (minutesSinceMidnight > 70) {
   ok(
     await PlacesUtils.history.hasVisits("https://today.com"),
     "Pretend visit to today.com should still exist"
   );
 }
 ok(
   await PlacesUtils.history.hasVisits("https://before-today.com"),
   "Pretend visit to before-today.com should still exist"
 );

 await countEntries(
   "1hour10minutes",
   "1hour10minutes form entry should be deleted",
   checkZero
 );
 await countEntries("2hour", "2hour form entry should still exist", checkOne);
 await countEntries(
   "2hour10minutes",
   "2hour10minutes form entry should still exist",
   checkOne
 );
 await countEntries("4hour", "4hour form entry should still exist", checkOne);
 await countEntries(
   "4hour10minutes",
   "4hour10minutes form entry should still exist",
   checkOne
 );
 if (minutesSinceMidnight > 70) {
   await countEntries(
     "today",
     "today form entry should still exist",
     checkOne
   );
 }
 await countEntries(
   "b4today",
   "b4today form entry should still exist",
   checkOne
 );

 ok(
   !(await downloadExists(publicList, "fakefile-1-hour-10-minutes")),
   "1 hour 10 minute old download should now be deleted"
 );
 ok(
   await downloadExists(publicList, "fakefile-old"),
   "Year old download should still be present"
 );
 ok(
   await downloadExists(publicList, "fakefile-2-hour"),
   "<2 hour old download should still be present"
 );
 ok(
   await downloadExists(publicList, "fakefile-2-hour-10-minutes"),
   "2 hour 10 minute download should still be present"
 );
 ok(
   await downloadExists(publicList, "fakefile-4-hour"),
   "<4 hour old download should still be present"
 );
 ok(
   await downloadExists(publicList, "fakefile-4-hour-10-minutes"),
   "4 hour 10 minute download should still be present"
 );
 if (minutesSinceMidnight > 70) {
   ok(
     await downloadExists(publicList, "fakefile-today"),
     "'Today' download should still be present"
   );
 }

 downloadPromise = promiseDownloadRemoved(publicList);
 formHistoryPromise = promiseFormHistoryRemoved();

 // Clear 2 hours
 Services.prefs.setIntPref(Sanitizer.PREF_TIMESPAN, 2);
 await Sanitizer.sanitize(itemsToClear, { ignoreTimespan: false });

 await formHistoryPromise;
 await downloadPromise;

 ok(
   !(await PlacesUtils.history.hasVisits("https://2hour.com")),
   "Pretend visit to 2hour.com should now be deleted"
 );
 ok(
   await PlacesUtils.history.hasVisits("https://2hour10minutes.com"),
   "Pretend visit to 2hour10minutes.com should should still exist"
 );
 ok(
   await PlacesUtils.history.hasVisits("https://4hour.com"),
   "Pretend visit to 4hour.com should should still exist"
 );
 ok(
   await PlacesUtils.history.hasVisits("https://4hour10minutes.com"),
   "Pretend visit to 4hour10minutes.com should should still exist"
 );
 if (hoursSinceMidnight > 2) {
   ok(
     await PlacesUtils.history.hasVisits("https://today.com"),
     "Pretend visit to today.com should still exist"
   );
 }
 ok(
   await PlacesUtils.history.hasVisits("https://before-today.com"),
   "Pretend visit to before-today.com should still exist"
 );

 await countEntries("2hour", "2hour form entry should be deleted", checkZero);
 await countEntries(
   "2hour10minutes",
   "2hour10minutes form entry should still exist",
   checkOne
 );
 await countEntries("4hour", "4hour form entry should still exist", checkOne);
 await countEntries(
   "4hour10minutes",
   "4hour10minutes form entry should still exist",
   checkOne
 );
 if (hoursSinceMidnight > 2) {
   await countEntries(
     "today",
     "today form entry should still exist",
     checkOne
   );
 }
 await countEntries(
   "b4today",
   "b4today form entry should still exist",
   checkOne
 );

 ok(
   !(await downloadExists(publicList, "fakefile-2-hour")),
   "<2 hour old download should now be deleted"
 );
 ok(
   await downloadExists(publicList, "fakefile-old"),
   "Year old download should still be present"
 );
 ok(
   await downloadExists(publicList, "fakefile-2-hour-10-minutes"),
   "2 hour 10 minute download should still be present"
 );
 ok(
   await downloadExists(publicList, "fakefile-4-hour"),
   "<4 hour old download should still be present"
 );
 ok(
   await downloadExists(publicList, "fakefile-4-hour-10-minutes"),
   "4 hour 10 minute download should still be present"
 );
 if (hoursSinceMidnight > 2) {
   ok(
     await downloadExists(publicList, "fakefile-today"),
     "'Today' download should still be present"
   );
 }

 downloadPromise = promiseDownloadRemoved(publicList);
 formHistoryPromise = promiseFormHistoryRemoved();

 // Clear 2 hours 10 minutes
 range = [now_uSec - 130 * 60 * 1000000, now_uSec];
 await Sanitizer.sanitize(itemsToClear, { range, ignoreTimespan: false });

 await formHistoryPromise;
 await downloadPromise;

 ok(
   !(await PlacesUtils.history.hasVisits("https://2hour10minutes.com")),
   "Pretend visit to 2hour10minutes.com should now be deleted"
 );
 ok(
   await PlacesUtils.history.hasVisits("https://4hour.com"),
   "Pretend visit to 4hour.com should should still exist"
 );
 ok(
   await PlacesUtils.history.hasVisits("https://4hour10minutes.com"),
   "Pretend visit to 4hour10minutes.com should should still exist"
 );
 if (minutesSinceMidnight > 130) {
   ok(
     await PlacesUtils.history.hasVisits("https://today.com"),
     "Pretend visit to today.com should still exist"
   );
 }
 ok(
   await PlacesUtils.history.hasVisits("https://before-today.com"),
   "Pretend visit to before-today.com should still exist"
 );

 await countEntries(
   "2hour10minutes",
   "2hour10minutes form entry should be deleted",
   checkZero
 );
 await countEntries("4hour", "4hour form entry should still exist", checkOne);
 await countEntries(
   "4hour10minutes",
   "4hour10minutes form entry should still exist",
   checkOne
 );
 if (minutesSinceMidnight > 130) {
   await countEntries(
     "today",
     "today form entry should still exist",
     checkOne
   );
 }
 await countEntries(
   "b4today",
   "b4today form entry should still exist",
   checkOne
 );

 ok(
   !(await downloadExists(publicList, "fakefile-2-hour-10-minutes")),
   "2 hour 10 minute old download should now be deleted"
 );
 ok(
   await downloadExists(publicList, "fakefile-4-hour"),
   "<4 hour old download should still be present"
 );
 ok(
   await downloadExists(publicList, "fakefile-4-hour-10-minutes"),
   "4 hour 10 minute download should still be present"
 );
 ok(
   await downloadExists(publicList, "fakefile-old"),
   "Year old download should still be present"
 );
 if (minutesSinceMidnight > 130) {
   ok(
     await downloadExists(publicList, "fakefile-today"),
     "'Today' download should still be present"
   );
 }

 downloadPromise = promiseDownloadRemoved(publicList);
 formHistoryPromise = promiseFormHistoryRemoved();

 // Clear 4 hours
 Services.prefs.setIntPref(Sanitizer.PREF_TIMESPAN, 3);
 await Sanitizer.sanitize(itemsToClear, { ignoreTimespan: false });

 await formHistoryPromise;
 await downloadPromise;

 ok(
   !(await PlacesUtils.history.hasVisits("https://4hour.com")),
   "Pretend visit to 4hour.com should now be deleted"
 );
 ok(
   await PlacesUtils.history.hasVisits("https://4hour10minutes.com"),
   "Pretend visit to 4hour10minutes.com should should still exist"
 );
 if (hoursSinceMidnight > 4) {
   ok(
     await PlacesUtils.history.hasVisits("https://today.com"),
     "Pretend visit to today.com should still exist"
   );
 }
 ok(
   await PlacesUtils.history.hasVisits("https://before-today.com"),
   "Pretend visit to before-today.com should still exist"
 );

 await countEntries("4hour", "4hour form entry should be deleted", checkZero);
 await countEntries(
   "4hour10minutes",
   "4hour10minutes form entry should still exist",
   checkOne
 );
 if (hoursSinceMidnight > 4) {
   await countEntries(
     "today",
     "today form entry should still exist",
     checkOne
   );
 }
 await countEntries(
   "b4today",
   "b4today form entry should still exist",
   checkOne
 );

 ok(
   !(await downloadExists(publicList, "fakefile-4-hour")),
   "<4 hour old download should now be deleted"
 );
 ok(
   await downloadExists(publicList, "fakefile-4-hour-10-minutes"),
   "4 hour 10 minute download should still be present"
 );
 ok(
   await downloadExists(publicList, "fakefile-old"),
   "Year old download should still be present"
 );
 if (hoursSinceMidnight > 4) {
   ok(
     await downloadExists(publicList, "fakefile-today"),
     "'Today' download should still be present"
   );
 }

 downloadPromise = promiseDownloadRemoved(publicList);
 formHistoryPromise = promiseFormHistoryRemoved();

 // Clear 4 hours 10 minutes
 range = [now_uSec - 250 * 60 * 1000000, now_uSec];
 await Sanitizer.sanitize(itemsToClear, { range, ignoreTimespan: false });

 await formHistoryPromise;
 await downloadPromise;

 ok(
   !(await PlacesUtils.history.hasVisits("https://4hour10minutes.com")),
   "Pretend visit to 4hour10minutes.com should now be deleted"
 );
 if (minutesSinceMidnight > 250) {
   ok(
     await PlacesUtils.history.hasVisits("https://today.com"),
     "Pretend visit to today.com should still exist"
   );
 }
 ok(
   await PlacesUtils.history.hasVisits("https://before-today.com"),
   "Pretend visit to before-today.com should still exist"
 );

 await countEntries(
   "4hour10minutes",
   "4hour10minutes form entry should be deleted",
   checkZero
 );
 if (minutesSinceMidnight > 250) {
   await countEntries(
     "today",
     "today form entry should still exist",
     checkOne
   );
 }
 await countEntries(
   "b4today",
   "b4today form entry should still exist",
   checkOne
 );

 ok(
   !(await downloadExists(publicList, "fakefile-4-hour-10-minutes")),
   "4 hour 10 minute download should now be deleted"
 );
 ok(
   await downloadExists(publicList, "fakefile-old"),
   "Year old download should still be present"
 );
 if (minutesSinceMidnight > 250) {
   ok(
     await downloadExists(publicList, "fakefile-today"),
     "'Today' download should still be present"
   );
 }

 // The 'Today' download might have been already deleted, in which case we
 // should not wait for a download removal notification.
 if (minutesSinceMidnight > 250) {
   downloadPromise = promiseDownloadRemoved(publicList);
   formHistoryPromise = promiseFormHistoryRemoved();
 } else {
   downloadPromise = formHistoryPromise = Promise.resolve();
 }

 // Clear Today
 Services.prefs.setIntPref(Sanitizer.PREF_TIMESPAN, 4);
 let progress = await Sanitizer.sanitize(itemsToClear, {
   ignoreTimespan: false,
 });
 Assert.deepEqual(progress, {
   historyAndFormData: "cleared",
   downloads: "cleared",
 });

 await formHistoryPromise;
 await downloadPromise;

 // Be careful.  If we add our objectss just before midnight, and sanitize
 // runs immediately after, they won't be expired.  This is expected, but
 // we should not test in that case.  We cannot just test for opposite
 // condition because we could cross midnight just one moment after we
 // cache our time, then we would have an even worse random failure.
 var today = isToday(new Date(now_mSec));
 if (today) {
   ok(
     !(await PlacesUtils.history.hasVisits("https://today.com")),
     "Pretend visit to today.com should now be deleted"
   );

   await countEntries(
     "today",
     "today form entry should be deleted",
     checkZero
   );
   ok(
     !(await downloadExists(publicList, "fakefile-today")),
     "'Today' download should now be deleted"
   );
 }

 ok(
   await PlacesUtils.history.hasVisits("https://before-today.com"),
   "Pretend visit to before-today.com should still exist"
 );
 await countEntries(
   "b4today",
   "b4today form entry should still exist",
   checkOne
 );
 ok(
   await downloadExists(publicList, "fakefile-old"),
   "Year old download should still be present"
 );

 downloadPromise = promiseDownloadRemoved(publicList);
 formHistoryPromise = promiseFormHistoryRemoved();

 // Choose everything
 Services.prefs.setIntPref(Sanitizer.PREF_TIMESPAN, 0);
 await Sanitizer.sanitize(itemsToClear, { ignoreTimespan: false });

 await formHistoryPromise;
 await downloadPromise;

 ok(
   !(await PlacesUtils.history.hasVisits("https://before-today.com")),
   "Pretend visit to before-today.com should now be deleted"
 );

 await countEntries(
   "b4today",
   "b4today form entry should be deleted",
   checkZero
 );

 ok(
   !(await downloadExists(publicList, "fakefile-old")),
   "Year old download should now be deleted"
 );
}

async function setupHistory() {
 let places = [];

 function addPlace(aURI, aTitle, aVisitDate) {
   places.push({
     uri: aURI,
     title: aTitle,
     visitDate: aVisitDate,
     transition: Ci.nsINavHistoryService.TRANSITION_LINK,
   });
 }

 addPlace(
   "https://10minutes.com/",
   "10 minutes ago",
   now_uSec - 10 * kUsecPerMin
 );
 addPlace(
   "https://1hour.com/",
   "Less than 1 hour ago",
   now_uSec - 45 * kUsecPerMin
 );
 addPlace(
   "https://1hour10minutes.com/",
   "1 hour 10 minutes ago",
   now_uSec - 70 * kUsecPerMin
 );
 addPlace(
   "https://2hour.com/",
   "Less than 2 hours ago",
   now_uSec - 90 * kUsecPerMin
 );
 addPlace(
   "https://2hour10minutes.com/",
   "2 hours 10 minutes ago",
   now_uSec - 130 * kUsecPerMin
 );
 addPlace(
   "https://4hour.com/",
   "Less than 4 hours ago",
   now_uSec - 180 * kUsecPerMin
 );
 addPlace(
   "https://4hour10minutes.com/",
   "4 hours 10 minutesago",
   now_uSec - 250 * kUsecPerMin
 );

 let today = new Date();
 today.setHours(0);
 today.setMinutes(0);
 today.setSeconds(0);
 today.setMilliseconds(1);
 addPlace("https://today.com/", "Today", today.getTime() * 1000);

 let lastYear = new Date();
 lastYear.setFullYear(lastYear.getFullYear() - 1);
 addPlace(
   "https://before-today.com/",
   "Before Today",
   lastYear.getTime() * 1000
 );
 await PlacesTestUtils.addVisits(places);
}

async function setupFormHistory() {
 function searchEntries(terms, params) {
   return FormHistory.search(terms, params);
 }

 // Make sure we've got a clean DB to start with, then add the entries we'll be testing.
 await FormHistory.update([
   {
     op: "remove",
   },
   {
     op: "add",
     fieldname: "10minutes",
     value: "10m",
   },
   {
     op: "add",
     fieldname: "1hour",
     value: "1h",
   },
   {
     op: "add",
     fieldname: "1hour10minutes",
     value: "1h10m",
   },
   {
     op: "add",
     fieldname: "2hour",
     value: "2h",
   },
   {
     op: "add",
     fieldname: "2hour10minutes",
     value: "2h10m",
   },
   {
     op: "add",
     fieldname: "4hour",
     value: "4h",
   },
   {
     op: "add",
     fieldname: "4hour10minutes",
     value: "4h10m",
   },
   {
     op: "add",
     fieldname: "today",
     value: "1d",
   },
   {
     op: "add",
     fieldname: "b4today",
     value: "1y",
   },
 ]);

 // Artifically age the entries to the proper vintage.
 let timestamp = now_uSec - 10 * kUsecPerMin;
 let results = await searchEntries(["guid"], { fieldname: "10minutes" });
 await FormHistory.update({
   op: "update",
   firstUsed: timestamp,
   guid: results[0].guid,
 });

 timestamp = now_uSec - 45 * kUsecPerMin;
 results = await searchEntries(["guid"], { fieldname: "1hour" });
 await FormHistory.update({
   op: "update",
   firstUsed: timestamp,
   guid: results[0].guid,
 });

 timestamp = now_uSec - 70 * kUsecPerMin;
 results = await searchEntries(["guid"], { fieldname: "1hour10minutes" });
 await FormHistory.update({
   op: "update",
   firstUsed: timestamp,
   guid: results[0].guid,
 });

 timestamp = now_uSec - 90 * kUsecPerMin;
 results = await searchEntries(["guid"], { fieldname: "2hour" });
 await FormHistory.update({
   op: "update",
   firstUsed: timestamp,
   guid: results[0].guid,
 });

 timestamp = now_uSec - 130 * kUsecPerMin;
 results = await searchEntries(["guid"], { fieldname: "2hour10minutes" });
 await FormHistory.update({
   op: "update",
   firstUsed: timestamp,
   guid: results[0].guid,
 });

 timestamp = now_uSec - 180 * kUsecPerMin;
 results = await searchEntries(["guid"], { fieldname: "4hour" });
 await FormHistory.update({
   op: "update",
   firstUsed: timestamp,
   guid: results[0].guid,
 });

 timestamp = now_uSec - 250 * kUsecPerMin;
 results = await searchEntries(["guid"], { fieldname: "4hour10minutes" });
 await FormHistory.update({
   op: "update",
   firstUsed: timestamp,
   guid: results[0].guid,
 });

 let today = new Date();
 today.setHours(0);
 today.setMinutes(0);
 today.setSeconds(0);
 today.setMilliseconds(1);
 timestamp = today.getTime() * 1000;
 results = await searchEntries(["guid"], { fieldname: "today" });
 await FormHistory.update({
   op: "update",
   firstUsed: timestamp,
   guid: results[0].guid,
 });

 let lastYear = new Date();
 lastYear.setFullYear(lastYear.getFullYear() - 1);
 timestamp = lastYear.getTime() * 1000;
 results = await searchEntries(["guid"], { fieldname: "b4today" });
 await FormHistory.update({
   op: "update",
   firstUsed: timestamp,
   guid: results[0].guid,
 });

 var checks = 0;
 let checkOne = function (num, message) {
   is(num, 1, message);
   checks++;
 };

 // Sanity check.
 await countEntries(
   "10minutes",
   "Checking for 10minutes form history entry creation",
   checkOne
 );
 await countEntries(
   "1hour",
   "Checking for 1hour form history entry creation",
   checkOne
 );
 await countEntries(
   "1hour10minutes",
   "Checking for 1hour10minutes form history entry creation",
   checkOne
 );
 await countEntries(
   "2hour",
   "Checking for 2hour form history entry creation",
   checkOne
 );
 await countEntries(
   "2hour10minutes",
   "Checking for 2hour10minutes form history entry creation",
   checkOne
 );
 await countEntries(
   "4hour",
   "Checking for 4hour form history entry creation",
   checkOne
 );
 await countEntries(
   "4hour10minutes",
   "Checking for 4hour10minutes form history entry creation",
   checkOne
 );
 await countEntries(
   "today",
   "Checking for today form history entry creation",
   checkOne
 );
 await countEntries(
   "b4today",
   "Checking for b4today form history entry creation",
   checkOne
 );
 is(checks, 9, "9 checks made");
}

async function setupDownloads() {
 let publicList = await Downloads.getList(Downloads.PUBLIC);

 let download = await Downloads.createDownload({
   source: "https://bugzilla.mozilla.org/show_bug.cgi?id=480169",
   target: "fakefile-10-minutes",
 });
 download.startTime = new Date(now_mSec - 10 * kMsecPerMin); // 10 minutes ago
 download.canceled = true;
 await publicList.add(download);

 download = await Downloads.createDownload({
   source: "https://bugzilla.mozilla.org/show_bug.cgi?id=453440",
   target: "fakefile-1-hour",
 });
 download.startTime = new Date(now_mSec - 45 * kMsecPerMin); // 45 minutes ago
 download.canceled = true;
 await publicList.add(download);

 download = await Downloads.createDownload({
   source: "https://bugzilla.mozilla.org/show_bug.cgi?id=480169",
   target: "fakefile-1-hour-10-minutes",
 });
 download.startTime = new Date(now_mSec - 70 * kMsecPerMin); // 70 minutes ago
 download.canceled = true;
 await publicList.add(download);

 download = await Downloads.createDownload({
   source: "https://bugzilla.mozilla.org/show_bug.cgi?id=453440",
   target: "fakefile-2-hour",
 });
 download.startTime = new Date(now_mSec - 90 * kMsecPerMin); // 90 minutes ago
 download.canceled = true;
 await publicList.add(download);

 download = await Downloads.createDownload({
   source: "https://bugzilla.mozilla.org/show_bug.cgi?id=480169",
   target: "fakefile-2-hour-10-minutes",
 });
 download.startTime = new Date(now_mSec - 130 * kMsecPerMin); // 130 minutes ago
 download.canceled = true;
 await publicList.add(download);

 download = await Downloads.createDownload({
   source: "https://bugzilla.mozilla.org/show_bug.cgi?id=453440",
   target: "fakefile-4-hour",
 });
 download.startTime = new Date(now_mSec - 180 * kMsecPerMin); // 180 minutes ago
 download.canceled = true;
 await publicList.add(download);

 download = await Downloads.createDownload({
   source: "https://bugzilla.mozilla.org/show_bug.cgi?id=480169",
   target: "fakefile-4-hour-10-minutes",
 });
 download.startTime = new Date(now_mSec - 250 * kMsecPerMin); // 250 minutes ago
 download.canceled = true;
 await publicList.add(download);

 // Add "today" download
 let today = new Date();
 today.setHours(0);
 today.setMinutes(0);
 today.setSeconds(0);
 today.setMilliseconds(1);

 download = await Downloads.createDownload({
   source: "https://bugzilla.mozilla.org/show_bug.cgi?id=453440",
   target: "fakefile-today",
 });
 download.startTime = today; // 12:00:01 AM this morning
 download.canceled = true;
 await publicList.add(download);

 // Add "before today" download
 let lastYear = new Date();
 lastYear.setFullYear(lastYear.getFullYear() - 1);

 download = await Downloads.createDownload({
   source: "https://bugzilla.mozilla.org/show_bug.cgi?id=453440",
   target: "fakefile-old",
 });
 download.startTime = lastYear;
 download.canceled = true;
 await publicList.add(download);

 // Confirm everything worked
 let downloads = await publicList.getAll();
 is(downloads.length, 9, "9 Pretend downloads added");

 ok(
   await downloadExists(publicList, "fakefile-old"),
   "Pretend download for everything case should exist"
 );
 ok(
   await downloadExists(publicList, "fakefile-10-minutes"),
   "Pretend download for 10-minutes case should exist"
 );
 ok(
   await downloadExists(publicList, "fakefile-1-hour"),
   "Pretend download for 1-hour case should exist"
 );
 ok(
   await downloadExists(publicList, "fakefile-1-hour-10-minutes"),
   "Pretend download for 1-hour-10-minutes case should exist"
 );
 ok(
   await downloadExists(publicList, "fakefile-2-hour"),
   "Pretend download for 2-hour case should exist"
 );
 ok(
   await downloadExists(publicList, "fakefile-2-hour-10-minutes"),
   "Pretend download for 2-hour-10-minutes case should exist"
 );
 ok(
   await downloadExists(publicList, "fakefile-4-hour"),
   "Pretend download for 4-hour case should exist"
 );
 ok(
   await downloadExists(publicList, "fakefile-4-hour-10-minutes"),
   "Pretend download for 4-hour-10-minutes case should exist"
 );
 ok(
   await downloadExists(publicList, "fakefile-today"),
   "Pretend download for Today case should exist"
 );
}

/**
* Checks to see if the downloads with the specified id exists.
*
* @param aID
*        The ids of the downloads to check.
*/
let downloadExists = async function (list, path) {
 let listArray = await list.getAll();
 return listArray.some(i => i.target.path == path);
};

function isToday(aDate) {
 return aDate.getDate() == new Date().getDate();
}