diff options
Diffstat (limited to 'toolkit/mozapps/extensions/internal/AddonRepository.sys.mjs')
| -rw-r--r-- | toolkit/mozapps/extensions/internal/AddonRepository.sys.mjs | 1139 |
1 files changed, 1139 insertions, 0 deletions
diff --git a/toolkit/mozapps/extensions/internal/AddonRepository.sys.mjs b/toolkit/mozapps/extensions/internal/AddonRepository.sys.mjs new file mode 100644 index 0000000000..f906f244b6 --- /dev/null +++ b/toolkit/mozapps/extensions/internal/AddonRepository.sys.mjs @@ -0,0 +1,1139 @@ +/* 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 { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs"; + +const lazy = {}; + +ChromeUtils.defineESModuleGetters(lazy, { + AddonManager: "resource://gre/modules/AddonManager.sys.mjs", + AddonManagerPrivate: "resource://gre/modules/AddonManager.sys.mjs", + AsyncShutdown: "resource://gre/modules/AsyncShutdown.sys.mjs", + DeferredTask: "resource://gre/modules/DeferredTask.sys.mjs", + Preferences: "resource://gre/modules/Preferences.sys.mjs", + ServiceRequest: "resource://gre/modules/ServiceRequest.sys.mjs", +}); + +XPCOMUtils.defineLazyModuleGetters(lazy, { + NetUtil: "resource://gre/modules/NetUtil.jsm", +}); + +// The current platform as specified in the AMO API: +// http://addons-server.readthedocs.io/en/latest/topics/api/addons.html#addon-detail-platform +XPCOMUtils.defineLazyGetter(lazy, "PLATFORM", () => { + let platform = Services.appinfo.OS; + switch (platform) { + case "Darwin": + return "mac"; + + case "Linux": + return "linux"; + + case "Android": + return "android"; + + case "WINNT": + return "windows"; + } + return platform; +}); + +const PREF_GETADDONS_CACHE_ENABLED = "extensions.getAddons.cache.enabled"; + +XPCOMUtils.defineLazyPreferenceGetter( + lazy, + "getAddonsCacheEnabled", + PREF_GETADDONS_CACHE_ENABLED +); + +const PREF_GETADDONS_CACHE_TYPES = "extensions.getAddons.cache.types"; +const PREF_GETADDONS_CACHE_ID_ENABLED = + "extensions.%ID%.getAddons.cache.enabled"; +const PREF_GETADDONS_BROWSEADDONS = "extensions.getAddons.browseAddons"; +const PREF_GETADDONS_BYIDS = "extensions.getAddons.get.url"; +const PREF_GETADDONS_BROWSESEARCHRESULTS = + "extensions.getAddons.search.browseURL"; +const PREF_GETADDONS_DB_SCHEMA = "extensions.getAddons.databaseSchema"; +const PREF_GET_LANGPACKS = "extensions.getAddons.langpacks.url"; + +const PREF_METADATA_LASTUPDATE = "extensions.getAddons.cache.lastUpdate"; +const PREF_METADATA_UPDATETHRESHOLD_SEC = + "extensions.getAddons.cache.updateThreshold"; +const DEFAULT_METADATA_UPDATETHRESHOLD_SEC = 172800; // two days + +const DEFAULT_CACHE_TYPES = "extension,theme,locale,dictionary"; + +const FILE_DATABASE = "addons.json"; +const DB_SCHEMA = 6; +const DB_MIN_JSON_SCHEMA = 5; +const DB_BATCH_TIMEOUT_MS = 50; + +const BLANK_DB = function () { + return { + addons: new Map(), + schema: DB_SCHEMA, + }; +}; + +import { Log } from "resource://gre/modules/Log.sys.mjs"; + +const LOGGER_ID = "addons.repository"; + +// Create a new logger for use by the Addons Repository +// (Requires AddonManager.jsm) +var logger = Log.repository.getLogger(LOGGER_ID); + +function convertHTMLToPlainText(html) { + if (!html) { + return html; + } + var converter = Cc[ + "@mozilla.org/widget/htmlformatconverter;1" + ].createInstance(Ci.nsIFormatConverter); + + var input = Cc["@mozilla.org/supports-string;1"].createInstance( + Ci.nsISupportsString + ); + input.data = html.replace(/\n/g, "<br>"); + + var output = {}; + converter.convert("text/html", input, "text/plain", output); + + if (output.value instanceof Ci.nsISupportsString) { + return output.value.data.replace(/\r\n/g, "\n"); + } + return html; +} + +async function getAddonsToCache(aIds) { + let types = + lazy.Preferences.get(PREF_GETADDONS_CACHE_TYPES) || DEFAULT_CACHE_TYPES; + + types = types.split(","); + + let addons = await lazy.AddonManager.getAddonsByIDs(aIds); + let enabledIds = []; + + for (let [i, addon] of addons.entries()) { + var preference = PREF_GETADDONS_CACHE_ID_ENABLED.replace("%ID%", aIds[i]); + // If the preference doesn't exist caching is enabled by default + if (!lazy.Preferences.get(preference, true)) { + continue; + } + + // The add-ons manager may not know about this ID yet if it is a pending + // install. In that case we'll just cache it regardless + + // Don't cache add-ons of the wrong types + if (addon && !types.includes(addon.type)) { + continue; + } + + // Don't cache system add-ons + if (addon && addon.isSystem) { + continue; + } + + enabledIds.push(aIds[i]); + } + + return enabledIds; +} + +function AddonSearchResult(aId) { + this.id = aId; + this.icons = {}; + this._unsupportedProperties = {}; +} + +AddonSearchResult.prototype = { + /** + * The ID of the add-on + */ + id: null, + + /** + * The add-on type (e.g. "extension" or "theme") + */ + type: null, + + /** + * The name of the add-on + */ + name: null, + + /** + * The version of the add-on + */ + version: null, + + /** + * The creator of the add-on + */ + creator: null, + + /** + * The developers of the add-on + */ + developers: null, + + /** + * A short description of the add-on + */ + description: null, + + /** + * The full description of the add-on + */ + fullDescription: null, + + /** + * The end-user licensing agreement (EULA) of the add-on + */ + eula: null, + + /** + * The url of the add-on's icon + */ + get iconURL() { + return this.icons && this.icons[32]; + }, + + /** + * The URLs of the add-on's icons, as an object with icon size as key + */ + icons: null, + + /** + * An array of screenshot urls for the add-on + */ + screenshots: null, + + /** + * The homepage for the add-on + */ + homepageURL: null, + + /** + * The support URL for the add-on + */ + supportURL: null, + + /** + * The contribution url of the add-on + */ + contributionURL: null, + + /** + * The rating of the add-on, 0-5 + */ + averageRating: null, + + /** + * The number of reviews for this add-on + */ + reviewCount: null, + + /** + * The URL to the list of reviews for this add-on + */ + reviewURL: null, + + /** + * The number of times the add-on was downloaded the current week + */ + weeklyDownloads: null, + + /** + * AddonInstall object generated from the add-on XPI url + */ + install: null, + + /** + * nsIURI storing where this add-on was installed from + */ + sourceURI: null, + + /** + * The Date that the add-on was most recently updated + */ + updateDate: null, + + toJSON() { + let json = {}; + + for (let property of Object.keys(this)) { + let value = this[property]; + if (property.startsWith("_") || typeof value === "function") { + continue; + } + + try { + switch (property) { + case "sourceURI": + json.sourceURI = value ? value.spec : ""; + break; + + case "updateDate": + json.updateDate = value ? value.getTime() : ""; + break; + + default: + json[property] = value; + } + } catch (ex) { + logger.warn("Error writing property value for " + property); + } + } + + for (let property of Object.keys(this._unsupportedProperties)) { + let value = this._unsupportedProperties[property]; + if (!property.startsWith("_")) { + json[property] = value; + } + } + + return json; + }, +}; + +/** + * The add-on repository is a source of add-ons that can be installed. It can + * be searched in three ways. The first takes a list of IDs and returns a + * list of the corresponding add-ons. The second returns a list of add-ons that + * come highly recommended. This list should change frequently. The third is to + * search for specific search terms entered by the user. Searches are + * asynchronous and results should be passed to the provided callback object + * when complete. The results passed to the callback should only include add-ons + * that are compatible with the current application and are not already + * installed. + */ +export var AddonRepository = { + /** + * The homepage for visiting this repository. If the corresponding preference + * is not defined, defaults to about:blank. + */ + get homepageURL() { + let url = this._formatURLPref(PREF_GETADDONS_BROWSEADDONS, {}); + return url != null ? url : "about:blank"; + }, + + /** + * Retrieves the url that can be visited to see search results for the given + * terms. If the corresponding preference is not defined, defaults to + * about:blank. + * + * @param aSearchTerms + * Search terms used to search the repository + */ + getSearchURL(aSearchTerms) { + let url = this._formatURLPref(PREF_GETADDONS_BROWSESEARCHRESULTS, { + TERMS: aSearchTerms, + }); + return url != null ? url : "about:blank"; + }, + + /** + * Whether caching is currently enabled + */ + get cacheEnabled() { + return lazy.getAddonsCacheEnabled; + }, + + /** + * Shut down AddonRepository + * return: promise{integer} resolves with the result of flushing + * the AddonRepository database + */ + shutdown() { + return AddonDatabase.shutdown(false); + }, + + metadataAge() { + let now = Math.round(Date.now() / 1000); + let lastUpdate = Services.prefs.getIntPref(PREF_METADATA_LASTUPDATE, 0); + return Math.max(0, now - lastUpdate); + }, + + isMetadataStale() { + let threshold = Services.prefs.getIntPref( + PREF_METADATA_UPDATETHRESHOLD_SEC, + DEFAULT_METADATA_UPDATETHRESHOLD_SEC + ); + return this.metadataAge() > threshold; + }, + + /** + * Asynchronously get a cached add-on by id. The add-on (or null if the + * add-on is not found) is passed to the specified callback. If caching is + * disabled, null is passed to the specified callback. + * + * The callback variant exists only for existing code in XPIProvider.jsm + * and XPIDatabase.jsm that requires a synchronous callback, yuck. + * + * @param aId + * The id of the add-on to get + */ + async getCachedAddonByID(aId, aCallback) { + if (!aId || !this.cacheEnabled) { + if (aCallback) { + aCallback(null); + } + return null; + } + + if (aCallback && AddonDatabase._loaded) { + let addon = AddonDatabase.getAddon(aId); + aCallback(addon); + return addon; + } + + await AddonDatabase.openConnection(); + + let addon = AddonDatabase.getAddon(aId); + if (aCallback) { + aCallback(addon); + } + return addon; + }, + + /* + * Clear and delete the AddonRepository database + * @return Promise{null} resolves when the database is deleted + */ + _clearCache() { + return AddonDatabase.delete().then(() => + lazy.AddonManagerPrivate.updateAddonRepositoryData() + ); + }, + + /** + * Fetch data from an API where the results may span multiple "pages". + * This function will take care of issuing multiple requests until all + * the results have been fetched, and will coalesce them all into a + * single return value. The handling here is specific to the way AMO + * implements paging (ie a JSON result with a "next" property). + * + * @param {string} startURL + * URL for the first page of results + * @param {function} handler + * This function will be called once per page of results, + * it should return an array of objects (the type depends + * on the particular API being called of course). + * + * @returns Promise{array} An array of all the individual results from + * the API call(s). + */ + _fetchPaged(ids, pref, handler) { + let startURL = this._formatURLPref(pref, { IDS: ids.join(",") }); + let results = []; + let idCheck = ids.map(id => { + if (id.startsWith("rta:")) { + return atob(id.split(":")[1]); + } + return id; + }); + + const fetchNextPage = url => { + return new Promise((resolve, reject) => { + let request = new lazy.ServiceRequest({ mozAnon: true }); + request.mozBackgroundRequest = true; + request.open("GET", url, true); + request.responseType = "json"; + + request.addEventListener("error", aEvent => { + reject(new Error(`GET ${url} failed`)); + }); + request.addEventListener("timeout", aEvent => { + reject(new Error(`GET ${url} timed out`)); + }); + request.addEventListener("load", aEvent => { + let response = request.response; + if (!response || (request.status != 200 && request.status != 0)) { + reject(new Error(`GET ${url} failed (status ${request.status})`)); + return; + } + + try { + let newResults = handler(response.results).filter(e => + idCheck.includes(e.id) + ); + results.push(...newResults); + } catch (err) { + reject(err); + } + + if (response.next) { + resolve(fetchNextPage(response.next)); + } + + resolve(results); + }); + + request.send(null); + }); + }; + + return fetchNextPage(startURL); + }, + + /** + * Fetch metadata for a given set of addons from AMO. + * + * @param aIDs + * The array of ids to retrieve metadata for. + * @returns {array<AddonSearchResult>} + */ + async getAddonsByIDs(aIDs) { + return this._fetchPaged(aIDs, PREF_GETADDONS_BYIDS, results => + results.map(entry => this._parseAddon(entry)) + ); + }, + + /** + * Fetch addon metadata for a set of addons. + * + * @param {array<string>} aIDs + * A list of addon IDs to fetch information about. + * + * @returns {array<AddonSearchResult>} + */ + async _getFullData(aIDs) { + let addons = []; + try { + addons = await this.getAddonsByIDs(aIDs, false); + } catch (err) { + logger.error(`Error in addon metadata check: ${err.message}`); + } + + return addons; + }, + + /** + * Asynchronously add add-ons to the cache corresponding to the specified + * ids. If caching is disabled, the cache is unchanged. + * + * @param aIds + * The array of add-on ids to add to the cache + */ + async cacheAddons(aIds) { + logger.debug( + "cacheAddons: enabled " + this.cacheEnabled + " IDs " + aIds.toSource() + ); + if (!this.cacheEnabled) { + return []; + } + + let ids = await getAddonsToCache(aIds); + + // If there are no add-ons to cache, act as if caching is disabled + if (!ids.length) { + return []; + } + + let addons = await this._getFullData(ids); + await AddonDatabase.update(addons); + + return Array.from(addons.values()); + }, + + /** + * Performs the daily background update check. + * + * @return Promise{null} Resolves when the metadata update is complete. + */ + async backgroundUpdateCheck() { + let shutter = (async () => { + let allAddons = await lazy.AddonManager.getAllAddons(); + + // Completely remove cache if caching is not enabled + if (!this.cacheEnabled) { + logger.debug("Clearing cache because it is disabled"); + await this._clearCache(); + return; + } + + let ids = allAddons.map(a => a.id); + logger.debug("Repopulate add-on cache with " + ids.toSource()); + + let addonsToCache = await getAddonsToCache(ids); + + // Completely remove cache if there are no add-ons to cache + if (!addonsToCache.length) { + logger.debug("Clearing cache because 0 add-ons were requested"); + await this._clearCache(); + return; + } + + let addons = await this._getFullData(addonsToCache); + + AddonDatabase.repopulate(addons); + + // Always call AddonManager updateAddonRepositoryData after we refill the cache + await lazy.AddonManagerPrivate.updateAddonRepositoryData(); + })(); + lazy.AddonManager.beforeShutdown.addBlocker( + "AddonRepository Background Updater", + shutter + ); + await shutter; + lazy.AddonManager.beforeShutdown.removeBlocker(shutter); + }, + + /* + * Creates an AddonSearchResult by parsing an entry from the AMO API. + * + * @param aEntry + * An entry from the AMO search API to parse. + * @return Result object containing the parsed AddonSearchResult + */ + _parseAddon(aEntry) { + let addon = new AddonSearchResult(aEntry.guid); + + addon.name = aEntry.name; + if (typeof aEntry.current_version == "object") { + addon.version = String(aEntry.current_version.version); + if (Array.isArray(aEntry.current_version.files)) { + for (let file of aEntry.current_version.files) { + if (file.platform == "all" || file.platform == lazy.PLATFORM) { + if (file.url) { + addon.sourceURI = lazy.NetUtil.newURI(file.url); + } + break; + } + } + } + } + addon.homepageURL = aEntry.homepage; + addon.supportURL = aEntry.support_url; + + addon.description = convertHTMLToPlainText(aEntry.summary); + addon.fullDescription = convertHTMLToPlainText(aEntry.description); + + addon.weeklyDownloads = aEntry.weekly_downloads; + + switch (aEntry.type) { + case "persona": + case "statictheme": + addon.type = "theme"; + break; + + case "language": + addon.type = "locale"; + break; + + default: + addon.type = aEntry.type; + break; + } + + if (Array.isArray(aEntry.authors)) { + let authors = aEntry.authors.map( + author => + new lazy.AddonManagerPrivate.AddonAuthor(author.name, author.url) + ); + if (authors.length) { + addon.creator = authors[0]; + addon.developers = authors.slice(1); + } + } + + if (typeof aEntry.previews == "object") { + addon.screenshots = aEntry.previews.map(shot => { + let safeSize = orig => + Array.isArray(orig) && orig.length >= 2 ? orig : [null, null]; + let imageSize = safeSize(shot.image_size); + let thumbSize = safeSize(shot.thumbnail_size); + return new lazy.AddonManagerPrivate.AddonScreenshot( + shot.image_url, + imageSize[0], + imageSize[1], + shot.thumbnail_url, + thumbSize[0], + thumbSize[1], + shot.caption + ); + }); + } + + addon.contributionURL = aEntry.contributions_url; + + if (typeof aEntry.ratings == "object") { + addon.averageRating = Math.min(5, aEntry.ratings.average); + addon.reviewCount = aEntry.ratings.text_count; + } + + addon.reviewURL = aEntry.ratings_url; + if (aEntry.last_updated) { + addon.updateDate = new Date(aEntry.last_updated); + } + + addon.icons = aEntry.icons || {}; + + return addon; + }, + + // Create url from preference, returning null if preference does not exist + _formatURLPref(aPreference, aSubstitutions = {}) { + let url = Services.prefs.getCharPref(aPreference, ""); + if (!url) { + logger.warn("_formatURLPref: Couldn't get pref: " + aPreference); + return null; + } + + url = url.replace(/%([A-Z_]+)%/g, function (aMatch, aKey) { + return aKey in aSubstitutions + ? encodeURIComponent(aSubstitutions[aKey]) + : aMatch; + }); + + return Services.urlFormatter.formatURL(url); + }, + + flush() { + return AddonDatabase.flush(); + }, + + async getAvailableLangpacks() { + // This should be the API endpoint documented at: + // http://addons-server.readthedocs.io/en/latest/topics/api/addons.html#language-tools + let url = this._formatURLPref(PREF_GET_LANGPACKS); + + let response = await fetch(url, { credentials: "omit" }); + if (!response.ok) { + throw new Error("fetching available language packs failed"); + } + + let data = await response.json(); + + let result = []; + for (let entry of data.results) { + if ( + !entry.current_compatible_version || + !entry.current_compatible_version.files + ) { + continue; + } + + for (let file of entry.current_compatible_version.files) { + if ( + file.platform == "all" || + file.platform == Services.appinfo.OS.toLowerCase() + ) { + result.push({ + target_locale: entry.target_locale, + url: file.url, + hash: file.hash, + }); + } + } + } + + return result; + }, +}; + +var AddonDatabase = { + connectionPromise: null, + _loaded: false, + _saveTask: null, + _blockerAdded: false, + + // the in-memory database + DB: BLANK_DB(), + + /** + * A getter to retrieve the path to the DB + */ + get jsonFile() { + return PathUtils.join( + Services.dirsvc.get("ProfD", Ci.nsIFile).path, + FILE_DATABASE + ); + }, + + /** + * Asynchronously opens a new connection to the database file. + * + * @return {Promise} a promise that resolves to the database. + */ + openConnection() { + if (!this.connectionPromise) { + this.connectionPromise = (async () => { + let inputDB, schema; + + try { + let data = await IOUtils.readUTF8(this.jsonFile); + inputDB = JSON.parse(data); + + if ( + !inputDB.hasOwnProperty("addons") || + !Array.isArray(inputDB.addons) + ) { + throw new Error("No addons array."); + } + + if (!inputDB.hasOwnProperty("schema")) { + throw new Error("No schema specified."); + } + + schema = parseInt(inputDB.schema, 10); + + if (!Number.isInteger(schema) || schema < DB_MIN_JSON_SCHEMA) { + throw new Error("Invalid schema value."); + } + } catch (e) { + if (e.name == "NotFoundError") { + logger.debug("No " + FILE_DATABASE + " found."); + } else { + logger.error( + `Malformed ${FILE_DATABASE}: ${e} - resetting to empty` + ); + } + + // Create a blank addons.json file + this.save(); + + Services.prefs.setIntPref(PREF_GETADDONS_DB_SCHEMA, DB_SCHEMA); + this._loaded = true; + return this.DB; + } + + Services.prefs.setIntPref(PREF_GETADDONS_DB_SCHEMA, DB_SCHEMA); + + // Convert the addon objects as necessary + // and store them in our in-memory copy of the database. + for (let addon of inputDB.addons) { + let id = addon.id; + + let entry = this._parseAddon(addon); + this.DB.addons.set(id, entry); + } + + this._loaded = true; + return this.DB; + })(); + } + + return this.connectionPromise; + }, + + /** + * Asynchronously shuts down the database connection and releases all + * cached objects + * + * @param aCallback + * An optional callback to call once complete + * @param aSkipFlush + * An optional boolean to skip flushing data to disk. Useful + * when the database is going to be deleted afterwards. + */ + shutdown(aSkipFlush) { + if (!this.connectionPromise) { + return Promise.resolve(); + } + + this.connectionPromise = null; + this._loaded = false; + + if (aSkipFlush) { + return Promise.resolve(); + } + + return this.flush(); + }, + + /** + * Asynchronously deletes the database, shutting down the connection + * first if initialized + * + * @param aCallback + * An optional callback to call once complete + * @return Promise{null} resolves when the database has been deleted + */ + delete(aCallback) { + this.DB = BLANK_DB(); + + if (this._saveTask) { + this._saveTask.disarm(); + this._saveTask = null; + } + + // shutdown(true) never rejects + this._deleting = this.shutdown(true) + .then(() => IOUtils.remove(this.jsonFile)) + .catch(error => + logger.error( + "Unable to delete Addon Repository file " + this.jsonFile, + error + ) + ) + .then(() => (this._deleting = null)) + .then(aCallback); + + return this._deleting; + }, + + async _saveNow() { + let json = { + schema: this.DB.schema, + addons: Array.from(this.DB.addons.values()), + }; + + await IOUtils.writeUTF8(this.jsonFile, JSON.stringify(json), { + tmpPath: `${this.jsonFile}.tmp`, + }); + }, + + save() { + if (!this._saveTask) { + this._saveTask = new lazy.DeferredTask( + () => this._saveNow(), + DB_BATCH_TIMEOUT_MS + ); + + if (!this._blockerAdded) { + lazy.AsyncShutdown.profileBeforeChange.addBlocker( + "Flush AddonRepository", + () => this.flush() + ); + this._blockerAdded = true; + } + } + this._saveTask.arm(); + }, + + /** + * Flush any pending I/O on the addons.json file + * @return: Promise{null} + * Resolves when the pending I/O (writing out or deleting + * addons.json) completes + */ + flush() { + if (this._deleting) { + return this._deleting; + } + + if (this._saveTask) { + let promise = this._saveTask.finalize(); + this._saveTask = null; + return promise; + } + + return Promise.resolve(); + }, + + /** + * Get an individual addon entry from the in-memory cache. + * Note: calling this function before the database is read will + * return undefined. + * + * @param {string} aId The id of the addon to retrieve. + */ + getAddon(aId) { + return this.DB.addons.get(aId); + }, + + /** + * Asynchronously repopulates the database so it only contains the + * specified add-ons + * + * @param {Map} aAddons + * Add-ons to repopulate the database with. + */ + repopulate(aAddons) { + this.DB = BLANK_DB(); + this._update(aAddons); + + let now = Math.round(Date.now() / 1000); + logger.debug( + "Cache repopulated, setting " + PREF_METADATA_LASTUPDATE + " to " + now + ); + Services.prefs.setIntPref(PREF_METADATA_LASTUPDATE, now); + }, + + /** + * Asynchronously insert new addons into the database. + * + * @param {Map} aAddons + * Add-ons to insert/update in the database + */ + async update(aAddons) { + await this.openConnection(); + + this._update(aAddons); + + this.save(); + }, + + /** + * Merge the given addons into the database. + * + * @param {Map} aAddons + * Add-ons to insert/update in the database + */ + _update(aAddons) { + for (let addon of aAddons) { + this.DB.addons.set(addon.id, this._parseAddon(addon)); + } + + this.save(); + }, + + /* + * Creates an AddonSearchResult by parsing an object structure + * retrieved from the DB JSON representation. + * + * @param aObj + * The object to parse + * @return Returns an AddonSearchResult object. + */ + _parseAddon(aObj) { + if (aObj instanceof AddonSearchResult) { + return aObj; + } + + let id = aObj.id; + if (!aObj.id) { + return null; + } + + let addon = new AddonSearchResult(id); + + for (let expectedProperty of Object.keys(AddonSearchResult.prototype)) { + if ( + !(expectedProperty in aObj) || + typeof aObj[expectedProperty] === "function" + ) { + continue; + } + + let value = aObj[expectedProperty]; + + try { + switch (expectedProperty) { + case "sourceURI": + addon.sourceURI = value ? lazy.NetUtil.newURI(value) : null; + break; + + case "creator": + addon.creator = value ? this._makeDeveloper(value) : null; + break; + + case "updateDate": + addon.updateDate = value ? new Date(value) : null; + break; + + case "developers": + if (!addon.developers) { + addon.developers = []; + } + for (let developer of value) { + addon.developers.push(this._makeDeveloper(developer)); + } + break; + + case "screenshots": + if (!addon.screenshots) { + addon.screenshots = []; + } + for (let screenshot of value) { + addon.screenshots.push(this._makeScreenshot(screenshot)); + } + break; + + case "icons": + if (!addon.icons) { + addon.icons = {}; + } + for (let size of Object.keys(aObj.icons)) { + addon.icons[size] = aObj.icons[size]; + } + break; + + case "iconURL": + break; + + default: + addon[expectedProperty] = value; + } + } catch (ex) { + logger.warn( + "Error in parsing property value for " + expectedProperty + " | " + ex + ); + } + + // delete property from obj to indicate we've already + // handled it. The remaining public properties will + // be stored separately and just passed through to + // be written back to the DB. + delete aObj[expectedProperty]; + } + + // Copy remaining properties to a separate object + // to prevent accidental access on downgraded versions. + // The properties will be merged in the same object + // prior to being written back through toJSON. + for (let remainingProperty of Object.keys(aObj)) { + switch (typeof aObj[remainingProperty]) { + case "boolean": + case "number": + case "string": + case "object": + // these types are accepted + break; + default: + continue; + } + + if (!remainingProperty.startsWith("_")) { + addon._unsupportedProperties[remainingProperty] = + aObj[remainingProperty]; + } + } + + return addon; + }, + + /** + * Make a developer object from a vanilla + * JS object from the JSON database + * + * @param aObj + * The JS object to use + * @return The created developer + */ + _makeDeveloper(aObj) { + let name = aObj.name; + let url = aObj.url; + return new lazy.AddonManagerPrivate.AddonAuthor(name, url); + }, + + /** + * Make a screenshot object from a vanilla + * JS object from the JSON database + * + * @param aObj + * The JS object to use + * @return The created screenshot + */ + _makeScreenshot(aObj) { + let url = aObj.url; + let width = aObj.width; + let height = aObj.height; + let thumbnailURL = aObj.thumbnailURL; + let thumbnailWidth = aObj.thumbnailWidth; + let thumbnailHeight = aObj.thumbnailHeight; + let caption = aObj.caption; + return new lazy.AddonManagerPrivate.AddonScreenshot( + url, + width, + height, + thumbnailURL, + thumbnailWidth, + thumbnailHeight, + caption + ); + }, +}; |