--- a/browser/components/extensions/parent/ext-devtools-inspectedWindow.js
+++ b/browser/components/extensions/parent/ext-devtools-inspectedWindow.js
@@ -6,17 +6,17 @@ var {
   SpreadArgs,
 } = ExtensionCommon;
 
 this.devtools_inspectedWindow = class extends ExtensionAPI {
   getAPI(context) {
     // Lazily retrieved inspectedWindow actor front per child context.
     let waitForInspectedWindowFront;
 
-    // TODO - Bug 1448878: retrive a more detailed callerInfo object,
+    // TODO - Bug 1448878: retrieve a more detailed callerInfo object,
     // like the filename and lineNumber of the actual extension called
     // in the child process.
     const callerInfo = {
       addonId: context.extension.id,
       url: context.extension.baseURI.spec,
     };
 
     return {

--- a/browser/components/extensions/parent/ext-devtools-panels.js
+++ b/browser/components/extensions/parent/ext-devtools-panels.js
@@ -500,17 +500,17 @@ class ParentDevToolsInspectorSidebar {
 const sidebarsById = new Map();
 
 this.devtools_panels = class extends ExtensionAPI {
   getAPI(context) {
     // Lazily retrieved inspectedWindow actor front per child context
     // (used by Sidebar.setExpression).
     let waitForInspectedWindowFront;
 
-    // TODO - Bug 1448878: retrive a more detailed callerInfo object,
+    // TODO - Bug 1448878: retrieve a more detailed callerInfo object,
     // like the filename and lineNumber of the actual extension called
     // in the child process.
     const callerInfo = {
       addonId: context.extension.id,
       url: context.extension.baseURI.spec,
     };
 
     // An incremental "per context" id used in the generated devtools panel id.

--- a/browser/components/extensions/parent/ext-find.js
+++ b/browser/components/extensions/parent/ext-find.js
@@ -93,17 +93,17 @@ this.find = class extends ExtensionAPI {
          */
         highlightResults(params) {
           params = params || {};
           return runFindOperation(params, "HighlightResults");
         },
 
         /**
          * browser.find.removeHighlighting
-         * Removes all hightlighting from previous search.
+         * Removes all highlighting from previous search.
          *
          * @param {number} tabId optional
          *                 Tab to clear highlighting in.  Defaults to the active tab.
          */
         removeHighlighting(tabId) {
           let tab = tabId ? tabTracker.getTab(tabId) : tabTracker.activeTab;
           tab.linkedBrowser.messageManager.sendAsyncMessage("ext-Finder:clearHighlighting");
         },

--- a/browser/components/extensions/test/xpcshell/test_ext_chrome_settings_overrides_update.js
+++ b/browser/components/extensions/test/xpcshell/test_ext_chrome_settings_overrides_update.js
@@ -68,20 +68,20 @@ add_task(async function test_overrides_u
   let defaultEngineName = Services.search.currentEngine.name;
 
   let prefPromise = promisePrefChanged(HOMEPAGE_URI);
   await extension.startup();
   await prefPromise;
 
   equal(extension.version, "1.0", "The installed addon has the expected version.");
   ok(getHomePageURL().endsWith(HOMEPAGE_URI),
-     "Home page url is overriden by the extension.");
+     "Home page url is overridden by the extension.");
   equal(Services.search.currentEngine.name,
         "DuckDuckGo",
-        "Default engine is overriden by the extension");
+        "Default engine is overridden by the extension");
 
   extensionInfo.manifest = {
     "version": "2.0",
     "applications": {
       "gecko": {
         "id": EXTENSION_ID,
       },
     },

--- a/browser/components/extensions/test/xpcshell/test_ext_url_overrides_newtab.js
+++ b/browser/components/extensions/test/xpcshell/test_ext_url_overrides_newtab.js
@@ -106,17 +106,17 @@ add_task(async function test_multiple_ex
   await ext1.startup();
   equal(aboutNewTabService.newTabURL, DEFAULT_NEW_TAB_URL,
         "newTabURL is still set to the default.");
 
   await checkNewTabPageOverride(ext1, aboutNewTabService.newTabURL, NOT_CONTROLLABLE);
 
   await ext2.startup();
   ok(aboutNewTabService.newTabURL.endsWith(NEWTAB_URI_2),
-     "newTabURL is overriden by the second extension.");
+     "newTabURL is overridden by the second extension.");
   await checkNewTabPageOverride(ext1, NEWTAB_URI_2, CONTROLLED_BY_OTHER);
 
   // Verify that calling set and clear do nothing.
   ext2.sendMessage("trySet");
   await ext2.awaitMessage("newTabPageSet");
   await checkNewTabPageOverride(ext1, NEWTAB_URI_2, CONTROLLED_BY_OTHER);
 
   ext2.sendMessage("tryClear");
@@ -132,48 +132,48 @@ add_task(async function test_multiple_ex
         "newTabURL url is reset to the default after second extension is disabled.");
   await checkNewTabPageOverride(ext1, aboutNewTabService.newTabURL, NOT_CONTROLLABLE);
 
   // Re-enable the second extension.
   let enabledPromise = awaitEvent("ready");
   addon.userDisabled = false;
   await enabledPromise;
   ok(aboutNewTabService.newTabURL.endsWith(NEWTAB_URI_2),
-     "newTabURL is overriden by the second extension.");
+     "newTabURL is overridden by the second extension.");
   await checkNewTabPageOverride(ext2, NEWTAB_URI_2, CONTROLLED_BY_THIS);
 
   await ext1.unload();
   ok(aboutNewTabService.newTabURL.endsWith(NEWTAB_URI_2),
-     "newTabURL is still overriden by the second extension.");
+     "newTabURL is still overridden by the second extension.");
   await checkNewTabPageOverride(ext2, NEWTAB_URI_2, CONTROLLED_BY_THIS);
 
   await ext3.startup();
   ok(aboutNewTabService.newTabURL.endsWith(NEWTAB_URI_3),
-     "newTabURL is overriden by the third extension.");
+     "newTabURL is overridden by the third extension.");
   await checkNewTabPageOverride(ext2, NEWTAB_URI_3, CONTROLLED_BY_OTHER);
 
   // Disable the second extension.
   disabledPromise = awaitEvent("shutdown");
   addon.userDisabled = true;
   await disabledPromise;
   ok(aboutNewTabService.newTabURL.endsWith(NEWTAB_URI_3),
-     "newTabURL is still overriden by the third extension.");
+     "newTabURL is still overridden by the third extension.");
   await checkNewTabPageOverride(ext3, NEWTAB_URI_3, CONTROLLED_BY_THIS);
 
   // Re-enable the second extension.
   enabledPromise = awaitEvent("ready");
   addon.userDisabled = false;
   await enabledPromise;
   ok(aboutNewTabService.newTabURL.endsWith(NEWTAB_URI_3),
-     "newTabURL is still overriden by the third extension.");
+     "newTabURL is still overridden by the third extension.");
   await checkNewTabPageOverride(ext3, NEWTAB_URI_3, CONTROLLED_BY_THIS);
 
   await ext3.unload();
   ok(aboutNewTabService.newTabURL.endsWith(NEWTAB_URI_2),
-     "newTabURL reverts to being overriden by the second extension.");
+     "newTabURL reverts to being overridden by the second extension.");
   await checkNewTabPageOverride(ext2, NEWTAB_URI_2, CONTROLLED_BY_THIS);
 
   await ext2.unload();
   equal(aboutNewTabService.newTabURL, DEFAULT_NEW_TAB_URL,
         "newTabURL url is reset to the default.");
 
   await promiseShutdownManager();
 });

--- a/browser/components/extensions/test/xpcshell/test_ext_url_overrides_newtab_update.js
+++ b/browser/components/extensions/test/xpcshell/test_ext_url_overrides_newtab_update.js
@@ -92,17 +92,17 @@ add_task(async function test_url_overrid
   let defaultNewTabURL = aboutNewTabService.newTabURL;
   equal(aboutNewTabService.newTabURL, defaultNewTabURL,
         `Default newtab url is ${defaultNewTabURL}.`);
 
   await extension.startup();
 
   equal(extension.version, "1.0", "The installed addon has the expected version.");
   ok(aboutNewTabService.newTabURL.endsWith(NEWTAB_URI),
-     "Newtab url is overriden by the extension.");
+     "Newtab url is overridden by the extension.");
 
   let update = await promiseFindAddonUpdates(extension.addon);
   let install = update.updateAvailable;
 
   await promiseCompleteAllInstalls([install]);
 
   await extension.awaitStartup();
 

--- a/toolkit/components/extensions/ExtensionCommon.jsm
+++ b/toolkit/components/extensions/ExtensionCommon.jsm
@@ -1758,17 +1758,17 @@ defineLazyGetter(LocaleData.prototype, "
  * to register the listener. `register` should return an
  * unregister function that will unregister the listener.
  * @constructor
  *
  * @param {BaseContext} context
  *        An object representing the extension instance using this event.
  * @param {string} name
  *        A name used only for debugging.
- * @param {functon} register
+ * @param {function} register
  *        A function called whenever a new listener is added.
  */
 function EventManager(context, name, register) {
   this.context = context;
   this.name = name;
   this.register = register;
   this.unregister = new Map();
   this.inputHandling = false;

--- a/toolkit/components/extensions/ExtensionParent.jsm
+++ b/toolkit/components/extensions/ExtensionParent.jsm
@@ -1433,17 +1433,17 @@ let IconDetails = {
   convertImageURLToDataURL(imageURL, contentWindow, browserWindow, size = 18) {
     return new Promise((resolve, reject) => {
       let image = new contentWindow.Image();
       image.onload = function() {
         let canvas = contentWindow.document.createElement("canvas");
         let ctx = canvas.getContext("2d");
         let dSize = size * browserWindow.devicePixelRatio;
 
-        // Scales the image while maintaing width to height ratio.
+        // Scales the image while maintaining width to height ratio.
         // If the width and height differ, the image is centered using the
         // smaller of the two dimensions.
         let dWidth, dHeight, dx, dy;
         if (this.width > this.height) {
           dWidth = dSize;
           dHeight = image.height * (dSize / image.width);
           dx = 0;
           dy = (dSize - dHeight) / 2;

--- a/toolkit/components/extensions/ExtensionPreferencesManager.jsm
+++ b/toolkit/components/extensions/ExtensionPreferencesManager.jsm
@@ -257,17 +257,17 @@ this.ExtensionPreferencesManager = {
     for (let name of settings) {
       disablePromises.push(this.disableSetting(id, name));
     }
     await Promise.all(disablePromises);
   },
 
   /**
    * Enables all disabled settings for an extension. This can be called when
-   * an extension has finsihed updating or is being re-enabled, for example.
+   * an extension has finished updating or is being re-enabled, for example.
    *
    * @param {string} id
    *        The id of the extension for which all settings are being enabled.
    */
   async enableAll(id) {
     await ExtensionSettingsStore.initialize();
     let settings = ExtensionSettingsStore.getAllForExtension(id, STORE_TYPE);
     let enablePromises = [];

--- a/toolkit/components/extensions/ExtensionStorageSync.jsm
+++ b/toolkit/components/extensions/ExtensionStorageSync.jsm
@@ -341,17 +341,17 @@ async function storageSyncInit() {
       Cu.reportError(e);
       storageSyncInit.promise = undefined;
       throw e;
     });
   }
   return storageSyncInit.promise;
 }
 
-// Kinto record IDs have two condtions:
+// Kinto record IDs have two conditions:
 //
 // - They must contain only ASCII alphanumerics plus - and _. To fix
 // this, we encode all non-letters using _C_, where C is the
 // percent-encoded character, so space becomes _20_
 // and underscore becomes _5F_.
 //
 // - They must start with an ASCII letter. To ensure this, we prefix
 // all keys with "key-".
@@ -1038,17 +1038,17 @@ class ExtensionStorageSync {
           // before this client did a sync (and got the new extension
           // and tried to sync the keyring again). Just to be safe,
           // let's signal that something went wrong and we should wipe
           // the bucket.
           throw new ServerKeyringDeleted();
         }
 
         if (keyResolution.accepted.uuid != cryptoKeyRecord.uuid) {
-          log.info(`Detected a new UUID (${keyResolution.accepted.uuid}, was ${cryptoKeyRecord.uuid}). Reseting sync status for everything.`);
+          log.info(`Detected a new UUID (${keyResolution.accepted.uuid}, was ${cryptoKeyRecord.uuid}). Resetting sync status for everything.`);
           await this.cryptoCollection.resetSyncStatus();
 
           // Server version is now correct. Return that result.
           return result;
         }
       }
       // No conflicts, or conflict was just someone else adding keys.
       return result;

--- a/toolkit/components/extensions/ExtensionUtils.jsm
+++ b/toolkit/components/extensions/ExtensionUtils.jsm
@@ -495,17 +495,17 @@ class MessageManagerProxy {
   }
 
   /**
    * Returns true if the given target is the same as, or owns, the given
    * message manager.
    *
    * @param {nsIMessageSender|MessageManagerProxy|Element} target
    *        The message manager, MessageManagerProxy, or <browser>
-   *        element agaisnt which to match.
+   *        element against which to match.
    * @param {nsIMessageSender} messageManager
    *        The message manager against which to match `target`.
    *
    * @returns {boolean}
    *        True if `messageManager` is the same object as `target`, or
    *        `target` is a MessageManagerProxy or <browser> element that
    *        is tied to it.
    */

--- a/toolkit/components/extensions/Schemas.jsm
+++ b/toolkit/components/extensions/Schemas.jsm
@@ -2571,17 +2571,17 @@ class Namespace extends Map {
   extendType(type) {
     let targetType = this.get(type.$extend);
 
     // Only allow extending object and choices types for now.
     if (targetType instanceof ObjectType) {
       type.type = "object";
     } else if (DEBUG) {
       if (!targetType) {
-        throw new Error(`Internal error: Attempt to extend a nonexistant type ${type.$extend}`);
+        throw new Error(`Internal error: Attempt to extend a nonexistent type ${type.$extend}`);
       } else if (!(targetType instanceof ChoiceType)) {
         throw new Error(`Internal error: Attempt to extend a non-extensible type ${type.$extend}`);
       }
     }
 
     let parsed = this.root.parseSchema(type, this.path, ["$extend"]);
 
     if (DEBUG && parsed.constructor !== targetType.constructor) {

--- a/toolkit/components/extensions/extension-process-script.js
+++ b/toolkit/components/extensions/extension-process-script.js
@@ -341,17 +341,17 @@ ExtensionManager = {
         backgroundScripts: (extension.manifest.background &&
                             extension.manifest.background.scripts),
 
         contentScripts: extension.contentScripts.map(parseScriptOptions),
       });
 
       policy.debugName = `${JSON.stringify(policy.name)} (ID: ${policy.id}, ${policy.getURL()})`;
 
-      // Register any existent dinamically registered content script for the extension
+      // Register any existent dynamically registered content script for the extension
       // when a content process is started for the first time (which also cover
       // a content process that crashed and it has been recreated).
       const registeredContentScripts = this.registeredContentScripts.get(policy);
 
       if (extension.registeredContentScripts) {
         for (let [scriptId, options] of extension.registeredContentScripts) {
           const parsedOptions = parseScriptOptions(options);
           const script = new WebExtensionContentScript(policy, parsedOptions);

--- a/toolkit/components/extensions/parent/ext-downloads.js
+++ b/toolkit/components/extensions/parent/ext-downloads.js
@@ -143,17 +143,17 @@ class DownloadItem {
   _storePrechange() {
     for (let field of DOWNLOAD_ITEM_CHANGE_FIELDS) {
       this.prechange[field] = this[field];
     }
   }
 }
 
 
-// DownloadMap maps back and forth betwen the numeric identifiers used in
+// DownloadMap maps back and forth between the numeric identifiers used in
 // the downloads WebExtension API and a Download object from the Downloads jsm.
 // TODO Bug 1247794: make id and extension info persistent
 const DownloadMap = new class extends EventEmitter {
   constructor() {
     super();
 
     this.currentId = 0;
     this.loadPromise = null;

--- a/toolkit/components/extensions/parent/ext-permissions.js
+++ b/toolkit/components/extensions/parent/ext-permissions.js
@@ -54,17 +54,17 @@ this.permissions = class extends Extensi
               };
               Services.obs.notifyObservers(subject, "webextension-optional-permission-prompt");
             });
             if (!allow) {
               return false;
             }
           }
 
-          // Unfortunatelly, we treat <all_urls> as an API permission as well.
+          // Unfortunately, we treat <all_urls> as an API permission as well.
           if (origins.includes("<all_urls>")) {
             perms.permissions.push("<all_urls>");
           }
 
           await ExtensionPermissions.add(context.extension, perms);
           return true;
         },
 

--- a/toolkit/components/extensions/parent/ext-tabs-base.js
+++ b/toolkit/components/extensions/parent/ext-tabs-base.js
@@ -70,17 +70,17 @@ class TabBase {
    * this tab. The tab's current innerWindowID is automatically added to the
    * recipient filter for the message, and is used to ensure that the message is
    * not processed if the content process navigates to a different content page
    * before the message is received.
    *
    * @param {BaseContext} context
    *        The context through which to send the message.
    * @param {string} messageName
-   *        The name of the messge to send.
+   *        The name of the message to send.
    * @param {object} [data = {}]
    *        Arbitrary, structured-clonable message data to send.
    * @param {object} [options]
    *        An options object, as accepted by BaseContext.sendMessage.
    *
    * @returns {Promise}
    */
   sendMessage(context, messageName, data = {}, options = null) {
@@ -562,17 +562,17 @@ class TabBase {
     }
 
     return true;
   }
 
   /**
    * Converts this tab object to a JSON-compatible object containing the values
    * of its properties which the extension is permitted to access, in the format
-   * requried to be returned by WebExtension APIs.
+   * required to be returned by WebExtension APIs.
    *
    * @param {Tab} [fallbackTab]
    *        A tab to retrieve geometry data from if the lazy geometry data for
    *        this tab hasn't been initialized yet.
    * @returns {object}
    */
   convert(fallbackTab = null) {
     let result = {
@@ -819,17 +819,17 @@ class WindowBase {
       return "popup";
     }
 
     return "normal";
   }
 
   /**
    * Converts this window object to a JSON-compatible object which may be
-   * returned to an extension, in the format requried to be returned by
+   * returned to an extension, in the format required to be returned by
    * WebExtension APIs.
    *
    * @param {object} [getInfo]
    *        An optional object, the properties of which determine what data is
    *        available on the result object.
    * @param {boolean} [getInfo.populate]
    *        Of true, the result object will contain a `tabs` property,
    *        containing an array of converted Tab objects, one for each tab in
@@ -1129,17 +1129,17 @@ Object.assign(WindowBase, {WINDOW_ID_NON
  *        The ID of the tab being removed.
  * @property {integer} windowId
  *        The ID of the window from which the tab is being removed.
  * @property {boolean} isWindowClosing
  *        True if the tab is being removed because the window is closing.
  */
 
 /**
- * An object containg basic, extension-independent information about the window
+ * An object containing basic, extension-independent information about the window
  * and tab that a XUL <browser> belongs to.
  *
  * @typedef {Object} BrowserData
  * @property {integer} tabId
  *        The numeric ID of the tab that a <browser> belongs to, or -1 if it
  *        does not belong to a tab.
  * @property {integer} windowId
  *        The numeric ID of the browser window that a <browser> belongs to, or -1
@@ -1556,17 +1556,17 @@ class WindowTrackerBase extends EventEmi
         }
       }
     } else if (topic === "domwindowopened") {
       window.addEventListener("load", this);
     }
   }
 
   /**
-   * Add an event listener to be called whenever the given DOM event is recieved
+   * Add an event listener to be called whenever the given DOM event is received
    * at the top level of any browser window.
    *
    * @param {string} type
    *        The type of event to listen for. May be any valid DOM event name, or
    *        one of the following special cases:
    *
    *        - "progress": Adds a tab progress listener to every browser window.
    *        - "status": Adds a StatusListener to every tab of every browser
@@ -1792,17 +1792,17 @@ class TabManagerBase {
    *        The wrapper for this tab.
    */
   getWrapper(nativeTab) {
     return this._tabs.get(nativeTab);
   }
 
   /**
    * Converts the given native tab to a JSON-compatible object, in the format
-   * requried to be returned by WebExtension APIs, which may be safely passed to
+   * required to be returned by WebExtension APIs, which may be safely passed to
    * extension code.
    *
    * @param {NativeTab} nativeTab
    *        The native tab to convert.
    * @param {NativeTab} [fallbackTab]
    *        A tab to retrieve geometry data from if the lazy geometry data for
    *        this tab hasn't been initialized yet.
    *
@@ -1898,17 +1898,17 @@ class WindowManagerBase {
   constructor(extension) {
     this.extension = extension;
 
     this._windows = new DefaultWeakMap(window => this.wrapWindow(window));
   }
 
   /**
    * Converts the given browser window to a JSON-compatible object, in the
-   * format requried to be returned by WebExtension APIs, which may be safely
+   * format required to be returned by WebExtension APIs, which may be safely
    * passed to extension code.
    *
    * @param {DOMWindow} window
    *        The browser window to convert.
    * @param {*} args
    *        Additional arguments to be passed to {@link WindowBase#convert}.
    *
    * @returns {Object}

--- a/toolkit/components/extensions/parent/ext-webNavigation.js
+++ b/toolkit/components/extensions/parent/ext-webNavigation.js
@@ -1,11 +1,11 @@
 "use strict";
 
-// This file expectes tabTracker to be defined in the global scope (e.g.
+// This file expects tabTracker to be defined in the global scope (e.g.
 // by ext-utils.js).
 /* global tabTracker */
 
 ChromeUtils.defineModuleGetter(this, "MatchURLFilters",
                                "resource://gre/modules/MatchURLFilters.jsm");
 ChromeUtils.defineModuleGetter(this, "WebNavigation",
                                "resource://gre/modules/WebNavigation.jsm");
 

--- a/toolkit/components/extensions/parent/ext-webRequest.js
+++ b/toolkit/components/extensions/parent/ext-webRequest.js
@@ -1,11 +1,11 @@
 "use strict";
 
-// This file expectes tabTracker to be defined in the global scope (e.g.
+// This file expects tabTracker to be defined in the global scope (e.g.
 // by ext-utils.js).
 /* global tabTracker */
 
 ChromeUtils.defineModuleGetter(this, "WebRequest",
                                "resource://gre/modules/WebRequest.jsm");
 
 // EventManager-like class specifically for WebRequest. Inherits from
 // EventManager. Takes care of converting |details| parameter

--- a/toolkit/components/extensions/test/mochitest/test_chrome_ext_webrequest_background_events.html
+++ b/toolkit/components/extensions/test/mochitest/test_chrome_ext_webrequest_background_events.html
@@ -37,17 +37,17 @@ let testExtension = {
       "onHeadersReceived",
       "onResponseStarted",
       "onCompleted",
     ];
 
     function listener(name, details) {
       // If we get anything, we failed.  Removing the system principal check
       // in ext-webrequest triggers this failure.
-      browser.test.fail(`recieved ${name}`);
+      browser.test.fail(`received ${name}`);
     }
 
     for (let name of eventNames) {
       browser.webRequest[name].addListener(
         listener.bind(null, name),
         {urls: ["https://example.com/*"]}
       );
     }

--- a/toolkit/components/extensions/test/mochitest/test_ext_webnavigation_filters.html
+++ b/toolkit/components/extensions/test/mochitest/test_ext_webnavigation_filters.html
@@ -99,23 +99,23 @@ add_task(async function test_webnav_unre
           okFilter: [{ports: [80, 22, 443]}],
           failFilter: [{ports: [81, 82, 83]}],
         },
         {
           okFilter: [{ports: [22, 443, [10, 80]]}],
           failFilter: [{ports: [22, 23, [81, 100]]}],
         },
         // multiple criteria in a single filter:
-        // if one of the critera is not verified, the event should not be received.
+        // if one of the criteria is not verified, the event should not be received.
         {
           okFilter: [{schemes: ["http"], ports: [80, 22, 443]}],
           failFilter: [{schemes: ["http"], ports: [81, 82, 83]}],
         },
         // multiple urlFilters on the same listener
-        // if at least one of the critera is verified, the event should be received.
+        // if at least one of the criteria is verified, the event should be received.
         {
           okFilter: [{schemes: ["https"]}, {ports: [80, 22, 443]}],
           failFilter: [{schemes: ["https"]}, {ports: [81, 82, 83]}],
         },
       ],
     },
     {
       url: "http://example.net/browser?param=1#ref",

--- a/toolkit/components/extensions/test/mochitest/test_ext_webrequest_background_events.html
+++ b/toolkit/components/extensions/test/mochitest/test_ext_webrequest_background_events.html
@@ -32,17 +32,17 @@ add_task(async function test_webRequest_
         "onSendHeaders",
         "onHeadersReceived",
         "onResponseStarted",
         "onCompleted",
         "onErrorOccurred",
       ]);
 
       function listener(name, details) {
-        browser.test.assertTrue(eventNames.has(name), `recieved ${name}`);
+        browser.test.assertTrue(eventNames.has(name), `received ${name}`);
         eventNames.delete(name);
         if (name == "onCompleted") {
           eventNames.delete("onErrorOccurred");
         } else if (name == "onErrorOccurred") {
           eventNames.delete("onCompleted");
         }
         if (eventNames.size == 0) {
           browser.test.sendMessage("done");
@@ -80,37 +80,37 @@ add_task(async function test_webRequest_
         "onBeforeSendHeaders",
         "onSendHeaders",
         "onHeadersReceived",
         "onResponseStarted",
         "onCompleted",
       ]);
 
       function listener(name, details) {
-        browser.test.assertTrue(eventNames.has(name), `recieved ${name}`);
+        browser.test.assertTrue(eventNames.has(name), `received ${name}`);
         eventNames.delete(name);
 
         if (eventNames.size === 0) {
           browser.test.assertEq("xmlhttprequest", details.type, "correct type for fetch [see bug 1366710]");
-          browser.test.assertEq(0, eventNames.size, "messages recieved");
+          browser.test.assertEq(0, eventNames.size, "messages received");
           browser.test.sendMessage("done");
         }
       }
 
       for (let name of eventNames) {
         browser.webRequest[name].addListener(
           listener.bind(null, name),
           {urls: ["https://example.com/*"]}
         );
       }
 
       fetch("https://example.com/example.txt").then(() => {
         browser.test.succeed("Fetch succeeded.");
       }, () => {
-        browser.test.fail("fetch recieved");
+        browser.test.fail("fetch received");
         browser.test.sendMessage("done");
       });
     },
   });
 
   await extension.startup();
   await extension.awaitMessage("done");
   await extension.unload();

--- a/toolkit/components/extensions/test/mochitest/test_ext_webrequest_frameId.html
+++ b/toolkit/components/extensions/test/mochitest/test_ext_webrequest_frameId.html
@@ -92,17 +92,17 @@ let expected = {
   },
   // Last frame tests content policy frame ancestors.
   "webRequestTest": {
     type: "sub_frame",
     depth: 3,
     origin: "file_simple_xhr_frame2.html",
     parent: "file_simple_xhr_frame2.html",
   },
-  // This is loaded in a sandbox iframe.  originUrl is not availabe for that,
+  // This is loaded in a sandbox iframe.  originUrl is not available for that,
   // and requests within a sandboxed iframe will additionally have an empty
   // url on their immediate parent/ancestor.
   "file_simple_sandboxed_frame.html": {
     type: "sub_frame",
     depth: 3,
     parent: "file_simple_xhr_frame2.html",
   },
   "xhr_sandboxed": {

--- a/toolkit/components/extensions/test/xpcshell/test_ext_dns.js
+++ b/toolkit/components/extensions/test/xpcshell/test_ext_dns.js
@@ -1,11 +1,11 @@
 "use strict";
 
-// Some test machines and android are not returing ipv6, turn it
+// Some test machines and android are not returning ipv6, turn it
 // off to get consistent test results.
 Services.prefs.setBoolPref("network.dns.disableIPv6", true);
 
 function getExtension(background = undefined) {
   let manifest = {
     "permissions": [
       "dns",
     ],

--- a/toolkit/components/extensions/test/xpcshell/test_ext_downloads_misc.js
+++ b/toolkit/components/extensions/test/xpcshell/test_ext_downloads_misc.js
@@ -763,44 +763,44 @@ add_task(async function test_erase() {
   }
 
   let ids = {};
   ids.dl1 = await download();
   ids.dl2 = await download();
   ids.dl3 = await download();
 
   let msg = await runInExtension("search", {});
-  equal(msg.status, "success", "search succeded");
+  equal(msg.status, "success", "search succeeded");
   equal(msg.result.length, 3, "search found 3 downloads");
 
   msg = await runInExtension("clearEvents");
 
   msg = await runInExtension("erase", {id: ids.dl1});
   equal(msg.status, "success", "erase by id succeeded");
 
   msg = await runInExtension("waitForEvents", [
     {type: "onErased", data: ids.dl1},
   ]);
   equal(msg.status, "success", "received onErased event");
 
   msg = await runInExtension("search", {});
-  equal(msg.status, "success", "search succeded");
+  equal(msg.status, "success", "search succeeded");
   equal(msg.result.length, 2, "search found 2 downloads");
 
   msg = await runInExtension("erase", {});
   equal(msg.status, "success", "erase everything succeeded");
 
   msg = await runInExtension("waitForEvents", [
     {type: "onErased", data: ids.dl2},
     {type: "onErased", data: ids.dl3},
   ], {inorder: false});
   equal(msg.status, "success", "received 2 onErased events");
 
   msg = await runInExtension("search", {});
-  equal(msg.status, "success", "search succeded");
+  equal(msg.status, "success", "search succeeded");
   equal(msg.result.length, 0, "search found 0 downloads");
 });
 
 function loadImage(img, data) {
   return new Promise((resolve) => {
     img.src = data;
     img.onload = resolve;
   });

--- a/toolkit/components/extensions/test/xpcshell/test_ext_downloads_search.js
+++ b/toolkit/components/extensions/test/xpcshell/test_ext_downloads_search.js
@@ -235,17 +235,17 @@ add_task(async function test_search() {
   //     so a sufficiently large number will be unused.
   const INVALID_ID = 1000;
   await checkSearch({id: INVALID_ID}, [], "invalid id");
 
   // Check that search on url works.
   await checkSearch({url: TXT_URL}, ["txt1", "txt2"], "url");
 
   // Check that regexp on url works.
-  const HTML_REGEX = "[downlad]{8}\.html+$";
+  const HTML_REGEX = "[download]{8}\.html+$";
   await checkSearch({urlRegex: HTML_REGEX}, ["html1", "html2"], "url regexp");
 
   // Check that compatible url+regexp works
   await checkSearch({url: HTML_URL, urlRegex: HTML_REGEX}, ["html1", "html2"], "compatible url+urlRegex");
 
   // Check that incompatible url+regexp works
   await checkSearch({url: TXT_URL, urlRegex: HTML_REGEX}, [], "incompatible url+urlRegex");
 
@@ -268,17 +268,17 @@ add_task(async function test_search() {
 
   // Check that positive search terms work case-insensitive.
   await checkSearch({query: ["nEwfILe"]}, ["txt2"], "term nEwfiLe");
 
   // Check that negative search terms work.
   await checkSearch({query: ["-txt"]}, ["html1", "html2"], "term -txt");
 
   // Check that positive and negative search terms together work.
-  await checkSearch({query: ["html", "-renamed"]}, ["html1"], "postive and negative terms");
+  await checkSearch({query: ["html", "-renamed"]}, ["html1"], "positive and negative terms");
 
   async function checkSearchWithDate(query, expected, description) {
     const fields = Object.keys(query);
     if (fields.length != 1 || !(query[fields[0]] instanceof Date)) {
       throw new Error("checkSearchWithDate expects exactly one Date field");
     }
     const field = fields[0];
     const date = query[field];

--- a/toolkit/components/extensions/test/xpcshell/test_ext_native_messaging_unresponsive.js
+++ b/toolkit/components/extensions/test/xpcshell/test_ext_native_messaging_unresponsive.js
@@ -73,10 +73,10 @@ add_task(async function test_unresponsiv
   let procCount = await getSubprocessCount();
   equal(procCount, 1, "subprocess is running");
 
   let exitPromise = waitForSubprocessExit();
   await extension.unload();
   await exitPromise;
 
   procCount = await getSubprocessCount();
-  equal(procCount, 0, "subprocess was succesfully killed");
+  equal(procCount, 0, "subprocess was successfully killed");
 });

--- a/toolkit/components/extensions/test/xpcshell/test_ext_permissions.js
+++ b/toolkit/components/extensions/test/xpcshell/test_ext_permissions.js
@@ -132,17 +132,17 @@ add_task(async function test_permissions
 
   // None of the optional permissions should be available yet
   for (let perm of OPTIONAL_PERMISSIONS) {
     result = await call("contains", {permissions: [perm]});
     equal(result, false, `contains() returns false for permission ${perm}`);
   }
   for (let origin of OPTIONAL_ORIGINS) {
     result = await call("contains", {origins: [origin]});
-    equal(result, false, `conains() returns false for origin ${origin}`);
+    equal(result, false, `contains() returns false for origin ${origin}`);
   }
 
   result = await call("contains", {
     permissions: [...REQUIRED_PERMISSIONS, ...OPTIONAL_PERMISSIONS],
   });
   equal(result, false, "contains() returns false for a mix of available and unavailable permissions");
 
   let perm = OPTIONAL_PERMISSIONS[0];
@@ -459,17 +459,17 @@ add_task(async function test_optional_al
   await extension.startup();
 
   await withHandlingUserInput(extension, async () => {
     extension.sendMessage("request");
     let [before, granted, after] = await extension.awaitMessage("results");
 
     equal(before, false, "captureVisibleTab() unavailable before optional permission request()");
     equal(granted, true, "request() for optional permissions granted");
-    equal(after, true, "captureVisibleTab() avaiable after optional permission request()");
+    equal(after, true, "captureVisibleTab() available after optional permission request()");
   });
 
   await extension.unload();
 });
 
 // Check that optional permissions are not included in update prompts
 add_task(async function test_permissions_prompt() {
   function background() {

--- a/toolkit/components/extensions/test/xpcshell/test_ext_webRequest_set_cookie.js
+++ b/toolkit/components/extensions/test/xpcshell/test_ext_webRequest_set_cookie.js
@@ -121,17 +121,17 @@ add_task(async function test_modifying_c
     };
     browser.webRequest.onHeadersReceived.addListener(onHeadersReceived, filter, headersReceivedInfoSpec);
 
     // First, perform a request that should not set any cookies, and check
     // that the cookie the extension sets is the only cookie in the
     // cookie jar.
     await testCookiesWithFile("data/file_sample.html", ["ext"]);
 
-    // Next, preform a request that will set on cookie (reqcookie=reqvalue)
+    // Next, perform a request that will set on cookie (reqcookie=reqvalue)
     // and check that two cookies wind up in the cookie jar (the request
     // set cookie, and the extension set cookie).
     await testCookiesWithFile("file_webrequestblocking_set_cookie.html", ["ext", "req"]);
 
     // Third, register another onHeadersReceived handler that also
     // sets a cookie (thirdcookie=thirdvalue), to make sure modifications from
     // multiple onHeadersReceived listeners are merged correctly.
     const thirdOnHeadersRecievedListener = details => {

--- a/toolkit/mozapps/extensions/AddonManager.jsm
+++ b/toolkit/mozapps/extensions/AddonManager.jsm
@@ -485,17 +485,17 @@ AddonScreenshot.prototype = {
   }
 };
 
 
 /**
  * This represents a compatibility override for an addon.
  *
  * @param  aType
- *         Overrride type - "compatible" or "incompatible"
+ *         Override type - "compatible" or "incompatible"
  * @param  aMinVersion
  *         Minimum version of the addon to match
  * @param  aMaxVersion
  *         Maximum version of the addon to match
  * @param  aAppID
  *         Application ID used to match appMinVersion and appMaxVersion
  * @param  aAppMinVersion
  *         Minimum version of the application to match
@@ -726,17 +726,17 @@ var AddonManagerInternal = {
 
     logger.debug(`Starting provider: ${providerName(aProvider)}`);
     callProvider(aProvider, "startup", null, aAppChanged, aOldAppVersion, aOldPlatformVersion);
     if ("shutdown" in aProvider) {
       let name = providerName(aProvider);
       let AMProviderShutdown = () => {
         // If the provider has been unregistered, it will have been removed from
         // this.providers. If it hasn't been unregistered, then this is a normal
-        // shutdown - and we move it to this.pendingProviders incase we're
+        // shutdown - and we move it to this.pendingProviders in case we're
         // running in a test that will start AddonManager again.
         if (this.providers.has(aProvider)) {
           this.providers.delete(aProvider);
           this.pendingProviders.add(aProvider);
         }
 
         return new Promise((resolve, reject) => {
             logger.debug("Calling shutdown blocker for " + name);
@@ -3186,17 +3186,17 @@ var AddonManager = {
   // These will show up as AddonManager.ERROR_* (eg, ERROR_NETWORK_FAILURE)
   _errors: new Map([
     // The download failed due to network problems.
     ["ERROR_NETWORK_FAILURE", -1],
     // The downloaded file did not match the provided hash.
     ["ERROR_INCORRECT_HASH", -2],
     // The downloaded file seems to be corrupted in some way.
     ["ERROR_CORRUPT_FILE", -3],
-    // An error occured trying to write to the filesystem.
+    // An error occurred trying to write to the filesystem.
     ["ERROR_FILE_ACCESS", -4],
     // The add-on must be signed and isn't.
     ["ERROR_SIGNEDSTATE_REQUIRED", -5],
     // The downloaded add-on had a different type than expected.
     ["ERROR_UNEXPECTED_ADDON_TYPE", -6],
     // The addon did not have the expected ID
     ["ERROR_INCORRECT_ID", -7],
   ]),

--- a/toolkit/mozapps/extensions/internal/AddonTestUtils.jsm
+++ b/toolkit/mozapps/extensions/internal/AddonTestUtils.jsm
@@ -99,17 +99,17 @@ var MockAsyncShutdown = {
   // We can use the real Barrier
   Barrier: AsyncShutdown.Barrier,
 };
 
 AMscope.AsyncShutdown = MockAsyncShutdown;
 
 
 /**
- * Escapes any occurances of &, ", < or > with XML entities.
+ * Escapes any occurrences of &, ", < or > with XML entities.
  *
  * @param {string} str
  *        The string to escape.
  * @return {string} The escaped string.
  */
 function escapeXML(str) {
   let replacements = {"&": "&amp;", '"': "&quot;", "'": "&apos;", "<": "&lt;", ">": "&gt;"};
   return String(str).replace(/[&"''<>]/g, m => replacements[m]);
@@ -853,17 +853,17 @@ var AddonTestUtils = {
     for (let dep of data.dependencies || [])
       rdf += escaped`<em:dependency><Description em:id="${dep}"/></em:dependency>\n`;
 
     rdf += "</Description>\n</RDF>\n";
     return rdf;
   },
 
   /**
-   * Recursively create all directories upto and including the given
+   * Recursively create all directories up to and including the given
    * path, if they do not exist.
    *
    * @param {string} path The path of the directory to create.
    * @returns {Promise} Resolves when all directories have been created.
    */
   recursiveMakeDir(path) {
     let paths = [];
     for (let lastPath; path != lastPath; lastPath = path, path = OS.Path.dirname(path))

--- a/toolkit/mozapps/extensions/internal/AddonUpdateChecker.jsm
+++ b/toolkit/mozapps/extensions/internal/AddonUpdateChecker.jsm
@@ -360,17 +360,17 @@ UpdateParser.prototype = {
 
     this.request = null;
     this._doneAt = new Error("UP_onError");
 
     this.notifyError(AddonManager.ERROR_DOWNLOAD_ERROR);
   },
 
   /**
-   * Helper method to notify the observer that an error occured.
+   * Helper method to notify the observer that an error occurred.
    */
   notifyError(aStatus) {
     if ("onUpdateCheckError" in this.observer) {
       try {
         this.observer.onUpdateCheckError(aStatus);
       } catch (e) {
         logger.warn("onUpdateCheckError notification failed", e);
       }

--- a/toolkit/mozapps/extensions/internal/XPIInstall.jsm
+++ b/toolkit/mozapps/extensions/internal/XPIInstall.jsm
@@ -186,17 +186,17 @@ var logger = Log.repository.getLogger(LO
 
 
 /**
  * Sets permissions on a file
  *
  * @param  aFile
  *         The file or directory to operate on.
  * @param  aPermissions
- *         The permisions to set
+ *         The permissions to set
  */
 function setFilePermissions(aFile, aPermissions) {
   try {
     aFile.permissions = aPermissions;
   } catch (e) {
     logger.warn("Failed to set permissions " + aPermissions.toString(8) + " on " +
          aFile.path, e);
   }
@@ -1530,17 +1530,17 @@ class AddonInstall {
         zipreader.close();
         return Promise.reject([AddonManager.ERROR_INCORRECT_ID,
                                `Refusing to upgrade addon ${this.existingAddon.id} to different ID ${this.addon.id}`]);
       }
 
       if (isWebExtension(this.existingAddon.type) && !isWebExtension(this.addon.type)) {
         zipreader.close();
         return Promise.reject([AddonManager.ERROR_UNEXPECTED_ADDON_TYPE,
-                               "WebExtensions may not be upated to other extension types"]);
+                               "WebExtensions may not be updated to other extension types"]);
       }
     }
 
     if (mustSign(this.addon.type)) {
       if (this.addon.signedState <= AddonManager.SIGNEDSTATE_MISSING) {
         // This add-on isn't properly signed by a signature that chains to the
         // trusted root.
         let state = this.addon.signedState;
@@ -2012,17 +2012,17 @@ var LocalAddonInstall = class extends Ad
   }
 
   install() {
     if (this.state == AddonManager.STATE_DOWNLOAD_FAILED) {
       // For a local install, this state means that verification of the
       // file failed (e.g., the hash or signature or manifest contents
       // were invalid).  It doesn't make sense to retry anything in this
       // case but we have callers who don't know if their AddonInstall
-      // object is a local file or a download so accomodate them here.
+      // object is a local file or a download so accommodate them here.
       AddonManagerPrivate.callInstallListeners("onDownloadFailed",
                                                this.listeners, this.wrapper);
       return;
     }
     super.install();
   }
 };
 

--- a/toolkit/mozapps/extensions/internal/XPIProvider.jsm
+++ b/toolkit/mozapps/extensions/internal/XPIProvider.jsm
@@ -496,17 +496,17 @@ function isTheme(type) {
 }
 
 /**
  * Sets permissions on a file
  *
  * @param  aFile
  *         The file or directory to operate on.
  * @param  aPermissions
- *         The permisions to set
+ *         The permissions to set
  */
 function setFilePermissions(aFile, aPermissions) {
   try {
     aFile.permissions = aPermissions;
   } catch (e) {
     logger.warn("Failed to set permissions " + aPermissions.toString(8) + " on " +
          aFile.path, e);
   }
@@ -5775,17 +5775,17 @@ class MutableDirectoryInstallLocation ex
         logger.warn("Failed to remove trash directory when installing " + id, e);
       }
     }
 
     let newFile = this._directory.clone();
 
     if (action == "proxy") {
       // When permanently installing sideloaded addon, we just put a proxy file
-      // refering to the addon sources
+      // referring to the addon sources
       newFile.append(id);
 
       writeStringToFile(newFile, source.path);
     } else {
       newFile.append(source.leafName);
     }
 
     try {

--- a/toolkit/mozapps/extensions/internal/XPIProviderUtils.js
+++ b/toolkit/mozapps/extensions/internal/XPIProviderUtils.js
@@ -345,19 +345,19 @@ this.XPIDatabase = {
   /**
    * Synchronously opens and reads the database file, upgrading from old
    * databases or making a new DB if needed.
    *
    * The possibilities, in order of priority, are:
    * 1) Perfectly good, up to date database
    * 2) Out of date JSON database needs to be upgraded => upgrade
    * 3) JSON database exists but is mangled somehow => build new JSON
-   * 4) no JSON DB, but a useable SQLITE db we can upgrade from => upgrade
+   * 4) no JSON DB, but a usable SQLITE db we can upgrade from => upgrade
    * 5) useless SQLITE DB => build new JSON
-   * 6) useable RDF DB => upgrade
+   * 6) usable RDF DB => upgrade
    * 7) useless RDF DB => build new JSON
    * 8) Nothing at all => build new JSON
    * @param  aRebuildOnError
    *         A boolean indicating whether add-on information should be loaded
    *         from the install locations if the database needs to be rebuilt.
    *         (if false, caller is XPIProvider.checkForChanges() which will rebuild)
    */
   syncLoadDB(aRebuildOnError) {
@@ -1520,17 +1520,17 @@ this.XPIDatabaseReconcile = {
       // Hide the system add-on updates if any are invalid.
       logger.info("One or more updated system add-ons invalid, falling back to defaults.");
       hideLocation = KEY_APP_SYSTEM_ADDONS;
     }
 
     let previousVisible = this.getVisibleAddons(previousAddons);
     let currentVisible = this.flattenByID(currentAddons, hideLocation);
 
-    // Pass over the new set of visible add-ons, record any changes that occured
+    // Pass over the new set of visible add-ons, record any changes that occurred
     // during startup and call bootstrap install/uninstall scripts as necessary
     for (let [id, currentAddon] of currentVisible) {
       let previousAddon = previousVisible.get(id);
 
       // Note if any visible add-on is not in the application install location
       if (currentAddon._installLocation.name != KEY_APP_GLOBAL)
         XPIProvider.allAppGlobal = false;
 

--- a/toolkit/mozapps/extensions/test/xpcshell/test_bug393285.js
+++ b/toolkit/mozapps/extensions/test/xpcshell/test_bug393285.js
@@ -305,17 +305,17 @@ function run_test_1() {
 
       // Not blocklisted because we are a different ABI
       Assert.ok(!Services.blocklist.isAddonBlocklisted(a9, "2", "1.9"));
 
       // Blocklisted based on ABI
       Assert.ok(Services.blocklist.isAddonBlocklisted(a10, "2", "1.9"));
       Assert.ok(Services.blocklist.isAddonBlocklisted(a11, "2", "1.9"));
 
-      // Doesnt match both os and abi so not blocked
+      // Doesn't match both os and abi so not blocked
       Assert.ok(!Services.blocklist.isAddonBlocklisted(a12, "2", "1.9"));
       Assert.ok(!Services.blocklist.isAddonBlocklisted(a13, "2", "1.9"));
       Assert.ok(!Services.blocklist.isAddonBlocklisted(a14, "2", "1.9"));
 
       // Matches both os and abi so blocked
       Assert.ok(Services.blocklist.isAddonBlocklisted(a15, "2", "1.9"));
       end_test();
     });

--- a/toolkit/mozapps/extensions/test/xpcshell/test_bug570173.js
+++ b/toolkit/mozapps/extensions/test/xpcshell/test_bug570173.js
@@ -1,13 +1,13 @@
 /* Any copyright is dedicated to the Public Domain.
  * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
-// This verifies that add-on update check failures are propogated correctly
+// This verifies that add-on update check failures are propagated correctly
 
 // The test extension uses an insecure update url.
 Services.prefs.setBoolPref("extensions.checkUpdateSecurity", false);
 
 var testserver;
 const profileDir = gProfD.clone();
 profileDir.append("extensions");
 

--- a/toolkit/mozapps/extensions/test/xpcshell/test_gfxBlacklist_prefs.js
+++ b/toolkit/mozapps/extensions/test/xpcshell/test_gfxBlacklist_prefs.js
@@ -1,13 +1,13 @@
 /* Any copyright is dedicated to the Public Domain.
  * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
-// Test whether the blacklist succesfully adds and removes the prefs that store
+// Test whether the blacklist successfully adds and removes the prefs that store
 // its decisions when the remote blacklist is changed.
 // Uses test_gfxBlacklist.xml and test_gfxBlacklist2.xml
 
 var gTestserver = AddonTestUtils.createHttpServer({hosts: ["example.com"]});
 gPort = gTestserver.identity.primaryPort;
 gTestserver.registerDirectory("/data/", do_get_file("data"));
 
 function load_blocklist(file) {

--- a/toolkit/mozapps/extensions/test/xpcshell/test_json_updatecheck.js
+++ b/toolkit/mozapps/extensions/test/xpcshell/test_json_updatecheck.js
@@ -266,17 +266,17 @@ add_task(async function test_update_url_
     });
   });
 
   equal(updates.length, 2, "both updates were processed");
   equal(updates[0].updateURL, null, "privileged update URL was removed");
   equal(updates[1].updateURL, "http://example.com/update.xpi", "safe update URL was accepted");
 
   messages = messages.filter(msg => /http:\/\/localhost.*\/updates\/.*may not load or link to chrome:/.test(msg.message));
-  equal(messages.length, 1, "privileged upate URL generated the expected console message");
+  equal(messages.length, 1, "privileged update URL generated the expected console message");
 });
 
 
 add_task(async function test_type_detection() {
   // Checks that JSON update manifests are detected correctly
   // regardless of extension or MIME type.
 
   let tests = [

--- a/toolkit/mozapps/extensions/test/xpcshell/test_legacy.js
+++ b/toolkit/mozapps/extensions/test/xpcshell/test_legacy.js
@@ -76,17 +76,17 @@ add_task(async function test_disable() {
 
   // And installing legacy extensions should fail
   let legacyXPIs = legacy.map(makeXPI);
   installs = await Promise.all(legacyXPIs.map(xpi => AddonManager.getInstallForFile(xpi)));
 
   // Yuck, the AddonInstall API is atrocious.  Installs of incompatible
   // extensions are detected when the install reaches the DOWNLOADED state
   // and the install is abandoned at that point.  Since this is a local file
-  // install we just start out in the DONWLOADED state.
+  // install we just start out in the DOWNLOADED state.
   for (let install of installs) {
     Assert.equal(install.state, AddonManager.STATE_DOWNLOADED);
     Assert.equal(install.addon.appDisabled, true);
   }
 
   // Now enable legacy extensions, and we should be able to install
   // the legacy extensions.
   Services.prefs.setBoolPref(LEGACY_PREF, true);

--- a/toolkit/mozapps/extensions/test/xpcshell/test_overrideblocklist.js
+++ b/toolkit/mozapps/extensions/test/xpcshell/test_overrideblocklist.js
@@ -79,17 +79,17 @@ function run_test() {
       clearBlocklists();
       appBlocklist.moveTo(gAppDir, FILE_BLOCKLIST);
     });
   }
 
   run_next_test();
 }
 
-// On first run whataver is in the app dir should get copied to the profile
+// On first run whatever is in the app dir should get copied to the profile
 add_test(function test_copy() {
   clearBlocklists();
   copyToApp(OLD);
 
   incrementAppVersion();
   startupManager();
 
   reloadBlocklist();

--- a/toolkit/mozapps/extensions/test/xpcshell/test_permissions_prefs.js
+++ b/toolkit/mozapps/extensions/test/xpcshell/test_permissions_prefs.js
@@ -45,17 +45,17 @@ function run_test() {
   startupManager();
 
   // Permissions are imported lazily - act as thought we're checking an install,
   // to trigger on-deman importing of the permissions.
   AddonManager.isInstallAllowed("application/x-xpinstall", newPrincipal("http://example.com/file.xpi"));
   do_check_permission_prefs(preferences);
 
 
-  // Import can also be triggerred by an observer notification by any other area
+  // Import can also be triggered by an observer notification by any other area
   // of code, such as a permissions management UI.
 
   // First, request to flush all permissions
   clear_imported_preferences_cache();
   Services.prefs.setCharPref("xpinstall.whitelist.add.TEST2", "https://whitelist2.example.com");
   Services.obs.notifyObservers(null, "flush-pending-permissions", "install");
   do_check_permission_prefs(preferences);
 

--- a/toolkit/mozapps/extensions/test/xpcshell/test_strictcompatibility.js
+++ b/toolkit/mozapps/extensions/test/xpcshell/test_strictcompatibility.js
@@ -101,17 +101,17 @@ const ADDONS = {
       }]
     },
     expected: {
       strictCompatibility: false,
     },
     compatible: [false, false, false, false],
   },
 
-  // Extremely old addon - maxVersion is less than the mimimum compat version
+  // Extremely old addon - maxVersion is less than the minimum compat version
   // set in extensions.minCompatibleVersion
   "addon6@tests.mozilla.org": {
     "install.rdf": {
       id: "addon6@tests.mozilla.org",
       version: "1.0",
       name: "Test 6",
       bootstrap: true,
       targetApplications: [{

--- a/toolkit/mozapps/extensions/test/xpcshell/test_webextension_paths.js
+++ b/toolkit/mozapps/extensions/test/xpcshell/test_webextension_paths.js
@@ -4,17 +4,17 @@ add_task(async function setup() {
   profileDir = gProfD.clone();
   profileDir.append("extensions");
 
   createAppInfo("xpcshell@tests.mozilla.org", "XPCShell", "1", "1.9.2");
   startupManager();
 });
 
 // When installing an unpacked addon we derive the ID from the
-// directory name.  Make sure that if the directoy name is not a valid
+// directory name.  Make sure that if the directory name is not a valid
 // addon ID that we reject it.
 add_task(async function test_bad_unpacked_path() {
   let MANIFEST_ID = "webext_bad_path@tests.mozilla.org";
 
   let manifest = {
     name: "path test",
     description: "test of a bad directory name",
     manifest_version: 2,