Make the persistent-storage request observable and warn when it is denied (#33987)

* Make the persistent-storage request observable and warn when it is denied

The end-to-end encryption crypto store lives in IndexedDB. If the origin's storage is not
durable, Chromium can evict it under storage pressure, forcing a logout and recovery-key
re-entry. tryPersistStorage() requested navigator.storage.persist() but only logged the
boolean result, so a denial was invisible.

Make the request observable: it is now async and checks persisted() first (short-circuiting
to avoid re-requesting/re-prompting), a failure to query the state no longer blocks the
request, and a denial warns via the logger (captured by rageshakes) with a stronger
desktop-specific message. It never rejects - the sole caller treats it as fire-and-forget.

This makes the risk observable but cannot by itself guarantee durability: no Electron
main-process API can force per-origin persistence, so a complete cure needs a follow-up.

* Address review: log query errors, drop the requestStorageAccess fallback and the desktop-specific warning

- Include the caught error when the persisted-state query fails.
- Remove the document.requestStorageAccess branch: it is the Storage Access
  API (cross-site cookie/storage access), not durability, and all supported
  browsers (Safari >= 15.2 included) have navigator.storage.persist().
- Drop the desktop-specific suffix from the denial warning.
- Reword the fire-and-forget doc to avoid referencing the caller.
- Simplify the test harness: no descriptor save/restore, delete the stub in
  afterEach.

apps/web/test/unit-tests/utils/StorageManager-test.ts

@@ -10,6 +10,7 @@ import "fake-indexeddb/auto";
 
 import { IDBFactory } from "fake-indexeddb";
 import { IndexedDBCryptoStore } from "matrix-js-sdk/src/matrix";
+import { logger } from "matrix-js-sdk/src/logger";
 
 import * as StorageManager from "../../../src/utils/StorageManager";
 
@@ -119,4 +120,92 @@ describe("StorageManager", () => {
             });
         });
     });
+
+    describe("tryPersistStorage", () => {
+        // jsdom does not implement navigator.storage, so stub it per-test; jest.replaceProperty
+        // cannot be used as it refuses to replace a property that does not exist.
+        function setStorage(value: unknown): void {
+            Object.defineProperty(navigator, "storage", { value, configurable: true });
+        }
+
+        beforeEach(() => {
+            jest.spyOn(logger, "log").mockImplementation(() => {});
+            jest.spyOn(logger, "warn").mockImplementation(() => {});
+            jest.spyOn(logger, "error").mockImplementation(() => {});
+        });
+
+        afterEach(() => {
+            delete (navigator as unknown as { storage?: unknown }).storage;
+            jest.restoreAllMocks();
+        });
+
+        it("returns true and does not re-request when storage is already persisted", async () => {
+            const persist = jest.fn().mockResolvedValue(true);
+            const persisted = jest.fn().mockResolvedValue(true);
+            setStorage({ persist, persisted });
+
+            await expect(StorageManager.tryPersistStorage()).resolves.toBe(true);
+            expect(persisted).toHaveBeenCalled();
+            expect(persist).not.toHaveBeenCalled();
+            expect(logger.warn).not.toHaveBeenCalled();
+        });
+
+        it("requests persistence and returns true when granted", async () => {
+            const persist = jest.fn().mockResolvedValue(true);
+            const persisted = jest.fn().mockResolvedValue(false);
+            setStorage({ persist, persisted });
+
+            await expect(StorageManager.tryPersistStorage()).resolves.toBe(true);
+            expect(persist).toHaveBeenCalled();
+            expect(logger.warn).not.toHaveBeenCalled();
+        });
+
+        it("requests persistence directly when persisted() is unavailable", async () => {
+            const persist = jest.fn().mockResolvedValue(true);
+            setStorage({ persist });
+
+            await expect(StorageManager.tryPersistStorage()).resolves.toBe(true);
+            expect(persist).toHaveBeenCalledTimes(1);
+        });
+
+        it("still requests persistence and logs the failure when querying the persisted state fails", async () => {
+            const queryError = new Error("query failed");
+            const persisted = jest.fn().mockRejectedValue(queryError);
+            const persist = jest.fn().mockResolvedValue(true);
+            setStorage({ persist, persisted });
+
+            await expect(StorageManager.tryPersistStorage()).resolves.toBe(true);
+            expect(persist).toHaveBeenCalled();
+            expect(logger.warn).toHaveBeenCalledWith(expect.stringContaining("Could not query"), queryError);
+        });
+
+        it("returns false and warns when persistence is denied", async () => {
+            const persist = jest.fn().mockResolvedValue(false);
+            const persisted = jest.fn().mockResolvedValue(false);
+            setStorage({ persist, persisted });
+
+            await expect(StorageManager.tryPersistStorage()).resolves.toBe(false);
+            expect(logger.warn).toHaveBeenCalledWith(expect.stringContaining("Persistent storage"));
+        });
+
+        it("returns false when navigator.storage lacks persist()", async () => {
+            setStorage({ persisted: jest.fn().mockResolvedValue(false) });
+
+            await expect(StorageManager.tryPersistStorage()).resolves.toBe(false);
+            expect(logger.log).toHaveBeenCalledWith(expect.stringContaining("unsupported"));
+        });
+
+        it("returns false without throwing when persistence is unsupported", async () => {
+            await expect(StorageManager.tryPersistStorage()).resolves.toBe(false);
+        });
+
+        it("does not reject but logs an error if requesting persistence throws", async () => {
+            const persist = jest.fn().mockRejectedValue(new Error("boom"));
+            const persisted = jest.fn().mockResolvedValue(false);
+            setStorage({ persist, persisted });
+
+            await expect(StorageManager.tryPersistStorage()).resolves.toBe(false);
+            expect(logger.error).toHaveBeenCalled();
+        });
+    });
 });