diff options
Diffstat (limited to 'toolkit/components/places/Database.cpp')
| -rw-r--r-- | toolkit/components/places/Database.cpp | 2333 |
1 files changed, 2333 insertions, 0 deletions
diff --git a/toolkit/components/places/Database.cpp b/toolkit/components/places/Database.cpp new file mode 100644 index 000000000..37502e2a1 --- /dev/null +++ b/toolkit/components/places/Database.cpp @@ -0,0 +1,2333 @@ +/* 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/. */ + +#include "mozilla/ArrayUtils.h" +#include "mozilla/Attributes.h" +#include "mozilla/DebugOnly.h" +#include "mozilla/ScopeExit.h" + +#include "Database.h" + +#include "nsIAnnotationService.h" +#include "nsINavBookmarksService.h" +#include "nsIInterfaceRequestorUtils.h" +#include "nsIFile.h" +#include "nsIWritablePropertyBag2.h" + +#include "nsNavHistory.h" +#include "nsPlacesTables.h" +#include "nsPlacesIndexes.h" +#include "nsPlacesTriggers.h" +#include "nsPlacesMacros.h" +#include "nsVariant.h" +#include "SQLFunctions.h" +#include "Helpers.h" + +#include "nsAppDirectoryServiceDefs.h" +#include "nsDirectoryServiceUtils.h" +#include "prenv.h" +#include "prsystem.h" +#include "nsPrintfCString.h" +#include "mozilla/Preferences.h" +#include "mozilla/Services.h" +#include "mozilla/Unused.h" +#include "prtime.h" + +#include "nsXULAppAPI.h" + +// Time between corrupt database backups. +#define RECENT_BACKUP_TIME_MICROSEC (int64_t)86400 * PR_USEC_PER_SEC // 24H + +// Filename of the database. +#define DATABASE_FILENAME NS_LITERAL_STRING("places.sqlite") +// Filename used to backup corrupt databases. +#define DATABASE_CORRUPT_FILENAME NS_LITERAL_STRING("places.sqlite.corrupt") + +// Set when the database file was found corrupt by a previous maintenance. +#define PREF_FORCE_DATABASE_REPLACEMENT "places.database.replaceOnStartup" + +// Set to specify the size of the places database growth increments in kibibytes +#define PREF_GROWTH_INCREMENT_KIB "places.database.growthIncrementKiB" + +// Set to disable the default robust storage and use volatile, in-memory +// storage without robust transaction flushing guarantees. This makes +// SQLite use much less I/O at the cost of losing data when things crash. +// The pref is only honored if an environment variable is set. The env +// variable is intentionally named something scary to help prevent someone +// from thinking it is a useful performance optimization they should enable. +#define PREF_DISABLE_DURABILITY "places.database.disableDurability" +#define ENV_ALLOW_CORRUPTION "ALLOW_PLACES_DATABASE_TO_LOSE_DATA_AND_BECOME_CORRUPT" + +// The maximum url length we can store in history. +// We do not add to history URLs longer than this value. +#define PREF_HISTORY_MAXURLLEN "places.history.maxUrlLength" +// This number is mostly a guess based on various facts: +// * IE didn't support urls longer than 2083 chars +// * Sitemaps protocol used to support a maximum of 2048 chars +// * Various SEO guides suggest to not go over 2000 chars +// * Various apps/services are known to have issues over 2000 chars +// * RFC 2616 - HTTP/1.1 suggests being cautious about depending +// on URI lengths above 255 bytes +#define PREF_HISTORY_MAXURLLEN_DEFAULT 2000 + +// Maximum size for the WAL file. It should be small enough since in case of +// crashes we could lose all the transactions in the file. But a too small +// file could hurt performance. +#define DATABASE_MAX_WAL_SIZE_IN_KIBIBYTES 512 + +#define BYTES_PER_KIBIBYTE 1024 + +// How much time Sqlite can wait before returning a SQLITE_BUSY error. +#define DATABASE_BUSY_TIMEOUT_MS 100 + +// Old Sync GUID annotation. +#define SYNCGUID_ANNO NS_LITERAL_CSTRING("sync/guid") + +// Places string bundle, contains internationalized bookmark root names. +#define PLACES_BUNDLE "chrome://places/locale/places.properties" + +// Livemarks annotations. +#define LMANNO_FEEDURI "livemark/feedURI" +#define LMANNO_SITEURI "livemark/siteURI" + +#define MOBILE_ROOT_GUID "mobile______" +#define MOBILE_ROOT_ANNO "mobile/bookmarksRoot" + +// We use a fixed title for the mobile root to avoid marking the database as +// corrupt if we can't look up the localized title in the string bundle. Sync +// sets the title to the localized version when it creates the left pane query. +#define MOBILE_ROOT_TITLE "mobile" + +using namespace mozilla; + +namespace mozilla { +namespace places { + +namespace { + +//////////////////////////////////////////////////////////////////////////////// +//// Helpers + +/** + * Checks whether exists a database backup created not longer than + * RECENT_BACKUP_TIME_MICROSEC ago. + */ +bool +hasRecentCorruptDB() +{ + MOZ_ASSERT(NS_IsMainThread()); + + nsCOMPtr<nsIFile> profDir; + NS_GetSpecialDirectory(NS_APP_USER_PROFILE_50_DIR, getter_AddRefs(profDir)); + NS_ENSURE_TRUE(profDir, false); + nsCOMPtr<nsISimpleEnumerator> entries; + profDir->GetDirectoryEntries(getter_AddRefs(entries)); + NS_ENSURE_TRUE(entries, false); + bool hasMore; + while (NS_SUCCEEDED(entries->HasMoreElements(&hasMore)) && hasMore) { + nsCOMPtr<nsISupports> next; + entries->GetNext(getter_AddRefs(next)); + NS_ENSURE_TRUE(next, false); + nsCOMPtr<nsIFile> currFile = do_QueryInterface(next); + NS_ENSURE_TRUE(currFile, false); + + nsAutoString leafName; + if (NS_SUCCEEDED(currFile->GetLeafName(leafName)) && + leafName.Length() >= DATABASE_CORRUPT_FILENAME.Length() && + leafName.Find(".corrupt", DATABASE_FILENAME.Length()) != -1) { + PRTime lastMod = 0; + currFile->GetLastModifiedTime(&lastMod); + NS_ENSURE_TRUE(lastMod > 0, false); + return (PR_Now() - lastMod) > RECENT_BACKUP_TIME_MICROSEC; + } + } + return false; +} + +/** + * Updates sqlite_stat1 table through ANALYZE. + * Since also nsPlacesExpiration.js executes ANALYZE, the analyzed tables + * must be the same in both components. So ensure they are in sync. + * + * @param aDBConn + * The database connection. + */ +nsresult +updateSQLiteStatistics(mozIStorageConnection* aDBConn) +{ + MOZ_ASSERT(NS_IsMainThread()); + nsCOMPtr<mozIStorageAsyncStatement> analyzePlacesStmt; + aDBConn->CreateAsyncStatement(NS_LITERAL_CSTRING( + "ANALYZE moz_places" + ), getter_AddRefs(analyzePlacesStmt)); + NS_ENSURE_STATE(analyzePlacesStmt); + nsCOMPtr<mozIStorageAsyncStatement> analyzeBookmarksStmt; + aDBConn->CreateAsyncStatement(NS_LITERAL_CSTRING( + "ANALYZE moz_bookmarks" + ), getter_AddRefs(analyzeBookmarksStmt)); + NS_ENSURE_STATE(analyzeBookmarksStmt); + nsCOMPtr<mozIStorageAsyncStatement> analyzeVisitsStmt; + aDBConn->CreateAsyncStatement(NS_LITERAL_CSTRING( + "ANALYZE moz_historyvisits" + ), getter_AddRefs(analyzeVisitsStmt)); + NS_ENSURE_STATE(analyzeVisitsStmt); + nsCOMPtr<mozIStorageAsyncStatement> analyzeInputStmt; + aDBConn->CreateAsyncStatement(NS_LITERAL_CSTRING( + "ANALYZE moz_inputhistory" + ), getter_AddRefs(analyzeInputStmt)); + NS_ENSURE_STATE(analyzeInputStmt); + + mozIStorageBaseStatement *stmts[] = { + analyzePlacesStmt, + analyzeBookmarksStmt, + analyzeVisitsStmt, + analyzeInputStmt + }; + + nsCOMPtr<mozIStoragePendingStatement> ps; + (void)aDBConn->ExecuteAsync(stmts, ArrayLength(stmts), nullptr, + getter_AddRefs(ps)); + return NS_OK; +} + +/** + * Sets the connection journal mode to one of the JOURNAL_* types. + * + * @param aDBConn + * The database connection. + * @param aJournalMode + * One of the JOURNAL_* types. + * @returns the current journal mode. + * @note this may return a different journal mode than the required one, since + * setting it may fail. + */ +enum JournalMode +SetJournalMode(nsCOMPtr<mozIStorageConnection>& aDBConn, + enum JournalMode aJournalMode) +{ + MOZ_ASSERT(NS_IsMainThread()); + nsAutoCString journalMode; + switch (aJournalMode) { + default: + MOZ_FALLTHROUGH_ASSERT("Trying to set an unknown journal mode."); + // Fall through to the default DELETE journal. + case JOURNAL_DELETE: + journalMode.AssignLiteral("delete"); + break; + case JOURNAL_TRUNCATE: + journalMode.AssignLiteral("truncate"); + break; + case JOURNAL_MEMORY: + journalMode.AssignLiteral("memory"); + break; + case JOURNAL_WAL: + journalMode.AssignLiteral("wal"); + break; + } + + nsCOMPtr<mozIStorageStatement> statement; + nsAutoCString query(MOZ_STORAGE_UNIQUIFY_QUERY_STR + "PRAGMA journal_mode = "); + query.Append(journalMode); + aDBConn->CreateStatement(query, getter_AddRefs(statement)); + NS_ENSURE_TRUE(statement, JOURNAL_DELETE); + + bool hasResult = false; + if (NS_SUCCEEDED(statement->ExecuteStep(&hasResult)) && hasResult && + NS_SUCCEEDED(statement->GetUTF8String(0, journalMode))) { + if (journalMode.EqualsLiteral("delete")) { + return JOURNAL_DELETE; + } + if (journalMode.EqualsLiteral("truncate")) { + return JOURNAL_TRUNCATE; + } + if (journalMode.EqualsLiteral("memory")) { + return JOURNAL_MEMORY; + } + if (journalMode.EqualsLiteral("wal")) { + return JOURNAL_WAL; + } + // This is an unknown journal. + MOZ_ASSERT(true); + } + + return JOURNAL_DELETE; +} + +nsresult +CreateRoot(nsCOMPtr<mozIStorageConnection>& aDBConn, + const nsCString& aRootName, const nsCString& aGuid, + const nsXPIDLString& titleString) +{ + MOZ_ASSERT(NS_IsMainThread()); + + // The position of the new item in its folder. + static int32_t itemPosition = 0; + + // A single creation timestamp for all roots so that the root folder's + // last modification time isn't earlier than its childrens' creation time. + static PRTime timestamp = 0; + if (!timestamp) + timestamp = RoundedPRNow(); + + // Create a new bookmark folder for the root. + nsCOMPtr<mozIStorageStatement> stmt; + nsresult rv = aDBConn->CreateStatement(NS_LITERAL_CSTRING( + "INSERT INTO moz_bookmarks " + "(type, position, title, dateAdded, lastModified, guid, parent) " + "VALUES (:item_type, :item_position, :item_title," + ":date_added, :last_modified, :guid," + "IFNULL((SELECT id FROM moz_bookmarks WHERE parent = 0), 0))" + ), getter_AddRefs(stmt)); + if (NS_FAILED(rv)) return rv; + + rv = stmt->BindInt32ByName(NS_LITERAL_CSTRING("item_type"), + nsINavBookmarksService::TYPE_FOLDER); + if (NS_FAILED(rv)) return rv; + rv = stmt->BindInt32ByName(NS_LITERAL_CSTRING("item_position"), itemPosition); + if (NS_FAILED(rv)) return rv; + rv = stmt->BindUTF8StringByName(NS_LITERAL_CSTRING("item_title"), + NS_ConvertUTF16toUTF8(titleString)); + if (NS_FAILED(rv)) return rv; + rv = stmt->BindInt64ByName(NS_LITERAL_CSTRING("date_added"), timestamp); + if (NS_FAILED(rv)) return rv; + rv = stmt->BindInt64ByName(NS_LITERAL_CSTRING("last_modified"), timestamp); + if (NS_FAILED(rv)) return rv; + rv = stmt->BindUTF8StringByName(NS_LITERAL_CSTRING("guid"), aGuid); + if (NS_FAILED(rv)) return rv; + rv = stmt->Execute(); + if (NS_FAILED(rv)) return rv; + + // The 'places' root is a folder containing the other roots. + // The first bookmark in a folder has position 0. + if (!aRootName.EqualsLiteral("places")) + ++itemPosition; + + return NS_OK; +} + + +} // namespace + +//////////////////////////////////////////////////////////////////////////////// +//// Database + +PLACES_FACTORY_SINGLETON_IMPLEMENTATION(Database, gDatabase) + +NS_IMPL_ISUPPORTS(Database +, nsIObserver +, nsISupportsWeakReference +) + +Database::Database() + : mMainThreadStatements(mMainConn) + , mMainThreadAsyncStatements(mMainConn) + , mAsyncThreadStatements(mMainConn) + , mDBPageSize(0) + , mDatabaseStatus(nsINavHistoryService::DATABASE_STATUS_OK) + , mClosed(false) + , mClientsShutdown(new ClientsShutdownBlocker()) + , mConnectionShutdown(new ConnectionShutdownBlocker(this)) + , mMaxUrlLength(0) +{ + MOZ_ASSERT(!XRE_IsContentProcess(), + "Cannot instantiate Places in the content process"); + // Attempting to create two instances of the service? + MOZ_ASSERT(!gDatabase); + gDatabase = this; +} + +already_AddRefed<nsIAsyncShutdownClient> +Database::GetProfileChangeTeardownPhase() +{ + nsCOMPtr<nsIAsyncShutdownService> asyncShutdownSvc = services::GetAsyncShutdown(); + MOZ_ASSERT(asyncShutdownSvc); + if (NS_WARN_IF(!asyncShutdownSvc)) { + return nullptr; + } + + // Consumers of Places should shutdown before us, at profile-change-teardown. + nsCOMPtr<nsIAsyncShutdownClient> shutdownPhase; + DebugOnly<nsresult> rv = asyncShutdownSvc-> + GetProfileChangeTeardown(getter_AddRefs(shutdownPhase)); + MOZ_ASSERT(NS_SUCCEEDED(rv)); + return shutdownPhase.forget(); +} + +already_AddRefed<nsIAsyncShutdownClient> +Database::GetProfileBeforeChangePhase() +{ + nsCOMPtr<nsIAsyncShutdownService> asyncShutdownSvc = services::GetAsyncShutdown(); + MOZ_ASSERT(asyncShutdownSvc); + if (NS_WARN_IF(!asyncShutdownSvc)) { + return nullptr; + } + + // Consumers of Places should shutdown before us, at profile-change-teardown. + nsCOMPtr<nsIAsyncShutdownClient> shutdownPhase; + DebugOnly<nsresult> rv = asyncShutdownSvc-> + GetProfileBeforeChange(getter_AddRefs(shutdownPhase)); + MOZ_ASSERT(NS_SUCCEEDED(rv)); + return shutdownPhase.forget(); +} + +Database::~Database() +{ +} + +bool +Database::IsShutdownStarted() const +{ + if (!mConnectionShutdown) { + // We have already broken the cycle between `this` and `mConnectionShutdown`. + return true; + } + return mConnectionShutdown->IsStarted(); +} + +already_AddRefed<mozIStorageAsyncStatement> +Database::GetAsyncStatement(const nsACString& aQuery) const +{ + if (IsShutdownStarted()) { + return nullptr; + } + MOZ_ASSERT(NS_IsMainThread()); + return mMainThreadAsyncStatements.GetCachedStatement(aQuery); +} + +already_AddRefed<mozIStorageStatement> +Database::GetStatement(const nsACString& aQuery) const +{ + if (IsShutdownStarted()) { + return nullptr; + } + if (NS_IsMainThread()) { + return mMainThreadStatements.GetCachedStatement(aQuery); + } + return mAsyncThreadStatements.GetCachedStatement(aQuery); +} + +already_AddRefed<nsIAsyncShutdownClient> +Database::GetClientsShutdown() +{ + MOZ_ASSERT(mClientsShutdown); + return mClientsShutdown->GetClient(); +} + +// static +already_AddRefed<Database> +Database::GetDatabase() +{ + if (PlacesShutdownBlocker::IsStarted()) { + return nullptr; + } + return GetSingleton(); +} + +nsresult +Database::Init() +{ + MOZ_ASSERT(NS_IsMainThread()); + + nsCOMPtr<mozIStorageService> storage = + do_GetService(MOZ_STORAGE_SERVICE_CONTRACTID); + NS_ENSURE_STATE(storage); + + // Init the database file and connect to it. + bool databaseCreated = false; + nsresult rv = InitDatabaseFile(storage, &databaseCreated); + if (NS_SUCCEEDED(rv) && databaseCreated) { + mDatabaseStatus = nsINavHistoryService::DATABASE_STATUS_CREATE; + } + else if (rv == NS_ERROR_FILE_CORRUPTED) { + // The database is corrupt, backup and replace it with a new one. + mDatabaseStatus = nsINavHistoryService::DATABASE_STATUS_CORRUPT; + rv = BackupAndReplaceDatabaseFile(storage); + // Fallback to catch-all handler, that notifies a database locked failure. + } + + // If the database connection still cannot be opened, it may just be locked + // by third parties. Send out a notification and interrupt initialization. + if (NS_FAILED(rv)) { + RefPtr<PlacesEvent> lockedEvent = new PlacesEvent(TOPIC_DATABASE_LOCKED); + (void)NS_DispatchToMainThread(lockedEvent); + return rv; + } + + // Initialize the database schema. In case of failure the existing schema is + // is corrupt or incoherent, thus the database should be replaced. + bool databaseMigrated = false; + rv = InitSchema(&databaseMigrated); + if (NS_FAILED(rv)) { + mDatabaseStatus = nsINavHistoryService::DATABASE_STATUS_CORRUPT; + rv = BackupAndReplaceDatabaseFile(storage); + NS_ENSURE_SUCCESS(rv, rv); + // Try to initialize the schema again on the new database. + rv = InitSchema(&databaseMigrated); + NS_ENSURE_SUCCESS(rv, rv); + } + + if (databaseMigrated) { + mDatabaseStatus = nsINavHistoryService::DATABASE_STATUS_UPGRADED; + } + + if (mDatabaseStatus != nsINavHistoryService::DATABASE_STATUS_OK) { + rv = updateSQLiteStatistics(MainConn()); + NS_ENSURE_SUCCESS(rv, rv); + } + + // Initialize here all the items that are not part of the on-disk database, + // like views, temp triggers or temp tables. The database should not be + // considered corrupt if any of the following fails. + + rv = InitTempEntities(); + NS_ENSURE_SUCCESS(rv, rv); + + // Notify we have finished database initialization. + // Enqueue the notification, so if we init another service that requires + // nsNavHistoryService we don't recursive try to get it. + RefPtr<PlacesEvent> completeEvent = + new PlacesEvent(TOPIC_PLACES_INIT_COMPLETE); + rv = NS_DispatchToMainThread(completeEvent); + NS_ENSURE_SUCCESS(rv, rv); + + // At this point we know the Database object points to a valid connection + // and we need to setup async shutdown. + { + // First of all Places clients should block profile-change-teardown. + nsCOMPtr<nsIAsyncShutdownClient> shutdownPhase = GetProfileChangeTeardownPhase(); + MOZ_ASSERT(shutdownPhase); + if (shutdownPhase) { + DebugOnly<nsresult> rv = shutdownPhase->AddBlocker( + static_cast<nsIAsyncShutdownBlocker*>(mClientsShutdown.get()), + NS_LITERAL_STRING(__FILE__), + __LINE__, + NS_LITERAL_STRING("")); + MOZ_ASSERT(NS_SUCCEEDED(rv)); + } + } + + { + // Then connection closing should block profile-before-change. + nsCOMPtr<nsIAsyncShutdownClient> shutdownPhase = GetProfileBeforeChangePhase(); + MOZ_ASSERT(shutdownPhase); + if (shutdownPhase) { + DebugOnly<nsresult> rv = shutdownPhase->AddBlocker( + static_cast<nsIAsyncShutdownBlocker*>(mConnectionShutdown.get()), + NS_LITERAL_STRING(__FILE__), + __LINE__, + NS_LITERAL_STRING("")); + MOZ_ASSERT(NS_SUCCEEDED(rv)); + } + } + + // Finally observe profile shutdown notifications. + nsCOMPtr<nsIObserverService> os = mozilla::services::GetObserverService(); + if (os) { + (void)os->AddObserver(this, TOPIC_PROFILE_CHANGE_TEARDOWN, true); + } + + return NS_OK; +} + +nsresult +Database::InitDatabaseFile(nsCOMPtr<mozIStorageService>& aStorage, + bool* aNewDatabaseCreated) +{ + MOZ_ASSERT(NS_IsMainThread()); + *aNewDatabaseCreated = false; + + nsCOMPtr<nsIFile> databaseFile; + nsresult rv = NS_GetSpecialDirectory(NS_APP_USER_PROFILE_50_DIR, + getter_AddRefs(databaseFile)); + NS_ENSURE_SUCCESS(rv, rv); + rv = databaseFile->Append(DATABASE_FILENAME); + NS_ENSURE_SUCCESS(rv, rv); + + bool databaseFileExists = false; + rv = databaseFile->Exists(&databaseFileExists); + NS_ENSURE_SUCCESS(rv, rv); + + if (databaseFileExists && + Preferences::GetBool(PREF_FORCE_DATABASE_REPLACEMENT, false)) { + // If this pref is set, Maintenance required a database replacement, due to + // integrity corruption. + // Be sure to clear the pref to avoid handling it more than once. + (void)Preferences::ClearUser(PREF_FORCE_DATABASE_REPLACEMENT); + + return NS_ERROR_FILE_CORRUPTED; + } + + // Open the database file. If it does not exist a new one will be created. + // Use an unshared connection, it will consume more memory but avoid shared + // cache contentions across threads. + rv = aStorage->OpenUnsharedDatabase(databaseFile, getter_AddRefs(mMainConn)); + NS_ENSURE_SUCCESS(rv, rv); + + *aNewDatabaseCreated = !databaseFileExists; + return NS_OK; +} + +nsresult +Database::BackupAndReplaceDatabaseFile(nsCOMPtr<mozIStorageService>& aStorage) +{ + MOZ_ASSERT(NS_IsMainThread()); + nsCOMPtr<nsIFile> profDir; + nsresult rv = NS_GetSpecialDirectory(NS_APP_USER_PROFILE_50_DIR, + getter_AddRefs(profDir)); + NS_ENSURE_SUCCESS(rv, rv); + nsCOMPtr<nsIFile> databaseFile; + rv = profDir->Clone(getter_AddRefs(databaseFile)); + NS_ENSURE_SUCCESS(rv, rv); + rv = databaseFile->Append(DATABASE_FILENAME); + NS_ENSURE_SUCCESS(rv, rv); + + // If we have + // already failed in the last 24 hours avoid to create another corrupt file, + // since doing so, in some situation, could cause us to create a new corrupt + // file at every try to access any Places service. That is bad because it + // would quickly fill the user's disk space without any notice. + if (!hasRecentCorruptDB()) { + nsCOMPtr<nsIFile> backup; + (void)aStorage->BackupDatabaseFile(databaseFile, DATABASE_CORRUPT_FILENAME, + profDir, getter_AddRefs(backup)); + } + + // If anything fails from this point on, we have a stale connection or + // database file, and there's not much more we can do. + // The only thing we can try to do is to replace the database on the next + // startup, and report the problem through telemetry. + { + enum eCorruptDBReplaceStage : int8_t { + stage_closing = 0, + stage_removing, + stage_reopening, + stage_replaced + }; + eCorruptDBReplaceStage stage = stage_closing; + auto guard = MakeScopeExit([&]() { + if (stage != stage_replaced) { + // Reaching this point means the database is corrupt and we failed to + // replace it. For this session part of the application related to + // bookmarks and history will misbehave. The frontend may show a + // "locked" notification to the user though. + // Set up a pref to try replacing the database at the next startup. + Preferences::SetBool(PREF_FORCE_DATABASE_REPLACEMENT, true); + } + // Report the corruption through telemetry. + Telemetry::Accumulate(Telemetry::PLACES_DATABASE_CORRUPTION_HANDLING_STAGE, + static_cast<int8_t>(stage)); + }); + + // Close database connection if open. + if (mMainConn) { + rv = mMainConn->Close(); + NS_ENSURE_SUCCESS(rv, rv); + } + + // Remove the broken database. + stage = stage_removing; + rv = databaseFile->Remove(false); + if (NS_FAILED(rv) && rv != NS_ERROR_FILE_TARGET_DOES_NOT_EXIST) { + return rv; + } + + // Create a new database file. + // Use an unshared connection, it will consume more memory but avoid shared + // cache contentions across threads. + stage = stage_reopening; + rv = aStorage->OpenUnsharedDatabase(databaseFile, getter_AddRefs(mMainConn)); + NS_ENSURE_SUCCESS(rv, rv); + + stage = stage_replaced; + } + + return NS_OK; +} + +nsresult +Database::InitSchema(bool* aDatabaseMigrated) +{ + MOZ_ASSERT(NS_IsMainThread()); + *aDatabaseMigrated = false; + + // WARNING: any statement executed before setting the journal mode must be + // finalized, since SQLite doesn't allow changing the journal mode if there + // is any outstanding statement. + + { + // Get the page size. This may be different than the default if the + // database file already existed with a different page size. + nsCOMPtr<mozIStorageStatement> statement; + nsresult rv = mMainConn->CreateStatement(NS_LITERAL_CSTRING( + MOZ_STORAGE_UNIQUIFY_QUERY_STR "PRAGMA page_size" + ), getter_AddRefs(statement)); + NS_ENSURE_SUCCESS(rv, rv); + bool hasResult = false; + rv = statement->ExecuteStep(&hasResult); + NS_ENSURE_TRUE(NS_SUCCEEDED(rv) && hasResult, NS_ERROR_FAILURE); + rv = statement->GetInt32(0, &mDBPageSize); + NS_ENSURE_TRUE(NS_SUCCEEDED(rv) && mDBPageSize > 0, NS_ERROR_UNEXPECTED); + } + + // Ensure that temp tables are held in memory, not on disk. + nsresult rv = mMainConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING( + MOZ_STORAGE_UNIQUIFY_QUERY_STR "PRAGMA temp_store = MEMORY")); + NS_ENSURE_SUCCESS(rv, rv); + + if (PR_GetEnv(ENV_ALLOW_CORRUPTION) && Preferences::GetBool(PREF_DISABLE_DURABILITY, false)) { + // Volatile storage was requested. Use the in-memory journal (no + // filesystem I/O) and don't sync the filesystem after writing. + SetJournalMode(mMainConn, JOURNAL_MEMORY); + rv = mMainConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING( + "PRAGMA synchronous = OFF")); + NS_ENSURE_SUCCESS(rv, rv); + } + else { + // Be sure to set journal mode after page_size. WAL would prevent the change + // otherwise. + if (JOURNAL_WAL == SetJournalMode(mMainConn, JOURNAL_WAL)) { + // Set the WAL journal size limit. We want it to be small, since in + // synchronous = NORMAL mode a crash could cause loss of all the + // transactions in the journal. For added safety we will also force + // checkpointing at strategic moments. + int32_t checkpointPages = + static_cast<int32_t>(DATABASE_MAX_WAL_SIZE_IN_KIBIBYTES * 1024 / mDBPageSize); + nsAutoCString checkpointPragma("PRAGMA wal_autocheckpoint = "); + checkpointPragma.AppendInt(checkpointPages); + rv = mMainConn->ExecuteSimpleSQL(checkpointPragma); + NS_ENSURE_SUCCESS(rv, rv); + } + else { + // Ignore errors, if we fail here the database could be considered corrupt + // and we won't be able to go on, even if it's just matter of a bogus file + // system. The default mode (DELETE) will be fine in such a case. + (void)SetJournalMode(mMainConn, JOURNAL_TRUNCATE); + + // Set synchronous to FULL to ensure maximum data integrity, even in + // case of crashes or unclean shutdowns. + rv = mMainConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING( + "PRAGMA synchronous = FULL")); + NS_ENSURE_SUCCESS(rv, rv); + } + } + + // The journal is usually free to grow for performance reasons, but it never + // shrinks back. Since the space taken may be problematic, especially on + // mobile devices, limit its size. + // Since exceeding the limit will cause a truncate, allow a slightly + // larger limit than DATABASE_MAX_WAL_SIZE_IN_KIBIBYTES to reduce the number + // of times it is needed. + nsAutoCString journalSizePragma("PRAGMA journal_size_limit = "); + journalSizePragma.AppendInt(DATABASE_MAX_WAL_SIZE_IN_KIBIBYTES * 3); + (void)mMainConn->ExecuteSimpleSQL(journalSizePragma); + + // Grow places in |growthIncrementKiB| increments to limit fragmentation on disk. + // By default, it's 10 MB. + int32_t growthIncrementKiB = + Preferences::GetInt(PREF_GROWTH_INCREMENT_KIB, 10 * BYTES_PER_KIBIBYTE); + if (growthIncrementKiB > 0) { + (void)mMainConn->SetGrowthIncrement(growthIncrementKiB * BYTES_PER_KIBIBYTE, EmptyCString()); + } + + nsAutoCString busyTimeoutPragma("PRAGMA busy_timeout = "); + busyTimeoutPragma.AppendInt(DATABASE_BUSY_TIMEOUT_MS); + (void)mMainConn->ExecuteSimpleSQL(busyTimeoutPragma); + + // We use our functions during migration, so initialize them now. + rv = InitFunctions(); + NS_ENSURE_SUCCESS(rv, rv); + + // Get the database schema version. + int32_t currentSchemaVersion; + rv = mMainConn->GetSchemaVersion(¤tSchemaVersion); + NS_ENSURE_SUCCESS(rv, rv); + bool databaseInitialized = currentSchemaVersion > 0; + + if (databaseInitialized && currentSchemaVersion == DATABASE_SCHEMA_VERSION) { + // The database is up to date and ready to go. + return NS_OK; + } + + // We are going to update the database, so everything from now on should be in + // a transaction for performances. + mozStorageTransaction transaction(mMainConn, false); + + if (databaseInitialized) { + // Migration How-to: + // + // 1. increment PLACES_SCHEMA_VERSION. + // 2. implement a method that performs upgrade to your version from the + // previous one. + // + // NOTE: The downgrade process is pretty much complicated by the fact old + // versions cannot know what a new version is going to implement. + // The only thing we will do for downgrades is setting back the schema + // version, so that next upgrades will run again the migration step. + + if (currentSchemaVersion > 36) { + // These versions are not downgradable. + return NS_ERROR_FILE_CORRUPTED; + } + + if (currentSchemaVersion < DATABASE_SCHEMA_VERSION) { + *aDatabaseMigrated = true; + + if (currentSchemaVersion < 11) { + // These are versions older than Firefox 4 that are not supported + // anymore. In this case it's safer to just replace the database. + return NS_ERROR_FILE_CORRUPTED; + } + + // Firefox 4 uses schema version 11. + + // Firefox 8 uses schema version 12. + + if (currentSchemaVersion < 13) { + rv = MigrateV13Up(); + NS_ENSURE_SUCCESS(rv, rv); + } + + if (currentSchemaVersion < 15) { + rv = MigrateV15Up(); + NS_ENSURE_SUCCESS(rv, rv); + } + + if (currentSchemaVersion < 17) { + rv = MigrateV17Up(); + NS_ENSURE_SUCCESS(rv, rv); + } + + // Firefox 12 uses schema version 17. + + if (currentSchemaVersion < 18) { + rv = MigrateV18Up(); + NS_ENSURE_SUCCESS(rv, rv); + } + + if (currentSchemaVersion < 19) { + rv = MigrateV19Up(); + NS_ENSURE_SUCCESS(rv, rv); + } + + // Firefox 13 uses schema version 19. + + if (currentSchemaVersion < 20) { + rv = MigrateV20Up(); + NS_ENSURE_SUCCESS(rv, rv); + } + + if (currentSchemaVersion < 21) { + rv = MigrateV21Up(); + NS_ENSURE_SUCCESS(rv, rv); + } + + // Firefox 14 uses schema version 21. + + if (currentSchemaVersion < 22) { + rv = MigrateV22Up(); + NS_ENSURE_SUCCESS(rv, rv); + } + + // Firefox 22 uses schema version 22. + + if (currentSchemaVersion < 23) { + rv = MigrateV23Up(); + NS_ENSURE_SUCCESS(rv, rv); + } + + // Firefox 24 uses schema version 23. + + if (currentSchemaVersion < 24) { + rv = MigrateV24Up(); + NS_ENSURE_SUCCESS(rv, rv); + } + + // Firefox 34 uses schema version 24. + + if (currentSchemaVersion < 25) { + rv = MigrateV25Up(); + NS_ENSURE_SUCCESS(rv, rv); + } + + // Firefox 36 uses schema version 25. + + if (currentSchemaVersion < 26) { + rv = MigrateV26Up(); + NS_ENSURE_SUCCESS(rv, rv); + } + + // Firefox 37 uses schema version 26. + + if (currentSchemaVersion < 27) { + rv = MigrateV27Up(); + NS_ENSURE_SUCCESS(rv, rv); + } + + if (currentSchemaVersion < 28) { + rv = MigrateV28Up(); + NS_ENSURE_SUCCESS(rv, rv); + } + + // Firefox 39 uses schema version 28. + + if (currentSchemaVersion < 30) { + rv = MigrateV30Up(); + NS_ENSURE_SUCCESS(rv, rv); + } + + // Firefox 41 uses schema version 30. + + if (currentSchemaVersion < 31) { + rv = MigrateV31Up(); + NS_ENSURE_SUCCESS(rv, rv); + } + + // Firefox 48 uses schema version 31. + + if (currentSchemaVersion < 32) { + rv = MigrateV32Up(); + NS_ENSURE_SUCCESS(rv, rv); + } + + // Firefox 49 uses schema version 32. + + if (currentSchemaVersion < 33) { + rv = MigrateV33Up(); + NS_ENSURE_SUCCESS(rv, rv); + } + + // Firefox 50 uses schema version 33. + + if (currentSchemaVersion < 34) { + rv = MigrateV34Up(); + NS_ENSURE_SUCCESS(rv, rv); + } + + // Firefox 51 uses schema version 34. + + if (currentSchemaVersion < 35) { + rv = MigrateV35Up(); + NS_ENSURE_SUCCESS(rv, rv); + } + + // Firefox 52 uses schema version 35. + + // Schema Upgrades must add migration code here. + + rv = UpdateBookmarkRootTitles(); + // We don't want a broken localization to cause us to think + // the database is corrupt and needs to be replaced. + MOZ_ASSERT(NS_SUCCEEDED(rv)); + } + } + else { + // This is a new database, so we have to create all the tables and indices. + + // moz_places. + rv = mMainConn->ExecuteSimpleSQL(CREATE_MOZ_PLACES); + NS_ENSURE_SUCCESS(rv, rv); + rv = mMainConn->ExecuteSimpleSQL(CREATE_IDX_MOZ_PLACES_URL_HASH); + NS_ENSURE_SUCCESS(rv, rv); + rv = mMainConn->ExecuteSimpleSQL(CREATE_IDX_MOZ_PLACES_FAVICON); + NS_ENSURE_SUCCESS(rv, rv); + rv = mMainConn->ExecuteSimpleSQL(CREATE_IDX_MOZ_PLACES_REVHOST); + NS_ENSURE_SUCCESS(rv, rv); + rv = mMainConn->ExecuteSimpleSQL(CREATE_IDX_MOZ_PLACES_VISITCOUNT); + NS_ENSURE_SUCCESS(rv, rv); + rv = mMainConn->ExecuteSimpleSQL(CREATE_IDX_MOZ_PLACES_FRECENCY); + NS_ENSURE_SUCCESS(rv, rv); + rv = mMainConn->ExecuteSimpleSQL(CREATE_IDX_MOZ_PLACES_LASTVISITDATE); + NS_ENSURE_SUCCESS(rv, rv); + rv = mMainConn->ExecuteSimpleSQL(CREATE_IDX_MOZ_PLACES_GUID); + NS_ENSURE_SUCCESS(rv, rv); + + // moz_historyvisits. + rv = mMainConn->ExecuteSimpleSQL(CREATE_MOZ_HISTORYVISITS); + NS_ENSURE_SUCCESS(rv, rv); + rv = mMainConn->ExecuteSimpleSQL(CREATE_IDX_MOZ_HISTORYVISITS_PLACEDATE); + NS_ENSURE_SUCCESS(rv, rv); + rv = mMainConn->ExecuteSimpleSQL(CREATE_IDX_MOZ_HISTORYVISITS_FROMVISIT); + NS_ENSURE_SUCCESS(rv, rv); + rv = mMainConn->ExecuteSimpleSQL(CREATE_IDX_MOZ_HISTORYVISITS_VISITDATE); + NS_ENSURE_SUCCESS(rv, rv); + + // moz_inputhistory. + rv = mMainConn->ExecuteSimpleSQL(CREATE_MOZ_INPUTHISTORY); + NS_ENSURE_SUCCESS(rv, rv); + + // moz_hosts. + rv = mMainConn->ExecuteSimpleSQL(CREATE_MOZ_HOSTS); + NS_ENSURE_SUCCESS(rv, rv); + + // moz_bookmarks. + rv = mMainConn->ExecuteSimpleSQL(CREATE_MOZ_BOOKMARKS); + NS_ENSURE_SUCCESS(rv, rv); + rv = mMainConn->ExecuteSimpleSQL(CREATE_IDX_MOZ_BOOKMARKS_PLACETYPE); + NS_ENSURE_SUCCESS(rv, rv); + rv = mMainConn->ExecuteSimpleSQL(CREATE_IDX_MOZ_BOOKMARKS_PARENTPOSITION); + NS_ENSURE_SUCCESS(rv, rv); + rv = mMainConn->ExecuteSimpleSQL(CREATE_IDX_MOZ_BOOKMARKS_PLACELASTMODIFIED); + NS_ENSURE_SUCCESS(rv, rv); + rv = mMainConn->ExecuteSimpleSQL(CREATE_IDX_MOZ_BOOKMARKS_GUID); + NS_ENSURE_SUCCESS(rv, rv); + + // moz_keywords. + rv = mMainConn->ExecuteSimpleSQL(CREATE_MOZ_KEYWORDS); + NS_ENSURE_SUCCESS(rv, rv); + rv = mMainConn->ExecuteSimpleSQL(CREATE_IDX_MOZ_KEYWORDS_PLACEPOSTDATA); + NS_ENSURE_SUCCESS(rv, rv); + + // moz_favicons. + rv = mMainConn->ExecuteSimpleSQL(CREATE_MOZ_FAVICONS); + NS_ENSURE_SUCCESS(rv, rv); + + // moz_anno_attributes. + rv = mMainConn->ExecuteSimpleSQL(CREATE_MOZ_ANNO_ATTRIBUTES); + NS_ENSURE_SUCCESS(rv, rv); + + // moz_annos. + rv = mMainConn->ExecuteSimpleSQL(CREATE_MOZ_ANNOS); + NS_ENSURE_SUCCESS(rv, rv); + rv = mMainConn->ExecuteSimpleSQL(CREATE_IDX_MOZ_ANNOS_PLACEATTRIBUTE); + NS_ENSURE_SUCCESS(rv, rv); + + // moz_items_annos. + rv = mMainConn->ExecuteSimpleSQL(CREATE_MOZ_ITEMS_ANNOS); + NS_ENSURE_SUCCESS(rv, rv); + rv = mMainConn->ExecuteSimpleSQL(CREATE_IDX_MOZ_ITEMSANNOS_PLACEATTRIBUTE); + NS_ENSURE_SUCCESS(rv, rv); + + // Initialize the bookmark roots in the new DB. + rv = CreateBookmarkRoots(); + NS_ENSURE_SUCCESS(rv, rv); + } + + // Set the schema version to the current one. + rv = mMainConn->SetSchemaVersion(DATABASE_SCHEMA_VERSION); + NS_ENSURE_SUCCESS(rv, rv); + + rv = transaction.Commit(); + NS_ENSURE_SUCCESS(rv, rv); + + ForceWALCheckpoint(); + + // ANY FAILURE IN THIS METHOD WILL CAUSE US TO MARK THE DATABASE AS CORRUPT + // AND TRY TO REPLACE IT. + // DO NOT PUT HERE ANYTHING THAT IS NOT RELATED TO INITIALIZATION OR MODIFYING + // THE DISK DATABASE. + + return NS_OK; +} + +nsresult +Database::CreateBookmarkRoots() +{ + MOZ_ASSERT(NS_IsMainThread()); + + nsCOMPtr<nsIStringBundleService> bundleService = + services::GetStringBundleService(); + NS_ENSURE_STATE(bundleService); + nsCOMPtr<nsIStringBundle> bundle; + nsresult rv = bundleService->CreateBundle(PLACES_BUNDLE, getter_AddRefs(bundle)); + if (NS_FAILED(rv)) return rv; + + nsXPIDLString rootTitle; + // The first root's title is an empty string. + rv = CreateRoot(mMainConn, NS_LITERAL_CSTRING("places"), + NS_LITERAL_CSTRING("root________"), rootTitle); + if (NS_FAILED(rv)) return rv; + + // Fetch the internationalized folder name from the string bundle. + rv = bundle->GetStringFromName(u"BookmarksMenuFolderTitle", + getter_Copies(rootTitle)); + if (NS_FAILED(rv)) return rv; + rv = CreateRoot(mMainConn, NS_LITERAL_CSTRING("menu"), + NS_LITERAL_CSTRING("menu________"), rootTitle); + if (NS_FAILED(rv)) return rv; + + rv = bundle->GetStringFromName(u"BookmarksToolbarFolderTitle", + getter_Copies(rootTitle)); + if (NS_FAILED(rv)) return rv; + rv = CreateRoot(mMainConn, NS_LITERAL_CSTRING("toolbar"), + NS_LITERAL_CSTRING("toolbar_____"), rootTitle); + if (NS_FAILED(rv)) return rv; + + rv = bundle->GetStringFromName(u"TagsFolderTitle", + getter_Copies(rootTitle)); + if (NS_FAILED(rv)) return rv; + rv = CreateRoot(mMainConn, NS_LITERAL_CSTRING("tags"), + NS_LITERAL_CSTRING("tags________"), rootTitle); + if (NS_FAILED(rv)) return rv; + + rv = bundle->GetStringFromName(u"OtherBookmarksFolderTitle", + getter_Copies(rootTitle)); + if (NS_FAILED(rv)) return rv; + rv = CreateRoot(mMainConn, NS_LITERAL_CSTRING("unfiled"), + NS_LITERAL_CSTRING("unfiled_____"), rootTitle); + if (NS_FAILED(rv)) return rv; + + int64_t mobileRootId = CreateMobileRoot(); + if (mobileRootId <= 0) return NS_ERROR_FAILURE; + +#if DEBUG + nsCOMPtr<mozIStorageStatement> stmt; + rv = mMainConn->CreateStatement(NS_LITERAL_CSTRING( + "SELECT count(*), sum(position) FROM moz_bookmarks" + ), getter_AddRefs(stmt)); + if (NS_FAILED(rv)) return rv; + + bool hasResult; + rv = stmt->ExecuteStep(&hasResult); + if (NS_FAILED(rv)) return rv; + MOZ_ASSERT(hasResult); + int32_t bookmarkCount = stmt->AsInt32(0); + int32_t positionSum = stmt->AsInt32(1); + MOZ_ASSERT(bookmarkCount == 6 && positionSum == 10); +#endif + + return NS_OK; +} + +nsresult +Database::InitFunctions() +{ + MOZ_ASSERT(NS_IsMainThread()); + + nsresult rv = GetUnreversedHostFunction::create(mMainConn); + NS_ENSURE_SUCCESS(rv, rv); + rv = MatchAutoCompleteFunction::create(mMainConn); + NS_ENSURE_SUCCESS(rv, rv); + rv = CalculateFrecencyFunction::create(mMainConn); + NS_ENSURE_SUCCESS(rv, rv); + rv = GenerateGUIDFunction::create(mMainConn); + NS_ENSURE_SUCCESS(rv, rv); + rv = FixupURLFunction::create(mMainConn); + NS_ENSURE_SUCCESS(rv, rv); + rv = FrecencyNotificationFunction::create(mMainConn); + NS_ENSURE_SUCCESS(rv, rv); + rv = StoreLastInsertedIdFunction::create(mMainConn); + NS_ENSURE_SUCCESS(rv, rv); + rv = HashFunction::create(mMainConn); + NS_ENSURE_SUCCESS(rv, rv); + + return NS_OK; +} + +nsresult +Database::InitTempEntities() +{ + MOZ_ASSERT(NS_IsMainThread()); + + nsresult rv = mMainConn->ExecuteSimpleSQL(CREATE_HISTORYVISITS_AFTERINSERT_TRIGGER); + NS_ENSURE_SUCCESS(rv, rv); + rv = mMainConn->ExecuteSimpleSQL(CREATE_HISTORYVISITS_AFTERDELETE_TRIGGER); + NS_ENSURE_SUCCESS(rv, rv); + + // Add the triggers that update the moz_hosts table as necessary. + rv = mMainConn->ExecuteSimpleSQL(CREATE_PLACES_AFTERINSERT_TRIGGER); + NS_ENSURE_SUCCESS(rv, rv); + rv = mMainConn->ExecuteSimpleSQL(CREATE_UPDATEHOSTS_TEMP); + NS_ENSURE_SUCCESS(rv, rv); + rv = mMainConn->ExecuteSimpleSQL(CREATE_UPDATEHOSTS_AFTERDELETE_TRIGGER); + NS_ENSURE_SUCCESS(rv, rv); + rv = mMainConn->ExecuteSimpleSQL(CREATE_PLACES_AFTERDELETE_TRIGGER); + NS_ENSURE_SUCCESS(rv, rv); + rv = mMainConn->ExecuteSimpleSQL(CREATE_PLACES_AFTERUPDATE_FRECENCY_TRIGGER); + NS_ENSURE_SUCCESS(rv, rv); + rv = mMainConn->ExecuteSimpleSQL(CREATE_PLACES_AFTERUPDATE_TYPED_TRIGGER); + NS_ENSURE_SUCCESS(rv, rv); + + rv = mMainConn->ExecuteSimpleSQL(CREATE_BOOKMARKS_FOREIGNCOUNT_AFTERDELETE_TRIGGER); + NS_ENSURE_SUCCESS(rv, rv); + rv = mMainConn->ExecuteSimpleSQL(CREATE_BOOKMARKS_FOREIGNCOUNT_AFTERINSERT_TRIGGER); + NS_ENSURE_SUCCESS(rv, rv); + rv = mMainConn->ExecuteSimpleSQL(CREATE_BOOKMARKS_FOREIGNCOUNT_AFTERUPDATE_TRIGGER); + NS_ENSURE_SUCCESS(rv, rv); + + rv = mMainConn->ExecuteSimpleSQL(CREATE_KEYWORDS_FOREIGNCOUNT_AFTERDELETE_TRIGGER); + NS_ENSURE_SUCCESS(rv, rv); + rv = mMainConn->ExecuteSimpleSQL(CREATE_KEYWORDS_FOREIGNCOUNT_AFTERINSERT_TRIGGER); + NS_ENSURE_SUCCESS(rv, rv); + rv = mMainConn->ExecuteSimpleSQL(CREATE_KEYWORDS_FOREIGNCOUNT_AFTERUPDATE_TRIGGER); + NS_ENSURE_SUCCESS(rv, rv); + + return NS_OK; +} + +nsresult +Database::UpdateBookmarkRootTitles() +{ + MOZ_ASSERT(NS_IsMainThread()); + + nsCOMPtr<nsIStringBundleService> bundleService = + services::GetStringBundleService(); + NS_ENSURE_STATE(bundleService); + + nsCOMPtr<nsIStringBundle> bundle; + nsresult rv = bundleService->CreateBundle(PLACES_BUNDLE, getter_AddRefs(bundle)); + if (NS_FAILED(rv)) return rv; + + nsCOMPtr<mozIStorageAsyncStatement> stmt; + rv = mMainConn->CreateAsyncStatement(NS_LITERAL_CSTRING( + "UPDATE moz_bookmarks SET title = :new_title WHERE guid = :guid" + ), getter_AddRefs(stmt)); + if (NS_FAILED(rv)) return rv; + + nsCOMPtr<mozIStorageBindingParamsArray> paramsArray; + rv = stmt->NewBindingParamsArray(getter_AddRefs(paramsArray)); + if (NS_FAILED(rv)) return rv; + + const char *rootGuids[] = { "menu________" + , "toolbar_____" + , "tags________" + , "unfiled_____" + , "mobile______" + }; + const char *titleStringIDs[] = { "BookmarksMenuFolderTitle" + , "BookmarksToolbarFolderTitle" + , "TagsFolderTitle" + , "OtherBookmarksFolderTitle" + , "MobileBookmarksFolderTitle" + }; + + for (uint32_t i = 0; i < ArrayLength(rootGuids); ++i) { + nsXPIDLString title; + rv = bundle->GetStringFromName(NS_ConvertASCIItoUTF16(titleStringIDs[i]).get(), + getter_Copies(title)); + if (NS_FAILED(rv)) return rv; + + nsCOMPtr<mozIStorageBindingParams> params; + rv = paramsArray->NewBindingParams(getter_AddRefs(params)); + if (NS_FAILED(rv)) return rv; + rv = params->BindUTF8StringByName(NS_LITERAL_CSTRING("guid"), + nsDependentCString(rootGuids[i])); + if (NS_FAILED(rv)) return rv; + rv = params->BindUTF8StringByName(NS_LITERAL_CSTRING("new_title"), + NS_ConvertUTF16toUTF8(title)); + if (NS_FAILED(rv)) return rv; + rv = paramsArray->AddParams(params); + if (NS_FAILED(rv)) return rv; + } + + rv = stmt->BindParameters(paramsArray); + if (NS_FAILED(rv)) return rv; + nsCOMPtr<mozIStoragePendingStatement> pendingStmt; + rv = stmt->ExecuteAsync(nullptr, getter_AddRefs(pendingStmt)); + if (NS_FAILED(rv)) return rv; + + return NS_OK; +} + +nsresult +Database::MigrateV13Up() +{ + MOZ_ASSERT(NS_IsMainThread()); + + // Dynamic containers are no longer supported. + nsCOMPtr<mozIStorageAsyncStatement> deleteDynContainersStmt; + nsresult rv = mMainConn->CreateAsyncStatement(NS_LITERAL_CSTRING( + "DELETE FROM moz_bookmarks WHERE type = :item_type"), + getter_AddRefs(deleteDynContainersStmt)); + rv = deleteDynContainersStmt->BindInt32ByName( + NS_LITERAL_CSTRING("item_type"), + nsINavBookmarksService::TYPE_DYNAMIC_CONTAINER + ); + NS_ENSURE_SUCCESS(rv, rv); + nsCOMPtr<mozIStoragePendingStatement> ps; + rv = deleteDynContainersStmt->ExecuteAsync(nullptr, getter_AddRefs(ps)); + NS_ENSURE_SUCCESS(rv, rv); + + return NS_OK; +} + +nsresult +Database::MigrateV15Up() +{ + MOZ_ASSERT(NS_IsMainThread()); + + // Drop moz_bookmarks_beforedelete_v1_trigger, since it's more expensive than + // useful. + nsresult rv = mMainConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING( + "DROP TRIGGER IF EXISTS moz_bookmarks_beforedelete_v1_trigger" + )); + NS_ENSURE_SUCCESS(rv, rv); + + // Remove any orphan keywords. + rv = mMainConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING( + "DELETE FROM moz_keywords " + "WHERE NOT EXISTS ( " + "SELECT id " + "FROM moz_bookmarks " + "WHERE keyword_id = moz_keywords.id " + ")" + )); + NS_ENSURE_SUCCESS(rv, rv); + + return NS_OK; +} + +nsresult +Database::MigrateV17Up() +{ + MOZ_ASSERT(NS_IsMainThread()); + + bool tableExists = false; + + nsresult rv = mMainConn->TableExists(NS_LITERAL_CSTRING("moz_hosts"), &tableExists); + NS_ENSURE_SUCCESS(rv, rv); + + if (!tableExists) { + // For anyone who used in-development versions of this autocomplete, + // drop the old tables and its indexes. + rv = mMainConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING( + "DROP INDEX IF EXISTS moz_hostnames_frecencyindex" + )); + NS_ENSURE_SUCCESS(rv, rv); + rv = mMainConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING( + "DROP TABLE IF EXISTS moz_hostnames" + )); + NS_ENSURE_SUCCESS(rv, rv); + + // Add the moz_hosts table so we can get hostnames for URL autocomplete. + rv = mMainConn->ExecuteSimpleSQL(CREATE_MOZ_HOSTS); + NS_ENSURE_SUCCESS(rv, rv); + } + + // Fill the moz_hosts table with all the domains in moz_places. + nsCOMPtr<mozIStorageAsyncStatement> fillHostsStmt; + rv = mMainConn->CreateAsyncStatement(NS_LITERAL_CSTRING( + "INSERT OR IGNORE INTO moz_hosts (host, frecency) " + "SELECT fixup_url(get_unreversed_host(h.rev_host)) AS host, " + "(SELECT MAX(frecency) FROM moz_places " + "WHERE rev_host = h.rev_host " + "OR rev_host = h.rev_host || 'www.' " + ") AS frecency " + "FROM moz_places h " + "WHERE LENGTH(h.rev_host) > 1 " + "GROUP BY h.rev_host" + ), getter_AddRefs(fillHostsStmt)); + NS_ENSURE_SUCCESS(rv, rv); + + nsCOMPtr<mozIStoragePendingStatement> ps; + rv = fillHostsStmt->ExecuteAsync(nullptr, getter_AddRefs(ps)); + NS_ENSURE_SUCCESS(rv, rv); + + return NS_OK; +} + +nsresult +Database::MigrateV18Up() +{ + MOZ_ASSERT(NS_IsMainThread()); + + // moz_hosts should distinguish on typed entries. + + // Check if the profile already has a typed column. + nsCOMPtr<mozIStorageStatement> stmt; + nsresult rv = mMainConn->CreateStatement(NS_LITERAL_CSTRING( + "SELECT typed FROM moz_hosts" + ), getter_AddRefs(stmt)); + if (NS_FAILED(rv)) { + rv = mMainConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING( + "ALTER TABLE moz_hosts ADD COLUMN typed NOT NULL DEFAULT 0" + )); + NS_ENSURE_SUCCESS(rv, rv); + } + + // With the addition of the typed column the covering index loses its + // advantages. On the other side querying on host and (optionally) typed + // largely restricts the number of results, making scans decently fast. + rv = mMainConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING( + "DROP INDEX IF EXISTS moz_hosts_frecencyhostindex" + )); + NS_ENSURE_SUCCESS(rv, rv); + + // Update typed data. + nsCOMPtr<mozIStorageAsyncStatement> updateTypedStmt; + rv = mMainConn->CreateAsyncStatement(NS_LITERAL_CSTRING( + "UPDATE moz_hosts SET typed = 1 WHERE host IN ( " + "SELECT fixup_url(get_unreversed_host(rev_host)) " + "FROM moz_places WHERE typed = 1 " + ") " + ), getter_AddRefs(updateTypedStmt)); + NS_ENSURE_SUCCESS(rv, rv); + + nsCOMPtr<mozIStoragePendingStatement> ps; + rv = updateTypedStmt->ExecuteAsync(nullptr, getter_AddRefs(ps)); + NS_ENSURE_SUCCESS(rv, rv); + + return NS_OK; +} + +nsresult +Database::MigrateV19Up() +{ + MOZ_ASSERT(NS_IsMainThread()); + + // Livemarks children are no longer bookmarks. + + // Remove all children of folders annotated as livemarks. + nsCOMPtr<mozIStorageStatement> deleteLivemarksChildrenStmt; + nsresult rv = mMainConn->CreateStatement(NS_LITERAL_CSTRING( + "DELETE FROM moz_bookmarks WHERE parent IN(" + "SELECT b.id FROM moz_bookmarks b " + "JOIN moz_items_annos a ON a.item_id = b.id " + "JOIN moz_anno_attributes n ON n.id = a.anno_attribute_id " + "WHERE b.type = :item_type AND n.name = :anno_name " + ")" + ), getter_AddRefs(deleteLivemarksChildrenStmt)); + NS_ENSURE_SUCCESS(rv, rv); + rv = deleteLivemarksChildrenStmt->BindUTF8StringByName( + NS_LITERAL_CSTRING("anno_name"), NS_LITERAL_CSTRING(LMANNO_FEEDURI) + ); + NS_ENSURE_SUCCESS(rv, rv); + rv = deleteLivemarksChildrenStmt->BindInt32ByName( + NS_LITERAL_CSTRING("item_type"), nsINavBookmarksService::TYPE_FOLDER + ); + NS_ENSURE_SUCCESS(rv, rv); + rv = deleteLivemarksChildrenStmt->Execute(); + NS_ENSURE_SUCCESS(rv, rv); + + // Clear obsolete livemark prefs. + (void)Preferences::ClearUser("browser.bookmarks.livemark_refresh_seconds"); + (void)Preferences::ClearUser("browser.bookmarks.livemark_refresh_limit_count"); + (void)Preferences::ClearUser("browser.bookmarks.livemark_refresh_delay_time"); + + // Remove the old status annotations. + nsCOMPtr<mozIStorageStatement> deleteLivemarksAnnosStmt; + rv = mMainConn->CreateStatement(NS_LITERAL_CSTRING( + "DELETE FROM moz_items_annos WHERE anno_attribute_id IN(" + "SELECT id FROM moz_anno_attributes " + "WHERE name IN (:anno_loading, :anno_loadfailed, :anno_expiration) " + ")" + ), getter_AddRefs(deleteLivemarksAnnosStmt)); + NS_ENSURE_SUCCESS(rv, rv); + rv = deleteLivemarksAnnosStmt->BindUTF8StringByName( + NS_LITERAL_CSTRING("anno_loading"), NS_LITERAL_CSTRING("livemark/loading") + ); + NS_ENSURE_SUCCESS(rv, rv); + rv = deleteLivemarksAnnosStmt->BindUTF8StringByName( + NS_LITERAL_CSTRING("anno_loadfailed"), NS_LITERAL_CSTRING("livemark/loadfailed") + ); + NS_ENSURE_SUCCESS(rv, rv); + rv = deleteLivemarksAnnosStmt->BindUTF8StringByName( + NS_LITERAL_CSTRING("anno_expiration"), NS_LITERAL_CSTRING("livemark/expiration") + ); + NS_ENSURE_SUCCESS(rv, rv); + rv = deleteLivemarksAnnosStmt->Execute(); + NS_ENSURE_SUCCESS(rv, rv); + + // Remove orphan annotation names. + rv = mMainConn->CreateStatement(NS_LITERAL_CSTRING( + "DELETE FROM moz_anno_attributes " + "WHERE name IN (:anno_loading, :anno_loadfailed, :anno_expiration) " + ), getter_AddRefs(deleteLivemarksAnnosStmt)); + NS_ENSURE_SUCCESS(rv, rv); + rv = deleteLivemarksAnnosStmt->BindUTF8StringByName( + NS_LITERAL_CSTRING("anno_loading"), NS_LITERAL_CSTRING("livemark/loading") + ); + NS_ENSURE_SUCCESS(rv, rv); + rv = deleteLivemarksAnnosStmt->BindUTF8StringByName( + NS_LITERAL_CSTRING("anno_loadfailed"), NS_LITERAL_CSTRING("livemark/loadfailed") + ); + NS_ENSURE_SUCCESS(rv, rv); + rv = deleteLivemarksAnnosStmt->BindUTF8StringByName( + NS_LITERAL_CSTRING("anno_expiration"), NS_LITERAL_CSTRING("livemark/expiration") + ); + NS_ENSURE_SUCCESS(rv, rv); + rv = deleteLivemarksAnnosStmt->Execute(); + NS_ENSURE_SUCCESS(rv, rv); + + return NS_OK; +} + +nsresult +Database::MigrateV20Up() +{ + MOZ_ASSERT(NS_IsMainThread()); + + // Remove obsolete bookmark GUID annotations. + nsCOMPtr<mozIStorageStatement> deleteOldBookmarkGUIDAnnosStmt; + nsresult rv = mMainConn->CreateStatement(NS_LITERAL_CSTRING( + "DELETE FROM moz_items_annos WHERE anno_attribute_id = (" + "SELECT id FROM moz_anno_attributes " + "WHERE name = :anno_guid" + ")" + ), getter_AddRefs(deleteOldBookmarkGUIDAnnosStmt)); + NS_ENSURE_SUCCESS(rv, rv); + rv = deleteOldBookmarkGUIDAnnosStmt->BindUTF8StringByName( + NS_LITERAL_CSTRING("anno_guid"), NS_LITERAL_CSTRING("placesInternal/GUID") + ); + NS_ENSURE_SUCCESS(rv, rv); + rv = deleteOldBookmarkGUIDAnnosStmt->Execute(); + NS_ENSURE_SUCCESS(rv, rv); + + // Remove the orphan annotation name. + rv = mMainConn->CreateStatement(NS_LITERAL_CSTRING( + "DELETE FROM moz_anno_attributes " + "WHERE name = :anno_guid" + ), getter_AddRefs(deleteOldBookmarkGUIDAnnosStmt)); + NS_ENSURE_SUCCESS(rv, rv); + rv = deleteOldBookmarkGUIDAnnosStmt->BindUTF8StringByName( + NS_LITERAL_CSTRING("anno_guid"), NS_LITERAL_CSTRING("placesInternal/GUID") + ); + NS_ENSURE_SUCCESS(rv, rv); + rv = deleteOldBookmarkGUIDAnnosStmt->Execute(); + NS_ENSURE_SUCCESS(rv, rv); + + return NS_OK; +} + +nsresult +Database::MigrateV21Up() +{ + MOZ_ASSERT(NS_IsMainThread()); + + // Add a prefix column to moz_hosts. + nsCOMPtr<mozIStorageStatement> stmt; + nsresult rv = mMainConn->CreateStatement(NS_LITERAL_CSTRING( + "SELECT prefix FROM moz_hosts" + ), getter_AddRefs(stmt)); + if (NS_FAILED(rv)) { + rv = mMainConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING( + "ALTER TABLE moz_hosts ADD COLUMN prefix" + )); + NS_ENSURE_SUCCESS(rv, rv); + } + + return NS_OK; +} + +nsresult +Database::MigrateV22Up() +{ + MOZ_ASSERT(NS_IsMainThread()); + + // Reset all session IDs to 0 since we don't support them anymore. + // We don't set them to NULL to avoid breaking downgrades. + nsresult rv = mMainConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING( + "UPDATE moz_historyvisits SET session = 0" + )); + NS_ENSURE_SUCCESS(rv, rv); + + return NS_OK; +} + + +nsresult +Database::MigrateV23Up() +{ + MOZ_ASSERT(NS_IsMainThread()); + + // Recalculate hosts prefixes. + nsCOMPtr<mozIStorageAsyncStatement> updatePrefixesStmt; + nsresult rv = mMainConn->CreateAsyncStatement(NS_LITERAL_CSTRING( + "UPDATE moz_hosts SET prefix = ( " HOSTS_PREFIX_PRIORITY_FRAGMENT ") " + ), getter_AddRefs(updatePrefixesStmt)); + NS_ENSURE_SUCCESS(rv, rv); + + nsCOMPtr<mozIStoragePendingStatement> ps; + rv = updatePrefixesStmt->ExecuteAsync(nullptr, getter_AddRefs(ps)); + NS_ENSURE_SUCCESS(rv, rv); + + return NS_OK; +} + +nsresult +Database::MigrateV24Up() +{ + MOZ_ASSERT(NS_IsMainThread()); + + // Add a foreign_count column to moz_places + nsCOMPtr<mozIStorageStatement> stmt; + nsresult rv = mMainConn->CreateStatement(NS_LITERAL_CSTRING( + "SELECT foreign_count FROM moz_places" + ), getter_AddRefs(stmt)); + if (NS_FAILED(rv)) { + rv = mMainConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING( + "ALTER TABLE moz_places ADD COLUMN foreign_count INTEGER DEFAULT 0 NOT NULL")); + NS_ENSURE_SUCCESS(rv, rv); + } + + // Adjust counts for all the rows + nsCOMPtr<mozIStorageStatement> updateStmt; + rv = mMainConn->CreateStatement(NS_LITERAL_CSTRING( + "UPDATE moz_places SET foreign_count = " + "(SELECT count(*) FROM moz_bookmarks WHERE fk = moz_places.id) " + ), getter_AddRefs(updateStmt)); + NS_ENSURE_SUCCESS(rv, rv); + mozStorageStatementScoper updateScoper(updateStmt); + rv = updateStmt->Execute(); + NS_ENSURE_SUCCESS(rv, rv); + + return NS_OK; +} + +nsresult +Database::MigrateV25Up() +{ + MOZ_ASSERT(NS_IsMainThread()); + + // Change bookmark roots GUIDs to constant values. + + // If moz_bookmarks_roots doesn't exist anymore, it's because we finally have + // been able to remove it. In such a case, we already assigned constant GUIDs + // to the roots and we can skip this migration. + { + nsCOMPtr<mozIStorageStatement> stmt; + nsresult rv = mMainConn->CreateStatement(NS_LITERAL_CSTRING( + "SELECT root_name FROM moz_bookmarks_roots" + ), getter_AddRefs(stmt)); + if (NS_FAILED(rv)) { + return NS_OK; + } + } + + nsCOMPtr<mozIStorageStatement> stmt; + nsresult rv = mMainConn->CreateStatement(NS_LITERAL_CSTRING( + "UPDATE moz_bookmarks SET guid = :guid " + "WHERE id = (SELECT folder_id FROM moz_bookmarks_roots WHERE root_name = :name) " + ), getter_AddRefs(stmt)); + NS_ENSURE_SUCCESS(rv, rv); + + const char *rootNames[] = { "places", "menu", "toolbar", "tags", "unfiled" }; + const char *rootGuids[] = { "root________" + , "menu________" + , "toolbar_____" + , "tags________" + , "unfiled_____" + }; + + for (uint32_t i = 0; i < ArrayLength(rootNames); ++i) { + // Since this is using the synchronous API, we cannot use + // a BindingParamsArray. + mozStorageStatementScoper scoper(stmt); + + rv = stmt->BindUTF8StringByName(NS_LITERAL_CSTRING("name"), + nsDependentCString(rootNames[i])); + NS_ENSURE_SUCCESS(rv, rv); + rv = stmt->BindUTF8StringByName(NS_LITERAL_CSTRING("guid"), + nsDependentCString(rootGuids[i])); + NS_ENSURE_SUCCESS(rv, rv); + + rv = stmt->Execute(); + NS_ENSURE_SUCCESS(rv, rv); + } + + return NS_OK; +} + +nsresult +Database::MigrateV26Up() { + MOZ_ASSERT(NS_IsMainThread()); + + // Round down dateAdded and lastModified values to milliseconds precision. + nsresult rv = mMainConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING( + "UPDATE moz_bookmarks SET dateAdded = dateAdded - dateAdded % 1000, " + " lastModified = lastModified - lastModified % 1000")); + NS_ENSURE_SUCCESS(rv, rv); + + return NS_OK; +} + +nsresult +Database::MigrateV27Up() { + MOZ_ASSERT(NS_IsMainThread()); + + // Change keywords store, moving their relation from bookmarks to urls. + nsCOMPtr<mozIStorageStatement> stmt; + nsresult rv = mMainConn->CreateStatement(NS_LITERAL_CSTRING( + "SELECT place_id FROM moz_keywords" + ), getter_AddRefs(stmt)); + if (NS_FAILED(rv)) { + // Even if these 2 columns have a unique constraint, we allow NULL values + // for backwards compatibility. NULL never breaks a unique constraint. + rv = mMainConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING( + "ALTER TABLE moz_keywords ADD COLUMN place_id INTEGER")); + NS_ENSURE_SUCCESS(rv, rv); + rv = mMainConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING( + "ALTER TABLE moz_keywords ADD COLUMN post_data TEXT")); + NS_ENSURE_SUCCESS(rv, rv); + rv = mMainConn->ExecuteSimpleSQL(CREATE_IDX_MOZ_KEYWORDS_PLACEPOSTDATA); + NS_ENSURE_SUCCESS(rv, rv); + } + + // Associate keywords with uris. A keyword could be associated to multiple + // bookmarks uris, or multiple keywords could be associated to the same uri. + // The new system only allows multiple uris per keyword, provided they have + // a different post_data value. + rv = mMainConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING( + "INSERT OR REPLACE INTO moz_keywords (id, keyword, place_id, post_data) " + "SELECT k.id, k.keyword, h.id, MAX(a.content) " + "FROM moz_places h " + "JOIN moz_bookmarks b ON b.fk = h.id " + "JOIN moz_keywords k ON k.id = b.keyword_id " + "LEFT JOIN moz_items_annos a ON a.item_id = b.id " + "AND a.anno_attribute_id = (SELECT id FROM moz_anno_attributes " + "WHERE name = 'bookmarkProperties/POSTData') " + "WHERE k.place_id ISNULL " + "GROUP BY keyword")); + NS_ENSURE_SUCCESS(rv, rv); + + // Remove any keyword that points to a non-existing place id. + rv = mMainConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING( + "DELETE FROM moz_keywords " + "WHERE NOT EXISTS (SELECT 1 FROM moz_places WHERE id = moz_keywords.place_id)")); + NS_ENSURE_SUCCESS(rv, rv); + rv = mMainConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING( + "UPDATE moz_bookmarks SET keyword_id = NULL " + "WHERE NOT EXISTS (SELECT 1 FROM moz_keywords WHERE id = moz_bookmarks.keyword_id)")); + NS_ENSURE_SUCCESS(rv, rv); + + // Adjust foreign_count for all the rows. + rv = mMainConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING( + "UPDATE moz_places SET foreign_count = " + "(SELECT count(*) FROM moz_bookmarks WHERE fk = moz_places.id) + " + "(SELECT count(*) FROM moz_keywords WHERE place_id = moz_places.id) " + )); + NS_ENSURE_SUCCESS(rv, rv); + + return NS_OK; +} + +nsresult +Database::MigrateV28Up() { + MOZ_ASSERT(NS_IsMainThread()); + + // v27 migration was bogus and set some unrelated annotations as post_data for + // keywords having an annotated bookmark. + // The current v27 migration function is fixed, but we still need to handle + // users that hit the bogus version. Since we can't distinguish, we'll just + // set again all of the post data. + DebugOnly<nsresult> rv = mMainConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING( + "UPDATE moz_keywords " + "SET post_data = ( " + "SELECT content FROM moz_items_annos a " + "JOIN moz_anno_attributes n ON n.id = a.anno_attribute_id " + "JOIN moz_bookmarks b on b.id = a.item_id " + "WHERE n.name = 'bookmarkProperties/POSTData' " + "AND b.keyword_id = moz_keywords.id " + "ORDER BY b.lastModified DESC " + "LIMIT 1 " + ") " + "WHERE EXISTS(SELECT 1 FROM moz_bookmarks WHERE keyword_id = moz_keywords.id) " + )); + // In case the update fails a constraint, we don't want to throw away the + // whole database for just a few keywords. In rare cases the user might have + // to recreate them. Though, at this point, there shouldn't be 2 keywords + // pointing to the same url and post data, cause the previous migration step + // removed them. + MOZ_ASSERT(NS_SUCCEEDED(rv)); + + return NS_OK; +} + +nsresult +Database::MigrateV30Up() { + MOZ_ASSERT(NS_IsMainThread()); + + nsresult rv = mMainConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING( + "DROP INDEX IF EXISTS moz_favicons_guid_uniqueindex" + )); + NS_ENSURE_SUCCESS(rv, rv); + + return NS_OK; +} + +nsresult +Database::MigrateV31Up() { + MOZ_ASSERT(NS_IsMainThread()); + + nsresult rv = mMainConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING( + "DROP TABLE IF EXISTS moz_bookmarks_roots" + )); + NS_ENSURE_SUCCESS(rv, rv); + + return NS_OK; +} + +nsresult +Database::MigrateV32Up() { + MOZ_ASSERT(NS_IsMainThread()); + + // Remove some old and no more used Places preferences that may be confusing + // for the user. + mozilla::Unused << Preferences::ClearUser("places.history.expiration.transient_optimal_database_size"); + mozilla::Unused << Preferences::ClearUser("places.last_vacuum"); + mozilla::Unused << Preferences::ClearUser("browser.history_expire_sites"); + mozilla::Unused << Preferences::ClearUser("browser.history_expire_days.mirror"); + mozilla::Unused << Preferences::ClearUser("browser.history_expire_days_min"); + + // For performance reasons we want to remove too long urls from history. + // We cannot use the moz_places triggers here, cause they are defined only + // after the schema migration. Thus we need to collect the hosts that need to + // be updated first. + nsresult rv = mMainConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING( + "CREATE TEMP TABLE moz_migrate_v32_temp (" + "host TEXT PRIMARY KEY " + ") WITHOUT ROWID " + )); + NS_ENSURE_SUCCESS(rv, rv); + { + nsCOMPtr<mozIStorageStatement> stmt; + rv = mMainConn->CreateStatement(NS_LITERAL_CSTRING( + "INSERT OR IGNORE INTO moz_migrate_v32_temp (host) " + "SELECT fixup_url(get_unreversed_host(rev_host)) " + "FROM moz_places WHERE LENGTH(url) > :maxlen AND foreign_count = 0" + ), getter_AddRefs(stmt)); + NS_ENSURE_SUCCESS(rv, rv); + mozStorageStatementScoper scoper(stmt); + rv = stmt->BindInt32ByName(NS_LITERAL_CSTRING("maxlen"), MaxUrlLength()); + NS_ENSURE_SUCCESS(rv, rv); + rv = stmt->Execute(); + NS_ENSURE_SUCCESS(rv, rv); + } + // Now remove the pages with a long url. + { + nsCOMPtr<mozIStorageStatement> stmt; + rv = mMainConn->CreateStatement(NS_LITERAL_CSTRING( + "DELETE FROM moz_places WHERE LENGTH(url) > :maxlen AND foreign_count = 0" + ), getter_AddRefs(stmt)); + NS_ENSURE_SUCCESS(rv, rv); + mozStorageStatementScoper scoper(stmt); + rv = stmt->BindInt32ByName(NS_LITERAL_CSTRING("maxlen"), MaxUrlLength()); + NS_ENSURE_SUCCESS(rv, rv); + rv = stmt->Execute(); + NS_ENSURE_SUCCESS(rv, rv); + } + + // Expire orphan visits and update moz_hosts. + // These may be a bit more expensive and are not critical for the DB + // functionality, so we execute them asynchronously. + nsCOMPtr<mozIStorageAsyncStatement> expireOrphansStmt; + rv = mMainConn->CreateAsyncStatement(NS_LITERAL_CSTRING( + "DELETE FROM moz_historyvisits " + "WHERE NOT EXISTS (SELECT 1 FROM moz_places WHERE id = place_id)" + ), getter_AddRefs(expireOrphansStmt)); + NS_ENSURE_SUCCESS(rv, rv); + nsCOMPtr<mozIStorageAsyncStatement> deleteHostsStmt; + rv = mMainConn->CreateAsyncStatement(NS_LITERAL_CSTRING( + "DELETE FROM moz_hosts " + "WHERE host IN (SELECT host FROM moz_migrate_v32_temp) " + "AND NOT EXISTS(" + "SELECT 1 FROM moz_places " + "WHERE rev_host = get_unreversed_host(host || '.') || '.' " + "OR rev_host = get_unreversed_host(host || '.') || '.www.' " + "); " + ), getter_AddRefs(deleteHostsStmt)); + NS_ENSURE_SUCCESS(rv, rv); + nsCOMPtr<mozIStorageAsyncStatement> updateHostsStmt; + rv = mMainConn->CreateAsyncStatement(NS_LITERAL_CSTRING( + "UPDATE moz_hosts " + "SET prefix = (" HOSTS_PREFIX_PRIORITY_FRAGMENT ") " + "WHERE host IN (SELECT host FROM moz_migrate_v32_temp) " + ), getter_AddRefs(updateHostsStmt)); + NS_ENSURE_SUCCESS(rv, rv); + nsCOMPtr<mozIStorageAsyncStatement> dropTableStmt; + rv = mMainConn->CreateAsyncStatement(NS_LITERAL_CSTRING( + "DROP TABLE IF EXISTS moz_migrate_v32_temp" + ), getter_AddRefs(dropTableStmt)); + NS_ENSURE_SUCCESS(rv, rv); + + mozIStorageBaseStatement *stmts[] = { + expireOrphansStmt, + deleteHostsStmt, + updateHostsStmt, + dropTableStmt + }; + nsCOMPtr<mozIStoragePendingStatement> ps; + rv = mMainConn->ExecuteAsync(stmts, ArrayLength(stmts), nullptr, + getter_AddRefs(ps)); + NS_ENSURE_SUCCESS(rv, rv); + + return NS_OK; +} + +nsresult +Database::MigrateV33Up() { + MOZ_ASSERT(NS_IsMainThread()); + + nsresult rv = mMainConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING( + "DROP INDEX IF EXISTS moz_places_url_uniqueindex" + )); + NS_ENSURE_SUCCESS(rv, rv); + + // Add an url_hash column to moz_places. + nsCOMPtr<mozIStorageStatement> stmt; + rv = mMainConn->CreateStatement(NS_LITERAL_CSTRING( + "SELECT url_hash FROM moz_places" + ), getter_AddRefs(stmt)); + if (NS_FAILED(rv)) { + rv = mMainConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING( + "ALTER TABLE moz_places ADD COLUMN url_hash INTEGER DEFAULT 0 NOT NULL" + )); + NS_ENSURE_SUCCESS(rv, rv); + } + + rv = mMainConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING( + "UPDATE moz_places SET url_hash = hash(url) WHERE url_hash = 0" + )); + NS_ENSURE_SUCCESS(rv, rv); + + // Create an index on url_hash. + rv = mMainConn->ExecuteSimpleSQL(CREATE_IDX_MOZ_PLACES_URL_HASH); + NS_ENSURE_SUCCESS(rv, rv); + + return NS_OK; +} + +nsresult +Database::MigrateV34Up() { + MOZ_ASSERT(NS_IsMainThread()); + + nsresult rv = mMainConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING( + "DELETE FROM moz_keywords WHERE id IN ( " + "SELECT id FROM moz_keywords k " + "WHERE NOT EXISTS (SELECT 1 FROM moz_places h WHERE k.place_id = h.id) " + ")" + )); + NS_ENSURE_SUCCESS(rv, rv); + + return NS_OK; +} + +nsresult +Database::MigrateV35Up() { + MOZ_ASSERT(NS_IsMainThread()); + + int64_t mobileRootId = CreateMobileRoot(); + if (mobileRootId <= 0) { + // Either the schema is broken or there isn't any root. The latter can + // happen if a consumer, for example Thunderbird, never used bookmarks. + // If there are no roots, this migration should not run. + nsCOMPtr<mozIStorageStatement> checkRootsStmt; + nsresult rv = mMainConn->CreateStatement(NS_LITERAL_CSTRING( + "SELECT id FROM moz_bookmarks WHERE parent = 0" + ), getter_AddRefs(checkRootsStmt)); + NS_ENSURE_SUCCESS(rv, rv); + mozStorageStatementScoper scoper(checkRootsStmt); + bool hasResult = false; + rv = checkRootsStmt->ExecuteStep(&hasResult); + if (NS_SUCCEEDED(rv) && !hasResult) { + return NS_OK; + } + return NS_ERROR_FAILURE; + } + + // At this point, we should have no more than two folders with the mobile + // bookmarks anno: the new root, and the old folder if one exists. If, for + // some reason, we have multiple folders with the anno, we append their + // children to the new root. + nsTArray<int64_t> folderIds; + nsresult rv = GetItemsWithAnno(NS_LITERAL_CSTRING(MOBILE_ROOT_ANNO), + nsINavBookmarksService::TYPE_FOLDER, + folderIds); + if (NS_FAILED(rv)) return rv; + + for (uint32_t i = 0; i < folderIds.Length(); ++i) { + if (folderIds[i] == mobileRootId) { + // Ignore the new mobile root. We'll remove this anno from the root in + // bug 1306445. + continue; + } + + // Append the folder's children to the new root. + nsCOMPtr<mozIStorageStatement> moveStmt; + rv = mMainConn->CreateStatement(NS_LITERAL_CSTRING( + "UPDATE moz_bookmarks " + "SET parent = :root_id, " + "position = position + IFNULL(" + "(SELECT MAX(position) + 1 FROM moz_bookmarks " + "WHERE parent = :root_id), 0)" + "WHERE parent = :folder_id" + ), getter_AddRefs(moveStmt)); + if (NS_FAILED(rv)) return rv; + mozStorageStatementScoper moveScoper(moveStmt); + + rv = moveStmt->BindInt64ByName(NS_LITERAL_CSTRING("root_id"), + mobileRootId); + if (NS_FAILED(rv)) return rv; + rv = moveStmt->BindInt64ByName(NS_LITERAL_CSTRING("folder_id"), + folderIds[i]); + if (NS_FAILED(rv)) return rv; + + rv = moveStmt->Execute(); + if (NS_FAILED(rv)) return rv; + + // Delete the old folder. + rv = DeleteBookmarkItem(folderIds[i]); + if (NS_FAILED(rv)) return rv; + } + + return NS_OK; +} + +nsresult +Database::GetItemsWithAnno(const nsACString& aAnnoName, int32_t aItemType, + nsTArray<int64_t>& aItemIds) +{ + nsCOMPtr<mozIStorageStatement> stmt; + nsresult rv = mMainConn->CreateStatement(NS_LITERAL_CSTRING( + "SELECT b.id FROM moz_items_annos a " + "JOIN moz_anno_attributes n ON n.id = a.anno_attribute_id " + "JOIN moz_bookmarks b ON b.id = a.item_id " + "WHERE n.name = :anno_name AND " + "b.type = :item_type" + ), getter_AddRefs(stmt)); + if (NS_FAILED(rv)) return rv; + mozStorageStatementScoper scoper(stmt); + + rv = stmt->BindUTF8StringByName(NS_LITERAL_CSTRING("anno_name"), aAnnoName); + if (NS_FAILED(rv)) return rv; + rv = stmt->BindInt64ByName(NS_LITERAL_CSTRING("item_type"), aItemType); + if (NS_FAILED(rv)) return rv; + + bool hasMore = false; + while (NS_SUCCEEDED(stmt->ExecuteStep(&hasMore)) && hasMore) { + int64_t itemId; + rv = stmt->GetInt64(0, &itemId); + if (NS_FAILED(rv)) return rv; + aItemIds.AppendElement(itemId); + } + + return NS_OK; +} + +nsresult +Database::DeleteBookmarkItem(int32_t aItemId) +{ + // Delete the old bookmark. + nsCOMPtr<mozIStorageStatement> deleteStmt; + nsresult rv = mMainConn->CreateStatement(NS_LITERAL_CSTRING( + "DELETE FROM moz_bookmarks WHERE id = :item_id" + ), getter_AddRefs(deleteStmt)); + if (NS_FAILED(rv)) return rv; + mozStorageStatementScoper deleteScoper(deleteStmt); + + rv = deleteStmt->BindInt64ByName(NS_LITERAL_CSTRING("item_id"), + aItemId); + if (NS_FAILED(rv)) return rv; + + rv = deleteStmt->Execute(); + if (NS_FAILED(rv)) return rv; + + // Clean up orphan annotations. + nsCOMPtr<mozIStorageStatement> removeAnnosStmt; + rv = mMainConn->CreateStatement(NS_LITERAL_CSTRING( + "DELETE FROM moz_items_annos WHERE item_id = :item_id" + ), getter_AddRefs(removeAnnosStmt)); + if (NS_FAILED(rv)) return rv; + mozStorageStatementScoper removeAnnosScoper(removeAnnosStmt); + + rv = removeAnnosStmt->BindInt64ByName(NS_LITERAL_CSTRING("item_id"), + aItemId); + if (NS_FAILED(rv)) return rv; + + rv = removeAnnosStmt->Execute(); + if (NS_FAILED(rv)) return rv; + + return NS_OK; +} + +int64_t +Database::CreateMobileRoot() +{ + MOZ_ASSERT(NS_IsMainThread()); + + // Create the mobile root, ignoring conflicts if one already exists (for + // example, if the user downgraded to an earlier release channel). + nsCOMPtr<mozIStorageStatement> createStmt; + nsresult rv = mMainConn->CreateStatement(NS_LITERAL_CSTRING( + "INSERT OR IGNORE INTO moz_bookmarks " + "(type, title, dateAdded, lastModified, guid, position, parent) " + "SELECT :item_type, :item_title, :timestamp, :timestamp, :guid, " + "(SELECT COUNT(*) FROM moz_bookmarks p WHERE p.parent = b.id), b.id " + "FROM moz_bookmarks b WHERE b.parent = 0" + ), getter_AddRefs(createStmt)); + if (NS_FAILED(rv)) return -1; + mozStorageStatementScoper createScoper(createStmt); + + rv = createStmt->BindInt32ByName(NS_LITERAL_CSTRING("item_type"), + nsINavBookmarksService::TYPE_FOLDER); + if (NS_FAILED(rv)) return -1; + rv = createStmt->BindUTF8StringByName(NS_LITERAL_CSTRING("item_title"), + NS_LITERAL_CSTRING(MOBILE_ROOT_TITLE)); + if (NS_FAILED(rv)) return -1; + rv = createStmt->BindInt64ByName(NS_LITERAL_CSTRING("timestamp"), + RoundedPRNow()); + if (NS_FAILED(rv)) return -1; + rv = createStmt->BindUTF8StringByName(NS_LITERAL_CSTRING("guid"), + NS_LITERAL_CSTRING(MOBILE_ROOT_GUID)); + if (NS_FAILED(rv)) return -1; + + rv = createStmt->Execute(); + if (NS_FAILED(rv)) return -1; + + // Find the mobile root ID. We can't use the last inserted ID because the + // root might already exist, and we ignore on conflict. + nsCOMPtr<mozIStorageStatement> findIdStmt; + rv = mMainConn->CreateStatement(NS_LITERAL_CSTRING( + "SELECT id FROM moz_bookmarks WHERE guid = :guid" + ), getter_AddRefs(findIdStmt)); + if (NS_FAILED(rv)) return -1; + mozStorageStatementScoper findIdScoper(findIdStmt); + + rv = findIdStmt->BindUTF8StringByName(NS_LITERAL_CSTRING("guid"), + NS_LITERAL_CSTRING(MOBILE_ROOT_GUID)); + if (NS_FAILED(rv)) return -1; + + bool hasResult = false; + rv = findIdStmt->ExecuteStep(&hasResult); + if (NS_FAILED(rv) || !hasResult) return -1; + + int64_t rootId; + rv = findIdStmt->GetInt64(0, &rootId); + if (NS_FAILED(rv)) return -1; + + // Set the mobile bookmarks anno on the new root, so that Sync code on an + // older channel can still find it in case of a downgrade. This can be + // removed in bug 1306445. + nsCOMPtr<mozIStorageStatement> addAnnoNameStmt; + rv = mMainConn->CreateStatement(NS_LITERAL_CSTRING( + "INSERT OR IGNORE INTO moz_anno_attributes (name) VALUES (:anno_name)" + ), getter_AddRefs(addAnnoNameStmt)); + if (NS_FAILED(rv)) return -1; + mozStorageStatementScoper addAnnoNameScoper(addAnnoNameStmt); + + rv = addAnnoNameStmt->BindUTF8StringByName( + NS_LITERAL_CSTRING("anno_name"), NS_LITERAL_CSTRING(MOBILE_ROOT_ANNO)); + if (NS_FAILED(rv)) return -1; + rv = addAnnoNameStmt->Execute(); + if (NS_FAILED(rv)) return -1; + + nsCOMPtr<mozIStorageStatement> addAnnoStmt; + rv = mMainConn->CreateStatement(NS_LITERAL_CSTRING( + "INSERT OR IGNORE INTO moz_items_annos " + "(id, item_id, anno_attribute_id, content, flags, " + "expiration, type, dateAdded, lastModified) " + "SELECT " + "(SELECT a.id FROM moz_items_annos a " + "WHERE a.anno_attribute_id = n.id AND " + "a.item_id = :root_id), " + ":root_id, n.id, 1, 0, :expiration, :type, :timestamp, :timestamp " + "FROM moz_anno_attributes n WHERE name = :anno_name" + ), getter_AddRefs(addAnnoStmt)); + if (NS_FAILED(rv)) return -1; + mozStorageStatementScoper addAnnoScoper(addAnnoStmt); + + rv = addAnnoStmt->BindInt64ByName(NS_LITERAL_CSTRING("root_id"), rootId); + if (NS_FAILED(rv)) return -1; + rv = addAnnoStmt->BindUTF8StringByName( + NS_LITERAL_CSTRING("anno_name"), NS_LITERAL_CSTRING(MOBILE_ROOT_ANNO)); + if (NS_FAILED(rv)) return -1; + rv = addAnnoStmt->BindInt32ByName(NS_LITERAL_CSTRING("expiration"), + nsIAnnotationService::EXPIRE_NEVER); + if (NS_FAILED(rv)) return -1; + rv = addAnnoStmt->BindInt32ByName(NS_LITERAL_CSTRING("type"), + nsIAnnotationService::TYPE_INT32); + if (NS_FAILED(rv)) return -1; + rv = addAnnoStmt->BindInt32ByName(NS_LITERAL_CSTRING("timestamp"), + RoundedPRNow()); + if (NS_FAILED(rv)) return -1; + + rv = addAnnoStmt->Execute(); + if (NS_FAILED(rv)) return -1; + + return rootId; +} + +void +Database::Shutdown() +{ + // As the last step in the shutdown path, finalize the database handle. + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(!mClosed); + + // Break cycles with the shutdown blockers. + mClientsShutdown = nullptr; + nsCOMPtr<mozIStorageCompletionCallback> connectionShutdown = mConnectionShutdown.forget(); + + if (!mMainConn) { + // The connection has never been initialized. Just mark it as closed. + mClosed = true; + (void)connectionShutdown->Complete(NS_OK, nullptr); + return; + } + +#ifdef DEBUG + { // Sanity check for missing guids. + bool haveNullGuids = false; + nsCOMPtr<mozIStorageStatement> stmt; + + nsresult rv = mMainConn->CreateStatement(NS_LITERAL_CSTRING( + "SELECT 1 " + "FROM moz_places " + "WHERE guid IS NULL " + ), getter_AddRefs(stmt)); + MOZ_ASSERT(NS_SUCCEEDED(rv)); + rv = stmt->ExecuteStep(&haveNullGuids); + MOZ_ASSERT(NS_SUCCEEDED(rv)); + MOZ_ASSERT(!haveNullGuids, "Found a page without a GUID!"); + + rv = mMainConn->CreateStatement(NS_LITERAL_CSTRING( + "SELECT 1 " + "FROM moz_bookmarks " + "WHERE guid IS NULL " + ), getter_AddRefs(stmt)); + MOZ_ASSERT(NS_SUCCEEDED(rv)); + rv = stmt->ExecuteStep(&haveNullGuids); + MOZ_ASSERT(NS_SUCCEEDED(rv)); + MOZ_ASSERT(!haveNullGuids, "Found a bookmark without a GUID!"); + } + + { // Sanity check for unrounded dateAdded and lastModified values (bug + // 1107308). + bool hasUnroundedDates = false; + nsCOMPtr<mozIStorageStatement> stmt; + + nsresult rv = mMainConn->CreateStatement(NS_LITERAL_CSTRING( + "SELECT 1 " + "FROM moz_bookmarks " + "WHERE dateAdded % 1000 > 0 OR lastModified % 1000 > 0 LIMIT 1" + ), getter_AddRefs(stmt)); + MOZ_ASSERT(NS_SUCCEEDED(rv)); + rv = stmt->ExecuteStep(&hasUnroundedDates); + MOZ_ASSERT(NS_SUCCEEDED(rv)); + MOZ_ASSERT(!hasUnroundedDates, "Found unrounded dates!"); + } + + { // Sanity check url_hash + bool hasNullHash = false; + nsCOMPtr<mozIStorageStatement> stmt; + nsresult rv = mMainConn->CreateStatement(NS_LITERAL_CSTRING( + "SELECT 1 FROM moz_places WHERE url_hash = 0" + ), getter_AddRefs(stmt)); + MOZ_ASSERT(NS_SUCCEEDED(rv)); + rv = stmt->ExecuteStep(&hasNullHash); + MOZ_ASSERT(NS_SUCCEEDED(rv)); + MOZ_ASSERT(!hasNullHash, "Found a place without a hash!"); + } + + { // Sanity check unique urls + bool hasDupeUrls = false; + nsCOMPtr<mozIStorageStatement> stmt; + nsresult rv = mMainConn->CreateStatement(NS_LITERAL_CSTRING( + "SELECT 1 FROM moz_places GROUP BY url HAVING count(*) > 1 " + ), getter_AddRefs(stmt)); + MOZ_ASSERT(NS_SUCCEEDED(rv)); + rv = stmt->ExecuteStep(&hasDupeUrls); + MOZ_ASSERT(NS_SUCCEEDED(rv)); + MOZ_ASSERT(!hasDupeUrls, "Found a duplicate url!"); + } +#endif + + mMainThreadStatements.FinalizeStatements(); + mMainThreadAsyncStatements.FinalizeStatements(); + + RefPtr< FinalizeStatementCacheProxy<mozIStorageStatement> > event = + new FinalizeStatementCacheProxy<mozIStorageStatement>( + mAsyncThreadStatements, + NS_ISUPPORTS_CAST(nsIObserver*, this) + ); + DispatchToAsyncThread(event); + + mClosed = true; + + (void)mMainConn->AsyncClose(connectionShutdown); +} + +//////////////////////////////////////////////////////////////////////////////// +//// nsIObserver + +NS_IMETHODIMP +Database::Observe(nsISupports *aSubject, + const char *aTopic, + const char16_t *aData) +{ + MOZ_ASSERT(NS_IsMainThread()); + if (strcmp(aTopic, TOPIC_PROFILE_CHANGE_TEARDOWN) == 0) { + // Tests simulating shutdown may cause multiple notifications. + if (IsShutdownStarted()) { + return NS_OK; + } + + nsCOMPtr<nsIObserverService> os = services::GetObserverService(); + NS_ENSURE_STATE(os); + + // If shutdown happens in the same mainthread loop as init, observers could + // handle the places-init-complete notification after xpcom-shutdown, when + // the connection does not exist anymore. Removing those observers would + // be less expensive but may cause their RemoveObserver calls to throw. + // Thus notify the topic now, so they stop listening for it. + nsCOMPtr<nsISimpleEnumerator> e; + if (NS_SUCCEEDED(os->EnumerateObservers(TOPIC_PLACES_INIT_COMPLETE, + getter_AddRefs(e))) && e) { + bool hasMore = false; + while (NS_SUCCEEDED(e->HasMoreElements(&hasMore)) && hasMore) { + nsCOMPtr<nsISupports> supports; + if (NS_SUCCEEDED(e->GetNext(getter_AddRefs(supports)))) { + nsCOMPtr<nsIObserver> observer = do_QueryInterface(supports); + (void)observer->Observe(observer, TOPIC_PLACES_INIT_COMPLETE, nullptr); + } + } + } + + // Notify all Places users that we are about to shutdown. + (void)os->NotifyObservers(nullptr, TOPIC_PLACES_SHUTDOWN, nullptr); + } else if (strcmp(aTopic, TOPIC_SIMULATE_PLACES_SHUTDOWN) == 0) { + // This notification is (and must be) only used by tests that are trying + // to simulate Places shutdown out of the normal shutdown path. + + // Tests simulating shutdown may cause re-entrance. + if (IsShutdownStarted()) { + return NS_OK; + } + + // We are simulating a shutdown, so invoke the shutdown blockers, + // wait for them, then proceed with connection shutdown. + // Since we are already going through shutdown, but it's not the real one, + // we won't need to block the real one anymore, so we can unblock it. + { + nsCOMPtr<nsIAsyncShutdownClient> shutdownPhase = GetProfileChangeTeardownPhase(); + if (shutdownPhase) { + shutdownPhase->RemoveBlocker(mClientsShutdown.get()); + } + (void)mClientsShutdown->BlockShutdown(nullptr); + } + + // Spin the events loop until the clients are done. + // Note, this is just for tests, specifically test_clearHistory_shutdown.js + while (mClientsShutdown->State() != PlacesShutdownBlocker::States::RECEIVED_DONE) { + (void)NS_ProcessNextEvent(); + } + + { + nsCOMPtr<nsIAsyncShutdownClient> shutdownPhase = GetProfileBeforeChangePhase(); + if (shutdownPhase) { + shutdownPhase->RemoveBlocker(mConnectionShutdown.get()); + } + (void)mConnectionShutdown->BlockShutdown(nullptr); + } + } + return NS_OK; +} + +uint32_t +Database::MaxUrlLength() { + MOZ_ASSERT(NS_IsMainThread()); + if (!mMaxUrlLength) { + mMaxUrlLength = Preferences::GetInt(PREF_HISTORY_MAXURLLEN, + PREF_HISTORY_MAXURLLEN_DEFAULT); + if (mMaxUrlLength < 255 || mMaxUrlLength > INT32_MAX) { + mMaxUrlLength = PREF_HISTORY_MAXURLLEN_DEFAULT; + } + } + return mMaxUrlLength; +} + + + +} // namespace places +} // namespace mozilla |