Unreviewed, rolling out r202676.
authorryanhaddad@apple.com <ryanhaddad@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Thu, 30 Jun 2016 20:44:42 +0000 (20:44 +0000)
committerryanhaddad@apple.com <ryanhaddad@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Thu, 30 Jun 2016 20:44:42 +0000 (20:44 +0000)
https://bugs.webkit.org/show_bug.cgi?id=159314

This change caused storage/websql tests to crash on Mac and
iOS WK1 (Requested by ryanhaddad on #webkit).

Reverted changeset:

"Purge PassRefPtr in Modules/webdatabase"
https://bugs.webkit.org/show_bug.cgi?id=159255
http://trac.webkit.org/changeset/202676

Patch by Commit Queue <commit-queue@webkit.org> on 2016-06-30

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@202698 268f45cc-cd09-0410-ab3c-d52691b4dbfc

18 files changed:
Source/WebCore/ChangeLog
Source/WebCore/Modules/webdatabase/ChangeVersionWrapper.cpp
Source/WebCore/Modules/webdatabase/DOMWindowWebDatabase.h
Source/WebCore/Modules/webdatabase/Database.cpp
Source/WebCore/Modules/webdatabase/Database.h
Source/WebCore/Modules/webdatabase/DatabaseAuthorizer.cpp
Source/WebCore/Modules/webdatabase/DatabaseManager.cpp
Source/WebCore/Modules/webdatabase/DatabaseManager.h
Source/WebCore/Modules/webdatabase/DatabaseServer.cpp
Source/WebCore/Modules/webdatabase/DatabaseTask.cpp
Source/WebCore/Modules/webdatabase/DatabaseTask.h
Source/WebCore/Modules/webdatabase/SQLCallbackWrapper.h
Source/WebCore/Modules/webdatabase/SQLResultSetRowList.h
Source/WebCore/Modules/webdatabase/SQLStatement.cpp
Source/WebCore/Modules/webdatabase/SQLStatement.h
Source/WebCore/Modules/webdatabase/SQLTransaction.h
Source/WebCore/Modules/webdatabase/SQLTransactionBackend.cpp
Source/WebCore/Modules/webdatabase/SQLTransactionBackend.h

index d49edfb..dc58e16 100644 (file)
@@ -1,3 +1,17 @@
+2016-06-30  Commit Queue  <commit-queue@webkit.org>
+
+        Unreviewed, rolling out r202676.
+        https://bugs.webkit.org/show_bug.cgi?id=159314
+
+        This change caused storage/websql tests to crash on Mac and
+        iOS WK1 (Requested by ryanhaddad on #webkit).
+
+        Reverted changeset:
+
+        "Purge PassRefPtr in Modules/webdatabase"
+        https://bugs.webkit.org/show_bug.cgi?id=159255
+        http://trac.webkit.org/changeset/202676
+
 2016-06-30  Antoine Quint  <graouts@apple.com>
 
         [iOS] Media controls are too cramped with small video
index 515ec28..3dae923 100644 (file)
@@ -30,6 +30,7 @@
 
 #include "Database.h"
 #include "SQLError.h"
+#include <wtf/PassRefPtr.h>
 #include <wtf/RefPtr.h>
 
 namespace WebCore {
index 90e8449..1ce239c 100644 (file)
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
  */
 
 #ifndef DOMWindowWebDatabase_h
 #define DOMWindowWebDatabase_h
 
 #include "ExceptionCode.h"
+#include <wtf/PassRefPtr.h>
 #include <wtf/RefCounted.h>
 #include <wtf/RefPtr.h>
 #include <wtf/text/WTFString.h>
index 1ff238c..da38e1c 100644 (file)
@@ -54,6 +54,7 @@
 #include "SecurityOrigin.h"
 #include "VoidCallback.h"
 #include <wtf/NeverDestroyed.h>
+#include <wtf/PassRefPtr.h>
 #include <wtf/RefPtr.h>
 #include <wtf/StdLibExtras.h>
 #include <wtf/text/CString.h>
@@ -202,9 +203,9 @@ static DatabaseGuid guidForOriginAndName(const String& origin, const String& nam
     return guid;
 }
 
-Database::Database(RefPtr<DatabaseContext>&& databaseContext, const String& name, const String& expectedVersion, const String& displayName, unsigned long estimatedSize)
+Database::Database(PassRefPtr<DatabaseContext> databaseContext, const String& name, const String& expectedVersion, const String& displayName, unsigned long estimatedSize)
     : m_scriptExecutionContext(databaseContext->scriptExecutionContext())
-    , m_databaseContext(WTFMove(databaseContext))
+    , m_databaseContext(databaseContext)
     , m_deleted(false)
     , m_name(name.isolatedCopy())
     , m_expectedVersion(expectedVersion.isolatedCopy())
@@ -241,13 +242,12 @@ Database::Database(RefPtr<DatabaseContext>&& databaseContext, const String& name
 
 Database::~Database()
 {
-    // The reference to the ScriptExecutionContext needs to be cleared on the JavaScript thread.
-    // If we're on that thread already, we can just let the RefPtr's destruction do the dereffing.
+    // The reference to the ScriptExecutionContext needs to be cleared on the JavaScript thread.  If we're on that thread already, we can just let the RefPtr's destruction do the dereffing.
     if (!m_scriptExecutionContext->isContextThread()) {
         // Grab a pointer to the script execution here because we're releasing it when we pass it to
         // DerefContextTask::create.
-        RefPtr<ScriptExecutionContext> passedContext;
-        passedContext->postTask({ScriptExecutionContext::Task::CleanupTask, [passedContext = WTFMove(m_scriptExecutionContext)] (ScriptExecutionContext& context) {
+        PassRefPtr<ScriptExecutionContext> passedContext = m_scriptExecutionContext.release();
+        passedContext->postTask({ScriptExecutionContext::Task::CleanupTask, [passedContext] (ScriptExecutionContext& context) {
             ASSERT_UNUSED(context, &context == passedContext);
             RefPtr<ScriptExecutionContext> scriptExecutionContext(passedContext);
         }});
@@ -571,7 +571,7 @@ void Database::scheduleTransaction()
         transaction = m_transactionQueue.takeFirst();
 
     if (transaction && databaseContext()->databaseThread()) {
-        auto task = std::make_unique<DatabaseTransactionTask>(WTFMove(transaction));
+        auto task = std::make_unique<DatabaseTransactionTask>(transaction);
         LOG(StorageAPI, "Scheduling DatabaseTransactionTask %p for transaction %p\n", task.get(), task->transaction());
         m_transactionInProgress = true;
         databaseContext()->databaseThread()->scheduleTask(WTFMove(task));
@@ -589,7 +589,7 @@ RefPtr<SQLTransactionBackend> Database::runTransaction(Ref<SQLTransaction>&& tra
     if (data)
         wrapper = ChangeVersionWrapper::create(data->oldVersion(), data->newVersion());
 
-    RefPtr<SQLTransactionBackend> transactionBackend = SQLTransactionBackend::create(this, WTFMove(transaction), WTFMove(wrapper), readOnly);
+    RefPtr<SQLTransactionBackend> transactionBackend = SQLTransactionBackend::create(this, WTFMove(transaction), wrapper, readOnly);
     m_transactionQueue.append(transactionBackend);
     if (!m_transactionInProgress)
         scheduleTransaction();
index 1e1000f..88ecd1c 100644 (file)
@@ -125,7 +125,7 @@ public:
     void performClose();
 
 private:
-    Database(RefPtr<DatabaseContext>&&, const String& name, const String& expectedVersion, const String& displayName, unsigned long estimatedSize);
+    Database(PassRefPtr<DatabaseContext>, const String& name, const String& expectedVersion, const String& displayName, unsigned long estimatedSize);
 
     void closeDatabase();
 
index 10310a0..0933f20 100644 (file)
@@ -29,6 +29,7 @@
 #include "config.h"
 #include "DatabaseAuthorizer.h"
 
+#include <wtf/PassRefPtr.h>
 #include <wtf/text/WTFString.h>
 
 namespace WebCore {
@@ -343,7 +344,7 @@ int DatabaseAuthorizer::allowRead(const String& tableName, const String&)
 {
     if (m_permissions & NoAccessMask && m_securityEnabled)
         return SQLAuthDeny;
-
+    
     return denyBasedOnTableName(tableName);
 }
 
index 0041169..afc788f 100644 (file)
@@ -20,7 +20,7 @@
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
  */
 
 #include "config.h"
@@ -272,7 +272,7 @@ void DatabaseManager::removeProposedDatabase(ProposedDatabase* proposedDb)
 
 RefPtr<Database> DatabaseManager::openDatabase(ScriptExecutionContext* context,
     const String& name, const String& expectedVersion, const String& displayName,
-    unsigned long estimatedSize, RefPtr<DatabaseCallback>&& creationCallback,
+    unsigned long estimatedSize, PassRefPtr<DatabaseCallback> creationCallback,
     DatabaseError& error)
 {
     ScriptController::initializeThreading();
@@ -327,7 +327,7 @@ String DatabaseManager::fullPathForDatabase(SecurityOrigin* origin, const String
                 return String();
         }
     }
-
+    
     return m_server->fullPathForDatabase(origin, name, createIfDoesNotExist);
 }
 
@@ -350,16 +350,16 @@ DatabaseDetails DatabaseManager::detailsForNameAndOrigin(const String& name, Sec
 {
     {
         std::lock_guard<Lock> lock(m_mutex);
-
+        
         for (auto* proposedDatabase : m_proposedDatabases) {
             if (proposedDatabase->details().name() == name && proposedDatabase->origin()->equal(origin)) {
                 ASSERT(proposedDatabase->details().threadID() == std::this_thread::get_id() || isMainThread());
-
+                
                 return proposedDatabase->details();
             }
         }
     }
-
+    
     return m_server->detailsForNameAndOrigin(name, origin);
 }
 
index ba41f1c..41cd7fe 100644 (file)
@@ -20,7 +20,7 @@
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
  */
 
 #ifndef DatabaseManager_h
@@ -33,6 +33,7 @@
 #include <wtf/HashMap.h>
 #include <wtf/HashSet.h>
 #include <wtf/Lock.h>
+#include <wtf/PassRefPtr.h>
 #include <wtf/Threading.h>
 
 namespace WebCore {
@@ -80,7 +81,7 @@ public:
 
     static ExceptionCode exceptionCodeForDatabaseError(DatabaseError);
 
-    RefPtr<Database> openDatabase(ScriptExecutionContext*, const String& name, const String& expectedVersion, const String& displayName, unsigned long estimatedSize, RefPtr<DatabaseCallback>&&, DatabaseError&);
+    RefPtr<Database> openDatabase(ScriptExecutionContext*, const String& name, const String& expectedVersion, const String& displayName, unsigned long estimatedSize, PassRefPtr<DatabaseCallback>, DatabaseError&);
 
     WEBCORE_EXPORT bool hasOpenDatabases(ScriptExecutionContext*);
 
index 8696344..624a737 100644 (file)
@@ -20,7 +20,7 @@
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
  */
 
 #include "config.h"
@@ -117,7 +117,7 @@ RefPtr<Database> DatabaseServer::openDatabase(RefPtr<DatabaseContext>& backendCo
 {
     RefPtr<Database> database;
     bool success = false; // Make some older compilers happy.
-
+    
     switch (attempt) {
     case FirstTryToOpenDatabase:
         success = DatabaseTracker::tracker().canEstablishDatabase(backendContext.get(), name, estimatedSize, error);
@@ -133,7 +133,7 @@ RefPtr<Database> DatabaseServer::openDatabase(RefPtr<DatabaseContext>& backendCo
 
 RefPtr<Database> DatabaseServer::createDatabase(RefPtr<DatabaseContext>& backendContext, const String& name, const String& expectedVersion, const String& displayName, unsigned long estimatedSize, bool setVersionInNewDatabase, DatabaseError& error, String& errorMessage)
 {
-    RefPtr<Database> database = adoptRef(new Database(backendContext.copyRef(), name, expectedVersion, displayName, estimatedSize));
+    RefPtr<Database> database = adoptRef(new Database(backendContext, name, expectedVersion, displayName, estimatedSize));
 
     if (!database->openAndVerifyVersion(setVersionInNewDatabase, error, errorMessage))
         return nullptr;
index b871515..6dbf57f 100644 (file)
@@ -144,9 +144,9 @@ const char* DatabaseCloseTask::debugTaskName() const
 // *** DatabaseTransactionTask ***
 // Starts a transaction that will report its results via a callback.
 
-DatabaseTransactionTask::DatabaseTransactionTask(RefPtr<SQLTransactionBackend>&& transaction)
+DatabaseTransactionTask::DatabaseTransactionTask(PassRefPtr<SQLTransactionBackend> transaction)
     : DatabaseTask(*transaction->database(), 0)
-    , m_transaction(WTFMove(transaction))
+    , m_transaction(transaction)
     , m_didPerformTask(false)
 {
 }
index e5f475c..2ff8df5 100644 (file)
@@ -33,6 +33,7 @@
 #include "SQLTransactionBackend.h"
 #include <wtf/Condition.h>
 #include <wtf/Lock.h>
+#include <wtf/PassRefPtr.h>
 #include <wtf/Vector.h>
 #include <wtf/text/WTFString.h>
 
@@ -122,7 +123,7 @@ private:
 
 class DatabaseTransactionTask : public DatabaseTask {
 public:
-    explicit DatabaseTransactionTask(RefPtr<SQLTransactionBackend>&&);
+    explicit DatabaseTransactionTask(PassRefPtr<SQLTransactionBackend>);
     virtual ~DatabaseTransactionTask();
 
     SQLTransactionBackend* transaction() const { return m_transaction.get(); }
index a65ccb7..b645482 100644 (file)
@@ -41,8 +41,8 @@ namespace WebCore {
 // - by unwrapping and then dereferencing normally - on context thread only
 template<typename T> class SQLCallbackWrapper {
 public:
-    SQLCallbackWrapper(RefPtr<T>&& callback, ScriptExecutionContext* scriptExecutionContext)
-        : m_callback(WTFMove(callback))
+    SQLCallbackWrapper(PassRefPtr<T> callback, ScriptExecutionContext* scriptExecutionContext)
+        : m_callback(callback)
         , m_scriptExecutionContext(m_callback ? scriptExecutionContext : 0)
     {
         ASSERT(!m_callback || (m_scriptExecutionContext.get() && m_scriptExecutionContext->isContextThread()));
index 55de2fb..eef148d 100644 (file)
@@ -29,6 +29,7 @@
 #ifndef SQLResultSetRowList_h
 #define SQLResultSetRowList_h
 
+#include <wtf/PassRefPtr.h>
 #include <wtf/RefCounted.h>
 #include "SQLValue.h"
 
index c1af90a..4d6bb3f 100644 (file)
@@ -40,7 +40,7 @@
 #include <wtf/text/CString.h>
 
 
-// The Life-Cycle of a SQLStatement i.e. Who's keeping the SQLStatement alive?
+// The Life-Cycle of a SQLStatement i.e. Who's keeping the SQLStatement alive? 
 // ==========================================================================
 // The RefPtr chain goes something like this:
 //
 
 namespace WebCore {
 
-SQLStatement::SQLStatement(Database& database, const String& statement, const Vector<SQLValue>& arguments, RefPtr<SQLStatementCallback>&& callback, RefPtr<SQLStatementErrorCallback>&& errorCallback, int permissions)
+SQLStatement::SQLStatement(Database& database, const String& statement, const Vector<SQLValue>& arguments, PassRefPtr<SQLStatementCallback> callback, PassRefPtr<SQLStatementErrorCallback> errorCallback, int permissions)
     : m_statement(statement.isolatedCopy())
     , m_arguments(arguments)
-    , m_statementCallbackWrapper(WTFMove(callback), database.scriptExecutionContext())
-    , m_statementErrorCallbackWrapper(WTFMove(errorCallback), database.scriptExecutionContext())
+    , m_statementCallbackWrapper(callback, database.scriptExecutionContext())
+    , m_statementErrorCallbackWrapper(errorCallback, database.scriptExecutionContext())
     , m_permissions(permissions)
 {
 }
@@ -87,14 +87,14 @@ SQLStatement::~SQLStatement()
 {
 }
 
-SQLError* SQLStatement::sqlError() const
+PassRefPtr<SQLError> SQLStatement::sqlError() const
 {
-    return m_error.get();
+    return m_error;
 }
 
-SQLResultSet* SQLStatement::sqlResultSet() const
+PassRefPtr<SQLResultSet> SQLStatement::sqlResultSet() const
 {
-    return m_resultSet.get();
+    return m_resultSet;
 }
 
 bool SQLStatement::execute(Database& db)
index 43c7c48..374602d 100644 (file)
@@ -45,7 +45,7 @@ class SQLTransactionBackend;
 
 class SQLStatement {
 public:
-    SQLStatement(Database&, const String&, const Vector<SQLValue>&, RefPtr<SQLStatementCallback>&&, RefPtr<SQLStatementErrorCallback>&&, int permissions);
+    SQLStatement(Database&, const String&, const Vector<SQLValue>&, PassRefPtr<SQLStatementCallback>, PassRefPtr<SQLStatementErrorCallback>, int permissions);
     ~SQLStatement();
 
     bool execute(Database&);
@@ -58,8 +58,8 @@ public:
     void setDatabaseDeletedError();
     void setVersionMismatchedError();
 
-    SQLError* sqlError() const;
-    SQLResultSet* sqlResultSet() const;
+    PassRefPtr<SQLError> sqlError() const;
+    PassRefPtr<SQLResultSet> sqlResultSet() const;
 
 private:
     void setFailureDueToQuota();
index ddacc8b..dec9b8a 100644 (file)
@@ -32,6 +32,7 @@
 #include "EventTarget.h"
 #include "SQLCallbackWrapper.h"
 #include "SQLTransactionStateMachine.h"
+#include <wtf/PassRefPtr.h>
 #include <wtf/Ref.h>
 #include <wtf/RefPtr.h>
 
index 81d7a1b..9d086cb 100644 (file)
 // to wait for further action.
 
 
-// The Life-Cycle of a SQLTransaction i.e. Who's keeping the SQLTransaction alive?
+// The Life-Cycle of a SQLTransaction i.e. Who's keeping the SQLTransaction alive? 
 // ==============================================================================
 // The RefPtr chain goes something like this:
 //
 //     - DatabaseBackend::close() will iterate
 //       DatabaseBackend::m_transactionQueue and call
 //       notifyDatabaseThreadIsShuttingDown() on each transaction there.
-//
+//        
 //     Phase 2. After scheduling, before state AcquireLock
 //
 //     - If the interruption occures before the DatabaseTransactionTask is
 
 namespace WebCore {
 
-Ref<SQLTransactionBackend> SQLTransactionBackend::create(Database* db, RefPtr<SQLTransaction>&& frontend, RefPtr<SQLTransactionWrapper>&& wrapper, bool readOnly)
+Ref<SQLTransactionBackend> SQLTransactionBackend::create(Database* db, PassRefPtr<SQLTransaction> frontend, PassRefPtr<SQLTransactionWrapper> wrapper, bool readOnly)
 {
-    return adoptRef(*new SQLTransactionBackend(db, WTFMove(frontend), WTFMove(wrapper), readOnly));
+    return adoptRef(*new SQLTransactionBackend(db, frontend, wrapper, readOnly));
 }
 
-SQLTransactionBackend::SQLTransactionBackend(Database* db, RefPtr<SQLTransaction>&& frontend, RefPtr<SQLTransactionWrapper>&& wrapper, bool readOnly)
-    : m_frontend(WTFMove(frontend))
+SQLTransactionBackend::SQLTransactionBackend(Database* db, PassRefPtr<SQLTransaction> frontend, PassRefPtr<SQLTransactionWrapper> wrapper, bool readOnly)
+    : m_frontend(frontend)
     , m_database(db)
-    , m_wrapper(WTFMove(wrapper))
+    , m_wrapper(wrapper)
     , m_hasCallback(m_frontend->hasCallback())
     , m_hasSuccessCallback(m_frontend->hasSuccessCallback())
     , m_hasErrorCallback(m_frontend->hasErrorCallback())
@@ -428,9 +428,9 @@ SQLStatement* SQLTransactionBackend::currentStatement()
     return m_currentStatementBackend.get();
 }
 
-SQLError* SQLTransactionBackend::transactionError()
+PassRefPtr<SQLError> SQLTransactionBackend::transactionError()
 {
-    return m_transactionError.get();
+    return m_transactionError;
 }
 
 void SQLTransactionBackend::setShouldRetryCurrentStatement(bool shouldRetry)
index bbfac0b..30cdf29 100644 (file)
@@ -58,7 +58,7 @@ public:
 
 class SQLTransactionBackend : public ThreadSafeRefCounted<SQLTransactionBackend>, public SQLTransactionStateMachine<SQLTransactionBackend> {
 public:
-    static Ref<SQLTransactionBackend> create(Database*, RefPtr<SQLTransaction>&&, RefPtr<SQLTransactionWrapper>&&, bool readOnly);
+    static Ref<SQLTransactionBackend> create(Database*, PassRefPtr<SQLTransaction>, PassRefPtr<SQLTransactionWrapper>, bool readOnly);
 
     virtual ~SQLTransactionBackend();
 
@@ -71,13 +71,13 @@ public:
 
     // APIs called from the frontend published via SQLTransactionBackend:
     void requestTransitToState(SQLTransactionState);
-    SQLError* transactionError();
+    PassRefPtr<SQLError> transactionError();
     SQLStatement* currentStatement();
     void setShouldRetryCurrentStatement(bool);
     void executeSQL(std::unique_ptr<SQLStatement>);
-
+    
 private:
-    SQLTransactionBackend(Database*, RefPtr<SQLTransaction>&&, RefPtr<SQLTransactionWrapper>&&, bool readOnly);
+    SQLTransactionBackend(Database*, PassRefPtr<SQLTransaction>, PassRefPtr<SQLTransactionWrapper>, bool readOnly);
 
     void doCleanup();