summaryrefslogtreecommitdiffstats
path: root/toolkit/components/autocomplete
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 00:47:55 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 00:47:55 +0000
commit26a029d407be480d791972afb5975cf62c9360a6 (patch)
treef435a8308119effd964b339f76abb83a57c29483 /toolkit/components/autocomplete
parentInitial commit. (diff)
downloadfirefox-26a029d407be480d791972afb5975cf62c9360a6.tar.xz
firefox-26a029d407be480d791972afb5975cf62c9360a6.zip
Adding upstream version 124.0.1.upstream/124.0.1
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'toolkit/components/autocomplete')
-rw-r--r--toolkit/components/autocomplete/AutoCompleteSimpleSearch.sys.mjs45
-rw-r--r--toolkit/components/autocomplete/components.conf20
-rw-r--r--toolkit/components/autocomplete/moz.build37
-rw-r--r--toolkit/components/autocomplete/nsAutoCompleteController.cpp1771
-rw-r--r--toolkit/components/autocomplete/nsAutoCompleteController.h217
-rw-r--r--toolkit/components/autocomplete/nsAutoCompleteSimpleResult.cpp256
-rw-r--r--toolkit/components/autocomplete/nsAutoCompleteSimpleResult.h63
-rw-r--r--toolkit/components/autocomplete/nsIAutoCompleteController.idl182
-rw-r--r--toolkit/components/autocomplete/nsIAutoCompleteInput.idl163
-rw-r--r--toolkit/components/autocomplete/nsIAutoCompletePopup.idl72
-rw-r--r--toolkit/components/autocomplete/nsIAutoCompleteResult.idl92
-rw-r--r--toolkit/components/autocomplete/nsIAutoCompleteSearch.idl68
-rw-r--r--toolkit/components/autocomplete/nsIAutoCompleteSimpleResult.idl120
-rw-r--r--toolkit/components/autocomplete/nsIAutoCompleteSimpleSearch.idl17
-rw-r--r--toolkit/components/autocomplete/tests/unit/head_autocomplete.js203
-rw-r--r--toolkit/components/autocomplete/tests/unit/test_330578.js41
-rw-r--r--toolkit/components/autocomplete/tests/unit/test_378079.js252
-rw-r--r--toolkit/components/autocomplete/tests/unit/test_393191.js237
-rw-r--r--toolkit/components/autocomplete/tests/unit/test_440866.js253
-rw-r--r--toolkit/components/autocomplete/tests/unit/test_463023.js13
-rw-r--r--toolkit/components/autocomplete/tests/unit/test_660156.js113
-rw-r--r--toolkit/components/autocomplete/tests/unit/test_autocomplete_multiple.js246
-rw-r--r--toolkit/components/autocomplete/tests/unit/test_autocomplete_userContextId.js44
-rw-r--r--toolkit/components/autocomplete/tests/unit/test_autofillSelectedPopupIndex.js109
-rw-r--r--toolkit/components/autocomplete/tests/unit/test_badDefaultIndex.js100
-rw-r--r--toolkit/components/autocomplete/tests/unit/test_completeDefaultIndex_casing.js64
-rw-r--r--toolkit/components/autocomplete/tests/unit/test_finalCompleteValue.js62
-rw-r--r--toolkit/components/autocomplete/tests/unit/test_finalCompleteValueSelectedIndex.js139
-rw-r--r--toolkit/components/autocomplete/tests/unit/test_finalCompleteValue_defaultIndex.js112
-rw-r--r--toolkit/components/autocomplete/tests/unit/test_finalCompleteValue_forceComplete.js138
-rw-r--r--toolkit/components/autocomplete/tests/unit/test_finalDefaultCompleteValue.js80
-rw-r--r--toolkit/components/autocomplete/tests/unit/test_immediate_search.js174
-rw-r--r--toolkit/components/autocomplete/tests/unit/test_insertMatchAt.js15
-rw-r--r--toolkit/components/autocomplete/tests/unit/test_previousResult.js255
-rw-r--r--toolkit/components/autocomplete/tests/unit/test_removeMatchAt.js16
-rw-r--r--toolkit/components/autocomplete/tests/unit/test_stopSearch.js171
-rw-r--r--toolkit/components/autocomplete/tests/unit/xpcshell.toml44
37 files changed, 6004 insertions, 0 deletions
diff --git a/toolkit/components/autocomplete/AutoCompleteSimpleSearch.sys.mjs b/toolkit/components/autocomplete/AutoCompleteSimpleSearch.sys.mjs
new file mode 100644
index 0000000000..b57d290cfb
--- /dev/null
+++ b/toolkit/components/autocomplete/AutoCompleteSimpleSearch.sys.mjs
@@ -0,0 +1,45 @@
+/* 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 https://mozilla.org/MPL/2.0/. */
+
+/**
+ * See nsIAutoCompleteSimpleSearch
+ */
+export class AutoCompleteSimpleSearch {
+ constructor() {
+ this.classID = Components.ID("{dc185a77-ba88-4caa-8f16-465253f7599a}");
+ this.QueryInterface = ChromeUtils.generateQI([
+ "nsIAutoCompleteSimpleSearch",
+ ]);
+
+ let initialState = Cc[
+ "@mozilla.org/autocomplete/simple-result;1"
+ ].createInstance(Ci.nsIAutoCompleteSimpleResult);
+ initialState.setDefaultIndex(0);
+ initialState.setSearchResult(Ci.nsIAutoCompleteResult.RESULT_NOMATCH);
+ this.overrideNextResult(initialState);
+ }
+
+ _result = null;
+
+ /**
+ * See nsIAutoCompleteSimpleSearch
+ */
+ overrideNextResult(result) {
+ this._result = result;
+ }
+
+ /**
+ * See nsIAutoCompleteSearch
+ */
+ startSearch(searchString, searchParam, previousResult, listener) {
+ let result = this._result;
+ result.setSearchString(searchString);
+ listener.onSearchResult(this, result);
+ }
+
+ /**
+ * See nsIAutoCompleteSearch
+ */
+ stopSearch() {}
+}
diff --git a/toolkit/components/autocomplete/components.conf b/toolkit/components/autocomplete/components.conf
new file mode 100644
index 0000000000..432a6309ed
--- /dev/null
+++ b/toolkit/components/autocomplete/components.conf
@@ -0,0 +1,20 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# 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/.
+
+Classes = [
+ {
+ 'cid': '{f6d5ebbd-34f4-487d-9d10-3d34123e3eb9}',
+ 'contract_ids': ['@mozilla.org/autocomplete/controller;1'],
+ 'type': 'nsAutoCompleteController',
+ 'headers': ['/toolkit/components/autocomplete/nsAutoCompleteController.h'],
+ },
+ {
+ 'cid': '{2ee3039b-2de4-43d9-93b0-649beacff39a}',
+ 'contract_ids': ['@mozilla.org/autocomplete/simple-result;1'],
+ 'type': 'nsAutoCompleteSimpleResult',
+ 'headers': ['/toolkit/components/autocomplete/nsAutoCompleteSimpleResult.h'],
+ },
+]
diff --git a/toolkit/components/autocomplete/moz.build b/toolkit/components/autocomplete/moz.build
new file mode 100644
index 0000000000..c8adb0bd5b
--- /dev/null
+++ b/toolkit/components/autocomplete/moz.build
@@ -0,0 +1,37 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# 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/.
+
+XPCSHELL_TESTS_MANIFESTS += ["tests/unit/xpcshell.toml"]
+
+XPIDL_SOURCES += [
+ "nsIAutoCompleteController.idl",
+ "nsIAutoCompleteInput.idl",
+ "nsIAutoCompletePopup.idl",
+ "nsIAutoCompleteResult.idl",
+ "nsIAutoCompleteSearch.idl",
+ "nsIAutoCompleteSimpleResult.idl",
+ "nsIAutoCompleteSimpleSearch.idl",
+]
+
+XPIDL_MODULE = "autocomplete"
+
+EXTRA_JS_MODULES += [
+ "AutoCompleteSimpleSearch.sys.mjs",
+]
+
+UNIFIED_SOURCES += [
+ "nsAutoCompleteController.cpp",
+ "nsAutoCompleteSimpleResult.cpp",
+]
+
+XPCOM_MANIFESTS += [
+ "components.conf",
+]
+
+FINAL_LIBRARY = "xul"
+
+with Files("**"):
+ BUG_COMPONENT = ("Toolkit", "Autocomplete")
diff --git a/toolkit/components/autocomplete/nsAutoCompleteController.cpp b/toolkit/components/autocomplete/nsAutoCompleteController.cpp
new file mode 100644
index 0000000000..7c3035271b
--- /dev/null
+++ b/toolkit/components/autocomplete/nsAutoCompleteController.cpp
@@ -0,0 +1,1771 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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 "nsAutoCompleteController.h"
+#include "nsAutoCompleteSimpleResult.h"
+
+#include "nsNetCID.h"
+#include "nsIIOService.h"
+#include "nsReadableUtils.h"
+#include "nsUnicharUtils.h"
+#include "nsIScriptSecurityManager.h"
+#include "nsIObserverService.h"
+#include "nsServiceManagerUtils.h"
+#include "mozilla/Services.h"
+#include "mozilla/Unused.h"
+#include "mozilla/dom/KeyboardEventBinding.h"
+#include "mozilla/dom/Event.h"
+
+static const char* kAutoCompleteSearchCID =
+ "@mozilla.org/autocomplete/search;1?name=";
+
+using namespace mozilla;
+
+NS_IMPL_CYCLE_COLLECTION_CLASS(nsAutoCompleteController)
+
+MOZ_CAN_RUN_SCRIPT_BOUNDARY
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(nsAutoCompleteController)
+ MOZ_KnownLive(tmp)->SetInput(nullptr);
+NS_IMPL_CYCLE_COLLECTION_UNLINK_END
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(nsAutoCompleteController)
+ NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mInput)
+ NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mSearches)
+ NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mResults)
+ NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mResultCache)
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(nsAutoCompleteController)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(nsAutoCompleteController)
+NS_INTERFACE_TABLE_HEAD(nsAutoCompleteController)
+ NS_INTERFACE_TABLE(nsAutoCompleteController, nsIAutoCompleteController,
+ nsIAutoCompleteObserver, nsITimerCallback, nsINamed)
+ NS_INTERFACE_TABLE_TO_MAP_SEGUE_CYCLE_COLLECTION(nsAutoCompleteController)
+NS_INTERFACE_MAP_END
+
+nsAutoCompleteController::nsAutoCompleteController()
+ : mDefaultIndexCompleted(false),
+ mPopupClosedByCompositionStart(false),
+ mProhibitAutoFill(false),
+ mUserClearedAutoFill(false),
+ mClearingAutoFillSearchesAgain(false),
+ mCompositionState(eCompositionState_None),
+ mSearchStatus(nsAutoCompleteController::STATUS_NONE),
+ mMatchCount(0),
+ mSearchesOngoing(0),
+ mSearchesFailed(0),
+ mImmediateSearchesCount(0),
+ mCompletedSelectionIndex(-1) {}
+
+nsAutoCompleteController::~nsAutoCompleteController() { SetInput(nullptr); }
+
+void nsAutoCompleteController::SetValueOfInputTo(const nsString& aValue) {
+ mSetValue = aValue;
+ nsCOMPtr<nsIAutoCompleteInput> input(mInput);
+ input->SetTextValue(aValue);
+}
+
+////////////////////////////////////////////////////////////////////////
+//// nsIAutoCompleteController
+
+NS_IMETHODIMP
+nsAutoCompleteController::GetSearchStatus(uint16_t* aSearchStatus) {
+ *aSearchStatus = mSearchStatus;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteController::GetMatchCount(uint32_t* aMatchCount) {
+ *aMatchCount = mMatchCount;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteController::GetInput(nsIAutoCompleteInput** aInput) {
+ *aInput = mInput;
+ NS_IF_ADDREF(*aInput);
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteController::SetInitiallySelectedIndex(int32_t aSelectedIndex) {
+ // First forward to the popup.
+ nsCOMPtr<nsIAutoCompleteInput> input(mInput);
+ NS_ENSURE_STATE(input);
+
+ nsCOMPtr<nsIAutoCompletePopup> popup(GetPopup());
+ NS_ENSURE_STATE(popup);
+ popup->SetSelectedIndex(aSelectedIndex);
+
+ // Now take care of internal stuff.
+ bool completeSelection;
+ if (NS_SUCCEEDED(input->GetCompleteSelectedIndex(&completeSelection)) &&
+ completeSelection) {
+ mCompletedSelectionIndex = aSelectedIndex;
+ }
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteController::SetInput(nsIAutoCompleteInput* aInput) {
+ // Don't do anything if the input isn't changing.
+ if (mInput == aInput) return NS_OK;
+
+ Unused << ResetInternalState();
+ if (mInput) {
+ mSearches.Clear();
+ ClosePopup();
+ }
+
+ mInput = aInput;
+
+ // Nothing more to do if the input was just being set to null.
+ if (!mInput) {
+ return NS_OK;
+ }
+ nsCOMPtr<nsIAutoCompleteInput> input(mInput);
+
+ // Reset the current search string.
+ nsAutoString value;
+ input->GetTextValue(value);
+ SetSearchStringInternal(value);
+
+ // Since the controller can be used as a service it's important to reset this.
+ mClearingAutoFillSearchesAgain = false;
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteController::ResetInternalState() {
+ // Clear out the current search context
+ if (mInput) {
+ nsAutoString value;
+ mInput->GetTextValue(value);
+ // Stop all searches in case they are async.
+ Unused << StopSearch();
+ Unused << ClearResults();
+ SetSearchStringInternal(value);
+ }
+
+ mPlaceholderCompletionString.Truncate();
+ mDefaultIndexCompleted = false;
+ mProhibitAutoFill = false;
+ mSearchStatus = nsIAutoCompleteController::STATUS_NONE;
+ mMatchCount = 0;
+ mCompletedSelectionIndex = -1;
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteController::StartSearch(const nsAString& aSearchString) {
+ // If composition is ongoing don't start searching yet, until it is committed.
+ if (mCompositionState == eCompositionState_Composing) {
+ return NS_OK;
+ }
+
+ SetSearchStringInternal(aSearchString);
+ StartSearches();
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteController::HandleText(bool* _retval) {
+ *_retval = false;
+ // Note: the events occur in the following order when IME is used.
+ // 1. a compositionstart event(HandleStartComposition)
+ // 2. some input events (HandleText), eCompositionState_Composing
+ // 3. a compositionend event(HandleEndComposition)
+ // 4. an input event(HandleText), eCompositionState_Committing
+ // We should do nothing during composition.
+ if (mCompositionState == eCompositionState_Composing) {
+ return NS_OK;
+ }
+
+ bool handlingCompositionCommit =
+ (mCompositionState == eCompositionState_Committing);
+ bool popupClosedByCompositionStart = mPopupClosedByCompositionStart;
+ if (handlingCompositionCommit) {
+ mCompositionState = eCompositionState_None;
+ mPopupClosedByCompositionStart = false;
+ }
+
+ if (!mInput) {
+ // Stop all searches in case they are async.
+ StopSearch();
+ // Note: if now is after blur and IME end composition,
+ // check mInput before calling.
+ // See https://bugzilla.mozilla.org/show_bug.cgi?id=193544#c31
+ NS_ERROR(
+ "Called before attaching to the control or after detaching from the "
+ "control");
+ return NS_OK;
+ }
+
+ nsCOMPtr<nsIAutoCompleteInput> input(mInput);
+ nsAutoString newValue;
+ input->GetTextValue(newValue);
+
+ // Stop all searches in case they are async.
+ StopSearch();
+
+ if (!mInput) {
+ // StopSearch() can call PostSearchCleanup() which might result
+ // in a blur event, which could null out mInput, so we need to check it
+ // again. See bug #395344 for more details
+ return NS_OK;
+ }
+
+ bool disabled;
+ input->GetDisableAutoComplete(&disabled);
+ NS_ENSURE_TRUE(!disabled, NS_OK);
+
+ // Usually we don't search again if the new string is the same as the last
+ // one. However, if this is called immediately after compositionend event, we
+ // need to search the same value again since the search was canceled at
+ // compositionstart event handler. The new string might also be the same as
+ // the last search if the autofilled portion was cleared. In this case, we may
+ // want to search again.
+
+ // Whether the user removed some text at the end.
+ bool userRemovedText =
+ newValue.Length() < mSearchString.Length() &&
+ Substring(mSearchString, 0, newValue.Length()).Equals(newValue);
+
+ // Whether the user is repeating the previous search.
+ bool repeatingPreviousSearch =
+ !userRemovedText && newValue.Equals(mSearchString);
+
+ mUserClearedAutoFill =
+ repeatingPreviousSearch &&
+ newValue.Length() < mPlaceholderCompletionString.Length() &&
+ Substring(mPlaceholderCompletionString, 0, newValue.Length())
+ .Equals(newValue);
+ bool searchAgainOnAutoFillClear =
+ mUserClearedAutoFill && mClearingAutoFillSearchesAgain;
+
+ if (!handlingCompositionCommit && !searchAgainOnAutoFillClear &&
+ newValue.Length() > 0 && repeatingPreviousSearch) {
+ return NS_OK;
+ }
+
+ if (userRemovedText || searchAgainOnAutoFillClear) {
+ if (userRemovedText) {
+ // We need to throw away previous results so we don't try to search
+ // through them again.
+ ClearResults();
+ }
+ mProhibitAutoFill = true;
+ mPlaceholderCompletionString.Truncate();
+ } else {
+ mProhibitAutoFill = false;
+ }
+
+ SetSearchStringInternal(newValue);
+
+ bool noRollupOnEmptySearch;
+ nsresult rv = input->GetNoRollupOnEmptySearch(&noRollupOnEmptySearch);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ // Don't search if the value is empty
+ if (newValue.Length() == 0 && !noRollupOnEmptySearch) {
+ // If autocomplete popup was closed by compositionstart event handler,
+ // we should reopen it forcibly even if the value is empty.
+ if (popupClosedByCompositionStart && handlingCompositionCommit) {
+ bool cancel;
+ HandleKeyNavigation(dom::KeyboardEvent_Binding::DOM_VK_DOWN, &cancel);
+ return NS_OK;
+ }
+ ClosePopup();
+ return NS_OK;
+ }
+
+ *_retval = true;
+ StartSearches();
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteController::HandleEnter(bool aIsPopupSelection,
+ dom::Event* aEvent, bool* _retval) {
+ *_retval = false;
+ if (!mInput) return NS_OK;
+
+ nsCOMPtr<nsIAutoCompleteInput> input(mInput);
+
+ // allow the event through unless there is something selected in the popup
+ input->GetPopupOpen(_retval);
+ if (*_retval) {
+ nsCOMPtr<nsIAutoCompletePopup> popup(GetPopup());
+ if (popup) {
+ int32_t selectedIndex;
+ popup->GetSelectedIndex(&selectedIndex);
+ *_retval = selectedIndex >= 0;
+ }
+ }
+
+ // Stop the search, and handle the enter.
+ StopSearch();
+ // StopSearch() can call PostSearchCleanup() which might result
+ // in a blur event, which could null out mInput, so we need to check it
+ // again. See bug #408463 for more details
+ if (!mInput) {
+ return NS_OK;
+ }
+
+ EnterMatch(aIsPopupSelection, aEvent);
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteController::HandleEscape(bool* _retval) {
+ *_retval = false;
+ if (!mInput) return NS_OK;
+
+ nsCOMPtr<nsIAutoCompleteInput> input(mInput);
+
+ // allow the event through if the popup is closed
+ input->GetPopupOpen(_retval);
+
+ // Stop all searches in case they are async.
+ StopSearch();
+ ClearResults();
+ RevertTextValue();
+ ClosePopup();
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteController::HandleStartComposition() {
+ NS_ENSURE_TRUE(mCompositionState != eCompositionState_Composing, NS_OK);
+
+ mPopupClosedByCompositionStart = false;
+ mCompositionState = eCompositionState_Composing;
+
+ if (!mInput) return NS_OK;
+
+ nsCOMPtr<nsIAutoCompleteInput> input(mInput);
+ bool disabled;
+ input->GetDisableAutoComplete(&disabled);
+ if (disabled) return NS_OK;
+
+ // Stop all searches in case they are async.
+ StopSearch();
+
+ bool isOpen = false;
+ input->GetPopupOpen(&isOpen);
+ if (isOpen) {
+ ClosePopup();
+
+ bool stillOpen = false;
+ input->GetPopupOpen(&stillOpen);
+ mPopupClosedByCompositionStart = !stillOpen;
+ }
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteController::HandleEndComposition() {
+ NS_ENSURE_TRUE(mCompositionState == eCompositionState_Composing, NS_OK);
+
+ // We can't yet retrieve the committed value from the editor, since it isn't
+ // completely committed yet. Set mCompositionState to
+ // eCompositionState_Committing, so that when HandleText() is called (in
+ // response to the "input" event), we know that we should handle the
+ // committed text.
+ mCompositionState = eCompositionState_Committing;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteController::HandleTab() {
+ bool cancel;
+ return HandleEnter(false, nullptr, &cancel);
+}
+
+NS_IMETHODIMP
+nsAutoCompleteController::HandleKeyNavigation(uint32_t aKey, bool* _retval) {
+ // By default, don't cancel the event
+ *_retval = false;
+
+ if (!mInput) {
+ // Stop all searches in case they are async.
+ StopSearch();
+ // Note: if now is after blur and IME end composition,
+ // check mInput before calling.
+ // See https://bugzilla.mozilla.org/show_bug.cgi?id=193544#c31
+ NS_ERROR(
+ "Called before attaching to the control or after detaching from the "
+ "control");
+ return NS_OK;
+ }
+
+ nsCOMPtr<nsIAutoCompleteInput> input(mInput);
+ nsCOMPtr<nsIAutoCompletePopup> popup(GetPopup());
+ NS_ENSURE_TRUE(popup != nullptr, NS_ERROR_FAILURE);
+
+ bool disabled;
+ input->GetDisableAutoComplete(&disabled);
+ NS_ENSURE_TRUE(!disabled, NS_OK);
+
+ if (aKey == dom::KeyboardEvent_Binding::DOM_VK_UP ||
+ aKey == dom::KeyboardEvent_Binding::DOM_VK_DOWN ||
+ aKey == dom::KeyboardEvent_Binding::DOM_VK_PAGE_UP ||
+ aKey == dom::KeyboardEvent_Binding::DOM_VK_PAGE_DOWN) {
+ bool isOpen = false;
+ input->GetPopupOpen(&isOpen);
+ if (isOpen) {
+ // Prevent the input from handling up/down events, as it may move
+ // the cursor to home/end on some systems
+ *_retval = true;
+ bool reverse = aKey == dom::KeyboardEvent_Binding::DOM_VK_UP ||
+ aKey == dom::KeyboardEvent_Binding::DOM_VK_PAGE_UP;
+ bool page = aKey == dom::KeyboardEvent_Binding::DOM_VK_PAGE_UP ||
+ aKey == dom::KeyboardEvent_Binding::DOM_VK_PAGE_DOWN;
+
+ // Fill in the value of the textbox with whatever is selected in the popup
+ // if the completeSelectedIndex attribute is set. We check this before
+ // calling SelectBy of an earlier attempt to avoid crashing.
+ bool completeSelection;
+ input->GetCompleteSelectedIndex(&completeSelection);
+
+ // The user has keyed up or down to change the selection. Stop the search
+ // (if there is one) now so that the results do not change while the user
+ // is making a selection.
+ Unused << StopSearch();
+
+ // Instruct the result view to scroll by the given amount and direction
+ popup->SelectBy(reverse, page);
+
+ if (completeSelection) {
+ int32_t selectedIndex;
+ popup->GetSelectedIndex(&selectedIndex);
+ if (selectedIndex >= 0) {
+ // A result is selected, so fill in its value
+ nsAutoString value;
+ if (NS_SUCCEEDED(GetResultValueAt(selectedIndex, false, value))) {
+ // If the result is the previously autofilled string, then restore
+ // the search string and selection that existed when the result was
+ // autofilled. Else, fill the result and move the caret to the end.
+ int32_t start;
+ if (value.Equals(mPlaceholderCompletionString,
+ nsCaseInsensitiveStringComparator)) {
+ start = mSearchString.Length();
+ value = mPlaceholderCompletionString;
+ SetValueOfInputTo(value);
+ } else {
+ start = value.Length();
+ SetValueOfInputTo(value);
+ }
+
+ input->SelectTextRange(start, value.Length());
+ }
+ mCompletedSelectionIndex = selectedIndex;
+ } else {
+ // Nothing is selected, so fill in the last typed value
+ SetValueOfInputTo(mSearchString);
+ input->SelectTextRange(mSearchString.Length(),
+ mSearchString.Length());
+ mCompletedSelectionIndex = -1;
+ }
+ }
+ } else {
+ // Only show the popup if the caret is at the start or end of the input
+ // and there is no selection, so that the default defined key shortcuts
+ // for up and down move to the beginning and end of the field otherwise.
+ if (aKey == dom::KeyboardEvent_Binding::DOM_VK_UP ||
+ aKey == dom::KeyboardEvent_Binding::DOM_VK_DOWN) {
+ const bool isUp = aKey == dom::KeyboardEvent_Binding::DOM_VK_UP;
+
+ int32_t start, end;
+ input->GetSelectionStart(&start);
+ input->GetSelectionEnd(&end);
+
+ if (isUp) {
+ if (start > 0 || start != end) {
+ return NS_OK;
+ }
+ } else {
+ nsAutoString text;
+ input->GetTextValue(text);
+ if (start != end || end < (int32_t)text.Length()) {
+ return NS_OK;
+ }
+ }
+ }
+
+ // Open the popup if there has been a previous non-errored search, or
+ // else kick off a new search
+ bool hadPreviousSearch = false;
+ for (uint32_t i = 0; i < mResults.Length(); ++i) {
+ nsAutoString oldSearchString;
+ uint16_t oldResult = 0;
+ nsIAutoCompleteResult* oldResultObject = mResults[i];
+ if (oldResultObject &&
+ NS_SUCCEEDED(oldResultObject->GetSearchResult(&oldResult)) &&
+ oldResult != nsIAutoCompleteResult::RESULT_FAILURE &&
+ NS_SUCCEEDED(oldResultObject->GetSearchString(oldSearchString)) &&
+ oldSearchString.Equals(mSearchString,
+ nsCaseInsensitiveStringComparator)) {
+ hadPreviousSearch = true;
+ break;
+ }
+ }
+ if (hadPreviousSearch) {
+ if (mMatchCount) {
+ OpenPopup();
+ }
+ } else {
+ // Stop all searches in case they are async.
+ StopSearch();
+
+ if (!mInput) {
+ // StopSearch() can call PostSearchCleanup() which might result
+ // in a blur event, which could null out mInput, so we need to check
+ // it again. See bug #395344 for more details
+ return NS_OK;
+ }
+
+ // Some script may have changed the value of the text field since our
+ // last keypress or after our focus handler and we don't want to
+ // search for a stale string.
+ nsAutoString value;
+ input->GetTextValue(value);
+ SetSearchStringInternal(value);
+
+ StartSearches();
+ }
+
+ bool isOpen = false;
+ input->GetPopupOpen(&isOpen);
+ if (isOpen) {
+ // Prevent the default action if we opened the popup in any of the code
+ // paths above.
+ *_retval = true;
+ }
+ }
+ } else if (aKey == dom::KeyboardEvent_Binding::DOM_VK_LEFT ||
+ aKey == dom::KeyboardEvent_Binding::DOM_VK_RIGHT
+#ifndef XP_MACOSX
+ || aKey == dom::KeyboardEvent_Binding::DOM_VK_HOME
+#endif
+ ) {
+ // The user hit a text-navigation key.
+ bool isOpen = false;
+ input->GetPopupOpen(&isOpen);
+
+ // If minresultsforpopup > 1 and there's less matches than the minimum
+ // required, the popup is not open, but the search suggestion is showing
+ // inline, so we should proceed as if we had the popup.
+ uint32_t minResultsForPopup;
+ input->GetMinResultsForPopup(&minResultsForPopup);
+ if (isOpen || (mMatchCount > 0 && mMatchCount < minResultsForPopup)) {
+ // For completeSelectedIndex autocomplete fields, if the popup shouldn't
+ // close when the caret is moved, don't adjust the text value or caret
+ // position.
+ bool completeSelection;
+ input->GetCompleteSelectedIndex(&completeSelection);
+ if (isOpen) {
+ bool noRollup;
+ input->GetNoRollupOnCaretMove(&noRollup);
+ if (noRollup) {
+ if (completeSelection) {
+ return NS_OK;
+ }
+ }
+ }
+
+ int32_t selectionEnd;
+ input->GetSelectionEnd(&selectionEnd);
+ int32_t selectionStart;
+ input->GetSelectionStart(&selectionStart);
+ bool shouldCompleteSelection =
+ (uint32_t)selectionEnd == mPlaceholderCompletionString.Length() &&
+ selectionStart < selectionEnd;
+ int32_t selectedIndex;
+ popup->GetSelectedIndex(&selectedIndex);
+ bool completeDefaultIndex;
+ input->GetCompleteDefaultIndex(&completeDefaultIndex);
+ if (completeDefaultIndex && shouldCompleteSelection) {
+ // We usually try to preserve the casing of what user has typed, but
+ // if he wants to autocomplete, we will replace the value with the
+ // actual autocomplete result. Note that the autocomplete input can also
+ // be showing e.g. "bar >> foo bar" if the search matched "bar", a
+ // word not at the start of the full value "foo bar".
+ // The user wants explicitely to use that result, so this ensures
+ // association of the result with the autocompleted text.
+ nsAutoString value;
+ nsAutoString inputValue;
+ input->GetTextValue(inputValue);
+ if (NS_SUCCEEDED(GetDefaultCompleteValue(-1, false, value))) {
+ nsAutoString suggestedValue;
+ int32_t pos = inputValue.Find(u" >> ");
+ if (pos > 0) {
+ inputValue.Right(suggestedValue, inputValue.Length() - pos - 4);
+ } else {
+ suggestedValue = inputValue;
+ }
+
+ if (value.Equals(suggestedValue, nsCaseInsensitiveStringComparator)) {
+ SetValueOfInputTo(value);
+ input->SelectTextRange(value.Length(), value.Length());
+ }
+ }
+ } else if (!completeDefaultIndex && !completeSelection &&
+ selectedIndex >= 0) {
+ // The pop-up is open and has a selection, take its value
+ nsAutoString value;
+ if (NS_SUCCEEDED(GetResultValueAt(selectedIndex, false, value))) {
+ SetValueOfInputTo(value);
+ input->SelectTextRange(value.Length(), value.Length());
+ }
+ }
+
+ // Close the pop-up even if nothing was selected
+ ClearSearchTimer();
+ ClosePopup();
+ }
+ // Update last-searched string to the current input, since the input may
+ // have changed. Without this, subsequent backspaces look like text
+ // additions, not text deletions.
+ nsAutoString value;
+ input->GetTextValue(value);
+ SetSearchStringInternal(value);
+ }
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteController::HandleDelete(bool* _retval) {
+ *_retval = false;
+ if (!mInput) return NS_OK;
+
+ nsCOMPtr<nsIAutoCompleteInput> input(mInput);
+ bool isOpen = false;
+ input->GetPopupOpen(&isOpen);
+ if (!isOpen || mMatchCount == 0) {
+ // Nothing left to delete, proceed as normal
+ bool unused = false;
+ HandleText(&unused);
+ return NS_OK;
+ }
+
+ nsCOMPtr<nsIAutoCompletePopup> popup(GetPopup());
+ NS_ENSURE_TRUE(popup, NS_ERROR_FAILURE);
+
+ int32_t index, searchIndex, matchIndex;
+ popup->GetSelectedIndex(&index);
+ if (index == -1) {
+ // No match is selected in the list
+ bool unused = false;
+ HandleText(&unused);
+ return NS_OK;
+ }
+
+ MatchIndexToSearch(index, &searchIndex, &matchIndex);
+ NS_ENSURE_TRUE(searchIndex >= 0 && matchIndex >= 0, NS_ERROR_FAILURE);
+
+ nsIAutoCompleteResult* result = mResults.SafeObjectAt(searchIndex);
+ NS_ENSURE_TRUE(result, NS_ERROR_FAILURE);
+
+ bool removable;
+ nsresult rv = result->IsRemovableAt(matchIndex, &removable);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (!removable) {
+ return NS_OK;
+ }
+
+ nsAutoString search;
+ input->GetSearchParam(search);
+
+ // Clear the match in our result and in the DB.
+ result->RemoveValueAt(matchIndex);
+ --mMatchCount;
+
+ // We removed it, so make sure we cancel the event that triggered this call.
+ *_retval = true;
+
+ // Unselect the current item.
+ popup->SetSelectedIndex(-1);
+
+ // Adjust index, if needed.
+ MOZ_ASSERT(index >= 0); // We verified this above, after MatchIndexToSearch.
+ if (static_cast<uint32_t>(index) >= mMatchCount) index = mMatchCount - 1;
+
+ if (mMatchCount > 0) {
+ // There are still matches in the popup, select the current index again.
+ popup->SetSelectedIndex(index);
+
+ // Complete to the new current value.
+ bool shouldComplete = false;
+ input->GetCompleteDefaultIndex(&shouldComplete);
+ if (shouldComplete) {
+ nsAutoString value;
+ if (NS_SUCCEEDED(GetResultValueAt(index, false, value))) {
+ CompleteValue(value);
+ }
+ }
+
+ // Invalidate the popup.
+ popup->Invalidate(nsIAutoCompletePopup::INVALIDATE_REASON_DELETE);
+ } else {
+ // Nothing left in the popup, clear any pending search timers and
+ // close the popup.
+ ClearSearchTimer();
+ uint32_t minResults;
+ input->GetMinResultsForPopup(&minResults);
+ if (minResults) {
+ ClosePopup();
+ }
+ }
+
+ return NS_OK;
+}
+
+nsresult nsAutoCompleteController::GetResultAt(int32_t aIndex,
+ nsIAutoCompleteResult** aResult,
+ int32_t* aMatchIndex) {
+ int32_t searchIndex;
+ MatchIndexToSearch(aIndex, &searchIndex, aMatchIndex);
+ NS_ENSURE_TRUE(searchIndex >= 0 && *aMatchIndex >= 0, NS_ERROR_FAILURE);
+
+ *aResult = mResults.SafeObjectAt(searchIndex);
+ NS_ENSURE_TRUE(*aResult, NS_ERROR_FAILURE);
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteController::GetValueAt(int32_t aIndex, nsAString& _retval) {
+ GetResultLabelAt(aIndex, _retval);
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteController::GetLabelAt(int32_t aIndex, nsAString& _retval) {
+ GetResultLabelAt(aIndex, _retval);
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteController::GetCommentAt(int32_t aIndex, nsAString& _retval) {
+ int32_t matchIndex;
+ nsIAutoCompleteResult* result;
+ nsresult rv = GetResultAt(aIndex, &result, &matchIndex);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ return result->GetCommentAt(matchIndex, _retval);
+}
+
+NS_IMETHODIMP
+nsAutoCompleteController::GetStyleAt(int32_t aIndex, nsAString& _retval) {
+ int32_t matchIndex;
+ nsIAutoCompleteResult* result;
+ nsresult rv = GetResultAt(aIndex, &result, &matchIndex);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ return result->GetStyleAt(matchIndex, _retval);
+}
+
+NS_IMETHODIMP
+nsAutoCompleteController::GetImageAt(int32_t aIndex, nsAString& _retval) {
+ int32_t matchIndex;
+ nsIAutoCompleteResult* result;
+ nsresult rv = GetResultAt(aIndex, &result, &matchIndex);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ return result->GetImageAt(matchIndex, _retval);
+}
+
+NS_IMETHODIMP
+nsAutoCompleteController::GetFinalCompleteValueAt(int32_t aIndex,
+ nsAString& _retval) {
+ int32_t matchIndex;
+ nsIAutoCompleteResult* result;
+ nsresult rv = GetResultAt(aIndex, &result, &matchIndex);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ return result->GetFinalCompleteValueAt(matchIndex, _retval);
+}
+
+NS_IMETHODIMP
+nsAutoCompleteController::SetSearchString(const nsAString& aSearchString) {
+ SetSearchStringInternal(aSearchString);
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteController::GetSearchString(nsAString& aSearchString) {
+ aSearchString = mSearchString;
+ return NS_OK;
+}
+
+////////////////////////////////////////////////////////////////////////
+//// nsIAutoCompleteObserver
+
+NS_IMETHODIMP
+nsAutoCompleteController::OnSearchResult(nsIAutoCompleteSearch* aSearch,
+ nsIAutoCompleteResult* aResult) {
+ MOZ_ASSERT(mSearchesOngoing > 0 && mSearches.Contains(aSearch));
+
+ uint16_t result = 0;
+ if (aResult) {
+ aResult->GetSearchResult(&result);
+ }
+
+ // If our results are incremental, the search is still ongoing.
+ if (result != nsIAutoCompleteResult::RESULT_SUCCESS_ONGOING &&
+ result != nsIAutoCompleteResult::RESULT_NOMATCH_ONGOING) {
+ --mSearchesOngoing;
+ }
+
+ // Look up the index of the search which is returning.
+ for (uint32_t i = 0; i < mSearches.Length(); ++i) {
+ if (mSearches[i] == aSearch) {
+ ProcessResult(i, aResult);
+ break;
+ }
+ }
+
+ // If a match is found in ProcessResult, PostSearchCleanup will open the popup
+ PostSearchCleanup();
+
+ return NS_OK;
+}
+
+////////////////////////////////////////////////////////////////////////
+//// nsITimerCallback
+
+MOZ_CAN_RUN_SCRIPT_BOUNDARY
+NS_IMETHODIMP
+nsAutoCompleteController::Notify(nsITimer* timer) {
+ mTimer = nullptr;
+
+ if (mImmediateSearchesCount == 0) {
+ // If there were no immediate searches, BeforeSearches has not yet been
+ // called, so do it now.
+ nsresult rv = BeforeSearches();
+ if (NS_FAILED(rv)) return rv;
+ }
+ StartSearch(nsIAutoCompleteSearchDescriptor::SEARCH_TYPE_DELAYED);
+ AfterSearches();
+ return NS_OK;
+}
+
+////////////////////////////////////////////////////////////////////////
+//// nsINamed
+
+NS_IMETHODIMP
+nsAutoCompleteController::GetName(nsACString& aName) {
+ aName.AssignLiteral("nsAutoCompleteController");
+ return NS_OK;
+}
+
+////////////////////////////////////////////////////////////////////////
+//// nsAutoCompleteController
+
+nsresult nsAutoCompleteController::OpenPopup() {
+ uint32_t minResults;
+ mInput->GetMinResultsForPopup(&minResults);
+
+ if (mMatchCount >= minResults) {
+ nsCOMPtr<nsIAutoCompleteInput> input = mInput;
+ return input->SetPopupOpen(true);
+ }
+
+ return NS_OK;
+}
+
+nsresult nsAutoCompleteController::ClosePopup() {
+ if (!mInput) {
+ return NS_OK;
+ }
+
+ nsCOMPtr<nsIAutoCompleteInput> input(mInput);
+
+ bool isOpen = false;
+ input->GetPopupOpen(&isOpen);
+ if (!isOpen) return NS_OK;
+
+ nsCOMPtr<nsIAutoCompletePopup> popup(GetPopup());
+ NS_ENSURE_TRUE(popup != nullptr, NS_ERROR_FAILURE);
+ MOZ_ALWAYS_SUCCEEDS(input->SetPopupOpen(false));
+ return popup->SetSelectedIndex(-1);
+}
+
+nsresult nsAutoCompleteController::BeforeSearches() {
+ NS_ENSURE_STATE(mInput);
+
+ mSearchStatus = nsIAutoCompleteController::STATUS_SEARCHING;
+ mDefaultIndexCompleted = false;
+
+ bool invalidatePreviousResult = false;
+ mInput->GetInvalidatePreviousResult(&invalidatePreviousResult);
+
+ if (!invalidatePreviousResult) {
+ // ClearResults will clear the mResults array, but we should pass the
+ // previous result to each search to allow reusing it. So we temporarily
+ // cache the current results until AfterSearches().
+ if (!mResultCache.AppendObjects(mResults)) {
+ return NS_ERROR_OUT_OF_MEMORY;
+ }
+ }
+ ClearResults(true);
+ mSearchesOngoing = mSearches.Length();
+ mSearchesFailed = 0;
+
+ // notify the input that the search is beginning
+ mInput->OnSearchBegin();
+
+ return NS_OK;
+}
+
+nsresult nsAutoCompleteController::StartSearch(uint16_t aSearchType) {
+ NS_ENSURE_STATE(mInput);
+ nsCOMPtr<nsIAutoCompleteInput> input = mInput;
+
+ // Iterate a copy of |mSearches| so that we don't run into trouble if the
+ // array is mutated while we're still in the loop. An nsIAutoCompleteSearch
+ // implementation could synchronously start a new search when StartSearch()
+ // is called and that would lead to assertions down the way.
+ nsCOMArray<nsIAutoCompleteSearch> searchesCopy(mSearches);
+ for (uint32_t i = 0; i < searchesCopy.Length(); ++i) {
+ nsCOMPtr<nsIAutoCompleteSearch> search = searchesCopy[i];
+
+ // Filter on search type. Not all the searches implement this interface,
+ // in such a case just consider them delayed.
+ uint16_t searchType = nsIAutoCompleteSearchDescriptor::SEARCH_TYPE_DELAYED;
+ nsCOMPtr<nsIAutoCompleteSearchDescriptor> searchDesc =
+ do_QueryInterface(search);
+ if (searchDesc) searchDesc->GetSearchType(&searchType);
+ if (searchType != aSearchType) continue;
+
+ nsIAutoCompleteResult* result = mResultCache.SafeObjectAt(i);
+
+ if (result) {
+ uint16_t searchResult;
+ result->GetSearchResult(&searchResult);
+ if (searchResult != nsIAutoCompleteResult::RESULT_SUCCESS &&
+ searchResult != nsIAutoCompleteResult::RESULT_SUCCESS_ONGOING &&
+ searchResult != nsIAutoCompleteResult::RESULT_NOMATCH)
+ result = nullptr;
+ }
+
+ nsAutoString searchParam;
+ nsresult rv = input->GetSearchParam(searchParam);
+ if (NS_FAILED(rv)) return rv;
+
+ // FormFill expects the searchParam to only contain the input element id,
+ // other consumers may have other expectations, so this modifies it only
+ // for new consumers handling autoFill by themselves.
+ if (mProhibitAutoFill && mClearingAutoFillSearchesAgain) {
+ searchParam.AppendLiteral(" prohibit-autofill");
+ }
+
+ uint32_t userContextId;
+ rv = input->GetUserContextId(&userContextId);
+ if (NS_SUCCEEDED(rv) &&
+ userContextId != nsIScriptSecurityManager::DEFAULT_USER_CONTEXT_ID) {
+ searchParam.AppendLiteral(" user-context-id:");
+ searchParam.AppendInt(userContextId, 10);
+ }
+
+ rv = search->StartSearch(mSearchString, searchParam, result,
+ static_cast<nsIAutoCompleteObserver*>(this));
+ if (NS_FAILED(rv)) {
+ ++mSearchesFailed;
+ MOZ_ASSERT(mSearchesOngoing > 0);
+ --mSearchesOngoing;
+ }
+ // Because of the joy of nested event loops (which can easily happen when
+ // some code uses a generator for an asynchronous AutoComplete search),
+ // nsIAutoCompleteSearch::StartSearch might cause us to be detached from our
+ // input field. The next time we iterate, we'd be touching something that
+ // we shouldn't be, and result in a crash.
+ if (!mInput) {
+ // The search operation has been finished.
+ return NS_OK;
+ }
+ }
+
+ return NS_OK;
+}
+
+void nsAutoCompleteController::AfterSearches() {
+ mResultCache.Clear();
+ // if the below evaluates to true, that means mSearchesOngoing must be 0
+ if (mSearchesFailed == mSearches.Length()) {
+ PostSearchCleanup();
+ }
+}
+
+NS_IMETHODIMP
+nsAutoCompleteController::StopSearch() {
+ // Stop the timer if there is one
+ ClearSearchTimer();
+
+ // Stop any ongoing asynchronous searches
+ if (mSearchStatus == nsIAutoCompleteController::STATUS_SEARCHING) {
+ for (uint32_t i = 0; i < mSearches.Length(); ++i) {
+ nsCOMPtr<nsIAutoCompleteSearch> search = mSearches[i];
+ search->StopSearch();
+ }
+ mSearchesOngoing = 0;
+ // since we were searching, but now we've stopped,
+ // we need to call PostSearchCleanup()
+ PostSearchCleanup();
+ }
+ return NS_OK;
+}
+
+void nsAutoCompleteController::MaybeCompletePlaceholder() {
+ MOZ_ASSERT(mInput);
+
+ if (!mInput) { // or mInput depending on what you choose
+ MOZ_ASSERT_UNREACHABLE("Input should always be valid at this point");
+ return;
+ }
+
+ int32_t selectionStart;
+ mInput->GetSelectionStart(&selectionStart);
+ int32_t selectionEnd;
+ mInput->GetSelectionEnd(&selectionEnd);
+
+ // Check if the current input should be completed with the placeholder string
+ // from the last completion until the actual search results come back.
+ // The new input string needs to be compatible with the last completed string.
+ // E.g. if the new value is "fob", but the last completion was "foobar",
+ // then the last completion is incompatible.
+ // If the search string is the same as the last completion value, then don't
+ // complete the value again (this prevents completion to happen e.g. if the
+ // cursor is moved and StartSeaches() is invoked).
+ // In addition, the selection must be at the end of the current input to
+ // trigger the placeholder completion.
+ bool usePlaceholderCompletion =
+ !mUserClearedAutoFill && !mPlaceholderCompletionString.IsEmpty() &&
+ mPlaceholderCompletionString.Length() > mSearchString.Length() &&
+ selectionEnd == selectionStart &&
+ selectionEnd == (int32_t)mSearchString.Length() &&
+ StringBeginsWith(mPlaceholderCompletionString, mSearchString,
+ nsCaseInsensitiveStringComparator);
+
+ if (usePlaceholderCompletion) {
+ CompleteValue(mPlaceholderCompletionString);
+ } else {
+ mPlaceholderCompletionString.Truncate();
+ }
+}
+
+nsresult nsAutoCompleteController::StartSearches() {
+ // Don't create a new search timer if we're already waiting for one to fire.
+ // If we don't check for this, we won't be able to cancel the original timer
+ // and may crash when it fires (bug 236659).
+ if (mTimer || !mInput) return NS_OK;
+
+ nsCOMPtr<nsIAutoCompleteInput> input(mInput);
+
+ if (!mSearches.Length()) {
+ // Initialize our list of search objects
+ uint32_t searchCount;
+ input->GetSearchCount(&searchCount);
+ mResults.SetCapacity(searchCount);
+ mSearches.SetCapacity(searchCount);
+ mImmediateSearchesCount = 0;
+
+ const char* searchCID = kAutoCompleteSearchCID;
+
+ for (uint32_t i = 0; i < searchCount; ++i) {
+ // Use the search name to create the contract id string for the search
+ // service
+ nsAutoCString searchName;
+ input->GetSearchAt(i, searchName);
+ nsAutoCString cid(searchCID);
+ cid.Append(searchName);
+
+ // Use the created cid to get a pointer to the search service and store it
+ // for later
+ nsCOMPtr<nsIAutoCompleteSearch> search = do_GetService(cid.get());
+ if (search) {
+ mSearches.AppendObject(search);
+
+ // Count immediate searches.
+ nsCOMPtr<nsIAutoCompleteSearchDescriptor> searchDesc =
+ do_QueryInterface(search);
+ if (searchDesc) {
+ uint16_t searchType =
+ nsIAutoCompleteSearchDescriptor::SEARCH_TYPE_DELAYED;
+ if (NS_SUCCEEDED(searchDesc->GetSearchType(&searchType)) &&
+ searchType ==
+ nsIAutoCompleteSearchDescriptor::SEARCH_TYPE_IMMEDIATE) {
+ mImmediateSearchesCount++;
+ }
+
+ if (!mClearingAutoFillSearchesAgain) {
+ searchDesc->GetClearingAutoFillSearchesAgain(
+ &mClearingAutoFillSearchesAgain);
+ }
+ }
+ }
+ }
+ }
+
+ // Check if the current input should be completed with the placeholder string
+ // from the last completion until the actual search results come back.
+ MaybeCompletePlaceholder();
+
+ // Get the timeout for delayed searches.
+ uint32_t timeout;
+ input->GetTimeout(&timeout);
+
+ uint32_t immediateSearchesCount = mImmediateSearchesCount;
+ if (timeout == 0) {
+ // All the searches should be executed immediately.
+ immediateSearchesCount = mSearches.Length();
+ }
+
+ if (immediateSearchesCount > 0) {
+ nsresult rv = BeforeSearches();
+ if (NS_FAILED(rv)) return rv;
+ StartSearch(nsIAutoCompleteSearchDescriptor::SEARCH_TYPE_IMMEDIATE);
+
+ if (mSearches.Length() == immediateSearchesCount) {
+ // Either all searches are immediate, or the timeout is 0. In the
+ // latter case we still have to execute the delayed searches, otherwise
+ // this will be a no-op.
+ StartSearch(nsIAutoCompleteSearchDescriptor::SEARCH_TYPE_DELAYED);
+
+ // All the searches have been started, just finish.
+ AfterSearches();
+ return NS_OK;
+ }
+ }
+
+ MOZ_ASSERT(timeout > 0, "Trying to delay searches with a 0 timeout!");
+
+ // Now start the delayed searches.
+ return NS_NewTimerWithCallback(getter_AddRefs(mTimer), this, timeout,
+ nsITimer::TYPE_ONE_SHOT);
+}
+
+nsresult nsAutoCompleteController::ClearSearchTimer() {
+ if (mTimer) {
+ mTimer->Cancel();
+ mTimer = nullptr;
+ }
+ return NS_OK;
+}
+
+nsresult nsAutoCompleteController::EnterMatch(bool aIsPopupSelection,
+ dom::Event* aEvent) {
+ nsCOMPtr<nsIAutoCompleteInput> input(mInput);
+ nsCOMPtr<nsIAutoCompletePopup> popup(GetPopup());
+ NS_ENSURE_TRUE(popup != nullptr, NS_ERROR_FAILURE);
+
+ bool forceComplete;
+ input->GetForceComplete(&forceComplete);
+
+ int32_t selectedIndex;
+ popup->GetSelectedIndex(&selectedIndex);
+
+ // Ask the popup if it wants to enter a special value into the textbox
+ nsAutoString value;
+ nsAutoString comment;
+
+ popup->GetOverrideValue(value);
+ if (value.IsEmpty()) {
+ bool shouldComplete;
+ input->GetCompleteDefaultIndex(&shouldComplete);
+ bool completeSelection;
+ input->GetCompleteSelectedIndex(&completeSelection);
+
+ if (selectedIndex >= 0) {
+ nsAutoString inputValue;
+ input->GetTextValue(inputValue);
+ GetCommentAt(selectedIndex, comment);
+ if (aIsPopupSelection || !completeSelection) {
+ // We need to fill-in the value if:
+ // * completeselectedindex is false
+ // * A match in the popup was confirmed
+ GetResultValueAt(selectedIndex, true, value);
+ } else if (mDefaultIndexCompleted &&
+ inputValue.Equals(mPlaceholderCompletionString,
+ nsCaseInsensitiveStringComparator)) {
+ // We also need to fill-in the value if the default index completion was
+ // confirmed, though we cannot use the selectedIndex cause the selection
+ // may have been changed by the mouse in the meanwhile.
+ GetFinalDefaultCompleteValue(value);
+ } else if (mCompletedSelectionIndex != -1) {
+ // If completeselectedindex is true, and EnterMatch was not invoked by
+ // mouse-clicking a match (for example the user pressed Enter),
+ // don't fill in the value as it will have already been filled in as
+ // needed, unless the selected match has a final complete value that
+ // differs from the user-facing value.
+ nsAutoString finalValue;
+ GetResultValueAt(mCompletedSelectionIndex, true, finalValue);
+ if (!inputValue.Equals(finalValue)) {
+ value = finalValue;
+ }
+ }
+ } else if (shouldComplete) {
+ // We usually try to preserve the casing of what user has typed, but
+ // if he wants to autocomplete, we will replace the value with the
+ // actual autocomplete result.
+ // The user wants explicitely to use that result, so this ensures
+ // association of the result with the autocompleted text.
+ nsAutoString defaultIndexValue;
+ if (NS_SUCCEEDED(GetFinalDefaultCompleteValue(defaultIndexValue)))
+ value = defaultIndexValue;
+ }
+
+ if (forceComplete && value.IsEmpty() && shouldComplete) {
+ // See if inputValue is one of the autocomplete results. It can be an
+ // identical value, or if it matched the middle of a result it can be
+ // something like "bar >> foobar" (user entered bar and foobar is
+ // the result value).
+ // If the current search matches one of the autocomplete results, we
+ // should use that result, and not overwrite it with the default value.
+ // It's indeed possible EnterMatch gets called a second time (for example
+ // by the blur handler) and it should not overwrite the current match.
+ nsAutoString inputValue;
+ input->GetTextValue(inputValue);
+ nsAutoString suggestedValue;
+ int32_t pos = inputValue.Find(u" >> ");
+ if (pos > 0) {
+ inputValue.Right(suggestedValue, inputValue.Length() - pos - 4);
+ } else {
+ suggestedValue = inputValue;
+ }
+
+ for (uint32_t i = 0; i < mResults.Length(); ++i) {
+ nsIAutoCompleteResult* result = mResults[i];
+ if (result) {
+ uint32_t matchCount = 0;
+ result->GetMatchCount(&matchCount);
+ for (uint32_t j = 0; j < matchCount; ++j) {
+ nsAutoString matchValue;
+ result->GetValueAt(j, matchValue);
+ if (suggestedValue.Equals(matchValue,
+ nsCaseInsensitiveStringComparator)) {
+ nsAutoString finalMatchValue;
+ result->GetFinalCompleteValueAt(j, finalMatchValue);
+ value = finalMatchValue;
+ break;
+ }
+ }
+ }
+ }
+ // The value should have been set at this point. If not, then it's not
+ // a value that should be autocompleted.
+ } else if (forceComplete && value.IsEmpty() && completeSelection) {
+ // Since nothing was selected, and forceComplete is specified, that means
+ // we have to find the first default match and enter it instead.
+ for (uint32_t i = 0; i < mResults.Length(); ++i) {
+ nsIAutoCompleteResult* result = mResults[i];
+ if (result) {
+ int32_t defaultIndex;
+ result->GetDefaultIndex(&defaultIndex);
+ if (defaultIndex >= 0) {
+ result->GetFinalCompleteValueAt(defaultIndex, value);
+ break;
+ }
+ }
+ }
+ }
+ }
+
+ if (comment.IsEmpty()) {
+ comment.Assign(u"{}");
+ }
+
+ nsCOMPtr<nsIObserverService> obsSvc = services::GetObserverService();
+ NS_ENSURE_STATE(obsSvc);
+ obsSvc->NotifyObservers(input, "autocomplete-will-enter-text", comment.get());
+
+ if (!value.IsEmpty()) {
+ SetValueOfInputTo(value);
+ input->SelectTextRange(value.Length(), value.Length());
+ SetSearchStringInternal(value);
+ }
+
+ obsSvc->NotifyObservers(input, "autocomplete-did-enter-text", nullptr);
+
+ input->OnTextEntered(aEvent);
+
+ ClosePopup();
+
+ return NS_OK;
+}
+
+nsresult nsAutoCompleteController::RevertTextValue() {
+ // StopSearch() can call PostSearchCleanup() which might result
+ // in a blur event, which could null out mInput, so we need to check it
+ // again. See bug #408463 for more details
+ if (!mInput) return NS_OK;
+
+ nsCOMPtr<nsIAutoCompleteInput> input(mInput);
+
+ // If current input value is different from what we have set, it means
+ // somebody modified the value like JS of the web content. In such case,
+ // we shouldn't overwrite it with the old value.
+ nsAutoString currentValue;
+ input->GetTextValue(currentValue);
+ if (currentValue != mSetValue) {
+ SetSearchStringInternal(currentValue);
+ return NS_OK;
+ }
+
+ bool cancel = false;
+ input->OnTextReverted(&cancel);
+
+ if (!cancel) {
+ nsCOMPtr<nsIObserverService> obsSvc = services::GetObserverService();
+ NS_ENSURE_STATE(obsSvc);
+ obsSvc->NotifyObservers(input, "autocomplete-will-revert-text", nullptr);
+
+ // Don't change the value if it is the same to prevent sending useless
+ // events. NOTE: how can |RevertTextValue| be called with inputValue !=
+ // oldValue?
+ if (mSearchString != currentValue) {
+ SetValueOfInputTo(mSearchString);
+ }
+
+ obsSvc->NotifyObservers(input, "autocomplete-did-revert-text", nullptr);
+ }
+
+ return NS_OK;
+}
+
+nsresult nsAutoCompleteController::ProcessResult(
+ int32_t aSearchIndex, nsIAutoCompleteResult* aResult) {
+ NS_ENSURE_STATE(mInput);
+ MOZ_ASSERT(aResult, "ProcessResult should always receive a result");
+ NS_ENSURE_ARG(aResult);
+
+ uint16_t searchResult = 0;
+ aResult->GetSearchResult(&searchResult);
+
+ // The following code supports incremental updating results in 2 ways:
+ // * The search may reuse the same result, just by adding entries to it.
+ // * The search may send a new result every time. In this case we merge
+ // the results and proceed on the same code path as before.
+ // This way both mSearches and mResults can be indexed by the search index,
+ // cause we'll always have only one result per search.
+ if (mResults.IndexOf(aResult) == -1) {
+ nsIAutoCompleteResult* oldResult = mResults.SafeObjectAt(aSearchIndex);
+ if (oldResult) {
+ MOZ_ASSERT(false,
+ "Passing new matches to OnSearchResult with a new "
+ "nsIAutoCompleteResult every time is deprecated, please "
+ "update the same result until the search is done");
+ // Build a new nsIAutocompleteSimpleResult and merge results into it.
+ RefPtr<nsAutoCompleteSimpleResult> mergedResult =
+ new nsAutoCompleteSimpleResult();
+ mergedResult->AppendResult(oldResult);
+ mergedResult->AppendResult(aResult);
+ mResults.ReplaceObjectAt(mergedResult, aSearchIndex);
+ } else {
+ // This inserts and grows the array if needed.
+ mResults.ReplaceObjectAt(aResult, aSearchIndex);
+ }
+ }
+ // When found the result should have the same index as the search.
+ MOZ_ASSERT_IF(mResults.IndexOf(aResult) != -1,
+ mResults.IndexOf(aResult) == aSearchIndex);
+ MOZ_ASSERT(mResults.Count() >= aSearchIndex + 1,
+ "aSearchIndex should always be valid for mResults");
+
+ uint32_t oldMatchCount = mMatchCount;
+ // If the search failed, increase the match count to include the error
+ // description.
+ if (searchResult == nsIAutoCompleteResult::RESULT_FAILURE) {
+ nsAutoString error;
+ aResult->GetErrorDescription(error);
+ if (!error.IsEmpty()) {
+ ++mMatchCount;
+ }
+ } else if (searchResult == nsIAutoCompleteResult::RESULT_SUCCESS ||
+ searchResult == nsIAutoCompleteResult::RESULT_SUCCESS_ONGOING) {
+ // Increase the match count for all matches in this result.
+ uint32_t totalMatchCount = 0;
+ for (uint32_t i = 0; i < mResults.Length(); i++) {
+ nsIAutoCompleteResult* result = mResults.SafeObjectAt(i);
+ if (result) {
+ uint32_t matchCount = 0;
+ result->GetMatchCount(&matchCount);
+ totalMatchCount += matchCount;
+ }
+ }
+ uint32_t delta = totalMatchCount - oldMatchCount;
+ mMatchCount += delta;
+ }
+
+ // Try to autocomplete the default index for this search.
+ // Do this before invalidating so the binding knows about it.
+ CompleteDefaultIndex(aSearchIndex);
+
+ // Refresh the popup view to display the new search results
+ nsCOMPtr<nsIAutoCompletePopup> popup(GetPopup());
+ NS_ENSURE_TRUE(popup != nullptr, NS_ERROR_FAILURE);
+ popup->Invalidate(nsIAutoCompletePopup::INVALIDATE_REASON_NEW_RESULT);
+
+ return NS_OK;
+}
+
+nsresult nsAutoCompleteController::PostSearchCleanup() {
+ NS_ENSURE_STATE(mInput);
+ nsCOMPtr<nsIAutoCompleteInput> input(mInput);
+
+ uint32_t minResults;
+ input->GetMinResultsForPopup(&minResults);
+
+ if (mMatchCount || minResults == 0) {
+ OpenPopup();
+ } else if (mSearchesOngoing == 0) {
+ ClosePopup();
+ }
+
+ if (mSearchesOngoing == 0) {
+ mSearchStatus = mMatchCount
+ ? nsIAutoCompleteController::STATUS_COMPLETE_MATCH
+ : nsIAutoCompleteController::STATUS_COMPLETE_NO_MATCH;
+ // notify the input that the search is complete
+ input->OnSearchComplete();
+ }
+
+ return NS_OK;
+}
+
+nsresult nsAutoCompleteController::ClearResults(bool aIsSearching) {
+ int32_t oldMatchCount = mMatchCount;
+ mMatchCount = 0;
+ mResults.Clear();
+ if (oldMatchCount != 0) {
+ if (mInput) {
+ nsCOMPtr<nsIAutoCompletePopup> popup(GetPopup());
+ NS_ENSURE_TRUE(popup != nullptr, NS_ERROR_FAILURE);
+ // Clear the selection.
+ popup->SetSelectedIndex(-1);
+ }
+ }
+ return NS_OK;
+}
+
+nsresult nsAutoCompleteController::CompleteDefaultIndex(int32_t aResultIndex) {
+ if (mDefaultIndexCompleted || mProhibitAutoFill ||
+ mSearchString.Length() == 0 || !mInput)
+ return NS_OK;
+
+ nsCOMPtr<nsIAutoCompleteInput> input(mInput);
+
+ int32_t selectionStart;
+ input->GetSelectionStart(&selectionStart);
+ int32_t selectionEnd;
+ input->GetSelectionEnd(&selectionEnd);
+
+ bool isPlaceholderSelected =
+ selectionEnd == (int32_t)mPlaceholderCompletionString.Length() &&
+ selectionStart == (int32_t)mSearchString.Length() &&
+ StringBeginsWith(mPlaceholderCompletionString, mSearchString,
+ nsCaseInsensitiveStringComparator);
+
+ // Don't try to automatically complete to the first result if there's already
+ // a selection or the cursor isn't at the end of the input. In case the
+ // selection is from the current placeholder completion value, then still
+ // automatically complete.
+ if (!isPlaceholderSelected &&
+ (selectionEnd != selectionStart ||
+ selectionEnd != (int32_t)mSearchString.Length()))
+ return NS_OK;
+
+ bool shouldComplete;
+ input->GetCompleteDefaultIndex(&shouldComplete);
+ if (!shouldComplete) return NS_OK;
+
+ nsAutoString resultValue;
+ if (NS_SUCCEEDED(GetDefaultCompleteValue(aResultIndex, true, resultValue))) {
+ CompleteValue(resultValue);
+ mDefaultIndexCompleted = true;
+ } else {
+ // Reset the search string again, in case it was completed with
+ // mPlaceholderCompletionString, but the actually received result doesn't
+ // have a default index result. Only reset the input when necessary, to
+ // avoid triggering unnecessary new searches.
+ nsAutoString inputValue;
+ input->GetTextValue(inputValue);
+ if (!inputValue.Equals(mSearchString)) {
+ SetValueOfInputTo(mSearchString);
+ input->SelectTextRange(mSearchString.Length(), mSearchString.Length());
+ }
+ mPlaceholderCompletionString.Truncate();
+ }
+
+ return NS_OK;
+}
+
+nsresult nsAutoCompleteController::GetDefaultCompleteResult(
+ int32_t aResultIndex, nsIAutoCompleteResult** _result,
+ int32_t* _defaultIndex) {
+ *_defaultIndex = -1;
+ int32_t resultIndex = aResultIndex;
+
+ // If a result index was not provided, find the first defaultIndex result.
+ for (int32_t i = 0; resultIndex < 0 && i < mResults.Count(); ++i) {
+ nsIAutoCompleteResult* result = mResults.SafeObjectAt(i);
+ if (result && NS_SUCCEEDED(result->GetDefaultIndex(_defaultIndex)) &&
+ *_defaultIndex >= 0) {
+ resultIndex = i;
+ }
+ }
+ if (resultIndex < 0) {
+ return NS_ERROR_FAILURE;
+ }
+
+ *_result = mResults.SafeObjectAt(resultIndex);
+ NS_ENSURE_TRUE(*_result, NS_ERROR_FAILURE);
+
+ if (*_defaultIndex < 0) {
+ // The search must explicitly provide a default index in order
+ // for us to be able to complete.
+ (*_result)->GetDefaultIndex(_defaultIndex);
+ }
+
+ if (*_defaultIndex < 0) {
+ // We were given a result index, but that result doesn't want to
+ // be autocompleted.
+ return NS_ERROR_FAILURE;
+ }
+
+ // If the result wrongly notifies a RESULT_SUCCESS with no matches, or
+ // provides a defaultIndex greater than its matchCount, avoid trying to
+ // complete to an empty value.
+ uint32_t matchCount = 0;
+ (*_result)->GetMatchCount(&matchCount);
+ // Here defaultIndex is surely non-negative, so can be cast to unsigned.
+ if ((uint32_t)(*_defaultIndex) >= matchCount) {
+ return NS_ERROR_FAILURE;
+ }
+
+ return NS_OK;
+}
+
+nsresult nsAutoCompleteController::GetDefaultCompleteValue(int32_t aResultIndex,
+ bool aPreserveCasing,
+ nsAString& _retval) {
+ nsIAutoCompleteResult* result;
+ int32_t defaultIndex = -1;
+ nsresult rv = GetDefaultCompleteResult(aResultIndex, &result, &defaultIndex);
+ if (NS_FAILED(rv)) return rv;
+
+ nsAutoString resultValue;
+ result->GetValueAt(defaultIndex, resultValue);
+ if (aPreserveCasing && StringBeginsWith(resultValue, mSearchString,
+ nsCaseInsensitiveStringComparator)) {
+ // We try to preserve user casing, otherwise we would end up changing
+ // the case of what he typed, if we have a result with a different casing.
+ // For example if we have result "Test", and user starts writing "tuna",
+ // after digiting t, we would convert it to T trying to autocomplete "Test".
+ // We will still complete to cased "Test" if the user explicitely choose
+ // that result, by either selecting it in the results popup, or with
+ // keyboard navigation or if autocompleting in the middle.
+ nsAutoString casedResultValue;
+ casedResultValue.Assign(mSearchString);
+ // Use what the user has typed so far.
+ casedResultValue.Append(
+ Substring(resultValue, mSearchString.Length(), resultValue.Length()));
+ _retval = casedResultValue;
+ } else
+ _retval = resultValue;
+
+ return NS_OK;
+}
+
+nsresult nsAutoCompleteController::GetFinalDefaultCompleteValue(
+ nsAString& _retval) {
+ MOZ_ASSERT(mInput, "Must have a valid input");
+ nsCOMPtr<nsIAutoCompleteInput> input(mInput);
+ nsIAutoCompleteResult* result;
+ int32_t defaultIndex = -1;
+ nsresult rv = GetDefaultCompleteResult(-1, &result, &defaultIndex);
+ if (NS_FAILED(rv)) return rv;
+
+ result->GetValueAt(defaultIndex, _retval);
+ nsAutoString inputValue;
+ input->GetTextValue(inputValue);
+ if (!_retval.Equals(inputValue, nsCaseInsensitiveStringComparator)) {
+ return NS_ERROR_FAILURE;
+ }
+
+ nsAutoString finalCompleteValue;
+ rv = result->GetFinalCompleteValueAt(defaultIndex, finalCompleteValue);
+ if (NS_SUCCEEDED(rv)) {
+ _retval = finalCompleteValue;
+ }
+
+ return NS_OK;
+}
+
+nsresult nsAutoCompleteController::CompleteValue(nsString& aValue)
+/* mInput contains mSearchString, which we want to autocomplete to aValue. If
+ * selectDifference is true, select the remaining portion of aValue not
+ * contained in mSearchString. */
+{
+ MOZ_ASSERT(mInput, "Must have a valid input");
+
+ nsCOMPtr<nsIAutoCompleteInput> input(mInput);
+ const int32_t mSearchStringLength = mSearchString.Length();
+ int32_t endSelect = aValue.Length(); // By default, select all of aValue.
+
+ if (aValue.IsEmpty() || StringBeginsWith(aValue, mSearchString,
+ nsCaseInsensitiveStringComparator)) {
+ // aValue is empty (we were asked to clear mInput), or mSearchString
+ // matches the beginning of aValue. In either case we can simply
+ // autocomplete to aValue.
+ mPlaceholderCompletionString = aValue;
+ SetValueOfInputTo(aValue);
+ } else {
+ nsresult rv;
+ nsCOMPtr<nsIIOService> ios = do_GetService(NS_IOSERVICE_CONTRACTID, &rv);
+ NS_ENSURE_SUCCESS(rv, rv);
+ nsAutoCString scheme;
+ if (NS_SUCCEEDED(
+ ios->ExtractScheme(NS_ConvertUTF16toUTF8(aValue), scheme))) {
+ // Trying to autocomplete a URI from somewhere other than the beginning.
+ // Only succeed if the missing portion is "http://"; otherwise do not
+ // autocomplete. This prevents us from "helpfully" autocompleting to a
+ // URI that isn't equivalent to what the user expected.
+ const int32_t findIndex = 7; // length of "http://"
+
+ if ((endSelect < findIndex + mSearchStringLength) ||
+ !scheme.EqualsLiteral("http") ||
+ !Substring(aValue, findIndex, mSearchStringLength)
+ .Equals(mSearchString, nsCaseInsensitiveStringComparator)) {
+ return NS_OK;
+ }
+
+ mPlaceholderCompletionString =
+ mSearchString +
+ Substring(aValue, mSearchStringLength + findIndex, endSelect);
+ SetValueOfInputTo(mPlaceholderCompletionString);
+
+ endSelect -= findIndex; // We're skipping this many characters of aValue.
+ } else {
+ // Autocompleting something other than a URI from the middle.
+ // Use the format "searchstring >> full string" to indicate to the user
+ // what we are going to replace their search string with.
+ SetValueOfInputTo(mSearchString + u" >> "_ns + aValue);
+
+ endSelect = mSearchString.Length() + 4 + aValue.Length();
+
+ // Reset the last search completion.
+ mPlaceholderCompletionString.Truncate();
+ }
+ }
+
+ input->SelectTextRange(mSearchStringLength, endSelect);
+
+ return NS_OK;
+}
+
+nsresult nsAutoCompleteController::GetResultLabelAt(int32_t aIndex,
+ nsAString& _retval) {
+ return GetResultValueLabelAt(aIndex, false, false, _retval);
+}
+
+nsresult nsAutoCompleteController::GetResultValueAt(int32_t aIndex,
+ bool aGetFinalValue,
+ nsAString& _retval) {
+ return GetResultValueLabelAt(aIndex, aGetFinalValue, true, _retval);
+}
+
+nsresult nsAutoCompleteController::GetResultValueLabelAt(int32_t aIndex,
+ bool aGetFinalValue,
+ bool aGetValue,
+ nsAString& _retval) {
+ NS_ENSURE_TRUE(aIndex >= 0 && static_cast<uint32_t>(aIndex) < mMatchCount,
+ NS_ERROR_ILLEGAL_VALUE);
+
+ int32_t matchIndex;
+ nsIAutoCompleteResult* result;
+ nsresult rv = GetResultAt(aIndex, &result, &matchIndex);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ uint16_t searchResult;
+ result->GetSearchResult(&searchResult);
+
+ if (searchResult == nsIAutoCompleteResult::RESULT_FAILURE) {
+ if (aGetValue) return NS_ERROR_FAILURE;
+ result->GetErrorDescription(_retval);
+ } else if (searchResult == nsIAutoCompleteResult::RESULT_SUCCESS ||
+ searchResult == nsIAutoCompleteResult::RESULT_SUCCESS_ONGOING) {
+ if (aGetFinalValue) {
+ // Some implementations may miss finalCompleteValue, try to be backwards
+ // compatible.
+ if (NS_FAILED(result->GetFinalCompleteValueAt(matchIndex, _retval))) {
+ result->GetValueAt(matchIndex, _retval);
+ }
+ } else if (aGetValue) {
+ result->GetValueAt(matchIndex, _retval);
+ } else {
+ result->GetLabelAt(matchIndex, _retval);
+ }
+ }
+
+ return NS_OK;
+}
+
+/**
+ * Given the index of a match in the autocomplete popup, find the
+ * corresponding nsIAutoCompleteSearch index, and sub-index into
+ * the search's results list.
+ */
+nsresult nsAutoCompleteController::MatchIndexToSearch(int32_t aMatchIndex,
+ int32_t* aSearchIndex,
+ int32_t* aItemIndex) {
+ *aSearchIndex = -1;
+ *aItemIndex = -1;
+
+ uint32_t index = 0;
+
+ // Move index through the results of each registered nsIAutoCompleteSearch
+ // until we find the given match
+ for (uint32_t i = 0; i < mSearches.Length(); ++i) {
+ nsIAutoCompleteResult* result = mResults.SafeObjectAt(i);
+ if (!result) continue;
+
+ uint32_t matchCount = 0;
+
+ uint16_t searchResult;
+ result->GetSearchResult(&searchResult);
+
+ // Find out how many results were provided by the
+ // current nsIAutoCompleteSearch.
+ if (searchResult == nsIAutoCompleteResult::RESULT_SUCCESS ||
+ searchResult == nsIAutoCompleteResult::RESULT_SUCCESS_ONGOING) {
+ result->GetMatchCount(&matchCount);
+ }
+
+ // If the given match index is within the results range
+ // of the current nsIAutoCompleteSearch then return the
+ // search index and sub-index into the results array
+ if ((matchCount != 0) &&
+ (index + matchCount - 1 >= (uint32_t)aMatchIndex)) {
+ *aSearchIndex = i;
+ *aItemIndex = aMatchIndex - index;
+ return NS_OK;
+ }
+
+ // Advance the popup table index cursor past the
+ // results of the current search.
+ index += matchCount;
+ }
+
+ return NS_OK;
+}
diff --git a/toolkit/components/autocomplete/nsAutoCompleteController.h b/toolkit/components/autocomplete/nsAutoCompleteController.h
new file mode 100644
index 0000000000..7e6d8a3b06
--- /dev/null
+++ b/toolkit/components/autocomplete/nsAutoCompleteController.h
@@ -0,0 +1,217 @@
+/* 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/. */
+
+#ifndef __nsAutoCompleteController__
+#define __nsAutoCompleteController__
+
+#include "nsIAutoCompleteController.h"
+
+#include "nsCOMPtr.h"
+#include "nsIAutoCompleteInput.h"
+#include "nsIAutoCompletePopup.h"
+#include "nsIAutoCompleteResult.h"
+#include "nsIAutoCompleteSearch.h"
+#include "nsINamed.h"
+#include "nsString.h"
+#include "nsITimer.h"
+#include "nsTArray.h"
+#include "nsCOMArray.h"
+#include "nsCycleCollectionParticipant.h"
+#include "mozilla/dom/Element.h"
+
+class nsAutoCompleteController final : public nsIAutoCompleteController,
+ public nsIAutoCompleteObserver,
+ public nsITimerCallback,
+ public nsINamed {
+ public:
+ NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+ NS_DECL_CYCLE_COLLECTION_CLASS_AMBIGUOUS(nsAutoCompleteController,
+ nsIAutoCompleteController)
+ NS_DECL_NSIAUTOCOMPLETECONTROLLER
+ NS_DECL_NSIAUTOCOMPLETEOBSERVER
+ NS_DECL_NSITIMERCALLBACK
+ NS_DECL_NSINAMED
+
+ nsAutoCompleteController();
+
+ protected:
+ MOZ_CAN_RUN_SCRIPT virtual ~nsAutoCompleteController();
+
+ /**
+ * SetValueOfInputTo() sets value of mInput to aValue.
+ */
+ void SetValueOfInputTo(const nsString& aValue);
+
+ /**
+ * SetSearchStringInternal() sets both mSearchString and mSetValue to
+ * aSearchString.
+ */
+ void SetSearchStringInternal(const nsAString& aSearchString) {
+ mSearchString = mSetValue = aSearchString;
+ }
+
+ MOZ_CAN_RUN_SCRIPT nsresult OpenPopup();
+ MOZ_CAN_RUN_SCRIPT nsresult ClosePopup();
+
+ nsresult StartSearch(uint16_t aSearchType);
+
+ nsresult BeforeSearches();
+ MOZ_CAN_RUN_SCRIPT nsresult StartSearches();
+ MOZ_CAN_RUN_SCRIPT void AfterSearches();
+ nsresult ClearSearchTimer();
+ void MaybeCompletePlaceholder();
+
+ MOZ_CAN_RUN_SCRIPT nsresult ProcessResult(int32_t aSearchIndex,
+ nsIAutoCompleteResult* aResult);
+ MOZ_CAN_RUN_SCRIPT nsresult PostSearchCleanup();
+
+ MOZ_CAN_RUN_SCRIPT nsresult EnterMatch(bool aIsPopupSelection,
+ mozilla::dom::Event* aEvent);
+ nsresult RevertTextValue();
+
+ nsresult CompleteDefaultIndex(int32_t aResultIndex);
+ nsresult CompleteValue(nsString& aValue);
+
+ nsresult GetResultAt(int32_t aIndex, nsIAutoCompleteResult** aResult,
+ int32_t* aMatchIndex);
+ nsresult GetResultValueAt(int32_t aIndex, bool aGetFinalValue,
+ nsAString& _retval);
+ nsresult GetResultLabelAt(int32_t aIndex, nsAString& _retval);
+
+ /**
+ * Returns autocomplete popup for the autocomplete input. nsIAutoCompleteInput
+ * can be implemented two different ways to return a popup. The first one is
+ * to return a popup object implementing nsIAutoCompletePopup interface,
+ * the second one is a DOM element representing a popup and implementing
+ * that interface.
+ */
+ already_AddRefed<nsIAutoCompletePopup> GetPopup() {
+ nsCOMPtr<nsIAutoCompletePopup> popup;
+ mInput->GetPopup(getter_AddRefs(popup));
+ if (popup) {
+ return popup.forget();
+ }
+
+ nsCOMPtr<mozilla::dom::Element> popupEl;
+ mInput->GetPopupElement(getter_AddRefs(popupEl));
+ if (popupEl) {
+ return popupEl->AsAutoCompletePopup();
+ }
+ return nullptr;
+ }
+
+ private:
+ nsresult GetResultValueLabelAt(int32_t aIndex, bool aGetFinalValue,
+ bool aGetValue, nsAString& _retval);
+
+ /**
+ * Gets and validates the defaultComplete result and the relative
+ * defaultIndex value.
+ *
+ * @param aResultIndex
+ * Index of the defaultComplete result to be used. Pass -1 to search
+ * for the first result providing a valid defaultIndex.
+ * @param _result
+ * The found result.
+ * @param _defaultIndex
+ * The defaultIndex relative to _result.
+ */
+ nsresult GetDefaultCompleteResult(int32_t aResultIndex,
+ nsIAutoCompleteResult** _result,
+ int32_t* _defaultIndex);
+
+ /**
+ * Gets the defaultComplete value to be suggested to the user.
+ *
+ * @param aResultIndex
+ * Index of the defaultComplete result to be used.
+ * @param aPreserveCasing
+ * Whether user casing should be preserved.
+ * @param _retval
+ * The value to be completed.
+ */
+ nsresult GetDefaultCompleteValue(int32_t aResultIndex, bool aPreserveCasing,
+ nsAString& _retval);
+
+ /**
+ * Gets the defaultComplete value to be used when the user confirms the
+ * current match.
+ * The value is returned only if it case-insensitively matches the current
+ * input text, otherwise the method returns NS_ERROR_FAILURE.
+ * This happens because we don't want to replace text if the user backspaces
+ * just before Enter.
+ *
+ * @param _retval
+ * The value to be completed.
+ */
+ nsresult GetFinalDefaultCompleteValue(nsAString& _retval);
+
+ nsresult ClearResults(bool aIsSearching = false);
+
+ nsresult MatchIndexToSearch(int32_t aMatchIndex, int32_t* aSearchIndex,
+ int32_t* aItemIndex);
+
+ // members //////////////////////////////////////////
+
+ nsCOMPtr<nsIAutoCompleteInput> mInput;
+
+ nsCOMArray<nsIAutoCompleteSearch> mSearches;
+ // This is used as a sparse array, always use SafeObjectAt to access it.
+ nsCOMArray<nsIAutoCompleteResult> mResults;
+ // Temporarily keeps the results alive while invoking startSearch() for each
+ // search. This is needed to allow the searches to reuse the previous result,
+ // since otherwise the first search clears mResults.
+ nsCOMArray<nsIAutoCompleteResult> mResultCache;
+
+ nsCOMPtr<nsITimer> mTimer;
+
+ // mSearchString stores value which is the original value of the input or
+ // typed by the user. When user is choosing an item from the popup, this
+ // is NOT modified by the item because this is used for reverting the input
+ // value when user cancels choosing an item from the popup.
+ // This should be set through only SetSearchStringInternal().
+ nsString mSearchString;
+ nsString mPlaceholderCompletionString;
+ // mSetValue stores value which is expected in the input. So, if input's
+ // value and mSetValue are different, it means somebody has changed the
+ // value like JS of the web content.
+ // This is set only by SetValueOfInputTo() or when modifying mSearchString
+ // through SetSearchStringInternal().
+ nsString mSetValue;
+ bool mDefaultIndexCompleted;
+ bool mPopupClosedByCompositionStart;
+
+ // Whether autofill is allowed for the next search. May be retrieved by the
+ // search through the "prohibit-autofill" searchParam.
+ bool mProhibitAutoFill;
+
+ // Indicates whether the user cleared the autofilled part, returning to the
+ // originally entered search string.
+ bool mUserClearedAutoFill;
+
+ // Indicates whether clearing the autofilled string should issue a new search.
+ bool mClearingAutoFillSearchesAgain;
+
+ enum CompositionState {
+ eCompositionState_None,
+ eCompositionState_Composing,
+ eCompositionState_Committing
+ };
+ CompositionState mCompositionState;
+ uint16_t mSearchStatus;
+ uint32_t mMatchCount;
+ uint32_t mSearchesOngoing;
+ uint32_t mSearchesFailed;
+ uint32_t mImmediateSearchesCount;
+ // The index of the match on the popup that was selected using the keyboard,
+ // if the completeselectedindex attribute is set.
+ // This is used to distinguish that selection (which would have been put in
+ // the input on being selected) from a moused-over selectedIndex value. This
+ // distinction is used to prevent mouse moves from inadvertently changing
+ // what happens once the user hits Enter on the keyboard.
+ // See bug 1043584 for more details.
+ int32_t mCompletedSelectionIndex;
+};
+
+#endif /* __nsAutoCompleteController__ */
diff --git a/toolkit/components/autocomplete/nsAutoCompleteSimpleResult.cpp b/toolkit/components/autocomplete/nsAutoCompleteSimpleResult.cpp
new file mode 100644
index 0000000000..94e970132d
--- /dev/null
+++ b/toolkit/components/autocomplete/nsAutoCompleteSimpleResult.cpp
@@ -0,0 +1,256 @@
+/* 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 "nsAutoCompleteSimpleResult.h"
+
+#define CHECK_MATCH_INDEX(_index, _insert) \
+ if (_index < 0 || \
+ static_cast<MatchesArray::size_type>(_index) > mMatches.Length() || \
+ (!_insert && \
+ static_cast<MatchesArray::size_type>(_index) == mMatches.Length())) { \
+ MOZ_ASSERT(false, "Trying to use an invalid index on mMatches"); \
+ return NS_ERROR_ILLEGAL_VALUE; \
+ }
+
+NS_IMPL_ISUPPORTS(nsAutoCompleteSimpleResult, nsIAutoCompleteResult,
+ nsIAutoCompleteSimpleResult)
+
+nsAutoCompleteSimpleResult::nsAutoCompleteSimpleResult()
+ : mDefaultIndex(-1), mSearchResult(RESULT_NOMATCH) {}
+
+nsresult nsAutoCompleteSimpleResult::AppendResult(
+ nsIAutoCompleteResult* aResult) {
+ nsAutoString searchString;
+ nsresult rv = aResult->GetSearchString(searchString);
+ NS_ENSURE_SUCCESS(rv, rv);
+ mSearchString = searchString;
+
+ uint16_t searchResult;
+ rv = aResult->GetSearchResult(&searchResult);
+ NS_ENSURE_SUCCESS(rv, rv);
+ mSearchResult = searchResult;
+
+ nsAutoString errorDescription;
+ if (NS_SUCCEEDED(aResult->GetErrorDescription(errorDescription)) &&
+ !errorDescription.IsEmpty()) {
+ mErrorDescription = errorDescription;
+ }
+
+ int32_t defaultIndex = -1;
+ if (NS_SUCCEEDED(aResult->GetDefaultIndex(&defaultIndex)) &&
+ defaultIndex >= 0) {
+ mDefaultIndex = defaultIndex;
+ }
+
+ nsCOMPtr<nsIAutoCompleteSimpleResult> simpleResult =
+ do_QueryInterface(aResult);
+ if (simpleResult) {
+ nsCOMPtr<nsIAutoCompleteSimpleResultListener> listener;
+ if (NS_SUCCEEDED(simpleResult->GetListener(getter_AddRefs(listener))) &&
+ listener) {
+ listener.swap(mListener);
+ }
+ }
+
+ // Copy matches.
+ uint32_t matchCount = 0;
+ rv = aResult->GetMatchCount(&matchCount);
+ NS_ENSURE_SUCCESS(rv, rv);
+ for (size_t i = 0; i < matchCount; ++i) {
+ nsAutoString value, comment, image, style, finalCompleteValue, label;
+
+ rv = aResult->GetValueAt(i, value);
+ NS_ENSURE_SUCCESS(rv, rv);
+ rv = aResult->GetCommentAt(i, comment);
+ NS_ENSURE_SUCCESS(rv, rv);
+ rv = aResult->GetImageAt(i, image);
+ NS_ENSURE_SUCCESS(rv, rv);
+ rv = aResult->GetStyleAt(i, style);
+ NS_ENSURE_SUCCESS(rv, rv);
+ rv = aResult->GetFinalCompleteValueAt(i, finalCompleteValue);
+ NS_ENSURE_SUCCESS(rv, rv);
+ rv = aResult->GetLabelAt(i, label);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ rv = AppendMatch(value, comment, image, style, finalCompleteValue, label);
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+
+ return NS_OK;
+}
+
+// searchString
+NS_IMETHODIMP
+nsAutoCompleteSimpleResult::GetSearchString(nsAString& aSearchString) {
+ aSearchString = mSearchString;
+ return NS_OK;
+}
+NS_IMETHODIMP
+nsAutoCompleteSimpleResult::SetSearchString(const nsAString& aSearchString) {
+ mSearchString.Assign(aSearchString);
+ return NS_OK;
+}
+
+// searchResult
+NS_IMETHODIMP
+nsAutoCompleteSimpleResult::GetSearchResult(uint16_t* aSearchResult) {
+ *aSearchResult = mSearchResult;
+ return NS_OK;
+}
+NS_IMETHODIMP
+nsAutoCompleteSimpleResult::SetSearchResult(uint16_t aSearchResult) {
+ mSearchResult = aSearchResult;
+ return NS_OK;
+}
+
+// defaultIndex
+NS_IMETHODIMP
+nsAutoCompleteSimpleResult::GetDefaultIndex(int32_t* aDefaultIndex) {
+ *aDefaultIndex = mDefaultIndex;
+ return NS_OK;
+}
+NS_IMETHODIMP
+nsAutoCompleteSimpleResult::SetDefaultIndex(int32_t aDefaultIndex) {
+ mDefaultIndex = aDefaultIndex;
+ return NS_OK;
+}
+
+// errorDescription
+NS_IMETHODIMP
+nsAutoCompleteSimpleResult::GetErrorDescription(nsAString& aErrorDescription) {
+ aErrorDescription = mErrorDescription;
+ return NS_OK;
+}
+NS_IMETHODIMP
+nsAutoCompleteSimpleResult::SetErrorDescription(
+ const nsAString& aErrorDescription) {
+ mErrorDescription.Assign(aErrorDescription);
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteSimpleResult::InsertMatchAt(
+ int32_t aIndex, const nsAString& aValue, const nsAString& aComment,
+ const nsAString& aImage, const nsAString& aStyle,
+ const nsAString& aFinalCompleteValue, const nsAString& aLabel) {
+ CHECK_MATCH_INDEX(aIndex, true);
+
+ AutoCompleteSimpleResultMatch match(aValue, aComment, aImage, aStyle,
+ aFinalCompleteValue, aLabel);
+
+ // XXX(Bug 1631371) Check if this should use a fallible operation as it
+ // pretended earlier.
+ mMatches.InsertElementAt(aIndex, match);
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteSimpleResult::AppendMatch(const nsAString& aValue,
+ const nsAString& aComment,
+ const nsAString& aImage,
+ const nsAString& aStyle,
+ const nsAString& aFinalCompleteValue,
+ const nsAString& aLabel) {
+ return InsertMatchAt(mMatches.Length(), aValue, aComment, aImage, aStyle,
+ aFinalCompleteValue, aLabel);
+}
+
+NS_IMETHODIMP
+nsAutoCompleteSimpleResult::RemoveMatchAt(int32_t aIndex) {
+ CHECK_MATCH_INDEX(aIndex, false);
+
+ mMatches.RemoveElementAt(aIndex);
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteSimpleResult::GetMatchCount(uint32_t* aMatchCount) {
+ *aMatchCount = mMatches.Length();
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteSimpleResult::GetValueAt(int32_t aIndex, nsAString& _retval) {
+ CHECK_MATCH_INDEX(aIndex, false);
+ _retval = mMatches[aIndex].mValue;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteSimpleResult::GetLabelAt(int32_t aIndex, nsAString& _retval) {
+ CHECK_MATCH_INDEX(aIndex, false);
+ _retval = mMatches[aIndex].mLabel;
+ if (_retval.IsEmpty()) {
+ _retval = mMatches[aIndex].mValue;
+ }
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteSimpleResult::GetCommentAt(int32_t aIndex, nsAString& _retval) {
+ CHECK_MATCH_INDEX(aIndex, false);
+ _retval = mMatches[aIndex].mComment;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteSimpleResult::GetImageAt(int32_t aIndex, nsAString& _retval) {
+ CHECK_MATCH_INDEX(aIndex, false);
+ _retval = mMatches[aIndex].mImage;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteSimpleResult::GetStyleAt(int32_t aIndex, nsAString& _retval) {
+ CHECK_MATCH_INDEX(aIndex, false);
+ _retval = mMatches[aIndex].mStyle;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteSimpleResult::GetFinalCompleteValueAt(int32_t aIndex,
+ nsAString& _retval) {
+ CHECK_MATCH_INDEX(aIndex, false);
+ _retval = mMatches[aIndex].mFinalCompleteValue;
+ if (_retval.IsEmpty()) {
+ _retval = mMatches[aIndex].mValue;
+ }
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteSimpleResult::SetListener(
+ nsIAutoCompleteSimpleResultListener* aListener) {
+ mListener = aListener;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteSimpleResult::GetListener(
+ nsIAutoCompleteSimpleResultListener** aListener) {
+ nsCOMPtr<nsIAutoCompleteSimpleResultListener> listener(mListener);
+ listener.forget(aListener);
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteSimpleResult::IsRemovableAt(int32_t aRowIndex, bool* _retval) {
+ *_retval = true;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteSimpleResult::RemoveValueAt(int32_t aRowIndex) {
+ CHECK_MATCH_INDEX(aRowIndex, false);
+
+ nsString value = mMatches[aRowIndex].mValue;
+ mMatches.RemoveElementAt(aRowIndex);
+
+ if (mListener) {
+ mListener->OnValueRemoved(this, value);
+ }
+
+ return NS_OK;
+}
diff --git a/toolkit/components/autocomplete/nsAutoCompleteSimpleResult.h b/toolkit/components/autocomplete/nsAutoCompleteSimpleResult.h
new file mode 100644
index 0000000000..0b2b482e71
--- /dev/null
+++ b/toolkit/components/autocomplete/nsAutoCompleteSimpleResult.h
@@ -0,0 +1,63 @@
+/* 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/. */
+
+#ifndef __nsAutoCompleteSimpleResult__
+#define __nsAutoCompleteSimpleResult__
+
+#include "nsIAutoCompleteResult.h"
+#include "nsIAutoCompleteSimpleResult.h"
+
+#include "nsString.h"
+#include "nsCOMPtr.h"
+#include "nsTArray.h"
+#include "mozilla/Attributes.h"
+
+struct AutoCompleteSimpleResultMatch {
+ AutoCompleteSimpleResultMatch(const nsAString& aValue,
+ const nsAString& aComment,
+ const nsAString& aImage,
+ const nsAString& aStyle,
+ const nsAString& aFinalCompleteValue,
+ const nsAString& aLabel)
+ : mValue(aValue),
+ mComment(aComment),
+ mImage(aImage),
+ mStyle(aStyle),
+ mFinalCompleteValue(aFinalCompleteValue),
+ mLabel(aLabel) {}
+
+ nsString mValue;
+ nsString mComment;
+ nsString mImage;
+ nsString mStyle;
+ nsString mFinalCompleteValue;
+ nsString mLabel;
+};
+
+class nsAutoCompleteSimpleResult final : public nsIAutoCompleteSimpleResult {
+ public:
+ nsAutoCompleteSimpleResult();
+
+ NS_DECL_ISUPPORTS
+ NS_DECL_NSIAUTOCOMPLETERESULT
+ NS_DECL_NSIAUTOCOMPLETESIMPLERESULT
+
+ nsresult AppendResult(nsIAutoCompleteResult* aResult);
+
+ private:
+ ~nsAutoCompleteSimpleResult() = default;
+
+ protected:
+ typedef nsTArray<AutoCompleteSimpleResultMatch> MatchesArray;
+ MatchesArray mMatches;
+
+ nsString mSearchString;
+ nsString mErrorDescription;
+ int32_t mDefaultIndex;
+ uint32_t mSearchResult;
+
+ nsCOMPtr<nsIAutoCompleteSimpleResultListener> mListener;
+};
+
+#endif // __nsAutoCompleteSimpleResult__
diff --git a/toolkit/components/autocomplete/nsIAutoCompleteController.idl b/toolkit/components/autocomplete/nsIAutoCompleteController.idl
new file mode 100644
index 0000000000..148e704b4c
--- /dev/null
+++ b/toolkit/components/autocomplete/nsIAutoCompleteController.idl
@@ -0,0 +1,182 @@
+/* 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 "nsISupports.idl"
+
+interface nsIAutoCompleteInput;
+
+webidl Event;
+
+[scriptable, uuid(ff9f8465-204a-47a6-b3c9-0628b3856684)]
+interface nsIAutoCompleteController : nsISupports
+{
+ /*
+ * Possible values for the searchStatus attribute
+ */
+ const unsigned short STATUS_NONE = 1;
+ const unsigned short STATUS_SEARCHING = 2;
+ const unsigned short STATUS_COMPLETE_NO_MATCH = 3;
+ const unsigned short STATUS_COMPLETE_MATCH = 4;
+
+ /*
+ * The input widget that is currently being controlled.
+ */
+ [setter_can_run_script]
+ attribute nsIAutoCompleteInput input;
+
+ /*
+ * State which indicates the status of possible ongoing searches
+ */
+ readonly attribute unsigned short searchStatus;
+
+ /*
+ * The number of matches
+ */
+ readonly attribute unsigned long matchCount;
+
+ /*
+ * Start a search on a string, assuming the input property is already set.
+ */
+ [can_run_script] void startSearch(in AString searchString);
+
+ /*
+ * Stop all asynchronous searches
+ */
+ [can_run_script] void stopSearch();
+
+ /*
+ * Notify the controller that the user has changed text in the textbox.
+ * This includes all means of changing the text value, including typing a
+ * character, backspacing, deleting, pasting, committing composition or
+ * canceling composition.
+ *
+ * NOTE: handleText() must be called after composition actually ends, even if
+ * the composition is canceled and the textbox value isn't changed.
+ * Then, implementation of handleText() can access the editor when
+ * it's not in composing mode. DOM compositionend event is not good
+ * timing for calling handleText(). DOM input event immediately after
+ * DOM compositionend event is the best timing to call this.
+ *
+ * @return whether this handler started a new search.
+ */
+ [can_run_script] boolean handleText();
+
+ /*
+ * Notify the controller that the user wishes to enter the current text. If
+ * aIsPopupSelection is true, then a selection was made from the popup, so
+ * fill this value into the input field before continuing. If false, just
+ * use the current value of the input field.
+ *
+ * @param aIsPopupSelection
+ * Pass true if the selection was made from the popup.
+ * @param aEvent
+ * The event that triggered the enter, like a key event if the user
+ * pressed the Return key or a click event if the user clicked a popup
+ * item.
+ * @return Whether the controller wishes to prevent event propagation and
+ * default event.
+ */
+ [can_run_script] boolean handleEnter(in boolean aIsPopupSelection,
+ [optional] in Event aEvent);
+
+ /*
+ * Notify the controller that the user wishes to revert autocomplete
+ *
+ * @return Whether the controller wishes to prevent event propagation and
+ * default event.
+ */
+ [can_run_script] boolean handleEscape();
+
+ /*
+ * Notify the controller that the user wishes to start composition
+ *
+ * NOTE: nsIAutoCompleteController implementation expects that this is called
+ * by DOM compositionstart handler.
+ */
+ [can_run_script] void handleStartComposition();
+
+ /*
+ * Notify the controller that the user wishes to end composition
+ *
+ * NOTE: nsIAutoCompleteController implementation expects that this is called
+ * by DOM compositionend handler.
+ */
+ void handleEndComposition();
+
+ /*
+ * Handle tab. Just closes up.
+ */
+ [can_run_script] void handleTab();
+
+ /*
+ * Notify the controller of the following key navigation events:
+ * up, down, left, right, page up, page down
+ *
+ * @return Whether the controller wishes to prevent event propagation and
+ * default event
+ */
+ [can_run_script] boolean handleKeyNavigation(in unsigned long key);
+
+ /*
+ * Notify the controller that the user chose to delete the current
+ * auto-complete result.
+ *
+ * @return Whether the controller removed a result item.
+ */
+ [can_run_script] boolean handleDelete();
+
+ /*
+ * Get the value of the result at a given index in the last completed search
+ */
+ AString getValueAt(in long index);
+
+ /*
+ * Get the label of the result at a given index in the last completed search
+ */
+ AString getLabelAt(in long index);
+
+ /*
+ * Get the comment of the result at a given index in the last completed search
+ */
+ AString getCommentAt(in long index);
+
+ /*
+ * Get the style hint for the result at a given index in the last completed search
+ */
+ AString getStyleAt(in long index);
+
+ /*
+ * Get the url of the image of the result at a given index in the last completed search
+ */
+ AString getImageAt(in long index);
+
+ /*
+ * For the last completed search, get the final value that should be completed
+ * when the user confirms the match at the given index
+ */
+ AString getFinalCompleteValueAt(in long index);
+
+ /*
+ * Get / set the current search string. Note, setting will not start searching
+ */
+ attribute AString searchString;
+
+ /*
+ * Set the index of the result item that should be initially selected.
+ * This should be used when a search wants to pre-select an element before
+ * the user starts using results.
+ *
+ * @note Setting this is not the same as just setting selectedIndex in
+ * nsIAutocompletePopup, since this will take care of updating any internal
+ * tracking variables of features like completeSelectedIndex.
+ */
+ void setInitiallySelectedIndex(in long index);
+
+ /*
+ * Reset controller internal caches for cases where the input doesn't change
+ * but its context resets, thus it is about to start a completely new search
+ * session.
+ */
+ [can_run_script] void resetInternalState();
+};
diff --git a/toolkit/components/autocomplete/nsIAutoCompleteInput.idl b/toolkit/components/autocomplete/nsIAutoCompleteInput.idl
new file mode 100644
index 0000000000..45e6cd9f46
--- /dev/null
+++ b/toolkit/components/autocomplete/nsIAutoCompleteInput.idl
@@ -0,0 +1,163 @@
+/* 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 "nsISupports.idl"
+#include "nsIAutoCompleteController.idl"
+
+interface nsIAutoCompletePopup;
+
+webidl Event;
+webidl Element;
+
+[scriptable, uuid(B068E70F-F82C-4C12-AD87-82E271C5C180)]
+interface nsIAutoCompleteInput : nsISupports
+{
+ /*
+ * The result view that will be used to display results
+ */
+ readonly attribute Element popupElement;
+ readonly attribute nsIAutoCompletePopup popup;
+
+ /*
+ * The controller.
+ */
+ readonly attribute nsIAutoCompleteController controller;
+
+ /*
+ * Indicates if the popup is currently open
+ */
+ [can_run_script] attribute boolean popupOpen;
+
+ /*
+ * Option to disable autocomplete functionality
+ */
+ attribute boolean disableAutoComplete;
+
+ /*
+ * If a search result has its defaultIndex set, this will optionally
+ * try to complete the text in the textbox to the entire text of the
+ * result at the default index as the user types
+ */
+ attribute boolean completeDefaultIndex;
+
+ /*
+ * complete text in the textbox as the user selects from the dropdown
+ * options if set to true
+ */
+ attribute boolean completeSelectedIndex;
+
+ /*
+ * Option for completing to the default result whenever the user hits
+ * enter or the textbox loses focus
+ */
+ attribute boolean forceComplete;
+
+ /*
+ * Option to open the popup only after a certain number of results are available
+ */
+ attribute unsigned long minResultsForPopup;
+
+ /*
+ * The maximum number of rows to show in the autocomplete popup.
+ */
+ attribute unsigned long maxRows;
+
+ /*
+ * Number of milliseconds after a keystroke before a search begins
+ */
+ attribute unsigned long timeout;
+
+ /*
+ * An extra parameter to configure searches with.
+ */
+ attribute AString searchParam;
+
+ /*
+ * The number of autocomplete session to search
+ */
+ readonly attribute unsigned long searchCount;
+
+ /*
+ * Get the name of one of the autocomplete search session objects
+ */
+ ACString getSearchAt(in unsigned long index);
+
+ /*
+ * The value of text in the autocomplete textbox.
+ */
+ attribute AString textValue;
+
+ /*
+ * Report the starting index of the cursor in the textbox
+ */
+ readonly attribute long selectionStart;
+
+ /*
+ * Report the ending index of the cursor in the textbox
+ */
+ readonly attribute long selectionEnd;
+
+ /*
+ * Select a range of text in the autocomplete textbox
+ */
+ void selectTextRange(in long startIndex, in long endIndex);
+
+ /*
+ * Notification that the search has started
+ */
+ void onSearchBegin();
+
+ /*
+ * Notification that the search concluded successfully
+ */
+ void onSearchComplete();
+
+ /*
+ * Notification that the user selected and entered a result item
+ *
+ * @param aEvent
+ * The event that triggered the enter.
+ */
+ void onTextEntered([optional] in Event aEvent);
+
+ /*
+ * Notification that the user cancelled the autocomplete session
+ *
+ * @return True if the user wishes to prevent the revert
+ */
+ boolean onTextReverted();
+
+ /*
+ * This popup should consume or dispatch the rollup event.
+ * TRUE: should consume; FALSE: should dispatch.
+ */
+ readonly attribute boolean consumeRollupEvent;
+
+ /*
+ * Indicates whether this input is in a "private browsing" context.
+ * nsIAutoCompleteSearches for these inputs should not persist any data to disk
+ * (such as a history database).
+ */
+ readonly attribute boolean inPrivateContext;
+
+ /*
+ * Don't rollup the popup when the caret is moved.
+ */
+ readonly attribute boolean noRollupOnCaretMove;
+
+ /*
+ * Don't rollup the popup when the search string becomes "".
+ */
+ readonly attribute boolean noRollupOnEmptySearch;
+
+ /**
+ * The userContextId of the current browser.
+ */
+ readonly attribute unsigned long userContextId;
+
+ /**
+ * Since search content is updated, we shouldn't use previous search result.
+ */
+ readonly attribute boolean invalidatePreviousResult;
+};
diff --git a/toolkit/components/autocomplete/nsIAutoCompletePopup.idl b/toolkit/components/autocomplete/nsIAutoCompletePopup.idl
new file mode 100644
index 0000000000..607863c9a7
--- /dev/null
+++ b/toolkit/components/autocomplete/nsIAutoCompletePopup.idl
@@ -0,0 +1,72 @@
+/* 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 "nsISupports.idl"
+
+interface nsIAutoCompleteInput;
+
+webidl Element;
+
+[scriptable, uuid(bd3c2662-a988-41ab-8c94-c15ed0e6ac7d)]
+interface nsIAutoCompletePopup : nsISupports
+{
+ /*
+ * The input object that the popup is currently bound to
+ */
+ readonly attribute nsIAutoCompleteInput input;
+
+ /*
+ * An alternative value to be used when text is entered, rather than the
+ * value of the selected item
+ */
+ readonly attribute AString overrideValue;
+
+ /*
+ * The index of the result item that is currently selected
+ */
+ attribute long selectedIndex;
+
+ /*
+ * Indicates if the popup is currently open
+ */
+ readonly attribute boolean popupOpen;
+
+ /*
+ * Bind the popup to an input object and display it with the given coordinates
+ *
+ * @param input - The input object that the popup will be bound to
+ * @param element - The element that the popup will be aligned with
+ */
+ void openAutocompletePopup(in nsIAutoCompleteInput input, in Element element);
+
+ /*
+ * Close the popup and detach from the bound input
+ */
+ void closePopup();
+
+ /*
+ * Instruct the result view to repaint itself to reflect the most current
+ * underlying data
+ *
+ * @param reason - The reason the popup needs to be invalidated, one of the
+ * INVALIDATE_REASON consts.
+ */
+ void invalidate(in unsigned short reason);
+
+ /*
+ * Possible values of invalidate()'s 'reason' argument.
+ */
+ const unsigned short INVALIDATE_REASON_NEW_RESULT = 0;
+ const unsigned short INVALIDATE_REASON_DELETE = 1;
+
+ /*
+ * Change the selection relative to the current selection and make sure
+ * the newly selected row is visible
+ *
+ * @param reverse - Select a row above the current selection
+ * @param page - Select a row that is a full visible page from the current selection
+ * @return The currently selected result item index
+ */
+ void selectBy(in boolean reverse, in boolean page);
+};
diff --git a/toolkit/components/autocomplete/nsIAutoCompleteResult.idl b/toolkit/components/autocomplete/nsIAutoCompleteResult.idl
new file mode 100644
index 0000000000..8e8b05ea46
--- /dev/null
+++ b/toolkit/components/autocomplete/nsIAutoCompleteResult.idl
@@ -0,0 +1,92 @@
+/* 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 "nsISupports.idl"
+
+[scriptable, uuid(9203c031-c4e7-4537-a4ec-81443d623d5a)]
+interface nsIAutoCompleteResult : nsISupports
+{
+ /**
+ * Possible values for the searchResult attribute
+ */
+ const unsigned short RESULT_IGNORED = 1; /* indicates invalid searchString */
+ const unsigned short RESULT_FAILURE = 2; /* indicates failure */
+ const unsigned short RESULT_NOMATCH = 3; /* indicates success with no matches
+ and that the search is complete */
+ const unsigned short RESULT_SUCCESS = 4; /* indicates success with matches
+ and that the search is complete */
+ const unsigned short RESULT_NOMATCH_ONGOING = 5; /* indicates success
+ with no matches
+ and that the search
+ is still ongoing */
+ const unsigned short RESULT_SUCCESS_ONGOING = 6; /* indicates success
+ with matches
+ and that the search
+ is still ongoing */
+ /**
+ * The original search string
+ */
+ readonly attribute AString searchString;
+
+ /**
+ * The result of the search
+ */
+ readonly attribute unsigned short searchResult;
+
+ /**
+ * Index of the default item that should be entered if none is selected
+ */
+ readonly attribute long defaultIndex;
+
+ /**
+ * A string describing the cause of a search failure
+ */
+ readonly attribute AString errorDescription;
+
+ /**
+ * The number of matches
+ */
+ readonly attribute unsigned long matchCount;
+
+ /**
+ * Get the value of the result at the given index
+ */
+ AString getValueAt(in long index);
+
+ /**
+ * This returns the string that is displayed in the dropdown
+ */
+ AString getLabelAt(in long index);
+
+ /**
+ * Get the comment of the result at the given index
+ */
+ AString getCommentAt(in long index);
+
+ /**
+ * Get the style hint for the result at the given index
+ */
+ AString getStyleAt(in long index);
+
+ /**
+ * Get the image of the result at the given index
+ */
+ AString getImageAt(in long index);
+
+ /**
+ * Get the final value that should be completed when the user confirms
+ * the match at the given index.
+ */
+ AString getFinalCompleteValueAt(in long index);
+
+ /**
+ * True if the value at the given index is removable.
+ */
+ bool isRemovableAt(in long rowIndex);
+
+ /**
+ * Remove the value at the given index from the autocomplete results.
+ */
+ void removeValueAt(in long rowIndex);
+};
diff --git a/toolkit/components/autocomplete/nsIAutoCompleteSearch.idl b/toolkit/components/autocomplete/nsIAutoCompleteSearch.idl
new file mode 100644
index 0000000000..2545340bf4
--- /dev/null
+++ b/toolkit/components/autocomplete/nsIAutoCompleteSearch.idl
@@ -0,0 +1,68 @@
+/* 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 "nsISupports.idl"
+
+interface nsIAutoCompleteResult;
+interface nsIAutoCompleteObserver;
+interface nsIPropertyBag2;
+
+[scriptable, uuid(DE8DB85F-C1DE-4d87-94BA-7844890F91FE)]
+interface nsIAutoCompleteSearch : nsISupports
+{
+ /*
+ * Search for a given string and notify a listener (either synchronously
+ * or asynchronously) of the result
+ *
+ * @param searchString - The string to search for
+ * @param searchParam - An extra parameter
+ * @param previousResult - A previous result to use for faster searching
+ * @param listener - A listener to notify when the search is complete
+ */
+ void startSearch(in AString searchString,
+ in AString searchParam,
+ in nsIAutoCompleteResult previousResult,
+ in nsIAutoCompleteObserver listener);
+
+ /*
+ * Stop all searches that are in progress
+ */
+ void stopSearch();
+};
+
+[scriptable, uuid(8bd1dbbc-dcce-4007-9afa-b551eb687b61)]
+interface nsIAutoCompleteObserver : nsISupports
+{
+ /*
+ * Called when a search is complete and the results are ready
+ *
+ * @param search - The search object that processed this search
+ * @param result - The search result object
+ */
+ [can_run_script] void onSearchResult(in nsIAutoCompleteSearch search,
+ in nsIAutoCompleteResult result);
+};
+
+[scriptable, uuid(4c3e7462-fbfb-4310-8f4b-239238392b75)]
+interface nsIAutoCompleteSearchDescriptor : nsISupports
+{
+ // The search is started after the timeout specified by the corresponding
+ // nsIAutoCompleteInput implementation.
+ const unsigned short SEARCH_TYPE_DELAYED = 0;
+ // The search is started synchronously, before any delayed searches.
+ const unsigned short SEARCH_TYPE_IMMEDIATE = 1;
+
+ /**
+ * Identifies the search behavior.
+ * Should be one of the SEARCH_TYPE_* constants above.
+ * Defaults to SEARCH_TYPE_DELAYED.
+ */
+ readonly attribute unsigned short searchType;
+
+ /*
+ * Whether a new search should be triggered when the user deletes the
+ * autofilled part.
+ */
+ readonly attribute boolean clearingAutoFillSearchesAgain;
+};
diff --git a/toolkit/components/autocomplete/nsIAutoCompleteSimpleResult.idl b/toolkit/components/autocomplete/nsIAutoCompleteSimpleResult.idl
new file mode 100644
index 0000000000..2be873eb59
--- /dev/null
+++ b/toolkit/components/autocomplete/nsIAutoCompleteSimpleResult.idl
@@ -0,0 +1,120 @@
+/* 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 "nsISupports.idl"
+#include "nsIAutoCompleteResult.idl"
+
+interface nsIAutoCompleteSimpleResultListener;
+
+/**
+ * This class implements nsIAutoCompleteResult and provides simple methods
+ * for setting the value and result items. It can be used whenever some basic
+ * auto complete results are needed that can be pre-generated and filled into
+ * an array.
+ */
+
+[scriptable, uuid(23de9c96-becb-4d0d-a9bb-1d131ce361b5)]
+interface nsIAutoCompleteSimpleResult : nsIAutoCompleteResult
+{
+ /**
+ * A writer for the readonly attribute 'searchString' which should contain
+ * the string that the user typed.
+ */
+ void setSearchString(in AString aSearchString);
+
+ /**
+ * A writer for the readonly attribute 'errorDescription'.
+ */
+ void setErrorDescription(in AString aErrorDescription);
+
+ /**
+ * A writer for the readonly attribute 'defaultIndex' which should contain
+ * the index of the list that will be selected by default (normally 0).
+ */
+ void setDefaultIndex(in long aDefaultIndex);
+
+ /**
+ * A writer for the readonly attribute 'searchResult' which should contain
+ * one of the constants nsIAutoCompleteResult.RESULT_* indicating the success
+ * of the search.
+ */
+ void setSearchResult(in unsigned short aSearchResult);
+
+ /**
+ * Inserts a match consisting of the given value, comment, image, style and
+ * the value to use for defaultIndex completion at a given position.
+ * @param aIndex
+ * The index to insert at
+ * @param aValue
+ * The value to autocomplete to
+ * @param aComment
+ * Comment shown in the autocomplete widget to describe this match
+ * @param aImage
+ * Image shown in the autocomplete widget for this match.
+ * @param aStyle
+ * Describes how to style the match in the autocomplete widget
+ * @param aFinalCompleteValue
+ * Value used when the user confirms selecting this match. If not
+ * provided, aValue will be used.
+ */
+ void insertMatchAt(in long aIndex,
+ in AString aValue,
+ in AString aComment,
+ [optional] in AString aImage,
+ [optional] in AString aStyle,
+ [optional] in AString aFinalCompleteValue,
+ [optional] in AString aLabel);
+
+ /**
+ * Appends a match consisting of the given value, comment, image, style and
+ * the value to use for defaultIndex completion.
+ * @param aValue
+ * The value to autocomplete to
+ * @param aComment
+ * Comment shown in the autocomplete widget to describe this match
+ * @param aImage
+ * Image shown in the autocomplete widget for this match.
+ * @param aStyle
+ * Describes how to style the match in the autocomplete widget
+ * @param aFinalCompleteValue
+ * Value used when the user confirms selecting this match. If not
+ * provided, aValue will be used.
+ */
+ void appendMatch(in AString aValue,
+ in AString aComment,
+ [optional] in AString aImage,
+ [optional] in AString aStyle,
+ [optional] in AString aFinalCompleteValue,
+ [optional] in AString aLabel);
+
+ /**
+ * Removes an existing match.
+ * @note this is different from removeValueAt, since it's not a consequence of
+ * a user action, and as such it won't notify onValueRemoved.
+ */
+ void removeMatchAt(in long aIndex);
+
+ /**
+ * Gets the listener for changes in the result.
+ */
+ nsIAutoCompleteSimpleResultListener getListener();
+
+ /**
+ * Sets a listener for changes in the result.
+ */
+ void setListener(in nsIAutoCompleteSimpleResultListener aListener);
+};
+
+[scriptable, uuid(004efdc5-1989-4874-8a7a-345bf2fa33af)]
+interface nsIAutoCompleteSimpleResultListener : nsISupports
+{
+ /**
+ * Dispatched after a value is removed from the result.
+ * @param aResult
+ * The result from which aValue has been removed.
+ * @param aValue
+ * The removed value.
+ */
+ void onValueRemoved(in nsIAutoCompleteSimpleResult aResult, in AString aValue);
+};
diff --git a/toolkit/components/autocomplete/nsIAutoCompleteSimpleSearch.idl b/toolkit/components/autocomplete/nsIAutoCompleteSimpleSearch.idl
new file mode 100644
index 0000000000..695cf5c589
--- /dev/null
+++ b/toolkit/components/autocomplete/nsIAutoCompleteSimpleSearch.idl
@@ -0,0 +1,17 @@
+/* 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 "nsIAutoCompleteSearch.idl"
+
+/*
+ * Simple interface that allows the results of the next search to be overridden.
+ */
+[scriptable, uuid(dc185a77-ba88-4caa-8f16-465253f7599a)]
+interface nsIAutoCompleteSimpleSearch : nsIAutoCompleteSearch
+{
+ /**
+ * Sets the result that should be used next time `startSearch` is called.
+ */
+ void overrideNextResult(in nsIAutoCompleteResult values);
+};
diff --git a/toolkit/components/autocomplete/tests/unit/head_autocomplete.js b/toolkit/components/autocomplete/tests/unit/head_autocomplete.js
new file mode 100644
index 0000000000..6aa0382d82
--- /dev/null
+++ b/toolkit/components/autocomplete/tests/unit/head_autocomplete.js
@@ -0,0 +1,203 @@
+/* Any copyright is dedicated to the Public Domain.
+ http://creativecommons.org/publicdomain/zero/1.0/ */
+
+var { XPCOMUtils } = ChromeUtils.importESModule(
+ "resource://gre/modules/XPCOMUtils.sys.mjs"
+);
+
+/**
+ * Dummy nsIAutoCompleteInput source that returns
+ * the given list of AutoCompleteSearch names.
+ *
+ * Implements only the methods needed for this test.
+ */
+function AutoCompleteInputBase(aSearches) {
+ this.searches = aSearches;
+}
+AutoCompleteInputBase.prototype = {
+ // Array of AutoCompleteSearch names
+ searches: null,
+
+ minResultsForPopup: 0,
+ timeout: 10,
+ searchParam: "",
+ textValue: "",
+ disableAutoComplete: false,
+ completeDefaultIndex: false,
+
+ // Text selection range
+ _selStart: 0,
+ _selEnd: 0,
+ get selectionStart() {
+ return this._selStart;
+ },
+ get selectionEnd() {
+ return this._selEnd;
+ },
+ selectTextRange(aStart, aEnd) {
+ this._selStart = aStart;
+ this._selEnd = aEnd;
+ },
+
+ get searchCount() {
+ return this.searches.length;
+ },
+
+ getSearchAt(aIndex) {
+ return this.searches[aIndex];
+ },
+
+ onSearchBegin() {},
+ onSearchComplete() {},
+
+ popupOpen: false,
+
+ get popup() {
+ if (!this._popup) {
+ this._popup = new AutocompletePopupBase(this);
+ }
+ return this._popup;
+ },
+
+ // nsISupports implementation
+ QueryInterface: ChromeUtils.generateQI(["nsIAutoCompleteInput"]),
+};
+
+/**
+ * nsIAutoCompleteResult implementation
+ */
+function AutoCompleteResultBase(aValues) {
+ this._values = aValues;
+}
+AutoCompleteResultBase.prototype = {
+ // Arrays
+ _values: null,
+ _comments: [],
+ _styles: [],
+ _finalCompleteValues: [],
+
+ searchString: "",
+ searchResult: null,
+
+ defaultIndex: -1,
+
+ get matchCount() {
+ return this._values.length;
+ },
+
+ getValueAt(aIndex) {
+ return this._values[aIndex];
+ },
+
+ getLabelAt(aIndex) {
+ return this.getValueAt(aIndex);
+ },
+
+ getCommentAt(aIndex) {
+ return this._comments[aIndex];
+ },
+
+ getStyleAt(aIndex) {
+ return this._styles[aIndex];
+ },
+
+ getImageAt(aIndex) {
+ return "";
+ },
+
+ getFinalCompleteValueAt(aIndex) {
+ return this._finalCompleteValues[aIndex] || this._values[aIndex];
+ },
+
+ isRemovableAt(aRowIndex) {
+ return true;
+ },
+
+ removeValueAt(aRowIndex) {},
+
+ // nsISupports implementation
+ QueryInterface: ChromeUtils.generateQI(["nsIAutoCompleteResult"]),
+};
+
+/**
+ * nsIAutoCompleteSearch implementation that always returns
+ * the same result set.
+ */
+function AutoCompleteSearchBase(aName, aResult) {
+ this.name = aName;
+ this._result = aResult;
+}
+AutoCompleteSearchBase.prototype = {
+ // Search name. Used by AutoCompleteController
+ name: null,
+
+ // AutoCompleteResult
+ _result: null,
+
+ startSearch(aSearchString, aSearchParam, aPreviousResult, aListener) {
+ var result = this._result;
+
+ result.searchResult = Ci.nsIAutoCompleteResult.RESULT_SUCCESS;
+ aListener.onSearchResult(this, result);
+ },
+
+ stopSearch() {},
+
+ // nsISupports implementation
+ QueryInterface: ChromeUtils.generateQI([
+ "nsIFactory",
+ "nsIAutoCompleteSearch",
+ ]),
+
+ // nsIFactory implementation
+ createInstance(iid) {
+ return this.QueryInterface(iid);
+ },
+};
+
+function AutocompletePopupBase(input) {
+ this.input = input;
+}
+AutocompletePopupBase.prototype = {
+ selectedIndex: 0,
+ invalidate() {},
+ selectBy(reverse, page) {
+ let numRows = this.input.controller.matchCount;
+ if (numRows > 0) {
+ let delta = reverse ? -1 : 1;
+ this.selectedIndex = (this.selectedIndex + delta) % numRows;
+ if (this.selectedIndex < 0) {
+ this.selectedIndex = numRows - 1;
+ }
+ }
+ },
+ QueryInterface: ChromeUtils.generateQI(["nsIAutoCompletePopup"]),
+};
+
+/**
+ * Helper to register an AutoCompleteSearch with the given name.
+ * Allows the AutoCompleteController to find the search.
+ */
+function registerAutoCompleteSearch(aSearch) {
+ var name = "@mozilla.org/autocomplete/search;1?name=" + aSearch.name;
+ var cid = Services.uuid.generateUUID();
+
+ var desc = "Test AutoCompleteSearch";
+ var componentManager = Components.manager.QueryInterface(
+ Ci.nsIComponentRegistrar
+ );
+ componentManager.registerFactory(cid, desc, name, aSearch);
+
+ // Keep the id on the object so we can unregister later
+ aSearch.cid = cid;
+}
+
+/**
+ * Helper to unregister an AutoCompleteSearch.
+ */
+function unregisterAutoCompleteSearch(aSearch) {
+ var componentManager = Components.manager.QueryInterface(
+ Ci.nsIComponentRegistrar
+ );
+ componentManager.unregisterFactory(aSearch.cid, aSearch);
+}
diff --git a/toolkit/components/autocomplete/tests/unit/test_330578.js b/toolkit/components/autocomplete/tests/unit/test_330578.js
new file mode 100644
index 0000000000..5f549cb4c7
--- /dev/null
+++ b/toolkit/components/autocomplete/tests/unit/test_330578.js
@@ -0,0 +1,41 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+var gResultListener = {
+ _lastResult: null,
+ _lastValue: "",
+
+ onValueRemoved(aResult, aValue) {
+ this._lastResult = aResult;
+ this._lastValue = aValue;
+ },
+};
+
+// main
+function run_test() {
+ var result = Cc["@mozilla.org/autocomplete/simple-result;1"].createInstance(
+ Ci.nsIAutoCompleteSimpleResult
+ );
+ result.appendMatch("a", "");
+ result.appendMatch("b", "");
+ result.appendMatch("c", "");
+ result.setListener(gResultListener);
+ Assert.equal(result.matchCount, 3);
+ result.removeValueAt(0);
+ Assert.equal(result.matchCount, 2);
+ Assert.equal(gResultListener._lastResult, result);
+ Assert.equal(gResultListener._lastValue, "a");
+
+ result.removeValueAt(0);
+ Assert.equal(result.matchCount, 1);
+ Assert.equal(gResultListener._lastValue, "b");
+
+ // check that we don't get notified if the listener is unset
+ result.setListener(null);
+ result.removeValueAt(0); // "c"
+ Assert.equal(result.matchCount, 0);
+ Assert.equal(gResultListener._lastValue, "b");
+}
diff --git a/toolkit/components/autocomplete/tests/unit/test_378079.js b/toolkit/components/autocomplete/tests/unit/test_378079.js
new file mode 100644
index 0000000000..06819df40b
--- /dev/null
+++ b/toolkit/components/autocomplete/tests/unit/test_378079.js
@@ -0,0 +1,252 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+/**
+ * Unit test for Bug 378079 - AutoComplete returns invalid rows when
+ * more than one AutoCompleteSearch is used.
+ */
+
+/**
+ * Dummy nsIAutoCompleteInput source that returns
+ * the given list of AutoCompleteSearch names.
+ *
+ * Implements only the methods needed for this test.
+ */
+function AutoCompleteInput(aSearches) {
+ this.searches = aSearches;
+}
+AutoCompleteInput.prototype = {
+ constructor: AutoCompleteInput,
+
+ // Array of AutoCompleteSearch names
+ searches: null,
+
+ minResultsForPopup: 0,
+ timeout: 10,
+ searchParam: "",
+ textValue: "",
+ disableAutoComplete: false,
+ completeDefaultIndex: false,
+
+ get searchCount() {
+ return this.searches.length;
+ },
+
+ getSearchAt(aIndex) {
+ return this.searches[aIndex];
+ },
+
+ onSearchBegin() {},
+ onSearchComplete() {},
+
+ popupOpen: false,
+
+ popup: {
+ setSelectedIndex(aIndex) {},
+ invalidate() {},
+
+ // nsISupports implementation
+ QueryInterface: ChromeUtils.generateQI(["nsIAutoCompletePopup"]),
+ },
+
+ // nsISupports implementation
+ QueryInterface: ChromeUtils.generateQI(["nsIAutoCompleteInput"]),
+};
+
+/**
+ * nsIAutoCompleteResult implementation
+ */
+function AutoCompleteResult(aValues, aComments, aStyles) {
+ this._values = aValues;
+ this._comments = aComments;
+ this._styles = aStyles;
+ this.searchResult = this._values.length
+ ? Ci.nsIAutoCompleteResult.RESULT_SUCCESS
+ : Ci.nsIAutoCompleteResult.RESULT_NOMATCH;
+}
+AutoCompleteResult.prototype = {
+ constructor: AutoCompleteResult,
+
+ // Arrays
+ _values: null,
+ _comments: null,
+ _styles: null,
+
+ searchString: "",
+ searchResult: null,
+
+ defaultIndex: 0,
+
+ get matchCount() {
+ return this._values.length;
+ },
+
+ getValueAt(aIndex) {
+ return this._values[aIndex];
+ },
+
+ getLabelAt(aIndex) {
+ return this.getValueAt(aIndex);
+ },
+
+ getCommentAt(aIndex) {
+ return this._comments[aIndex];
+ },
+
+ getStyleAt(aIndex) {
+ return this._styles[aIndex];
+ },
+
+ getImageAt(aIndex) {
+ return "";
+ },
+
+ getFinalCompleteValueAt(aIndex) {
+ return this.getValueAt(aIndex);
+ },
+
+ isRemovableAt(aRowIndex) {
+ return true;
+ },
+
+ removeValueAt(aRowIndex) {},
+
+ // nsISupports implementation
+ QueryInterface: ChromeUtils.generateQI(["nsIAutoCompleteResult"]),
+};
+
+/**
+ * nsIAutoCompleteSearch implementation that always returns
+ * the same result set.
+ */
+function AutoCompleteSearch(aName, aResult) {
+ this.name = aName;
+ this._result = aResult;
+}
+AutoCompleteSearch.prototype = {
+ constructor: AutoCompleteSearch,
+
+ // Search name. Used by AutoCompleteController
+ name: null,
+
+ // AutoCompleteResult
+ _result: null,
+
+ /**
+ * Return the same result set for every search
+ */
+ startSearch(aSearchString, aSearchParam, aPreviousResult, aListener) {
+ aListener.onSearchResult(this, this._result);
+ },
+
+ stopSearch() {},
+
+ // nsISupports implementation
+ QueryInterface: ChromeUtils.generateQI([
+ "nsIFactory",
+ "nsIAutoCompleteSearch",
+ ]),
+
+ // nsIFactory implementation
+ createInstance(iid) {
+ return this.QueryInterface(iid);
+ },
+};
+
+/**
+ * Helper to register an AutoCompleteSearch with the given name.
+ * Allows the AutoCompleteController to find the search.
+ */
+function registerAutoCompleteSearch(aSearch) {
+ var name = "@mozilla.org/autocomplete/search;1?name=" + aSearch.name;
+
+ var uuidGenerator = Services.uuid;
+ var cid = uuidGenerator.generateUUID();
+
+ var desc = "Test AutoCompleteSearch";
+
+ var componentManager = Components.manager.QueryInterface(
+ Ci.nsIComponentRegistrar
+ );
+ componentManager.registerFactory(cid, desc, name, aSearch);
+
+ // Keep the id on the object so we can unregister later
+ aSearch.cid = cid;
+}
+
+/**
+ * Helper to unregister an AutoCompleteSearch.
+ */
+function unregisterAutoCompleteSearch(aSearch) {
+ var componentManager = Components.manager.QueryInterface(
+ Ci.nsIComponentRegistrar
+ );
+ componentManager.unregisterFactory(aSearch.cid, aSearch);
+}
+
+/**
+ * Test AutoComplete with multiple AutoCompleteSearch sources.
+ */
+function run_test() {
+ // Make an AutoCompleteSearch that always returns nothing
+ var emptySearch = new AutoCompleteSearch(
+ "test-empty-search",
+ new AutoCompleteResult([], [], [])
+ );
+
+ // Make an AutoCompleteSearch that returns two values
+ var expectedValues = ["test1", "test2"];
+ var regularSearch = new AutoCompleteSearch(
+ "test-regular-search",
+ new AutoCompleteResult(expectedValues, [], [])
+ );
+
+ // Register searches so AutoCompleteController can find them
+ registerAutoCompleteSearch(emptySearch);
+ registerAutoCompleteSearch(regularSearch);
+
+ var controller = Cc["@mozilla.org/autocomplete/controller;1"].getService(
+ Ci.nsIAutoCompleteController
+ );
+
+ // Make an AutoCompleteInput that uses our searches
+ // and confirms results on search complete
+ var input = new AutoCompleteInput([emptySearch.name, regularSearch.name]);
+ var numSearchesStarted = 0;
+
+ input.onSearchBegin = function () {
+ numSearchesStarted++;
+ Assert.equal(numSearchesStarted, 1);
+ };
+
+ input.onSearchComplete = function () {
+ Assert.equal(numSearchesStarted, 1);
+
+ Assert.equal(
+ controller.searchStatus,
+ Ci.nsIAutoCompleteController.STATUS_COMPLETE_MATCH
+ );
+ Assert.equal(controller.matchCount, 2);
+
+ // Confirm expected result values
+ for (var i = 0; i < expectedValues.length; i++) {
+ Assert.equal(expectedValues[i], controller.getValueAt(i));
+ }
+
+ // Unregister searches
+ unregisterAutoCompleteSearch(emptySearch);
+ unregisterAutoCompleteSearch(regularSearch);
+
+ do_test_finished();
+ };
+
+ controller.input = input;
+
+ // Search is asynchronous, so don't let the test finish immediately
+ do_test_pending();
+
+ controller.startSearch("test");
+}
diff --git a/toolkit/components/autocomplete/tests/unit/test_393191.js b/toolkit/components/autocomplete/tests/unit/test_393191.js
new file mode 100644
index 0000000000..9a0481718d
--- /dev/null
+++ b/toolkit/components/autocomplete/tests/unit/test_393191.js
@@ -0,0 +1,237 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+/**
+ * Unit test for Bug 393191 - AutoComplete crashes if result is null
+ */
+
+/**
+ * Dummy nsIAutoCompleteInput source that returns
+ * the given list of AutoCompleteSearch names.
+ *
+ * Implements only the methods needed for this test.
+ */
+function AutoCompleteInput(aSearches) {
+ this.searches = aSearches;
+}
+AutoCompleteInput.prototype = {
+ constructor: AutoCompleteInput,
+
+ // Array of AutoCompleteSearch names
+ searches: null,
+
+ minResultsForPopup: 0,
+ timeout: 10,
+ searchParam: "",
+ textValue: "",
+ disableAutoComplete: false,
+ completeDefaultIndex: false,
+
+ get searchCount() {
+ return this.searches.length;
+ },
+
+ getSearchAt(aIndex) {
+ return this.searches[aIndex];
+ },
+
+ onSearchBegin() {},
+ onSearchComplete() {},
+
+ popupOpen: false,
+
+ popup: {
+ setSelectedIndex(aIndex) {},
+ invalidate() {},
+
+ // nsISupports implementation
+ QueryInterface: ChromeUtils.generateQI(["nsIAutoCompletePopup"]),
+ },
+
+ // nsISupports implementation
+ QueryInterface: ChromeUtils.generateQI(["nsIAutoCompleteInput"]),
+};
+
+/**
+ * nsIAutoCompleteResult implementation
+ */
+function AutoCompleteResult(aValues, aComments, aStyles) {
+ this._values = aValues;
+ this._comments = aComments;
+ this._styles = aStyles;
+ this.searchResult = this._values.length
+ ? Ci.nsIAutoCompleteResult.RESULT_SUCCESS
+ : Ci.nsIAutoCompleteResult.RESULT_NOMATCH;
+}
+AutoCompleteResult.prototype = {
+ constructor: AutoCompleteResult,
+
+ // Arrays
+ _values: null,
+ _comments: null,
+ _styles: null,
+
+ searchString: "",
+ searchResult: null,
+
+ defaultIndex: 0,
+
+ get matchCount() {
+ return this._values.length;
+ },
+
+ getValueAt(aIndex) {
+ return this._values[aIndex];
+ },
+
+ getLabelAt(aIndex) {
+ return this.getValueAt(aIndex);
+ },
+
+ getCommentAt(aIndex) {
+ return this._comments[aIndex];
+ },
+
+ getStyleAt(aIndex) {
+ return this._styles[aIndex];
+ },
+
+ getImageAt(aIndex) {
+ return "";
+ },
+
+ getFinalCompleteValueAt(aIndex) {
+ return this.getValueAt(aIndex);
+ },
+
+ isRemovableAt(aRowIndex) {
+ return true;
+ },
+
+ removeValueAt(aRowIndex) {},
+
+ // nsISupports implementation
+ QueryInterface: ChromeUtils.generateQI(["nsIAutoCompleteResult"]),
+};
+
+/**
+ * nsIAutoCompleteSearch implementation that always returns
+ * the same result set.
+ */
+function AutoCompleteSearch(aName, aResult) {
+ this.name = aName;
+ this._result = aResult;
+}
+AutoCompleteSearch.prototype = {
+ constructor: AutoCompleteSearch,
+
+ // Search name. Used by AutoCompleteController
+ name: null,
+
+ // AutoCompleteResult
+ _result: null,
+
+ /**
+ * Return the same result set for every search
+ */
+ startSearch(aSearchString, aSearchParam, aPreviousResult, aListener) {
+ aListener.onSearchResult(this, this._result);
+ },
+
+ stopSearch() {},
+
+ // nsISupports implementation
+ QueryInterface: ChromeUtils.generateQI([
+ "nsIFactory",
+ "nsIAutoCompleteSearch",
+ ]),
+
+ // nsIFactory implementation
+ createInstance(iid) {
+ return this.QueryInterface(iid);
+ },
+};
+
+/**
+ * Helper to register an AutoCompleteSearch with the given name.
+ * Allows the AutoCompleteController to find the search.
+ */
+function registerAutoCompleteSearch(aSearch) {
+ var name = "@mozilla.org/autocomplete/search;1?name=" + aSearch.name;
+
+ var uuidGenerator = Services.uuid;
+ var cid = uuidGenerator.generateUUID();
+
+ var desc = "Test AutoCompleteSearch";
+
+ var componentManager = Components.manager.QueryInterface(
+ Ci.nsIComponentRegistrar
+ );
+ componentManager.registerFactory(cid, desc, name, aSearch);
+
+ // Keep the id on the object so we can unregister later
+ aSearch.cid = cid;
+}
+
+/**
+ * Helper to unregister an AutoCompleteSearch.
+ */
+function unregisterAutoCompleteSearch(aSearch) {
+ var componentManager = Components.manager.QueryInterface(
+ Ci.nsIComponentRegistrar
+ );
+ componentManager.unregisterFactory(aSearch.cid, aSearch);
+}
+
+/**
+ * Test AutoComplete with a search that returns a null result
+ */
+function run_test() {
+ // Make an AutoCompleteSearch that always returns nothing
+ var emptySearch = new AutoCompleteSearch(
+ "test-empty-search",
+ new AutoCompleteResult([], [], [])
+ );
+
+ // Register search so AutoCompleteController can find them
+ registerAutoCompleteSearch(emptySearch);
+
+ var controller = Cc["@mozilla.org/autocomplete/controller;1"].getService(
+ Ci.nsIAutoCompleteController
+ );
+
+ // Make an AutoCompleteInput that uses our search
+ // and confirms results on search complete
+ var input = new AutoCompleteInput([emptySearch.name]);
+ var numSearchesStarted = 0;
+
+ input.onSearchBegin = function () {
+ numSearchesStarted++;
+ Assert.equal(numSearchesStarted, 1);
+ };
+
+ input.onSearchComplete = function () {
+ Assert.equal(numSearchesStarted, 1);
+
+ Assert.equal(
+ controller.searchStatus,
+ Ci.nsIAutoCompleteController.STATUS_COMPLETE_NO_MATCH
+ );
+ Assert.equal(controller.matchCount, 0);
+
+ // Unregister searches
+ unregisterAutoCompleteSearch(emptySearch);
+
+ do_test_finished();
+ };
+
+ controller.input = input;
+
+ // Search is asynchronous, so don't let the test finish immediately
+ do_test_pending();
+
+ controller.startSearch("test");
+}
diff --git a/toolkit/components/autocomplete/tests/unit/test_440866.js b/toolkit/components/autocomplete/tests/unit/test_440866.js
new file mode 100644
index 0000000000..ef538cd931
--- /dev/null
+++ b/toolkit/components/autocomplete/tests/unit/test_440866.js
@@ -0,0 +1,253 @@
+/* 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/. */
+
+/**
+ * Unit test for Bug 440866 - First AutoCompleteSearch that returns
+ * RESULT_NOMATCH cancels all other searches when popup is open
+ */
+
+/**
+ * Dummy nsIAutoCompleteInput source that returns
+ * the given list of AutoCompleteSearch names.
+ *
+ * Implements only the methods needed for this test.
+ */
+function AutoCompleteInput(aSearches) {
+ this.searches = aSearches;
+}
+AutoCompleteInput.prototype = {
+ constructor: AutoCompleteInput,
+
+ // Array of AutoCompleteSearch names
+ searches: null,
+
+ minResultsForPopup: 0,
+ timeout: 10,
+ searchParam: "",
+ textValue: "",
+ disableAutoComplete: false,
+ completeDefaultIndex: false,
+
+ get searchCount() {
+ return this.searches.length;
+ },
+
+ getSearchAt(aIndex) {
+ return this.searches[aIndex];
+ },
+
+ onSearchBegin() {},
+ onSearchComplete() {},
+
+ popupOpen: false,
+
+ popup: {
+ setSelectedIndex(aIndex) {},
+ invalidate() {},
+
+ // nsISupports implementation
+ QueryInterface: ChromeUtils.generateQI(["nsIAutoCompletePopup"]),
+ },
+
+ // nsISupports implementation
+ QueryInterface: ChromeUtils.generateQI(["nsIAutoCompleteInput"]),
+};
+
+/**
+ * nsIAutoCompleteResult implementation
+ */
+function AutoCompleteResult(aValues, aComments, aStyles) {
+ this._values = aValues;
+ this._comments = aComments;
+ this._styles = aStyles;
+ this.searchResult = this._values.length
+ ? Ci.nsIAutoCompleteResult.RESULT_SUCCESS
+ : Ci.nsIAutoCompleteResult.RESULT_NOMATCH;
+}
+AutoCompleteResult.prototype = {
+ constructor: AutoCompleteResult,
+
+ // Arrays
+ _values: null,
+ _comments: null,
+ _styles: null,
+
+ searchString: "",
+ searchResult: null,
+
+ defaultIndex: 0,
+
+ get matchCount() {
+ return this._values.length;
+ },
+
+ getValueAt(aIndex) {
+ return this._values[aIndex];
+ },
+
+ getLabelAt(aIndex) {
+ return this.getValueAt(aIndex);
+ },
+
+ getCommentAt(aIndex) {
+ return this._comments[aIndex];
+ },
+
+ getStyleAt(aIndex) {
+ return this._styles[aIndex];
+ },
+
+ getImageAt(aIndex) {
+ return "";
+ },
+
+ getFinalCompleteValueAt(aIndex) {
+ return this.getValueAt(aIndex);
+ },
+
+ isRemovableAt(aRowIndex) {
+ return true;
+ },
+
+ removeValueAt(aRowIndex) {},
+
+ // nsISupports implementation
+ QueryInterface: ChromeUtils.generateQI(["nsIAutoCompleteResult"]),
+};
+
+/**
+ * nsIAutoCompleteSearch implementation that always returns
+ * the same result set.
+ */
+function AutoCompleteSearch(aName, aResult) {
+ this.name = aName;
+ this._result = aResult;
+}
+AutoCompleteSearch.prototype = {
+ constructor: AutoCompleteSearch,
+
+ // Search name. Used by AutoCompleteController
+ name: null,
+
+ // AutoCompleteResult
+ _result: null,
+
+ /**
+ * Return the same result set for every search
+ */
+ startSearch(aSearchString, aSearchParam, aPreviousResult, aListener) {
+ aListener.onSearchResult(this, this._result);
+ },
+
+ stopSearch() {},
+
+ // nsISupports implementation
+ QueryInterface: ChromeUtils.generateQI([
+ "nsIFactory",
+ "nsIAutoCompleteSearch",
+ ]),
+
+ // nsIFactory implementation
+ createInstance(iid) {
+ return this.QueryInterface(iid);
+ },
+};
+
+/**
+ * Helper to register an AutoCompleteSearch with the given name.
+ * Allows the AutoCompleteController to find the search.
+ */
+function registerAutoCompleteSearch(aSearch) {
+ var name = "@mozilla.org/autocomplete/search;1?name=" + aSearch.name;
+
+ var uuidGenerator = Services.uuid;
+ var cid = uuidGenerator.generateUUID();
+
+ var desc = "Test AutoCompleteSearch";
+
+ var componentManager = Components.manager.QueryInterface(
+ Ci.nsIComponentRegistrar
+ );
+ componentManager.registerFactory(cid, desc, name, aSearch);
+
+ // Keep the id on the object so we can unregister later
+ aSearch.cid = cid;
+}
+
+/**
+ * Helper to unregister an AutoCompleteSearch.
+ */
+function unregisterAutoCompleteSearch(aSearch) {
+ var componentManager = Components.manager.QueryInterface(
+ Ci.nsIComponentRegistrar
+ );
+ componentManager.unregisterFactory(aSearch.cid, aSearch);
+}
+
+/**
+ * Test AutoComplete with multiple AutoCompleteSearch sources.
+ */
+function run_test() {
+ // Make an AutoCompleteSearch that always returns nothing
+ var emptySearch = new AutoCompleteSearch(
+ "test-empty-search",
+ new AutoCompleteResult([], [], [])
+ );
+
+ // Make an AutoCompleteSearch that returns two values
+ var expectedValues = ["test1", "test2"];
+ var regularSearch = new AutoCompleteSearch(
+ "test-regular-search",
+ new AutoCompleteResult(expectedValues, [], [])
+ );
+
+ // Register searches so AutoCompleteController can find them
+ registerAutoCompleteSearch(emptySearch);
+ registerAutoCompleteSearch(regularSearch);
+
+ var controller = Cc["@mozilla.org/autocomplete/controller;1"].getService(
+ Ci.nsIAutoCompleteController
+ );
+
+ // Make an AutoCompleteInput that uses our searches
+ // and confirms results on search complete
+ var input = new AutoCompleteInput([emptySearch.name, regularSearch.name]);
+ var numSearchesStarted = 0;
+
+ input.onSearchBegin = function () {
+ numSearchesStarted++;
+ Assert.equal(numSearchesStarted, 1);
+ Assert.equal(input.searchCount, 2);
+ };
+
+ input.onSearchComplete = function () {
+ Assert.equal(numSearchesStarted, 1);
+
+ Assert.equal(
+ controller.searchStatus,
+ Ci.nsIAutoCompleteController.STATUS_COMPLETE_MATCH
+ );
+ Assert.equal(controller.matchCount, 2);
+
+ // Confirm expected result values
+ for (var i = 0; i < expectedValues.length; i++) {
+ Assert.equal(expectedValues[i], controller.getValueAt(i));
+ }
+
+ Assert.ok(input.popupOpen);
+
+ // Unregister searches
+ unregisterAutoCompleteSearch(emptySearch);
+ unregisterAutoCompleteSearch(regularSearch);
+
+ do_test_finished();
+ };
+
+ controller.input = input;
+
+ // Search is asynchronous, so don't let the test finish immediately
+ do_test_pending();
+
+ controller.startSearch("test");
+}
diff --git a/toolkit/components/autocomplete/tests/unit/test_463023.js b/toolkit/components/autocomplete/tests/unit/test_463023.js
new file mode 100644
index 0000000000..48d2284c1b
--- /dev/null
+++ b/toolkit/components/autocomplete/tests/unit/test_463023.js
@@ -0,0 +1,13 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+// main
+function run_test() {
+ var result = Cc["@mozilla.org/autocomplete/controller;1"].createInstance(
+ Ci.nsIAutoCompleteController
+ );
+ Assert.equal(result.searchStatus, Ci.nsIAutoCompleteController.STATUS_NONE);
+}
diff --git a/toolkit/components/autocomplete/tests/unit/test_660156.js b/toolkit/components/autocomplete/tests/unit/test_660156.js
new file mode 100644
index 0000000000..a5f167e15b
--- /dev/null
+++ b/toolkit/components/autocomplete/tests/unit/test_660156.js
@@ -0,0 +1,113 @@
+/**
+ * Search object that returns results at different times.
+ * First, the search that returns results asynchronously.
+ */
+function AutoCompleteAsyncSearch(aName, aResult) {
+ this.name = aName;
+ this._result = aResult;
+}
+AutoCompleteAsyncSearch.prototype = Object.create(
+ AutoCompleteSearchBase.prototype
+);
+AutoCompleteAsyncSearch.prototype.startSearch = function (
+ aSearchString,
+ aSearchParam,
+ aPreviousResult,
+ aListener
+) {
+ this._result.searchResult = Ci.nsIAutoCompleteResult.RESULT_NOMATCH_ONGOING;
+ aListener.onSearchResult(this, this._result);
+
+ do_timeout(500, () => {
+ this._returnResults(aListener);
+ });
+};
+
+AutoCompleteAsyncSearch.prototype._returnResults = function (aListener) {
+ var result = this._result;
+
+ result.searchResult = Ci.nsIAutoCompleteResult.RESULT_SUCCESS;
+ aListener.onSearchResult(this, result);
+};
+
+/**
+ * The synchronous version
+ */
+function AutoCompleteSyncSearch(aName, aResult) {
+ this.name = aName;
+ this._result = aResult;
+}
+AutoCompleteSyncSearch.prototype = Object.create(
+ AutoCompleteAsyncSearch.prototype
+);
+AutoCompleteSyncSearch.prototype.startSearch = function (
+ aSearchString,
+ aSearchParam,
+ aPreviousResult,
+ aListener
+) {
+ this._returnResults(aListener);
+};
+
+/**
+ * Results object
+ */
+function AutoCompleteResult(aValues, aDefaultIndex) {
+ this._values = aValues;
+ this.defaultIndex = aDefaultIndex;
+}
+AutoCompleteResult.prototype = Object.create(AutoCompleteResultBase.prototype);
+
+/**
+ * Test AutoComplete with multiple AutoCompleteSearch sources, with one of them
+ * (index != 0) returning before the rest.
+ */
+function run_test() {
+ do_test_pending();
+
+ var results = ["mozillaTest"];
+ var inputStr = "moz";
+
+ // Async search
+ var asyncSearch = new AutoCompleteAsyncSearch(
+ "Async",
+ new AutoCompleteResult(results, -1)
+ );
+ // Sync search
+ var syncSearch = new AutoCompleteSyncSearch(
+ "Sync",
+ new AutoCompleteResult(results, 0)
+ );
+
+ // Register searches so AutoCompleteController can find them
+ registerAutoCompleteSearch(asyncSearch);
+ registerAutoCompleteSearch(syncSearch);
+
+ var controller = Cc["@mozilla.org/autocomplete/controller;1"].getService(
+ Ci.nsIAutoCompleteController
+ );
+
+ // Make an AutoCompleteInput that uses our searches
+ // and confirms results on search complete.
+ // Async search MUST be FIRST to trigger the bug this tests.
+ var input = new AutoCompleteInputBase([asyncSearch.name, syncSearch.name]);
+ input.completeDefaultIndex = true;
+ input.textValue = inputStr;
+
+ // Caret must be at the end. Autofill doesn't happen unless you're typing
+ // characters at the end.
+ var strLen = inputStr.length;
+ input.selectTextRange(strLen, strLen);
+
+ controller.input = input;
+ controller.startSearch(inputStr);
+
+ input.onSearchComplete = function () {
+ Assert.equal(input.textValue, results[0]);
+
+ // Unregister searches
+ unregisterAutoCompleteSearch(asyncSearch);
+ unregisterAutoCompleteSearch(syncSearch);
+ do_test_finished();
+ };
+}
diff --git a/toolkit/components/autocomplete/tests/unit/test_autocomplete_multiple.js b/toolkit/components/autocomplete/tests/unit/test_autocomplete_multiple.js
new file mode 100644
index 0000000000..68885dc4ab
--- /dev/null
+++ b/toolkit/components/autocomplete/tests/unit/test_autocomplete_multiple.js
@@ -0,0 +1,246 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+/**
+ * Dummy nsIAutoCompleteInput source that returns
+ * the given list of AutoCompleteSearch names.
+ *
+ * Implements only the methods needed for this test.
+ */
+function AutoCompleteInput(aSearches) {
+ this.searches = aSearches;
+}
+AutoCompleteInput.prototype = {
+ constructor: AutoCompleteInput,
+
+ // Array of AutoCompleteSearch names
+ searches: null,
+
+ minResultsForPopup: 0,
+ timeout: 10,
+ searchParam: "",
+ textValue: "",
+ disableAutoComplete: false,
+ completeDefaultIndex: false,
+
+ get searchCount() {
+ return this.searches.length;
+ },
+
+ getSearchAt(aIndex) {
+ return this.searches[aIndex];
+ },
+
+ onSearchBegin() {},
+ onSearchComplete() {},
+
+ popupOpen: false,
+
+ popup: {
+ setSelectedIndex(aIndex) {},
+ invalidate() {},
+
+ // nsISupports implementation
+ QueryInterface: ChromeUtils.generateQI(["nsIAutoCompletePopup"]),
+ },
+
+ // nsISupports implementation
+ QueryInterface: ChromeUtils.generateQI(["nsIAutoCompleteInput"]),
+};
+
+/**
+ * nsIAutoCompleteResult implementation
+ */
+function AutoCompleteResult(aValues, aComments, aStyles) {
+ this._values = aValues;
+ this._comments = aComments;
+ this._styles = aStyles;
+}
+AutoCompleteResult.prototype = {
+ constructor: AutoCompleteResult,
+
+ // Arrays
+ _values: null,
+ _comments: null,
+ _styles: null,
+
+ searchString: "",
+ searchResult: null,
+
+ defaultIndex: 0,
+
+ get matchCount() {
+ return this._values.length;
+ },
+
+ getValueAt(aIndex) {
+ return this._values[aIndex];
+ },
+
+ getLabelAt(aIndex) {
+ return this.getValueAt(aIndex);
+ },
+
+ getCommentAt(aIndex) {
+ return this._comments[aIndex];
+ },
+
+ getStyleAt(aIndex) {
+ return this._styles[aIndex];
+ },
+
+ getImageAt(aIndex) {
+ return "";
+ },
+
+ getFinalCompleteValueAt(aIndex) {
+ return this.getValueAt(aIndex);
+ },
+
+ isRemovableAt(aRowIndex) {
+ return true;
+ },
+
+ removeValueAt(aRowIndex) {},
+
+ // nsISupports implementation
+ QueryInterface: ChromeUtils.generateQI(["nsIAutoCompleteResult"]),
+};
+
+/**
+ * nsIAutoCompleteSearch implementation that always returns
+ * the same result set.
+ */
+function AutoCompleteSearch(aName, aResult) {
+ this.name = aName;
+ this._result = aResult;
+}
+AutoCompleteSearch.prototype = {
+ constructor: AutoCompleteSearch,
+
+ // Search name. Used by AutoCompleteController
+ name: null,
+
+ // AutoCompleteResult
+ _result: null,
+
+ /**
+ * Return the same result set for every search
+ */
+ startSearch(aSearchString, aSearchParam, aPreviousResult, aListener) {
+ var result = this._result;
+ result.searchResult = result._values.length
+ ? Ci.nsIAutoCompleteResult.RESULT_SUCCESS_ONGOING
+ : Ci.nsIAutoCompleteResult.RESULT_NOMATCH_ONGOING;
+ aListener.onSearchResult(this, result);
+
+ result.searchResult = result._values.length
+ ? Ci.nsIAutoCompleteResult.RESULT_SUCCESS
+ : Ci.nsIAutoCompleteResult.RESULT_NOMATCH;
+ aListener.onSearchResult(this, result);
+ },
+
+ stopSearch() {},
+
+ // nsISupports implementation
+ QueryInterface: ChromeUtils.generateQI([
+ "nsIFactory",
+ "nsIAutoCompleteSearch",
+ ]),
+
+ // nsIFactory implementation
+ createInstance(iid) {
+ return this.QueryInterface(iid);
+ },
+};
+
+/**
+ * Helper to register an AutoCompleteSearch with the given name.
+ * Allows the AutoCompleteController to find the search.
+ */
+function registerAutoCompleteSearch(aSearch) {
+ var name = "@mozilla.org/autocomplete/search;1?name=" + aSearch.name;
+
+ var uuidGenerator = Services.uuid;
+ var cid = uuidGenerator.generateUUID();
+
+ var desc = "Test AutoCompleteSearch";
+
+ var componentManager = Components.manager.QueryInterface(
+ Ci.nsIComponentRegistrar
+ );
+ componentManager.registerFactory(cid, desc, name, aSearch);
+
+ // Keep the id on the object so we can unregister later
+ aSearch.cid = cid;
+}
+
+/**
+ * Helper to unregister an AutoCompleteSearch.
+ */
+function unregisterAutoCompleteSearch(aSearch) {
+ var componentManager = Components.manager.QueryInterface(
+ Ci.nsIComponentRegistrar
+ );
+ componentManager.unregisterFactory(aSearch.cid, aSearch);
+}
+
+/**
+ * Test AutoComplete with multiple AutoCompleteSearch sources.
+ */
+function run_test() {
+ var expected1 = ["1", "2", "3"];
+ var expected2 = ["a", "b", "c"];
+ var search1 = new AutoCompleteSearch(
+ "search1",
+ new AutoCompleteResult(expected1, [], [])
+ );
+ var search2 = new AutoCompleteSearch(
+ "search2",
+ new AutoCompleteResult(expected2, [], [])
+ );
+
+ // Register searches so AutoCompleteController can find them
+ registerAutoCompleteSearch(search1);
+ registerAutoCompleteSearch(search2);
+
+ var controller = Cc["@mozilla.org/autocomplete/controller;1"].getService(
+ Ci.nsIAutoCompleteController
+ );
+
+ // Make an AutoCompleteInput that uses our searches
+ // and confirms results on search complete
+ var input = new AutoCompleteInput([search1.name, search2.name]);
+ var numSearchesStarted = 0;
+
+ input.onSearchBegin = function () {
+ numSearchesStarted++;
+ Assert.equal(numSearchesStarted, 1);
+ };
+
+ input.onSearchComplete = function () {
+ Assert.equal(numSearchesStarted, 1);
+
+ Assert.equal(
+ controller.searchStatus,
+ Ci.nsIAutoCompleteController.STATUS_COMPLETE_MATCH
+ );
+ Assert.equal(controller.matchCount, expected1.length + expected2.length);
+
+ // Unregister searches
+ unregisterAutoCompleteSearch(search1);
+ unregisterAutoCompleteSearch(search2);
+
+ do_test_finished();
+ };
+
+ controller.input = input;
+
+ // Search is asynchronous, so don't let the test finish immediately
+ do_test_pending();
+
+ controller.startSearch("test");
+}
diff --git a/toolkit/components/autocomplete/tests/unit/test_autocomplete_userContextId.js b/toolkit/components/autocomplete/tests/unit/test_autocomplete_userContextId.js
new file mode 100644
index 0000000000..4fbec408dc
--- /dev/null
+++ b/toolkit/components/autocomplete/tests/unit/test_autocomplete_userContextId.js
@@ -0,0 +1,44 @@
+"use strict";
+
+function AutoCompleteInput(aSearches, aUserContextId) {
+ this.searches = aSearches;
+ this.userContextId = aUserContextId;
+ this.popup.selectedIndex = -1;
+}
+AutoCompleteInput.prototype = Object.create(AutoCompleteInputBase.prototype);
+
+function AutoCompleteSearch(aName) {
+ this.name = aName;
+}
+AutoCompleteSearch.prototype = Object.create(AutoCompleteSearchBase.prototype);
+
+add_task(async function test_userContextId() {
+ let searchParam = await doSearch("test", 1);
+ Assert.equal(searchParam, " user-context-id:1");
+});
+
+function doSearch(aString, aUserContextId) {
+ return new Promise(resolve => {
+ let search = new AutoCompleteSearch("test");
+
+ search.startSearch = function (
+ aSearchString,
+ aSearchParam,
+ aPreviousResult,
+ aListener
+ ) {
+ unregisterAutoCompleteSearch(search);
+ resolve(aSearchParam);
+ };
+
+ registerAutoCompleteSearch(search);
+
+ let controller = Cc["@mozilla.org/autocomplete/controller;1"].getService(
+ Ci.nsIAutoCompleteController
+ );
+
+ let input = new AutoCompleteInput([search.name], aUserContextId);
+ controller.input = input;
+ controller.startSearch(aString);
+ });
+}
diff --git a/toolkit/components/autocomplete/tests/unit/test_autofillSelectedPopupIndex.js b/toolkit/components/autocomplete/tests/unit/test_autofillSelectedPopupIndex.js
new file mode 100644
index 0000000000..9b38b95c9c
--- /dev/null
+++ b/toolkit/components/autocomplete/tests/unit/test_autofillSelectedPopupIndex.js
@@ -0,0 +1,109 @@
+"use strict";
+
+add_task(async function sameCaseAsMatch() {
+ await runTest("moz");
+});
+
+add_task(async function differentCaseFromMatch() {
+ await runTest("MOZ");
+});
+
+async function runTest(searchStr) {
+ let matches = ["mozilla.org", "example.com"];
+ let result = new AutoCompleteResultBase(matches);
+ result.defaultIndex = 0;
+
+ let search = new AutoCompleteSearchBase("search", result);
+ registerAutoCompleteSearch(search);
+
+ let input = new AutoCompleteInputBase([search.name]);
+ input.completeSelectedIndex = true;
+ input.completeDefaultIndex = true;
+
+ // Start off with the search string in the input. The selection must be
+ // collapsed and the caret must be at the end to trigger autofill below.
+ input.textValue = searchStr;
+ input.selectTextRange(searchStr.length, searchStr.length);
+ Assert.equal(
+ input.selectionStart,
+ searchStr.length,
+ "Selection should start at the end of the input"
+ );
+ Assert.equal(
+ input.selectionEnd,
+ searchStr.length,
+ "Selection should end at the end of the input"
+ );
+
+ let controller = Cc["@mozilla.org/autocomplete/controller;1"].createInstance(
+ Ci.nsIAutoCompleteController
+ );
+ controller.input = input;
+ input.controller = controller;
+
+ // Start a search.
+ await new Promise(resolve => {
+ controller.startSearch(searchStr);
+ input.onSearchComplete = () => {
+ // The first match should have autofilled, but the case of the search
+ // string should be preserved.
+ let expectedValue = searchStr + matches[0].substr(searchStr.length);
+ Assert.equal(input.textValue, expectedValue, "Should have autofilled");
+ Assert.equal(
+ input.selectionStart,
+ searchStr.length,
+ "Selection should start after search string"
+ );
+ Assert.equal(
+ input.selectionEnd,
+ expectedValue.length,
+ "Selection should end at the end of the input"
+ );
+ resolve();
+ };
+ });
+
+ // Key down to select the second match in the popup.
+ // Hardcode KeyboardEvent.DOM_VK_DOWN, because we can't easily
+ // include KeyboardEvent here.
+ controller.handleKeyNavigation(0x28 /* KeyboardEvent.DOM_VK_DOWN */);
+ let expectedValue = matches[1];
+ Assert.equal(
+ input.textValue,
+ expectedValue,
+ "Should have filled second match"
+ );
+ Assert.equal(
+ input.selectionStart,
+ expectedValue.length,
+ "Selection should start at the end of the input"
+ );
+ Assert.equal(
+ input.selectionEnd,
+ expectedValue.length,
+ "Selection should end at the end of the input"
+ );
+
+ // Key up to select the first match again. The input should be restored
+ // exactly as it was when the first match was autofilled above: the search
+ // string's case should be preserved, and the selection should be preserved.
+ // Hardcode KeyboardEvent.DOM_VK_UP, because we can't easily
+ // include KeyboardEvent here.
+ controller.handleKeyNavigation(0x26 /* KeyboardEvent.DOM_VK_UP */);
+ expectedValue = searchStr + matches[0].substr(searchStr.length);
+ Assert.equal(
+ input.textValue,
+ expectedValue,
+ "Should have filled first match again"
+ );
+ Assert.equal(
+ input.selectionStart,
+ searchStr.length,
+ "Selection should start after search string again"
+ );
+ Assert.equal(
+ input.selectionEnd,
+ expectedValue.length,
+ "Selection should end at the end of the input again"
+ );
+}
diff --git a/toolkit/components/autocomplete/tests/unit/test_badDefaultIndex.js b/toolkit/components/autocomplete/tests/unit/test_badDefaultIndex.js
new file mode 100644
index 0000000000..52da4f4b4a
--- /dev/null
+++ b/toolkit/components/autocomplete/tests/unit/test_badDefaultIndex.js
@@ -0,0 +1,100 @@
+/* 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/. */
+
+/**
+ * A results that wants to defaultComplete to 0, but it has no matches,
+ * though it notifies SUCCESS to the controller.
+ */
+function AutoCompleteNoMatchResult() {
+ this.defaultIndex = 0;
+}
+AutoCompleteNoMatchResult.prototype = Object.create(
+ AutoCompleteResultBase.prototype
+);
+
+/**
+ * A results that wants to defaultComplete to an index greater than the number
+ * of matches.
+ */
+function AutoCompleteBadIndexResult(aValues, aDefaultIndex) {
+ Assert.ok(aValues.length <= aDefaultIndex);
+ this._values = aValues;
+ this.defaultIndex = aDefaultIndex;
+}
+AutoCompleteBadIndexResult.prototype = Object.create(
+ AutoCompleteResultBase.prototype
+);
+
+add_test(function autocomplete_noMatch_success() {
+ const INPUT_STR = "moz";
+
+ let searchNoMatch = new AutoCompleteSearchBase(
+ "searchNoMatch",
+ new AutoCompleteNoMatchResult()
+ );
+ registerAutoCompleteSearch(searchNoMatch);
+
+ // Make an AutoCompleteInput that uses our search and confirms results.
+ let input = new AutoCompleteInputBase([searchNoMatch.name]);
+ input.completeDefaultIndex = true;
+ input.textValue = INPUT_STR;
+
+ // Caret must be at the end for autoFill to happen.
+ let strLen = INPUT_STR.length;
+ input.selectTextRange(strLen, strLen);
+ Assert.equal(input.selectionStart, strLen);
+ Assert.equal(input.selectionEnd, strLen);
+
+ let controller = Cc["@mozilla.org/autocomplete/controller;1"].getService(
+ Ci.nsIAutoCompleteController
+ );
+ controller.input = input;
+ controller.startSearch(INPUT_STR);
+
+ input.onSearchComplete = function () {
+ // Should not try to autoFill to an empty value.
+ Assert.equal(input.textValue, "moz");
+
+ // Clean up.
+ unregisterAutoCompleteSearch(searchNoMatch);
+ run_next_test();
+ };
+});
+
+add_test(function autocomplete_defaultIndex_exceeds_matchCount() {
+ const INPUT_STR = "moz";
+
+ // Result returning matches, but a bad defaultIndex.
+ let searchBadIndex = new AutoCompleteSearchBase(
+ "searchBadIndex",
+ new AutoCompleteBadIndexResult(["mozillaTest"], 1)
+ );
+ registerAutoCompleteSearch(searchBadIndex);
+
+ // Make an AutoCompleteInput that uses our search and confirms results.
+ let input = new AutoCompleteInputBase([searchBadIndex.name]);
+ input.completeDefaultIndex = true;
+ input.textValue = INPUT_STR;
+
+ // Caret must be at the end for autoFill to happen.
+ let strLen = INPUT_STR.length;
+ input.selectTextRange(strLen, strLen);
+ Assert.equal(input.selectionStart, strLen);
+ Assert.equal(input.selectionEnd, strLen);
+
+ let controller = Cc["@mozilla.org/autocomplete/controller;1"].getService(
+ Ci.nsIAutoCompleteController
+ );
+ controller.input = input;
+ controller.startSearch(INPUT_STR);
+
+ input.onSearchComplete = function () {
+ // Should not try to autoFill to an empty value.
+ Assert.equal(input.textValue, "moz");
+
+ // Clean up.
+ unregisterAutoCompleteSearch(searchBadIndex);
+ run_next_test();
+ };
+});
diff --git a/toolkit/components/autocomplete/tests/unit/test_completeDefaultIndex_casing.js b/toolkit/components/autocomplete/tests/unit/test_completeDefaultIndex_casing.js
new file mode 100644
index 0000000000..2d1dfdf34d
--- /dev/null
+++ b/toolkit/components/autocomplete/tests/unit/test_completeDefaultIndex_casing.js
@@ -0,0 +1,64 @@
+/* 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/. */
+
+function AutoCompleteResult(aValues) {
+ this._values = aValues;
+ this.defaultIndex = 0;
+}
+AutoCompleteResult.prototype = Object.create(AutoCompleteResultBase.prototype);
+
+function AutoCompleteInput(aSearches) {
+ this.searches = aSearches;
+ this.popup.selectedIndex = -1;
+ this.completeDefaultIndex = true;
+}
+AutoCompleteInput.prototype = Object.create(AutoCompleteInputBase.prototype);
+
+add_test(function test_keyNavigation() {
+ doSearch("MOZ", "mozilla", function (aController) {
+ Assert.equal(aController.input.textValue, "MOZilla");
+ // Hardcode KeyboardEvent.DOM_VK_RIGHT, because we can't easily
+ // include KeyboardEvent here.
+ aController.handleKeyNavigation(0x27 /* KeyboardEvent.DOM_VK_RIGHT */);
+ Assert.equal(aController.input.textValue, "mozilla");
+ });
+});
+
+add_test(function test_handleEnter() {
+ doSearch("MOZ", "mozilla", function (aController) {
+ Assert.equal(aController.input.textValue, "MOZilla");
+ aController.handleEnter(false);
+ Assert.equal(aController.input.textValue, "mozilla");
+ });
+});
+
+function doSearch(aSearchString, aResultValue, aOnCompleteCallback) {
+ let search = new AutoCompleteSearchBase(
+ "search",
+ new AutoCompleteResult(["mozilla", "toolkit"], 0)
+ );
+ registerAutoCompleteSearch(search);
+
+ let controller = Cc["@mozilla.org/autocomplete/controller;1"].getService(
+ Ci.nsIAutoCompleteController
+ );
+
+ // Make an AutoCompleteInput that uses our searches and confirms results.
+ let input = new AutoCompleteInput([search.name]);
+ input.textValue = aSearchString;
+
+ // Caret must be at the end for autofill to happen.
+ let strLen = aSearchString.length;
+ input.selectTextRange(strLen, strLen);
+ controller.input = input;
+ controller.startSearch(aSearchString);
+
+ input.onSearchComplete = function onSearchComplete() {
+ aOnCompleteCallback(controller);
+
+ // Clean up.
+ unregisterAutoCompleteSearch(search);
+ run_next_test();
+ };
+}
diff --git a/toolkit/components/autocomplete/tests/unit/test_finalCompleteValue.js b/toolkit/components/autocomplete/tests/unit/test_finalCompleteValue.js
new file mode 100644
index 0000000000..9b777d08a5
--- /dev/null
+++ b/toolkit/components/autocomplete/tests/unit/test_finalCompleteValue.js
@@ -0,0 +1,62 @@
+function AutoCompleteResult(aValues, aFinalCompleteValues) {
+ this._values = aValues;
+ this._finalCompleteValues = aFinalCompleteValues;
+}
+AutoCompleteResult.prototype = Object.create(AutoCompleteResultBase.prototype);
+
+function AutoCompleteInput(aSearches) {
+ this.searches = aSearches;
+ this.popup.selectedIndex = 0;
+}
+AutoCompleteInput.prototype = Object.create(AutoCompleteInputBase.prototype);
+
+add_test(function test_handleEnter_mouse() {
+ doSearch(
+ "moz",
+ "mozilla.com",
+ "http://www.mozilla.com",
+ function (aController) {
+ Assert.equal(aController.input.textValue, "moz");
+ Assert.equal(
+ aController.getFinalCompleteValueAt(0),
+ "http://www.mozilla.com"
+ );
+ // Keyboard interaction is tested by test_finalCompleteValueSelectedIndex.js
+ // so here just test popup selection.
+ aController.handleEnter(true);
+ Assert.equal(aController.input.textValue, "http://www.mozilla.com");
+ }
+ );
+});
+
+function doSearch(
+ aSearchString,
+ aResultValue,
+ aFinalCompleteValue,
+ aOnCompleteCallback
+) {
+ let search = new AutoCompleteSearchBase(
+ "search",
+ new AutoCompleteResult([aResultValue], [aFinalCompleteValue])
+ );
+ registerAutoCompleteSearch(search);
+
+ let controller = Cc["@mozilla.org/autocomplete/controller;1"].getService(
+ Ci.nsIAutoCompleteController
+ );
+
+ // Make an AutoCompleteInput that uses our searches and confirms results.
+ let input = new AutoCompleteInput([search.name]);
+ input.textValue = aSearchString;
+
+ controller.input = input;
+ controller.startSearch(aSearchString);
+
+ input.onSearchComplete = function onSearchComplete() {
+ aOnCompleteCallback(controller);
+
+ // Clean up.
+ unregisterAutoCompleteSearch(search);
+ run_next_test();
+ };
+}
diff --git a/toolkit/components/autocomplete/tests/unit/test_finalCompleteValueSelectedIndex.js b/toolkit/components/autocomplete/tests/unit/test_finalCompleteValueSelectedIndex.js
new file mode 100644
index 0000000000..ec9491d781
--- /dev/null
+++ b/toolkit/components/autocomplete/tests/unit/test_finalCompleteValueSelectedIndex.js
@@ -0,0 +1,139 @@
+function AutoCompleteResult(aResultValues) {
+ this._values = aResultValues.map(x => x[0]);
+ this._finalCompleteValues = aResultValues.map(x => x[1]);
+}
+AutoCompleteResult.prototype = Object.create(AutoCompleteResultBase.prototype);
+
+var selectByWasCalled = false;
+function AutoCompleteInput(aSearches) {
+ this.searches = aSearches;
+ this.popup.selectedIndex = 0;
+ this.popup.selectBy = function (reverse, page) {
+ Assert.equal(selectByWasCalled, false);
+ selectByWasCalled = true;
+ Assert.equal(reverse, false);
+ Assert.equal(page, false);
+ this.selectedIndex += (reverse ? -1 : 1) * (page ? 100 : 1);
+ };
+ this.completeSelectedIndex = true;
+}
+AutoCompleteInput.prototype = Object.create(AutoCompleteInputBase.prototype);
+
+add_test(function test_handleEnter_key() {
+ let results = [
+ ["mozilla.com", "http://www.mozilla.com"],
+ ["mozilla.org", "http://www.mozilla.org"],
+ ];
+ // First check the case where we do select a value with the keyboard:
+ doSearch("moz", results, function (aController) {
+ Assert.equal(aController.input.textValue, "moz");
+ Assert.equal(
+ aController.getFinalCompleteValueAt(0),
+ "http://www.mozilla.com"
+ );
+ Assert.equal(
+ aController.getFinalCompleteValueAt(1),
+ "http://www.mozilla.org"
+ );
+
+ Assert.equal(aController.input.popup.selectedIndex, 0);
+ // Hardcode KeyboardEvent.DOM_VK_DOWN, because we can't easily
+ // include KeyboardEvent here.
+ aController.handleKeyNavigation(0x28 /* KeyboardEvent.DOM_VK_DOWN */);
+ Assert.equal(aController.input.popup.selectedIndex, 1);
+ // Simulate mouse interaction changing selectedIndex
+ // ie NOT keyboard interaction:
+ aController.input.popup.selectedIndex = 0;
+
+ aController.handleEnter(false);
+ // Verify that the keyboard-selected thing got inserted,
+ // and not the mouse selection:
+ Assert.equal(aController.input.textValue, "http://www.mozilla.org");
+ });
+});
+
+add_test(function test_handleEnter_mouse() {
+ let results = [
+ ["mozilla.com", "http://www.mozilla.com"],
+ ["mozilla.org", "http://www.mozilla.org"],
+ ];
+ // Then the case where we do not:
+ doSearch("moz", results, function (aController) {
+ Assert.equal(aController.input.textValue, "moz");
+ Assert.equal(
+ aController.getFinalCompleteValueAt(0),
+ "http://www.mozilla.com"
+ );
+ Assert.equal(
+ aController.getFinalCompleteValueAt(1),
+ "http://www.mozilla.org"
+ );
+
+ Assert.equal(aController.input.popup.selectedIndex, 0);
+ aController.input.popupOpen = true;
+ // Simulate mouse interaction changing selectedIndex
+ // ie NOT keyboard interaction:
+ aController.input.popup.selectedIndex = 1;
+ Assert.equal(selectByWasCalled, false);
+ Assert.equal(aController.input.popup.selectedIndex, 1);
+
+ aController.handleEnter(false);
+ // Verify that the input stayed the same, because no selection was made
+ // with the keyboard:
+ Assert.equal(aController.input.textValue, "moz");
+ });
+});
+
+add_test(function test_handleEnter_preselected() {
+ let results = [
+ ["mozilla.com", "http://www.mozilla.com"],
+ ["mozilla.org", "http://www.mozilla.org"],
+ ];
+ // Then test a preselection.
+ doSearch("moz", results, function (aController) {
+ Assert.equal(aController.input.textValue, "moz");
+ Assert.equal(
+ aController.getFinalCompleteValueAt(0),
+ "http://www.mozilla.com"
+ );
+ Assert.equal(
+ aController.getFinalCompleteValueAt(1),
+ "http://www.mozilla.org"
+ );
+
+ aController.setInitiallySelectedIndex(0);
+
+ aController.handleEnter(false);
+ // Verify that the input stayed the same, because no selection was made
+ // with the keyboard:
+ Assert.equal(aController.input.textValue, "http://www.mozilla.com");
+ });
+});
+
+function doSearch(aSearchString, aResults, aOnCompleteCallback) {
+ selectByWasCalled = false;
+ let search = new AutoCompleteSearchBase(
+ "search",
+ new AutoCompleteResult(aResults)
+ );
+ registerAutoCompleteSearch(search);
+
+ let controller = Cc["@mozilla.org/autocomplete/controller;1"].getService(
+ Ci.nsIAutoCompleteController
+ );
+
+ // Make an AutoCompleteInput that uses our searches and confirms results.
+ let input = new AutoCompleteInput([search.name]);
+ input.textValue = aSearchString;
+
+ controller.input = input;
+ controller.startSearch(aSearchString);
+
+ input.onSearchComplete = function onSearchComplete() {
+ aOnCompleteCallback(controller);
+
+ // Clean up.
+ unregisterAutoCompleteSearch(search);
+ run_next_test();
+ };
+}
diff --git a/toolkit/components/autocomplete/tests/unit/test_finalCompleteValue_defaultIndex.js b/toolkit/components/autocomplete/tests/unit/test_finalCompleteValue_defaultIndex.js
new file mode 100644
index 0000000000..7b8a51f03a
--- /dev/null
+++ b/toolkit/components/autocomplete/tests/unit/test_finalCompleteValue_defaultIndex.js
@@ -0,0 +1,112 @@
+function AutoCompleteResult(aResultValues) {
+ this.defaultIndex = 0;
+ this._values = aResultValues.map(x => x[0]);
+ this._finalCompleteValues = aResultValues.map(x => x[1]);
+}
+AutoCompleteResult.prototype = Object.create(AutoCompleteResultBase.prototype);
+
+function AutoCompleteInput(aSearches) {
+ this.searches = aSearches;
+ this.popup.selectedIndex = 0;
+ this.completeSelectedIndex = true;
+ this.completeDefaultIndex = true;
+}
+AutoCompleteInput.prototype = Object.create(AutoCompleteInputBase.prototype);
+
+add_test(function test_handleEnter() {
+ let results = [
+ ["mozilla.com", "https://www.mozilla.com"],
+ ["gomozilla.org", "http://www.gomozilla.org"],
+ ];
+ doSearch("moz", results, { selectedIndex: 0 }, controller => {
+ let input = controller.input;
+ Assert.equal(input.textValue, "mozilla.com");
+ Assert.equal(controller.getFinalCompleteValueAt(0), results[0][1]);
+ Assert.equal(controller.getFinalCompleteValueAt(1), results[1][1]);
+ Assert.equal(input.popup.selectedIndex, 0);
+
+ controller.handleEnter(false);
+ // Verify that the keyboard-selected thing got inserted,
+ // and not the mouse selection:
+ Assert.equal(controller.input.textValue, "https://www.mozilla.com");
+ });
+});
+
+add_test(function test_handleEnter_otherSelected() {
+ // The popup selection may not coincide with what is filled into the input
+ // field, for example if the user changed it with the mouse and then pressed
+ // Enter. In such a case we should still use the inputField value and not the
+ // popup selected value.
+ let results = [
+ ["mozilla.com", "https://www.mozilla.com"],
+ ["gomozilla.org", "http://www.gomozilla.org"],
+ ];
+ doSearch("moz", results, { selectedIndex: 1 }, controller => {
+ let input = controller.input;
+ Assert.equal(input.textValue, "mozilla.com");
+ Assert.equal(controller.getFinalCompleteValueAt(0), results[0][1]);
+ Assert.equal(controller.getFinalCompleteValueAt(1), results[1][1]);
+ Assert.equal(input.popup.selectedIndex, 1);
+
+ controller.handleEnter(false);
+ // Verify that the keyboard-selected thing got inserted,
+ // and not the mouse selection:
+ Assert.equal(controller.input.textValue, "https://www.mozilla.com");
+ });
+});
+
+add_test(function test_handleEnter_otherSelected_nocompleteselectedindex() {
+ let results = [
+ ["mozilla.com", "https://www.mozilla.com"],
+ ["gomozilla.org", "http://www.gomozilla.org"],
+ ];
+ doSearch(
+ "moz",
+ results,
+ { selectedIndex: 1, completeSelectedIndex: false },
+ controller => {
+ let input = controller.input;
+ Assert.equal(input.textValue, "mozilla.com");
+ Assert.equal(controller.getFinalCompleteValueAt(0), results[0][1]);
+ Assert.equal(controller.getFinalCompleteValueAt(1), results[1][1]);
+ Assert.equal(input.popup.selectedIndex, 1);
+
+ controller.handleEnter(false);
+ // Verify that the keyboard-selected result is inserted, not the
+ // defaultComplete.
+ Assert.equal(controller.input.textValue, "http://www.gomozilla.org");
+ }
+ );
+});
+
+function doSearch(aSearchString, aResults, aOptions, aOnCompleteCallback) {
+ let search = new AutoCompleteSearchBase(
+ "search",
+ new AutoCompleteResult(aResults)
+ );
+ registerAutoCompleteSearch(search);
+
+ let input = new AutoCompleteInput([search.name]);
+ input.textValue = aSearchString;
+ if ("selectedIndex" in aOptions) {
+ input.popup.selectedIndex = aOptions.selectedIndex;
+ }
+ if ("completeSelectedIndex" in aOptions) {
+ input.completeSelectedIndex = aOptions.completeSelectedIndex;
+ }
+ // Needed for defaultIndex completion.
+ input.selectTextRange(aSearchString.length, aSearchString.length);
+
+ let controller = Cc["@mozilla.org/autocomplete/controller;1"].getService(
+ Ci.nsIAutoCompleteController
+ );
+ controller.input = input;
+ controller.startSearch(aSearchString);
+
+ input.onSearchComplete = function onSearchComplete() {
+ aOnCompleteCallback(controller);
+
+ unregisterAutoCompleteSearch(search);
+ run_next_test();
+ };
+}
diff --git a/toolkit/components/autocomplete/tests/unit/test_finalCompleteValue_forceComplete.js b/toolkit/components/autocomplete/tests/unit/test_finalCompleteValue_forceComplete.js
new file mode 100644
index 0000000000..5456a8d2ab
--- /dev/null
+++ b/toolkit/components/autocomplete/tests/unit/test_finalCompleteValue_forceComplete.js
@@ -0,0 +1,138 @@
+/* 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/. */
+
+function AutoCompleteResult(aValues, aFinalCompleteValues) {
+ this._values = aValues;
+ this._finalCompleteValues = aFinalCompleteValues;
+ this.defaultIndex = 0;
+}
+AutoCompleteResult.prototype = Object.create(AutoCompleteResultBase.prototype);
+
+function AutoCompleteInput(aSearches) {
+ this.searches = aSearches;
+ this.popup.selectedIndex = -1;
+}
+AutoCompleteInput.prototype = Object.create(AutoCompleteInputBase.prototype);
+
+add_test(function test_handleEnterWithDirectMatchCompleteSelectedIndex() {
+ doSearch(
+ "moz",
+ "mozilla.com",
+ "http://www.mozilla.com",
+ { forceComplete: true, completeSelectedIndex: true },
+ function (aController) {
+ Assert.equal(aController.input.textValue, "moz");
+ Assert.equal(
+ aController.getFinalCompleteValueAt(0),
+ "http://www.mozilla.com"
+ );
+ aController.handleEnter(false);
+ // After enter the final complete value should be shown in the input.
+ Assert.equal(aController.input.textValue, "http://www.mozilla.com");
+ }
+ );
+});
+
+add_test(function test_handleEnterWithDirectMatch() {
+ doSearch(
+ "mozilla",
+ "mozilla.com",
+ "http://www.mozilla.com",
+ { forceComplete: true, completeDefaultIndex: true },
+ function (aController) {
+ // Should autocomplete the search string to a suggestion.
+ Assert.equal(aController.input.textValue, "mozilla.com");
+ Assert.equal(
+ aController.getFinalCompleteValueAt(0),
+ "http://www.mozilla.com"
+ );
+ aController.handleEnter(false);
+ // After enter the final complete value should be shown in the input.
+ Assert.equal(aController.input.textValue, "http://www.mozilla.com");
+ }
+ );
+});
+
+add_test(function test_handleEnterWithNoMatch() {
+ doSearch(
+ "mozilla",
+ "mozilla.com",
+ "http://www.mozilla.com",
+ { forceComplete: true, completeDefaultIndex: true },
+ function (aController) {
+ // Should autocomplete the search string to a suggestion.
+ Assert.equal(aController.input.textValue, "mozilla.com");
+ Assert.equal(
+ aController.getFinalCompleteValueAt(0),
+ "http://www.mozilla.com"
+ );
+ // Now input something that does not match...
+ aController.input.textValue = "mozillax";
+ // ... and confirm. We don't want one of the values from the previous
+ // results to be taken, since what's now in the input field doesn't match.
+ aController.handleEnter(false);
+ Assert.equal(aController.input.textValue, "mozillax");
+ }
+ );
+});
+
+add_test(function test_handleEnterWithIndirectMatch() {
+ doSearch(
+ "com",
+ "mozilla.com",
+ "http://www.mozilla.com",
+ { forceComplete: true, completeDefaultIndex: true },
+ function (aController) {
+ // Should autocomplete the search string to a suggestion.
+ Assert.equal(aController.input.textValue, "com >> mozilla.com");
+ Assert.equal(
+ aController.getFinalCompleteValueAt(0),
+ "http://www.mozilla.com"
+ );
+ aController.handleEnter(false);
+ // After enter the final complete value from the suggestion should be shown
+ // in the input.
+ Assert.equal(aController.input.textValue, "http://www.mozilla.com");
+ }
+ );
+});
+
+function doSearch(
+ aSearchString,
+ aResultValue,
+ aFinalCompleteValue,
+ aInputProps,
+ aOnCompleteCallback
+) {
+ let search = new AutoCompleteSearchBase(
+ "search",
+ new AutoCompleteResult([aResultValue], [aFinalCompleteValue])
+ );
+ registerAutoCompleteSearch(search);
+
+ let controller = Cc["@mozilla.org/autocomplete/controller;1"].getService(
+ Ci.nsIAutoCompleteController
+ );
+
+ // Make an AutoCompleteInput that uses our searches and confirms results.
+ let input = new AutoCompleteInput([search.name]);
+ for (var p in aInputProps) {
+ input[p] = aInputProps[p];
+ }
+ input.textValue = aSearchString;
+ // Place the cursor at the end of the input so that completion to
+ // default index will kick in.
+ input.selectTextRange(aSearchString.length, aSearchString.length);
+
+ controller.input = input;
+ controller.startSearch(aSearchString);
+
+ input.onSearchComplete = function onSearchComplete() {
+ aOnCompleteCallback(controller);
+
+ // Clean up.
+ unregisterAutoCompleteSearch(search);
+ run_next_test();
+ };
+}
diff --git a/toolkit/components/autocomplete/tests/unit/test_finalDefaultCompleteValue.js b/toolkit/components/autocomplete/tests/unit/test_finalDefaultCompleteValue.js
new file mode 100644
index 0000000000..95cff2d4a8
--- /dev/null
+++ b/toolkit/components/autocomplete/tests/unit/test_finalDefaultCompleteValue.js
@@ -0,0 +1,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/. */
+
+function AutoCompleteResult(aValues, aFinalCompleteValues) {
+ this._values = aValues;
+ this._finalCompleteValues = aFinalCompleteValues;
+ this.defaultIndex = 0;
+}
+AutoCompleteResult.prototype = Object.create(AutoCompleteResultBase.prototype);
+
+function AutoCompleteInput(aSearches) {
+ this.searches = aSearches;
+ this.popup.selectedIndex = -1;
+ this.completeDefaultIndex = true;
+}
+AutoCompleteInput.prototype = Object.create(AutoCompleteInputBase.prototype);
+
+add_test(function test_keyNavigation() {
+ doSearch(
+ "moz",
+ "mozilla.com",
+ "http://www.mozilla.com",
+ function (aController) {
+ Assert.equal(aController.input.textValue, "mozilla.com");
+ // Hardcode KeyboardEvent.DOM_VK_RIGHT, because we can't easily
+ // include KeyboardEvent here.
+ aController.handleKeyNavigation(0x27 /* KeyboardEvent.DOM_VK_RIGHT */);
+ Assert.equal(aController.input.textValue, "mozilla.com");
+ }
+ );
+});
+
+add_test(function test_handleEnter() {
+ doSearch(
+ "moz",
+ "mozilla.com",
+ "http://www.mozilla.com",
+ function (aController) {
+ Assert.equal(aController.input.textValue, "mozilla.com");
+ aController.handleEnter(false);
+ Assert.equal(aController.input.textValue, "http://www.mozilla.com");
+ }
+ );
+});
+
+function doSearch(
+ aSearchString,
+ aResultValue,
+ aFinalCompleteValue,
+ aOnCompleteCallback
+) {
+ let search = new AutoCompleteSearchBase(
+ "search",
+ new AutoCompleteResult([aResultValue], [aFinalCompleteValue])
+ );
+ registerAutoCompleteSearch(search);
+
+ let controller = Cc["@mozilla.org/autocomplete/controller;1"].getService(
+ Ci.nsIAutoCompleteController
+ );
+
+ // Make an AutoCompleteInput that uses our searches and confirms results.
+ let input = new AutoCompleteInput([search.name]);
+ input.textValue = aSearchString;
+
+ // Caret must be at the end for autofill to happen.
+ let strLen = aSearchString.length;
+ input.selectTextRange(strLen, strLen);
+ controller.input = input;
+ controller.startSearch(aSearchString);
+
+ input.onSearchComplete = function onSearchComplete() {
+ aOnCompleteCallback(controller);
+
+ // Clean up.
+ unregisterAutoCompleteSearch(search);
+ run_next_test();
+ };
+}
diff --git a/toolkit/components/autocomplete/tests/unit/test_immediate_search.js b/toolkit/components/autocomplete/tests/unit/test_immediate_search.js
new file mode 100644
index 0000000000..a4524ca5c9
--- /dev/null
+++ b/toolkit/components/autocomplete/tests/unit/test_immediate_search.js
@@ -0,0 +1,174 @@
+/* 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/. */
+
+function AutoCompleteImmediateSearch(aName, aResult) {
+ this.name = aName;
+ this._result = aResult;
+}
+AutoCompleteImmediateSearch.prototype = Object.create(
+ AutoCompleteSearchBase.prototype
+);
+AutoCompleteImmediateSearch.prototype.searchType =
+ Ci.nsIAutoCompleteSearchDescriptor.SEARCH_TYPE_IMMEDIATE;
+AutoCompleteImmediateSearch.prototype.QueryInterface = ChromeUtils.generateQI([
+ "nsIFactory",
+ "nsIAutoCompleteSearch",
+ "nsIAutoCompleteSearchDescriptor",
+]);
+
+function AutoCompleteDelayedSearch(aName, aResult) {
+ this.name = aName;
+ this._result = aResult;
+}
+AutoCompleteDelayedSearch.prototype = Object.create(
+ AutoCompleteSearchBase.prototype
+);
+
+function AutoCompleteResult(aValues, aDefaultIndex) {
+ this._values = aValues;
+ this.defaultIndex = aDefaultIndex;
+}
+AutoCompleteResult.prototype = Object.create(AutoCompleteResultBase.prototype);
+
+/**
+ * An immediate search should be executed synchronously.
+ */
+add_test(function test_immediate_search() {
+ let inputStr = "moz";
+
+ let immediateSearch = new AutoCompleteImmediateSearch(
+ "immediate",
+ new AutoCompleteResult(["moz-immediate"], 0)
+ );
+ registerAutoCompleteSearch(immediateSearch);
+ let delayedSearch = new AutoCompleteDelayedSearch(
+ "delayed",
+ new AutoCompleteResult(["moz-delayed"], 0)
+ );
+ registerAutoCompleteSearch(delayedSearch);
+
+ let controller = Cc["@mozilla.org/autocomplete/controller;1"].getService(
+ Ci.nsIAutoCompleteController
+ );
+
+ let input = new AutoCompleteInputBase([
+ delayedSearch.name,
+ immediateSearch.name,
+ ]);
+ input.completeDefaultIndex = true;
+ input.textValue = inputStr;
+
+ // Caret must be at the end. Autofill doesn't happen unless you're typing
+ // characters at the end.
+ let strLen = inputStr.length;
+ input.selectTextRange(strLen, strLen);
+
+ controller.input = input;
+ controller.startSearch(inputStr);
+
+ // Immediately check the result, the immediate search should have finished.
+ Assert.equal(input.textValue, "moz-immediate");
+
+ // Wait for both queries to finish.
+ input.onSearchComplete = function () {
+ // Sanity check.
+ Assert.equal(input.textValue, "moz-immediate");
+
+ unregisterAutoCompleteSearch(immediateSearch);
+ unregisterAutoCompleteSearch(delayedSearch);
+ run_next_test();
+ };
+});
+
+/**
+ * An immediate search should be executed before any delayed search.
+ */
+add_test(function test_immediate_search_notimeout() {
+ let inputStr = "moz";
+
+ let immediateSearch = new AutoCompleteImmediateSearch(
+ "immediate",
+ new AutoCompleteResult(["moz-immediate"], 0)
+ );
+ registerAutoCompleteSearch(immediateSearch);
+
+ let delayedSearch = new AutoCompleteDelayedSearch(
+ "delayed",
+ new AutoCompleteResult(["moz-delayed"], 0)
+ );
+ registerAutoCompleteSearch(delayedSearch);
+
+ let controller = Cc["@mozilla.org/autocomplete/controller;1"].getService(
+ Ci.nsIAutoCompleteController
+ );
+
+ let input = new AutoCompleteInputBase([
+ delayedSearch.name,
+ immediateSearch.name,
+ ]);
+ input.completeDefaultIndex = true;
+ input.textValue = inputStr;
+ input.timeout = 0;
+
+ // Caret must be at the end. Autofill doesn't happen unless you're typing
+ // characters at the end.
+ let strLen = inputStr.length;
+ input.selectTextRange(strLen, strLen);
+
+ controller.input = input;
+ let complete = false;
+ input.onSearchComplete = function () {
+ complete = true;
+ };
+ controller.startSearch(inputStr);
+ Assert.ok(complete);
+
+ // Immediately check the result, the immediate search should have finished.
+ Assert.equal(input.textValue, "moz-immediate");
+
+ unregisterAutoCompleteSearch(immediateSearch);
+ unregisterAutoCompleteSearch(delayedSearch);
+ run_next_test();
+});
+
+/**
+ * A delayed search should be executed synchronously with a zero timeout.
+ */
+add_test(function test_delayed_search_notimeout() {
+ let inputStr = "moz";
+
+ let delayedSearch = new AutoCompleteDelayedSearch(
+ "delayed",
+ new AutoCompleteResult(["moz-delayed"], 0)
+ );
+ registerAutoCompleteSearch(delayedSearch);
+
+ let controller = Cc["@mozilla.org/autocomplete/controller;1"].getService(
+ Ci.nsIAutoCompleteController
+ );
+
+ let input = new AutoCompleteInputBase([delayedSearch.name]);
+ input.completeDefaultIndex = true;
+ input.textValue = inputStr;
+ input.timeout = 0;
+
+ // Caret must be at the end. Autofill doesn't happen unless you're typing
+ // characters at the end.
+ let strLen = inputStr.length;
+ input.selectTextRange(strLen, strLen);
+
+ controller.input = input;
+ let complete = false;
+ input.onSearchComplete = function () {
+ complete = true;
+ };
+ controller.startSearch(inputStr);
+ Assert.ok(complete);
+
+ // Immediately check the result, the delayed search should have finished.
+ Assert.equal(input.textValue, "moz-delayed");
+
+ unregisterAutoCompleteSearch(delayedSearch);
+ run_next_test();
+});
diff --git a/toolkit/components/autocomplete/tests/unit/test_insertMatchAt.js b/toolkit/components/autocomplete/tests/unit/test_insertMatchAt.js
new file mode 100644
index 0000000000..cef3fb9683
--- /dev/null
+++ b/toolkit/components/autocomplete/tests/unit/test_insertMatchAt.js
@@ -0,0 +1,15 @@
+function run_test() {
+ let result = Cc["@mozilla.org/autocomplete/simple-result;1"].createInstance(
+ Ci.nsIAutoCompleteSimpleResult
+ );
+ result.appendMatch("a", "");
+ result.appendMatch("c", "");
+ result.insertMatchAt(1, "b", "");
+ result.insertMatchAt(3, "d", "");
+
+ Assert.equal(result.matchCount, 4);
+ Assert.equal(result.getValueAt(0), "a");
+ Assert.equal(result.getValueAt(1), "b");
+ Assert.equal(result.getValueAt(2), "c");
+ Assert.equal(result.getValueAt(3), "d");
+}
diff --git a/toolkit/components/autocomplete/tests/unit/test_previousResult.js b/toolkit/components/autocomplete/tests/unit/test_previousResult.js
new file mode 100644
index 0000000000..85db3f08c5
--- /dev/null
+++ b/toolkit/components/autocomplete/tests/unit/test_previousResult.js
@@ -0,0 +1,255 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+/**
+ * Unit test for Bug 438861 - Previous search results not returned to multiple
+ * searches.
+ */
+
+/**
+ * Dummy nsIAutoCompleteInput source that returns
+ * the given list of AutoCompleteSearch names.
+ *
+ * Implements only the methods needed for this test.
+ */
+function AutoCompleteInput(aSearches) {
+ this.searches = aSearches;
+}
+AutoCompleteInput.prototype = {
+ constructor: AutoCompleteInput,
+
+ // Array of AutoCompleteSearch names
+ searches: null,
+
+ minResultsForPopup: 0,
+ timeout: 10,
+ searchParam: "",
+ textValue: "",
+ disableAutoComplete: false,
+ completeDefaultIndex: false,
+
+ get searchCount() {
+ return this.searches.length;
+ },
+
+ getSearchAt(aIndex) {
+ return this.searches[aIndex];
+ },
+
+ onSearchBegin() {},
+ onSearchComplete() {},
+
+ popupOpen: false,
+
+ popup: {
+ setSelectedIndex(aIndex) {},
+ invalidate() {},
+
+ // nsISupports implementation
+ QueryInterface: ChromeUtils.generateQI(["nsIAutoCompletePopup"]),
+ },
+
+ // nsISupports implementation
+ QueryInterface: ChromeUtils.generateQI(["nsIAutoCompleteInput"]),
+};
+
+/**
+ * nsIAutoCompleteResult implementation
+ */
+function AutoCompleteResult(aValues, aComments, aStyles) {
+ this._values = aValues;
+ this._comments = aComments;
+ this._styles = aStyles;
+ this.searchResult = this._values.length
+ ? Ci.nsIAutoCompleteResult.RESULT_SUCCESS
+ : Ci.nsIAutoCompleteResult.RESULT_NOMATCH;
+}
+AutoCompleteResult.prototype = {
+ constructor: AutoCompleteResult,
+
+ // Arrays
+ _values: null,
+ _comments: null,
+ _styles: null,
+
+ searchString: "",
+ searchResult: null,
+
+ defaultIndex: 0,
+
+ get matchCount() {
+ return this._values.length;
+ },
+
+ getValueAt(aIndex) {
+ return this._values[aIndex];
+ },
+
+ getLabelAt(aIndex) {
+ return this.getValueAt(aIndex);
+ },
+
+ getCommentAt(aIndex) {
+ return this._comments[aIndex];
+ },
+
+ getStyleAt(aIndex) {
+ return this._styles[aIndex];
+ },
+
+ getImageAt(aIndex) {
+ return "";
+ },
+
+ getFinalCompleteValueAt(aIndex) {
+ return this.getValueAt(aIndex);
+ },
+
+ isRemovableAt(aRowIndex) {
+ return true;
+ },
+
+ removeValueAt(aRowIndex) {},
+
+ // nsISupports implementation
+ QueryInterface: ChromeUtils.generateQI(["nsIAutoCompleteResult"]),
+};
+
+/**
+ * nsIAutoCompleteSearch implementation that always returns
+ * the same result set.
+ */
+function AutoCompleteSearch(aName, aResult) {
+ this.name = aName;
+ this._result = aResult;
+}
+AutoCompleteSearch.prototype = {
+ constructor: AutoCompleteSearch,
+
+ // Search name. Used by AutoCompleteController
+ name: null,
+
+ // AutoCompleteResult
+ _result: null,
+
+ _previousResult: null,
+
+ /**
+ * Return the same result set for every search
+ */
+ startSearch(aSearchString, aSearchParam, aPreviousResult, aListener) {
+ this._previousResult = aPreviousResult;
+ aListener.onSearchResult(this, this._result);
+ },
+
+ stopSearch() {},
+
+ // nsISupports implementation
+ QueryInterface: ChromeUtils.generateQI([
+ "nsIFactory",
+ "nsIAutoCompleteSearch",
+ ]),
+
+ // nsIFactory implementation
+ createInstance(iid) {
+ return this.QueryInterface(iid);
+ },
+};
+
+/**
+ * Helper to register an AutoCompleteSearch with the given name.
+ * Allows the AutoCompleteController to find the search.
+ */
+function registerAutoCompleteSearch(aSearch) {
+ var name = "@mozilla.org/autocomplete/search;1?name=" + aSearch.name;
+
+ var uuidGenerator = Services.uuid;
+ var cid = uuidGenerator.generateUUID();
+
+ var desc = "Test AutoCompleteSearch";
+
+ var componentManager = Components.manager.QueryInterface(
+ Ci.nsIComponentRegistrar
+ );
+ componentManager.registerFactory(cid, desc, name, aSearch);
+
+ // Keep the id on the object so we can unregister later
+ aSearch.cid = cid;
+}
+
+/**
+ * Helper to unregister an AutoCompleteSearch.
+ */
+function unregisterAutoCompleteSearch(aSearch) {
+ var componentManager = Components.manager.QueryInterface(
+ Ci.nsIComponentRegistrar
+ );
+ componentManager.unregisterFactory(aSearch.cid, aSearch);
+}
+
+/**
+ */
+function run_test() {
+ // Make an AutoCompleteSearch that always returns nothing
+ var search1 = new AutoCompleteSearch(
+ "test-previous-result1",
+ new AutoCompleteResult(["hello1"], [""], [""])
+ );
+
+ var search2 = new AutoCompleteSearch(
+ "test-previous-result2",
+ new AutoCompleteResult(["hello2"], [""], [""])
+ );
+
+ // Register search so AutoCompleteController can find them
+ registerAutoCompleteSearch(search1);
+ registerAutoCompleteSearch(search2);
+
+ var controller = Cc["@mozilla.org/autocomplete/controller;1"].getService(
+ Ci.nsIAutoCompleteController
+ );
+
+ // Make an AutoCompleteInput that uses our search
+ // and confirms results on search complete
+ var input = new AutoCompleteInput([search1.name, search2.name]);
+ var numSearchesStarted = 0;
+
+ input.onSearchBegin = function () {
+ numSearchesStarted++;
+ };
+
+ input.onSearchComplete = function () {
+ Assert.equal(
+ controller.searchStatus,
+ Ci.nsIAutoCompleteController.STATUS_COMPLETE_MATCH
+ );
+ Assert.equal(controller.matchCount, 2);
+
+ if (numSearchesStarted == 1) {
+ Assert.equal(search1._previousResult, null);
+ Assert.equal(search2._previousResult, null);
+
+ // Now start it again
+ controller.startSearch("test");
+ return;
+ }
+ Assert.notEqual(search1._previousResult, null);
+ Assert.notEqual(search2._previousResult, null);
+
+ // Unregister searches
+ unregisterAutoCompleteSearch(search1);
+ unregisterAutoCompleteSearch(search2);
+
+ do_test_finished();
+ };
+
+ controller.input = input;
+
+ // Search is asynchronous, so don't let the test finish immediately
+ do_test_pending();
+
+ controller.startSearch("test");
+}
diff --git a/toolkit/components/autocomplete/tests/unit/test_removeMatchAt.js b/toolkit/components/autocomplete/tests/unit/test_removeMatchAt.js
new file mode 100644
index 0000000000..c8abf0b832
--- /dev/null
+++ b/toolkit/components/autocomplete/tests/unit/test_removeMatchAt.js
@@ -0,0 +1,16 @@
+function run_test() {
+ let result = Cc["@mozilla.org/autocomplete/simple-result;1"].createInstance(
+ Ci.nsIAutoCompleteSimpleResult
+ );
+ result.appendMatch("a", "");
+ result.appendMatch("b", "");
+ result.removeMatchAt(0);
+ Assert.equal(result.matchCount, 1);
+ Assert.equal(result.getValueAt(0), "b");
+ result.appendMatch("c", "");
+ result.removeMatchAt(1);
+ Assert.equal(result.matchCount, 1);
+ Assert.equal(result.getValueAt(0), "b");
+ result.removeMatchAt(0);
+ Assert.equal(result.matchCount, 0);
+}
diff --git a/toolkit/components/autocomplete/tests/unit/test_stopSearch.js b/toolkit/components/autocomplete/tests/unit/test_stopSearch.js
new file mode 100644
index 0000000000..aecf572df0
--- /dev/null
+++ b/toolkit/components/autocomplete/tests/unit/test_stopSearch.js
@@ -0,0 +1,171 @@
+/*
+ * Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+/**
+ * Purpose of the test is to check that a stopSearch call comes always before a
+ * startSearch call.
+ */
+
+/**
+ * Dummy nsIAutoCompleteInput source that returns
+ * the given list of AutoCompleteSearch names.
+ *
+ * Implements only the methods needed for this test.
+ */
+function AutoCompleteInput(aSearches) {
+ this.searches = aSearches;
+}
+AutoCompleteInput.prototype = {
+ constructor: AutoCompleteInput,
+ minResultsForPopup: 0,
+ timeout: 10,
+ searchParam: "",
+ textValue: "hello",
+ disableAutoComplete: false,
+ completeDefaultIndex: false,
+ set popupOpen(val) {}, // ignore
+ get popupOpen() {
+ return false;
+ },
+ get searchCount() {
+ return this.searches.length;
+ },
+ getSearchAt(aIndex) {
+ return this.searches[aIndex];
+ },
+ onSearchBegin() {},
+ onSearchComplete() {},
+ onTextReverted() {},
+ onTextEntered() {},
+ popup: {
+ selectBy() {},
+ invalidate() {},
+ set selectedIndex(val) {}, // ignore
+ get selectedIndex() {
+ return -1;
+ },
+ QueryInterface: ChromeUtils.generateQI(["nsIAutoCompletePopup"]),
+ },
+ QueryInterface: ChromeUtils.generateQI(["nsIAutoCompleteInput"]),
+};
+
+/**
+ * nsIAutoCompleteSearch implementation.
+ */
+function AutoCompleteSearch(aName) {
+ this.name = aName;
+}
+AutoCompleteSearch.prototype = {
+ constructor: AutoCompleteSearch,
+ stopSearchInvoked: true,
+ startSearch(aSearchString, aSearchParam, aPreviousResult, aListener) {
+ info("Check stop search has been called");
+ Assert.ok(this.stopSearchInvoked);
+ this.stopSearchInvoked = false;
+ },
+ stopSearch() {
+ this.stopSearchInvoked = true;
+ },
+ QueryInterface: ChromeUtils.generateQI([
+ "nsIFactory",
+ "nsIAutoCompleteSearch",
+ ]),
+ createInstance(iid) {
+ return this.QueryInterface(iid);
+ },
+};
+
+/**
+ * Helper to register an AutoCompleteSearch with the given name.
+ * Allows the AutoCompleteController to find the search.
+ */
+function registerAutoCompleteSearch(aSearch) {
+ let name = "@mozilla.org/autocomplete/search;1?name=" + aSearch.name;
+ let uuidGenerator = Services.uuid;
+ let cid = uuidGenerator.generateUUID();
+ let desc = "Test AutoCompleteSearch";
+ let componentManager = Components.manager.QueryInterface(
+ Ci.nsIComponentRegistrar
+ );
+ componentManager.registerFactory(cid, desc, name, aSearch);
+ // Keep the id on the object so we can unregister later
+ aSearch.cid = cid;
+}
+
+/**
+ * Helper to unregister an AutoCompleteSearch.
+ */
+function unregisterAutoCompleteSearch(aSearch) {
+ let componentManager = Components.manager.QueryInterface(
+ Ci.nsIComponentRegistrar
+ );
+ componentManager.unregisterFactory(aSearch.cid, aSearch);
+}
+
+var gTests = [
+ function (controller) {
+ info("handleText");
+ controller.input.textValue = "hel";
+ controller.handleText();
+ },
+ function (controller) {
+ info("handleStartComposition");
+ controller.handleStartComposition();
+ info("handleEndComposition");
+ controller.handleEndComposition();
+ // an input event always follows compositionend event.
+ controller.handleText();
+ },
+ function (controller) {
+ info("handleEscape");
+ controller.handleEscape();
+ },
+ function (controller) {
+ info("handleEnter");
+ controller.handleEnter(false);
+ },
+ function (controller) {
+ info("handleTab");
+ controller.handleTab();
+ },
+
+ function (controller) {
+ info("handleKeyNavigation");
+ // Hardcode KeyboardEvent.DOM_VK_RIGHT, because we can't easily
+ // include KeyboardEvent here.
+ controller.handleKeyNavigation(0x26 /* KeyboardEvent.DOM_VK_UP */);
+ },
+];
+
+add_task(async function () {
+ // Make an AutoCompleteSearch that always returns nothing
+ let search = new AutoCompleteSearch("test");
+ registerAutoCompleteSearch(search);
+
+ let controller = Cc["@mozilla.org/autocomplete/controller;1"].getService(
+ Ci.nsIAutoCompleteController
+ );
+
+ // Make an AutoCompleteInput that uses our search.
+ let input = new AutoCompleteInput([search.name]);
+ controller.input = input;
+
+ for (let testFn of gTests) {
+ input.onSearchBegin = function () {
+ executeSoon(() => testFn(controller));
+ };
+ let promise = new Promise(resolve => {
+ input.onSearchComplete = function () {
+ resolve();
+ };
+ });
+ controller.startSearch("hello");
+ await promise;
+ }
+
+ unregisterAutoCompleteSearch(search);
+ controller.stopSearch();
+ controller.input = null;
+});
diff --git a/toolkit/components/autocomplete/tests/unit/xpcshell.toml b/toolkit/components/autocomplete/tests/unit/xpcshell.toml
new file mode 100644
index 0000000000..00d238cdf7
--- /dev/null
+++ b/toolkit/components/autocomplete/tests/unit/xpcshell.toml
@@ -0,0 +1,44 @@
+[DEFAULT]
+head = "head_autocomplete.js"
+
+["test_330578.js"]
+
+["test_378079.js"]
+
+["test_393191.js"]
+
+["test_440866.js"]
+
+["test_463023.js"]
+
+["test_660156.js"]
+
+["test_autocomplete_multiple.js"]
+
+["test_autocomplete_userContextId.js"]
+
+["test_autofillSelectedPopupIndex.js"]
+
+["test_badDefaultIndex.js"]
+
+["test_completeDefaultIndex_casing.js"]
+
+["test_finalCompleteValue.js"]
+
+["test_finalCompleteValueSelectedIndex.js"]
+
+["test_finalCompleteValue_defaultIndex.js"]
+
+["test_finalCompleteValue_forceComplete.js"]
+
+["test_finalDefaultCompleteValue.js"]
+
+["test_immediate_search.js"]
+
+["test_insertMatchAt.js"]
+
+["test_previousResult.js"]
+
+["test_removeMatchAt.js"]
+
+["test_stopSearch.js"]