Add m-esr52 at 52.6.0

1 files changed, 2087 insertions, 0 deletions

diff --git a/toolkit/components/autocomplete/nsAutoCompleteController.cpp b/toolkit/components/autocomplete/nsAutoCompleteController.cpp
new file mode 100644
index 000000000..5d69ea1a3
--- /dev/null
+++ b/toolkit/components/autocomplete/nsAutoCompleteController.cpp
@@ -0,0 +1,2087 @@
+/* -*- 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 "nsAutoPtr.h"
+#include "nsNetCID.h"
+#include "nsIIOService.h"
+#include "nsToolkitCompsCID.h"
+#include "nsIServiceManager.h"
+#include "nsReadableUtils.h"
+#include "nsUnicharUtils.h"
+#include "nsIScriptSecurityManager.h"
+#include "nsITreeBoxObject.h"
+#include "nsITreeColumns.h"
+#include "nsIObserverService.h"
+#include "nsIDOMKeyEvent.h"
+#include "mozilla/Services.h"
+#include "mozilla/ModuleUtils.h"
+
+static const char *kAutoCompleteSearchCID = "@mozilla.org/autocomplete/search;1?name=";
+
+namespace {
+
+void
+SetTextValue(nsIAutoCompleteInput* aInput,
+             const nsString& aValue,
+             uint16_t aReason) {
+  nsresult rv = aInput->SetTextValueWithReason(aValue, aReason);
+  if (NS_FAILED(rv)) {
+    aInput->SetTextValue(aValue);
+  }
+}
+
+} // anon namespace
+
+NS_IMPL_CYCLE_COLLECTION_CLASS(nsAutoCompleteController)
+
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(nsAutoCompleteController)
+  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_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, nsITreeView)
+  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),
+  mRowCount(0),
+  mSearchesOngoing(0),
+  mSearchesFailed(0),
+  mFirstSearchResult(false),
+  mImmediateSearchesCount(0),
+  mCompletedSelectionIndex(-1)
+{
+}
+
+nsAutoCompleteController::~nsAutoCompleteController()
+{
+  SetInput(nullptr);
+}
+
+////////////////////////////////////////////////////////////////////////
+//// nsIAutoCompleteController
+
+NS_IMETHODIMP
+nsAutoCompleteController::GetSearchStatus(uint16_t *aSearchStatus)
+{
+  *aSearchStatus = mSearchStatus;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteController::GetMatchCount(uint32_t *aMatchCount)
+{
+  *aMatchCount = mRowCount;
+  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;
+  input->GetPopup(getter_AddRefs(popup));
+  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;
+
+  // Clear out the current search context
+  if (mInput) {
+    // Stop all searches in case they are async.
+    StopSearch();
+    ClearResults();
+    ClosePopup();
+    mSearches.Clear();
+  }
+
+  mInput = aInput;
+
+  // Nothing more to do if the input was just being set to null.
+  if (!aInput)
+    return NS_OK;
+
+  nsAutoString newValue;
+  aInput->GetTextValue(newValue);
+
+  // Clear out this reference in case the new input's popup has no tree
+  mTree = nullptr;
+
+  // Reset all search state members to default values
+  mSearchString = newValue;
+  mPlaceholderCompletionString.Truncate();
+  mDefaultIndexCompleted = false;
+  mProhibitAutoFill = false;
+  mSearchStatus = nsIAutoCompleteController::STATUS_NONE;
+  mRowCount = 0;
+  mSearchesOngoing = 0;
+  mCompletedSelectionIndex = -1;
+
+  // Initialize our list of search objects
+  uint32_t searchCount;
+  aInput->GetSearchCount(&searchCount);
+  mResults.SetCapacity(searchCount);
+  mSearches.SetCapacity(searchCount);
+  mImmediateSearchesCount = 0;
+
+  const char *searchCID = kAutoCompleteSearchCID;
+
+  // Since the controller can be used as a service it's important to reset this.
+  mClearingAutoFillSearchesAgain = false;
+
+  for (uint32_t i = 0; i < searchCount; ++i) {
+    // Use the search name to create the contract id string for the search service
+    nsAutoCString searchName;
+    aInput->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);
+        }
+      }
+    }
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteController::StartSearch(const nsAString &aSearchString)
+{
+  mSearchString = 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;
+  }
+
+  mSearchString = newValue;
+
+  // Don't search if the value is empty
+  if (newValue.Length() == 0) {
+    // 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(nsIDOMKeyEvent::DOM_VK_DOWN, &cancel);
+      return NS_OK;
+    }
+    ClosePopup();
+    return NS_OK;
+  }
+
+  *_retval = true;
+  StartSearches();
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteController::HandleEnter(bool aIsPopupSelection,
+                                      nsIDOMEvent *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;
+    input->GetPopup(getter_AddRefs(popup));
+
+    if (popup) {
+      int32_t selectedIndex;
+      popup->GetSelectedIndex(&selectedIndex);
+      *_retval = selectedIndex >= 0;
+    }
+  }
+
+  // Stop the search, and handle the enter.
+  StopSearch();
+  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;
+  input->GetPopup(getter_AddRefs(popup));
+  NS_ENSURE_TRUE(popup != nullptr, NS_ERROR_FAILURE);
+
+  bool disabled;
+  input->GetDisableAutoComplete(&disabled);
+  NS_ENSURE_TRUE(!disabled, NS_OK);
+
+  if (aKey == nsIDOMKeyEvent::DOM_VK_UP ||
+      aKey == nsIDOMKeyEvent::DOM_VK_DOWN ||
+      aKey == nsIDOMKeyEvent::DOM_VK_PAGE_UP ||
+      aKey == nsIDOMKeyEvent::DOM_VK_PAGE_DOWN)
+  {
+    // Prevent the input from handling up/down events, as it may move
+    // the cursor to home/end on some systems
+    *_retval = true;
+
+    bool isOpen = false;
+    input->GetPopupOpen(&isOpen);
+    if (isOpen) {
+      bool reverse = aKey == nsIDOMKeyEvent::DOM_VK_UP ||
+                      aKey == nsIDOMKeyEvent::DOM_VK_PAGE_UP ? true : false;
+      bool page = aKey == nsIDOMKeyEvent::DOM_VK_PAGE_UP ||
+                    aKey == nsIDOMKeyEvent::DOM_VK_PAGE_DOWN ? true : false;
+
+      // 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);
+
+      // 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;
+              SetTextValue(input, value,
+                           nsIAutoCompleteInput::TEXTVALUE_REASON_COMPLETEDEFAULT);
+            } else {
+              start = value.Length();
+              SetTextValue(input, value,
+                           nsIAutoCompleteInput::TEXTVALUE_REASON_COMPLETESELECTED);
+            }
+
+            input->SelectTextRange(start, value.Length());
+          }
+          mCompletedSelectionIndex = selectedIndex;
+        } else {
+          // Nothing is selected, so fill in the last typed value
+          SetTextValue(input, mSearchString,
+                       nsIAutoCompleteInput::TEXTVALUE_REASON_REVERT);
+          input->SelectTextRange(mSearchString.Length(), mSearchString.Length());
+          mCompletedSelectionIndex = -1;
+        }
+      }
+    } else {
+#ifdef XP_MACOSX
+      // on Mac, 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.
+      int32_t start, end;
+      if (aKey == nsIDOMKeyEvent::DOM_VK_UP) {
+        input->GetSelectionStart(&start);
+        input->GetSelectionEnd(&end);
+        if (start > 0 || start != end)
+          *_retval = false;
+      }
+      else if (aKey == nsIDOMKeyEvent::DOM_VK_DOWN) {
+        nsAutoString text;
+        input->GetTextValue(text);
+        input->GetSelectionStart(&start);
+        input->GetSelectionEnd(&end);
+        if (start != end || end < (int32_t)text.Length())
+          *_retval = false;
+      }
+#endif
+      if (*_retval) {
+        // Open the popup if there has been a previous search, or else kick off a new search
+        if (!mResults.IsEmpty()) {
+          if (mRowCount) {
+            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);
+          mSearchString = value;
+
+          StartSearches();
+        }
+      }
+    }
+  } else if (   aKey == nsIDOMKeyEvent::DOM_VK_LEFT
+             || aKey == nsIDOMKeyEvent::DOM_VK_RIGHT
+#ifndef XP_MACOSX
+             || aKey == nsIDOMKeyEvent::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 || (mRowCount > 0 && mRowCount < 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.
+      if (isOpen) {
+        bool noRollup;
+        input->GetNoRollupOnCaretMove(&noRollup);
+        if (noRollup) {
+          bool completeSelection;
+          input->GetCompleteSelectedIndex(&completeSelection);
+          if (completeSelection) {
+            return NS_OK;
+          }
+        }
+      }
+
+      int32_t selectedIndex;
+      popup->GetSelectedIndex(&selectedIndex);
+      bool shouldComplete;
+      input->GetCompleteDefaultIndex(&shouldComplete);
+      if (selectedIndex >= 0) {
+        // The pop-up is open and has a selection, take its value
+        nsAutoString value;
+        if (NS_SUCCEEDED(GetResultValueAt(selectedIndex, false, value))) {
+          SetTextValue(input, value,
+                       nsIAutoCompleteInput::TEXTVALUE_REASON_COMPLETESELECTED);
+          input->SelectTextRange(value.Length(), value.Length());
+        }
+      }
+      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. 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(" >> ");
+          if (pos > 0) {
+            inputValue.Right(suggestedValue, inputValue.Length() - pos - 4);
+          } else {
+            suggestedValue = inputValue;
+          }
+
+          if (value.Equals(suggestedValue, nsCaseInsensitiveStringComparator())) {
+            SetTextValue(input, value,
+                         nsIAutoCompleteInput::TEXTVALUE_REASON_COMPLETEDEFAULT);
+            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);
+    mSearchString = 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 || mRowCount <= 0) {
+    // Nothing left to delete, proceed as normal
+    bool unused = false;
+    HandleText(&unused);
+    return NS_OK;
+  }
+
+  nsCOMPtr<nsIAutoCompletePopup> popup;
+  input->GetPopup(getter_AddRefs(popup));
+
+  int32_t index, searchIndex, rowIndex;
+  popup->GetSelectedIndex(&index);
+  if (index == -1) {
+    // No row is selected in the list
+    bool unused = false;
+    HandleText(&unused);
+    return NS_OK;
+  }
+
+  RowIndexToSearch(index, &searchIndex, &rowIndex);
+  NS_ENSURE_TRUE(searchIndex >= 0 && rowIndex >= 0, NS_ERROR_FAILURE);
+
+  nsIAutoCompleteResult *result = mResults.SafeObjectAt(searchIndex);
+  NS_ENSURE_TRUE(result, NS_ERROR_FAILURE);
+
+  nsAutoString search;
+  input->GetSearchParam(search);
+
+  // Clear the row in our result and in the DB.
+  result->RemoveValueAt(rowIndex, true);
+  --mRowCount;
+
+  // We removed it, so make sure we cancel the event that triggered this call.
+  *_retval = true;
+
+  // Unselect the current item.
+  popup->SetSelectedIndex(-1);
+
+  // Tell the tree that the row count changed.
+  if (mTree)
+    mTree->RowCountChanged(mRowCount, -1);
+
+  // Adjust index, if needed.
+  if (index >= (int32_t)mRowCount)
+    index = mRowCount - 1;
+
+  if (mRowCount > 0) {
+    // There are still rows 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* aRowIndex)
+{
+  int32_t searchIndex;
+  RowIndexToSearch(aIndex, &searchIndex, aRowIndex);
+  NS_ENSURE_TRUE(searchIndex >= 0 && *aRowIndex >= 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 rowIndex;
+  nsIAutoCompleteResult* result;
+  nsresult rv = GetResultAt(aIndex, &result, &rowIndex);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return result->GetCommentAt(rowIndex, _retval);
+}
+
+NS_IMETHODIMP
+nsAutoCompleteController::GetStyleAt(int32_t aIndex, nsAString & _retval)
+{
+  int32_t rowIndex;
+  nsIAutoCompleteResult* result;
+  nsresult rv = GetResultAt(aIndex, &result, &rowIndex);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return result->GetStyleAt(rowIndex, _retval);
+}
+
+NS_IMETHODIMP
+nsAutoCompleteController::GetImageAt(int32_t aIndex, nsAString & _retval)
+{
+  int32_t rowIndex;
+  nsIAutoCompleteResult* result;
+  nsresult rv = GetResultAt(aIndex, &result, &rowIndex);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return result->GetImageAt(rowIndex, _retval);
+}
+
+NS_IMETHODIMP
+nsAutoCompleteController::GetFinalCompleteValueAt(int32_t aIndex,
+                                                  nsAString & _retval)
+{
+  int32_t rowIndex;
+  nsIAutoCompleteResult* result;
+  nsresult rv = GetResultAt(aIndex, &result, &rowIndex);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return result->GetFinalCompleteValueAt(rowIndex, _retval);
+}
+
+NS_IMETHODIMP
+nsAutoCompleteController::SetSearchString(const nsAString &aSearchString)
+{
+  mSearchString = aSearchString;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteController::GetSearchString(nsAString &aSearchString)
+{
+  aSearchString = mSearchString;
+  return NS_OK;
+}
+
+void
+nsAutoCompleteController::HandleSearchResult(nsIAutoCompleteSearch *aSearch,
+                                             nsIAutoCompleteResult *aResult)
+{
+  // 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);
+    }
+  }
+}
+
+
+////////////////////////////////////////////////////////////////////////
+//// nsIAutoCompleteObserver
+
+NS_IMETHODIMP
+nsAutoCompleteController::OnUpdateSearchResult(nsIAutoCompleteSearch *aSearch, nsIAutoCompleteResult* aResult)
+{
+  MOZ_ASSERT(mSearches.Contains(aSearch));
+
+  ClearResults();
+  HandleSearchResult(aSearch, aResult);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteController::OnSearchResult(nsIAutoCompleteSearch *aSearch, nsIAutoCompleteResult* aResult)
+{
+  MOZ_ASSERT(mSearchesOngoing > 0 && mSearches.Contains(aSearch));
+
+  // If this is the first search result we are processing
+  // we should clear out the previously cached results.
+  if (mFirstSearchResult) {
+    ClearResults();
+    mFirstSearchResult = false;
+  }
+
+  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;
+  }
+
+  HandleSearchResult(aSearch, aResult);
+
+  if (mSearchesOngoing == 0) {
+    // If this is the last search to return, cleanup.
+    PostSearchCleanup();
+  }
+
+  return NS_OK;
+}
+
+////////////////////////////////////////////////////////////////////////
+//// nsITimerCallback
+
+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;
+}
+
+////////////////////////////////////////////////////////////////////////
+// nsITreeView
+
+NS_IMETHODIMP
+nsAutoCompleteController::GetRowCount(int32_t *aRowCount)
+{
+  *aRowCount = mRowCount;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteController::GetRowProperties(int32_t index, nsAString& aProps)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteController::GetCellProperties(int32_t row, nsITreeColumn* col,
+                                            nsAString& aProps)
+{
+  if (row >= 0) {
+    GetStyleAt(row, aProps);
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteController::GetColumnProperties(nsITreeColumn* col, nsAString& aProps)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteController::GetImageSrc(int32_t row, nsITreeColumn* col, nsAString& _retval)
+{
+  const char16_t* colID;
+  col->GetIdConst(&colID);
+
+  if (NS_LITERAL_STRING("treecolAutoCompleteValue").Equals(colID))
+    return GetImageAt(row, _retval);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteController::GetProgressMode(int32_t row, nsITreeColumn* col, int32_t* _retval)
+{
+  NS_NOTREACHED("tree has no progress cells");
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteController::GetCellValue(int32_t row, nsITreeColumn* col, nsAString& _retval)
+{
+  NS_NOTREACHED("all of our cells are text");
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteController::GetCellText(int32_t row, nsITreeColumn* col, nsAString& _retval)
+{
+  const char16_t* colID;
+  col->GetIdConst(&colID);
+
+  if (NS_LITERAL_STRING("treecolAutoCompleteValue").Equals(colID))
+    GetValueAt(row, _retval);
+  else if (NS_LITERAL_STRING("treecolAutoCompleteComment").Equals(colID))
+    GetCommentAt(row, _retval);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteController::IsContainer(int32_t index, bool *_retval)
+{
+  *_retval = false;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteController::IsContainerOpen(int32_t index, bool *_retval)
+{
+  NS_NOTREACHED("no container cells");
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteController::IsContainerEmpty(int32_t index, bool *_retval)
+{
+  NS_NOTREACHED("no container cells");
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteController::GetLevel(int32_t index, int32_t *_retval)
+{
+  *_retval = 0;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteController::GetParentIndex(int32_t rowIndex, int32_t *_retval)
+{
+  *_retval = -1;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteController::HasNextSibling(int32_t rowIndex, int32_t afterIndex, bool *_retval)
+{
+  *_retval = false;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteController::ToggleOpenState(int32_t index)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteController::SetTree(nsITreeBoxObject *tree)
+{
+  mTree = tree;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteController::GetSelection(nsITreeSelection * *aSelection)
+{
+  *aSelection = mSelection;
+  NS_IF_ADDREF(*aSelection);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsAutoCompleteController::SetSelection(nsITreeSelection * aSelection)
+{
+  mSelection = aSelection;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteController::SelectionChanged()
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteController::SetCellValue(int32_t row, nsITreeColumn* col, const nsAString& value)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteController::SetCellText(int32_t row, nsITreeColumn* col, const nsAString& value)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteController::CycleHeader(nsITreeColumn* col)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteController::CycleCell(int32_t row, nsITreeColumn* col)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteController::IsEditable(int32_t row, nsITreeColumn* col, bool *_retval)
+{
+  *_retval = false;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteController::IsSelectable(int32_t row, nsITreeColumn* col, bool *_retval)
+{
+  *_retval = false;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteController::IsSeparator(int32_t index, bool *_retval)
+{
+  *_retval = false;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteController::IsSorted(bool *_retval)
+{
+  *_retval = false;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteController::CanDrop(int32_t index, int32_t orientation,
+                                  nsIDOMDataTransfer* dataTransfer, bool *_retval)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteController::Drop(int32_t row, int32_t orientation, nsIDOMDataTransfer* dataTransfer)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteController::PerformAction(const char16_t *action)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteController::PerformActionOnRow(const char16_t *action, int32_t row)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteController::PerformActionOnCell(const char16_t* action, int32_t row, nsITreeColumn* col)
+{
+  return NS_OK;
+}
+
+////////////////////////////////////////////////////////////////////////
+//// nsAutoCompleteController
+
+nsresult
+nsAutoCompleteController::OpenPopup()
+{
+  uint32_t minResults;
+  mInput->GetMinResultsForPopup(&minResults);
+
+  if (mRowCount >= minResults) {
+    return mInput->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;
+  input->GetPopup(getter_AddRefs(popup));
+  NS_ENSURE_TRUE(popup != nullptr, NS_ERROR_FAILURE);
+  popup->SetSelectedIndex(-1);
+  return input->SetPopupOpen(false);
+}
+
+nsresult
+nsAutoCompleteController::BeforeSearches()
+{
+  NS_ENSURE_STATE(mInput);
+
+  mSearchStatus = nsIAutoCompleteController::STATUS_SEARCHING;
+  mDefaultIndexCompleted = false;
+
+  // The first search result will clear mResults array, though we should pass
+  // the previous result to each search to allow them to reuse it.  So we
+  // temporarily cache current results till AfterSearches().
+  if (!mResultCache.AppendObjects(mResults)) {
+    return NS_ERROR_OUT_OF_MEMORY;
+  }
+
+  mSearchesOngoing = mSearches.Length();
+  mSearchesFailed = 0;
+  mFirstSearchResult = true;
+
+  // 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 (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;
+
+  // Check if the current input should be completed with the placeholder string
+  // from the last completion until the actual search results come back.
+  MaybeCompletePlaceholder();
+
+  nsCOMPtr<nsIAutoCompleteInput> input(mInput);
+
+  // 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.
+  nsresult rv;
+  mTimer = do_CreateInstance("@mozilla.org/timer;1", &rv);
+  if (NS_FAILED(rv))
+      return rv;
+  rv = mTimer->InitWithCallback(this, timeout, nsITimer::TYPE_ONE_SHOT);
+  if (NS_FAILED(rv))
+      mTimer = nullptr;
+
+  return rv;
+}
+
+nsresult
+nsAutoCompleteController::ClearSearchTimer()
+{
+  if (mTimer) {
+    mTimer->Cancel();
+    mTimer = nullptr;
+  }
+  return NS_OK;
+}
+
+nsresult
+nsAutoCompleteController::EnterMatch(bool aIsPopupSelection,
+                                     nsIDOMEvent *aEvent)
+{
+  nsCOMPtr<nsIAutoCompleteInput> input(mInput);
+  nsCOMPtr<nsIAutoCompletePopup> popup;
+  input->GetPopup(getter_AddRefs(popup));
+  NS_ENSURE_TRUE(popup != nullptr, NS_ERROR_FAILURE);
+
+  bool forceComplete;
+  input->GetForceComplete(&forceComplete);
+
+  // Ask the popup if it wants to enter a special value into the textbox
+  nsAutoString value;
+  popup->GetOverrideValue(value);
+  if (value.IsEmpty()) {
+    bool shouldComplete;
+    input->GetCompleteDefaultIndex(&shouldComplete);
+    bool completeSelection;
+    input->GetCompleteSelectedIndex(&completeSelection);
+
+    int32_t selectedIndex;
+    popup->GetSelectedIndex(&selectedIndex);
+    if (selectedIndex >= 0) {
+      nsAutoString inputValue;
+      input->GetTextValue(inputValue);
+      if (aIsPopupSelection || !completeSelection) {
+        // We need to fill-in the value if:
+        //  * completeselectedindex is false
+        //  * A row in the popup was confirmed
+        //
+        // TODO: This is not totally correct, cause it will also confirm
+        // a result selected with a simple mouseover, that could also have
+        // happened accidentally, maybe touching a touchpad.
+        // The reason is that autocomplete.xml sets selectedIndex on mousemove
+        // making impossible, in the !completeSelection case, to distinguish if
+        // the user wanted to confirm autoFill or the popup entry.
+        // The solution may be to change autocomplete.xml to set selectedIndex
+        // only on popupClick, but that requires changing the selection behavior.
+        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;
+        }
+        // Note that if the user opens the popup, mouses over entries without
+        // ever selecting one with the keyboard, and then hits enter, none of
+        // the above cases will be hit, since mouseover doesn't activate
+        // completeselectedindex and thus mCompletedSelectionIndex would be
+        // -1.
+      }
+    } 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(" >> ");
+      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;
+          }
+        }
+      }
+    }
+  }
+
+  nsCOMPtr<nsIObserverService> obsSvc =
+    mozilla::services::GetObserverService();
+  NS_ENSURE_STATE(obsSvc);
+  obsSvc->NotifyObservers(input, "autocomplete-will-enter-text", nullptr);
+
+  if (!value.IsEmpty()) {
+    SetTextValue(input, value, nsIAutoCompleteInput::TEXTVALUE_REASON_ENTERMATCH);
+    input->SelectTextRange(value.Length(), value.Length());
+    mSearchString = value;
+  }
+
+  obsSvc->NotifyObservers(input, "autocomplete-did-enter-text", nullptr);
+  ClosePopup();
+
+  bool cancel;
+  input->OnTextEntered(aEvent, &cancel);
+
+  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;
+
+  nsAutoString oldValue(mSearchString);
+  nsCOMPtr<nsIAutoCompleteInput> input(mInput);
+
+  bool cancel = false;
+  input->OnTextReverted(&cancel);
+
+  if (!cancel) {
+    nsCOMPtr<nsIObserverService> obsSvc =
+      mozilla::services::GetObserverService();
+    NS_ENSURE_STATE(obsSvc);
+    obsSvc->NotifyObservers(input, "autocomplete-will-revert-text", nullptr);
+
+    nsAutoString inputValue;
+    input->GetTextValue(inputValue);
+    // 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 (!oldValue.Equals(inputValue)) {
+      SetTextValue(input, oldValue, nsIAutoCompleteInput::TEXTVALUE_REASON_REVERT);
+    }
+
+    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);
+  nsCOMPtr<nsIAutoCompleteInput> input(mInput);
+
+  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 oldRowCount = mRowCount;
+  // 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()) {
+      ++mRowCount;
+      if (mTree) {
+        mTree->RowCountChanged(oldRowCount, 1);
+      }
+    }
+  } 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 - oldRowCount;
+
+    mRowCount += delta;
+    if (mTree) {
+      mTree->RowCountChanged(oldRowCount, 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;
+  input->GetPopup(getter_AddRefs(popup));
+  NS_ENSURE_TRUE(popup != nullptr, NS_ERROR_FAILURE);
+  popup->Invalidate(nsIAutoCompletePopup::INVALIDATE_REASON_NEW_RESULT);
+
+  uint32_t minResults;
+  input->GetMinResultsForPopup(&minResults);
+
+  // Make sure the popup is open, if necessary, since we now have at least one
+  // search result ready to display. Don't force the popup closed if we might
+  // get results in the future to avoid unnecessarily canceling searches.
+  if (mRowCount || !minResults) {
+    OpenPopup();
+  } else if (mSearchesOngoing == 0) {
+    ClosePopup();
+  }
+
+  return NS_OK;
+}
+
+nsresult
+nsAutoCompleteController::PostSearchCleanup()
+{
+  NS_ENSURE_STATE(mInput);
+  nsCOMPtr<nsIAutoCompleteInput> input(mInput);
+
+  uint32_t minResults;
+  input->GetMinResultsForPopup(&minResults);
+
+  if (mRowCount || minResults == 0) {
+    OpenPopup();
+    if (mRowCount)
+      mSearchStatus = nsIAutoCompleteController::STATUS_COMPLETE_MATCH;
+    else
+      mSearchStatus = nsIAutoCompleteController::STATUS_COMPLETE_NO_MATCH;
+  } else {
+    mSearchStatus = nsIAutoCompleteController::STATUS_COMPLETE_NO_MATCH;
+    ClosePopup();
+  }
+
+  // notify the input that the search is complete
+  input->OnSearchComplete();
+
+  return NS_OK;
+}
+
+nsresult
+nsAutoCompleteController::ClearResults()
+{
+  int32_t oldRowCount = mRowCount;
+  mRowCount = 0;
+  mResults.Clear();
+  if (oldRowCount != 0) {
+    if (mTree)
+      mTree->RowCountChanged(0, -oldRowCount);
+    else if (mInput) {
+      nsCOMPtr<nsIAutoCompletePopup> popup;
+      mInput->GetPopup(getter_AddRefs(popup));
+      NS_ENSURE_TRUE(popup != nullptr, NS_ERROR_FAILURE);
+      // if we had a tree, RowCountChanged() would have cleared the selection
+      // when the selected row was removed.  But since we don't have a tree,
+      // we need to clear the selection manually.
+      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;
+  }
+
+  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;
+    SetTextValue(input, aValue,
+                 nsIAutoCompleteInput::TEXTVALUE_REASON_COMPLETEDEFAULT);
+  } 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.LowerCaseEqualsLiteral("http") ||
+          !Substring(aValue, findIndex, mSearchStringLength).Equals(
+            mSearchString, nsCaseInsensitiveStringComparator())) {
+        return NS_OK;
+      }
+
+      mPlaceholderCompletionString = mSearchString +
+        Substring(aValue, mSearchStringLength + findIndex, endSelect);
+      SetTextValue(input, mPlaceholderCompletionString,
+                   nsIAutoCompleteInput::TEXTVALUE_REASON_COMPLETEDEFAULT);
+
+      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.
+      SetTextValue(input, mSearchString + NS_LITERAL_STRING(" >> ") + aValue,
+                   nsIAutoCompleteInput::TEXTVALUE_REASON_COMPLETEDEFAULT);
+
+      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 && (uint32_t) aIndex < mRowCount, NS_ERROR_ILLEGAL_VALUE);
+
+  int32_t rowIndex;
+  nsIAutoCompleteResult *result;
+  nsresult rv = GetResultAt(aIndex, &result, &rowIndex);
+  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(rowIndex, _retval))) {
+        result->GetValueAt(rowIndex, _retval);
+      }
+    } else if (aGetValue) {
+      result->GetValueAt(rowIndex, _retval);
+    } else {
+      result->GetLabelAt(rowIndex, _retval);
+    }
+  }
+
+  return NS_OK;
+}
+
+/**
+ * Given the index of a row in the autocomplete popup, find the
+ * corresponding nsIAutoCompleteSearch index, and sub-index into
+ * the search's results list.
+ */
+nsresult
+nsAutoCompleteController::RowIndexToSearch(int32_t aRowIndex, 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 row
+  for (uint32_t i = 0; i < mSearches.Length(); ++i) {
+    nsIAutoCompleteResult *result = mResults.SafeObjectAt(i);
+    if (!result)
+      continue;
+
+    uint32_t rowCount = 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(&rowCount);
+    }
+
+    // If the given row index is within the results range
+    // of the current nsIAutoCompleteSearch then return the
+    // search index and sub-index into the results array
+    if ((rowCount != 0) && (index + rowCount-1 >= (uint32_t) aRowIndex)) {
+      *aSearchIndex = i;
+      *aItemIndex = aRowIndex - index;
+      return NS_OK;
+    }
+
+    // Advance the popup table index cursor past the
+    // results of the current search.
+    index += rowCount;
+  }
+
+  return NS_OK;
+}
+
+NS_GENERIC_FACTORY_CONSTRUCTOR(nsAutoCompleteController)
+NS_GENERIC_FACTORY_CONSTRUCTOR(nsAutoCompleteSimpleResult)
+
+NS_DEFINE_NAMED_CID(NS_AUTOCOMPLETECONTROLLER_CID);
+NS_DEFINE_NAMED_CID(NS_AUTOCOMPLETESIMPLERESULT_CID);
+
+static const mozilla::Module::CIDEntry kAutoCompleteCIDs[] = {
+  { &kNS_AUTOCOMPLETECONTROLLER_CID, false, nullptr, nsAutoCompleteControllerConstructor },
+  { &kNS_AUTOCOMPLETESIMPLERESULT_CID, false, nullptr, nsAutoCompleteSimpleResultConstructor },
+  { nullptr }
+};
+
+static const mozilla::Module::ContractIDEntry kAutoCompleteContracts[] = {
+  { NS_AUTOCOMPLETECONTROLLER_CONTRACTID, &kNS_AUTOCOMPLETECONTROLLER_CID },
+  { NS_AUTOCOMPLETESIMPLERESULT_CONTRACTID, &kNS_AUTOCOMPLETESIMPLERESULT_CID },
+  { nullptr }
+};
+
+static const mozilla::Module kAutoCompleteModule = {
+  mozilla::Module::kVersion,
+  kAutoCompleteCIDs,
+  kAutoCompleteContracts
+};
+
+NSMODULE_DEFN(tkAutoCompleteModule) = &kAutoCompleteModule;