The Tor Browser: toolkit/components/places/History.cpp@129ffea94266 (annotated)

toolkit/components/places/History.cpp@129ffea94266 (annotated)

toolkit/components/places/History.cpp

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

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

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

 /* -*- Mode: C++; tab-width: 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 "nsIXPConnect.h"
 #include "mozilla/unused.h"
 #include "nsContentUtils.h" // for nsAutoScriptBlocker
 #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_SIZE 128
 // Initial size for the visits removal hash.
 #define VISITS_REMOVAL_INITIAL_HASH_SIZE 128
 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)
   , typed(false)
   , transitionType(UINT32_MAX)
   , visitTime(0)
   , frecency(-1)
   , titleChanged(false)
   , shouldUpdateFrecency(true)
   {
     guid.SetIsVoid(true);
     title.SetIsVoid(true);
   }
   VisitData(nsIURI* aURI,
             nsIURI* aReferrer = nullptr)
   : placeId(0)
   , visitId(0)
   , hidden(true)
   , typed(false)
   , transitionType(UINT32_MAX)
   , visitTime(0)
   , frecency(-1)
   , titleChanged(false)
   , shouldUpdateFrecency(true)
   {
     (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;
   }
   /**
    * Determines if this refers to the same url as aOther, and updates aOther
    * with missing information if so.
    *
    * @param aOther
    *        The other place to check against.
    * @return true if this is a visit for the same place as aOther, false
    *         otherwise.
    */
   bool IsSamePlaceAs(VisitData& aOther)
   {
     if (!spec.Equals(aOther.spec)) {
       return false;
     }
     aOther.placeId = placeId;
     aOther.guid = guid;
     return true;
   }
   int64_t placeId;
   nsCString guid;
   int64_t visitId;
   nsCString spec;
   nsString revHost;
   bool hidden;
   bool typed;
   uint32_t transitionType;
   PRTime visitTime;
   int32_t frecency;
   /**
    * 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;
   // 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:
     PlaceHashKey(const nsACString& aSpec)
     : nsCStringHashKey(&aSpec)
     , visitCount(-1)
     , bookmarked(-1)
     {
     }
     PlaceHashKey(const nsACString* aSpec)
     : nsCStringHashKey(aSpec)
     , visitCount(-1)
     , bookmarked(-1)
     {
     }
     PlaceHashKey(const PlaceHashKey& aOther)
     : nsCStringHashKey(&aOther.GetKey())
     {
       MOZ_ASSERT(false, "Do not call me!");
     }
     // Visit count for this place.
     int32_t visitCount;
     // Whether this place is bookmarked.
     int32_t bookmarked;
     // Array of VisitData objects.
     nsTArray<VisitData> visits;
 };
 ////////////////////////////////////////////////////////////////////////////////
 //// 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());
     if (JS_IsArrayObject(aCtx, val)) {
       _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, nullptr, nullptr, 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 (!JSVAL_IS_PRIMITIVE(aValue)) {
     nsCOMPtr<nsIXPConnect> xpc = mozilla::services::GetXPConnect();
     nsCOMPtr<nsIXPConnectWrappedNative> wrappedObj;
     nsresult rv = xpc->GetWrappedNativeOfJSObject(aCtx, JSVAL_TO_OBJECT(aValue),
                                                   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 (JSVAL_IS_VOID(aValue) ||
       !(JSVAL_IS_NULL(aValue) || JSVAL_IS_STRING(aValue))) {
     _string.SetIsVoid(true);
     return;
   }
   // |null| in JS maps to the empty string.
   if (JSVAL_IS_NULL(aValue)) {
     _string.Truncate();
     return;
   }
   size_t length;
   const jschar* chars =
     JS_GetStringCharsZAndLength(aCtx, JSVAL_TO_STRING(aValue), &length);
   if (!chars) {
     _string.SetIsVoid(true);
     return;
   }
   _string.Assign(static_cast<const char16_t*>(chars), length);
 }
 /**
  * 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 (JSVAL_IS_VOID(value)) {
     return NS_ERROR_INVALID_ARG;
   }
   NS_ENSURE_ARG(JSVAL_IS_PRIMITIVE(value));
   NS_ENSURE_ARG(JSVAL_IS_NUMBER(value));
   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)
 {
   NS_PRECONDITION(JS_IsArrayObject(aCtx, aArray),
                   "Must provide an object that is an array!");
   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 : public AsyncStatementCallback
 {
 public:
   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_GetProcessType() == GeckoProcessType_Content) {
     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;
   }
     nsNavHistory* navHistory = nsNavHistory::GetHistoryService();
     NS_ENSURE_STATE(navHistory);
     if (navHistory->hasEmbedVisit(aURI)) {
       nsRefPtr<VisitedQuery> callback = new VisitedQuery(aURI, aCallback, true);
       NS_ENSURE_TRUE(callback, NS_ERROR_OUT_OF_MEMORY);
       // As per IHistory contract, we must notify asynchronously.
       nsCOMPtr<nsIRunnable> event =
         NS_NewRunnableMethod(callback, &VisitedQuery::NotifyVisitedStatus);
       NS_DispatchToMainThread(event);
       return NS_OK;
     }
     History* history = History::GetService();
     NS_ENSURE_STATE(history);
     mozIStorageAsyncStatement* stmt = history->GetIsVisitedStatement();
     NS_ENSURE_STATE(stmt);
     // Bind by index for performance.
     nsresult rv = URIBinder::Bind(stmt, 0, aURI);
     NS_ENSURE_SUCCESS(rv, rv);
     nsRefPtr<VisitedQuery> callback = new VisitedQuery(aURI, aCallback);
     NS_ENSURE_TRUE(callback, NS_ERROR_OUT_OF_MEMORY);
     nsCOMPtr<mozIStoragePendingStatement> handle;
     return stmt->ExecuteAsync(callback, getter_AddRefs(handle));
   }
   NS_IMETHOD HandleResult(mozIStorageResultSet* aResults)
   {
     // 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)
   {
     // 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)
   {
     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:
   VisitedQuery(nsIURI* aURI,
                mozIVisitedStatusCallback *aCallback=nullptr,
                bool aIsVisited=false)
   : mURI(aURI)
   , mCallback(aCallback)
   , mIsVisited(aIsVisited)
   {
   }
   nsCOMPtr<nsIURI> mURI;
   nsCOMPtr<mozIVisitedStatusCallback> mCallback;
   bool mIsVisited;
 };
 /**
  * Notifies observers about a visit.
  */
 class NotifyVisitObservers : public nsRunnable
 {
 public:
   NotifyVisitObservers(VisitData& aPlace,
                        VisitData& aReferrer)
   : mPlace(aPlace)
   , mReferrer(aReferrer)
   , mHistory(History::GetService())
   {
   }
   NS_IMETHOD Run()
   {
     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;
     (void)NS_NewURI(getter_AddRefs(uri), mPlace.spec);
     // 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,
                                 mReferrer.visitId, mPlace.transitionType,
                                 mPlace.guid, mPlace.hidden);
     }
     nsCOMPtr<nsIObserverService> obsService =
       mozilla::services::GetObserverService();
     if (obsService) {
       DebugOnly<nsresult> rv =
         obsService->NotifyObservers(uri, URI_VISIT_SAVED, nullptr);
       NS_WARN_IF_FALSE(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;
   VisitData mReferrer;
   nsRefPtr<History> mHistory;
 };
 /**
  * Notifies observers about a pages title changing.
  */
 class NotifyTitleObservers : public nsRunnable
 {
 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()
   {
     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;
     (void)NS_NewURI(getter_AddRefs(uri), mSpec);
     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 nsRunnable
 {
 public:
   NotifyPlaceInfoCallback(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()
   {
     MOZ_ASSERT(NS_IsMainThread(), "This should be called on the main thread");
     nsCOMPtr<nsIURI> referrerURI;
     if (!mPlace.referrerSpec.IsEmpty()) {
       (void)NS_NewURI(getter_AddRefs(referrerURI), mPlace.referrerSpec);
     }
     nsCOMPtr<nsIURI> uri;
     (void)NS_NewURI(getter_AddRefs(uri), mPlace.spec);
     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)) {
       (void)mCallback->HandleResult(place);
     }
     else {
       (void)mCallback->HandleError(mResult, place);
     }
     return NS_OK;
   }
 private:
   /**
    * Callers MUST hold a strong reference to this that outlives us because we
    * may be created off of the main thread, and therefore cannot call AddRef on
    * this object (and therefore cannot hold a strong reference to it).
    */
   mozIVisitInfoCallback* mCallback;
   VisitData mPlace;
   const nsresult mResult;
   bool mIsSingleVisit;
 };
 /**
  * Notifies a callback object when the operation is complete.
  */
 class NotifyCompletion : public nsRunnable
 {
 public:
   NotifyCompletion(mozIVisitInfoCallback* aCallback)
   : mCallback(aCallback)
   {
     MOZ_ASSERT(aCallback, "Must pass a non-null callback!");
   }
   NS_IMETHOD Run()
   {
     if (NS_IsMainThread()) {
       (void)mCallback->HandleCompletion();
     }
     else {
       (void)NS_DispatchToMainThread(this);
       // Also dispatch an event to release the reference to the callback after
       // we have run.
       nsCOMPtr<nsIThread> mainThread = do_GetMainThread();
       (void)NS_ProxyRelease(mainThread, mCallback, true);
     }
     return NS_OK;
   }
 private:
   /**
    * Callers MUST hold a strong reference to this because we may be created
    * off of the main thread, and therefore cannot call AddRef on this object
    * (and therefore cannot hold a strong reference to it). If invoked from a
    * background thread, NotifyCompletion will release the reference to this.
    */
   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)
 {
   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) {
     // NotifyPlaceInfoCallback does not hold a strong reference to the callback, so we
     // have to manage it by AddRefing now and then releasing it after the event
     // has run.
     NS_ADDREF(aCallback);
     VisitData place(aURI);
     place.guid = aGUID;
     nsCOMPtr<nsIRunnable> event =
       new NotifyPlaceInfoCallback(aCallback, place, true, NS_ERROR_INVALID_ARG);
     (void)NS_DispatchToMainThread(event);
     // Also dispatch an event to release our reference to the callback after
     // NotifyPlaceInfoCallback has run.
     nsCOMPtr<nsIThread> mainThread = do_GetMainThread();
     (void)NS_ProxyRelease(mainThread, aCallback, true);
   }
   return false;
 }
 /**
  * Adds a visit to the database.
  */
 class InsertVisitedURIs : public nsRunnable
 {
 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!");
     nsRefPtr<InsertVisitedURIs> event =
       new InsertVisitedURIs(aConnection, aPlaces, aCallback);
     // 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()
   {
     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* lastPlace = nullptr;
     for (nsTArray<VisitData>::size_type i = 0; i < mPlaces.Length(); i++) {
       VisitData& place = mPlaces.ElementAt(i);
       VisitData& referrer = mReferrers.ElementAt(i);
       // We can avoid a database lookup if it's the same place as the last
       // visit we added.
       bool known = lastPlace && lastPlace->IsSamePlaceAs(place);
       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;
         }
       }
       FetchReferrerInfo(referrer, place);
       nsresult rv = DoDatabaseInserts(known, place, referrer);
       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, referrer);
       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);
       }
       lastPlace = &mPlaces.ElementAt(i);
     }
     nsresult rv = transaction.Commit();
     NS_ENSURE_SUCCESS(rv, rv);
     return NS_OK;
   }
 private:
   InsertVisitedURIs(mozIStorageConnection* aConnection,
                     nsTArray<VisitData>& aPlaces,
                     mozIVisitInfoCallback* aCallback)
   : mDBConn(aConnection)
   , mCallback(aCallback)
   , mHistory(History::GetService())
   {
     MOZ_ASSERT(NS_IsMainThread(), "This should be called on the main thread");
     (void)mPlaces.SwapElements(aPlaces);
     (void)mReferrers.SetLength(mPlaces.Length());
     nsNavHistory* navHistory = nsNavHistory::GetHistoryService();
     NS_ABORT_IF_FALSE(navHistory, "Could not get nsNavHistory?!");
     for (nsTArray<VisitData>::size_type i = 0; i < mPlaces.Length(); i++) {
       mReferrers[i].spec = mPlaces[i].referrerSpec;
 #ifdef DEBUG
       nsCOMPtr<nsIURI> uri;
       (void)NS_NewURI(getter_AddRefs(uri), mPlaces[i].spec);
       NS_ASSERTION(CanAddURI(uri),
                    "Passed a VisitData with a URI we cannot add to history!");
 #endif
     }
   }
   virtual ~InsertVisitedURIs()
   {
     if (mCallback) {
       nsCOMPtr<nsIThread> mainThread = do_GetMainThread();
       (void)NS_ProxyRelease(mainThread, mCallback, true);
     }
   }
   /**
    * 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.
    * @param aReferrer
    *        The referrer for aPlace.
    */
   nsresult DoDatabaseInserts(bool aKnown,
                              VisitData& aPlace,
                              VisitData& aReferrer)
   {
     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);
       // We need the place id and guid of the page we just inserted when we
       // have a callback or when the GUID isn't known.  No point in doing the
       // disk I/O if we do not need it.
       if (mCallback || aPlace.guid.IsEmpty()) {
         bool exists;
         rv = mHistory->FetchPageInfo(aPlace, &exists);
         NS_ENSURE_SUCCESS(rv, rv);
         if (!exists) {
           NS_NOTREACHED("should have an entry in moz_places");
         }
       }
     }
     rv = AddVisit(aPlace, aReferrer);
     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;
   }
   /**
    * Loads visit information about the page into _place.
    *
    * @param _place
    *        The VisitData for the place we need to know visit information about.
    * @param [optional] aThresholdStart
    *        The timestamp of a new visit (not represented by _place) used to
    *        determine if the page was recently visited or not.
    * @return true if the page was recently (determined with aThresholdStart)
    *         visited, false otherwise.
    */
   bool FetchVisitInfo(VisitData& _place,
                       PRTime aThresholdStart = 0)
   {
     NS_PRECONDITION(!_place.spec.IsEmpty(), "must have a non-empty spec!");
     nsCOMPtr<mozIStorageStatement> stmt;
     // If we have a visitTime, we want information on that specific visit.
     if (_place.visitTime) {
       stmt = mHistory->GetStatement(
         "SELECT id, visit_date "
         "FROM moz_historyvisits "
         "WHERE place_id = (SELECT id FROM moz_places WHERE url = :page_url) "
         "AND visit_date = :visit_date "
       );
       NS_ENSURE_TRUE(stmt, false);
       mozStorageStatementScoper scoper(stmt);
       nsresult rv = stmt->BindInt64ByName(NS_LITERAL_CSTRING("visit_date"),
                                           _place.visitTime);
       NS_ENSURE_SUCCESS(rv, false);
       scoper.Abandon();
     }
     // Otherwise, we want information about the most recent visit.
     else {
       stmt = mHistory->GetStatement(
         "SELECT id, visit_date "
         "FROM moz_historyvisits "
         "WHERE place_id = (SELECT id FROM moz_places WHERE url = :page_url) "
         "ORDER BY visit_date DESC "
       );
       NS_ENSURE_TRUE(stmt, false);
     }
     mozStorageStatementScoper scoper(stmt);
     nsresult rv = URIBinder::Bind(stmt, NS_LITERAL_CSTRING("page_url"),
                                   _place.spec);
     NS_ENSURE_SUCCESS(rv, false);
     bool hasResult;
     rv = stmt->ExecuteStep(&hasResult);
     NS_ENSURE_SUCCESS(rv, false);
     if (!hasResult) {
       return false;
     }
     rv = stmt->GetInt64(0, &_place.visitId);
     NS_ENSURE_SUCCESS(rv, false);
     rv = stmt->GetInt64(1, reinterpret_cast<int64_t*>(&_place.visitTime));
     NS_ENSURE_SUCCESS(rv, false);
     // If we have been given a visit threshold start time, go ahead and
     // calculate if we have been recently visited.
     if (aThresholdStart &&
         aThresholdStart - _place.visitTime <= RECENT_EVENT_THRESHOLD) {
       return true;
     }
     return false;
   }
   /**
    * Fetches information about a referrer for aPlace if it was a recent
    * visit or not.
    *
    * @param aReferrer
    *        The VisitData for the referrer.  This will be populated with
    *        FetchVisitInfo.
    * @param aPlace
    *        The VisitData for the visit we will eventually add.
    *
    */
   void FetchReferrerInfo(VisitData& aReferrer,
                          VisitData& aPlace)
   {
     if (aReferrer.spec.IsEmpty()) {
       return;
     }
     if (!FetchVisitInfo(aReferrer, aPlace.visitTime)) {
       // We must change both the place and referrer to indicate that we will
       // not be using the referrer's data. This behavior has test coverage, so
       // if this invariant changes, we'll know.
       aPlace.referrerSpec.Truncate();
       aReferrer.visitId = 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.
    * @param aReferrer
    *        A reference to the referrer's visit data.
    */
   nsresult AddVisit(VisitData& _place,
                     const VisitData& aReferrer)
   {
     nsresult rv;
     nsCOMPtr<mozIStorageStatement> stmt;
     if (_place.placeId) {
       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);
       rv = stmt->BindInt64ByName(NS_LITERAL_CSTRING("page_id"), _place.placeId);
       NS_ENSURE_SUCCESS(rv, rv);
     }
     else {
       stmt = mHistory->GetStatement(
         "INSERT INTO moz_historyvisits "
           "(from_visit, place_id, visit_date, visit_type, session) "
         "VALUES (:from_visit, (SELECT id FROM moz_places WHERE url = :page_url), :visit_date, :visit_type, 0) "
       );
       NS_ENSURE_STATE(stmt);
       rv = URIBinder::Bind(stmt, NS_LITERAL_CSTRING("page_url"), _place.spec);
       NS_ENSURE_SUCCESS(rv, rv);
     }
     rv = stmt->BindInt64ByName(NS_LITERAL_CSTRING("from_visit"),
                                aReferrer.visitId);
     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;
     NS_ASSERTION(transitionType >= nsINavHistoryService::TRANSITION_LINK &&
                  transitionType <= nsINavHistoryService::TRANSITION_FRAMED_LINK,
                  "Invalid transition type!");
     rv = stmt->BindInt32ByName(NS_LITERAL_CSTRING("visit_type"),
                                transitionType);
     NS_ENSURE_SUCCESS(rv, rv);
     mozStorageStatementScoper scoper(stmt);
     rv = stmt->Execute();
     NS_ENSURE_SUCCESS(rv, rv);
     // Now that it should be in the database, we need to obtain the id of the
     // visit we just added.
     (void)FetchVisitInfo(_place);
     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);
     nsresult rv;
     { // First, set our frecency to the proper value.
       nsCOMPtr<mozIStorageStatement> stmt;
       if (aPlace.placeId) {
         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);
         rv = stmt->BindInt64ByName(NS_LITERAL_CSTRING("page_id"), aPlace.placeId);
         NS_ENSURE_SUCCESS(rv, rv);
       }
       else {
         stmt = mHistory->GetStatement(
           "UPDATE moz_places "
           "SET frecency = NOTIFY_FRECENCY("
             "CALCULATE_FRECENCY(id), url, guid, hidden, last_visit_date"
           ") "
           "WHERE url = :page_url"
         );
         NS_ENSURE_STATE(stmt);
         rv = URIBinder::Bind(stmt, NS_LITERAL_CSTRING("page_url"), aPlace.spec);
         NS_ENSURE_SUCCESS(rv, rv);
       }
       mozStorageStatementScoper scoper(stmt);
       rv = stmt->Execute();
       NS_ENSURE_SUCCESS(rv, rv);
     }
     if (!aPlace.hidden) {
       // Mark the page as not hidden if the frecency is now nonzero.
       nsCOMPtr<mozIStorageStatement> stmt;
       if (aPlace.placeId) {
         stmt = mHistory->GetStatement(
           "UPDATE moz_places "
           "SET hidden = 0 "
           "WHERE id = :page_id AND frecency <> 0"
         );
         NS_ENSURE_STATE(stmt);
         rv = stmt->BindInt64ByName(NS_LITERAL_CSTRING("page_id"), aPlace.placeId);
         NS_ENSURE_SUCCESS(rv, rv);
       }
       else {
         stmt = mHistory->GetStatement(
           "UPDATE moz_places "
           "SET hidden = 0 "
           "WHERE url = :page_url AND frecency <> 0"
         );
         NS_ENSURE_STATE(stmt);
         rv = URIBinder::Bind(stmt, NS_LITERAL_CSTRING("page_url"), aPlace.spec);
         NS_ENSURE_SUCCESS(rv, rv);
       }
       mozStorageStatementScoper scoper(stmt);
       rv = stmt->Execute();
       NS_ENSURE_SUCCESS(rv, rv);
     }
     return NS_OK;
   }
   mozIStorageConnection* mDBConn;
   nsTArray<VisitData> mPlaces;
   nsTArray<VisitData> mReferrers;
   nsCOMPtr<mozIVisitInfoCallback> mCallback;
   /**
    * Strong reference to the History object because we do not want it to
    * disappear out from under us.
    */
   nsRefPtr<History> mHistory;
 };
 class GetPlaceInfo MOZ_FINAL : public nsRunnable {
 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");
     nsRefPtr<GetPlaceInfo> event = new GetPlaceInfo(aPlace, aCallback);
     // 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()
   {
     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,
                mozIVisitInfoCallback* aCallback)
   : mPlace(aPlace)
   , mCallback(aCallback)
   , mHistory(History::GetService())
   {
     MOZ_ASSERT(NS_IsMainThread(), "This should be called on the main thread");
   }
   virtual ~GetPlaceInfo()
   {
     if (mCallback) {
       nsCOMPtr<nsIThread> mainThread = do_GetMainThread();
       (void)NS_ProxyRelease(mainThread, mCallback, true);
     }
   }
   VisitData mPlace;
   nsCOMPtr<mozIVisitInfoCallback> mCallback;
   nsRefPtr<History> mHistory;
 };
 /**
  * Sets the page title for a page in moz_places (if necessary).
  */
 class SetPageTitle : public nsRunnable
 {
 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);
     nsRefPtr<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()
   {
     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;
     }
     NS_ASSERTION(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.
    */
   nsRefPtr<History> mHistory;
 };
 /**
  * Adds download-specific annotations to a download page.
  */
 class SetDownloadAnnotations MOZ_FINAL : public mozIVisitInfoCallback
 {
 public:
   NS_DECL_ISUPPORTS
   SetDownloadAnnotations(nsIURI* aDestination)
   : mDestination(aDestination)
   , mHistory(History::GetService())
   {
     MOZ_ASSERT(mDestination);
     MOZ_ASSERT(NS_IsMainThread());
   }
   NS_IMETHOD HandleError(nsresult aResultCode, mozIPlaceInfo *aPlaceInfo)
   {
     // Just don't add the annotations in case the visit isn't added.
     return NS_OK;
   }
   NS_IMETHOD HandleResult(mozIPlaceInfo *aPlaceInfo)
   {
     // 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),
 ,
       nsIAnnotationService::EXPIRE_WITH_HISTORY
     );
     NS_ENSURE_SUCCESS(rv, rv);
     rv = annosvc->SetPageAnnotationString(
       source,
       DESTINATIONFILENAME_ANNO,
       destinationFileName,
 ,
       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()
   {
     return NS_OK;
   }
 private:
   nsCOMPtr<nsIURI> mDestination;
   /**
    * Strong reference to the History object because we do not want it to
    * disappear out from under us.
    */
   nsRefPtr<History> mHistory;
 };
 NS_IMPL_ISUPPORTS(
   SetDownloadAnnotations,
   mozIVisitInfoCallback
 )
 /**
  * Enumerator used by NotifyRemoveVisits to transfer the hash entries.
  */
 static PLDHashOperator TransferHashEntries(PlaceHashKey* aEntry,
                                            void* aHash)
 {
   nsTHashtable<PlaceHashKey>* hash =
     static_cast<nsTHashtable<PlaceHashKey> *>(aHash);
   PlaceHashKey* copy = hash->PutEntry(aEntry->GetKey());
   copy->visitCount = aEntry->visitCount;
   copy->bookmarked = aEntry->bookmarked;
   aEntry->visits.SwapElements(copy->visits);
   return PL_DHASH_NEXT;
 }
 /**
  * Enumerator used by NotifyRemoveVisits to notify removals.
  */
 static PLDHashOperator NotifyVisitRemoval(PlaceHashKey* aEntry,
                                           void* aHistory)
 {
   nsNavHistory* history = static_cast<nsNavHistory *>(aHistory);
   const nsTArray<VisitData>& visits = aEntry->visits;
   nsCOMPtr<nsIURI> uri;
   (void)NS_NewURI(getter_AddRefs(uri), visits[0].spec);
   bool removingPage = visits.Length() == aEntry->visitCount &&
                       !aEntry->bookmarked;
   // 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;
   history->NotifyOnPageExpired(uri, visits[0].visitTime, removingPage,
                                visits[0].guid,
                                nsINavHistoryObserver::REASON_DELETED,
                                transition);
   return PL_DHASH_NEXT;
 }
 /**
  * Notify removed visits to observers.
  */
 class NotifyRemoveVisits : public nsRunnable
 {
 public:
   NotifyRemoveVisits(nsTHashtable<PlaceHashKey>& aPlaces)
     : mPlaces(VISITS_REMOVAL_INITIAL_HASH_SIZE)
     , mHistory(History::GetService())
   {
     MOZ_ASSERT(!NS_IsMainThread(),
                "This should not be called on the main thread");
     aPlaces.EnumerateEntries(TransferHashEntries, &mPlaces);
   }
   NS_IMETHOD Run()
   {
     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();
     mPlaces.EnumerateEntries(NotifyVisitRemoval, navHistory);
     (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.
    */
   nsRefPtr<History> mHistory;
 };
 /**
  * Enumerator used by RemoveVisits to populate list of removed place ids.
  */
 static PLDHashOperator ListToBeRemovedPlaceIds(PlaceHashKey* aEntry,
                                                void* aIdsList)
 {
   const nsTArray<VisitData>& visits = aEntry->visits;
   // Only orphan ids should be listed.
   if (visits.Length() == aEntry->visitCount && !aEntry->bookmarked) {
     nsCString* list = static_cast<nsCString*>(aIdsList);
     if (!list->IsEmpty())
       list->AppendLiteral(",");
     list->AppendInt(visits[0].placeId);
   }
   return PL_DHASH_NEXT;
 }
 /**
  * Remove visits from history.
  */
 class RemoveVisits : public nsRunnable
 {
 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");
     nsRefPtr<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()
   {
     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_SIZE);
     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]);
       }
     }
   }
   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->visitCount = visitCount;
       entry->bookmarked = bookmarked;
       entry->visits.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;
     aPlaces.EnumerateEntries(ListToBeRemovedPlaceIds, &placeIdsToRemove);
 #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.AppendLiteral(")");
     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.
    */
   nsRefPtr<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;
   (void)NS_NewURI(getter_AddRefs(uri), aPlace.spec);
   nsNavHistory* navHistory = nsNavHistory::GetHistoryService();
   if (!navHistory || !uri) {
     return;
   }
   navHistory->registerEmbedVisit(uri, aPlace.visitTime);
   if (aCallback) {
     // NotifyPlaceInfoCallback does not hold a strong reference to the callback,
     // so we have to manage it by AddRefing now and then releasing it after the
     // event has run.
     NS_ADDREF(aCallback);
     nsCOMPtr<nsIRunnable> event =
       new NotifyPlaceInfoCallback(aCallback, aPlace, true, NS_OK);
     (void)NS_DispatchToMainThread(event);
     // Also dispatch an event to release our reference to the callback after
     // NotifyPlaceInfoCallback has run.
     nsCOMPtr<nsIThread> mainThread = do_GetMainThread();
     (void)NS_ProxyRelease(mainThread, aCallback, true);
   }
   VisitData noReferrer;
   nsCOMPtr<nsIRunnable> event = new NotifyVisitObservers(aPlace, noReferrer);
   (void)NS_DispatchToMainThread(event);
 }
 } // anonymous namespace
 ////////////////////////////////////////////////////////////////////////////////
 //// History
 History* History::gService = nullptr;
 History::History()
   : mShuttingDown(false)
   , mShutdownMutex("History::mShutdownMutex")
   , mObservers(VISIT_OBSERVERS_INITIAL_CACHE_SIZE)
   , mRecentlyVisitedURIsNextIndex(0)
 {
   NS_ASSERTION(!gService, "Ruh-roh!  This service has already been created!");
   gService = this;
   nsCOMPtr<nsIObserverService> os = services::GetObserverService();
   NS_WARN_IF_FALSE(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)
 {
   NS_ENSURE_ARG(aURI);
   nsAutoScriptBlocker scriptBlocker;
   if (XRE_GetProcessType() == GeckoProcessType_Default) {
     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.
       NS_ABORT_IF_FALSE(key == mObservers.GetEntry(aURI),
                         "The URIs hash mutated!");
     }
   }
   // All the registered nodes can now be removed for this URI.
   mObservers.RemoveEntry(aURI);
   return NS_OK;
 }
 mozIStorageAsyncStatement*
 History::GetIsVisitedStatement()
 {
   if (mIsVisitedStatement) {
     return mIsVisitedStatement;
   }
   // If we don't yet have a database connection, go ahead and clone it now.
   if (!mReadOnlyDBConn) {
     mozIStorageConnection* dbConn = GetDBConn();
     NS_ENSURE_TRUE(dbConn, nullptr);
     (void)dbConn->Clone(true, getter_AddRefs(mReadOnlyDBConn));
     NS_ENSURE_TRUE(mReadOnlyDBConn, nullptr);
   }
   // Now we can create our cached statement.
   nsresult rv = mReadOnlyDBConn->CreateAsyncStatement(NS_LITERAL_CSTRING(
     "SELECT 1 "
     "FROM moz_places h "
     "WHERE url = ?1 "
       "AND last_visit_date NOTNULL "
   ),  getter_AddRefs(mIsVisitedStatement));
   NS_ENSURE_SUCCESS(rv, nullptr);
   return mIsVisitedStatement;
 }
 nsresult
 History::InsertPlace(const VisitData& aPlace)
 {
   NS_PRECONDITION(aPlace.placeId == 0, "should not have a valid place id!");
   NS_PRECONDITION(!NS_IsMainThread(), "must be called off of the main thread!");
   nsCOMPtr<mozIStorageStatement> stmt = GetStatement(
       "INSERT INTO moz_places "
         "(url, title, rev_host, hidden, typed, frecency, guid) "
       "VALUES (: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);
   nsAutoCString guid(aPlace.guid);
   if (aPlace.guid.IsVoid()) {
     rv = GenerateGUID(guid);
     NS_ENSURE_SUCCESS(rv, rv);
   }
   rv = stmt->BindUTF8StringByName(NS_LITERAL_CSTRING("guid"), 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, guid,
                                                   aPlace.hidden,
                                                   aPlace.visitTime);
   return NS_OK;
 }
 nsresult
 History::UpdatePlace(const VisitData& aPlace)
 {
   NS_PRECONDITION(!NS_IsMainThread(), "must be called off of the main thread!");
   NS_PRECONDITION(aPlace.placeId > 0, "must have a valid place id!");
   NS_PRECONDITION(!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)
 {
   NS_PRECONDITION(!_place.spec.IsEmpty() || !_place.guid.IsEmpty(), "must have either a non-empty spec or guid!");
   NS_PRECONDITION(!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 "
       "FROM moz_places "
       "WHERE 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 "
       "FROM moz_places "
       "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()));
   }
   if (_place.hidden) {
     // If this transition was hidden, it is possible that others were not.
     // Any one visible transition makes this location visible. If database
     // has location as visible, reflect that in our data structure.
     int32_t hidden;
     rv = stmt->GetInt32(3, &hidden);
     NS_ENSURE_SUCCESS(rv, rv);
     _place.hidden = !!hidden;
   }
   if (!_place.typed) {
     // If this transition wasn't typed, others might have been. If database
     // has location as typed, reflect that in our data structure.
     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);
   return NS_OK;
 }
 /* static */ size_t
 History::SizeOfEntryExcludingThis(KeyClass* aEntry, mozilla::MallocSizeOf aMallocSizeOf, void *)
 {
   return aEntry->array.SizeOfExcludingThis(aMallocSizeOf);
 }
 MOZ_DEFINE_MALLOC_SIZE_OF(HistoryMallocSizeOf)
 NS_IMETHODIMP
 History::CollectReports(nsIHandleReportCallback* aHandleReport,
                         nsISupports* aData)
 {
   return 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.");
 }
 size_t
 History::SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOfThis)
 {
   return aMallocSizeOfThis(this) +
          mObservers.SizeOfExcludingThis(SizeOfEntryExcludingThis, aMallocSizeOfThis);
 }
 /* static */
 History*
 History::GetService()
 {
   if (gService) {
     return gService;
   }
   nsCOMPtr<IHistory> service(do_GetService(NS_IHISTORY_CONTRACTID));
   NS_ABORT_IF_FALSE(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 (!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 (mReadOnlyDBConn) {
     if (mIsVisitedStatement) {
       (void)mIsVisitedStatement->Finalize();
     }
     (void)mReadOnlyDBConn->AsyncClose(nullptr);
   }
 }
 void
 History::AppendToRecentlyVisitedURIs(nsIURI* aURI) {
   if (mRecentlyVisitedURIs.Length() < RECENTLY_VISITED_URI_SIZE) {
     // Append a new element while the array is not full.
     mRecentlyVisitedURIs.AppendElement(aURI);
   } else {
     // Otherwise, replace the oldest member.
     mRecentlyVisitedURIsNextIndex %= RECENTLY_VISITED_URI_SIZE;
     mRecentlyVisitedURIs.ElementAt(mRecentlyVisitedURIsNextIndex) = aURI;
     mRecentlyVisitedURIsNextIndex++;
   }
 }
 inline bool
 History::IsRecentlyVisitedURI(nsIURI* aURI) {
   bool equals = false;
   RecentlyVisitedArray::index_type i;
   for (i = 0; i < mRecentlyVisitedURIs.Length() && !equals; ++i) {
     aURI->Equals(mRecentlyVisitedURIs.ElementAt(i), &equals);
   }
   return equals;
 }
 ////////////////////////////////////////////////////////////////////////////////
 //// IHistory
 NS_IMETHODIMP
 History::VisitURI(nsIURI* aURI,
                   nsIURI* aLastVisitedURI,
                   uint32_t aFlags)
 {
   NS_PRECONDITION(aURI, "URI should not be NULL.");
   if (mShuttingDown) {
     return NS_OK;
   }
   if (XRE_GetProcessType() == GeckoProcessType_Content) {
     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;
   }
   if (aLastVisitedURI) {
     bool same;
     rv = aURI->Equals(aLastVisitedURI, &same);
     NS_ENSURE_SUCCESS(rv, rv);
     if (same && IsRecentlyVisitedURI(aURI)) {
       // Do not save refresh visits if we have visited this URI recently.
       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 ((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)
 {
   NS_ASSERTION(aURI, "Must pass a non-null URI!");
   if (XRE_GetProcessType() == GeckoProcessType_Content) {
     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.
       mObservers.RemoveEntry(aURI);
       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_GetProcessType() == GeckoProcessType_Default,
                  "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)
 {
   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_PRECONDITION(aURI, "Must pass a non-null URI!");
   if (mShuttingDown) {
     return NS_OK;
   }
   if (XRE_GetProcessType() == GeckoProcessType_Content) {
     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_GetProcessType() == GeckoProcessType_Content) {
     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);
   nsCOMPtr<mozIVisitInfoCallback> callback = aDestination
                                   ? new SetDownloadAnnotations(aDestination)
                                   : nullptr;
   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_GetProcessType() == GeckoProcessType_Content) {
     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) {
   nsNavHistory* navHistory = nsNavHistory::GetHistoryService();
   NS_ABORT_IF_FALSE(navHistory, "Could not get nsNavHistory?!");
   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) {
     // NotifyCompletion does not hold a strong reference to the callback,
     // so we have to manage it by AddRefing now. NotifyCompletion will
     // release it for us once it has dispatched the callback to the main
     // thread.
     NS_ADDREF(aCallback);
     nsCOMPtr<nsIEventTarget> backgroundThread = do_GetInterface(dbConn);
     NS_ENSURE_TRUE(backgroundThread, NS_ERROR_UNEXPECTED);
     nsCOMPtr<nsIRunnable> event = new NotifyCompletion(aCallback);
     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(!JSVAL_IS_PRIMITIVE(aPlaceInfos), 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 (!JSVAL_IS_PRIMITIVE(visitsVal)) {
         visits = JSVAL_TO_OBJECT(visitsVal);
         NS_ENSURE_ARG(JS_IsArrayObject(aCtx, visits));
       }
     }
     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_FRAMED_LINK);
       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);
   // 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, 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) {
     // NotifyCompletion does not hold a strong reference to the callback,
     // so we have to manage it by AddRefing now. NotifyCompletion will
     // release it for us once it has dispatched the callback to the main
     // thread.
     NS_ADDREF(aCallback);
     nsCOMPtr<nsIEventTarget> backgroundThread = do_GetInterface(dbConn);
     NS_ENSURE_TRUE(backgroundThread, NS_ERROR_UNEXPECTED);
     nsCOMPtr<nsIRunnable> event = new NotifyCompletion(aCallback);
     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

The Tor Browser / annotate

toolkit/components/places/History.cpp@129ffea94266 (annotated)

toolkit/components/places/History.cpp