The Tor Browser / file revision

 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

 /* This Source Code Form is subject to the terms of the Mozilla Public

  * License, v. 2.0. If a copy of the MPL was not distributed with this

  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

 #include "mozilla/DebugOnly.h"

 #include "mozIStorageService.h"

 #include "nsIAlertsService.h"

 #include "nsIArray.h"

 #include "nsIClassInfoImpl.h"

 #include "nsIDOMWindow.h"

 #include "nsIDownloadHistory.h"

 #include "nsIDownloadManagerUI.h"

 #include "nsIMIMEService.h"

 #include "nsIParentalControlsService.h"

 #include "nsIPrefService.h"

 #include "nsIPromptService.h"

 #include "nsIResumableChannel.h"

 #include "nsIWebBrowserPersist.h"

 #include "nsIWindowMediator.h"

 #include "nsILocalFileWin.h"

 #include "nsILoadContext.h"

 #include "nsIXULAppInfo.h"

 #include "nsAppDirectoryServiceDefs.h"

 #include "nsArrayEnumerator.h"

 #include "nsCExternalHandlerService.h"

 #include "nsDirectoryServiceDefs.h"

 #include "nsDownloadManager.h"

 #include "nsNetUtil.h"

 #include "nsThreadUtils.h"

 #include "mozStorageCID.h"

 #include "nsDocShellCID.h"

 #include "nsEmbedCID.h"

 #include "nsToolkitCompsCID.h"

 #include "SQLFunctions.h"

 #include "mozilla/Preferences.h"

 #ifdef XP_WIN

 #include <shlobj.h>

 #include "nsWindowsHelpers.h"

 #ifdef DOWNLOAD_SCANNER

 #include "nsDownloadScanner.h"

 #endif

 #endif

 #ifdef XP_MACOSX

 #include <CoreFoundation/CoreFoundation.h>

 #endif

 #ifdef MOZ_WIDGET_ANDROID

 #include "AndroidBridge.h"

 using namespace mozilla::widget::android;

 #endif

 #ifdef MOZ_WIDGET_GTK

 #include <gtk/gtk.h>

 #endif

 using namespace mozilla;

 using mozilla::downloads::GenerateGUID;

 #define DOWNLOAD_MANAGER_BUNDLE "chrome://mozapps/locale/downloads/downloads.properties"

 #define DOWNLOAD_MANAGER_ALERT_ICON "chrome://mozapps/skin/downloads/downloadIcon.png"

 #define PREF_BD_USEJSTRANSFER "browser.download.useJSTransfer"

 #define PREF_BDM_SHOWALERTONCOMPLETE "browser.download.manager.showAlertOnComplete"

 #define PREF_BDM_SHOWALERTINTERVAL "browser.download.manager.showAlertInterval"

 #define PREF_BDM_RETENTION "browser.download.manager.retention"

 #define PREF_BDM_QUITBEHAVIOR "browser.download.manager.quitBehavior"

 #define PREF_BDM_ADDTORECENTDOCS "browser.download.manager.addToRecentDocs"

 #define PREF_BDM_SCANWHENDONE "browser.download.manager.scanWhenDone"

 #define PREF_BDM_RESUMEONWAKEDELAY "browser.download.manager.resumeOnWakeDelay"

 #define PREF_BH_DELETETEMPFILEONEXIT "browser.helperApps.deleteTempFileOnExit"

 static const int64_t gUpdateInterval = 400 * PR_USEC_PER_MSEC;

 #define DM_SCHEMA_VERSION      9

 #define DM_DB_NAME             NS_LITERAL_STRING("downloads.sqlite")

 #define DM_DB_CORRUPT_FILENAME NS_LITERAL_STRING("downloads.sqlite.corrupt")

 #define NS_SYSTEMINFO_CONTRACTID "@mozilla.org/system-info;1"

 ////////////////////////////////////////////////////////////////////////////////

 //// nsDownloadManager

 NS_IMPL_ISUPPORTS(

   nsDownloadManager

 , nsIDownloadManager

 , nsINavHistoryObserver

 , nsIObserver

 , nsISupportsWeakReference

 )

 nsDownloadManager *nsDownloadManager::gDownloadManagerService = nullptr;

 nsDownloadManager *

 nsDownloadManager::GetSingleton()

 {

   if (gDownloadManagerService) {

     NS_ADDREF(gDownloadManagerService);

     return gDownloadManagerService;

   }

   gDownloadManagerService = new nsDownloadManager();

   if (gDownloadManagerService) {

 #if defined(MOZ_WIDGET_GTK)

     g_type_init();

 #endif

     NS_ADDREF(gDownloadManagerService);

     if (NS_FAILED(gDownloadManagerService->Init()))

       NS_RELEASE(gDownloadManagerService);

   }

   return gDownloadManagerService;

 }

 nsDownloadManager::~nsDownloadManager()

 {

 #ifdef DOWNLOAD_SCANNER

   if (mScanner) {

     delete mScanner;

     mScanner = nullptr;

   }

 #endif

   gDownloadManagerService = nullptr;

 }

 nsresult

 nsDownloadManager::ResumeRetry(nsDownload *aDl)

 {

   // Keep a reference in case we need to cancel the download

   nsRefPtr<nsDownload> dl = aDl;

   // Try to resume the active download

   nsresult rv = dl->Resume();

   // If not, try to retry the download

   if (NS_FAILED(rv)) {

     // First cancel the download so it's no longer active

     rv = dl->Cancel();

     // Then retry it

     if (NS_SUCCEEDED(rv))

       rv = dl->Retry();

   }

   return rv;

 }

 nsresult

 nsDownloadManager::PauseAllDownloads(bool aSetResume)

 {

   nsresult rv = PauseAllDownloads(mCurrentDownloads, aSetResume);

   nsresult rv2 = PauseAllDownloads(mCurrentPrivateDownloads, aSetResume);

   NS_ENSURE_SUCCESS(rv, rv);

   NS_ENSURE_SUCCESS(rv2, rv2);

   return NS_OK;

 }

 nsresult

 nsDownloadManager::PauseAllDownloads(nsCOMArray<nsDownload>& aDownloads, bool aSetResume)

 {

   nsresult retVal = NS_OK;

   for (int32_t i = aDownloads.Count() - 1; i >= 0; --i) {

     nsRefPtr<nsDownload> dl = aDownloads[i];

     // Only pause things that need to be paused

     if (!dl->IsPaused()) {

       // Set auto-resume before pausing so that it gets into the DB

       dl->mAutoResume = aSetResume ? nsDownload::AUTO_RESUME :

                                      nsDownload::DONT_RESUME;

       // Try to pause the download but don't bail now if we fail

       nsresult rv = dl->Pause();

       if (NS_FAILED(rv))

         retVal = rv;

     }

   }

   return retVal;

 }

 nsresult

 nsDownloadManager::ResumeAllDownloads(bool aResumeAll)

 {

   nsresult rv = ResumeAllDownloads(mCurrentDownloads, aResumeAll);

   nsresult rv2 = ResumeAllDownloads(mCurrentPrivateDownloads, aResumeAll);

   NS_ENSURE_SUCCESS(rv, rv);

   NS_ENSURE_SUCCESS(rv2, rv2);

   return NS_OK;

 }

 nsresult

 nsDownloadManager::ResumeAllDownloads(nsCOMArray<nsDownload>& aDownloads, bool aResumeAll)

 {

   nsresult retVal = NS_OK;

   for (int32_t i = aDownloads.Count() - 1; i >= 0; --i) {

     nsRefPtr<nsDownload> dl = aDownloads[i];

     // If aResumeAll is true, then resume everything; otherwise, check if the

     // download should auto-resume

     if (aResumeAll || dl->ShouldAutoResume()) {

       // Reset auto-resume before retrying so that it gets into the DB through

       // ResumeRetry's eventual call to SetState. We clear the value now so we

       // don't accidentally query completed downloads that were previously

       // auto-resumed (and try to resume them).

       dl->mAutoResume = nsDownload::DONT_RESUME;

       // Try to resume/retry the download but don't bail now if we fail

       nsresult rv = ResumeRetry(dl);

       if (NS_FAILED(rv))

         retVal = rv;

     }

   }

   return retVal;

 }

 nsresult

 nsDownloadManager::RemoveAllDownloads()

 {

   nsresult rv = RemoveAllDownloads(mCurrentDownloads);

   nsresult rv2 = RemoveAllDownloads(mCurrentPrivateDownloads);

   NS_ENSURE_SUCCESS(rv, rv);

   NS_ENSURE_SUCCESS(rv2, rv2);

   return NS_OK;

 }

 nsresult

 nsDownloadManager::RemoveAllDownloads(nsCOMArray<nsDownload>& aDownloads)

 {

   nsresult rv = NS_OK;

   for (int32_t i = aDownloads.Count() - 1; i >= 0; --i) {

     nsRefPtr<nsDownload> dl = aDownloads[0];

     nsresult result = NS_OK;

     if (!dl->mPrivate && dl->IsPaused() && GetQuitBehavior() != QUIT_AND_CANCEL)

       aDownloads.RemoveObject(dl);

     else

       result = dl->Cancel();

     // Track the failure, but don't miss out on other downloads

     if (NS_FAILED(result))

       rv = result;

   }

   return rv;

 }

 nsresult

 nsDownloadManager::RemoveDownloadsForURI(mozIStorageStatement* aStatement, nsIURI *aURI)

 {

   mozStorageStatementScoper scope(aStatement);

   nsAutoCString source;

   nsresult rv = aURI->GetSpec(source);

   NS_ENSURE_SUCCESS(rv, rv);

   rv = aStatement->BindUTF8StringByName(

     NS_LITERAL_CSTRING("source"), source);

   NS_ENSURE_SUCCESS(rv, rv);

   bool hasMore = false;

   nsAutoTArray<nsCString, 4> downloads;

   // Get all the downloads that match the provided URI

   while (NS_SUCCEEDED(aStatement->ExecuteStep(&hasMore)) &&

          hasMore) {

     nsAutoCString downloadGuid;

     rv = aStatement->GetUTF8String(0, downloadGuid);

     NS_ENSURE_SUCCESS(rv, rv);

     downloads.AppendElement(downloadGuid);

   }

   // Remove each download ignoring any failure so we reach other downloads

   for (int32_t i = downloads.Length(); --i >= 0; )

     (void)RemoveDownload(downloads[i]);

   return NS_OK;

 }

 void // static

 nsDownloadManager::ResumeOnWakeCallback(nsITimer *aTimer, void *aClosure)

 {

   // Resume the downloads that were set to autoResume

   nsDownloadManager *dlMgr = static_cast<nsDownloadManager *>(aClosure);

   (void)dlMgr->ResumeAllDownloads(false);

 }

 already_AddRefed<mozIStorageConnection>

 nsDownloadManager::GetFileDBConnection(nsIFile *dbFile) const

 {

   NS_ASSERTION(dbFile, "GetFileDBConnection called with an invalid nsIFile");

   nsCOMPtr<mozIStorageService> storage =

     do_GetService(MOZ_STORAGE_SERVICE_CONTRACTID);

   NS_ENSURE_TRUE(storage, nullptr);

   nsCOMPtr<mozIStorageConnection> conn;

   nsresult rv = storage->OpenDatabase(dbFile, getter_AddRefs(conn));

   if (rv == NS_ERROR_FILE_CORRUPTED) {

     // delete and try again, since we don't care so much about losing a user's

     // download history

     rv = dbFile->Remove(false);

     NS_ENSURE_SUCCESS(rv, nullptr);

     rv = storage->OpenDatabase(dbFile, getter_AddRefs(conn));

   }

   NS_ENSURE_SUCCESS(rv, nullptr);

   return conn.forget();

 }

 already_AddRefed<mozIStorageConnection>

 nsDownloadManager::GetPrivateDBConnection() const

 {

   nsCOMPtr<mozIStorageService> storage =

     do_GetService(MOZ_STORAGE_SERVICE_CONTRACTID);

   NS_ENSURE_TRUE(storage, nullptr);

   nsCOMPtr<mozIStorageConnection> conn;

   nsresult rv = storage->OpenSpecialDatabase("memory", getter_AddRefs(conn));

   NS_ENSURE_SUCCESS(rv, nullptr);

   return conn.forget();

 }

 void

 nsDownloadManager::CloseAllDBs()

 {

   CloseDB(mDBConn, mUpdateDownloadStatement, mGetIdsForURIStatement);

   CloseDB(mPrivateDBConn, mUpdatePrivateDownloadStatement, mGetPrivateIdsForURIStatement);

 }

 void

 nsDownloadManager::CloseDB(mozIStorageConnection* aDBConn,

                            mozIStorageStatement* aUpdateStmt,

                            mozIStorageStatement* aGetIdsStmt)

 {

   DebugOnly<nsresult> rv = aGetIdsStmt->Finalize();

   MOZ_ASSERT(NS_SUCCEEDED(rv));

   rv = aUpdateStmt->Finalize();

   MOZ_ASSERT(NS_SUCCEEDED(rv));

   rv = aDBConn->AsyncClose(nullptr);

   MOZ_ASSERT(NS_SUCCEEDED(rv));

 }

 static nsresult

 InitSQLFunctions(mozIStorageConnection* aDBConn)

 {

   nsresult rv = mozilla::downloads::GenerateGUIDFunction::create(aDBConn);

   NS_ENSURE_SUCCESS(rv, rv);

   return NS_OK;

 }

 nsresult

 nsDownloadManager::InitPrivateDB()

 {

   bool ready = false;

   if (mPrivateDBConn && NS_SUCCEEDED(mPrivateDBConn->GetConnectionReady(&ready)) && ready)

     CloseDB(mPrivateDBConn, mUpdatePrivateDownloadStatement, mGetPrivateIdsForURIStatement);

   mPrivateDBConn = GetPrivateDBConnection();

   if (!mPrivateDBConn)

     return NS_ERROR_NOT_AVAILABLE;

   nsresult rv = InitSQLFunctions(mPrivateDBConn);

   NS_ENSURE_SUCCESS(rv, rv);

   rv = CreateTable(mPrivateDBConn);

   NS_ENSURE_SUCCESS(rv, rv);

   rv = InitStatements(mPrivateDBConn, getter_AddRefs(mUpdatePrivateDownloadStatement),

                       getter_AddRefs(mGetPrivateIdsForURIStatement));

   NS_ENSURE_SUCCESS(rv, rv);

   return NS_OK;

 }

 nsresult

 nsDownloadManager::InitFileDB()

 {

   nsresult rv;

   nsCOMPtr<nsIFile> dbFile;

   rv = NS_GetSpecialDirectory(NS_APP_USER_PROFILE_50_DIR,

                               getter_AddRefs(dbFile));

   NS_ENSURE_SUCCESS(rv, rv);

   rv = dbFile->Append(DM_DB_NAME);

   NS_ENSURE_SUCCESS(rv, rv);

   bool ready = false;

   if (mDBConn && NS_SUCCEEDED(mDBConn->GetConnectionReady(&ready)) && ready)

     CloseDB(mDBConn, mUpdateDownloadStatement, mGetIdsForURIStatement);

   mDBConn = GetFileDBConnection(dbFile);

   NS_ENSURE_TRUE(mDBConn, NS_ERROR_NOT_AVAILABLE);

   rv = InitSQLFunctions(mDBConn);

   NS_ENSURE_SUCCESS(rv, rv);

   bool tableExists;

   rv = mDBConn->TableExists(NS_LITERAL_CSTRING("moz_downloads"), &tableExists);

   NS_ENSURE_SUCCESS(rv, rv);

   if (!tableExists) {

     rv = CreateTable(mDBConn);

     NS_ENSURE_SUCCESS(rv, rv);

     // We're done with the initialization now and can skip the remaining

     // upgrading logic.

     return NS_OK;

   }

   // Checking the database schema now

   int32_t schemaVersion;

   rv = mDBConn->GetSchemaVersion(&schemaVersion);

   NS_ENSURE_SUCCESS(rv, rv);

   // Changing the database?  Be sure to do these two things!

   // 1) Increment DM_SCHEMA_VERSION

   // 2) Implement the proper downgrade/upgrade code for the current version

   switch (schemaVersion) {

   // Upgrading

   // Every time you increment the database schema, you need to implement

   // the upgrading code from the previous version to the new one.

   // Also, don't forget to make a unit test to test your upgrading code!

   case 1: // Drop a column (iconURL) from the database (bug 385875)

     {

       // Safely wrap this in a transaction so we don't hose the whole DB

       mozStorageTransaction safeTransaction(mDBConn, true);

       // Create a temporary table that will store the existing records

       rv = mDBConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING(

         "CREATE TEMPORARY TABLE moz_downloads_backup ("

           "id INTEGER PRIMARY KEY, "

           "name TEXT, "

           "source TEXT, "

           "target TEXT, "

           "startTime INTEGER, "

           "endTime INTEGER, "

           "state INTEGER"

         ")"));

       NS_ENSURE_SUCCESS(rv, rv);

       // Insert into a temporary table

       rv = mDBConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING(

         "INSERT INTO moz_downloads_backup "

         "SELECT id, name, source, target, startTime, endTime, state "

         "FROM moz_downloads"));

       NS_ENSURE_SUCCESS(rv, rv);

       // Drop the old table

       rv = mDBConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING(

         "DROP TABLE moz_downloads"));

       NS_ENSURE_SUCCESS(rv, rv);

       // Now recreate it with this schema version

       rv = mDBConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING(

         "CREATE TABLE moz_downloads ("

           "id INTEGER PRIMARY KEY, "

           "name TEXT, "

           "source TEXT, "

           "target TEXT, "

           "startTime INTEGER, "

           "endTime INTEGER, "

           "state INTEGER"

         ")"));

       NS_ENSURE_SUCCESS(rv, rv);

       // Insert the data back into it

       rv = mDBConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING(

         "INSERT INTO moz_downloads "

         "SELECT id, name, source, target, startTime, endTime, state "

         "FROM moz_downloads_backup"));

       NS_ENSURE_SUCCESS(rv, rv);

       // And drop our temporary table

       rv = mDBConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING(

         "DROP TABLE moz_downloads_backup"));

       NS_ENSURE_SUCCESS(rv, rv);

       // Finally, update the schemaVersion variable and the database schema

       schemaVersion = 2;

       rv = mDBConn->SetSchemaVersion(schemaVersion);

       NS_ENSURE_SUCCESS(rv, rv);

     }

     // Fallthrough to the next upgrade

   case 2: // Add referrer column to the database

     {

       rv = mDBConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING(

         "ALTER TABLE moz_downloads "

         "ADD COLUMN referrer TEXT"));

       NS_ENSURE_SUCCESS(rv, rv);

       // Finally, update the schemaVersion variable and the database schema

       schemaVersion = 3;

       rv = mDBConn->SetSchemaVersion(schemaVersion);

       NS_ENSURE_SUCCESS(rv, rv);

     }

     // Fallthrough to the next upgrade

   case 3: // This version adds a column to the database (entityID)

     {

       rv = mDBConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING(

         "ALTER TABLE moz_downloads "

         "ADD COLUMN entityID TEXT"));

       NS_ENSURE_SUCCESS(rv, rv);

       // Finally, update the schemaVersion variable and the database schema

       schemaVersion = 4;

       rv = mDBConn->SetSchemaVersion(schemaVersion);

       NS_ENSURE_SUCCESS(rv, rv);

     }

     // Fallthrough to the next upgrade

   case 4: // This version adds a column to the database (tempPath)

     {

       rv = mDBConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING(

         "ALTER TABLE moz_downloads "

         "ADD COLUMN tempPath TEXT"));

       NS_ENSURE_SUCCESS(rv, rv);

       // Finally, update the schemaVersion variable and the database schema

       schemaVersion = 5;

       rv = mDBConn->SetSchemaVersion(schemaVersion);

       NS_ENSURE_SUCCESS(rv, rv);

     }

     // Fallthrough to the next upgrade

   case 5: // This version adds two columns for tracking transfer progress

     {

       rv = mDBConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING(

         "ALTER TABLE moz_downloads "

         "ADD COLUMN currBytes INTEGER NOT NULL DEFAULT 0"));

       NS_ENSURE_SUCCESS(rv, rv);

       rv = mDBConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING(

         "ALTER TABLE moz_downloads "

         "ADD COLUMN maxBytes INTEGER NOT NULL DEFAULT -1"));

       NS_ENSURE_SUCCESS(rv, rv);

       // Finally, update the schemaVersion variable and the database schema

       schemaVersion = 6;

       rv = mDBConn->SetSchemaVersion(schemaVersion);

       NS_ENSURE_SUCCESS(rv, rv);

     }

     // Fallthrough to the next upgrade

   case 6: // This version adds three columns to DB (MIME type related info)

     {

       rv = mDBConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING(

         "ALTER TABLE moz_downloads "

         "ADD COLUMN mimeType TEXT"));

       NS_ENSURE_SUCCESS(rv, rv);

       rv = mDBConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING(

         "ALTER TABLE moz_downloads "

         "ADD COLUMN preferredApplication TEXT"));

       NS_ENSURE_SUCCESS(rv, rv);

       rv = mDBConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING(

         "ALTER TABLE moz_downloads "

         "ADD COLUMN preferredAction INTEGER NOT NULL DEFAULT 0"));

       NS_ENSURE_SUCCESS(rv, rv);

       // Finally, update the schemaVersion variable and the database schema

       schemaVersion = 7;

       rv = mDBConn->SetSchemaVersion(schemaVersion);

       NS_ENSURE_SUCCESS(rv, rv);

     }

     // Fallthrough to next upgrade

   case 7: // This version adds a column to remember to auto-resume downloads

     {

       rv = mDBConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING(

         "ALTER TABLE moz_downloads "

         "ADD COLUMN autoResume INTEGER NOT NULL DEFAULT 0"));

       NS_ENSURE_SUCCESS(rv, rv);

       // Finally, update the schemaVersion variable and the database schema

       schemaVersion = 8;

       rv = mDBConn->SetSchemaVersion(schemaVersion);

       NS_ENSURE_SUCCESS(rv, rv);

     }

     // Fallthrough to the next upgrade

     // Warning: schema versions >=8 must take into account that they can

     // be operating on schemas from unknown, future versions that have

     // been downgraded. Operations such as adding columns may fail,

     // since the column may already exist.

   case 8: // This version adds a column for GUIDs

     {

       bool exists;

       rv = mDBConn->IndexExists(NS_LITERAL_CSTRING("moz_downloads_guid_uniqueindex"),

                                 &exists);

       NS_ENSURE_SUCCESS(rv, rv);

       if (!exists) {

         rv = mDBConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING(

           "ALTER TABLE moz_downloads ADD COLUMN guid TEXT"));

         NS_ENSURE_SUCCESS(rv, rv);

         rv = mDBConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING(

           "CREATE UNIQUE INDEX moz_downloads_guid_uniqueindex ON moz_downloads (guid)"));

         NS_ENSURE_SUCCESS(rv, rv);

       }

       rv = mDBConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING(

         "UPDATE moz_downloads SET guid = GENERATE_GUID() WHERE guid ISNULL"));

       NS_ENSURE_SUCCESS(rv, rv);

       // Finally, update the database schema

       schemaVersion = 9;

       rv = mDBConn->SetSchemaVersion(schemaVersion);

       NS_ENSURE_SUCCESS(rv, rv);

     }

     // Fallthrough to the next upgrade

   // Extra sanity checking for developers

 #ifndef DEBUG

   case DM_SCHEMA_VERSION:

 #endif

     break;

   case 0:

     {

       NS_WARNING("Could not get download database's schema version!");

       // The table may still be usable - someone may have just messed with the

       // schema version, so let's just treat this like a downgrade and verify

       // that the needed columns are there.  If they aren't there, we'll drop

       // the table anyway.

       rv = mDBConn->SetSchemaVersion(DM_SCHEMA_VERSION);

       NS_ENSURE_SUCCESS(rv, rv);

     }

     // Fallthrough to downgrade check

   // Downgrading

   // If columns have been added to the table, we can still use the ones we

   // understand safely.  If columns have been deleted or alterd, we just

   // drop the table and start from scratch.  If you change how a column

   // should be interpreted, make sure you also change its name so this

   // check will catch it.

   default:

     {

       nsCOMPtr<mozIStorageStatement> stmt;

       rv = mDBConn->CreateStatement(NS_LITERAL_CSTRING(

         "SELECT id, name, source, target, tempPath, startTime, endTime, state, "

                "referrer, entityID, currBytes, maxBytes, mimeType, "

                "preferredApplication, preferredAction, autoResume, guid "

         "FROM moz_downloads"), getter_AddRefs(stmt));

       if (NS_SUCCEEDED(rv)) {

         // We have a database that contains all of the elements that make up

         // the latest known schema. Reset the version to force an upgrade

         // path if this downgraded database is used in a later version.

         mDBConn->SetSchemaVersion(DM_SCHEMA_VERSION);

         break;

       }

       // if the statement fails, that means all the columns were not there.

       // First we backup the database

       nsCOMPtr<mozIStorageService> storage =

         do_GetService(MOZ_STORAGE_SERVICE_CONTRACTID);

       NS_ENSURE_TRUE(storage, NS_ERROR_NOT_AVAILABLE);

       nsCOMPtr<nsIFile> backup;

       rv = storage->BackupDatabaseFile(dbFile, DM_DB_CORRUPT_FILENAME, nullptr,

                                        getter_AddRefs(backup));

       NS_ENSURE_SUCCESS(rv, rv);

       // Then we dump it

       rv = mDBConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING(

         "DROP TABLE moz_downloads"));

       NS_ENSURE_SUCCESS(rv, rv);

       rv = CreateTable(mDBConn);

       NS_ENSURE_SUCCESS(rv, rv);

     }

     break;

   }

   return NS_OK;

 }

 nsresult

 nsDownloadManager::CreateTable(mozIStorageConnection* aDBConn)

 {

   nsresult rv = aDBConn->SetSchemaVersion(DM_SCHEMA_VERSION);

   if (NS_FAILED(rv)) return rv;

   rv = aDBConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING(

     "CREATE TABLE moz_downloads ("

       "id INTEGER PRIMARY KEY, "

       "name TEXT, "

       "source TEXT, "

       "target TEXT, "

       "tempPath TEXT, "

       "startTime INTEGER, "

       "endTime INTEGER, "

       "state INTEGER, "

       "referrer TEXT, "

       "entityID TEXT, "

       "currBytes INTEGER NOT NULL DEFAULT 0, "

       "maxBytes INTEGER NOT NULL DEFAULT -1, "

       "mimeType TEXT, "

       "preferredApplication TEXT, "

       "preferredAction INTEGER NOT NULL DEFAULT 0, "

       "autoResume INTEGER NOT NULL DEFAULT 0, "

       "guid TEXT"

     ")"));

   if (NS_FAILED(rv)) return rv;

   rv = aDBConn->ExecuteSimpleSQL(NS_LITERAL_CSTRING(

     "CREATE UNIQUE INDEX moz_downloads_guid_uniqueindex "

       "ON moz_downloads(guid)"));

   return rv;

 }

 nsresult

 nsDownloadManager::RestoreDatabaseState()

 {

   // Restore downloads that were in a scanning state.  We can assume that they

   // have been dealt with by the virus scanner

   nsCOMPtr<mozIStorageStatement> stmt;

   nsresult rv = mDBConn->CreateStatement(NS_LITERAL_CSTRING(

     "UPDATE moz_downloads "

     "SET state = :state "

     "WHERE state = :state_cond"), getter_AddRefs(stmt));

   NS_ENSURE_SUCCESS(rv, rv);

   rv = stmt->BindInt32ByName(NS_LITERAL_CSTRING("state"), nsIDownloadManager::DOWNLOAD_FINISHED);

   NS_ENSURE_SUCCESS(rv, rv);

   rv = stmt->BindInt32ByName(NS_LITERAL_CSTRING("state_cond"), nsIDownloadManager::DOWNLOAD_SCANNING);

   NS_ENSURE_SUCCESS(rv, rv);

   rv = stmt->Execute();

   NS_ENSURE_SUCCESS(rv, rv);

   // Convert supposedly-active downloads into downloads that should auto-resume

   rv = mDBConn->CreateStatement(NS_LITERAL_CSTRING(

     "UPDATE moz_downloads "

     "SET autoResume = :autoResume "

     "WHERE state = :notStarted "

       "OR state = :queued "

       "OR state = :downloading"), getter_AddRefs(stmt));

   NS_ENSURE_SUCCESS(rv, rv);

   rv = stmt->BindInt32ByName(NS_LITERAL_CSTRING("autoResume"), nsDownload::AUTO_RESUME);

   NS_ENSURE_SUCCESS(rv, rv);

   rv = stmt->BindInt32ByName(NS_LITERAL_CSTRING("notStarted"), nsIDownloadManager::DOWNLOAD_NOTSTARTED);

   NS_ENSURE_SUCCESS(rv, rv);

   rv = stmt->BindInt32ByName(NS_LITERAL_CSTRING("queued"), nsIDownloadManager::DOWNLOAD_QUEUED);

   NS_ENSURE_SUCCESS(rv, rv);

   rv = stmt->BindInt32ByName(NS_LITERAL_CSTRING("downloading"), nsIDownloadManager::DOWNLOAD_DOWNLOADING);

   NS_ENSURE_SUCCESS(rv, rv);

   rv = stmt->Execute();

   NS_ENSURE_SUCCESS(rv, rv);

   // Switch any download that is supposed to automatically resume and is in a

   // finished state to *not* automatically resume.  See Bug 409179 for details.

   rv = mDBConn->CreateStatement(NS_LITERAL_CSTRING(

     "UPDATE moz_downloads "

     "SET autoResume = :autoResume "

     "WHERE state = :state "

       "AND autoResume = :autoResume_cond"),

     getter_AddRefs(stmt));

   NS_ENSURE_SUCCESS(rv, rv);

   rv = stmt->BindInt32ByName(NS_LITERAL_CSTRING("autoResume"), nsDownload::DONT_RESUME);

   NS_ENSURE_SUCCESS(rv, rv);

   rv = stmt->BindInt32ByName(NS_LITERAL_CSTRING("state"), nsIDownloadManager::DOWNLOAD_FINISHED);

   NS_ENSURE_SUCCESS(rv, rv);

   rv = stmt->BindInt32ByName(NS_LITERAL_CSTRING("autoResume_cond"), nsDownload::AUTO_RESUME);

   NS_ENSURE_SUCCESS(rv, rv);

   rv = stmt->Execute();

   NS_ENSURE_SUCCESS(rv, rv);

   return NS_OK;

 }

 nsresult

 nsDownloadManager::RestoreActiveDownloads()

 {

   nsCOMPtr<mozIStorageStatement> stmt;

   nsresult rv = mDBConn->CreateStatement(NS_LITERAL_CSTRING(

     "SELECT id "

     "FROM moz_downloads "

     "WHERE (state = :state AND LENGTH(entityID) > 0) "

       "OR autoResume != :autoResume"), getter_AddRefs(stmt));

   NS_ENSURE_SUCCESS(rv, rv);

   rv = stmt->BindInt32ByName(NS_LITERAL_CSTRING("state"), nsIDownloadManager::DOWNLOAD_PAUSED);

   NS_ENSURE_SUCCESS(rv, rv);

   rv = stmt->BindInt32ByName(NS_LITERAL_CSTRING("autoResume"), nsDownload::DONT_RESUME);

   NS_ENSURE_SUCCESS(rv, rv);

   nsresult retVal = NS_OK;

   bool hasResults;

   while (NS_SUCCEEDED(stmt->ExecuteStep(&hasResults)) && hasResults) {

     nsRefPtr<nsDownload> dl;

     // Keep trying to add even if we fail one, but make sure to return failure.

     // Additionally, be careful to not call anything that tries to change the

     // database because we're iterating over a live statement.

     if (NS_FAILED(GetDownloadFromDB(stmt->AsInt32(0), getter_AddRefs(dl))) ||

         NS_FAILED(AddToCurrentDownloads(dl)))

       retVal = NS_ERROR_FAILURE;

   }

   // Try to resume only the downloads that should auto-resume

   rv = ResumeAllDownloads(false);

   NS_ENSURE_SUCCESS(rv, rv);

   return retVal;

 }

 int64_t

 nsDownloadManager::AddDownloadToDB(const nsAString &aName,

                                    const nsACString &aSource,

                                    const nsACString &aTarget,

                                    const nsAString &aTempPath,

                                    int64_t aStartTime,

                                    int64_t aEndTime,

                                    const nsACString &aMimeType,

                                    const nsACString &aPreferredApp,

                                    nsHandlerInfoAction aPreferredAction,

                                    bool aPrivate,

                                    nsACString& aNewGUID)

 {

   mozIStorageConnection* dbConn = aPrivate ? mPrivateDBConn : mDBConn;

   nsCOMPtr<mozIStorageStatement> stmt;

   nsresult rv = dbConn->CreateStatement(NS_LITERAL_CSTRING(

     "INSERT INTO moz_downloads "

     "(name, source, target, tempPath, startTime, endTime, state, "

      "mimeType, preferredApplication, preferredAction, guid) VALUES "

     "(:name, :source, :target, :tempPath, :startTime, :endTime, :state, "

      ":mimeType, :preferredApplication, :preferredAction, :guid)"),

     getter_AddRefs(stmt));

   NS_ENSURE_SUCCESS(rv, 0);

   rv = stmt->BindStringByName(NS_LITERAL_CSTRING("name"), aName);

   NS_ENSURE_SUCCESS(rv, 0);

   rv = stmt->BindUTF8StringByName(NS_LITERAL_CSTRING("source"), aSource);

   NS_ENSURE_SUCCESS(rv, 0);

   rv = stmt->BindUTF8StringByName(NS_LITERAL_CSTRING("target"), aTarget);

   NS_ENSURE_SUCCESS(rv, 0);

   rv = stmt->BindStringByName(NS_LITERAL_CSTRING("tempPath"), aTempPath);

   NS_ENSURE_SUCCESS(rv, 0);

   rv = stmt->BindInt64ByName(NS_LITERAL_CSTRING("startTime"), aStartTime);

   NS_ENSURE_SUCCESS(rv, 0);

   rv = stmt->BindInt64ByName(NS_LITERAL_CSTRING("endTime"), aEndTime);

   NS_ENSURE_SUCCESS(rv, 0);

   rv = stmt->BindInt32ByName(NS_LITERAL_CSTRING("state"), nsIDownloadManager::DOWNLOAD_NOTSTARTED);

   NS_ENSURE_SUCCESS(rv, 0);

   rv = stmt->BindUTF8StringByName(NS_LITERAL_CSTRING("mimeType"), aMimeType);

   NS_ENSURE_SUCCESS(rv, 0);

   rv = stmt->BindUTF8StringByName(NS_LITERAL_CSTRING("preferredApplication"), aPreferredApp);

   NS_ENSURE_SUCCESS(rv, 0);

   rv = stmt->BindInt32ByName(NS_LITERAL_CSTRING("preferredAction"), aPreferredAction);

   NS_ENSURE_SUCCESS(rv, 0);

   nsAutoCString guid;

   rv = GenerateGUID(guid);

   NS_ENSURE_SUCCESS(rv, 0);

   rv = stmt->BindUTF8StringByName(NS_LITERAL_CSTRING("guid"), guid);

   NS_ENSURE_SUCCESS(rv, 0);

   bool hasMore;

   rv = stmt->ExecuteStep(&hasMore); // we want to keep our lock

   NS_ENSURE_SUCCESS(rv, 0);

   int64_t id = 0;

   rv = dbConn->GetLastInsertRowID(&id);

   NS_ENSURE_SUCCESS(rv, 0);

   aNewGUID = guid;

   // lock on DB from statement will be released once we return

   return id;

 }

 nsresult

 nsDownloadManager::InitDB()

 {

   nsresult rv = InitPrivateDB();

   NS_ENSURE_SUCCESS(rv, rv);

   rv = InitFileDB();

   NS_ENSURE_SUCCESS(rv, rv);

   rv = InitStatements(mDBConn, getter_AddRefs(mUpdateDownloadStatement),

                       getter_AddRefs(mGetIdsForURIStatement));

   NS_ENSURE_SUCCESS(rv, rv);

   return NS_OK;

 }

 nsresult

 nsDownloadManager::InitStatements(mozIStorageConnection* aDBConn,

                                   mozIStorageStatement** aUpdateStatement,

                                   mozIStorageStatement** aGetIdsStatement)

 {

   nsresult rv = aDBConn->CreateStatement(NS_LITERAL_CSTRING(

     "UPDATE moz_downloads "

     "SET tempPath = :tempPath, startTime = :startTime, endTime = :endTime, "

       "state = :state, referrer = :referrer, entityID = :entityID, "

       "currBytes = :currBytes, maxBytes = :maxBytes, autoResume = :autoResume "

     "WHERE id = :id"), aUpdateStatement);

   NS_ENSURE_SUCCESS(rv, rv);

   rv = aDBConn->CreateStatement(NS_LITERAL_CSTRING(

     "SELECT guid "

     "FROM moz_downloads "

     "WHERE source = :source"), aGetIdsStatement);

   NS_ENSURE_SUCCESS(rv, rv);

   return NS_OK;

 }

 nsresult

 nsDownloadManager::Init()

 {

   nsresult rv;

   nsCOMPtr<nsIStringBundleService> bundleService =

     mozilla::services::GetStringBundleService();

   if (!bundleService)

     return NS_ERROR_FAILURE;

   rv = bundleService->CreateBundle(DOWNLOAD_MANAGER_BUNDLE,

                                    getter_AddRefs(mBundle));

   NS_ENSURE_SUCCESS(rv, rv);

 #if !defined(MOZ_JSDOWNLOADS)

   // When MOZ_JSDOWNLOADS is undefined, we still check the preference that can

   // be used to enable the JavaScript API during the migration process.

   mUseJSTransfer = Preferences::GetBool(PREF_BD_USEJSTRANSFER, false);

 #else

   nsAutoCString appID;

   nsCOMPtr<nsIXULAppInfo> info = do_GetService("@mozilla.org/xre/app-info;1");

   if (info) {

     rv = info->GetID(appID);

     NS_ENSURE_SUCCESS(rv, rv);

   }

   // The webapp runtime doesn't use the new JS downloads API yet.

   // The conversion of the webapp runtime to use the JavaScript API for

   // downloads is tracked in bug 911636.

   if (appID.EqualsLiteral("webapprt@mozilla.org")) {

     mUseJSTransfer = false;

   } else {

 #if !defined(XP_WIN)

     mUseJSTransfer = true;

 #else

     // When MOZ_JSDOWNLOADS is defined on Windows, this component is disabled

     // unless we are running in Windows Metro.  The conversion of Windows Metro

     // to use the JavaScript API for downloads is tracked in bug 906042.

     mUseJSTransfer = !IsRunningInWindowsMetro();

 #endif

   }

 #endif

   if (mUseJSTransfer)

     return NS_OK;

   // Clean up any old downloads.rdf files from before Firefox 3

   {

     nsCOMPtr<nsIFile> oldDownloadsFile;

     bool fileExists;

     if (NS_SUCCEEDED(NS_GetSpecialDirectory(NS_APP_DOWNLOADS_50_FILE,

           getter_AddRefs(oldDownloadsFile))) &&

         NS_SUCCEEDED(oldDownloadsFile->Exists(&fileExists)) &&

         fileExists) {

       (void)oldDownloadsFile->Remove(false);

     }

   }

   mObserverService = mozilla::services::GetObserverService();

   if (!mObserverService)

     return NS_ERROR_FAILURE;

   rv = InitDB();

   NS_ENSURE_SUCCESS(rv, rv);

 #ifdef DOWNLOAD_SCANNER

   mScanner = new nsDownloadScanner();

   if (!mScanner)

     return NS_ERROR_OUT_OF_MEMORY;

   rv = mScanner->Init();

   if (NS_FAILED(rv)) {

     delete mScanner;

     mScanner = nullptr;

   }

 #endif

   // Do things *after* initializing various download manager properties such as

   // restoring downloads to a consistent state

   rv = RestoreDatabaseState();

   NS_ENSURE_SUCCESS(rv, rv);

   rv = RestoreActiveDownloads();

   NS_WARN_IF_FALSE(NS_SUCCEEDED(rv), "Failed to restore all active downloads");

   nsCOMPtr<nsINavHistoryService> history =

     do_GetService(NS_NAVHISTORYSERVICE_CONTRACTID);

   (void)mObserverService->NotifyObservers(

                                 static_cast<nsIDownloadManager *>(this),

                                 "download-manager-initialized",

                                 nullptr);

   // The following AddObserver calls must be the last lines in this function,

   // because otherwise, this function may fail (and thus, this object would be not

   // completely initialized), but the observerservice would still keep a reference

   // to us and notify us about shutdown, which may cause crashes.

   // failure to add an observer is not critical

   (void)mObserverService->AddObserver(this, "quit-application", true);

   (void)mObserverService->AddObserver(this, "quit-application-requested", true);

   (void)mObserverService->AddObserver(this, "offline-requested", true);

   (void)mObserverService->AddObserver(this, "sleep_notification", true);

   (void)mObserverService->AddObserver(this, "wake_notification", true);

   (void)mObserverService->AddObserver(this, "suspend_process_notification", true);

   (void)mObserverService->AddObserver(this, "resume_process_notification", true);

   (void)mObserverService->AddObserver(this, "profile-before-change", true);

   (void)mObserverService->AddObserver(this, NS_IOSERVICE_GOING_OFFLINE_TOPIC, true);

   (void)mObserverService->AddObserver(this, NS_IOSERVICE_OFFLINE_STATUS_TOPIC, true);

   (void)mObserverService->AddObserver(this, "last-pb-context-exited", true);

   (void)mObserverService->AddObserver(this, "last-pb-context-exiting", true);

   if (history)

     (void)history->AddObserver(this, true);

   return NS_OK;

 }

 int32_t

 nsDownloadManager::GetRetentionBehavior()

 {

   // We use 0 as the default, which is "remove when done"

   nsresult rv;

   nsCOMPtr<nsIPrefBranch> pref = do_GetService(NS_PREFSERVICE_CONTRACTID, &rv);

   NS_ENSURE_SUCCESS(rv, 0);

   int32_t val;

   rv = pref->GetIntPref(PREF_BDM_RETENTION, &val);

   NS_ENSURE_SUCCESS(rv, 0);

   // Allow the Downloads Panel to change the retention behavior.  We do this to

   // allow proper migration to the new feature when using the same profile on

   // multiple versions of the product (bug 697678).  Implementation note: in

   // order to allow observers to change the retention value, we have to pass an

   // object in the aSubject parameter, we cannot use aData for that.

   nsCOMPtr<nsISupportsPRInt32> retentionBehavior =

     do_CreateInstance(NS_SUPPORTS_PRINT32_CONTRACTID);

   retentionBehavior->SetData(val);

   (void)mObserverService->NotifyObservers(retentionBehavior,

                                           "download-manager-change-retention",

                                           nullptr);

   retentionBehavior->GetData(&val);

   return val;

 }

 enum nsDownloadManager::QuitBehavior

 nsDownloadManager::GetQuitBehavior()

 {

   // We use 0 as the default, which is "remember and resume the download"

   nsresult rv;

   nsCOMPtr<nsIPrefBranch> pref = do_GetService(NS_PREFSERVICE_CONTRACTID, &rv);

   NS_ENSURE_SUCCESS(rv, QUIT_AND_RESUME);

   int32_t val;

   rv = pref->GetIntPref(PREF_BDM_QUITBEHAVIOR, &val);

   NS_ENSURE_SUCCESS(rv, QUIT_AND_RESUME);

   switch (val) {

     case 1:

       return QUIT_AND_PAUSE;

     case 2:

       return QUIT_AND_CANCEL;

     default:

       return QUIT_AND_RESUME;

   }

 }

 // Using a globally-unique GUID, search all databases (both private and public).

 // A return value of NS_ERROR_NOT_AVAILABLE means no download with the given GUID

 // could be found, either private or public.

 nsresult

 nsDownloadManager::GetDownloadFromDB(const nsACString& aGUID, nsDownload **retVal)

 {

   MOZ_ASSERT(!FindDownload(aGUID),

              "If it is a current download, you should not call this method!");

   NS_NAMED_LITERAL_CSTRING(query,

     "SELECT id, state, startTime, source, target, tempPath, name, referrer, "

            "entityID, currBytes, maxBytes, mimeType, preferredAction, "

            "preferredApplication, autoResume, guid "

     "FROM moz_downloads "

     "WHERE guid = :guid");

   // First, let's query the database and see if it even exists

   nsCOMPtr<mozIStorageStatement> stmt;

   nsresult rv = mDBConn->CreateStatement(query, getter_AddRefs(stmt));

   NS_ENSURE_SUCCESS(rv, rv);

   rv = stmt->BindUTF8StringByName(NS_LITERAL_CSTRING("guid"), aGUID);

   NS_ENSURE_SUCCESS(rv, rv);

   rv = GetDownloadFromDB(mDBConn, stmt, retVal);

   // If the download cannot be found in the public database, try again

   // in the private one. Otherwise, return whatever successful result

   // or failure obtained from the public database.

   if (rv == NS_ERROR_NOT_AVAILABLE) {

     rv = mPrivateDBConn->CreateStatement(query, getter_AddRefs(stmt));

     NS_ENSURE_SUCCESS(rv, rv);

     rv = stmt->BindUTF8StringByName(NS_LITERAL_CSTRING("guid"), aGUID);

     NS_ENSURE_SUCCESS(rv, rv);

     rv = GetDownloadFromDB(mPrivateDBConn, stmt, retVal);

     // Only if it still cannot be found do we report the failure.

     if (rv == NS_ERROR_NOT_AVAILABLE) {

       *retVal = nullptr;

     }

   }

   return rv;

 }

 nsresult

 nsDownloadManager::GetDownloadFromDB(uint32_t aID, nsDownload **retVal)

 {

   NS_WARNING("Using integer IDs without compat mode enabled");

   MOZ_ASSERT(!FindDownload(aID),

              "If it is a current download, you should not call this method!");

   // First, let's query the database and see if it even exists

   nsCOMPtr<mozIStorageStatement> stmt;

   nsresult rv = mDBConn->CreateStatement(NS_LITERAL_CSTRING(

     "SELECT id, state, startTime, source, target, tempPath, name, referrer, "

            "entityID, currBytes, maxBytes, mimeType, preferredAction, "

            "preferredApplication, autoResume, guid "

     "FROM moz_downloads "

     "WHERE id = :id"), getter_AddRefs(stmt));

   NS_ENSURE_SUCCESS(rv, rv);

   rv = stmt->BindInt64ByName(NS_LITERAL_CSTRING("id"), aID);

   NS_ENSURE_SUCCESS(rv, rv);

   return GetDownloadFromDB(mDBConn, stmt, retVal);

 }

 nsresult

 nsDownloadManager::GetDownloadFromDB(mozIStorageConnection* aDBConn,

                                      mozIStorageStatement* stmt,

                                      nsDownload **retVal)

 {

   bool hasResults = false;

   nsresult rv = stmt->ExecuteStep(&hasResults);

   if (NS_FAILED(rv) || !hasResults)

     return NS_ERROR_NOT_AVAILABLE;

   // We have a download, so lets create it

   nsRefPtr<nsDownload> dl = new nsDownload();

   if (!dl)

     return NS_ERROR_OUT_OF_MEMORY;

   dl->mPrivate = aDBConn == mPrivateDBConn;

   dl->mDownloadManager = this;

   int32_t i = 0;

   // Setting all properties of the download now

   dl->mCancelable = nullptr;

   dl->mID = stmt->AsInt64(i++);

   dl->mDownloadState = stmt->AsInt32(i++);

   dl->mStartTime = stmt->AsInt64(i++);

   nsCString source;

   stmt->GetUTF8String(i++, source);

   rv = NS_NewURI(getter_AddRefs(dl->mSource), source);

   NS_ENSURE_SUCCESS(rv, rv);

   nsCString target;

   stmt->GetUTF8String(i++, target);

   rv = NS_NewURI(getter_AddRefs(dl->mTarget), target);

   NS_ENSURE_SUCCESS(rv, rv);

   nsString tempPath;

   stmt->GetString(i++, tempPath);

   if (!tempPath.IsEmpty()) {

     rv = NS_NewLocalFile(tempPath, true, getter_AddRefs(dl->mTempFile));

     NS_ENSURE_SUCCESS(rv, rv);

   }

   stmt->GetString(i++, dl->mDisplayName);

   nsCString referrer;

   rv = stmt->GetUTF8String(i++, referrer);

   if (NS_SUCCEEDED(rv) && !referrer.IsEmpty()) {

     rv = NS_NewURI(getter_AddRefs(dl->mReferrer), referrer);

     NS_ENSURE_SUCCESS(rv, rv);

   }

   rv = stmt->GetUTF8String(i++, dl->mEntityID);

   NS_ENSURE_SUCCESS(rv, rv);

   int64_t currBytes = stmt->AsInt64(i++);

   int64_t maxBytes = stmt->AsInt64(i++);

   dl->SetProgressBytes(currBytes, maxBytes);

   // Build mMIMEInfo only if the mimeType in DB is not empty

   nsAutoCString mimeType;

   rv = stmt->GetUTF8String(i++, mimeType);

   NS_ENSURE_SUCCESS(rv, rv);

   if (!mimeType.IsEmpty()) {

     nsCOMPtr<nsIMIMEService> mimeService =

       do_GetService(NS_MIMESERVICE_CONTRACTID, &rv);

     NS_ENSURE_SUCCESS(rv, rv);

     rv = mimeService->GetFromTypeAndExtension(mimeType, EmptyCString(),

                                               getter_AddRefs(dl->mMIMEInfo));

     NS_ENSURE_SUCCESS(rv, rv);

     nsHandlerInfoAction action = stmt->AsInt32(i++);

     rv = dl->mMIMEInfo->SetPreferredAction(action);

     NS_ENSURE_SUCCESS(rv, rv);

     nsAutoCString persistentDescriptor;

     rv = stmt->GetUTF8String(i++, persistentDescriptor);

     NS_ENSURE_SUCCESS(rv, rv);

     if (!persistentDescriptor.IsEmpty()) {

       nsCOMPtr<nsILocalHandlerApp> handler =

         do_CreateInstance(NS_LOCALHANDLERAPP_CONTRACTID, &rv);

       NS_ENSURE_SUCCESS(rv, rv);

       nsCOMPtr<nsIFile> localExecutable;

       rv = NS_NewNativeLocalFile(EmptyCString(), false,

                                  getter_AddRefs(localExecutable));

       NS_ENSURE_SUCCESS(rv, rv);

       rv = localExecutable->SetPersistentDescriptor(persistentDescriptor);

       NS_ENSURE_SUCCESS(rv, rv);

       rv = handler->SetExecutable(localExecutable);

       NS_ENSURE_SUCCESS(rv, rv);

       rv = dl->mMIMEInfo->SetPreferredApplicationHandler(handler);

       NS_ENSURE_SUCCESS(rv, rv);

     }

   } else {

     // Compensate for the i++s skipped in the true block

     i += 2;

   }

   dl->mAutoResume =

     static_cast<enum nsDownload::AutoResume>(stmt->AsInt32(i++));

   rv = stmt->GetUTF8String(i++, dl->mGUID);

   NS_ENSURE_SUCCESS(rv, rv);

   // Handle situations where we load a download from a database that has been

   // used in an older version and not gone through the upgrade path (ie. it

   // contains empty GUID entries).

   if (dl->mGUID.IsEmpty()) {

     rv = GenerateGUID(dl->mGUID);

     NS_ENSURE_SUCCESS(rv, rv);

     nsCOMPtr<mozIStorageStatement> stmt;

     rv = mDBConn->CreateStatement(NS_LITERAL_CSTRING(

                                     "UPDATE moz_downloads SET guid = :guid "

                                     "WHERE id = :id"),

                                   getter_AddRefs(stmt));

     NS_ENSURE_SUCCESS(rv, rv);

     rv = stmt->BindUTF8StringByName(NS_LITERAL_CSTRING("guid"), dl->mGUID);

     NS_ENSURE_SUCCESS(rv, rv);

     rv = stmt->BindInt64ByName(NS_LITERAL_CSTRING("id"), dl->mID);

     NS_ENSURE_SUCCESS(rv, rv);

     rv = stmt->Execute();

     NS_ENSURE_SUCCESS(rv, rv);

   }

   // Addrefing and returning

   NS_ADDREF(*retVal = dl);

   return NS_OK;

 }

 nsresult

 nsDownloadManager::AddToCurrentDownloads(nsDownload *aDl)

 {

   nsCOMArray<nsDownload>& currentDownloads =

     aDl->mPrivate ? mCurrentPrivateDownloads : mCurrentDownloads;

   if (!currentDownloads.AppendObject(aDl))

     return NS_ERROR_OUT_OF_MEMORY;

   aDl->mDownloadManager = this;

   return NS_OK;

 }

 void

 nsDownloadManager::SendEvent(nsDownload *aDownload, const char *aTopic)

 {

   (void)mObserverService->NotifyObservers(aDownload, aTopic, nullptr);

 }

 ////////////////////////////////////////////////////////////////////////////////

 //// nsIDownloadManager

 NS_IMETHODIMP

 nsDownloadManager::GetActivePrivateDownloadCount(int32_t* aResult)

 {

   NS_ENSURE_STATE(!mUseJSTransfer);

   *aResult = mCurrentPrivateDownloads.Count();

   return NS_OK;

 }

 NS_IMETHODIMP

 nsDownloadManager::GetActiveDownloadCount(int32_t *aResult)

 {

   NS_ENSURE_STATE(!mUseJSTransfer);

   *aResult = mCurrentDownloads.Count();

   return NS_OK;

 }

 NS_IMETHODIMP

 nsDownloadManager::GetActiveDownloads(nsISimpleEnumerator **aResult)

 {

   NS_ENSURE_STATE(!mUseJSTransfer);

   return NS_NewArrayEnumerator(aResult, mCurrentDownloads);

 }

 NS_IMETHODIMP

 nsDownloadManager::GetActivePrivateDownloads(nsISimpleEnumerator **aResult)

 {

   NS_ENSURE_STATE(!mUseJSTransfer);

   return NS_NewArrayEnumerator(aResult, mCurrentPrivateDownloads);

 }

 /**

  * For platforms where helper apps use the downloads directory (i.e. mobile),

  * this should be kept in sync with nsExternalHelperAppService.cpp

  */

 NS_IMETHODIMP

 nsDownloadManager::GetDefaultDownloadsDirectory(nsIFile **aResult)

 {

   nsCOMPtr<nsIFile> downloadDir;

   nsresult rv;

   nsCOMPtr<nsIProperties> dirService =

      do_GetService(NS_DIRECTORY_SERVICE_CONTRACTID, &rv);

   NS_ENSURE_SUCCESS(rv, rv);

   // OSX 10.4:

   // Desktop

   // OSX 10.5:

   // User download directory

   // Vista:

   // Downloads

   // XP/2K:

   // My Documents/Downloads

   // Linux:

   // XDG user dir spec, with a fallback to Home/Downloads

   nsXPIDLString folderName;

   mBundle->GetStringFromName(MOZ_UTF16("downloadsFolder"),

                              getter_Copies(folderName));

 #if defined (XP_MACOSX)

   rv = dirService->Get(NS_OSX_DEFAULT_DOWNLOAD_DIR,

                        NS_GET_IID(nsIFile),

                        getter_AddRefs(downloadDir));

   NS_ENSURE_SUCCESS(rv, rv);

 #elif defined(XP_WIN)

   rv = dirService->Get(NS_WIN_DEFAULT_DOWNLOAD_DIR,

                        NS_GET_IID(nsIFile),

                        getter_AddRefs(downloadDir));

   NS_ENSURE_SUCCESS(rv, rv);

   // Check the os version

   nsCOMPtr<nsIPropertyBag2> infoService =

      do_GetService(NS_SYSTEMINFO_CONTRACTID, &rv);

   NS_ENSURE_SUCCESS(rv, rv);

   int32_t version;

   NS_NAMED_LITERAL_STRING(osVersion, "version");

   rv = infoService->GetPropertyAsInt32(osVersion, &version);

   NS_ENSURE_SUCCESS(rv, rv);

   if (version < 6) { // XP/2K

     // First get "My Documents"

     rv = dirService->Get(NS_WIN_PERSONAL_DIR,

                          NS_GET_IID(nsIFile),

                          getter_AddRefs(downloadDir));

     NS_ENSURE_SUCCESS(rv, rv);

     rv = downloadDir->Append(folderName);

     NS_ENSURE_SUCCESS(rv, rv);

     // This could be the first time we are creating the downloads folder in My

     // Documents, so make sure it exists.

     bool exists;

     rv = downloadDir->Exists(&exists);

     NS_ENSURE_SUCCESS(rv, rv);

     if (!exists) {

       rv = downloadDir->Create(nsIFile::DIRECTORY_TYPE, 0755);

       NS_ENSURE_SUCCESS(rv, rv);

     }

   }

 #elif defined(XP_UNIX)

 #if defined(MOZ_WIDGET_ANDROID)

     // Android doesn't have a $HOME directory, and by default we only have

     // write access to /data/data/org.mozilla.{$APP} and /sdcard

     char* downloadDirPath = getenv("DOWNLOADS_DIRECTORY");

     if (downloadDirPath) {

       rv = NS_NewNativeLocalFile(nsDependentCString(downloadDirPath),

                                  true, getter_AddRefs(downloadDir));

       NS_ENSURE_SUCCESS(rv, rv);

     }

     else {

       rv = NS_ERROR_FAILURE;

     }

 #else

   rv = dirService->Get(NS_UNIX_DEFAULT_DOWNLOAD_DIR,

                        NS_GET_IID(nsIFile),

                        getter_AddRefs(downloadDir));

   // fallback to Home/Downloads

   if (NS_FAILED(rv)) {

     rv = dirService->Get(NS_UNIX_HOME_DIR,

                          NS_GET_IID(nsIFile),

                          getter_AddRefs(downloadDir));

     NS_ENSURE_SUCCESS(rv, rv);

     rv = downloadDir->Append(folderName);

     NS_ENSURE_SUCCESS(rv, rv);

   }

 #endif

 #else

   rv = dirService->Get(NS_OS_HOME_DIR,

                        NS_GET_IID(nsIFile),

                        getter_AddRefs(downloadDir));

   NS_ENSURE_SUCCESS(rv, rv);

   rv = downloadDir->Append(folderName);

   NS_ENSURE_SUCCESS(rv, rv);

 #endif

   downloadDir.forget(aResult);

   return NS_OK;

 }

 #define NS_BRANCH_DOWNLOAD     "browser.download."

 #define NS_PREF_FOLDERLIST     "folderList"

 #define NS_PREF_DIR            "dir"

 NS_IMETHODIMP

 nsDownloadManager::GetUserDownloadsDirectory(nsIFile **aResult)

 {

   nsresult rv;

   nsCOMPtr<nsIProperties> dirService =

      do_GetService(NS_DIRECTORY_SERVICE_CONTRACTID, &rv);

   NS_ENSURE_SUCCESS(rv, rv);

   nsCOMPtr<nsIPrefService> prefService =

      do_GetService(NS_PREFSERVICE_CONTRACTID, &rv);

   NS_ENSURE_SUCCESS(rv, rv);

   nsCOMPtr<nsIPrefBranch> prefBranch;

   rv = prefService->GetBranch(NS_BRANCH_DOWNLOAD,

                               getter_AddRefs(prefBranch));

   NS_ENSURE_SUCCESS(rv, rv);

   int32_t val;

   rv = prefBranch->GetIntPref(NS_PREF_FOLDERLIST,

                               &val);

   NS_ENSURE_SUCCESS(rv, rv);

   switch(val) {

     case 0: // Desktop

       {

         nsCOMPtr<nsIFile> downloadDir;

         nsCOMPtr<nsIProperties> dirService =

            do_GetService(NS_DIRECTORY_SERVICE_CONTRACTID, &rv);

         NS_ENSURE_SUCCESS(rv, rv);

         rv = dirService->Get(NS_OS_DESKTOP_DIR,

                              NS_GET_IID(nsIFile),

                              getter_AddRefs(downloadDir));

         NS_ENSURE_SUCCESS(rv, rv);

         downloadDir.forget(aResult);

         return NS_OK;

       }

       break;

     case 1: // Downloads

       return GetDefaultDownloadsDirectory(aResult);

     case 2: // Custom

       {

         nsCOMPtr<nsIFile> customDirectory;

         prefBranch->GetComplexValue(NS_PREF_DIR,

                                     NS_GET_IID(nsIFile),

                                     getter_AddRefs(customDirectory));

         if (customDirectory) {

           bool exists = false;

           (void)customDirectory->Exists(&exists);

           if (!exists) {

             rv = customDirectory->Create(nsIFile::DIRECTORY_TYPE, 0755);

             if (NS_SUCCEEDED(rv)) {

               customDirectory.forget(aResult);

               return NS_OK;

             }

             // Create failed, so it still doesn't exist.  Fall out and get the

             // default downloads directory.

           }

           bool writable = false;

           bool directory = false;

           (void)customDirectory->IsWritable(&writable);

           (void)customDirectory->IsDirectory(&directory);

           if (exists && writable && directory) {

             customDirectory.forget(aResult);

             return NS_OK;

           }

         }

         rv = GetDefaultDownloadsDirectory(aResult);

         if (NS_SUCCEEDED(rv)) {

           (void)prefBranch->SetComplexValue(NS_PREF_DIR,

                                             NS_GET_IID(nsIFile),

                                             *aResult);

         }

         return rv;

       }

       break;

   }

   return NS_ERROR_INVALID_ARG;

 }

 NS_IMETHODIMP

 nsDownloadManager::AddDownload(DownloadType aDownloadType,

                                nsIURI *aSource,

                                nsIURI *aTarget,

                                const nsAString& aDisplayName,

                                nsIMIMEInfo *aMIMEInfo,

                                PRTime aStartTime,

                                nsIFile *aTempFile,

                                nsICancelable *aCancelable,

                                bool aIsPrivate,

                                nsIDownload **aDownload)

 {

   NS_ENSURE_STATE(!mUseJSTransfer);

   NS_ENSURE_ARG_POINTER(aSource);

   NS_ENSURE_ARG_POINTER(aTarget);

   NS_ENSURE_ARG_POINTER(aDownload);

   nsresult rv;

   // target must be on the local filesystem

   nsCOMPtr<nsIFileURL> targetFileURL = do_QueryInterface(aTarget, &rv);

   NS_ENSURE_SUCCESS(rv, rv);

   nsCOMPtr<nsIFile> targetFile;

   rv = targetFileURL->GetFile(getter_AddRefs(targetFile));

   NS_ENSURE_SUCCESS(rv, rv);

   nsRefPtr<nsDownload> dl = new nsDownload();

   if (!dl)

     return NS_ERROR_OUT_OF_MEMORY;

   // give our new nsIDownload some info so it's ready to go off into the world

   dl->mTarget = aTarget;

   dl->mSource = aSource;

   dl->mTempFile = aTempFile;

   dl->mPrivate = aIsPrivate;

   dl->mDisplayName = aDisplayName;

   if (dl->mDisplayName.IsEmpty())

     targetFile->GetLeafName(dl->mDisplayName);

   dl->mMIMEInfo = aMIMEInfo;

   dl->SetStartTime(aStartTime == 0 ? PR_Now() : aStartTime);

   // Creates a cycle that will be broken when the download finishes

   dl->mCancelable = aCancelable;

   // Adding to the DB

   nsAutoCString source, target;

   aSource->GetSpec(source);

   aTarget->GetSpec(target);

   // Track the temp file for exthandler downloads

   nsAutoString tempPath;

   if (aTempFile)

     aTempFile->GetPath(tempPath);

   // Break down MIMEInfo but don't panic if we can't get all the pieces - we

   // can still download the file

   nsAutoCString persistentDescriptor, mimeType;

   nsHandlerInfoAction action = nsIMIMEInfo::saveToDisk;

   if (aMIMEInfo) {

     (void)aMIMEInfo->GetType(mimeType);

     nsCOMPtr<nsIHandlerApp> handlerApp;

     (void)aMIMEInfo->GetPreferredApplicationHandler(getter_AddRefs(handlerApp));

     nsCOMPtr<nsILocalHandlerApp> locHandlerApp = do_QueryInterface(handlerApp);

     if (locHandlerApp) {

       nsCOMPtr<nsIFile> executable;

       (void)locHandlerApp->GetExecutable(getter_AddRefs(executable));

       (void)executable->GetPersistentDescriptor(persistentDescriptor);

     }

     (void)aMIMEInfo->GetPreferredAction(&action);

   }

   int64_t id = AddDownloadToDB(dl->mDisplayName, source, target, tempPath,

                                dl->mStartTime, dl->mLastUpdate,

                                mimeType, persistentDescriptor, action,

                                dl->mPrivate, dl->mGUID /* outparam */);

   NS_ENSURE_TRUE(id, NS_ERROR_FAILURE);

   dl->mID = id;

   rv = AddToCurrentDownloads(dl);

   (void)dl->SetState(nsIDownloadManager::DOWNLOAD_QUEUED);

   NS_ENSURE_SUCCESS(rv, rv);

 #ifdef DOWNLOAD_SCANNER

   if (mScanner) {

     bool scan = true;

     nsCOMPtr<nsIPrefBranch> prefs(do_GetService(NS_PREFSERVICE_CONTRACTID));

     if (prefs) {

       (void)prefs->GetBoolPref(PREF_BDM_SCANWHENDONE, &scan);

     }

     // We currently apply local security policy to downloads when we scan

     // via windows all-in-one download security api. The CheckPolicy call

     // below is a pre-emptive part of that process. So tie applying security

     // zone policy settings when downloads are intiated to the same pref

     // that triggers applying security zone policy settings after a download

     // completes. (bug 504804)

     if (scan) {

       AVCheckPolicyState res = mScanner->CheckPolicy(aSource, aTarget);

       if (res == AVPOLICY_BLOCKED) {

         // This download will get deleted during a call to IAE's Save,

         // so go ahead and mark it as blocked and avoid the download.

         (void)CancelDownload(id);

         (void)dl->SetState(nsIDownloadManager::DOWNLOAD_BLOCKED_POLICY);

       }

     }

   }

 #endif

   // Check with parental controls to see if file downloads

   // are allowed for this user. If not allowed, cancel the

   // download and mark its state as being blocked.

   nsCOMPtr<nsIParentalControlsService> pc =

     do_CreateInstance(NS_PARENTALCONTROLSSERVICE_CONTRACTID);

   if (pc) {

     bool enabled = false;

     (void)pc->GetBlockFileDownloadsEnabled(&enabled);

     if (enabled) {

       (void)CancelDownload(id);

       (void)dl->SetState(nsIDownloadManager::DOWNLOAD_BLOCKED_PARENTAL);

     }

     // Log the event if required by pc settings.

     bool logEnabled = false;

     (void)pc->GetLoggingEnabled(&logEnabled);

     if (logEnabled) {

       (void)pc->Log(nsIParentalControlsService::ePCLog_FileDownload,

                     enabled,

                     aSource,

                     nullptr);

     }

   }

   NS_ADDREF(*aDownload = dl);

   return NS_OK;

 }

 NS_IMETHODIMP

 nsDownloadManager::GetDownload(uint32_t aID, nsIDownload **aDownloadItem)

 {

   NS_ENSURE_STATE(!mUseJSTransfer);

   NS_WARNING("Using integer IDs without compat mode enabled");

   nsDownload *itm = FindDownload(aID);

   nsRefPtr<nsDownload> dl;

   if (!itm) {

     nsresult rv = GetDownloadFromDB(aID, getter_AddRefs(dl));

     NS_ENSURE_SUCCESS(rv, rv);

     itm = dl.get();

   }

   NS_ADDREF(*aDownloadItem = itm);

   return NS_OK;

 }

 namespace {

 class AsyncResult : public nsRunnable

 {

 public:

   AsyncResult(nsresult aStatus, nsIDownload* aResult,

               nsIDownloadManagerResult* aCallback)

   : mStatus(aStatus), mResult(aResult), mCallback(aCallback)

   {

   }

   NS_IMETHOD Run()

   {

     mCallback->HandleResult(mStatus, mResult);

     return NS_OK;

   }

 private:

   nsresult mStatus;

   nsCOMPtr<nsIDownload> mResult;

   nsCOMPtr<nsIDownloadManagerResult> mCallback;

 };

 } // anonymous namespace

 NS_IMETHODIMP

 nsDownloadManager::GetDownloadByGUID(const nsACString& aGUID,

                                      nsIDownloadManagerResult* aCallback)

 {

   NS_ENSURE_STATE(!mUseJSTransfer);

   nsDownload *itm = FindDownload(aGUID);

   nsresult rv = NS_OK;

   nsRefPtr<nsDownload> dl;

   if (!itm) {

     rv = GetDownloadFromDB(aGUID, getter_AddRefs(dl));

     itm = dl.get();

   }

   nsRefPtr<AsyncResult> runnable = new AsyncResult(rv, itm, aCallback);

   NS_DispatchToMainThread(runnable);

   return NS_OK;

 }

 nsDownload *

 nsDownloadManager::FindDownload(uint32_t aID)

 {

   // we shouldn't ever have many downloads, so we can loop over them

   for (int32_t i = mCurrentDownloads.Count() - 1; i >= 0; --i) {

     nsDownload *dl = mCurrentDownloads[i];

     if (dl->mID == aID)

       return dl;

   }

   return nullptr;

 }

 nsDownload *

 nsDownloadManager::FindDownload(const nsACString& aGUID)

 {

   // we shouldn't ever have many downloads, so we can loop over them

   for (int32_t i = mCurrentDownloads.Count() - 1; i >= 0; --i) {

     nsDownload *dl = mCurrentDownloads[i];

     if (dl->mGUID == aGUID)

       return dl;

   }

   for (int32_t i = mCurrentPrivateDownloads.Count() - 1; i >= 0; --i) {

     nsDownload *dl = mCurrentPrivateDownloads[i];

     if (dl->mGUID == aGUID)

       return dl;

   }

   return nullptr;

 }

 NS_IMETHODIMP

 nsDownloadManager::CancelDownload(uint32_t aID)

 {

   NS_ENSURE_STATE(!mUseJSTransfer);

   NS_WARNING("Using integer IDs without compat mode enabled");

   // We AddRef here so we don't lose access to member variables when we remove

   nsRefPtr<nsDownload> dl = FindDownload(aID);

   // if it's null, someone passed us a bad id.

   if (!dl)

     return NS_ERROR_FAILURE;

   return dl->Cancel();

 }

 nsresult

 nsDownloadManager::RetryDownload(const nsACString& aGUID)

 {

   nsRefPtr<nsDownload> dl;

   nsresult rv = GetDownloadFromDB(aGUID, getter_AddRefs(dl));

   NS_ENSURE_SUCCESS(rv, rv);

   return RetryDownload(dl);

 }

 NS_IMETHODIMP

 nsDownloadManager::RetryDownload(uint32_t aID)

 {

   NS_ENSURE_STATE(!mUseJSTransfer);

   NS_WARNING("Using integer IDs without compat mode enabled");

   nsRefPtr<nsDownload> dl;

   nsresult rv = GetDownloadFromDB(aID, getter_AddRefs(dl));

   NS_ENSURE_SUCCESS(rv, rv);

   return RetryDownload(dl);

 }

 nsresult

 nsDownloadManager::RetryDownload(nsDownload* dl)

 {

   // if our download is not canceled or failed, we should fail

   if (dl->mDownloadState != nsIDownloadManager::DOWNLOAD_FAILED &&

       dl->mDownloadState != nsIDownloadManager::DOWNLOAD_BLOCKED_PARENTAL &&

       dl->mDownloadState != nsIDownloadManager::DOWNLOAD_BLOCKED_POLICY &&

       dl->mDownloadState != nsIDownloadManager::DOWNLOAD_DIRTY &&

       dl->mDownloadState != nsIDownloadManager::DOWNLOAD_CANCELED)

     return NS_ERROR_FAILURE;

   // If the download has failed and is resumable then we first try resuming it

   nsresult rv;

   if (dl->mDownloadState == nsIDownloadManager::DOWNLOAD_FAILED && dl->IsResumable()) {

     rv = dl->Resume();

     if (NS_SUCCEEDED(rv))

       return rv;

   }

   // reset time and download progress

   dl->SetStartTime(PR_Now());

   dl->SetProgressBytes(0, -1);

   nsCOMPtr<nsIWebBrowserPersist> wbp =

     do_CreateInstance("@mozilla.org/embedding/browser/nsWebBrowserPersist;1", &rv);

   NS_ENSURE_SUCCESS(rv, rv);

   rv = wbp->SetPersistFlags(nsIWebBrowserPersist::PERSIST_FLAGS_REPLACE_EXISTING_FILES |

                             nsIWebBrowserPersist::PERSIST_FLAGS_AUTODETECT_APPLY_CONVERSION);

   NS_ENSURE_SUCCESS(rv, rv);

   rv = AddToCurrentDownloads(dl);

   NS_ENSURE_SUCCESS(rv, rv);

   rv = dl->SetState(nsIDownloadManager::DOWNLOAD_QUEUED);

   NS_ENSURE_SUCCESS(rv, rv);

   // Creates a cycle that will be broken when the download finishes

   dl->mCancelable = wbp;

   (void)wbp->SetProgressListener(dl);

   rv = wbp->SavePrivacyAwareURI(dl->mSource, nullptr, nullptr, nullptr, nullptr,

                                 dl->mTarget, dl->mPrivate);

   if (NS_FAILED(rv)) {

     dl->mCancelable = nullptr;

     (void)wbp->SetProgressListener(nullptr);

     return rv;

   }

   return NS_OK;

 }

 static nsresult

 RemoveDownloadByGUID(const nsACString& aGUID, mozIStorageConnection* aDBConn)

 {

   nsCOMPtr<mozIStorageStatement> stmt;

   nsresult rv = aDBConn->CreateStatement(NS_LITERAL_CSTRING(

     "DELETE FROM moz_downloads "

     "WHERE guid = :guid"), getter_AddRefs(stmt));

   NS_ENSURE_SUCCESS(rv, rv);

   rv = stmt->BindUTF8StringByName(NS_LITERAL_CSTRING("guid"), aGUID);

   NS_ENSURE_SUCCESS(rv, rv);

   rv = stmt->Execute();

   NS_ENSURE_SUCCESS(rv, rv);

   return NS_OK;

 }

 nsresult

 nsDownloadManager::RemoveDownload(const nsACString& aGUID)

 {

   nsRefPtr<nsDownload> dl = FindDownload(aGUID);

   MOZ_ASSERT(!dl, "Can't call RemoveDownload on a download in progress!");

   if (dl)

     return NS_ERROR_FAILURE;

   nsresult rv = GetDownloadFromDB(aGUID, getter_AddRefs(dl));

   NS_ENSURE_SUCCESS(rv, rv);

   if (dl->mPrivate) {

     RemoveDownloadByGUID(aGUID, mPrivateDBConn);

   } else {

     RemoveDownloadByGUID(aGUID, mDBConn);

   }

   return NotifyDownloadRemoval(dl);

 }

 NS_IMETHODIMP

 nsDownloadManager::RemoveDownload(uint32_t aID)

 {

   NS_ENSURE_STATE(!mUseJSTransfer);

   NS_WARNING("Using integer IDs without compat mode enabled");

   nsRefPtr<nsDownload> dl = FindDownload(aID);

   MOZ_ASSERT(!dl, "Can't call RemoveDownload on a download in progress!");

   if (dl)

     return NS_ERROR_FAILURE;

   nsresult rv = GetDownloadFromDB(aID, getter_AddRefs(dl));

   NS_ENSURE_SUCCESS(rv, rv);

   nsCOMPtr<mozIStorageStatement> stmt;

   rv = mDBConn->CreateStatement(NS_LITERAL_CSTRING(

     "DELETE FROM moz_downloads "

     "WHERE id = :id"), getter_AddRefs(stmt));

   NS_ENSURE_SUCCESS(rv, rv);

   rv = stmt->BindInt64ByName(NS_LITERAL_CSTRING("id"), aID); // unsigned; 64-bit to prevent overflow

   NS_ENSURE_SUCCESS(rv, rv);

   rv = stmt->Execute();

   NS_ENSURE_SUCCESS(rv, rv);

   // Notify the UI with the topic and download id

   return NotifyDownloadRemoval(dl);

 }

 nsresult

 nsDownloadManager::NotifyDownloadRemoval(nsDownload* aRemoved)

 {

   nsCOMPtr<nsISupportsPRUint32> id;

   nsCOMPtr<nsISupportsCString> guid;

   nsresult rv;

   // Only send an integer ID notification if the download is public.

   bool sendDeprecatedNotification = !(aRemoved && aRemoved->mPrivate);

   if (sendDeprecatedNotification && aRemoved) {

     id = do_CreateInstance(NS_SUPPORTS_PRUINT32_CONTRACTID, &rv);

     NS_ENSURE_SUCCESS(rv, rv);

     uint32_t dlID;

     rv = aRemoved->GetId(&dlID);

     NS_ENSURE_SUCCESS(rv, rv);

     rv = id->SetData(dlID);

     NS_ENSURE_SUCCESS(rv, rv);

   }

   if (sendDeprecatedNotification) {

     mObserverService->NotifyObservers(id,

                                      "download-manager-remove-download",

                                      nullptr);

   }

   if (aRemoved) {

     guid = do_CreateInstance(NS_SUPPORTS_CSTRING_CONTRACTID, &rv);

     NS_ENSURE_SUCCESS(rv, rv);

     nsAutoCString guidStr;

     rv = aRemoved->GetGuid(guidStr);

     NS_ENSURE_SUCCESS(rv, rv);

     rv = guid->SetData(guidStr);

     NS_ENSURE_SUCCESS(rv, rv);

   }

   mObserverService->NotifyObservers(guid,

                                     "download-manager-remove-download-guid",

                                     nullptr);

   return NS_OK;

 }

 static nsresult

 DoRemoveDownloadsByTimeframe(mozIStorageConnection* aDBConn,

                              int64_t aStartTime,

                              int64_t aEndTime)

 {

   nsCOMPtr<mozIStorageStatement> stmt;

   nsresult rv = aDBConn->CreateStatement(NS_LITERAL_CSTRING(

     "DELETE FROM moz_downloads "

     "WHERE startTime >= :startTime "

     "AND startTime <= :endTime "

     "AND state NOT IN (:downloading, :paused, :queued)"), getter_AddRefs(stmt));

   NS_ENSURE_SUCCESS(rv, rv);

   // Bind the times

   rv = stmt->BindInt64ByName(NS_LITERAL_CSTRING("startTime"), aStartTime);

   NS_ENSURE_SUCCESS(rv, rv);

   rv = stmt->BindInt64ByName(NS_LITERAL_CSTRING("endTime"), aEndTime);

   NS_ENSURE_SUCCESS(rv, rv);

   // Bind the active states

   rv = stmt->BindInt32ByName(NS_LITERAL_CSTRING("downloading"), nsIDownloadManager::DOWNLOAD_DOWNLOADING);

   NS_ENSURE_SUCCESS(rv, rv);

   rv = stmt->BindInt32ByName(NS_LITERAL_CSTRING("paused"), nsIDownloadManager::DOWNLOAD_PAUSED);

   NS_ENSURE_SUCCESS(rv, rv);

   rv = stmt->BindInt32ByName(NS_LITERAL_CSTRING("queued"), nsIDownloadManager::DOWNLOAD_QUEUED);

   NS_ENSURE_SUCCESS(rv, rv);

   // Execute

   rv = stmt->Execute();

   NS_ENSURE_SUCCESS(rv, rv);

   return NS_OK;

 }

 NS_IMETHODIMP

 nsDownloadManager::RemoveDownloadsByTimeframe(int64_t aStartTime,

                                               int64_t aEndTime)

 {

   NS_ENSURE_STATE(!mUseJSTransfer);

   nsresult rv = DoRemoveDownloadsByTimeframe(mDBConn, aStartTime, aEndTime);

   nsresult rv2 = DoRemoveDownloadsByTimeframe(mPrivateDBConn, aStartTime, aEndTime);

   NS_ENSURE_SUCCESS(rv, rv);

   NS_ENSURE_SUCCESS(rv2, rv2);

   // Notify the UI with the topic and null subject to indicate "remove multiple"

   return NotifyDownloadRemoval(nullptr);

 }

 NS_IMETHODIMP

 nsDownloadManager::CleanUp()

 {

   NS_ENSURE_STATE(!mUseJSTransfer);

   return CleanUp(mDBConn);

 }

 NS_IMETHODIMP

 nsDownloadManager::CleanUpPrivate()

 {

   NS_ENSURE_STATE(!mUseJSTransfer);

   return CleanUp(mPrivateDBConn);

 }

 nsresult

 nsDownloadManager::CleanUp(mozIStorageConnection* aDBConn)

 {

   DownloadState states[] = { nsIDownloadManager::DOWNLOAD_FINISHED,

                              nsIDownloadManager::DOWNLOAD_FAILED,

                              nsIDownloadManager::DOWNLOAD_CANCELED,

                              nsIDownloadManager::DOWNLOAD_BLOCKED_PARENTAL,

                              nsIDownloadManager::DOWNLOAD_BLOCKED_POLICY,

                              nsIDownloadManager::DOWNLOAD_DIRTY };

   nsCOMPtr<mozIStorageStatement> stmt;

   nsresult rv = aDBConn->CreateStatement(NS_LITERAL_CSTRING(

     "DELETE FROM moz_downloads "

     "WHERE state = ? "

       "OR state = ? "

       "OR state = ? "

       "OR state = ? "

       "OR state = ? "

       "OR state = ?"), getter_AddRefs(stmt));

   NS_ENSURE_SUCCESS(rv, rv);

   for (uint32_t i = 0; i < ArrayLength(states); ++i) {

     rv = stmt->BindInt32ByIndex(i, states[i]);

     NS_ENSURE_SUCCESS(rv, rv);

   }

   rv = stmt->Execute();

   NS_ENSURE_SUCCESS(rv, rv);

   // Notify the UI with the topic and null subject to indicate "remove multiple"

   return NotifyDownloadRemoval(nullptr);

 }

 static nsresult

 DoGetCanCleanUp(mozIStorageConnection* aDBConn, bool *aResult)

 {

   // This method should never return anything but NS_OK for the benefit of

   // unwitting consumers.

   *aResult = false;

   DownloadState states[] = { nsIDownloadManager::DOWNLOAD_FINISHED,

                              nsIDownloadManager::DOWNLOAD_FAILED,

                              nsIDownloadManager::DOWNLOAD_CANCELED,

                              nsIDownloadManager::DOWNLOAD_BLOCKED_PARENTAL,

                              nsIDownloadManager::DOWNLOAD_BLOCKED_POLICY,

                              nsIDownloadManager::DOWNLOAD_DIRTY };

   nsCOMPtr<mozIStorageStatement> stmt;

   nsresult rv = aDBConn->CreateStatement(NS_LITERAL_CSTRING(

     "SELECT COUNT(*) "

     "FROM moz_downloads "

     "WHERE state = ? "

       "OR state = ? "

       "OR state = ? "

       "OR state = ? "

       "OR state = ? "

       "OR state = ?"), getter_AddRefs(stmt));

   NS_ENSURE_SUCCESS(rv, NS_OK);

   for (uint32_t i = 0; i < ArrayLength(states); ++i) {

     rv = stmt->BindInt32ByIndex(i, states[i]);

     NS_ENSURE_SUCCESS(rv, NS_OK);

   }

   bool moreResults; // We don't really care...

   rv = stmt->ExecuteStep(&moreResults);

   NS_ENSURE_SUCCESS(rv, NS_OK);

   int32_t count;

   rv = stmt->GetInt32(0, &count);

   NS_ENSURE_SUCCESS(rv, NS_OK);

   if (count > 0)

     *aResult = true;

   return NS_OK;

 }

 NS_IMETHODIMP

 nsDownloadManager::GetCanCleanUp(bool *aResult)

 {

   NS_ENSURE_STATE(!mUseJSTransfer);

   return DoGetCanCleanUp(mDBConn, aResult);

 }

 NS_IMETHODIMP

 nsDownloadManager::GetCanCleanUpPrivate(bool *aResult)

 {

   NS_ENSURE_STATE(!mUseJSTransfer);

   return DoGetCanCleanUp(mPrivateDBConn, aResult);

 }

 NS_IMETHODIMP

 nsDownloadManager::PauseDownload(uint32_t aID)

 {

   NS_ENSURE_STATE(!mUseJSTransfer);

   NS_WARNING("Using integer IDs without compat mode enabled");

   nsDownload *dl = FindDownload(aID);

   if (!dl)

     return NS_ERROR_FAILURE;

   return dl->Pause();

 }

 NS_IMETHODIMP

 nsDownloadManager::ResumeDownload(uint32_t aID)

 {

   NS_ENSURE_STATE(!mUseJSTransfer);

   NS_WARNING("Using integer IDs without compat mode enabled");

   nsDownload *dl = FindDownload(aID);

   if (!dl)

     return NS_ERROR_FAILURE;

   return dl->Resume();

 }

 NS_IMETHODIMP

 nsDownloadManager::GetDBConnection(mozIStorageConnection **aDBConn)

 {

   NS_ENSURE_STATE(!mUseJSTransfer);

   NS_ADDREF(*aDBConn = mDBConn);

   return NS_OK;

 }

 NS_IMETHODIMP

 nsDownloadManager::GetPrivateDBConnection(mozIStorageConnection **aDBConn)

 {

   NS_ENSURE_STATE(!mUseJSTransfer);

   NS_ADDREF(*aDBConn = mPrivateDBConn);

   return NS_OK;

  }

 NS_IMETHODIMP

 nsDownloadManager::AddListener(nsIDownloadProgressListener *aListener)

 {

   NS_ENSURE_STATE(!mUseJSTransfer);

   mListeners.AppendObject(aListener);

   return NS_OK;

 }

 NS_IMETHODIMP

 nsDownloadManager::AddPrivacyAwareListener(nsIDownloadProgressListener *aListener)

 {

   NS_ENSURE_STATE(!mUseJSTransfer);

   mPrivacyAwareListeners.AppendObject(aListener);

   return NS_OK;

 }

 NS_IMETHODIMP

 nsDownloadManager::RemoveListener(nsIDownloadProgressListener *aListener)

 {

   NS_ENSURE_STATE(!mUseJSTransfer);

   mListeners.RemoveObject(aListener);

   mPrivacyAwareListeners.RemoveObject(aListener);

   return NS_OK;

 }

 void

 nsDownloadManager::NotifyListenersOnDownloadStateChange(int16_t aOldState,

                                                         nsDownload *aDownload)

 {

   for (int32_t i = mPrivacyAwareListeners.Count() - 1; i >= 0; --i) {

     mPrivacyAwareListeners[i]->OnDownloadStateChange(aOldState, aDownload);

   }

   // Only privacy-aware listeners should receive notifications about private

   // downloads, while non-privacy-aware listeners receive no sign they exist.

   if (aDownload->mPrivate) {

     return;

   }

   for (int32_t i = mListeners.Count() - 1; i >= 0; --i) {

     mListeners[i]->OnDownloadStateChange(aOldState, aDownload);

   }

 }

 void

 nsDownloadManager::NotifyListenersOnProgressChange(nsIWebProgress *aProgress,

                                                    nsIRequest *aRequest,

                                                    int64_t aCurSelfProgress,

                                                    int64_t aMaxSelfProgress,

                                                    int64_t aCurTotalProgress,

                                                    int64_t aMaxTotalProgress,

                                                    nsDownload *aDownload)

 {

   for (int32_t i = mPrivacyAwareListeners.Count() - 1; i >= 0; --i) {

     mPrivacyAwareListeners[i]->OnProgressChange(aProgress, aRequest, aCurSelfProgress,

                                                 aMaxSelfProgress, aCurTotalProgress,

                                                 aMaxTotalProgress, aDownload);

   }

   // Only privacy-aware listeners should receive notifications about private

   // downloads, while non-privacy-aware listeners receive no sign they exist.

   if (aDownload->mPrivate) {

     return;

   }

   for (int32_t i = mListeners.Count() - 1; i >= 0; --i) {

     mListeners[i]->OnProgressChange(aProgress, aRequest, aCurSelfProgress,

                                     aMaxSelfProgress, aCurTotalProgress,

                                     aMaxTotalProgress, aDownload);

   }

 }

 void

 nsDownloadManager::NotifyListenersOnStateChange(nsIWebProgress *aProgress,

                                                 nsIRequest *aRequest,

                                                 uint32_t aStateFlags,

                                                 nsresult aStatus,

                                                 nsDownload *aDownload)

 {

   for (int32_t i = mPrivacyAwareListeners.Count() - 1; i >= 0; --i) {

     mPrivacyAwareListeners[i]->OnStateChange(aProgress, aRequest, aStateFlags, aStatus,

                                              aDownload);

   }

   // Only privacy-aware listeners should receive notifications about private

   // downloads, while non-privacy-aware listeners receive no sign they exist.

   if (aDownload->mPrivate) {

     return;

   }

   for (int32_t i = mListeners.Count() - 1; i >= 0; --i) {

     mListeners[i]->OnStateChange(aProgress, aRequest, aStateFlags, aStatus,

                                  aDownload);

   }

 }

 ////////////////////////////////////////////////////////////////////////////////

 //// nsINavHistoryObserver

 NS_IMETHODIMP

 nsDownloadManager::OnBeginUpdateBatch()

 {

   // This method in not normally invoked when mUseJSTransfer is enabled, however

   // we provide an extra check in case it is called manually by add-ons.

   NS_ENSURE_STATE(!mUseJSTransfer);

   // We already have a transaction, so don't make another

   if (mHistoryTransaction)

     return NS_OK;

   // Start a transaction that commits when deleted

   mHistoryTransaction = new mozStorageTransaction(mDBConn, true);

   return NS_OK;

 }

 NS_IMETHODIMP

 nsDownloadManager::OnEndUpdateBatch()

 {

   // Get rid of the transaction and cause it to commit

   mHistoryTransaction = nullptr;

   return NS_OK;

 }

 NS_IMETHODIMP

 nsDownloadManager::OnVisit(nsIURI *aURI, int64_t aVisitID, PRTime aTime,

                            int64_t aSessionID, int64_t aReferringID,

                            uint32_t aTransitionType, const nsACString& aGUID,

                            bool aHidden)

 {

   return NS_OK;

 }

 NS_IMETHODIMP

 nsDownloadManager::OnTitleChanged(nsIURI *aURI,

                                   const nsAString &aPageTitle,

                                   const nsACString &aGUID)

 {

   return NS_OK;

 }

 NS_IMETHODIMP

 nsDownloadManager::OnFrecencyChanged(nsIURI* aURI,

                                      int32_t aNewFrecency,

                                      const nsACString& aGUID,

                                      bool aHidden,

                                      PRTime aLastVisitDate)

 {

   return NS_OK;

 }

 NS_IMETHODIMP

 nsDownloadManager::OnManyFrecenciesChanged()

 {

   return NS_OK;

 }

 NS_IMETHODIMP

 nsDownloadManager::OnDeleteURI(nsIURI *aURI,

                                const nsACString& aGUID,

                                uint16_t aReason)

 {

   // This method in not normally invoked when mUseJSTransfer is enabled, however

   // we provide an extra check in case it is called manually by add-ons.

   NS_ENSURE_STATE(!mUseJSTransfer);

   nsresult rv = RemoveDownloadsForURI(mGetIdsForURIStatement, aURI);

   nsresult rv2 = RemoveDownloadsForURI(mGetPrivateIdsForURIStatement, aURI);

   NS_ENSURE_SUCCESS(rv, rv);

   NS_ENSURE_SUCCESS(rv2, rv2);

   return NS_OK;

 }

 NS_IMETHODIMP

 nsDownloadManager::OnClearHistory()

 {

   return CleanUp();

 }

 NS_IMETHODIMP

 nsDownloadManager::OnPageChanged(nsIURI *aURI,

                                  uint32_t aChangedAttribute,

                                  const nsAString& aNewValue,

                                  const nsACString &aGUID)

 {

   return NS_OK;

 }

 NS_IMETHODIMP

 nsDownloadManager::OnDeleteVisits(nsIURI *aURI, PRTime aVisitTime,

                                   const nsACString& aGUID,

                                   uint16_t aReason, uint32_t aTransitionType)

 {

   // Don't bother removing downloads until the page is removed.

   return NS_OK;

 }

 ////////////////////////////////////////////////////////////////////////////////

 //// nsIObserver

 NS_IMETHODIMP

 nsDownloadManager::Observe(nsISupports *aSubject,

                            const char *aTopic,

                            const char16_t *aData)

 {

   // This method in not normally invoked when mUseJSTransfer is enabled, however

   // we provide an extra check in case it is called manually by add-ons.

   NS_ENSURE_STATE(!mUseJSTransfer);

   // We need to count the active public downloads that could be lost

   // by quitting, and add any active private ones as well, since per-window

   // private browsing may be active.

   int32_t currDownloadCount = mCurrentDownloads.Count();

   // If we don't need to cancel all the downloads on quit, only count the ones

   // that aren't resumable.

   if (GetQuitBehavior() != QUIT_AND_CANCEL) {

     for (int32_t i = currDownloadCount - 1; i >= 0; --i) {

       if (mCurrentDownloads[i]->IsResumable()) {

         currDownloadCount--;

       }

     }

     // We have a count of the public, non-resumable downloads. Now we need

     // to add the total number of private downloads, since they are in danger

     // of being lost.

     currDownloadCount += mCurrentPrivateDownloads.Count();

   }

   nsresult rv;

   if (strcmp(aTopic, "oncancel") == 0) {

     nsCOMPtr<nsIDownload> dl = do_QueryInterface(aSubject, &rv);

     NS_ENSURE_SUCCESS(rv, rv);

     dl->Cancel();

   } else if (strcmp(aTopic, "profile-before-change") == 0) {

     CloseAllDBs();

   } else if (strcmp(aTopic, "quit-application") == 0) {

     // Try to pause all downloads and, if appropriate, mark them as auto-resume

     // unless user has specified that downloads should be canceled

     enum QuitBehavior behavior = GetQuitBehavior();

     if (behavior != QUIT_AND_CANCEL)

       (void)PauseAllDownloads(bool(behavior != QUIT_AND_PAUSE));

     // Remove downloads to break cycles and cancel downloads

     (void)RemoveAllDownloads();

    // Now that active downloads have been canceled, remove all completed or

    // aborted downloads if the user's retention policy specifies it.

     if (GetRetentionBehavior() == 1)

       CleanUp();

   } else if (strcmp(aTopic, "quit-application-requested") == 0 &&

              currDownloadCount) {

     nsCOMPtr<nsISupportsPRBool> cancelDownloads =

       do_QueryInterface(aSubject, &rv);

     NS_ENSURE_SUCCESS(rv, rv);

 #ifndef XP_MACOSX

     ConfirmCancelDownloads(currDownloadCount, cancelDownloads,

                            MOZ_UTF16("quitCancelDownloadsAlertTitle"),

                            MOZ_UTF16("quitCancelDownloadsAlertMsgMultiple"),

                            MOZ_UTF16("quitCancelDownloadsAlertMsg"),

                            MOZ_UTF16("dontQuitButtonWin"));

 #else

     ConfirmCancelDownloads(currDownloadCount, cancelDownloads,

                            MOZ_UTF16("quitCancelDownloadsAlertTitle"),

                            MOZ_UTF16("quitCancelDownloadsAlertMsgMacMultiple"),

                            MOZ_UTF16("quitCancelDownloadsAlertMsgMac"),

                            MOZ_UTF16("dontQuitButtonMac"));

 #endif

   } else if (strcmp(aTopic, "offline-requested") == 0 && currDownloadCount) {

     nsCOMPtr<nsISupportsPRBool> cancelDownloads =

       do_QueryInterface(aSubject, &rv);

     NS_ENSURE_SUCCESS(rv, rv);

     ConfirmCancelDownloads(currDownloadCount, cancelDownloads,

                            MOZ_UTF16("offlineCancelDownloadsAlertTitle"),

                            MOZ_UTF16("offlineCancelDownloadsAlertMsgMultiple"),

                            MOZ_UTF16("offlineCancelDownloadsAlertMsg"),

                            MOZ_UTF16("dontGoOfflineButton"));

   }

   else if (strcmp(aTopic, NS_IOSERVICE_GOING_OFFLINE_TOPIC) == 0) {

     // Pause all downloads, and mark them to auto-resume.

     (void)PauseAllDownloads(true);

   }

   else if (strcmp(aTopic, NS_IOSERVICE_OFFLINE_STATUS_TOPIC) == 0 &&

            nsDependentString(aData).EqualsLiteral(NS_IOSERVICE_ONLINE)) {

     // We can now resume all downloads that are supposed to auto-resume.

     (void)ResumeAllDownloads(false);

   }

   else if (strcmp(aTopic, "alertclickcallback") == 0) {

     nsCOMPtr<nsIDownloadManagerUI> dmui =

       do_GetService("@mozilla.org/download-manager-ui;1", &rv);

     NS_ENSURE_SUCCESS(rv, rv);

     return dmui->Show(nullptr, nullptr, nsIDownloadManagerUI::REASON_USER_INTERACTED,

                       aData && NS_strcmp(aData, MOZ_UTF16("private")) == 0);

   } else if (strcmp(aTopic, "sleep_notification") == 0 ||

              strcmp(aTopic, "suspend_process_notification") == 0) {

     // Pause downloads if we're sleeping, and mark the downloads as auto-resume

     (void)PauseAllDownloads(true);

   } else if (strcmp(aTopic, "wake_notification") == 0 ||

              strcmp(aTopic, "resume_process_notification") == 0) {

     int32_t resumeOnWakeDelay = 10000;

     nsCOMPtr<nsIPrefBranch> pref = do_GetService(NS_PREFSERVICE_CONTRACTID);

     if (pref)

       (void)pref->GetIntPref(PREF_BDM_RESUMEONWAKEDELAY, &resumeOnWakeDelay);

     // Wait a little bit before trying to resume to avoid resuming when network

     // connections haven't restarted yet

     mResumeOnWakeTimer = do_CreateInstance("@mozilla.org/timer;1");

     if (resumeOnWakeDelay >= 0 && mResumeOnWakeTimer) {

       (void)mResumeOnWakeTimer->InitWithFuncCallback(ResumeOnWakeCallback,

         this, resumeOnWakeDelay, nsITimer::TYPE_ONE_SHOT);

     }

   } else if (strcmp(aTopic, "last-pb-context-exited") == 0) {

     // Upon leaving private browsing mode, cancel all private downloads,

     // remove all trace of them, and then blow away the private database

     // and recreate a blank one.

     RemoveAllDownloads(mCurrentPrivateDownloads);

     InitPrivateDB();

   } else if (strcmp(aTopic, "last-pb-context-exiting") == 0) {

     // If there are active private downloads, prompt the user to confirm leaving

     // private browsing mode (thereby cancelling them). Otherwise, silently proceed.

     if (!mCurrentPrivateDownloads.Count())

       return NS_OK;

     nsCOMPtr<nsISupportsPRBool> cancelDownloads = do_QueryInterface(aSubject, &rv);

     NS_ENSURE_SUCCESS(rv, rv);

     ConfirmCancelDownloads(mCurrentPrivateDownloads.Count(), cancelDownloads,

                            MOZ_UTF16("leavePrivateBrowsingCancelDownloadsAlertTitle"),

                            MOZ_UTF16("leavePrivateBrowsingWindowsCancelDownloadsAlertMsgMultiple"),

                            MOZ_UTF16("leavePrivateBrowsingWindowsCancelDownloadsAlertMsg"),

                            MOZ_UTF16("dontLeavePrivateBrowsingButton"));

   }

   return NS_OK;

 }

 void

 nsDownloadManager::ConfirmCancelDownloads(int32_t aCount,

                                           nsISupportsPRBool *aCancelDownloads,

                                           const char16_t *aTitle,

                                           const char16_t *aCancelMessageMultiple,

                                           const char16_t *aCancelMessageSingle,

                                           const char16_t *aDontCancelButton)

 {

   // If user has already dismissed quit request, then do nothing

   bool quitRequestCancelled = false;

   aCancelDownloads->GetData(&quitRequestCancelled);

   if (quitRequestCancelled)

     return;

   nsXPIDLString title, message, quitButton, dontQuitButton;

   mBundle->GetStringFromName(aTitle, getter_Copies(title));

   nsAutoString countString;

   countString.AppendInt(aCount);

   const char16_t *strings[1] = { countString.get() };

   if (aCount > 1) {

     mBundle->FormatStringFromName(aCancelMessageMultiple, strings, 1,

                                   getter_Copies(message));

     mBundle->FormatStringFromName(MOZ_UTF16("cancelDownloadsOKTextMultiple"),

                                   strings, 1, getter_Copies(quitButton));

   } else {

     mBundle->GetStringFromName(aCancelMessageSingle, getter_Copies(message));

     mBundle->GetStringFromName(MOZ_UTF16("cancelDownloadsOKText"),

                                getter_Copies(quitButton));

   }

   mBundle->GetStringFromName(aDontCancelButton, getter_Copies(dontQuitButton));

   // Get Download Manager window, to be parent of alert.

   nsCOMPtr<nsIWindowMediator> wm = do_GetService(NS_WINDOWMEDIATOR_CONTRACTID);

   nsCOMPtr<nsIDOMWindow> dmWindow;

   if (wm) {

     wm->GetMostRecentWindow(MOZ_UTF16("Download:Manager"),

                             getter_AddRefs(dmWindow));

   }

   // Show alert.

   nsCOMPtr<nsIPromptService> prompter(do_GetService(NS_PROMPTSERVICE_CONTRACTID));

   if (prompter) {

     int32_t flags = (nsIPromptService::BUTTON_TITLE_IS_STRING * nsIPromptService::BUTTON_POS_0) + (nsIPromptService::BUTTON_TITLE_IS_STRING * nsIPromptService::BUTTON_POS_1);

     bool nothing = false;

     int32_t button;

     prompter->ConfirmEx(dmWindow, title, message, flags, quitButton.get(), dontQuitButton.get(), nullptr, nullptr, &nothing, &button);

     aCancelDownloads->SetData(button == 1);

   }

 }

 ////////////////////////////////////////////////////////////////////////////////

 //// nsDownload

 NS_IMPL_CLASSINFO(nsDownload, nullptr, 0, NS_DOWNLOAD_CID)

 NS_IMPL_ISUPPORTS_CI(

     nsDownload

   , nsIDownload

   , nsITransfer

   , nsIWebProgressListener

   , nsIWebProgressListener2

 )

 nsDownload::nsDownload() : mDownloadState(nsIDownloadManager::DOWNLOAD_NOTSTARTED),

                            mID(0),

                            mPercentComplete(0),

                            mCurrBytes(0),

                            mMaxBytes(-1),

                            mStartTime(0),

                            mLastUpdate(PR_Now() - (uint32_t)gUpdateInterval),

                            mResumedAt(-1),

                            mSpeed(0),

                            mHasMultipleFiles(false),

                            mPrivate(false),

                            mAutoResume(DONT_RESUME)

 {

 }

 nsDownload::~nsDownload()

 {

 }

 NS_IMETHODIMP nsDownload::SetSha256Hash(const nsACString& aHash) {

   MOZ_ASSERT(NS_IsMainThread(), "Must call SetSha256Hash on main thread");

   // This will be used later to query the application reputation service.

   mHash = aHash;

   return NS_OK;

 }

 NS_IMETHODIMP nsDownload::SetSignatureInfo(nsIArray* aSignatureInfo) {

   MOZ_ASSERT(NS_IsMainThread(), "Must call SetSignatureInfo on main thread");

   // This will be used later to query the application reputation service.

   mSignatureInfo = aSignatureInfo;

   return NS_OK;

 }

 #ifdef MOZ_ENABLE_GIO