Merge branch 'main' of https://github.com/bitwarden/clients into ps/p…

…m-5717/fix-calling-init-on-undefined-in-biometrics-service

apps/browser/gulpfile.js

@@ -62,6 +62,9 @@ function distFirefox() {
   return dist("firefox", (manifest) => {
     delete manifest.storage;
     delete manifest.sandbox;
+    manifest.optional_permissions = manifest.optional_permissions.filter(
+      (permission) => permission !== "privacy",
+    );
     return manifest;
   });
 }

apps/browser/src/_locales/en/messages.json

@@ -2895,5 +2895,33 @@
   "commonImportFormats": {
     "message": "Common formats",
     "description": "Label indicating the most common import formats"
+  },
+  "overrideDefaultBrowserAutofillTitle": {
+    "message": "Make Bitwarden your default password manager?",
+    "description": "Dialog title facilitating the ability to override a chrome browser's default autofill behavior"
+  },
+  "overrideDefaultBrowserAutofillDescription": {
+    "message": "Ignoring this option may cause conflicts between the Bitwarden auto-fill menu and your browser's.",
+    "description": "Dialog message facilitating the ability to override a chrome browser's default autofill behavior"
+  },
+  "overrideDefaultBrowserAutofillPrivacyRequiredDescription": {
+    "message": "This action will restart the Bitwarden extension. Ignoring this option may cause conflicts between the Bitwarden auto-fill menu and your browser's.",
+    "description": "Dialog message facilitating the ability to override a chrome browser's default autofill behavior"
+  },
+  "overrideDefaultBrowserAutoFillSettings": {
+    "message": "Make Bitwarden your default password manager",
+    "description": "Label for the setting that allows overriding the default browser autofill settings"
+  },
+  "privacyPermissionAdditionNotGrantedTitle": {
+    "message": "Unable to set Bitwarden as the default password manager",
+    "description": "Title for the dialog that appears when the user has not granted the extension permission to set privacy settings"
+  },
+  "privacyPermissionAdditionNotGrantedDescription": {
+    "message": "You must grant browser privacy permissions to Bitwarden to set it as the default password manager.",
+    "description": "Description for the dialog that appears when the user has not granted the extension permission to set privacy settings"
+  },
+  "makeDefault": {
+    "message": "Make default",
+    "description": "Button text for the setting that allows overriding the default browser autofill settings"
   }
 }

apps/browser/src/autofill/background/service_factories/autofill-service.factory.ts

@@ -10,10 +10,6 @@ import {
   settingsServiceFactory,
   SettingsServiceInitOptions,
 } from "../../../background/service-factories/settings-service.factory";
-import {
-  configServiceFactory,
-  ConfigServiceInitOptions,
-} from "../../../platform/background/service-factories/config-service.factory";
 import {
   CachedServices,
   factory,
@@ -47,8 +43,7 @@ export type AutoFillServiceInitOptions = AutoFillServiceOptions &
   EventCollectionServiceInitOptions &
   LogServiceInitOptions &
   SettingsServiceInitOptions &
-  UserVerificationServiceInitOptions &
-  ConfigServiceInitOptions;
+  UserVerificationServiceInitOptions;
 
 export function autofillServiceFactory(
   cache: { autofillService?: AbstractAutoFillService } & CachedServices,
@@ -67,7 +62,6 @@ export function autofillServiceFactory(
         await logServiceFactory(cache, opts),
         await settingsServiceFactory(cache, opts),
         await userVerificationServiceFactory(cache, opts),
-        await configServiceFactory(cache, opts),
       ),
   );
 }

apps/browser/src/autofill/popup/settings/autofill.component.html

@@ -41,21 +41,37 @@ <h1 class="center">
           </option>
         </select>
       </div>
-      <div class="box-footer" *ngIf="accountSwitcherEnabled">
+      <div class="box-footer" *ngIf="accountSwitcherEnabled && canOverrideBrowserAutofillSetting">
         {{ "showAutoFillMenuOnFormFieldsDescAlt" | i18n }}
       </div>
-      <div class="box-footer">
-        {{ "turnOffBrowserBuiltInPasswordManagerSettings" | i18n }}
-        <a
-          [attr.href]="disablePasswordManagerLink"
-          (click)="openDisablePasswordManagerLink($event)"
-          target="_blank"
-          rel="noopener noreferrer"
-        >
-          {{ "turnOffBrowserBuiltInPasswordManagerSettingsLink" | i18n }}
-        </a>
+    </div>
+  </div>
+  <div class="box">
+    <div class="box-content" *ngIf="canOverrideBrowserAutofillSetting">
+      <div class="box-content-row box-content-row-checkbox" appBoxRow>
+        <label for="overrideBrowserAutofill" class="!tw-mr-0">{{
+          "overrideDefaultBrowserAutoFillSettings" | i18n
+        }}</label>
+        <input
+          id="overrideBrowserAutofill"
+          type="checkbox"
+          (change)="updateDefaultBrowserAutofillDisabled()"
+          [(ngModel)]="defaultBrowserAutofillDisabled"
+        />
       </div>
     </div>
+    <div class="box-footer">
+      <span *ngIf="accountSwitcherEnabled">{{ "showAutoFillMenuOnFormFieldsDescAlt" | i18n }}</span>
+      {{ "turnOffBrowserBuiltInPasswordManagerSettings" | i18n }}
+      <a
+        [attr.href]="disablePasswordManagerLink"
+        (click)="openDisablePasswordManagerLink($event)"
+        target="_blank"
+        rel="noopener noreferrer"
+      >
+        {{ "turnOffBrowserBuiltInPasswordManagerSettingsLink" | i18n }}
+      </a>
+    </div>
   </div>
   <div class="box tw-mt-4">
     <div class="box-content">

apps/browser/src/autofill/popup/settings/autofill.component.ts

@@ -6,6 +6,7 @@ import { I18nService } from "@bitwarden/common/platform/abstractions/i18n.servic
 import { PlatformUtilsService } from "@bitwarden/common/platform/abstractions/platform-utils.service";
 import { StateService } from "@bitwarden/common/platform/abstractions/state.service";
 import { UriMatchType } from "@bitwarden/common/vault/enums";
+import { DialogService } from "@bitwarden/components";
 
 import { BrowserApi } from "../../../platform/browser/browser-api";
 import { enableAccountSwitching } from "../../../platform/flags";
@@ -17,6 +18,8 @@ import { AutofillOverlayVisibility } from "../../utils/autofill-overlay.enum";
   templateUrl: "autofill.component.html",
 })
 export class AutofillComponent implements OnInit {
+  protected canOverrideBrowserAutofillSetting = false;
+  protected defaultBrowserAutofillDisabled = false;
   protected autoFillOverlayVisibility: number;
   protected autoFillOverlayVisibilityOptions: any[];
   protected disablePasswordManagerLink: string;
@@ -35,6 +38,7 @@ export class AutofillComponent implements OnInit {
     private configService: ConfigServiceAbstraction,
     private settingsService: SettingsService,
     private autofillService: AutofillService,
+    private dialogService: DialogService,
   ) {
     this.autoFillOverlayVisibilityOptions = [
       {
@@ -68,6 +72,14 @@ export class AutofillComponent implements OnInit {
   }
 
   async ngOnInit() {
+    this.canOverrideBrowserAutofillSetting =
+      this.platformUtilsService.isChrome() ||
+      this.platformUtilsService.isEdge() ||
+      this.platformUtilsService.isOpera() ||
+      this.platformUtilsService.isVivaldi();
+
+    this.defaultBrowserAutofillDisabled = await this.browserAutofillSettingCurrentlyOverridden();
+
     this.autoFillOverlayVisibility =
       (await this.settingsService.getAutoFillOverlayVisibility()) || AutofillOverlayVisibility.Off;
 
@@ -87,6 +99,7 @@ export class AutofillComponent implements OnInit {
       await this.settingsService.getAutoFillOverlayVisibility();
     await this.settingsService.setAutoFillOverlayVisibility(this.autoFillOverlayVisibility);
     await this.handleUpdatingAutofillOverlayContentScripts(previousAutoFillOverlayVisibility);
+    await this.requestPrivacyPermission();
   }
 
   async updateAutoFillOnPageLoad() {
@@ -165,4 +178,73 @@ export class AutofillComponent implements OnInit {
 
     await this.autofillService.reloadAutofillScripts();
   }
+
+  async requestPrivacyPermission() {
+    if (
+      this.autoFillOverlayVisibility === AutofillOverlayVisibility.Off ||
+      !this.canOverrideBrowserAutofillSetting ||
+      (await this.browserAutofillSettingCurrentlyOverridden())
+    ) {
+      return;
+    }
+
+    const permissionGranted = await this.privacyPermissionGranted();
+    const contentKey = permissionGranted
+      ? "overrideDefaultBrowserAutofillDescription"
+      : "overrideDefaultBrowserAutofillPrivacyRequiredDescription";
+    await this.dialogService.openSimpleDialog({
+      title: { key: "overrideDefaultBrowserAutofillTitle" },
+      content: { key: contentKey },
+      acceptButtonText: { key: "makeDefault" },
+      acceptAction: async () => await this.handleOverrideDialogAccept(),
+      cancelButtonText: { key: "ignore" },
+      type: "info",
+    });
+  }
+
+  async updateDefaultBrowserAutofillDisabled() {
+    const privacyPermissionGranted = await this.privacyPermissionGranted();
+    if (!this.defaultBrowserAutofillDisabled && !privacyPermissionGranted) {
+      return;
+    }
+
+    if (
+      !privacyPermissionGranted &&
+      !(await BrowserApi.requestPermission({ permissions: ["privacy"] }))
+    ) {
+      await this.dialogService.openSimpleDialog({
+        title: { key: "privacyPermissionAdditionNotGrantedTitle" },
+        content: { key: "privacyPermissionAdditionNotGrantedDescription" },
+        acceptButtonText: { key: "ok" },
+        cancelButtonText: null,
+        type: "warning",
+      });
+      this.defaultBrowserAutofillDisabled = false;
+
+      return;
+    }
+
+    BrowserApi.updateDefaultBrowserAutofillSettings(!this.defaultBrowserAutofillDisabled);
+  }
+
+  private handleOverrideDialogAccept = async () => {
+    this.defaultBrowserAutofillDisabled = true;
+    await this.updateDefaultBrowserAutofillDisabled();
+  };
+
+  async browserAutofillSettingCurrentlyOverridden() {
+    if (!this.canOverrideBrowserAutofillSetting) {
+      return false;
+    }
+
+    if (!(await this.privacyPermissionGranted())) {
+      return false;
+    }
+
+    return await BrowserApi.browserAutofillSettingsOverridden();
+  }
+
+  async privacyPermissionGranted(): Promise<boolean> {
+    return await BrowserApi.permissionsGranted(["privacy"]);
+  }
 }

apps/browser/src/autofill/services/autofill-constants.ts

@@ -65,6 +65,11 @@ export class AutoFillConstants {
     "checkbox",
     ...AutoFillConstants.ExcludedAutofillLoginTypes,
   ];
+
+  static readonly ExcludedOverlayTypes: string[] = [
+    "textarea",
+    ...AutoFillConstants.ExcludedAutofillTypes,
+  ];
 }
 
 export class CreditCardAutoFillConstants {

apps/browser/src/autofill/services/autofill-overlay-content.service.spec.ts

@@ -195,8 +195,8 @@ describe("AutofillOverlayContentService", () => {
         expect(autofillFieldElement.addEventListener).not.toHaveBeenCalled();
       });
 
-      it("ignores fields that are part of the ExcludedAutofillTypes", () => {
-        AutoFillConstants.ExcludedAutofillTypes.forEach((excludedType) => {
+      it("ignores fields that are part of the ExcludedOverlayTypes", () => {
+        AutoFillConstants.ExcludedOverlayTypes.forEach((excludedType) => {
           autofillFieldData.type = excludedType;
 
           autofillOverlayContentService.setupAutofillOverlayListenerOnField(

apps/browser/src/autofill/services/autofill-overlay-content.service.ts

@@ -32,6 +32,7 @@ class AutofillOverlayContentService implements AutofillOverlayContentServiceInte
   private readonly findTabs = tabbable;
   private readonly sendExtensionMessage = sendExtensionMessage;
   private formFieldElements: Set<ElementWithOpId<FormFieldElement>> = new Set([]);
+  private ignoredFieldTypes: Set<string> = new Set(AutoFillConstants.ExcludedOverlayTypes);
   private userFilledFields: Record<string, FillableFormFieldElement> = {};
   private authStatus: AuthenticationStatus;
   private focusableElements: FocusableElement[] = [];
@@ -715,12 +716,11 @@ class AutofillOverlayContentService implements AutofillOverlayContentServiceInte
    * @param autofillFieldData - Autofill field data captured from the form field element.
    */
   private isIgnoredField(autofillFieldData: AutofillField): boolean {
-    const ignoredFieldTypes = new Set(AutoFillConstants.ExcludedAutofillTypes);
     if (
       autofillFieldData.readonly ||
       autofillFieldData.disabled ||
       !autofillFieldData.viewable ||
-      ignoredFieldTypes.has(autofillFieldData.type) ||
+      this.ignoredFieldTypes.has(autofillFieldData.type) ||
       this.keywordsFoundInFieldData(autofillFieldData, ["search", "captcha"])
     ) {
       return true;

apps/browser/src/autofill/services/autofill.service.spec.ts

@@ -3,7 +3,6 @@ import { mock, mockReset } from "jest-mock-extended";
 import { UserVerificationService } from "@bitwarden/common/auth/services/user-verification/user-verification.service";
 import { EventType } from "@bitwarden/common/enums";
 import { LogService } from "@bitwarden/common/platform/abstractions/log.service";
-import { ConfigService } from "@bitwarden/common/platform/services/config/config.service";
 import { EventCollectionService } from "@bitwarden/common/services/event/event-collection.service";
 import { SettingsService } from "@bitwarden/common/services/settings.service";
 import {
@@ -56,7 +55,6 @@ describe("AutofillService", () => {
   const logService = mock<LogService>();
   const settingsService = mock<SettingsService>();
   const userVerificationService = mock<UserVerificationService>();
-  const configService = mock<ConfigService>();
 
   beforeEach(() => {
     autofillService = new AutofillService(
@@ -67,7 +65,6 @@ describe("AutofillService", () => {
       logService,
       settingsService,
       userVerificationService,
-      configService,
     );
   });
 

apps/browser/src/autofill/services/autofill.service.ts

@@ -2,7 +2,6 @@ import { EventCollectionService } from "@bitwarden/common/abstractions/event/eve
 import { SettingsService } from "@bitwarden/common/abstractions/settings.service";
 import { UserVerificationService } from "@bitwarden/common/auth/abstractions/user-verification/user-verification.service.abstraction";
 import { EventType } from "@bitwarden/common/enums";
-import { ConfigServiceAbstraction } from "@bitwarden/common/platform/abstractions/config/config.service.abstraction";
 import { LogService } from "@bitwarden/common/platform/abstractions/log.service";
 import { CipherService } from "@bitwarden/common/vault/abstractions/cipher.service";
 import { TotpService } from "@bitwarden/common/vault/abstractions/totp.service";
@@ -47,7 +46,6 @@ export default class AutofillService implements AutofillServiceInterface {
     private logService: LogService,
     private settingsService: SettingsService,
     private userVerificationService: UserVerificationService,
-    private configService: ConfigServiceAbstraction,
   ) {}
 
   /**

apps/browser/src/autofill/services/collect-autofill-content.service.spec.ts

@@ -1967,19 +1967,42 @@ describe("CollectAutofillContentService", () => {
   });
 
   describe("getShadowRoot", () => {
+    beforeEach(() => {
+      // eslint-disable-next-line
+      // @ts-ignore
+      globalThis.chrome.dom = {
+        openOrClosedShadowRoot: jest.fn(),
+      };
+    });
+
     it("returns null if the passed node is not an HTMLElement instance", () => {
       const textNode = document.createTextNode("Hello, world!");
       const shadowRoot = collectAutofillContentService["getShadowRoot"](textNode);
 
       expect(shadowRoot).toEqual(null);
     });
 
-    it("returns a value provided by Chrome's openOrClosedShadowRoot API", () => {
+    it("returns null if the passed node contains children elements", () => {
+      const element = document.createElement("div");
+      element.innerHTML = "<p>Hello, world!</p>";
+      const shadowRoot = collectAutofillContentService["getShadowRoot"](element);
+
       // eslint-disable-next-line
       // @ts-ignore
-      globalThis.chrome.dom = {
-        openOrClosedShadowRoot: jest.fn(),
-      };
+      expect(chrome.dom.openOrClosedShadowRoot).not.toBeCalled();
+      expect(shadowRoot).toEqual(null);
+    });
+
+    it("returns an open shadow root if the passed node has a shadowDOM element", () => {
+      const element = document.createElement("div");
+      element.attachShadow({ mode: "open" });
+
+      const shadowRoot = collectAutofillContentService["getShadowRoot"](element);
+
+      expect(shadowRoot).toBeInstanceOf(ShadowRoot);
+    });
+
+    it("returns a value provided by Chrome's openOrClosedShadowRoot API", () => {
       const element = document.createElement("div");
       collectAutofillContentService["getShadowRoot"](element);