The Tor Browser: toolkit/components/autocomplete/nsAutoCompleteController.cpp@129ffea94266 (annotated)

toolkit/components/autocomplete/nsAutoCompleteController.cpp@129ffea94266 (annotated)

toolkit/components/autocomplete/nsAutoCompleteController.cpp

Sat, 03 Jan 2015 20:18:00 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Sat, 03 Jan 2015 20:18:00 +0100
branch: TOR_BUG_3246
changeset 7: 129ffea94266
permissions: -rw-r--r--

Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.

 /* -*- 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;

The Tor Browser / annotate

toolkit/components/autocomplete/nsAutoCompleteController.cpp@129ffea94266 (annotated)

toolkit/components/autocomplete/nsAutoCompleteController.cpp