Add m-esr52 at 52.6.0

1 files changed, 2977 insertions, 0 deletions

diff --git a/toolkit/components/places/History.cpp b/toolkit/components/places/History.cpp
new file mode 100644
index 000000000..61f78cb83
--- /dev/null
+++ b/toolkit/components/places/History.cpp
@@ -0,0 +1,2977 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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 "mozilla/ArrayUtils.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/DebugOnly.h"
+#include "mozilla/MemoryReporting.h"
+
+#include "mozilla/dom/ContentChild.h"
+#include "mozilla/dom/ContentParent.h"
+#include "nsXULAppAPI.h"
+
+#include "History.h"
+#include "nsNavHistory.h"
+#include "nsNavBookmarks.h"
+#include "nsAnnotationService.h"
+#include "Helpers.h"
+#include "PlaceInfo.h"
+#include "VisitInfo.h"
+#include "nsPlacesMacros.h"
+
+#include "mozilla/storage.h"
+#include "mozilla/dom/Link.h"
+#include "nsDocShellCID.h"
+#include "mozilla/Services.h"
+#include "nsThreadUtils.h"
+#include "nsNetUtil.h"
+#include "nsIFileURL.h"
+#include "nsIXPConnect.h"
+#include "mozilla/Unused.h"
+#include "nsContentUtils.h" // for nsAutoScriptBlocker
+#include "nsJSUtils.h"
+#include "mozilla/ipc/URIUtils.h"
+#include "nsPrintfCString.h"
+#include "nsTHashtable.h"
+#include "jsapi.h"
+
+// Initial size for the cache holding visited status observers.
+#define VISIT_OBSERVERS_INITIAL_CACHE_LENGTH 64
+
+// Initial length for the visits removal hash.
+#define VISITS_REMOVAL_INITIAL_HASH_LENGTH 64
+
+using namespace mozilla::dom;
+using namespace mozilla::ipc;
+using mozilla::Unused;
+
+namespace mozilla {
+namespace places {
+
+////////////////////////////////////////////////////////////////////////////////
+//// Global Defines
+
+#define URI_VISITED "visited"
+#define URI_NOT_VISITED "not visited"
+#define URI_VISITED_RESOLUTION_TOPIC "visited-status-resolution"
+// Observer event fired after a visit has been registered in the DB.
+#define URI_VISIT_SAVED "uri-visit-saved"
+
+#define DESTINATIONFILEURI_ANNO \
+        NS_LITERAL_CSTRING("downloads/destinationFileURI")
+#define DESTINATIONFILENAME_ANNO \
+        NS_LITERAL_CSTRING("downloads/destinationFileName")
+
+////////////////////////////////////////////////////////////////////////////////
+//// VisitData
+
+struct VisitData {
+  VisitData()
+  : placeId(0)
+  , visitId(0)
+  , hidden(true)
+  , shouldUpdateHidden(true)
+  , typed(false)
+  , transitionType(UINT32_MAX)
+  , visitTime(0)
+  , frecency(-1)
+  , lastVisitId(0)
+  , lastVisitTime(0)
+  , visitCount(0)
+  , referrerVisitId(0)
+  , titleChanged(false)
+  , shouldUpdateFrecency(true)
+  {
+    guid.SetIsVoid(true);
+    title.SetIsVoid(true);
+  }
+
+  explicit VisitData(nsIURI* aURI,
+                     nsIURI* aReferrer = nullptr)
+  : placeId(0)
+  , visitId(0)
+  , hidden(true)
+  , shouldUpdateHidden(true)
+  , typed(false)
+  , transitionType(UINT32_MAX)
+  , visitTime(0)
+  , frecency(-1)
+  , lastVisitId(0)
+  , lastVisitTime(0)
+  , visitCount(0)
+  , referrerVisitId(0)
+  , titleChanged(false)
+  , shouldUpdateFrecency(true)
+  {
+    MOZ_ASSERT(aURI);
+    if (aURI) {
+      (void)aURI->GetSpec(spec);
+      (void)GetReversedHostname(aURI, revHost);
+    }
+    if (aReferrer) {
+      (void)aReferrer->GetSpec(referrerSpec);
+    }
+    guid.SetIsVoid(true);
+    title.SetIsVoid(true);
+  }
+
+  /**
+   * Sets the transition type of the visit, as well as if it was typed.
+   *
+   * @param aTransitionType
+   *        The transition type constant to set.  Must be one of the
+   *        TRANSITION_ constants on nsINavHistoryService.
+   */
+  void SetTransitionType(uint32_t aTransitionType)
+  {
+    typed = aTransitionType == nsINavHistoryService::TRANSITION_TYPED;
+    transitionType = aTransitionType;
+  }
+
+  int64_t placeId;
+  nsCString guid;
+  int64_t visitId;
+  nsCString spec;
+  nsString revHost;
+  bool hidden;
+  bool shouldUpdateHidden;
+  bool typed;
+  uint32_t transitionType;
+  PRTime visitTime;
+  int32_t frecency;
+  int64_t lastVisitId;
+  PRTime lastVisitTime;
+  uint32_t visitCount;
+
+  /**
+   * Stores the title.  If this is empty (IsEmpty() returns true), then the
+   * title should be removed from the Place.  If the title is void (IsVoid()
+   * returns true), then no title has been set on this object, and titleChanged
+   * should remain false.
+   */
+  nsString title;
+
+  nsCString referrerSpec;
+  int64_t referrerVisitId;
+
+  // TODO bug 626836 hook up hidden and typed change tracking too!
+  bool titleChanged;
+
+  // Indicates whether frecency should be updated for this visit.
+  bool shouldUpdateFrecency;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+//// RemoveVisitsFilter
+
+/**
+ * Used to store visit filters for RemoveVisits.
+ */
+struct RemoveVisitsFilter {
+  RemoveVisitsFilter()
+  : transitionType(UINT32_MAX)
+  {
+  }
+
+  uint32_t transitionType;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+//// PlaceHashKey
+
+class PlaceHashKey : public nsCStringHashKey
+{
+public:
+  explicit PlaceHashKey(const nsACString& aSpec)
+    : nsCStringHashKey(&aSpec)
+    , mVisitCount(0)
+    , mBookmarked(false)
+#ifdef DEBUG
+    , mIsInitialized(false)
+#endif
+  {
+  }
+
+  explicit PlaceHashKey(const nsACString* aSpec)
+    : nsCStringHashKey(aSpec)
+    , mVisitCount(0)
+    , mBookmarked(false)
+#ifdef DEBUG
+    , mIsInitialized(false)
+#endif
+  {
+  }
+
+  PlaceHashKey(const PlaceHashKey& aOther)
+    : nsCStringHashKey(&aOther.GetKey())
+  {
+    MOZ_ASSERT(false, "Do not call me!");
+  }
+
+  void SetProperties(uint32_t aVisitCount, bool aBookmarked)
+  {
+    mVisitCount = aVisitCount;
+    mBookmarked = aBookmarked;
+#ifdef DEBUG
+    mIsInitialized = true;
+#endif
+  }
+
+  uint32_t VisitCount() const
+  {
+#ifdef DEBUG
+    MOZ_ASSERT(mIsInitialized, "PlaceHashKey::mVisitCount not set");
+#endif
+    return mVisitCount;
+  }
+
+  bool IsBookmarked() const
+  {
+#ifdef DEBUG
+    MOZ_ASSERT(mIsInitialized, "PlaceHashKey::mBookmarked not set");
+#endif
+    return mBookmarked;
+  }
+
+  // Array of VisitData objects.
+  nsTArray<VisitData> mVisits;
+private:
+  // Visit count for this place.
+  uint32_t mVisitCount;
+  // Whether this place is bookmarked.
+  bool mBookmarked;
+#ifdef DEBUG
+  // Whether previous attributes are set.
+  bool mIsInitialized;
+#endif
+};
+
+////////////////////////////////////////////////////////////////////////////////
+//// Anonymous Helpers
+
+namespace {
+
+/**
+ * Convert the given js value to a js array.
+ *
+ * @param [in] aValue
+ *        the JS value to convert.
+ * @param [in] aCtx
+ *        The JSContext for aValue.
+ * @param [out] _array
+ *        the JS array.
+ * @param [out] _arrayLength
+ *        _array's length.
+ */
+nsresult
+GetJSArrayFromJSValue(JS::Handle<JS::Value> aValue,
+                      JSContext* aCtx,
+                      JS::MutableHandle<JSObject*> _array,
+                      uint32_t* _arrayLength) {
+  if (aValue.isObjectOrNull()) {
+    JS::Rooted<JSObject*> val(aCtx, aValue.toObjectOrNull());
+    bool isArray;
+    if (!JS_IsArrayObject(aCtx, val, &isArray)) {
+      return NS_ERROR_UNEXPECTED;
+    }
+    if (isArray) {
+      _array.set(val);
+      (void)JS_GetArrayLength(aCtx, _array, _arrayLength);
+      NS_ENSURE_ARG(*_arrayLength > 0);
+      return NS_OK;
+    }
+  }
+
+  // Build a temporary array to store this one item so the code below can
+  // just loop.
+  *_arrayLength = 1;
+  _array.set(JS_NewArrayObject(aCtx, 0));
+  NS_ENSURE_TRUE(_array, NS_ERROR_OUT_OF_MEMORY);
+
+  bool rc = JS_DefineElement(aCtx, _array, 0, aValue, 0);
+  NS_ENSURE_TRUE(rc, NS_ERROR_UNEXPECTED);
+  return NS_OK;
+}
+
+/**
+ * Attemps to convert a given js value to a nsIURI object.
+ * @param aCtx
+ *        The JSContext for aValue.
+ * @param aValue
+ *        The JS value to convert.
+ * @return the nsIURI object, or null if aValue is not a nsIURI object.
+ */
+already_AddRefed<nsIURI>
+GetJSValueAsURI(JSContext* aCtx,
+                const JS::Value& aValue) {
+  if (!aValue.isPrimitive()) {
+    nsCOMPtr<nsIXPConnect> xpc = mozilla::services::GetXPConnect();
+
+    nsCOMPtr<nsIXPConnectWrappedNative> wrappedObj;
+    nsresult rv = xpc->GetWrappedNativeOfJSObject(aCtx, aValue.toObjectOrNull(),
+                                                  getter_AddRefs(wrappedObj));
+    NS_ENSURE_SUCCESS(rv, nullptr);
+    nsCOMPtr<nsIURI> uri = do_QueryWrappedNative(wrappedObj);
+    return uri.forget();
+  }
+  return nullptr;
+}
+
+/**
+ * Obtains an nsIURI from the "uri" property of a JSObject.
+ *
+ * @param aCtx
+ *        The JSContext for aObject.
+ * @param aObject
+ *        The JSObject to get the URI from.
+ * @param aProperty
+ *        The name of the property to get the URI from.
+ * @return the URI if it exists.
+ */
+already_AddRefed<nsIURI>
+GetURIFromJSObject(JSContext* aCtx,
+                   JS::Handle<JSObject *> aObject,
+                   const char* aProperty)
+{
+  JS::Rooted<JS::Value> uriVal(aCtx);
+  bool rc = JS_GetProperty(aCtx, aObject, aProperty, &uriVal);
+  NS_ENSURE_TRUE(rc, nullptr);
+  return GetJSValueAsURI(aCtx, uriVal);
+}
+
+/**
+ * Attemps to convert a JS value to a string.
+ * @param aCtx
+ *        The JSContext for aObject.
+ * @param aValue
+ *        The JS value to convert.
+ * @param _string
+ *        The string to populate with the value, or set it to void.
+ */
+void
+GetJSValueAsString(JSContext* aCtx,
+                   const JS::Value& aValue,
+                   nsString& _string) {
+  if (aValue.isUndefined() ||
+      !(aValue.isNull() || aValue.isString())) {
+    _string.SetIsVoid(true);
+    return;
+  }
+
+  // |null| in JS maps to the empty string.
+  if (aValue.isNull()) {
+    _string.Truncate();
+    return;
+  }
+
+  if (!AssignJSString(aCtx, _string, aValue.toString())) {
+    _string.SetIsVoid(true);
+  }
+}
+
+/**
+ * Obtains the specified property of a JSObject.
+ *
+ * @param aCtx
+ *        The JSContext for aObject.
+ * @param aObject
+ *        The JSObject to get the string from.
+ * @param aProperty
+ *        The property to get the value from.
+ * @param _string
+ *        The string to populate with the value, or set it to void.
+ */
+void
+GetStringFromJSObject(JSContext* aCtx,
+                      JS::Handle<JSObject *> aObject,
+                      const char* aProperty,
+                      nsString& _string)
+{
+  JS::Rooted<JS::Value> val(aCtx);
+  bool rc = JS_GetProperty(aCtx, aObject, aProperty, &val);
+  if (!rc) {
+    _string.SetIsVoid(true);
+    return;
+  }
+  else {
+    GetJSValueAsString(aCtx, val, _string);
+  }
+}
+
+/**
+ * Obtains the specified property of a JSObject.
+ *
+ * @param aCtx
+ *        The JSContext for aObject.
+ * @param aObject
+ *        The JSObject to get the int from.
+ * @param aProperty
+ *        The property to get the value from.
+ * @param _int
+ *        The integer to populate with the value on success.
+ */
+template <typename IntType>
+nsresult
+GetIntFromJSObject(JSContext* aCtx,
+                   JS::Handle<JSObject *> aObject,
+                   const char* aProperty,
+                   IntType* _int)
+{
+  JS::Rooted<JS::Value> value(aCtx);
+  bool rc = JS_GetProperty(aCtx, aObject, aProperty, &value);
+  NS_ENSURE_TRUE(rc, NS_ERROR_UNEXPECTED);
+  if (value.isUndefined()) {
+    return NS_ERROR_INVALID_ARG;
+  }
+  NS_ENSURE_ARG(value.isPrimitive());
+  NS_ENSURE_ARG(value.isNumber());
+
+  double num;
+  rc = JS::ToNumber(aCtx, value, &num);
+  NS_ENSURE_TRUE(rc, NS_ERROR_UNEXPECTED);
+  NS_ENSURE_ARG(IntType(num) == num);
+
+  *_int = IntType(num);
+  return NS_OK;
+}
+
+/**
+ * Obtains the specified property of a JSObject.
+ *
+ * @pre aArray must be an Array object.
+ *
+ * @param aCtx
+ *        The JSContext for aArray.
+ * @param aArray
+ *        The JSObject to get the object from.
+ * @param aIndex
+ *        The index to get the object from.
+ * @param objOut
+ *        Set to the JSObject pointer on success.
+ */
+nsresult
+GetJSObjectFromArray(JSContext* aCtx,
+                     JS::Handle<JSObject*> aArray,
+                     uint32_t aIndex,
+                     JS::MutableHandle<JSObject*> objOut)
+{
+  JS::Rooted<JS::Value> value(aCtx);
+  bool rc = JS_GetElement(aCtx, aArray, aIndex, &value);
+  NS_ENSURE_TRUE(rc, NS_ERROR_UNEXPECTED);
+  NS_ENSURE_ARG(!value.isPrimitive());
+  objOut.set(&value.toObject());
+  return NS_OK;
+}
+
+class VisitedQuery final : public AsyncStatementCallback,
+                           public mozIStorageCompletionCallback
+{
+public:
+  NS_DECL_ISUPPORTS_INHERITED
+
+  static nsresult Start(nsIURI* aURI,
+                        mozIVisitedStatusCallback* aCallback=nullptr)
+  {
+    NS_PRECONDITION(aURI, "Null URI");
+
+    // If we are a content process, always remote the request to the
+    // parent process.
+    if (XRE_IsContentProcess()) {
+      URIParams uri;
+      SerializeURI(aURI, uri);
+
+      mozilla::dom::ContentChild* cpc =
+        mozilla::dom::ContentChild::GetSingleton();
+      NS_ASSERTION(cpc, "Content Protocol is NULL!");
+      (void)cpc->SendStartVisitedQuery(uri);
+      return NS_OK;
+    }
+
+    nsMainThreadPtrHandle<mozIVisitedStatusCallback>
+      callback(new nsMainThreadPtrHolder<mozIVisitedStatusCallback>(aCallback));
+
+    nsNavHistory* navHistory = nsNavHistory::GetHistoryService();
+    NS_ENSURE_STATE(navHistory);
+    if (navHistory->hasEmbedVisit(aURI)) {
+      RefPtr<VisitedQuery> cb = new VisitedQuery(aURI, callback, true);
+      NS_ENSURE_TRUE(cb, NS_ERROR_OUT_OF_MEMORY);
+      // As per IHistory contract, we must notify asynchronously.
+      NS_DispatchToMainThread(NewRunnableMethod(cb, &VisitedQuery::NotifyVisitedStatus));
+
+      return NS_OK;
+    }
+
+    History* history = History::GetService();
+    NS_ENSURE_STATE(history);
+    RefPtr<VisitedQuery> cb = new VisitedQuery(aURI, callback);
+    NS_ENSURE_TRUE(cb, NS_ERROR_OUT_OF_MEMORY);
+    nsresult rv = history->GetIsVisitedStatement(cb);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    return NS_OK;
+  }
+
+  // Note: the return value matters here.  We call into this method, it's not
+  // just xpcom boilerplate.
+  NS_IMETHOD Complete(nsresult aResult, nsISupports* aStatement) override
+  {
+    NS_ENSURE_SUCCESS(aResult, aResult);
+    nsCOMPtr<mozIStorageAsyncStatement> stmt = do_QueryInterface(aStatement);
+    NS_ENSURE_STATE(stmt);
+    // Bind by index for performance.
+    nsresult rv = URIBinder::Bind(stmt, 0, mURI);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    nsCOMPtr<mozIStoragePendingStatement> handle;
+    return stmt->ExecuteAsync(this, getter_AddRefs(handle));
+  }
+
+  NS_IMETHOD HandleResult(mozIStorageResultSet* aResults) override
+  {
+    // If this method is called, we've gotten results, which means we have a
+    // visit.
+    mIsVisited = true;
+    return NS_OK;
+  }
+
+  NS_IMETHOD HandleError(mozIStorageError* aError) override
+  {
+    // mIsVisited is already set to false, and that's the assumption we will
+    // make if an error occurred.
+    return NS_OK;
+  }
+
+  NS_IMETHOD HandleCompletion(uint16_t aReason) override
+  {
+    if (aReason != mozIStorageStatementCallback::REASON_FINISHED) {
+      return NS_OK;
+    }
+
+    nsresult rv = NotifyVisitedStatus();
+    NS_ENSURE_SUCCESS(rv, rv);
+    return NS_OK;
+  }
+
+  nsresult NotifyVisitedStatus()
+  {
+    // If an external handling callback is provided, just notify through it.
+    if (!!mCallback) {
+      mCallback->IsVisited(mURI, mIsVisited);
+      return NS_OK;
+    }
+
+    if (mIsVisited) {
+      History* history = History::GetService();
+      NS_ENSURE_STATE(history);
+      history->NotifyVisited(mURI);
+    }
+
+    nsCOMPtr<nsIObserverService> observerService =
+      mozilla::services::GetObserverService();
+    if (observerService) {
+      nsAutoString status;
+      if (mIsVisited) {
+        status.AssignLiteral(URI_VISITED);
+      }
+      else {
+        status.AssignLiteral(URI_NOT_VISITED);
+      }
+      (void)observerService->NotifyObservers(mURI,
+                                             URI_VISITED_RESOLUTION_TOPIC,
+                                             status.get());
+    }
+
+    return NS_OK;
+  }
+
+private:
+  explicit VisitedQuery(nsIURI* aURI,
+                        const nsMainThreadPtrHandle<mozIVisitedStatusCallback>& aCallback,
+                        bool aIsVisited=false)
+  : mURI(aURI)
+  , mCallback(aCallback)
+  , mIsVisited(aIsVisited)
+  {
+  }
+
+  ~VisitedQuery()
+  {
+  }
+
+  nsCOMPtr<nsIURI> mURI;
+  nsMainThreadPtrHandle<mozIVisitedStatusCallback> mCallback;
+  bool mIsVisited;
+};
+
+NS_IMPL_ISUPPORTS_INHERITED(
+  VisitedQuery
+, AsyncStatementCallback
+, mozIStorageCompletionCallback
+)
+
+/**
+ * Notifies observers about a visit.
+ */
+class NotifyVisitObservers : public Runnable
+{
+public:
+  explicit NotifyVisitObservers(VisitData& aPlace)
+  : mPlace(aPlace)
+  , mHistory(History::GetService())
+  {
+  }
+
+  NS_IMETHOD Run() override
+  {
+    MOZ_ASSERT(NS_IsMainThread(), "This should be called on the main thread");
+
+    // We are in the main thread, no need to lock.
+    if (mHistory->IsShuttingDown()) {
+      // If we are shutting down, we cannot notify the observers.
+      return NS_OK;
+    }
+
+    nsNavHistory* navHistory = nsNavHistory::GetHistoryService();
+    if (!navHistory) {
+      NS_WARNING("Trying to notify about a visit but cannot get the history service!");
+      return NS_OK;
+    }
+
+    nsCOMPtr<nsIURI> uri;
+    MOZ_ALWAYS_SUCCEEDS(NS_NewURI(getter_AddRefs(uri), mPlace.spec));
+    if (!uri) {
+      return NS_ERROR_UNEXPECTED;
+    }
+
+    // Notify the visit.  Note that TRANSITION_EMBED visits are never added
+    // to the database, thus cannot be queried and we don't notify them.
+    if (mPlace.transitionType != nsINavHistoryService::TRANSITION_EMBED) {
+      navHistory->NotifyOnVisit(uri, mPlace.visitId, mPlace.visitTime,
+                                mPlace.referrerVisitId, mPlace.transitionType,
+                                mPlace.guid, mPlace.hidden,
+                                mPlace.visitCount + 1, // Add current visit.
+                                static_cast<uint32_t>(mPlace.typed));
+    }
+
+    nsCOMPtr<nsIObserverService> obsService =
+      mozilla::services::GetObserverService();
+    if (obsService) {
+      DebugOnly<nsresult> rv =
+        obsService->NotifyObservers(uri, URI_VISIT_SAVED, nullptr);
+      NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "Could not notify observers");
+    }
+
+    History* history = History::GetService();
+    NS_ENSURE_STATE(history);
+    history->AppendToRecentlyVisitedURIs(uri);
+    history->NotifyVisited(uri);
+
+    return NS_OK;
+  }
+private:
+  VisitData mPlace;
+  RefPtr<History> mHistory;
+};
+
+/**
+ * Notifies observers about a pages title changing.
+ */
+class NotifyTitleObservers : public Runnable
+{
+public:
+  /**
+   * Notifies observers on the main thread.
+   *
+   * @param aSpec
+   *        The spec of the URI to notify about.
+   * @param aTitle
+   *        The new title to notify about.
+   */
+  NotifyTitleObservers(const nsCString& aSpec,
+                       const nsString& aTitle,
+                       const nsCString& aGUID)
+  : mSpec(aSpec)
+  , mTitle(aTitle)
+  , mGUID(aGUID)
+  {
+  }
+
+  NS_IMETHOD Run() override
+  {
+    MOZ_ASSERT(NS_IsMainThread(), "This should be called on the main thread");
+
+    nsNavHistory* navHistory = nsNavHistory::GetHistoryService();
+    NS_ENSURE_TRUE(navHistory, NS_ERROR_OUT_OF_MEMORY);
+    nsCOMPtr<nsIURI> uri;
+    MOZ_ALWAYS_SUCCEEDS(NS_NewURI(getter_AddRefs(uri), mSpec));
+    if (!uri) {
+      return NS_ERROR_UNEXPECTED;
+    }
+
+    navHistory->NotifyTitleChange(uri, mTitle, mGUID);
+
+    return NS_OK;
+  }
+private:
+  const nsCString mSpec;
+  const nsString mTitle;
+  const nsCString mGUID;
+};
+
+/**
+ * Helper class for methods which notify their callers through the
+ * mozIVisitInfoCallback interface.
+ */
+class NotifyPlaceInfoCallback : public Runnable
+{
+public:
+  NotifyPlaceInfoCallback(const nsMainThreadPtrHandle<mozIVisitInfoCallback>& aCallback,
+                          const VisitData& aPlace,
+                          bool aIsSingleVisit,
+                          nsresult aResult)
+  : mCallback(aCallback)
+  , mPlace(aPlace)
+  , mResult(aResult)
+  , mIsSingleVisit(aIsSingleVisit)
+  {
+    MOZ_ASSERT(aCallback, "Must pass a non-null callback!");
+  }
+
+  NS_IMETHOD Run() override
+  {
+    MOZ_ASSERT(NS_IsMainThread(), "This should be called on the main thread");
+
+    bool hasValidURIs = true;
+    nsCOMPtr<nsIURI> referrerURI;
+    if (!mPlace.referrerSpec.IsEmpty()) {
+      MOZ_ALWAYS_SUCCEEDS(NS_NewURI(getter_AddRefs(referrerURI), mPlace.referrerSpec));
+      hasValidURIs = !!referrerURI;
+    }
+
+    nsCOMPtr<nsIURI> uri;
+    MOZ_ALWAYS_SUCCEEDS(NS_NewURI(getter_AddRefs(uri), mPlace.spec));
+    hasValidURIs = hasValidURIs && !!uri;
+
+    nsCOMPtr<mozIPlaceInfo> place;
+    if (mIsSingleVisit) {
+      nsCOMPtr<mozIVisitInfo> visit =
+        new VisitInfo(mPlace.visitId, mPlace.visitTime, mPlace.transitionType,
+                      referrerURI.forget());
+      PlaceInfo::VisitsArray visits;
+      (void)visits.AppendElement(visit);
+
+      // The frecency isn't exposed because it may not reflect the updated value
+      // in the case of InsertVisitedURIs.
+      place =
+        new PlaceInfo(mPlace.placeId, mPlace.guid, uri.forget(), mPlace.title,
+                      -1, visits);
+    }
+    else {
+      // Same as above.
+      place =
+        new PlaceInfo(mPlace.placeId, mPlace.guid, uri.forget(), mPlace.title,
+                      -1);
+    }
+
+    if (NS_SUCCEEDED(mResult) && hasValidURIs) {
+      (void)mCallback->HandleResult(place);
+    } else {
+      (void)mCallback->HandleError(mResult, place);
+    }
+
+    return NS_OK;
+  }
+
+private:
+  nsMainThreadPtrHandle<mozIVisitInfoCallback> mCallback;
+  VisitData mPlace;
+  const nsresult mResult;
+  bool mIsSingleVisit;
+};
+
+/**
+ * Notifies a callback object when the operation is complete.
+ */
+class NotifyCompletion : public Runnable
+{
+public:
+  explicit NotifyCompletion(const nsMainThreadPtrHandle<mozIVisitInfoCallback>& aCallback)
+  : mCallback(aCallback)
+  {
+    MOZ_ASSERT(aCallback, "Must pass a non-null callback!");
+  }
+
+  NS_IMETHOD Run() override
+  {
+    if (NS_IsMainThread()) {
+      (void)mCallback->HandleCompletion();
+    }
+    else {
+      (void)NS_DispatchToMainThread(this);
+    }
+    return NS_OK;
+  }
+
+private:
+  nsMainThreadPtrHandle<mozIVisitInfoCallback> mCallback;
+};
+
+/**
+ * Checks to see if we can add aURI to history, and dispatches an error to
+ * aCallback (if provided) if we cannot.
+ *
+ * @param aURI
+ *        The URI to check.
+ * @param [optional] aGUID
+ *        The guid of the URI to check.  This is passed back to the callback.
+ * @param [optional] aCallback
+ *        The callback to notify if the URI cannot be added to history.
+ * @return true if the URI can be added to history, false otherwise.
+ */
+bool
+CanAddURI(nsIURI* aURI,
+          const nsCString& aGUID = EmptyCString(),
+          mozIVisitInfoCallback* aCallback = nullptr)
+{
+  MOZ_ASSERT(NS_IsMainThread());
+  nsNavHistory* navHistory = nsNavHistory::GetHistoryService();
+  NS_ENSURE_TRUE(navHistory, false);
+
+  bool canAdd;
+  nsresult rv = navHistory->CanAddURI(aURI, &canAdd);
+  if (NS_SUCCEEDED(rv) && canAdd) {
+    return true;
+  };
+
+  // We cannot add the URI.  Notify the callback, if we were given one.
+  if (aCallback) {
+    VisitData place(aURI);
+    place.guid = aGUID;
+    nsMainThreadPtrHandle<mozIVisitInfoCallback>
+      callback(new nsMainThreadPtrHolder<mozIVisitInfoCallback>(aCallback));
+    nsCOMPtr<nsIRunnable> event =
+      new NotifyPlaceInfoCallback(callback, place, true, NS_ERROR_INVALID_ARG);
+    (void)NS_DispatchToMainThread(event);
+  }
+
+  return false;
+}
+
+/**
+ * Adds a visit to the database.
+ */
+class InsertVisitedURIs final: public Runnable
+{
+public:
+  /**
+   * Adds a visit to the database asynchronously.
+   *
+   * @param aConnection
+   *        The database connection to use for these operations.
+   * @param aPlaces
+   *        The locations to record visits.
+   * @param [optional] aCallback
+   *        The callback to notify about the visit.
+   */
+  static nsresult Start(mozIStorageConnection* aConnection,
+                        nsTArray<VisitData>& aPlaces,
+                        mozIVisitInfoCallback* aCallback = nullptr)
+  {
+    MOZ_ASSERT(NS_IsMainThread(), "This should be called on the main thread");
+    MOZ_ASSERT(aPlaces.Length() > 0, "Must pass a non-empty array!");
+
+    // Make sure nsNavHistory service is up before proceeding:
+    nsNavHistory* navHistory = nsNavHistory::GetHistoryService();
+    MOZ_ASSERT(navHistory, "Could not get nsNavHistory?!");
+    if (!navHistory) {
+      return NS_ERROR_FAILURE;
+    }
+
+    nsMainThreadPtrHandle<mozIVisitInfoCallback>
+      callback(new nsMainThreadPtrHolder<mozIVisitInfoCallback>(aCallback));
+    RefPtr<InsertVisitedURIs> event =
+      new InsertVisitedURIs(aConnection, aPlaces, callback);
+
+    // Get the target thread, and then start the work!
+    nsCOMPtr<nsIEventTarget> target = do_GetInterface(aConnection);
+    NS_ENSURE_TRUE(target, NS_ERROR_UNEXPECTED);
+    nsresult rv = target->Dispatch(event, NS_DISPATCH_NORMAL);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    return NS_OK;
+  }
+
+  NS_IMETHOD Run() override
+  {
+    MOZ_ASSERT(!NS_IsMainThread(), "This should not be called on the main thread");
+
+    // Prevent the main thread from shutting down while this is running.
+    MutexAutoLock lockedScope(mHistory->GetShutdownMutex());
+    if (mHistory->IsShuttingDown()) {
+      // If we were already shutting down, we cannot insert the URIs.
+      return NS_OK;
+    }
+
+    mozStorageTransaction transaction(mDBConn, false,
+                                      mozIStorageConnection::TRANSACTION_IMMEDIATE);
+
+    VisitData* lastFetchedPlace = nullptr;
+    for (nsTArray<VisitData>::size_type i = 0; i < mPlaces.Length(); i++) {
+      VisitData& place = mPlaces.ElementAt(i);
+
+      // Fetching from the database can overwrite this information, so save it
+      // apart.
+      bool typed = place.typed;
+      bool hidden = place.hidden;
+
+      // We can avoid a database lookup if it's the same place as the last
+      // visit we added.
+      bool known = lastFetchedPlace && lastFetchedPlace->spec.Equals(place.spec);
+      if (!known) {
+        nsresult rv = mHistory->FetchPageInfo(place, &known);
+        if (NS_FAILED(rv)) {
+          if (!!mCallback) {
+            nsCOMPtr<nsIRunnable> event =
+              new NotifyPlaceInfoCallback(mCallback, place, true, rv);
+            return NS_DispatchToMainThread(event);
+          }
+          return NS_OK;
+        }
+        lastFetchedPlace = &mPlaces.ElementAt(i);
+      } else {
+        // Copy over the data from the already known place.
+        place.placeId = lastFetchedPlace->placeId;
+        place.guid = lastFetchedPlace->guid;
+        place.lastVisitId = lastFetchedPlace->visitId;
+        place.lastVisitTime = lastFetchedPlace->visitTime;
+        place.titleChanged = !lastFetchedPlace->title.Equals(place.title);
+        place.frecency = lastFetchedPlace->frecency;
+        // Add one visit for the previous loop.
+        place.visitCount = ++(*lastFetchedPlace).visitCount;
+      }
+
+      // If any transition is typed, ensure the page is marked as typed.
+      if (typed != lastFetchedPlace->typed) {
+        place.typed = true;
+      }
+
+      // If any transition is visible, ensure the page is marked as visible.
+      if (hidden != lastFetchedPlace->hidden) {
+        place.hidden = false;
+      }
+
+      // If this is a new page, or the existing page was already visible,
+      // there's no need to try to unhide it.
+      if (!known || !lastFetchedPlace->hidden) {
+        place.shouldUpdateHidden = false;
+      }
+
+      FetchReferrerInfo(place);
+
+      nsresult rv = DoDatabaseInserts(known, place);
+      if (!!mCallback) {
+        nsCOMPtr<nsIRunnable> event =
+          new NotifyPlaceInfoCallback(mCallback, place, true, rv);
+        nsresult rv2 = NS_DispatchToMainThread(event);
+        NS_ENSURE_SUCCESS(rv2, rv2);
+      }
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      nsCOMPtr<nsIRunnable> event = new NotifyVisitObservers(place);
+      rv = NS_DispatchToMainThread(event);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      // Notify about title change if needed.
+      if ((!known && !place.title.IsVoid()) || place.titleChanged) {
+        event = new NotifyTitleObservers(place.spec, place.title, place.guid);
+        rv = NS_DispatchToMainThread(event);
+        NS_ENSURE_SUCCESS(rv, rv);
+      }
+    }
+
+    nsresult rv = transaction.Commit();
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    return NS_OK;
+  }
+private:
+  InsertVisitedURIs(mozIStorageConnection* aConnection,
+                    nsTArray<VisitData>& aPlaces,
+                    const nsMainThreadPtrHandle<mozIVisitInfoCallback>& aCallback)
+  : mDBConn(aConnection)
+  , mCallback(aCallback)
+  , mHistory(History::GetService())
+  {
+    MOZ_ASSERT(NS_IsMainThread(), "This should be called on the main thread");
+
+    mPlaces.SwapElements(aPlaces);
+
+#ifdef DEBUG
+    for (nsTArray<VisitData>::size_type i = 0; i < mPlaces.Length(); i++) {
+      nsCOMPtr<nsIURI> uri;
+      MOZ_ASSERT(NS_SUCCEEDED(NS_NewURI(getter_AddRefs(uri), mPlaces[i].spec)));
+      MOZ_ASSERT(CanAddURI(uri),
+                 "Passed a VisitData with a URI we cannot add to history!");
+    }
+#endif
+  }
+
+  /**
+   * Inserts or updates the entry in moz_places for this visit, adds the visit,
+   * and updates the frecency of the place.
+   *
+   * @param aKnown
+   *        True if we already have an entry for this place in moz_places, false
+   *        otherwise.
+   * @param aPlace
+   *        The place we are adding a visit for.
+   */
+  nsresult DoDatabaseInserts(bool aKnown,
+                             VisitData& aPlace)
+  {
+    MOZ_ASSERT(!NS_IsMainThread(), "This should not be called on the main thread");
+
+    // If the page was in moz_places, we need to update the entry.
+    nsresult rv;
+    if (aKnown) {
+      rv = mHistory->UpdatePlace(aPlace);
+      NS_ENSURE_SUCCESS(rv, rv);
+    }
+    // Otherwise, the page was not in moz_places, so now we have to add it.
+    else {
+      rv = mHistory->InsertPlace(aPlace);
+      NS_ENSURE_SUCCESS(rv, rv);
+      aPlace.placeId = nsNavHistory::sLastInsertedPlaceId;
+    }
+    MOZ_ASSERT(aPlace.placeId > 0);
+
+    rv = AddVisit(aPlace);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    // TODO (bug 623969) we shouldn't update this after each visit, but
+    // rather only for each unique place to save disk I/O.
+
+    // Don't update frecency if the page should not appear in autocomplete.
+    if (aPlace.shouldUpdateFrecency) {
+      rv = UpdateFrecency(aPlace);
+      NS_ENSURE_SUCCESS(rv, rv);
+    }
+
+    return NS_OK;
+  }
+
+  /**
+   * Fetches information about a referrer for aPlace if it was a recent
+   * visit or not.
+   *
+   * @param aPlace
+   *        The VisitData for the visit we will eventually add.
+   *
+   */
+  void FetchReferrerInfo(VisitData& aPlace)
+  {
+    if (aPlace.referrerSpec.IsEmpty()) {
+      return;
+    }
+
+    VisitData referrer;
+    referrer.spec = aPlace.referrerSpec;
+    // If the referrer is the same as the page, we don't need to fetch it.
+    if (aPlace.referrerSpec.Equals(aPlace.spec)) {
+      referrer = aPlace;
+      // The page last visit id is also the referrer visit id.
+      aPlace.referrerVisitId = aPlace.lastVisitId;
+    } else {
+      bool exists = false;
+      if (NS_SUCCEEDED(mHistory->FetchPageInfo(referrer, &exists)) && exists) {
+        // Copy the referrer last visit id.
+        aPlace.referrerVisitId = referrer.lastVisitId;
+      }
+    }
+
+    // Check if the page has effectively been visited recently, otherwise
+    // discard the referrer info.
+    if (!aPlace.referrerVisitId || !referrer.lastVisitTime ||
+        aPlace.visitTime - referrer.lastVisitTime > RECENT_EVENT_THRESHOLD) {
+      // We will not be using the referrer data.
+      aPlace.referrerSpec.Truncate();
+      aPlace.referrerVisitId = 0;
+    }
+  }
+
+  /**
+   * Adds a visit for _place and updates it with the right visit id.
+   *
+   * @param _place
+   *        The VisitData for the place we need to know visit information about.
+   */
+  nsresult AddVisit(VisitData& _place)
+  {
+    MOZ_ASSERT(_place.placeId > 0);
+
+    nsresult rv;
+    nsCOMPtr<mozIStorageStatement> stmt;
+    stmt = mHistory->GetStatement(
+      "INSERT INTO moz_historyvisits "
+        "(from_visit, place_id, visit_date, visit_type, session) "
+      "VALUES (:from_visit, :page_id, :visit_date, :visit_type, 0) "
+    );
+    NS_ENSURE_STATE(stmt);
+    mozStorageStatementScoper scoper(stmt);
+
+    rv = stmt->BindInt64ByName(NS_LITERAL_CSTRING("page_id"), _place.placeId);
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = stmt->BindInt64ByName(NS_LITERAL_CSTRING("from_visit"),
+                               _place.referrerVisitId);
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = stmt->BindInt64ByName(NS_LITERAL_CSTRING("visit_date"),
+                               _place.visitTime);
+    NS_ENSURE_SUCCESS(rv, rv);
+    uint32_t transitionType = _place.transitionType;
+    MOZ_ASSERT(transitionType >= nsINavHistoryService::TRANSITION_LINK &&
+               transitionType <= nsINavHistoryService::TRANSITION_RELOAD,
+                 "Invalid transition type!");
+    rv = stmt->BindInt32ByName(NS_LITERAL_CSTRING("visit_type"),
+                               transitionType);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    rv = stmt->Execute();
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    _place.visitId = nsNavHistory::sLastInsertedVisitId;
+    MOZ_ASSERT(_place.visitId > 0);
+
+    return NS_OK;
+  }
+
+  /**
+   * Updates the frecency, and possibly the hidden-ness of aPlace.
+   *
+   * @param aPlace
+   *        The VisitData for the place we want to update.
+   */
+  nsresult UpdateFrecency(const VisitData& aPlace)
+  {
+    MOZ_ASSERT(aPlace.shouldUpdateFrecency);
+    MOZ_ASSERT(aPlace.placeId > 0);
+
+    nsresult rv;
+    { // First, set our frecency to the proper value.
+      nsCOMPtr<mozIStorageStatement> stmt;
+      stmt = mHistory->GetStatement(
+        "UPDATE moz_places "
+        "SET frecency = NOTIFY_FRECENCY("
+          "CALCULATE_FRECENCY(:page_id), "
+          "url, guid, hidden, last_visit_date"
+        ") "
+        "WHERE id = :page_id"
+      );
+      NS_ENSURE_STATE(stmt);
+      mozStorageStatementScoper scoper(stmt);
+
+      rv = stmt->BindInt64ByName(NS_LITERAL_CSTRING("page_id"), aPlace.placeId);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      rv = stmt->Execute();
+      NS_ENSURE_SUCCESS(rv, rv);
+    }
+
+    if (!aPlace.hidden && aPlace.shouldUpdateHidden) {
+      // Mark the page as not hidden if the frecency is now nonzero.
+      nsCOMPtr<mozIStorageStatement> stmt;
+      stmt = mHistory->GetStatement(
+        "UPDATE moz_places "
+        "SET hidden = 0 "
+        "WHERE id = :page_id AND frecency <> 0"
+      );
+      NS_ENSURE_STATE(stmt);
+      mozStorageStatementScoper scoper(stmt);
+
+      rv = stmt->BindInt64ByName(NS_LITERAL_CSTRING("page_id"), aPlace.placeId);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      rv = stmt->Execute();
+      NS_ENSURE_SUCCESS(rv, rv);
+    }
+
+    return NS_OK;
+  }
+
+  mozIStorageConnection* mDBConn;
+
+  nsTArray<VisitData> mPlaces;
+
+  nsMainThreadPtrHandle<mozIVisitInfoCallback> mCallback;
+
+  /**
+   * Strong reference to the History object because we do not want it to
+   * disappear out from under us.
+   */
+  RefPtr<History> mHistory;
+};
+
+class GetPlaceInfo final : public Runnable {
+public:
+  /**
+   * Get the place info for a given place (by GUID or URI)  asynchronously.
+   */
+  static nsresult Start(mozIStorageConnection* aConnection,
+                        VisitData& aPlace,
+                        mozIVisitInfoCallback* aCallback) {
+    MOZ_ASSERT(NS_IsMainThread(), "This should be called on the main thread");
+
+    nsMainThreadPtrHandle<mozIVisitInfoCallback>
+      callback(new nsMainThreadPtrHolder<mozIVisitInfoCallback>(aCallback));
+    RefPtr<GetPlaceInfo> event = new GetPlaceInfo(aPlace, callback);
+
+    // Get the target thread, and then start the work!
+    nsCOMPtr<nsIEventTarget> target = do_GetInterface(aConnection);
+    NS_ENSURE_TRUE(target, NS_ERROR_UNEXPECTED);
+    nsresult rv = target->Dispatch(event, NS_DISPATCH_NORMAL);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    return NS_OK;
+  }
+
+  NS_IMETHOD Run() override
+  {
+    MOZ_ASSERT(!NS_IsMainThread(), "This should not be called on the main thread");
+
+    bool exists;
+    nsresult rv = mHistory->FetchPageInfo(mPlace, &exists);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    if (!exists)
+      rv = NS_ERROR_NOT_AVAILABLE;
+
+    nsCOMPtr<nsIRunnable> event =
+      new NotifyPlaceInfoCallback(mCallback, mPlace, false, rv);
+
+    rv = NS_DispatchToMainThread(event);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    return NS_OK;
+  }
+private:
+  GetPlaceInfo(VisitData& aPlace,
+               const nsMainThreadPtrHandle<mozIVisitInfoCallback>& aCallback)
+  : mPlace(aPlace)
+  , mCallback(aCallback)
+  , mHistory(History::GetService())
+  {
+    MOZ_ASSERT(NS_IsMainThread(), "This should be called on the main thread");
+  }
+
+  VisitData mPlace;
+  nsMainThreadPtrHandle<mozIVisitInfoCallback> mCallback;
+  RefPtr<History> mHistory;
+};
+
+/**
+ * Sets the page title for a page in moz_places (if necessary).
+ */
+class SetPageTitle : public Runnable
+{
+public:
+  /**
+   * Sets a pages title in the database asynchronously.
+   *
+   * @param aConnection
+   *        The database connection to use for this operation.
+   * @param aURI
+   *        The URI to set the page title on.
+   * @param aTitle
+   *        The title to set for the page, if the page exists.
+   */
+  static nsresult Start(mozIStorageConnection* aConnection,
+                        nsIURI* aURI,
+                        const nsAString& aTitle)
+  {
+    MOZ_ASSERT(NS_IsMainThread(), "This should be called on the main thread");
+    MOZ_ASSERT(aURI, "Must pass a non-null URI object!");
+
+    nsCString spec;
+    nsresult rv = aURI->GetSpec(spec);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    RefPtr<SetPageTitle> event = new SetPageTitle(spec, aTitle);
+
+    // Get the target thread, and then start the work!
+    nsCOMPtr<nsIEventTarget> target = do_GetInterface(aConnection);
+    NS_ENSURE_TRUE(target, NS_ERROR_UNEXPECTED);
+    rv = target->Dispatch(event, NS_DISPATCH_NORMAL);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    return NS_OK;
+  }
+
+  NS_IMETHOD Run() override
+  {
+    MOZ_ASSERT(!NS_IsMainThread(), "This should not be called on the main thread");
+
+    // First, see if the page exists in the database (we'll need its id later).
+    bool exists;
+    nsresult rv = mHistory->FetchPageInfo(mPlace, &exists);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    if (!exists || !mPlace.titleChanged) {
+      // We have no record of this page, or we have no title change, so there
+      // is no need to do any further work.
+      return NS_OK;
+    }
+
+    MOZ_ASSERT(mPlace.placeId > 0,
+               "We somehow have an invalid place id here!");
+
+    // Now we can update our database record.
+    nsCOMPtr<mozIStorageStatement> stmt =
+      mHistory->GetStatement(
+        "UPDATE moz_places "
+        "SET title = :page_title "
+        "WHERE id = :page_id "
+      );
+    NS_ENSURE_STATE(stmt);
+
+    {
+      mozStorageStatementScoper scoper(stmt);
+      rv = stmt->BindInt64ByName(NS_LITERAL_CSTRING("page_id"), mPlace.placeId);
+      NS_ENSURE_SUCCESS(rv, rv);
+      // Empty strings should clear the title, just like
+      // nsNavHistory::SetPageTitle.
+      if (mPlace.title.IsEmpty()) {
+        rv = stmt->BindNullByName(NS_LITERAL_CSTRING("page_title"));
+      }
+      else {
+        rv = stmt->BindStringByName(NS_LITERAL_CSTRING("page_title"),
+                                    StringHead(mPlace.title, TITLE_LENGTH_MAX));
+      }
+      NS_ENSURE_SUCCESS(rv, rv);
+      rv = stmt->Execute();
+      NS_ENSURE_SUCCESS(rv, rv);
+    }
+
+    nsCOMPtr<nsIRunnable> event =
+      new NotifyTitleObservers(mPlace.spec, mPlace.title, mPlace.guid);
+    rv = NS_DispatchToMainThread(event);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    return NS_OK;
+  }
+
+private:
+  SetPageTitle(const nsCString& aSpec,
+               const nsAString& aTitle)
+  : mHistory(History::GetService())
+  {
+    mPlace.spec = aSpec;
+    mPlace.title = aTitle;
+  }
+
+  VisitData mPlace;
+
+  /**
+   * Strong reference to the History object because we do not want it to
+   * disappear out from under us.
+   */
+  RefPtr<History> mHistory;
+};
+
+/**
+ * Adds download-specific annotations to a download page.
+ */
+class SetDownloadAnnotations final : public mozIVisitInfoCallback
+{
+public:
+  NS_DECL_ISUPPORTS
+
+  explicit SetDownloadAnnotations(nsIURI* aDestination)
+  : mDestination(aDestination)
+  , mHistory(History::GetService())
+  {
+    MOZ_ASSERT(mDestination);
+    MOZ_ASSERT(NS_IsMainThread());
+  }
+
+  NS_IMETHOD HandleError(nsresult aResultCode, mozIPlaceInfo *aPlaceInfo) override
+  {
+    // Just don't add the annotations in case the visit isn't added.
+    return NS_OK;
+  }
+
+  NS_IMETHOD HandleResult(mozIPlaceInfo *aPlaceInfo) override
+  {
+    // Exit silently if the download destination is not a local file.
+    nsCOMPtr<nsIFileURL> destinationFileURL = do_QueryInterface(mDestination);
+    if (!destinationFileURL) {
+      return NS_OK;
+    }
+
+    nsCOMPtr<nsIURI> source;
+    nsresult rv = aPlaceInfo->GetUri(getter_AddRefs(source));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    nsCOMPtr<nsIFile> destinationFile;
+    rv = destinationFileURL->GetFile(getter_AddRefs(destinationFile));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    nsAutoString destinationFileName;
+    rv = destinationFile->GetLeafName(destinationFileName);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    nsAutoCString destinationURISpec;
+    rv = destinationFileURL->GetSpec(destinationURISpec);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    // Use annotations for storing the additional download metadata.
+    nsAnnotationService* annosvc = nsAnnotationService::GetAnnotationService();
+    NS_ENSURE_TRUE(annosvc, NS_ERROR_OUT_OF_MEMORY);
+
+    rv = annosvc->SetPageAnnotationString(
+      source,
+      DESTINATIONFILEURI_ANNO,
+      NS_ConvertUTF8toUTF16(destinationURISpec),
+      0,
+      nsIAnnotationService::EXPIRE_WITH_HISTORY
+    );
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    rv = annosvc->SetPageAnnotationString(
+      source,
+      DESTINATIONFILENAME_ANNO,
+      destinationFileName,
+      0,
+      nsIAnnotationService::EXPIRE_WITH_HISTORY
+    );
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    nsAutoString title;
+    rv = aPlaceInfo->GetTitle(title);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    // In case we are downloading a file that does not correspond to a web
+    // page for which the title is present, we populate the otherwise empty
+    // history title with the name of the destination file, to allow it to be
+    // visible and searchable in history results.
+    if (title.IsEmpty()) {
+      rv = mHistory->SetURITitle(source, destinationFileName);
+      NS_ENSURE_SUCCESS(rv, rv);
+    }
+
+    return NS_OK;
+  }
+
+  NS_IMETHOD HandleCompletion() override
+  {
+    return NS_OK;
+  }
+
+private:
+  ~SetDownloadAnnotations() {}
+
+  nsCOMPtr<nsIURI> mDestination;
+
+  /**
+   * Strong reference to the History object because we do not want it to
+   * disappear out from under us.
+   */
+  RefPtr<History> mHistory;
+};
+NS_IMPL_ISUPPORTS(
+  SetDownloadAnnotations,
+  mozIVisitInfoCallback
+)
+
+/**
+ * Notify removed visits to observers.
+ */
+class NotifyRemoveVisits : public Runnable
+{
+public:
+
+  explicit NotifyRemoveVisits(nsTHashtable<PlaceHashKey>& aPlaces)
+    : mPlaces(VISITS_REMOVAL_INITIAL_HASH_LENGTH)
+    , mHistory(History::GetService())
+  {
+    MOZ_ASSERT(!NS_IsMainThread(),
+               "This should not be called on the main thread");
+    for (auto iter = aPlaces.Iter(); !iter.Done(); iter.Next()) {
+      PlaceHashKey* entry = iter.Get();
+      PlaceHashKey* copy = mPlaces.PutEntry(entry->GetKey());
+      copy->SetProperties(entry->VisitCount(), entry->IsBookmarked());
+      entry->mVisits.SwapElements(copy->mVisits);
+    }
+  }
+
+  NS_IMETHOD Run() override
+  {
+    MOZ_ASSERT(NS_IsMainThread(), "This should be called on the main thread");
+
+    // We are in the main thread, no need to lock.
+    if (mHistory->IsShuttingDown()) {
+      // If we are shutting down, we cannot notify the observers.
+      return NS_OK;
+    }
+
+    nsNavHistory* navHistory = nsNavHistory::GetHistoryService();
+    if (!navHistory) {
+      NS_WARNING("Cannot notify without the history service!");
+      return NS_OK;
+    }
+
+    // Wrap all notifications in a batch, so the view can handle changes in a
+    // more performant way, by initiating a refresh after a limited number of
+    // single changes.
+    (void)navHistory->BeginUpdateBatch();
+    for (auto iter = mPlaces.Iter(); !iter.Done(); iter.Next()) {
+      PlaceHashKey* entry = iter.Get();
+      const nsTArray<VisitData>& visits = entry->mVisits;
+      nsCOMPtr<nsIURI> uri;
+      MOZ_ALWAYS_SUCCEEDS(NS_NewURI(getter_AddRefs(uri), visits[0].spec));
+      // Notify an expiration only if we have a valid uri, otherwise
+      // the observer couldn't gather any useful data from the notification.
+      // This should be false only if there's a bug in the code preceding us.
+      if (uri) {
+        bool removingPage = visits.Length() == entry->VisitCount() &&
+                            !entry->IsBookmarked();
+
+        // FindRemovableVisits only sets the transition type on the VisitData
+        // objects it collects if the visits were filtered by transition type.
+        // RemoveVisitsFilter currently only supports filtering by transition
+        // type, so FindRemovableVisits will either find all visits, or all
+        // visits of a given type. Therefore, if transitionType is set on this
+        // visit, we pass the transition type to NotifyOnPageExpired which in
+        // turns passes it to OnDeleteVisits to indicate that all visits of a
+        // given type were removed.
+        uint32_t transition = visits[0].transitionType < UINT32_MAX
+                            ? visits[0].transitionType
+                            : 0;
+        navHistory->NotifyOnPageExpired(uri, visits[0].visitTime, removingPage,
+                                        visits[0].guid,
+                                        nsINavHistoryObserver::REASON_DELETED,
+                                        transition);
+      }
+    }
+    (void)navHistory->EndUpdateBatch();
+
+    return NS_OK;
+  }
+
+private:
+  nsTHashtable<PlaceHashKey> mPlaces;
+
+  /**
+   * Strong reference to the History object because we do not want it to
+   * disappear out from under us.
+   */
+  RefPtr<History> mHistory;
+};
+
+/**
+ * Remove visits from history.
+ */
+class RemoveVisits : public Runnable
+{
+public:
+  /**
+   * Asynchronously removes visits from history.
+   *
+   * @param aConnection
+   *        The database connection to use for these operations.
+   * @param aFilter
+   *        Filter to remove visits.
+   */
+  static nsresult Start(mozIStorageConnection* aConnection,
+                        RemoveVisitsFilter& aFilter)
+  {
+    MOZ_ASSERT(NS_IsMainThread(), "This should be called on the main thread");
+
+    RefPtr<RemoveVisits> event = new RemoveVisits(aConnection, aFilter);
+
+    // Get the target thread, and then start the work!
+    nsCOMPtr<nsIEventTarget> target = do_GetInterface(aConnection);
+    NS_ENSURE_TRUE(target, NS_ERROR_UNEXPECTED);
+    nsresult rv = target->Dispatch(event, NS_DISPATCH_NORMAL);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    return NS_OK;
+  }
+
+  NS_IMETHOD Run() override
+  {
+    MOZ_ASSERT(!NS_IsMainThread(),
+               "This should not be called on the main thread");
+
+    // Prevent the main thread from shutting down while this is running.
+    MutexAutoLock lockedScope(mHistory->GetShutdownMutex());
+    if (mHistory->IsShuttingDown()) {
+      // If we were already shutting down, we cannot remove the visits.
+      return NS_OK;
+    }
+
+    // Find all the visits relative to the current filters and whether their
+    // pages will be removed or not.
+    nsTHashtable<PlaceHashKey> places(VISITS_REMOVAL_INITIAL_HASH_LENGTH);
+    nsresult rv = FindRemovableVisits(places);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    if (places.Count() == 0)
+      return NS_OK;
+
+    mozStorageTransaction transaction(mDBConn, false,
+                                      mozIStorageConnection::TRANSACTION_IMMEDIATE);
+
+    rv = RemoveVisitsFromDatabase();
+    NS_ENSURE_SUCCESS(rv, rv);
+    rv = RemovePagesFromDatabase(places);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    rv = transaction.Commit();
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    nsCOMPtr<nsIRunnable> event = new NotifyRemoveVisits(places);
+    rv = NS_DispatchToMainThread(event);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    return NS_OK;
+  }
+
+private:
+  RemoveVisits(mozIStorageConnection* aConnection,
+               RemoveVisitsFilter& aFilter)
+  : mDBConn(aConnection)
+  , mHasTransitionType(false)
+  , mHistory(History::GetService())
+  {
+    MOZ_ASSERT(NS_IsMainThread(), "This should be called on the main thread");
+
+    // Build query conditions.
+    nsTArray<nsCString> conditions;
+    // TODO: add support for binding params when adding further stuff here.
+    if (aFilter.transitionType < UINT32_MAX) {
+      conditions.AppendElement(nsPrintfCString("visit_type = %d", aFilter.transitionType));
+      mHasTransitionType = true;
+    }
+    if (conditions.Length() > 0) {
+      mWhereClause.AppendLiteral (" WHERE ");
+      for (uint32_t i = 0; i < conditions.Length(); ++i) {
+        if (i > 0)
+          mWhereClause.AppendLiteral(" AND ");
+        mWhereClause.Append(conditions[i]);
+      }
+    }
+  }
+
+  /**
+   * Find the list of entries that may be removed from `moz_places`.
+   *
+   * Calling this method makes sense only if we are not clearing the entire history.
+   */
+  nsresult
+  FindRemovableVisits(nsTHashtable<PlaceHashKey>& aPlaces)
+  {
+    MOZ_ASSERT(!NS_IsMainThread(),
+               "This should not be called on the main thread");
+
+    nsCString query("SELECT h.id, url, guid, visit_date, visit_type, "
+                    "(SELECT count(*) FROM moz_historyvisits WHERE place_id = h.id) as full_visit_count, "
+                    "EXISTS(SELECT 1 FROM moz_bookmarks WHERE fk = h.id) as bookmarked "
+                    "FROM moz_historyvisits "
+                    "JOIN moz_places h ON place_id = h.id");
+    query.Append(mWhereClause);
+
+    nsCOMPtr<mozIStorageStatement> stmt = mHistory->GetStatement(query);
+    NS_ENSURE_STATE(stmt);
+    mozStorageStatementScoper scoper(stmt);
+
+    bool hasResult;
+    nsresult rv;
+    while (NS_SUCCEEDED((rv = stmt->ExecuteStep(&hasResult))) && hasResult) {
+      VisitData visit;
+      rv = stmt->GetInt64(0, &visit.placeId);
+      NS_ENSURE_SUCCESS(rv, rv);
+      rv = stmt->GetUTF8String(1, visit.spec);
+      NS_ENSURE_SUCCESS(rv, rv);
+      rv = stmt->GetUTF8String(2, visit.guid);
+      NS_ENSURE_SUCCESS(rv, rv);
+      rv = stmt->GetInt64(3, &visit.visitTime);
+      NS_ENSURE_SUCCESS(rv, rv);
+      if (mHasTransitionType) {
+        int32_t transition;
+        rv = stmt->GetInt32(4, &transition);
+        NS_ENSURE_SUCCESS(rv, rv);
+        visit.transitionType = static_cast<uint32_t>(transition);
+      }
+      int32_t visitCount, bookmarked;
+      rv = stmt->GetInt32(5, &visitCount);
+      NS_ENSURE_SUCCESS(rv, rv);
+      rv = stmt->GetInt32(6, &bookmarked);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      PlaceHashKey* entry = aPlaces.GetEntry(visit.spec);
+      if (!entry) {
+        entry = aPlaces.PutEntry(visit.spec);
+      }
+      entry->SetProperties(static_cast<uint32_t>(visitCount), static_cast<bool>(bookmarked));
+      entry->mVisits.AppendElement(visit);
+    }
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    return NS_OK;
+  }
+
+  nsresult
+  RemoveVisitsFromDatabase()
+  {
+    MOZ_ASSERT(!NS_IsMainThread(),
+               "This should not be called on the main thread");
+
+    nsCString query("DELETE FROM moz_historyvisits");
+    query.Append(mWhereClause);
+
+    nsCOMPtr<mozIStorageStatement> stmt = mHistory->GetStatement(query);
+    NS_ENSURE_STATE(stmt);
+    mozStorageStatementScoper scoper(stmt);
+    nsresult rv = stmt->Execute();
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    return NS_OK;
+  }
+
+  nsresult
+  RemovePagesFromDatabase(nsTHashtable<PlaceHashKey>& aPlaces)
+  {
+    MOZ_ASSERT(!NS_IsMainThread(),
+               "This should not be called on the main thread");
+
+    nsCString placeIdsToRemove;
+    for (auto iter = aPlaces.Iter(); !iter.Done(); iter.Next()) {
+      PlaceHashKey* entry = iter.Get();
+      const nsTArray<VisitData>& visits = entry->mVisits;
+      // Only orphan ids should be listed.
+      if (visits.Length() == entry->VisitCount() && !entry->IsBookmarked()) {
+        if (!placeIdsToRemove.IsEmpty())
+          placeIdsToRemove.Append(',');
+        placeIdsToRemove.AppendInt(visits[0].placeId);
+      }
+    }
+
+#ifdef DEBUG
+    {
+      // Ensure that we are not removing any problematic entry.
+      nsCString query("SELECT id FROM moz_places h WHERE id IN (");
+      query.Append(placeIdsToRemove);
+      query.AppendLiteral(") AND ("
+          "EXISTS(SELECT 1 FROM moz_bookmarks WHERE fk = h.id) OR "
+          "EXISTS(SELECT 1 FROM moz_historyvisits WHERE place_id = h.id) OR "
+          "SUBSTR(h.url, 1, 6) = 'place:' "
+        ")");
+      nsCOMPtr<mozIStorageStatement> stmt = mHistory->GetStatement(query);
+      NS_ENSURE_STATE(stmt);
+      mozStorageStatementScoper scoper(stmt);
+      bool hasResult;
+      MOZ_ASSERT(NS_SUCCEEDED(stmt->ExecuteStep(&hasResult)) && !hasResult,
+                 "Trying to remove a non-oprhan place from the database");
+    }
+#endif
+
+    {
+      nsCString query("DELETE FROM moz_places "
+                      "WHERE id IN (");
+      query.Append(placeIdsToRemove);
+      query.Append(')');
+
+      nsCOMPtr<mozIStorageStatement> stmt = mHistory->GetStatement(query);
+      NS_ENSURE_STATE(stmt);
+      mozStorageStatementScoper scoper(stmt);
+      nsresult rv = stmt->Execute();
+      NS_ENSURE_SUCCESS(rv, rv);
+    }
+
+    {
+      // Hosts accumulated during the places delete are updated through a trigger
+      // (see nsPlacesTriggers.h).
+      nsAutoCString query("DELETE FROM moz_updatehosts_temp");
+      nsCOMPtr<mozIStorageStatement> stmt = mHistory->GetStatement(query);
+      NS_ENSURE_STATE(stmt);
+      mozStorageStatementScoper scoper(stmt);
+      nsresult rv = stmt->Execute();
+      NS_ENSURE_SUCCESS(rv, rv);
+    }
+
+    return NS_OK;
+  }
+
+  mozIStorageConnection* mDBConn;
+  bool mHasTransitionType;
+  nsCString mWhereClause;
+
+  /**
+   * Strong reference to the History object because we do not want it to
+   * disappear out from under us.
+   */
+  RefPtr<History> mHistory;
+};
+
+/**
+ * Stores an embed visit, and notifies observers.
+ *
+ * @param aPlace
+ *        The VisitData of the visit to store as an embed visit.
+ * @param [optional] aCallback
+ *        The mozIVisitInfoCallback to notify, if provided.
+ */
+void
+StoreAndNotifyEmbedVisit(VisitData& aPlace,
+                         mozIVisitInfoCallback* aCallback = nullptr)
+{
+  MOZ_ASSERT(aPlace.transitionType == nsINavHistoryService::TRANSITION_EMBED,
+             "Must only pass TRANSITION_EMBED visits to this!");
+  MOZ_ASSERT(NS_IsMainThread(), "Must be called on the main thread!");
+
+  nsCOMPtr<nsIURI> uri;
+  MOZ_ALWAYS_SUCCEEDS(NS_NewURI(getter_AddRefs(uri), aPlace.spec));
+
+  nsNavHistory* navHistory = nsNavHistory::GetHistoryService();
+  if (!navHistory || !uri) {
+    return;
+  }
+
+  navHistory->registerEmbedVisit(uri, aPlace.visitTime);
+
+  if (!!aCallback) {
+    nsMainThreadPtrHandle<mozIVisitInfoCallback>
+      callback(new nsMainThreadPtrHolder<mozIVisitInfoCallback>(aCallback));
+    nsCOMPtr<nsIRunnable> event =
+      new NotifyPlaceInfoCallback(callback, aPlace, true, NS_OK);
+    (void)NS_DispatchToMainThread(event);
+  }
+
+  nsCOMPtr<nsIRunnable> event = new NotifyVisitObservers(aPlace);
+  (void)NS_DispatchToMainThread(event);
+}
+
+} // namespace
+
+////////////////////////////////////////////////////////////////////////////////
+//// History
+
+History* History::gService = nullptr;
+
+History::History()
+  : mShuttingDown(false)
+  , mShutdownMutex("History::mShutdownMutex")
+  , mObservers(VISIT_OBSERVERS_INITIAL_CACHE_LENGTH)
+  , mRecentlyVisitedURIs(RECENTLY_VISITED_URIS_SIZE)
+{
+  NS_ASSERTION(!gService, "Ruh-roh!  This service has already been created!");
+  gService = this;
+
+  nsCOMPtr<nsIObserverService> os = services::GetObserverService();
+  NS_WARNING_ASSERTION(os, "Observer service was not found!");
+  if (os) {
+    (void)os->AddObserver(this, TOPIC_PLACES_SHUTDOWN, false);
+  }
+}
+
+History::~History()
+{
+  UnregisterWeakMemoryReporter(this);
+
+  gService = nullptr;
+
+  NS_ASSERTION(mObservers.Count() == 0,
+               "Not all Links were removed before we disappear!");
+}
+
+void
+History::InitMemoryReporter()
+{
+  RegisterWeakMemoryReporter(this);
+}
+
+NS_IMETHODIMP
+History::NotifyVisited(nsIURI* aURI)
+{
+  MOZ_ASSERT(NS_IsMainThread());
+  NS_ENSURE_ARG(aURI);
+
+  nsAutoScriptBlocker scriptBlocker;
+
+  if (XRE_IsParentProcess()) {
+    nsTArray<ContentParent*> cplist;
+    ContentParent::GetAll(cplist);
+
+    if (!cplist.IsEmpty()) {
+      URIParams uri;
+      SerializeURI(aURI, uri);
+      for (uint32_t i = 0; i < cplist.Length(); ++i) {
+        Unused << cplist[i]->SendNotifyVisited(uri);
+      }
+    }
+  }
+
+  // If we have no observers for this URI, we have nothing to notify about.
+  KeyClass* key = mObservers.GetEntry(aURI);
+  if (!key) {
+    return NS_OK;
+  }
+
+  // Update status of each Link node.
+  {
+    // RemoveEntry will destroy the array, this iterator should not survive it.
+    ObserverArray::ForwardIterator iter(key->array);
+    while (iter.HasMore()) {
+      Link* link = iter.GetNext();
+      link->SetLinkState(eLinkState_Visited);
+      // Verify that the observers hash doesn't mutate while looping through
+      // the links associated with this URI.
+      MOZ_ASSERT(key == mObservers.GetEntry(aURI),
+                 "The URIs hash mutated!");
+    }
+  }
+
+  // All the registered nodes can now be removed for this URI.
+  mObservers.RemoveEntry(key);
+  return NS_OK;
+}
+
+class ConcurrentStatementsHolder final : public mozIStorageCompletionCallback {
+public:
+  NS_DECL_ISUPPORTS
+
+  explicit ConcurrentStatementsHolder(mozIStorageConnection* aDBConn)
+  {
+    DebugOnly<nsresult> rv = aDBConn->AsyncClone(true, this);
+    MOZ_ASSERT(NS_SUCCEEDED(rv));
+  }
+
+  NS_IMETHOD Complete(nsresult aStatus, nsISupports* aConnection) override {
+    if (NS_FAILED(aStatus))
+      return NS_OK;
+    mReadOnlyDBConn = do_QueryInterface(aConnection);
+
+    // Now we can create our cached statements.
+
+    if (!mIsVisitedStatement) {
+      (void)mReadOnlyDBConn->CreateAsyncStatement(NS_LITERAL_CSTRING(
+        "SELECT 1 FROM moz_places h "
+        "WHERE url_hash = hash(?1) AND url = ?1 AND last_visit_date NOTNULL "
+      ),  getter_AddRefs(mIsVisitedStatement));
+      MOZ_ASSERT(mIsVisitedStatement);
+      nsresult result = mIsVisitedStatement ? NS_OK : NS_ERROR_NOT_AVAILABLE;
+      for (int32_t i = 0; i < mIsVisitedCallbacks.Count(); ++i) {
+        DebugOnly<nsresult> rv;
+        rv = mIsVisitedCallbacks[i]->Complete(result, mIsVisitedStatement);
+        MOZ_ASSERT(NS_SUCCEEDED(rv));
+      }
+      mIsVisitedCallbacks.Clear();
+    }
+
+    return NS_OK;
+  }
+
+  void GetIsVisitedStatement(mozIStorageCompletionCallback* aCallback)
+  {
+    if (mIsVisitedStatement) {
+      DebugOnly<nsresult> rv;
+      rv = aCallback->Complete(NS_OK, mIsVisitedStatement);
+      MOZ_ASSERT(NS_SUCCEEDED(rv));
+    } else {
+      DebugOnly<bool> added = mIsVisitedCallbacks.AppendObject(aCallback);
+      MOZ_ASSERT(added);
+    }
+  }
+
+  void Shutdown() {
+    if (mReadOnlyDBConn) {
+      mIsVisitedCallbacks.Clear();
+      DebugOnly<nsresult> rv;
+      if (mIsVisitedStatement) {
+        rv = mIsVisitedStatement->Finalize();
+        MOZ_ASSERT(NS_SUCCEEDED(rv));
+      }
+      rv = mReadOnlyDBConn->AsyncClose(nullptr);
+      MOZ_ASSERT(NS_SUCCEEDED(rv));
+    }
+  }
+
+private:
+  ~ConcurrentStatementsHolder()
+  {
+  }
+
+  nsCOMPtr<mozIStorageAsyncConnection> mReadOnlyDBConn;
+  nsCOMPtr<mozIStorageAsyncStatement> mIsVisitedStatement;
+  nsCOMArray<mozIStorageCompletionCallback> mIsVisitedCallbacks;
+};
+
+NS_IMPL_ISUPPORTS(
+  ConcurrentStatementsHolder
+, mozIStorageCompletionCallback
+)
+
+nsresult
+History::GetIsVisitedStatement(mozIStorageCompletionCallback* aCallback)
+{
+  MOZ_ASSERT(NS_IsMainThread());
+  if (mShuttingDown)
+    return NS_ERROR_NOT_AVAILABLE;
+
+  if (!mConcurrentStatementsHolder) {
+    mozIStorageConnection* dbConn = GetDBConn();
+    NS_ENSURE_STATE(dbConn);
+    mConcurrentStatementsHolder = new ConcurrentStatementsHolder(dbConn);
+  }
+  mConcurrentStatementsHolder->GetIsVisitedStatement(aCallback);
+  return NS_OK;
+}
+
+nsresult
+History::InsertPlace(VisitData& aPlace)
+{
+  MOZ_ASSERT(aPlace.placeId == 0, "should not have a valid place id!");
+  MOZ_ASSERT(!aPlace.shouldUpdateHidden, "We should not need to update hidden");
+  MOZ_ASSERT(!NS_IsMainThread(), "must be called off of the main thread!");
+
+  nsCOMPtr<mozIStorageStatement> stmt = GetStatement(
+      "INSERT INTO moz_places "
+        "(url, url_hash, title, rev_host, hidden, typed, frecency, guid) "
+      "VALUES (:url, hash(:url), :title, :rev_host, :hidden, :typed, :frecency, :guid) "
+    );
+  NS_ENSURE_STATE(stmt);
+  mozStorageStatementScoper scoper(stmt);
+
+  nsresult rv = stmt->BindStringByName(NS_LITERAL_CSTRING("rev_host"),
+                                       aPlace.revHost);
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = URIBinder::Bind(stmt, NS_LITERAL_CSTRING("url"), aPlace.spec);
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsString title = aPlace.title;
+  // Empty strings should have no title, just like nsNavHistory::SetPageTitle.
+  if (title.IsEmpty()) {
+    rv = stmt->BindNullByName(NS_LITERAL_CSTRING("title"));
+  }
+  else {
+    title.Assign(StringHead(aPlace.title, TITLE_LENGTH_MAX));
+    rv = stmt->BindStringByName(NS_LITERAL_CSTRING("title"), title);
+  }
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = stmt->BindInt32ByName(NS_LITERAL_CSTRING("typed"), aPlace.typed);
+  NS_ENSURE_SUCCESS(rv, rv);
+  // When inserting a page for a first visit that should not appear in
+  // autocomplete, for example an error page, use a zero frecency.
+  int32_t frecency = aPlace.shouldUpdateFrecency ? aPlace.frecency : 0;
+  rv = stmt->BindInt32ByName(NS_LITERAL_CSTRING("frecency"), frecency);
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = stmt->BindInt32ByName(NS_LITERAL_CSTRING("hidden"), aPlace.hidden);
+  NS_ENSURE_SUCCESS(rv, rv);
+  if (aPlace.guid.IsVoid()) {
+    rv = GenerateGUID(aPlace.guid);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+  rv = stmt->BindUTF8StringByName(NS_LITERAL_CSTRING("guid"), aPlace.guid);
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = stmt->Execute();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Post an onFrecencyChanged observer notification.
+  const nsNavHistory* navHistory = nsNavHistory::GetConstHistoryService();
+  NS_ENSURE_STATE(navHistory);
+  navHistory->DispatchFrecencyChangedNotification(aPlace.spec, frecency,
+                                                  aPlace.guid,
+                                                  aPlace.hidden,
+                                                  aPlace.visitTime);
+
+  return NS_OK;
+}
+
+nsresult
+History::UpdatePlace(const VisitData& aPlace)
+{
+  MOZ_ASSERT(!NS_IsMainThread(), "must be called off of the main thread!");
+  MOZ_ASSERT(aPlace.placeId > 0, "must have a valid place id!");
+  MOZ_ASSERT(!aPlace.guid.IsVoid(), "must have a guid!");
+
+  nsCOMPtr<mozIStorageStatement> stmt = GetStatement(
+      "UPDATE moz_places "
+      "SET title = :title, "
+          "hidden = :hidden, "
+          "typed = :typed, "
+          "guid = :guid "
+      "WHERE id = :page_id "
+    );
+  NS_ENSURE_STATE(stmt);
+  mozStorageStatementScoper scoper(stmt);
+
+  nsresult rv;
+  // Empty strings should clear the title, just like nsNavHistory::SetPageTitle.
+  if (aPlace.title.IsEmpty()) {
+    rv = stmt->BindNullByName(NS_LITERAL_CSTRING("title"));
+  }
+  else {
+    rv = stmt->BindStringByName(NS_LITERAL_CSTRING("title"),
+                                StringHead(aPlace.title, TITLE_LENGTH_MAX));
+  }
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = stmt->BindInt32ByName(NS_LITERAL_CSTRING("typed"), aPlace.typed);
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = stmt->BindInt32ByName(NS_LITERAL_CSTRING("hidden"), aPlace.hidden);
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = stmt->BindUTF8StringByName(NS_LITERAL_CSTRING("guid"), aPlace.guid);
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = stmt->BindInt64ByName(NS_LITERAL_CSTRING("page_id"),
+                             aPlace.placeId);
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = stmt->Execute();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return NS_OK;
+}
+
+nsresult
+History::FetchPageInfo(VisitData& _place, bool* _exists)
+{
+  MOZ_ASSERT(!_place.spec.IsEmpty() || !_place.guid.IsEmpty(), "must have either a non-empty spec or guid!");
+  MOZ_ASSERT(!NS_IsMainThread(), "must be called off of the main thread!");
+
+  nsresult rv;
+
+  // URI takes precedence.
+  nsCOMPtr<mozIStorageStatement> stmt;
+  bool selectByURI = !_place.spec.IsEmpty();
+  if (selectByURI) {
+    stmt = GetStatement(
+      "SELECT guid, id, title, hidden, typed, frecency, visit_count, last_visit_date, "
+      "(SELECT id FROM moz_historyvisits "
+       "WHERE place_id = h.id AND visit_date = h.last_visit_date) AS last_visit_id "
+      "FROM moz_places h "
+      "WHERE url_hash = hash(:page_url) AND url = :page_url "
+    );
+    NS_ENSURE_STATE(stmt);
+
+    rv = URIBinder::Bind(stmt, NS_LITERAL_CSTRING("page_url"), _place.spec);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+  else {
+    stmt = GetStatement(
+      "SELECT url, id, title, hidden, typed, frecency, visit_count, last_visit_date, "
+      "(SELECT id FROM moz_historyvisits "
+       "WHERE place_id = h.id AND visit_date = h.last_visit_date) AS last_visit_id "
+      "FROM moz_places h "
+      "WHERE guid = :guid "
+    );
+    NS_ENSURE_STATE(stmt);
+
+    rv = stmt->BindUTF8StringByName(NS_LITERAL_CSTRING("guid"), _place.guid);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  mozStorageStatementScoper scoper(stmt);
+
+  rv = stmt->ExecuteStep(_exists);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (!*_exists) {
+    return NS_OK;
+  }
+
+  if (selectByURI) {
+    if (_place.guid.IsEmpty()) {
+      rv = stmt->GetUTF8String(0, _place.guid);
+      NS_ENSURE_SUCCESS(rv, rv);
+    }
+  }
+  else {
+    nsAutoCString spec;
+    rv = stmt->GetUTF8String(0, spec);
+    NS_ENSURE_SUCCESS(rv, rv);
+    _place.spec = spec;
+  }
+
+  rv = stmt->GetInt64(1, &_place.placeId);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsAutoString title;
+  rv = stmt->GetString(2, title);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // If the title we were given was void, that means we did not bother to set
+  // it to anything.  As a result, ignore the fact that we may have changed the
+  // title (because we don't want to, that would be empty), and set the title
+  // to what is currently stored in the datbase.
+  if (_place.title.IsVoid()) {
+    _place.title = title;
+  }
+  // Otherwise, just indicate if the title has changed.
+  else {
+    _place.titleChanged = !(_place.title.Equals(title) ||
+                            (_place.title.IsEmpty() && title.IsVoid()));
+  }
+
+  int32_t hidden;
+  rv = stmt->GetInt32(3, &hidden);
+  NS_ENSURE_SUCCESS(rv, rv);
+  _place.hidden = !!hidden;
+
+  int32_t typed;
+  rv = stmt->GetInt32(4, &typed);
+  NS_ENSURE_SUCCESS(rv, rv);
+  _place.typed = !!typed;
+
+  rv = stmt->GetInt32(5, &_place.frecency);
+  NS_ENSURE_SUCCESS(rv, rv);
+  int32_t visitCount;
+  rv = stmt->GetInt32(6, &visitCount);
+  NS_ENSURE_SUCCESS(rv, rv);
+  _place.visitCount = visitCount;
+  rv = stmt->GetInt64(7, &_place.lastVisitTime);
+  NS_ENSURE_SUCCESS(rv, rv);
+  rv = stmt->GetInt64(8, &_place.lastVisitId);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return NS_OK;
+}
+
+MOZ_DEFINE_MALLOC_SIZE_OF(HistoryMallocSizeOf)
+
+NS_IMETHODIMP
+History::CollectReports(nsIHandleReportCallback* aHandleReport,
+                        nsISupports* aData, bool aAnonymize)
+{
+  MOZ_COLLECT_REPORT(
+    "explicit/history-links-hashtable", KIND_HEAP, UNITS_BYTES,
+    SizeOfIncludingThis(HistoryMallocSizeOf),
+    "Memory used by the hashtable that records changes to the visited state "
+    "of links.");
+
+  return NS_OK;
+}
+
+size_t
+History::SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOfThis)
+{
+  return aMallocSizeOfThis(this) +
+         mObservers.SizeOfExcludingThis(aMallocSizeOfThis);
+}
+
+/* static */
+History*
+History::GetService()
+{
+  if (gService) {
+    return gService;
+  }
+
+  nsCOMPtr<IHistory> service(do_GetService(NS_IHISTORY_CONTRACTID));
+  MOZ_ASSERT(service, "Cannot obtain IHistory service!");
+  NS_ASSERTION(gService, "Our constructor was not run?!");
+
+  return gService;
+}
+
+/* static */
+History*
+History::GetSingleton()
+{
+  if (!gService) {
+    gService = new History();
+    NS_ENSURE_TRUE(gService, nullptr);
+    gService->InitMemoryReporter();
+  }
+
+  NS_ADDREF(gService);
+  return gService;
+}
+
+mozIStorageConnection*
+History::GetDBConn()
+{
+  if (mShuttingDown)
+    return nullptr;
+  if (!mDB) {
+    mDB = Database::GetDatabase();
+    NS_ENSURE_TRUE(mDB, nullptr);
+  }
+  return mDB->MainConn();
+}
+
+void
+History::Shutdown()
+{
+  MOZ_ASSERT(NS_IsMainThread());
+
+  // Prevent other threads from scheduling uses of the DB while we mark
+  // ourselves as shutting down.
+  MutexAutoLock lockedScope(mShutdownMutex);
+  MOZ_ASSERT(!mShuttingDown && "Shutdown was called more than once!");
+
+  mShuttingDown = true;
+
+  if (mConcurrentStatementsHolder) {
+    mConcurrentStatementsHolder->Shutdown();
+  }
+}
+
+void
+History::AppendToRecentlyVisitedURIs(nsIURI* aURI) {
+  // Add a new entry, if necessary.
+  RecentURIKey* entry = mRecentlyVisitedURIs.GetEntry(aURI);
+  if (!entry) {
+    entry = mRecentlyVisitedURIs.PutEntry(aURI);
+  }
+  if (entry) {
+    entry->time = PR_Now();
+  }
+
+  // Remove entries older than RECENTLY_VISITED_URIS_MAX_AGE.
+  for (auto iter = mRecentlyVisitedURIs.Iter(); !iter.Done(); iter.Next()) {
+    RecentURIKey* entry = iter.Get();
+    if ((PR_Now() - entry->time) > RECENTLY_VISITED_URIS_MAX_AGE) {
+      iter.Remove();
+    }
+  }
+}
+
+inline bool
+History::IsRecentlyVisitedURI(nsIURI* aURI) {
+  RecentURIKey* entry = mRecentlyVisitedURIs.GetEntry(aURI);
+  // Check if the entry exists and is younger than RECENTLY_VISITED_URIS_MAX_AGE.
+  return entry && (PR_Now() - entry->time) < RECENTLY_VISITED_URIS_MAX_AGE;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//// IHistory
+
+NS_IMETHODIMP
+History::VisitURI(nsIURI* aURI,
+                  nsIURI* aLastVisitedURI,
+                  uint32_t aFlags)
+{
+  NS_ENSURE_ARG(aURI);
+
+  if (mShuttingDown) {
+    return NS_OK;
+  }
+
+  if (XRE_IsContentProcess()) {
+    URIParams uri;
+    SerializeURI(aURI, uri);
+
+    OptionalURIParams lastVisitedURI;
+    SerializeURI(aLastVisitedURI, lastVisitedURI);
+
+    mozilla::dom::ContentChild* cpc =
+      mozilla::dom::ContentChild::GetSingleton();
+    NS_ASSERTION(cpc, "Content Protocol is NULL!");
+    (void)cpc->SendVisitURI(uri, lastVisitedURI, aFlags);
+    return NS_OK;
+  }
+
+  nsNavHistory* navHistory = nsNavHistory::GetHistoryService();
+  NS_ENSURE_TRUE(navHistory, NS_ERROR_OUT_OF_MEMORY);
+
+  // Silently return if URI is something we shouldn't add to DB.
+  bool canAdd;
+  nsresult rv = navHistory->CanAddURI(aURI, &canAdd);
+  NS_ENSURE_SUCCESS(rv, rv);
+  if (!canAdd) {
+    return NS_OK;
+  }
+
+  // Do not save a reloaded uri if we have visited the same URI recently.
+  bool reload = false;
+  if (aLastVisitedURI) {
+    rv = aURI->Equals(aLastVisitedURI, &reload);
+    NS_ENSURE_SUCCESS(rv, rv);
+    if (reload && IsRecentlyVisitedURI(aURI)) {
+      // Regardless we must update the stored visit time.
+      AppendToRecentlyVisitedURIs(aURI);
+      return NS_OK;
+    }
+  }
+
+  nsTArray<VisitData> placeArray(1);
+  NS_ENSURE_TRUE(placeArray.AppendElement(VisitData(aURI, aLastVisitedURI)),
+                 NS_ERROR_OUT_OF_MEMORY);
+  VisitData& place = placeArray.ElementAt(0);
+  NS_ENSURE_FALSE(place.spec.IsEmpty(), NS_ERROR_INVALID_ARG);
+
+  place.visitTime = PR_Now();
+
+  // Assigns a type to the edge in the visit linked list. Each type will be
+  // considered differently when weighting the frecency of a location.
+  uint32_t recentFlags = navHistory->GetRecentFlags(aURI);
+  bool isFollowedLink = recentFlags & nsNavHistory::RECENT_ACTIVATED;
+
+  // Embed visits should never be added to the database, and the same is valid
+  // for redirects across frames.
+  // For the above reasoning non-toplevel transitions are handled at first.
+  // if the visit is toplevel or a non-toplevel followed link, then it can be
+  // handled as usual and stored on disk.
+
+  uint32_t transitionType = nsINavHistoryService::TRANSITION_LINK;
+
+  if (!(aFlags & IHistory::TOP_LEVEL) && !isFollowedLink) {
+    // A frame redirected to a new site without user interaction.
+    transitionType = nsINavHistoryService::TRANSITION_EMBED;
+  }
+  else if (aFlags & IHistory::REDIRECT_TEMPORARY) {
+    transitionType = nsINavHistoryService::TRANSITION_REDIRECT_TEMPORARY;
+  }
+  else if (aFlags & IHistory::REDIRECT_PERMANENT) {
+    transitionType = nsINavHistoryService::TRANSITION_REDIRECT_PERMANENT;
+  }
+  else if (reload) {
+    transitionType = nsINavHistoryService::TRANSITION_RELOAD;
+  }
+  else if ((recentFlags & nsNavHistory::RECENT_TYPED) &&
+           !(aFlags & IHistory::UNRECOVERABLE_ERROR)) {
+    // Don't mark error pages as typed, even if they were actually typed by
+    // the user.  This is useful to limit their score in autocomplete.
+    transitionType = nsINavHistoryService::TRANSITION_TYPED;
+  }
+  else if (recentFlags & nsNavHistory::RECENT_BOOKMARKED) {
+    transitionType = nsINavHistoryService::TRANSITION_BOOKMARK;
+  }
+  else if (!(aFlags & IHistory::TOP_LEVEL) && isFollowedLink) {
+    // User activated a link in a frame.
+    transitionType = nsINavHistoryService::TRANSITION_FRAMED_LINK;
+  }
+
+  place.SetTransitionType(transitionType);
+  place.hidden = GetHiddenState(aFlags & IHistory::REDIRECT_SOURCE,
+                                transitionType);
+
+  // Error pages should never be autocompleted.
+  if (aFlags & IHistory::UNRECOVERABLE_ERROR) {
+    place.shouldUpdateFrecency = false;
+  }
+
+  // EMBED visits are session-persistent and should not go through the database.
+  // They exist only to keep track of isVisited status during the session.
+  if (place.transitionType == nsINavHistoryService::TRANSITION_EMBED) {
+    StoreAndNotifyEmbedVisit(place);
+  }
+  else {
+    mozIStorageConnection* dbConn = GetDBConn();
+    NS_ENSURE_STATE(dbConn);
+
+    rv = InsertVisitedURIs::Start(dbConn, placeArray);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  // Finally, notify that we've been visited.
+  nsCOMPtr<nsIObserverService> obsService =
+    mozilla::services::GetObserverService();
+  if (obsService) {
+    obsService->NotifyObservers(aURI, NS_LINK_VISITED_EVENT_TOPIC, nullptr);
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+History::RegisterVisitedCallback(nsIURI* aURI,
+                                 Link* aLink)
+{
+  MOZ_ASSERT(NS_IsMainThread());
+  NS_ASSERTION(aURI, "Must pass a non-null URI!");
+  if (XRE_IsContentProcess()) {
+    NS_PRECONDITION(aLink, "Must pass a non-null Link!");
+  }
+
+  // Obtain our array of observers for this URI.
+#ifdef DEBUG
+  bool keyAlreadyExists = !!mObservers.GetEntry(aURI);
+#endif
+  KeyClass* key = mObservers.PutEntry(aURI);
+  NS_ENSURE_TRUE(key, NS_ERROR_OUT_OF_MEMORY);
+  ObserverArray& observers = key->array;
+
+  if (observers.IsEmpty()) {
+    NS_ASSERTION(!keyAlreadyExists,
+                 "An empty key was kept around in our hashtable!");
+
+    // We are the first Link node to ask about this URI, or there are no pending
+    // Links wanting to know about this URI.  Therefore, we should query the
+    // database now.
+    nsresult rv = VisitedQuery::Start(aURI);
+
+    // In IPC builds, we are passed a nullptr Link from
+    // ContentParent::RecvStartVisitedQuery.  Since we won't be adding a
+    // nullptr entry to our list of observers, and the code after this point
+    // assumes that aLink is non-nullptr, we will need to return now.
+    if (NS_FAILED(rv) || !aLink) {
+      // Remove our array from the hashtable so we don't keep it around.
+      // In some case calling RemoveEntry on the key obtained by PutEntry
+      // crashes for currently unknown reasons.  Our suspect is that something
+      // between PutEntry and this call causes a nested loop that either removes
+      // the entry or reallocs the hash.
+      // TODO (Bug 1412647): we must figure the root cause for these issues and
+      // remove this stop-gap crash fix.
+      key = mObservers.GetEntry(aURI);
+      if (key) {
+        mObservers.RemoveEntry(key);
+      }
+      return rv;
+    }
+  }
+  // In IPC builds, we are passed a nullptr Link from
+  // ContentParent::RecvStartVisitedQuery.  All of our code after this point
+  // assumes aLink is non-nullptr, so we have to return now.
+  else if (!aLink) {
+    NS_ASSERTION(XRE_IsParentProcess(),
+                 "We should only ever get a null Link in the default process!");
+    return NS_OK;
+  }
+
+  // Sanity check that Links are not registered more than once for a given URI.
+  // This will not catch a case where it is registered for two different URIs.
+  NS_ASSERTION(!observers.Contains(aLink),
+               "Already tracking this Link object!");
+
+  // Start tracking our Link.
+  if (!observers.AppendElement(aLink)) {
+    // Curses - unregister and return failure.
+    (void)UnregisterVisitedCallback(aURI, aLink);
+    return NS_ERROR_OUT_OF_MEMORY;
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+History::UnregisterVisitedCallback(nsIURI* aURI,
+                                   Link* aLink)
+{
+  MOZ_ASSERT(NS_IsMainThread());
+  // TODO: aURI is sometimes null - see bug 548685
+  NS_ASSERTION(aURI, "Must pass a non-null URI!");
+  NS_ASSERTION(aLink, "Must pass a non-null Link object!");
+
+  // Get the array, and remove the item from it.
+  KeyClass* key = mObservers.GetEntry(aURI);
+  if (!key) {
+    NS_ERROR("Trying to unregister for a URI that wasn't registered!");
+    return NS_ERROR_UNEXPECTED;
+  }
+  ObserverArray& observers = key->array;
+  if (!observers.RemoveElement(aLink)) {
+    NS_ERROR("Trying to unregister a node that wasn't registered!");
+    return NS_ERROR_UNEXPECTED;
+  }
+
+  // If the array is now empty, we should remove it from the hashtable.
+  if (observers.IsEmpty()) {
+    mObservers.RemoveEntry(aURI);
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+History::SetURITitle(nsIURI* aURI, const nsAString& aTitle)
+{
+  NS_ENSURE_ARG(aURI);
+
+  if (mShuttingDown) {
+    return NS_OK;
+  }
+
+  if (XRE_IsContentProcess()) {
+    URIParams uri;
+    SerializeURI(aURI, uri);
+
+    mozilla::dom::ContentChild * cpc = 
+      mozilla::dom::ContentChild::GetSingleton();
+    NS_ASSERTION(cpc, "Content Protocol is NULL!");
+    (void)cpc->SendSetURITitle(uri, PromiseFlatString(aTitle));
+    return NS_OK;
+  } 
+
+  nsNavHistory* navHistory = nsNavHistory::GetHistoryService();
+
+  // At first, it seems like nav history should always be available here, no
+  // matter what.
+  //
+  // nsNavHistory fails to register as a service if there is no profile in
+  // place (for instance, if user is choosing a profile).
+  //
+  // Maybe the correct thing to do is to not register this service if no
+  // profile has been selected?
+  //
+  NS_ENSURE_TRUE(navHistory, NS_ERROR_FAILURE);
+
+  bool canAdd;
+  nsresult rv = navHistory->CanAddURI(aURI, &canAdd);
+  NS_ENSURE_SUCCESS(rv, rv);
+  if (!canAdd) {
+    return NS_OK;
+  }
+
+  // Embed visits don't have a database entry, thus don't set a title on them.
+  if (navHistory->hasEmbedVisit(aURI)) {
+    return NS_OK;
+  }
+
+  mozIStorageConnection* dbConn = GetDBConn();
+  NS_ENSURE_STATE(dbConn);
+
+  rv = SetPageTitle::Start(dbConn, aURI, aTitle);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return NS_OK;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//// nsIDownloadHistory
+
+NS_IMETHODIMP
+History::AddDownload(nsIURI* aSource, nsIURI* aReferrer,
+                     PRTime aStartTime, nsIURI* aDestination)
+{
+  MOZ_ASSERT(NS_IsMainThread());
+  NS_ENSURE_ARG(aSource);
+
+  if (mShuttingDown) {
+    return NS_OK;
+  }
+
+  if (XRE_IsContentProcess()) {
+    NS_ERROR("Cannot add downloads to history from content process!");
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  nsNavHistory* navHistory = nsNavHistory::GetHistoryService();
+  NS_ENSURE_TRUE(navHistory, NS_ERROR_OUT_OF_MEMORY);
+
+  // Silently return if URI is something we shouldn't add to DB.
+  bool canAdd;
+  nsresult rv = navHistory->CanAddURI(aSource, &canAdd);
+  NS_ENSURE_SUCCESS(rv, rv);
+  if (!canAdd) {
+    return NS_OK;
+  }
+
+  nsTArray<VisitData> placeArray(1);
+  NS_ENSURE_TRUE(placeArray.AppendElement(VisitData(aSource, aReferrer)),
+                 NS_ERROR_OUT_OF_MEMORY);
+  VisitData& place = placeArray.ElementAt(0);
+  NS_ENSURE_FALSE(place.spec.IsEmpty(), NS_ERROR_INVALID_ARG);
+
+  place.visitTime = aStartTime;
+  place.SetTransitionType(nsINavHistoryService::TRANSITION_DOWNLOAD);
+  place.hidden = false;
+
+  mozIStorageConnection* dbConn = GetDBConn();
+  NS_ENSURE_STATE(dbConn);
+
+  nsMainThreadPtrHandle<mozIVisitInfoCallback> callback;
+  if (aDestination) {
+    callback = new nsMainThreadPtrHolder<mozIVisitInfoCallback>(new SetDownloadAnnotations(aDestination));
+  }
+
+  rv = InsertVisitedURIs::Start(dbConn, placeArray, callback);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Finally, notify that we've been visited.
+  nsCOMPtr<nsIObserverService> obsService =
+    mozilla::services::GetObserverService();
+  if (obsService) {
+    obsService->NotifyObservers(aSource, NS_LINK_VISITED_EVENT_TOPIC, nullptr);
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+History::RemoveAllDownloads()
+{
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (mShuttingDown) {
+    return NS_OK;
+  }
+
+  if (XRE_IsContentProcess()) {
+    NS_ERROR("Cannot remove downloads to history from content process!");
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  // Ensure navHistory is initialized.
+  nsNavHistory* navHistory = nsNavHistory::GetHistoryService();
+  NS_ENSURE_TRUE(navHistory, NS_ERROR_OUT_OF_MEMORY);
+  mozIStorageConnection* dbConn = GetDBConn();
+  NS_ENSURE_STATE(dbConn);
+
+  RemoveVisitsFilter filter;
+  filter.transitionType = nsINavHistoryService::TRANSITION_DOWNLOAD;
+
+  nsresult rv = RemoveVisits::Start(dbConn, filter);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return NS_OK;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//// mozIAsyncHistory
+
+NS_IMETHODIMP
+History::GetPlacesInfo(JS::Handle<JS::Value> aPlaceIdentifiers,
+                       mozIVisitInfoCallback* aCallback,
+                       JSContext* aCtx)
+{
+  // Make sure nsNavHistory service is up before proceeding:
+  nsNavHistory* navHistory = nsNavHistory::GetHistoryService();
+  MOZ_ASSERT(navHistory, "Could not get nsNavHistory?!");
+  if (!navHistory) {
+    return NS_ERROR_FAILURE;
+  }
+
+  uint32_t placesIndentifiersLength;
+  JS::Rooted<JSObject*> placesIndentifiers(aCtx);
+  nsresult rv = GetJSArrayFromJSValue(aPlaceIdentifiers, aCtx,
+                                      &placesIndentifiers,
+                                      &placesIndentifiersLength);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsTArray<VisitData> placesInfo;
+  placesInfo.SetCapacity(placesIndentifiersLength);
+  for (uint32_t i = 0; i < placesIndentifiersLength; i++) {
+    JS::Rooted<JS::Value> placeIdentifier(aCtx);
+    bool rc = JS_GetElement(aCtx, placesIndentifiers, i, &placeIdentifier);
+    NS_ENSURE_TRUE(rc, NS_ERROR_UNEXPECTED);
+
+    // GUID
+    nsAutoString fatGUID;
+    GetJSValueAsString(aCtx, placeIdentifier, fatGUID);
+    if (!fatGUID.IsVoid()) {
+      NS_ConvertUTF16toUTF8 guid(fatGUID);
+      if (!IsValidGUID(guid))
+        return NS_ERROR_INVALID_ARG;
+
+      VisitData& placeInfo = *placesInfo.AppendElement(VisitData());
+      placeInfo.guid = guid;
+    }
+    else {
+      nsCOMPtr<nsIURI> uri = GetJSValueAsURI(aCtx, placeIdentifier);
+      if (!uri)
+        return NS_ERROR_INVALID_ARG; // neither a guid, nor a uri.
+      placesInfo.AppendElement(VisitData(uri));
+    }
+  }
+
+  mozIStorageConnection* dbConn = GetDBConn();
+  NS_ENSURE_STATE(dbConn);
+
+  for (nsTArray<VisitData>::size_type i = 0; i < placesInfo.Length(); i++) {
+    nsresult rv = GetPlaceInfo::Start(dbConn, placesInfo.ElementAt(i), aCallback);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  // Be sure to notify that all of our operations are complete.  This
+  // is dispatched to the background thread first and redirected to the
+  // main thread from there to make sure that all database notifications
+  // and all embed or canAddURI notifications have finished.
+  if (aCallback) {
+    nsMainThreadPtrHandle<mozIVisitInfoCallback>
+      callback(new nsMainThreadPtrHolder<mozIVisitInfoCallback>(aCallback));
+    nsCOMPtr<nsIEventTarget> backgroundThread = do_GetInterface(dbConn);
+    NS_ENSURE_TRUE(backgroundThread, NS_ERROR_UNEXPECTED);
+    nsCOMPtr<nsIRunnable> event = new NotifyCompletion(callback);
+    return backgroundThread->Dispatch(event, NS_DISPATCH_NORMAL);
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+History::UpdatePlaces(JS::Handle<JS::Value> aPlaceInfos,
+                      mozIVisitInfoCallback* aCallback,
+                      JSContext* aCtx)
+{
+  NS_ENSURE_TRUE(NS_IsMainThread(), NS_ERROR_UNEXPECTED);
+  NS_ENSURE_TRUE(!aPlaceInfos.isPrimitive(), NS_ERROR_INVALID_ARG);
+
+  uint32_t infosLength;
+  JS::Rooted<JSObject*> infos(aCtx);
+  nsresult rv = GetJSArrayFromJSValue(aPlaceInfos, aCtx, &infos, &infosLength);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsTArray<VisitData> visitData;
+  for (uint32_t i = 0; i < infosLength; i++) {
+    JS::Rooted<JSObject*> info(aCtx);
+    nsresult rv = GetJSObjectFromArray(aCtx, infos, i, &info);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    nsCOMPtr<nsIURI> uri = GetURIFromJSObject(aCtx, info, "uri");
+    nsCString guid;
+    {
+      nsString fatGUID;
+      GetStringFromJSObject(aCtx, info, "guid", fatGUID);
+      if (fatGUID.IsVoid()) {
+        guid.SetIsVoid(true);
+      }
+      else {
+        guid = NS_ConvertUTF16toUTF8(fatGUID);
+      }
+    }
+
+    // Make sure that any uri we are given can be added to history, and if not,
+    // skip it (CanAddURI will notify our callback for us).
+    if (uri && !CanAddURI(uri, guid, aCallback)) {
+      continue;
+    }
+
+    // We must have at least one of uri or guid.
+    NS_ENSURE_ARG(uri || !guid.IsVoid());
+
+    // If we were given a guid, make sure it is valid.
+    bool isValidGUID = IsValidGUID(guid);
+    NS_ENSURE_ARG(guid.IsVoid() || isValidGUID);
+
+    nsString title;
+    GetStringFromJSObject(aCtx, info, "title", title);
+
+    JS::Rooted<JSObject*> visits(aCtx, nullptr);
+    {
+      JS::Rooted<JS::Value> visitsVal(aCtx);
+      bool rc = JS_GetProperty(aCtx, info, "visits", &visitsVal);
+      NS_ENSURE_TRUE(rc, NS_ERROR_UNEXPECTED);
+      if (!visitsVal.isPrimitive()) {
+        visits = visitsVal.toObjectOrNull();
+        bool isArray;
+        if (!JS_IsArrayObject(aCtx, visits, &isArray)) {
+          return NS_ERROR_UNEXPECTED;
+        }
+        if (!isArray) {
+          return NS_ERROR_INVALID_ARG;
+        }
+      }
+    }
+    NS_ENSURE_ARG(visits);
+
+    uint32_t visitsLength = 0;
+    if (visits) {
+      (void)JS_GetArrayLength(aCtx, visits, &visitsLength);
+    }
+    NS_ENSURE_ARG(visitsLength > 0);
+
+    // Check each visit, and build our array of VisitData objects.
+    visitData.SetCapacity(visitData.Length() + visitsLength);
+    for (uint32_t j = 0; j < visitsLength; j++) {
+      JS::Rooted<JSObject*> visit(aCtx);
+      rv = GetJSObjectFromArray(aCtx, visits, j, &visit);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      VisitData& data = *visitData.AppendElement(VisitData(uri));
+      data.title = title;
+      data.guid = guid;
+
+      // We must have a date and a transaction type!
+      rv = GetIntFromJSObject(aCtx, visit, "visitDate", &data.visitTime);
+      NS_ENSURE_SUCCESS(rv, rv);
+      uint32_t transitionType = 0;
+      rv = GetIntFromJSObject(aCtx, visit, "transitionType", &transitionType);
+      NS_ENSURE_SUCCESS(rv, rv);
+      NS_ENSURE_ARG_RANGE(transitionType,
+                          nsINavHistoryService::TRANSITION_LINK,
+                          nsINavHistoryService::TRANSITION_RELOAD);
+      data.SetTransitionType(transitionType);
+      data.hidden = GetHiddenState(false, transitionType);
+
+      // If the visit is an embed visit, we do not actually add it to the
+      // database.
+      if (transitionType == nsINavHistoryService::TRANSITION_EMBED) {
+        StoreAndNotifyEmbedVisit(data, aCallback);
+        visitData.RemoveElementAt(visitData.Length() - 1);
+        continue;
+      }
+
+      // The referrer is optional.
+      nsCOMPtr<nsIURI> referrer = GetURIFromJSObject(aCtx, visit,
+                                                     "referrerURI");
+      if (referrer) {
+        (void)referrer->GetSpec(data.referrerSpec);
+      }
+    }
+  }
+
+  mozIStorageConnection* dbConn = GetDBConn();
+  NS_ENSURE_STATE(dbConn);
+
+  nsMainThreadPtrHandle<mozIVisitInfoCallback>
+    callback(new nsMainThreadPtrHolder<mozIVisitInfoCallback>(aCallback));
+
+  // It is possible that all of the visits we were passed were dissallowed by
+  // CanAddURI, which isn't an error.  If we have no visits to add, however,
+  // we should not call InsertVisitedURIs::Start.
+  if (visitData.Length()) {
+    nsresult rv = InsertVisitedURIs::Start(dbConn, visitData, callback);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  // Be sure to notify that all of our operations are complete.  This
+  // is dispatched to the background thread first and redirected to the
+  // main thread from there to make sure that all database notifications
+  // and all embed or canAddURI notifications have finished.
+  if (aCallback) {
+    nsCOMPtr<nsIEventTarget> backgroundThread = do_GetInterface(dbConn);
+    NS_ENSURE_TRUE(backgroundThread, NS_ERROR_UNEXPECTED);
+    nsCOMPtr<nsIRunnable> event = new NotifyCompletion(callback);
+    return backgroundThread->Dispatch(event, NS_DISPATCH_NORMAL);
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+History::IsURIVisited(nsIURI* aURI,
+                      mozIVisitedStatusCallback* aCallback)
+{
+  NS_ENSURE_STATE(NS_IsMainThread());
+  NS_ENSURE_ARG(aURI);
+  NS_ENSURE_ARG(aCallback);
+
+  nsresult rv = VisitedQuery::Start(aURI, aCallback);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return NS_OK;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//// nsIObserver
+
+NS_IMETHODIMP
+History::Observe(nsISupports* aSubject, const char* aTopic,
+                 const char16_t* aData)
+{
+  if (strcmp(aTopic, TOPIC_PLACES_SHUTDOWN) == 0) {
+    Shutdown();
+
+    nsCOMPtr<nsIObserverService> os = mozilla::services::GetObserverService();
+    if (os) {
+      (void)os->RemoveObserver(this, TOPIC_PLACES_SHUTDOWN);
+    }
+  }
+
+  return NS_OK;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//// nsISupports
+
+NS_IMPL_ISUPPORTS(
+  History
+, IHistory
+, nsIDownloadHistory
+, mozIAsyncHistory
+, nsIObserver
+, nsIMemoryReporter
+)
+
+} // namespace places
+} // namespace mozilla