Adding upstream version 115.7.0esr.upstream/115.7.0esr

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

6 files changed, 1000 insertions, 0 deletions

diff --git a/toolkit/components/places/tests/gtest/mock_Link.h b/toolkit/components/places/tests/gtest/mock_Link.h
new file mode 100644
index 0000000000..aa83a2fe7b
--- /dev/null
+++ b/toolkit/components/places/tests/gtest/mock_Link.h
@@ -0,0 +1,72 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ * vim: sw=2 ts=2 et lcs=trail\:.,tab\:>~ :
+ * 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/. */
+
+/**
+ * This is a mock Link object which can be used in tests.
+ */
+
+#ifndef mock_Link_h__
+#define mock_Link_h__
+
+#include "mozilla/MemoryReporting.h"
+#include "mozilla/dom/Link.h"
+#include "mozilla/StaticPrefs_layout.h"
+
+class mock_Link : public mozilla::dom::Link {
+ public:
+  NS_DECL_ISUPPORTS
+
+  typedef void (*Handler)(State);
+
+  explicit mock_Link(Handler aHandlerFunction, bool aRunNextTest = true)
+      : mozilla::dom::Link(), mRunNextTest(aRunNextTest) {
+    AwaitNewNotification(aHandlerFunction);
+  }
+
+  void VisitedQueryFinished(bool aVisited) final {
+    // Notify our callback function.
+    mHandler(aVisited ? State::Visited : State::Unvisited);
+
+    // Break the cycle so the object can be destroyed.
+    mDeathGrip = nullptr;
+  }
+
+  size_t SizeOfExcludingThis(mozilla::SizeOfState& aState) const final {
+    return 0;  // the value shouldn't matter
+  }
+
+  void NodeInfoChanged(mozilla::dom::Document* aOldDoc) final {}
+
+  bool GotNotified() const { return !mDeathGrip; }
+
+  void AwaitNewNotification(Handler aNewHandler) {
+    MOZ_ASSERT(!mDeathGrip, "Still waiting for a notification");
+    // Create a cyclic ownership, so that the link will be released only
+    // after its status has been updated.  This will ensure that, when it should
+    // run the next test, it will happen at the end of the test function, if
+    // the link status has already been set before.  Indeed the link status is
+    // updated on a separate connection, thus may happen at any time.
+    mDeathGrip = this;
+    mHandler = aNewHandler;
+  }
+
+ protected:
+  ~mock_Link() {
+    // Run the next test if we are supposed to.
+    if (mRunNextTest) {
+      run_next_test();
+    }
+  }
+
+ private:
+  Handler mHandler = nullptr;
+  bool mRunNextTest;
+  RefPtr<Link> mDeathGrip;
+};
+
+NS_IMPL_ISUPPORTS(mock_Link, mozilla::dom::Link)
+
+#endif  // mock_Link_h__
diff --git a/toolkit/components/places/tests/gtest/moz.build b/toolkit/components/places/tests/gtest/moz.build
new file mode 100644
index 0000000000..eb7157efc5
--- /dev/null
+++ b/toolkit/components/places/tests/gtest/moz.build
@@ -0,0 +1,12 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# 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/.
+
+UNIFIED_SOURCES += [
+    "test_casing.cpp",
+    "test_IHistory.cpp",
+]
+
+FINAL_LIBRARY = "xul-gtest"
diff --git a/toolkit/components/places/tests/gtest/places_test_harness.h b/toolkit/components/places/tests/gtest/places_test_harness.h
new file mode 100644
index 0000000000..f2d3e06c35
--- /dev/null
+++ b/toolkit/components/places/tests/gtest/places_test_harness.h
@@ -0,0 +1,353 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ * vim: sw=2 ts=2 et lcs=trail\:.,tab\:>~ :
+ * 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 "gtest/gtest.h"
+#include "nsThreadUtils.h"
+#include "nsDocShellCID.h"
+
+#include "nsToolkitCompsCID.h"
+#include "nsServiceManagerUtils.h"
+#include "nsINavHistoryService.h"
+#include "nsIObserverService.h"
+#include "nsIThread.h"
+#include "nsIURI.h"
+#include "mozilla/IHistory.h"
+#include "mozilla/SpinEventLoopUntil.h"
+#include "mozIStorageConnection.h"
+#include "mozIStorageStatement.h"
+#include "mozIStorageAsyncStatement.h"
+#include "mozIStorageStatementCallback.h"
+#include "mozIStoragePendingStatement.h"
+#include "nsIObserver.h"
+#include "prinrval.h"
+#include "prtime.h"
+#include "mozilla/Attributes.h"
+
+#define WAITFORTOPIC_TIMEOUT_SECONDS 5
+
+#define do_check_true(aCondition) EXPECT_TRUE(aCondition)
+
+#define do_check_false(aCondition) EXPECT_FALSE(aCondition)
+
+#define do_check_success(aResult) do_check_true(NS_SUCCEEDED(aResult))
+
+#define do_check_eq(aExpected, aActual) do_check_true(aExpected == aActual)
+
+struct Test {
+  void (*func)(void);
+  const char* const name;
+};
+#define PTEST(aName) \
+  { aName, #aName }
+
+/**
+ * Runs the next text.
+ */
+void run_next_test();
+
+/**
+ * To be used around asynchronous work.
+ */
+void do_test_pending();
+void do_test_finished();
+
+/**
+ * Spins current thread until a topic is received.
+ */
+class WaitForTopicSpinner final : public nsIObserver {
+ public:
+  NS_DECL_ISUPPORTS
+
+  explicit WaitForTopicSpinner(const char* const aTopic)
+      : mTopicReceived(false), mStartTime(PR_IntervalNow()) {
+    nsCOMPtr<nsIObserverService> observerService =
+        do_GetService(NS_OBSERVERSERVICE_CONTRACTID);
+    do_check_true(observerService);
+    (void)observerService->AddObserver(this, aTopic, false);
+  }
+
+  void Spin() {
+    bool timedOut = false;
+    mozilla::SpinEventLoopUntil(
+        "places:WaitForTopicSpinner::Spin"_ns, [&]() -> bool {
+          if (mTopicReceived) {
+            return true;
+          }
+
+          if ((PR_IntervalNow() - mStartTime) >
+              (WAITFORTOPIC_TIMEOUT_SECONDS * PR_USEC_PER_SEC)) {
+            timedOut = true;
+            return true;
+          }
+
+          return false;
+        });
+
+    if (timedOut) {
+      // Timed out waiting for the topic.
+      do_check_true(false);
+    }
+  }
+
+  NS_IMETHOD Observe(nsISupports* aSubject, const char* aTopic,
+                     const char16_t* aData) override {
+    mTopicReceived = true;
+    nsCOMPtr<nsIObserverService> observerService =
+        do_GetService(NS_OBSERVERSERVICE_CONTRACTID);
+    do_check_true(observerService);
+    (void)observerService->RemoveObserver(this, aTopic);
+    return NS_OK;
+  }
+
+ private:
+  ~WaitForTopicSpinner() = default;
+
+  bool mTopicReceived;
+  PRIntervalTime mStartTime;
+};
+NS_IMPL_ISUPPORTS(WaitForTopicSpinner, nsIObserver)
+
+/**
+ * Spins current thread until an async statement is executed.
+ */
+class PlacesAsyncStatementSpinner final : public mozIStorageStatementCallback {
+ public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_MOZISTORAGESTATEMENTCALLBACK
+
+  PlacesAsyncStatementSpinner();
+  void SpinUntilCompleted();
+  uint16_t completionReason;
+
+ protected:
+  ~PlacesAsyncStatementSpinner() = default;
+
+  volatile bool mCompleted;
+};
+
+NS_IMPL_ISUPPORTS(PlacesAsyncStatementSpinner, mozIStorageStatementCallback)
+
+PlacesAsyncStatementSpinner::PlacesAsyncStatementSpinner()
+    : completionReason(0), mCompleted(false) {}
+
+NS_IMETHODIMP
+PlacesAsyncStatementSpinner::HandleResult(mozIStorageResultSet* aResultSet) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PlacesAsyncStatementSpinner::HandleError(mozIStorageError* aError) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PlacesAsyncStatementSpinner::HandleCompletion(uint16_t aReason) {
+  completionReason = aReason;
+  mCompleted = true;
+  return NS_OK;
+}
+
+void PlacesAsyncStatementSpinner::SpinUntilCompleted() {
+  nsCOMPtr<nsIThread> thread(::do_GetCurrentThread());
+  nsresult rv = NS_OK;
+  bool processed = true;
+  while (!mCompleted && NS_SUCCEEDED(rv)) {
+    rv = thread->ProcessNextEvent(true, &processed);
+  }
+}
+
+struct PlaceRecord {
+  int64_t id;
+  int32_t hidden;
+  int32_t typed;
+  int32_t visitCount;
+  nsCString guid;
+};
+
+struct VisitRecord {
+  int64_t id;
+  int64_t lastVisitId;
+  int32_t transitionType;
+};
+
+already_AddRefed<mozilla::IHistory> do_get_IHistory() {
+  nsCOMPtr<mozilla::IHistory> history = do_GetService(NS_IHISTORY_CONTRACTID);
+  do_check_true(history);
+  return history.forget();
+}
+
+already_AddRefed<nsINavHistoryService> do_get_NavHistory() {
+  nsCOMPtr<nsINavHistoryService> serv =
+      do_GetService(NS_NAVHISTORYSERVICE_CONTRACTID);
+  do_check_true(serv);
+  return serv.forget();
+}
+
+already_AddRefed<mozIStorageConnection> do_get_db() {
+  nsCOMPtr<nsINavHistoryService> history = do_get_NavHistory();
+  do_check_true(history);
+
+  nsCOMPtr<mozIStorageConnection> dbConn;
+  nsresult rv = history->GetDBConnection(getter_AddRefs(dbConn));
+  do_check_success(rv);
+  return dbConn.forget();
+}
+
+/**
+ * Get the place record from the database.
+ *
+ * @param aURI The unique URI of the place we are looking up
+ * @param result Out parameter where the result is stored
+ */
+void do_get_place(nsIURI* aURI, PlaceRecord& result) {
+  nsCOMPtr<mozIStorageConnection> dbConn = do_get_db();
+  nsCOMPtr<mozIStorageStatement> stmt;
+
+  nsCString spec;
+  nsresult rv = aURI->GetSpec(spec);
+  do_check_success(rv);
+
+  rv = dbConn->CreateStatement(
+      nsLiteralCString(
+          "SELECT id, hidden, typed, visit_count, guid FROM moz_places "
+          "WHERE url_hash = hash(?1) AND url = ?1"),
+      getter_AddRefs(stmt));
+  do_check_success(rv);
+
+  rv = stmt->BindUTF8StringByIndex(0, spec);
+  do_check_success(rv);
+
+  bool hasResults;
+  rv = stmt->ExecuteStep(&hasResults);
+  do_check_success(rv);
+  if (!hasResults) {
+    result.id = 0;
+    return;
+  }
+
+  rv = stmt->GetInt64(0, &result.id);
+  do_check_success(rv);
+  rv = stmt->GetInt32(1, &result.hidden);
+  do_check_success(rv);
+  rv = stmt->GetInt32(2, &result.typed);
+  do_check_success(rv);
+  rv = stmt->GetInt32(3, &result.visitCount);
+  do_check_success(rv);
+  rv = stmt->GetUTF8String(4, result.guid);
+  do_check_success(rv);
+}
+
+/**
+ * Gets the most recent visit to a place.
+ *
+ * @param placeID ID from the moz_places table
+ * @param result Out parameter where visit is stored
+ */
+void do_get_lastVisit(int64_t placeId, VisitRecord& result) {
+  nsCOMPtr<mozIStorageConnection> dbConn = do_get_db();
+  nsCOMPtr<mozIStorageStatement> stmt;
+
+  nsresult rv = dbConn->CreateStatement(
+      nsLiteralCString(
+          "SELECT id, from_visit, visit_type FROM moz_historyvisits "
+          "WHERE place_id=?1 "
+          "LIMIT 1"),
+      getter_AddRefs(stmt));
+  do_check_success(rv);
+
+  rv = stmt->BindInt64ByIndex(0, placeId);
+  do_check_success(rv);
+
+  bool hasResults;
+  rv = stmt->ExecuteStep(&hasResults);
+  do_check_success(rv);
+
+  if (!hasResults) {
+    result.id = 0;
+    return;
+  }
+
+  rv = stmt->GetInt64(0, &result.id);
+  do_check_success(rv);
+  rv = stmt->GetInt64(1, &result.lastVisitId);
+  do_check_success(rv);
+  rv = stmt->GetInt32(2, &result.transitionType);
+  do_check_success(rv);
+}
+
+void do_wait_async_updates() {
+  nsCOMPtr<mozIStorageConnection> db = do_get_db();
+  nsCOMPtr<mozIStorageAsyncStatement> stmt;
+
+  db->CreateAsyncStatement("BEGIN EXCLUSIVE"_ns, getter_AddRefs(stmt));
+  nsCOMPtr<mozIStoragePendingStatement> pending;
+  (void)stmt->ExecuteAsync(nullptr, getter_AddRefs(pending));
+
+  db->CreateAsyncStatement("COMMIT"_ns, getter_AddRefs(stmt));
+  RefPtr<PlacesAsyncStatementSpinner> spinner =
+      new PlacesAsyncStatementSpinner();
+  (void)stmt->ExecuteAsync(spinner, getter_AddRefs(pending));
+
+  spinner->SpinUntilCompleted();
+}
+
+/**
+ * Adds a URI to the database.
+ *
+ * @param aURI
+ *        The URI to add to the database.
+ */
+void addURI(nsIURI* aURI) {
+  nsCOMPtr<mozilla::IHistory> history = do_GetService(NS_IHISTORY_CONTRACTID);
+  do_check_true(history);
+  nsresult rv = history->VisitURI(nullptr, aURI, nullptr,
+                                  mozilla::IHistory::TOP_LEVEL, 0);
+  do_check_success(rv);
+
+  do_wait_async_updates();
+}
+
+static const char TOPIC_PROFILE_CHANGE_QM[] = "profile-before-change-qm";
+static const char TOPIC_PLACES_CONNECTION_CLOSED[] = "places-connection-closed";
+
+class WaitForConnectionClosed final : public nsIObserver {
+  RefPtr<WaitForTopicSpinner> mSpinner;
+
+  ~WaitForConnectionClosed() = default;
+
+ public:
+  NS_DECL_ISUPPORTS
+
+  WaitForConnectionClosed() {
+    nsCOMPtr<nsIObserverService> os =
+        do_GetService(NS_OBSERVERSERVICE_CONTRACTID);
+    MOZ_ASSERT(os);
+    if (os) {
+      // The places-connection-closed notification happens because of things
+      // that occur during profile-before-change, so we use the stage after that
+      // to wait for it.
+      MOZ_ALWAYS_SUCCEEDS(
+          os->AddObserver(this, TOPIC_PROFILE_CHANGE_QM, false));
+    }
+    mSpinner = new WaitForTopicSpinner(TOPIC_PLACES_CONNECTION_CLOSED);
+  }
+
+  NS_IMETHOD Observe(nsISupports* aSubject, const char* aTopic,
+                     const char16_t* aData) override {
+    nsCOMPtr<nsIObserverService> os =
+        do_GetService(NS_OBSERVERSERVICE_CONTRACTID);
+    MOZ_ASSERT(os);
+    if (os) {
+      MOZ_ALWAYS_SUCCEEDS(os->RemoveObserver(this, aTopic));
+    }
+
+    mSpinner->Spin();
+
+    return NS_OK;
+  }
+};
+
+NS_IMPL_ISUPPORTS(WaitForConnectionClosed, nsIObserver)
diff --git a/toolkit/components/places/tests/gtest/places_test_harness_tail.h b/toolkit/components/places/tests/gtest/places_test_harness_tail.h
new file mode 100644
index 0000000000..0464d14e0d
--- /dev/null
+++ b/toolkit/components/places/tests/gtest/places_test_harness_tail.h
@@ -0,0 +1,89 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ * vim: sw=2 ts=2 et lcs=trail\:.,tab\:>~ :
+ * 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 "nsWidgetsCID.h"
+#include "nsIUserIdleService.h"
+#include "mozilla/StackWalk.h"
+
+#ifndef TEST_NAME
+#  error "Must #define TEST_NAME before including places_test_harness_tail.h"
+#endif
+
+int gTestsIndex = 0;
+
+#define TEST_INFO_STR "TEST-INFO | "
+
+class RunNextTest : public mozilla::Runnable {
+ public:
+  RunNextTest() : mozilla::Runnable("RunNextTest") {}
+  NS_IMETHOD Run() override {
+    NS_ASSERTION(NS_IsMainThread(), "Not running on the main thread?");
+    if (gTestsIndex < int(mozilla::ArrayLength(gTests))) {
+      do_test_pending();
+      Test& test = gTests[gTestsIndex++];
+      (void)fprintf(stderr, TEST_INFO_STR "Running %s.\n", test.name);
+      test.func();
+    }
+
+    do_test_finished();
+    return NS_OK;
+  }
+};
+
+static const bool kDebugRunNextTest = false;
+
+void run_next_test() {
+  if (kDebugRunNextTest) {
+    printf_stderr("run_next_test()\n");
+    MozWalkTheStack(stderr);
+  }
+  nsCOMPtr<nsIRunnable> event = new RunNextTest();
+  do_check_success(NS_DispatchToCurrentThread(event));
+}
+
+int gPendingTests = 0;
+
+void do_test_pending() {
+  NS_ASSERTION(NS_IsMainThread(), "Not running on the main thread?");
+  if (kDebugRunNextTest) {
+    printf_stderr("do_test_pending()\n");
+    MozWalkTheStack(stderr);
+  }
+  gPendingTests++;
+}
+
+void do_test_finished() {
+  NS_ASSERTION(NS_IsMainThread(), "Not running on the main thread?");
+  NS_ASSERTION(gPendingTests > 0, "Invalid pending test count!");
+  gPendingTests--;
+}
+
+void disable_idle_service() {
+  (void)fprintf(stderr, TEST_INFO_STR "Disabling Idle Service.\n");
+
+  nsCOMPtr<nsIUserIdleService> idle =
+      do_GetService("@mozilla.org/widget/useridleservice;1");
+  idle->SetDisabled(true);
+}
+
+TEST(IHistory, Test)
+{
+  RefPtr<WaitForConnectionClosed> spinClose = new WaitForConnectionClosed();
+
+  // Tinderboxes are constantly on idle.  Since idle tasks can interact with
+  // tests, causing random failures, disable the idle service.
+  disable_idle_service();
+
+  do_test_pending();
+  run_next_test();
+
+  // Spin the event loop until we've run out of tests to run.
+  mozilla::SpinEventLoopUntil("places:TEST(IHistory, Test)"_ns,
+                              [&]() { return !gPendingTests; });
+
+  // And let any other events finish before we quit.
+  (void)NS_ProcessPendingEvents(nullptr);
+}
diff --git a/toolkit/components/places/tests/gtest/test_IHistory.cpp b/toolkit/components/places/tests/gtest/test_IHistory.cpp
new file mode 100644
index 0000000000..1a54c2c401
--- /dev/null
+++ b/toolkit/components/places/tests/gtest/test_IHistory.cpp
@@ -0,0 +1,445 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ * vim: sw=2 ts=2 et lcs=trail\:.,tab\:>~ :
+ * 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 "places_test_harness.h"
+#include "nsIPrefBranch.h"
+#include "nsIPrefService.h"
+#include "nsString.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/SpinEventLoopUntil.h"
+#include "mozilla/StaticPrefs_layout.h"
+#include "nsNetUtil.h"
+
+#include "mock_Link.h"
+using namespace mozilla;
+using namespace mozilla::dom;
+
+/**
+ * This file tests the IHistory interface.
+ */
+
+////////////////////////////////////////////////////////////////////////////////
+//// Helper Methods
+
+void expect_visit(Link::State aState) {
+  do_check_true(aState == Link::State::Visited);
+}
+
+void expect_no_visit(Link::State aState) {
+  do_check_true(aState == Link::State::Unvisited);
+}
+
+already_AddRefed<nsIURI> new_test_uri() {
+  // Create a unique spec.
+  static int32_t specNumber = 0;
+  nsCString spec = "http://mozilla.org/"_ns;
+  spec.AppendInt(specNumber++);
+
+  // Create the URI for the spec.
+  nsCOMPtr<nsIURI> testURI;
+  nsresult rv = NS_NewURI(getter_AddRefs(testURI), spec);
+  do_check_success(rv);
+  return testURI.forget();
+}
+
+class VisitURIObserver final : public nsIObserver {
+  ~VisitURIObserver() = default;
+
+ public:
+  NS_DECL_ISUPPORTS
+
+  explicit VisitURIObserver(int aExpectedVisits = 1)
+      : mVisits(0), mExpectedVisits(aExpectedVisits) {
+    nsCOMPtr<nsIObserverService> observerService =
+        do_GetService(NS_OBSERVERSERVICE_CONTRACTID);
+    do_check_true(observerService);
+    (void)observerService->AddObserver(this, "uri-visit-saved", false);
+  }
+
+  void WaitForNotification() {
+    SpinEventLoopUntil("places:VisitURIObserver::WaitForNotification"_ns,
+                       [&]() { return mVisits >= mExpectedVisits; });
+  }
+
+  NS_IMETHOD Observe(nsISupports* aSubject, const char* aTopic,
+                     const char16_t* aData) override {
+    mVisits++;
+
+    if (mVisits == mExpectedVisits) {
+      nsCOMPtr<nsIObserverService> observerService =
+          do_GetService(NS_OBSERVERSERVICE_CONTRACTID);
+      (void)observerService->RemoveObserver(this, "uri-visit-saved");
+    }
+
+    return NS_OK;
+  }
+
+ private:
+  int mVisits;
+  int mExpectedVisits;
+};
+NS_IMPL_ISUPPORTS(VisitURIObserver, nsIObserver)
+
+////////////////////////////////////////////////////////////////////////////////
+//// Test Functions
+
+void test_set_places_enabled() {
+  // Ensure places is enabled for everyone.
+  nsresult rv;
+  nsCOMPtr<nsIPrefBranch> prefBranch =
+      do_GetService(NS_PREFSERVICE_CONTRACTID, &rv);
+  do_check_success(rv);
+
+  rv = prefBranch->SetBoolPref("places.history.enabled", true);
+  do_check_success(rv);
+
+  // Run the next test.
+  run_next_test();
+}
+
+void test_wait_checkpoint() {
+  // This "fake" test is here to wait for the initial WAL checkpoint we force
+  // after creating the database schema, since that may happen at any time,
+  // and cause concurrent readers to access an older checkpoint.
+  nsCOMPtr<mozIStorageConnection> db = do_get_db();
+  nsCOMPtr<mozIStorageAsyncStatement> stmt;
+  db->CreateAsyncStatement("SELECT 1"_ns, getter_AddRefs(stmt));
+  RefPtr<PlacesAsyncStatementSpinner> spinner =
+      new PlacesAsyncStatementSpinner();
+  nsCOMPtr<mozIStoragePendingStatement> pending;
+  (void)stmt->ExecuteAsync(spinner, getter_AddRefs(pending));
+  spinner->SpinUntilCompleted();
+
+  // Run the next test.
+  run_next_test();
+}
+
+// These variables are shared between part 1 and part 2 of the test.  Part 2
+// sets the nsCOMPtr's to nullptr, freeing the reference.
+namespace test_unvisited_does_not_notify {
+nsCOMPtr<nsIURI> testURI;
+RefPtr<mock_Link> testLink;
+}  // namespace test_unvisited_does_not_notify
+void test_unvisited_does_not_notify_part1() {
+  using namespace test_unvisited_does_not_notify;
+
+  // This test is done in two parts.  The first part registers for a URI that
+  // should not be visited.  We then run another test that will also do a
+  // lookup and will be notified.  Since requests are answered in the order they
+  // are requested (at least as long as the same URI isn't asked for later), we
+  // will know that the Link was not notified.
+
+  // First, we need a test URI.
+  testURI = new_test_uri();
+
+  // Create our test Link.
+  testLink = new mock_Link(expect_no_visit);
+
+  // Now, register our Link to be notified.
+  nsCOMPtr<IHistory> history = do_get_IHistory();
+  history->RegisterVisitedCallback(testURI, testLink);
+
+  // Run the next test.
+  run_next_test();
+}
+
+void test_visited_notifies() {
+  // First, we add our test URI to history.
+  nsCOMPtr<nsIURI> testURI = new_test_uri();
+  addURI(testURI);
+
+  // Create our test Link.  The callback function will release the reference we
+  // have on the Link.
+  RefPtr<Link> link = new mock_Link(expect_visit);
+
+  // Now, register our Link to be notified.
+  nsCOMPtr<IHistory> history = do_get_IHistory();
+  history->RegisterVisitedCallback(testURI, link);
+
+  // Note: test will continue upon notification.
+}
+
+void test_unvisited_does_not_notify_part2() {
+  using namespace test_unvisited_does_not_notify;
+
+  SpinEventLoopUntil("places:test_unvisited_does_not_notify_part2"_ns,
+                     [&]() { return testLink->GotNotified(); });
+
+  // We would have had a failure at this point had the content node been told it
+  // was visited. Therefore, now we change it so that it expects a visited
+  // notification, and unregisters itself after addURI.
+  testLink->AwaitNewNotification(expect_visit);
+  addURI(testURI);
+
+  // Clear the stored variables now.
+  testURI = nullptr;
+  testLink = nullptr;
+}
+
+void test_same_uri_notifies_both() {
+  // First, we add our test URI to history.
+  nsCOMPtr<nsIURI> testURI = new_test_uri();
+  addURI(testURI);
+
+  // Create our two test Links.  The callback function will release the
+  // reference we have on the Links.  Only the second Link should run the next
+  // test!
+  RefPtr<Link> link1 = new mock_Link(expect_visit, false);
+  RefPtr<Link> link2 = new mock_Link(expect_visit);
+
+  // Now, register our Link to be notified.
+  nsCOMPtr<IHistory> history = do_get_IHistory();
+  history->RegisterVisitedCallback(testURI, link1);
+  history->RegisterVisitedCallback(testURI, link2);
+
+  // Note: test will continue upon notification.
+}
+
+void test_unregistered_visited_does_not_notify() {
+  // This test must have a test that has a successful notification after it.
+  // The Link would have been notified by now if we were buggy and notified
+  // unregistered Links (due to request serialization).
+
+  nsCOMPtr<nsIURI> testURI = new_test_uri();
+  RefPtr<Link> link = new mock_Link(expect_no_visit, false);
+  nsCOMPtr<IHistory> history(do_get_IHistory());
+  history->RegisterVisitedCallback(testURI, link);
+
+  // Unregister the Link.
+  history->UnregisterVisitedCallback(testURI, link);
+
+  // And finally add a visit for the URI.
+  addURI(testURI);
+
+  // If history tries to notify us, we'll either crash because the Link will
+  // have been deleted (we are the only thing holding a reference to it), or our
+  // expect_no_visit call back will produce a failure.  Either way, the test
+  // will be reported as a failure.
+
+  // Run the next test.
+  run_next_test();
+}
+
+void test_new_visit_notifies_waiting_Link() {
+  // Create our test Link.  The callback function will release the reference we
+  // have on the link.
+  //
+  // Note that this will query the database and we'll get an _unvisited_
+  // notification, then (after we addURI) a _visited_ one.
+  RefPtr<mock_Link> link = new mock_Link(expect_no_visit);
+
+  // Now, register our content node to be notified.
+  nsCOMPtr<nsIURI> testURI = new_test_uri();
+  nsCOMPtr<IHistory> history = do_get_IHistory();
+  history->RegisterVisitedCallback(testURI, link);
+
+  SpinEventLoopUntil("places:test_new_visit_notifies_waiting_Link"_ns,
+                     [&]() { return link->GotNotified(); });
+
+  link->AwaitNewNotification(expect_visit);
+
+  // Add ourselves to history.
+  addURI(testURI);
+
+  // Note: test will continue upon notification.
+}
+
+void test_RegisterVisitedCallback_returns_before_notifying() {
+  // Add a URI so that it's already in history.
+  nsCOMPtr<nsIURI> testURI = new_test_uri();
+  addURI(testURI);
+
+  // Create our test Link.
+  RefPtr<Link> link = new mock_Link(expect_no_visit, false);
+
+  // Now, register our content node to be notified.  It should not be notified.
+  nsCOMPtr<IHistory> history = do_get_IHistory();
+  history->RegisterVisitedCallback(testURI, link);
+
+  // Remove ourselves as an observer.  We would have failed if we had been
+  // notified.
+  history->UnregisterVisitedCallback(testURI, link);
+
+  run_next_test();
+}
+
+void test_visituri_inserts() {
+  nsCOMPtr<IHistory> history = do_get_IHistory();
+  nsCOMPtr<nsIURI> lastURI = new_test_uri();
+  nsCOMPtr<nsIURI> visitedURI = new_test_uri();
+
+  history->VisitURI(nullptr, visitedURI, lastURI, mozilla::IHistory::TOP_LEVEL,
+                    0);
+
+  RefPtr<VisitURIObserver> finisher = new VisitURIObserver();
+  finisher->WaitForNotification();
+
+  PlaceRecord place;
+  do_get_place(visitedURI, place);
+
+  do_check_true(place.id > 0);
+  do_check_false(place.hidden);
+  do_check_false(place.typed);
+  do_check_eq(place.visitCount, 1);
+
+  run_next_test();
+}
+
+void test_visituri_updates() {
+  nsCOMPtr<IHistory> history = do_get_IHistory();
+  nsCOMPtr<nsIURI> lastURI = new_test_uri();
+  nsCOMPtr<nsIURI> visitedURI = new_test_uri();
+  RefPtr<VisitURIObserver> finisher;
+
+  history->VisitURI(nullptr, visitedURI, lastURI, mozilla::IHistory::TOP_LEVEL,
+                    0);
+  finisher = new VisitURIObserver();
+  finisher->WaitForNotification();
+
+  history->VisitURI(nullptr, visitedURI, lastURI, mozilla::IHistory::TOP_LEVEL,
+                    0);
+  finisher = new VisitURIObserver();
+  finisher->WaitForNotification();
+
+  PlaceRecord place;
+  do_get_place(visitedURI, place);
+
+  do_check_eq(place.visitCount, 2);
+
+  run_next_test();
+}
+
+void test_visituri_preserves_shown_and_typed() {
+  nsCOMPtr<IHistory> history = do_get_IHistory();
+  nsCOMPtr<nsIURI> lastURI = new_test_uri();
+  nsCOMPtr<nsIURI> visitedURI = new_test_uri();
+
+  history->VisitURI(nullptr, visitedURI, lastURI, mozilla::IHistory::TOP_LEVEL,
+                    0);
+  // this simulates the uri visit happening in a frame.  Normally frame
+  // transitions would be hidden unless it was previously loaded top-level
+  history->VisitURI(nullptr, visitedURI, lastURI, 0, 0);
+
+  RefPtr<VisitURIObserver> finisher = new VisitURIObserver(2);
+  finisher->WaitForNotification();
+
+  PlaceRecord place;
+  do_get_place(visitedURI, place);
+  do_check_false(place.hidden);
+
+  run_next_test();
+}
+
+void test_visituri_creates_visit() {
+  nsCOMPtr<IHistory> history = do_get_IHistory();
+  nsCOMPtr<nsIURI> lastURI = new_test_uri();
+  nsCOMPtr<nsIURI> visitedURI = new_test_uri();
+
+  history->VisitURI(nullptr, visitedURI, lastURI, mozilla::IHistory::TOP_LEVEL,
+                    0);
+  RefPtr<VisitURIObserver> finisher = new VisitURIObserver();
+  finisher->WaitForNotification();
+
+  PlaceRecord place;
+  VisitRecord visit;
+  do_get_place(visitedURI, place);
+  do_get_lastVisit(place.id, visit);
+
+  do_check_true(visit.id > 0);
+  do_check_eq(visit.lastVisitId, 0);
+  do_check_eq(visit.transitionType, nsINavHistoryService::TRANSITION_LINK);
+
+  run_next_test();
+}
+
+void test_visituri_transition_typed() {
+  nsCOMPtr<nsINavHistoryService> navHistory = do_get_NavHistory();
+  nsCOMPtr<IHistory> history = do_get_IHistory();
+  nsCOMPtr<nsIURI> lastURI = new_test_uri();
+  nsCOMPtr<nsIURI> visitedURI = new_test_uri();
+
+  navHistory->MarkPageAsTyped(visitedURI);
+  history->VisitURI(nullptr, visitedURI, lastURI, mozilla::IHistory::TOP_LEVEL,
+                    0);
+  RefPtr<VisitURIObserver> finisher = new VisitURIObserver();
+  finisher->WaitForNotification();
+
+  PlaceRecord place;
+  VisitRecord visit;
+  do_get_place(visitedURI, place);
+  do_get_lastVisit(place.id, visit);
+
+  do_check_true(visit.transitionType == nsINavHistoryService::TRANSITION_TYPED);
+
+  run_next_test();
+}
+
+void test_visituri_transition_embed() {
+  nsCOMPtr<IHistory> history = do_get_IHistory();
+  nsCOMPtr<nsIURI> lastURI = new_test_uri();
+  nsCOMPtr<nsIURI> visitedURI = new_test_uri();
+
+  history->VisitURI(nullptr, visitedURI, lastURI, 0, 0);
+  RefPtr<VisitURIObserver> finisher = new VisitURIObserver();
+  finisher->WaitForNotification();
+
+  PlaceRecord place;
+  VisitRecord visit;
+  do_get_place(visitedURI, place);
+  do_get_lastVisit(place.id, visit);
+
+  do_check_eq(place.id, 0);
+  do_check_eq(visit.id, 0);
+
+  run_next_test();
+}
+
+void test_new_visit_adds_place_guid() {
+  // First, add a visit and wait.  This will also add a place.
+  nsCOMPtr<nsIURI> visitedURI = new_test_uri();
+  nsCOMPtr<IHistory> history = do_get_IHistory();
+  nsresult rv = history->VisitURI(nullptr, visitedURI, nullptr,
+                                  mozilla::IHistory::TOP_LEVEL, 0);
+  do_check_success(rv);
+  RefPtr<VisitURIObserver> finisher = new VisitURIObserver();
+  finisher->WaitForNotification();
+
+  // Check that we have a guid for our visit.
+  PlaceRecord place;
+  do_get_place(visitedURI, place);
+  do_check_eq(place.visitCount, 1);
+  do_check_eq(place.guid.Length(), 12u);
+
+  run_next_test();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//// Test Harness
+
+/**
+ * Note: for tests marked "Order Important!", please see the test for details.
+ */
+Test gTests[] = {
+    PTEST(test_set_places_enabled),               // Must come first!
+    PTEST(test_wait_checkpoint),                  // Must come second!
+    PTEST(test_unvisited_does_not_notify_part1),  // Order Important!
+    PTEST(test_visited_notifies),
+    PTEST(test_unvisited_does_not_notify_part2),  // Order Important!
+    PTEST(test_same_uri_notifies_both),
+    PTEST(test_unregistered_visited_does_not_notify),  // Order Important!
+    PTEST(test_new_visit_notifies_waiting_Link),
+    PTEST(test_RegisterVisitedCallback_returns_before_notifying),
+    PTEST(test_visituri_inserts),
+    PTEST(test_visituri_updates),
+    PTEST(test_visituri_preserves_shown_and_typed),
+    PTEST(test_visituri_creates_visit),
+    PTEST(test_visituri_transition_typed),
+    PTEST(test_visituri_transition_embed),
+    PTEST(test_new_visit_adds_place_guid),
+};
+
+#define TEST_NAME "IHistory"
+#include "places_test_harness_tail.h"
diff --git a/toolkit/components/places/tests/gtest/test_casing.cpp b/toolkit/components/places/tests/gtest/test_casing.cpp
new file mode 100644
index 0000000000..079d64bbd0
--- /dev/null
+++ b/toolkit/components/places/tests/gtest/test_casing.cpp
@@ -0,0 +1,29 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ * vim: sw=2 ts=2 et lcs=trail\:.,tab\:>~ :
+ * 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 "gtest/gtest.h"
+#include "mozilla/intl/UnicodeProperties.h"
+
+// Verify the assertion in SQLFunctions.cpp / nextSearchCandidate that the
+// only non-ASCII characters that lower-case to ASCII ones are:
+//  * U+0130 LATIN CAPITAL LETTER I WITH DOT ABOVE
+//  * U+212A KELVIN SIGN
+TEST(MatchAutocompleteCasing, CaseAssumption)
+{
+  for (uint32_t c = 128; c < 0x110000; c++) {
+    if (c != 304 && c != 8490) {
+      ASSERT_GE(mozilla::intl::UnicodeProperties::ToLower(c), 128U);
+    }
+  }
+}
+
+// Verify the assertion that all ASCII characters lower-case to ASCII.
+TEST(MatchAutocompleteCasing, CaseAssumption2)
+{
+  for (uint32_t c = 0; c < 128; c++) {
+    ASSERT_LT(mozilla::intl::UnicodeProperties::ToLower(c), 128U);
+  }
+}