+

+    if (!info.mMustRevalidate) {

+      nsAutoCString vary;

+      (void)httpChannel->GetResponseHeader("vary"_ns, vary);

+      info.mMustRevalidate = [&] {

+        for (const nsACString& token :

+             nsCCharSeparatedTokenizer(vary, ',').ToRange()) {

+          if (token.EqualsLiteral("*")) {

+            return true;

+          }

+          if (token.EqualsIgnoreCase("cookie")) {

+            return true;

+          }

+        }

+        return false;

+      }();

+    }

+const int64_t kRoundUpNumber = 131072;

+  const size_t availElemCount = lengthInType / channels;

+  if (availElemCount > 1 && !validationInfo.isArray) {

+  const size_t elemCount =

+      validationInfo.isArray

+          ? std::min(availElemCount, size_t(activeInfo.elemCount))

+          : availElemCount;

+      if (mPromise) {

+        mPromise->MaybeResolveWithUndefined();

+        mPromise = nullptr;

+      }

+    RefPtr<Runnable> runnable(resolver);

+    eventTarget->Dispatch(runnable.forget());

+const uint32_t kMaxRandomNumber = 1048576;

+  auto endSubmit = MakeScopeExit([&] { EndSubmitClick(aVisitor); });

+  if (doc->GetSandboxFlags() & SANDBOXED_FORMS) {

+    return NS_OK;

+  }

+

+  nsIGlobalObject* currentGlobal = xpc::CurrentNativeGlobal(cx);

+  if (currentGlobal->IsSharedMemoryAllowed()) {

+    cloneDataPolicy.allowSharedMemoryObjects();

+  }

+

+pixman-edge-saturate.patch: Saturate when rounding up trapezoid edges

+    unsigned long max_records;

+    /* records[] starts after the 6-byte tt_name_t header (format,

+     * num_records, strings_offset); only records lying entirely within the

+     * size-byte table may be read. */

+    if (size < offsetof (tt_name_t, records)) {

+	*str_out = NULL;

+	return CAIRO_STATUS_SUCCESS;

+    }

+    max_records = (size - offsetof (tt_name_t, records)) / sizeof(name->records[0]);

+    for (i = 0; i < MIN(be16_to_cpu (name->num_records), max_records); i++) {

+	 * Use 64 bits to get a saturating add, in case lx or rx are near

+	 * the limits of pixman_fixed_t.

+	 *

+	lx = (pixman_fixed_t) MIN ((int64_t) lx + (X_FRAC_FIRST(1) - pixman_fixed_e), INT32_MAX);

+	rx = (pixman_fixed_t) MIN ((int64_t) rx + (X_FRAC_FIRST(1) - pixman_fixed_e), INT32_MAX);

+diff --git a/gfx/cairo/cairo/src/cairo-truetype-subset.c b/gfx/cairo/cairo/src/cairo-truetype-subset.c

+--- a/gfx/cairo/cairo/src/cairo-truetype-subset.c

++++ b/gfx/cairo/cairo/src/cairo-truetype-subset.c

+@@ -1446,23 +1446,32 @@ cleanup:

+  */

+ #define MAX_FONT_NAME_LENGTH 127

+ 

+ static cairo_status_t

+ find_name (tt_name_t *name, unsigned long size, int name_id, int platform, int encoding, int language, char **str_out)

+ {

+     tt_name_record_t *record;

+     unsigned int i, len;

++    unsigned long max_records;

+     char *str;

+     char *p;

+     cairo_bool_t has_tag;

+     cairo_status_t status;

+ 

+     str = NULL;

+-    for (i = 0; i < MIN(be16_to_cpu (name->num_records), size / sizeof(name->records[0])); i++) {

++    /* records[] starts after the 6-byte tt_name_t header (format,

++     * num_records, strings_offset); only records lying entirely within the

++     * size-byte table may be read. */

++    if (size < offsetof (tt_name_t, records)) {

++	*str_out = NULL;

++	return CAIRO_STATUS_SUCCESS;

++    }

++    max_records = (size - offsetof (tt_name_t, records)) / sizeof(name->records[0]);

++    for (i = 0; i < MIN(be16_to_cpu (name->num_records), max_records); i++) {

+         record = &(name->records[i]);

+ 	if (be16_to_cpu (record->name) == name_id &&

+ 	    be16_to_cpu (record->platform) == platform &&

+             be16_to_cpu (record->encoding) == encoding &&

+ 	    (language == -1 || be16_to_cpu (record->language) == language)) {

+ 

+ 	    len = be16_to_cpu (record->length);

+ 	    if (platform == 3 && len > MAX_FONT_NAME_LENGTH*2) /* UTF-16 name */

+From: Jim Blandy <jimb@mozilla.com>

+Subject: Saturate when rounding up trapezoid edges

+

+diff --git a/gfx/cairo/libpixman/src/pixman-edge-imp.h b/gfx/cairo/libpixman/src/pixman-edge-imp.h

+index a4698eddb281..39e8d71d2568 100644

+--- a/gfx/cairo/libpixman/src/pixman-edge-imp.h

++++ b/gfx/cairo/libpixman/src/pixman-edge-imp.h

+@@ -53,10 +53,13 @@ RASTERIZE_EDGES (pixman_image_t  *image,

+ 	 * when the sample point lies exactly on the line, we round towards

+ 	 * north-west.

+ 	 *

++	 * Use 64 bits to get a saturating add, in case lx or rx are near

++	 * the limits of pixman_fixed_t.

++	 *

+ 	 * (The AA case does a similar  adjustment in RENDER_SAMPLES_X)

+ 	 */

+-	lx += X_FRAC_FIRST(1) - pixman_fixed_e;

+-	rx += X_FRAC_FIRST(1) - pixman_fixed_e;

++	lx = (pixman_fixed_t) MIN ((int64_t) lx + (X_FRAC_FIRST(1) - pixman_fixed_e), INT32_MAX);

++	rx = (pixman_fixed_t) MIN ((int64_t) rx + (X_FRAC_FIRST(1) - pixman_fixed_e), INT32_MAX);

+ #endif

+ 	/* clip X */

+ 	if (lx < 0)

+import mozilla.components.support.utils.OnEnterAnimationCompleteListener

+internal open class SitePermissionsDialogFragment :

+    NoObscuredTouchesDialogFragment(),

+    OnEnterAnimationCompleteListener {

+    override fun onEnterAnimationComplete() {

+        // Extend the positive button click delay.

+        promptAbuserDetector.updateJSDialogAbusedState()

+    }

+

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

+

+package mozilla.components.support.utils

+

+/**

+ * Allows forwarding [android.app.Activity.onEnterAnimationComplete] to other classes

+ * (e.g. fragments) that want to participate in handling it.

+ */

+interface OnEnterAnimationCompleteListener {

+    /**

+     * Called when the Activity's entering animation has completed.

+     */

+    fun onEnterAnimationComplete()

+}

+import mozilla.components.support.utils.OnEnterAnimationCompleteListener

+

+        val fragments = supportFragmentManager.fragments.toMutableList()

+        while (fragments.isNotEmpty()) {

+            val fragment = fragments.removeAt(0)

+            if (fragment is OnEnterAnimationCompleteListener) {

+                fragment.onEnterAnimationComplete()

+            }

+            fragments.addAll(fragment.childFragmentManager.fragments)

+        }

+diff --git a/expat/expat/lib/xmltok.c b/expat/expat/lib/xmltok.c

+--- a/expat/expat/lib/xmltok.c

++++ b/expat/expat/lib/xmltok.c

+@@ -707,7 +707,9 @@ unicode_byte_type(char hi, char lo) {

+     fromLim = *fromP + (((fromLim - *fromP) >> 1) << 1); /* shrink to even */  \

+     /* Avoid copying first half only of surrogate */                           \

+     if (fromLim - *fromP > ((toLim - *toP) << 1)                               \

+-        && (GET_HI(fromLim - 2) & 0xF8) == 0xD8) {                             \

++/* BEGIN MOZILLA CHANGE (Only high surrogate mask) */                          \

++        && (GET_HI(fromLim - 2) & 0xFC) == 0xD8) {                             \

++/* END MOZILLA CHANGE */                                                       \

+       fromLim -= 2;                                                            \

+       res = XML_CONVERT_INPUT_INCOMPLETE;                                      \

+     }                                                                          \

+/* BEGIN MOZILLA CHANGE (Only high surrogate mask) */                          \

+        && (GET_HI(fromLim - 2) & 0xFC) == 0xD8) {                             \

+/* END MOZILLA CHANGE */                                                       \

+    - 13_high_surrogate_mask.patch

+      if (!iframeBC || iframeBC.parent != browsingContext) {

+        continue;

+      }

+

+    let pkg = Package.get(aBundle);

+    try {

+      let { signedState, signedTypes } = await pkg.verifySignedState(

+        aAddon.id,

+        aAddon.type,

+        aAddon.location

+      );

+      return { signedState, signedTypes };

+    } finally {

+      pkg.close();

+    }

+  } catch (e) {

+    logger.warn(`verifyBundleSignedState failed for ${aAddon.id}`, e);

+    if (!shouldVerifySignedState(aAddon.type, aAddon.location)) {

+      return { signedState: AddonManager.SIGNEDSTATE_NOT_REQUIRED };

+    }

+    return { signedState: AddonManager.SIGNEDSTATE_BROKEN };

+async function writeCorruptedXPIFile(extensionId) {

+  let file = AddonTestUtils.getFileForAddon(profileDir, extensionId);

+  // Clear any handles to the file before replacing it; Windows is very picky.

+  Services.obs.notifyObservers(file, "flush-cache-entry");

+  await IOUtils.writeUTF8(file.path, "not a XPI file anymore");

+}

+

+

+add_task(

+  {

+    ...useAMOStageCert(),

+    // This test verifies a behavior that is only hit on builds where the

+    // enterprise policies are enabled (and skipped in build where enterprise

+    // policies are disabled, like in mobile builds).

+    skip_if: () => !Services.policies,

+  },

+  async function test_adminInstallOnly_on_verify_with_invalid_manifest() {

+    const { sinon } = ChromeUtils.importESModule(

+      "resource://testing-common/Sinon.sys.mjs"

+    );

+    const sandbox = sinon.createSandbox();

+

+    const { addon: addon1 } = await promiseInstallFile(

+      do_get_file(`${DATA}/signed1.xpi`)

+    );

+    const { addon: addon2 } = await promiseInstallFile(

+      do_get_file(`${DATA}/long.xpi`)

+    );

+

+    const { XPIExports } = ChromeUtils.importESModule(

+      "resource://gre/modules/addons/XPIExports.sys.mjs"

+    );

+    sinon

+      .stub(XPIExports.XPIInstall, "loadManifestFromFile")

+      .callsFake((_sourceBundle, _location) => {

+        throw new Error("FAKE invalid manifest error");

+      });

+

+    const { messages } = await AddonTestUtils.promiseConsoleOutput(async () => {

+      await verifySignatures();

+    });

+    sandbox.restore();

+

+    // Expect a logged warning for each of the two extensions.

+    AddonTestUtils.checkMessages(messages, {

+      expected: [

+        {

+          message:

+            /XPI_verifySignature Warning on 'test@somewhere.com': Error: FAKE invalid manifest error/,

+        },

+        {

+          message:

+            /XPI_verifySignature Warning on '123456789.*@somewhere.com': Error: FAKE invalid manifest error/,

+        },

+      ],

+    });

+

+    await addon1.uninstall();

+    await addon2.uninstall();

+  }

+);

+

+add_task(useAMOStageCert(), async function test_broken_file() {

+  await promiseInstallFile(do_get_file(`${DATA}/signed1.xpi`));

+

+  let addon = await promiseAddonByID(ID);

+  Assert.notEqual(addon, null);

+  Assert.equal(addon.appDisabled, false);

+  Assert.equal(addon.isActive, true);

+  Assert.equal(addon.signedState, AddonManager.SIGNEDSTATE_SIGNED);

+

+  await writeCorruptedXPIFile(ID);

+

+  let changedProperties = [];

+  let listener = {

+    onPropertyChanged(addon, properties) {

+      changedProperties.push(...properties);

+    },

+  };

+

+  AddonManager.addAddonListener(listener);

+

+  const disablePromise = promiseAddonEvent("onDisabling");

+  let changes;

+  const { messages } = await AddonTestUtils.promiseConsoleOutput(async () => {

+    changes = await verifySignatures();

+  });

+  await disablePromise;

+

+  Assert.equal(changes.enabled.length, 0);

+  Assert.equal(changes.disabled.length, 1);

+  Assert.equal(changes.disabled[0], ID);

+

+  Assert.deepEqual(

+    changedProperties,

+    ["signedState", "signedTypes", "appDisabled"],

+    "Got onPropertyChanged events for signedState and appDisabled"

+  );

+

+  Assert.ok(addon.appDisabled);

+  Assert.ok(!addon.isActive);

+  Assert.equal(addon.signedState, AddonManager.SIGNEDSTATE_BROKEN);

+

+  await addon.uninstall();

+  AddonManager.removeAddonListener(listener);

+

+  AddonTestUtils.checkMessages(messages, {

+    expected: [

+      { message: /verifyBundleSignedState failed for test@somewhere.com/ },

+    ],

+  });

+});

+

+// Verify that verifySignatures() does not change signedState for addons that

+// do not require signatures, even if the underlying file got corrupted.

+add_task(

+  {

+    ...useAMOStageCert(),

+    // # Non-extension add-ons are not supported on Android.

+    skip_if: () => AppConstants.platform == "android",

+  },

+  async function test_broken_file_not_requiring_signatures() {

+    // Note: If dictionaries ever require signatures (bug 1753276), change this

+    // test to another test case where shouldVerifySignedState returns false.

+    let addon = await promiseInstallWebExtension({

+      useAddonManager: true,

+      manifest: {

+        browser_specific_settings: { gecko: { id: "broken@dict" } },

+        dictionaries: { "en-US": "en-US.dic" },

+      },

+      files: { "en-US.dic": "", "en-US.aff": "" },

+    });

+    Assert.equal(addon.signedState, AddonManager.SIGNEDSTATE_NOT_REQUIRED);

+

+    await writeCorruptedXPIFile(addon.id);

+

+    let listener = {

+      onPropertyChanged(_addon) {

+        Assert.ok(false, `Got unexpected onPropertyChanged for ${_addon.id}`);

+      },

+    };

+

+    AddonManager.addAddonListener(listener);

+

+    let changes;

+    const { messages } = await AddonTestUtils.promiseConsoleOutput(async () => {

+      changes = await verifySignatures();

+    });

+    Assert.equal(changes.enabled.length, 0);

+    Assert.equal(changes.disabled.length, 0);

+

+    Assert.equal(addon.appDisabled, false);

+    Assert.equal(addon.isActive, true);

+    Assert.equal(addon.signedState, AddonManager.SIGNEDSTATE_NOT_REQUIRED);

+

+    await addon.uninstall();

+    AddonManager.removeAddonListener(listener);

+

+    AddonTestUtils.checkMessages(messages, {

+      expected: [{ message: /verifyBundleSignedState failed for broken@dict/ }],

+    });

+  }

+);