Adding upstream version 115.7.0esr.upstream/115.7.0esrupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1359 insertions, 0 deletions

diff --git a/toolkit/components/satchel/nsFormFillController.cpp b/toolkit/components/satchel/nsFormFillController.cpp
new file mode 100644
index 0000000000..ba55e678d4
--- /dev/null
+++ b/toolkit/components/satchel/nsFormFillController.cpp
@@ -0,0 +1,1359 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#include "nsFormFillController.h"
+
+#include "mozilla/ClearOnShutdown.h"
+#include "mozilla/ErrorResult.h"
+#include "mozilla/EventListenerManager.h"
+#include "mozilla/dom/Document.h"
+#include "mozilla/dom/Element.h"
+#include "mozilla/dom/Event.h"  // for Event
+#include "mozilla/dom/HTMLDataListElement.h"
+#include "mozilla/dom/HTMLInputElement.h"
+#include "mozilla/dom/KeyboardEvent.h"
+#include "mozilla/dom/KeyboardEventBinding.h"
+#include "mozilla/dom/MouseEvent.h"
+#include "mozilla/dom/PageTransitionEvent.h"
+#include "mozilla/Logging.h"
+#include "mozilla/PresShell.h"
+#include "mozilla/Services.h"
+#include "mozilla/StaticPrefs_ui.h"
+#include "nsCRT.h"
+#include "nsIFormAutoComplete.h"
+#include "nsIInputListAutoComplete.h"
+#include "nsString.h"
+#include "nsPIDOMWindow.h"
+#include "nsIAutoCompleteResult.h"
+#include "nsIContent.h"
+#include "nsInterfaceHashtable.h"
+#include "nsContentUtils.h"
+#include "nsGenericHTMLElement.h"
+#include "nsILoadContext.h"
+#include "nsIFrame.h"
+#include "nsIScriptSecurityManager.h"
+#include "nsFocusManager.h"
+#include "nsQueryActor.h"
+#include "nsQueryObject.h"
+#include "nsServiceManagerUtils.h"
+#include "xpcpublic.h"
+
+using namespace mozilla;
+using namespace mozilla::dom;
+using mozilla::ErrorResult;
+using mozilla::LogLevel;
+
+static mozilla::LazyLogModule sLogger("satchel");
+
+static nsIFormAutoComplete* GetFormAutoComplete() {
+  static nsCOMPtr<nsIFormAutoComplete> sInstance;
+  static bool sInitialized = false;
+  if (!sInitialized) {
+    nsresult rv;
+    sInstance = do_GetService("@mozilla.org/satchel/form-autocomplete;1", &rv);
+
+    if (NS_SUCCEEDED(rv)) {
+      ClearOnShutdown(&sInstance);
+      sInitialized = true;
+    }
+  }
+  return sInstance;
+}
+
+NS_IMPL_CYCLE_COLLECTION(nsFormFillController, mController, mLoginManagerAC,
+                         mLoginReputationService, mFocusedPopup, mPopups,
+                         mLastListener, mLastFormAutoComplete)
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsFormFillController)
+  NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIFormFillController)
+  NS_INTERFACE_MAP_ENTRY(nsIFormFillController)
+  NS_INTERFACE_MAP_ENTRY(nsIAutoCompleteInput)
+  NS_INTERFACE_MAP_ENTRY(nsIAutoCompleteSearch)
+  NS_INTERFACE_MAP_ENTRY(nsIFormAutoCompleteObserver)
+  NS_INTERFACE_MAP_ENTRY(nsIDOMEventListener)
+  NS_INTERFACE_MAP_ENTRY(nsIObserver)
+  NS_INTERFACE_MAP_ENTRY(nsIMutationObserver)
+NS_INTERFACE_MAP_END
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(nsFormFillController)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(nsFormFillController)
+
+nsFormFillController::nsFormFillController()
+    : mFocusedInput(nullptr),
+      mListNode(nullptr),
+      // The amount of time a context menu event supresses showing a
+      // popup from a focus event in ms. This matches the threshold in
+      // toolkit/components/passwordmgr/LoginManagerChild.jsm.
+      mFocusAfterRightClickThreshold(400),
+      mTimeout(50),
+      mMinResultsForPopup(1),
+      mMaxRows(0),
+      mLastRightClickTimeStamp(TimeStamp()),
+      mDisableAutoComplete(false),
+      mCompleteDefaultIndex(false),
+      mCompleteSelectedIndex(false),
+      mForceComplete(false),
+      mSuppressOnInput(false),
+      mPasswordPopupAutomaticallyOpened(false) {
+  mController = do_GetService("@mozilla.org/autocomplete/controller;1");
+  MOZ_ASSERT(mController);
+
+  nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
+  MOZ_ASSERT(obs);
+
+  obs->AddObserver(this, "chrome-event-target-created", false);
+  obs->AddObserver(this, "autofill-fill-starting", false);
+  obs->AddObserver(this, "autofill-fill-complete", false);
+}
+
+nsFormFillController::~nsFormFillController() {
+  if (mListNode) {
+    mListNode->RemoveMutationObserver(this);
+    mListNode = nullptr;
+  }
+  if (mFocusedInput) {
+    MaybeRemoveMutationObserver(mFocusedInput);
+    mFocusedInput = nullptr;
+  }
+  RemoveForDocument(nullptr);
+}
+
+/* static */
+already_AddRefed<nsFormFillController> nsFormFillController::GetSingleton() {
+  static RefPtr<nsFormFillController> sSingleton;
+  if (!sSingleton) {
+    sSingleton = new nsFormFillController();
+    ClearOnShutdown(&sSingleton);
+  }
+  return do_AddRef(sSingleton);
+}
+
+////////////////////////////////////////////////////////////////////////
+//// nsIMutationObserver
+//
+
+MOZ_CAN_RUN_SCRIPT_BOUNDARY
+void nsFormFillController::AttributeChanged(mozilla::dom::Element* aElement,
+                                            int32_t aNameSpaceID,
+                                            nsAtom* aAttribute,
+                                            int32_t aModType,
+                                            const nsAttrValue* aOldValue) {
+  if ((aAttribute == nsGkAtoms::type || aAttribute == nsGkAtoms::readonly ||
+       aAttribute == nsGkAtoms::autocomplete) &&
+      aNameSpaceID == kNameSpaceID_None) {
+    RefPtr<HTMLInputElement> focusedInput(mFocusedInput);
+    // Reset the current state of the controller, unconditionally.
+    StopControllingInput();
+    // Then restart based on the new values.  We have to delay this
+    // to avoid ending up in an endless loop due to re-registering our
+    // mutation observer (which would notify us again for *this* event).
+    nsCOMPtr<nsIRunnable> event =
+        mozilla::NewRunnableMethod<RefPtr<HTMLInputElement>>(
+            "nsFormFillController::MaybeStartControllingInput", this,
+            &nsFormFillController::MaybeStartControllingInput, focusedInput);
+    aElement->OwnerDoc()->Dispatch(TaskCategory::Other, event.forget());
+  }
+
+  if (mListNode && mListNode->Contains(aElement)) {
+    RevalidateDataList();
+  }
+}
+
+MOZ_CAN_RUN_SCRIPT_BOUNDARY
+void nsFormFillController::ContentAppended(nsIContent* aChild) {
+  if (mListNode && mListNode->Contains(aChild->GetParent())) {
+    RevalidateDataList();
+  }
+}
+
+MOZ_CAN_RUN_SCRIPT_BOUNDARY
+void nsFormFillController::ContentInserted(nsIContent* aChild) {
+  if (mListNode && mListNode->Contains(aChild->GetParent())) {
+    RevalidateDataList();
+  }
+}
+
+MOZ_CAN_RUN_SCRIPT_BOUNDARY
+void nsFormFillController::ContentRemoved(nsIContent* aChild,
+                                          nsIContent* aPreviousSibling) {
+  if (mListNode && mListNode->Contains(aChild->GetParent())) {
+    RevalidateDataList();
+  }
+}
+
+void nsFormFillController::CharacterDataWillChange(
+    nsIContent* aContent, const CharacterDataChangeInfo&) {}
+
+void nsFormFillController::CharacterDataChanged(
+    nsIContent* aContent, const CharacterDataChangeInfo&) {}
+
+void nsFormFillController::AttributeWillChange(mozilla::dom::Element* aElement,
+                                               int32_t aNameSpaceID,
+                                               nsAtom* aAttribute,
+                                               int32_t aModType) {}
+
+void nsFormFillController::ParentChainChanged(nsIContent* aContent) {}
+
+void nsFormFillController::ARIAAttributeDefaultWillChange(
+    mozilla::dom::Element* aElement, nsAtom* aAttribute, int32_t aModType) {}
+
+void nsFormFillController::ARIAAttributeDefaultChanged(
+    mozilla::dom::Element* aElement, nsAtom* aAttribute, int32_t aModType) {}
+
+MOZ_CAN_RUN_SCRIPT_BOUNDARY
+void nsFormFillController::NodeWillBeDestroyed(nsINode* aNode) {
+  MOZ_LOG(sLogger, LogLevel::Verbose, ("NodeWillBeDestroyed: %p", aNode));
+  mPwmgrInputs.Remove(aNode);
+  mAutofillInputs.Remove(aNode);
+  MaybeRemoveMutationObserver(aNode);
+  if (aNode == mListNode) {
+    mListNode = nullptr;
+    RevalidateDataList();
+  } else if (aNode == mFocusedInput) {
+    mFocusedInput = nullptr;
+  }
+}
+
+void nsFormFillController::MaybeRemoveMutationObserver(nsINode* aNode) {
+  // Nodes being tracked in mPwmgrInputs will have their observers removed when
+  // they stop being tracked.
+  if (!mPwmgrInputs.Get(aNode) && !mAutofillInputs.Get(aNode)) {
+    aNode->RemoveMutationObserver(this);
+  }
+}
+
+////////////////////////////////////////////////////////////////////////
+//// nsIFormFillController
+
+NS_IMETHODIMP
+nsFormFillController::AttachPopupElementToDocument(Document* aDocument,
+                                                   dom::Element* aPopupEl) {
+  if (!xpc::IsInAutomation()) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  MOZ_LOG(sLogger, LogLevel::Debug,
+          ("AttachPopupElementToDocument for document %p with popup %p",
+           aDocument, aPopupEl));
+  NS_ENSURE_TRUE(aDocument && aPopupEl, NS_ERROR_ILLEGAL_VALUE);
+
+  nsCOMPtr<nsIAutoCompletePopup> popup = aPopupEl->AsAutoCompletePopup();
+  NS_ENSURE_STATE(popup);
+
+  mPopups.InsertOrUpdate(aDocument, popup);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsFormFillController::DetachFromDocument(Document* aDocument) {
+  if (!xpc::IsInAutomation()) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+  mPopups.Remove(aDocument);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsFormFillController::MarkAsLoginManagerField(HTMLInputElement* aInput) {
+  /*
+   * The Login Manager can supply autocomplete results for username fields,
+   * when a user has multiple logins stored for a site. It uses this
+   * interface to indicate that the form manager shouldn't handle the
+   * autocomplete. The form manager also checks for this tag when saving
+   * form history (so it doesn't save usernames).
+   */
+  NS_ENSURE_STATE(aInput);
+
+  // If the field was already marked, we don't want to show the popup again.
+  if (mPwmgrInputs.Get(aInput)) {
+    return NS_OK;
+  }
+
+  mPwmgrInputs.InsertOrUpdate(aInput, true);
+  aInput->AddMutationObserverUnlessExists(this);
+
+  nsFocusManager* fm = nsFocusManager::GetFocusManager();
+  if (fm) {
+    nsCOMPtr<nsIContent> focusedContent = fm->GetFocusedElement();
+    if (focusedContent == aInput) {
+      if (!mFocusedInput) {
+        MaybeStartControllingInput(aInput);
+      } else {
+        // If we change who is responsible for searching the autocomplete
+        // result, notify the controller that the previous result is not valid
+        // anymore.
+        nsCOMPtr<nsIAutoCompleteController> controller = mController;
+        controller->ResetInternalState();
+      }
+    }
+  }
+
+  if (!mLoginManagerAC) {
+    mLoginManagerAC =
+        do_GetService("@mozilla.org/login-manager/autocompletesearch;1");
+  }
+
+  return NS_OK;
+}
+
+MOZ_CAN_RUN_SCRIPT NS_IMETHODIMP nsFormFillController::IsLoginManagerField(
+    HTMLInputElement* aInput, bool* isLoginManagerField) {
+  *isLoginManagerField = mPwmgrInputs.Get(aInput);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsFormFillController::MarkAsAutofillField(HTMLInputElement* aInput) {
+  /*
+   * Support other components implementing form autofill and handle autocomplete
+   * for the field.
+   */
+  NS_ENSURE_STATE(aInput);
+
+  MOZ_LOG(sLogger, LogLevel::Verbose,
+          ("MarkAsAutofillField: aInput = %p", aInput));
+
+  if (mAutofillInputs.Get(aInput)) {
+    return NS_OK;
+  }
+
+  mAutofillInputs.InsertOrUpdate(aInput, true);
+  aInput->AddMutationObserverUnlessExists(this);
+
+  aInput->EnablePreview();
+
+  nsFocusManager* fm = nsFocusManager::GetFocusManager();
+  if (fm) {
+    nsCOMPtr<nsIContent> focusedContent = fm->GetFocusedElement();
+    if (focusedContent == aInput) {
+      if (!mFocusedInput) {
+        MaybeStartControllingInput(aInput);
+      } else {
+        // See `MarkAsLoginManagerField` for why this is needed.
+        nsCOMPtr<nsIAutoCompleteController> controller = mController;
+        controller->ResetInternalState();
+      }
+    }
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsFormFillController::GetFocusedInput(HTMLInputElement** aInput) {
+  *aInput = mFocusedInput;
+  NS_IF_ADDREF(*aInput);
+  return NS_OK;
+}
+
+////////////////////////////////////////////////////////////////////////
+//// nsIAutoCompleteInput
+
+NS_IMETHODIMP
+nsFormFillController::GetPopup(nsIAutoCompletePopup** aPopup) {
+  *aPopup = mFocusedPopup;
+  NS_IF_ADDREF(*aPopup);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsFormFillController::GetPopupElement(Element** aPopup) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+nsFormFillController::GetController(nsIAutoCompleteController** aController) {
+  *aController = mController;
+  NS_IF_ADDREF(*aController);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsFormFillController::GetPopupOpen(bool* aPopupOpen) {
+  if (mFocusedPopup) {
+    mFocusedPopup->GetPopupOpen(aPopupOpen);
+  } else {
+    *aPopupOpen = false;
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsFormFillController::SetPopupOpen(bool aPopupOpen) {
+  if (mFocusedPopup) {
+    if (aPopupOpen) {
+      // make sure input field is visible before showing popup (bug 320938)
+      nsCOMPtr<nsIContent> content = mFocusedInput;
+      NS_ENSURE_STATE(content);
+      nsCOMPtr<nsIDocShell> docShell = GetDocShellForInput(mFocusedInput);
+      NS_ENSURE_STATE(docShell);
+      RefPtr<PresShell> presShell = docShell->GetPresShell();
+      NS_ENSURE_STATE(presShell);
+      presShell->ScrollContentIntoView(
+          content,
+          ScrollAxis(WhereToScroll::Nearest, WhenToScroll::IfNotVisible),
+          ScrollAxis(WhereToScroll::Nearest, WhenToScroll::IfNotVisible),
+          ScrollFlags::ScrollOverflowHidden);
+      // mFocusedPopup can be destroyed after ScrollContentIntoView, see bug
+      // 420089
+      if (mFocusedPopup) {
+        mFocusedPopup->OpenAutocompletePopup(this, mFocusedInput);
+      }
+    } else {
+      mFocusedPopup->ClosePopup();
+      mPasswordPopupAutomaticallyOpened = false;
+    }
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsFormFillController::GetDisableAutoComplete(bool* aDisableAutoComplete) {
+  *aDisableAutoComplete = mDisableAutoComplete;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsFormFillController::SetDisableAutoComplete(bool aDisableAutoComplete) {
+  mDisableAutoComplete = aDisableAutoComplete;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsFormFillController::GetCompleteDefaultIndex(bool* aCompleteDefaultIndex) {
+  *aCompleteDefaultIndex = mCompleteDefaultIndex;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsFormFillController::SetCompleteDefaultIndex(bool aCompleteDefaultIndex) {
+  mCompleteDefaultIndex = aCompleteDefaultIndex;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsFormFillController::GetCompleteSelectedIndex(bool* aCompleteSelectedIndex) {
+  *aCompleteSelectedIndex = mCompleteSelectedIndex;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsFormFillController::SetCompleteSelectedIndex(bool aCompleteSelectedIndex) {
+  mCompleteSelectedIndex = aCompleteSelectedIndex;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsFormFillController::GetForceComplete(bool* aForceComplete) {
+  *aForceComplete = mForceComplete;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsFormFillController::SetForceComplete(bool aForceComplete) {
+  mForceComplete = aForceComplete;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsFormFillController::GetMinResultsForPopup(uint32_t* aMinResultsForPopup) {
+  *aMinResultsForPopup = mMinResultsForPopup;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsFormFillController::SetMinResultsForPopup(
+    uint32_t aMinResultsForPopup) {
+  mMinResultsForPopup = aMinResultsForPopup;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsFormFillController::GetMaxRows(uint32_t* aMaxRows) {
+  *aMaxRows = mMaxRows;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsFormFillController::SetMaxRows(uint32_t aMaxRows) {
+  mMaxRows = aMaxRows;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsFormFillController::GetTimeout(uint32_t* aTimeout) {
+  *aTimeout = mTimeout;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsFormFillController::SetTimeout(uint32_t aTimeout) {
+  mTimeout = aTimeout;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsFormFillController::SetSearchParam(const nsAString& aSearchParam) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+nsFormFillController::GetSearchParam(nsAString& aSearchParam) {
+  if (!mFocusedInput) {
+    NS_WARNING(
+        "mFocusedInput is null for some reason! avoiding a crash. should find "
+        "out why... - ben");
+    return NS_ERROR_FAILURE;  // XXX why? fix me.
+  }
+
+  mFocusedInput->GetName(aSearchParam);
+  if (aSearchParam.IsEmpty()) {
+    mFocusedInput->GetId(aSearchParam);
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsFormFillController::GetSearchCount(uint32_t* aSearchCount) {
+  *aSearchCount = 1;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsFormFillController::GetSearchAt(uint32_t index, nsACString& _retval) {
+  if (mAutofillInputs.Get(mFocusedInput)) {
+    MOZ_LOG(sLogger, LogLevel::Debug, ("GetSearchAt: autofill-profiles field"));
+    nsCOMPtr<nsIAutoCompleteSearch> profileSearch = do_GetService(
+        "@mozilla.org/autocomplete/search;1?name=autofill-profiles");
+    if (profileSearch) {
+      _retval.AssignLiteral("autofill-profiles");
+      return NS_OK;
+    }
+  }
+
+  MOZ_LOG(sLogger, LogLevel::Debug, ("GetSearchAt: form-history field"));
+  _retval.AssignLiteral("form-history");
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsFormFillController::GetTextValue(nsAString& aTextValue) {
+  if (mFocusedInput) {
+    mFocusedInput->GetValue(aTextValue, CallerType::System);
+  } else {
+    aTextValue.Truncate();
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsFormFillController::SetTextValue(const nsAString& aTextValue) {
+  if (mFocusedInput) {
+    mSuppressOnInput = true;
+    mFocusedInput->SetUserInput(aTextValue,
+                                *nsContentUtils::GetSystemPrincipal());
+    mSuppressOnInput = false;
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsFormFillController::GetSelectionStart(int32_t* aSelectionStart) {
+  if (!mFocusedInput) {
+    return NS_ERROR_UNEXPECTED;
+  }
+  ErrorResult rv;
+  *aSelectionStart = mFocusedInput->GetSelectionStartIgnoringType(rv);
+  return rv.StealNSResult();
+}
+
+NS_IMETHODIMP
+nsFormFillController::GetSelectionEnd(int32_t* aSelectionEnd) {
+  if (!mFocusedInput) {
+    return NS_ERROR_UNEXPECTED;
+  }
+  ErrorResult rv;
+  *aSelectionEnd = mFocusedInput->GetSelectionEndIgnoringType(rv);
+  return rv.StealNSResult();
+}
+
+MOZ_CAN_RUN_SCRIPT_BOUNDARY NS_IMETHODIMP
+nsFormFillController::SelectTextRange(int32_t aStartIndex, int32_t aEndIndex) {
+  if (!mFocusedInput) {
+    return NS_ERROR_UNEXPECTED;
+  }
+  RefPtr<HTMLInputElement> focusedInput(mFocusedInput);
+  ErrorResult rv;
+  focusedInput->SetSelectionRange(aStartIndex, aEndIndex, Optional<nsAString>(),
+                                  rv);
+  return rv.StealNSResult();
+}
+
+NS_IMETHODIMP
+nsFormFillController::OnSearchBegin() { return NS_OK; }
+
+NS_IMETHODIMP
+nsFormFillController::OnSearchComplete() { return NS_OK; }
+
+NS_IMETHODIMP
+nsFormFillController::OnTextEntered(Event* aEvent, bool itemWasSelected,
+                                    bool* aPrevent) {
+  NS_ENSURE_ARG(aPrevent);
+  NS_ENSURE_TRUE(mFocusedInput, NS_OK);
+
+  /**
+   * This function can get called when text wasn't actually entered
+   * into the field (e.g. if an autocomplete item wasn't selected) so
+   * we don't fire DOMAutoComplete in that case since nothing
+   * was actually autocompleted.
+   */
+  if (!itemWasSelected) {
+    return NS_OK;
+  }
+
+  // Fire off a DOMAutoComplete event
+
+  IgnoredErrorResult ignored;
+  RefPtr<Event> event = mFocusedInput->OwnerDoc()->CreateEvent(
+      u"Events"_ns, CallerType::System, ignored);
+  NS_ENSURE_STATE(event);
+
+  event->InitEvent(u"DOMAutoComplete"_ns, true, true);
+
+  // XXXjst: We mark this event as a trusted event, it's up to the
+  // callers of this to ensure that it's only called from trusted
+  // code.
+  event->SetTrusted(true);
+
+  bool defaultActionEnabled =
+      mFocusedInput->DispatchEvent(*event, CallerType::System, IgnoreErrors());
+  *aPrevent = !defaultActionEnabled;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsFormFillController::OnTextReverted(bool* _retval) {
+  mPasswordPopupAutomaticallyOpened = false;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsFormFillController::GetConsumeRollupEvent(bool* aConsumeRollupEvent) {
+  *aConsumeRollupEvent = false;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsFormFillController::GetInPrivateContext(bool* aInPrivateContext) {
+  if (!mFocusedInput) {
+    *aInPrivateContext = false;
+    return NS_OK;
+  }
+
+  RefPtr<Document> doc = mFocusedInput->OwnerDoc();
+  nsCOMPtr<nsILoadContext> loadContext = doc->GetLoadContext();
+  *aInPrivateContext = loadContext && loadContext->UsePrivateBrowsing();
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsFormFillController::GetNoRollupOnCaretMove(bool* aNoRollupOnCaretMove) {
+  *aNoRollupOnCaretMove = false;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsFormFillController::GetNoRollupOnEmptySearch(bool* aNoRollupOnEmptySearch) {
+  if (mFocusedInput && (mPwmgrInputs.Get(mFocusedInput) ||
+                        mFocusedInput->HasBeenTypePassword())) {
+    // Don't close the login popup when the field is cleared (bug 1534896).
+    *aNoRollupOnEmptySearch = true;
+  } else {
+    *aNoRollupOnEmptySearch = false;
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsFormFillController::GetUserContextId(uint32_t* aUserContextId) {
+  *aUserContextId = nsIScriptSecurityManager::DEFAULT_USER_CONTEXT_ID;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsFormFillController::GetInvalidatePreviousResult(
+    bool* aInvalidatePreviousResult) {
+  *aInvalidatePreviousResult = mInvalidatePreviousResult;
+  return NS_OK;
+}
+
+////////////////////////////////////////////////////////////////////////
+//// nsIAutoCompleteSearch
+
+NS_IMETHODIMP
+nsFormFillController::StartSearch(const nsAString& aSearchString,
+                                  const nsAString& aSearchParam,
+                                  nsIAutoCompleteResult* aPreviousResult,
+                                  nsIAutoCompleteObserver* aListener,
+                                  nsIPropertyBag2* aOptions) {
+  MOZ_LOG(sLogger, LogLevel::Debug, ("StartSearch for %p", mFocusedInput));
+
+  nsresult rv;
+
+  // If the login manager has indicated it's responsible for this field, let it
+  // handle the autocomplete. Otherwise, handle with form history.
+  // This method is sometimes called in unit tests and from XUL without a
+  // focused node.
+  if (mFocusedInput && (mPwmgrInputs.Get(mFocusedInput) ||
+                        mFocusedInput->HasBeenTypePassword())) {
+    MOZ_LOG(sLogger, LogLevel::Debug, ("StartSearch: login field"));
+
+    // Handle the case where a password field is focused but
+    // MarkAsLoginManagerField wasn't called because password manager is
+    // disabled.
+    if (!mLoginManagerAC) {
+      mLoginManagerAC =
+          do_GetService("@mozilla.org/login-manager/autocompletesearch;1");
+    }
+
+    if (NS_WARN_IF(!mLoginManagerAC)) {
+      return NS_ERROR_FAILURE;
+    }
+
+    // XXX aPreviousResult shouldn't ever be a historyResult type, since we're
+    // not letting satchel manage the field?
+    mLastListener = aListener;
+    rv = mLoginManagerAC->StartSearch(aSearchString, aPreviousResult,
+                                      mFocusedInput, this);
+    NS_ENSURE_SUCCESS(rv, rv);
+  } else {
+    MOZ_LOG(sLogger, LogLevel::Debug, ("StartSearch: non-login field"));
+    mLastListener = aListener;
+
+    nsCOMPtr<nsIAutoCompleteResult> datalistResult;
+    if (IsTextControl(mFocusedInput)) {
+      rv = PerformInputListAutoComplete(aSearchString,
+                                        getter_AddRefs(datalistResult));
+      NS_ENSURE_SUCCESS(rv, rv);
+    }
+
+    auto formAutoComplete = GetFormAutoComplete();
+    NS_ENSURE_TRUE(formAutoComplete, NS_ERROR_FAILURE);
+
+    formAutoComplete->AutoCompleteSearchAsync(aSearchParam, aSearchString,
+                                              mFocusedInput, aPreviousResult,
+                                              datalistResult, this, aOptions);
+    mLastFormAutoComplete = formAutoComplete;
+  }
+
+  return NS_OK;
+}
+
+nsresult nsFormFillController::PerformInputListAutoComplete(
+    const nsAString& aSearch, nsIAutoCompleteResult** aResult) {
+  // If an <input> is focused, check if it has a list="<datalist>" which can
+  // provide the list of suggestions.
+
+  MOZ_ASSERT(!mPwmgrInputs.Get(mFocusedInput));
+  nsresult rv;
+
+  nsCOMPtr<nsIInputListAutoComplete> inputListAutoComplete =
+      do_GetService("@mozilla.org/satchel/inputlist-autocomplete;1", &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = inputListAutoComplete->AutoCompleteSearch(aSearch, mFocusedInput,
+                                                 aResult);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (mFocusedInput) {
+    Element* list = mFocusedInput->GetList();
+
+    // Add a mutation observer to check for changes to the items in the
+    // <datalist> and update the suggestions accordingly.
+    if (mListNode != list) {
+      if (mListNode) {
+        mListNode->RemoveMutationObserver(this);
+        mListNode = nullptr;
+      }
+      if (list) {
+        list->AddMutationObserverUnlessExists(this);
+        mListNode = list;
+      }
+    }
+  }
+
+  return NS_OK;
+}
+
+void nsFormFillController::RevalidateDataList() {
+  if (!mLastListener) {
+    return;
+  }
+
+  nsCOMPtr<nsIAutoCompleteController> controller(
+      do_QueryInterface(mLastListener));
+  if (!controller) {
+    return;
+  }
+
+  // We cannot use previous result since any items in search target are updated.
+  mInvalidatePreviousResult = true;
+  controller->StartSearch(mLastSearchString);
+}
+
+NS_IMETHODIMP
+nsFormFillController::StopSearch() {
+  // Make sure to stop and clear this, otherwise the controller will prevent
+  // mLastFormAutoComplete from being deleted.
+  if (mLastFormAutoComplete) {
+    mLastFormAutoComplete->StopAutoCompleteSearch();
+    mLastFormAutoComplete = nullptr;
+  }
+
+  if (mLoginManagerAC) {
+    mLoginManagerAC->StopSearch();
+  }
+  return NS_OK;
+}
+
+nsresult nsFormFillController::StartQueryLoginReputation(
+    HTMLInputElement* aInput) {
+  return NS_OK;
+}
+
+////////////////////////////////////////////////////////////////////////
+//// nsIFormAutoCompleteObserver
+
+NS_IMETHODIMP
+nsFormFillController::OnSearchCompletion(nsIAutoCompleteResult* aResult) {
+  nsAutoString searchString;
+  aResult->GetSearchString(searchString);
+
+  mLastSearchString = searchString;
+
+  if (mLastListener) {
+    nsCOMPtr<nsIAutoCompleteObserver> lastListener = mLastListener;
+    lastListener->OnSearchResult(this, aResult);
+  }
+
+  return NS_OK;
+}
+
+////////////////////////////////////////////////////////////////////////
+//// nsIObserver
+
+NS_IMETHODIMP
+nsFormFillController::Observe(nsISupports* aSubject, const char* aTopic,
+                              const char16_t* aData) {
+  if (!nsCRT::strcmp(aTopic, "chrome-event-target-created")) {
+    if (RefPtr<EventTarget> eventTarget = do_QueryObject(aSubject)) {
+      AttachListeners(eventTarget);
+    }
+  } else if (!nsCRT::strcmp(aTopic, "autofill-fill-starting")) {
+    mAutoCompleteActive = true;
+  } else if (!nsCRT::strcmp(aTopic, "autofill-fill-complete")) {
+    mAutoCompleteActive = false;
+  }
+  return NS_OK;
+}
+
+////////////////////////////////////////////////////////////////////////
+//// nsIDOMEventListener
+
+NS_IMETHODIMP
+nsFormFillController::HandleEvent(Event* aEvent) {
+  EventTarget* target = aEvent->GetOriginalTarget();
+  NS_ENSURE_STATE(target);
+
+  mInvalidatePreviousResult = false;
+
+  nsIGlobalObject* global = target->GetOwnerGlobal();
+  NS_ENSURE_STATE(global);
+  nsPIDOMWindowInner* inner = global->AsInnerWindow();
+  NS_ENSURE_STATE(inner);
+
+  if (!inner->GetBrowsingContext()->IsContent()) {
+    return NS_OK;
+  }
+
+  if (aEvent->ShouldIgnoreChromeEventTargetListener()) {
+    return NS_OK;
+  }
+
+  WidgetEvent* internalEvent = aEvent->WidgetEventPtr();
+  NS_ENSURE_STATE(internalEvent);
+
+  switch (internalEvent->mMessage) {
+    case eFocus:
+      return Focus(aEvent);
+    case eMouseDown:
+      return MouseDown(aEvent);
+    case eKeyDown:
+      return KeyDown(aEvent);
+    case eEditorInput: {
+      if (!(mAutoCompleteActive || mSuppressOnInput)) {
+        nsCOMPtr<nsINode> input =
+            do_QueryInterface(aEvent->GetComposedTarget());
+        if (IsTextControl(input) && IsFocusedInputControlled()) {
+          nsCOMPtr<nsIAutoCompleteController> controller = mController;
+          bool unused = false;
+          return controller->HandleText(&unused);
+        }
+      }
+      return NS_OK;
+    }
+    case eBlur:
+      if (mFocusedInput && !StaticPrefs::ui_popup_disable_autohide()) {
+        StopControllingInput();
+      }
+      return NS_OK;
+    case eCompositionStart:
+      NS_ASSERTION(mController, "should have a controller!");
+      if (IsFocusedInputControlled()) {
+        nsCOMPtr<nsIAutoCompleteController> controller = mController;
+        controller->HandleStartComposition();
+      }
+      return NS_OK;
+    case eCompositionEnd:
+      NS_ASSERTION(mController, "should have a controller!");
+      if (IsFocusedInputControlled()) {
+        nsCOMPtr<nsIAutoCompleteController> controller = mController;
+        controller->HandleEndComposition();
+      }
+      return NS_OK;
+    case eContextMenu:
+      if (mFocusedPopup) {
+        mFocusedPopup->ClosePopup();
+      }
+      return NS_OK;
+    case ePageHide: {
+      nsCOMPtr<Document> doc = do_QueryInterface(aEvent->GetTarget());
+      if (!doc) {
+        return NS_OK;
+      }
+
+      if (mFocusedInput && doc == mFocusedInput->OwnerDoc()) {
+        StopControllingInput();
+      }
+
+      // Only remove the observer notifications and marked autofill and password
+      // manager fields if the page isn't going to be persisted (i.e. it's being
+      // unloaded) so that appropriate autocomplete handling works with bfcache.
+      bool persisted = aEvent->AsPageTransitionEvent()->Persisted();
+      if (!persisted) {
+        RemoveForDocument(doc);
+      }
+    } break;
+    default:
+      // Handling the default case to shut up stupid -Wswitch warnings.
+      // One day compilers will be smarter...
+      break;
+  }
+
+  return NS_OK;
+}
+
+void nsFormFillController::AttachListeners(EventTarget* aEventTarget) {
+  EventListenerManager* elm = aEventTarget->GetOrCreateListenerManager();
+  NS_ENSURE_TRUE_VOID(elm);
+
+  elm->AddEventListenerByType(this, u"focus"_ns, TrustedEventsAtCapture());
+  elm->AddEventListenerByType(this, u"blur"_ns, TrustedEventsAtCapture());
+  elm->AddEventListenerByType(this, u"pagehide"_ns, TrustedEventsAtCapture());
+  elm->AddEventListenerByType(this, u"mousedown"_ns, TrustedEventsAtCapture());
+  elm->AddEventListenerByType(this, u"input"_ns, TrustedEventsAtCapture());
+  elm->AddEventListenerByType(this, u"keydown"_ns, TrustedEventsAtCapture());
+  elm->AddEventListenerByType(this, u"keypress"_ns,
+                              TrustedEventsAtSystemGroupCapture());
+  elm->AddEventListenerByType(this, u"compositionstart"_ns,
+                              TrustedEventsAtCapture());
+  elm->AddEventListenerByType(this, u"compositionend"_ns,
+                              TrustedEventsAtCapture());
+  elm->AddEventListenerByType(this, u"contextmenu"_ns,
+                              TrustedEventsAtCapture());
+}
+
+void nsFormFillController::RemoveForDocument(Document* aDoc) {
+  MOZ_LOG(sLogger, LogLevel::Verbose, ("RemoveForDocument: %p", aDoc));
+  for (auto iter = mPwmgrInputs.Iter(); !iter.Done(); iter.Next()) {
+    const nsINode* key = iter.Key();
+    if (key && (!aDoc || key->OwnerDoc() == aDoc)) {
+      // mFocusedInput's observer is tracked separately, so don't remove it
+      // here.
+      if (key != mFocusedInput) {
+        const_cast<nsINode*>(key)->RemoveMutationObserver(this);
+      }
+      iter.Remove();
+    }
+  }
+
+  for (auto iter = mAutofillInputs.Iter(); !iter.Done(); iter.Next()) {
+    const nsINode* key = iter.Key();
+    if (key && (!aDoc || key->OwnerDoc() == aDoc)) {
+      // mFocusedInput's observer is tracked separately, so don't remove it
+      // here.
+      if (key != mFocusedInput) {
+        const_cast<nsINode*>(key)->RemoveMutationObserver(this);
+      }
+      iter.Remove();
+    }
+  }
+}
+
+bool nsFormFillController::IsTextControl(nsINode* aNode) {
+  nsCOMPtr<nsIFormControl> formControl = do_QueryInterface(aNode);
+  return formControl && formControl->IsSingleLineTextControl(false);
+}
+
+void nsFormFillController::MaybeStartControllingInput(
+    HTMLInputElement* aInput) {
+  MOZ_LOG(sLogger, LogLevel::Verbose,
+          ("MaybeStartControllingInput for %p", aInput));
+  if (!aInput) {
+    return;
+  }
+
+  bool hasList = !!aInput->GetList();
+
+  if (!IsTextControl(aInput)) {
+    // Even if this is not a text control yet, it can become one in the future
+    if (hasList) {
+      StartControllingInput(aInput);
+    }
+    return;
+  }
+
+  bool autocomplete = nsContentUtils::IsAutocompleteEnabled(aInput);
+
+  bool isPwmgrInput = false;
+  if (mPwmgrInputs.Get(aInput) || aInput->HasBeenTypePassword()) {
+    isPwmgrInput = true;
+  }
+
+  bool isAutofillInput = false;
+  if (mAutofillInputs.Get(aInput)) {
+    isAutofillInput = true;
+  }
+
+  if (isAutofillInput || isPwmgrInput || hasList || autocomplete) {
+    StartControllingInput(aInput);
+  }
+
+#ifdef NIGHTLY_BUILD
+  // Trigger an asynchronous login reputation query when user focuses on the
+  // password field.
+  if (aInput->HasBeenTypePassword()) {
+    StartQueryLoginReputation(aInput);
+  }
+#endif
+}
+
+nsresult nsFormFillController::HandleFocus(HTMLInputElement* aInput) {
+  MaybeStartControllingInput(aInput);
+
+  // Bail if we didn't start controlling the input.
+  if (!mFocusedInput) {
+    return NS_OK;
+  }
+
+  // If this focus doesn't follow a right click within our specified
+  // threshold then show the autocomplete popup for all password fields.
+  // This is done to avoid showing both the context menu and the popup
+  // at the same time.
+  // We use a timestamp instead of a bool to avoid complexity when dealing with
+  // multiple input forms and the fact that a mousedown into an already focused
+  // field does not trigger another focus.
+
+  if (!mFocusedInput->HasBeenTypePassword()) {
+    return NS_OK;
+  }
+
+  // If we have not seen a right click yet, just show the popup.
+  if (mLastRightClickTimeStamp.IsNull()) {
+    mPasswordPopupAutomaticallyOpened = true;
+    ShowPopup();
+    return NS_OK;
+  }
+
+  uint64_t timeDiff =
+      (TimeStamp::Now() - mLastRightClickTimeStamp).ToMilliseconds();
+  if (timeDiff > mFocusAfterRightClickThreshold) {
+    mPasswordPopupAutomaticallyOpened = true;
+    ShowPopup();
+  }
+
+  return NS_OK;
+}
+
+nsresult nsFormFillController::Focus(Event* aEvent) {
+  nsCOMPtr<nsIContent> input = do_QueryInterface(aEvent->GetComposedTarget());
+  return HandleFocus(MOZ_KnownLive(HTMLInputElement::FromNodeOrNull(input)));
+}
+
+nsresult nsFormFillController::KeyDown(Event* aEvent) {
+  NS_ASSERTION(mController, "should have a controller!");
+
+  mPasswordPopupAutomaticallyOpened = false;
+
+  if (!IsFocusedInputControlled()) {
+    return NS_OK;
+  }
+
+  RefPtr<KeyboardEvent> keyEvent = aEvent->AsKeyboardEvent();
+  if (!keyEvent) {
+    return NS_ERROR_FAILURE;
+  }
+
+  bool cancel = false;
+  bool unused = false;
+
+  uint32_t k = keyEvent->KeyCode();
+  switch (k) {
+    case KeyboardEvent_Binding::DOM_VK_RETURN: {
+      nsCOMPtr<nsIAutoCompleteController> controller = mController;
+      controller->HandleEnter(false, aEvent, &cancel);
+      break;
+    }
+    case KeyboardEvent_Binding::DOM_VK_DELETE:
+#ifndef XP_MACOSX
+    {
+      nsCOMPtr<nsIAutoCompleteController> controller = mController;
+      controller->HandleDelete(&cancel);
+      break;
+    }
+    case KeyboardEvent_Binding::DOM_VK_BACK_SPACE: {
+      nsCOMPtr<nsIAutoCompleteController> controller = mController;
+      controller->HandleText(&unused);
+      break;
+    }
+#else
+    case KeyboardEvent_Binding::DOM_VK_BACK_SPACE: {
+      if (keyEvent->ShiftKey()) {
+        nsCOMPtr<nsIAutoCompleteController> controller = mController;
+        controller->HandleDelete(&cancel);
+      } else {
+        nsCOMPtr<nsIAutoCompleteController> controller = mController;
+        controller->HandleText(&unused);
+      }
+      break;
+    }
+#endif
+    case KeyboardEvent_Binding::DOM_VK_PAGE_UP:
+    case KeyboardEvent_Binding::DOM_VK_PAGE_DOWN: {
+      if (keyEvent->CtrlKey() || keyEvent->AltKey() || keyEvent->MetaKey()) {
+        break;
+      }
+    }
+      [[fallthrough]];
+    case KeyboardEvent_Binding::DOM_VK_UP:
+    case KeyboardEvent_Binding::DOM_VK_DOWN:
+    case KeyboardEvent_Binding::DOM_VK_LEFT:
+    case KeyboardEvent_Binding::DOM_VK_RIGHT: {
+      // Get the writing-mode of the relevant input element,
+      // so that we can remap arrow keys if necessary.
+      mozilla::WritingMode wm;
+      if (mFocusedInput) {
+        nsIFrame* frame = mFocusedInput->GetPrimaryFrame();
+        if (frame) {
+          wm = frame->GetWritingMode();
+        }
+      }
+      if (wm.IsVertical()) {
+        switch (k) {
+          case KeyboardEvent_Binding::DOM_VK_LEFT:
+            k = wm.IsVerticalLR() ? KeyboardEvent_Binding::DOM_VK_UP
+                                  : KeyboardEvent_Binding::DOM_VK_DOWN;
+            break;
+          case KeyboardEvent_Binding::DOM_VK_RIGHT:
+            k = wm.IsVerticalLR() ? KeyboardEvent_Binding::DOM_VK_DOWN
+                                  : KeyboardEvent_Binding::DOM_VK_UP;
+            break;
+          case KeyboardEvent_Binding::DOM_VK_UP:
+            k = KeyboardEvent_Binding::DOM_VK_LEFT;
+            break;
+          case KeyboardEvent_Binding::DOM_VK_DOWN:
+            k = KeyboardEvent_Binding::DOM_VK_RIGHT;
+            break;
+        }
+      }
+      nsCOMPtr<nsIAutoCompleteController> controller = mController;
+      controller->HandleKeyNavigation(k, &cancel);
+      break;
+    }
+    case KeyboardEvent_Binding::DOM_VK_ESCAPE: {
+      nsCOMPtr<nsIAutoCompleteController> controller = mController;
+      controller->HandleEscape(&cancel);
+      break;
+    }
+    case KeyboardEvent_Binding::DOM_VK_TAB: {
+      nsCOMPtr<nsIAutoCompleteController> controller = mController;
+      controller->HandleTab();
+      cancel = false;
+      break;
+    }
+  }
+
+  if (cancel) {
+    aEvent->PreventDefault();
+    // Don't let the page see the RETURN event when the popup is open
+    // (indicated by cancel=true) so sites don't manually submit forms
+    // (e.g. via submit.click()) without the autocompleted value being filled.
+    // Bug 286933 will fix this for other key events.
+    if (k == KeyboardEvent_Binding::DOM_VK_RETURN) {
+      aEvent->StopPropagation();
+    }
+  }
+
+  return NS_OK;
+}
+
+nsresult nsFormFillController::MouseDown(Event* aEvent) {
+  MouseEvent* mouseEvent = aEvent->AsMouseEvent();
+  if (!mouseEvent) {
+    return NS_ERROR_FAILURE;
+  }
+
+  nsCOMPtr<nsINode> targetNode = do_QueryInterface(aEvent->GetComposedTarget());
+  if (!HTMLInputElement::FromNodeOrNull(targetNode)) {
+    return NS_OK;
+  }
+
+  int16_t button = mouseEvent->Button();
+
+  // In case of a right click we set a timestamp that
+  // will be checked in Focus() to avoid showing
+  // both contextmenu and popup at the same time.
+  if (button == 2) {
+    mLastRightClickTimeStamp = TimeStamp::Now();
+    return NS_OK;
+  }
+
+  if (button != 0) {
+    return NS_OK;
+  }
+
+  return ShowPopup();
+}
+
+NS_IMETHODIMP
+nsFormFillController::ShowPopup() {
+  bool isOpen = false;
+  GetPopupOpen(&isOpen);
+  if (isOpen) {
+    return SetPopupOpen(false);
+  }
+
+  nsCOMPtr<nsIAutoCompleteController> controller = mController;
+
+  nsCOMPtr<nsIAutoCompleteInput> input;
+  controller->GetInput(getter_AddRefs(input));
+  if (!input) {
+    return NS_OK;
+  }
+
+  nsAutoString value;
+  input->GetTextValue(value);
+  if (value.Length() > 0) {
+    // Show the popup with a filtered result set
+    controller->SetSearchString(u""_ns);
+    bool unused = false;
+    controller->HandleText(&unused);
+  } else {
+    // Show the popup with the complete result set.  Can't use HandleText()
+    // because it doesn't display the popup if the input is blank.
+    bool cancel = false;
+    controller->HandleKeyNavigation(KeyboardEvent_Binding::DOM_VK_DOWN,
+                                    &cancel);
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsFormFillController::GetPasswordPopupAutomaticallyOpened(
+    bool* _retval) {
+  *_retval = mPasswordPopupAutomaticallyOpened;
+  return NS_OK;
+}
+
+void nsFormFillController::StartControllingInput(HTMLInputElement* aInput) {
+  MOZ_LOG(sLogger, LogLevel::Verbose, ("StartControllingInput for %p", aInput));
+  // Make sure we're not still attached to an input
+  StopControllingInput();
+
+  if (!mController || !aInput) {
+    return;
+  }
+
+  nsCOMPtr<nsIAutoCompletePopup> popup = mPopups.Get(aInput->OwnerDoc());
+  if (!popup) {
+    popup = do_QueryActor("AutoComplete", aInput->OwnerDoc());
+    if (!popup) {
+      return;
+    }
+  }
+
+  mFocusedPopup = popup;
+
+  aInput->AddMutationObserverUnlessExists(this);
+  mFocusedInput = aInput;
+
+  if (Element* list = mFocusedInput->GetList()) {
+    list->AddMutationObserverUnlessExists(this);
+    mListNode = list;
+  }
+
+  if (!mFocusedInput->ReadOnly()) {
+    nsCOMPtr<nsIAutoCompleteController> controller = mController;
+    controller->SetInput(this);
+  }
+}
+
+bool nsFormFillController::IsFocusedInputControlled() const {
+  return mFocusedInput && mController && !mFocusedInput->ReadOnly();
+}
+
+void nsFormFillController::StopControllingInput() {
+  mPasswordPopupAutomaticallyOpened = false;
+
+  if (mListNode) {
+    mListNode->RemoveMutationObserver(this);
+    mListNode = nullptr;
+  }
+
+  if (nsCOMPtr<nsIAutoCompleteController> controller = mController) {
+    // Reset the controller's input, but not if it has been switched
+    // to another input already, which might happen if the user switches
+    // focus by clicking another autocomplete textbox
+    nsCOMPtr<nsIAutoCompleteInput> input;
+    controller->GetInput(getter_AddRefs(input));
+    if (input == this) {
+      MOZ_LOG(sLogger, LogLevel::Verbose,
+              ("StopControllingInput: Nulled controller input for %p", this));
+      controller->SetInput(nullptr);
+    }
+  }
+
+  MOZ_LOG(sLogger, LogLevel::Verbose,
+          ("StopControllingInput: Stopped controlling %p", mFocusedInput));
+  if (mFocusedInput) {
+    MaybeRemoveMutationObserver(mFocusedInput);
+    mFocusedInput = nullptr;
+  }
+
+  if (mFocusedPopup) {
+    mFocusedPopup->ClosePopup();
+  }
+  mFocusedPopup = nullptr;
+}
+
+nsIDocShell* nsFormFillController::GetDocShellForInput(
+    HTMLInputElement* aInput) {
+  NS_ENSURE_TRUE(aInput, nullptr);
+
+  nsCOMPtr<nsPIDOMWindowOuter> win = aInput->OwnerDoc()->GetWindow();
+  NS_ENSURE_TRUE(win, nullptr);
+
+  return win->GetDocShell();
+}