tor-browser

test_connection_idle_maintenance_stop.js (5651B)

---

/**
* Any copyright is dedicated to the Public Domain.
* http://creativecommons.org/publicdomain/zero/1.0/
*/

/* exported testSteps */
async function testSteps() {
 // A constant used to deal with small decrease in usage when transactions are
 // transferred from the WAL file back into the original database, also called
 // as checkpointing.
 const cosmologicalConstant = 35000;

 // The maximum number of threads that can be used for database activity at a
 // single time.
 const maxConnectionThreadCount = 20;

 // The length of time that database connections will be held open after all
 // transactions have completed before doing idle maintenance.
 const connectionIdleMaintenanceMS = 2 * 1000;

 const name = "test_connection_idle_maintenance_stop";
 const abc = "abcdefghijklmnopqrstuvwxyz";

 // IndexedDB on Android does `PRAGMA auto_vacuum = FULL`, so the freelist
 // pages are moved to the end of the database file and the database file is
 // truncated to remove the freelist pages at every transaction commit.
 if (mozinfo.os == "android") {
   info("Test disabled on Android for now");
   return;
 }

 info("Setting pref");

 Services.prefs.setIntPref(
   "dom.indexedDB.connectionIdleMaintenance.pauseOnConnectionThreadMs",
   2 * connectionIdleMaintenanceMS
 );

 info("Forcing only one connection thread to be available");

 let done = false;

 // Create databases which will continuously keep their connection threads
 // busy.
 const completePromises = await (async function () {
   let promises = [];

   for (let index = 0; index < maxConnectionThreadCount - 1; index++) {
     const request = indexedDB.open(name + "-" + index, 1);

     {
       const event = await expectingUpgrade(request);

       const database = event.target.result;

       const objectStore = database.createObjectStore(name);

       objectStore.add("foo", 42);
     }

     const event = await expectingSuccess(request);

     const database = event.target.result;

     const transaction = database.transaction(name);

     const objectStore = transaction.objectStore(name);

     function doWork() {
       const request = objectStore.get(42);
       request.onsuccess = function () {
         if (!done) {
           doWork();
         }
       };
     }

     doWork();

     const promise = new Promise(function (resolve) {
       transaction.oncomplete = resolve;
     });

     promises.push(promise);
   }

   return promises;
 })();

 info("Creating database A");

 // Create a database which will be used for stopping of the connection idle
 // maintenance.
 const databaseA = await (async function () {
   const request = indexedDB.open(name + "-a", 1);

   {
     const event = await expectingUpgrade(request);

     const database = event.target.result;

     database.createObjectStore(name);
   }

   const event = await expectingSuccess(request);

   const database = event.target.result;

   return database;
 })();

 info("Creating database B");

 // Create a database for checking of the connection idle maintenance.
 {
   const request = indexedDB.open(name + "-b", 1);

   const event = await expectingUpgrade(request);

   const database = event.target.result;

   const objectStore = database.createObjectStore(name);

   // Add lots of data...
   for (let index = 0; index < 10000; index++) {
     objectStore.add(abc, index);
   }

   // And then clear it so that maintenance has some space to reclaim.
   objectStore.clear();

   await expectingSuccess(request);
 }

 info("Getting database usage before maintenance");

 const databaseUsageBeforeMaintenance = await new Promise(function (resolve) {
   getCurrentUsage(function (request) {
     resolve(request.result.databaseUsage);
   });
 });

 info("Waiting for maintenance to start");

 // This time is a double of connectionIdleMaintenanceMS which should be
 // pessimistic enough to work with randomly slowed down threads in the
 // chaos mode.
 await new Promise(function (resolve) {
   do_timeout(2 * connectionIdleMaintenanceMS, resolve);
 });

 info("Activating database A");

 // Activate an open database which should trigger stopping of the connection
 // idle maintenance of the database which had a lot of data.
 {
   const transaction = databaseA.transaction(name);

   const objectStore = transaction.objectStore(name);

   const request = objectStore.get(42);

   await requestSucceeded(request);
 }

 info("Waiting for maintenance to finish");

 // This time is a double of connectionIdleMaintenanceMS which should be
 // pessimistic enough to work with randomly slowed down threads in the
 // chaos mode.
 await new Promise(function (resolve) {
   do_timeout(2 * connectionIdleMaintenanceMS, resolve);
 });

 info("Getting database usage after maintenance");

 const databaseUsageAfterMaintenance = await new Promise(function (resolve) {
   getCurrentUsage(function (request) {
     resolve(request.result.databaseUsage);
   });
 });

 info(
   "Database usage before: " +
     databaseUsageBeforeMaintenance +
     ". " +
     "Database usage after: " +
     databaseUsageAfterMaintenance
 );

 // Checkpointing done immediately after the maintenance can slightly decrease
 // the usage even when the maintenance was stopped very early.
 ok(
   databaseUsageBeforeMaintenance - databaseUsageAfterMaintenance <
     cosmologicalConstant,
   "Maintenance did not significantly decrease database usage"
 );

 done = true;

 info("Waiting for transactions to complete");

 await Promise.all(completePromises);
}