The Tor Browser: storage/src/mozStorageAsyncStatementExecution.h@129ffea94266 (annotated)

storage/src/mozStorageAsyncStatementExecution.h@129ffea94266 (annotated)

storage/src/mozStorageAsyncStatementExecution.h

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: 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/. */
 #ifndef mozStorageAsyncStatementExecution_h
 #define mozStorageAsyncStatementExecution_h
 #include "nscore.h"
 #include "nsTArray.h"
 #include "nsAutoPtr.h"
 #include "mozilla/Mutex.h"
 #include "mozilla/TimeStamp.h"
 #include "mozilla/Attributes.h"
 #include "nsIRunnable.h"
 #include "SQLiteMutex.h"
 #include "mozIStoragePendingStatement.h"
 #include "mozIStorageStatementCallback.h"
 #include "mozStorageHelper.h"
 struct sqlite3_stmt;
 namespace mozilla {
 namespace storage {
 class Connection;
 class ResultSet;
 class StatementData;
 class AsyncExecuteStatements MOZ_FINAL : public nsIRunnable
                                        , public mozIStoragePendingStatement
 {
 public:
   NS_DECL_THREADSAFE_ISUPPORTS
   NS_DECL_NSIRUNNABLE
   NS_DECL_MOZISTORAGEPENDINGSTATEMENT
   /**
    * Describes the state of execution.
    */
   enum ExecutionState {
     PENDING = -1,
     COMPLETED = mozIStorageStatementCallback::REASON_FINISHED,
     CANCELED = mozIStorageStatementCallback::REASON_CANCELED,
     ERROR = mozIStorageStatementCallback::REASON_ERROR
   };
   typedef nsTArray<StatementData> StatementDataArray;
   /**
    * Executes a statement in the background, and passes results back to the
    * caller.
    *
    * @param aStatements
    *        The statements to execute and possibly bind in the background.
    *        Ownership is transfered from the caller.
    * @param aConnection
    *        The connection that created the statements to execute.
    * @param aNativeConnection
    *        The native Sqlite connection that created the statements to execute.
    * @param aCallback
    *        The callback that is notified of results, completion, and errors.
    * @param _stmt
    *        The handle to control the execution of the statements.
    */
   static nsresult execute(StatementDataArray &aStatements,
                           Connection *aConnection,
                           sqlite3 *aNativeConnection,
                           mozIStorageStatementCallback *aCallback,
                           mozIStoragePendingStatement **_stmt);
   /**
    * Indicates when events on the calling thread should run or not.  Certain
    * events posted back to the calling thread should call this see if they
    * should run or not.
    *
    * @pre mMutex is not held
    *
    * @returns true if the event should notify still, false otherwise.
    */
   bool shouldNotify();
 private:
   AsyncExecuteStatements(StatementDataArray &aStatements,
                          Connection *aConnection,
                          sqlite3 *aNativeConnection,
                          mozIStorageStatementCallback *aCallback);
   ~AsyncExecuteStatements();
   /**
    * Binds and then executes a given statement until completion, an error
    * occurs, or we are canceled.  If aLastStatement is true, we should set
    * mState accordingly.
    *
    * @pre mMutex is not held
    *
    * @param aData
    *        The StatementData to bind, execute, and then process.
    * @param aLastStatement
    *        Indicates if this is the last statement or not.  If it is, we have
    *        to set the proper state.
    * @returns true if we should continue to process statements, false otherwise.
    */
   bool bindExecuteAndProcessStatement(StatementData &aData,
                                       bool aLastStatement);
   /**
    * Executes a given statement until completion, an error occurs, or we are
    * canceled.  If aLastStatement is true, we should set mState accordingly.
    *
    * @pre mMutex is not held
    *
    * @param aStatement
    *        The statement to execute and then process.
    * @param aLastStatement
    *        Indicates if this is the last statement or not.  If it is, we have
    *        to set the proper state.
    * @returns true if we should continue to process statements, false otherwise.
    */
   bool executeAndProcessStatement(sqlite3_stmt *aStatement,
                                   bool aLastStatement);
   /**
    * Executes a statement to completion, properly handling any error conditions.
    *
    * @pre mMutex is not held
    *
    * @param aStatement
    *        The statement to execute to completion.
    * @returns true if results were obtained, false otherwise.
    */
   bool executeStatement(sqlite3_stmt *aStatement);
   /**
    * Builds a result set up with a row from a given statement.  If we meet the
    * right criteria, go ahead and notify about this results too.
    *
    * @pre mMutex is not held
    *
    * @param aStatement
    *        The statement to get the row data from.
    */
   nsresult buildAndNotifyResults(sqlite3_stmt *aStatement);
   /**
    * Notifies callback about completion, and does any necessary cleanup.
    *
    * @pre mMutex is not held
    */
   nsresult notifyComplete();
   /**
    * Notifies callback about an error.
    *
    * @pre mMutex is not held
    * @pre mDBMutex is not held
    *
    * @param aErrorCode
    *        The error code defined in mozIStorageError for the error.
    * @param aMessage
    *        The error string, if any.
    * @param aError
    *        The error object to notify the caller with.
    */
   nsresult notifyError(int32_t aErrorCode, const char *aMessage);
   nsresult notifyError(mozIStorageError *aError);
   /**
    * Notifies the callback about a result set.
    *
    * @pre mMutex is not held
    */
   nsresult notifyResults();
   /**
    * Tests whether the current statements should be wrapped in an explicit
    * transaction.
    *
    * @return true if an explicit transaction is needed, false otherwise.
    */
   bool statementsNeedTransaction();
   StatementDataArray mStatements;
   nsRefPtr<Connection> mConnection;
   sqlite3 *mNativeConnection;
   bool mHasTransaction;
   mozIStorageStatementCallback *mCallback;
   nsCOMPtr<nsIThread> mCallingThread;
   nsRefPtr<ResultSet> mResultSet;
   /**
    * The maximum amount of time we want to wait between results.  Defined by
    * MAX_MILLISECONDS_BETWEEN_RESULTS and set at construction.
    */
   const TimeDuration mMaxWait;
   /**
    * The start time since our last set of results.
    */
   TimeStamp mIntervalStart;
   /**
    * Indicates our state of execution.
    */
   ExecutionState mState;
   /**
    * Indicates if we should try to cancel at a cancelation point.
    */
   bool mCancelRequested;
   /**
    * This is the mutex that protects our state from changing between threads.
    * This includes the following variables:
    *   - mCancelRequested is only set on the calling thread while the lock is
    *     held.  It is always read from within the lock on the background thread,
    *     but not on the calling thread (see shouldNotify for why).
    */
   Mutex &mMutex;
   /**
    * The wrapped SQLite recursive connection mutex.  We use it whenever we call
    * sqlite3_step and care about having reliable error messages.  By taking it
    * prior to the call and holding it until the point where we no longer care
    * about the error message, the user gets reliable error messages.
    */
   SQLiteMutex &mDBMutex;
   /**
    * The instant at which the request was started.
    *
    * Used by telemetry.
    */
   TimeStamp mRequestStartDate;
 };
 } // namespace storage
 } // namespace mozilla
 #endif // mozStorageAsyncStatementExecution_h

The Tor Browser / annotate

storage/src/mozStorageAsyncStatementExecution.h@129ffea94266 (annotated)

storage/src/mozStorageAsyncStatementExecution.h