[PM-6383] Migrate clearClipboard account setting to autofill settings service (#8022)

* migrate clearClipboard account setting to autofill settings state provider

* replace state service get/set clearClipboard with autofill settings service equivalents

* PR suggestions cleanup

libs/common/src/autofill/services/autofill-settings.service.ts

@@ -1,5 +1,9 @@
 import { filter, switchMap, tap, firstValueFrom, map, Observable } from "rxjs";
 
+import {
+  ClearClipboardDelaySetting,
+  ClearClipboardDelay,
+} from "../../../../../apps/browser/src/autofill/constants";
 import {
   AutofillOverlayVisibility,
   InlineMenuVisibilitySetting,
@@ -56,6 +60,14 @@ const INLINE_MENU_VISIBILITY = new KeyDefinition(
   },
 );
 
+const CLEAR_CLIPBOARD_DELAY = new KeyDefinition(
+  AUTOFILL_SETTINGS_DISK_LOCAL,
+  "clearClipboardDelay",
+  {
+    deserializer: (value: ClearClipboardDelaySetting) => value ?? ClearClipboardDelay.Never,
+  },
+);
+
 export abstract class AutofillSettingsServiceAbstraction {
   autofillOnPageLoad$: Observable<boolean>;
   setAutofillOnPageLoad: (newValue: boolean) => Promise<void>;
@@ -69,6 +81,8 @@ export abstract class AutofillSettingsServiceAbstraction {
   setActivateAutofillOnPageLoadFromPolicy: (newValue: boolean) => Promise<void>;
   inlineMenuVisibility$: Observable<InlineMenuVisibilitySetting>;
   setInlineMenuVisibility: (newValue: InlineMenuVisibilitySetting) => Promise<void>;
+  clearClipboardDelay$: Observable<ClearClipboardDelaySetting>;
+  setClearClipboardDelay: (newValue: ClearClipboardDelaySetting) => Promise<void>;
   handleActivateAutofillPolicy: (policies: Observable<Policy[]>) => Observable<boolean[]>;
 }
 
@@ -91,6 +105,9 @@ export class AutofillSettingsService implements AutofillSettingsServiceAbstracti
   private inlineMenuVisibilityState: GlobalState<InlineMenuVisibilitySetting>;
   readonly inlineMenuVisibility$: Observable<InlineMenuVisibilitySetting>;
 
+  private clearClipboardDelayState: ActiveUserState<ClearClipboardDelaySetting>;
+  readonly clearClipboardDelay$: Observable<ClearClipboardDelaySetting>;
+
   constructor(
     private stateProvider: StateProvider,
     policyService: PolicyService,
@@ -125,6 +142,11 @@ export class AutofillSettingsService implements AutofillSettingsServiceAbstracti
       map((x) => x ?? AutofillOverlayVisibility.Off),
     );
 
+    this.clearClipboardDelayState = this.stateProvider.getActive(CLEAR_CLIPBOARD_DELAY);
+    this.clearClipboardDelay$ = this.clearClipboardDelayState.state$.pipe(
+      map((x) => x ?? ClearClipboardDelay.Never),
+    );
+
     policyService.policies$.pipe(this.handleActivateAutofillPolicy.bind(this)).subscribe();
   }
 
@@ -152,6 +174,10 @@ export class AutofillSettingsService implements AutofillSettingsServiceAbstracti
     await this.inlineMenuVisibilityState.update(() => newValue);
   }
 
+  async setClearClipboardDelay(newValue: ClearClipboardDelaySetting): Promise<void> {
+    await this.clearClipboardDelayState.update(() => newValue);
+  }
+
   /**
    * If the ActivateAutofill policy is enabled, save a flag indicating if we need to
    * enable Autofill on page load.

libs/common/src/platform/abstractions/state.service.ts

@@ -81,8 +81,6 @@ export abstract class StateService<T extends Account = Account> {
   setHasPremiumPersonally: (value: boolean, options?: StorageOptions) => Promise<void>;
   setHasPremiumFromOrganization: (value: boolean, options?: StorageOptions) => Promise<void>;
   getHasPremiumFromOrganization: (options?: StorageOptions) => Promise<boolean>;
-  getClearClipboard: (options?: StorageOptions) => Promise<number>;
-  setClearClipboard: (value: number, options?: StorageOptions) => Promise<void>;
   getConvertAccountToKeyConnector: (options?: StorageOptions) => Promise<boolean>;
   setConvertAccountToKeyConnector: (value: boolean, options?: StorageOptions) => Promise<void>;
   /**

libs/common/src/platform/models/domain/account.ts

@@ -201,7 +201,6 @@ export class AccountProfile {
 export class AccountSettings {
   autoConfirmFingerPrints?: boolean;
   biometricUnlock?: boolean;
-  clearClipboard?: number;
   defaultUriMatch?: UriMatchType;
   disableBadgeCounter?: boolean;
   disableGa?: boolean;

libs/common/src/platform/services/state.service.ts

@@ -462,27 +462,6 @@ export class StateService<
     );
   }
 
-  async getClearClipboard(options?: StorageOptions): Promise<number> {
-    return (
-      (
-        await this.getAccount(
-          this.reconcileOptions(options, await this.defaultOnDiskLocalOptions()),
-        )
-      )?.settings?.clearClipboard ?? null
-    );
-  }
-
-  async setClearClipboard(value: number, options?: StorageOptions): Promise<void> {
-    const account = await this.getAccount(
-      this.reconcileOptions(options, await this.defaultOnDiskLocalOptions()),
-    );
-    account.settings.clearClipboard = value;
-    await this.saveAccount(
-      account,
-      this.reconcileOptions(options, await this.defaultOnDiskLocalOptions()),
-    );
-  }
-
   async getConvertAccountToKeyConnector(options?: StorageOptions): Promise<boolean> {
     return (
       await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions()))

libs/common/src/platform/services/system.service.ts

@@ -3,6 +3,7 @@ import { firstValueFrom, timeout } from "rxjs";
 import { VaultTimeoutSettingsService } from "../../abstractions/vault-timeout/vault-timeout-settings.service";
 import { AuthService } from "../../auth/abstractions/auth.service";
 import { AuthenticationStatus } from "../../auth/enums/authentication-status";
+import { AutofillSettingsServiceAbstraction } from "../../autofill/services/autofill-settings.service";
 import { VaultTimeoutAction } from "../../enums/vault-timeout-action.enum";
 import { MessagingService } from "../abstractions/messaging.service";
 import { PlatformUtilsService } from "../abstractions/platform-utils.service";
@@ -20,6 +21,7 @@ export class SystemService implements SystemServiceAbstraction {
     private platformUtilsService: PlatformUtilsService,
     private reloadCallback: () => Promise<void> = null,
     private stateService: StateService,
+    private autofillSettingsService: AutofillSettingsServiceAbstraction,
     private vaultTimeoutSettingsService: VaultTimeoutSettingsService,
   ) {}
 
@@ -93,26 +95,33 @@ export class SystemService implements SystemServiceAbstraction {
       clearTimeout(this.clearClipboardTimeout);
       this.clearClipboardTimeout = null;
     }
+
     if (Utils.isNullOrWhitespace(clipboardValue)) {
       return;
     }
-    await this.stateService.getClearClipboard().then((clearSeconds) => {
-      if (clearSeconds == null) {
-        return;
+
+    const clearClipboardDelay = await firstValueFrom(
+      this.autofillSettingsService.clearClipboardDelay$,
+    );
+
+    if (clearClipboardDelay == null) {
+      return;
+    }
+
+    if (timeoutMs == null) {
+      timeoutMs = clearClipboardDelay * 1000;
+    }
+
+    this.clearClipboardTimeoutFunction = async () => {
+      const clipboardValueNow = await this.platformUtilsService.readFromClipboard();
+      if (clipboardValue === clipboardValueNow) {
+        this.platformUtilsService.copyToClipboard("", { clearing: true });
       }
-      if (timeoutMs == null) {
-        timeoutMs = clearSeconds * 1000;
-      }
-      this.clearClipboardTimeoutFunction = async () => {
-        const clipboardValueNow = await this.platformUtilsService.readFromClipboard();
-        if (clipboardValue === clipboardValueNow) {
-          this.platformUtilsService.copyToClipboard("", { clearing: true });
-        }
-      };
-      this.clearClipboardTimeout = setTimeout(async () => {
-        await this.clearPendingClipboard();
-      }, timeoutMs);
-    });
+    };
+
+    this.clearClipboardTimeout = setTimeout(async () => {
+      await this.clearPendingClipboard();
+    }, timeoutMs);
   }
 
   async clearPendingClipboard() {

libs/common/src/state-migrations/migrate.ts

@@ -19,6 +19,7 @@ import { CollectionMigrator } from "./migrations/21-move-collections-state-to-st
 import { CollapsedGroupingsMigrator } from "./migrations/22-move-collapsed-groupings-to-state-provider";
 import { MoveBiometricPromptsToStateProviders } from "./migrations/23-move-biometric-prompts-to-state-providers";
 import { SmOnboardingTasksMigrator } from "./migrations/24-move-sm-onboarding-key-to-state-providers";
+import { ClearClipboardDelayMigrator } from "./migrations/25-move-clear-clipboard-to-autofill-settings-state-provider";
 import { FixPremiumMigrator } from "./migrations/3-fix-premium";
 import { RemoveEverBeenUnlockedMigrator } from "./migrations/4-remove-ever-been-unlocked";
 import { AddKeyTypeToOrgKeysMigrator } from "./migrations/5-add-key-type-to-org-keys";
@@ -29,7 +30,7 @@ import { MoveBrowserSettingsToGlobal } from "./migrations/9-move-browser-setting
 import { MinVersionMigrator } from "./migrations/min-version";
 
 export const MIN_VERSION = 2;
-export const CURRENT_VERSION = 24;
+export const CURRENT_VERSION = 25;
 export type MinVersion = typeof MIN_VERSION;
 
 export function createMigrationBuilder() {
@@ -56,7 +57,8 @@ export function createMigrationBuilder() {
     .with(CollectionMigrator, 20, 21)
     .with(CollapsedGroupingsMigrator, 21, 22)
     .with(MoveBiometricPromptsToStateProviders, 22, 23)
-    .with(SmOnboardingTasksMigrator, 23, CURRENT_VERSION);
+    .with(SmOnboardingTasksMigrator, 23, 24)
+    .with(ClearClipboardDelayMigrator, 24, CURRENT_VERSION);
 }
 
 export async function currentVersion(

libs/common/src/state-migrations/migrations/18-move-autofill-settings-to-state-providers.spec.ts

@@ -1,11 +1,16 @@
 import { any, MockProxy } from "jest-mock-extended";
 
-import { AutofillOverlayVisibility } from "../../../../../apps/browser/src/autofill/utils/autofill-overlay.enum";
 import { StateDefinitionLike, MigrationHelper } from "../migration-helper";
 import { mockMigrationHelper } from "../migration-helper.spec";
 
 import { AutofillSettingsKeyMigrator } from "./18-move-autofill-settings-to-state-providers";
 
+const AutofillOverlayVisibility = {
+  Off: 0,
+  OnButtonClick: 1,
+  OnFieldFocus: 2,
+} as const;
+
 function exampleJSON() {
   return {
     global: {

libs/common/src/state-migrations/migrations/25-move-clear-clipboard-to-autofill-settings-state-provider.spec.ts

@@ -0,0 +1,177 @@
+import { any, MockProxy } from "jest-mock-extended";
+
+import { StateDefinitionLike, MigrationHelper } from "../migration-helper";
+import { mockMigrationHelper } from "../migration-helper.spec";
+
+import { ClearClipboardDelayMigrator } from "./25-move-clear-clipboard-to-autofill-settings-state-provider";
+
+export const ClearClipboardDelay = {
+  Never: null as null,
+  TenSeconds: 10,
+  TwentySeconds: 20,
+  ThirtySeconds: 30,
+  OneMinute: 60,
+  TwoMinutes: 120,
+  FiveMinutes: 300,
+} as const;
+
+const AutofillOverlayVisibility = {
+  Off: 0,
+  OnButtonClick: 1,
+  OnFieldFocus: 2,
+} as const;
+
+function exampleJSON() {
+  return {
+    global: {
+      otherStuff: "otherStuff1",
+    },
+    authenticatedAccounts: ["user-1", "user-2", "user-3"],
+    "user-1": {
+      settings: {
+        clearClipboard: ClearClipboardDelay.TenSeconds,
+        otherStuff: "otherStuff2",
+      },
+      otherStuff: "otherStuff3",
+    },
+    "user-2": {
+      settings: {
+        clearClipboard: ClearClipboardDelay.Never,
+        otherStuff: "otherStuff4",
+      },
+      otherStuff: "otherStuff5",
+    },
+    "user-3": {
+      settings: {
+        otherStuff: "otherStuff4",
+      },
+      otherStuff: "otherStuff5",
+    },
+  };
+}
+
+function rollbackJSON() {
+  return {
+    global_autofillSettingsLocal_inlineMenuVisibility: AutofillOverlayVisibility.OnButtonClick,
+    "user_user-1_autofillSettingsLocal_clearClipboardDelay": ClearClipboardDelay.TenSeconds,
+    "user_user-2_autofillSettingsLocal_clearClipboardDelay": ClearClipboardDelay.Never,
+    global: {
+      otherStuff: "otherStuff1",
+    },
+    authenticatedAccounts: ["user-1", "user-2", "user-3"],
+    "user-1": {
+      settings: {
+        otherStuff: "otherStuff2",
+      },
+      otherStuff: "otherStuff3",
+    },
+    "user-2": {
+      settings: {
+        otherStuff: "otherStuff4",
+      },
+      otherStuff: "otherStuff5",
+    },
+  };
+}
+
+const autofillSettingsLocalStateDefinition: {
+  stateDefinition: StateDefinitionLike;
+} = {
+  stateDefinition: {
+    name: "autofillSettingsLocal",
+  },
+};
+
+describe("ProviderKeysMigrator", () => {
+  let helper: MockProxy<MigrationHelper>;
+  let sut: ClearClipboardDelayMigrator;
+
+  describe("migrate", () => {
+    beforeEach(() => {
+      helper = mockMigrationHelper(exampleJSON(), 24);
+      sut = new ClearClipboardDelayMigrator(24, 25);
+    });
+
+    it("should remove clearClipboard setting from all accounts", async () => {
+      await sut.migrate(helper);
+      expect(helper.set).toHaveBeenCalledTimes(2);
+      expect(helper.set).toHaveBeenCalledWith("user-1", {
+        settings: {
+          otherStuff: "otherStuff2",
+        },
+        otherStuff: "otherStuff3",
+      });
+      expect(helper.set).toHaveBeenCalledWith("user-2", {
+        settings: {
+          otherStuff: "otherStuff4",
+        },
+        otherStuff: "otherStuff5",
+      });
+    });
+
+    it("should set autofill setting values for each account", async () => {
+      await sut.migrate(helper);
+
+      expect(helper.setToUser).toHaveBeenCalledTimes(2);
+      expect(helper.setToUser).toHaveBeenCalledWith(
+        "user-1",
+        { ...autofillSettingsLocalStateDefinition, key: "clearClipboardDelay" },
+        ClearClipboardDelay.TenSeconds,
+      );
+      expect(helper.setToUser).toHaveBeenCalledWith(
+        "user-2",
+        { ...autofillSettingsLocalStateDefinition, key: "clearClipboardDelay" },
+        ClearClipboardDelay.Never,
+      );
+    });
+  });
+
+  describe("rollback", () => {
+    beforeEach(() => {
+      helper = mockMigrationHelper(rollbackJSON(), 23);
+      sut = new ClearClipboardDelayMigrator(24, 25);
+    });
+
+    it("should null out new values for each account", async () => {
+      await sut.rollback(helper);
+
+      expect(helper.setToUser).toHaveBeenCalledTimes(2);
+      expect(helper.setToUser).toHaveBeenCalledWith(
+        "user-1",
+        { ...autofillSettingsLocalStateDefinition, key: "clearClipboardDelay" },
+        null,
+      );
+      expect(helper.setToUser).toHaveBeenCalledWith(
+        "user-2",
+        { ...autofillSettingsLocalStateDefinition, key: "clearClipboardDelay" },
+        null,
+      );
+    });
+
+    it("should add explicit value back to accounts", async () => {
+      await sut.rollback(helper);
+
+      expect(helper.set).toHaveBeenCalledTimes(2);
+      expect(helper.set).toHaveBeenCalledWith("user-1", {
+        settings: {
+          clearClipboard: ClearClipboardDelay.TenSeconds,
+          otherStuff: "otherStuff2",
+        },
+        otherStuff: "otherStuff3",
+      });
+      expect(helper.set).toHaveBeenCalledWith("user-2", {
+        settings: {
+          clearClipboard: ClearClipboardDelay.Never,
+          otherStuff: "otherStuff4",
+        },
+        otherStuff: "otherStuff5",
+      });
+    });
+
+    it("should not try to restore values to missing accounts", async () => {
+      await sut.rollback(helper);
+
+      expect(helper.set).not.toHaveBeenCalledWith("user-3", any());
+    });
+  });
+});

libs/common/src/state-migrations/migrations/25-move-clear-clipboard-to-autofill-settings-state-provider.ts

@@ -0,0 +1,77 @@
+import { ClearClipboardDelaySetting } from "../../../../../apps/browser/src/autofill/constants";
+import { StateDefinitionLike, MigrationHelper } from "../migration-helper";
+import { Migrator } from "../migrator";
+
+type ExpectedAccountState = {
+  settings?: {
+    clearClipboard?: ClearClipboardDelaySetting;
+  };
+};
+
+const autofillSettingsLocalStateDefinition: {
+  stateDefinition: StateDefinitionLike;
+} = {
+  stateDefinition: {
+    name: "autofillSettingsLocal",
+  },
+};
+
+export class ClearClipboardDelayMigrator extends Migrator<24, 25> {
+  async migrate(helper: MigrationHelper): Promise<void> {
+    // account state (e.g. account settings -> state provider framework keys)
+    const accounts = await helper.getAccounts<ExpectedAccountState>();
+
+    await Promise.all([...accounts.map(({ userId, account }) => migrateAccount(userId, account))]);
+
+    // migrate account state
+    async function migrateAccount(userId: string, account: ExpectedAccountState): Promise<void> {
+      const accountSettings = account?.settings;
+
+      if (accountSettings?.clearClipboard !== undefined) {
+        await helper.setToUser(
+          userId,
+          { ...autofillSettingsLocalStateDefinition, key: "clearClipboardDelay" },
+          accountSettings.clearClipboard,
+        );
+        delete account.settings.clearClipboard;
+
+        // update the state account settings with the migrated values deleted
+        await helper.set(userId, account);
+      }
+    }
+  }
+
+  async rollback(helper: MigrationHelper): Promise<void> {
+    // account state (e.g. state provider framework keys -> account settings)
+    const accounts = await helper.getAccounts<ExpectedAccountState>();
+
+    await Promise.all([...accounts.map(({ userId, account }) => rollbackAccount(userId, account))]);
+
+    // rollback account state
+    async function rollbackAccount(userId: string, account: ExpectedAccountState): Promise<void> {
+      let settings = account?.settings || {};
+
+      const clearClipboardDelay: ClearClipboardDelaySetting = await helper.getFromUser(userId, {
+        ...autofillSettingsLocalStateDefinition,
+        key: "clearClipboardDelay",
+      });
+
+      // update new settings and remove the account state provider framework keys for the rolled back values
+      if (clearClipboardDelay !== undefined) {
+        settings = { ...settings, clearClipboard: clearClipboardDelay };
+
+        await helper.setToUser(
+          userId,
+          { ...autofillSettingsLocalStateDefinition, key: "clearClipboardDelay" },
+          null,
+        );
+
+        // commit updated settings to state
+        await helper.set(userId, {
+          ...account,
+          settings,
+        });
+      }
+    }
+  }
+}