Changeset 143551 in webkit


Ignore:
Timestamp:
Feb 20, 2013 6:36:26 PM (11 years ago)
Author:
mark.lam@apple.com
Message:

\2013-02-20 Mark Lam <mark.lam@apple.com>

Rename DatabaseBackendAsync to DatabaseBackend.
https://bugs.webkit.org/show_bug.cgi?id=110422.

Reviewed by Geoffrey Garen.

This is a purely cosmetic change to make the naming consistent with
the front-end Database.

No new tests.

  • CMakeLists.txt:
  • GNUmakefile.list.am:
  • Modules/webdatabase/ChangeVersionWrapper.cpp:

(WebCore::ChangeVersionWrapper::performPreflight):
(WebCore::ChangeVersionWrapper::performPostflight):

  • Modules/webdatabase/Database.cpp:

(WebCore::Database::Database):
(WebCore::Database::from):
(WebCore::Database::backend):

  • Modules/webdatabase/Database.h:
  • Modules/webdatabase/DatabaseBackend.cpp: Copied from Source/WebCore/Modules/webdatabase/DatabaseBackendAsync.cpp.

(WebCore::DatabaseBackend::DatabaseBackend):
(WebCore::DatabaseBackend::openAndVerifyVersion):
(WebCore::DatabaseBackend::performOpenAndVerify):
(WebCore::DatabaseBackend::close):
(WebCore::DatabaseBackend::runTransaction):
(WebCore::DatabaseBackend::inProgressTransactionCompleted):
(WebCore::DatabaseBackend::scheduleTransaction):
(WebCore::DatabaseBackend::scheduleTransactionStep):
(WebCore::DatabaseBackend::transactionClient):
(WebCore::DatabaseBackend::transactionCoordinator):

  • Modules/webdatabase/DatabaseBackend.h: Copied from Source/WebCore/Modules/webdatabase/DatabaseBackendAsync.h.
  • Modules/webdatabase/DatabaseBackendAsync.cpp: Removed.
  • Modules/webdatabase/DatabaseBackendAsync.h: Removed.
  • Modules/webdatabase/DatabaseBackendBase.cpp:

(WebCore::DatabaseBackendBase::~DatabaseBackendBase):

  • Modules/webdatabase/DatabaseManager.cpp:
  • Modules/webdatabase/DatabaseServer.cpp:
  • Modules/webdatabase/DatabaseTask.cpp:

(WebCore::DatabaseTask::DatabaseTask):
(WebCore::DatabaseBackend::DatabaseOpenTask::DatabaseOpenTask):
(WebCore::DatabaseBackend::DatabaseOpenTask::doPerformTask):
(WebCore::DatabaseBackend::DatabaseOpenTask::debugTaskName):
(WebCore::DatabaseBackend::DatabaseCloseTask::DatabaseCloseTask):
(WebCore::DatabaseBackend::DatabaseCloseTask::doPerformTask):
(WebCore::DatabaseBackend::DatabaseCloseTask::debugTaskName):
(WebCore::DatabaseBackend::DatabaseTransactionTask::DatabaseTransactionTask):
(WebCore::DatabaseBackend::DatabaseTransactionTask::~DatabaseTransactionTask):
(WebCore::DatabaseBackend::DatabaseTransactionTask::doPerformTask):
(WebCore::DatabaseBackend::DatabaseTransactionTask::debugTaskName):
(WebCore::DatabaseBackend::DatabaseTableNamesTask::DatabaseTableNamesTask):
(WebCore::DatabaseBackend::DatabaseTableNamesTask::doPerformTask):
(WebCore::DatabaseBackend::DatabaseTableNamesTask::debugTaskName):

  • Modules/webdatabase/DatabaseTask.h:

(WebCore::DatabaseTask::database):
(DatabaseTask):
(WebCore::DatabaseBackend::DatabaseOpenTask::create):
(DatabaseBackend::DatabaseOpenTask):
(WebCore::DatabaseBackend::DatabaseCloseTask::create):
(DatabaseBackend::DatabaseCloseTask):
(WebCore::DatabaseBackend::DatabaseTableNamesTask::create):
(DatabaseBackend::DatabaseTableNamesTask):

  • Modules/webdatabase/DatabaseThread.cpp:

(WebCore::DatabaseThread::recordDatabaseOpen):
(WebCore::DatabaseThread::recordDatabaseClosed):
(WebCore::SameDatabasePredicate::SameDatabasePredicate):
(SameDatabasePredicate):
(WebCore::DatabaseThread::unscheduleDatabaseTasks):

  • Modules/webdatabase/DatabaseThread.h:
  • Modules/webdatabase/SQLStatementBackend.cpp:

(WebCore::SQLStatementBackend::execute):
(WebCore::SQLStatementBackend::setDatabaseDeletedError):
(WebCore::SQLStatementBackend::setVersionMismatchedError):
(WebCore::SQLStatementBackend::setFailureDueToQuota):

  • Modules/webdatabase/SQLStatementBackend.h:
  • Modules/webdatabase/SQLTransactionBackend.cpp:

(WebCore::SQLTransactionBackend::create):
(WebCore::SQLTransactionBackend::SQLTransactionBackend):

  • Modules/webdatabase/SQLTransactionBackend.h:

(WebCore::SQLTransactionBackend::database):

  • Modules/webdatabase/SQLTransactionCoordinator.cpp:

(WebCore::getDatabaseIdentifier):

  • Target.pri:
  • WebCore.gypi:
  • WebCore.vcproj/WebCore.vcproj:
  • WebCore.vcxproj/WebCore.vcxproj:
  • WebCore.vcxproj/WebCore.vcxproj.filters:
  • WebCore.xcodeproj/project.pbxproj:
Location:
trunk/Source/WebCore
Files:
24 edited
2 moved

Legend:

Unmodified
Added
Removed
  • trunk/Source/WebCore/CMakeLists.txt

    r143471 r143551  
    940940    Modules/webdatabase/Database.cpp
    941941    Modules/webdatabase/DatabaseAuthorizer.cpp
    942     Modules/webdatabase/DatabaseBackendAsync.cpp
     942    Modules/webdatabase/DatabaseBackend.cpp
    943943    Modules/webdatabase/DatabaseBackendBase.cpp
    944944    Modules/webdatabase/DatabaseBackendContext.cpp
  • trunk/Source/WebCore/ChangeLog

    r143550 r143551  
     1\2013-02-20  Mark Lam  <mark.lam@apple.com>
     2
     3        Rename DatabaseBackendAsync to DatabaseBackend.
     4        https://bugs.webkit.org/show_bug.cgi?id=110422.
     5
     6        Reviewed by Geoffrey Garen.
     7
     8        This is a purely cosmetic change to make the naming consistent with
     9        the front-end Database.
     10
     11        No new tests.
     12
     13        * CMakeLists.txt:
     14        * GNUmakefile.list.am:
     15        * Modules/webdatabase/ChangeVersionWrapper.cpp:
     16        (WebCore::ChangeVersionWrapper::performPreflight):
     17        (WebCore::ChangeVersionWrapper::performPostflight):
     18        * Modules/webdatabase/Database.cpp:
     19        (WebCore::Database::Database):
     20        (WebCore::Database::from):
     21        (WebCore::Database::backend):
     22        * Modules/webdatabase/Database.h:
     23        * Modules/webdatabase/DatabaseBackend.cpp: Copied from Source/WebCore/Modules/webdatabase/DatabaseBackendAsync.cpp.
     24        (WebCore::DatabaseBackend::DatabaseBackend):
     25        (WebCore::DatabaseBackend::openAndVerifyVersion):
     26        (WebCore::DatabaseBackend::performOpenAndVerify):
     27        (WebCore::DatabaseBackend::close):
     28        (WebCore::DatabaseBackend::runTransaction):
     29        (WebCore::DatabaseBackend::inProgressTransactionCompleted):
     30        (WebCore::DatabaseBackend::scheduleTransaction):
     31        (WebCore::DatabaseBackend::scheduleTransactionStep):
     32        (WebCore::DatabaseBackend::transactionClient):
     33        (WebCore::DatabaseBackend::transactionCoordinator):
     34        * Modules/webdatabase/DatabaseBackend.h: Copied from Source/WebCore/Modules/webdatabase/DatabaseBackendAsync.h.
     35        * Modules/webdatabase/DatabaseBackendAsync.cpp: Removed.
     36        * Modules/webdatabase/DatabaseBackendAsync.h: Removed.
     37        * Modules/webdatabase/DatabaseBackendBase.cpp:
     38        (WebCore::DatabaseBackendBase::~DatabaseBackendBase):
     39        * Modules/webdatabase/DatabaseManager.cpp:
     40        * Modules/webdatabase/DatabaseServer.cpp:
     41        * Modules/webdatabase/DatabaseTask.cpp:
     42        (WebCore::DatabaseTask::DatabaseTask):
     43        (WebCore::DatabaseBackend::DatabaseOpenTask::DatabaseOpenTask):
     44        (WebCore::DatabaseBackend::DatabaseOpenTask::doPerformTask):
     45        (WebCore::DatabaseBackend::DatabaseOpenTask::debugTaskName):
     46        (WebCore::DatabaseBackend::DatabaseCloseTask::DatabaseCloseTask):
     47        (WebCore::DatabaseBackend::DatabaseCloseTask::doPerformTask):
     48        (WebCore::DatabaseBackend::DatabaseCloseTask::debugTaskName):
     49        (WebCore::DatabaseBackend::DatabaseTransactionTask::DatabaseTransactionTask):
     50        (WebCore::DatabaseBackend::DatabaseTransactionTask::~DatabaseTransactionTask):
     51        (WebCore::DatabaseBackend::DatabaseTransactionTask::doPerformTask):
     52        (WebCore::DatabaseBackend::DatabaseTransactionTask::debugTaskName):
     53        (WebCore::DatabaseBackend::DatabaseTableNamesTask::DatabaseTableNamesTask):
     54        (WebCore::DatabaseBackend::DatabaseTableNamesTask::doPerformTask):
     55        (WebCore::DatabaseBackend::DatabaseTableNamesTask::debugTaskName):
     56        * Modules/webdatabase/DatabaseTask.h:
     57        (WebCore::DatabaseTask::database):
     58        (DatabaseTask):
     59        (WebCore::DatabaseBackend::DatabaseOpenTask::create):
     60        (DatabaseBackend::DatabaseOpenTask):
     61        (WebCore::DatabaseBackend::DatabaseCloseTask::create):
     62        (DatabaseBackend::DatabaseCloseTask):
     63        (WebCore::DatabaseBackend::DatabaseTableNamesTask::create):
     64        (DatabaseBackend::DatabaseTableNamesTask):
     65        * Modules/webdatabase/DatabaseThread.cpp:
     66        (WebCore::DatabaseThread::recordDatabaseOpen):
     67        (WebCore::DatabaseThread::recordDatabaseClosed):
     68        (WebCore::SameDatabasePredicate::SameDatabasePredicate):
     69        (SameDatabasePredicate):
     70        (WebCore::DatabaseThread::unscheduleDatabaseTasks):
     71        * Modules/webdatabase/DatabaseThread.h:
     72        * Modules/webdatabase/SQLStatementBackend.cpp:
     73        (WebCore::SQLStatementBackend::execute):
     74        (WebCore::SQLStatementBackend::setDatabaseDeletedError):
     75        (WebCore::SQLStatementBackend::setVersionMismatchedError):
     76        (WebCore::SQLStatementBackend::setFailureDueToQuota):
     77        * Modules/webdatabase/SQLStatementBackend.h:
     78        * Modules/webdatabase/SQLTransactionBackend.cpp:
     79        (WebCore::SQLTransactionBackend::create):
     80        (WebCore::SQLTransactionBackend::SQLTransactionBackend):
     81        * Modules/webdatabase/SQLTransactionBackend.h:
     82        (WebCore::SQLTransactionBackend::database):
     83        * Modules/webdatabase/SQLTransactionCoordinator.cpp:
     84        (WebCore::getDatabaseIdentifier):
     85        * Target.pri:
     86        * WebCore.gypi:
     87        * WebCore.vcproj/WebCore.vcproj:
     88        * WebCore.vcxproj/WebCore.vcxproj:
     89        * WebCore.vcxproj/WebCore.vcxproj.filters:
     90        * WebCore.xcodeproj/project.pbxproj:
     91
    1922013-02-20  David Kilzer  <ddkilzer@apple.com>
    293
  • trunk/Source/WebCore/GNUmakefile.list.am

    r143471 r143551  
    21122112        Source/WebCore/Modules/webdatabase/DatabaseAuthorizer.cpp \
    21132113        Source/WebCore/Modules/webdatabase/DatabaseAuthorizer.h \
    2114         Source/WebCore/Modules/webdatabase/DatabaseBackendAsync.cpp \
    2115         Source/WebCore/Modules/webdatabase/DatabaseBackendAsync.h \
     2114        Source/WebCore/Modules/webdatabase/DatabaseBackend.cpp \
     2115        Source/WebCore/Modules/webdatabase/DatabaseBackend.h \
    21162116        Source/WebCore/Modules/webdatabase/DatabaseBackendBase.cpp \
    21172117        Source/WebCore/Modules/webdatabase/DatabaseBackendBase.h \
  • trunk/Source/WebCore/Modules/webdatabase/ChangeVersionWrapper.cpp

    r142921 r143551  
    4848    ASSERT(transaction && transaction->database());
    4949
    50     DatabaseBackendAsync* database = transaction->database();
     50    DatabaseBackend* database = transaction->database();
    5151
    5252    String actualVersion;
     
    7272    ASSERT(transaction && transaction->database());
    7373
    74     DatabaseBackendAsync* database = transaction->database();
     74    DatabaseBackend* database = transaction->database();
    7575
    7676    if (!database->setVersionInDatabase(m_newVersion)) {
  • trunk/Source/WebCore/Modules/webdatabase/Database.cpp

    r143471 r143551  
    7878    const String& name, const String& expectedVersion, const String& displayName, unsigned long estimatedSize)
    7979    : DatabaseBase(databaseContext->scriptExecutionContext())
    80     , DatabaseBackendAsync(databaseContext, name, expectedVersion, displayName, estimatedSize)
    81     , m_databaseContext(DatabaseBackendAsync::databaseContext()->frontend())
     80    , DatabaseBackend(databaseContext, name, expectedVersion, displayName, estimatedSize)
     81    , m_databaseContext(DatabaseBackend::databaseContext()->frontend())
    8282    , m_deleted(false)
    8383{
     
    124124}
    125125
    126 Database* Database::from(DatabaseBackendAsync* backend)
     126Database* Database::from(DatabaseBackend* backend)
    127127{
    128128    return static_cast<Database*>(backend->m_frontend);
    129129}
    130130
    131 PassRefPtr<DatabaseBackendAsync> Database::backend()
     131PassRefPtr<DatabaseBackend> Database::backend()
    132132{
    133133    return this;
  • trunk/Source/WebCore/Modules/webdatabase/Database.h

    r143471 r143551  
    3232#if ENABLE(SQL_DATABASE)
    3333
    34 #include "DatabaseBackendAsync.h"
     34#include "DatabaseBackend.h"
    3535#include "DatabaseBase.h"
    3636#include "DatabaseBasicTypes.h"
     
    5050class VoidCallback;
    5151
    52 class Database : public DatabaseBase, public DatabaseBackendAsync {
     52class Database : public DatabaseBase, public DatabaseBackend {
    5353public:
    5454    virtual ~Database();
     
    6262
    6363    // Internal engine support
    64     static Database* from(DatabaseBackendAsync*);
     64    static Database* from(DatabaseBackend*);
    6565    DatabaseContext* databaseContext() const { return m_databaseContext.get(); }
    6666
     
    8282    Database(PassRefPtr<DatabaseBackendContext>, const String& name,
    8383        const String& expectedVersion, const String& displayName, unsigned long estimatedSize);
    84     PassRefPtr<DatabaseBackendAsync> backend();
     84    PassRefPtr<DatabaseBackend> backend();
    8585    static PassRefPtr<Database> create(ScriptExecutionContext*, PassRefPtr<DatabaseBackendBase>);
    8686
     
    105105    friend class DatabaseManager;
    106106    friend class DatabaseServer; // FIXME: remove this when the backend has been split out.
    107     friend class DatabaseBackendAsync; // FIXME: remove this when the backend has been split out.
     107    friend class DatabaseBackend; // FIXME: remove this when the backend has been split out.
    108108    friend class SQLStatement;
    109109    friend class SQLTransaction;
  • trunk/Source/WebCore/Modules/webdatabase/DatabaseBackend.cpp

    r143471 r143551  
    2525
    2626#include "config.h"
    27 #include "DatabaseBackendAsync.h"
     27#include "DatabaseBackend.h"
    2828
    2929#if ENABLE(SQL_DATABASE)
     
    4343namespace WebCore {
    4444
    45 DatabaseBackendAsync::DatabaseBackendAsync(PassRefPtr<DatabaseBackendContext> databaseContext, const String& name, const String& expectedVersion, const String& displayName, unsigned long estimatedSize)
     45DatabaseBackend::DatabaseBackend(PassRefPtr<DatabaseBackendContext> databaseContext, const String& name, const String& expectedVersion, const String& displayName, unsigned long estimatedSize)
    4646    : DatabaseBackendBase(databaseContext, name, expectedVersion, displayName, estimatedSize, DatabaseType::Async)
    4747    , m_transactionInProgress(false)
     
    5050}
    5151
    52 bool DatabaseBackendAsync::openAndVerifyVersion(bool setVersionInNewDatabase, DatabaseError& error, String& errorMessage)
     52bool DatabaseBackend::openAndVerifyVersion(bool setVersionInNewDatabase, DatabaseError& error, String& errorMessage)
    5353{
    5454    DatabaseTaskSynchronizer synchronizer;
     
    6767}
    6868
    69 bool DatabaseBackendAsync::performOpenAndVerify(bool setVersionInNewDatabase, DatabaseError& error, String& errorMessage)
     69bool DatabaseBackend::performOpenAndVerify(bool setVersionInNewDatabase, DatabaseError& error, String& errorMessage)
    7070{
    7171    if (DatabaseBackendBase::performOpenAndVerify(setVersionInNewDatabase, error, errorMessage)) {
     
    7979}
    8080
    81 void DatabaseBackendAsync::close()
     81void DatabaseBackend::close()
    8282{
    8383    ASSERT(databaseContext()->databaseThread());
     
    108108    // unschedule any DatabaseTasks that refer to it before the database gets
    109109    // deleted.
    110     RefPtr<DatabaseBackendAsync> protect = this;
     110    RefPtr<DatabaseBackend> protect = this;
    111111    databaseContext()->databaseThread()->recordDatabaseClosed(this);
    112112    databaseContext()->databaseThread()->unscheduleDatabaseTasks(this);
    113113}
    114114
    115 PassRefPtr<SQLTransactionBackend> DatabaseBackendAsync::runTransaction(PassRefPtr<SQLTransaction> transaction,
     115PassRefPtr<SQLTransactionBackend> DatabaseBackend::runTransaction(PassRefPtr<SQLTransaction> transaction,
    116116    bool readOnly, const ChangeVersionData* data)
    117117{
     
    132132}
    133133
    134 void DatabaseBackendAsync::inProgressTransactionCompleted()
     134void DatabaseBackend::inProgressTransactionCompleted()
    135135{
    136136    MutexLocker locker(m_transactionInProgressMutex);
     
    139139}
    140140
    141 void DatabaseBackendAsync::scheduleTransaction()
     141void DatabaseBackend::scheduleTransaction()
    142142{
    143143    ASSERT(!m_transactionInProgressMutex.tryLock()); // Locked by caller.
     
    156156}
    157157
    158 void DatabaseBackendAsync::scheduleTransactionStep(SQLTransactionBackend* transaction)
     158void DatabaseBackend::scheduleTransactionStep(SQLTransactionBackend* transaction)
    159159{
    160160    if (!databaseContext()->databaseThread())
     
    166166}
    167167
    168 SQLTransactionClient* DatabaseBackendAsync::transactionClient() const
     168SQLTransactionClient* DatabaseBackend::transactionClient() const
    169169{
    170170    return databaseContext()->databaseThread()->transactionClient();
    171171}
    172172
    173 SQLTransactionCoordinator* DatabaseBackendAsync::transactionCoordinator() const
     173SQLTransactionCoordinator* DatabaseBackend::transactionCoordinator() const
    174174{
    175175    return databaseContext()->databaseThread()->transactionCoordinator();
  • trunk/Source/WebCore/Modules/webdatabase/DatabaseBackend.h

    r143471 r143551  
    2424 */
    2525
    26 #ifndef DatabaseBackendAsync_h
    27 #define DatabaseBackendAsync_h
     26#ifndef DatabaseBackend_h
     27#define DatabaseBackend_h
    2828
    2929#if ENABLE(SQL_DATABASE)
     
    4343class SQLTransactionCoordinator;
    4444
    45 // FIXME: This implementation of DatabaseBackendAsync is only a place holder
     45// FIXME: This implementation of DatabaseBackend is only a place holder
    4646// for the split out of the Database backend to be done later. This
    4747// place holder is needed to allow other code that need to reference the
    48 // DatabaseBackendAsync to do so before the proper backend split is
     48// DatabaseBackend to do so before the proper backend split is
    4949// available. This should be replaced with the actual implementation later.
    5050
    51 class DatabaseBackendAsync : public DatabaseBackendBase {
     51class DatabaseBackend : public DatabaseBackendBase {
    5252public:
    53     DatabaseBackendAsync(PassRefPtr<DatabaseBackendContext>, const String& name, const String& expectedVersion, const String& displayName, unsigned long estimatedSize);
     53    DatabaseBackend(PassRefPtr<DatabaseBackendContext>, const String& name, const String& expectedVersion, const String& displayName, unsigned long estimatedSize);
    5454
    5555    virtual bool openAndVerifyVersion(bool setVersionInNewDatabase, DatabaseError&, String& errorMessage);
     
    8585#endif // ENABLE(SQL_DATABASE)
    8686
    87 #endif // DatabaseBackendAsync_h
     87#endif // DatabaseBackend_h
  • trunk/Source/WebCore/Modules/webdatabase/DatabaseBackendBase.cpp

    r143471 r143551  
    245245    // on a single thread at a time.
    246246    //
    247     // For DatabaseBackendAsync, we open the SQLite database on the DatabaseThread,
     247    // For DatabaseBackend, we open the SQLite database on the DatabaseThread,
    248248    // and hence we should also close it on that same thread. This means that the
    249249    // SQLite database need to be closed by another mechanism (see
  • trunk/Source/WebCore/Modules/webdatabase/DatabaseManager.cpp

    r143471 r143551  
    3131#include "AbstractDatabaseServer.h"
    3232#include "Database.h"
    33 #include "DatabaseBackendAsync.h"
     33#include "DatabaseBackend.h"
    3434#include "DatabaseBackendBase.h"
    3535#include "DatabaseBackendContext.h"
  • trunk/Source/WebCore/Modules/webdatabase/DatabaseServer.cpp

    r143471 r143551  
    3030
    3131#include "Database.h"
    32 #include "DatabaseBackendAsync.h"
     32#include "DatabaseBackend.h"
    3333#include "DatabaseBackendContext.h"
    3434#include "DatabaseBackendSync.h"
  • trunk/Source/WebCore/Modules/webdatabase/DatabaseTask.cpp

    r143271 r143551  
    3232
    3333#include "Database.h"
    34 #include "DatabaseBackendAsync.h"
     34#include "DatabaseBackend.h"
    3535#include "Logging.h"
    3636
     
    6161}
    6262
    63 DatabaseTask::DatabaseTask(DatabaseBackendAsync* database, DatabaseTaskSynchronizer* synchronizer)
     63DatabaseTask::DatabaseTask(DatabaseBackend* database, DatabaseTaskSynchronizer* synchronizer)
    6464    : m_database(database)
    6565    , m_synchronizer(synchronizer)
     
    100100// Opens the database file and verifies the version matches the expected version.
    101101
    102 DatabaseBackendAsync::DatabaseOpenTask::DatabaseOpenTask(DatabaseBackendAsync* database, bool setVersionInNewDatabase, DatabaseTaskSynchronizer* synchronizer, DatabaseError& error, String& errorMessage, bool& success)
     102DatabaseBackend::DatabaseOpenTask::DatabaseOpenTask(DatabaseBackend* database, bool setVersionInNewDatabase, DatabaseTaskSynchronizer* synchronizer, DatabaseError& error, String& errorMessage, bool& success)
    103103    : DatabaseTask(database, synchronizer)
    104104    , m_setVersionInNewDatabase(setVersionInNewDatabase)
     
    110110}
    111111
    112 void DatabaseBackendAsync::DatabaseOpenTask::doPerformTask()
     112void DatabaseBackend::DatabaseOpenTask::doPerformTask()
    113113{
    114114    String errorMessage;
     
    119119
    120120#if !LOG_DISABLED
    121 const char* DatabaseBackendAsync::DatabaseOpenTask::debugTaskName() const
     121const char* DatabaseBackend::DatabaseOpenTask::debugTaskName() const
    122122{
    123123    return "DatabaseOpenTask";
     
    128128// Closes the database.
    129129
    130 DatabaseBackendAsync::DatabaseCloseTask::DatabaseCloseTask(DatabaseBackendAsync* database, DatabaseTaskSynchronizer* synchronizer)
     130DatabaseBackend::DatabaseCloseTask::DatabaseCloseTask(DatabaseBackend* database, DatabaseTaskSynchronizer* synchronizer)
    131131    : DatabaseTask(database, synchronizer)
    132132{
    133133}
    134134
    135 void DatabaseBackendAsync::DatabaseCloseTask::doPerformTask()
     135void DatabaseBackend::DatabaseCloseTask::doPerformTask()
    136136{
    137137    Database::from(database())->close();
     
    139139
    140140#if !LOG_DISABLED
    141 const char* DatabaseBackendAsync::DatabaseCloseTask::debugTaskName() const
     141const char* DatabaseBackend::DatabaseCloseTask::debugTaskName() const
    142142{
    143143    return "DatabaseCloseTask";
     
    148148// Starts a transaction that will report its results via a callback.
    149149
    150 DatabaseBackendAsync::DatabaseTransactionTask::DatabaseTransactionTask(PassRefPtr<SQLTransactionBackend> transaction)
     150DatabaseBackend::DatabaseTransactionTask::DatabaseTransactionTask(PassRefPtr<SQLTransactionBackend> transaction)
    151151    : DatabaseTask(Database::from(transaction->database()), 0)
    152152    , m_transaction(transaction)
     
    155155}
    156156
    157 DatabaseBackendAsync::DatabaseTransactionTask::~DatabaseTransactionTask()
     157DatabaseBackend::DatabaseTransactionTask::~DatabaseTransactionTask()
    158158{
    159159    // If the task is being destructed without the transaction ever being run,
     
    169169}
    170170
    171 void DatabaseBackendAsync::DatabaseTransactionTask::doPerformTask()
     171void DatabaseBackend::DatabaseTransactionTask::doPerformTask()
    172172{
    173173    m_transaction->performNextStep();
     
    176176
    177177#if !LOG_DISABLED
    178 const char* DatabaseBackendAsync::DatabaseTransactionTask::debugTaskName() const
     178const char* DatabaseBackend::DatabaseTransactionTask::debugTaskName() const
    179179{
    180180    return "DatabaseTransactionTask";
     
    185185// Retrieves a list of all tables in the database - for WebInspector support.
    186186
    187 DatabaseBackendAsync::DatabaseTableNamesTask::DatabaseTableNamesTask(DatabaseBackendAsync* database, DatabaseTaskSynchronizer* synchronizer, Vector<String>& names)
     187DatabaseBackend::DatabaseTableNamesTask::DatabaseTableNamesTask(DatabaseBackend* database, DatabaseTaskSynchronizer* synchronizer, Vector<String>& names)
    188188    : DatabaseTask(database, synchronizer)
    189189    , m_tableNames(names)
     
    192192}
    193193
    194 void DatabaseBackendAsync::DatabaseTableNamesTask::doPerformTask()
     194void DatabaseBackend::DatabaseTableNamesTask::doPerformTask()
    195195{
    196196    m_tableNames = Database::from(database())->performGetTableNames();
     
    198198
    199199#if !LOG_DISABLED
    200 const char* DatabaseBackendAsync::DatabaseTableNamesTask::debugTaskName() const
     200const char* DatabaseBackend::DatabaseTableNamesTask::debugTaskName() const
    201201{
    202202    return "DatabaseTableNamesTask";
  • trunk/Source/WebCore/Modules/webdatabase/DatabaseTask.h

    r143271 r143551  
    3131#if ENABLE(SQL_DATABASE)
    3232
    33 #include "DatabaseBackendAsync.h"
     33#include "DatabaseBackend.h"
    3434#include "DatabaseBasicTypes.h"
    3535#include "DatabaseError.h"
     
    7878    void performTask();
    7979
    80     DatabaseBackendAsync* database() const { return m_database; }
     80    DatabaseBackend* database() const { return m_database; }
    8181#ifndef NDEBUG
    8282    bool hasSynchronizer() const { return m_synchronizer; }
     
    8585
    8686protected:
    87     DatabaseTask(DatabaseBackendAsync*, DatabaseTaskSynchronizer*);
     87    DatabaseTask(DatabaseBackend*, DatabaseTaskSynchronizer*);
    8888
    8989private:
    9090    virtual void doPerformTask() = 0;
    9191
    92     DatabaseBackendAsync* m_database;
     92    DatabaseBackend* m_database;
    9393    DatabaseTaskSynchronizer* m_synchronizer;
    9494
     
    9999};
    100100
    101 class DatabaseBackendAsync::DatabaseOpenTask : public DatabaseTask {
     101class DatabaseBackend::DatabaseOpenTask : public DatabaseTask {
    102102public:
    103     static PassOwnPtr<DatabaseOpenTask> create(DatabaseBackendAsync* db, bool setVersionInNewDatabase, DatabaseTaskSynchronizer* synchronizer, DatabaseError& error, String& errorMessage, bool& success)
     103    static PassOwnPtr<DatabaseOpenTask> create(DatabaseBackend* db, bool setVersionInNewDatabase, DatabaseTaskSynchronizer* synchronizer, DatabaseError& error, String& errorMessage, bool& success)
    104104    {
    105105        return adoptPtr(new DatabaseOpenTask(db, setVersionInNewDatabase, synchronizer, error, errorMessage, success));
     
    107107
    108108private:
    109     DatabaseOpenTask(DatabaseBackendAsync*, bool setVersionInNewDatabase, DatabaseTaskSynchronizer*, DatabaseError&, String& errorMessage, bool& success);
     109    DatabaseOpenTask(DatabaseBackend*, bool setVersionInNewDatabase, DatabaseTaskSynchronizer*, DatabaseError&, String& errorMessage, bool& success);
    110110
    111111    virtual void doPerformTask();
     
    120120};
    121121
    122 class DatabaseBackendAsync::DatabaseCloseTask : public DatabaseTask {
     122class DatabaseBackend::DatabaseCloseTask : public DatabaseTask {
    123123public:
    124     static PassOwnPtr<DatabaseCloseTask> create(DatabaseBackendAsync* db, DatabaseTaskSynchronizer* synchronizer)
     124    static PassOwnPtr<DatabaseCloseTask> create(DatabaseBackend* db, DatabaseTaskSynchronizer* synchronizer)
    125125    {
    126126        return adoptPtr(new DatabaseCloseTask(db, synchronizer));
     
    128128
    129129private:
    130     DatabaseCloseTask(DatabaseBackendAsync*, DatabaseTaskSynchronizer*);
     130    DatabaseCloseTask(DatabaseBackend*, DatabaseTaskSynchronizer*);
    131131
    132132    virtual void doPerformTask();
     
    136136};
    137137
    138 class DatabaseBackendAsync::DatabaseTransactionTask : public DatabaseTask {
     138class DatabaseBackend::DatabaseTransactionTask : public DatabaseTask {
    139139public:
    140140    virtual ~DatabaseTransactionTask();
     
    160160};
    161161
    162 class DatabaseBackendAsync::DatabaseTableNamesTask : public DatabaseTask {
     162class DatabaseBackend::DatabaseTableNamesTask : public DatabaseTask {
    163163public:
    164     static PassOwnPtr<DatabaseTableNamesTask> create(DatabaseBackendAsync* db, DatabaseTaskSynchronizer* synchronizer, Vector<String>& names)
     164    static PassOwnPtr<DatabaseTableNamesTask> create(DatabaseBackend* db, DatabaseTaskSynchronizer* synchronizer, Vector<String>& names)
    165165    {
    166166        return adoptPtr(new DatabaseTableNamesTask(db, synchronizer, names));
     
    168168
    169169private:
    170     DatabaseTableNamesTask(DatabaseBackendAsync*, DatabaseTaskSynchronizer*, Vector<String>& names);
     170    DatabaseTableNamesTask(DatabaseBackend*, DatabaseTaskSynchronizer*, Vector<String>& names);
    171171
    172172    virtual void doPerformTask();
  • trunk/Source/WebCore/Modules/webdatabase/DatabaseThread.cpp

    r143271 r143551  
    142142}
    143143
    144 void DatabaseThread::recordDatabaseOpen(DatabaseBackendAsync* database)
     144void DatabaseThread::recordDatabaseOpen(DatabaseBackend* database)
    145145{
    146146    ASSERT(currentThread() == m_threadID);
     
    150150}
    151151
    152 void DatabaseThread::recordDatabaseClosed(DatabaseBackendAsync* database)
     152void DatabaseThread::recordDatabaseClosed(DatabaseBackend* database)
    153153{
    154154    ASSERT(currentThread() == m_threadID);
     
    172172class SameDatabasePredicate {
    173173public:
    174     SameDatabasePredicate(const DatabaseBackendAsync* database) : m_database(database) { }
     174    SameDatabasePredicate(const DatabaseBackend* database) : m_database(database) { }
    175175    bool operator()(DatabaseTask* task) const { return task->database() == m_database; }
    176176private:
    177     const DatabaseBackendAsync* m_database;
     177    const DatabaseBackend* m_database;
    178178};
    179179
    180 void DatabaseThread::unscheduleDatabaseTasks(DatabaseBackendAsync* database)
     180void DatabaseThread::unscheduleDatabaseTasks(DatabaseBackend* database)
    181181{
    182182    // Note that the thread loop is running, so some tasks for the database
  • trunk/Source/WebCore/Modules/webdatabase/DatabaseThread.h

    r141956 r143551  
    4343namespace WebCore {
    4444
    45 class DatabaseBackendAsync;
     45class DatabaseBackend;
    4646class DatabaseTask;
    4747class DatabaseTaskSynchronizer;
     
    6161    void scheduleTask(PassOwnPtr<DatabaseTask>);
    6262    void scheduleImmediateTask(PassOwnPtr<DatabaseTask>); // This just adds the task to the front of the queue - the caller needs to be extremely careful not to create deadlocks when waiting for completion.
    63     void unscheduleDatabaseTasks(DatabaseBackendAsync*);
     63    void unscheduleDatabaseTasks(DatabaseBackend*);
    6464
    65     void recordDatabaseOpen(DatabaseBackendAsync*);
    66     void recordDatabaseClosed(DatabaseBackendAsync*);
     65    void recordDatabaseOpen(DatabaseBackend*);
     66    void recordDatabaseClosed(DatabaseBackend*);
    6767    ThreadIdentifier getThreadID() { return m_threadID; }
    6868
     
    8383
    8484    // This set keeps track of the open databases that have been used on this thread.
    85     typedef HashSet<RefPtr<DatabaseBackendAsync> > DatabaseSet;
     85    typedef HashSet<RefPtr<DatabaseBackend> > DatabaseSet;
    8686    DatabaseSet m_openDatabaseSet;
    8787
  • trunk/Source/WebCore/Modules/webdatabase/SQLStatementBackend.cpp

    r143264 r143551  
    3232
    3333#include "AbstractSQLStatement.h"
    34 #include "DatabaseBackendAsync.h"
     34#include "DatabaseBackend.h"
    3535#include "Logging.h"
    3636#include "SQLError.h"
     
    108108}
    109109
    110 bool SQLStatementBackend::execute(DatabaseBackendAsync* db)
     110bool SQLStatementBackend::execute(DatabaseBackend* db)
    111111{
    112112    ASSERT(!m_resultSet);
     
    212212}
    213213
    214 void SQLStatementBackend::setDatabaseDeletedError(DatabaseBackendAsync* database)
     214void SQLStatementBackend::setDatabaseDeletedError(DatabaseBackend* database)
    215215{
    216216    ASSERT(!m_error && !m_resultSet);
     
    219219}
    220220
    221 void SQLStatementBackend::setVersionMismatchedError(DatabaseBackendAsync* database)
     221void SQLStatementBackend::setVersionMismatchedError(DatabaseBackend* database)
    222222{
    223223    ASSERT(!m_error && !m_resultSet);
     
    226226}
    227227
    228 void SQLStatementBackend::setFailureDueToQuota(DatabaseBackendAsync* database)
     228void SQLStatementBackend::setFailureDueToQuota(DatabaseBackend* database)
    229229{
    230230    ASSERT(!m_error && !m_resultSet);
  • trunk/Source/WebCore/Modules/webdatabase/SQLStatementBackend.h

    r143264 r143551  
    4141
    4242class AbstractSQLStatement;
    43 class DatabaseBackendAsync;
     43class DatabaseBackend;
    4444class SQLError;
    4545class SQLTransactionBackend;
     
    5050        const String& sqlStatement, const Vector<SQLValue>& arguments, int permissions);
    5151
    52     bool execute(DatabaseBackendAsync*);
     52    bool execute(DatabaseBackend*);
    5353    bool lastExecutionFailedDueToQuota() const;
    5454
     
    5656    bool hasStatementErrorCallback() const { return m_hasErrorCallback; }
    5757
    58     void setDatabaseDeletedError(DatabaseBackendAsync*);
    59     void setVersionMismatchedError(DatabaseBackendAsync*);
     58    void setDatabaseDeletedError(DatabaseBackend*);
     59    void setVersionMismatchedError(DatabaseBackend*);
    6060
    6161    AbstractSQLStatement* frontend();
     
    6767        const Vector<SQLValue>& arguments, int permissions);
    6868
    69     void setFailureDueToQuota(DatabaseBackendAsync*);
     69    void setFailureDueToQuota(DatabaseBackend*);
    7070    void clearFailureDueToQuota();
    7171
  • trunk/Source/WebCore/Modules/webdatabase/SQLTransactionBackend.cpp

    r143489 r143551  
    3535#include "Database.h" // FIXME: Should only be used in the frontend.
    3636#include "DatabaseAuthorizer.h"
    37 #include "DatabaseBackendAsync.h"
     37#include "DatabaseBackend.h"
    3838#include "DatabaseBackendContext.h"
    3939#include "DatabaseThread.h"
     
    234234// The RefPtr chain goes something like this:
    235235//
    236 //     At birth (in DatabaseBackendAsync::runTransaction()):
     236//     At birth (in DatabaseBackend::runTransaction()):
    237237//     ====================================================
    238 //     DatabaseBackendAsync               // Deque<RefPtr<SQLTransactionBackend> > m_transactionQueue points to ...
     238//     DatabaseBackend                    // Deque<RefPtr<SQLTransactionBackend> > m_transactionQueue points to ...
    239239//     --> SQLTransactionBackend          // RefPtr<SQLTransaction> m_frontend points to ...
    240240//         --> SQLTransaction             // RefPtr<SQLTransactionBackend> m_backend points to ...
     
    249249//     is interrupted?" below for details.
    250250//
    251 //     After scheduling the transaction with the DatabaseThread (DatabaseBackendAsync::scheduleTransaction()):
     251//     After scheduling the transaction with the DatabaseThread (DatabaseBackend::scheduleTransaction()):
    252252//     ======================================================================================================
    253253//     DatabaseThread                         // MessageQueue<DatabaseTask> m_queue points to ...
     
    303303//
    304304//     - To clean up, DatabaseThread::databaseThread() will call
    305 //       DatabaseBackendAsync::close() during its shutdown.
    306 //     - DatabaseBackendAsync::close() will iterate
    307 //       DatabaseBackendAsync::m_transactionQueue and call
     305//       DatabaseBackend::close() during its shutdown.
     306//     - DatabaseBackend::close() will iterate
     307//       DatabaseBackend::m_transactionQueue and call
    308308//       notifyDatabaseThreadIsShuttingDown() on each transaction there.
    309309//       
     
    349349namespace WebCore {
    350350
    351 PassRefPtr<SQLTransactionBackend> SQLTransactionBackend::create(DatabaseBackendAsync* db,
     351PassRefPtr<SQLTransactionBackend> SQLTransactionBackend::create(DatabaseBackend* db,
    352352    PassRefPtr<AbstractSQLTransaction> frontend, PassRefPtr<SQLTransactionWrapper> wrapper, bool readOnly)
    353353{
     
    355355}
    356356
    357 SQLTransactionBackend::SQLTransactionBackend(DatabaseBackendAsync* db,
     357SQLTransactionBackend::SQLTransactionBackend(DatabaseBackend* db,
    358358    PassRefPtr<AbstractSQLTransaction> frontend, PassRefPtr<SQLTransactionWrapper> wrapper, bool readOnly)
    359359    : m_frontend(frontend)
  • trunk/Source/WebCore/Modules/webdatabase/SQLTransactionBackend.h

    r143489 r143551  
    4242
    4343class AbstractSQLTransaction;
    44 class DatabaseBackendAsync;
     44class DatabaseBackend;
    4545class SQLError;
    4646class SQLiteTransaction;
     
    6060class SQLTransactionBackend : public SQLTransactionStateMachine<SQLTransactionBackend>, public AbstractSQLTransactionBackend {
    6161public:
    62     static PassRefPtr<SQLTransactionBackend> create(DatabaseBackendAsync*,
     62    static PassRefPtr<SQLTransactionBackend> create(DatabaseBackend*,
    6363        PassRefPtr<AbstractSQLTransaction>, PassRefPtr<SQLTransactionWrapper>, bool readOnly);
    6464
     
    6868    void performNextStep();
    6969
    70     DatabaseBackendAsync* database() { return m_database.get(); }
     70    DatabaseBackend* database() { return m_database.get(); }
    7171    bool isReadOnly() { return m_readOnly; }
    7272    void notifyDatabaseThreadIsShuttingDown();
    7373
    7474private:
    75     SQLTransactionBackend(DatabaseBackendAsync*, PassRefPtr<AbstractSQLTransaction>,
     75    SQLTransactionBackend(DatabaseBackend*, PassRefPtr<AbstractSQLTransaction>,
    7676        PassRefPtr<SQLTransactionWrapper>, bool readOnly);
    7777
     
    112112    RefPtr<SQLStatementBackend> m_currentStatementBackend;
    113113
    114     RefPtr<DatabaseBackendAsync> m_database;
     114    RefPtr<DatabaseBackend> m_database;
    115115    RefPtr<SQLTransactionWrapper> m_wrapper;
    116116    RefPtr<SQLError> m_transactionError;
  • trunk/Source/WebCore/Modules/webdatabase/SQLTransactionCoordinator.cpp

    r143271 r143551  
    3535#if ENABLE(SQL_DATABASE)
    3636
    37 #include "DatabaseBackendAsync.h"
     37#include "DatabaseBackend.h"
    3838#include "SQLTransactionBackend.h"
    3939#include <wtf/Deque.h>
     
    4646static String getDatabaseIdentifier(SQLTransactionBackend* transaction)
    4747{
    48     DatabaseBackendAsync* database = transaction->database();
     48    DatabaseBackend* database = transaction->database();
    4949    ASSERT(database);
    5050    return database->stringIdentifier();
  • trunk/Source/WebCore/Target.pri

    r143471 r143551  
    14651465    Modules/webdatabase/DatabaseAuthorizer.h \
    14661466    Modules/webdatabase/Database.h \
    1467     Modules/webdatabase/DatabaseBackendAsync.h \
     1467    Modules/webdatabase/DatabaseBackend.h \
    14681468    Modules/webdatabase/DatabaseBackendBase.h \
    14691469    Modules/webdatabase/DatabaseBackendContext.h \
     
    30643064    SOURCES += \
    30653065        Modules/webdatabase/ChangeVersionWrapper.cpp \
    3066         Modules/webdatabase/DatabaseBackendAsync.cpp \
     3066        Modules/webdatabase/DatabaseBackend.cpp \
    30673067        Modules/webdatabase/DatabaseBackendContext.cpp \
    30683068        Modules/webdatabase/DatabaseBackendSync.cpp \
  • trunk/Source/WebCore/WebCore.gypi

    r143471 r143551  
    993993            'Modules/webdatabase/DatabaseAuthorizer.cpp',
    994994            'Modules/webdatabase/DatabaseAuthorizer.h',
    995             'Modules/webdatabase/DatabaseBackendAsync.cpp',
    996             'Modules/webdatabase/DatabaseBackendAsync.h',
     995            'Modules/webdatabase/DatabaseBackend.cpp',
     996            'Modules/webdatabase/DatabaseBackend.h',
    997997            'Modules/webdatabase/DatabaseBackendBase.cpp',
    998998            'Modules/webdatabase/DatabaseBackendBase.h',
  • trunk/Source/WebCore/WebCore.vcproj/WebCore.vcproj

    r143471 r143551  
    2541525415                                </File>
    2541625416                                <File
    25417                                         RelativePath="..\Modules\webdatabase\DatabaseBackendAsync.cpp"
    25418                                         >
    25419                                 </File>
    25420                                 <File
    25421                                         RelativePath="..\Modules\webdatabase\DatabaseBackendAsync.h"
     25417                                        RelativePath="..\Modules\webdatabase\DatabaseBackend.cpp"
     25418                                        >
     25419                                </File>
     25420                                <File
     25421                                        RelativePath="..\Modules\webdatabase\DatabaseBackend.h"
    2542225422                                        >
    2542325423                                </File>
  • trunk/Source/WebCore/WebCore.vcxproj/WebCore.vcxproj

    r143529 r143551  
    27532753    <ClCompile Include="..\Modules\webdatabase\Database.cpp" />
    27542754    <ClCompile Include="..\Modules\webdatabase\DatabaseAuthorizer.cpp" />
    2755     <ClCompile Include="..\Modules\webdatabase\DatabaseBackendAsync.cpp" />
     2755    <ClCompile Include="..\Modules\webdatabase\DatabaseBackend.cpp" />
    27562756    <ClCompile Include="..\Modules\webdatabase\DatabaseBackendBase.cpp" />
    27572757    <ClCompile Include="..\Modules\webdatabase\DatabaseBackendContext.cpp" />
     
    88248824    <ClInclude Include="..\Modules\webdatabase\Database.h" />
    88258825    <ClInclude Include="..\Modules\webdatabase\DatabaseAuthorizer.h" />
    8826     <ClInclude Include="..\Modules\webdatabase\DatabaseBackendAsync.h" />
     8826    <ClInclude Include="..\Modules\webdatabase\DatabaseBackend.h" />
    88278827    <ClInclude Include="..\Modules\webdatabase\DatabaseBackendBase.h" />
    88288828    <ClInclude Include="..\Modules\webdatabase\DatabaseBackendContext.h" />
  • trunk/Source/WebCore/WebCore.vcxproj/WebCore.vcxproj.filters

    r143471 r143551  
    18371837      <Filter>Modules\webdatabase</Filter>
    18381838    </ClCompile>
    1839     <ClCompile Include="..\Modules\webdatabase\DatabaseBackendAsync.cpp">
     1839    <ClCompile Include="..\Modules\webdatabase\DatabaseBackend.cpp">
    18401840      <Filter>Modules\webdatabase</Filter>
    18411841    </ClCompile>
     
    85038503      <Filter>Modules\webdatabase</Filter>
    85048504    </ClInclude>
    8505     <ClInclude Include="..\Modules\webdatabase\DatabaseBackendAsync.h">
     8505    <ClInclude Include="..\Modules\webdatabase\DatabaseBackend.h">
    85068506      <Filter>Modules\webdatabase</Filter>
    85078507    </ClInclude>
  • trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj

    r143550 r143551  
    67806780                FE09DB49169E2D6E00622557 /* DatabaseError.h in Headers */ = {isa = PBXBuildFile; fileRef = FE09DB46169E2D6E00622557 /* DatabaseError.h */; settings = {ATTRIBUTES = (Private, ); }; };
    67816781                FE115FAB167988CD00249134 /* AbstractDatabaseServer.h in Headers */ = {isa = PBXBuildFile; fileRef = FE115FA9167988CD00249134 /* AbstractDatabaseServer.h */; settings = {ATTRIBUTES = (Private, ); }; };
    6782                 FE16CFD3169D1DED00D3A0C7 /* DatabaseBackendAsync.cpp in Sources */ = {isa = PBXBuildFile; fileRef = FE16CFCF169D1DEC00D3A0C7 /* DatabaseBackendAsync.cpp */; };
    6783                 FE16CFD4169D1DED00D3A0C7 /* DatabaseBackendAsync.h in Headers */ = {isa = PBXBuildFile; fileRef = FE16CFD0169D1DEC00D3A0C7 /* DatabaseBackendAsync.h */; settings = {ATTRIBUTES = (Private, ); }; };
     6782                FE16CFD3169D1DED00D3A0C7 /* DatabaseBackend.cpp in Sources */ = {isa = PBXBuildFile; fileRef = FE16CFCF169D1DEC00D3A0C7 /* DatabaseBackend.cpp */; };
     6783                FE16CFD4169D1DED00D3A0C7 /* DatabaseBackend.h in Headers */ = {isa = PBXBuildFile; fileRef = FE16CFD0169D1DEC00D3A0C7 /* DatabaseBackend.h */; settings = {ATTRIBUTES = (Private, ); }; };
    67846784                FE16CFD5169D1DED00D3A0C7 /* DatabaseBackendSync.cpp in Sources */ = {isa = PBXBuildFile; fileRef = FE16CFD1169D1DEC00D3A0C7 /* DatabaseBackendSync.cpp */; };
    67856785                FE16CFD6169D1DED00D3A0C7 /* DatabaseBackendSync.h in Headers */ = {isa = PBXBuildFile; fileRef = FE16CFD2169D1DEC00D3A0C7 /* DatabaseBackendSync.h */; settings = {ATTRIBUTES = (Private, ); }; };
     
    1453614536                FE09DB46169E2D6E00622557 /* DatabaseError.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = DatabaseError.h; path = Modules/webdatabase/DatabaseError.h; sourceTree = "<group>"; };
    1453714537                FE115FA9167988CD00249134 /* AbstractDatabaseServer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = AbstractDatabaseServer.h; path = Modules/webdatabase/AbstractDatabaseServer.h; sourceTree = "<group>"; };
    14538                 FE16CFCF169D1DEC00D3A0C7 /* DatabaseBackendAsync.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = DatabaseBackendAsync.cpp; path = Modules/webdatabase/DatabaseBackendAsync.cpp; sourceTree = "<group>"; };
    14539                 FE16CFD0169D1DEC00D3A0C7 /* DatabaseBackendAsync.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = DatabaseBackendAsync.h; path = Modules/webdatabase/DatabaseBackendAsync.h; sourceTree = "<group>"; };
     14538                FE16CFCF169D1DEC00D3A0C7 /* DatabaseBackend.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = DatabaseBackend.cpp; path = Modules/webdatabase/DatabaseBackend.cpp; sourceTree = "<group>"; };
     14539                FE16CFD0169D1DEC00D3A0C7 /* DatabaseBackend.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = DatabaseBackend.h; path = Modules/webdatabase/DatabaseBackend.h; sourceTree = "<group>"; };
    1454014540                FE16CFD1169D1DEC00D3A0C7 /* DatabaseBackendSync.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = DatabaseBackendSync.cpp; path = Modules/webdatabase/DatabaseBackendSync.cpp; sourceTree = "<group>"; };
    1454114541                FE16CFD2169D1DEC00D3A0C7 /* DatabaseBackendSync.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = DatabaseBackendSync.h; path = Modules/webdatabase/DatabaseBackendSync.h; sourceTree = "<group>"; };
     
    1867618676                                97BC69E11505F081001B74AC /* DatabaseAuthorizer.cpp */,
    1867718677                                97BC69E21505F081001B74AC /* DatabaseAuthorizer.h */,
    18678                                 FE16CFCF169D1DEC00D3A0C7 /* DatabaseBackendAsync.cpp */,
    18679                                 FE16CFD0169D1DEC00D3A0C7 /* DatabaseBackendAsync.h */,
     18678                                FE16CFCF169D1DEC00D3A0C7 /* DatabaseBackend.cpp */,
     18679                                FE16CFD0169D1DEC00D3A0C7 /* DatabaseBackend.h */,
    1868018680                                97BC69D61505F076001B74AC /* DatabaseBackendBase.cpp */,
    1868118681                                97BC69D71505F076001B74AC /* DatabaseBackendBase.h */,
     
    2355923559                                97BC6A211505F081001B74AC /* Database.h in Headers */,
    2356023560                                97BC6A241505F081001B74AC /* DatabaseAuthorizer.h in Headers */,
    23561                                 FE16CFD4169D1DED00D3A0C7 /* DatabaseBackendAsync.h in Headers */,
     23561                                FE16CFD4169D1DED00D3A0C7 /* DatabaseBackend.h in Headers */,
    2356223562                                97BC69DB1505F076001B74AC /* DatabaseBackendBase.h in Headers */,
    2356323563                                FE6F6AB0169E057500FC30A2 /* DatabaseBackendContext.h in Headers */,
     
    2723327233                                97BC6A201505F081001B74AC /* Database.cpp in Sources */,
    2723427234                                97BC6A231505F081001B74AC /* DatabaseAuthorizer.cpp in Sources */,
    27235                                 FE16CFD3169D1DED00D3A0C7 /* DatabaseBackendAsync.cpp in Sources */,
     27235                                FE16CFD3169D1DED00D3A0C7 /* DatabaseBackend.cpp in Sources */,
    2723627236                                97BC69DA1505F076001B74AC /* DatabaseBackendBase.cpp in Sources */,
    2723727237                                FE6F6AAF169E057500FC30A2 /* DatabaseBackendContext.cpp in Sources */,
Note: See TracChangeset for help on using the changeset viewer.