Changeset 31971 in webkit


Ignore:
Timestamp:
Apr 16, 2008 4:25:13 PM (16 years ago)
Author:
beidson@apple.com
Message:

JavaScriptCore:

2008-04-16 Brady Eidson <beidson@apple.com>

Reviewed by Sam Weinig

Change ThreadSafeShared to act like RefCounted by starting out with a single ref by default

  • wtf/Threading.h: (WTF::ThreadSafeShared::ThreadSafeShared):

WebCore:

2008-04-16 Brady Eidson <beidson@apple.com>

Reviewed by Sam Weinig

Changing ThreadSafeShared to start with a ref count of 1, so updating all users to
adoptRef() that initial reference.

  • bindings/js/JSCustomSQLStatementCallback.h: (WebCore::JSCustomSQLStatementCallback::create):
  • bindings/js/JSCustomSQLStatementErrorCallback.h: (WebCore::JSCustomSQLStatementErrorCallback::create):
  • bindings/js/JSCustomSQLTransactionCallback.h: (WebCore::JSCustomSQLTransactionCallback::create):
  • bindings/js/JSCustomSQLTransactionErrorCallback.h: (WebCore::JSCustomSQLTransactionErrorCallback::create):
  • bindings/js/JSDatabaseCustom.cpp: (WebCore::JSDatabase::changeVersion): (WebCore::JSDatabase::transaction):
  • bindings/js/JSSQLTransactionCustom.cpp: (WebCore::JSSQLTransaction::executeSql):
  • dom/Document.cpp: (WebCore::Document::databaseThread):
  • platform/SecurityOrigin.cpp: (WebCore::SecurityOrigin::create):
  • platform/sql/SQLiteAuthorizer.h: (WebCore::SQLiteAuthorizer::create): (WebCore::SQLiteAuthorizer::SQLiteAuthorizer):
  • storage/ChangeVersionWrapper.cpp: (WebCore::ChangeVersionWrapper::performPreflight): (WebCore::ChangeVersionWrapper::performPostflight):
  • storage/ChangeVersionWrapper.h: (WebCore::ChangeVersionWrapper::create):
  • storage/Database.cpp: (WebCore::Database::openAndVerifyVersion): (WebCore::Database::markAsDeletedAndClose): (WebCore::Database::changeVersion): (WebCore::Database::transaction): (WebCore::Database::scheduleTransaction): (WebCore::Database::scheduleTransactionStep): (WebCore::Database::tableNames):
  • storage/DatabaseAuthorizer.h: (WebCore::DatabaseAuthorizer::create):
  • storage/DatabaseTask.h: (WebCore::DatabaseOpenTask::create): (WebCore::DatabaseCloseTask::create): (WebCore::DatabaseTransactionTask::create): (WebCore::DatabaseTableNamesTask::create):
  • storage/DatabaseThread.cpp: (WebCore::DatabaseThread::scheduleTask): Change to take a PassRefPtr instead of raw (WebCore::DatabaseThread::scheduleImmediateTask): Ditto
  • storage/DatabaseThread.h: (WebCore::DatabaseThread::create):
  • storage/SQLError.h: (WebCore::SQLError::create): (WebCore::SQLError::SQLError):
  • storage/SQLResultSet.h: (WebCore::SQLResultSet::create):
  • storage/SQLStatement.cpp: (WebCore::SQLStatement::create): (WebCore::SQLStatement::execute): (WebCore::SQLStatement::setDatabaseDeletedError): (WebCore::SQLStatement::setVersionMismatchedError): (WebCore::SQLStatement::setFailureDueToQuota):
  • storage/SQLStatement.h:
  • storage/SQLTransaction.cpp: (WebCore::SQLTransaction::create): (WebCore::SQLTransaction::executeSQL): (WebCore::SQLTransaction::openTransactionAndPreflight): (WebCore::SQLTransaction::deliverTransactionCallback): (WebCore::SQLTransaction::handleCurrentStatementError): (WebCore::SQLTransaction::deliverStatementCallback): (WebCore::SQLTransaction::postflightAndCommit):
  • storage/SQLTransaction.h:
Location:
trunk
Files:
25 edited

Legend:

Unmodified
Added
Removed
  • trunk/JavaScriptCore/ChangeLog

    r31962 r31971  
     12008-04-16  Brady Eidson  <beidson@apple.com>
     2
     3        Reviewed by Sam Weinig
     4
     5        Change ThreadSafeShared to act like RefCounted by starting out with a single ref by default
     6
     7        * wtf/Threading.h:
     8        (WTF::ThreadSafeShared::ThreadSafeShared):
     9
    1102008-04-16  Sam Weinig  <sam@webkit.org>
    211
  • trunk/JavaScriptCore/wtf/Threading.h

    r31690 r31971  
    191191template<class T> class ThreadSafeShared : Noncopyable {
    192192public:
    193     ThreadSafeShared()
    194         : m_refCount(0)
     193    ThreadSafeShared(int initialRefCount = 1)
     194        : m_refCount(initialRefCount)
    195195    {
    196196    }
  • trunk/WebCore/ChangeLog

    r31970 r31971  
     12008-04-16  Brady Eidson  <beidson@apple.com>
     2
     3        Reviewed by Sam Weinig
     4
     5        Changing ThreadSafeShared to start with a ref count of 1, so updating all users to
     6        adoptRef() that initial reference.
     7
     8        * bindings/js/JSCustomSQLStatementCallback.h:
     9        (WebCore::JSCustomSQLStatementCallback::create):
     10        * bindings/js/JSCustomSQLStatementErrorCallback.h:
     11        (WebCore::JSCustomSQLStatementErrorCallback::create):
     12        * bindings/js/JSCustomSQLTransactionCallback.h:
     13        (WebCore::JSCustomSQLTransactionCallback::create):
     14        * bindings/js/JSCustomSQLTransactionErrorCallback.h:
     15        (WebCore::JSCustomSQLTransactionErrorCallback::create):
     16
     17        * bindings/js/JSDatabaseCustom.cpp:
     18        (WebCore::JSDatabase::changeVersion):
     19        (WebCore::JSDatabase::transaction):
     20
     21        * bindings/js/JSSQLTransactionCustom.cpp:
     22        (WebCore::JSSQLTransaction::executeSql):
     23
     24        * dom/Document.cpp:
     25        (WebCore::Document::databaseThread):
     26
     27        * platform/SecurityOrigin.cpp:
     28        (WebCore::SecurityOrigin::create):
     29
     30        * platform/sql/SQLiteAuthorizer.h:
     31        (WebCore::SQLiteAuthorizer::create):
     32        (WebCore::SQLiteAuthorizer::SQLiteAuthorizer):
     33
     34        * storage/ChangeVersionWrapper.cpp:
     35        (WebCore::ChangeVersionWrapper::performPreflight):
     36        (WebCore::ChangeVersionWrapper::performPostflight):
     37        * storage/ChangeVersionWrapper.h:
     38        (WebCore::ChangeVersionWrapper::create):
     39
     40        * storage/Database.cpp:
     41        (WebCore::Database::openAndVerifyVersion):
     42        (WebCore::Database::markAsDeletedAndClose):
     43        (WebCore::Database::changeVersion):
     44        (WebCore::Database::transaction):
     45        (WebCore::Database::scheduleTransaction):
     46        (WebCore::Database::scheduleTransactionStep):
     47        (WebCore::Database::tableNames):
     48
     49        * storage/DatabaseAuthorizer.h:
     50        (WebCore::DatabaseAuthorizer::create):
     51
     52        * storage/DatabaseTask.h:
     53        (WebCore::DatabaseOpenTask::create):
     54        (WebCore::DatabaseCloseTask::create):
     55        (WebCore::DatabaseTransactionTask::create):
     56        (WebCore::DatabaseTableNamesTask::create):
     57
     58        * storage/DatabaseThread.cpp:
     59        (WebCore::DatabaseThread::scheduleTask): Change to take a PassRefPtr instead of raw
     60        (WebCore::DatabaseThread::scheduleImmediateTask): Ditto
     61        * storage/DatabaseThread.h:
     62        (WebCore::DatabaseThread::create):
     63
     64        * storage/SQLError.h:
     65        (WebCore::SQLError::create):
     66        (WebCore::SQLError::SQLError):
     67
     68        * storage/SQLResultSet.h:
     69        (WebCore::SQLResultSet::create):
     70
     71        * storage/SQLStatement.cpp:
     72        (WebCore::SQLStatement::create):
     73        (WebCore::SQLStatement::execute):
     74        (WebCore::SQLStatement::setDatabaseDeletedError):
     75        (WebCore::SQLStatement::setVersionMismatchedError):
     76        (WebCore::SQLStatement::setFailureDueToQuota):
     77        * storage/SQLStatement.h:
     78
     79        * storage/SQLTransaction.cpp:
     80        (WebCore::SQLTransaction::create):
     81        (WebCore::SQLTransaction::executeSQL):
     82        (WebCore::SQLTransaction::openTransactionAndPreflight):
     83        (WebCore::SQLTransaction::deliverTransactionCallback):
     84        (WebCore::SQLTransaction::handleCurrentStatementError):
     85        (WebCore::SQLTransaction::deliverStatementCallback):
     86        (WebCore::SQLTransaction::postflightAndCommit):
     87        * storage/SQLTransaction.h:
     88
    1892008-04-16  Anders Carlsson  <andersca@apple.com>
    290
  • trunk/WebCore/bindings/js/JSCustomSQLStatementCallback.h

    r29663 r31971  
    4747class JSCustomSQLStatementCallback : public SQLStatementCallback {
    4848public:
     49    static PassRefPtr<JSCustomSQLStatementCallback> create(KJS::JSObject* callback, Frame* frame) { return adoptRef(new JSCustomSQLStatementCallback(callback, frame)); }
     50
     51    virtual void handleEvent(SQLTransaction*, SQLResultSet*, bool& raisedException);
     52
     53private:
    4954    JSCustomSQLStatementCallback(KJS::JSObject* callback, Frame*);
    50    
    51     virtual void handleEvent(SQLTransaction*, SQLResultSet*, bool& raisedException);
    52 private:
     55
    5356    KJS::ProtectedPtr<KJS::JSObject> m_callback;
    5457    RefPtr<Frame> m_frame;
  • trunk/WebCore/bindings/js/JSCustomSQLStatementErrorCallback.h

    r29663 r31971  
    4747class JSCustomSQLStatementErrorCallback : public SQLStatementErrorCallback {
    4848public:
    49     JSCustomSQLStatementErrorCallback(KJS::JSObject* callback, Frame*);
     49    static PassRefPtr<JSCustomSQLStatementErrorCallback> create(KJS::JSObject* callback, Frame* frame) { return adoptRef(new JSCustomSQLStatementErrorCallback(callback, frame)); }
    5050       
    5151    virtual bool handleEvent(SQLTransaction*, SQLError*);
     52
    5253private:
     54    JSCustomSQLStatementErrorCallback(KJS::JSObject* callback, Frame*);
     55
    5356    KJS::ProtectedPtr<KJS::JSObject> m_callback;
    5457    RefPtr<Frame> m_frame;
  • trunk/WebCore/bindings/js/JSCustomSQLTransactionCallback.h

    r29966 r31971  
    3232#include "SQLTransactionCallback.h"
    3333
     34#include <wtf/PassRefPtr.h>
     35
    3436namespace KJS {
    3537    class JSObject;
     
    4244class JSCustomSQLTransactionCallback : public SQLTransactionCallback {
    4345public:
    44     JSCustomSQLTransactionCallback(KJS::JSObject* callback, Frame*);
     46    static PassRefPtr<JSCustomSQLTransactionCallback> create(KJS::JSObject* callback, Frame* frame) { return adoptRef(new JSCustomSQLTransactionCallback(callback, frame)); }
     47
    4548    virtual ~JSCustomSQLTransactionCallback();
    4649   
     
    4851
    4952private:
     53    JSCustomSQLTransactionCallback(KJS::JSObject* callback, Frame*);
     54
    5055    static void deleteData(void*);
    5156
  • trunk/WebCore/bindings/js/JSCustomSQLTransactionErrorCallback.h

    r29663 r31971  
    4747class JSCustomSQLTransactionErrorCallback : public SQLTransactionErrorCallback {
    4848public:
    49     JSCustomSQLTransactionErrorCallback(KJS::JSObject* callback, Frame*);
     49    static PassRefPtr<JSCustomSQLTransactionErrorCallback> create(KJS::JSObject* callback, Frame* frame) { return adoptRef(new JSCustomSQLTransactionErrorCallback(callback, frame)); }
    5050   
    5151    virtual bool handleEvent(SQLError*);
     52
    5253private:
     54    JSCustomSQLTransactionErrorCallback(KJS::JSObject* callback, Frame*);
     55
    5356    KJS::ProtectedPtr<KJS::JSObject> m_callback;
    5457    RefPtr<Frame> m_frame;
  • trunk/WebCore/bindings/js/JSDatabaseCustom.cpp

    r30787 r31971  
    6161    }
    6262   
    63     RefPtr<SQLTransactionCallback> callback(new JSCustomSQLTransactionCallback(object, frame));
     63    RefPtr<SQLTransactionCallback> callback(JSCustomSQLTransactionCallback::create(object, frame));
    6464   
    6565    RefPtr<SQLTransactionErrorCallback> errorCallback;
     
    7070        }
    7171       
    72         errorCallback = new JSCustomSQLTransactionErrorCallback(object, frame);
     72        errorCallback = JSCustomSQLTransactionErrorCallback::create(object, frame);
    7373    }
    7474   
     
    100100        return jsUndefined();
    101101   
    102     RefPtr<SQLTransactionCallback> callback(new JSCustomSQLTransactionCallback(object, frame));
     102    RefPtr<SQLTransactionCallback> callback(JSCustomSQLTransactionCallback::create(object, frame));
    103103    RefPtr<SQLTransactionErrorCallback> errorCallback;
    104104   
     
    109109        }
    110110
    111         errorCallback = new JSCustomSQLTransactionErrorCallback(object, frame);
     111        errorCallback = JSCustomSQLTransactionErrorCallback::create(object, frame);
    112112    }
    113113
  • trunk/WebCore/bindings/js/JSSQLTransactionCustom.cpp

    r30787 r31971  
    9090       
    9191        if (Frame* frame = toJSDOMWindow(exec->dynamicGlobalObject())->impl()->frame())
    92             callback = new JSCustomSQLStatementCallback(object, frame);
     92            callback = JSCustomSQLStatementCallback::create(object, frame);
    9393    }
    9494   
     
    102102       
    103103        if (Frame* frame = toJSDOMWindow(exec->dynamicGlobalObject())->impl()->frame())
    104             errorCallback = new JSCustomSQLStatementErrorCallback(object, frame);
     104            errorCallback = JSCustomSQLStatementErrorCallback::create(object, frame);
    105105    }
    106106   
  • trunk/WebCore/dom/Document.cpp

    r31801 r31971  
    41124112        // Create the database thread on first request - but not if at least one database was already opened,
    41134113        // because in that case we already had a database thread and terminated it and should not create another.
    4114         m_databaseThread = new DatabaseThread(this);
     4114        m_databaseThread = DatabaseThread::create(this);
    41154115        if (!m_databaseThread->start())
    41164116            m_databaseThread = 0;
  • trunk/WebCore/platform/SecurityOrigin.cpp

    r31405 r31971  
    8484PassRefPtr<SecurityOrigin> SecurityOrigin::create(const String& protocol, const String& host, unsigned short port, SecurityOrigin* ownerFrameOrigin)
    8585{
    86     RefPtr<SecurityOrigin> origin = new SecurityOrigin(protocol, host, port);
     86    RefPtr<SecurityOrigin> origin = adoptRef(new SecurityOrigin(protocol, host, port));
    8787
    8888    // If we do not obtain a meaningful origin from the URL, then we try to find one
  • trunk/WebCore/platform/sql/SQLiteAuthorizer.h

    r30522 r31971  
    2929#define SQLiteAuthorizer_h
    3030
     31#include <wtf/PassRefPtr.h>
    3132#include <wtf/Threading.h>
    3233
     
    4142class SQLiteAuthorizer : public ThreadSafeShared<SQLiteAuthorizer> {
    4243public:
     44    static PassRefPtr<SQLiteAuthorizer> create() { return adoptRef(new SQLiteAuthorizer); }
     45
    4346    virtual ~SQLiteAuthorizer() { }
    4447
     
    8285    virtual int allowFunction(const String& functionName) { return SQLAuthAllow; }
    8386    virtual int allowPragma(const String& pragmaName, const String& firstArgument) { return SQLAuthAllow; }
     87   
     88protected:
     89    SQLiteAuthorizer() { }
    8490};
    8591
  • trunk/WebCore/storage/ChangeVersionWrapper.cpp

    r29663 r31971  
    4747    if (!transaction->database()->getVersionFromDatabase(actualVersion)) {
    4848        LOG_ERROR("Unable to retrieve actual current version from database");
    49         m_sqlError = new SQLError(0, "unable to verify current version of database");
     49        m_sqlError = SQLError::create(0, "unable to verify current version of database");
    5050        return false;
    5151    }
     
    5353    if (actualVersion != m_oldVersion) {
    5454        LOG_ERROR("Old version doesn't match actual version");
    55         m_sqlError = new SQLError(2, "current version of the database and `oldVersion` argument do not match");
     55        m_sqlError = SQLError::create(2, "current version of the database and `oldVersion` argument do not match");
    5656        return false;
    5757    }
     
    6666    if (!transaction->database()->setVersionInDatabase(m_newVersion)) {
    6767        LOG_ERROR("Unable to set new version in database");
    68         m_sqlError = new SQLError(0, "unable to set new version in database");
     68        m_sqlError = SQLError::create(0, "unable to set new version in database");
    6969        return false;
    7070    }
  • trunk/WebCore/storage/ChangeVersionWrapper.h

    r29663 r31971  
    3636class ChangeVersionWrapper : public SQLTransactionWrapper {
    3737public:
    38     ChangeVersionWrapper(const String& oldVersion, const String& newVersion);
     38    static PassRefPtr<ChangeVersionWrapper> create(const String& oldVersion, const String& newVersion) { return adoptRef(new ChangeVersionWrapper(oldVersion, newVersion)); }
    3939
    4040    virtual bool performPreflight(SQLTransaction*);
     
    4242
    4343    virtual SQLError* sqlError() const { return m_sqlError.get(); }
     44
    4445private:
     46    ChangeVersionWrapper(const String& oldVersion, const String& newVersion);
     47
    4548    String m_oldVersion;
    4649    String m_newVersion;
  • trunk/WebCore/storage/Database.cpp

    r31730 r31971  
    175175bool Database::openAndVerifyVersion(ExceptionCode& e)
    176176{
    177     m_databaseAuthorizer = new DatabaseAuthorizer();
    178 
    179     RefPtr<DatabaseOpenTask> task = new DatabaseOpenTask(this);
     177    m_databaseAuthorizer = DatabaseAuthorizer::create();
     178
     179    RefPtr<DatabaseOpenTask> task = DatabaseOpenTask::create(this);
    180180
    181181    task->lockForSynchronousScheduling();
    182     m_document->databaseThread()->scheduleImmediateTask(task.get());
     182    m_document->databaseThread()->scheduleImmediateTask(task);
    183183    task->waitForSynchronousCompletion();
    184184
     
    288288    document()->databaseThread()->unscheduleDatabaseTasks(this);
    289289
    290     RefPtr<DatabaseCloseTask> task = new DatabaseCloseTask(this);
     290    RefPtr<DatabaseCloseTask> task = DatabaseCloseTask::create(this);
    291291
    292292    task->lockForSynchronousScheduling();
    293     m_document->databaseThread()->scheduleImmediateTask(task.get());
     293    m_document->databaseThread()->scheduleImmediateTask(task);
    294294    task->waitForSynchronousCompletion();
    295295}
     
    466466                             PassRefPtr<VoidCallback> successCallback)
    467467{
    468     m_transactionQueue.append(new SQLTransaction(this, callback, errorCallback, successCallback, new ChangeVersionWrapper(oldVersion, newVersion)));
     468    m_transactionQueue.append(SQLTransaction::create(this, callback, errorCallback, successCallback, ChangeVersionWrapper::create(oldVersion, newVersion)));
    469469    MutexLocker locker(m_transactionInProgressMutex);
    470470    if (!m_transactionInProgress)
     
    475475                           PassRefPtr<VoidCallback> successCallback)
    476476{
    477     m_transactionQueue.append(new SQLTransaction(this, callback, errorCallback, successCallback, 0));
     477    m_transactionQueue.append(SQLTransaction::create(this, callback, errorCallback, successCallback, 0));
    478478    MutexLocker locker(m_transactionInProgressMutex);
    479479    if (!m_transactionInProgress)
     
    486486    RefPtr<SQLTransaction> transaction;
    487487    if (m_transactionQueue.tryGetMessage(transaction) && m_document->databaseThread()) {
    488         DatabaseTransactionTask* task = new DatabaseTransactionTask(transaction);
    489         LOG(StorageAPI, "Scheduling DatabaseTransactionTask %p for transaction %p\n", task, task->transaction());
     488        RefPtr<DatabaseTransactionTask> task = DatabaseTransactionTask::create(transaction);
     489        LOG(StorageAPI, "Scheduling DatabaseTransactionTask %p for transaction %p\n", task.get(), task->transaction());
    490490        m_transactionInProgress = true;
    491         m_document->databaseThread()->scheduleTask(task);
     491        m_document->databaseThread()->scheduleTask(task.release());
    492492    } else
    493493        m_transactionInProgress = false;
     
    497497{
    498498    if (m_document->databaseThread()) {
    499         DatabaseTransactionTask* task = new DatabaseTransactionTask(transaction);
    500         LOG(StorageAPI, "Scheduling DatabaseTransactionTask %p for the transaction step\n", task);
    501         m_document->databaseThread()->scheduleTask(task);
     499        RefPtr<DatabaseTransactionTask> task = DatabaseTransactionTask::create(transaction);
     500        LOG(StorageAPI, "Scheduling DatabaseTransactionTask %p for the transaction step\n", task.get());
     501        m_document->databaseThread()->scheduleTask(task.release());
    502502    }
    503503}
     
    555555Vector<String> Database::tableNames()
    556556{
    557     RefPtr<DatabaseTableNamesTask> task = new DatabaseTableNamesTask(this);
     557    RefPtr<DatabaseTableNamesTask> task = DatabaseTableNamesTask::create(this);
    558558
    559559    task->lockForSynchronousScheduling();
    560     m_document->databaseThread()->scheduleImmediateTask(task.get());
     560    m_document->databaseThread()->scheduleImmediateTask(task);
    561561    task->waitForSynchronousCompletion();
    562562
  • trunk/WebCore/storage/DatabaseAuthorizer.h

    r29663 r31971  
    3535class DatabaseAuthorizer : public SQLiteAuthorizer {
    3636public:
    37     DatabaseAuthorizer();
     37    static PassRefPtr<DatabaseAuthorizer> create() { return adoptRef(new DatabaseAuthorizer); }
    3838
    3939    virtual int createTable(const String& tableName);
     
    7878    bool lastActionWasInsert() const { return m_lastActionWasInsert; }
    7979    bool lastActionChangedDatabase() const { return m_lastActionChangedDatabase; }
     80
    8081private:
     82    DatabaseAuthorizer();
    8183    int denyBasedOnTableName(const String&);
     84
    8285    bool m_securityEnabled;
    8386    bool m_lastActionWasInsert;
  • trunk/WebCore/storage/DatabaseTask.h

    r30522 r31971  
    7979{
    8080public:
    81     DatabaseOpenTask(Database*);
     81    static PassRefPtr<DatabaseOpenTask> create(Database* db) { return adoptRef(new DatabaseOpenTask(db)); }
    8282
    8383    ExceptionCode exceptionCode() const { return m_code; }
     
    8585
    8686private:
     87    DatabaseOpenTask(Database*);
     88
    8789    virtual void doPerformTask();
    8890#ifndef NDEBUG
     
    9799{
    98100public:
     101    static PassRefPtr<DatabaseCloseTask> create(Database* db) { return adoptRef(new DatabaseCloseTask(db)); }
     102
     103private:
    99104    DatabaseCloseTask(Database*);
    100105
    101 private:
    102106    virtual void doPerformTask();
    103107#ifndef NDEBUG
     
    109113{
    110114public:
    111     DatabaseTransactionTask(PassRefPtr<SQLTransaction>);
     115    static PassRefPtr<DatabaseTransactionTask> create(PassRefPtr<SQLTransaction> transaction) { return adoptRef(new DatabaseTransactionTask(transaction)); }
     116
    112117    SQLTransaction* transaction() const { return m_transaction.get(); }
    113118
    114119    virtual ~DatabaseTransactionTask();
    115120private:
     121    DatabaseTransactionTask(PassRefPtr<SQLTransaction>);
     122
    116123    virtual void doPerformTask();
    117124#ifndef NDEBUG
     
    125132{
    126133public:
    127     DatabaseTableNamesTask(Database*);
     134    static PassRefPtr<DatabaseTableNamesTask> create(Database* db) { return adoptRef(new DatabaseTableNamesTask(db)); }
    128135
    129136    Vector<String>& tableNames() { return m_tableNames; }
    130137
    131138private:
     139    DatabaseTableNamesTask(Database*);
     140
    132141    virtual void doPerformTask();
    133142#ifndef NDEBUG
  • trunk/WebCore/storage/DatabaseThread.cpp

    r30331 r31971  
    100100}
    101101
    102 void DatabaseThread::scheduleTask(DatabaseTask* task)
     102void DatabaseThread::scheduleTask(PassRefPtr<DatabaseTask> task)
    103103{
    104104    m_queue.append(task);
    105105}
    106106
    107 void DatabaseThread::scheduleImmediateTask(DatabaseTask* task)
     107void DatabaseThread::scheduleImmediateTask(PassRefPtr<DatabaseTask> task)
    108108{
    109109    m_queue.prepend(task);
  • trunk/WebCore/storage/DatabaseThread.h

    r30522 r31971  
    2929#define DatabaseThread_h
    3030
    31 #include <wtf/MessageQueue.h>
    32 
     31#include <wtf/Deque.h>
    3332#include <wtf/HashMap.h>
    3433#include <wtf/HashSet.h>
    35 #include <wtf/Deque.h>
     34#include <wtf/MessageQueue.h>
     35#include <wtf/PassRefPtr.h>
    3636#include <wtf/RefPtr.h>
    3737
     
    4545{
    4646public:
    47     DatabaseThread(Document*);
     47    static PassRefPtr<DatabaseThread> create(Document* doc) { return adoptRef(new DatabaseThread(doc)); }
    4848    ~DatabaseThread();
    4949
     
    5252    bool terminationRequested() const;
    5353
    54     void scheduleTask(DatabaseTask*);
    55     void scheduleImmediateTask(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.
     54    void scheduleTask(PassRefPtr<DatabaseTask>);
     55    void scheduleImmediateTask(PassRefPtr<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.
    5656    void unscheduleDatabaseTasks(Database*);
    5757
    5858private:
     59    DatabaseThread(Document*);
     60
    5961    static void* databaseThreadStart(void*);
    6062    void* databaseThread();
  • trunk/WebCore/storage/SQLError.h

    r30522 r31971  
    3737class SQLError : public ThreadSafeShared<SQLError> {
    3838public:
    39     SQLError(unsigned code, const String& message) : m_code(code), m_message(message.copy()) { }
     39    static PassRefPtr<SQLError> create(unsigned code, const String& message) { return adoptRef(new SQLError(code, message)); }
     40
    4041    unsigned code() const { return m_code; }
    4142    String message() const { return m_message.copy(); }
    4243   
    4344private:
     45    SQLError(unsigned code, const String& message) : m_code(code), m_message(message.copy()) { }
    4446    unsigned m_code;
    4547    String m_message;
  • trunk/WebCore/storage/SQLResultSet.h

    r30522 r31971  
    3939class SQLResultSet : public ThreadSafeShared<SQLResultSet> {
    4040public:
    41     SQLResultSet();
     41    static PassRefPtr<SQLResultSet> create() { return adoptRef(new SQLResultSet); }
    4242
    4343    SQLResultSetRowList* rows() const;
     
    5151
    5252private:
     53    SQLResultSet();
     54
    5355    RefPtr<SQLResultSetRowList> m_rows;
    5456    int64_t m_insertId;
  • trunk/WebCore/storage/SQLStatement.cpp

    r30104 r31971  
    4343namespace WebCore {
    4444
     45PassRefPtr<SQLStatement> SQLStatement::create(const String& statement, const Vector<SQLValue>& arguments, PassRefPtr<SQLStatementCallback> callback, PassRefPtr<SQLStatementErrorCallback> errorCallback)
     46{
     47    return adoptRef(new SQLStatement(statement, arguments, callback, errorCallback));
     48}
     49
    4550SQLStatement::SQLStatement(const String& statement, const Vector<SQLValue>& arguments, PassRefPtr<SQLStatementCallback> callback, PassRefPtr<SQLStatementErrorCallback> errorCallback)
    4651    : m_statement(statement.copy())
     
    7075    if (result != SQLResultOk) {
    7176        LOG(StorageAPI, "Unable to verify correctness of statement %s - error %i (%s)", m_statement.ascii().data(), result, database->lastErrorMsg());
    72         m_error = new SQLError(1, database->lastErrorMsg());
     77        m_error = SQLError::create(1, database->lastErrorMsg());
    7378        return false;
    7479    }
     
    7883    if (statement.bindParameterCount() != m_arguments.size()) {
    7984        LOG(StorageAPI, "Bind parameter count doesn't match number of question marks");
    80         m_error = new SQLError(1, "number of '?'s in statement string does not match argument count");
     85        m_error = SQLError::create(1, "number of '?'s in statement string does not match argument count");
    8186        return false;
    8287    }
     
    9196        if (result != SQLResultOk) {
    9297            LOG(StorageAPI, "Failed to bind value index %i to statement for query '%s'", i + 1, m_statement.ascii().data());
    93             m_error = new SQLError(1, database->lastErrorMsg());
     98            m_error = SQLError::create(1, database->lastErrorMsg());
    9499            return false;
    95100        }
    96101    }
    97102
    98     RefPtr<SQLResultSet> resultSet = new SQLResultSet;
     103    RefPtr<SQLResultSet> resultSet = SQLResultSet::create();
    99104
    100105    // Step so we can fetch the column names.
     
    115120
    116121        if (result != SQLResultDone) {
    117             m_error = new SQLError(1, database->lastErrorMsg());
     122            m_error = SQLError::create(1, database->lastErrorMsg());
    118123            return false;
    119124        }
     
    127132        return false;
    128133    } else {
    129         m_error = new SQLError(1, database->lastErrorMsg());
     134        m_error = SQLError::create(1, database->lastErrorMsg());
    130135        return false;
    131136    }
     
    143148{
    144149    ASSERT(!m_error && !m_resultSet);
    145     m_error = new SQLError(0, "unable to execute statement, because the user deleted the database");
     150    m_error = SQLError::create(0, "unable to execute statement, because the user deleted the database");
    146151}
    147152
     
    149154{
    150155    ASSERT(!m_error && !m_resultSet);
    151     m_error = new SQLError(2, "current version of the database and `oldVersion` argument do not match");
     156    m_error = SQLError::create(2, "current version of the database and `oldVersion` argument do not match");
    152157}
    153158
     
    176181{
    177182    ASSERT(!m_error && !m_resultSet);
    178     m_error = new SQLError(4, "there was not enough remaining storage space, or the storage quota was reached and the user declined to allow more space");
     183    m_error = SQLError::create(4, "there was not enough remaining storage space, or the storage quota was reached and the user declined to allow more space");
    179184}
    180185
  • trunk/WebCore/storage/SQLStatement.h

    r30522 r31971  
    5050class SQLStatement : public ThreadSafeShared<SQLStatement> {
    5151public:
    52     SQLStatement(const String& statement, const Vector<SQLValue>& arguments, PassRefPtr<SQLStatementCallback> callback, PassRefPtr<SQLStatementErrorCallback> errorCallback);
     52    static PassRefPtr<SQLStatement> create(const String&, const Vector<SQLValue>&, PassRefPtr<SQLStatementCallback>, PassRefPtr<SQLStatementErrorCallback>);
    5353   
    5454    bool execute(Database*);
     
    6565    SQLError* sqlError() const { return m_error.get(); }
    6666private:
     67    SQLStatement(const String& statement, const Vector<SQLValue>& arguments, PassRefPtr<SQLStatementCallback> callback, PassRefPtr<SQLStatementErrorCallback> errorCallback);
     68
    6769    void setFailureDueToQuota();
    6870    void clearFailureDueToQuota();
  • trunk/WebCore/storage/SQLTransaction.cpp

    r30811 r31971  
    5757namespace WebCore {
    5858
     59PassRefPtr<SQLTransaction> SQLTransaction::create(Database* db, PassRefPtr<SQLTransactionCallback> callback, PassRefPtr<SQLTransactionErrorCallback> errorCallback,
     60                                           PassRefPtr<VoidCallback> successCallback, PassRefPtr<SQLTransactionWrapper> wrapper)
     61{
     62    return adoptRef(new SQLTransaction(db, callback, errorCallback, successCallback, wrapper));
     63}
     64
    5965SQLTransaction::SQLTransaction(Database* db, PassRefPtr<SQLTransactionCallback> callback, PassRefPtr<SQLTransactionErrorCallback> errorCallback, PassRefPtr<VoidCallback> successCallback,
    6066                               PassRefPtr<SQLTransactionWrapper> wrapper)
     
    8490    }
    8591   
    86     RefPtr<SQLStatement> statement = new SQLStatement(sqlStatement.copy(), arguments, callback, callbackError);
     92    RefPtr<SQLStatement> statement = SQLStatement::create(sqlStatement.copy(), arguments, callback, callbackError);
    8793
    8894    if (m_database->deleted())
     
    191197    // If the database was deleted, jump to the error callback
    192198    if (m_database->deleted()) {
    193         m_transactionError = new SQLError(0, "unable to open a transaction, because the user deleted the database");
     199        m_transactionError = SQLError::create(0, "unable to open a transaction, because the user deleted the database");
    194200        handleTransactionError(false);
    195201        return;
     
    210216        ASSERT(!m_database->m_sqliteDatabase.transactionInProgress());
    211217        m_sqliteTransaction.clear();
    212         m_transactionError = new SQLError(0, "unable to open a transaction to the database");
     218        m_transactionError = SQLError::create(0, "unable to open a transaction to the database");
    213219        handleTransactionError(false);
    214220        return;
     
    221227        m_transactionError = m_wrapper->sqlError();
    222228        if (!m_transactionError)
    223             m_transactionError = new SQLError(0, "unknown error occured setting up transaction");
     229            m_transactionError = SQLError::create(0, "unknown error occured setting up transaction");
    224230
    225231        handleTransactionError(false);
     
    246252    // Transaction Step 5 - If the transaction callback was null or raised an exception, jump to the error callback
    247253    if (shouldDeliverErrorCallback) {
    248         m_transactionError = new SQLError(0, "the SQLTransactionCallback was null or threw an exception");
     254        m_transactionError = SQLError::create(0, "the SQLTransactionCallback was null or threw an exception");
    249255        deliverTransactionErrorCallback();
    250256    } else
     
    352358        m_transactionError = m_currentStatement->sqlError();
    353359        if (!m_transactionError)
    354             m_transactionError = new SQLError(1, "the statement failed to execute");
     360            m_transactionError = SQLError::create(1, "the statement failed to execute");
    355361        handleTransactionError(false);
    356362    }
     
    368374
    369375    if (result) {
    370         m_transactionError = new SQLError(0, "the statement callback raised an exception or statement error callback did not return false");
     376        m_transactionError = SQLError::create(0, "the statement callback raised an exception or statement error callback did not return false");
    371377        handleTransactionError(true);
    372378    } else
     
    403409        m_transactionError = m_wrapper->sqlError();
    404410        if (!m_transactionError)
    405             m_transactionError = new SQLError(0, "unknown error occured setting up transaction");
     411            m_transactionError = SQLError::create(0, "unknown error occured setting up transaction");
    406412        handleTransactionError(false);
    407413        return;
     
    418424    if (m_sqliteTransaction->inProgress()) {
    419425        m_shouldCommitAfterErrorCallback = false;
    420         m_transactionError = new SQLError(0, "failed to commit the transaction");
     426        m_transactionError = SQLError::create(0, "failed to commit the transaction");
    421427        handleTransactionError(false);
    422428        return;
  • trunk/WebCore/storage/SQLTransaction.h

    r30811 r31971  
    6565class SQLTransaction : public ThreadSafeShared<SQLTransaction> {
    6666public:
    67     SQLTransaction(Database*, PassRefPtr<SQLTransactionCallback>, PassRefPtr<SQLTransactionErrorCallback>, PassRefPtr<VoidCallback>, PassRefPtr<SQLTransactionWrapper>);
     67    static PassRefPtr<SQLTransaction> create(Database*, PassRefPtr<SQLTransactionCallback>, PassRefPtr<SQLTransactionErrorCallback>, PassRefPtr<VoidCallback>, PassRefPtr<SQLTransactionWrapper>);
     68
    6869    ~SQLTransaction();
    6970   
     
    7778
    7879private:
     80    SQLTransaction(Database*, PassRefPtr<SQLTransactionCallback>, PassRefPtr<SQLTransactionErrorCallback>, PassRefPtr<VoidCallback>, PassRefPtr<SQLTransactionWrapper>);
     81
    7982    typedef void (SQLTransaction::*TransactionStepMethod)();
    8083    TransactionStepMethod m_nextStep;
Note: See TracChangeset for help on using the changeset viewer.