The Tor Browser: comparison toolkit/components/places/nsPlacesAutoComplete.js

comparison: toolkit/components/places/nsPlacesAutoComplete.js

toolkit/components/places/nsPlacesAutoComplete.js

branch: TOR_BUG_3246
changeset 7: 129ffea94266

equal deleted inserted replaced

--1:000000000000
+:f2718fa2c5a6
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+* vim: sw=2 ts=2 sts=2 expandtab
+* 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/. */
+Components.utils.import("resource://gre/modules/XPCOMUtils.jsm");
+Components.utils.import("resource://gre/modules/Services.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "PlacesUtils",
+"resource://gre/modules/PlacesUtils.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "TelemetryStopwatch",
+"resource://gre/modules/TelemetryStopwatch.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "NetUtil",
+"resource://gre/modules/NetUtil.jsm");
+////////////////////////////////////////////////////////////////////////////////
+//// Constants
+const Cc = Components.classes;
+const Ci = Components.interfaces;
+const Cr = Components.results;
+// This SQL query fragment provides the following:
+//   - whether the entry is bookmarked (kQueryIndexBookmarked)
+//   - the bookmark title, if it is a bookmark (kQueryIndexBookmarkTitle)
+//   - the tags associated with a bookmarked entry (kQueryIndexTags)
+const kBookTagSQLFragment =
+"EXISTS(SELECT 1 FROM moz_bookmarks WHERE fk = h.id) AS bookmarked, "
++ "( "
++   "SELECT title FROM moz_bookmarks WHERE fk = h.id AND title NOTNULL "
++   "ORDER BY lastModified DESC LIMIT 1 "
++ ") AS btitle, "
++ "( "
++   "SELECT GROUP_CONCAT(t.title, ',') "
++   "FROM moz_bookmarks b "
++   "JOIN moz_bookmarks t ON t.id = +b.parent AND t.parent = :parent "
++   "WHERE b.fk = h.id "
++ ") AS tags";
+// observer topics
+const kTopicShutdown = "places-shutdown";
+const kPrefChanged = "nsPref:changed";
+// Match type constants.  These indicate what type of search function we should
+// be using.
+const MATCH_ANYWHERE = Ci.mozIPlacesAutoComplete.MATCH_ANYWHERE;
+const MATCH_BOUNDARY_ANYWHERE = Ci.mozIPlacesAutoComplete.MATCH_BOUNDARY_ANYWHERE;
+const MATCH_BOUNDARY = Ci.mozIPlacesAutoComplete.MATCH_BOUNDARY;
+const MATCH_BEGINNING = Ci.mozIPlacesAutoComplete.MATCH_BEGINNING;
+const MATCH_BEGINNING_CASE_SENSITIVE = Ci.mozIPlacesAutoComplete.MATCH_BEGINNING_CASE_SENSITIVE;
+// AutoComplete index constants.  All AutoComplete queries will provide these
+// columns in this order.
+const kQueryIndexURL = 0;
+const kQueryIndexTitle = 1;
+const kQueryIndexFaviconURL = 2;
+const kQueryIndexBookmarked = 3;
+const kQueryIndexBookmarkTitle = 4;
+const kQueryIndexTags = 5;
+const kQueryIndexVisitCount = 6;
+const kQueryIndexTyped = 7;
+const kQueryIndexPlaceId = 8;
+const kQueryIndexQueryType = 9;
+const kQueryIndexOpenPageCount = 10;
+// AutoComplete query type constants.  Describes the various types of queries
+// that we can process.
+const kQueryTypeKeyword = 0;
+const kQueryTypeFiltered = 1;
+// This separator is used as an RTL-friendly way to split the title and tags.
+// It can also be used by an nsIAutoCompleteResult consumer to re-split the
+// "comment" back into the title and the tag.
+const kTitleTagsSeparator = " \u2013 ";
+const kBrowserUrlbarBranch = "browser.urlbar.";
+// Toggle autocomplete.
+const kBrowserUrlbarAutocompleteEnabledPref = "autocomplete.enabled";
+// Toggle autoFill.
+const kBrowserUrlbarAutofillPref = "autoFill";
+// Whether to search only typed entries.
+const kBrowserUrlbarAutofillTypedPref = "autoFill.typed";
+// The Telemetry histogram for urlInlineComplete query on domain
+const DOMAIN_QUERY_TELEMETRY = "PLACES_AUTOCOMPLETE_URLINLINE_DOMAIN_QUERY_TIME_MS";
+////////////////////////////////////////////////////////////////////////////////
+//// Globals
+XPCOMUtils.defineLazyServiceGetter(this, "gTextURIService",
+"@mozilla.org/intl/texttosuburi;1",
+"nsITextToSubURI");
+////////////////////////////////////////////////////////////////////////////////
+//// Helpers
+/**
+* Initializes our temporary table on a given database.
+*
+* @param aDatabase
+*        The mozIStorageConnection to set up the temp table on.
+*/
+function initTempTable(aDatabase)
+{
+// Note: this should be kept up-to-date with the definition in
+//       nsPlacesTables.h.
+let stmt = aDatabase.createAsyncStatement(
+"CREATE TEMP TABLE moz_openpages_temp ( "
++ "  url TEXT PRIMARY KEY "
++ ", open_count INTEGER "
++ ") "
+);
+stmt.executeAsync();
+stmt.finalize();
+// Note: this should be kept up-to-date with the definition in
+//       nsPlacesTriggers.h.
+stmt = aDatabase.createAsyncStatement(
+"CREATE TEMPORARY TRIGGER moz_openpages_temp_afterupdate_trigger "
++ "AFTER UPDATE OF open_count ON moz_openpages_temp FOR EACH ROW "
++ "WHEN NEW.open_count = 0 "
++ "BEGIN "
++   "DELETE FROM moz_openpages_temp "
++   "WHERE url = NEW.url; "
++ "END "
+);
+stmt.executeAsync();
+stmt.finalize();
+}
+/**
+* Used to unescape encoded URI strings, and drop information that we do not
+* care about for searching.
+*
+* @param aURIString
+*        The text to unescape and modify.
+* @return the modified uri.
+*/
+function fixupSearchText(aURIString)
+{
+let uri = stripPrefix(aURIString);
+return gTextURIService.unEscapeURIForUI("UTF-8", uri);
+}
+/**
+* Strip prefixes from the URI that we don't care about for searching.
+*
+* @param aURIString
+*        The text to modify.
+* @return the modified uri.
+*/
+function stripPrefix(aURIString)
+{
+let uri = aURIString;
+if (uri.indexOf("http://") == 0) {
+uri = uri.slice(7);
+}
+else if (uri.indexOf("https://") == 0) {
+uri = uri.slice(8);
+}
+else if (uri.indexOf("ftp://") == 0) {
+uri = uri.slice(6);
+}
+if (uri.indexOf("www.") == 0) {
+uri = uri.slice(4);
+}
+return uri;
+}
+/**
+* safePrefGetter get the pref with typo safety.
+* This will return the default value provided if no pref is set.
+*
+* @param aPrefBranch
+*        The nsIPrefBranch containing the required preference
+* @param aName
+*        A preference name
+* @param aDefault
+*        The preference's default value
+* @return the preference value or provided default
+*/
+function safePrefGetter(aPrefBranch, aName, aDefault) {
+let types = {
+boolean: "Bool",
+number: "Int",
+string: "Char"
+};
+let type = types[typeof(aDefault)];
+if (!type) {
+throw "Unknown type!";
+}
+// If the pref isn't set, we want to use the default.
+try {
+return aPrefBranch["get" + type + "Pref"](aName);
+}
+catch (e) {
+return aDefault;
+}
+}
+////////////////////////////////////////////////////////////////////////////////
+//// AutoCompleteStatementCallbackWrapper class
+/**
+* Wraps a callback and ensures that handleCompletion is not dispatched if the
+* query is no longer tracked.
+*
+* @param aAutocomplete
+*        A reference to a nsPlacesAutoComplete.
+* @param aCallback
+*        A reference to a mozIStorageStatementCallback
+* @param aDBConnection
+*        The database connection to execute the queries on.
+*/
+function AutoCompleteStatementCallbackWrapper(aAutocomplete, aCallback,
+aDBConnection)
+{
+this._autocomplete = aAutocomplete;
+this._callback = aCallback;
+this._db = aDBConnection;
+}
+AutoCompleteStatementCallbackWrapper.prototype = {
+//////////////////////////////////////////////////////////////////////////////
+//// mozIStorageStatementCallback
+handleResult: function ACSCW_handleResult(aResultSet)
+{
+this._callback.handleResult.apply(this._callback, arguments);
+},
+handleError: function ACSCW_handleError(aError)
+{
+this._callback.handleError.apply(this._callback, arguments);
+},
+handleCompletion: function ACSCW_handleCompletion(aReason)
+{
+// Only dispatch handleCompletion if we are not done searching and are a
+// pending search.
+if (!this._autocomplete.isSearchComplete() &&
+this._autocomplete.isPendingSearch(this._handle)) {
+this._callback.handleCompletion.apply(this._callback, arguments);
+}
+},
+//////////////////////////////////////////////////////////////////////////////
+//// AutoCompleteStatementCallbackWrapper
+/**
+* Executes the specified query asynchronously.  This object will notify
+* this._callback if we should notify (logic explained in handleCompletion).
+*
+* @param aQueries
+*        The queries to execute asynchronously.
+* @return a mozIStoragePendingStatement that can be used to cancel the
+*         queries.
+*/
+executeAsync: function ACSCW_executeAsync(aQueries)
+{
+return this._handle = this._db.executeAsync(aQueries, aQueries.length,
+this);
+},
+//////////////////////////////////////////////////////////////////////////////
+//// nsISupports
+QueryInterface: XPCOMUtils.generateQI([
+Ci.mozIStorageStatementCallback,
+])
+};
+////////////////////////////////////////////////////////////////////////////////
+//// nsPlacesAutoComplete class
+//// @mozilla.org/autocomplete/search;1?name=history
+function nsPlacesAutoComplete()
+{
+//////////////////////////////////////////////////////////////////////////////
+//// Shared Constants for Smart Getters
+// TODO bug 412736 in case of a frecency tie, break it with h.typed and
+// h.visit_count which is better than nothing.  This is slow, so not doing it
+// yet...
+const SQL_BASE = "SELECT h.url, h.title, f.url, " + kBookTagSQLFragment + ", "
++        "h.visit_count, h.typed, h.id, :query_type, "
++        "t.open_count "
++ "FROM moz_places h "
++ "LEFT JOIN moz_favicons f ON f.id = h.favicon_id "
++ "LEFT JOIN moz_openpages_temp t ON t.url = h.url "
++ "WHERE h.frecency <> 0 "
++   "AND AUTOCOMPLETE_MATCH(:searchString, h.url, "
++                          "IFNULL(btitle, h.title), tags, "
++                          "h.visit_count, h.typed, "
++                          "bookmarked, t.open_count, "
++                          ":matchBehavior, :searchBehavior) "
++  "{ADDITIONAL_CONDITIONS} "
++ "ORDER BY h.frecency DESC, h.id DESC "
++ "LIMIT :maxResults";
+//////////////////////////////////////////////////////////////////////////////
+//// Smart Getters
+XPCOMUtils.defineLazyGetter(this, "_db", function() {
+// Get a cloned, read-only version of the database.  We'll only ever write
+// to our own in-memory temp table, and having a cloned copy means we do not
+// run the risk of our queries taking longer due to the main database
+// connection performing a long-running task.
+let db = PlacesUtils.history.DBConnection.clone(true);
+// Autocomplete often fallbacks to a table scan due to lack of text indices.
+// In such cases a larger cache helps reducing IO.  The default Storage
+// value is MAX_CACHE_SIZE_BYTES in storage/src/mozStorageConnection.cpp.
+let stmt = db.createAsyncStatement("PRAGMA cache_size = -6144"); // 6MiB
+stmt.executeAsync();
+stmt.finalize();
+// Create our in-memory tables for tab tracking.
+initTempTable(db);
+// Populate the table with current open pages cache contents.
+if (this._openPagesCache.length > 0) {
+// Avoid getter re-entrance from the _registerOpenPageQuery lazy getter.
+let stmt = this._registerOpenPageQuery =
+db.createAsyncStatement(this._registerOpenPageQuerySQL);
+let params = stmt.newBindingParamsArray();
+for (let i = 0; i < this._openPagesCache.length; i++) {
+let bp = params.newBindingParams();
+bp.bindByName("page_url", this._openPagesCache[i]);
+params.addParams(bp);
+}
+stmt.bindParameters(params);
+stmt.executeAsync();
+stmt.finalize();
+delete this._openPagesCache;
+}
+return db;
+});
+XPCOMUtils.defineLazyGetter(this, "_defaultQuery", function() {
+let replacementText = "";
+return this._db.createAsyncStatement(
+SQL_BASE.replace("{ADDITIONAL_CONDITIONS}", replacementText, "g")
+);
+});
+XPCOMUtils.defineLazyGetter(this, "_historyQuery", function() {
+// Enforce ignoring the visit_count index, since the frecency one is much
+// faster in this case.  ANALYZE helps the query planner to figure out the
+// faster path, but it may not have run yet.
+let replacementText = "AND +h.visit_count > 0";
+return this._db.createAsyncStatement(
+SQL_BASE.replace("{ADDITIONAL_CONDITIONS}", replacementText, "g")
+);
+});
+XPCOMUtils.defineLazyGetter(this, "_bookmarkQuery", function() {
+let replacementText = "AND bookmarked";
+return this._db.createAsyncStatement(
+SQL_BASE.replace("{ADDITIONAL_CONDITIONS}", replacementText, "g")
+);
+});
+XPCOMUtils.defineLazyGetter(this, "_tagsQuery", function() {
+let replacementText = "AND tags IS NOT NULL";
+return this._db.createAsyncStatement(
+SQL_BASE.replace("{ADDITIONAL_CONDITIONS}", replacementText, "g")
+);
+});
+XPCOMUtils.defineLazyGetter(this, "_openPagesQuery", function() {
+return this._db.createAsyncStatement(
+"SELECT t.url, t.url, NULL, NULL, NULL, NULL, NULL, NULL, NULL, "
++         ":query_type, t.open_count, NULL "
++ "FROM moz_openpages_temp t "
++ "LEFT JOIN moz_places h ON h.url = t.url "
++ "WHERE h.id IS NULL "
++   "AND AUTOCOMPLETE_MATCH(:searchString, t.url, t.url, NULL, "
++                          "NULL, NULL, NULL, t.open_count, "
++                          ":matchBehavior, :searchBehavior) "
++ "ORDER BY t.ROWID DESC "
++ "LIMIT :maxResults "
+);
+});
+XPCOMUtils.defineLazyGetter(this, "_typedQuery", function() {
+let replacementText = "AND h.typed = 1";
+return this._db.createAsyncStatement(
+SQL_BASE.replace("{ADDITIONAL_CONDITIONS}", replacementText, "g")
+);
+});
+XPCOMUtils.defineLazyGetter(this, "_adaptiveQuery", function() {
+return this._db.createAsyncStatement(
+"/* do not warn (bug 487789) */ "
++ "SELECT h.url, h.title, f.url, " + kBookTagSQLFragment + ", "
++         "h.visit_count, h.typed, h.id, :query_type, t.open_count "
++ "FROM ( "
++ "SELECT ROUND( "
++     "MAX(use_count) * (1 + (input = :search_string)), 1 "
++   ") AS rank, place_id "
++   "FROM moz_inputhistory "
++   "WHERE input BETWEEN :search_string AND :search_string || X'FFFF' "
++   "GROUP BY place_id "
++ ") AS i "
++ "JOIN moz_places h ON h.id = i.place_id "
++ "LEFT JOIN moz_favicons f ON f.id = h.favicon_id "
++ "LEFT JOIN moz_openpages_temp t ON t.url = h.url "
++ "WHERE AUTOCOMPLETE_MATCH(NULL, h.url, "
++                          "IFNULL(btitle, h.title), tags, "
++                          "h.visit_count, h.typed, bookmarked, "
++                          "t.open_count, "
++                          ":matchBehavior, :searchBehavior) "
++ "ORDER BY rank DESC, h.frecency DESC "
+);
+});
+XPCOMUtils.defineLazyGetter(this, "_keywordQuery", function() {
+return this._db.createAsyncStatement(
+"/* do not warn (bug 487787) */ "
++ "SELECT "
++  "(SELECT REPLACE(url, '%s', :query_string) FROM moz_places WHERE id = b.fk) "
++  "AS search_url, h.title, "
++  "IFNULL(f.url, (SELECT f.url "
++                 "FROM moz_places "
++                 "JOIN moz_favicons f ON f.id = favicon_id "
++                 "WHERE rev_host = (SELECT rev_host FROM moz_places WHERE id = b.fk) "
++                 "ORDER BY frecency DESC "
++                 "LIMIT 1) "
++ "), 1, b.title, NULL, h.visit_count, h.typed, IFNULL(h.id, b.fk), "
++  ":query_type, t.open_count "
++  "FROM moz_keywords k "
++  "JOIN moz_bookmarks b ON b.keyword_id = k.id "
++  "LEFT JOIN moz_places h ON h.url = search_url "
++  "LEFT JOIN moz_favicons f ON f.id = h.favicon_id "
++  "LEFT JOIN moz_openpages_temp t ON t.url = search_url "
++  "WHERE LOWER(k.keyword) = LOWER(:keyword) "
++  "ORDER BY h.frecency DESC "
+);
+});
+this._registerOpenPageQuerySQL = "INSERT OR REPLACE INTO moz_openpages_temp "
++   "(url, open_count) "
++ "VALUES (:page_url, "
++   "IFNULL("
++     "("
++        "SELECT open_count + 1 "
++        "FROM moz_openpages_temp "
++        "WHERE url = :page_url "
++      "), "
++     "1"
++   ")"
++ ")";
+XPCOMUtils.defineLazyGetter(this, "_registerOpenPageQuery", function() {
+return this._db.createAsyncStatement(this._registerOpenPageQuerySQL);
+});
+XPCOMUtils.defineLazyGetter(this, "_unregisterOpenPageQuery", function() {
+return this._db.createAsyncStatement(
+"UPDATE moz_openpages_temp "
++ "SET open_count = open_count - 1 "
++ "WHERE url = :page_url"
+);
+});
+//////////////////////////////////////////////////////////////////////////////
+//// Initialization
+// load preferences
+this._prefs = Cc["@mozilla.org/preferences-service;1"].
+getService(Ci.nsIPrefService).
+getBranch(kBrowserUrlbarBranch);
+this._loadPrefs(true);
+// register observers
+this._os = Cc["@mozilla.org/observer-service;1"].
+getService(Ci.nsIObserverService);
+this._os.addObserver(this, kTopicShutdown, false);
+}
+nsPlacesAutoComplete.prototype = {
+//////////////////////////////////////////////////////////////////////////////
+//// nsIAutoCompleteSearch
+startSearch: function PAC_startSearch(aSearchString, aSearchParam,
+aPreviousResult, aListener)
+{
+// Stop the search in case the controller has not taken care of it.
+this.stopSearch();
+// Note: We don't use aPreviousResult to make sure ordering of results are
+//       consistent.  See bug 412730 for more details.
+// We want to store the original string with no leading or trailing
+// whitespace for case sensitive searches.
+this._originalSearchString = aSearchString.trim();
+this._currentSearchString =
+fixupSearchText(this._originalSearchString.toLowerCase());
+let searchParamParts = aSearchParam.split(" ");
+this._enableActions = searchParamParts.indexOf("enable-actions") != -1;
+this._listener = aListener;
+let result = Cc["@mozilla.org/autocomplete/simple-result;1"].
+createInstance(Ci.nsIAutoCompleteSimpleResult);
+result.setSearchString(aSearchString);
+result.setListener(this);
+this._result = result;
+// If we are not enabled, we need to return now.
+if (!this._enabled) {
+this._finishSearch(true);
+return;
+}
+// Reset our search behavior to the default.
+if (this._currentSearchString) {
+this._behavior = this._defaultBehavior;
+}
+else {
+this._behavior = this._emptySearchDefaultBehavior;
+}
+// For any given search, we run up to four queries:
+// 1) keywords (this._keywordQuery)
+// 2) adaptive learning (this._adaptiveQuery)
+// 3) open pages not supported by history (this._openPagesQuery)
+// 4) query from this._getSearch
+// (1) only gets ran if we get any filtered tokens from this._getSearch,
+// since if there are no tokens, there is nothing to match, so there is no
+// reason to run the query).
+let {query, tokens} =
+this._getSearch(this._getUnfilteredSearchTokens(this._currentSearchString));
+let queries = tokens.length ?
+[this._getBoundKeywordQuery(tokens), this._getBoundAdaptiveQuery(), this._getBoundOpenPagesQuery(tokens), query] :
+[this._getBoundAdaptiveQuery(), this._getBoundOpenPagesQuery(tokens), query];
+// Start executing our queries.
+this._telemetryStartTime = Date.now();
+this._executeQueries(queries);
+// Set up our persistent state for the duration of the search.
+this._searchTokens = tokens;
+this._usedPlaces = {};
+},
+stopSearch: function PAC_stopSearch()
+{
+// We need to cancel our searches so we do not get any [more] results.
+// However, it's possible we haven't actually started any searches, so this
+// method may throw because this._pendingQuery may be undefined.
+if (this._pendingQuery) {
+this._stopActiveQuery();
+}
+this._finishSearch(false);
+},
+//////////////////////////////////////////////////////////////////////////////
+//// nsIAutoCompleteSimpleResultListener
+onValueRemoved: function PAC_onValueRemoved(aResult, aURISpec, aRemoveFromDB)
+{
+if (aRemoveFromDB) {
+PlacesUtils.history.removePage(NetUtil.newURI(aURISpec));
+}
+},
+//////////////////////////////////////////////////////////////////////////////
+//// mozIPlacesAutoComplete
+// If the connection has not yet been started, use this local cache.  This
+// prevents autocomplete from initing the database till the first search.
+_openPagesCache: [],
+registerOpenPage: function PAC_registerOpenPage(aURI)
+{
+if (!this._databaseInitialized) {
+this._openPagesCache.push(aURI.spec);
+return;
+}
+let stmt = this._registerOpenPageQuery;
+stmt.params.page_url = aURI.spec;
+stmt.executeAsync();
+},
+unregisterOpenPage: function PAC_unregisterOpenPage(aURI)
+{
+if (!this._databaseInitialized) {
+let index = this._openPagesCache.indexOf(aURI.spec);
+if (index != -1) {
+this._openPagesCache.splice(index, 1);
+}
+return;
+}
+let stmt = this._unregisterOpenPageQuery;
+stmt.params.page_url = aURI.spec;
+stmt.executeAsync();
+},
+//////////////////////////////////////////////////////////////////////////////
+//// mozIStorageStatementCallback
+handleResult: function PAC_handleResult(aResultSet)
+{
+let row, haveMatches = false;
+while ((row = aResultSet.getNextRow())) {
+let match = this._processRow(row);
+haveMatches = haveMatches || match;
+if (this._result.matchCount == this._maxRichResults) {
+// We have enough results, so stop running our search.
+this._stopActiveQuery();
+// And finish our search.
+this._finishSearch(true);
+return;
+}
+}
+// Notify about results if we've gotten them.
+if (haveMatches) {
+this._notifyResults(true);
+}
+},
+handleError: function PAC_handleError(aError)
+{
+Components.utils.reportError("Places AutoComplete: An async statement encountered an " +
+"error: " + aError.result + ", '" + aError.message + "'");
+},
+handleCompletion: function PAC_handleCompletion(aReason)
+{
+// If we have already finished our search, we should bail out early.
+if (this.isSearchComplete()) {
+return;
+}
+// If we do not have enough results, and our match type is
+// MATCH_BOUNDARY_ANYWHERE, search again with MATCH_ANYWHERE to get more
+// results.
+if (this._matchBehavior == MATCH_BOUNDARY_ANYWHERE &&
+this._result.matchCount < this._maxRichResults && !this._secondPass) {
+this._secondPass = true;
+let queries = [
+this._getBoundAdaptiveQuery(MATCH_ANYWHERE),
+this._getBoundSearchQuery(MATCH_ANYWHERE, this._searchTokens),
+];
+this._executeQueries(queries);
+return;
+}
+this._finishSearch(true);
+},
+//////////////////////////////////////////////////////////////////////////////
+//// nsIObserver
+observe: function PAC_observe(aSubject, aTopic, aData)
+{
+if (aTopic == kTopicShutdown) {
+this._os.removeObserver(this, kTopicShutdown);
+// Remove our preference observer.
+this._prefs.removeObserver("", this);
+delete this._prefs;
+// Finalize the statements that we have used.
+let stmts = [
+"_defaultQuery",
+"_historyQuery",
+"_bookmarkQuery",
+"_tagsQuery",
+"_openPagesQuery",
+"_typedQuery",
+"_adaptiveQuery",
+"_keywordQuery",
+"_registerOpenPageQuery",
+"_unregisterOpenPageQuery",
+];
+for (let i = 0; i < stmts.length; i++) {
+// We do not want to create any query we haven't already created, so
+// see if it is a getter first.
+if (Object.getOwnPropertyDescriptor(this, stmts[i]).value !== undefined) {
+this[stmts[i]].finalize();
+}
+}
+if (this._databaseInitialized) {
+this._db.asyncClose();
+}
+}
+else if (aTopic == kPrefChanged) {
+this._loadPrefs();
+}
+},
+//////////////////////////////////////////////////////////////////////////////
+//// nsPlacesAutoComplete
+get _databaseInitialized()
+Object.getOwnPropertyDescriptor(this, "_db").value !== undefined,
+/**
+* Generates the tokens used in searching from a given string.
+*
+* @param aSearchString
+*        The string to generate tokens from.
+* @return an array of tokens.
+*/
+_getUnfilteredSearchTokens: function PAC_unfilteredSearchTokens(aSearchString)
+{
+// Calling split on an empty string will return an array containing one
+// empty string.  We don't want that, as it'll break our logic, so return an
+// empty array then.
+return aSearchString.length ? aSearchString.split(" ") : [];
+},
+/**
+* Properly cleans up when searching is completed.
+*
+* @param aNotify
+*        Indicates if we should notify the AutoComplete listener about our
+*        results or not.
+*/
+_finishSearch: function PAC_finishSearch(aNotify)
+{
+// Notify about results if we are supposed to.
+if (aNotify) {
+this._notifyResults(false);
+}
+// Clear our state
+delete this._originalSearchString;
+delete this._currentSearchString;
+delete this._strippedPrefix;
+delete this._searchTokens;
+delete this._listener;
+delete this._result;
+delete this._usedPlaces;
+delete this._pendingQuery;
+this._secondPass = false;
+this._enableActions = false;
+},
+/**
+* Executes the given queries asynchronously.
+*
+* @param aQueries
+*        The queries to execute.
+*/
+_executeQueries: function PAC_executeQueries(aQueries)
+{
+// Because we might get a handleCompletion for canceled queries, we want to
+// filter out queries we no longer care about (described in the
+// handleCompletion implementation of AutoCompleteStatementCallbackWrapper).
+// Create our wrapper object and execute the queries.
+let wrapper = new AutoCompleteStatementCallbackWrapper(this, this, this._db);
+this._pendingQuery = wrapper.executeAsync(aQueries);
+},
+/**
+* Stops executing our active query.
+*/
+_stopActiveQuery: function PAC_stopActiveQuery()
+{
+this._pendingQuery.cancel();
+delete this._pendingQuery;
+},
+/**
+* Notifies the listener about results.
+*
+* @param aSearchOngoing
+*        Indicates if the search is ongoing or not.
+*/
+_notifyResults: function PAC_notifyResults(aSearchOngoing)
+{
+let result = this._result;
+let resultCode = result.matchCount ? "RESULT_SUCCESS" : "RESULT_NOMATCH";
+if (aSearchOngoing) {
+resultCode += "_ONGOING";
+}
+result.setSearchResult(Ci.nsIAutoCompleteResult[resultCode]);
+this._listener.onSearchResult(this, result);
+if (this._telemetryStartTime) {
+let elapsed = Date.now() - this._telemetryStartTime;
+if (elapsed > 50) {
+try {
+Services.telemetry
+.getHistogramById("PLACES_AUTOCOMPLETE_1ST_RESULT_TIME_MS")
+.add(elapsed);
+} catch (ex) {
+Components.utils.reportError("Unable to report telemetry.");
+}
+}
+this._telemetryStartTime = null;
+}
+},
+/**
+* Loads the preferences that we care about.
+*
+* @param [optional] aRegisterObserver
+*        Indicates if the preference observer should be added or not.  The
+*        default value is false.
+*/
+_loadPrefs: function PAC_loadPrefs(aRegisterObserver)
+{
+this._enabled = safePrefGetter(this._prefs,
+kBrowserUrlbarAutocompleteEnabledPref,
+true);
+this._matchBehavior = safePrefGetter(this._prefs,
+"matchBehavior",
+MATCH_BOUNDARY_ANYWHERE);
+this._filterJavaScript = safePrefGetter(this._prefs, "filter.javascript", true);
+this._maxRichResults = safePrefGetter(this._prefs, "maxRichResults", 25);
+this._restrictHistoryToken = safePrefGetter(this._prefs,
+"restrict.history", "^");
+this._restrictBookmarkToken = safePrefGetter(this._prefs,
+"restrict.bookmark", "*");
+this._restrictTypedToken = safePrefGetter(this._prefs, "restrict.typed", "~");
+this._restrictTagToken = safePrefGetter(this._prefs, "restrict.tag", "+");
+this._restrictOpenPageToken = safePrefGetter(this._prefs,
+"restrict.openpage", "%");
+this._matchTitleToken = safePrefGetter(this._prefs, "match.title", "#");
+this._matchURLToken = safePrefGetter(this._prefs, "match.url", "@");
+this._defaultBehavior = safePrefGetter(this._prefs, "default.behavior", 0);
+// Further restrictions to apply for "empty searches" (i.e. searches for "").
+this._emptySearchDefaultBehavior =
+this._defaultBehavior |
+safePrefGetter(this._prefs, "default.behavior.emptyRestriction",
+Ci.mozIPlacesAutoComplete.BEHAVIOR_HISTORY |
+Ci.mozIPlacesAutoComplete.BEHAVIOR_TYPED);
+// Validate matchBehavior; default to MATCH_BOUNDARY_ANYWHERE.
+if (this._matchBehavior != MATCH_ANYWHERE &&
+this._matchBehavior != MATCH_BOUNDARY &&
+this._matchBehavior != MATCH_BEGINNING) {
+this._matchBehavior = MATCH_BOUNDARY_ANYWHERE;
+}
+// register observer
+if (aRegisterObserver) {
+this._prefs.addObserver("", this, false);
+}
+},
+/**
+* Given an array of tokens, this function determines which query should be
+* ran.  It also removes any special search tokens.
+*
+* @param aTokens
+*        An array of search tokens.
+* @return an object with two properties:
+*         query: the correctly optimized, bound query to search the database
+*                with.
+*         tokens: the filtered list of tokens to search with.
+*/
+_getSearch: function PAC_getSearch(aTokens)
+{
+// Set the proper behavior so our call to _getBoundSearchQuery gives us the
+// correct query.
+for (let i = aTokens.length - 1; i >= 0; i--) {
+switch (aTokens[i]) {
+case this._restrictHistoryToken:
+this._setBehavior("history");
+break;
+case this._restrictBookmarkToken:
+this._setBehavior("bookmark");
+break;
+case this._restrictTagToken:
+this._setBehavior("tag");
+break;
+case this._restrictOpenPageToken:
+if (!this._enableActions) {
+continue;
+}
+this._setBehavior("openpage");
+break;
+case this._matchTitleToken:
+this._setBehavior("title");
+break;
+case this._matchURLToken:
+this._setBehavior("url");
+break;
+case this._restrictTypedToken:
+this._setBehavior("typed");
+break;
+default:
+// We do not want to remove the token if we did not match.
+continue;
+};
+aTokens.splice(i, 1);
+}
+// Set the right JavaScript behavior based on our preference.  Note that the
+// preference is whether or not we should filter JavaScript, and the
+// behavior is if we should search it or not.
+if (!this._filterJavaScript) {
+this._setBehavior("javascript");
+}
+return {
+query: this._getBoundSearchQuery(this._matchBehavior, aTokens),
+tokens: aTokens
+};
+},
+/**
+* Obtains the search query to be used based on the previously set search
+* behaviors (accessed by this._hasBehavior).  The query is bound and ready to
+* execute.
+*
+* @param aMatchBehavior
+*        How this query should match its tokens to the search string.
+* @param aTokens
+*        An array of search tokens.
+* @return the correctly optimized query to search the database with and the
+*         new list of tokens to search with.  The query has all the needed
+*         parameters bound, so consumers can execute it without doing any
+*         additional work.
+*/
+_getBoundSearchQuery: function PAC_getBoundSearchQuery(aMatchBehavior,
+aTokens)
+{
+// We use more optimized queries for restricted searches, so we will always
+// return the most restrictive one to the least restrictive one if more than
+// one token is found.
+// Note: "openpages" behavior is supported by the default query.
+//       _openPagesQuery instead returns only pages not supported by
+//       history and it is always executed.
+let query = this._hasBehavior("tag") ? this._tagsQuery :
+this._hasBehavior("bookmark") ? this._bookmarkQuery :
+this._hasBehavior("typed") ? this._typedQuery :
+this._hasBehavior("history") ? this._historyQuery :
+this._defaultQuery;
+// Bind the needed parameters to the query so consumers can use it.
+let (params = query.params) {
+params.parent = PlacesUtils.tagsFolderId;
+params.query_type = kQueryTypeFiltered;
+params.matchBehavior = aMatchBehavior;
+params.searchBehavior = this._behavior;
+// We only want to search the tokens that we are left with - not the
+// original search string.
+params.searchString = aTokens.join(" ");
+// Limit the query to the the maximum number of desired results.
+// This way we can avoid doing more work than needed.
+params.maxResults = this._maxRichResults;
+}
+return query;
+},
+_getBoundOpenPagesQuery: function PAC_getBoundOpenPagesQuery(aTokens)
+{
+let query = this._openPagesQuery;
+// Bind the needed parameters to the query so consumers can use it.
+let (params = query.params) {
+params.query_type = kQueryTypeFiltered;
+params.matchBehavior = this._matchBehavior;
+params.searchBehavior = this._behavior;
+// We only want to search the tokens that we are left with - not the
+// original search string.
+params.searchString = aTokens.join(" ");
+params.maxResults = this._maxRichResults;
+}
+return query;
+},
+/**
+* Obtains the keyword query with the properly bound parameters.
+*
+* @param aTokens
+*        The array of search tokens to check against.
+* @return the bound keyword query.
+*/
+_getBoundKeywordQuery: function PAC_getBoundKeywordQuery(aTokens)
+{
+// The keyword is the first word in the search string, with the parameters
+// following it.
+let searchString = this._originalSearchString;
+let queryString = "";
+let queryIndex = searchString.indexOf(" ");
+if (queryIndex != -1) {
+queryString = searchString.substring(queryIndex + 1);
+}
+// We need to escape the parameters as if they were the query in a URL
+queryString = encodeURIComponent(queryString).replace("%20", "+", "g");
+// The first word could be a keyword, so that's what we'll search.
+let keyword = aTokens[0];
+let query = this._keywordQuery;
+let (params = query.params) {
+params.keyword = keyword;
+params.query_string = queryString;
+params.query_type = kQueryTypeKeyword;
+}
+return query;
+},
+/**
+* Obtains the adaptive query with the properly bound parameters.
+*
+* @return the bound adaptive query.
+*/
+_getBoundAdaptiveQuery: function PAC_getBoundAdaptiveQuery(aMatchBehavior)
+{
+// If we were not given a match behavior, use the stored match behavior.
+if (arguments.length == 0) {
+aMatchBehavior = this._matchBehavior;
+}
+let query = this._adaptiveQuery;
+let (params = query.params) {
+params.parent = PlacesUtils.tagsFolderId;
+params.search_string = this._currentSearchString;
+params.query_type = kQueryTypeFiltered;
+params.matchBehavior = aMatchBehavior;
+params.searchBehavior = this._behavior;
+}
+return query;
+},
+/**
+* Processes a mozIStorageRow to generate the proper data for the AutoComplete
+* result.  This will add an entry to the current result if it matches the
+* criteria.
+*
+* @param aRow
+*        The row to process.
+* @return true if the row is accepted, and false if not.
+*/
+_processRow: function PAC_processRow(aRow)
+{
+// Before we do any work, make sure this entry isn't already in our results.
+let entryId = aRow.getResultByIndex(kQueryIndexPlaceId);
+let escapedEntryURL = aRow.getResultByIndex(kQueryIndexURL);
+let openPageCount = aRow.getResultByIndex(kQueryIndexOpenPageCount) || 0;
+// If actions are enabled and the page is open, add only the switch-to-tab
+// result.  Otherwise, add the normal result.
+let [url, action] = this._enableActions && openPageCount > 0 ?
+["moz-action:switchtab," + escapedEntryURL, "action "] :
+[escapedEntryURL, ""];
+if (this._inResults(entryId, url)) {
+return false;
+}
+let entryTitle = aRow.getResultByIndex(kQueryIndexTitle) || "";
+let entryFavicon = aRow.getResultByIndex(kQueryIndexFaviconURL) || "";
+let entryBookmarked = aRow.getResultByIndex(kQueryIndexBookmarked);
+let entryBookmarkTitle = entryBookmarked ?
+aRow.getResultByIndex(kQueryIndexBookmarkTitle) : null;
+let entryTags = aRow.getResultByIndex(kQueryIndexTags) || "";
+// Always prefer the bookmark title unless it is empty
+let title = entryBookmarkTitle || entryTitle;
+let style;
+if (aRow.getResultByIndex(kQueryIndexQueryType) == kQueryTypeKeyword) {
+// If we do not have a title, then we must have a keyword, so let the UI
+// know it is a keyword.  Otherwise, we found an exact page match, so just
+// show the page like a regular result.  Because the page title is likely
+// going to be more specific than the bookmark title (keyword title).
+if (!entryTitle) {
+style = "keyword";
+}
+else {
+title = entryTitle;
+}
+}
+// We will always prefer to show tags if we have them.
+let showTags = !!entryTags;
+// However, we'll act as if a page is not bookmarked or tagged if the user
+// only wants only history and not bookmarks or tags.
+if (this._hasBehavior("history") &&
+!(this._hasBehavior("bookmark") || this._hasBehavior("tag"))) {
+showTags = false;
+style = "favicon";
+}
+// If we have tags and should show them, we need to add them to the title.
+if (showTags) {
+title += kTitleTagsSeparator + entryTags;
+}
+// We have to determine the right style to display.  Tags show the tag icon,
+// bookmarks get the bookmark icon, and keywords get the keyword icon.  If
+// the result does not fall into any of those, it just gets the favicon.
+if (!style) {
+// It is possible that we already have a style set (from a keyword
+// search or because of the user's preferences), so only set it if we
+// haven't already done so.
+if (showTags) {
+style = "tag";
+}
+else if (entryBookmarked) {
+style = "bookmark";
+}
+else {
+style = "favicon";
+}
+}
+this._addToResults(entryId, url, title, entryFavicon, action + style);
+return true;
+},
+/**
+* Checks to see if the given place has already been added to the results.
+*
+* @param aPlaceId
+*        The place id to check for, may be null.
+* @param aUrl
+*        The url to check for.
+* @return true if the place has been added, false otherwise.
+*
+* @note Must check both the id and the url for a negative match, since
+*       autocomplete may run in the middle of a new page addition.  In such
+*       a case the switch-to-tab query would hash the page by url, then a
+*       next query, running after the page addition, would hash it by id.
+*       It's not possible to just rely on url though, since keywords
+*       dynamically modify the url to include their search string.
+*/
+_inResults: function PAC_inResults(aPlaceId, aUrl)
+{
+if (aPlaceId && aPlaceId in this._usedPlaces) {
+return true;
+}
+return aUrl in this._usedPlaces;
+},
+/**
+* Adds a result to the AutoComplete results.  Also tracks that we've added
+* this place_id into the result set.
+*
+* @param aPlaceId
+*        The place_id of the item to be added to the result set.  This is
+*        used by _inResults.
+* @param aURISpec
+*        The URI spec for the entry.
+* @param aTitle
+*        The title to give the entry.
+* @param aFaviconSpec
+*        The favicon to give to the entry.
+* @param aStyle
+*        Indicates how the entry should be styled when displayed.
+*/
+_addToResults: function PAC_addToResults(aPlaceId, aURISpec, aTitle,
+aFaviconSpec, aStyle)
+{
+// Add this to our internal tracker to ensure duplicates do not end up in
+// the result.  _usedPlaces is an Object that is being used as a set.
+// Not all entries have a place id, thus we fallback to the url for them.
+// We cannot use only the url since keywords entries are modified to
+// include the search string, and would be returned multiple times.  Ids
+// are faster too.
+this._usedPlaces[aPlaceId || aURISpec] = true;
+// Obtain the favicon for this URI.
+let favicon;
+if (aFaviconSpec) {
+let uri = NetUtil.newURI(aFaviconSpec);
+favicon = PlacesUtils.favicons.getFaviconLinkForIcon(uri).spec;
+}
+favicon = favicon || PlacesUtils.favicons.defaultFavicon.spec;
+this._result.appendMatch(aURISpec, aTitle, favicon, aStyle);
+},
+/**
+* Determines if the specified AutoComplete behavior is set.
+*
+* @param aType
+*        The behavior type to test for.
+* @return true if the behavior is set, false otherwise.
+*/
+_hasBehavior: function PAC_hasBehavior(aType)
+{
+return (this._behavior &
+Ci.mozIPlacesAutoComplete["BEHAVIOR_" + aType.toUpperCase()]);
+},
+/**
+* Enables the desired AutoComplete behavior.
+*
+* @param aType
+*        The behavior type to set.
+*/
+_setBehavior: function PAC_setBehavior(aType)
+{
+this._behavior |=
+Ci.mozIPlacesAutoComplete["BEHAVIOR_" + aType.toUpperCase()];
+},
+/**
+* Determines if we are done searching or not.
+*
+* @return true if we have completed searching, false otherwise.
+*/
+isSearchComplete: function PAC_isSearchComplete()
+{
+// If _pendingQuery is null, we should no longer do any work since we have
+// already called _finishSearch.  This means we completed our search.
+return this._pendingQuery == null;
+},
+/**
+* Determines if the given handle of a pending statement is a pending search
+* or not.
+*
+* @param aHandle
+*        A mozIStoragePendingStatement to check and see if we are waiting for
+*        results from it still.
+* @return true if it is a pending query, false otherwise.
+*/
+isPendingSearch: function PAC_isPendingSearch(aHandle)
+{
+return this._pendingQuery == aHandle;
+},
+//////////////////////////////////////////////////////////////////////////////
+//// nsISupports
+classID: Components.ID("d0272978-beab-4adc-a3d4-04b76acfa4e7"),
+_xpcom_factory: XPCOMUtils.generateSingletonFactory(nsPlacesAutoComplete),
+QueryInterface: XPCOMUtils.generateQI([
+Ci.nsIAutoCompleteSearch,
+Ci.nsIAutoCompleteSimpleResultListener,
+Ci.mozIPlacesAutoComplete,
+Ci.mozIStorageStatementCallback,
+Ci.nsIObserver,
+Ci.nsISupportsWeakReference,
+])
+};
+////////////////////////////////////////////////////////////////////////////////
+//// urlInlineComplete class
+//// component @mozilla.org/autocomplete/search;1?name=urlinline
+function urlInlineComplete()
+{
+this._loadPrefs(true);
+Services.obs.addObserver(this, kTopicShutdown, true);
+}
+urlInlineComplete.prototype = {
+/////////////////////////////////////////////////////////////////////////////////
+//// Database and query getters
+__db: null,
+get _db()
+{
+if (!this.__db && this._autofillEnabled) {
+this.__db = PlacesUtils.history.DBConnection.clone(true);
+}
+return this.__db;
+},
+__hostQuery: null,
+get _hostQuery()
+{
+if (!this.__hostQuery) {
+// Add a trailing slash at the end of the hostname, since we always
+// want to complete up to and including a URL separator.
+this.__hostQuery = this._db.createAsyncStatement(
+"/* do not warn (bug no): could index on (typed,frecency) but not worth it */ "
++ "SELECT host || '/', prefix || host || '/' "
++ "FROM moz_hosts "
++ "WHERE host BETWEEN :search_string AND :search_string || X'FFFF' "
++ "AND frecency <> 0 "
++ (this._autofillTyped ? "AND typed = 1 " : "")
++ "ORDER BY frecency DESC "
++ "LIMIT 1"
+);
+}
+return this.__hostQuery;
+},
+__urlQuery: null,
+get _urlQuery()
+{
+if (!this.__urlQuery) {
+this.__urlQuery = this._db.createAsyncStatement(
+"/* do not warn (bug no): can't use an index */ "
++ "SELECT h.url "
++ "FROM moz_places h "
++ "WHERE h.frecency <> 0 "
++ (this._autofillTyped ? "AND h.typed = 1 " : "")
++   "AND AUTOCOMPLETE_MATCH(:searchString, h.url, "
++                          "h.title, '', "
++                          "h.visit_count, h.typed, 0, 0, "
++                          ":matchBehavior, :searchBehavior) "
++ "ORDER BY h.frecency DESC, h.id DESC "
++ "LIMIT 1"
+);
+}
+return this.__urlQuery;
+},
+//////////////////////////////////////////////////////////////////////////////
+//// nsIAutoCompleteSearch
+startSearch: function UIC_startSearch(aSearchString, aSearchParam,
+aPreviousResult, aListener)
+{
+// Stop the search in case the controller has not taken care of it.
+if (this._pendingQuery) {
+this.stopSearch();
+}
+// We want to store the original string with no leading or trailing
+// whitespace for case sensitive searches.
+this._originalSearchString = aSearchString;
+this._currentSearchString =
+fixupSearchText(this._originalSearchString.toLowerCase());
+// The protocol and the host are lowercased by nsIURI, so it's fine to
+// lowercase the typed prefix to add it back to the results later.
+this._strippedPrefix = this._originalSearchString.slice(
+0, this._originalSearchString.length - this._currentSearchString.length
+).toLowerCase();
+this._result = Cc["@mozilla.org/autocomplete/simple-result;1"].
+createInstance(Ci.nsIAutoCompleteSimpleResult);
+this._result.setSearchString(aSearchString);
+this._result.setTypeAheadResult(true);
+this._listener = aListener;
+// Don't autoFill if the search term is recognized as a keyword, otherwise
+// it will override default keywords behavior.  Note that keywords are
+// hashed on first use, so while the first query may delay a little bit,
+// next ones will just hit the memory hash.
+if (this._currentSearchString.length == 0 || !this._db ||
+PlacesUtils.bookmarks.getURIForKeyword(this._currentSearchString)) {
+this._finishSearch();
+return;
+}
+// Don't try to autofill if the search term includes any whitespace.
+// This may confuse completeDefaultIndex cause the AUTOCOMPLETE_MATCH
+// tokenizer ends up trimming the search string and returning a value
+// that doesn't match it, or is even shorter.
+if (/\s/.test(this._currentSearchString)) {
+this._finishSearch();
+return;
+}
+// Hosts have no "/" in them.
+let lastSlashIndex = this._currentSearchString.lastIndexOf("/");
+// Search only URLs if there's a slash in the search string...
+if (lastSlashIndex != -1) {
+// ...but not if it's exactly at the end of the search string.
+if (lastSlashIndex < this._currentSearchString.length - 1)
+this._queryURL();
+else
+this._finishSearch();
+return;
+}
+// Do a synchronous search on the table of hosts.
+let query = this._hostQuery;
+query.params.search_string = this._currentSearchString.toLowerCase();
+// This is just to measure the delay to reach the UI, not the query time.
+TelemetryStopwatch.start(DOMAIN_QUERY_TELEMETRY);
+let ac = this;
+let wrapper = new AutoCompleteStatementCallbackWrapper(this, {
+handleResult: function (aResultSet) {
+let row = aResultSet.getNextRow();
+let trimmedHost = row.getResultByIndex(0);
+let untrimmedHost = row.getResultByIndex(1);
+// If the untrimmed value doesn't preserve the user's input just
+// ignore it and complete to the found host.
+if (untrimmedHost &&
+!untrimmedHost.toLowerCase().contains(ac._originalSearchString.toLowerCase())) {
+untrimmedHost = null;
+}
+ac._result.appendMatch(ac._strippedPrefix + trimmedHost, "", "", "", untrimmedHost);
+// handleCompletion() will cause the result listener to be called, and
+// will display the result in the UI.
+},
+handleError: function (aError) {
+Components.utils.reportError(
+"URL Inline Complete: An async statement encountered an " +
+"error: " + aError.result + ", '" + aError.message + "'");
+},
+handleCompletion: function (aReason) {
+TelemetryStopwatch.finish(DOMAIN_QUERY_TELEMETRY);
+ac._finishSearch();
+}
+}, this._db);
+this._pendingQuery = wrapper.executeAsync([query]);
+},
+/**
+* Execute an asynchronous search through places, and complete
+* up to the next URL separator.
+*/
+_queryURL: function UIC__queryURL()
+{
+// The URIs in the database are fixed up, so we can match on a lowercased
+// host, but the path must be matched in a case sensitive way.
+let pathIndex =
+this._originalSearchString.indexOf("/", this._strippedPrefix.length);
+this._currentSearchString = fixupSearchText(
+this._originalSearchString.slice(0, pathIndex).toLowerCase() +
+this._originalSearchString.slice(pathIndex)
+);
+// Within the standard autocomplete query, we only search the beginning
+// of URLs for 1 result.
+let query = this._urlQuery;
+let (params = query.params) {
+params.matchBehavior = MATCH_BEGINNING_CASE_SENSITIVE;
+params.searchBehavior = Ci.mozIPlacesAutoComplete["BEHAVIOR_URL"];
+params.searchString = this._currentSearchString;
+}
+// Execute the query.
+let ac = this;
+let wrapper = new AutoCompleteStatementCallbackWrapper(this, {
+handleResult: function(aResultSet) {
+let row = aResultSet.getNextRow();
+let value = row.getResultByIndex(0);
+let url = fixupSearchText(value);
+let prefix = value.slice(0, value.length - stripPrefix(value).length);
+// We must complete the URL up to the next separator (which is /, ? or #).
+let separatorIndex = url.slice(ac._currentSearchString.length)
+.search(/[\/\?\#]/);
+if (separatorIndex != -1) {
+separatorIndex += ac._currentSearchString.length;
+if (url[separatorIndex] == "/") {
+separatorIndex++; // Include the "/" separator
+}
+url = url.slice(0, separatorIndex);
+}
+// Add the result.
+// If the untrimmed value doesn't preserve the user's input just
+// ignore it and complete to the found url.
+let untrimmedURL = prefix + url;
+if (untrimmedURL &&
+!untrimmedURL.toLowerCase().contains(ac._originalSearchString.toLowerCase())) {
+untrimmedURL = null;
+}
+ac._result.appendMatch(ac._strippedPrefix + url, "", "", "", untrimmedURL);
+// handleCompletion() will cause the result listener to be called, and
+// will display the result in the UI.
+},
+handleError: function(aError) {
+Components.utils.reportError(
+"URL Inline Complete: An async statement encountered an " +
+"error: " + aError.result + ", '" + aError.message + "'");
+},
+handleCompletion: function(aReason) {
+ac._finishSearch();
+}
+}, this._db);
+this._pendingQuery = wrapper.executeAsync([query]);
+},
+stopSearch: function UIC_stopSearch()
+{
+delete this._originalSearchString;
+delete this._currentSearchString;
+delete this._result;
+delete this._listener;
+if (this._pendingQuery) {
+this._pendingQuery.cancel();
+delete this._pendingQuery;
+}
+},
+/**
+* Loads the preferences that we care about.
+*
+* @param [optional] aRegisterObserver
+*        Indicates if the preference observer should be added or not.  The
+*        default value is false.
+*/
+_loadPrefs: function UIC_loadPrefs(aRegisterObserver)
+{
+let prefBranch = Services.prefs.getBranch(kBrowserUrlbarBranch);
+let autocomplete = safePrefGetter(prefBranch,
+kBrowserUrlbarAutocompleteEnabledPref,
+true);
+let autofill = safePrefGetter(prefBranch,
+kBrowserUrlbarAutofillPref,
+true);
+this._autofillEnabled = autocomplete && autofill;
+this._autofillTyped = safePrefGetter(prefBranch,
+kBrowserUrlbarAutofillTypedPref,
+true);
+if (aRegisterObserver) {
+Services.prefs.addObserver(kBrowserUrlbarBranch, this, true);
+}
+},
+//////////////////////////////////////////////////////////////////////////////
+//// nsIAutoCompleteSearchDescriptor
+get searchType() Ci.nsIAutoCompleteSearchDescriptor.SEARCH_TYPE_IMMEDIATE,
+//////////////////////////////////////////////////////////////////////////////
+//// nsIObserver
+observe: function UIC_observe(aSubject, aTopic, aData)
+{
+if (aTopic == kTopicShutdown) {
+this._closeDatabase();
+}
+else if (aTopic == kPrefChanged &&
+(aData.substr(kBrowserUrlbarBranch.length) == kBrowserUrlbarAutofillPref ||
+aData.substr(kBrowserUrlbarBranch.length) == kBrowserUrlbarAutocompleteEnabledPref ||
+aData.substr(kBrowserUrlbarBranch.length) == kBrowserUrlbarAutofillTypedPref)) {
+let previousAutofillTyped = this._autofillTyped;
+this._loadPrefs();
+if (!this._autofillEnabled) {
+this.stopSearch();
+this._closeDatabase();
+}
+else if (this._autofillTyped != previousAutofillTyped) {
+// Invalidate the statements to update them for the new typed status.
+this._invalidateStatements();
+}
+}
+},
+/**
+* Finalizes and invalidates cached statements.
+*/
+_invalidateStatements: function UIC_invalidateStatements()
+{
+// Finalize the statements that we have used.
+let stmts = [
+"__hostQuery",
+"__urlQuery",
+];
+for (let i = 0; i < stmts.length; i++) {
+// We do not want to create any query we haven't already created, so
+// see if it is a getter first.
+if (this[stmts[i]]) {
+this[stmts[i]].finalize();
+this[stmts[i]] = null;
+}
+}
+},
+/**
+* Closes the database.
+*/
+_closeDatabase: function UIC_closeDatabase()
+{
+this._invalidateStatements();
+if (this.__db) {
+this._db.asyncClose();
+this.__db = null;
+}
+},
+//////////////////////////////////////////////////////////////////////////////
+//// urlInlineComplete
+_finishSearch: function UIC_finishSearch()
+{
+// Notify the result object
+let result = this._result;
+if (result.matchCount) {
+result.setDefaultIndex(0);
+result.setSearchResult(Ci.nsIAutoCompleteResult["RESULT_SUCCESS"]);
+} else {
+result.setDefaultIndex(-1);
+result.setSearchResult(Ci.nsIAutoCompleteResult["RESULT_NOMATCH"]);
+}
+this._listener.onSearchResult(this, result);
+this.stopSearch();
+},
+isSearchComplete: function UIC_isSearchComplete()
+{
+return this._pendingQuery == null;
+},
+isPendingSearch: function UIC_isPendingSearch(aHandle)
+{
+return this._pendingQuery == aHandle;
+},
+//////////////////////////////////////////////////////////////////////////////
+//// nsISupports
+classID: Components.ID("c88fae2d-25cf-4338-a1f4-64a320ea7440"),
+_xpcom_factory: XPCOMUtils.generateSingletonFactory(urlInlineComplete),
+QueryInterface: XPCOMUtils.generateQI([
+Ci.nsIAutoCompleteSearch,
+Ci.nsIAutoCompleteSearchDescriptor,
+Ci.nsIObserver,
+Ci.nsISupportsWeakReference,
+])
+};
+let components = [nsPlacesAutoComplete, urlInlineComplete];
+this.NSGetFactory = XPCOMUtils.generateNSGetFactory(components);