author Marco Bonardo <mbonardo@mozilla.com>

Mon, 14 Nov 2016 16:22:46 +0100

changeset 561149 4d25966596dcdf63c9c872425c5bf147406d25ac

parent 560921 f40e24f40b4c4556944c762d4764eace261297f5

child 561150 fa49c4a81d6ab6b34a2f19ee4175e889a6e9d734

push id 53651

push user mak77@bonardo.net

push date Wed, 12 Apr 2017 09:15:32 +0000

reviewers adw

bugs 977177

milestone 55.0a1

dom/push/PushRecord.jsm file | annotate | diff | comparison | revisions

toolkit/components/places/Database.cpp file | annotate | diff | comparison | revisions

toolkit/components/places/Database.h file | annotate | diff | comparison | revisions

toolkit/components/places/FaviconHelpers.cpp file | annotate | diff | comparison | revisions

toolkit/components/places/FaviconHelpers.h file | annotate | diff | comparison | revisions

toolkit/components/places/SQLFunctions.cpp file | annotate | diff | comparison | revisions

toolkit/components/places/nsFaviconService.cpp file | annotate | diff | comparison | revisions

toolkit/components/places/nsFaviconService.h file | annotate | diff | comparison | revisions

toolkit/components/places/nsPlacesExpiration.js file | annotate | diff | comparison | revisions

toolkit/components/places/nsPlacesIndexes.h file | annotate | diff | comparison | revisions

toolkit/components/places/nsPlacesTables.h file | annotate | diff | comparison | revisions

toolkit/components/places/nsPlacesTriggers.h file | annotate | diff | comparison | revisions

toolkit/components/places/tests/head_common.js file | annotate | diff | comparison | revisions

toolkit/components/places/tests/migration/places_v36.sqlite file | annotate | diff | comparison | revisions

toolkit/components/places/tests/migration/places_v37.sqlite file | annotate | diff | comparison | revisions

toolkit/components/places/tests/migration/test_current_from_v36.js file | annotate | diff | comparison | revisions

toolkit/components/places/tests/migration/xpcshell.ini file | annotate | diff | comparison | revisions
--- a/dom/push/PushRecord.jsm
+++ b/dom/push/PushRecord.jsm
@@ -158,17 +158,17 @@ PushRecord.prototype = {
       Ci.nsINavHistoryService.TRANSITION_REDIRECT_PERMANENT,
       Ci.nsINavHistoryService.TRANSITION_REDIRECT_TEMPORARY
     ].join(",");
 
     let db =  yield PlacesUtils.promiseDBConnection();
     // We're using a custom query instead of `nsINavHistoryQueryOptions`
     // because the latter doesn't expose a way to filter by transition type:
     // `setTransitions` performs a logical "and," but we want an "or." We
-    // also avoid an unneeded left join on `moz_favicons`, and an `ORDER BY`
+    // also avoid an unneeded left join with favicons, and an `ORDER BY`
     // clause that emits a suboptimal index warning.
     let rows = yield db.executeCached(
       `SELECT MAX(visit_date) AS lastVisit
        FROM moz_places p
        JOIN moz_historyvisits ON p.id = place_id
        WHERE rev_host = get_unreversed_host(:host || '.') || '.'
          AND url BETWEEN :prePath AND :prePath || X'FFFF'
          AND visit_type IN (${QUOTA_REFRESH_TRANSITIONS_SQL})
--- a/toolkit/components/places/Database.cpp
+++ b/toolkit/components/places/Database.cpp
@@ -18,16 +18,17 @@
 #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 "nsFaviconService.h"
 
 #include "nsAppDirectoryServiceDefs.h"
 #include "nsDirectoryServiceUtils.h"
 #include "prenv.h"
 #include "prsystem.h"
 #include "nsPrintfCString.h"
 #include "mozilla/Preferences.h"
 #include "mozilla/Services.h"
@@ -38,16 +39,18 @@
 
 // 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")
+// Filename of the icons database.
+#define DATABASE_FAVICONS_FILENAME NS_LITERAL_STRING("favicons.sqlite")
 
 // 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
@@ -199,17 +202,17 @@ updateSQLiteStatistics(mozIStorageConnec
  * @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)
+               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:
@@ -222,18 +225,17 @@ SetJournalMode(nsCOMPtr<mozIStorageConne
       journalMode.AssignLiteral("memory");
       break;
     case JOURNAL_WAL:
       journalMode.AssignLiteral("wal");
       break;
   }
 
   nsCOMPtr<mozIStorageStatement> statement;
-  nsAutoCString query(MOZ_STORAGE_UNIQUIFY_QUERY_STR
-		      "PRAGMA journal_mode = ");
+  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")) {
@@ -306,16 +308,97 @@ CreateRoot(nsCOMPtr<mozIStorageConnectio
   // 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;
 }
 
+nsresult
+SetupDurability(nsCOMPtr<mozIStorageConnection>& aDBConn, int32_t aDBPageSize) {
+  nsresult 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(aDBConn, JOURNAL_MEMORY);
+    rv = aDBConn->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(aDBConn, 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 / aDBPageSize);
+      nsAutoCString checkpointPragma("PRAGMA wal_autocheckpoint = ");
+      checkpointPragma.AppendInt(checkpointPages);
+      rv = aDBConn->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(aDBConn, JOURNAL_TRUNCATE);
+
+      // Set synchronous to FULL to ensure maximum data integrity, even in
+      // case of crashes or unclean shutdowns.
+      rv = aDBConn->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)aDBConn->ExecuteSimpleSQL(journalSizePragma);
+
+  // Grow places in |growthIncrementKiB| increments to limit fragmentation on disk.
+  // By default, it's 5 MB.
+  int32_t growthIncrementKiB =
+    Preferences::GetInt(PREF_GROWTH_INCREMENT_KIB, 5 * BYTES_PER_KIBIBYTE);
+  if (growthIncrementKiB > 0) {
+    (void)aDBConn->SetGrowthIncrement(growthIncrementKiB * BYTES_PER_KIBIBYTE, EmptyCString());
+  }
+  return NS_OK;
+}
+
+nsresult
+AttachFaviconsDatabase(nsCOMPtr<mozIStorageConnection>& aDBConn) {
+  // Attach the favicons database to the main connection.
+  nsString path;
+  nsCOMPtr<nsIFile> file;
+  nsresult rv = NS_GetSpecialDirectory(NS_APP_USER_PROFILE_50_DIR, getter_AddRefs(file));
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = file->Append(DATABASE_FAVICONS_FILENAME);
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = file->GetPath(path);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = aDBConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING("ATTACH DATABASE '") +
+    NS_ConvertUTF16toUTF8(path) + NS_LITERAL_CSTRING("' AS favicons"));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = aDBConn->ExecuteSimpleSQL(CREATE_ICONS_AFTERINSERT_TRIGGER);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return NS_OK;
+}
 
 } // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 //// Database
 
 PLACES_FACTORY_SINGLETON_IMPLEMENTATION(Database, gDatabase)
 
@@ -464,16 +547,24 @@ Database::Init()
   // 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 icons database.
+  rv = InitFaviconsDatabaseFile(storage);
+  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);
@@ -542,16 +633,98 @@ Database::Init()
   if (os) {
     (void)os->AddObserver(this, TOPIC_PROFILE_CHANGE_TEARDOWN, true);
   }
 
   return NS_OK;
 }
 
 nsresult
+Database::InitFaviconsDatabaseFile(nsCOMPtr<mozIStorageService>& aStorage)
+{
+  MOZ_ASSERT(NS_IsMainThread());
+
+  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_FAVICONS_FILENAME);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  bool databaseFileExists = false;
+  rv = databaseFile->Exists(&databaseFileExists);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // 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.
+  // This also checks the database sanity, so we must do it regardless.
+  nsCOMPtr<mozIStorageConnection> conn;
+  rv = aStorage->OpenUnsharedDatabase(databaseFile, getter_AddRefs(conn));
+  if (rv == NS_ERROR_FILE_CORRUPTED) {
+    rv = databaseFile->Remove(true);
+    NS_ENSURE_SUCCESS(rv, rv);
+    databaseFileExists = false;
+    rv = aStorage->OpenUnsharedDatabase(databaseFile, getter_AddRefs(conn));
+  }
+  NS_ENSURE_SUCCESS(rv, rv);
+
+#define CLOSE_AND_BAILOUT_IF_FAILED(_rv)          \
+  PR_BEGIN_MACRO                                  \
+  if (NS_WARN_IF(NS_FAILED(_rv))) {               \
+    MOZ_ALWAYS_TRUE(NS_SUCCEEDED(conn->Close())); \
+    return _rv;                                   \
+  }                                               \
+  PR_END_MACRO
+
+  if (!databaseFileExists) {
+    int32_t defaultPageSize;
+    rv = conn->GetDefaultPageSize(&defaultPageSize);
+    CLOSE_AND_BAILOUT_IF_FAILED(rv);
+    rv = SetupDurability(conn, defaultPageSize);
+    CLOSE_AND_BAILOUT_IF_FAILED(rv);
+
+    // Enable incremental vacuum for this database. Since it will contain even
+    // large blobs and can be cleared with history, it's worth to have it.
+    // Note that it will be necessary to manually use PRAGMA incremental_vacuum.
+    rv = conn->ExecuteSimpleSQL(NS_LITERAL_CSTRING(
+      "PRAGMA auto_vacuum = INCREMENTAL"
+    ));
+    CLOSE_AND_BAILOUT_IF_FAILED(rv);
+
+    // We are going to update the database, so everything from now on should be
+    // in a transaction for performances.
+    mozStorageTransaction transaction(conn, false);
+
+    rv = conn->ExecuteSimpleSQL(CREATE_MOZ_ICONS);
+    CLOSE_AND_BAILOUT_IF_FAILED(rv);
+    rv = conn->ExecuteSimpleSQL(CREATE_IDX_MOZ_ICONS_ICONURLHASH);
+    CLOSE_AND_BAILOUT_IF_FAILED(rv);
+
+    rv = conn->ExecuteSimpleSQL(CREATE_MOZ_PAGES_W_ICONS);
+    CLOSE_AND_BAILOUT_IF_FAILED(rv);
+    rv = conn->ExecuteSimpleSQL(CREATE_IDX_MOZ_PAGES_W_ICONS_ICONURLHASH);
+    CLOSE_AND_BAILOUT_IF_FAILED(rv);
+
+    rv = conn->ExecuteSimpleSQL(CREATE_MOZ_ICONS_TO_PAGES);
+    CLOSE_AND_BAILOUT_IF_FAILED(rv);
+
+    rv = transaction.Commit();
+    CLOSE_AND_BAILOUT_IF_FAILED(rv);
+  }
+
+#undef CLOSE_AND_BAILOUT_IF_FAILED
+
+  rv = conn->Close();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  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,
@@ -652,78 +825,52 @@ Database::InitSchema(bool* aDatabaseMigr
     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"));
+    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());
-  }
+  rv = SetupDurability(mMainConn, mDBPageSize);
+  NS_ENSURE_SUCCESS(rv, rv);
 
   nsAutoCString busyTimeoutPragma("PRAGMA busy_timeout = ");
   busyTimeoutPragma.AppendInt(DATABASE_BUSY_TIMEOUT_MS);
   (void)mMainConn->ExecuteSimpleSQL(busyTimeoutPragma);
 
+  // Enable FOREIGN KEY support.
+  rv = mMainConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING(
+    MOZ_STORAGE_UNIQUIFY_QUERY_STR "PRAGMA foreign_keys = ON")
+  );
+  NS_ENSURE_SUCCESS(rv, rv);
+#ifdef DEBUG
+  {
+    // There are a few cases where setting foreign_keys doesn't work:
+    //  * in the middle of a multi-statement transaction
+    //  * if the SQLite library in use doesn't support them
+    // Since we need foreign_keys, let's at least assert in debug mode.
+    nsCOMPtr<mozIStorageStatement> stmt;
+    mMainConn->CreateStatement(NS_LITERAL_CSTRING("PRAGMA foreign_keys"),
+                            getter_AddRefs(stmt));
+    bool hasResult = false;
+    if (stmt && NS_SUCCEEDED(stmt->ExecuteStep(&hasResult)) && hasResult) {
+      int32_t fkState = stmt->AsInt32(0);
+      MOZ_ASSERT(fkState, "Foreign keys should be enabled");
+    }
+  }
+#endif
+
+  rv = AttachFaviconsDatabase(mMainConn);
+  NS_ENSURE_SUCCESS(rv, rv);
+
   // 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(&currentSchemaVersion);
   NS_ENSURE_SUCCESS(rv, rv);
@@ -893,17 +1040,22 @@ Database::InitSchema(bool* aDatabaseMigr
 
       // Firefox 52 uses schema version 35.
 
       if (currentSchemaVersion < 36) {
         rv = MigrateV36Up();
         NS_ENSURE_SUCCESS(rv, rv);
       }
 
-      // Firefox 53 uses schema version 36.
+      if (currentSchemaVersion < 37) {
+        rv = MigrateV37Up();
+        NS_ENSURE_SUCCESS(rv, rv);
+      }
+
+      // Firefox 55 uses schema version 37.
 
       // 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));
     }
@@ -911,18 +1063,16 @@ Database::InitSchema(bool* aDatabaseMigr
   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);
@@ -962,20 +1112,16 @@ Database::InitSchema(bool* aDatabaseMigr
     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);
@@ -1511,20 +1657,26 @@ Database::MigrateV21Up()
 
 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);
+  nsCOMPtr<mozIStorageStatement> stmt;
+  nsresult rv = mMainConn->CreateStatement(NS_LITERAL_CSTRING(
+    "SELECT session FROM moz_historyvisits"
+  ), getter_AddRefs(stmt));
+  if (NS_SUCCEEDED(rv)) {
+    nsresult rv = mMainConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING(
+      "UPDATE moz_historyvisits SET session = 0"
+    ));
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
 
   return NS_OK;
 }
 
 
 nsresult
 Database::MigrateV23Up()
 {
@@ -1999,16 +2151,91 @@ Database::MigrateV36Up() {
     rv = mMainConn->ExecuteSimpleSQL(CREATE_MOZ_BOOKMARKS_DELETED);
     NS_ENSURE_SUCCESS(rv, rv);
   }
 
   return NS_OK;
 }
 
 nsresult
+Database::MigrateV37Up() {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  // Move favicons to the new database.
+  // For now we retain the old moz_favicons table, but we empty it.
+  // This allows for a "safer" downgrade, even if icons will be lost in the
+  // process. In a couple versions we shall drop moz_favicons completely.
+
+  // First, check if the old favicons table still exists.
+  nsCOMPtr<mozIStorageStatement> stmt;
+  nsresult rv = mMainConn->CreateStatement(NS_LITERAL_CSTRING(
+    "SELECT url FROM moz_favicons"
+  ), getter_AddRefs(stmt));
+  if (NS_FAILED(rv)) {
+    // The table has already been removed, nothing to do.
+    return NS_OK;
+  }
+
+  // The new table accepts only png or svg payloads, so we set a valid width
+  // only for them, the mime-type for the others.  Later we will asynchronously
+  // try to convert the unsupported payloads, or remove them.
+
+  // Add pages.
+  rv = mMainConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING(
+    "INSERT INTO moz_pages_w_icons (page_url, page_url_hash) "
+    "SELECT h.url, hash(h.url) "
+    "FROM moz_places h "
+    "JOIN moz_favicons f ON f.id = h.favicon_id"
+  ));
+  NS_ENSURE_SUCCESS(rv, rv);
+  // Set icons as expired, so we will replace them with proper versions at the
+  // first load.
+  // Note: we use a peculiarity of Sqlite here, where the column affinity
+  // is not enforced, thanks to that we can store a string in an integer column.
+  rv = mMainConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING(
+    "INSERT INTO moz_icons (icon_url, fixed_icon_url_hash, width, data) "
+      "SELECT url, hash(fixup_url(url)), "
+             "(CASE WHEN mime_type = 'image/png' THEN 16 "
+                   "WHEN mime_type = 'image/svg+xml' THEN 65535 "
+                   "ELSE mime_type END), "
+             "data FROM moz_favicons "
+             "WHERE LENGTH(data) > 0 "
+  ));
+  NS_ENSURE_SUCCESS(rv, rv);
+  // Create relations.
+  rv = mMainConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING(
+    "INSERT OR IGNORE INTO moz_icons_to_pages (page_id, icon_id) "
+      "SELECT (SELECT id FROM moz_pages_w_icons "
+              "WHERE page_url_hash = h.url_hash "
+                "AND page_url = h.url), "
+             "(SELECT id FROM moz_icons "
+              "WHERE fixed_icon_url_hash = hash(fixup_url(f.url)) "
+                "AND icon_url = f.url) "
+      "FROM moz_favicons f "
+      "JOIN moz_places h on f.id = h.favicon_id"
+  ));
+  NS_ENSURE_SUCCESS(rv, rv);
+  // Remove old favicons and relations.
+  rv = mMainConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING(
+    "DELETE FROM moz_favicons"
+  ));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = mMainConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING(
+    "UPDATE moz_places SET favicon_id = NULL"
+  ));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Start the async conversion
+  nsFaviconService::ConvertUnsupportedPayloads(mMainConn);
+
+  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 "
@@ -2300,17 +2527,17 @@ Database::Observe(nsISupports *aSubject,
     // 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;
+        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.
--- a/toolkit/components/places/Database.h
+++ b/toolkit/components/places/Database.h
@@ -13,17 +13,17 @@
 #include "mozilla/storage.h"
 #include "mozilla/storage/StatementCache.h"
 #include "mozilla/Attributes.h"
 #include "nsIEventTarget.h"
 #include "Shutdown.h"
 
 // This is the schema version. Update it at any schema change and add a
 // corresponding migrateVxx method below.
-#define DATABASE_SCHEMA_VERSION 36
+#define DATABASE_SCHEMA_VERSION 37
 
 // Fired after Places inited.
 #define TOPIC_PLACES_INIT_COMPLETE "places-init-complete"
 // Fired when initialization fails due to a locked database.
 #define TOPIC_DATABASE_LOCKED "places-database-locked"
 // This topic is received when the profile is about to be lost.  Places does
 // initial shutdown work and notifies TOPIC_PLACES_SHUTDOWN to all listeners.
 // Any shutdown work that requires the Places APIs should happen here.
@@ -211,16 +211,25 @@ protected:
    *        mozStorage service instance.
    * @param aNewDatabaseCreated
    *        whether a new database file has been created.
    */
   nsresult InitDatabaseFile(nsCOMPtr<mozIStorageService>& aStorage,
                             bool* aNewDatabaseCreated);
 
   /**
+   * Initializes the favicons database file.  If it does not exist or is
+   * corrupt, a new one is created.
+   *
+   * @param aStorage
+   *        mozStorage service instance.
+   */
+  nsresult InitFaviconsDatabaseFile(nsCOMPtr<mozIStorageService>& aStorage);
+
+  /**
    * Creates a database backup and replaces the original file with a new
    * one.
    *
    * @param aStorage
    *        mozStorage service instance.
    */
   nsresult BackupAndReplaceDatabaseFile(nsCOMPtr<mozIStorageService>& aStorage);
 
@@ -267,16 +276,17 @@ protected:
   nsresult MigrateV28Up();
   nsresult MigrateV30Up();
   nsresult MigrateV31Up();
   nsresult MigrateV32Up();
   nsresult MigrateV33Up();
   nsresult MigrateV34Up();
   nsresult MigrateV35Up();
   nsresult MigrateV36Up();
+  nsresult MigrateV37Up();
 
   nsresult UpdateBookmarkRootTitles();
 
   friend class ConnectionShutdownBlocker;
 
   int64_t CreateMobileRoot();
   nsresult GetItemsWithAnno(const nsACString& aAnnoName, int32_t aItemType,
                             nsTArray<int64_t>& aItemIds);
--- a/toolkit/components/places/FaviconHelpers.cpp
+++ b/toolkit/components/places/FaviconHelpers.cpp
@@ -13,20 +13,26 @@
 
 #include "nsNavHistory.h"
 #include "nsFaviconService.h"
 #include "mozilla/storage.h"
 #include "mozilla/Telemetry.h"
 #include "nsNetUtil.h"
 #include "nsPrintfCString.h"
 #include "nsStreamUtils.h"
+#include "nsStringStream.h"
 #include "nsIPrivateBrowsingChannel.h"
 #include "nsISupportsPriority.h"
 #include "nsContentUtils.h"
 #include <algorithm>
+#include "mozilla/gfx/2D.h"
+#include "imgIContainer.h"
+#include "ImageOps.h"
+#include "imgLoader.h"
+#include "imgIEncoder.h"
 
 using namespace mozilla::places;
 using namespace mozilla::storage;
 
 namespace mozilla {
 namespace places {
 
 namespace {
@@ -925,10 +931,245 @@ NotifyIconObservers::SendGlobalNotificat
     // This will be silent, so be sure to not pass in the current callback.
     nsMainThreadPtrHandle<nsIFaviconDataCallback> nullCallback;
     RefPtr<AsyncAssociateIconToPage> event =
         new AsyncAssociateIconToPage(mIcon, bookmarkedPage, nullCallback);
     DB->DispatchToAsyncThread(event);
   }
 }
 
+////////////////////////////////////////////////////////////////////////////////
+//// FetchAndConvertUnsupportedPayloads
+
+FetchAndConvertUnsupportedPayloads::FetchAndConvertUnsupportedPayloads (
+  mozIStorageConnection* aDBConn
+) : mDB(aDBConn)
+{
+
+}
+
+NS_IMETHODIMP
+FetchAndConvertUnsupportedPayloads::Run()
+{
+  if (NS_IsMainThread()) {
+    Preferences::ClearUser(PREF_CONVERT_PAYLOADS);
+    return NS_OK;
+  }
+
+  MOZ_ASSERT(!NS_IsMainThread());
+  NS_ENSURE_STATE(mDB);
+
+  nsCOMPtr<mozIStorageStatement> stmt;
+  nsresult rv = mDB->CreateStatement(NS_LITERAL_CSTRING(
+    "SELECT id, width, data FROM moz_icons WHERE typeof(width) = 'text' "
+    "ORDER BY id ASC "
+    "LIMIT 200 "
+  ), getter_AddRefs(stmt));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  mozStorageTransaction transaction(mDB, false,
+                                    mozIStorageConnection::TRANSACTION_IMMEDIATE);
+
+  // We should do the work in chunks, or the wal journal may grow too much.
+  uint8_t count = 0;
+  bool hasResult;
+  while (NS_SUCCEEDED(stmt->ExecuteStep(&hasResult)) && hasResult) {
+    ++count;
+    int64_t id = stmt->AsInt64(0);
+    MOZ_ASSERT(id > 0);
+    nsAutoCString mimeType;
+    rv = stmt->GetUTF8String(1, mimeType);
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      continue;
+    }
+    uint8_t* data;
+    uint32_t dataLen = 0;
+    rv = stmt->GetBlob(2, &dataLen, &data);
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      continue;
+    }
+    nsCString buf;
+    buf.Adopt(TO_CHARBUFFER(data), dataLen);
+
+    int32_t width = 0;
+    rv = ConvertPayload(id, mimeType, buf, &width);
+    Unused << NS_WARN_IF(NS_FAILED(rv));
+    if (NS_SUCCEEDED(rv)) {
+      rv = StorePayload(id, width, buf);
+      if (NS_WARN_IF(NS_FAILED(rv))) {
+        continue;
+      }
+    }
+  }
+
+  rv = transaction.Commit();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (count == 200) {
+    // There are more results to handle. Re-dispatch to the same thread for the
+    // next chunk.
+    return NS_DispatchToCurrentThread(this);
+  }
+
+  // We're done. Remove any leftovers and force a checkpoint for safety.
+  rv = mDB->ExecuteSimpleSQL(NS_LITERAL_CSTRING(
+    "DELETE FROM moz_icons WHERE typeof(width) = 'text'"
+  ));
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = mDB->ExecuteSimpleSQL(NS_LITERAL_CSTRING(
+    "PRAGMA wal_checkpoint"
+  ));
+  NS_ENSURE_SUCCESS(rv, rv);
+  // Run a one-time VACUUM of places.sqlite, since we removed a lot from it.
+  // It may cause jank, but not doing it could cause dataloss due to expiration.
+  rv = mDB->ExecuteSimpleSQL(NS_LITERAL_CSTRING(
+    "VACUUM"
+  ));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Re-dispatch to the main-thread to flip the conversion pref.
+  return NS_DispatchToMainThread(this);
+}
+
+nsresult
+FetchAndConvertUnsupportedPayloads::ConvertPayload(int64_t aId,
+                                                   const nsACString& aMimeType,
+                                                   nsCString& aPayload,
+                                                   int32_t* aWidth)
+{
+  // TODO (bug 1346139): this should probably be unified with the function that
+  // will handle additions optimization off the main thread.
+  MOZ_ASSERT(!NS_IsMainThread());
+  *aWidth = 0;
+
+  // Exclude invalid mime types.
+  if (aPayload.Length() == 0 ||
+      !imgLoader::SupportImageWithMimeType(PromiseFlatCString(aMimeType).get(),
+                                           AcceptedMimeTypes::IMAGES)) {
+    return NS_ERROR_FAILURE;
+  }
+
+  // If it's an SVG, there's nothing to optimize or convert.
+  if (aMimeType.EqualsLiteral(SVG_MIME_TYPE)) {
+    *aWidth = UINT16_MAX;
+    return NS_OK;
+  }
+
+  // Convert the payload to an input stream.
+  nsCOMPtr<nsIInputStream> stream;
+  nsresult rv = NS_NewByteInputStream(getter_AddRefs(stream),
+                aPayload.get(), aPayload.Length(),
+                NS_ASSIGNMENT_DEPEND);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Decode the input stream to a surface.
+  RefPtr<gfx::SourceSurface> surface =
+      image::ImageOps::DecodeToSurface(stream,
+                                       aMimeType,
+                                       imgIContainer::DECODE_FLAGS_DEFAULT);
+  NS_ENSURE_STATE(surface);
+  RefPtr<gfx::DataSourceSurface> dataSurface = surface->GetDataSurface();
+  NS_ENSURE_STATE(dataSurface);
+
+  // Read the current size and set an appropriate final width.
+  int32_t width = dataSurface->GetSize().width;
+  int32_t height = dataSurface->GetSize().height;
+  // For non-square images, pick the largest side.
+  int32_t originalSize = std::max(width, height);
+  int32_t size = originalSize;
+  for (uint16_t supportedSize : sFaviconSizes) {
+    if (supportedSize <= originalSize) {
+      size = supportedSize;
+      break;
+    }
+  }
+  *aWidth = size;
+
+  // If the original payload is png and the size is the same, no reason to
+  // rescale the image.
+  if (aMimeType.EqualsLiteral(PNG_MIME_TYPE) && size == originalSize) {
+    return NS_OK;
+  }
+
+  // Rescale when needed.
+  RefPtr<gfx::DataSourceSurface> targetDataSurface =
+    gfx::Factory::CreateDataSourceSurface(gfx::IntSize(size, size),
+                                          gfx::SurfaceFormat::B8G8R8A8,
+                                          true);
+  NS_ENSURE_STATE(targetDataSurface);
+
+  { // Block scope for map.
+    gfx::DataSourceSurface::MappedSurface map;
+    if (!targetDataSurface->Map(gfx::DataSourceSurface::MapType::WRITE, &map)) {
+      return NS_ERROR_FAILURE;
+    }
+
+    RefPtr<gfx::DrawTarget> dt =
+      gfx::Factory::CreateDrawTargetForData(gfx::BackendType::CAIRO,
+                                            map.mData,
+                                            targetDataSurface->GetSize(),
+                                            map.mStride,
+                                            gfx::SurfaceFormat::B8G8R8A8);
+    NS_ENSURE_STATE(dt);
+
+    gfx::IntSize frameSize = dataSurface->GetSize();
+    dt->DrawSurface(dataSurface,
+                    gfx::Rect(0, 0, size, size),
+                    gfx::Rect(0, 0, frameSize.width, frameSize.height),
+                    gfx::DrawSurfaceOptions(),
+                    gfx::DrawOptions(1.0f, gfx::CompositionOp::OP_SOURCE));
+    targetDataSurface->Unmap();
+  }
+
+  // Finally Encode.
+  nsCOMPtr<imgIEncoder> encoder =
+    do_CreateInstance("@mozilla.org/image/encoder;2?type=image/png");
+  NS_ENSURE_STATE(encoder);
+
+  gfx::DataSourceSurface::MappedSurface map;
+  if (!targetDataSurface->Map(gfx::DataSourceSurface::MapType::READ, &map)) {
+    return NS_ERROR_FAILURE;
+  }
+  rv = encoder->InitFromData(map.mData, map.mStride * size, size, size,
+                             map.mStride, imgIEncoder::INPUT_FORMAT_HOSTARGB,
+                             EmptyString());
+  targetDataSurface->Unmap();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Read the stream into a new buffer.
+  nsCOMPtr<nsIInputStream> iconStream = do_QueryInterface(encoder);
+  NS_ENSURE_STATE(iconStream);
+  rv = NS_ConsumeStream(iconStream, UINT32_MAX, aPayload);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return NS_OK;
+}
+
+nsresult
+FetchAndConvertUnsupportedPayloads::StorePayload(int64_t aId,
+                                                 int32_t aWidth,
+                                                 const nsCString& aPayload)
+{
+  MOZ_ASSERT(!NS_IsMainThread());
+
+  NS_ENSURE_STATE(mDB);
+  nsCOMPtr<mozIStorageStatement> stmt;
+  nsresult rv = mDB->CreateStatement(NS_LITERAL_CSTRING(
+    "UPDATE moz_icons SET data = :data, width = :width WHERE id = :id"
+  ), getter_AddRefs(stmt));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = stmt->BindInt64ByName(NS_LITERAL_CSTRING("id"), aId);
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = stmt->BindInt32ByName(NS_LITERAL_CSTRING("width"), aWidth);
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = stmt->BindBlobByName(NS_LITERAL_CSTRING("data"),
+                            TO_INTBUFFER(aPayload), aPayload.Length());
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = stmt->Execute();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return NS_OK;
+}
+
 } // namespace places
 } // namespace mozilla
--- a/toolkit/components/places/FaviconHelpers.h
+++ b/toolkit/components/places/FaviconHelpers.h
@@ -8,16 +8,18 @@
 
 #include "nsIFaviconService.h"
 #include "nsIChannelEventSink.h"
 #include "nsIInterfaceRequestor.h"
 #include "nsIStreamListener.h"
 #include "mozIPlacesPendingOperation.h"
 #include "nsThreadUtils.h"
 #include "nsProxyRelease.h"
+#include "imgITools.h"
+#include "imgIContainer.h"
 
 class nsIPrincipal;
 
 #include "Database.h"
 #include "mozilla/storage.h"
 
 #define ICON_STATUS_UNKNOWN 0
 #define ICON_STATUS_CHANGED 1 << 0
@@ -25,24 +27,30 @@ class nsIPrincipal;
 #define ICON_STATUS_ASSOCIATED 1 << 2
 #define ICON_STATUS_CACHED 1 << 3
 
 #define TO_CHARBUFFER(_buffer) \
   reinterpret_cast<char*>(const_cast<uint8_t*>(_buffer))
 #define TO_INTBUFFER(_string) \
   reinterpret_cast<uint8_t*>(const_cast<char*>(_string.get()))
 
+#define PNG_MIME_TYPE "image/png"
+#define SVG_MIME_TYPE "image/svg+xml"
+
 /**
  * The maximum time we will keep a favicon around.  We always ask the cache, if
  * we can, but default to this value if we do not get a time back, or the time
  * is more in the future than this.
  * Currently set to one week from now.
  */
 #define MAX_FAVICON_EXPIRATION ((PRTime)7 * 24 * 60 * 60 * PR_USEC_PER_SEC)
 
+// Whether there are unsupported payloads to convert yet.
+#define PREF_CONVERT_PAYLOADS "places.favicons.convertPayloads"
+
 namespace mozilla {
 namespace places {
 
 /**
  * Indicates when a icon should be fetched from network.
  */
 enum AsyncFaviconFetchMode {
   FETCH_NEVER = 0
@@ -264,10 +272,35 @@ public:
 private:
   nsMainThreadPtrHandle<nsIFaviconDataCallback> mCallback;
   IconData mIcon;
   PageData mPage;
 
   void SendGlobalNotifications(nsIURI* aIconURI);
 };
 
+/**
+ * Fetches and converts unsupported payloads. This is used during the initial
+ * migration of icons from the old to the new store.
+ */
+class FetchAndConvertUnsupportedPayloads final : public Runnable
+{
+public:
+  NS_DECL_NSIRUNNABLE
+
+  /**
+   * Constructor.
+   *
+   * @param aDBConn
+   *        The database connection to use.
+   */
+  explicit FetchAndConvertUnsupportedPayloads(mozIStorageConnection* aDBConn);
+
+private:
+  nsresult ConvertPayload(int64_t aId, const nsACString& aMimeType,
+                          nsCString& aPayload, int32_t* aWidth);
+  nsresult StorePayload(int64_t aId, int32_t aWidth, const nsCString& aPayload);
+
+  nsCOMPtr<mozIStorageConnection> mDB;
+};
+
 } // namespace places
 } // namespace mozilla
--- a/toolkit/components/places/SQLFunctions.cpp
+++ b/toolkit/components/places/SQLFunctions.cpp
@@ -882,20 +882,23 @@ namespace places {
     nsAutoCString table;
     rv = aArgs->GetUTF8String(0, table);
     NS_ENSURE_SUCCESS(rv, rv);
 
     int64_t lastInsertedId = aArgs->AsInt64(1);
 
     MOZ_ASSERT(table.EqualsLiteral("moz_places") ||
                table.EqualsLiteral("moz_historyvisits") ||
-               table.EqualsLiteral("moz_bookmarks"));
+               table.EqualsLiteral("moz_bookmarks") ||
+               table.EqualsLiteral("moz_icons"));
 
     if (table.EqualsLiteral("moz_bookmarks")) {
       nsNavBookmarks::StoreLastInsertedId(table, lastInsertedId);
+    } else if (table.EqualsLiteral("moz_icons")) {
+      nsFaviconService::StoreLastInsertedId(table, lastInsertedId);
     } else {
       nsNavHistory::StoreLastInsertedId(table, lastInsertedId);
     }
 
     RefPtr<nsVariant> result = new nsVariant();
     rv = result->SetAsInt64(lastInsertedId);
     NS_ENSURE_SUCCESS(rv, rv);
     result.forget(_result);
--- a/toolkit/components/places/nsFaviconService.cpp
+++ b/toolkit/components/places/nsFaviconService.cpp
@@ -28,37 +28,26 @@
 #include "mozilla/ArrayUtils.h"
 #include "mozilla/LoadInfo.h"
 #include "mozilla/Preferences.h"
 #include "nsILoadInfo.h"
 #include "nsIContentPolicy.h"
 #include "nsContentUtils.h"
 #include "NullPrincipal.h"
 
-// For large favicons optimization.
-#include "imgITools.h"
-#include "imgIContainer.h"
-
-// The target dimension, in pixels, for favicons we optimize.
-#define OPTIMIZED_FAVICON_DIMENSION 32
-
 #define MAX_FAILED_FAVICONS 256
 #define FAVICON_CACHE_REDUCE_COUNT 64
 
 #define UNASSOCIATED_FAVICONS_LENGTH 32
 
 // When replaceFaviconData is called, we store the icons in an in-memory cache
 // instead of in storage. Icons in the cache are expired according to this
 // interval.
 #define UNASSOCIATED_ICON_EXPIRY_INTERVAL 60000
 
-// The MIME type of the default favicon and favicons created by
-// OptimizeFaviconImage.
-#define DEFAULT_MIME_TYPE "image/png"
-
 using namespace mozilla;
 using namespace mozilla::places;
 
 /**
  * Used to notify a topic to system observers on async execute completion.
  * Will throw on error.
  */
 class ExpireFaviconsStatementCallbackNotifier : public AsyncStatementCallback
@@ -93,26 +82,41 @@ nsFaviconService::nsFaviconService()
 nsFaviconService::~nsFaviconService()
 {
   NS_ASSERTION(gFaviconService == this,
                "Deleting a non-singleton instance of the service");
   if (gFaviconService == this)
     gFaviconService = nullptr;
 }
 
+Atomic<int64_t> nsFaviconService::sLastInsertedIconId(0);
+
+void // static
+nsFaviconService::StoreLastInsertedId(const nsACString& aTable,
+                                      const int64_t aLastInsertedId) {
+  MOZ_ASSERT(aTable.EqualsLiteral("moz_icons"));
+  sLastInsertedIconId = aLastInsertedId;
+}
 
 nsresult
 nsFaviconService::Init()
 {
   mDB = Database::GetDatabase();
   NS_ENSURE_STATE(mDB);
 
   mExpireUnassociatedIconsTimer = do_CreateInstance("@mozilla.org/timer;1");
   NS_ENSURE_STATE(mExpireUnassociatedIconsTimer);
 
+  // Check if there are still icon payloads to be converted.
+  bool shouldConvertPayloads =
+    Preferences::GetBool(PREF_CONVERT_PAYLOADS, false);
+  if (shouldConvertPayloads) {
+    ConvertUnsupportedPayloads(mDB->MainConn());
+  }
+
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsFaviconService::ExpireAllFavicons()
 {
   nsCOMPtr<mozIStorageAsyncStatement> unlinkIconsStmt = mDB->GetAsyncStatement(
     "UPDATE moz_places "
@@ -631,38 +635,36 @@ nsFaviconService::GetFaviconSpecForIconS
 nsresult
 nsFaviconService::OptimizeFaviconImage(const uint8_t* aData, uint32_t aDataLen,
                                        const nsACString& aMimeType,
                                        nsACString& aNewData,
                                        nsACString& aNewMimeType)
 {
   nsresult rv;
 
-  nsCOMPtr<imgITools> imgtool = do_CreateInstance("@mozilla.org/image/tools;1");
-
   nsCOMPtr<nsIInputStream> stream;
   rv = NS_NewByteInputStream(getter_AddRefs(stream),
                 reinterpret_cast<const char*>(aData), aDataLen,
                 NS_ASSIGNMENT_DEPEND);
   NS_ENSURE_SUCCESS(rv, rv);
 
   // decode image
   nsCOMPtr<imgIContainer> container;
-  rv = imgtool->DecodeImageData(stream, aMimeType, getter_AddRefs(container));
+  rv = GetImgTools()->DecodeImageData(stream, aMimeType, getter_AddRefs(container));
   NS_ENSURE_SUCCESS(rv, rv);
 
-  aNewMimeType.AssignLiteral(DEFAULT_MIME_TYPE);
+  aNewMimeType.AssignLiteral(PNG_MIME_TYPE);
 
   // scale and recompress
   nsCOMPtr<nsIInputStream> iconStream;
-  rv = imgtool->EncodeScaledImage(container, aNewMimeType,
-                                  OPTIMIZED_FAVICON_DIMENSION,
-                                  OPTIMIZED_FAVICON_DIMENSION,
-                                  EmptyString(),
-                                  getter_AddRefs(iconStream));
+  rv = GetImgTools()->EncodeScaledImage(container, aNewMimeType,
+                                        DEFAULT_FAVICON_SIZE,
+                                        DEFAULT_FAVICON_SIZE,
+                                        EmptyString(),
+                                        getter_AddRefs(iconStream));
   NS_ENSURE_SUCCESS(rv, rv);
 
   // Read the stream into a new buffer.
   rv = NS_ConsumeStream(iconStream, UINT32_MAX, aNewData);
   NS_ENSURE_SUCCESS(rv, rv);
 
   return NS_OK;
 }
@@ -684,16 +686,37 @@ nsFaviconService::GetFaviconDataAsync(ns
   aFaviconURI->GetSpecIgnoringRef(faviconURI);
   nsresult rv = URIBinder::Bind(stmt, NS_LITERAL_CSTRING("icon_url"), faviconURI);
   NS_ENSURE_SUCCESS(rv, rv);
 
   nsCOMPtr<mozIStoragePendingStatement> pendingStatement;
   return stmt->ExecuteAsync(aCallback, getter_AddRefs(pendingStatement));
 }
 
+void // static
+nsFaviconService::ConvertUnsupportedPayloads(mozIStorageConnection* aDBConn)
+{
+  MOZ_ASSERT(NS_IsMainThread());
+  // Ensure imgTools are initialized, so that the image decoders can be used
+  // off the main thread.
+  nsCOMPtr<imgITools> imgTools = do_CreateInstance("@mozilla.org/image/tools;1");
+
+  Preferences::SetBool(PREF_CONVERT_PAYLOADS, true);
+  MOZ_ASSERT(aDBConn);
+  if (aDBConn) {
+    RefPtr<FetchAndConvertUnsupportedPayloads> event =
+      new FetchAndConvertUnsupportedPayloads(aDBConn);
+    nsCOMPtr<nsIEventTarget> target = do_GetInterface(aDBConn);
+    MOZ_ASSERT(target);
+    if (target) {
+      (void)target->Dispatch(event, NS_DISPATCH_NORMAL);
+    }
+  }
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 //// ExpireFaviconsStatementCallbackNotifier
 
 ExpireFaviconsStatementCallbackNotifier::ExpireFaviconsStatementCallbackNotifier()
 {
 }
 
 
--- a/toolkit/components/places/nsFaviconService.h
+++ b/toolkit/components/places/nsFaviconService.h
@@ -13,21 +13,29 @@
 #include "nsString.h"
 #include "nsDataHashtable.h"
 #include "nsServiceManagerUtils.h"
 #include "nsTHashtable.h"
 #include "nsToolkitCompsCID.h"
 #include "nsURIHashKey.h"
 #include "nsITimer.h"
 #include "Database.h"
+#include "imgITools.h"
 #include "mozilla/storage.h"
 #include "mozilla/Attributes.h"
 
 #include "FaviconHelpers.h"
 
+// The target dimension in pixels for favicons we store, in reverse order.
+static uint16_t sFaviconSizes[8] = {
+  256, 192, 144, 96, 64, 48, 32, 16
+};
+// Default size when preferred size is unknown, doubled for hi-dpi.
+#define DEFAULT_FAVICON_SIZE 32
+
 // Favicons bigger than this (in bytes) will not be stored in the database.  We
 // expect that most 32x32 PNG favicons will be no larger due to compression.
 #define MAX_FAVICON_FILESIZE 3072 /* 3 KiB */
 
 // forward class definitions
 class mozIStorageStatementCallback;
 
 class UnassociatedIconHashKey : public nsURIHashKey
@@ -73,16 +81,21 @@ public:
       nsCOMPtr<nsIFaviconService> serv =
         do_GetService(NS_FAVICONSERVICE_CONTRACTID);
       NS_ENSURE_TRUE(serv, nullptr);
       NS_ASSERTION(gFaviconService, "Should have static instance pointer now");
     }
     return gFaviconService;
   }
 
+  /**
+   * Fetch and migrate favicons from an unsupported payload to a supported one.
+   */
+  static void ConvertUnsupportedPayloads(mozIStorageConnection* aDBConn);
+
   // addition to API for strings to prevent excessive parsing of URIs
   nsresult GetFaviconLinkForIconString(const nsCString& aIcon, nsIURI** aOutput);
   void GetFaviconSpecForIconString(const nsCString& aIcon, nsACString& aOutput);
 
   nsresult OptimizeFaviconImage(const uint8_t* aData, uint32_t aDataLen,
                                 const nsACString& aMimeType,
                                 nsACString& aNewData, nsACString& aNewMimeType);
 
@@ -107,27 +120,39 @@ public:
    * @param aFaviconURI
    *        The moz-anno:favicon URI of the icon.
    * @param aGUID
    *        The unique ID associated with the page.
    */
   void SendFaviconNotifications(nsIURI* aPageURI, nsIURI* aFaviconURI,
                                 const nsACString& aGUID);
 
+  static mozilla::Atomic<int64_t> sLastInsertedIconId;
+  static void StoreLastInsertedId(const nsACString& aTable,
+                                  const int64_t aLastInsertedId);
+
   NS_DECL_ISUPPORTS
   NS_DECL_NSIFAVICONSERVICE
   NS_DECL_MOZIASYNCFAVICONS
   NS_DECL_NSITIMERCALLBACK
 
 private:
+  imgITools* GetImgTools() {
+    if (!mImgTools) {
+      mImgTools = do_CreateInstance("@mozilla.org/image/tools;1");
+    }
+    return mImgTools;
+  }
+
   ~nsFaviconService();
 
   RefPtr<mozilla::places::Database> mDB;
 
   nsCOMPtr<nsITimer> mExpireUnassociatedIconsTimer;
+  nsCOMPtr<imgITools> mImgTools;
 
   static nsFaviconService* gFaviconService;
 
   /**
    * A cached URI for the default icon. We return this a lot, and don't want to
    * re-parse and normalize our unchanging string many times.  Important: do
    * not return this directly; use Clone() since callers may change the object
    * they get back. May be null, in which case it needs initialization.
--- a/toolkit/components/places/nsPlacesExpiration.js
+++ b/toolkit/components/places/nsPlacesExpiration.js
@@ -69,17 +69,17 @@ const PREF_INTERVAL_SECONDS_NOTSET = 3 *
 // This percentage of memory size is used to protect against calculating a too
 // large database size on systems with small memory.
 const DATABASE_TO_MEMORY_PERC = 4;
 // This percentage of disk size is used to protect against calculating a too
 // large database size on disks with tiny quota or available space.
 const DATABASE_TO_DISK_PERC = 2;
 // Maximum size of the optimal database.  High-end hardware has plenty of
 // memory and disk space, but performances don't grow linearly.
-const DATABASE_MAX_SIZE = 73400320; // 70MiB
+const DATABASE_MAX_SIZE = 62914560; // 60MiB
 // If the physical memory size is bogus, fallback to this.
 const MEMSIZE_FALLBACK_BYTES = 268435456; // 256 MiB
 // If the disk available space is bogus, fallback to this.
 const DISKSIZE_FALLBACK_BYTES = 268435456; // 256 MiB
 
 // Max number of entries to expire at each expiration step.
 // This value is globally used for different kind of data we expire, can be
 // tweaked based on data type.  See below in getBoundStatement.
--- a/toolkit/components/places/nsPlacesIndexes.h
+++ b/toolkit/components/places/nsPlacesIndexes.h
@@ -116,9 +116,23 @@
  * moz_keywords
  */
 
 #define CREATE_IDX_MOZ_KEYWORDS_PLACEPOSTDATA \
   CREATE_PLACES_IDX( \
     "placepostdata_uniqueindex", "moz_keywords", "place_id, post_data", "UNIQUE" \
   )
 
+// moz_pages_w_icons
+
+#define CREATE_IDX_MOZ_PAGES_W_ICONS_ICONURLHASH \
+  CREATE_PLACES_IDX( \
+    "urlhashindex", "moz_pages_w_icons", "page_url_hash", "" \
+  )
+
+// moz_icons
+
+#define CREATE_IDX_MOZ_ICONS_ICONURLHASH \
+  CREATE_PLACES_IDX( \
+    "iconurlhashindex", "moz_icons", "fixed_icon_url_hash", "" \
+  )
+
 #endif // nsPlacesIndexes_h__
--- a/toolkit/components/places/nsPlacesTables.h
+++ b/toolkit/components/places/nsPlacesTables.h
@@ -12,17 +12,16 @@
     "CREATE TABLE moz_places ( " \
     "  id INTEGER PRIMARY KEY" \
     ", url LONGVARCHAR" \
     ", title LONGVARCHAR" \
     ", rev_host LONGVARCHAR" \
     ", visit_count INTEGER DEFAULT 0" \
     ", hidden INTEGER DEFAULT 0 NOT NULL" \
     ", typed INTEGER DEFAULT 0 NOT NULL" \
-    ", favicon_id INTEGER" \
     ", frecency INTEGER DEFAULT -1 NOT NULL" \
     ", last_visit_date INTEGER " \
     ", guid TEXT" \
     ", foreign_count INTEGER DEFAULT 0 NOT NULL" \
     ", url_hash INTEGER DEFAULT 0 NOT NULL " \
   ")" \
 )
 
@@ -47,17 +46,16 @@
   ")" \
 )
 
 #define CREATE_MOZ_ANNOS NS_LITERAL_CSTRING( \
   "CREATE TABLE moz_annos (" \
     "  id INTEGER PRIMARY KEY" \
     ", place_id INTEGER NOT NULL" \
     ", anno_attribute_id INTEGER" \
-    ", mime_type VARCHAR(32) DEFAULT NULL" \
     ", content LONGVARCHAR" \
     ", flags INTEGER DEFAULT 0" \
     ", expiration INTEGER DEFAULT 0" \
     ", type INTEGER DEFAULT 0" \
     ", dateAdded INTEGER DEFAULT 0" \
     ", lastModified INTEGER DEFAULT 0" \
   ")" \
 )
@@ -69,36 +67,25 @@
   ")" \
 )
 
 #define CREATE_MOZ_ITEMS_ANNOS NS_LITERAL_CSTRING( \
   "CREATE TABLE moz_items_annos (" \
     "  id INTEGER PRIMARY KEY" \
     ", item_id INTEGER NOT NULL" \
     ", anno_attribute_id INTEGER" \
-    ", mime_type VARCHAR(32) DEFAULT NULL" \
     ", content LONGVARCHAR" \
     ", flags INTEGER DEFAULT 0" \
     ", expiration INTEGER DEFAULT 0" \
     ", type INTEGER DEFAULT 0" \
     ", dateAdded INTEGER DEFAULT 0" \
     ", lastModified INTEGER DEFAULT 0" \
   ")" \
 )
 
-#define CREATE_MOZ_FAVICONS NS_LITERAL_CSTRING( \
-  "CREATE TABLE moz_favicons (" \
-    "  id INTEGER PRIMARY KEY" \
-    ", url LONGVARCHAR UNIQUE" \
-    ", data BLOB" \
-    ", mime_type VARCHAR(32)" \
-    ", expiration LONG" \
-  ")" \
-)
-
 #define CREATE_MOZ_BOOKMARKS NS_LITERAL_CSTRING( \
   "CREATE TABLE moz_bookmarks (" \
     "  id INTEGER PRIMARY KEY" \
     ", type INTEGER" \
     ", fk INTEGER DEFAULT NULL" /* place_id */ \
     ", parent INTEGER" \
     ", position INTEGER" \
     ", title LONGVARCHAR" \
@@ -174,9 +161,53 @@
 // take care of updating the moz_hosts table for every modified host.
 // See CREATE_PLACES_AFTERDELETE_TRIGGER in nsPlacestriggers.h for details.
 #define CREATE_UPDATEHOSTS_TEMP NS_LITERAL_CSTRING( \
   "CREATE TEMP TABLE moz_updatehosts_temp (" \
     "  host TEXT PRIMARY KEY " \
   ") WITHOUT ROWID " \
 )
 
+// This table would not be strictly needed for functionality since it's just
+// mimicking moz_places, though it's great for database portability.
+// With this we don't have to take care into account a bunch of database
+// mismatch cases, where places.sqlite could be mixed up with a favicons.sqlite
+// created with a different places.sqlite (not just in case of a user messing
+// up with the profile, but also in case of corruption).
+#define CREATE_MOZ_PAGES_W_ICONS NS_LITERAL_CSTRING( \
+  "CREATE TABLE moz_pages_w_icons ( " \
+    "id INTEGER PRIMARY KEY, " \
+    "page_url TEXT NOT NULL, " \
+    "page_url_hash INTEGER NOT NULL " \
+  ") " \
+)
+
+// This table retains the icons data. The hashes url is "fixed" (thus the scheme
+// and www are trimmed in most cases) so we can quickly query for root icon urls
+// like "domain/favicon.ico".
+// We are considering squared icons for simplicity, so storing only one size.
+// For svg payloads, width will be set to 65535 (UINT16_MAX).
+#define CREATE_MOZ_ICONS NS_LITERAL_CSTRING( \
+  "CREATE TABLE moz_icons ( " \
+    "id INTEGER PRIMARY KEY, " \
+    "icon_url TEXT NOT NULL, " \
+    "fixed_icon_url_hash INTEGER NOT NULL, " \
+    "width INTEGER NOT NULL DEFAULT 0, " \
+    "color INTEGER, " \
+    "expire_ms INTEGER NOT NULL DEFAULT 0, " \
+    "data BLOB " \
+  ") " \
+)
+
+// This table maintains relations between icons and pages.
+// Each page can have multiple icons, and each icon can be used by multiple
+// pages.
+#define CREATE_MOZ_ICONS_TO_PAGES NS_LITERAL_CSTRING( \
+  "CREATE TABLE moz_icons_to_pages ( " \
+    "page_id INTEGER NOT NULL, " \
+    "icon_id INTEGER NOT NULL, " \
+    "PRIMARY KEY (page_id, icon_id), " \
+    "FOREIGN KEY (page_id) REFERENCES moz_pages_w_icons ON DELETE CASCADE, " \
+    "FOREIGN KEY (icon_id) REFERENCES moz_icons ON DELETE CASCADE " \
+  ") WITHOUT ROWID " \
+)
+
 #endif // __nsPlacesTables_h__
--- a/toolkit/components/places/nsPlacesTriggers.h
+++ b/toolkit/components/places/nsPlacesTriggers.h
@@ -140,16 +140,19 @@
       "AND NOT EXISTS(" \
         "SELECT 1 FROM moz_places " \
           "WHERE rev_host = get_unreversed_host(host || '.') || '.' " \
              "OR rev_host = get_unreversed_host(host || '.') || '.www.' " \
       "); " \
     "UPDATE moz_hosts " \
     "SET prefix = (" HOSTS_PREFIX_PRIORITY_FRAGMENT ") " \
     "WHERE host = OLD.host; " \
+    "DELETE FROM moz_icons " \
+    "WHERE fixed_icon_url_hash = hash(OLD.host || '/favicon.ico') " \
+      "AND fixup_url(icon_url) = OLD.host || '/favicon.ico';" \
   "END" \
 )
 
 // For performance reasons the host frecency is updated only when the page
 // frecency changes by a meaningful percentage.  This is because the frecency
 // decay algorithm requires to update all the frecencies at once, causing a
 // too high overhead, while leaving the ordering unchanged.
 #define CREATE_PLACES_AFTERUPDATE_FRECENCY_TRIGGER NS_LITERAL_CSTRING( \
@@ -259,9 +262,17 @@
     "SET foreign_count = foreign_count + 1 " \
     "WHERE id = NEW.place_id; " \
     "UPDATE moz_places " \
     "SET foreign_count = foreign_count - 1 " \
     "WHERE id = OLD.place_id; " \
   "END" \
 )
 
+#define CREATE_ICONS_AFTERINSERT_TRIGGER NS_LITERAL_CSTRING( \
+  "CREATE TEMP TRIGGER moz_icons_afterinsert_v1_trigger " \
+  "AFTER INSERT ON moz_icons FOR EACH ROW " \
+  "BEGIN " \
+    "SELECT store_last_inserted_id('moz_icons', NEW.id); " \
+  "END" \
+)
+
 #endif // __nsPlacesTriggers_h__
--- a/toolkit/components/places/tests/head_common.js
+++ b/toolkit/components/places/tests/head_common.js
@@ -1,17 +1,17 @@
 /* -*- indent-tabs-mode: nil; js-indent-level: 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/. */
 
 // It is expected that the test files importing this file define Cu etc.
 /* global Cu, Ci, Cc, Cr */
 
-const CURRENT_SCHEMA_VERSION = 36;
+const CURRENT_SCHEMA_VERSION = 37;
 const FIRST_UPGRADABLE_SCHEMA_VERSION = 11;
 
 const NS_APP_USER_PROFILE_50_DIR = "ProfD";
 const NS_APP_PROFILE_DIR_STARTUP = "ProfDS";
 
 // Shortcuts to transitions type.
 const TRANSITION_LINK = Ci.nsINavHistoryService.TRANSITION_LINK;
 const TRANSITION_TYPED = Ci.nsINavHistoryService.TRANSITION_TYPED;
new file mode 100644
--- /dev/null
+++ b/toolkit/components/places/tests/migration/test_current_from_v36.js
@@ -0,0 +1,82 @@
+const MAX_UNSIGNED_SHORT = 65535;
+
+var gTestcases = [];
+add_task(function* setup() {
+  // The database has been pre-populated, since we cannot generate the necessary
+  // hashes from a raw connection.
+  // To add further tests, the data must be copied over to this db from an
+  // existing one.
+  yield setupPlacesDatabase("places_v36.sqlite");
+  // Fetch database contents to be migrated.
+  let path = OS.Path.join(OS.Constants.Path.profileDir, DB_FILENAME);
+  let db = yield Sqlite.openConnection({ path });
+
+  let rows = yield db.execute(`
+    SELECT h.url AS page_url, f.url AS favicon_url, mime_type, expiration, LENGTH(data) AS datalen
+    FROM moz_favicons f
+    LEFT JOIN moz_places h ON h.favicon_id = f.id`);
+  for (let row of rows) {
+    let info = {
+      icon_url: row.getResultByName("favicon_url"),
+      page_url: row.getResultByName("page_url"),
+      mime_type: row.getResultByName("mime_type"),
+      expiration: row.getResultByName("expiration"),
+      has_data: row.getResultByName("mime_type") != "broken" &&
+                row.getResultByName("datalen") > 0,
+    };
+    gTestcases.push(info);
+  }
+  yield db.close();
+});
+
+add_task(function* database_is_valid() {
+  Assert.equal(PlacesUtils.history.databaseStatus,
+               PlacesUtils.history.DATABASE_STATUS_UPGRADED);
+
+  let db = yield PlacesUtils.promiseDBConnection();
+  Assert.equal((yield db.getSchemaVersion()), CURRENT_SCHEMA_VERSION);
+});
+
+add_task(function* test_icons() {
+  let db = yield PlacesUtils.promiseDBConnection();
+  let rows = yield db.execute(`SELECT url FROM moz_favicons`);
+  Assert.equal(rows.length, 0, "favicons table should be empty");
+  for (let entry of gTestcases) {
+    do_print("");
+    do_print("Checking " + entry.icon_url + " - " + entry.page_url);
+    rows = yield db.execute(`SELECT id, expire_ms, width FROM moz_icons
+                             WHERE fixed_icon_url_hash = hash(fixup_url(:icon_url))
+                               AND icon_url = :icon_url
+                            `, { icon_url: entry.icon_url });
+    Assert.equal(!!rows.length, entry.has_data, "icon exists");
+    if (!entry.has_data) {
+      // Icon not migrated.
+      continue;
+    }
+    Assert.equal(rows[0].getResultByName("expire_ms"), 0,
+                 "expiration is correct");
+
+    let width = rows[0].getResultByName("width");
+    if (entry.mime_type == "image/svg+xml") {
+      Assert.equal(width, MAX_UNSIGNED_SHORT, "width is correct");
+    } else {
+      Assert.ok(width > 0 && (width < 16 || width % 16 == 0), "width is correct");
+    }
+
+    let icon_id = rows[0].getResultByName("id");
+
+    rows = yield db.execute(`SELECT page_id FROM moz_icons_to_pages
+                             WHERE icon_id = :icon_id`, { icon_id });
+    let has_relation = !!entry.page_url;
+    Assert.equal(!!rows.length, has_relation, "page relations found");
+    if (has_relation) {
+      let page_ids = rows.map(r => r.getResultByName("page_id"));
+
+      rows = yield db.execute(`SELECT page_url FROM moz_pages_w_icons
+                               WHERE id IN(${page_ids.join(",")})`);
+      let urls = rows.map(r => r.getResultByName("page_url"));
+      Assert.ok(urls.some(url => url == entry.page_url),
+                "page_url found");
+    }
+  }
+});
--- a/toolkit/components/places/tests/migration/xpcshell.ini
+++ b/toolkit/components/places/tests/migration/xpcshell.ini
@@ -17,20 +17,22 @@ support-files =
   places_v28.sqlite
   places_v30.sqlite
   places_v31.sqlite
   places_v32.sqlite
   places_v33.sqlite
   places_v34.sqlite
   places_v35.sqlite
   places_v36.sqlite
+  places_v37.sqlite
 
 [test_current_from_downgraded.js]
 [test_current_from_v6.js]
 [test_current_from_v11.js]
 [test_current_from_v19.js]
 [test_current_from_v24.js]
 [test_current_from_v25.js]
 [test_current_from_v26.js]
 [test_current_from_v27.js]
 [test_current_from_v31.js]
 [test_current_from_v34.js]
 [test_current_from_v35.js]
+[test_current_from_v36.js]
author	Marco Bonardo <mbonardo@mozilla.com>
	Mon, 14 Nov 2016 16:22:46 +0100
changeset 561149	4d25966596dcdf63c9c872425c5bf147406d25ac
parent 560921	f40e24f40b4c4556944c762d4764eace261297f5
child 561150	fa49c4a81d6ab6b34a2f19ee4175e889a6e9d734
push id	53651
push user	mak77@bonardo.net
push date	Wed, 12 Apr 2017 09:15:32 +0000
reviewers	adw
bugs	977177
milestone	55.0a1
dom/push/PushRecord.jsm		file \| annotate \| diff \| comparison \| revisions
toolkit/components/places/Database.cpp		file \| annotate \| diff \| comparison \| revisions
toolkit/components/places/Database.h		file \| annotate \| diff \| comparison \| revisions
toolkit/components/places/FaviconHelpers.cpp		file \| annotate \| diff \| comparison \| revisions
toolkit/components/places/FaviconHelpers.h		file \| annotate \| diff \| comparison \| revisions
toolkit/components/places/SQLFunctions.cpp		file \| annotate \| diff \| comparison \| revisions
toolkit/components/places/nsFaviconService.cpp		file \| annotate \| diff \| comparison \| revisions
toolkit/components/places/nsFaviconService.h		file \| annotate \| diff \| comparison \| revisions
toolkit/components/places/nsPlacesExpiration.js		file \| annotate \| diff \| comparison \| revisions
toolkit/components/places/nsPlacesIndexes.h		file \| annotate \| diff \| comparison \| revisions
toolkit/components/places/nsPlacesTables.h		file \| annotate \| diff \| comparison \| revisions
toolkit/components/places/nsPlacesTriggers.h		file \| annotate \| diff \| comparison \| revisions
toolkit/components/places/tests/head_common.js		file \| annotate \| diff \| comparison \| revisions
toolkit/components/places/tests/migration/places_v36.sqlite		file \| annotate \| diff \| comparison \| revisions
toolkit/components/places/tests/migration/places_v37.sqlite		file \| annotate \| diff \| comparison \| revisions
toolkit/components/places/tests/migration/test_current_from_v36.js		file \| annotate \| diff \| comparison \| revisions
toolkit/components/places/tests/migration/xpcshell.ini		file \| annotate \| diff \| comparison \| revisions