Changeset 60508 in webkit


Ignore:
Timestamp:
Jun 1, 2010 2:39:11 PM (14 years ago)
Author:
dumi@chromium.org
Message:

Clean up the DB classes in preparation for a bigger refactoring.
​https://bugs.webkit.org/show_bug.cgi?id=39041

Reviewed by Adam Barth.

  • storage/ChangeVersionWrapper.cpp:
  • storage/ChangeVersionWrapper.h:
  • storage/Database.cpp:

(WebCore::Database::Database):
(WebCore::Database::lastActionChangedDatabase):
(WebCore::Database::lastActionWasInsert):
(WebCore::Database::inProgressTransactionCompleted):
(WebCore::Database::securityOrigin):

  • storage/Database.h:

(WebCore::Database::sqliteDatabase):
(WebCore::Database::databaseDebugName):

  • storage/DatabaseTask.cpp:

(WebCore::DatabaseTransactionTask::doPerformTask):

  • storage/DatabaseTask.h:
  • storage/SQLStatement.cpp:

(WebCore::SQLStatement::execute):

  • storage/SQLStatement.h:
  • storage/SQLTransaction.cpp:

(WebCore::SQLTransaction::SQLTransaction):
(WebCore::SQLTransaction::openTransactionAndPreflight):
(WebCore::SQLTransaction::runStatements):
(WebCore::SQLTransaction::runCurrentStatement):
(WebCore::SQLTransaction::postflightAndCommit):
(WebCore::SQLTransaction::cleanupAfterSuccessCallback):
(WebCore::SQLTransaction::cleanupAfterTransactionErrorCallback):

  • storage/SQLTransaction.h:
Location:
trunk/WebCore
Files:
11 edited

Legend:

Unmodified
Added
Removed

  • trunk/WebCore/ChangeLog

    r60503 r60508  
     12010-06-01  Dumitru Daniliuc  <dumi@chromium.org>
     2
     3        Reviewed by Adam Barth.
     4
     5        Clean up the DB classes in preparation for a bigger refactoring.
     6        https://bugs.webkit.org/show_bug.cgi?id=39041
     7
     8        * storage/ChangeVersionWrapper.cpp:
     9        * storage/ChangeVersionWrapper.h:
     10        * storage/Database.cpp:
     11        (WebCore::Database::Database):
     12        (WebCore::Database::lastActionChangedDatabase):
     13        (WebCore::Database::lastActionWasInsert):
     14        (WebCore::Database::inProgressTransactionCompleted):
     15        (WebCore::Database::securityOrigin):
     16        * storage/Database.h:
     17        (WebCore::Database::sqliteDatabase):
     18        (WebCore::Database::databaseDebugName):
     19        * storage/DatabaseTask.cpp:
     20        (WebCore::DatabaseTransactionTask::doPerformTask):
     21        * storage/DatabaseTask.h:
     22        * storage/SQLStatement.cpp:
     23        (WebCore::SQLStatement::execute):
     24        * storage/SQLStatement.h:
     25        * storage/SQLTransaction.cpp:
     26        (WebCore::SQLTransaction::SQLTransaction):
     27        (WebCore::SQLTransaction::openTransactionAndPreflight):
     28        (WebCore::SQLTransaction::runStatements):
     29        (WebCore::SQLTransaction::runCurrentStatement):
     30        (WebCore::SQLTransaction::postflightAndCommit):
     31        (WebCore::SQLTransaction::cleanupAfterSuccessCallback):
     32        (WebCore::SQLTransaction::cleanupAfterTransactionErrorCallback):
     33        * storage/SQLTransaction.h:
     34
    1352010-06-01  Rob Buis  <rwlbuis@gmail.com>
    236

  • trunk/WebCore/storage/ChangeVersionWrapper.cpp

    r49160 r60508  
    3131#if ENABLE(DATABASE)
    3232#include "Database.h"
     33#include "SQLError.h"
     34#include <wtf/PassRefPtr.h>
     35#include <wtf/RefPtr.h>
    3336
    3437namespace WebCore {

  • trunk/WebCore/storage/ChangeVersionWrapper.h

    r43283 r60508  
    3333#include "PlatformString.h"
    3434#include "SQLTransaction.h"
     35#include <wtf/Forward.h>
    3536
    3637namespace WebCore {
     38
     39class SQLError;
    3740
    3841class ChangeVersionWrapper : public SQLTransactionWrapper {

  • trunk/WebCore/storage/Database.cpp

    r58366 r60508  
    3030#include "Database.h"
    3131
    32 #include <wtf/StdLibExtras.h>
    33 
    3432#if ENABLE(DATABASE)
    3533#include "ChangeVersionWrapper.h"
    … …  
    4139#include "Document.h"
    4240#include "ExceptionCode.h"
    43 #include "Frame.h"
    4441#include "InspectorController.h"
    4542#include "Logging.h"
    4643#include "NotImplemented.h"
    4744#include "Page.h"
    48 #include "OriginQuotaManager.h"
    49 #include "ScriptController.h"
    50 #include "SQLiteDatabase.h"
    51 #include "SQLiteFileSystem.h"
    52 #include "SQLiteStatement.h"
    53 #include "SQLResultSet.h"
     45#include "SQLTransactionCallback.h"
    5446#include "SQLTransactionClient.h"
    5547#include "SQLTransactionCoordinator.h"
    56 
    57 #endif // ENABLE(DATABASE)
     48#include "SQLTransactionErrorCallback.h"
     49#include "SQLiteStatement.h"
     50#include "ScriptController.h"
     51#include "ScriptExecutionContext.h"
     52#include "SecurityOrigin.h"
     53#include "StringHash.h"
     54#include "VoidCallback.h"
     55#include <wtf/OwnPtr.h>
     56#include <wtf/PassOwnPtr.h>
     57#include <wtf/PassRefPtr.h>
     58#include <wtf/RefPtr.h>
     59#include <wtf/StdLibExtras.h>
    5860
    5961#if USE(JSC)
    … …  
    7173    return name;
    7274}
    73 
    74 #if ENABLE(DATABASE)
    7575
    7676static bool isDatabaseAvailable = true;
    … …  
    214214{
    215215    ASSERT(m_scriptExecutionContext.get());
    216     m_mainThreadSecurityOrigin = m_scriptExecutionContext->securityOrigin();
    217     m_databaseThreadSecurityOrigin = m_mainThreadSecurityOrigin->threadsafeCopy();
     216    m_contextThreadSecurityOrigin = m_scriptExecutionContext->securityOrigin();
     217    m_databaseThreadSecurityOrigin = m_contextThreadSecurityOrigin->threadsafeCopy();
    218218    if (m_name.isNull())
    219219        m_name = "";
    … …  
    490490    ASSERT(m_databaseAuthorizer);
    491491    m_databaseAuthorizer->setReadOnly();
     492}
     493
     494bool Database::lastActionChangedDatabase()
     495{
     496    ASSERT(m_databaseAuthorizer);
     497    return m_databaseAuthorizer->lastActionChangedDatabase();
     498}
     499
     500bool Database::lastActionWasInsert()
     501{
     502    ASSERT(m_databaseAuthorizer);
     503    return m_databaseAuthorizer->lastActionWasInsert();
    492504}
    493505
    … …  
    644656}
    645657
     658void Database::inProgressTransactionCompleted()
     659{
     660    MutexLocker locker(m_transactionInProgressMutex);
     661    m_transactionInProgress = false;
     662    scheduleTransaction();
     663}
     664
    646665void Database::scheduleTransaction()
    647666{
    … …  
    781800SecurityOrigin* Database::securityOrigin() const
    782801{
    783     if (scriptExecutionContext()->isContextThread())
    784         return m_mainThreadSecurityOrigin.get();
     802    if (m_scriptExecutionContext->isContextThread())
     803        return m_contextThreadSecurityOrigin.get();
    785804    if (currentThread() == m_scriptExecutionContext->databaseThread()->getThreadID())
    786805        return m_databaseThreadSecurityOrigin.get();
    … …  
    819838}
    820839
     840} // namespace WebCore
     841
    821842#endif // ENABLE(DATABASE)
    822 
    823 } // namespace WebCore

  • trunk/WebCore/storage/Database.h

    r58437 r60508  
    3232#if ENABLE(DATABASE)
    3333#include "PlatformString.h"
     34#include "SQLiteDatabase.h"
     35#ifndef NDEBUG
    3436#include "SecurityOrigin.h"
    35 #include "SQLiteDatabase.h"
    36 #include "SQLTransaction.h"
    37 #include "StringHash.h"
    38 #include "Timer.h"
    39 #include "VoidCallback.h"
    40 
    41 #include <wtf/Forward.h>
    42 #include <wtf/HashSet.h>
    43 #include <wtf/PassRefPtr.h>
    44 #include <wtf/RefPtr.h>
    45 #include <wtf/Deque.h>
    46 #else
    47 #include "PlatformString.h"
    4837#endif
    4938
    50 #if ENABLE(DATABASE)
     39#include <wtf/Deque.h>
     40#include <wtf/Forward.h>
     41
    5142namespace WebCore {
    5243
    … …  
    5546class DatabaseThread;
    5647class ScriptExecutionContext;
    57 class SQLResultSet;
     48class SecurityOrigin;
     49class SQLTransaction;
    5850class SQLTransactionCallback;
    5951class SQLTransactionClient;
    6052class SQLTransactionCoordinator;
    6153class SQLTransactionErrorCallback;
    62 class SQLValue;
     54class VoidCallback;
    6355
    6456typedef int ExceptionCode;
    6557
    6658class Database : public ThreadSafeShared<Database> {
    67     friend class DatabaseTransactionTask;
    68     friend class SQLStatement;
    69     friend class SQLTransaction;
    7059public:
    7160    static void setIsAvailable(bool);
    … …  
    7564
    7665    // Direct support for the DOM API
    77     static PassRefPtr<Database> openDatabase(ScriptExecutionContext* context, const String& name,
    78                                              const String& expectedVersion, const String& displayName,
    79                                              unsigned long estimatedSize, PassRefPtr<DatabaseCallback> creationCallback,
    80                                              ExceptionCode&);
     66    static PassRefPtr<Database> openDatabase(ScriptExecutionContext*, const String& name, const String& expectedVersion, const String& displayName,
     67                                             unsigned long estimatedSize, PassRefPtr<DatabaseCallback>, ExceptionCode&);
    8168    String version() const;
    82     void changeVersion(const String& oldVersion, const String& newVersion,
    83                        PassRefPtr<SQLTransactionCallback> callback, PassRefPtr<SQLTransactionErrorCallback> errorCallback,
    84                        PassRefPtr<VoidCallback> successCallback);
    85     void transaction(PassRefPtr<SQLTransactionCallback> callback, PassRefPtr<SQLTransactionErrorCallback> errorCallback,
     69    void changeVersion(const String& oldVersion, const String& newVersion, PassRefPtr<SQLTransactionCallback>,
     70                       PassRefPtr<SQLTransactionErrorCallback>, PassRefPtr<VoidCallback> successCallback);
     71    void transaction(PassRefPtr<SQLTransactionCallback>, PassRefPtr<SQLTransactionErrorCallback>,
    8672                     PassRefPtr<VoidCallback> successCallback, bool readOnly);
    8773
    … …  
    9278    void enableAuthorizer();
    9379    void setAuthorizerReadOnly();
     80    bool lastActionChangedDatabase();
     81    bool lastActionWasInsert();
    9482
    9583    Vector<String> tableNames();
    … …  
    9785    ScriptExecutionContext* scriptExecutionContext() const { return m_scriptExecutionContext.get(); }
    9886    SecurityOrigin* securityOrigin() const;
     87    SQLiteDatabase& sqliteDatabase() { return m_sqliteDatabase; }
    9988    String stringIdentifier() const;
    10089    String displayName() const;
    … …  
    128117    bool performOpenAndVerify(ExceptionCode&);
    129118
     119    void inProgressTransactionCompleted();
     120    void scheduleTransactionCallback(SQLTransaction*);
     121    void scheduleTransactionStep(SQLTransaction*, bool immediately = false);
     122
    130123    Vector<String> performGetTableNames();
    131124    void performCreationCallback();
    … …  
    137130
    138131private:
    139     Database(ScriptExecutionContext* context, const String& name,
    140              const String& expectedVersion, const String& displayName,
    141              unsigned long estimatedSize, PassRefPtr<DatabaseCallback> creationCallback);
     132    Database(ScriptExecutionContext*, const String& name, const String& expectedVersion,
     133             const String& displayName, unsigned long estimatedSize, PassRefPtr<DatabaseCallback>);
    142134
    143135    bool openAndVerifyVersion(ExceptionCode&);
    144136
    145137    void scheduleTransaction();
    146     void scheduleTransactionCallback(SQLTransaction*);
    147     void scheduleTransactionStep(SQLTransaction* transaction, bool immediately = false);
    148138
    149139    Deque<RefPtr<SQLTransaction> > m_transactionQueue;
    … …  
    155145
    156146    RefPtr<ScriptExecutionContext> m_scriptExecutionContext;
    157     RefPtr<SecurityOrigin> m_mainThreadSecurityOrigin;
     147    RefPtr<SecurityOrigin> m_contextThreadSecurityOrigin;
    158148    RefPtr<SecurityOrigin> m_databaseThreadSecurityOrigin;
    159149    String m_name;
    … …  
    178168
    179169#ifndef NDEBUG
    180     String databaseDebugName() const { return m_mainThreadSecurityOrigin->toString() + "::" + m_name; }
     170    String databaseDebugName() const { return m_contextThreadSecurityOrigin->toString() + "::" + m_name; }
    181171#endif
    182172};
    … …  
    184174} // namespace WebCore
    185175
    186 #else
    187 
    188 namespace WebCore {
    189 class Database : public ThreadSafeShared<Database> {
    190 public:
    191     static const String& databaseInfoTableName();
    192 };
    193 } // namespace WebCore
    194 
    195176#endif // ENABLE(DATABASE)
    196177

  • trunk/WebCore/storage/DatabaseTask.cpp

    r57034 r60508  
    144144void DatabaseTransactionTask::doPerformTask()
    145145{
    146     if (m_transaction->performNextStep()) {
    147         // The transaction is complete, we can move on to the next one.
    148         MutexLocker locker(m_transaction->database()->m_transactionInProgressMutex);
    149         m_transaction->database()->scheduleTransaction();
    150     }
     146    if (m_transaction->performNextStep())
     147        m_transaction->database()->inProgressTransactionCompleted();
    151148}
    152149

  • trunk/WebCore/storage/DatabaseTask.h

    r57034 r60508  
    3333#include "ExceptionCode.h"
    3434#include "PlatformString.h"
     35#include "SQLTransaction.h"
    3536#include <wtf/OwnPtr.h>
    3637#include <wtf/PassOwnPtr.h>
    … …  
    4041
    4142namespace WebCore {
    42 
    43 class DatabaseTask;
    44 class DatabaseThread;
    45 class SQLValue;
    46 class SQLCallback;
    47 class SQLTransaction;
    48 class VersionChangeCallback;
    4943
    5044// Can be used to wait until DatabaseTask is completed.

  • trunk/WebCore/storage/SQLStatement.cpp

    r58801 r60508  
    3232
    3333#include "Database.h"
    34 #include "DatabaseAuthorizer.h"
    3534#include "Logging.h"
    3635#include "SQLError.h"
    3736#include "SQLiteDatabase.h"
    3837#include "SQLiteStatement.h"
    39 #include "SQLResultSet.h"
    4038#include "SQLStatementCallback.h"
    4139#include "SQLStatementErrorCallback.h"
    … …  
    7472        db->setAuthorizerReadOnly();
    7573
    76     SQLiteDatabase* database = &db->m_sqliteDatabase;
     74    SQLiteDatabase* database = &db->sqliteDatabase();
    7775
    7876    SQLiteStatement statement(*database, m_statement);
    … …  
    131129    } else if (result == SQLResultDone) {
    132130        // Didn't find anything, or was an insert
    133         if (db->m_databaseAuthorizer->lastActionWasInsert())
     131        if (db->lastActionWasInsert())
    134132            resultSet->setInsertId(database->lastInsertRowID());
    135133    } else if (result == SQLResultFull) {

  • trunk/WebCore/storage/SQLStatement.h

    r47808 r60508  
    3232
    3333#include "PlatformString.h"
    34 
    35 #include "SQLError.h"
    3634#include "SQLResultSet.h"
    37 #include "SQLStatementCallback.h"
    38 #include "SQLStatementErrorCallback.h"
    3935#include "SQLValue.h"
    40 
    41 #include <wtf/PassRefPtr.h>
    42 #include <wtf/RefPtr.h>
    43 #include <wtf/Threading.h>
     36#include <wtf/Forward.h>
    4437#include <wtf/Vector.h>
    4538
    … …  
    4740
    4841class Database;
     42class SQLError;
     43class SQLStatementCallback;
     44class SQLStatementErrorCallback;
    4945class SQLTransaction;
    50 class String;
    5146
    5247class SQLStatement : public ThreadSafeShared<SQLStatement> {
    … …  
    6762    SQLError* sqlError() const { return m_error.get(); }
    6863private:
    69     SQLStatement(const String& statement, const Vector<SQLValue>& arguments, PassRefPtr<SQLStatementCallback> callback, PassRefPtr<SQLStatementErrorCallback> errorCallback, bool readOnly);
     64    SQLStatement(const String& statement, const Vector<SQLValue>& arguments, PassRefPtr<SQLStatementCallback>, PassRefPtr<SQLStatementErrorCallback>, bool readOnly);
    7065
    7166    void setFailureDueToQuota();

  • trunk/WebCore/storage/SQLTransaction.cpp

    r59267 r60508  
    3232#if ENABLE(DATABASE)
    3333
    34 #include "ChromeClient.h"
    3534#include "Database.h"
    36 #include "DatabaseAuthorizer.h"
    37 #include "DatabaseDetails.h"
    3835#include "DatabaseThread.h"
    3936#include "ExceptionCode.h"
    4037#include "Logging.h"
    41 #include "Page.h"
    4238#include "PlatformString.h"
    4339#include "ScriptExecutionContext.h"
    44 #include "Settings.h"
    4540#include "SQLError.h"
    4641#include "SQLiteTransaction.h"
    47 #include "SQLResultSet.h"
    4842#include "SQLStatement.h"
    4943#include "SQLStatementCallback.h"
    5044#include "SQLStatementErrorCallback.h"
     45#include "SQLTransactionCallback.h"
    5146#include "SQLTransactionClient.h"
    5247#include "SQLTransactionCoordinator.h"
     48#include "SQLTransactionErrorCallback.h"
    5349#include "SQLValue.h"
     50#include "VoidCallback.h"
     51#include <wtf/OwnPtr.h>
     52#include <wtf/PassRefPtr.h>
     53#include <wtf/RefPtr.h>
    5454
    5555// There's no way of knowing exactly how much more space will be required when a statement hits the quota limit.
    … …  
    6666}
    6767
    68 SQLTransaction::SQLTransaction(Database* db, PassRefPtr<SQLTransactionCallback> callback, PassRefPtr<SQLTransactionErrorCallback> errorCallback, PassRefPtr<VoidCallback> successCallback,
    69                                PassRefPtr<SQLTransactionWrapper> wrapper, bool readOnly)
     68SQLTransaction::SQLTransaction(Database* db, PassRefPtr<SQLTransactionCallback> callback, PassRefPtr<SQLTransactionErrorCallback> errorCallback,
     69                               PassRefPtr<VoidCallback> successCallback, PassRefPtr<SQLTransactionWrapper> wrapper, bool readOnly)
    7070    : m_nextStep(&SQLTransaction::acquireLock)
    7171    , m_executeSqlAllowed(false)
    … …  
    235235void SQLTransaction::openTransactionAndPreflight()
    236236{
    237     ASSERT(!m_database->m_sqliteDatabase.transactionInProgress());
     237    ASSERT(!m_database->sqliteDatabase().transactionInProgress());
    238238    ASSERT(m_lockAcquired);
    239239
    … …  
    249249    // Set the maximum usage for this transaction if this transactions is not read-only
    250250    if (!m_readOnly)
    251         m_database->m_sqliteDatabase.setMaximumSize(m_database->maximumSize());
     251        m_database->sqliteDatabase().setMaximumSize(m_database->maximumSize());
    252252
    253253    ASSERT(!m_sqliteTransaction);
    254     m_sqliteTransaction.set(new SQLiteTransaction(m_database->m_sqliteDatabase, m_readOnly));
    255 
    256     m_database->m_databaseAuthorizer->disable();
     254    m_sqliteTransaction.set(new SQLiteTransaction(m_database->sqliteDatabase(), m_readOnly));
     255
     256    m_database->disableAuthorizer();
    257257    m_sqliteTransaction->begin();
    258     m_database->m_databaseAuthorizer->enable();
     258    m_database->enableAuthorizer();
    259259
    260260    // Transaction Steps 1+2 - Open a transaction to the database, jumping to the error callback if that fails
    261261    if (!m_sqliteTransaction->inProgress()) {
    262         ASSERT(!m_database->m_sqliteDatabase.transactionInProgress());
     262        ASSERT(!m_database->sqliteDatabase().transactionInProgress());
    263263        m_sqliteTransaction.clear();
    264264        m_transactionError = SQLError::create(0, "unable to open a transaction to the database");
    … …  
    269269    // Transaction Steps 3 - Peform preflight steps, jumping to the error callback if they fail
    270270    if (m_wrapper && !m_wrapper->performPreflight(this)) {
    271         ASSERT(!m_database->m_sqliteDatabase.transactionInProgress());
     271        ASSERT(!m_database->sqliteDatabase().transactionInProgress());
    272272        m_sqliteTransaction.clear();
    273273        m_transactionError = m_wrapper->sqlError();
    … …  
    327327            // the quota, which can happen only in a read-write transaction. Therefore, there
    328328            // is no need to check here if the transaction is read-write.
    329             m_database->m_sqliteDatabase.setMaximumSize(m_database->maximumSize());
     329            m_database->sqliteDatabase().setMaximumSize(m_database->maximumSize());
    330330        } else {
    331331            // If the current statement has already been run, failed due to quota constraints, and we're not retrying it,
    … …  
    364364        return false;
    365365
    366     m_database->m_databaseAuthorizer->reset();
     366    m_database->resetAuthorizer();
    367367
    368368    if (m_currentStatement->execute(m_database.get())) {
    369         if (m_database->m_databaseAuthorizer->lastActionChangedDatabase()) {
     369        if (m_database->lastActionChangedDatabase()) {
    370370            // Flag this transaction as having changed the database for later delegate notification
    371371            m_modifiedDatabase = true;
    … …  
    456456    ASSERT(m_sqliteTransaction);
    457457
    458     m_database->m_databaseAuthorizer->disable();
     458    m_database->disableAuthorizer();
    459459    m_sqliteTransaction->commit();
    460     m_database->m_databaseAuthorizer->enable();
     460    m_database->enableAuthorizer();
    461461
    462462    // If the commit failed, the transaction will still be marked as "in progress"
    … …  
    510510    // There is no next step
    511511    LOG(StorageAPI, "Transaction %p is complete\n", this);
    512     ASSERT(!m_database->m_sqliteDatabase.transactionInProgress());
     512    ASSERT(!m_database->sqliteDatabase().transactionInProgress());
    513513    m_sqliteTransaction.clear();
    514514    m_nextStep = 0;
    … …  
    560560    ASSERT(m_lockAcquired);
    561561
    562     m_database->m_databaseAuthorizer->disable();
     562    m_database->disableAuthorizer();
    563563    if (m_sqliteTransaction) {
    564564        // Transaction Step 12 - Rollback the transaction.
    565565        m_sqliteTransaction->rollback();
    566566
    567         ASSERT(!m_database->m_sqliteDatabase.transactionInProgress());
     567        ASSERT(!m_database->sqliteDatabase().transactionInProgress());
    568568        m_sqliteTransaction.clear();
    569569    }
    570     m_database->m_databaseAuthorizer->enable();
     570    m_database->enableAuthorizer();
    571571
    572572    // Transaction Step 12 - Any still-pending statements in the transaction are discarded.
    … …  
    578578    // Transaction is complete!  There is no next step
    579579    LOG(StorageAPI, "Transaction %p is complete with an error\n", this);
    580     ASSERT(!m_database->m_sqliteDatabase.transactionInProgress());
     580    ASSERT(!m_database->sqliteDatabase().transactionInProgress());
    581581    m_nextStep = 0;
    582582

  • trunk/WebCore/storage/SQLTransaction.h

    r54162 r60508  
    3333#include <wtf/Threading.h>
    3434
    35 #include "SQLiteTransaction.h"
    3635#include "SQLStatement.h"
    37 #include "SQLTransactionCallback.h"
    38 #include "SQLTransactionErrorCallback.h"
    3936#include <wtf/Deque.h>
    4037#include <wtf/Forward.h>
    41 #include <wtf/OwnPtr.h>
    42 #include <wtf/RefPtr.h>
    4338#include <wtf/Vector.h>
    4439
    … …  
    4944class Database;
    5045class SQLError;
     46class SQLiteTransaction;
    5147class SQLStatementCallback;
    5248class SQLStatementErrorCallback;
    5349class SQLTransaction;
     50class SQLTransactionCallback;
     51class SQLTransactionErrorCallback;
    5452class SQLValue;
    5553class String;
    … …  
    7371
    7472    void executeSQL(const String& sqlStatement, const Vector<SQLValue>& arguments,
    75                     PassRefPtr<SQLStatementCallback> callback, PassRefPtr<SQLStatementErrorCallback> callbackError, ExceptionCode& e);
     73                    PassRefPtr<SQLStatementCallback>, PassRefPtr<SQLStatementErrorCallback>, ExceptionCode&);
    7674
    7775    void lockAcquired();
Note: See TracChangeset for help on using the changeset viewer.