tor-browser

MSMigrationUtils.sys.mjs (24019B)

---

/* 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/. */

import { ctypes } from "resource://gre/modules/ctypes.sys.mjs";
import { MigrationUtils } from "resource:///modules/MigrationUtils.sys.mjs";

const lazy = {};

ChromeUtils.defineESModuleGetters(lazy, {
 PlacesUtils: "resource://gre/modules/PlacesUtils.sys.mjs",
 WindowsRegistry: "resource://gre/modules/WindowsRegistry.sys.mjs",
});

const EDGE_FAVORITES = "AC\\MicrosoftEdge\\User\\Default\\Favorites";
const FREE_CLOSE_FAILED = 0;
const INTERNET_EXPLORER_EDGE_GUID = [
 0x3ccd5499, 0x4b1087a8, 0x886015a2, 0x553bdd88,
];
const RESULT_SUCCESS = 0;
const VAULT_ENUMERATE_ALL_ITEMS = 512;
const WEB_CREDENTIALS_VAULT_ID = [
 0x4bf4c442, 0x41a09b8a, 0x4add80b3, 0x28db4d70,
];

const wintypes = {
 BOOL: ctypes.int,
 DWORD: ctypes.uint32_t,
 DWORDLONG: ctypes.uint64_t,
 CHAR: ctypes.char,
 PCHAR: ctypes.char.ptr,
 LPCWSTR: ctypes.char16_t.ptr,
 PDWORD: ctypes.uint32_t.ptr,
 VOIDP: ctypes.voidptr_t,
 WORD: ctypes.uint16_t,
};

// TODO: Bug 1202978 - Refactor MSMigrationUtils ctypes helpers
function CtypesKernelHelpers() {
 this._structs = {};
 this._functions = {};
 this._libs = {};

 this._structs.SYSTEMTIME = new ctypes.StructType("SYSTEMTIME", [
   { wYear: wintypes.WORD },
   { wMonth: wintypes.WORD },
   { wDayOfWeek: wintypes.WORD },
   { wDay: wintypes.WORD },
   { wHour: wintypes.WORD },
   { wMinute: wintypes.WORD },
   { wSecond: wintypes.WORD },
   { wMilliseconds: wintypes.WORD },
 ]);

 this._structs.FILETIME = new ctypes.StructType("FILETIME", [
   { dwLowDateTime: wintypes.DWORD },
   { dwHighDateTime: wintypes.DWORD },
 ]);

 try {
   this._libs.kernel32 = ctypes.open("Kernel32");

   this._functions.FileTimeToSystemTime = this._libs.kernel32.declare(
     "FileTimeToSystemTime",
     ctypes.winapi_abi,
     wintypes.BOOL,
     this._structs.FILETIME.ptr,
     this._structs.SYSTEMTIME.ptr
   );
 } catch (ex) {
   this.finalize();
 }
}

CtypesKernelHelpers.prototype = {
 /**
  * Must be invoked once after last use of any of the provided helpers.
  */
 finalize() {
   this._structs = {};
   this._functions = {};
   for (let key in this._libs) {
     let lib = this._libs[key];
     try {
       lib.close();
     } catch (ex) {}
   }
   this._libs = {};
 },

 /**
  * Converts a FILETIME struct (2 DWORDS), to a SYSTEMTIME struct,
  * and then deduces the number of seconds since the epoch (which
  * is the data we want for the cookie expiry date).
  *
  * @param {number} aTimeHi
  *        Least significant DWORD.
  * @param {number} aTimeLo
  *        Most significant DWORD.
  * @returns {number} the number of seconds since the epoch
  */
 fileTimeToSecondsSinceEpoch(aTimeHi, aTimeLo) {
   let fileTime = this._structs.FILETIME();
   fileTime.dwLowDateTime = aTimeLo;
   fileTime.dwHighDateTime = aTimeHi;
   let systemTime = this._structs.SYSTEMTIME();
   let result = this._functions.FileTimeToSystemTime(
     fileTime.address(),
     systemTime.address()
   );
   if (result == 0) {
     throw new Error(ctypes.winLastError);
   }

   // System time is in UTC, so we use Date.UTC to get milliseconds from epoch,
   // then divide by 1000 to get seconds, and round down:
   return Math.floor(
     Date.UTC(
       systemTime.wYear,
       systemTime.wMonth - 1,
       systemTime.wDay,
       systemTime.wHour,
       systemTime.wMinute,
       systemTime.wSecond,
       systemTime.wMilliseconds
     ) / 1000
   );
 },
};

function CtypesVaultHelpers() {
 this._structs = {};
 this._functions = {};

 this._structs.GUID = new ctypes.StructType("GUID", [
   { id: wintypes.DWORD.array(4) },
 ]);

 this._structs.VAULT_ITEM_ELEMENT = new ctypes.StructType(
   "VAULT_ITEM_ELEMENT",
   [
     // not documented
     { schemaElementId: wintypes.DWORD },
     // not documented
     { unknown1: wintypes.DWORD },
     // vault type
     { type: wintypes.DWORD },
     // not documented
     { unknown2: wintypes.DWORD },
     // value of the item
     { itemValue: wintypes.LPCWSTR },
     // not documented
     { unknown3: wintypes.CHAR.array(12) },
   ]
 );

 this._structs.VAULT_ELEMENT = new ctypes.StructType("VAULT_ELEMENT", [
   // vault item schemaId
   { schemaId: this._structs.GUID },
   // a pointer to the name of the browser VAULT_ITEM_ELEMENT
   { pszCredentialFriendlyName: wintypes.LPCWSTR },
   // a pointer to the url VAULT_ITEM_ELEMENT
   { pResourceElement: this._structs.VAULT_ITEM_ELEMENT.ptr },
   // a pointer to the username VAULT_ITEM_ELEMENT
   { pIdentityElement: this._structs.VAULT_ITEM_ELEMENT.ptr },
   // not documented
   { pAuthenticatorElement: this._structs.VAULT_ITEM_ELEMENT.ptr },
   // not documented
   { pPackageSid: this._structs.VAULT_ITEM_ELEMENT.ptr },
   // time stamp in local format
   { lowLastModified: wintypes.DWORD },
   { highLastModified: wintypes.DWORD },
   // not documented
   { flags: wintypes.DWORD },
   // not documented
   { dwPropertiesCount: wintypes.DWORD },
   // not documented
   { pPropertyElements: this._structs.VAULT_ITEM_ELEMENT.ptr },
 ]);

 try {
   this._vaultcliLib = ctypes.open("vaultcli.dll");

   this._functions.VaultOpenVault = this._vaultcliLib.declare(
     "VaultOpenVault",
     ctypes.winapi_abi,
     wintypes.DWORD,
     // GUID
     this._structs.GUID.ptr,
     // Flags
     wintypes.DWORD,
     // Vault Handle
     wintypes.VOIDP.ptr
   );
   this._functions.VaultEnumerateItems = this._vaultcliLib.declare(
     "VaultEnumerateItems",
     ctypes.winapi_abi,
     wintypes.DWORD,
     // Vault Handle
     wintypes.VOIDP,
     // Flags
     wintypes.DWORD,
     // Items Count
     wintypes.PDWORD,
     // Items
     ctypes.voidptr_t
   );
   this._functions.VaultCloseVault = this._vaultcliLib.declare(
     "VaultCloseVault",
     ctypes.winapi_abi,
     wintypes.DWORD,
     // Vault Handle
     wintypes.VOIDP
   );
   this._functions.VaultGetItem = this._vaultcliLib.declare(
     "VaultGetItem",
     ctypes.winapi_abi,
     wintypes.DWORD,
     // Vault Handle
     wintypes.VOIDP,
     // Schema Id
     this._structs.GUID.ptr,
     // Resource
     this._structs.VAULT_ITEM_ELEMENT.ptr,
     // Identity
     this._structs.VAULT_ITEM_ELEMENT.ptr,
     // Package Sid
     this._structs.VAULT_ITEM_ELEMENT.ptr,
     // HWND Owner
     wintypes.DWORD,
     // Flags
     wintypes.DWORD,
     // Items
     this._structs.VAULT_ELEMENT.ptr.ptr
   );
   this._functions.VaultFree = this._vaultcliLib.declare(
     "VaultFree",
     ctypes.winapi_abi,
     wintypes.DWORD,
     // Memory
     this._structs.VAULT_ELEMENT.ptr
   );
 } catch (ex) {
   this.finalize();
 }
}

CtypesVaultHelpers.prototype = {
 /**
  * Must be invoked once after last use of any of the provided helpers.
  */
 finalize() {
   this._structs = {};
   this._functions = {};
   try {
     this._vaultcliLib.close();
   } catch (ex) {}
   this._vaultcliLib = null;
 },
};

var gEdgeDir;
function getEdgeLocalDataFolder() {
 if (gEdgeDir) {
   return gEdgeDir.clone();
 }
 let packages = Services.dirsvc.get("LocalAppData", Ci.nsIFile);
 packages.append("Packages");
 let edgeDir = packages.clone();
 edgeDir.append("Microsoft.MicrosoftEdge_8wekyb3d8bbwe");
 try {
   if (edgeDir.exists() && edgeDir.isReadable() && edgeDir.isDirectory()) {
     gEdgeDir = edgeDir;
     return edgeDir.clone();
   }

   // Let's try the long way:
   let dirEntries = packages.directoryEntries;
   while (dirEntries.hasMoreElements()) {
     let subDir = dirEntries.nextFile;
     if (
       subDir.leafName.startsWith("Microsoft.MicrosoftEdge") &&
       subDir.isReadable() &&
       subDir.isDirectory()
     ) {
       gEdgeDir = subDir;
       return subDir.clone();
     }
   }
 } catch (ex) {
   console.error(
     "Exception trying to find the Edge favorites directory: ",
     ex
   );
 }
 return null;
}

function Bookmarks(migrationType) {
 this._migrationType = migrationType;
}

Bookmarks.prototype = {
 type: MigrationUtils.resourceTypes.BOOKMARKS,

 get exists() {
   return !!this._favoritesFolder;
 },

 get importedAppLabel() {
   return this._migrationType == MSMigrationUtils.MIGRATION_TYPE_IE
     ? "IE"
     : "Edge";
 },

 __favoritesFolder: null,
 get _favoritesFolder() {
   if (!this.__favoritesFolder) {
     if (this._migrationType == MSMigrationUtils.MIGRATION_TYPE_IE) {
       let favoritesFolder = Services.dirsvc.get("Favs", Ci.nsIFile);
       if (favoritesFolder.exists() && favoritesFolder.isReadable()) {
         this.__favoritesFolder = favoritesFolder;
       }
     } else if (this._migrationType == MSMigrationUtils.MIGRATION_TYPE_EDGE) {
       let edgeDir = getEdgeLocalDataFolder();
       if (edgeDir) {
         edgeDir.appendRelativePath(EDGE_FAVORITES);
         if (
           edgeDir.exists() &&
           edgeDir.isReadable() &&
           edgeDir.isDirectory()
         ) {
           this.__favoritesFolder = edgeDir;
         }
       }
     }
   }
   return this.__favoritesFolder;
 },

 __toolbarFolderName: null,
 get _toolbarFolderName() {
   if (!this.__toolbarFolderName) {
     if (this._migrationType == MSMigrationUtils.MIGRATION_TYPE_IE) {
       // Retrieve the name of IE's favorites subfolder that holds the bookmarks
       // in the toolbar. This was previously stored in the registry and changed
       // in IE7 to always be called "Links".
       let folderName = lazy.WindowsRegistry.readRegKey(
         Ci.nsIWindowsRegKey.ROOT_KEY_CURRENT_USER,
         "Software\\Microsoft\\Internet Explorer\\Toolbar",
         "LinksFolderName"
       );
       this.__toolbarFolderName = folderName || "Links";
     } else {
       this.__toolbarFolderName = "Links";
     }
   }
   return this.__toolbarFolderName;
 },

 migrate: function B_migrate(aCallback) {
   return (async () => {
     // Import to the bookmarks menu.
     let folderGuid = lazy.PlacesUtils.bookmarks.menuGuid;
     await this._migrateFolder(this._favoritesFolder, folderGuid);
   })().then(
     () => aCallback(true),
     e => {
       console.error(e);
       aCallback(false);
     }
   );
 },

 async _migrateFolder(aSourceFolder, aDestFolderGuid) {
   let { bookmarks, favicons } =
     await this._getBookmarksInFolder(aSourceFolder);
   if (!bookmarks.length) {
     return;
   }

   await MigrationUtils.insertManyBookmarksWrapper(bookmarks, aDestFolderGuid);
   MigrationUtils.insertManyFavicons(favicons).catch(console.error);
 },

 /**
  * Iterates through a bookmark folder to obtain whatever information from each bookmark is needed elsewhere. This function also recurses into child folders.
  *
  * @param {nsIFile} aSourceFolder the folder to search for bookmarks and subfolders.
  * @returns {Promise<object>} An object with the following properties:
  * {Object[]} bookmarks:
  *   An array of Objects with these properties:
  *     {number} type: A type mapping to one of the types in nsINavBookmarksService
  *     {string} title: The title of the bookmark
  *     {Object[]} children: An array of objects with the same structure as this one.
  *
  * {Object[]} favicons
  *   An array of Objects with these properties:
  *     {Uint8Array} faviconData: The binary data of a favicon
  *     {nsIURI} uri: The URI of the associated bookmark
  */
 async _getBookmarksInFolder(aSourceFolder) {
   // TODO (bug 741993): the favorites order is stored in the Registry, at
   // HCU\Software\Microsoft\Windows\CurrentVersion\Explorer\MenuOrder\Favorites
   // for IE, and in a similar location for Edge.
   // Until we support it, bookmarks are imported in alphabetical order.
   let entries = aSourceFolder.directoryEntries;
   let rv = [];
   let favicons = [];
   while (entries.hasMoreElements()) {
     let entry = entries.nextFile;
     try {
       // Make sure that entry.path == entry.target to not follow .lnk folder
       // shortcuts which could lead to infinite cycles.
       // Don't use isSymlink(), since it would throw for invalid
       // lnk files pointing to URLs or to unresolvable paths.
       if (entry.path == entry.target && entry.isDirectory()) {
         let isBookmarksFolder =
           entry.leafName == this._toolbarFolderName &&
           entry.parent.equals(this._favoritesFolder);
         if (isBookmarksFolder && entry.isReadable()) {
           // Import to the bookmarks toolbar.
           let folderGuid = lazy.PlacesUtils.bookmarks.toolbarGuid;
           await this._migrateFolder(entry, folderGuid);
         } else if (entry.isReadable()) {
           let { bookmarks: childBookmarks, favicons: childFavicons } =
             await this._getBookmarksInFolder(entry);
           favicons = favicons.concat(childFavicons);
           rv.push({
             type: lazy.PlacesUtils.bookmarks.TYPE_FOLDER,
             title: entry.leafName,
             children: childBookmarks,
           });
         }
       } else {
         // Strip the .url extension, to both check this is a valid link file,
         // and get the associated title.
         let matches = entry.leafName.match(/(.+)\.url$/i);
         if (matches) {
           let fileHandler = Cc[
             "@mozilla.org/network/protocol;1?name=file"
           ].getService(Ci.nsIFileProtocolHandler);
           let uri = fileHandler.readURLFile(entry);
           // Silently failing in the event that the alternative data stream for the favicon doesn't exist
           try {
             let faviconData = await IOUtils.read(entry.path + ":favicon");
             favicons.push({ faviconData, uri });
           } catch {}

           rv.push({ url: uri, title: matches[1] });
         }
       }
     } catch (ex) {
       console.error(
         "Unable to import ",
         this.importedAppLabel,
         " favorite (",
         entry.leafName,
         "): ",
         ex
       );
     }
   }
   return { bookmarks: rv, favicons };
 },
};

function getTypedURLs(registryKeyPath) {
 // The list of typed URLs is a sort of annotation stored in the registry.
 // The number of entries stored is not UI-configurable, but has changed
 // between different Windows versions. We just keep reading up to the first
 // non-existing entry to support different limits / states of the registry.
 let typedURLs = new Map();
 let typedURLKey = Cc["@mozilla.org/windows-registry-key;1"].createInstance(
   Ci.nsIWindowsRegKey
 );
 let typedURLTimeKey = Cc[
   "@mozilla.org/windows-registry-key;1"
 ].createInstance(Ci.nsIWindowsRegKey);
 let cTypes = new CtypesKernelHelpers();
 try {
   try {
     typedURLKey.open(
       Ci.nsIWindowsRegKey.ROOT_KEY_CURRENT_USER,
       registryKeyPath + "\\TypedURLs",
       Ci.nsIWindowsRegKey.ACCESS_READ
     );
   } catch (ex) {
     // Ignore errors opening this registry key - if it doesn't work, there's
     // no way we can get useful info here.
     return typedURLs;
   }
   try {
     typedURLTimeKey.open(
       Ci.nsIWindowsRegKey.ROOT_KEY_CURRENT_USER,
       registryKeyPath + "\\TypedURLsTime",
       Ci.nsIWindowsRegKey.ACCESS_READ
     );
   } catch (ex) {
     typedURLTimeKey = null;
   }
   let entryName;
   for (
     let entry = 1;
     typedURLKey.hasValue((entryName = "url" + entry));
     entry++
   ) {
     let url = typedURLKey.readStringValue(entryName);
     // If we can't get a date for whatever reason, default to 6 months ago
     let timeTyped = Date.now() - 31536000 / 2;
     if (typedURLTimeKey && typedURLTimeKey.hasValue(entryName)) {
       let urlTime = "";
       try {
         urlTime = typedURLTimeKey.readBinaryValue(entryName);
       } catch (ex) {
         console.error("Couldn't read url time for ", entryName);
       }
       if (urlTime.length == 8) {
         let urlTimeHex = [];
         for (let i = 0; i < 8; i++) {
           let c = urlTime.charCodeAt(i).toString(16);
           if (c.length == 1) {
             c = "0" + c;
           }
           urlTimeHex.unshift(c);
         }
         try {
           let hi = parseInt(urlTimeHex.slice(0, 4).join(""), 16);
           let lo = parseInt(urlTimeHex.slice(4, 8).join(""), 16);
           // Convert to seconds since epoch:
           let secondsSinceEpoch = cTypes.fileTimeToSecondsSinceEpoch(hi, lo);

           // If the date is very far in the past, just use the default
           if (secondsSinceEpoch > Date.now() / 1000000) {
             // Callers expect PRTime, which is microseconds since epoch:
             timeTyped = secondsSinceEpoch * 1000;
           }
         } catch (ex) {
           // Ignore conversion exceptions. Callers will have to deal
           // with the fallback value.
         }
       }
     }
     typedURLs.set(url, timeTyped * 1000);
   }
 } catch (ex) {
   console.error("Error reading typed URL history: ", ex);
 } finally {
   if (typedURLKey) {
     typedURLKey.close();
   }
   if (typedURLTimeKey) {
     typedURLTimeKey.close();
   }
   cTypes.finalize();
 }
 return typedURLs;
}

// Migrator for form passwords
function WindowsVaultFormPasswords() {}

WindowsVaultFormPasswords.prototype = {
 type: MigrationUtils.resourceTypes.PASSWORDS,

 get exists() {
   // check if there are passwords available for migration.
   return this.migrate(() => {}, true);
 },

 /**
  * If aOnlyCheckExists is false, import the form passwords from the vault
  * and then call the aCallback.
  * Otherwise, check if there are passwords in the vault.
  *
  * @param {Function} aCallback - a callback called when the migration is done.
  * @param {boolean} [aOnlyCheckExists=false] - if aOnlyCheckExists is true, just check if there are some
  * passwords to migrate. Import the passwords from the vault and call aCallback otherwise.
  * @returns {boolean} true if there are passwords in the vault and aOnlyCheckExists is set to true,
  * false if there is no password in the vault and aOnlyCheckExists is set to true, undefined if
  * aOnlyCheckExists is set to false.
  */
 async migrate(aCallback, aOnlyCheckExists = false) {
   // check if the vault item is an IE/Edge one
   function _isIEOrEdgePassword(id) {
     return (
       id[0] == INTERNET_EXPLORER_EDGE_GUID[0] &&
       id[1] == INTERNET_EXPLORER_EDGE_GUID[1] &&
       id[2] == INTERNET_EXPLORER_EDGE_GUID[2] &&
       id[3] == INTERNET_EXPLORER_EDGE_GUID[3]
     );
   }

   let ctypesVaultHelpers = new CtypesVaultHelpers();
   let ctypesKernelHelpers = new CtypesKernelHelpers();
   let migrationSucceeded = true;
   let successfulVaultOpen = false;
   let error, vault;
   try {
     // web credentials vault id
     let vaultGuid = new ctypesVaultHelpers._structs.GUID(
       WEB_CREDENTIALS_VAULT_ID
     );
     error = new wintypes.DWORD();
     // web credentials vault
     vault = new wintypes.VOIDP();
     // open the current vault using the vaultGuid
     error = ctypesVaultHelpers._functions.VaultOpenVault(
       vaultGuid.address(),
       0,
       vault.address()
     );
     if (error != RESULT_SUCCESS) {
       throw new Error("Unable to open Vault: " + error);
     }
     successfulVaultOpen = true;

     let item = new ctypesVaultHelpers._structs.VAULT_ELEMENT.ptr();
     let itemCount = new wintypes.DWORD();
     // enumerate all the available items. This api is going to return a table of all the
     // available items and item is going to point to the first element of this table.
     error = ctypesVaultHelpers._functions.VaultEnumerateItems(
       vault,
       VAULT_ENUMERATE_ALL_ITEMS,
       itemCount.address(),
       item.address()
     );
     if (error != RESULT_SUCCESS) {
       throw new Error("Unable to enumerate Vault items: " + error);
     }

     let logins = [];
     for (let j = 0; j < itemCount.value; j++) {
       try {
         // if it's not an ie/edge password, skip it
         if (!_isIEOrEdgePassword(item.contents.schemaId.id)) {
           continue;
         }
         let url =
           item.contents.pResourceElement.contents.itemValue.readString();
         let realURL = URL.parse(url);
         if (
           !realURL ||
           !["http:", "https:", "ftp:"].includes(realURL.protocol)
         ) {
           // Ignore items for non-URLs or URLs that aren't HTTP(S)/FTP
           continue;
         }

         // if aOnlyCheckExists is set to true, the purpose of the call is to return true if there is at
         // least a password which is true in this case because a password was by now already found
         if (aOnlyCheckExists) {
           return true;
         }
         let username =
           item.contents.pIdentityElement.contents.itemValue.readString();
         // the current login credential object
         let credential = new ctypesVaultHelpers._structs.VAULT_ELEMENT.ptr();
         error = ctypesVaultHelpers._functions.VaultGetItem(
           vault,
           item.contents.schemaId.address(),
           item.contents.pResourceElement,
           item.contents.pIdentityElement,
           null,
           0,
           0,
           credential.address()
         );
         if (error != RESULT_SUCCESS) {
           throw new Error("Unable to get item: " + error);
         }

         let password =
           credential.contents.pAuthenticatorElement.contents.itemValue.readString();
         let creation = Date.now();
         try {
           // login manager wants time in milliseconds since epoch, so convert
           // to seconds since epoch and multiply to get milliseconds:
           creation =
             ctypesKernelHelpers.fileTimeToSecondsSinceEpoch(
               item.contents.highLastModified,
               item.contents.lowLastModified
             ) * 1000;
         } catch (ex) {
           // Ignore exceptions in the dates and just create the login for right now.
         }
         // create a new login
         logins.push({
           username,
           password,
           origin: realURL.URI.prePath,
           timeCreated: creation,
         });

         // close current item
         error = ctypesVaultHelpers._functions.VaultFree(credential);
         if (error == FREE_CLOSE_FAILED) {
           throw new Error("Unable to free item: " + error);
         }
       } catch (e) {
         migrationSucceeded = false;
         console.error(e);
       } finally {
         // move to next item in the table returned by VaultEnumerateItems
         item = item.increment();
       }
     }

     if (logins.length) {
       await MigrationUtils.insertLoginsWrapper(logins);
     }
   } catch (e) {
     console.error(e);
     migrationSucceeded = false;
   } finally {
     if (successfulVaultOpen) {
       // close current vault
       error = ctypesVaultHelpers._functions.VaultCloseVault(vault);
       if (error == FREE_CLOSE_FAILED) {
         console.error("Unable to close vault: ", error);
       }
     }
     ctypesKernelHelpers.finalize();
     ctypesVaultHelpers.finalize();
     aCallback(migrationSucceeded);
   }
   if (aOnlyCheckExists) {
     return false;
   }
   return undefined;
 },
};

export var MSMigrationUtils = {
 MIGRATION_TYPE_IE: 1,
 MIGRATION_TYPE_EDGE: 2,
 CtypesKernelHelpers,
 getBookmarksMigrator(migrationType = this.MIGRATION_TYPE_IE) {
   return new Bookmarks(migrationType);
 },
 getWindowsVaultFormPasswordsMigrator() {
   return new WindowsVaultFormPasswords();
 },
 getTypedURLs,
 getEdgeLocalDataFolder,
};