/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- * 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 CURRENT_SCHEMA_VERSION = 21; const NS_APP_USER_PROFILE_50_DIR = "ProfD"; const NS_APP_PROFILE_DIR_STARTUP = "ProfDS"; const NS_APP_BOOKMARKS_50_FILE = "BMarks"; // Shortcuts to transitions type. const TRANSITION_LINK = Ci.nsINavHistoryService.TRANSITION_LINK; const TRANSITION_TYPED = Ci.nsINavHistoryService.TRANSITION_TYPED; const TRANSITION_BOOKMARK = Ci.nsINavHistoryService.TRANSITION_BOOKMARK; const TRANSITION_EMBED = Ci.nsINavHistoryService.TRANSITION_EMBED; const TRANSITION_FRAMED_LINK = Ci.nsINavHistoryService.TRANSITION_FRAMED_LINK; const TRANSITION_REDIRECT_PERMANENT = Ci.nsINavHistoryService.TRANSITION_REDIRECT_PERMANENT; const TRANSITION_REDIRECT_TEMPORARY = Ci.nsINavHistoryService.TRANSITION_REDIRECT_TEMPORARY; const TRANSITION_DOWNLOAD = Ci.nsINavHistoryService.TRANSITION_DOWNLOAD; const TITLE_LENGTH_MAX = 4096; Cu.import("resource://gre/modules/XPCOMUtils.jsm"); XPCOMUtils.defineLazyModuleGetter(this, "FileUtils", "resource://gre/modules/FileUtils.jsm"); XPCOMUtils.defineLazyModuleGetter(this, "NetUtil", "resource://gre/modules/NetUtil.jsm"); XPCOMUtils.defineLazyModuleGetter(this, "Promise", "resource://gre/modules/commonjs/promise/core.js"); XPCOMUtils.defineLazyModuleGetter(this, "Services", "resource://gre/modules/Services.jsm"); XPCOMUtils.defineLazyModuleGetter(this, "Task", "resource://gre/modules/Task.jsm"); // This imports various other objects in addition to PlacesUtils. Cu.import("resource://gre/modules/PlacesUtils.jsm"); XPCOMUtils.defineLazyGetter(this, "SMALLPNG_DATA_URI", function() { return NetUtil.newURI( "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAA" + "AAAA6fptVAAAACklEQVQI12NgAAAAAgAB4iG8MwAAAABJRU5ErkJggg=="); }); function LOG(aMsg) { aMsg = ("*** PLACES TESTS: " + aMsg); Services.console.logStringMessage(aMsg); print(aMsg); } let gTestDir = do_get_cwd(); // Ensure history is enabled. Services.prefs.setBoolPref("places.history.enabled", true); // Initialize profile. let gProfD = do_get_profile(); // Remove any old database. clearDB(); /** * Adds a task generator function written for Task.jsm to the list of tests that * are to be run asynchronously. * * The next asynchronous test runs automatically when the task terminates. The * task should not call run_next_test() to continue. Any exception in the task * function causes the current test to fail immediately, and the next test to be * executed. * * Test files should call run_next_test() inside run_test() to execute all the * asynchronous tests, as usual. Test files may include both function added * with add_test() as well as function added with add_task(). * * Example: * * add_task(function test_promise_resolves_to_true() { * let result = yield promiseThatResolvesToTrue; * do_check_true(result); * }); */ function add_task(aTaskFn) { function wrapperFn() { Task.spawn(aTaskFn) .then(run_next_test, do_report_unexpected_exception); } eval("add_test(function " + aTaskFn.name + "() wrapperFn());"); } /** * Shortcut to create a nsIURI. * * @param aSpec * URLString of the uri. */ function uri(aSpec) NetUtil.newURI(aSpec); /** * 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. */ let gDBConn; function DBConn(aForceNewConnection) { 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; }; /** * Reads data from the provided inputstream. * * @return an array of bytes. */ function readInputStreamData(aStream) { let bistream = Cc["@mozilla.org/binaryinputstream;1"]. createInstance(Ci.nsIBinaryInputStream); try { bistream.setInputStream(aStream); let expectedData = []; let avail; while ((avail = bistream.available())) { expectedData = expectedData.concat(bistream.readByteArray(avail)); } return expectedData; } finally { bistream.close(); } } /** * Reads the data from the specified nsIFile. * * @param aFile * The nsIFile to read from. * @return an array of bytes. */ function readFileData(aFile) { let inputStream = Cc["@mozilla.org/network/file-input-stream;1"]. createInstance(Ci.nsIFileInputStream); // init the stream as RD_ONLY, -1 == default permissions. inputStream.init(aFile, 0x01, -1, null); // Check the returned size versus the expected size. let size = inputStream.available(); let bytes = readInputStreamData(inputStream); if (size != bytes.length) { throw "Didn't read expected number of bytes"; } return bytes; } /** * Reads the data from the named file, verifying the expected file length. * * @param aFileName * This file should be located in the same folder as the test. * @param aExpectedLength * Expected length of the file. * * @return The array of bytes read from the file. */ function readFileOfLength(aFileName, aExpectedLength) { let data = readFileData(do_get_file(aFileName)); do_check_eq(data.length, aExpectedLength); return data; } /** * Returns the base64-encoded version of the given string. This function is * similar to window.btoa, but is available to xpcshell tests also. * * @param aString * Each character in this string corresponds to a byte, and must be a * code point in the range 0-255. * * @return The base64-encoded string. */ function base64EncodeString(aString) { var stream = Cc["@mozilla.org/io/string-input-stream;1"] .createInstance(Ci.nsIStringInputStream); stream.setData(aString, aString.length); var encoder = Cc["@mozilla.org/scriptablebase64encoder;1"] .createInstance(Ci.nsIScriptableBase64Encoder); return encoder.encodeToString(stream, aString.length); } /** * Compares two arrays, and returns true if they are equal. * * @param aArray1 * First array to compare. * @param aArray2 * Second array to compare. */ function compareArrays(aArray1, aArray2) { if (aArray1.length != aArray2.length) { print("compareArrays: array lengths differ\n"); return false; } for (let i = 0; i < aArray1.length; i++) { if (aArray1[i] != aArray2[i]) { print("compareArrays: arrays differ at index " + i + ": " + "(" + aArray1[i] + ") != (" + aArray2[i] +")\n"); return false; } } return true; } /** * Deletes a previously created sqlite file from the profile folder. */ function clearDB() { try { let file = Services.dirsvc.get('ProfD', Ci.nsIFile); file.append("places.sqlite"); if (file.exists()) file.remove(false); } catch(ex) { dump("Exception: " + ex); } } /** * Dumps the rows of a table out to the console. * * @param aName * The name of the table or view to output. */ function dump_table(aName) { let stmt = DBConn().createStatement("SELECT * FROM " + aName); print("\n*** Printing data from " + aName); let count = 0; while (stmt.executeStep()) { let columns = stmt.numEntries; if (count == 0) { // Print the column names. for (let i = 0; i < columns; i++) dump(stmt.getColumnName(i) + "\t"); dump("\n"); } // Print the rows. for (let i = 0; i < columns; i++) { switch (stmt.getTypeOfIndex(i)) { case Ci.mozIStorageValueArray.VALUE_TYPE_NULL: dump("NULL\t"); break; case Ci.mozIStorageValueArray.VALUE_TYPE_INTEGER: dump(stmt.getInt64(i) + "\t"); break; case Ci.mozIStorageValueArray.VALUE_TYPE_FLOAT: dump(stmt.getDouble(i) + "\t"); break; case Ci.mozIStorageValueArray.VALUE_TYPE_TEXT: dump(stmt.getString(i) + "\t"); break; } } dump("\n"); count++; } print("*** There were a total of " + count + " rows of data.\n"); stmt.finalize(); } /** * Checks if an address is found in the database. * @param aURI * nsIURI or address to look for. * @return place id of the page or 0 if not found */ function page_in_database(aURI) { let url = aURI instanceof Ci.nsIURI ? aURI.spec : aURI; let stmt = DBConn().createStatement( "SELECT id FROM moz_places WHERE url = :url" ); stmt.params.url = url; try { if (!stmt.executeStep()) return 0; return stmt.getInt64(0); } finally { stmt.finalize(); } } /** * Checks how many visits exist for a specified page. * @param aURI * nsIURI or address to look for. * @return number of visits found. */ function visits_in_database(aURI) { let url = aURI instanceof Ci.nsIURI ? aURI.spec : aURI; let stmt = DBConn().createStatement( "SELECT count(*) FROM moz_historyvisits v " + "JOIN moz_places h ON h.id = v.place_id " + "WHERE url = :url" ); stmt.params.url = url; try { if (!stmt.executeStep()) return 0; return stmt.getInt64(0); } finally { stmt.finalize(); } } /** * Removes all bookmarks and checks for correct cleanup */ function remove_all_bookmarks() { let PU = PlacesUtils; // Clear all bookmarks PU.bookmarks.removeFolderChildren(PU.bookmarks.bookmarksMenuFolder); PU.bookmarks.removeFolderChildren(PU.bookmarks.toolbarFolder); PU.bookmarks.removeFolderChildren(PU.bookmarks.unfiledBookmarksFolder); // Check for correct cleanup check_no_bookmarks(); } /** * Checks that we don't have any bookmark */ function check_no_bookmarks() { let query = PlacesUtils.history.getNewQuery(); let folders = [ PlacesUtils.bookmarks.toolbarFolder, PlacesUtils.bookmarks.bookmarksMenuFolder, PlacesUtils.bookmarks.unfiledBookmarksFolder, ]; query.setFolders(folders, 3); let options = PlacesUtils.history.getNewQueryOptions(); options.queryType = Ci.nsINavHistoryQueryOptions.QUERY_TYPE_BOOKMARKS; let root = PlacesUtils.history.executeQuery(query, options).root; root.containerOpen = true; if (root.childCount != 0) do_throw("Unable to remove all bookmarks"); root.containerOpen = false; } /** * Sets title synchronously for a page in moz_places. * * @param aURI * An nsIURI to set the title for. * @param aTitle * The title to set the page to. * @throws if the page is not found in the database. * * @note This is just a test compatibility mock. */ function setPageTitle(aURI, aTitle) { PlacesUtils.history.setPageTitle(aURI, aTitle); } /** * 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; } /** * Simulates a Places shutdown. */ function shutdownPlaces(aKeepAliveConnection) { let hs = PlacesUtils.history.QueryInterface(Ci.nsIObserver); hs.observe(null, "profile-change-teardown", null); hs.observe(null, "profile-before-change", null); } const FILENAME_BOOKMARKS_HTML = "bookmarks.html"; let (backup_date = new Date().toLocaleFormat("%Y-%m-%d")) { const FILENAME_BOOKMARKS_JSON = "bookmarks-" + backup_date + ".json"; } /** * Creates a bookmarks.html file in the profile folder from a given source file. * * @param aFilename * Name of the file to copy to the profile folder. This file must * exist in the directory that contains the test files. * * @return nsIFile object for the file. */ function create_bookmarks_html(aFilename) { if (!aFilename) do_throw("you must pass a filename to create_bookmarks_html function"); remove_bookmarks_html(); let bookmarksHTMLFile = gTestDir.clone(); bookmarksHTMLFile.append(aFilename); do_check_true(bookmarksHTMLFile.exists()); bookmarksHTMLFile.copyTo(gProfD, FILENAME_BOOKMARKS_HTML); let profileBookmarksHTMLFile = gProfD.clone(); profileBookmarksHTMLFile.append(FILENAME_BOOKMARKS_HTML); do_check_true(profileBookmarksHTMLFile.exists()); return profileBookmarksHTMLFile; } /** * Remove bookmarks.html file from the profile folder. */ function remove_bookmarks_html() { let profileBookmarksHTMLFile = gProfD.clone(); profileBookmarksHTMLFile.append(FILENAME_BOOKMARKS_HTML); if (profileBookmarksHTMLFile.exists()) { profileBookmarksHTMLFile.remove(false); do_check_false(profileBookmarksHTMLFile.exists()); } } /** * Check bookmarks.html file exists in the profile folder. * * @return nsIFile object for the file. */ function check_bookmarks_html() { let profileBookmarksHTMLFile = gProfD.clone(); profileBookmarksHTMLFile.append(FILENAME_BOOKMARKS_HTML); do_check_true(profileBookmarksHTMLFile.exists()); return profileBookmarksHTMLFile; } /** * Creates a JSON backup in the profile folder folder from a given source file. * * @param aFilename * Name of the file to copy to the profile folder. This file must * exist in the directory that contains the test files. * * @return nsIFile object for the file. */ function create_JSON_backup(aFilename) { if (!aFilename) do_throw("you must pass a filename to create_JSON_backup function"); remove_all_JSON_backups(); let bookmarksBackupDir = gProfD.clone(); bookmarksBackupDir.append("bookmarkbackups"); if (!bookmarksBackupDir.exists()) { bookmarksBackupDir.create(Ci.nsIFile.DIRECTORY_TYPE, parseInt("0755")); do_check_true(bookmarksBackupDir.exists()); } let bookmarksJSONFile = gTestDir.clone(); bookmarksJSONFile.append(aFilename); do_check_true(bookmarksJSONFile.exists()); bookmarksJSONFile.copyTo(bookmarksBackupDir, FILENAME_BOOKMARKS_JSON); let profileBookmarksJSONFile = bookmarksBackupDir.clone(); profileBookmarksJSONFile.append(FILENAME_BOOKMARKS_JSON); do_check_true(profileBookmarksJSONFile.exists()); return profileBookmarksJSONFile; } /** * Remove bookmarksbackup dir and all backups from the profile folder. */ function remove_all_JSON_backups() { let bookmarksBackupDir = gProfD.clone(); bookmarksBackupDir.append("bookmarkbackups"); if (bookmarksBackupDir.exists()) { bookmarksBackupDir.remove(true); do_check_false(bookmarksBackupDir.exists()); } } /** * Check a JSON backup file for today exists in the profile folder. * * @return nsIFile object for the file. */ function check_JSON_backup() { let profileBookmarksJSONFile = gProfD.clone(); profileBookmarksJSONFile.append("bookmarkbackups"); profileBookmarksJSONFile.append(FILENAME_BOOKMARKS_JSON); do_check_true(profileBookmarksJSONFile.exists()); return profileBookmarksJSONFile; } /** * Returns the frecency of a url. * * @param aURI * The URI or spec to get frecency for. * @return the frecency value. */ function frecencyForUrl(aURI) { let url = aURI instanceof Ci.nsIURI ? aURI.spec : aURI; let stmt = DBConn().createStatement( "SELECT frecency FROM moz_places WHERE url = ?1" ); stmt.bindByIndex(0, url); try { if (!stmt.executeStep()) { throw new Error("No result for frecency."); } return stmt.getInt32(0); } finally { stmt.finalize(); } } /** * Returns the hidden status of a url. * * @param aURI * The URI or spec to get hidden for. * @return @return true if the url is hidden, false otherwise. */ function isUrlHidden(aURI) { let url = aURI instanceof Ci.nsIURI ? aURI.spec : aURI; let stmt = DBConn().createStatement( "SELECT hidden FROM moz_places WHERE url = ?1" ); stmt.bindByIndex(0, url); if (!stmt.executeStep()) throw new Error("No result for hidden."); let hidden = stmt.getInt32(0); stmt.finalize(); return !!hidden; } /** * Compares two times in usecs, considering eventual platform timers skews. * * @param aTimeBefore * The older time in usecs. * @param aTimeAfter * The newer time in usecs. * @return true if times are ordered, false otherwise. */ function is_time_ordered(before, after) { // Windows has an estimated 16ms timers precision, since Date.now() and // PR_Now() use different code atm, the results can be unordered by this // amount of time. See bug 558745 and bug 557406. let isWindows = ("@mozilla.org/windows-registry-key;1" in Cc); // Just to be safe we consider 20ms. let skew = isWindows ? 20000000 : 0; return after - before > -skew; } /** * 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 = DBConn(); 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; } /** * Shutdowns Places, invoking the callback when the connection has been closed. * * @param aCallback * Function to be called when done. */ function waitForConnectionClosed(aCallback) { Services.obs.addObserver(function WFCCCallback() { Services.obs.removeObserver(WFCCCallback, "places-connection-closed"); aCallback(); }, "places-connection-closed", false); shutdownPlaces(); } /** * Tests if a given guid is valid for use in Places or not. * * @param aGuid * The guid to test. * @param [optional] aStack * The stack frame used to report the error. */ function do_check_valid_places_guid(aGuid, aStack) { if (!aStack) { aStack = Components.stack.caller; } do_check_true(/^[a-zA-Z0-9\-_]{12}$/.test(aGuid), aStack); } /** * Retrieves the guid for a given uri. * * @param aURI * The uri to check. * @param [optional] aStack * The stack frame used to report the error. * @return the associated the guid. */ function do_get_guid_for_uri(aURI, aStack) { if (!aStack) { aStack = Components.stack.caller; } let stmt = DBConn().createStatement( "SELECT guid " + "FROM moz_places " + "WHERE url = :url " ); stmt.params.url = aURI.spec; do_check_true(stmt.executeStep(), aStack); let guid = stmt.row.guid; stmt.finalize(); do_check_valid_places_guid(guid, aStack); return guid; } /** * 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 do_check_guid_for_uri(aURI, aGUID) { let caller = Components.stack.caller; let guid = do_get_guid_for_uri(aURI, caller); if (aGUID) { do_check_valid_places_guid(aGUID, caller); do_check_eq(guid, aGUID, caller); } } /** * Retrieves the guid for a given bookmark. * * @param aId * The bookmark id to check. * @param [optional] aStack * The stack frame used to report the error. * @return the associated the guid. */ function do_get_guid_for_bookmark(aId, aStack) { if (!aStack) { aStack = Components.stack.caller; } let stmt = DBConn().createStatement( "SELECT guid " + "FROM moz_bookmarks " + "WHERE id = :item_id " ); stmt.params.item_id = aId; do_check_true(stmt.executeStep(), aStack); let guid = stmt.row.guid; stmt.finalize(); do_check_valid_places_guid(guid, aStack); return guid; } /** * Tests that a guid was set in moz_places for a given bookmark. * * @param aId * The bookmark id to check. * @param [optional] aGUID * The expected guid in the database. */ function do_check_guid_for_bookmark(aId, aGUID) { let caller = Components.stack.caller; let guid = do_get_guid_for_bookmark(aId, caller); if (aGUID) { do_check_valid_places_guid(aGUID, caller); do_check_eq(guid, aGUID, caller); } } /** * Logs info to the console in the standard way (includes the filename). * * @param aMessage * The message to log to the console. */ function do_log_info(aMessage) { print("TEST-INFO | " + _TEST_FILE + " | " + aMessage); } /** * Compares 2 arrays returning whether they contains the same elements. * * @param a1 * First array to compare. * @param a2 * Second array to compare. * @param [optional] sorted * Whether the comparison should take in count position of the elements. * @return true if the arrays contain the same elements, false otherwise. */ function do_compare_arrays(a1, a2, sorted) { if (a1.length != a2.length) return false; if (sorted) { return a1.every(function (e, i) e == a2[i]); } else { return a1.filter(function (e) a2.indexOf(e) == -1).length == 0 && a2.filter(function (e) a1.indexOf(e) == -1).length == 0; } } /** * 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 () {}, onBeforeDeleteURI: function () {}, onDeleteURI: function () {}, onClearHistory: function () {}, onPageChanged: function () {}, onDeleteVisits: function () {}, QueryInterface: XPCOMUtils.generateQI([ Ci.nsINavHistoryObserver, ]) }; /** * Generic nsINavHistoryResultObserver that doesn't implement anything, but * provides dummy methods to prevent errors about an object not having a certain * method. */ function NavHistoryResultObserver() {} NavHistoryResultObserver.prototype = { batching: function () {}, containerClosed: function () {}, containerOpened: function () {}, containerStateChanged: function () {}, invalidateContainer: function () {}, nodeAnnotationChanged: function () {}, nodeDateAddedChanged: function () {}, nodeHistoryDetailsChanged: function () {}, nodeIconChanged: function () {}, nodeInserted: function () {}, nodeKeywordChanged: function () {}, nodeLastModifiedChanged: function () {}, nodeMoved: function () {}, nodeRemoved: function () {}, nodeReplaced: function () {}, nodeTagsChanged: function () {}, nodeTitleChanged: function () {}, nodeURIChanged: function () {}, sortingChanged: function () {}, QueryInterface: XPCOMUtils.generateQI([ Ci.nsINavHistoryResultObserver, ]) }; /** * Asynchronously adds visits to a page, invoking a callback function when done. * * @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 * } * @param [optional] aCallback * Function to be invoked on completion. * @param [optional] aStack * The stack frame used to report errors. */ function addVisits(aPlaceInfo, 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 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() { do_throw("Unexpected error in adding visit.", stack); }, handleResult: function () {}, handleCompletion: function UP_handleCompletion() { if (aCallback) aCallback(); } } ); }