Changeset 142193 in webkit


Ignore:
Timestamp:
Feb 7, 2013 3:49:28 PM (11 years ago)
Author:
mark.lam@apple.com
Message:

Introduce SQLTransactionBackend and SQLTransactionBackendSync.
​https://bugs.webkit.org/show_bug.cgi?id=109109.

Reviewed by Anders Carlsson.

  • Renamed SQLTransaction and SQLTransactionSync to SQLTransactionBackend and SQLTransactionBackendSync respectively.
  • Added back SQLTransaction and SQLTransactionSync as new files, and have their classes extends their respective backends. This is a stop gap measure to keep things working until the front-end and back-end can be properly split. Note: these files will be committed in a subsequent commit to ensure that the patching goes smoothly.
  • Where needed, I made use of new SQLTransaction::from() and SQLTransactionSync::from() static methods that "get" the front-end transactions from the back-ends. This is also a stop gap measure to keep things working until the proper refactoring is complete.
  • Fixed up pre-existing style checker violations that are now detected on code that were touched during my renaming.
  • Added the back-end files to all the build files.

No new tests.

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

(WebCore::Database::scheduleTransactionStep):

  • Modules/webdatabase/Database.h:

(Database):

  • Modules/webdatabase/DatabaseBackend.h:

(DatabaseBackend):

  • Modules/webdatabase/DatabaseTask.cpp:

(WebCore::DatabaseBackendAsync::DatabaseTransactionTask::DatabaseTransactionTask):

  • Modules/webdatabase/DatabaseTask.h:

(WebCore::DatabaseBackendAsync::DatabaseTransactionTask::create):
(WebCore::DatabaseBackendAsync::DatabaseTransactionTask::transaction):
(DatabaseBackendAsync::DatabaseTransactionTask):

  • Modules/webdatabase/SQLTransaction.cpp: Removed.
  • Modules/webdatabase/SQLTransaction.h: Removed.
  • Modules/webdatabase/SQLTransactionBackend.cpp: Copied from Source/WebCore/Modules/webdatabase/SQLTransaction.cpp.

(WebCore::SQLTransactionBackend::SQLTransactionBackend):
(WebCore::SQLTransactionBackend::~SQLTransactionBackend):
(WebCore::SQLTransactionBackend::executeSQL):
(WebCore::SQLTransactionBackend::enqueueStatement):
(WebCore::SQLTransactionBackend::debugStepName):
(WebCore::SQLTransactionBackend::checkAndHandleClosedOrInterruptedDatabase):
(WebCore::SQLTransactionBackend::performNextStep):
(WebCore::SQLTransactionBackend::performPendingCallback):
(WebCore::SQLTransactionBackend::notifyDatabaseThreadIsShuttingDown):
(WebCore::SQLTransactionBackend::acquireLock):
(WebCore::SQLTransactionBackend::lockAcquired):
(WebCore::SQLTransactionBackend::openTransactionAndPreflight):
(WebCore::SQLTransactionBackend::deliverTransactionCallback):
(WebCore::SQLTransactionBackend::scheduleToRunStatements):
(WebCore::SQLTransactionBackend::runStatements):
(WebCore::SQLTransactionBackend::getNextStatement):
(WebCore::SQLTransactionBackend::runCurrentStatement):
(WebCore::SQLTransactionBackend::handleCurrentStatementError):
(WebCore::SQLTransactionBackend::deliverStatementCallback):
(WebCore::SQLTransactionBackend::deliverQuotaIncreaseCallback):
(WebCore::SQLTransactionBackend::postflightAndCommit):
(WebCore::SQLTransactionBackend::deliverSuccessCallback):
(WebCore::SQLTransactionBackend::cleanupAfterSuccessCallback):
(WebCore::SQLTransactionBackend::handleTransactionError):
(WebCore::SQLTransactionBackend::deliverTransactionErrorCallback):
(WebCore::SQLTransactionBackend::cleanupAfterTransactionErrorCallback):

  • Modules/webdatabase/SQLTransactionBackend.h: Copied from Source/WebCore/Modules/webdatabase/SQLTransaction.h.

(SQLTransactionBackend):

  • Modules/webdatabase/SQLTransactionBackendSync.cpp: Copied from Source/WebCore/Modules/webdatabase/SQLTransactionSync.cpp.

(WebCore::SQLTransactionBackendSync::SQLTransactionBackendSync):
(WebCore::SQLTransactionBackendSync::~SQLTransactionBackendSync):
(WebCore::SQLTransactionBackendSync::executeSQL):
(WebCore::SQLTransactionBackendSync::begin):
(WebCore::SQLTransactionBackendSync::execute):
(WebCore::SQLTransactionBackendSync::commit):
(WebCore::SQLTransactionBackendSync::rollback):

  • Modules/webdatabase/SQLTransactionBackendSync.h: Copied from Source/WebCore/Modules/webdatabase/SQLTransactionSync.h.

(SQLTransactionBackendSync):

  • Modules/webdatabase/SQLTransactionCoordinator.cpp:

(WebCore::getDatabaseIdentifier):
(WebCore::SQLTransactionCoordinator::processPendingTransactions):
(WebCore::SQLTransactionCoordinator::acquireLock):
(WebCore::SQLTransactionCoordinator::releaseLock):
(WebCore::SQLTransactionCoordinator::shutdown):

  • Modules/webdatabase/SQLTransactionCoordinator.h:

(SQLTransactionCoordinator):
(WebCore::SQLTransactionCoordinator::SQLTransactionCoordinator):
(CoordinationInfo):

  • Modules/webdatabase/SQLTransactionSync.cpp: Removed.
  • Modules/webdatabase/SQLTransactionSync.h: Removed.
  • 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:
16 edited
4 moved

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/CMakeLists.txt

    r142143 r142193  
    974974    Modules/webdatabase/SQLStatementSync.cpp
    975975    Modules/webdatabase/SQLTransaction.cpp
     976    Modules/webdatabase/SQLTransactionBackend.cpp
     977    Modules/webdatabase/SQLTransactionBackendSync.cpp
    976978    Modules/webdatabase/SQLTransactionClient.cpp
    977979    Modules/webdatabase/SQLTransactionCoordinator.cpp

  • trunk/Source/WebCore/ChangeLog

    r142191 r142193  
     12013-02-07  Mark Lam  <mark.lam@apple.com>
     2
     3        Introduce SQLTransactionBackend and SQLTransactionBackendSync.
     4        https://bugs.webkit.org/show_bug.cgi?id=109109.
     5
     6        Reviewed by Anders Carlsson.
     7
     8        - Renamed SQLTransaction and SQLTransactionSync to SQLTransactionBackend
     9          and SQLTransactionBackendSync respectively.
     10        - Added back SQLTransaction and SQLTransactionSync as new files, and have
     11          their classes extends their respective backends. This is a stop gap
     12          measure to keep things working until the front-end and back-end can be
     13          properly split.
     14          Note: these files will be committed in a subsequent commit to ensure
     15          that the patching goes smoothly.
     16        - Where needed, I made use of new SQLTransaction::from() and
     17          SQLTransactionSync::from() static methods that "get" the front-end
     18          transactions from the back-ends. This is also a stop gap measure to
     19          keep things working until the proper refactoring is complete.
     20        - Fixed up pre-existing style checker violations that are now detected
     21          on code that were touched during my renaming.
     22        - Added the back-end files to all the build files.
     23
     24        No new tests.
     25
     26        * CMakeLists.txt:
     27        * GNUmakefile.list.am:
     28        * Modules/webdatabase/Database.cpp:
     29        (WebCore::Database::scheduleTransactionStep):
     30        * Modules/webdatabase/Database.h:
     31        (Database):
     32        * Modules/webdatabase/DatabaseBackend.h:
     33        (DatabaseBackend):
     34        * Modules/webdatabase/DatabaseTask.cpp:
     35        (WebCore::DatabaseBackendAsync::DatabaseTransactionTask::DatabaseTransactionTask):
     36        * Modules/webdatabase/DatabaseTask.h:
     37        (WebCore::DatabaseBackendAsync::DatabaseTransactionTask::create):
     38        (WebCore::DatabaseBackendAsync::DatabaseTransactionTask::transaction):
     39        (DatabaseBackendAsync::DatabaseTransactionTask):
     40        * Modules/webdatabase/SQLTransaction.cpp: Removed.
     41        * Modules/webdatabase/SQLTransaction.h: Removed.
     42        * Modules/webdatabase/SQLTransactionBackend.cpp: Copied from Source/WebCore/Modules/webdatabase/SQLTransaction.cpp.
     43        (WebCore::SQLTransactionBackend::SQLTransactionBackend):
     44        (WebCore::SQLTransactionBackend::~SQLTransactionBackend):
     45        (WebCore::SQLTransactionBackend::executeSQL):
     46        (WebCore::SQLTransactionBackend::enqueueStatement):
     47        (WebCore::SQLTransactionBackend::debugStepName):
     48        (WebCore::SQLTransactionBackend::checkAndHandleClosedOrInterruptedDatabase):
     49        (WebCore::SQLTransactionBackend::performNextStep):
     50        (WebCore::SQLTransactionBackend::performPendingCallback):
     51        (WebCore::SQLTransactionBackend::notifyDatabaseThreadIsShuttingDown):
     52        (WebCore::SQLTransactionBackend::acquireLock):
     53        (WebCore::SQLTransactionBackend::lockAcquired):
     54        (WebCore::SQLTransactionBackend::openTransactionAndPreflight):
     55        (WebCore::SQLTransactionBackend::deliverTransactionCallback):
     56        (WebCore::SQLTransactionBackend::scheduleToRunStatements):
     57        (WebCore::SQLTransactionBackend::runStatements):
     58        (WebCore::SQLTransactionBackend::getNextStatement):
     59        (WebCore::SQLTransactionBackend::runCurrentStatement):
     60        (WebCore::SQLTransactionBackend::handleCurrentStatementError):
     61        (WebCore::SQLTransactionBackend::deliverStatementCallback):
     62        (WebCore::SQLTransactionBackend::deliverQuotaIncreaseCallback):
     63        (WebCore::SQLTransactionBackend::postflightAndCommit):
     64        (WebCore::SQLTransactionBackend::deliverSuccessCallback):
     65        (WebCore::SQLTransactionBackend::cleanupAfterSuccessCallback):
     66        (WebCore::SQLTransactionBackend::handleTransactionError):
     67        (WebCore::SQLTransactionBackend::deliverTransactionErrorCallback):
     68        (WebCore::SQLTransactionBackend::cleanupAfterTransactionErrorCallback):
     69        * Modules/webdatabase/SQLTransactionBackend.h: Copied from Source/WebCore/Modules/webdatabase/SQLTransaction.h.
     70        (SQLTransactionBackend):
     71        * Modules/webdatabase/SQLTransactionBackendSync.cpp: Copied from Source/WebCore/Modules/webdatabase/SQLTransactionSync.cpp.
     72        (WebCore::SQLTransactionBackendSync::SQLTransactionBackendSync):
     73        (WebCore::SQLTransactionBackendSync::~SQLTransactionBackendSync):
     74        (WebCore::SQLTransactionBackendSync::executeSQL):
     75        (WebCore::SQLTransactionBackendSync::begin):
     76        (WebCore::SQLTransactionBackendSync::execute):
     77        (WebCore::SQLTransactionBackendSync::commit):
     78        (WebCore::SQLTransactionBackendSync::rollback):
     79        * Modules/webdatabase/SQLTransactionBackendSync.h: Copied from Source/WebCore/Modules/webdatabase/SQLTransactionSync.h.
     80        (SQLTransactionBackendSync):
     81        * Modules/webdatabase/SQLTransactionCoordinator.cpp:
     82        (WebCore::getDatabaseIdentifier):
     83        (WebCore::SQLTransactionCoordinator::processPendingTransactions):
     84        (WebCore::SQLTransactionCoordinator::acquireLock):
     85        (WebCore::SQLTransactionCoordinator::releaseLock):
     86        (WebCore::SQLTransactionCoordinator::shutdown):
     87        * Modules/webdatabase/SQLTransactionCoordinator.h:
     88        (SQLTransactionCoordinator):
     89        (WebCore::SQLTransactionCoordinator::SQLTransactionCoordinator):
     90        (CoordinationInfo):
     91        * Modules/webdatabase/SQLTransactionSync.cpp: Removed.
     92        * Modules/webdatabase/SQLTransactionSync.h: Removed.
     93        * Target.pri:
     94        * WebCore.gypi:
     95        * WebCore.vcproj/WebCore.vcproj:
     96        * WebCore.vcxproj/WebCore.vcxproj:
     97        * WebCore.vcxproj/WebCore.vcxproj.filters:
     98        * WebCore.xcodeproj/project.pbxproj:
     99
    11002013-02-07  Dean Jackson  <dino@apple.com>
    2101

  • trunk/Source/WebCore/GNUmakefile.list.am

    r142094 r142193  
    21532153        Source/WebCore/Modules/webdatabase/SQLStatementSync.cpp \
    21542154        Source/WebCore/Modules/webdatabase/SQLStatementSync.h \
     2155        Source/WebCore/Modules/webdatabase/SQLTransaction.cpp \
     2156        Source/WebCore/Modules/webdatabase/SQLTransaction.h \
     2157        Source/WebCore/Modules/webdatabase/SQLTransactionBackend.cpp \
     2158        Source/WebCore/Modules/webdatabase/SQLTransactionBackend.h \
     2159        Source/WebCore/Modules/webdatabase/SQLTransactionBackendSync.cpp \
     2160        Source/WebCore/Modules/webdatabase/SQLTransactionBackendSync.h \
    21552161        Source/WebCore/Modules/webdatabase/SQLTransactionCallback.h \
    21562162        Source/WebCore/Modules/webdatabase/SQLTransactionClient.cpp \
    … …  
    21582164        Source/WebCore/Modules/webdatabase/SQLTransactionCoordinator.cpp \
    21592165        Source/WebCore/Modules/webdatabase/SQLTransactionCoordinator.h \
    2160         Source/WebCore/Modules/webdatabase/SQLTransaction.cpp \
    21612166        Source/WebCore/Modules/webdatabase/SQLTransactionErrorCallback.h \
    2162         Source/WebCore/Modules/webdatabase/SQLTransaction.h \
    21632167        Source/WebCore/Modules/webdatabase/SQLTransactionSyncCallback.h \
    21642168        Source/WebCore/Modules/webdatabase/SQLTransactionSync.cpp \

  • trunk/Source/WebCore/Modules/webdatabase/Database.cpp

    r142030 r142193  
    11/*
    2  * Copyright (C) 2007, 2008 Apple Inc. All rights reserved.
     2 * Copyright (C) 2007, 2008, 2013 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    256256}
    257257
    258 void Database::scheduleTransactionStep(SQLTransaction* transaction, bool immediately)
     258void Database::scheduleTransactionStep(SQLTransactionBackend* transaction, bool immediately)
    259259{
    260260    if (!databaseContext()->databaseThread())

  • trunk/Source/WebCore/Modules/webdatabase/Database.h

    r142030 r142193  
    11/*
    2  * Copyright (C) 2007, 2008 Apple Inc. All rights reserved.
     2 * Copyright (C) 2007, 2008, 2013 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    4545class SecurityOrigin;
    4646class SQLTransaction;
     47class SQLTransactionBackend;
    4748class SQLTransactionCallback;
    4849class SQLTransactionClient;
    … …  
    8081
    8182    void scheduleTransactionCallback(SQLTransaction*);
    82     void scheduleTransactionStep(SQLTransaction*, bool immediately = false);
     83    void scheduleTransactionStep(SQLTransactionBackend*, bool immediately = false);
    8384
    8485    SQLTransactionClient* transactionClient() const;

  • trunk/Source/WebCore/Modules/webdatabase/DatabaseBackend.h

    r142030 r142193  
    9696    friend class SQLStatement;
    9797    friend class SQLStatementSync;
    98     friend class SQLTransactionSync;
    99     friend class SQLTransaction;
     98    friend class SQLTransactionBackend;
     99    friend class SQLTransactionBackendSync;
    100100
    101101    DatabaseBackend(PassRefPtr<DatabaseBackendContext>, const String& name, const String& expectedVersion,

  • trunk/Source/WebCore/Modules/webdatabase/DatabaseTask.cpp

    r141956 r142193  
    11/*
    2  * Copyright (C) 2007, 2008 Apple Inc. All rights reserved.
     2 * Copyright (C) 2007, 2008, 2013 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    148148// Starts a transaction that will report its results via a callback.
    149149
    150 DatabaseBackendAsync::DatabaseTransactionTask::DatabaseTransactionTask(PassRefPtr<SQLTransaction> transaction)
     150DatabaseBackendAsync::DatabaseTransactionTask::DatabaseTransactionTask(PassRefPtr<SQLTransactionBackend> transaction)
    151151    : DatabaseTask(Database::from(transaction->database()), 0)
    152152    , m_transaction(transaction)

  • trunk/Source/WebCore/Modules/webdatabase/DatabaseTask.h

    r141956 r142193  
    11/*
    2  * Copyright (C) 2007, 2008 Apple Inc. All rights reserved.
     2 * Copyright (C) 2007, 2008, 2013 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    3434#include "DatabaseBasicTypes.h"
    3535#include "DatabaseError.h"
    36 #include "SQLTransaction.h"
     36#include "SQLTransactionBackend.h"
    3737#include <wtf/OwnPtr.h>
    3838#include <wtf/PassOwnPtr.h>
    … …  
    139139public:
    140140    // Transaction task is never synchronous, so no 'synchronizer' parameter.
    141     static PassOwnPtr<DatabaseTransactionTask> create(PassRefPtr<SQLTransaction> transaction)
     141    static PassOwnPtr<DatabaseTransactionTask> create(PassRefPtr<SQLTransactionBackend> transaction)
    142142    {
    143143        return adoptPtr(new DatabaseTransactionTask(transaction));
    144144    }
    145145
    146     SQLTransaction* transaction() const { return m_transaction.get(); }
     146    SQLTransactionBackend* transaction() const { return m_transaction.get(); }
    147147
    148148private:
    149     explicit DatabaseTransactionTask(PassRefPtr<SQLTransaction>);
     149    explicit DatabaseTransactionTask(PassRefPtr<SQLTransactionBackend>);
    150150
    151151    virtual void doPerformTask();
    … …  
    154154#endif
    155155
    156     RefPtr<SQLTransaction> m_transaction;
     156    RefPtr<SQLTransactionBackend> m_transaction;
    157157};
    158158

  • trunk/Source/WebCore/Modules/webdatabase/SQLTransactionBackend.cpp

    r142181 r142193  
    11/*
    2  * Copyright (C) 2007, 2008 Apple Inc. All rights reserved.
     2 * Copyright (C) 2007, 2008, 2013 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    2828
    2929#include "config.h"
    30 #include "SQLTransaction.h"
     30#include "SQLTransactionBackend.h"
    3131
    3232#if ENABLE(SQL_DATABASE)
    … …  
    3838#include "ExceptionCode.h"
    3939#include "Logging.h"
    40 #include "ScriptExecutionContext.h"
    4140#include "SQLError.h"
    42 #include "SQLiteTransaction.h"
    4341#include "SQLStatement.h"
    4442#include "SQLStatementCallback.h"
    4543#include "SQLStatementErrorCallback.h"
     44#include "SQLTransaction.h"
    4645#include "SQLTransactionCallback.h"
    4746#include "SQLTransactionClient.h"
    … …  
    4948#include "SQLTransactionErrorCallback.h"
    5049#include "SQLValue.h"
     50#include "SQLiteTransaction.h"
     51#include "ScriptExecutionContext.h"
    5152#include "VoidCallback.h"
    5253#include <wtf/OwnPtr.h>
    … …  
    6263namespace WebCore {
    6364
    64 PassRefPtr<SQLTransaction> SQLTransaction::create(Database* db, PassRefPtr<SQLTransactionCallback> callback, PassRefPtr<SQLTransactionErrorCallback> errorCallback,
    65                                                   PassRefPtr<VoidCallback> successCallback, PassRefPtr<SQLTransactionWrapper> wrapper, bool readOnly)
    66 {
    67     return adoptRef(new SQLTransaction(db, callback, errorCallback, successCallback, wrapper, readOnly));
    68 }
    69 
    70 SQLTransaction::SQLTransaction(Database* db, PassRefPtr<SQLTransactionCallback> callback, PassRefPtr<SQLTransactionErrorCallback> errorCallback,
    71                                PassRefPtr<VoidCallback> successCallback, PassRefPtr<SQLTransactionWrapper> wrapper, bool readOnly)
    72     : m_nextStep(&SQLTransaction::acquireLock)
     65SQLTransactionBackend::SQLTransactionBackend(Database* db, PassRefPtr<SQLTransactionCallback> callback,
     66    PassRefPtr<SQLTransactionErrorCallback> errorCallback, PassRefPtr<VoidCallback> successCallback,
     67    PassRefPtr<SQLTransactionWrapper> wrapper, bool readOnly)
     68    : m_nextStep(&SQLTransactionBackend::acquireLock)
    7369    , m_executeSqlAllowed(false)
    7470    , m_database(db)
    … …  
    8682}
    8783
    88 SQLTransaction::~SQLTransaction()
     84SQLTransactionBackend::~SQLTransactionBackend()
    8985{
    9086    ASSERT(!m_sqliteTransaction);
    9187}
    9288
    93 void SQLTransaction::executeSQL(const String& sqlStatement, const Vector<SQLValue>& arguments, PassRefPtr<SQLStatementCallback> callback, PassRefPtr<SQLStatementErrorCallback> callbackError, ExceptionCode& e)
     89void SQLTransactionBackend::executeSQL(const String& sqlStatement, const Vector<SQLValue>& arguments, PassRefPtr<SQLStatementCallback> callback, PassRefPtr<SQLStatementErrorCallback> callbackError, ExceptionCode& e)
    9490{
    9591    if (!m_executeSqlAllowed || !m_database->opened()) {
    … …  
    112108}
    113109
    114 void SQLTransaction::enqueueStatement(PassRefPtr<SQLStatement> statement)
     110void SQLTransactionBackend::enqueueStatement(PassRefPtr<SQLStatement> statement)
    115111{
    116112    MutexLocker locker(m_statementMutex);
    … …  
    119115
    120116#if !LOG_DISABLED
    121 const char* SQLTransaction::debugStepName(SQLTransaction::TransactionStepMethod step)
    122 {
    123     if (step == &SQLTransaction::acquireLock)
     117const char* SQLTransactionBackend::debugStepName(SQLTransactionBackend::TransactionStepMethod step)
     118{
     119    if (step == &SQLTransactionBackend::acquireLock)
    124120        return "acquireLock";
    125     else if (step == &SQLTransaction::openTransactionAndPreflight)
     121    if (step == &SQLTransactionBackend::openTransactionAndPreflight)
    126122        return "openTransactionAndPreflight";
    127     else if (step == &SQLTransaction::runStatements)
     123    if (step == &SQLTransactionBackend::runStatements)
    128124        return "runStatements";
    129     else if (step == &SQLTransaction::postflightAndCommit)
     125    if (step == &SQLTransactionBackend::postflightAndCommit)
    130126        return "postflightAndCommit";
    131     else if (step == &SQLTransaction::cleanupAfterTransactionErrorCallback)
     127    if (step == &SQLTransactionBackend::cleanupAfterTransactionErrorCallback)
    132128        return "cleanupAfterTransactionErrorCallback";
    133     else if (step == &SQLTransaction::deliverTransactionCallback)
     129    if (step == &SQLTransactionBackend::deliverTransactionCallback)
    134130        return "deliverTransactionCallback";
    135     else if (step == &SQLTransaction::deliverTransactionErrorCallback)
     131    if (step == &SQLTransactionBackend::deliverTransactionErrorCallback)
    136132        return "deliverTransactionErrorCallback";
    137     else if (step == &SQLTransaction::deliverStatementCallback)
     133    if (step == &SQLTransactionBackend::deliverStatementCallback)
    138134        return "deliverStatementCallback";
    139     else if (step == &SQLTransaction::deliverQuotaIncreaseCallback)
     135    if (step == &SQLTransactionBackend::deliverQuotaIncreaseCallback)
    140136        return "deliverQuotaIncreaseCallback";
    141     else if (step == &SQLTransaction::deliverSuccessCallback)
     137    if (step == &SQLTransactionBackend::deliverSuccessCallback)
    142138        return "deliverSuccessCallback";
    143     else if (step == &SQLTransaction::cleanupAfterSuccessCallback)
     139    if (step == &SQLTransactionBackend::cleanupAfterSuccessCallback)
    144140        return "cleanupAfterSuccessCallback";
    145     else
    146         return "UNKNOWN";
     141    return "UNKNOWN";
    147142}
    148143#endif
    149144
    150 void SQLTransaction::checkAndHandleClosedOrInterruptedDatabase()
     145void SQLTransactionBackend::checkAndHandleClosedOrInterruptedDatabase()
    151146{
    152147    if (m_database->opened() && !m_database->isInterrupted())
    … …  
    179174
    180175
    181 bool SQLTransaction::performNextStep()
     176bool SQLTransactionBackend::performNextStep()
    182177{
    183178    LOG(StorageAPI, "Step %s\n", debugStepName(m_nextStep));
    184179
    185     ASSERT(m_nextStep == &SQLTransaction::acquireLock ||
    186            m_nextStep == &SQLTransaction::openTransactionAndPreflight ||
    187            m_nextStep == &SQLTransaction::runStatements ||
    188            m_nextStep == &SQLTransaction::postflightAndCommit ||
    189            m_nextStep == &SQLTransaction::cleanupAfterSuccessCallback ||
    190            m_nextStep == &SQLTransaction::cleanupAfterTransactionErrorCallback);
     180    ASSERT(m_nextStep == &SQLTransactionBackend::acquireLock
     181        || m_nextStep == &SQLTransactionBackend::openTransactionAndPreflight
     182        || m_nextStep == &SQLTransactionBackend::runStatements
     183        || m_nextStep == &SQLTransactionBackend::postflightAndCommit
     184        || m_nextStep == &SQLTransactionBackend::cleanupAfterSuccessCallback
     185        || m_nextStep == &SQLTransactionBackend::cleanupAfterTransactionErrorCallback);
    191186
    192187    checkAndHandleClosedOrInterruptedDatabase();
    … …  
    199194}
    200195
    201 void SQLTransaction::performPendingCallback()
     196void SQLTransactionBackend::performPendingCallback()
    202197{
    203198    LOG(StorageAPI, "Callback %s\n", debugStepName(m_nextStep));
    204199
    205     ASSERT(m_nextStep == &SQLTransaction::deliverTransactionCallback ||
    206            m_nextStep == &SQLTransaction::deliverTransactionErrorCallback ||
    207            m_nextStep == &SQLTransaction::deliverStatementCallback ||
    208            m_nextStep == &SQLTransaction::deliverQuotaIncreaseCallback ||
    209            m_nextStep == &SQLTransaction::deliverSuccessCallback);
     200    ASSERT(m_nextStep == &SQLTransactionBackend::deliverTransactionCallback
     201        || m_nextStep == &SQLTransactionBackend::deliverTransactionErrorCallback
     202        || m_nextStep == &SQLTransactionBackend::deliverStatementCallback
     203        || m_nextStep == &SQLTransactionBackend::deliverQuotaIncreaseCallback
     204        || m_nextStep == &SQLTransactionBackend::deliverSuccessCallback);
    210205
    211206    checkAndHandleClosedOrInterruptedDatabase();
    … …  
    215210}
    216211
    217 void SQLTransaction::notifyDatabaseThreadIsShuttingDown()
     212void SQLTransactionBackend::notifyDatabaseThreadIsShuttingDown()
    218213{
    219214    ASSERT(currentThread() == database()->databaseContext()->databaseThread()->getThreadID());
    … …  
    225220}
    226221
    227 void SQLTransaction::acquireLock()
     222void SQLTransactionBackend::acquireLock()
    228223{
    229224    m_database->transactionCoordinator()->acquireLock(this);
    230225}
    231226
    232 void SQLTransaction::lockAcquired()
     227void SQLTransactionBackend::lockAcquired()
    233228{
    234229    m_lockAcquired = true;
    235     m_nextStep = &SQLTransaction::openTransactionAndPreflight;
     230    m_nextStep = &SQLTransactionBackend::openTransactionAndPreflight;
    236231    LOG(StorageAPI, "Scheduling openTransactionAndPreflight immediately for transaction %p\n", this);
    237232    m_database->scheduleTransactionStep(this, true);
    238233}
    239234
    240 void SQLTransaction::openTransactionAndPreflight()
     235void SQLTransactionBackend::openTransactionAndPreflight()
    241236{
    242237    ASSERT(!m_database->sqliteDatabase().transactionInProgress());
    … …  
    270265        m_database->reportStartTransactionResult(2, SQLError::DATABASE_ERR, m_database->sqliteDatabase().lastError());
    271266        m_transactionError = SQLError::create(SQLError::DATABASE_ERR, "unable to begin transaction",
    272                                               m_database->sqliteDatabase().lastError(), m_database->sqliteDatabase().lastErrorMsg());
     267            m_database->sqliteDatabase().lastError(), m_database->sqliteDatabase().lastErrorMsg());
    273268        m_sqliteTransaction.clear();
    274269        handleTransactionError(false);
    … …  
    283278        m_database->reportStartTransactionResult(3, SQLError::DATABASE_ERR, m_database->sqliteDatabase().lastError());
    284279        m_transactionError = SQLError::create(SQLError::DATABASE_ERR, "unable to read version",
    285                                               m_database->sqliteDatabase().lastError(), m_database->sqliteDatabase().lastErrorMsg());
     280            m_database->sqliteDatabase().lastError(), m_database->sqliteDatabase().lastErrorMsg());
    286281        m_database->disableAuthorizer();
    287282        m_sqliteTransaction.clear();
    … …  
    290285        return;
    291286    }
    292     m_hasVersionMismatch = !m_database->expectedVersion().isEmpty()
    293                            && (m_database->expectedVersion() != actualVersion);
     287    m_hasVersionMismatch = !m_database->expectedVersion().isEmpty() && (m_database->expectedVersion() != actualVersion);
    294288
    295289    // Transaction Steps 3 - Peform preflight steps, jumping to the error callback if they fail
    296     if (m_wrapper && !m_wrapper->performPreflight(this)) {
     290    if (m_wrapper && !m_wrapper->performPreflight(SQLTransaction::from(this))) {
    297291        m_database->disableAuthorizer();
    298292        m_sqliteTransaction.clear();
    … …  
    308302
    309303    // Transaction Step 4 - Invoke the transaction callback with the new SQLTransaction object
    310     m_nextStep = &SQLTransaction::deliverTransactionCallback;
     304    m_nextStep = &SQLTransactionBackend::deliverTransactionCallback;
    311305    LOG(StorageAPI, "Scheduling deliverTransactionCallback for transaction %p\n", this);
    312     m_database->scheduleTransactionCallback(this);
    313 }
    314 
    315 void SQLTransaction::deliverTransactionCallback()
     306    m_database->scheduleTransactionCallback(SQLTransaction::from(this));
     307}
     308
     309void SQLTransactionBackend::deliverTransactionCallback()
    316310{
    317311    bool shouldDeliverErrorCallback = false;
    … …  
    320314    if (callback) {
    321315        m_executeSqlAllowed = true;
    322         shouldDeliverErrorCallback = !callback->handleEvent(this);
     316        shouldDeliverErrorCallback = !callback->handleEvent(SQLTransaction::from(this));
    323317        m_executeSqlAllowed = false;
    324318    }
    … …  
    335329}
    336330
    337 void SQLTransaction::scheduleToRunStatements()
    338 {
    339     m_nextStep = &SQLTransaction::runStatements;
     331void SQLTransactionBackend::scheduleToRunStatements()
     332{
     333    m_nextStep = &SQLTransactionBackend::runStatements;
    340334    LOG(StorageAPI, "Scheduling runStatements for transaction %p\n", this);
    341335    m_database->scheduleTransactionStep(this);
    342336}
    343337
    344 void SQLTransaction::runStatements()
     338void SQLTransactionBackend::runStatements()
    345339{
    346340    ASSERT(m_lockAcquired);
    … …  
    361355        } else {
    362356            // If the current statement has already been run, failed due to quota constraints, and we're not retrying it,
    363             // that means it ended in an error.  Handle it now
     357            // that means it ended in an error. Handle it now
    364358            if (m_currentStatement && m_currentStatement->lastExecutionFailedDueToQuota()) {
    365359                handleCurrentStatementError();
    … …  
    373367
    374368    // If runCurrentStatement() returned false, that means either there was no current statement to run,
    375     // or the current statement requires a callback to complete.  In the later case, it also scheduled
     369    // or the current statement requires a callback to complete. In the later case, it also scheduled
    376370    // the callback or performed any other additional work so we can return
    377371    if (!m_currentStatement)
    … …  
    379373}
    380374
    381 void SQLTransaction::getNextStatement()
     375void SQLTransactionBackend::getNextStatement()
    382376{
    383377    m_currentStatement = 0;
    384378
    385379    MutexLocker locker(m_statementMutex);
    386     if (!m_statementQueue.isEmpty()) {
     380    if (!m_statementQueue.isEmpty())
    387381        m_currentStatement = m_statementQueue.takeFirst();
    388     }
    389 }
    390 
    391 bool SQLTransaction::runCurrentStatement()
     382}
     383
     384bool SQLTransactionBackend::runCurrentStatement()
    392385{
    393386    if (!m_currentStatement)
    … …  
    408401
    409402        if (m_currentStatement->hasStatementCallback()) {
    410             m_nextStep = &SQLTransaction::deliverStatementCallback;
     403            m_nextStep = &SQLTransactionBackend::deliverStatementCallback;
    411404            LOG(StorageAPI, "Scheduling deliverStatementCallback for transaction %p\n", this);
    412             m_database->scheduleTransactionCallback(this);
     405            m_database->scheduleTransactionCallback(SQLTransaction::from(this));
    413406            return false;
    414407        }
    … …  
    417410
    418411    if (m_currentStatement->lastExecutionFailedDueToQuota()) {
    419         m_nextStep = &SQLTransaction::deliverQuotaIncreaseCallback;
     412        m_nextStep = &SQLTransactionBackend::deliverQuotaIncreaseCallback;
    420413        LOG(StorageAPI, "Scheduling deliverQuotaIncreaseCallback for transaction %p\n", this);
    421         m_database->scheduleTransactionCallback(this);
     414        m_database->scheduleTransactionCallback(SQLTransaction::from(this));
    422415        return false;
    423416    }
    … …  
    428421}
    429422
    430 void SQLTransaction::handleCurrentStatementError()
     423void SQLTransactionBackend::handleCurrentStatementError()
    431424{
    432425    // Transaction Steps 6.error - Call the statement's error callback, but if there was no error callback,
    433426    // or the transaction was rolled back, jump to the transaction error callback
    434427    if (m_currentStatement->hasStatementErrorCallback() && !m_sqliteTransaction->wasRolledBackBySqlite()) {
    435         m_nextStep = &SQLTransaction::deliverStatementCallback;
     428        m_nextStep = &SQLTransactionBackend::deliverStatementCallback;
    436429        LOG(StorageAPI, "Scheduling deliverStatementCallback for transaction %p\n", this);
    437         m_database->scheduleTransactionCallback(this);
     430        m_database->scheduleTransactionCallback(SQLTransaction::from(this));
    438431    } else {
    439432        m_transactionError = m_currentStatement->sqlError();
    … …  
    446439}
    447440
    448 void SQLTransaction::deliverStatementCallback()
     441void SQLTransactionBackend::deliverStatementCallback()
    449442{
    450443    ASSERT(m_currentStatement);
    … …  
    453446    // Otherwise, continue to loop through the statement queue
    454447    m_executeSqlAllowed = true;
    455     bool result = m_currentStatement->performCallback(this);
     448    bool result = m_currentStatement->performCallback(SQLTransaction::from(this));
    456449    m_executeSqlAllowed = false;
    457450
    … …  
    464457}
    465458
    466 void SQLTransaction::deliverQuotaIncreaseCallback()
     459void SQLTransactionBackend::deliverQuotaIncreaseCallback()
    467460{
    468461    ASSERT(m_currentStatement);
    … …  
    471464    m_shouldRetryCurrentStatement = m_database->transactionClient()->didExceedQuota(database());
    472465
    473     m_nextStep = &SQLTransaction::runStatements;
     466    m_nextStep = &SQLTransactionBackend::runStatements;
    474467    LOG(StorageAPI, "Scheduling runStatements for transaction %p\n", this);
    475468    m_database->scheduleTransactionStep(this);
    476469}
    477470
    478 void SQLTransaction::postflightAndCommit()
     471void SQLTransactionBackend::postflightAndCommit()
    479472{
    480473    ASSERT(m_lockAcquired);
    481474
    482475    // Transaction Step 7 - Peform postflight steps, jumping to the error callback if they fail
    483     if (m_wrapper && !m_wrapper->performPostflight(this)) {
     476    if (m_wrapper && !m_wrapper->performPostflight(SQLTransaction::from(this))) {
    484477        m_transactionError = m_wrapper->sqlError();
    485478        if (!m_transactionError) {
    … …  
    501494    if (m_sqliteTransaction->inProgress()) {
    502495        if (m_wrapper)
    503             m_wrapper->handleCommitFailedAfterPostflight(this);
     496            m_wrapper->handleCommitFailedAfterPostflight(SQLTransaction::from(this));
    504497        m_successCallbackWrapper.clear();
    505498        m_database->reportCommitTransactionResult(4, SQLError::DATABASE_ERR, m_database->sqliteDatabase().lastError());
    506499        m_transactionError = SQLError::create(SQLError::DATABASE_ERR, "unable to commit transaction",
    507                                               m_database->sqliteDatabase().lastError(), m_database->sqliteDatabase().lastErrorMsg());
     500            m_database->sqliteDatabase().lastError(), m_database->sqliteDatabase().lastErrorMsg());
    508501        handleTransactionError(false);
    509502        return;
    … …  
    525518    // Transaction Step 10 - Deliver success callback, if there is one
    526519    if (m_successCallbackWrapper.hasCallback()) {
    527         m_nextStep = &SQLTransaction::deliverSuccessCallback;
     520        m_nextStep = &SQLTransactionBackend::deliverSuccessCallback;
    528521        LOG(StorageAPI, "Scheduling deliverSuccessCallback for transaction %p\n", this);
    529         m_database->scheduleTransactionCallback(this);
     522        m_database->scheduleTransactionCallback(SQLTransaction::from(this));
    530523    } else
    531524        cleanupAfterSuccessCallback();
    532525}
    533526
    534 void SQLTransaction::deliverSuccessCallback()
     527void SQLTransactionBackend::deliverSuccessCallback()
    535528{
    536529    // Transaction Step 10 - Deliver success callback
    … …  
    541534    // Schedule a "post-success callback" step to return control to the database thread in case there
    542535    // are further transactions queued up for this Database
    543     m_nextStep = &SQLTransaction::cleanupAfterSuccessCallback;
     536    m_nextStep = &SQLTransactionBackend::cleanupAfterSuccessCallback;
    544537    LOG(StorageAPI, "Scheduling cleanupAfterSuccessCallback for transaction %p\n", this);
    545538    m_database->scheduleTransactionStep(this);
    546539}
    547540
    548 void SQLTransaction::cleanupAfterSuccessCallback()
     541void SQLTransactionBackend::cleanupAfterSuccessCallback()
    549542{
    550543    ASSERT(m_lockAcquired);
    … …  
    561554}
    562555
    563 void SQLTransaction::handleTransactionError(bool inCallback)
     556void SQLTransactionBackend::handleTransactionError(bool inCallback)
    564557{
    565558    if (m_errorCallbackWrapper.hasCallback()) {
    … …  
    567560            deliverTransactionErrorCallback();
    568561        else {
    569             m_nextStep = &SQLTransaction::deliverTransactionErrorCallback;
     562            m_nextStep = &SQLTransactionBackend::deliverTransactionErrorCallback;
    570563            LOG(StorageAPI, "Scheduling deliverTransactionErrorCallback for transaction %p\n", this);
    571             m_database->scheduleTransactionCallback(this);
     564            m_database->scheduleTransactionCallback(SQLTransaction::from(this));
    572565        }
    573566        return;
    … …  
    577570    // Transaction Step 12 - Rollback the transaction.
    578571    if (inCallback) {
    579         m_nextStep = &SQLTransaction::cleanupAfterTransactionErrorCallback;
     572        m_nextStep = &SQLTransactionBackend::cleanupAfterTransactionErrorCallback;
    580573        LOG(StorageAPI, "Scheduling cleanupAfterTransactionErrorCallback for transaction %p\n", this);
    581574        m_database->scheduleTransactionStep(this);
    582     } else {
     575    } else
    583576        cleanupAfterTransactionErrorCallback();
    584     }
    585 }
    586 
    587 void SQLTransaction::deliverTransactionErrorCallback()
     577}
     578
     579void SQLTransactionBackend::deliverTransactionErrorCallback()
    588580{
    589581    ASSERT(m_transactionError);
    … …  
    595587        errorCallback->handleEvent(m_transactionError.get());
    596588
    597     m_nextStep = &SQLTransaction::cleanupAfterTransactionErrorCallback;
     589    m_nextStep = &SQLTransactionBackend::cleanupAfterTransactionErrorCallback;
    598590    LOG(StorageAPI, "Scheduling cleanupAfterTransactionErrorCallback for transaction %p\n", this);
    599591    m_database->scheduleTransactionStep(this);
    600592}
    601593
    602 void SQLTransaction::cleanupAfterTransactionErrorCallback()
     594void SQLTransactionBackend::cleanupAfterTransactionErrorCallback()
    603595{
    604596    ASSERT(m_lockAcquired);
    … …  
    620612    }
    621613
    622     // Transaction is complete!  There is no next step
     614    // Transaction is complete! There is no next step
    623615    LOG(StorageAPI, "Transaction %p is complete with an error\n", this);
    624616    ASSERT(!m_database->sqliteDatabase().transactionInProgress());

  • trunk/Source/WebCore/Modules/webdatabase/SQLTransactionBackend.h

    r142181 r142193  
    11/*
    2  * Copyright (C) 2007 Apple Inc. All rights reserved.
     2 * Copyright (C) 2007, 2013 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    2626 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    2727 */
    28 #ifndef SQLTransaction_h
    29 #define SQLTransaction_h
     28#ifndef SQLTransactionBackend_h
     29#define SQLTransactionBackend_h
    3030
    3131#if ENABLE(SQL_DATABASE)
    … …  
    6060};
    6161
    62 class SQLTransaction : public ThreadSafeRefCounted<SQLTransaction> {
     62class SQLTransactionBackend : public ThreadSafeRefCounted<SQLTransactionBackend> {
    6363public:
    64     static PassRefPtr<SQLTransaction> create(Database*, PassRefPtr<SQLTransactionCallback>, PassRefPtr<SQLTransactionErrorCallback>,
    65                                              PassRefPtr<VoidCallback>, PassRefPtr<SQLTransactionWrapper>, bool readOnly = false);
    66 
    67     ~SQLTransaction();
     64    ~SQLTransactionBackend();
    6865
    6966    void executeSQL(const String& sqlStatement, const Vector<SQLValue>& arguments,
    70                     PassRefPtr<SQLStatementCallback>, PassRefPtr<SQLStatementErrorCallback>, ExceptionCode&);
     67        PassRefPtr<SQLStatementCallback>, PassRefPtr<SQLStatementErrorCallback>, ExceptionCode&);
    7168
    7269    void lockAcquired();
    … …  
    7976
    8077private:
    81     SQLTransaction(Database*, PassRefPtr<SQLTransactionCallback>, PassRefPtr<SQLTransactionErrorCallback>,
    82                    PassRefPtr<VoidCallback>, PassRefPtr<SQLTransactionWrapper>, bool readOnly);
     78    SQLTransactionBackend(Database*, PassRefPtr<SQLTransactionCallback>, PassRefPtr<SQLTransactionErrorCallback>,
     79        PassRefPtr<VoidCallback>, PassRefPtr<SQLTransactionWrapper>, bool readOnly);
    8380
    84     typedef void (SQLTransaction::*TransactionStepMethod)();
     81    typedef void (SQLTransactionBackend::*TransactionStepMethod)();
    8582    TransactionStepMethod m_nextStep;
    8683
    … …  
    130127
    131128    OwnPtr<SQLiteTransaction> m_sqliteTransaction;
     129
     130    friend class SQLTransaction; // FIXME: Remove this once the front-end has been properly isolated.
    132131};
    133132
    … …  
    136135#endif
    137136
    138 #endif // SQLTransaction_h
     137#endif // SQLTransactionBackend_h

  • trunk/Source/WebCore/Modules/webdatabase/SQLTransactionBackendSync.cpp

    r142181 r142193  
    11/*
    22 * Copyright (C) 2010 Google Inc. All rights reserved.
     3 * Copyright (C) 2013 Apple Inc. All rights reserved.
    34 *
    45 * Redistribution and use in source and binary forms, with or without
    … …  
    3031
    3132#include "config.h"
    32 #include "SQLTransactionSync.h"
     33#include "SQLTransactionBackendSync.h"
    3334
    3435#if ENABLE(SQL_DATABASE)
    … …  
    4142#include "SQLStatementSync.h"
    4243#include "SQLTransactionClient.h"
     44#include "SQLTransactionSync.h"
    4345#include "SQLTransactionSyncCallback.h"
    4446#include "SQLValue.h"
    … …  
    5153namespace WebCore {
    5254
    53 PassRefPtr<SQLTransactionSync> SQLTransactionSync::create(DatabaseSync* db, PassRefPtr<SQLTransactionSyncCallback> callback, bool readOnly)
    54 {
    55     return adoptRef(new SQLTransactionSync(db, callback, readOnly));
    56 }
    57 
    58 SQLTransactionSync::SQLTransactionSync(DatabaseSync* db, PassRefPtr<SQLTransactionSyncCallback> callback, bool readOnly)
     55SQLTransactionBackendSync::SQLTransactionBackendSync(DatabaseSync* db, PassRefPtr<SQLTransactionSyncCallback> callback, bool readOnly)
    5956    : m_database(db)
    6057    , m_callback(callback)
    … …  
    6764}
    6865
    69 SQLTransactionSync::~SQLTransactionSync()
     66SQLTransactionBackendSync::~SQLTransactionBackendSync()
    7067{
    7168    ASSERT(m_database->scriptExecutionContext()->isContextThread());
    … …  
    7471}
    7572
    76 PassRefPtr<SQLResultSet> SQLTransactionSync::executeSQL(const String& sqlStatement, const Vector<SQLValue>& arguments, ExceptionCode& ec)
     73PassRefPtr<SQLResultSet> SQLTransactionBackendSync::executeSQL(const String& sqlStatement, const Vector<SQLValue>& arguments, ExceptionCode& ec)
    7774{
    7875    ASSERT(m_database->scriptExecutionContext()->isContextThread());
    … …  
    9794    int permissions = DatabaseAuthorizer::ReadWriteMask;
    9895    if (!m_database->databaseContext()->allowDatabaseAccess())
    99       permissions |= DatabaseAuthorizer::NoAccessMask;
     96        permissions |= DatabaseAuthorizer::NoAccessMask;
    10097    else if (m_readOnly)
    101       permissions |= DatabaseAuthorizer::ReadOnlyMask;
     98        permissions |= DatabaseAuthorizer::ReadOnlyMask;
    10299
    103100    SQLStatementSync statement(sqlStatement, arguments, permissions);
    … …  
    133130}
    134131
    135 ExceptionCode SQLTransactionSync::begin()
     132ExceptionCode SQLTransactionBackendSync::begin()
    136133{
    137134    ASSERT(m_database->scriptExecutionContext()->isContextThread());
    … …  
    161158        m_database->reportStartTransactionResult(2, SQLException::DATABASE_ERR, m_database->sqliteDatabase().lastError());
    162159        m_database->setLastErrorMessage("unable to begin transaction",
    163                                         m_database->sqliteDatabase().lastError(), m_database->sqliteDatabase().lastErrorMsg());
     160            m_database->sqliteDatabase().lastError(), m_database->sqliteDatabase().lastErrorMsg());
    164161        m_sqliteTransaction.clear();
    165162        return SQLException::DATABASE_ERR;
    … …  
    173170        m_database->reportStartTransactionResult(3, SQLException::DATABASE_ERR, m_database->sqliteDatabase().lastError());
    174171        m_database->setLastErrorMessage("unable to read version",
    175                                         m_database->sqliteDatabase().lastError(), m_database->sqliteDatabase().lastErrorMsg());
     172            m_database->sqliteDatabase().lastError(), m_database->sqliteDatabase().lastErrorMsg());
    176173        rollback();
    177174        return SQLException::DATABASE_ERR;
    178175    }
    179     m_hasVersionMismatch = !m_database->expectedVersion().isEmpty()
    180                            && (m_database->expectedVersion() != actualVersion);
     176    m_hasVersionMismatch = !m_database->expectedVersion().isEmpty() && (m_database->expectedVersion() != actualVersion);
    181177    m_database->reportStartTransactionResult(0, -1, 0); // OK
    182178    return 0;
    183179}
    184180
    185 ExceptionCode SQLTransactionSync::execute()
    186 {
    187     ASSERT(m_database->scriptExecutionContext()->isContextThread());
    188     if (!m_database->opened() || (m_callback && !m_callback->handleEvent(this))) {
     181ExceptionCode SQLTransactionBackendSync::execute()
     182{
     183    ASSERT(m_database->scriptExecutionContext()->isContextThread());
     184    if (!m_database->opened() || (m_callback && !m_callback->handleEvent(SQLTransactionSync::from(this)))) {
    189185        if (m_database->lastErrorMessage().isEmpty())
    190186            m_database->setLastErrorMessage("failed to execute transaction callback");
    … …  
    197193}
    198194
    199 ExceptionCode SQLTransactionSync::commit()
     195ExceptionCode SQLTransactionBackendSync::commit()
    200196{
    201197    ASSERT(m_database->scriptExecutionContext()->isContextThread());
    … …  
    216212        m_database->reportCommitTransactionResult(2, SQLException::DATABASE_ERR, m_database->sqliteDatabase().lastError());
    217213        m_database->setLastErrorMessage("unable to commit transaction",
    218                                         m_database->sqliteDatabase().lastError(), m_database->sqliteDatabase().lastErrorMsg());
     214            m_database->sqliteDatabase().lastError(), m_database->sqliteDatabase().lastErrorMsg());
    219215        return SQLException::DATABASE_ERR;
    220216    }
    … …  
    234230}
    235231
    236 void SQLTransactionSync::rollback()
     232void SQLTransactionBackendSync::rollback()
    237233{
    238234    ASSERT(m_database->scriptExecutionContext()->isContextThread());

  • trunk/Source/WebCore/Modules/webdatabase/SQLTransactionBackendSync.h

    r142181 r142193  
    11/*
    22 * Copyright (C) 2010 Google Inc. All rights reserved.
     3 * Copyright (C) 2013 Apple Inc. All rights reserved.
    34 *
    45 * Redistribution and use in source and binary forms, with or without
    … …  
    2930 */
    3031
    31 #ifndef SQLTransactionSync_h
    32 #define SQLTransactionSync_h
     32#ifndef SQLTransactionBackendSync_h
     33#define SQLTransactionBackendSync_h
    3334
    3435#if ENABLE(SQL_DATABASE)
    … …  
    5051
    5152// Instances of this class should be created and used only on the worker's context thread.
    52 class SQLTransactionSync : public RefCounted<SQLTransactionSync> {
     53class SQLTransactionBackendSync : public RefCounted<SQLTransactionBackendSync> {
    5354public:
    54     static PassRefPtr<SQLTransactionSync> create(DatabaseSync*, PassRefPtr<SQLTransactionSyncCallback>, bool readOnly = false);
    55 
    56     ~SQLTransactionSync();
     55    ~SQLTransactionBackendSync();
    5756
    5857    PassRefPtr<SQLResultSet> executeSQL(const String& sqlStatement, const Vector<SQLValue>& arguments, ExceptionCode&);
    … …  
    6766
    6867private:
    69     SQLTransactionSync(DatabaseSync*, PassRefPtr<SQLTransactionSyncCallback>, bool readOnly);
     68    SQLTransactionBackendSync(DatabaseSync*, PassRefPtr<SQLTransactionSyncCallback>, bool readOnly);
    7069
    7170    RefPtr<DatabaseSync> m_database;
    … …  
    7776    OwnPtr<SQLTransactionClient> m_transactionClient;
    7877    OwnPtr<SQLiteTransaction> m_sqliteTransaction;
     78
     79    friend class SQLTransactionSync; // FIXME: Remove this once the front-end has been properly isolated.
    7980};
    8081
    … …  
    8384#endif
    8485
    85 #endif // SQLTransactionSync_h
     86#endif // SQLTransactionBackendSync_h

  • trunk/Source/WebCore/Modules/webdatabase/SQLTransactionCoordinator.cpp

    r130612 r142193  
    11/*
    22 * Copyright (C) 2009 Google Inc. All rights reserved.
     3 * Copyright (C) 2013 Apple Inc. All rights reserved.
    34 *
    45 * Redistribution and use in source and binary forms, with or without
    … …  
    3536
    3637#include "Database.h"
    37 #include "SQLTransaction.h"
     38#include "SQLTransactionBackend.h"
    3839#include <wtf/Deque.h>
    3940#include <wtf/HashMap.h>
    … …  
    4344namespace WebCore {
    4445
    45 static String getDatabaseIdentifier(SQLTransaction* transaction)
     46static String getDatabaseIdentifier(SQLTransactionBackend* transaction)
    4647{
    4748    Database* database = transaction->database();
    … …  
    5556        return;
    5657
    57     RefPtr<SQLTransaction> firstPendingTransaction = info.pendingTransactions.first();
     58    RefPtr<SQLTransactionBackend> firstPendingTransaction = info.pendingTransactions.first();
    5859    if (firstPendingTransaction->isReadOnly()) {
    5960        do {
    … …  
    6970}
    7071
    71 void SQLTransactionCoordinator::acquireLock(SQLTransaction* transaction)
     72void SQLTransactionCoordinator::acquireLock(SQLTransactionBackend* transaction)
    7273{
    7374    String dbIdentifier = getDatabaseIdentifier(transaction);
    … …  
    8485}
    8586
    86 void SQLTransactionCoordinator::releaseLock(SQLTransaction* transaction)
     87void SQLTransactionCoordinator::releaseLock(SQLTransactionBackend* transaction)
    8788{
    8889    if (m_coordinationInfoMap.isEmpty())
    … …  
    114115        if (info.activeWriteTransaction)
    115116            info.activeWriteTransaction->notifyDatabaseThreadIsShuttingDown();
    116         for (HashSet<RefPtr<SQLTransaction> >::iterator activeReadTransactionsIterator =
     117        for (HashSet<RefPtr<SQLTransactionBackend> >::iterator activeReadTransactionsIterator =
    117118                     info.activeReadTransactions.begin();
    118119             activeReadTransactionsIterator != info.activeReadTransactions.end();

  • trunk/Source/WebCore/Modules/webdatabase/SQLTransactionCoordinator.h

    r109877 r142193  
    11/*
    22 * Copyright (C) 2009 Google Inc. All rights reserved.
     3 * Copyright (C) 2013 Apple Inc. All rights reserved.
    34 *
    45 * Redistribution and use in source and binary forms, with or without
    … …  
    4243namespace WebCore {
    4344
    44     class SQLTransaction;
     45class SQLTransactionBackend;
    4546
    46     class SQLTransactionCoordinator {
    47         WTF_MAKE_NONCOPYABLE(SQLTransactionCoordinator); WTF_MAKE_FAST_ALLOCATED;
    48     public:
    49         SQLTransactionCoordinator() { }
    50         void acquireLock(SQLTransaction*);
    51         void releaseLock(SQLTransaction*);
    52         void shutdown();
    53     private:
    54         typedef Deque<RefPtr<SQLTransaction> > TransactionsQueue;
    55         struct CoordinationInfo {
    56             TransactionsQueue pendingTransactions;
    57             HashSet<RefPtr<SQLTransaction> > activeReadTransactions;
    58             RefPtr<SQLTransaction> activeWriteTransaction;
    59         };
    60         // Maps database names to information about pending transactions
    61         typedef HashMap<String, CoordinationInfo> CoordinationInfoMap;
    62         CoordinationInfoMap m_coordinationInfoMap;
     47class SQLTransactionCoordinator {
     48    WTF_MAKE_NONCOPYABLE(SQLTransactionCoordinator); WTF_MAKE_FAST_ALLOCATED;
     49public:
     50    SQLTransactionCoordinator() { }
     51    void acquireLock(SQLTransactionBackend*);
     52    void releaseLock(SQLTransactionBackend*);
     53    void shutdown();
     54private:
     55    typedef Deque<RefPtr<SQLTransactionBackend> > TransactionsQueue;
     56    struct CoordinationInfo {
     57        TransactionsQueue pendingTransactions;
     58        HashSet<RefPtr<SQLTransactionBackend> > activeReadTransactions;
     59        RefPtr<SQLTransactionBackend> activeWriteTransaction;
     60    };
     61    // Maps database names to information about pending transactions
     62    typedef HashMap<String, CoordinationInfo> CoordinationInfoMap;
     63    CoordinationInfoMap m_coordinationInfoMap;
    6364
    64         void processPendingTransactions(CoordinationInfo& info);
    65     };
    66 }
     65    void processPendingTransactions(CoordinationInfo&);
     66};
     67
     68} // namespace WebCore
    6769
    6870#endif // ENABLE(SQL_DATABASE)

  • trunk/Source/WebCore/Target.pri

    r142143 r142193  
    14801480    Modules/webdatabase/SQLStatementSync.h \
    14811481    Modules/webdatabase/SQLTransaction.h \
     1482    Modules/webdatabase/SQLTransactionBackend.h \
     1483    Modules/webdatabase/SQLTransactionBackendSync.h \
    14821484    Modules/webdatabase/SQLTransactionClient.h \
    14831485    Modules/webdatabase/SQLTransactionCoordinator.h \
    … …  
    30553057        Modules/webdatabase/SQLStatementSync.cpp \
    30563058        Modules/webdatabase/SQLTransaction.cpp \
     3059        Modules/webdatabase/SQLTransactionBackend.cpp \
     3060        Modules/webdatabase/SQLTransactionBackendSync.cpp \
    30573061        Modules/webdatabase/SQLTransactionClient.cpp \
    30583062        Modules/webdatabase/SQLTransactionCoordinator.cpp \

  • trunk/Source/WebCore/WebCore.gypi

    r142072 r142193  
    10471047            'Modules/webdatabase/SQLStatementSync.h',
    10481048            'Modules/webdatabase/SQLTransaction.cpp',
     1049            'Modules/webdatabase/SQLTransaction.h',
     1050            'Modules/webdatabase/SQLTransactionBackend.cpp',
     1051            'Modules/webdatabase/SQLTransactionBackend.h',
     1052            'Modules/webdatabase/SQLTransactionBackendSync.cpp',
     1053            'Modules/webdatabase/SQLTransactionBackendSync.h',
    10491054            'Modules/webdatabase/SQLTransactionClient.cpp',
    10501055            'Modules/webdatabase/SQLTransactionClient.h',

  • trunk/Source/WebCore/WebCore.vcproj/WebCore.vcproj

    r141928 r142193  
    2554325543                                </File>
    2554425544                                <File
     25545                                        RelativePath="..\Modules\webdatabase\SQLTransactionBackend.cpp"
     25546                                        >
     25547                                </File>
     25548                                <File
     25549                                        RelativePath="..\Modules\webdatabase\SQLTransactionBackend.h"
     25550                                        >
     25551                                </File>
     25552                                <File
     25553                                        RelativePath="..\Modules\webdatabase\SQLTransactionBackendSync.cpp"
     25554                                        >
     25555                                </File>
     25556                                <File
     25557                                        RelativePath="..\Modules\webdatabase\SQLTransactionBackendSync.h"
     25558                                        >
     25559                                </File>
     25560                                <File
    2554525561                                        RelativePath="..\Modules\webdatabase\SQLTransactionCallback.h"
    2554625562                                        >

  • trunk/Source/WebCore/WebCore.vcxproj/WebCore.vcxproj

    r141928 r142193  
    18771877    <ClCompile Include="..\Modules\webdatabase\SQLStatementSync.cpp" />
    18781878    <ClCompile Include="..\Modules\webdatabase\SQLTransaction.cpp" />
     1879    <ClCompile Include="..\Modules\webdatabase\SQLTransactionBackend.cpp" />
     1880    <ClCompile Include="..\Modules\webdatabase\SQLTransactionBackendSync.cpp" />
    18791881    <ClCompile Include="..\Modules\webdatabase\SQLTransactionClient.cpp" />
    18801882    <ClCompile Include="..\Modules\webdatabase\SQLTransactionCoordinator.cpp" />
    … …  
    64406442    <ClInclude Include="..\Modules\webdatabase\SQLStatementSync.h" />
    64416443    <ClInclude Include="..\Modules\webdatabase\SQLTransaction.h" />
     6444    <ClInclude Include="..\Modules\webdatabase\SQLTransactionBackend.h" />
     6445    <ClInclude Include="..\Modules\webdatabase\SQLTransactionBackendSync.h" />
    64426446    <ClInclude Include="..\Modules\webdatabase\SQLTransactionCallback.h" />
    64436447    <ClInclude Include="..\Modules\webdatabase\SQLTransactionClient.h" />

  • trunk/Source/WebCore/WebCore.vcxproj/WebCore.vcxproj.filters

    r141928 r142193  
    19001900      <Filter>Modules\webdatabase</Filter>
    19011901    </ClCompile>
     1902    <ClCompile Include="..\Modules\webdatabase\SQLTransaction.cpp">
     1903      <Filter>Modules\webdatabase</Filter>
     1904    </ClCompile>
     1905    <ClCompile Include="..\Modules\webdatabase\SQLTransactionBackend.cpp">
     1906      <Filter>Modules\webdatabase</Filter>
     1907    </ClCompile>
     1908    <ClCompile Include="..\Modules\webdatabase\SQLTransactionBackendSync.cpp">
     1909      <Filter>Modules\webdatabase</Filter>
     1910    </ClCompile>
    19021911    <ClCompile Include="..\Modules\webdatabase\SQLTransactionClient.cpp">
    19031912      <Filter>Modules\webdatabase</Filter>
    … …  
    85528561    </ClInclude>
    85538562    <ClInclude Include="..\Modules\webdatabase\SQLTransaction.h">
     8563      <Filter>Modules\webdatabase</Filter>
     8564    </ClInclude>
     8565    <ClInclude Include="..\Modules\webdatabase\SQLTransactionBackend.h">
     8566      <Filter>Modules\webdatabase</Filter>
     8567    </ClInclude>
     8568    <ClInclude Include="..\Modules\webdatabase\SQLTransactionBackendSync.h">
    85548569      <Filter>Modules\webdatabase</Filter>
    85558570    </ClInclude>

  • trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj

    r142072 r142193  
    37373737                97BC6A4F1505F081001B74AC /* SQLTransaction.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 97BC6A0D1505F081001B74AC /* SQLTransaction.cpp */; };
    37383738                97BC6A501505F081001B74AC /* SQLTransaction.h in Headers */ = {isa = PBXBuildFile; fileRef = 97BC6A0E1505F081001B74AC /* SQLTransaction.h */; };
     3739                FEE1811316C319E800084849 /* SQLTransactionBackend.cpp in Sources */ = {isa = PBXBuildFile; fileRef = FEE1811116C319E800084849 /* SQLTransactionBackend.cpp */; };
     3740                FEE1811416C319E800084849 /* SQLTransactionBackend.h in Headers */ = {isa = PBXBuildFile; fileRef = FEE1811216C319E800084849 /* SQLTransactionBackend.h */; };
     3741                FEAD7D8716C339EE00D4670B /* SQLTransactionBackendSync.cpp in Sources */ = {isa = PBXBuildFile; fileRef = FEAD7D8516C339EE00D4670B /* SQLTransactionBackendSync.cpp */; };
     3742                FEAD7D8816C339EE00D4670B /* SQLTransactionBackendSync.h in Headers */ = {isa = PBXBuildFile; fileRef = FEAD7D8616C339EE00D4670B /* SQLTransactionBackendSync.h */; };
    37393743                97BC6A521505F081001B74AC /* SQLTransactionCallback.h in Headers */ = {isa = PBXBuildFile; fileRef = 97BC6A101505F081001B74AC /* SQLTransactionCallback.h */; };
    37403744                97BC6A541505F081001B74AC /* SQLTransactionClient.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 97BC6A121505F081001B74AC /* SQLTransactionClient.cpp */; };
    … …  
    1116711171                97BC6A0E1505F081001B74AC /* SQLTransaction.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SQLTransaction.h; path = Modules/webdatabase/SQLTransaction.h; sourceTree = "<group>"; };
    1116811172                97BC6A0F1505F081001B74AC /* SQLTransaction.idl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; name = SQLTransaction.idl; path = Modules/webdatabase/SQLTransaction.idl; sourceTree = "<group>"; };
     11173                FEE1811116C319E800084849 /* SQLTransactionBackend.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SQLTransactionBackend.cpp; path = Modules/webdatabase/SQLTransactionBackend.cpp; sourceTree = "<group>"; };
     11174                FEE1811216C319E800084849 /* SQLTransactionBackend.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SQLTransactionBackend.h; path = Modules/webdatabase/SQLTransactionBackend.h; sourceTree = "<group>"; };
     11175                FEAD7D8516C339EE00D4670B /* SQLTransactionBackendSync.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SQLTransactionBackendSync.cpp; path = Modules/webdatabase/SQLTransactionBackendSync.cpp; sourceTree = "<group>"; };
     11176                FEAD7D8616C339EE00D4670B /* SQLTransactionBackendSync.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SQLTransactionBackendSync.h; path = Modules/webdatabase/SQLTransactionBackendSync.h; sourceTree = "<group>"; };
    1116911177                97BC6A101505F081001B74AC /* SQLTransactionCallback.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SQLTransactionCallback.h; path = Modules/webdatabase/SQLTransactionCallback.h; sourceTree = "<group>"; };
    1117011178                97BC6A111505F081001B74AC /* SQLTransactionCallback.idl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; name = SQLTransactionCallback.idl; path = Modules/webdatabase/SQLTransactionCallback.idl; sourceTree = "<group>"; };
    … …  
    1860118609                                97BC6A0E1505F081001B74AC /* SQLTransaction.h */,
    1860218610                                97BC6A0F1505F081001B74AC /* SQLTransaction.idl */,
     18611                                FEE1811116C319E800084849 /* SQLTransactionBackend.cpp */,
     18612                                FEE1811216C319E800084849 /* SQLTransactionBackend.h */,
     18613                                FEAD7D8516C339EE00D4670B /* SQLTransactionBackendSync.cpp */,
     18614                                FEAD7D8616C339EE00D4670B /* SQLTransactionBackendSync.h */,
    1860318615                                97BC6A101505F081001B74AC /* SQLTransactionCallback.h */,
    1860418616                                97BC6A111505F081001B74AC /* SQLTransactionCallback.idl */,
    … …  
    2578425796                                97BC6A4E1505F081001B74AC /* SQLStatementSync.h in Headers */,
    2578525797                                97BC6A501505F081001B74AC /* SQLTransaction.h in Headers */,
     25798                                FEE1811416C319E800084849 /* SQLTransactionBackend.h in Headers */,
     25799                                FEAD7D8816C339EE00D4670B /* SQLTransactionBackendSync.h in Headers */,
    2578625800                                97BC6A521505F081001B74AC /* SQLTransactionCallback.h in Headers */,
    2578725801                                97BC6A551505F081001B74AC /* SQLTransactionClient.h in Headers */,
    … …  
    2906429078                                97BC6A4D1505F081001B74AC /* SQLStatementSync.cpp in Sources */,
    2906529079                                97BC6A4F1505F081001B74AC /* SQLTransaction.cpp in Sources */,
     29080                                FEE1811316C319E800084849 /* SQLTransactionBackend.cpp in Sources */,
     29081                                FEAD7D8716C339EE00D4670B /* SQLTransactionBackendSync.cpp in Sources */,
    2906629082                                97BC6A541505F081001B74AC /* SQLTransactionClient.cpp in Sources */,
    2906729083                                97BC6A561505F081001B74AC /* SQLTransactionCoordinator.cpp in Sources */,
Note: See TracChangeset for help on using the changeset viewer.