The Tor Browser: storage/test/test_true_async.cpp@b8a032363ba2 (annotated)

storage/test/test_true_async.cpp@b8a032363ba2 (annotated)

storage/test/test_true_async.cpp

Thu, 22 Jan 2015 13:21:57 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 22 Jan 2015 13:21:57 +0100
branch: TOR_BUG_9701
changeset 15: b8a032363ba2
permissions: -rw-r--r--

Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6

 /* -*- 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 "storage_test_harness.h"
 #include "prthread.h"
 #include "nsIEventTarget.h"
 #include "nsIInterfaceRequestorUtils.h"
 #include "sqlite3.h"
 #include "mozilla/ReentrantMonitor.h"
 using mozilla::ReentrantMonitor;
 using mozilla::ReentrantMonitorAutoEnter;
 /**
  * Verify that mozIStorageAsyncStatement's life-cycle never triggers a mutex on
  * the caller (generally main) thread.  We do this by decorating the sqlite
  * mutex logic with our own code that checks what thread it is being invoked on
  * and sets a flag if it is invoked on the main thread.  We are able to easily
  * decorate the SQLite mutex logic because SQLite allows us to retrieve the
  * current function pointers being used and then provide a new set.
  */
 /* ===== Mutex Watching ===== */
 sqlite3_mutex_methods orig_mutex_methods;
 sqlite3_mutex_methods wrapped_mutex_methods;
 bool mutex_used_on_watched_thread = false;
 PRThread *watched_thread = nullptr;
 /**
  * Ugly hack to let us figure out what a connection's async thread is.  If we
  * were MOZILLA_INTERNAL_API and linked as such we could just include
  * mozStorageConnection.h and just ask Connection directly.  But that turns out
  * poorly.
  *
  * When the thread a mutex is invoked on isn't watched_thread we save it to this
  * variable.
  */
 PRThread *last_non_watched_thread = nullptr;
 /**
  * Set a flag if the mutex is used on the thread we are watching, but always
  * call the real mutex function.
  */
 extern "C" void wrapped_MutexEnter(sqlite3_mutex *mutex)
 {
   PRThread *curThread = ::PR_GetCurrentThread();
   if (curThread == watched_thread)
     mutex_used_on_watched_thread = true;
   else
     last_non_watched_thread = curThread;
   orig_mutex_methods.xMutexEnter(mutex);
 }
 extern "C" int wrapped_MutexTry(sqlite3_mutex *mutex)
 {
   if (::PR_GetCurrentThread() == watched_thread)
     mutex_used_on_watched_thread = true;
   return orig_mutex_methods.xMutexTry(mutex);
 }
 #define do_check_ok(aInvoc) do_check_true((aInvoc) == SQLITE_OK)
 void hook_sqlite_mutex()
 {
   // We need to initialize and teardown SQLite to get it to set up the
   // default mutex handlers for us so we can steal them and wrap them.
   do_check_ok(sqlite3_initialize());
   do_check_ok(sqlite3_shutdown());
   do_check_ok(::sqlite3_config(SQLITE_CONFIG_GETMUTEX, &orig_mutex_methods));
   do_check_ok(::sqlite3_config(SQLITE_CONFIG_GETMUTEX, &wrapped_mutex_methods));
   wrapped_mutex_methods.xMutexEnter = wrapped_MutexEnter;
   wrapped_mutex_methods.xMutexTry = wrapped_MutexTry;
   do_check_ok(::sqlite3_config(SQLITE_CONFIG_MUTEX, &wrapped_mutex_methods));
 }
 /**
  * Call to clear the watch state and to set the watching against this thread.
  *
  * Check |mutex_used_on_watched_thread| to see if the mutex has fired since
  * this method was last called.  Since we're talking about the current thread,
  * there are no race issues to be concerned about
  */
 void watch_for_mutex_use_on_this_thread()
 {
   watched_thread = ::PR_GetCurrentThread();
   mutex_used_on_watched_thread = false;
 }
 ////////////////////////////////////////////////////////////////////////////////
 //// Thread Wedgers
 /**
  * A runnable that blocks until code on another thread invokes its unwedge
  * method.  By dispatching this to a thread you can ensure that no subsequent
  * runnables dispatched to the thread will execute until you invoke unwedge.
  *
  * The wedger is self-dispatching, just construct it with its target.
  */
 class ThreadWedger : public nsRunnable
 {
 public:
   ThreadWedger(nsIEventTarget *aTarget)
   : mReentrantMonitor("thread wedger")
   , unwedged(false)
   {
     aTarget->Dispatch(this, aTarget->NS_DISPATCH_NORMAL);
   }
   NS_IMETHOD Run()
   {
     ReentrantMonitorAutoEnter automon(mReentrantMonitor);
     if (!unwedged)
       automon.Wait();
     return NS_OK;
   }
   void unwedge()
   {
     ReentrantMonitorAutoEnter automon(mReentrantMonitor);
     unwedged = true;
     automon.Notify();
   }
 private:
   ReentrantMonitor mReentrantMonitor;
   bool unwedged;
 };
 ////////////////////////////////////////////////////////////////////////////////
 //// Async Helpers
 /**
  * A horrible hack to figure out what the connection's async thread is.  By
  * creating a statement and async dispatching we can tell from the mutex who
  * is the async thread, PRThread style.  Then we map that to an nsIThread.
  */
 already_AddRefed<nsIThread>
 get_conn_async_thread(mozIStorageConnection *db)
 {
   // Make sure we are tracking the current thread as the watched thread
   watch_for_mutex_use_on_this_thread();
   // - statement with nothing to bind
   nsCOMPtr<mozIStorageAsyncStatement> stmt;
   db->CreateAsyncStatement(
     NS_LITERAL_CSTRING("SELECT 1"),
     getter_AddRefs(stmt));
   blocking_async_execute(stmt);
   stmt->Finalize();
   nsCOMPtr<nsIThreadManager> threadMan =
     do_GetService("@mozilla.org/thread-manager;1");
   nsCOMPtr<nsIThread> asyncThread;
   threadMan->GetThreadFromPRThread(last_non_watched_thread,
                                    getter_AddRefs(asyncThread));
   // Additionally, check that the thread we get as the background thread is the
   // same one as the one we report from getInterface.
   nsCOMPtr<nsIEventTarget> target = do_GetInterface(db);
   nsCOMPtr<nsIThread> allegedAsyncThread = do_QueryInterface(target);
   PRThread *allegedPRThread;
   (void)allegedAsyncThread->GetPRThread(&allegedPRThread);
   do_check_eq(allegedPRThread, last_non_watched_thread);
   return asyncThread.forget();
 }
 ////////////////////////////////////////////////////////////////////////////////
 //// Tests
 void
 test_TrueAsyncStatement()
 {
   // (only the first test needs to call this)
   hook_sqlite_mutex();
   nsCOMPtr<mozIStorageConnection> db(getMemoryDatabase());
   // Start watching for forbidden mutex usage.
   watch_for_mutex_use_on_this_thread();
   // - statement with nothing to bind
   nsCOMPtr<mozIStorageAsyncStatement> stmt;
   db->CreateAsyncStatement(
     NS_LITERAL_CSTRING("CREATE TABLE test (id INTEGER PRIMARY KEY)"),
     getter_AddRefs(stmt)
   );
   blocking_async_execute(stmt);
   stmt->Finalize();
   do_check_false(mutex_used_on_watched_thread);
   // - statement with something to bind ordinally
   db->CreateAsyncStatement(
     NS_LITERAL_CSTRING("INSERT INTO test (id) VALUES (?)"),
     getter_AddRefs(stmt)
   );
   stmt->BindInt32ByIndex(0, 1);
   blocking_async_execute(stmt);
   stmt->Finalize();
   do_check_false(mutex_used_on_watched_thread);
   // - statement with something to bind by name
   db->CreateAsyncStatement(
     NS_LITERAL_CSTRING("INSERT INTO test (id) VALUES (:id)"),
     getter_AddRefs(stmt)
   );
   nsCOMPtr<mozIStorageBindingParamsArray> paramsArray;
   stmt->NewBindingParamsArray(getter_AddRefs(paramsArray));
   nsCOMPtr<mozIStorageBindingParams> params;
   paramsArray->NewBindingParams(getter_AddRefs(params));
   params->BindInt32ByName(NS_LITERAL_CSTRING("id"), 2);
   paramsArray->AddParams(params);
   params = nullptr;
   stmt->BindParameters(paramsArray);
   paramsArray = nullptr;
   blocking_async_execute(stmt);
   stmt->Finalize();
   do_check_false(mutex_used_on_watched_thread);
   // - now, make sure creating a sync statement does trigger our guard.
   // (If this doesn't happen, our test is bunk and it's important to know that.)
   nsCOMPtr<mozIStorageStatement> syncStmt;
   db->CreateStatement(NS_LITERAL_CSTRING("SELECT * FROM test"),
                       getter_AddRefs(syncStmt));
   syncStmt->Finalize();
   do_check_true(mutex_used_on_watched_thread);
   blocking_async_close(db);
 }
 /**
  * Test that cancellation before a statement is run successfully stops the
  * statement from executing.
  */
 void
 test_AsyncCancellation()
 {
   nsCOMPtr<mozIStorageConnection> db(getMemoryDatabase());
   // -- wedge the thread
   nsCOMPtr<nsIThread> target(get_conn_async_thread(db));
   do_check_true(target);
   nsRefPtr<ThreadWedger> wedger (new ThreadWedger(target));
   // -- create statements and cancel them
   // - async
   nsCOMPtr<mozIStorageAsyncStatement> asyncStmt;
   db->CreateAsyncStatement(
     NS_LITERAL_CSTRING("CREATE TABLE asyncTable (id INTEGER PRIMARY KEY)"),
     getter_AddRefs(asyncStmt)
   );
   nsRefPtr<AsyncStatementSpinner> asyncSpin(new AsyncStatementSpinner());
   nsCOMPtr<mozIStoragePendingStatement> asyncPend;
   (void)asyncStmt->ExecuteAsync(asyncSpin, getter_AddRefs(asyncPend));
   do_check_true(asyncPend);
   asyncPend->Cancel();
   // - sync
   nsCOMPtr<mozIStorageStatement> syncStmt;
   db->CreateStatement(
     NS_LITERAL_CSTRING("CREATE TABLE syncTable (id INTEGER PRIMARY KEY)"),
     getter_AddRefs(syncStmt)
   );
   nsRefPtr<AsyncStatementSpinner> syncSpin(new AsyncStatementSpinner());
   nsCOMPtr<mozIStoragePendingStatement> syncPend;
   (void)syncStmt->ExecuteAsync(syncSpin, getter_AddRefs(syncPend));
   do_check_true(syncPend);
   syncPend->Cancel();
   // -- unwedge the async thread
   wedger->unwedge();
   // -- verify that both statements report they were canceled
   asyncSpin->SpinUntilCompleted();
   do_check_true(asyncSpin->completionReason ==
                 mozIStorageStatementCallback::REASON_CANCELED);
   syncSpin->SpinUntilCompleted();
   do_check_true(syncSpin->completionReason ==
                 mozIStorageStatementCallback::REASON_CANCELED);
   // -- verify that neither statement constructed their tables
   nsresult rv;
   bool exists;
   rv = db->TableExists(NS_LITERAL_CSTRING("asyncTable"), &exists);
   do_check_true(rv == NS_OK);
   do_check_false(exists);
   rv = db->TableExists(NS_LITERAL_CSTRING("syncTable"), &exists);
   do_check_true(rv == NS_OK);
   do_check_false(exists);
   // -- cleanup
   asyncStmt->Finalize();
   syncStmt->Finalize();
   blocking_async_close(db);
 }
 /**
  * Test that the destructor for an asynchronous statement which has a
  *  sqlite3_stmt will dispatch that statement to the async thread for
  *  finalization rather than trying to finalize it on the main thread
  *  (and thereby running afoul of our mutex use detector).
  */
 void test_AsyncDestructorFinalizesOnAsyncThread()
 {
   // test_TrueAsyncStatement called hook_sqlite_mutex() for us
   nsCOMPtr<mozIStorageConnection> db(getMemoryDatabase());
   watch_for_mutex_use_on_this_thread();
   // -- create an async statement
   nsCOMPtr<mozIStorageAsyncStatement> stmt;
   db->CreateAsyncStatement(
     NS_LITERAL_CSTRING("CREATE TABLE test (id INTEGER PRIMARY KEY)"),
     getter_AddRefs(stmt)
   );
   // -- execute it so it gets a sqlite3_stmt that needs to be finalized
   blocking_async_execute(stmt);
   do_check_false(mutex_used_on_watched_thread);
   // -- forget our reference
   stmt = nullptr;
   // -- verify the mutex was not touched
   do_check_false(mutex_used_on_watched_thread);
   // -- make sure the statement actually gets finalized / cleanup
   // the close will assert if we failed to finalize!
   blocking_async_close(db);
 }
 void (*gTests[])(void) = {
   // this test must be first because it hooks the mutex mechanics
   test_TrueAsyncStatement,
   test_AsyncCancellation,
   test_AsyncDestructorFinalizesOnAsyncThread
 };
 const char *file = __FILE__;
 #define TEST_NAME "true async statement"
 #define TEST_FILE file
 #include "storage_test_harness_tail.h"

The Tor Browser / annotate

storage/test/test_true_async.cpp@b8a032363ba2 (annotated)

storage/test/test_true_async.cpp