Changeset 31971 in webkit
- Timestamp:
- Apr 16, 2008 4:25:13 PM (16 years ago)
- Location:
- trunk
- Files:
-
- 25 edited
Legend:
- Unmodified
- Added
- Removed
-
trunk/JavaScriptCore/ChangeLog
r31962 r31971 1 2008-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 1 10 2008-04-16 Sam Weinig <sam@webkit.org> 2 11 -
trunk/JavaScriptCore/wtf/Threading.h
r31690 r31971 191 191 template<class T> class ThreadSafeShared : Noncopyable { 192 192 public: 193 ThreadSafeShared( )194 : m_refCount( 0)193 ThreadSafeShared(int initialRefCount = 1) 194 : m_refCount(initialRefCount) 195 195 { 196 196 } -
trunk/WebCore/ChangeLog
r31970 r31971 1 2008-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 1 89 2008-04-16 Anders Carlsson <andersca@apple.com> 2 90 -
trunk/WebCore/bindings/js/JSCustomSQLStatementCallback.h
r29663 r31971 47 47 class JSCustomSQLStatementCallback : public SQLStatementCallback { 48 48 public: 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 53 private: 49 54 JSCustomSQLStatementCallback(KJS::JSObject* callback, Frame*); 50 51 virtual void handleEvent(SQLTransaction*, SQLResultSet*, bool& raisedException); 52 private: 55 53 56 KJS::ProtectedPtr<KJS::JSObject> m_callback; 54 57 RefPtr<Frame> m_frame; -
trunk/WebCore/bindings/js/JSCustomSQLStatementErrorCallback.h
r29663 r31971 47 47 class JSCustomSQLStatementErrorCallback : public SQLStatementErrorCallback { 48 48 public: 49 JSCustomSQLStatementErrorCallback(KJS::JSObject* callback, Frame*);49 static PassRefPtr<JSCustomSQLStatementErrorCallback> create(KJS::JSObject* callback, Frame* frame) { return adoptRef(new JSCustomSQLStatementErrorCallback(callback, frame)); } 50 50 51 51 virtual bool handleEvent(SQLTransaction*, SQLError*); 52 52 53 private: 54 JSCustomSQLStatementErrorCallback(KJS::JSObject* callback, Frame*); 55 53 56 KJS::ProtectedPtr<KJS::JSObject> m_callback; 54 57 RefPtr<Frame> m_frame; -
trunk/WebCore/bindings/js/JSCustomSQLTransactionCallback.h
r29966 r31971 32 32 #include "SQLTransactionCallback.h" 33 33 34 #include <wtf/PassRefPtr.h> 35 34 36 namespace KJS { 35 37 class JSObject; … … 42 44 class JSCustomSQLTransactionCallback : public SQLTransactionCallback { 43 45 public: 44 JSCustomSQLTransactionCallback(KJS::JSObject* callback, Frame*); 46 static PassRefPtr<JSCustomSQLTransactionCallback> create(KJS::JSObject* callback, Frame* frame) { return adoptRef(new JSCustomSQLTransactionCallback(callback, frame)); } 47 45 48 virtual ~JSCustomSQLTransactionCallback(); 46 49 … … 48 51 49 52 private: 53 JSCustomSQLTransactionCallback(KJS::JSObject* callback, Frame*); 54 50 55 static void deleteData(void*); 51 56 -
trunk/WebCore/bindings/js/JSCustomSQLTransactionErrorCallback.h
r29663 r31971 47 47 class JSCustomSQLTransactionErrorCallback : public SQLTransactionErrorCallback { 48 48 public: 49 JSCustomSQLTransactionErrorCallback(KJS::JSObject* callback, Frame*);49 static PassRefPtr<JSCustomSQLTransactionErrorCallback> create(KJS::JSObject* callback, Frame* frame) { return adoptRef(new JSCustomSQLTransactionErrorCallback(callback, frame)); } 50 50 51 51 virtual bool handleEvent(SQLError*); 52 52 53 private: 54 JSCustomSQLTransactionErrorCallback(KJS::JSObject* callback, Frame*); 55 53 56 KJS::ProtectedPtr<KJS::JSObject> m_callback; 54 57 RefPtr<Frame> m_frame; -
trunk/WebCore/bindings/js/JSDatabaseCustom.cpp
r30787 r31971 61 61 } 62 62 63 RefPtr<SQLTransactionCallback> callback( new JSCustomSQLTransactionCallback(object, frame));63 RefPtr<SQLTransactionCallback> callback(JSCustomSQLTransactionCallback::create(object, frame)); 64 64 65 65 RefPtr<SQLTransactionErrorCallback> errorCallback; … … 70 70 } 71 71 72 errorCallback = new JSCustomSQLTransactionErrorCallback(object, frame);72 errorCallback = JSCustomSQLTransactionErrorCallback::create(object, frame); 73 73 } 74 74 … … 100 100 return jsUndefined(); 101 101 102 RefPtr<SQLTransactionCallback> callback( new JSCustomSQLTransactionCallback(object, frame));102 RefPtr<SQLTransactionCallback> callback(JSCustomSQLTransactionCallback::create(object, frame)); 103 103 RefPtr<SQLTransactionErrorCallback> errorCallback; 104 104 … … 109 109 } 110 110 111 errorCallback = new JSCustomSQLTransactionErrorCallback(object, frame);111 errorCallback = JSCustomSQLTransactionErrorCallback::create(object, frame); 112 112 } 113 113 -
trunk/WebCore/bindings/js/JSSQLTransactionCustom.cpp
r30787 r31971 90 90 91 91 if (Frame* frame = toJSDOMWindow(exec->dynamicGlobalObject())->impl()->frame()) 92 callback = new JSCustomSQLStatementCallback(object, frame);92 callback = JSCustomSQLStatementCallback::create(object, frame); 93 93 } 94 94 … … 102 102 103 103 if (Frame* frame = toJSDOMWindow(exec->dynamicGlobalObject())->impl()->frame()) 104 errorCallback = new JSCustomSQLStatementErrorCallback(object, frame);104 errorCallback = JSCustomSQLStatementErrorCallback::create(object, frame); 105 105 } 106 106 -
trunk/WebCore/dom/Document.cpp
r31801 r31971 4112 4112 // Create the database thread on first request - but not if at least one database was already opened, 4113 4113 // 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); 4115 4115 if (!m_databaseThread->start()) 4116 4116 m_databaseThread = 0; -
trunk/WebCore/platform/SecurityOrigin.cpp
r31405 r31971 84 84 PassRefPtr<SecurityOrigin> SecurityOrigin::create(const String& protocol, const String& host, unsigned short port, SecurityOrigin* ownerFrameOrigin) 85 85 { 86 RefPtr<SecurityOrigin> origin = new SecurityOrigin(protocol, host, port);86 RefPtr<SecurityOrigin> origin = adoptRef(new SecurityOrigin(protocol, host, port)); 87 87 88 88 // 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 29 29 #define SQLiteAuthorizer_h 30 30 31 #include <wtf/PassRefPtr.h> 31 32 #include <wtf/Threading.h> 32 33 … … 41 42 class SQLiteAuthorizer : public ThreadSafeShared<SQLiteAuthorizer> { 42 43 public: 44 static PassRefPtr<SQLiteAuthorizer> create() { return adoptRef(new SQLiteAuthorizer); } 45 43 46 virtual ~SQLiteAuthorizer() { } 44 47 … … 82 85 virtual int allowFunction(const String& functionName) { return SQLAuthAllow; } 83 86 virtual int allowPragma(const String& pragmaName, const String& firstArgument) { return SQLAuthAllow; } 87 88 protected: 89 SQLiteAuthorizer() { } 84 90 }; 85 91 -
trunk/WebCore/storage/ChangeVersionWrapper.cpp
r29663 r31971 47 47 if (!transaction->database()->getVersionFromDatabase(actualVersion)) { 48 48 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"); 50 50 return false; 51 51 } … … 53 53 if (actualVersion != m_oldVersion) { 54 54 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"); 56 56 return false; 57 57 } … … 66 66 if (!transaction->database()->setVersionInDatabase(m_newVersion)) { 67 67 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"); 69 69 return false; 70 70 } -
trunk/WebCore/storage/ChangeVersionWrapper.h
r29663 r31971 36 36 class ChangeVersionWrapper : public SQLTransactionWrapper { 37 37 public: 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)); } 39 39 40 40 virtual bool performPreflight(SQLTransaction*); … … 42 42 43 43 virtual SQLError* sqlError() const { return m_sqlError.get(); } 44 44 45 private: 46 ChangeVersionWrapper(const String& oldVersion, const String& newVersion); 47 45 48 String m_oldVersion; 46 49 String m_newVersion; -
trunk/WebCore/storage/Database.cpp
r31730 r31971 175 175 bool Database::openAndVerifyVersion(ExceptionCode& e) 176 176 { 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); 180 180 181 181 task->lockForSynchronousScheduling(); 182 m_document->databaseThread()->scheduleImmediateTask(task .get());182 m_document->databaseThread()->scheduleImmediateTask(task); 183 183 task->waitForSynchronousCompletion(); 184 184 … … 288 288 document()->databaseThread()->unscheduleDatabaseTasks(this); 289 289 290 RefPtr<DatabaseCloseTask> task = new DatabaseCloseTask(this);290 RefPtr<DatabaseCloseTask> task = DatabaseCloseTask::create(this); 291 291 292 292 task->lockForSynchronousScheduling(); 293 m_document->databaseThread()->scheduleImmediateTask(task .get());293 m_document->databaseThread()->scheduleImmediateTask(task); 294 294 task->waitForSynchronousCompletion(); 295 295 } … … 466 466 PassRefPtr<VoidCallback> successCallback) 467 467 { 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))); 469 469 MutexLocker locker(m_transactionInProgressMutex); 470 470 if (!m_transactionInProgress) … … 475 475 PassRefPtr<VoidCallback> successCallback) 476 476 { 477 m_transactionQueue.append( new SQLTransaction(this, callback, errorCallback, successCallback, 0));477 m_transactionQueue.append(SQLTransaction::create(this, callback, errorCallback, successCallback, 0)); 478 478 MutexLocker locker(m_transactionInProgressMutex); 479 479 if (!m_transactionInProgress) … … 486 486 RefPtr<SQLTransaction> transaction; 487 487 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()); 490 490 m_transactionInProgress = true; 491 m_document->databaseThread()->scheduleTask(task );491 m_document->databaseThread()->scheduleTask(task.release()); 492 492 } else 493 493 m_transactionInProgress = false; … … 497 497 { 498 498 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()); 502 502 } 503 503 } … … 555 555 Vector<String> Database::tableNames() 556 556 { 557 RefPtr<DatabaseTableNamesTask> task = new DatabaseTableNamesTask(this);557 RefPtr<DatabaseTableNamesTask> task = DatabaseTableNamesTask::create(this); 558 558 559 559 task->lockForSynchronousScheduling(); 560 m_document->databaseThread()->scheduleImmediateTask(task .get());560 m_document->databaseThread()->scheduleImmediateTask(task); 561 561 task->waitForSynchronousCompletion(); 562 562 -
trunk/WebCore/storage/DatabaseAuthorizer.h
r29663 r31971 35 35 class DatabaseAuthorizer : public SQLiteAuthorizer { 36 36 public: 37 DatabaseAuthorizer();37 static PassRefPtr<DatabaseAuthorizer> create() { return adoptRef(new DatabaseAuthorizer); } 38 38 39 39 virtual int createTable(const String& tableName); … … 78 78 bool lastActionWasInsert() const { return m_lastActionWasInsert; } 79 79 bool lastActionChangedDatabase() const { return m_lastActionChangedDatabase; } 80 80 81 private: 82 DatabaseAuthorizer(); 81 83 int denyBasedOnTableName(const String&); 84 82 85 bool m_securityEnabled; 83 86 bool m_lastActionWasInsert; -
trunk/WebCore/storage/DatabaseTask.h
r30522 r31971 79 79 { 80 80 public: 81 DatabaseOpenTask(Database*);81 static PassRefPtr<DatabaseOpenTask> create(Database* db) { return adoptRef(new DatabaseOpenTask(db)); } 82 82 83 83 ExceptionCode exceptionCode() const { return m_code; } … … 85 85 86 86 private: 87 DatabaseOpenTask(Database*); 88 87 89 virtual void doPerformTask(); 88 90 #ifndef NDEBUG … … 97 99 { 98 100 public: 101 static PassRefPtr<DatabaseCloseTask> create(Database* db) { return adoptRef(new DatabaseCloseTask(db)); } 102 103 private: 99 104 DatabaseCloseTask(Database*); 100 105 101 private:102 106 virtual void doPerformTask(); 103 107 #ifndef NDEBUG … … 109 113 { 110 114 public: 111 DatabaseTransactionTask(PassRefPtr<SQLTransaction>); 115 static PassRefPtr<DatabaseTransactionTask> create(PassRefPtr<SQLTransaction> transaction) { return adoptRef(new DatabaseTransactionTask(transaction)); } 116 112 117 SQLTransaction* transaction() const { return m_transaction.get(); } 113 118 114 119 virtual ~DatabaseTransactionTask(); 115 120 private: 121 DatabaseTransactionTask(PassRefPtr<SQLTransaction>); 122 116 123 virtual void doPerformTask(); 117 124 #ifndef NDEBUG … … 125 132 { 126 133 public: 127 DatabaseTableNamesTask(Database*);134 static PassRefPtr<DatabaseTableNamesTask> create(Database* db) { return adoptRef(new DatabaseTableNamesTask(db)); } 128 135 129 136 Vector<String>& tableNames() { return m_tableNames; } 130 137 131 138 private: 139 DatabaseTableNamesTask(Database*); 140 132 141 virtual void doPerformTask(); 133 142 #ifndef NDEBUG -
trunk/WebCore/storage/DatabaseThread.cpp
r30331 r31971 100 100 } 101 101 102 void DatabaseThread::scheduleTask( DatabaseTask*task)102 void DatabaseThread::scheduleTask(PassRefPtr<DatabaseTask> task) 103 103 { 104 104 m_queue.append(task); 105 105 } 106 106 107 void DatabaseThread::scheduleImmediateTask( DatabaseTask*task)107 void DatabaseThread::scheduleImmediateTask(PassRefPtr<DatabaseTask> task) 108 108 { 109 109 m_queue.prepend(task); -
trunk/WebCore/storage/DatabaseThread.h
r30522 r31971 29 29 #define DatabaseThread_h 30 30 31 #include <wtf/MessageQueue.h> 32 31 #include <wtf/Deque.h> 33 32 #include <wtf/HashMap.h> 34 33 #include <wtf/HashSet.h> 35 #include <wtf/Deque.h> 34 #include <wtf/MessageQueue.h> 35 #include <wtf/PassRefPtr.h> 36 36 #include <wtf/RefPtr.h> 37 37 … … 45 45 { 46 46 public: 47 DatabaseThread(Document*);47 static PassRefPtr<DatabaseThread> create(Document* doc) { return adoptRef(new DatabaseThread(doc)); } 48 48 ~DatabaseThread(); 49 49 … … 52 52 bool terminationRequested() const; 53 53 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. 56 56 void unscheduleDatabaseTasks(Database*); 57 57 58 58 private: 59 DatabaseThread(Document*); 60 59 61 static void* databaseThreadStart(void*); 60 62 void* databaseThread(); -
trunk/WebCore/storage/SQLError.h
r30522 r31971 37 37 class SQLError : public ThreadSafeShared<SQLError> { 38 38 public: 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 40 41 unsigned code() const { return m_code; } 41 42 String message() const { return m_message.copy(); } 42 43 43 44 private: 45 SQLError(unsigned code, const String& message) : m_code(code), m_message(message.copy()) { } 44 46 unsigned m_code; 45 47 String m_message; -
trunk/WebCore/storage/SQLResultSet.h
r30522 r31971 39 39 class SQLResultSet : public ThreadSafeShared<SQLResultSet> { 40 40 public: 41 SQLResultSet();41 static PassRefPtr<SQLResultSet> create() { return adoptRef(new SQLResultSet); } 42 42 43 43 SQLResultSetRowList* rows() const; … … 51 51 52 52 private: 53 SQLResultSet(); 54 53 55 RefPtr<SQLResultSetRowList> m_rows; 54 56 int64_t m_insertId; -
trunk/WebCore/storage/SQLStatement.cpp
r30104 r31971 43 43 namespace WebCore { 44 44 45 PassRefPtr<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 45 50 SQLStatement::SQLStatement(const String& statement, const Vector<SQLValue>& arguments, PassRefPtr<SQLStatementCallback> callback, PassRefPtr<SQLStatementErrorCallback> errorCallback) 46 51 : m_statement(statement.copy()) … … 70 75 if (result != SQLResultOk) { 71 76 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()); 73 78 return false; 74 79 } … … 78 83 if (statement.bindParameterCount() != m_arguments.size()) { 79 84 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"); 81 86 return false; 82 87 } … … 91 96 if (result != SQLResultOk) { 92 97 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()); 94 99 return false; 95 100 } 96 101 } 97 102 98 RefPtr<SQLResultSet> resultSet = new SQLResultSet;103 RefPtr<SQLResultSet> resultSet = SQLResultSet::create(); 99 104 100 105 // Step so we can fetch the column names. … … 115 120 116 121 if (result != SQLResultDone) { 117 m_error = new SQLError(1, database->lastErrorMsg());122 m_error = SQLError::create(1, database->lastErrorMsg()); 118 123 return false; 119 124 } … … 127 132 return false; 128 133 } else { 129 m_error = new SQLError(1, database->lastErrorMsg());134 m_error = SQLError::create(1, database->lastErrorMsg()); 130 135 return false; 131 136 } … … 143 148 { 144 149 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"); 146 151 } 147 152 … … 149 154 { 150 155 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"); 152 157 } 153 158 … … 176 181 { 177 182 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"); 179 184 } 180 185 -
trunk/WebCore/storage/SQLStatement.h
r30522 r31971 50 50 class SQLStatement : public ThreadSafeShared<SQLStatement> { 51 51 public: 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>); 53 53 54 54 bool execute(Database*); … … 65 65 SQLError* sqlError() const { return m_error.get(); } 66 66 private: 67 SQLStatement(const String& statement, const Vector<SQLValue>& arguments, PassRefPtr<SQLStatementCallback> callback, PassRefPtr<SQLStatementErrorCallback> errorCallback); 68 67 69 void setFailureDueToQuota(); 68 70 void clearFailureDueToQuota(); -
trunk/WebCore/storage/SQLTransaction.cpp
r30811 r31971 57 57 namespace WebCore { 58 58 59 PassRefPtr<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 59 65 SQLTransaction::SQLTransaction(Database* db, PassRefPtr<SQLTransactionCallback> callback, PassRefPtr<SQLTransactionErrorCallback> errorCallback, PassRefPtr<VoidCallback> successCallback, 60 66 PassRefPtr<SQLTransactionWrapper> wrapper) … … 84 90 } 85 91 86 RefPtr<SQLStatement> statement = new SQLStatement(sqlStatement.copy(), arguments, callback, callbackError);92 RefPtr<SQLStatement> statement = SQLStatement::create(sqlStatement.copy(), arguments, callback, callbackError); 87 93 88 94 if (m_database->deleted()) … … 191 197 // If the database was deleted, jump to the error callback 192 198 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"); 194 200 handleTransactionError(false); 195 201 return; … … 210 216 ASSERT(!m_database->m_sqliteDatabase.transactionInProgress()); 211 217 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"); 213 219 handleTransactionError(false); 214 220 return; … … 221 227 m_transactionError = m_wrapper->sqlError(); 222 228 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"); 224 230 225 231 handleTransactionError(false); … … 246 252 // Transaction Step 5 - If the transaction callback was null or raised an exception, jump to the error callback 247 253 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"); 249 255 deliverTransactionErrorCallback(); 250 256 } else … … 352 358 m_transactionError = m_currentStatement->sqlError(); 353 359 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"); 355 361 handleTransactionError(false); 356 362 } … … 368 374 369 375 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"); 371 377 handleTransactionError(true); 372 378 } else … … 403 409 m_transactionError = m_wrapper->sqlError(); 404 410 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"); 406 412 handleTransactionError(false); 407 413 return; … … 418 424 if (m_sqliteTransaction->inProgress()) { 419 425 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"); 421 427 handleTransactionError(false); 422 428 return; -
trunk/WebCore/storage/SQLTransaction.h
r30811 r31971 65 65 class SQLTransaction : public ThreadSafeShared<SQLTransaction> { 66 66 public: 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 68 69 ~SQLTransaction(); 69 70 … … 77 78 78 79 private: 80 SQLTransaction(Database*, PassRefPtr<SQLTransactionCallback>, PassRefPtr<SQLTransactionErrorCallback>, PassRefPtr<VoidCallback>, PassRefPtr<SQLTransactionWrapper>); 81 79 82 typedef void (SQLTransaction::*TransactionStepMethod)(); 80 83 TransactionStepMethod m_nextStep;
Note: See TracChangeset
for help on using the changeset viewer.