GitLab

at 2024-08-28T17:41:16+02:00

fixup! Bug 31740: Remove some unnecessary RemoteSettings instances

Bug 42730: Revert some changes

Bug 42730: Patch RemoteSettings to use only local dumps as a data source

         lazy.RemoteSecuritySettings.init();

       },

+      function RemoteSettingsPollChanges() {

+        // Support clients that use the "sync" event or "remote-settings:changes-poll-end".

+        lazy.RemoteSettings.pollChanges({ trigger: "timer" });

+      },

+

       function BrowserUsageTelemetryReportProfileCount() {

         lazy.BrowserUsageTelemetry.reportProfileCount();

       },

   InitializationTracker: "resource://gre/modules/GeckoViewTelemetry.sys.mjs",

   RemoteSecuritySettings:

     "resource://gre/modules/psm/RemoteSecuritySettings.sys.mjs",

+  RemoteSettings: "resource://services-settings/remote-settings.sys.mjs",

   SafeBrowsing: "resource://gre/modules/SafeBrowsing.sys.mjs",

 });

       Blocklist.loadBlocklistAsync();

     });

+    InitLater(() => {

+      RemoteSettings.pollChanges({ trigger: "timer" });

+    });

+

     // This should always go last, since the idle tasks (except for the ones with

     // timeouts) should execute in order. Note that this observer notification is

     // not guaranteed to fire, since the window could close before we get here.

       fallbackToDump = false;

     }

+    avoidDownload = true;

+    fallbackToCache = true;

+    fallbackToDump = true;

+

     const dumpInfo = new LazyRecordAndBuffer(() =>

       this._readAttachmentDump(attachmentId)

     );

       attachment: { location, hash, size },

     } = record;

+    return (await this.#fetchAttachment(record)).buffer;

+    // eslint-disable-next-line no-unreachable

     const remoteFileUrl = (await this._baseAttachmentsURL()) + location;

     const { retries = 3, checkHash = true } = options;

       order = "", // not sorted by default.

       dumpFallback = true,

       emptyListFallback = true,

-      forceSync = false,

       loadDumpIfNewer = true,

-      syncIfEmpty = true,

     } = options;

-    let { verifySignature = false } = options;

+

+    const hasLocalDump = await lazy.Utils.hasLocalDump(

+      this.bucketName,

+      this.collectionName

+    );

+    if (!hasLocalDump) {

+      return [];

+    }

+    const forceSync = false;

+    const syncIfEmpty = true;

+    let verifySignature = false;

     const hasParallelCall = !!this._importingPromise;

     let data;

    * @param {Object} options See #maybeSync() options.

    */

   async sync(options) {

+    if (AppConstants.BASE_BROWSER_VERSION) {

+      return;

+    }

+

     if (lazy.Utils.shouldSkipRemoteActivityDueToTests) {

       return;

     }

     let thrownError = null;

     try {

       // If network is offline, we can't synchronize.

-      if (lazy.Utils.isOffline) {

+      if (!AppConstants.BASE_BROWSER_VERSION && lazy.Utils.isOffline) {

         throw new RemoteSettingsClient.NetworkOfflineError();

       }

     options = {}

   ) {

     const { retry = false } = options;

-    const since = retry || !localTimestamp ? undefined : `"${localTimestamp}"`;

-    // Fetch collection metadata and list of changes from server.

-    lazy.console.debug(

-      `${this.identifier} Fetch changes from server (expected=${expectedTimestamp}, since=${since})`

-    );

-    const { metadata, remoteTimestamp, remoteRecords } =

-      await this._fetchChangeset(expectedTimestamp, since);

+    let metadata, remoteTimestamp;

     // We build a sync result, based on remote changes.

     const syncResult = {

       updated: [],

       deleted: [],

     };

-    // If data wasn't changed, return empty sync result.

-    // This can happen when we update the signature but not the data.

-    lazy.console.debug(

-      `${this.identifier} local timestamp: ${localTimestamp}, remote: ${remoteTimestamp}`

-    );

-    if (localTimestamp && remoteTimestamp < localTimestamp) {

+

+    try {

+      await this._importJSONDump();

+    } catch (e) {

       return syncResult;

     }

-    await this.db.importChanges(metadata, remoteTimestamp, remoteRecords, {

-      clear: retry,

-    });

-

     // Read the new local data, after updating.

     const newLocal = await this.db.list();

     const newRecords = newLocal.map(r => this._cleanLocalFields(r));

     // And verify the signature on what is now stored.

-    if (this.verifySignature) {

+    if (metadata === undefined) {

+      // When working only with dumps, we do not have signatures.

+    } else if (this.verifySignature) {

       try {

         await this._validateCollectionSignature(

           newRecords,

     dumps_locations = []

     if buildconfig.substs["MOZ_BUILD_APP"] == "browser":

         dumps_locations += ["services/settings/dumps/"]

+        dumps_locations += ["services/settings/static-dumps/"]

     elif buildconfig.substs["MOZ_BUILD_APP"] == "mobile/android":

         dumps_locations += ["services/settings/dumps/"]

+        dumps_locations += ["services/settings/static-dumps/"]

     elif buildconfig.substs["MOZ_BUILD_APP"] == "mobile/ios":

         dumps_locations += ["services/settings/dumps/"]

     elif buildconfig.substs["MOZ_BUILD_APP"] == "comm/mail":

 function remoteSettingsFunction() {

   const _clients = new Map();

   let _invalidatePolling = false;

+  let _initialized = false;

   // If not explicitly specified, use the default signer.

   const defaultOptions = {

     trigger = "manual",

     full = false,

   } = {}) => {

+    if (AppConstants.BASE_BROWSER_VERSION) {

+      // Called multiple times on GeckoView due to bug 1730026

+      if (_initialized) {

+        return;

+      }

+      _initialized = true;

+      let importedFromDump = false;

+      for (const client of _clients.values()) {

+        const hasLocalDump = await lazy.Utils.hasLocalDump(

+          client.bucketName,

+          client.collectionName

+        );

+        if (hasLocalDump) {

+          const lastModified = await client.getLastModified();

+          const lastModifiedDump = await lazy.Utils.getLocalDumpLastModified(

+            client.bucketName,

+            client.collectionName

+          );

+          if (lastModified < lastModifiedDump) {

+            await client.maybeSync(lastModifiedDump, {

+              loadDump: true,

+              trigger,

+            });

+            importedFromDump = true;

+          }

+        }

+      }

+      if (importedFromDump) {

+        Services.obs.notifyObservers(null, "remote-settings:changes-poll-end");

+      }

+      return;

+    }

+

     if (lazy.Utils.shouldSkipRemoteActivityDueToTests) {

       return;

     }

     // When running in full mode, we ignore last polling status.

-    if (full || AppConstants.BASE_BROWSER_VERSION) {

+    if (full) {

       lazy.gPrefs.clearUserPref(PREF_SETTINGS_SERVER_BACKOFF);

       lazy.gPrefs.clearUserPref(PREF_SETTINGS_LAST_UPDATE);

       lazy.gPrefs.clearUserPref(PREF_SETTINGS_LAST_ETAG);

     }

-    if (AppConstants.BASE_BROWSER_VERSION) {

-      // tor-browser#41704: pollChanges is always online, so do not allow it.

-      return;

-    }

-

     let pollTelemetryArgs = {

       source: TELEMETRY_SOURCE_POLL,

       trigger,

 #ifdef MOZ_THUNDERBIRD

     "https://thunderbird-settings.thunderbird.net/v1",

 #else

-    "https://firefox.settings.services.mozilla.com/v1",

+    "",

 #endif

   REMOTE_SETTINGS_VERIFY_SIGNATURE:

-#ifdef MOZ_THUNDERBIRD

+#if defined(MOZ_THUNDERBIRD) || defined(BASE_BROWSER_VERSION)

     false,

 #else

     true,

 const lazy = {};

 ChromeUtils.defineESModuleGetters(lazy, {

+  RemoteSettings: "resource://services-settings/remote-settings.sys.mjs",

   RemoteSettingsClient:

     "resource://services-settings/RemoteSettingsClient.sys.mjs",

 });

-class IgnoreListsManager {

-  _ignoreListSettings = null;

+const SETTINGS_IGNORELIST_KEY = "hijack-blocklists";

+class IgnoreListsManager {

   async init() {

-    // TODO: Restore the initialization, once we use only the local dumps for

-    // the remote settings.

+    if (!this._ignoreListSettings) {

+      this._ignoreListSettings = lazy.RemoteSettings(SETTINGS_IGNORELIST_KEY);

+    }

   }

   async getAndSubscribe(listener) {

     const settings = await this._getIgnoreList();

     // Listen for future updates after we first get the values.

-    this._ignoreListSettings?.on("sync", listener);

+    this._ignoreListSettings.on("sync", listener);

     return settings;

   }

    *   could be obtained.

    */

   async _getIgnoreListSettings(firstTime = true) {

-    if (!this._ignoreListSettings) {

-      const dump = await fetch(

-        "resource:///defaults/settings/main/hijack-blocklists.json"

-      );

-      const { data } = await dump.json();

-      return data;

-    }

-

     let result = [];

     try {

       result = await this._ignoreListSettings.get({

Pier Angelo Vendrame pushed to branch mullvad-browser-128.2.0esr-14.0-1 at The Tor Project / Applications / Mullvad Browser

Commits:

8 changed files:

Changes: