Update To 11.40.268.0

[platform/framework/web/crosswalk.git] / src / third_party / WebKit / Source / modules / webdatabase / Database.cpp

diff --git a/src/third_party/WebKit/Source/modules/webdatabase/Database.cpp b/src/third_party/WebKit/Source/modules/webdatabase/Database.cpp
index 869cd01..f4cd066 100644 (file)
--- a/src/third_party/WebKit/Source/modules/webdatabase/Database.cpp
+++ b/src/third_party/WebKit/Source/modules/webdatabase/Database.cpp
@@ -282,7 +282,7 @@ void Database::close()
         // Clean up transactions that have not been scheduled yet:
         // Transaction phase 1 cleanup. See comment on "What happens if a
         // transaction is interrupted?" at the top of SQLTransactionBackend.cpp.
-        RefPtrWillBeRawPtr<SQLTransactionBackend> transaction = nullptr;
+        SQLTransactionBackend* transaction = nullptr;
         while (!m_transactionQueue.isEmpty()) {
             transaction = m_transactionQueue.takeFirst();
             transaction->notifyDatabaseThreadIsShuttingDown();
@@ -296,18 +296,17 @@ void Database::close()
     databaseContext()->databaseThread()->recordDatabaseClosed(this);
 }
 
-PassRefPtrWillBeRawPtr<SQLTransactionBackend> Database::runTransaction(PassRefPtrWillBeRawPtr<SQLTransaction> transaction,
-    bool readOnly, const ChangeVersionData* data)
+SQLTransactionBackend* Database::runTransaction(SQLTransaction* transaction, bool readOnly, const ChangeVersionData* data)
 {
     MutexLocker locker(m_transactionInProgressMutex);
     if (!m_isTransactionQueueEnabled)
         return nullptr;
 
-    RefPtrWillBeRawPtr<SQLTransactionWrapper> wrapper = nullptr;
+    SQLTransactionWrapper* wrapper = nullptr;
     if (data)
         wrapper = ChangeVersionWrapper::create(data->oldVersion(), data->newVersion());
 
-    RefPtrWillBeRawPtr<SQLTransactionBackend> transactionBackend = SQLTransactionBackend::create(this, transaction, wrapper.release(), readOnly);
+    SQLTransactionBackend* transactionBackend = SQLTransactionBackend::create(this, transaction, wrapper, readOnly);
     m_transactionQueue.append(transactionBackend);
     if (!m_transactionInProgress)
         scheduleTransaction();
@@ -325,7 +324,7 @@ void Database::inProgressTransactionCompleted()
 void Database::scheduleTransaction()
 {
     ASSERT(!m_transactionInProgressMutex.tryLock()); // Locked by caller.
-    RefPtrWillBeRawPtr<SQLTransactionBackend> transaction = nullptr;
+    SQLTransactionBackend* transaction = nullptr;
 
     if (m_isTransactionQueueEnabled && !m_transactionQueue.isEmpty())
         transaction = m_transactionQueue.takeFirst();
@@ -400,6 +399,7 @@ String Database::version() const
 }
 
 class DoneCreatingDatabaseOnExitCaller {
+    STACK_ALLOCATED();
 public:
     DoneCreatingDatabaseOnExitCaller(Database* database)
         : m_database(database)
@@ -415,7 +415,7 @@ public:
     void setOpenSucceeded() { m_openSucceeded = true; }
 
 private:
-    Database* m_database;
+    Member<Database> m_database;
     bool m_openSucceeded;
 };
 
@@ -429,7 +429,7 @@ bool Database::performOpenAndVerify(bool shouldSetVersionInNewDatabase, Database
 
     const int maxSqliteBusyWaitTime = 30000;
 
-    if (!m_sqliteDatabase.open(m_filename, true)) {
+    if (!m_sqliteDatabase.open(m_filename)) {
         reportOpenDatabaseResult(1, InvalidStateError, m_sqliteDatabase.lastError());
         errorMessage = formatErrorMessage("unable to open database", m_sqliteDatabase.lastError(), m_sqliteDatabase.lastErrorMsg());
         return false;
@@ -716,8 +716,7 @@ void Database::reportOpenDatabaseResult(int errorSite, int webSqlErrorCode, int
     if (Platform::current()->databaseObserver()) {
         Platform::current()->databaseObserver()->reportOpenDatabaseResult(
             createDatabaseIdentifierFromSecurityOrigin(securityOrigin()),
-            stringIdentifier(), false,
-            errorSite, webSqlErrorCode, sqliteErrorCode);
+            stringIdentifier(), errorSite, webSqlErrorCode, sqliteErrorCode);
     }
 }
 
@@ -726,8 +725,7 @@ void Database::reportChangeVersionResult(int errorSite, int webSqlErrorCode, int
     if (Platform::current()->databaseObserver()) {
         Platform::current()->databaseObserver()->reportChangeVersionResult(
             createDatabaseIdentifierFromSecurityOrigin(securityOrigin()),
-            stringIdentifier(), false,
-            errorSite, webSqlErrorCode, sqliteErrorCode);
+            stringIdentifier(), errorSite, webSqlErrorCode, sqliteErrorCode);
     }
 }
 
@@ -736,8 +734,7 @@ void Database::reportStartTransactionResult(int errorSite, int webSqlErrorCode,
     if (Platform::current()->databaseObserver()) {
         Platform::current()->databaseObserver()->reportStartTransactionResult(
             createDatabaseIdentifierFromSecurityOrigin(securityOrigin()),
-            stringIdentifier(), false,
-            errorSite, webSqlErrorCode, sqliteErrorCode);
+            stringIdentifier(), errorSite, webSqlErrorCode, sqliteErrorCode);
     }
 }
 
@@ -746,8 +743,7 @@ void Database::reportCommitTransactionResult(int errorSite, int webSqlErrorCode,
     if (Platform::current()->databaseObserver()) {
         Platform::current()->databaseObserver()->reportCommitTransactionResult(
             createDatabaseIdentifierFromSecurityOrigin(securityOrigin()),
-            stringIdentifier(), false,
-            errorSite, webSqlErrorCode, sqliteErrorCode);
+            stringIdentifier(), errorSite, webSqlErrorCode, sqliteErrorCode);
     }
 }
 
@@ -756,8 +752,7 @@ void Database::reportExecuteStatementResult(int errorSite, int webSqlErrorCode,
     if (Platform::current()->databaseObserver()) {
         Platform::current()->databaseObserver()->reportExecuteStatementResult(
             createDatabaseIdentifierFromSecurityOrigin(securityOrigin()),
-            stringIdentifier(), false,
-            errorSite, webSqlErrorCode, sqliteErrorCode);
+            stringIdentifier(), errorSite, webSqlErrorCode, sqliteErrorCode);
     }
 }
 
@@ -766,7 +761,7 @@ void Database::reportVacuumDatabaseResult(int sqliteErrorCode)
     if (Platform::current()->databaseObserver()) {
         Platform::current()->databaseObserver()->reportVacuumDatabaseResult(
             createDatabaseIdentifierFromSecurityOrigin(securityOrigin()),
-            stringIdentifier(), false, sqliteErrorCode);
+            stringIdentifier(), sqliteErrorCode);
     }
 }
 
@@ -818,8 +813,7 @@ void Database::readTransaction(
 
 static void callTransactionErrorCallback(ExecutionContext*, SQLTransactionErrorCallback* callback, PassOwnPtr<SQLErrorData> errorData)
 {
-    RefPtrWillBeRawPtr<SQLError> error = SQLError::create(*errorData);
-    callback->handleEvent(error.get());
+    callback->handleEvent(SQLError::create(*errorData));
 }
 
 void Database::runTransaction(
@@ -836,8 +830,8 @@ void Database::runTransaction(
 #if ENABLE(ASSERT)
     SQLTransactionErrorCallback* originalErrorCallback = errorCallback;
 #endif
-    RefPtrWillBeRawPtr<SQLTransaction> transaction = SQLTransaction::create(this, callback, successCallback, errorCallback, readOnly);
-    RefPtrWillBeRawPtr<SQLTransactionBackend> transactionBackend = runTransaction(transaction, readOnly, changeVersionData);
+    SQLTransaction* transaction = SQLTransaction::create(this, callback, successCallback, errorCallback, readOnly);
+    SQLTransactionBackend* transactionBackend = runTransaction(transaction, readOnly, changeVersionData);
     if (!transactionBackend) {
         SQLTransactionErrorCallback* callback = transaction->releaseErrorCallback();
         ASSERT(callback == originalErrorCallback);
@@ -850,25 +844,25 @@ void Database::runTransaction(
 
 // This object is constructed in a database thread, and destructed in the
 // context thread.
-class DeliverPendingCallbackTask FINAL : public ExecutionContextTask {
+class DeliverPendingCallbackTask final : public ExecutionContextTask {
 public:
-    static PassOwnPtr<DeliverPendingCallbackTask> create(PassRefPtrWillBeRawPtr<SQLTransaction> transaction)
+    static PassOwnPtr<DeliverPendingCallbackTask> create(SQLTransaction* transaction)
     {
         return adoptPtr(new DeliverPendingCallbackTask(transaction));
     }
 
-    virtual void performTask(ExecutionContext*) OVERRIDE
+    virtual void performTask(ExecutionContext*) override
     {
         m_transaction->performPendingCallback();
     }
 
 private:
-    DeliverPendingCallbackTask(PassRefPtrWillBeRawPtr<SQLTransaction> transaction)
+    DeliverPendingCallbackTask(SQLTransaction* transaction)
         : m_transaction(transaction)
     {
     }
 
-    RefPtrWillBeCrossThreadPersistent<SQLTransaction> m_transaction;
+    CrossThreadPersistent<SQLTransaction> m_transaction;
 };
 
 void Database::scheduleTransactionCallback(SQLTransaction* transaction)