The Tor Browser: storage/src/StorageBaseStatementInternal.cpp@97036ab72558 (annotated)

storage/src/StorageBaseStatementInternal.cpp@97036ab72558 (annotated)

storage/src/StorageBaseStatementInternal.cpp

Tue, 06 Jan 2015 21:39:09 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Tue, 06 Jan 2015 21:39:09 +0100
branch: TOR_BUG_9701
changeset 8: 97036ab72558
permissions: -rw-r--r--

Conditionally force memory storage according to privacy.thirdparty.isolate;
This solves Tor bug #9701, complying with disk avoidance documented in
https://www.torproject.org/projects/torbrowser/design/#disk-avoidance.

 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
  * vim: sw=2 ts=2 sts=2 expandtab
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 #include "StorageBaseStatementInternal.h"
 #include "nsProxyRelease.h"
 #include "mozStorageBindingParamsArray.h"
 #include "mozStorageStatementData.h"
 #include "mozStorageAsyncStatementExecution.h"
 namespace mozilla {
 namespace storage {
 ////////////////////////////////////////////////////////////////////////////////
 //// Local Classes
 /**
  * Used to finalize an asynchronous statement on the background thread.
  */
 class AsyncStatementFinalizer : public nsRunnable
 {
 public:
   /**
    * Constructor for the event.
    *
    * @param aStatement
    *        We need the AsyncStatement to be able to get at the sqlite3_stmt;
    *        we only access/create it on the async thread.
    * @param aConnection
    *        We need the connection to know what thread to release the statement
    *        on.  We release the statement on that thread since releasing the
    *        statement might end up releasing the connection too.
    */
   AsyncStatementFinalizer(StorageBaseStatementInternal *aStatement,
                           Connection *aConnection)
   : mStatement(aStatement)
   , mConnection(aConnection)
   {
   }
   NS_IMETHOD Run()
   {
     if (mStatement->mAsyncStatement) {
       (void)::sqlite3_finalize(mStatement->mAsyncStatement);
       mStatement->mAsyncStatement = nullptr;
     }
     (void)::NS_ProxyRelease(mConnection->threadOpenedOn, mStatement);
     return NS_OK;
   }
 private:
   nsRefPtr<StorageBaseStatementInternal> mStatement;
   nsRefPtr<Connection> mConnection;
 };
 /**
  * Finalize a sqlite3_stmt on the background thread for a statement whose
  * destructor was invoked and the statement was non-null.
  */
 class LastDitchSqliteStatementFinalizer : public nsRunnable
 {
 public:
   /**
    * Event constructor.
    *
    * @param aConnection
    *        Used to keep the connection alive.  If we failed to do this, it
    *        is possible that the statement going out of scope invoking us
    *        might have the last reference to the connection and so trigger
    *        an attempt to close the connection which is doomed to fail
    *        (because the asynchronous execution thread must exist which will
    *        trigger the failure case).
    * @param aStatement
    *        The sqlite3_stmt to finalize.  This object takes ownership /
    *        responsibility for the instance and all other references to it
    *        should be forgotten.
    */
   LastDitchSqliteStatementFinalizer(nsRefPtr<Connection> &aConnection,
                                     sqlite3_stmt *aStatement)
   : mConnection(aConnection)
   , mAsyncStatement(aStatement)
   {
     NS_PRECONDITION(aConnection, "You must provide a Connection");
   }
   NS_IMETHOD Run()
   {
     (void)::sqlite3_finalize(mAsyncStatement);
     mAsyncStatement = nullptr;
     // Because of our ambiguous nsISupports we cannot use the NS_ProxyRelease
     // template helpers.
     Connection *rawConnection = nullptr;
     mConnection.swap(rawConnection);
     (void)::NS_ProxyRelease(
       rawConnection->threadOpenedOn,
       NS_ISUPPORTS_CAST(mozIStorageConnection *, rawConnection));
     return NS_OK;
   }
 private:
   nsRefPtr<Connection> mConnection;
   sqlite3_stmt *mAsyncStatement;
 };
 ////////////////////////////////////////////////////////////////////////////////
 //// StorageBaseStatementInternal
 StorageBaseStatementInternal::StorageBaseStatementInternal()
 : mAsyncStatement(nullptr)
 {
 }
 void
 StorageBaseStatementInternal::asyncFinalize()
 {
   nsIEventTarget *target = mDBConnection->getAsyncExecutionTarget();
   if (target) {
     // Attempt to finalize asynchronously
     nsCOMPtr<nsIRunnable> event =
       new AsyncStatementFinalizer(this, mDBConnection);
     // Dispatch. Note that dispatching can fail, typically if
     // we have a race condition with asyncClose(). It's ok,
     // let asyncClose() win.
     (void)target->Dispatch(event, NS_DISPATCH_NORMAL);
   }
   // If we cannot get the background thread,
   // mozStorageConnection::AsyncClose() has already been called and
   // the statement either has been or will be cleaned up by
   // internalClose().
 }
 void
 StorageBaseStatementInternal::destructorAsyncFinalize()
 {
   if (!mAsyncStatement)
     return;
   // If we reach this point, our owner has not finalized this
   // statement, yet we are being destructed. If possible, we want to
   // auto-finalize it early, to release the resources early.
   nsIEventTarget *target = mDBConnection->getAsyncExecutionTarget();
   if (target) {
     // If we can get the async execution target, we can indeed finalize
     // the statement, as the connection is still open.
     bool isAsyncThread = false;
     (void)target->IsOnCurrentThread(&isAsyncThread);
     nsCOMPtr<nsIRunnable> event =
       new LastDitchSqliteStatementFinalizer(mDBConnection, mAsyncStatement);
     if (isAsyncThread) {
       (void)event->Run();
     } else {
       (void)target->Dispatch(event, NS_DISPATCH_NORMAL);
     }
   }
   // We might not be able to dispatch to the background thread,
   // presumably because it is being shutdown. Since said shutdown will
   // finalize the statement, we just need to clean-up around here.
   mAsyncStatement = nullptr;
 }
 NS_IMETHODIMP
 StorageBaseStatementInternal::NewBindingParamsArray(
   mozIStorageBindingParamsArray **_array
 )
 {
   nsCOMPtr<mozIStorageBindingParamsArray> array = new BindingParamsArray(this);
   NS_ENSURE_TRUE(array, NS_ERROR_OUT_OF_MEMORY);
   array.forget(_array);
   return NS_OK;
 }
 NS_IMETHODIMP
 StorageBaseStatementInternal::ExecuteAsync(
   mozIStorageStatementCallback *aCallback,
   mozIStoragePendingStatement **_stmt
 )
 {
   // We used to call Connection::ExecuteAsync but it takes a
   // mozIStorageBaseStatement signature because it is also a public API.  Since
   // our 'this' has no static concept of mozIStorageBaseStatement and Connection
   // would just QI it back across to a StorageBaseStatementInternal and the
   // actual logic is very simple, we now roll our own.
   nsTArray<StatementData> stmts(1);
   StatementData data;
   nsresult rv = getAsynchronousStatementData(data);
   NS_ENSURE_SUCCESS(rv, rv);
   NS_ENSURE_TRUE(stmts.AppendElement(data), NS_ERROR_OUT_OF_MEMORY);
   // Dispatch to the background
   return AsyncExecuteStatements::execute(stmts, mDBConnection,
                                          mNativeConnection, aCallback, _stmt);
 }
 NS_IMETHODIMP
 StorageBaseStatementInternal::EscapeStringForLIKE(
   const nsAString &aValue,
   const char16_t aEscapeChar,
   nsAString &_escapedString
 )
 {
   const char16_t MATCH_ALL('%');
   const char16_t MATCH_ONE('_');
   _escapedString.Truncate(0);
   for (uint32_t i = 0; i < aValue.Length(); i++) {
     if (aValue[i] == aEscapeChar || aValue[i] == MATCH_ALL ||
         aValue[i] == MATCH_ONE) {
       _escapedString += aEscapeChar;
     }
     _escapedString += aValue[i];
   }
   return NS_OK;
 }
 } // namespace storage
 } // namespace mozilla

The Tor Browser / annotate

storage/src/StorageBaseStatementInternal.cpp@97036ab72558 (annotated)

storage/src/StorageBaseStatementInternal.cpp