Add m-esr52 at 52.6.0

34 files changed, 6208 insertions, 0 deletions

diff --git a/toolkit/components/autocomplete/moz.build b/toolkit/components/autocomplete/moz.build
new file mode 100644
index 000000000..f3817d642
--- /dev/null
+++ b/toolkit/components/autocomplete/moz.build
@@ -0,0 +1,28 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+XPCSHELL_TESTS_MANIFESTS += ['tests/unit/xpcshell.ini']
+
+XPIDL_SOURCES += [
+    'nsIAutoCompleteController.idl',
+    'nsIAutoCompleteInput.idl',
+    'nsIAutoCompletePopup.idl',
+    'nsIAutoCompleteResult.idl',
+    'nsIAutoCompleteSearch.idl',
+    'nsIAutoCompleteSimpleResult.idl',
+]
+
+XPIDL_MODULE = 'autocomplete'
+
+UNIFIED_SOURCES += [
+    'nsAutoCompleteController.cpp',
+    'nsAutoCompleteSimpleResult.cpp',
+]
+
+FINAL_LIBRARY = 'xul'
+
+with Files('**'):
+    BUG_COMPONENT = ('Toolkit', 'Autocomplete')
diff --git a/toolkit/components/autocomplete/nsAutoCompleteController.cpp b/toolkit/components/autocomplete/nsAutoCompleteController.cpp
new file mode 100644
index 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;
diff --git a/toolkit/components/autocomplete/nsAutoCompleteController.h b/toolkit/components/autocomplete/nsAutoCompleteController.h
new file mode 100644
index 000000000..62aa980f6
--- /dev/null
+++ b/toolkit/components/autocomplete/nsAutoCompleteController.h
@@ -0,0 +1,176 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef __nsAutoCompleteController__
+#define __nsAutoCompleteController__
+
+#include "nsIAutoCompleteController.h"
+
+#include "nsCOMPtr.h"
+#include "nsIAutoCompleteInput.h"
+#include "nsIAutoCompletePopup.h"
+#include "nsIAutoCompleteResult.h"
+#include "nsIAutoCompleteSearch.h"
+#include "nsString.h"
+#include "nsITreeView.h"
+#include "nsITreeSelection.h"
+#include "nsITimer.h"
+#include "nsTArray.h"
+#include "nsCOMArray.h"
+#include "nsCycleCollectionParticipant.h"
+
+class nsAutoCompleteController final : public nsIAutoCompleteController,
+                                       public nsIAutoCompleteObserver,
+                                       public nsITimerCallback,
+                                       public nsITreeView
+{
+public:
+  NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+  NS_DECL_CYCLE_COLLECTION_CLASS_AMBIGUOUS(nsAutoCompleteController,
+                                           nsIAutoCompleteController)
+  NS_DECL_NSIAUTOCOMPLETECONTROLLER
+  NS_DECL_NSIAUTOCOMPLETEOBSERVER
+  NS_DECL_NSITREEVIEW
+  NS_DECL_NSITIMERCALLBACK
+   
+  nsAutoCompleteController();
+  
+protected:
+  virtual ~nsAutoCompleteController();
+
+  nsresult OpenPopup();
+  nsresult ClosePopup();
+
+  nsresult StartSearch(uint16_t aSearchType);
+
+  nsresult BeforeSearches();
+  nsresult StartSearches();
+  void AfterSearches();
+  nsresult ClearSearchTimer();
+  void MaybeCompletePlaceholder();
+
+  void HandleSearchResult(nsIAutoCompleteSearch *aSearch,
+                          nsIAutoCompleteResult *aResult);
+  nsresult ProcessResult(int32_t aSearchIndex, nsIAutoCompleteResult *aResult);
+  nsresult PostSearchCleanup();
+
+  nsresult EnterMatch(bool aIsPopupSelection,
+                      nsIDOMEvent *aEvent);
+  nsresult RevertTextValue();
+
+  nsresult CompleteDefaultIndex(int32_t aResultIndex);
+  nsresult CompleteValue(nsString &aValue);
+
+  nsresult GetResultAt(int32_t aIndex, nsIAutoCompleteResult** aResult,
+                       int32_t* aRowIndex);
+  nsresult GetResultValueAt(int32_t aIndex, bool aGetFinalValue,
+                            nsAString & _retval);
+  nsresult GetResultLabelAt(int32_t aIndex, nsAString & _retval);
+private:
+  nsresult GetResultValueLabelAt(int32_t aIndex, bool aGetFinalValue,
+                                 bool aGetValue, nsAString & _retval);
+protected:
+
+  /**
+   * Gets and validates the defaultComplete result and the relative
+   * defaultIndex value.
+   *
+   * @param aResultIndex
+   *        Index of the defaultComplete result to be used.  Pass -1 to search
+   *        for the first result providing a valid defaultIndex.
+   * @param _result
+   *        The found result.
+   * @param _defaultIndex
+   *        The defaultIndex relative to _result.
+   */
+  nsresult GetDefaultCompleteResult(int32_t aResultIndex,
+                                    nsIAutoCompleteResult** _result,
+                                    int32_t* _defaultIndex);
+
+  /**
+   * Gets the defaultComplete value to be suggested to the user.
+   *
+   * @param aResultIndex
+   *        Index of the defaultComplete result to be used.
+   * @param aPreserveCasing
+   *        Whether user casing should be preserved.
+   * @param _retval
+   *        The value to be completed.
+   */
+  nsresult GetDefaultCompleteValue(int32_t aResultIndex, bool aPreserveCasing,
+                                   nsAString &_retval);
+
+  /**
+   * Gets the defaultComplete value to be used when the user confirms the
+   * current match.
+   * The value is returned only if it case-insensitively matches the current
+   * input text, otherwise the method returns NS_ERROR_FAILURE.
+   * This happens because we don't want to replace text if the user backspaces
+   * just before Enter.
+   *
+   * @param _retval
+   *        The value to be completed.
+   */
+  nsresult GetFinalDefaultCompleteValue(nsAString &_retval);
+
+  nsresult ClearResults();
+  
+  nsresult RowIndexToSearch(int32_t aRowIndex,
+                            int32_t *aSearchIndex, int32_t *aItemIndex);
+
+  // members //////////////////////////////////////////
+  
+  nsCOMPtr<nsIAutoCompleteInput> mInput;
+
+  nsCOMArray<nsIAutoCompleteSearch> mSearches;
+  // This is used as a sparse array, always use SafeObjectAt to access it.
+  nsCOMArray<nsIAutoCompleteResult> mResults;
+  // Temporarily keeps the results alive while invoking startSearch() for each
+  // search.  This is needed to allow the searches to reuse the previous result,
+  // since otherwise the first search clears mResults.
+  nsCOMArray<nsIAutoCompleteResult> mResultCache;
+
+  nsCOMPtr<nsITimer> mTimer;
+  nsCOMPtr<nsITreeSelection> mSelection;
+  nsCOMPtr<nsITreeBoxObject> mTree;
+
+  nsString mSearchString;
+  nsString mPlaceholderCompletionString;
+  bool mDefaultIndexCompleted;
+  bool mPopupClosedByCompositionStart;
+
+  // Whether autofill is allowed for the next search. May be retrieved by the
+  // search through the "prohibit-autofill" searchParam.
+  bool mProhibitAutoFill;
+
+  // Indicates whether the user cleared the autofilled part, returning to the
+  // originally entered search string.
+  bool mUserClearedAutoFill;
+
+  // Indicates whether clearing the autofilled string should issue a new search.
+  bool mClearingAutoFillSearchesAgain;
+
+  enum CompositionState {
+    eCompositionState_None,
+    eCompositionState_Composing,
+    eCompositionState_Committing
+  };
+  CompositionState mCompositionState;
+  uint16_t mSearchStatus;
+  uint32_t mRowCount;
+  uint32_t mSearchesOngoing;
+  uint32_t mSearchesFailed;
+  bool mFirstSearchResult;
+  uint32_t mImmediateSearchesCount;
+  // The index of the match on the popup that was selected using the keyboard,
+  // if the completeselectedindex attribute is set.
+  // This is used to distinguish that selection (which would have been put in
+  // the input on being selected) from a moused-over selectedIndex value. This
+  // distinction is used to prevent mouse moves from inadvertently changing
+  // what happens once the user hits Enter on the keyboard.
+  // See bug 1043584 for more details.
+  int32_t  mCompletedSelectionIndex;
+};
+
+#endif /* __nsAutoCompleteController__ */
diff --git a/toolkit/components/autocomplete/nsAutoCompleteSimpleResult.cpp b/toolkit/components/autocomplete/nsAutoCompleteSimpleResult.cpp
new file mode 100644
index 000000000..9fd2c0022
--- /dev/null
+++ b/toolkit/components/autocomplete/nsAutoCompleteSimpleResult.cpp
@@ -0,0 +1,292 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsAutoCompleteSimpleResult.h"
+
+#define CHECK_MATCH_INDEX(_index, _insert)                                     \
+  if (_index < 0 ||                                                            \
+      static_cast<MatchesArray::size_type>(_index) > mMatches.Length() ||      \
+      (!_insert && static_cast<MatchesArray::size_type>(_index) == mMatches.Length())) { \
+    MOZ_ASSERT(false, "Trying to use an invalid index on mMatches");           \
+    return NS_ERROR_ILLEGAL_VALUE;                                             \
+  }                                                                            \
+
+NS_IMPL_ISUPPORTS(nsAutoCompleteSimpleResult,
+                  nsIAutoCompleteResult,
+                  nsIAutoCompleteSimpleResult)
+
+struct AutoCompleteSimpleResultMatch
+{
+  AutoCompleteSimpleResultMatch(const nsAString& aValue,
+                                const nsAString& aComment,
+                                const nsAString& aImage,
+                                const nsAString& aStyle,
+                                const nsAString& aFinalCompleteValue,
+                                const nsAString& aLabel)
+    : mValue(aValue)
+    , mComment(aComment)
+    , mImage(aImage)
+    , mStyle(aStyle)
+    , mFinalCompleteValue(aFinalCompleteValue)
+    , mLabel(aLabel)
+  {
+  }
+
+  nsString mValue;
+  nsString mComment;
+  nsString mImage;
+  nsString mStyle;
+  nsString mFinalCompleteValue;
+  nsString mLabel;
+};
+
+nsAutoCompleteSimpleResult::nsAutoCompleteSimpleResult() :
+  mDefaultIndex(-1),
+  mSearchResult(RESULT_NOMATCH)
+{
+}
+
+nsresult
+nsAutoCompleteSimpleResult::AppendResult(nsIAutoCompleteResult* aResult)
+{
+  nsAutoString searchString;
+  nsresult rv = aResult->GetSearchString(searchString);
+  NS_ENSURE_SUCCESS(rv, rv);
+  mSearchString = searchString;
+
+  uint16_t searchResult;
+  rv = aResult->GetSearchResult(&searchResult);
+  NS_ENSURE_SUCCESS(rv, rv);
+  mSearchResult = searchResult;
+
+  nsAutoString errorDescription;
+  if (NS_SUCCEEDED(aResult->GetErrorDescription(errorDescription)) &&
+      !errorDescription.IsEmpty()) {
+    mErrorDescription = errorDescription;
+  }
+
+  int32_t defaultIndex = -1;
+  if (NS_SUCCEEDED(aResult->GetDefaultIndex(&defaultIndex)) &&
+      defaultIndex >= 0) {
+    mDefaultIndex = defaultIndex;
+  }
+
+  nsCOMPtr<nsIAutoCompleteSimpleResult> simpleResult =
+    do_QueryInterface(aResult);
+  if (simpleResult) {
+    nsCOMPtr<nsIAutoCompleteSimpleResultListener> listener;
+    if (NS_SUCCEEDED(simpleResult->GetListener(getter_AddRefs(listener))) &&
+        listener) {
+      listener.swap(mListener);
+    }
+  }
+
+  // Copy matches.
+  uint32_t matchCount = 0;
+  rv = aResult->GetMatchCount(&matchCount);
+  NS_ENSURE_SUCCESS(rv, rv);
+  for (size_t i = 0; i < matchCount; ++i) {
+    nsAutoString value, comment, image, style, finalCompleteValue, label;
+
+    rv = aResult->GetValueAt(i, value);
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = aResult->GetCommentAt(i, comment);
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = aResult->GetImageAt(i, image);
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = aResult->GetStyleAt(i, style);
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = aResult->GetFinalCompleteValueAt(i, finalCompleteValue);
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = aResult->GetLabelAt(i, label);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    rv = AppendMatch(value, comment, image, style, finalCompleteValue, label);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  return NS_OK;
+}
+
+// searchString
+NS_IMETHODIMP
+nsAutoCompleteSimpleResult::GetSearchString(nsAString &aSearchString)
+{
+  aSearchString = mSearchString;
+  return NS_OK;
+}
+NS_IMETHODIMP
+nsAutoCompleteSimpleResult::SetSearchString(const nsAString &aSearchString)
+{
+  mSearchString.Assign(aSearchString);
+  return NS_OK;
+}
+
+// searchResult
+NS_IMETHODIMP
+nsAutoCompleteSimpleResult::GetSearchResult(uint16_t *aSearchResult)
+{
+  *aSearchResult = mSearchResult;
+  return NS_OK;
+}
+NS_IMETHODIMP
+nsAutoCompleteSimpleResult::SetSearchResult(uint16_t aSearchResult)
+{
+  mSearchResult = aSearchResult;
+  return NS_OK;
+}
+
+// defaultIndex
+NS_IMETHODIMP
+nsAutoCompleteSimpleResult::GetDefaultIndex(int32_t *aDefaultIndex)
+{
+  *aDefaultIndex = mDefaultIndex;
+  return NS_OK;
+}
+NS_IMETHODIMP
+nsAutoCompleteSimpleResult::SetDefaultIndex(int32_t aDefaultIndex)
+{
+  mDefaultIndex = aDefaultIndex;
+  return NS_OK;
+}
+
+// errorDescription
+NS_IMETHODIMP
+nsAutoCompleteSimpleResult::GetErrorDescription(nsAString & aErrorDescription)
+{
+  aErrorDescription = mErrorDescription;
+  return NS_OK;
+}
+NS_IMETHODIMP
+nsAutoCompleteSimpleResult::SetErrorDescription(
+                                             const nsAString &aErrorDescription)
+{
+  mErrorDescription.Assign(aErrorDescription);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteSimpleResult::InsertMatchAt(int32_t aIndex,
+                                          const nsAString& aValue,
+                                          const nsAString& aComment,
+                                          const nsAString& aImage,
+                                          const nsAString& aStyle,
+                                          const nsAString& aFinalCompleteValue,
+                                          const nsAString& aLabel)
+{
+  CHECK_MATCH_INDEX(aIndex, true);
+
+  AutoCompleteSimpleResultMatch match(aValue, aComment, aImage, aStyle, aFinalCompleteValue, aLabel);
+
+  if (!mMatches.InsertElementAt(aIndex, match)) {
+    return NS_ERROR_OUT_OF_MEMORY;
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteSimpleResult::AppendMatch(const nsAString& aValue,
+                                        const nsAString& aComment,
+                                        const nsAString& aImage,
+                                        const nsAString& aStyle,
+                                        const nsAString& aFinalCompleteValue,
+                                        const nsAString& aLabel)
+{
+  return InsertMatchAt(mMatches.Length(), aValue, aComment, aImage, aStyle,
+                       aFinalCompleteValue, aLabel);
+}
+
+NS_IMETHODIMP
+nsAutoCompleteSimpleResult::GetMatchCount(uint32_t *aMatchCount)
+{
+  *aMatchCount = mMatches.Length();
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteSimpleResult::GetValueAt(int32_t aIndex, nsAString& _retval)
+{
+  CHECK_MATCH_INDEX(aIndex, false);
+  _retval = mMatches[aIndex].mValue;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteSimpleResult::GetLabelAt(int32_t aIndex, nsAString& _retval)
+{
+  CHECK_MATCH_INDEX(aIndex, false);
+  _retval = mMatches[aIndex].mLabel;
+  if (_retval.IsEmpty()) {
+    _retval = mMatches[aIndex].mValue;
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteSimpleResult::GetCommentAt(int32_t aIndex, nsAString& _retval)
+{
+  CHECK_MATCH_INDEX(aIndex, false);
+  _retval = mMatches[aIndex].mComment;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteSimpleResult::GetImageAt(int32_t aIndex, nsAString& _retval)
+{
+  CHECK_MATCH_INDEX(aIndex, false);
+  _retval = mMatches[aIndex].mImage;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteSimpleResult::GetStyleAt(int32_t aIndex, nsAString& _retval)
+{
+  CHECK_MATCH_INDEX(aIndex, false);
+  _retval = mMatches[aIndex].mStyle;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteSimpleResult::GetFinalCompleteValueAt(int32_t aIndex,
+                                                    nsAString& _retval)
+{
+  CHECK_MATCH_INDEX(aIndex, false);
+  _retval = mMatches[aIndex].mFinalCompleteValue;
+  if (_retval.IsEmpty()) {
+    _retval = mMatches[aIndex].mValue;
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteSimpleResult::SetListener(nsIAutoCompleteSimpleResultListener* aListener)
+{
+  mListener = aListener;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteSimpleResult::GetListener(nsIAutoCompleteSimpleResultListener** aListener)
+{
+  nsCOMPtr<nsIAutoCompleteSimpleResultListener> listener(mListener);
+  listener.forget(aListener);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteSimpleResult::RemoveValueAt(int32_t aRowIndex,
+                                          bool aRemoveFromDb)
+{
+  CHECK_MATCH_INDEX(aRowIndex, false);
+
+  nsString value = mMatches[aRowIndex].mValue;
+  mMatches.RemoveElementAt(aRowIndex);
+
+  if (mListener) {
+    mListener->OnValueRemoved(this, value, aRemoveFromDb);
+  }
+
+  return NS_OK;
+}
diff --git a/toolkit/components/autocomplete/nsAutoCompleteSimpleResult.h b/toolkit/components/autocomplete/nsAutoCompleteSimpleResult.h
new file mode 100644
index 000000000..28968aa57
--- /dev/null
+++ b/toolkit/components/autocomplete/nsAutoCompleteSimpleResult.h
@@ -0,0 +1,44 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef __nsAutoCompleteSimpleResult__
+#define __nsAutoCompleteSimpleResult__
+
+#include "nsIAutoCompleteResult.h"
+#include "nsIAutoCompleteSimpleResult.h"
+
+#include "nsString.h"
+#include "nsCOMPtr.h"
+#include "nsTArray.h"
+#include "mozilla/Attributes.h"
+
+struct AutoCompleteSimpleResultMatch;
+
+class nsAutoCompleteSimpleResult final : public nsIAutoCompleteSimpleResult
+{
+public:
+  nsAutoCompleteSimpleResult();
+
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIAUTOCOMPLETERESULT
+  NS_DECL_NSIAUTOCOMPLETESIMPLERESULT
+
+  nsresult AppendResult(nsIAutoCompleteResult* aResult);
+
+private:
+  ~nsAutoCompleteSimpleResult() {}
+
+protected:
+  typedef nsTArray<AutoCompleteSimpleResultMatch> MatchesArray;
+   MatchesArray mMatches;
+
+  nsString mSearchString;
+  nsString mErrorDescription;
+  int32_t mDefaultIndex;
+  uint32_t mSearchResult;
+
+  nsCOMPtr<nsIAutoCompleteSimpleResultListener> mListener;
+};
+
+#endif // __nsAutoCompleteSimpleResult__
diff --git a/toolkit/components/autocomplete/nsIAutoCompleteController.idl b/toolkit/components/autocomplete/nsIAutoCompleteController.idl
new file mode 100644
index 000000000..0b68032dc
--- /dev/null
+++ b/toolkit/components/autocomplete/nsIAutoCompleteController.idl
@@ -0,0 +1,173 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+
+interface nsIAutoCompleteInput;
+interface nsIDOMEvent;
+
+[scriptable, uuid(ff9f8465-204a-47a6-b3c9-0628b3856684)]
+interface nsIAutoCompleteController : nsISupports
+{
+  /*
+   * Possible values for the searchStatus attribute
+   */
+  const unsigned short STATUS_NONE = 1;
+  const unsigned short STATUS_SEARCHING = 2;
+  const unsigned short STATUS_COMPLETE_NO_MATCH = 3;
+  const unsigned short STATUS_COMPLETE_MATCH = 4;
+
+  /*
+   * The input widget that is currently being controlled.
+   */
+  attribute nsIAutoCompleteInput input;
+
+  /*
+   * State which indicates the status of possible ongoing searches
+   */
+  readonly attribute unsigned short searchStatus;
+
+  /*
+   * The number of matches
+   */
+  readonly attribute unsigned long matchCount;
+
+  /*
+   * Start a search on a string, assuming the input property is already set.
+   */
+  void startSearch(in AString searchString);
+
+  /*
+   * Stop all asynchronous searches
+   */
+  void stopSearch();
+
+  /*
+   * Notify the controller that the user has changed text in the textbox.
+   * This includes all means of changing the text value, including typing a
+   * character, backspacing, deleting, pasting, committing composition or
+   * canceling composition.
+   *
+   * NOTE: handleText() must be called after composition actually ends, even if
+   *       the composition is canceled and the textbox value isn't changed.
+   *       Then, implementation of handleText() can access the editor when
+   *       it's not in composing mode. DOM compositionend event is not good
+   *       timing for calling handleText(). DOM input event immediately after
+   *       DOM compositionend event is the best timing to call this.
+   *
+   * @return whether this handler started a new search.
+   */
+  boolean handleText();
+
+  /*
+   * Notify the controller that the user wishes to enter the current text. If
+   * aIsPopupSelection is true, then a selection was made from the popup, so
+   * fill this value into the input field before continuing. If false, just
+   * use the current value of the input field.
+   *
+   * @param aIsPopupSelection
+   *        Pass true if the selection was made from the popup.
+   * @param aEvent
+   *        The event that triggered the enter, like a key event if the user
+   *        pressed the Return key or a click event if the user clicked a popup
+   *        item.
+   * @return Whether the controller wishes to prevent event propagation and
+   *         default event.
+   */
+  boolean handleEnter(in boolean aIsPopupSelection,
+                      [optional] in nsIDOMEvent aEvent);
+
+  /*
+   * Notify the controller that the user wishes to revert autocomplete
+   *
+   * @return Whether the controller wishes to prevent event propagation and
+   *         default event.
+   */
+  boolean handleEscape();
+
+  /*
+   * Notify the controller that the user wishes to start composition
+   *
+   * NOTE: nsIAutoCompleteController implementation expects that this is called
+   *       by DOM compositionstart handler.
+   */
+  void handleStartComposition();
+
+  /*
+   * Notify the controller that the user wishes to end composition
+   *
+   * NOTE: nsIAutoCompleteController implementation expects that this is called
+   *       by DOM compositionend handler.
+   */
+  void handleEndComposition();
+
+  /*
+   * Handle tab. Just closes up.
+   */
+  void handleTab();
+
+  /*
+   * Notify the controller of the following key navigation events:
+   *   up, down, left, right, page up, page down
+   *
+   * @return Whether the controller wishes to prevent event propagation and
+   *         default event
+   */
+  boolean handleKeyNavigation(in unsigned long key);
+
+  /*
+   * Notify the controller that the user chose to delete the current
+   * auto-complete result.
+   *
+   * @return Whether the controller removed a result item.
+   */
+  boolean handleDelete();
+
+  /*
+   * Get the value of the result at a given index in the last completed search
+   */
+  AString getValueAt(in long index);
+
+  /*
+   * Get the label of the result at a given index in the last completed search
+   */
+  AString getLabelAt(in long index);
+
+  /*
+   * Get the comment of the result at a given index in the last completed search
+   */
+  AString getCommentAt(in long index);
+
+  /*
+   * Get the style hint for the result at a given index in the last completed search
+   */
+  AString getStyleAt(in long index);
+
+  /*
+   * Get the url of the image of the result at a given index in the last completed search
+   */
+  AString getImageAt(in long index);
+
+  /*
+   * For the last completed search, get the final value that should be completed
+   * when the user confirms the match at the given index
+   */
+  AString getFinalCompleteValueAt(in long index);
+
+  /*
+   * Get / set the current search string.  Note, setting will not start searching
+   */
+  attribute AString searchString;
+
+  /*
+   * Set the index of the result item that should be initially selected.
+   * This should be used when a search wants to pre-select an element before
+   * the user starts using results.
+   *
+   * @note Setting this is not the same as just setting selectedIndex in
+   * nsIAutocompletePopup, since this will take care of updating any internal
+   * tracking variables of features like completeSelectedIndex.
+   */
+  void setInitiallySelectedIndex(in long index);
+};
diff --git a/toolkit/components/autocomplete/nsIAutoCompleteInput.idl b/toolkit/components/autocomplete/nsIAutoCompleteInput.idl
new file mode 100644
index 000000000..26a75ea77
--- /dev/null
+++ b/toolkit/components/autocomplete/nsIAutoCompleteInput.idl
@@ -0,0 +1,181 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+#include "nsIAutoCompleteController.idl"
+
+interface nsIAutoCompletePopup;
+
+[scriptable, uuid(B068E70F-F82C-4C12-AD87-82E271C5C180)]
+interface nsIAutoCompleteInput : nsISupports
+{
+  /*
+   * The result view that will be used to display results
+   */
+  readonly attribute nsIAutoCompletePopup popup;
+
+  /*
+   * The controller.
+   */
+  readonly attribute nsIAutoCompleteController controller;
+
+  /*
+   * Indicates if the popup is currently open
+   */
+  attribute boolean popupOpen;
+
+  /*
+   * Option to disable autocomplete functionality
+   */
+  attribute boolean disableAutoComplete;
+
+  /*
+   * If a search result has its defaultIndex set, this will optionally
+   * try to complete the text in the textbox to the entire text of the
+   * result at the default index as the user types
+   */
+  attribute boolean completeDefaultIndex;
+
+  /*
+   * complete text in the textbox as the user selects from the dropdown
+   * options if set to true
+   */
+  attribute boolean completeSelectedIndex;
+
+  /*
+   * Option for completing to the default result whenever the user hits
+   * enter or the textbox loses focus
+   */
+  attribute boolean forceComplete;
+
+  /*
+   * Option to open the popup only after a certain number of results are available
+   */
+  attribute unsigned long minResultsForPopup;
+
+  /*
+   * The maximum number of rows to show in the autocomplete popup.
+   */
+  attribute unsigned long maxRows;
+
+  /*
+   * Option to show a second column in the popup which contains
+   * the comment for each autocomplete result
+   */
+  attribute boolean showCommentColumn;
+
+  /*
+   * Option to show a third column in the popup which contains
+   * an additional image for each autocomplete result
+   */
+  attribute boolean showImageColumn;
+
+  /*
+   * Number of milliseconds after a keystroke before a search begins
+   */
+  attribute unsigned long timeout;
+
+  /*
+   * An extra parameter to configure searches with.
+   */
+  attribute AString searchParam;
+
+  /*
+   * The number of autocomplete session to search
+   */
+  readonly attribute unsigned long searchCount;
+
+  /*
+   * Get the name of one of the autocomplete search session objects
+   */
+  ACString getSearchAt(in unsigned long index);
+
+  /*
+   * The value of text in the autocomplete textbox.
+   *
+   * @note when setting a new value, the controller always first tries to use
+   *       setTextboxValueWithReason, and only if that throws (unimplemented),
+   *       fallbacks to the textValue's setter.  If a reason is not provided,
+   *       the implementation should assume TEXTVALUE_REASON_UNKNOWN, but it
+   *       should only happen in testing code.
+   */
+  attribute AString textValue;
+
+  /*
+   * Set the value of text in the autocomplete textbox, providing a reason to
+   * the autocomplete view.
+   */
+  const unsigned short TEXTVALUE_REASON_UNKNOWN = 0;
+  const unsigned short TEXTVALUE_REASON_COMPLETEDEFAULT = 1;
+  const unsigned short TEXTVALUE_REASON_COMPLETESELECTED = 2;
+  const unsigned short TEXTVALUE_REASON_REVERT = 3;
+  const unsigned short TEXTVALUE_REASON_ENTERMATCH = 4;
+
+  void setTextValueWithReason(in AString aValue,
+                              in unsigned short aReason);
+
+  /*
+   * Report the starting index of the cursor in the textbox
+   */
+  readonly attribute long selectionStart;
+
+  /*
+   * Report the ending index of the cursor in the textbox
+   */
+  readonly attribute long selectionEnd;
+
+  /*
+   * Select a range of text in the autocomplete textbox
+   */
+  void selectTextRange(in long startIndex, in long endIndex);
+
+  /*
+   * Notification that the search has started
+   */
+  void onSearchBegin();
+
+  /*
+   * Notification that the search concluded successfully
+   */
+  void onSearchComplete();
+
+  /*
+   * Notification that the user selected and entered a result item
+   *
+   * @param aEvent
+   *        The event that triggered the enter.
+   * @return True if the user wishes to prevent the enter
+   */
+  boolean onTextEntered([optional] in nsIDOMEvent aEvent);
+
+  /*
+   * Notification that the user cancelled the autocomplete session
+   *
+   * @return True if the user wishes to prevent the revert
+   */
+  boolean onTextReverted();
+
+  /*
+   * This popup should consume or dispatch the rollup event.
+   * TRUE: should consume; FALSE: should dispatch.
+   */
+  readonly attribute boolean consumeRollupEvent;
+
+  /*
+   * Indicates whether this input is in a "private browsing" context.
+   * nsIAutoCompleteSearches for these inputs should not persist any data to disk
+   * (such as a history database).
+   */
+  readonly attribute boolean inPrivateContext;
+
+  /*
+   * Don't rollup the popup when the caret is moved.
+   */
+  readonly attribute boolean noRollupOnCaretMove;
+
+  /**
+   * The userContextId of the current browser.
+   */
+  readonly attribute unsigned long userContextId;
+};
diff --git a/toolkit/components/autocomplete/nsIAutoCompletePopup.idl b/toolkit/components/autocomplete/nsIAutoCompletePopup.idl
new file mode 100644
index 000000000..cb5dda6f2
--- /dev/null
+++ b/toolkit/components/autocomplete/nsIAutoCompletePopup.idl
@@ -0,0 +1,71 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+
+interface nsIDOMElement;
+interface nsIAutoCompleteInput;
+
+[scriptable, uuid(bd3c2662-a988-41ab-8c94-c15ed0e6ac7d)]
+interface nsIAutoCompletePopup : nsISupports
+{
+  /*
+   * The input object that the popup is currently bound to
+   */
+  readonly attribute nsIAutoCompleteInput input;
+
+  /*
+   * An alternative value to be used when text is entered, rather than the
+   * value of the selected item
+   */
+  readonly attribute AString overrideValue;
+
+  /*
+   * The index of the result item that is currently selected
+   */
+  attribute long selectedIndex;
+
+  /* 
+   * Indicates if the popup is currently open
+   */
+  readonly attribute boolean popupOpen;
+
+  /* 
+   * Bind the popup to an input object and display it with the given coordinates
+   *
+   * @param input - The input object that the popup will be bound to
+   * @param element - The element that the popup will be aligned with
+   */
+  void openAutocompletePopup(in nsIAutoCompleteInput input, in nsIDOMElement element);
+
+  /* 
+   * Close the popup and detach from the bound input
+   */
+  void closePopup();
+
+  /*
+   * Instruct the result view to repaint itself to reflect the most current
+   * underlying data
+   *
+   * @param reason - The reason the popup needs to be invalidated, one of the
+   *        INVALIDATE_REASON consts.
+   */
+  void invalidate(in unsigned short reason);
+
+  /*
+   * Possible values of invalidate()'s 'reason' argument.
+   */
+  const unsigned short INVALIDATE_REASON_NEW_RESULT = 0;
+  const unsigned short INVALIDATE_REASON_DELETE = 1;
+
+  /*
+   * Change the selection relative to the current selection and make sure
+   * the newly selected row is visible
+   *
+   * @param reverse - Select a row above the current selection
+   * @param page - Select a row that is a full visible page from the current selection
+   * @return The currently selected result item index
+   */
+  void selectBy(in boolean reverse, in boolean page);
+};
diff --git a/toolkit/components/autocomplete/nsIAutoCompleteResult.idl b/toolkit/components/autocomplete/nsIAutoCompleteResult.idl
new file mode 100644
index 000000000..c719d9427
--- /dev/null
+++ b/toolkit/components/autocomplete/nsIAutoCompleteResult.idl
@@ -0,0 +1,89 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+
+[scriptable, uuid(9203c031-c4e7-4537-a4ec-81443d623d5a)]
+interface nsIAutoCompleteResult : nsISupports
+{
+  /**
+   * Possible values for the searchResult attribute
+   */
+  const unsigned short RESULT_IGNORED = 1; /* indicates invalid searchString */
+  const unsigned short RESULT_FAILURE = 2; /* indicates failure */
+  const unsigned short RESULT_NOMATCH = 3; /* indicates success with no matches
+                                              and that the search is complete */
+  const unsigned short RESULT_SUCCESS = 4; /* indicates success with matches
+                                              and that the search is complete */
+  const unsigned short RESULT_NOMATCH_ONGOING = 5; /* indicates success 
+                                                      with no matches
+                                                      and that the search 
+                                                      is still ongoing */
+  const unsigned short RESULT_SUCCESS_ONGOING = 6; /* indicates success 
+                                                      with matches
+                                                      and that the search 
+                                                      is still ongoing */
+  /**
+   * The original search string
+   */
+  readonly attribute AString searchString;
+
+  /**
+   * The result of the search
+   */
+  readonly attribute unsigned short searchResult;
+
+  /**
+   * Index of the default item that should be entered if none is selected
+   */
+  readonly attribute long defaultIndex;
+
+  /**
+   * A string describing the cause of a search failure
+   */
+  readonly attribute AString errorDescription;
+
+  /**
+   * The number of matches
+   */
+  readonly attribute unsigned long matchCount;
+
+  /**
+   * Get the value of the result at the given index
+   */
+  AString getValueAt(in long index);
+
+  /**
+   * This returns the string that is displayed in the dropdown
+   */
+  AString getLabelAt(in long index);
+
+  /**
+   * Get the comment of the result at the given index
+   */
+  AString getCommentAt(in long index);
+
+  /**
+   * Get the style hint for the result at the given index
+   */
+  AString getStyleAt(in long index);
+
+  /**
+   * Get the image of the result at the given index
+   */
+  AString getImageAt(in long index);
+
+  /**
+   * Get the final value that should be completed when the user confirms
+   * the match at the given index.
+   */
+  AString getFinalCompleteValueAt(in long index);
+
+  /**
+   * Remove the value at the given index from the autocomplete results.
+   * If removeFromDb is set to true, the value should be removed from
+   * persistent storage as well.
+   */
+  void removeValueAt(in long rowIndex, in boolean removeFromDb);
+};
diff --git a/toolkit/components/autocomplete/nsIAutoCompleteSearch.idl b/toolkit/components/autocomplete/nsIAutoCompleteSearch.idl
new file mode 100644
index 000000000..188c333ac
--- /dev/null
+++ b/toolkit/components/autocomplete/nsIAutoCompleteSearch.idl
@@ -0,0 +1,74 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+
+interface nsIAutoCompleteResult;
+interface nsIAutoCompleteObserver;
+
+[scriptable, uuid(DE8DB85F-C1DE-4d87-94BA-7844890F91FE)]
+interface nsIAutoCompleteSearch : nsISupports
+{
+  /*
+   * Search for a given string and notify a listener (either synchronously
+   * or asynchronously) of the result
+   *
+   * @param searchString - The string to search for
+   * @param searchParam - An extra parameter
+   * @param previousResult - A previous result to use for faster searching
+   * @param listener - A listener to notify when the search is complete
+   */
+  void startSearch(in AString searchString,
+                   in AString searchParam,
+                   in nsIAutoCompleteResult previousResult,
+                   in nsIAutoCompleteObserver listener);
+
+  /*
+   * Stop all searches that are in progress
+   */
+  void stopSearch();
+};
+
+[scriptable, uuid(8bd1dbbc-dcce-4007-9afa-b551eb687b61)]
+interface nsIAutoCompleteObserver : nsISupports
+{ 
+  /*
+   * Called when a search is complete and the results are ready
+   *
+   * @param search - The search object that processed this search
+   * @param result - The search result object
+   */
+  void onSearchResult(in nsIAutoCompleteSearch search, in nsIAutoCompleteResult result);
+
+  /*
+   * Called to update with new results
+   *
+   * @param search - The search object that processed this search
+   * @param result - The search result object
+   */
+  void onUpdateSearchResult(in nsIAutoCompleteSearch search, in nsIAutoCompleteResult result);
+};
+
+[scriptable, uuid(4c3e7462-fbfb-4310-8f4b-239238392b75)]
+interface nsIAutoCompleteSearchDescriptor : nsISupports
+{
+  // The search is started after the timeout specified by the corresponding
+  // nsIAutoCompleteInput implementation.
+  const unsigned short SEARCH_TYPE_DELAYED = 0;
+  // The search is started synchronously, before any delayed searches.
+  const unsigned short SEARCH_TYPE_IMMEDIATE = 1;
+
+  /**
+   * Identifies the search behavior.
+   * Should be one of the SEARCH_TYPE_* constants above.
+   * Defaults to SEARCH_TYPE_DELAYED.
+   */
+  readonly attribute unsigned short searchType;
+
+  /*
+   * Whether a new search should be triggered when the user deletes the
+   * autofilled part.
+   */
+  readonly attribute boolean clearingAutoFillSearchesAgain;
+};
diff --git a/toolkit/components/autocomplete/nsIAutoCompleteSimpleResult.idl b/toolkit/components/autocomplete/nsIAutoCompleteSimpleResult.idl
new file mode 100644
index 000000000..5e92e037a
--- /dev/null
+++ b/toolkit/components/autocomplete/nsIAutoCompleteSimpleResult.idl
@@ -0,0 +1,116 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+#include "nsIAutoCompleteResult.idl"
+
+interface nsIAutoCompleteSimpleResultListener;
+
+/**
+ * This class implements nsIAutoCompleteResult and provides simple methods
+ * for setting the value and result items. It can be used whenever some basic
+ * auto complete results are needed that can be pre-generated and filled into
+ * an array.
+ */
+
+[scriptable, uuid(23de9c96-becb-4d0d-a9bb-1d131ce361b5)]
+interface nsIAutoCompleteSimpleResult : nsIAutoCompleteResult
+{
+  /**
+   * A writer for the readonly attribute 'searchString' which should contain
+   * the string that the user typed.
+   */
+  void setSearchString(in AString aSearchString);
+
+  /**
+   * A writer for the readonly attribute 'errorDescription'.
+   */
+  void setErrorDescription(in AString aErrorDescription);
+
+  /**
+   * A writer for the readonly attribute 'defaultIndex' which should contain
+   * the index of the list that will be selected by default (normally 0).
+   */
+  void setDefaultIndex(in long aDefaultIndex);
+
+  /**
+   * A writer for the readonly attribute 'searchResult' which should contain
+   * one of the constants nsIAutoCompleteResult.RESULT_* indicating the success
+   * of the search.
+   */
+  void setSearchResult(in unsigned short aSearchResult);
+
+  /**
+   * Inserts a match consisting of the given value, comment, image, style and
+   * the value to use for defaultIndex completion at a given position.
+   * @param aIndex
+   *        The index to insert at
+   * @param aValue
+   *        The value to autocomplete to
+   * @param aComment
+   *        Comment shown in the autocomplete widget to describe this match
+   * @param aImage
+   *        Image shown in the autocomplete widget for this match.
+   * @param aStyle
+   *        Describes how to style the match in the autocomplete widget
+   * @param aFinalCompleteValue
+   *        Value used when the user confirms selecting this match. If not
+   *        provided, aValue will be used.
+   */
+  void insertMatchAt(in long aIndex,
+                     in AString aValue,
+                     in AString aComment,
+                     [optional] in AString aImage,
+                     [optional] in AString aStyle,
+                     [optional] in AString aFinalCompleteValue,
+                     [optional] in AString aLabel);
+
+  /**
+   * Appends a match consisting of the given value, comment, image, style and
+   * the value to use for defaultIndex completion.
+   * @param aValue
+   *        The value to autocomplete to
+   * @param aComment
+   *        Comment shown in the autocomplete widget to describe this match
+   * @param aImage
+   *        Image shown in the autocomplete widget for this match.
+   * @param aStyle
+   *        Describes how to style the match in the autocomplete widget
+   * @param aFinalCompleteValue
+   *        Value used when the user confirms selecting this match. If not
+   *        provided, aValue will be used.
+   */
+  void appendMatch(in AString aValue,
+                   in AString aComment,
+                   [optional] in AString aImage,
+                   [optional] in AString aStyle,
+                   [optional] in AString aFinalCompleteValue,
+                   [optional] in AString aLabel);
+
+  /**
+   * Gets the listener for changes in the result.
+   */
+  nsIAutoCompleteSimpleResultListener getListener();
+
+  /**
+   * Sets a listener for changes in the result.
+   */
+  void setListener(in nsIAutoCompleteSimpleResultListener aListener);
+};
+
+[scriptable, uuid(004efdc5-1989-4874-8a7a-345bf2fa33af)]
+interface nsIAutoCompleteSimpleResultListener : nsISupports
+{
+  /**
+   * Dispatched after a value is removed from the result.
+   * @param aResult
+   *        The result from which aValue has been removed.
+   * @param aValue
+   *        The removed value.
+   * @param aRemoveFromDb
+   *        Whether the value should be removed from persistent storage as well.
+   */
+  void onValueRemoved(in nsIAutoCompleteSimpleResult aResult, in AString aValue,
+                      in boolean aRemoveFromDb);
+};
diff --git a/toolkit/components/autocomplete/tests/unit/.eslintrc.js b/toolkit/components/autocomplete/tests/unit/.eslintrc.js
new file mode 100644
index 000000000..d35787cd2
--- /dev/null
+++ b/toolkit/components/autocomplete/tests/unit/.eslintrc.js
@@ -0,0 +1,7 @@
+"use strict";
+
+module.exports = {
+  "extends": [
+    "../../../../../testing/xpcshell/xpcshell.eslintrc.js"
+  ]
+};
diff --git a/toolkit/components/autocomplete/tests/unit/head_autocomplete.js b/toolkit/components/autocomplete/tests/unit/head_autocomplete.js
new file mode 100644
index 000000000..1443879f0
--- /dev/null
+++ b/toolkit/components/autocomplete/tests/unit/head_autocomplete.js
@@ -0,0 +1,206 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+Components.utils.import("resource://gre/modules/XPCOMUtils.jsm");
+
+var Cc = Components.classes;
+var Ci = Components.interfaces;
+var Cu = Components.utils;
+
+/**
+ * Dummy nsIAutoCompleteInput source that returns
+ * the given list of AutoCompleteSearch names.
+ *
+ * Implements only the methods needed for this test.
+ */
+function AutoCompleteInputBase(aSearches) {
+  this.searches = aSearches;
+}
+AutoCompleteInputBase.prototype = {
+
+  // Array of AutoCompleteSearch names
+  searches: null,
+
+  minResultsForPopup: 0,
+  timeout: 10,
+  searchParam: "",
+  textValue: "",
+  disableAutoComplete: false,
+  completeDefaultIndex: false,
+
+  // Text selection range
+  _selStart: 0,
+  _selEnd: 0,
+  get selectionStart() {
+    return this._selStart;
+  },
+  get selectionEnd() {
+    return this._selEnd;
+  },
+  selectTextRange: function(aStart, aEnd) {
+    this._selStart = aStart;
+    this._selEnd = aEnd;
+  },
+
+  get searchCount() {
+    return this.searches.length;
+  },
+
+  getSearchAt: function(aIndex) {
+    return this.searches[aIndex];
+  },
+
+  onSearchBegin: function() {},
+  onSearchComplete: function() {},
+
+  popupOpen: false,
+
+  get popup() {
+    if (!this._popup) {
+      this._popup = new AutocompletePopupBase(this);
+    }
+    return this._popup;
+  },
+
+  // nsISupports implementation
+  QueryInterface: XPCOMUtils.generateQI([Ci.nsIAutoCompleteInput])
+}
+
+/**
+ * nsIAutoCompleteResult implementation
+ */
+function AutoCompleteResultBase(aValues) {
+  this._values = aValues;
+}
+AutoCompleteResultBase.prototype = {
+
+  // Arrays
+  _values: null,
+  _comments: [],
+  _styles: [],
+  _finalCompleteValues: [],
+
+  searchString: "",
+  searchResult: null,
+
+  defaultIndex: -1,
+
+  get matchCount() {
+    return this._values.length;
+  },
+
+  getValueAt: function(aIndex) {
+    return this._values[aIndex];
+  },
+
+  getLabelAt: function(aIndex) {
+    return this.getValueAt(aIndex);
+  },
+
+  getCommentAt: function(aIndex) {
+    return this._comments[aIndex];
+  },
+
+  getStyleAt: function(aIndex) {
+    return this._styles[aIndex];
+  },
+
+  getImageAt: function(aIndex) {
+    return "";
+  },
+
+  getFinalCompleteValueAt: function(aIndex) {
+    return this._finalCompleteValues[aIndex] || this._values[aIndex];
+  },
+
+  removeValueAt: function (aRowIndex, aRemoveFromDb) {},
+
+  // nsISupports implementation
+  QueryInterface: XPCOMUtils.generateQI([Ci.nsIAutoCompleteResult])
+}
+
+/**
+ * nsIAutoCompleteSearch implementation that always returns
+ * the same result set.
+ */
+function AutoCompleteSearchBase(aName, aResult) {
+  this.name = aName;
+  this._result = aResult;
+}
+AutoCompleteSearchBase.prototype = {
+
+  // Search name. Used by AutoCompleteController
+  name: null,
+
+  // AutoCompleteResult
+  _result: null,
+
+  startSearch: function(aSearchString,
+                        aSearchParam,
+                        aPreviousResult,
+                        aListener) {
+    var result = this._result;
+
+    result.searchResult = Ci.nsIAutoCompleteResult.RESULT_SUCCESS;
+    aListener.onSearchResult(this, result);
+  },
+
+  stopSearch: function() {},
+
+  // nsISupports implementation
+  QueryInterface: XPCOMUtils.generateQI([Ci.nsIFactory,
+                                         Ci.nsIAutoCompleteSearch]),
+
+  // nsIFactory implementation
+  createInstance: function(outer, iid) {
+    return this.QueryInterface(iid);
+  }
+}
+
+function AutocompletePopupBase(input) {
+  this.input = input;
+}
+AutocompletePopupBase.prototype = {
+  selectedIndex: 0,
+  invalidate() {},
+  selectBy(reverse, page) {
+    let numRows = this.input.controller.matchCount;
+    if (numRows > 0) {
+      let delta = reverse ? -1 : 1;
+      this.selectedIndex = (this.selectedIndex + delta) % numRows;
+      if (this.selectedIndex < 0) {
+        this.selectedIndex = numRows - 1;
+      }
+    }
+  },
+  QueryInterface: XPCOMUtils.generateQI([Ci.nsIAutoCompletePopup]),
+};
+
+/**
+ * Helper to register an AutoCompleteSearch with the given name.
+ * Allows the AutoCompleteController to find the search.
+ */
+function registerAutoCompleteSearch(aSearch) {
+  var name = "@mozilla.org/autocomplete/search;1?name=" + aSearch.name;
+  var cid = Cc["@mozilla.org/uuid-generator;1"].
+            getService(Ci.nsIUUIDGenerator).
+            generateUUID();
+
+  var desc = "Test AutoCompleteSearch";
+  var componentManager = Components.manager
+                                   .QueryInterface(Ci.nsIComponentRegistrar);
+  componentManager.registerFactory(cid, desc, name, aSearch);
+
+  // Keep the id on the object so we can unregister later
+  aSearch.cid = cid;
+}
+
+/**
+ * Helper to unregister an AutoCompleteSearch.
+ */
+function unregisterAutoCompleteSearch(aSearch) {
+  var componentManager = Components.manager
+                                   .QueryInterface(Ci.nsIComponentRegistrar);
+  componentManager.unregisterFactory(aSearch.cid, aSearch);
+}
+
diff --git a/toolkit/components/autocomplete/tests/unit/test_330578.js b/toolkit/components/autocomplete/tests/unit/test_330578.js
new file mode 100644
index 000000000..c422dbb6a
--- /dev/null
+++ b/toolkit/components/autocomplete/tests/unit/test_330578.js
@@ -0,0 +1,45 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+var gResultListener = {
+  _lastResult: null,
+  _lastValue: "",
+  _lastRemoveFromDb: false,
+
+  onValueRemoved: function(aResult, aValue, aRemoveFromDb) {
+    this._lastResult = aResult;
+    this._lastValue = aValue;
+    this._lastRemoveFromDb = aRemoveFromDb;
+  }
+};
+
+
+// main
+function run_test() {
+  var result = Cc["@mozilla.org/autocomplete/simple-result;1"].
+               createInstance(Ci.nsIAutoCompleteSimpleResult);
+  result.appendMatch("a", "");
+  result.appendMatch("b", "");
+  result.appendMatch("c", "");
+  result.setListener(gResultListener);
+  do_check_eq(result.matchCount, 3);
+  result.removeValueAt(0, true);
+  do_check_eq(result.matchCount, 2);
+  do_check_eq(gResultListener._lastResult, result);
+  do_check_eq(gResultListener._lastValue, "a");
+  do_check_eq(gResultListener._lastRemoveFromDb, true);
+
+  result.removeValueAt(0, false);
+  do_check_eq(result.matchCount, 1);
+  do_check_eq(gResultListener._lastValue, "b");
+  do_check_eq(gResultListener._lastRemoveFromDb, false);
+
+  // check that we don't get notified if the listener is unset
+  result.setListener(null);
+  result.removeValueAt(0, true); // "c"
+  do_check_eq(result.matchCount, 0);
+  do_check_eq(gResultListener._lastValue, "b");
+}
diff --git a/toolkit/components/autocomplete/tests/unit/test_378079.js b/toolkit/components/autocomplete/tests/unit/test_378079.js
new file mode 100644
index 000000000..ad7e5590f
--- /dev/null
+++ b/toolkit/components/autocomplete/tests/unit/test_378079.js
@@ -0,0 +1,285 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/**
+ * Unit test for Bug 378079 - AutoComplete returns invalid rows when
+ * more than one AutoCompleteSearch is used.
+ */
+
+
+
+/**
+ * Dummy nsIAutoCompleteInput source that returns
+ * the given list of AutoCompleteSearch names.
+ *
+ * Implements only the methods needed for this test.
+ */
+function AutoCompleteInput(aSearches) {
+  this.searches = aSearches;
+}
+AutoCompleteInput.prototype = {
+  constructor: AutoCompleteInput,
+
+  // Array of AutoCompleteSearch names
+  searches: null,
+
+  minResultsForPopup: 0,
+  timeout: 10,
+  searchParam: "",
+  textValue: "",
+  disableAutoComplete: false,
+  completeDefaultIndex: false,
+
+  get searchCount() {
+    return this.searches.length;
+  },
+
+  getSearchAt: function(aIndex) {
+    return this.searches[aIndex];
+  },
+
+  onSearchBegin: function() {},
+  onSearchComplete: function() {},
+
+  popupOpen: false,
+
+  popup: {
+    setSelectedIndex: function(aIndex) {},
+    invalidate: function() {},
+
+    // nsISupports implementation
+    QueryInterface: function(iid) {
+      if (iid.equals(Ci.nsISupports) ||
+          iid.equals(Ci.nsIAutoCompletePopup))
+        return this;
+
+      throw Components.results.NS_ERROR_NO_INTERFACE;
+    }
+  },
+
+  // nsISupports implementation
+  QueryInterface: function(iid) {
+    if (iid.equals(Ci.nsISupports) ||
+        iid.equals(Ci.nsIAutoCompleteInput))
+      return this;
+
+    throw Components.results.NS_ERROR_NO_INTERFACE;
+  }
+}
+
+
+
+/**
+ * nsIAutoCompleteResult implementation
+ */
+function AutoCompleteResult(aValues, aComments, aStyles) {
+  this._values = aValues;
+  this._comments = aComments;
+  this._styles = aStyles;
+
+  if (this._values.length > 0) {
+    this.searchResult = Ci.nsIAutoCompleteResult.RESULT_SUCCESS;
+  } else {
+    this.searchResult = Ci.nsIAutoCompleteResult.NOMATCH;
+  }
+}
+AutoCompleteResult.prototype = {
+  constructor: AutoCompleteResult,
+
+  // Arrays
+  _values: null,
+  _comments: null,
+  _styles: null,
+
+  searchString: "",
+  searchResult: null,
+
+  defaultIndex: 0,
+
+  get matchCount() {
+    return this._values.length;
+  },
+
+  getValueAt: function(aIndex) {
+    return this._values[aIndex];
+  },
+
+  getLabelAt: function(aIndex) {
+    return this.getValueAt(aIndex);
+  },
+
+  getCommentAt: function(aIndex) {
+    return this._comments[aIndex];
+  },
+
+  getStyleAt: function(aIndex) {
+    return this._styles[aIndex];
+  },
+
+  getImageAt: function(aIndex) {
+    return "";
+  },
+
+  getFinalCompleteValueAt: function(aIndex) {
+    return this.getValueAt(aIndex);
+  },
+
+  removeValueAt: function (aRowIndex, aRemoveFromDb) {},
+
+  // nsISupports implementation
+  QueryInterface: function(iid) {
+    if (iid.equals(Ci.nsISupports) ||
+        iid.equals(Ci.nsIAutoCompleteResult))
+      return this;
+
+    throw Components.results.NS_ERROR_NO_INTERFACE;
+  }
+}
+
+
+
+/**
+ * nsIAutoCompleteSearch implementation that always returns
+ * the same result set.
+ */
+function AutoCompleteSearch(aName, aResult) {
+  this.name = aName;
+  this._result = aResult;
+}
+AutoCompleteSearch.prototype = {
+  constructor: AutoCompleteSearch,
+
+  // Search name. Used by AutoCompleteController
+  name: null,
+
+  // AutoCompleteResult
+  _result:null,
+
+
+  /**
+   * Return the same result set for every search
+   */
+  startSearch: function(aSearchString,
+                        aSearchParam,
+                        aPreviousResult,
+                        aListener)
+  {
+    aListener.onSearchResult(this, this._result);
+  },
+
+  stopSearch: function() {},
+
+  // nsISupports implementation
+  QueryInterface: function(iid) {
+    if (iid.equals(Ci.nsISupports) ||
+        iid.equals(Ci.nsIFactory) ||
+        iid.equals(Ci.nsIAutoCompleteSearch))
+      return this;
+
+    throw Components.results.NS_ERROR_NO_INTERFACE;
+  },
+
+  // nsIFactory implementation
+  createInstance: function(outer, iid) {
+    return this.QueryInterface(iid);
+  }
+}
+
+
+
+/**
+ * Helper to register an AutoCompleteSearch with the given name.
+ * Allows the AutoCompleteController to find the search.
+ */
+function registerAutoCompleteSearch(aSearch) {
+  var name = "@mozilla.org/autocomplete/search;1?name=" + aSearch.name;
+
+  var uuidGenerator = Cc["@mozilla.org/uuid-generator;1"].
+                      getService(Ci.nsIUUIDGenerator);
+  var cid = uuidGenerator.generateUUID();
+
+  var desc = "Test AutoCompleteSearch";
+
+  var componentManager = Components.manager
+                                   .QueryInterface(Ci.nsIComponentRegistrar);
+  componentManager.registerFactory(cid, desc, name, aSearch);
+
+  // Keep the id on the object so we can unregister later
+  aSearch.cid = cid;
+}
+
+
+
+/**
+ * Helper to unregister an AutoCompleteSearch.
+ */
+function unregisterAutoCompleteSearch(aSearch) {
+  var componentManager = Components.manager
+                                   .QueryInterface(Ci.nsIComponentRegistrar);
+  componentManager.unregisterFactory(aSearch.cid, aSearch);
+}
+
+
+
+/**
+ * Test AutoComplete with multiple AutoCompleteSearch sources.
+ */
+function run_test() {
+
+  // Make an AutoCompleteSearch that always returns nothing
+  var emptySearch = new AutoCompleteSearch("test-empty-search",
+                             new AutoCompleteResult([], [], []));
+
+  // Make an AutoCompleteSearch that returns two values
+  var expectedValues = ["test1", "test2"];
+  var regularSearch = new AutoCompleteSearch("test-regular-search",
+                             new AutoCompleteResult(expectedValues, [], []));
+
+  // Register searches so AutoCompleteController can find them
+  registerAutoCompleteSearch(emptySearch);
+  registerAutoCompleteSearch(regularSearch);
+
+  var controller = Components.classes["@mozilla.org/autocomplete/controller;1"].
+                   getService(Components.interfaces.nsIAutoCompleteController);
+
+  // Make an AutoCompleteInput that uses our searches
+  // and confirms results on search complete
+  var input = new AutoCompleteInput([emptySearch.name, regularSearch.name]);
+  var numSearchesStarted = 0;
+
+  input.onSearchBegin = function() {
+    numSearchesStarted++;
+    do_check_eq(numSearchesStarted, 1);
+  };
+
+  input.onSearchComplete = function() {
+
+    do_check_eq(numSearchesStarted, 1);
+
+    do_check_eq(controller.searchStatus,
+                Ci.nsIAutoCompleteController.STATUS_COMPLETE_MATCH);
+    do_check_eq(controller.matchCount, 2);
+
+    // Confirm expected result values
+    for (var i = 0; i < expectedValues.length; i++) {
+      do_check_eq(expectedValues[i], controller.getValueAt(i));
+    }
+
+    // Unregister searches
+    unregisterAutoCompleteSearch(emptySearch);
+    unregisterAutoCompleteSearch(regularSearch);
+
+    do_test_finished();
+  };
+
+  controller.input = input;
+
+  // Search is asynchronous, so don't let the test finish immediately
+  do_test_pending();
+
+  controller.startSearch("test");
+}
+
diff --git a/toolkit/components/autocomplete/tests/unit/test_393191.js b/toolkit/components/autocomplete/tests/unit/test_393191.js
new file mode 100644
index 000000000..6fb57e6c4
--- /dev/null
+++ b/toolkit/components/autocomplete/tests/unit/test_393191.js
@@ -0,0 +1,272 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/**
+ * Unit test for Bug 393191 - AutoComplete crashes if result is null
+ */
+
+
+
+/**
+ * Dummy nsIAutoCompleteInput source that returns
+ * the given list of AutoCompleteSearch names.
+ *
+ * Implements only the methods needed for this test.
+ */
+function AutoCompleteInput(aSearches) {
+  this.searches = aSearches;
+}
+AutoCompleteInput.prototype = {
+  constructor: AutoCompleteInput,
+
+  // Array of AutoCompleteSearch names
+  searches: null,
+
+  minResultsForPopup: 0,
+  timeout: 10,
+  searchParam: "",
+  textValue: "",
+  disableAutoComplete: false,
+  completeDefaultIndex: false,
+
+  get searchCount() {
+    return this.searches.length;
+  },
+
+  getSearchAt: function(aIndex) {
+    return this.searches[aIndex];
+  },
+
+  onSearchBegin: function() {},
+  onSearchComplete: function() {},
+
+  popupOpen: false,
+
+  popup: {
+    setSelectedIndex: function(aIndex) {},
+    invalidate: function() {},
+
+    // nsISupports implementation
+    QueryInterface: function(iid) {
+      if (iid.equals(Ci.nsISupports) ||
+          iid.equals(Ci.nsIAutoCompletePopup))
+        return this;
+
+      throw Components.results.NS_ERROR_NO_INTERFACE;
+    }
+  },
+
+  // nsISupports implementation
+  QueryInterface: function(iid) {
+    if (iid.equals(Ci.nsISupports) ||
+        iid.equals(Ci.nsIAutoCompleteInput))
+      return this;
+
+    throw Components.results.NS_ERROR_NO_INTERFACE;
+  }
+}
+
+
+
+/**
+ * nsIAutoCompleteResult implementation
+ */
+function AutoCompleteResult(aValues, aComments, aStyles) {
+  this._values = aValues;
+  this._comments = aComments;
+  this._styles = aStyles;
+
+  if (this._values.length > 0) {
+    this.searchResult = Ci.nsIAutoCompleteResult.RESULT_SUCCESS;
+  } else {
+    this.searchResult = Ci.nsIAutoCompleteResult.NOMATCH;
+  }
+}
+AutoCompleteResult.prototype = {
+  constructor: AutoCompleteResult,
+
+  // Arrays
+  _values: null,
+  _comments: null,
+  _styles: null,
+
+  searchString: "",
+  searchResult: null,
+
+  defaultIndex: 0,
+
+  get matchCount() {
+    return this._values.length;
+  },
+
+  getValueAt: function(aIndex) {
+    return this._values[aIndex];
+  },
+
+  getLabelAt: function(aIndex) {
+    return this.getValueAt(aIndex);
+  },
+
+  getCommentAt: function(aIndex) {
+    return this._comments[aIndex];
+  },
+
+  getStyleAt: function(aIndex) {
+    return this._styles[aIndex];
+  },
+
+  getImageAt: function(aIndex) {
+    return "";
+  },
+
+  getFinalCompleteValueAt: function(aIndex) {
+    return this.getValueAt(aIndex);
+  },
+
+  removeValueAt: function (aRowIndex, aRemoveFromDb) {},
+
+  // nsISupports implementation
+  QueryInterface: function(iid) {
+    if (iid.equals(Ci.nsISupports) ||
+        iid.equals(Ci.nsIAutoCompleteResult))
+      return this;
+
+    throw Components.results.NS_ERROR_NO_INTERFACE;
+  }
+}
+
+
+
+/**
+ * nsIAutoCompleteSearch implementation that always returns
+ * the same result set.
+ */
+function AutoCompleteSearch(aName, aResult) {
+  this.name = aName;
+  this._result = aResult;
+}
+AutoCompleteSearch.prototype = {
+  constructor: AutoCompleteSearch,
+
+  // Search name. Used by AutoCompleteController
+  name: null,
+
+  // AutoCompleteResult
+  _result: null,
+
+
+  /**
+   * Return the same result set for every search
+   */
+  startSearch: function(aSearchString,
+                        aSearchParam,
+                        aPreviousResult,
+                        aListener)
+  {
+    aListener.onSearchResult(this, this._result);
+  },
+
+  stopSearch: function() {},
+
+  // nsISupports implementation
+  QueryInterface: function(iid) {
+    if (iid.equals(Ci.nsISupports) ||
+        iid.equals(Ci.nsIFactory) ||
+        iid.equals(Ci.nsIAutoCompleteSearch))
+      return this;
+
+    throw Components.results.NS_ERROR_NO_INTERFACE;
+  },
+
+  // nsIFactory implementation
+  createInstance: function(outer, iid) {
+    return this.QueryInterface(iid);
+  }
+}
+
+
+
+/**
+ * Helper to register an AutoCompleteSearch with the given name.
+ * Allows the AutoCompleteController to find the search.
+ */
+function registerAutoCompleteSearch(aSearch) {
+  var name = "@mozilla.org/autocomplete/search;1?name=" + aSearch.name;
+
+  var uuidGenerator = Cc["@mozilla.org/uuid-generator;1"].
+                      getService(Ci.nsIUUIDGenerator);
+  var cid = uuidGenerator.generateUUID();
+
+  var desc = "Test AutoCompleteSearch";
+
+  var componentManager = Components.manager
+                                   .QueryInterface(Ci.nsIComponentRegistrar);
+  componentManager.registerFactory(cid, desc, name, aSearch);
+
+  // Keep the id on the object so we can unregister later
+  aSearch.cid = cid;
+}
+
+
+
+/**
+ * Helper to unregister an AutoCompleteSearch.
+ */
+function unregisterAutoCompleteSearch(aSearch) {
+  var componentManager = Components.manager
+                                   .QueryInterface(Ci.nsIComponentRegistrar);
+  componentManager.unregisterFactory(aSearch.cid, aSearch);
+}
+
+
+
+/**
+ * Test AutoComplete with a search that returns a null result
+ */
+function run_test() {
+
+  // Make an AutoCompleteSearch that always returns nothing
+  var emptySearch = new AutoCompleteSearch("test-empty-search",
+                             new AutoCompleteResult([], [], []));
+
+  // Register search so AutoCompleteController can find them
+  registerAutoCompleteSearch(emptySearch);
+
+  var controller = Components.classes["@mozilla.org/autocomplete/controller;1"].
+                   getService(Components.interfaces.nsIAutoCompleteController);
+
+  // Make an AutoCompleteInput that uses our search
+  // and confirms results on search complete
+  var input = new AutoCompleteInput([emptySearch.name]);
+  var numSearchesStarted = 0;
+
+  input.onSearchBegin = function() {
+    numSearchesStarted++;
+    do_check_eq(numSearchesStarted, 1);
+  };
+
+  input.onSearchComplete = function() {
+
+    do_check_eq(numSearchesStarted, 1);
+
+    do_check_eq(controller.searchStatus,
+                Ci.nsIAutoCompleteController.STATUS_COMPLETE_NO_MATCH);
+    do_check_eq(controller.matchCount, 0);
+
+    // Unregister searches
+    unregisterAutoCompleteSearch(emptySearch);
+
+    do_test_finished();
+  };
+
+  controller.input = input;
+
+  // Search is asynchronous, so don't let the test finish immediately
+  do_test_pending();
+
+  controller.startSearch("test");
+}
+
diff --git a/toolkit/components/autocomplete/tests/unit/test_440866.js b/toolkit/components/autocomplete/tests/unit/test_440866.js
new file mode 100644
index 000000000..e450aebbf
--- /dev/null
+++ b/toolkit/components/autocomplete/tests/unit/test_440866.js
@@ -0,0 +1,285 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/**
+ * Unit test for Bug 440866 - First AutoCompleteSearch that returns
+ * RESULT_NOMATCH cancels all other searches when popup is open
+ */
+
+
+
+/**
+ * Dummy nsIAutoCompleteInput source that returns
+ * the given list of AutoCompleteSearch names.
+ *
+ * Implements only the methods needed for this test.
+ */
+function AutoCompleteInput(aSearches) {
+  this.searches = aSearches;
+}
+AutoCompleteInput.prototype = {
+  constructor: AutoCompleteInput,
+
+  // Array of AutoCompleteSearch names
+  searches: null,
+
+  minResultsForPopup: 0,
+  timeout: 10,
+  searchParam: "",
+  textValue: "",
+  disableAutoComplete: false,
+  completeDefaultIndex: false,
+
+  get searchCount() {
+    return this.searches.length;
+  },
+
+  getSearchAt: function(aIndex) {
+    return this.searches[aIndex];
+  },
+
+  onSearchBegin: function() {},
+  onSearchComplete: function() {},
+
+  popupOpen: false,
+
+  popup: {
+    setSelectedIndex: function(aIndex) {},
+    invalidate: function() {},
+
+    // nsISupports implementation
+    QueryInterface: function(iid) {
+      if (iid.equals(Ci.nsISupports) ||
+          iid.equals(Ci.nsIAutoCompletePopup))
+        return this;
+
+      throw Components.results.NS_ERROR_NO_INTERFACE;
+    }
+  },
+
+  // nsISupports implementation
+  QueryInterface: function(iid) {
+    if (iid.equals(Ci.nsISupports) ||
+        iid.equals(Ci.nsIAutoCompleteInput))
+      return this;
+
+    throw Components.results.NS_ERROR_NO_INTERFACE;
+  }
+}
+
+
+
+/**
+ * nsIAutoCompleteResult implementation
+ */
+function AutoCompleteResult(aValues, aComments, aStyles) {
+  this._values = aValues;
+  this._comments = aComments;
+  this._styles = aStyles;
+
+  if (this._values.length > 0) {
+    this.searchResult = Ci.nsIAutoCompleteResult.RESULT_SUCCESS;
+  } else {
+    this.searchResult = Ci.nsIAutoCompleteResult.NOMATCH;
+  }
+}
+AutoCompleteResult.prototype = {
+  constructor: AutoCompleteResult,
+
+  // Arrays
+  _values: null,
+  _comments: null,
+  _styles: null,
+
+  searchString: "",
+  searchResult: null,
+
+  defaultIndex: 0,
+
+  get matchCount() {
+    return this._values.length;
+  },
+
+  getValueAt: function(aIndex) {
+    return this._values[aIndex];
+  },
+
+  getLabelAt: function(aIndex) {
+    return this.getValueAt(aIndex);
+  },
+
+  getCommentAt: function(aIndex) {
+    return this._comments[aIndex];
+  },
+
+  getStyleAt: function(aIndex) {
+    return this._styles[aIndex];
+  },
+
+  getImageAt: function(aIndex) {
+    return "";
+  },
+
+  getFinalCompleteValueAt: function(aIndex) {
+    return this.getValueAt(aIndex);
+  },
+
+  removeValueAt: function (aRowIndex, aRemoveFromDb) {},
+
+  // nsISupports implementation
+  QueryInterface: function(iid) {
+    if (iid.equals(Ci.nsISupports) ||
+        iid.equals(Ci.nsIAutoCompleteResult))
+      return this;
+
+    throw Components.results.NS_ERROR_NO_INTERFACE;
+  }
+}
+
+
+
+/**
+ * nsIAutoCompleteSearch implementation that always returns
+ * the same result set.
+ */
+function AutoCompleteSearch(aName, aResult) {
+  this.name = aName;
+  this._result = aResult;
+}
+AutoCompleteSearch.prototype = {
+  constructor: AutoCompleteSearch,
+
+  // Search name. Used by AutoCompleteController
+  name: null,
+
+  // AutoCompleteResult
+  _result:null,
+
+
+  /**
+   * Return the same result set for every search
+   */
+  startSearch: function(aSearchString,
+                        aSearchParam,
+                        aPreviousResult,
+                        aListener)
+  {
+    aListener.onSearchResult(this, this._result);
+  },
+
+  stopSearch: function() {},
+
+  // nsISupports implementation
+  QueryInterface: function(iid) {
+    if (iid.equals(Ci.nsISupports) ||
+        iid.equals(Ci.nsIFactory) ||
+        iid.equals(Ci.nsIAutoCompleteSearch))
+      return this;
+
+    throw Components.results.NS_ERROR_NO_INTERFACE;
+  },
+
+  // nsIFactory implementation
+  createInstance: function(outer, iid) {
+    return this.QueryInterface(iid);
+  }
+}
+
+
+
+/**
+ * Helper to register an AutoCompleteSearch with the given name.
+ * Allows the AutoCompleteController to find the search.
+ */
+function registerAutoCompleteSearch(aSearch) {
+  var name = "@mozilla.org/autocomplete/search;1?name=" + aSearch.name;
+
+  var uuidGenerator = Cc["@mozilla.org/uuid-generator;1"].
+                      getService(Ci.nsIUUIDGenerator);
+  var cid = uuidGenerator.generateUUID();
+
+  var desc = "Test AutoCompleteSearch";
+
+  var componentManager = Components.manager
+                                   .QueryInterface(Ci.nsIComponentRegistrar);
+  componentManager.registerFactory(cid, desc, name, aSearch);
+
+  // Keep the id on the object so we can unregister later
+  aSearch.cid = cid;
+}
+
+
+
+/**
+ * Helper to unregister an AutoCompleteSearch.
+ */
+function unregisterAutoCompleteSearch(aSearch) {
+  var componentManager = Components.manager
+                                   .QueryInterface(Ci.nsIComponentRegistrar);
+  componentManager.unregisterFactory(aSearch.cid, aSearch);
+}
+
+
+
+/**
+ * Test AutoComplete with multiple AutoCompleteSearch sources.
+ */
+function run_test() {
+
+  // Make an AutoCompleteSearch that always returns nothing
+  var emptySearch = new AutoCompleteSearch("test-empty-search",
+                             new AutoCompleteResult([], [], []));
+
+  // Make an AutoCompleteSearch that returns two values
+  var expectedValues = ["test1", "test2"];
+  var regularSearch = new AutoCompleteSearch("test-regular-search",
+                             new AutoCompleteResult(expectedValues, [], []));
+
+  // Register searches so AutoCompleteController can find them
+  registerAutoCompleteSearch(emptySearch);
+  registerAutoCompleteSearch(regularSearch);
+
+  var controller = Components.classes["@mozilla.org/autocomplete/controller;1"].
+                   getService(Components.interfaces.nsIAutoCompleteController);
+
+  // Make an AutoCompleteInput that uses our searches
+  // and confirms results on search complete
+  var input = new AutoCompleteInput([emptySearch.name, regularSearch.name]);
+  var numSearchesStarted = 0;
+
+  input.onSearchBegin = function() {
+    numSearchesStarted++;
+    do_check_eq(numSearchesStarted, 1);
+    do_check_eq(input.searchCount, 2);
+  };
+
+  input.onSearchComplete = function() {
+    do_check_eq(numSearchesStarted, 1);
+
+    do_check_eq(controller.searchStatus,
+                Ci.nsIAutoCompleteController.STATUS_COMPLETE_MATCH);
+    do_check_eq(controller.matchCount, 2);
+
+    // Confirm expected result values
+    for (var i = 0; i < expectedValues.length; i++) {
+      do_check_eq(expectedValues[i], controller.getValueAt(i));
+    }
+
+    do_check_true(input.popupOpen);
+
+    // Unregister searches
+    unregisterAutoCompleteSearch(emptySearch);
+    unregisterAutoCompleteSearch(regularSearch);
+
+    do_test_finished();
+  };
+
+  controller.input = input;
+
+  // Search is asynchronous, so don't let the test finish immediately
+  do_test_pending();
+
+  controller.startSearch("test");
+}
+
diff --git a/toolkit/components/autocomplete/tests/unit/test_463023.js b/toolkit/components/autocomplete/tests/unit/test_463023.js
new file mode 100644
index 000000000..a2639fd03
--- /dev/null
+++ b/toolkit/components/autocomplete/tests/unit/test_463023.js
@@ -0,0 +1,12 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+// main
+function run_test() {
+  var result = Cc["@mozilla.org/autocomplete/controller;1"].
+               createInstance(Ci.nsIAutoCompleteController);
+  do_check_eq(result.searchStatus, Ci.nsIAutoCompleteController.STATUS_NONE);
+}
diff --git a/toolkit/components/autocomplete/tests/unit/test_660156.js b/toolkit/components/autocomplete/tests/unit/test_660156.js
new file mode 100644
index 000000000..98acb243e
--- /dev/null
+++ b/toolkit/components/autocomplete/tests/unit/test_660156.js
@@ -0,0 +1,101 @@
+/**
+ * Search object that returns results at different times.
+ * First, the search that returns results asynchronously.
+ */
+function AutoCompleteAsyncSearch(aName, aResult) {
+  this.name = aName;
+  this._result = aResult;
+}
+AutoCompleteAsyncSearch.prototype = Object.create(AutoCompleteSearchBase.prototype);
+AutoCompleteAsyncSearch.prototype.startSearch = function(aSearchString,
+                                                         aSearchParam,
+                                                         aPreviousResult,
+                                                         aListener) {
+  this._result.searchResult = Ci.nsIAutoCompleteResult.RESULT_NOMATCH_ONGOING;
+  aListener.onSearchResult(this, this._result);
+
+  do_timeout(500, () => {
+    this._returnResults(aListener);
+  });
+};
+
+AutoCompleteAsyncSearch.prototype._returnResults = function(aListener) {
+  var result = this._result;
+
+  result.searchResult = Ci.nsIAutoCompleteResult.RESULT_SUCCESS;
+  aListener.onSearchResult(this, result);
+};
+
+/**
+ * The synchronous version
+ */
+function AutoCompleteSyncSearch(aName, aResult) {
+  this.name = aName;
+  this._result = aResult;
+}
+AutoCompleteSyncSearch.prototype = Object.create(AutoCompleteAsyncSearch.prototype);
+AutoCompleteSyncSearch.prototype.startSearch = function(aSearchString,
+                                                        aSearchParam,
+                                                        aPreviousResult,
+                                                        aListener) {
+  this._returnResults(aListener);
+};
+
+/**
+ * Results object
+ */
+function AutoCompleteResult(aValues, aDefaultIndex) {
+  this._values = aValues;
+  this.defaultIndex = aDefaultIndex;
+}
+AutoCompleteResult.prototype = Object.create(AutoCompleteResultBase.prototype);
+
+
+/**
+ * Test AutoComplete with multiple AutoCompleteSearch sources, with one of them
+ * (index != 0) returning before the rest.
+ */
+function run_test() {
+  do_test_pending();
+
+  var results = ["mozillaTest"];
+  var inputStr = "moz";
+
+  // Async search
+  var asyncSearch = new AutoCompleteAsyncSearch("Async",
+                                                new AutoCompleteResult(results, -1));
+  // Sync search
+  var syncSearch = new AutoCompleteSyncSearch("Sync",
+                                              new AutoCompleteResult(results, 0));
+
+  // Register searches so AutoCompleteController can find them
+  registerAutoCompleteSearch(asyncSearch);
+  registerAutoCompleteSearch(syncSearch);
+
+  var controller = Cc["@mozilla.org/autocomplete/controller;1"].
+                   getService(Ci.nsIAutoCompleteController);
+
+  // Make an AutoCompleteInput that uses our searches
+  // and confirms results on search complete.
+  // Async search MUST be FIRST to trigger the bug this tests.
+  var input = new AutoCompleteInputBase([asyncSearch.name, syncSearch.name]);
+  input.completeDefaultIndex = true;
+  input.textValue = inputStr;
+
+  // Caret must be at the end. Autofill doesn't happen unless you're typing
+  // characters at the end.
+  var strLen = inputStr.length;
+  input.selectTextRange(strLen, strLen);
+
+  controller.input = input;
+  controller.startSearch(inputStr);
+
+  input.onSearchComplete = function() {
+    do_check_eq(input.textValue, results[0]);
+
+    // Unregister searches
+    unregisterAutoCompleteSearch(asyncSearch);
+    unregisterAutoCompleteSearch(syncSearch);
+    do_test_finished();
+  };
+}
diff --git a/toolkit/components/autocomplete/tests/unit/test_autocomplete_multiple.js b/toolkit/components/autocomplete/tests/unit/test_autocomplete_multiple.js
new file mode 100644
index 000000000..7fee48d55
--- /dev/null
+++ b/toolkit/components/autocomplete/tests/unit/test_autocomplete_multiple.js
@@ -0,0 +1,276 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/**
+ * Dummy nsIAutoCompleteInput source that returns
+ * the given list of AutoCompleteSearch names.
+ *
+ * Implements only the methods needed for this test.
+ */
+function AutoCompleteInput(aSearches) {
+  this.searches = aSearches;
+}
+AutoCompleteInput.prototype = {
+  constructor: AutoCompleteInput,
+
+  // Array of AutoCompleteSearch names
+  searches: null,
+
+  minResultsForPopup: 0,
+  timeout: 10,
+  searchParam: "",
+  textValue: "",
+  disableAutoComplete: false,
+  completeDefaultIndex: false,
+
+  get searchCount() {
+    return this.searches.length;
+  },
+
+  getSearchAt: function(aIndex) {
+    return this.searches[aIndex];
+  },
+
+  onSearchBegin: function() {},
+  onSearchComplete: function() {},
+
+  popupOpen: false,
+
+  popup: {
+    setSelectedIndex: function(aIndex) {},
+    invalidate: function() {},
+
+    // nsISupports implementation
+    QueryInterface: function(iid) {
+      if (iid.equals(Ci.nsISupports) ||
+          iid.equals(Ci.nsIAutoCompletePopup))
+        return this;
+
+      throw Components.results.NS_ERROR_NO_INTERFACE;
+    }
+  },
+
+  // nsISupports implementation
+  QueryInterface: function(iid) {
+    if (iid.equals(Ci.nsISupports) ||
+        iid.equals(Ci.nsIAutoCompleteInput))
+      return this;
+
+    throw Components.results.NS_ERROR_NO_INTERFACE;
+  }
+}
+
+
+
+/**
+ * nsIAutoCompleteResult implementation
+ */
+function AutoCompleteResult(aValues, aComments, aStyles) {
+  this._values = aValues;
+  this._comments = aComments;
+  this._styles = aStyles;
+}
+AutoCompleteResult.prototype = {
+  constructor: AutoCompleteResult,
+
+  // Arrays
+  _values: null,
+  _comments: null,
+  _styles: null,
+
+  searchString: "",
+  searchResult: null,
+
+  defaultIndex: 0,
+
+  get matchCount() {
+    return this._values.length;
+  },
+
+  getValueAt: function(aIndex) {
+    return this._values[aIndex];
+  },
+
+  getLabelAt: function(aIndex) {
+    return this.getValueAt(aIndex);
+  },
+
+  getCommentAt: function(aIndex) {
+    return this._comments[aIndex];
+  },
+
+  getStyleAt: function(aIndex) {
+    return this._styles[aIndex];
+  },
+
+  getImageAt: function(aIndex) {
+    return "";
+  },
+
+  getFinalCompleteValueAt: function(aIndex) {
+    return this.getValueAt(aIndex);
+  },
+
+  removeValueAt: function (aRowIndex, aRemoveFromDb) {},
+
+  // nsISupports implementation
+  QueryInterface: function(iid) {
+    if (iid.equals(Ci.nsISupports) ||
+        iid.equals(Ci.nsIAutoCompleteResult))
+      return this;
+
+    throw Components.results.NS_ERROR_NO_INTERFACE;
+  }
+}
+
+
+
+/**
+ * nsIAutoCompleteSearch implementation that always returns
+ * the same result set.
+ */
+function AutoCompleteSearch(aName, aResult) {
+  this.name = aName;
+  this._result = aResult;
+}
+AutoCompleteSearch.prototype = {
+  constructor: AutoCompleteSearch,
+
+  // Search name. Used by AutoCompleteController
+  name: null,
+
+  // AutoCompleteResult
+  _result:null,
+
+
+  /**
+   * Return the same result set for every search
+   */
+  startSearch: function(aSearchString,
+                        aSearchParam,
+                        aPreviousResult,
+                        aListener)
+  {
+    var result = this._result;
+    if (result._values.length > 0) {
+      result.searchResult = Ci.nsIAutoCompleteResult.RESULT_SUCCESS_ONGOING;
+    } else {
+      result.searchResult = Ci.nsIAutoCompleteResult.RESULT_NOMATCH_ONGOING;
+    }
+    aListener.onSearchResult(this, result);
+
+    if (result._values.length > 0) {
+      result.searchResult = Ci.nsIAutoCompleteResult.RESULT_SUCCESS;
+    } else {
+      result.searchResult = Ci.nsIAutoCompleteResult.RESULT_NOMATCH;
+    }
+    aListener.onSearchResult(this, result);
+  },
+
+  stopSearch: function() {},
+
+  // nsISupports implementation
+  QueryInterface: function(iid) {
+    if (iid.equals(Ci.nsISupports) ||
+        iid.equals(Ci.nsIFactory) ||
+        iid.equals(Ci.nsIAutoCompleteSearch))
+      return this;
+
+    throw Components.results.NS_ERROR_NO_INTERFACE;
+  },
+
+  // nsIFactory implementation
+  createInstance: function(outer, iid) {
+    return this.QueryInterface(iid);
+  }
+}
+
+
+
+/**
+ * Helper to register an AutoCompleteSearch with the given name.
+ * Allows the AutoCompleteController to find the search.
+ */
+function registerAutoCompleteSearch(aSearch) {
+  var name = "@mozilla.org/autocomplete/search;1?name=" + aSearch.name;
+
+  var uuidGenerator = Cc["@mozilla.org/uuid-generator;1"].
+                      getService(Ci.nsIUUIDGenerator);
+  var cid = uuidGenerator.generateUUID();
+
+  var desc = "Test AutoCompleteSearch";
+
+  var componentManager = Components.manager
+                                   .QueryInterface(Ci.nsIComponentRegistrar);
+  componentManager.registerFactory(cid, desc, name, aSearch);
+
+  // Keep the id on the object so we can unregister later
+  aSearch.cid = cid;
+}
+
+
+
+/**
+ * Helper to unregister an AutoCompleteSearch.
+ */
+function unregisterAutoCompleteSearch(aSearch) {
+  var componentManager = Components.manager
+                                   .QueryInterface(Ci.nsIComponentRegistrar);
+  componentManager.unregisterFactory(aSearch.cid, aSearch);
+}
+
+
+
+/**
+ * Test AutoComplete with multiple AutoCompleteSearch sources.
+ */
+function run_test() {
+  var expected1 = ["1", "2", "3"];
+  var expected2 = ["a", "b", "c"];
+  var search1 = new AutoCompleteSearch("search1",
+                             new AutoCompleteResult(expected1, [], []));
+  var search2 = new AutoCompleteSearch("search2",
+                             new AutoCompleteResult(expected2, [], []));
+
+  // Register searches so AutoCompleteController can find them
+  registerAutoCompleteSearch(search1);
+  registerAutoCompleteSearch(search2);
+
+  var controller = Components.classes["@mozilla.org/autocomplete/controller;1"].
+                   getService(Components.interfaces.nsIAutoCompleteController);
+
+  // Make an AutoCompleteInput that uses our searches
+  // and confirms results on search complete
+  var input = new AutoCompleteInput([search1.name, search2.name]);
+  var numSearchesStarted = 0;
+
+  input.onSearchBegin = function() {
+    numSearchesStarted++;
+    do_check_eq(numSearchesStarted, 1);
+  };
+
+  input.onSearchComplete = function() {
+
+    do_check_eq(numSearchesStarted, 1);
+
+    do_check_eq(controller.searchStatus,
+                Ci.nsIAutoCompleteController.STATUS_COMPLETE_MATCH);
+    do_check_eq(controller.matchCount, expected1.length + expected2.length);
+
+    // Unregister searches
+    unregisterAutoCompleteSearch(search1);
+    unregisterAutoCompleteSearch(search2);
+
+    do_test_finished();
+  };
+
+  controller.input = input;
+
+  // Search is asynchronous, so don't let the test finish immediately
+  do_test_pending();
+
+  controller.startSearch("test");
+}
diff --git a/toolkit/components/autocomplete/tests/unit/test_autocomplete_userContextId.js b/toolkit/components/autocomplete/tests/unit/test_autocomplete_userContextId.js
new file mode 100644
index 000000000..c98db7f8f
--- /dev/null
+++ b/toolkit/components/autocomplete/tests/unit/test_autocomplete_userContextId.js
@@ -0,0 +1,45 @@
+"use strict";
+
+Cu.import("resource://gre/modules/Promise.jsm");
+
+function AutoCompleteInput(aSearches, aUserContextId) {
+  this.searches = aSearches;
+  this.userContextId = aUserContextId;
+  this.popup.selectedIndex = -1;
+}
+AutoCompleteInput.prototype = Object.create(AutoCompleteInputBase.prototype);
+
+function AutoCompleteSearch(aName) {
+  this.name = aName;
+}
+AutoCompleteSearch.prototype = Object.create(AutoCompleteSearchBase.prototype);
+
+add_task(function *test_userContextId() {
+  let searchParam = yield doSearch("test", 1);
+  Assert.equal(searchParam, " user-context-id:1");
+});
+
+function doSearch(aString, aUserContextId) {
+  let deferred = Promise.defer();
+  let search = new AutoCompleteSearch("test");
+
+  search.startSearch = function (aSearchString,
+                                 aSearchParam,
+                                 aPreviousResult,
+                                 aListener) {
+    unregisterAutoCompleteSearch(search);
+    deferred.resolve(aSearchParam);
+  };
+
+  registerAutoCompleteSearch(search);
+
+  let controller = Cc["@mozilla.org/autocomplete/controller;1"].
+                   getService(Ci.nsIAutoCompleteController);
+
+  let input = new AutoCompleteInput([ search.name ], aUserContextId);
+  controller.input = input;
+  controller.startSearch(aString);
+
+  return deferred.promise;
+ }
+
diff --git a/toolkit/components/autocomplete/tests/unit/test_autofillSelectedPopupIndex.js b/toolkit/components/autocomplete/tests/unit/test_autofillSelectedPopupIndex.js
new file mode 100644
index 000000000..5fb93abc1
--- /dev/null
+++ b/toolkit/components/autocomplete/tests/unit/test_autofillSelectedPopupIndex.js
@@ -0,0 +1,78 @@
+"use strict";
+
+add_task(function* sameCaseAsMatch() {
+  yield runTest("moz");
+});
+
+add_task(function* differentCaseFromMatch() {
+  yield runTest("MOZ");
+});
+
+function* runTest(searchStr) {
+  let matches = [
+    "mozilla.org",
+    "example.com",
+  ];
+  let result = new AutoCompleteResultBase(matches);
+  result.defaultIndex = 0;
+
+  let search = new AutoCompleteSearchBase("search", result);
+  registerAutoCompleteSearch(search);
+
+  let input = new AutoCompleteInputBase([search.name]);
+  input.completeSelectedIndex = true;
+  input.completeDefaultIndex = true;
+
+  // Start off with the search string in the input.  The selection must be
+  // collapsed and the caret must be at the end to trigger autofill below.
+  input.textValue = searchStr;
+  input.selectTextRange(searchStr.length, searchStr.length);
+  Assert.equal(input.selectionStart, searchStr.length,
+               "Selection should start at the end of the input");
+  Assert.equal(input.selectionEnd, searchStr.length,
+               "Selection should end at the end of the input");
+
+  let controller = Cc["@mozilla.org/autocomplete/controller;1"].
+                   createInstance(Ci.nsIAutoCompleteController);
+  controller.input = input;
+  input.controller = controller;
+
+  // Start a search.
+  yield new Promise(resolve => {
+    controller.startSearch(searchStr);
+    input.onSearchComplete = () => {
+      // The first match should have autofilled, but the case of the search
+      // string should be preserved.
+      let expectedValue = searchStr + matches[0].substr(searchStr.length);
+      Assert.equal(input.textValue, expectedValue,
+                   "Should have autofilled");
+      Assert.equal(input.selectionStart, searchStr.length,
+                   "Selection should start after search string");
+      Assert.equal(input.selectionEnd, expectedValue.length,
+                   "Selection should end at the end of the input");
+      resolve();
+    };
+  });
+
+  // Key down to select the second match in the popup.
+  controller.handleKeyNavigation(Ci.nsIDOMKeyEvent.DOM_VK_DOWN);
+  let expectedValue = matches[1];
+  Assert.equal(input.textValue, expectedValue,
+               "Should have filled second match");
+  Assert.equal(input.selectionStart, expectedValue.length,
+               "Selection should start at the end of the input");
+  Assert.equal(input.selectionEnd, expectedValue.length,
+               "Selection should end at the end of the input");
+
+  // Key up to select the first match again.  The input should be restored
+  // exactly as it was when the first match was autofilled above: the search
+  // string's case should be preserved, and the selection should be preserved.
+  controller.handleKeyNavigation(Ci.nsIDOMKeyEvent.DOM_VK_UP);
+  expectedValue = searchStr + matches[0].substr(searchStr.length);
+  Assert.equal(input.textValue, expectedValue,
+               "Should have filled first match again");
+  Assert.equal(input.selectionStart, searchStr.length,
+               "Selection should start after search string again");
+  Assert.equal(input.selectionEnd, expectedValue.length,
+               "Selection should end at the end of the input again");
+}
diff --git a/toolkit/components/autocomplete/tests/unit/test_badDefaultIndex.js b/toolkit/components/autocomplete/tests/unit/test_badDefaultIndex.js
new file mode 100644
index 000000000..17f735388
--- /dev/null
+++ b/toolkit/components/autocomplete/tests/unit/test_badDefaultIndex.js
@@ -0,0 +1,96 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/**
+ * A results that wants to defaultComplete to 0, but it has no matches,
+ * though it notifies SUCCESS to the controller.
+ */
+function AutoCompleteNoMatchResult() {
+  this.defaultIndex = 0;
+}
+AutoCompleteNoMatchResult.prototype = Object.create(AutoCompleteResultBase.prototype);
+
+/**
+ * A results that wants to defaultComplete to an index greater than the number
+ * of matches.
+ */
+function AutoCompleteBadIndexResult(aValues, aDefaultIndex) {
+  do_check_true(aValues.length <= aDefaultIndex);
+  this._values = aValues;
+  this.defaultIndex = aDefaultIndex;
+}
+AutoCompleteBadIndexResult.prototype = Object.create(AutoCompleteResultBase.prototype);
+
+add_test(function autocomplete_noMatch_success() {
+  const INPUT_STR = "moz";
+
+  let searchNoMatch =
+    new AutoCompleteSearchBase("searchNoMatch",
+                               new AutoCompleteNoMatchResult());
+  registerAutoCompleteSearch(searchNoMatch);
+
+  // Make an AutoCompleteInput that uses our search and confirms results.
+  let input = new AutoCompleteInputBase([searchNoMatch.name]);
+  input.completeDefaultIndex = true;
+  input.textValue = INPUT_STR;
+
+  // Caret must be at the end for autoFill to happen.
+  let strLen = INPUT_STR.length;
+  input.selectTextRange(strLen, strLen);
+  do_check_eq(input.selectionStart, strLen);
+  do_check_eq(input.selectionEnd, strLen);
+
+  let controller = Cc["@mozilla.org/autocomplete/controller;1"].
+                   getService(Ci.nsIAutoCompleteController);
+  controller.input = input;
+  controller.startSearch(INPUT_STR);
+
+  input.onSearchComplete = function () {
+    // Should not try to autoFill to an empty value.
+    do_check_eq(input.textValue, "moz");
+
+    // Clean up.
+    unregisterAutoCompleteSearch(searchNoMatch);
+    run_next_test();
+  };
+});
+
+add_test(function autocomplete_defaultIndex_exceeds_matchCount() {
+  const INPUT_STR = "moz";
+
+  // Result returning matches, but a bad defaultIndex.
+  let searchBadIndex =
+    new AutoCompleteSearchBase("searchBadIndex",
+                               new AutoCompleteBadIndexResult(["mozillaTest"], 1));
+  registerAutoCompleteSearch(searchBadIndex);
+
+  // Make an AutoCompleteInput that uses our search and confirms results.
+  let input = new AutoCompleteInputBase([searchBadIndex.name]);
+  input.completeDefaultIndex = true;
+  input.textValue = INPUT_STR;
+
+  // Caret must be at the end for autoFill to happen.
+  let strLen = INPUT_STR.length;
+  input.selectTextRange(strLen, strLen);
+  do_check_eq(input.selectionStart, strLen);
+  do_check_eq(input.selectionEnd, strLen);
+
+  let controller = Cc["@mozilla.org/autocomplete/controller;1"].
+                   getService(Ci.nsIAutoCompleteController);
+  controller.input = input;
+  controller.startSearch(INPUT_STR);
+
+  input.onSearchComplete = function () {
+    // Should not try to autoFill to an empty value.
+    do_check_eq(input.textValue, "moz");
+
+    // Clean up.
+    unregisterAutoCompleteSearch(searchBadIndex);
+    run_next_test();
+  };
+});
+
+function run_test() {
+  run_next_test();
+}
diff --git a/toolkit/components/autocomplete/tests/unit/test_completeDefaultIndex_casing.js b/toolkit/components/autocomplete/tests/unit/test_completeDefaultIndex_casing.js
new file mode 100644
index 000000000..c25b00907
--- /dev/null
+++ b/toolkit/components/autocomplete/tests/unit/test_completeDefaultIndex_casing.js
@@ -0,0 +1,63 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+function AutoCompleteResult(aValues) {
+  this._values = aValues;
+  this.defaultIndex = 0;
+}
+AutoCompleteResult.prototype = Object.create(AutoCompleteResultBase.prototype);
+
+function AutoCompleteInput(aSearches) {
+  this.searches = aSearches;
+  this.popup.selectedIndex = -1;
+  this.completeDefaultIndex = true;
+}
+AutoCompleteInput.prototype = Object.create(AutoCompleteInputBase.prototype);
+
+function run_test() {
+  run_next_test();
+}
+
+add_test(function test_keyNavigation() {
+  doSearch("MOZ", "mozilla", function(aController) {
+    do_check_eq(aController.input.textValue, "MOZilla");
+    aController.handleKeyNavigation(Ci.nsIDOMKeyEvent.DOM_VK_RIGHT);
+    do_check_eq(aController.input.textValue, "mozilla");
+  });
+});
+
+add_test(function test_handleEnter() {
+  doSearch("MOZ", "mozilla", function(aController) {
+    do_check_eq(aController.input.textValue, "MOZilla");
+    aController.handleEnter(false);
+    do_check_eq(aController.input.textValue, "mozilla");
+  });
+});
+
+function doSearch(aSearchString, aResultValue, aOnCompleteCallback) {
+  let search = new AutoCompleteSearchBase("search",
+                                          new AutoCompleteResult([ "mozilla", "toolkit" ], 0));
+  registerAutoCompleteSearch(search);
+
+  let controller = Cc["@mozilla.org/autocomplete/controller;1"].
+                   getService(Ci.nsIAutoCompleteController);
+
+  // Make an AutoCompleteInput that uses our searches and confirms results.
+  let input = new AutoCompleteInput([ search.name ]);
+  input.textValue = aSearchString;
+
+  // Caret must be at the end for autofill to happen.
+  let strLen = aSearchString.length;
+  input.selectTextRange(strLen, strLen);
+  controller.input = input;
+  controller.startSearch(aSearchString);
+
+  input.onSearchComplete = function onSearchComplete() {
+    aOnCompleteCallback(controller);
+
+    // Clean up.
+    unregisterAutoCompleteSearch(search);
+    run_next_test();
+  };
+}
diff --git a/toolkit/components/autocomplete/tests/unit/test_finalCompleteValue.js b/toolkit/components/autocomplete/tests/unit/test_finalCompleteValue.js
new file mode 100644
index 000000000..fcac8ae43
--- /dev/null
+++ b/toolkit/components/autocomplete/tests/unit/test_finalCompleteValue.js
@@ -0,0 +1,48 @@
+function AutoCompleteResult(aValues, aFinalCompleteValues) {
+  this._values = aValues;
+  this._finalCompleteValues = aFinalCompleteValues;
+}
+AutoCompleteResult.prototype = Object.create(AutoCompleteResultBase.prototype);
+
+function AutoCompleteInput(aSearches) {
+  this.searches = aSearches;
+  this.popup.selectedIndex = 0;
+}
+AutoCompleteInput.prototype = Object.create(AutoCompleteInputBase.prototype);
+
+add_test(function test_handleEnter_mouse() {
+  doSearch("moz", "mozilla.com", "http://www.mozilla.com", function(aController) {
+    do_check_eq(aController.input.textValue, "moz");
+    do_check_eq(aController.getFinalCompleteValueAt(0), "http://www.mozilla.com");
+    // Keyboard interaction is tested by test_finalCompleteValueSelectedIndex.js
+    // so here just test popup selection.
+    aController.handleEnter(true);
+    do_check_eq(aController.input.textValue, "http://www.mozilla.com");
+  });
+});
+
+function doSearch(aSearchString, aResultValue, aFinalCompleteValue, aOnCompleteCallback) {
+  let search = new AutoCompleteSearchBase(
+    "search",
+    new AutoCompleteResult([ aResultValue ], [ aFinalCompleteValue ])
+  );
+  registerAutoCompleteSearch(search);
+
+  let controller = Cc["@mozilla.org/autocomplete/controller;1"].
+                   getService(Ci.nsIAutoCompleteController);
+
+  // Make an AutoCompleteInput that uses our searches and confirms results.
+  let input = new AutoCompleteInput([ search.name ]);
+  input.textValue = aSearchString;
+
+  controller.input = input;
+  controller.startSearch(aSearchString);
+
+  input.onSearchComplete = function onSearchComplete() {
+    aOnCompleteCallback(controller);
+
+    // Clean up.
+    unregisterAutoCompleteSearch(search);
+    run_next_test();
+  };
+}
diff --git a/toolkit/components/autocomplete/tests/unit/test_finalCompleteValueSelectedIndex.js b/toolkit/components/autocomplete/tests/unit/test_finalCompleteValueSelectedIndex.js
new file mode 100644
index 000000000..6556a26dc
--- /dev/null
+++ b/toolkit/components/autocomplete/tests/unit/test_finalCompleteValueSelectedIndex.js
@@ -0,0 +1,119 @@
+function AutoCompleteResult(aResultValues) {
+  this._values = aResultValues.map(x => x[0]);
+  this._finalCompleteValues = aResultValues.map(x => x[1]);
+}
+AutoCompleteResult.prototype = Object.create(AutoCompleteResultBase.prototype);
+
+var selectByWasCalled = false;
+function AutoCompleteInput(aSearches) {
+  this.searches = aSearches;
+  this.popup.selectedIndex = 0;
+  this.popup.selectBy = function(reverse, page) {
+    Assert.equal(selectByWasCalled, false);
+    selectByWasCalled = true;
+    Assert.equal(reverse, false);
+    Assert.equal(page, false);
+    this.selectedIndex += (reverse ? -1 : 1) * (page ? 100 : 1);
+  };
+  this.completeSelectedIndex = true;
+}
+AutoCompleteInput.prototype = Object.create(AutoCompleteInputBase.prototype);
+
+add_test(function test_handleEnter_key() {
+  let results = [
+    ["mozilla.com", "http://www.mozilla.com"],
+    ["mozilla.org", "http://www.mozilla.org"],
+  ];
+  // First check the case where we do select a value with the keyboard:
+  doSearch("moz", results, function(aController) {
+    Assert.equal(aController.input.textValue, "moz");
+    Assert.equal(aController.getFinalCompleteValueAt(0), "http://www.mozilla.com");
+    Assert.equal(aController.getFinalCompleteValueAt(1), "http://www.mozilla.org");
+
+    Assert.equal(aController.input.popup.selectedIndex, 0);
+    aController.handleKeyNavigation(Ci.nsIDOMKeyEvent.DOM_VK_DOWN);
+    Assert.equal(aController.input.popup.selectedIndex, 1);
+    // Simulate mouse interaction changing selectedIndex
+    // ie NOT keyboard interaction:
+    aController.input.popup.selectedIndex = 0;
+
+    aController.handleEnter(false);
+    // Verify that the keyboard-selected thing got inserted,
+    // and not the mouse selection:
+    Assert.equal(aController.input.textValue, "http://www.mozilla.org");
+  });
+});
+
+add_test(function test_handleEnter_mouse() {
+  let results = [
+    ["mozilla.com", "http://www.mozilla.com"],
+    ["mozilla.org", "http://www.mozilla.org"],
+  ];
+  // Then the case where we do not:
+  doSearch("moz", results, function(aController) {
+    Assert.equal(aController.input.textValue, "moz");
+    Assert.equal(aController.getFinalCompleteValueAt(0), "http://www.mozilla.com");
+    Assert.equal(aController.getFinalCompleteValueAt(1), "http://www.mozilla.org");
+
+    Assert.equal(aController.input.popup.selectedIndex, 0);
+    aController.input.popupOpen = true;
+    // Simulate mouse interaction changing selectedIndex
+    // ie NOT keyboard interaction:
+    aController.input.popup.selectedIndex = 1;
+    Assert.equal(selectByWasCalled, false);
+    Assert.equal(aController.input.popup.selectedIndex, 1);
+
+    aController.handleEnter(false);
+    // Verify that the input stayed the same, because no selection was made
+    // with the keyboard:
+    Assert.equal(aController.input.textValue, "moz");
+  });
+});
+
+add_test(function test_handleEnter_preselected() {
+  let results = [
+    ["mozilla.com", "http://www.mozilla.com"],
+    ["mozilla.org", "http://www.mozilla.org"],
+  ];
+  // Then test a preselection.
+  doSearch("moz", results, function(aController) {
+    Assert.equal(aController.input.textValue, "moz");
+    Assert.equal(aController.getFinalCompleteValueAt(0), "http://www.mozilla.com");
+    Assert.equal(aController.getFinalCompleteValueAt(1), "http://www.mozilla.org");
+
+    aController.setInitiallySelectedIndex(0);
+
+    aController.handleEnter(false);
+    // Verify that the input stayed the same, because no selection was made
+    // with the keyboard:
+    Assert.equal(aController.input.textValue, "http://www.mozilla.com");
+  });
+});
+
+function doSearch(aSearchString, aResults, aOnCompleteCallback) {
+  selectByWasCalled = false;
+  let search = new AutoCompleteSearchBase(
+    "search",
+    new AutoCompleteResult(aResults)
+  );
+  registerAutoCompleteSearch(search);
+
+  let controller = Cc["@mozilla.org/autocomplete/controller;1"].
+                   getService(Ci.nsIAutoCompleteController);
+
+  // Make an AutoCompleteInput that uses our searches and confirms results.
+  let input = new AutoCompleteInput([ search.name ]);
+  input.textValue = aSearchString;
+
+  controller.input = input;
+  controller.startSearch(aSearchString);
+
+  input.onSearchComplete = function onSearchComplete() {
+    aOnCompleteCallback(controller);
+
+    // Clean up.
+    unregisterAutoCompleteSearch(search);
+    run_next_test();
+  };
+}
+
diff --git a/toolkit/components/autocomplete/tests/unit/test_finalCompleteValue_defaultIndex.js b/toolkit/components/autocomplete/tests/unit/test_finalCompleteValue_defaultIndex.js
new file mode 100644
index 000000000..4942e7a9f
--- /dev/null
+++ b/toolkit/components/autocomplete/tests/unit/test_finalCompleteValue_defaultIndex.js
@@ -0,0 +1,107 @@
+function AutoCompleteResult(aResultValues) {
+  this.defaultIndex = 0;
+  this._values = aResultValues.map(x => x[0]);
+  this._finalCompleteValues = aResultValues.map(x => x[1]);
+}
+AutoCompleteResult.prototype = Object.create(AutoCompleteResultBase.prototype);
+
+function AutoCompleteInput(aSearches) {
+  this.searches = aSearches;
+  this.popup.selectedIndex = 0;
+  this.completeSelectedIndex = true;
+  this.completeDefaultIndex = true;
+}
+AutoCompleteInput.prototype = Object.create(AutoCompleteInputBase.prototype);
+
+add_test(function test_handleEnter() {
+  let results = [
+    ["mozilla.com", "https://www.mozilla.com"],
+    ["gomozilla.org", "http://www.gomozilla.org"],
+  ];
+  doSearch("moz", results, { selectedIndex: 0 }, controller => {
+    let input = controller.input;
+    Assert.equal(input.textValue, "mozilla.com");
+    Assert.equal(controller.getFinalCompleteValueAt(0), results[0][1]);
+    Assert.equal(controller.getFinalCompleteValueAt(1), results[1][1]);
+    Assert.equal(input.popup.selectedIndex, 0);
+
+    controller.handleEnter(false);
+    // Verify that the keyboard-selected thing got inserted,
+    // and not the mouse selection:
+    Assert.equal(controller.input.textValue, "https://www.mozilla.com");
+  });
+});
+
+add_test(function test_handleEnter_otherSelected() {
+  // The popup selection may not coincide with what is filled into the input
+  // field, for example if the user changed it with the mouse and then pressed
+  // Enter. In such a case we should still use the inputField value and not the
+  // popup selected value.
+  let results = [
+    ["mozilla.com", "https://www.mozilla.com"],
+    ["gomozilla.org", "http://www.gomozilla.org"],
+  ];
+  doSearch("moz", results, { selectedIndex: 1 }, controller => {
+    let input = controller.input;
+    Assert.equal(input.textValue, "mozilla.com");
+    Assert.equal(controller.getFinalCompleteValueAt(0), results[0][1]);
+    Assert.equal(controller.getFinalCompleteValueAt(1), results[1][1]);
+    Assert.equal(input.popup.selectedIndex, 1);
+
+    controller.handleEnter(false);
+    // Verify that the keyboard-selected thing got inserted,
+    // and not the mouse selection:
+    Assert.equal(controller.input.textValue, "https://www.mozilla.com");
+  });
+});
+
+add_test(function test_handleEnter_otherSelected_nocompleteselectedindex() {
+  let results = [
+    ["mozilla.com", "https://www.mozilla.com"],
+    ["gomozilla.org", "http://www.gomozilla.org"],
+  ];
+  doSearch("moz", results, { selectedIndex: 1,
+                             completeSelectedIndex: false }, controller => {
+    let input = controller.input;
+    Assert.equal(input.textValue, "mozilla.com");
+    Assert.equal(controller.getFinalCompleteValueAt(0), results[0][1]);
+    Assert.equal(controller.getFinalCompleteValueAt(1), results[1][1]);
+    Assert.equal(input.popup.selectedIndex, 1);
+
+    controller.handleEnter(false);
+    // Verify that the keyboard-selected result is inserted, not the
+    // defaultComplete.
+    Assert.equal(controller.input.textValue, "http://www.gomozilla.org");
+  });
+});
+
+function doSearch(aSearchString, aResults, aOptions, aOnCompleteCallback) {
+  let search = new AutoCompleteSearchBase(
+    "search",
+    new AutoCompleteResult(aResults)
+  );
+  registerAutoCompleteSearch(search);
+
+  let input = new AutoCompleteInput([ search.name ]);
+  input.textValue = aSearchString;
+  if ("selectedIndex" in aOptions) {
+    input.popup.selectedIndex = aOptions.selectedIndex;
+  }
+  if ("completeSelectedIndex" in aOptions) {
+    input.completeSelectedIndex = aOptions.completeSelectedIndex;
+  }
+  // Needed for defaultIndex completion.
+  input.selectTextRange(aSearchString.length, aSearchString.length);
+
+  let controller = Cc["@mozilla.org/autocomplete/controller;1"].
+                   getService(Ci.nsIAutoCompleteController);
+  controller.input = input;
+  controller.startSearch(aSearchString);
+
+  input.onSearchComplete = function onSearchComplete() {
+    aOnCompleteCallback(controller);
+
+    unregisterAutoCompleteSearch(search);
+    run_next_test();
+  };
+}
diff --git a/toolkit/components/autocomplete/tests/unit/test_finalCompleteValue_forceComplete.js b/toolkit/components/autocomplete/tests/unit/test_finalCompleteValue_forceComplete.js
new file mode 100644
index 000000000..5642d3e3e
--- /dev/null
+++ b/toolkit/components/autocomplete/tests/unit/test_finalCompleteValue_forceComplete.js
@@ -0,0 +1,104 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+function AutoCompleteResult(aValues, aFinalCompleteValues) {
+  this._values = aValues;
+  this._finalCompleteValues = aFinalCompleteValues;
+  this.defaultIndex = 0;
+}
+AutoCompleteResult.prototype = Object.create(AutoCompleteResultBase.prototype);
+
+function AutoCompleteInput(aSearches) {
+  this.searches = aSearches;
+  this.popup.selectedIndex = -1;
+}
+AutoCompleteInput.prototype = Object.create(AutoCompleteInputBase.prototype);
+
+function run_test() {
+  run_next_test();
+}
+
+add_test(function test_handleEnterWithDirectMatchCompleteSelectedIndex() {
+  doSearch("moz", "mozilla.com", "http://www.mozilla.com",
+    { forceComplete: true, completeSelectedIndex: true }, function(aController) {
+    do_check_eq(aController.input.textValue, "moz");
+    do_check_eq(aController.getFinalCompleteValueAt(0), "http://www.mozilla.com");
+    aController.handleEnter(false);
+    // After enter the final complete value should be shown in the input.
+    do_check_eq(aController.input.textValue, "http://www.mozilla.com");
+  });
+});
+
+add_test(function test_handleEnterWithDirectMatch() {
+  doSearch("mozilla", "mozilla.com", "http://www.mozilla.com",
+    { forceComplete: true, completeDefaultIndex: true }, function(aController) {
+    // Should autocomplete the search string to a suggestion.
+    do_check_eq(aController.input.textValue, "mozilla.com");
+    do_check_eq(aController.getFinalCompleteValueAt(0), "http://www.mozilla.com");
+    aController.handleEnter(false);
+    // After enter the final complete value should be shown in the input.
+    do_check_eq(aController.input.textValue, "http://www.mozilla.com");
+  });
+});
+
+add_test(function test_handleEnterWithNoMatch() {
+  doSearch("mozilla", "mozilla.com", "http://www.mozilla.com",
+    { forceComplete: true, completeDefaultIndex: true }, function(aController) {
+    // Should autocomplete the search string to a suggestion.
+    do_check_eq(aController.input.textValue, "mozilla.com");
+    do_check_eq(aController.getFinalCompleteValueAt(0), "http://www.mozilla.com");
+    // Now input something that does not match...
+    aController.input.textValue = "mozillax";
+    // ... and confirm. We don't want one of the values from the previous
+    // results to be taken, since what's now in the input field doesn't match.
+    aController.handleEnter(false);
+    do_check_eq(aController.input.textValue, "mozillax");
+  });
+});
+
+add_test(function test_handleEnterWithIndirectMatch() {
+  doSearch("com", "mozilla.com", "http://www.mozilla.com",
+    { forceComplete: true, completeDefaultIndex: true }, function(aController) {
+    // Should autocomplete the search string to a suggestion.
+    do_check_eq(aController.input.textValue, "com >> mozilla.com");
+    do_check_eq(aController.getFinalCompleteValueAt(0), "http://www.mozilla.com");
+    aController.handleEnter(false);
+    // After enter the final complete value from the suggestion should be shown
+    // in the input.
+    do_check_eq(aController.input.textValue, "http://www.mozilla.com");
+  });
+});
+
+function doSearch(aSearchString, aResultValue, aFinalCompleteValue,
+                  aInputProps, aOnCompleteCallback) {
+  let search = new AutoCompleteSearchBase(
+    "search",
+    new AutoCompleteResult([ aResultValue ], [ aFinalCompleteValue ])
+  );
+  registerAutoCompleteSearch(search);
+
+  let controller = Cc["@mozilla.org/autocomplete/controller;1"].
+                   getService(Ci.nsIAutoCompleteController);
+
+  // Make an AutoCompleteInput that uses our searches and confirms results.
+  let input = new AutoCompleteInput([ search.name ]);
+  for (var p in aInputProps) {
+    input[p] = aInputProps[p];
+  }
+  input.textValue = aSearchString;
+  // Place the cursor at the end of the input so that completion to
+  // default index will kick in.
+  input.selectTextRange(aSearchString.length, aSearchString.length);
+
+  controller.input = input;
+  controller.startSearch(aSearchString);
+
+  input.onSearchComplete = function onSearchComplete() {
+    aOnCompleteCallback(controller);
+
+    // Clean up.
+    unregisterAutoCompleteSearch(search);
+    run_next_test();
+  };
+}
diff --git a/toolkit/components/autocomplete/tests/unit/test_finalDefaultCompleteValue.js b/toolkit/components/autocomplete/tests/unit/test_finalDefaultCompleteValue.js
new file mode 100644
index 000000000..c983d969b
--- /dev/null
+++ b/toolkit/components/autocomplete/tests/unit/test_finalDefaultCompleteValue.js
@@ -0,0 +1,66 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+function AutoCompleteResult(aValues, aFinalCompleteValues) {
+  this._values = aValues;
+  this._finalCompleteValues = aFinalCompleteValues;
+  this.defaultIndex = 0;
+}
+AutoCompleteResult.prototype = Object.create(AutoCompleteResultBase.prototype);
+
+function AutoCompleteInput(aSearches) {
+  this.searches = aSearches;
+  this.popup.selectedIndex = -1;
+  this.completeDefaultIndex = true;
+}
+AutoCompleteInput.prototype = Object.create(AutoCompleteInputBase.prototype);
+
+function run_test() {
+  run_next_test();
+}
+
+add_test(function test_keyNavigation() {
+  doSearch("moz", "mozilla.com", "http://www.mozilla.com", function(aController) {
+    do_check_eq(aController.input.textValue, "mozilla.com");
+    aController.handleKeyNavigation(Ci.nsIDOMKeyEvent.DOM_VK_RIGHT);
+    do_check_eq(aController.input.textValue, "mozilla.com");
+  });
+});
+
+add_test(function test_handleEnter() {
+  doSearch("moz", "mozilla.com", "http://www.mozilla.com", function(aController) {
+    do_check_eq(aController.input.textValue, "mozilla.com");
+    aController.handleEnter(false);
+    do_check_eq(aController.input.textValue, "http://www.mozilla.com");
+  });
+});
+
+function doSearch(aSearchString, aResultValue, aFinalCompleteValue, aOnCompleteCallback) {
+  let search = new AutoCompleteSearchBase(
+    "search",
+    new AutoCompleteResult([ aResultValue ], [ aFinalCompleteValue ])
+  );
+  registerAutoCompleteSearch(search);
+
+  let controller = Cc["@mozilla.org/autocomplete/controller;1"].
+                   getService(Ci.nsIAutoCompleteController);
+
+  // Make an AutoCompleteInput that uses our searches and confirms results.
+  let input = new AutoCompleteInput([ search.name ]);
+  input.textValue = aSearchString;
+
+  // Caret must be at the end for autofill to happen.
+  let strLen = aSearchString.length;
+  input.selectTextRange(strLen, strLen);
+  controller.input = input;
+  controller.startSearch(aSearchString);
+
+  input.onSearchComplete = function onSearchComplete() {
+    aOnCompleteCallback(controller);
+
+    // Clean up.
+    unregisterAutoCompleteSearch(search);
+    run_next_test();
+  };
+}
diff --git a/toolkit/components/autocomplete/tests/unit/test_immediate_search.js b/toolkit/components/autocomplete/tests/unit/test_immediate_search.js
new file mode 100644
index 000000000..0579f5dcb
--- /dev/null
+++ b/toolkit/components/autocomplete/tests/unit/test_immediate_search.js
@@ -0,0 +1,157 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+
+function AutoCompleteImmediateSearch(aName, aResult) {
+  this.name = aName;
+  this._result = aResult;
+}
+AutoCompleteImmediateSearch.prototype = Object.create(AutoCompleteSearchBase.prototype);
+AutoCompleteImmediateSearch.prototype.searchType =
+  Ci.nsIAutoCompleteSearchDescriptor.SEARCH_TYPE_IMMEDIATE;
+AutoCompleteImmediateSearch.prototype.QueryInterface =
+  XPCOMUtils.generateQI([Ci.nsIFactory,
+                         Ci.nsIAutoCompleteSearch,
+                         Ci.nsIAutoCompleteSearchDescriptor]);
+
+function AutoCompleteDelayedSearch(aName, aResult) {
+  this.name = aName;
+  this._result = aResult;
+}
+AutoCompleteDelayedSearch.prototype = Object.create(AutoCompleteSearchBase.prototype);
+
+function AutoCompleteResult(aValues, aDefaultIndex) {
+  this._values = aValues;
+  this.defaultIndex = aDefaultIndex;
+}
+AutoCompleteResult.prototype = Object.create(AutoCompleteResultBase.prototype);
+
+function run_test() {
+  run_next_test();
+}
+
+/**
+ * An immediate search should be executed synchronously.
+ */
+add_test(function test_immediate_search() {
+  let inputStr = "moz";
+
+  let immediateSearch = new AutoCompleteImmediateSearch(
+    "immediate", new AutoCompleteResult(["moz-immediate"], 0));
+  registerAutoCompleteSearch(immediateSearch);
+  let delayedSearch = new AutoCompleteDelayedSearch(
+    "delayed", new AutoCompleteResult(["moz-delayed"], 0));
+  registerAutoCompleteSearch(delayedSearch);
+
+  let controller = Cc["@mozilla.org/autocomplete/controller;1"].
+                   getService(Ci.nsIAutoCompleteController);
+
+  let input = new AutoCompleteInputBase([delayedSearch.name,
+                                         immediateSearch.name]);
+  input.completeDefaultIndex = true;
+  input.textValue = inputStr;
+
+  // Caret must be at the end. Autofill doesn't happen unless you're typing
+  // characters at the end.
+  let strLen = inputStr.length;
+  input.selectTextRange(strLen, strLen);
+
+  controller.input = input;
+  controller.startSearch(inputStr);
+
+  // Immediately check the result, the immediate search should have finished.
+  do_check_eq(input.textValue, "moz-immediate");
+
+  // Wait for both queries to finish.
+  input.onSearchComplete = function() {
+    // Sanity check.
+    do_check_eq(input.textValue, "moz-immediate");
+
+    unregisterAutoCompleteSearch(immediateSearch);
+    unregisterAutoCompleteSearch(delayedSearch);
+    run_next_test();
+  };
+});
+
+/**
+ * An immediate search should be executed before any delayed search.
+ */
+add_test(function test_immediate_search_notimeout() {
+  let inputStr = "moz";
+
+  let immediateSearch = new AutoCompleteImmediateSearch(
+    "immediate", new AutoCompleteResult(["moz-immediate"], 0));
+  registerAutoCompleteSearch(immediateSearch);
+
+  let delayedSearch = new AutoCompleteDelayedSearch(
+    "delayed", new AutoCompleteResult(["moz-delayed"], 0));
+  registerAutoCompleteSearch(delayedSearch);
+
+  let controller = Cc["@mozilla.org/autocomplete/controller;1"].
+                   getService(Ci.nsIAutoCompleteController);
+
+  let input = new AutoCompleteInputBase([delayedSearch.name,
+                                         immediateSearch.name]);
+  input.completeDefaultIndex = true;
+  input.textValue = inputStr;
+  input.timeout = 0;
+
+  // Caret must be at the end. Autofill doesn't happen unless you're typing
+  // characters at the end.
+  let strLen = inputStr.length;
+  input.selectTextRange(strLen, strLen);
+
+  controller.input = input;
+  let complete = false;
+  input.onSearchComplete = function() {
+    complete = true;
+  };
+  controller.startSearch(inputStr);
+  do_check_true(complete);
+
+  // Immediately check the result, the immediate search should have finished.
+  do_check_eq(input.textValue, "moz-immediate");
+
+  unregisterAutoCompleteSearch(immediateSearch);
+  unregisterAutoCompleteSearch(delayedSearch);
+  run_next_test();
+});
+
+/**
+ * A delayed search should be executed synchronously with a zero timeout.
+ */
+add_test(function test_delayed_search_notimeout() {
+  let inputStr = "moz";
+
+  let delayedSearch = new AutoCompleteDelayedSearch(
+    "delayed", new AutoCompleteResult(["moz-delayed"], 0));
+  registerAutoCompleteSearch(delayedSearch);
+
+  let controller = Cc["@mozilla.org/autocomplete/controller;1"].
+                   getService(Ci.nsIAutoCompleteController);
+
+  let input = new AutoCompleteInputBase([delayedSearch.name]);
+  input.completeDefaultIndex = true;
+  input.textValue = inputStr;
+  input.timeout = 0;
+
+  // Caret must be at the end. Autofill doesn't happen unless you're typing
+  // characters at the end.
+  let strLen = inputStr.length;
+  input.selectTextRange(strLen, strLen);
+
+  controller.input = input;
+  let complete = false;
+  input.onSearchComplete = function() {
+    complete = true;
+  };
+  controller.startSearch(inputStr);
+  do_check_true(complete);
+
+  // Immediately check the result, the delayed search should have finished.
+  do_check_eq(input.textValue, "moz-delayed");
+
+  unregisterAutoCompleteSearch(delayedSearch);
+  run_next_test();
+});
diff --git a/toolkit/components/autocomplete/tests/unit/test_insertMatchAt.js b/toolkit/components/autocomplete/tests/unit/test_insertMatchAt.js
new file mode 100644
index 000000000..14ee388b8
--- /dev/null
+++ b/toolkit/components/autocomplete/tests/unit/test_insertMatchAt.js
@@ -0,0 +1,14 @@
+function run_test() {
+  let result = Cc["@mozilla.org/autocomplete/simple-result;1"]
+                 .createInstance(Ci.nsIAutoCompleteSimpleResult);
+  result.appendMatch("a", "");
+  result.appendMatch("c", "");
+  result.insertMatchAt(1, "b", "");
+  result.insertMatchAt(3, "d", "");
+
+  Assert.equal(result.matchCount, 4);
+  Assert.equal(result.getValueAt(0), "a");
+  Assert.equal(result.getValueAt(1), "b");
+  Assert.equal(result.getValueAt(2), "c");
+  Assert.equal(result.getValueAt(3), "d");
+}
diff --git a/toolkit/components/autocomplete/tests/unit/test_previousResult.js b/toolkit/components/autocomplete/tests/unit/test_previousResult.js
new file mode 100644
index 000000000..bfe6c7aae
--- /dev/null
+++ b/toolkit/components/autocomplete/tests/unit/test_previousResult.js
@@ -0,0 +1,280 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/**
+ * Unit test for Bug 438861 - Previous search results not returned to multiple
+ * searches.
+ */
+
+
+/**
+ * Dummy nsIAutoCompleteInput source that returns
+ * the given list of AutoCompleteSearch names.
+ *
+ * Implements only the methods needed for this test.
+ */
+function AutoCompleteInput(aSearches) {
+  this.searches = aSearches;
+}
+AutoCompleteInput.prototype = {
+  constructor: AutoCompleteInput,
+
+  // Array of AutoCompleteSearch names
+  searches: null,
+
+  minResultsForPopup: 0,
+  timeout: 10,
+  searchParam: "",
+  textValue: "",
+  disableAutoComplete: false,
+  completeDefaultIndex: false,
+
+  get searchCount() {
+    return this.searches.length;
+  },
+
+  getSearchAt: function(aIndex) {
+    return this.searches[aIndex];
+  },
+
+  onSearchBegin: function() {},
+  onSearchComplete: function() {},
+
+  popupOpen: false,
+
+  popup: {
+    setSelectedIndex: function(aIndex) {},
+    invalidate: function() {},
+
+    // nsISupports implementation
+    QueryInterface: function(iid) {
+      if (iid.equals(Ci.nsISupports) ||
+          iid.equals(Ci.nsIAutoCompletePopup))
+        return this;
+
+      throw Components.results.NS_ERROR_NO_INTERFACE;
+    }
+  },
+
+  // nsISupports implementation
+  QueryInterface: function(iid) {
+    if (iid.equals(Ci.nsISupports) ||
+        iid.equals(Ci.nsIAutoCompleteInput))
+      return this;
+
+    throw Components.results.NS_ERROR_NO_INTERFACE;
+  }
+}
+
+
+
+/**
+ * nsIAutoCompleteResult implementation
+ */
+function AutoCompleteResult(aValues, aComments, aStyles) {
+  this._values = aValues;
+  this._comments = aComments;
+  this._styles = aStyles;
+  if (this._values.length > 0) {
+    this.searchResult = Ci.nsIAutoCompleteResult.RESULT_SUCCESS;
+  } else {
+    this.searchResult = Ci.nsIAutoCompleteResult.NOMATCH;
+  }
+}
+AutoCompleteResult.prototype = {
+  constructor: AutoCompleteResult,
+
+  // Arrays
+  _values: null,
+  _comments: null,
+  _styles: null,
+
+  searchString: "",
+  searchResult: null,
+
+  defaultIndex: 0,
+
+  get matchCount() {
+    return this._values.length;
+  },
+
+  getValueAt: function(aIndex) {
+    return this._values[aIndex];
+  },
+
+  getLabelAt: function(aIndex) {
+    return this.getValueAt(aIndex);
+  },
+
+  getCommentAt: function(aIndex) {
+    return this._comments[aIndex];
+  },
+
+  getStyleAt: function(aIndex) {
+    return this._styles[aIndex];
+  },
+
+  getImageAt: function(aIndex) {
+    return "";
+  },
+
+  getFinalCompleteValueAt: function(aIndex) {
+    return this.getValueAt(aIndex);
+  },
+
+  removeValueAt: function (aRowIndex, aRemoveFromDb) {},
+
+  // nsISupports implementation
+  QueryInterface: function(iid) {
+    if (iid.equals(Ci.nsISupports) ||
+        iid.equals(Ci.nsIAutoCompleteResult))
+      return this;
+
+    throw Components.results.NS_ERROR_NO_INTERFACE;
+  }
+}
+
+
+/**
+ * nsIAutoCompleteSearch implementation that always returns
+ * the same result set.
+ */
+function AutoCompleteSearch(aName, aResult) {
+  this.name = aName;
+  this._result = aResult;
+}
+AutoCompleteSearch.prototype = {
+  constructor: AutoCompleteSearch,
+
+  // Search name. Used by AutoCompleteController
+  name: null,
+
+  // AutoCompleteResult
+  _result: null,
+
+  _previousResult: null,
+
+
+  /**
+   * Return the same result set for every search
+   */
+  startSearch: function(aSearchString,
+                        aSearchParam,
+                        aPreviousResult,
+                        aListener)
+  {
+    this._previousResult = aPreviousResult;
+    aListener.onSearchResult(this, this._result);
+  },
+
+  stopSearch: function() {},
+
+  // nsISupports implementation
+  QueryInterface: function(iid) {
+    if (iid.equals(Ci.nsISupports) ||
+        iid.equals(Ci.nsIFactory) ||
+        iid.equals(Ci.nsIAutoCompleteSearch))
+      return this;
+
+    throw Components.results.NS_ERROR_NO_INTERFACE;
+  },
+
+  // nsIFactory implementation
+  createInstance: function(outer, iid) {
+    return this.QueryInterface(iid);
+  }
+}
+
+
+/**
+ * Helper to register an AutoCompleteSearch with the given name.
+ * Allows the AutoCompleteController to find the search.
+ */
+function registerAutoCompleteSearch(aSearch) {
+  var name = "@mozilla.org/autocomplete/search;1?name=" + aSearch.name;
+
+  var uuidGenerator = Cc["@mozilla.org/uuid-generator;1"].
+                      getService(Ci.nsIUUIDGenerator);
+  var cid = uuidGenerator.generateUUID();
+
+  var desc = "Test AutoCompleteSearch";
+
+  var componentManager = Components.manager
+                                   .QueryInterface(Ci.nsIComponentRegistrar);
+  componentManager.registerFactory(cid, desc, name, aSearch);
+
+  // Keep the id on the object so we can unregister later
+  aSearch.cid = cid;
+}
+
+
+/**
+ * Helper to unregister an AutoCompleteSearch.
+ */
+function unregisterAutoCompleteSearch(aSearch) {
+  var componentManager = Components.manager
+                                   .QueryInterface(Ci.nsIComponentRegistrar);
+  componentManager.unregisterFactory(aSearch.cid, aSearch);
+}
+
+
+/**
+ */
+function run_test() {
+  // Make an AutoCompleteSearch that always returns nothing
+  var search1 = new AutoCompleteSearch("test-previous-result1",
+    new AutoCompleteResult(["hello1"], [""], [""]));
+
+  var search2 = new AutoCompleteSearch("test-previous-result2",
+    new AutoCompleteResult(["hello2"], [""], [""]));
+
+  // Register search so AutoCompleteController can find them
+  registerAutoCompleteSearch(search1);
+  registerAutoCompleteSearch(search2);
+
+  var controller = Components.classes["@mozilla.org/autocomplete/controller;1"].
+                   getService(Components.interfaces.nsIAutoCompleteController);
+
+  // Make an AutoCompleteInput that uses our search
+  // and confirms results on search complete
+  var input = new AutoCompleteInput([search1.name,
+                                     search2.name]);
+  var numSearchesStarted = 0;
+
+  input.onSearchBegin = function() {
+    numSearchesStarted++;
+  };
+
+  input.onSearchComplete = function() {
+    do_check_eq(controller.searchStatus,
+                Ci.nsIAutoCompleteController.STATUS_COMPLETE_MATCH);
+    do_check_eq(controller.matchCount, 2);
+
+    if (numSearchesStarted == 1) {
+      do_check_eq(search1._previousResult, null);
+      do_check_eq(search2._previousResult, null);
+
+      // Now start it again
+      controller.startSearch("test");
+      return;
+    }
+    do_check_neq(search1._previousResult, null);
+    do_check_neq(search2._previousResult, null);
+
+    // Unregister searches
+    unregisterAutoCompleteSearch(search1);
+    unregisterAutoCompleteSearch(search2);
+
+    do_test_finished();
+  };
+
+  controller.input = input;
+
+  // Search is asynchronous, so don't let the test finish immediately
+  do_test_pending();
+
+  controller.startSearch("test");
+}
diff --git a/toolkit/components/autocomplete/tests/unit/test_stopSearch.js b/toolkit/components/autocomplete/tests/unit/test_stopSearch.js
new file mode 100644
index 000000000..5ef3454b4
--- /dev/null
+++ b/toolkit/components/autocomplete/tests/unit/test_stopSearch.js
@@ -0,0 +1,187 @@
+/*
+ * Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+/**
+ * Purpose of the test is to check that a stopSearch call comes always before a
+ * startSearch call.
+ */
+
+Components.utils.import("resource://gre/modules/XPCOMUtils.jsm");
+
+
+/**
+ * Dummy nsIAutoCompleteInput source that returns
+ * the given list of AutoCompleteSearch names.
+ *
+ * Implements only the methods needed for this test.
+ */
+function AutoCompleteInput(aSearches)
+{
+  this.searches = aSearches;
+}
+AutoCompleteInput.prototype = {
+  constructor: AutoCompleteInput,
+  minResultsForPopup: 0,
+  timeout: 10,
+  searchParam: "",
+  textValue: "hello",
+  disableAutoComplete: false,
+  completeDefaultIndex: false,
+  set popupOpen(val) { return val; }, // ignore
+  get popupOpen() { return false; },
+  get searchCount() { return this.searches.length; },
+  getSearchAt: function(aIndex) { return this.searches[aIndex]; },
+  onSearchBegin: function() {},
+  onSearchComplete: function() {},
+  onTextReverted: function () {},
+  onTextEntered: function () {},
+  popup: {
+    selectBy: function() {},
+    invalidate: function() {},
+    set selectedIndex(val) { return val; }, // ignore
+    get selectedIndex() { return -1 },
+    QueryInterface: XPCOMUtils.generateQI([Ci.nsIAutoCompletePopup])
+  },
+  QueryInterface: XPCOMUtils.generateQI([Ci.nsIAutoCompleteInput])
+}
+
+
+/**
+ * nsIAutoCompleteSearch implementation.
+ */
+function AutoCompleteSearch(aName)
+{
+  this.name = aName;
+}
+AutoCompleteSearch.prototype = {
+  constructor: AutoCompleteSearch,
+  stopSearchInvoked: true,
+  startSearch: function(aSearchString, aSearchParam, aPreviousResult, aListener)
+  {
+    print("Check stop search has been called");
+    do_check_true(this.stopSearchInvoked);
+    this.stopSearchInvoked = false;
+  },
+  stopSearch: function()
+  {
+    this.stopSearchInvoked = true;
+  },
+  QueryInterface: XPCOMUtils.generateQI([
+    Ci.nsIFactory
+  , Ci.nsIAutoCompleteSearch
+  ]),
+  createInstance: function(outer, iid)
+  {
+    return this.QueryInterface(iid);
+  }
+}
+
+
+/**
+ * Helper to register an AutoCompleteSearch with the given name.
+ * Allows the AutoCompleteController to find the search.
+ */
+function registerAutoCompleteSearch(aSearch)
+{
+  let name = "@mozilla.org/autocomplete/search;1?name=" + aSearch.name;
+  let uuidGenerator = Cc["@mozilla.org/uuid-generator;1"].
+                      getService(Ci.nsIUUIDGenerator);
+  let cid = uuidGenerator.generateUUID();
+  let desc = "Test AutoCompleteSearch";
+  let componentManager = Components.manager
+                                   .QueryInterface(Ci.nsIComponentRegistrar);
+  componentManager.registerFactory(cid, desc, name, aSearch);
+  // Keep the id on the object so we can unregister later
+  aSearch.cid = cid;
+}
+
+
+/**
+ * Helper to unregister an AutoCompleteSearch.
+ */
+function unregisterAutoCompleteSearch(aSearch) {
+  let componentManager = Components.manager
+                                   .QueryInterface(Ci.nsIComponentRegistrar);
+  componentManager.unregisterFactory(aSearch.cid, aSearch);
+}
+
+
+var gTests = [
+  function(controller) {
+    print("handleText");
+    controller.input.textValue = "hel";
+    controller.handleText();
+  },
+  function(controller) {
+    print("handleStartComposition");
+    controller.handleStartComposition();
+  },
+  function(controller) {
+    print("handleEndComposition");
+    controller.handleEndComposition();
+    // an input event always follows compositionend event.
+    controller.handleText();
+  },
+  function(controller) {
+    print("handleEscape");
+    controller.handleEscape();
+  },
+  function(controller) {
+    print("handleEnter");
+    controller.handleEnter(false);
+  },
+  function(controller) {
+    print("handleTab");
+    controller.handleTab();
+  },
+
+  function(controller) {
+    print("handleKeyNavigation");
+    controller.handleKeyNavigation(Ci.nsIDOMKeyEvent.DOM_VK_UP);
+  },
+];
+
+
+var gSearch;
+var gCurrentTest;
+function run_test() {
+  // Make an AutoCompleteSearch that always returns nothing
+  gSearch = new AutoCompleteSearch("test");
+  registerAutoCompleteSearch(gSearch);
+
+  let controller = Cc["@mozilla.org/autocomplete/controller;1"].
+                   getService(Ci.nsIAutoCompleteController);
+
+  // Make an AutoCompleteInput that uses our search.
+  let input = new AutoCompleteInput([gSearch.name]);
+  controller.input = input;
+
+  input.onSearchBegin = function() {
+    do_execute_soon(function() {
+      gCurrentTest(controller);
+    });
+  };
+  input.onSearchComplete = function() {
+    run_next_test(controller);
+  }
+
+  // Search is asynchronous, so don't let the test finish immediately
+  do_test_pending();
+
+  run_next_test(controller);
+}
+
+function run_next_test(controller) {
+  if (gTests.length == 0) {
+    unregisterAutoCompleteSearch(gSearch);
+    controller.stopSearch();
+    controller.input = null;
+    do_test_finished();
+    return;
+  }
+
+  gCurrentTest = gTests.shift();
+  controller.startSearch("hello");
+}
diff --git a/toolkit/components/autocomplete/tests/unit/xpcshell.ini b/toolkit/components/autocomplete/tests/unit/xpcshell.ini
new file mode 100644
index 000000000..4d193965c
--- /dev/null
+++ b/toolkit/components/autocomplete/tests/unit/xpcshell.ini
@@ -0,0 +1,24 @@
+[DEFAULT]
+head = head_autocomplete.js
+tail = 
+
+[test_330578.js]
+[test_378079.js]
+[test_393191.js]
+[test_440866.js]
+[test_463023.js]
+[test_660156.js]
+[test_autocomplete_multiple.js]
+[test_autocomplete_userContextId.js]
+[test_autofillSelectedPopupIndex.js]
+[test_badDefaultIndex.js]
+[test_completeDefaultIndex_casing.js]
+[test_finalCompleteValue.js]
+[test_finalCompleteValue_defaultIndex.js]
+[test_finalCompleteValue_forceComplete.js]
+[test_finalCompleteValueSelectedIndex.js]
+[test_finalDefaultCompleteValue.js]
+[test_immediate_search.js]
+[test_insertMatchAt.js]
+[test_previousResult.js]
+[test_stopSearch.js]