diff -r 000000000000 -r 6474c204b198 toolkit/components/autocomplete/nsAutoCompleteController.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/toolkit/components/autocomplete/nsAutoCompleteController.cpp	Wed Dec 31 06:09:35 2014 +0100
@@ -0,0 +1,1761 @@
+/* -*- 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 "nsIAtomService.h"
+#include "nsReadableUtils.h"
+#include "nsUnicharUtils.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=";
+
+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),
+  mBackspaced(false),
+  mPopupClosedByCompositionStart(false),
+  mCompositionState(eCompositionState_None),
+  mSearchStatus(nsAutoCompleteController::STATUS_NONE),
+  mRowCount(0),
+  mSearchesOngoing(0),
+  mSearchesFailed(0),
+  mFirstSearchResult(false),
+  mImmediateSearchesCount(0)
+{
+}
+
+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::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;
+  mDefaultIndexCompleted = false;
+  mBackspaced = false;
+  mSearchStatus = nsIAutoCompleteController::STATUS_NONE;
+  mRowCount = 0;
+  mSearchesOngoing = 0;
+
+  // Initialize our list of search objects
+  uint32_t searchCount;
+  aInput->GetSearchCount(&searchCount);
+  mResults.SetCapacity(searchCount);
+  mSearches.SetCapacity(searchCount);
+  mMatchCounts.SetLength(searchCount);
+  mImmediateSearchesCount = 0;
+
+  const char *searchCID = kAutoCompleteSearchCID;
+
+  for (uint32_t i = 0; i < searchCount; ++i) {
+    // Use the search name to create the contract id string for the search service
+    nsAutoCString searchName;
+    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.
+      uint16_t searchType = nsIAutoCompleteSearchDescriptor::SEARCH_TYPE_DELAYED;
+      nsCOMPtr<nsIAutoCompleteSearchDescriptor> searchDesc =
+        do_QueryInterface(search);
+      if (searchDesc && NS_SUCCEEDED(searchDesc->GetSearchType(&searchType)) &&
+          searchType == nsIAutoCompleteSearchDescriptor::SEARCH_TYPE_IMMEDIATE)
+        mImmediateSearchesCount++;
+    }
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteController::StartSearch(const nsAString &aSearchString)
+{
+  mSearchString = aSearchString;
+  StartSearches();
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteController::HandleText()
+{
+  // 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;
+  }
+
+  nsAutoString newValue;
+  nsCOMPtr<nsIAutoCompleteInput> input(mInput);
+  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);
+
+  // Don't search again if the new string is the same as the last search
+  // 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.
+  if (!handlingCompositionCommit && newValue.Length() > 0 &&
+      newValue.Equals(mSearchString)) {
+    return NS_OK;
+  }
+
+  // Determine if the user has removed text from the end (probably by backspacing)
+  if (newValue.Length() < mSearchString.Length() &&
+      Substring(mSearchString, 0, newValue.Length()).Equals(newValue))
+  {
+    // We need to throw away previous results so we don't try to search through them again
+    ClearResults();
+    mBackspaced = true;
+  } else
+    mBackspaced = 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;
+  }
+
+  StartSearches();
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteController::HandleEnter(bool aIsPopupSelection, bool *_retval)
+{
+  *_retval = false;
+  if (!mInput)
+    return NS_OK;
+
+  // allow the event through unless there is something selected in the popup
+  mInput->GetPopupOpen(_retval);
+  if (*_retval) {
+    nsCOMPtr<nsIAutoCompletePopup> popup;
+    mInput->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);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAutoCompleteController::HandleEscape(bool *_retval)
+{
+  *_retval = false;
+  if (!mInput)
+    return NS_OK;
+
+  // allow the event through if the popup is closed
+  mInput->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, &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))) {
+            input->SetTextValue(value);
+            input->SelectTextRange(value.Length(), value.Length());
+          }
+        } else {
+          // Nothing is selected, so fill in the last typed value
+          input->SetTextValue(mSearchString);
+          input->SelectTextRange(mSearchString.Length(), mSearchString.Length());
+        }
+      }
+    } 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;
+          }
+
+          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 (isOpen) {
+      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))) {
+          input->SetTextValue(value);
+          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.
+        // 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)) &&
+            value.Equals(inputValue, nsCaseInsensitiveStringComparator())) {
+          input->SetTextValue(value);
+          input->SelectTextRange(value.Length(), value.Length());
+        }
+      }
+      // Close the pop-up even if nothing was selected
+      ClearSearchTimer();
+      ClosePopup();
+    }
+    // Update last-searched string to the current input, since the input may
+    // have changed.  Without this, subsequent backspaces look like text
+    // additions, not text deletions.
+    nsAutoString value;
+    input->GetTextValue(value);
+    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
+    HandleText();
+    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
+    HandleText();
+    return NS_OK;
+  }
+
+  RowIndexToSearch(index, &searchIndex, &rowIndex);
+  NS_ENSURE_TRUE(searchIndex >= 0 && rowIndex >= 0, NS_ERROR_FAILURE);
+
+  nsIAutoCompleteResult *result = mResults[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();
+  } 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[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;
+}
+
+
+////////////////////////////////////////////////////////////////////////
+//// nsIAutoCompleteObserver
+
+NS_IMETHODIMP
+nsAutoCompleteController::OnUpdateSearchResult(nsIAutoCompleteSearch *aSearch, nsIAutoCompleteResult* aResult)
+{
+  ClearResults();
+  return OnSearchResult(aSearch, aResult);
+}
+
+NS_IMETHODIMP
+nsAutoCompleteController::OnSearchResult(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);
+    }
+  }
+
+  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;
+  }
+
+  bool isOpen = false;
+  mInput->GetPopupOpen(&isOpen);
+  if (!isOpen)
+    return NS_OK;
+
+  nsCOMPtr<nsIAutoCompletePopup> popup;
+  mInput->GetPopup(getter_AddRefs(popup));
+  NS_ENSURE_TRUE(popup != nullptr, NS_ERROR_FAILURE);
+  popup->SetSelectedIndex(-1);
+  return mInput->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;
+
+  for (uint32_t i = 0; i < mSearches.Length(); ++i) {
+    nsCOMPtr<nsIAutoCompleteSearch> search = mSearches[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;
+
+    rv = search->StartSearch(mSearchString, searchParam, result, static_cast<nsIAutoCompleteObserver *>(this));
+    if (NS_FAILED(rv)) {
+      ++mSearchesFailed;
+      --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;
+}
+
+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;
+
+  // Get the timeout for delayed searches.
+  uint32_t timeout;
+  mInput->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)
+{
+  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) {
+      // If completeselectedindex is false or a row was selected from the popup,
+      // enter it into the textbox. If completeselectedindex is true, or
+      // EnterMatch was called via other means, for instance pressing Enter,
+      // don't fill in the value as it will have already been filled in as
+      // needed, unless the final complete value differs.
+      nsAutoString finalValue, inputValue;
+      GetResultValueAt(selectedIndex, true, finalValue);
+      input->GetTextValue(inputValue);
+      if (!completeSelection || aIsPopupSelection ||
+          !finalValue.Equals(inputValue)) {
+        value = finalValue;
+      }
+    }
+    else if (shouldComplete) {
+      // We usually try to preserve the casing of what user has typed, but
+      // if he wants to autocomplete, we will replace the value with the
+      // actual autocomplete result.
+      // The user wants explicitely to use that result, so this ensures
+      // association of the result with the autocompleted text.
+      nsAutoString defaultIndexValue;
+      if (NS_SUCCEEDED(GetFinalDefaultCompleteValue(defaultIndexValue)))
+        value = defaultIndexValue;
+    }
+
+    if (forceComplete && value.IsEmpty()) {
+      // 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()) {
+    input->SetTextValue(value);
+    input->SelectTextRange(value.Length(), value.Length());
+    mSearchString = value;
+  }
+
+  obsSvc->NotifyObservers(input, "autocomplete-did-enter-text", nullptr);
+  ClosePopup();
+
+  bool cancel;
+  input->OnTextEntered(&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)) {
+      input->SetTextValue(oldValue);
+    }
+
+    obsSvc->NotifyObservers(input, "autocomplete-did-revert-text", nullptr);
+  }
+
+  return NS_OK;
+}
+
+nsresult
+nsAutoCompleteController::ProcessResult(int32_t aSearchIndex, nsIAutoCompleteResult *aResult)
+{
+  NS_ENSURE_STATE(mInput);
+  nsCOMPtr<nsIAutoCompleteInput> input(mInput);
+
+  // 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;
+  }
+
+  uint32_t oldMatchCount = 0;
+  uint32_t matchCount = 0;
+  if (aResult)
+    aResult->GetMatchCount(&matchCount);
+
+  int32_t resultIndex = mResults.IndexOf(aResult);
+  if (resultIndex == -1) {
+    // cache the result
+    mResults.AppendObject(aResult);
+    mMatchCounts.AppendElement(matchCount);
+    resultIndex = mResults.Count() - 1;
+  }
+  else {
+    oldMatchCount = mMatchCounts[aSearchIndex];
+    mMatchCounts[resultIndex] = matchCount;
+  }
+
+  bool isTypeAheadResult = false;
+  if (aResult) {
+    aResult->GetTypeAheadResult(&isTypeAheadResult);
+  }
+
+  if (!isTypeAheadResult) {
+    uint32_t oldRowCount = mRowCount;
+    // If the search failed, increase the match count to include the error
+    // description.
+    if (result == nsIAutoCompleteResult::RESULT_FAILURE) {
+      nsAutoString error;
+      aResult->GetErrorDescription(error);
+      if (!error.IsEmpty()) {
+        ++mRowCount;
+        if (mTree) {
+          mTree->RowCountChanged(oldRowCount, 1);
+        }
+      }
+    } else if (result == nsIAutoCompleteResult::RESULT_SUCCESS ||
+               result == nsIAutoCompleteResult::RESULT_SUCCESS_ONGOING) {
+      // Increase the match count for all matches in this result.
+      mRowCount += matchCount - oldMatchCount;
+
+      if (mTree) {
+        mTree->RowCountChanged(oldRowCount, matchCount - oldMatchCount);
+      }
+    }
+
+    // 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();
+
+    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 (result != nsIAutoCompleteResult::RESULT_NOMATCH_ONGOING) {
+      ClosePopup();
+    }
+  }
+
+  if (result == nsIAutoCompleteResult::RESULT_SUCCESS ||
+      result == nsIAutoCompleteResult::RESULT_SUCCESS_ONGOING) {
+    // Try to autocomplete the default index for this search.
+    CompleteDefaultIndex(resultIndex);
+  }
+
+  if (mSearchesOngoing == 0) {
+    // If this is the last search to return, cleanup.
+    PostSearchCleanup();
+  }
+
+  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();
+  mMatchCounts.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 || mBackspaced || mSearchString.Length() == 0 || !mInput)
+    return NS_OK;
+
+  int32_t selectionStart;
+  mInput->GetSelectionStart(&selectionStart);
+  int32_t selectionEnd;
+  mInput->GetSelectionEnd(&selectionEnd);
+
+  // 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
+  if (selectionEnd != selectionStart ||
+      selectionEnd != (int32_t)mSearchString.Length())
+    return NS_OK;
+
+  bool shouldComplete;
+  mInput->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[i];
+    if (result &&
+        NS_SUCCEEDED(result->GetDefaultIndex(_defaultIndex)) &&
+        *_defaultIndex >= 0) {
+      resultIndex = i;
+    }
+  }
+  NS_ENSURE_TRUE(resultIndex >= 0, 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");
+  nsIAutoCompleteResult *result;
+  int32_t defaultIndex = -1;
+  nsresult rv = GetDefaultCompleteResult(-1, &result, &defaultIndex);
+  if (NS_FAILED(rv)) return rv;
+
+  result->GetValueAt(defaultIndex, _retval);
+  nsAutoString inputValue;
+  mInput->GetTextValue(inputValue);
+  if (!_retval.Equals(inputValue, nsCaseInsensitiveStringComparator())) {
+    return NS_ERROR_FAILURE;
+  }
+
+  nsAutoString finalCompleteValue;
+  rv = result->GetFinalCompleteValueAt(defaultIndex, finalCompleteValue);
+  if (NS_SUCCEEDED(rv)) {
+    _retval = finalCompleteValue;
+  }
+
+  MOZ_ASSERT(FindInReadable(inputValue, _retval, nsCaseInsensitiveStringComparator()),
+             "Return value must include input value.");
+  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");
+  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.
+    mInput->SetTextValue(aValue);
+  } else {
+    nsresult rv;
+    nsCOMPtr<nsIIOService> ios = do_GetService(NS_IOSERVICE_CONTRACTID, &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+    nsAutoCString scheme;
+    if (NS_SUCCEEDED(ios->ExtractScheme(NS_ConvertUTF16toUTF8(aValue), scheme))) {
+      // Trying to autocomplete a URI from somewhere other than the beginning.
+      // Only succeed if the missing portion is "http://"; otherwise do not
+      // autocomplete.  This prevents us from "helpfully" autocompleting to a
+      // URI that isn't equivalent to what the user expected.
+      const int32_t findIndex = 7; // length of "http://"
+
+      if ((endSelect < findIndex + mSearchStringLength) ||
+          !scheme.LowerCaseEqualsLiteral("http") ||
+          !Substring(aValue, findIndex, mSearchStringLength).Equals(
+            mSearchString, nsCaseInsensitiveStringComparator())) {
+        return NS_OK;
+      }
+
+      mInput->SetTextValue(mSearchString +
+                           Substring(aValue, mSearchStringLength + findIndex,
+                                     endSelect));
+
+      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.
+      mInput->SetTextValue(mSearchString + NS_LITERAL_STRING(" >> ") + aValue);
+
+      endSelect = mSearchString.Length() + 4 + aValue.Length();
+    }
+  }
+
+  mInput->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)
+      result->GetFinalCompleteValueAt(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;
+
+    // Skip past the result completely if it is marked as hidden
+    bool isTypeAheadResult = false;
+    result->GetTypeAheadResult(&isTypeAheadResult);
+
+    if (!isTypeAheadResult) {
+      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;