The Tor Browser: storage/test/unit/head_storage.js@97036ab72558 (annotated)

storage/test/unit/head_storage.js@97036ab72558 (annotated)

storage/test/unit/head_storage.js

Tue, 06 Jan 2015 21:39:09 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Tue, 06 Jan 2015 21:39:09 +0100
branch: TOR_BUG_9701
changeset 8: 97036ab72558
permissions: -rw-r--r--

Conditionally force memory storage according to privacy.thirdparty.isolate;
This solves Tor bug #9701, complying with disk avoidance documented in
https://www.torproject.org/projects/torbrowser/design/#disk-avoidance.

 /* 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/. */
 const Ci = Components.interfaces;
 const Cc = Components.classes;
 const Cr = Components.results;
 const Cu = Components.utils;
 Cu.import("resource://gre/modules/XPCOMUtils.jsm");
 XPCOMUtils.defineLazyModuleGetter(this, "Promise",
     "resource://gre/modules/Promise.jsm");
 do_get_profile();
 var dirSvc = Cc["@mozilla.org/file/directory_service;1"].
              getService(Ci.nsIProperties);
 function getTestDB()
 {
   var db = dirSvc.get("ProfD", Ci.nsIFile);
   db.append("test_storage.sqlite");
   return db;
 }
 /**
  * Obtains a corrupt database to test against.
  */
 function getCorruptDB()
 {
   return do_get_file("corruptDB.sqlite");
 }
 /**
  * Obtains a fake (non-SQLite format) database to test against.
  */
 function getFakeDB()
 {
   return do_get_file("fakeDB.sqlite");
 }
 function cleanup()
 {
   // close the connection
   print("*** Storage Tests: Trying to close!");
   getOpenedDatabase().close();
   // we need to null out the database variable to get a new connection the next
   // time getOpenedDatabase is called
   gDBConn = null;
   // removing test db
   print("*** Storage Tests: Trying to remove file!");
   var dbFile = getTestDB();
   if (dbFile.exists())
     try { dbFile.remove(false); } catch(e) { /* stupid windows box */ }
 }
 /**
  * Use asyncClose to cleanup a connection.  Synchronous by means of internally
  * spinning an event loop.
  */
 function asyncCleanup()
 {
   let closed = false;
   // close the connection
   print("*** Storage Tests: Trying to asyncClose!");
   getOpenedDatabase().asyncClose(function() { closed = true; });
   let curThread = Components.classes["@mozilla.org/thread-manager;1"]
                             .getService().currentThread;
   while (!closed)
     curThread.processNextEvent(true);
   // we need to null out the database variable to get a new connection the next
   // time getOpenedDatabase is called
   gDBConn = null;
   // removing test db
   print("*** Storage Tests: Trying to remove file!");
   var dbFile = getTestDB();
   if (dbFile.exists())
     try { dbFile.remove(false); } catch(e) { /* stupid windows box */ }
 }
 function getService()
 {
   return Cc["@mozilla.org/storage/service;1"].getService(Ci.mozIStorageService);
 }
 var gDBConn = null;
 /**
  * Get a connection to the test database.  Creates and caches the connection
  * if necessary, otherwise reuses the existing cached connection. This
  * connection shares its cache.
  *
  * @returns the mozIStorageConnection for the file.
  */
 function getOpenedDatabase()
 {
   if (!gDBConn) {
     gDBConn = getService().openDatabase(getTestDB());
   }
   return gDBConn;
 }
 /**
  * Get a connection to the test database.  Creates and caches the connection
  * if necessary, otherwise reuses the existing cached connection. This
  * connection doesn't share its cache.
  *
  * @returns the mozIStorageConnection for the file.
  */
 function getOpenedUnsharedDatabase()
 {
   if (!gDBConn) {
     gDBConn = getService().openUnsharedDatabase(getTestDB());
   }
   return gDBConn;
 }
 /**
  * Obtains a specific database to use.
  *
  * @param aFile
  *        The nsIFile representing the db file to open.
  * @returns the mozIStorageConnection for the file.
  */
 function getDatabase(aFile)
 {
   return getService().openDatabase(aFile);
 }
 function createStatement(aSQL)
 {
   return getOpenedDatabase().createStatement(aSQL);
 }
 /**
  * Creates an asynchronous SQL statement.
  *
  * @param aSQL
  *        The SQL to parse into a statement.
  * @returns a mozIStorageAsyncStatement from aSQL.
  */
 function createAsyncStatement(aSQL)
 {
   return getOpenedDatabase().createAsyncStatement(aSQL);
 }
 /**
  * Invoke the given function and assert that it throws an exception expressing
  * the provided error code in its 'result' attribute.  JS function expressions
  * can be used to do this concisely.
  *
  * Example:
  *  expectError(Cr.NS_ERROR_INVALID_ARG, function() explodingFunction());
  *
  * @param aErrorCode
  *        The error code to expect from invocation of aFunction.
  * @param aFunction
  *        The function to invoke and expect an XPCOM-style error from.
  */
 function expectError(aErrorCode, aFunction)
 {
   let exceptionCaught = false;
   try {
     aFunction();
   }
   catch(e) {
     if (e.result != aErrorCode) {
       do_throw("Got an exception, but the result code was not the expected " +
                "one.  Expected " + aErrorCode + ", got " + e.result);
     }
     exceptionCaught = true;
   }
   if (!exceptionCaught)
     do_throw(aFunction + " should have thrown an exception but did not!");
 }
 /**
  * Run a query synchronously and verify that we get back the expected results.
  *
  * @param aSQLString
  *        The SQL string for the query.
  * @param aBind
  *        The value to bind at index 0.
  * @param aResults
  *        A list of the expected values returned in the sole result row.
  *        Express blobs as lists.
  */
 function verifyQuery(aSQLString, aBind, aResults)
 {
   let stmt = getOpenedDatabase().createStatement(aSQLString);
   stmt.bindByIndex(0, aBind);
   try {
     do_check_true(stmt.executeStep());
     let nCols = stmt.numEntries;
     if (aResults.length != nCols)
       do_throw("Expected " + aResults.length + " columns in result but " +
                "there are only " + aResults.length + "!");
     for (let iCol = 0; iCol < nCols; iCol++) {
       let expectedVal = aResults[iCol];
       let valType = stmt.getTypeOfIndex(iCol);
       if (expectedVal === null) {
         do_check_eq(stmt.VALUE_TYPE_NULL, valType);
         do_check_true(stmt.getIsNull(iCol));
       }
       else if (typeof(expectedVal) == "number") {
         if (Math.floor(expectedVal) == expectedVal) {
           do_check_eq(stmt.VALUE_TYPE_INTEGER, valType);
           do_check_eq(expectedVal, stmt.getInt32(iCol));
         }
         else {
           do_check_eq(stmt.VALUE_TYPE_FLOAT, valType);
           do_check_eq(expectedVal, stmt.getDouble(iCol));
         }
       }
       else if (typeof(expectedVal) == "string") {
         do_check_eq(stmt.VALUE_TYPE_TEXT, valType);
         do_check_eq(expectedVal, stmt.getUTF8String(iCol));
       }
       else { // blob
         do_check_eq(stmt.VALUE_TYPE_BLOB, valType);
         let count = { value: 0 }, blob = { value: null };
         stmt.getBlob(iCol, count, blob);
         do_check_eq(count.value, expectedVal.length);
         for (let i = 0; i < count.value; i++) {
           do_check_eq(expectedVal[i], blob.value[i]);
         }
       }
     }
   }
   finally {
     stmt.finalize();
   }
 }
 /**
  * Return the number of rows in the able with the given name using a synchronous
  * query.
  *
  * @param aTableName
  *        The name of the table.
  * @return The number of rows.
  */
 function getTableRowCount(aTableName)
 {
   var currentRows = 0;
   var countStmt = getOpenedDatabase().createStatement(
     "SELECT COUNT(1) AS count FROM " + aTableName
   );
   try {
     do_check_true(countStmt.executeStep());
     currentRows = countStmt.row.count;
   }
   finally {
     countStmt.finalize();
   }
   return currentRows;
 }
 cleanup();