diff options
Diffstat (limited to 'toolkit/components/autocomplete/nsAutoCompleteController.cpp')
| -rw-r--r-- | toolkit/components/autocomplete/nsAutoCompleteController.cpp | 1771 |
1 files changed, 1771 insertions, 0 deletions
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; +} |