[oilpan] Move IDBDatabase, IDBDatabaseCallbacks, IDBDatabaseBackendInterface and other related clas…

Source/modules/indexeddb/IDBDatabaseBackendImpl.cpp

Index: Source/modules/indexeddb/IDBDatabaseBackendImpl.cpp
diff --git a/Source/modules/indexeddb/IDBDatabaseBackendImpl.cpp b/Source/modules/indexeddb/IDBDatabaseBackendImpl.cpp
index 57d9567d07c228c1dd51520e507518e883ef37ce..7cd6d9c3e9e62ff416a951db38194dbc0fce656b 100644
--- a/Source/modules/indexeddb/IDBDatabaseBackendImpl.cpp
+++ b/Source/modules/indexeddb/IDBDatabaseBackendImpl.cpp
@@ -41,6 +41,8 @@
 
 namespace WebCore {
 
+DEFINE_GC_MAP(IDBDatabaseBackendInterface);
+
 class CreateObjectStoreOperation : public IDBTransactionBackendImpl::Operation {
 public:
     static PassOwnPtr<IDBTransactionBackendImpl::Operation> create(PassRefPtr<IDBBackingStore> backingStore, const IDBObjectStoreMetadata& objectStoreMetadata)
@@ -79,13 +81,13 @@ private:
 
 class IDBDatabaseBackendImpl::VersionChangeOperation : public IDBTransactionBackendImpl::Operation {
 public:
-    static PassOwnPtr<IDBTransactionBackendImpl::Operation> create(PassRefPtr<IDBDatabaseBackendImpl> database, int64_t transactionId, int64_t version, PassRefPtr<IDBCallbacks> callbacks, PassRefPtr<IDBDatabaseCallbacks> databaseCallbacks)
+    static PassOwnPtr<IDBTransactionBackendImpl::Operation> create(IDBDatabaseBackendImpl* database, int64_t transactionId, int64_t version, PassRefPtr<IDBCallbacks> callbacks, IDBDatabaseCallbacks* databaseCallbacks)
     {
         return adoptPtr(new VersionChangeOperation(database, transactionId, version, callbacks, databaseCallbacks));
     }
     virtual void perform(IDBTransactionBackendImpl*);
 private:
-    VersionChangeOperation(PassRefPtr<IDBDatabaseBackendImpl> database, int64_t transactionId, int64_t version, PassRefPtr<IDBCallbacks> callbacks, PassRefPtr<IDBDatabaseCallbacks> databaseCallbacks)
+    VersionChangeOperation(IDBDatabaseBackendImpl* database, int64_t transactionId, int64_t version, PassRefPtr<IDBCallbacks> callbacks, IDBDatabaseCallbacks* databaseCallbacks)
         : m_database(database)
         , m_transactionId(transactionId)
         , m_version(version)
@@ -94,65 +96,65 @@ private:
     {
     }
 
-    RefPtr<IDBDatabaseBackendImpl> m_database;
+    Persistent<IDBDatabaseBackendImpl> m_database;
     int64_t m_transactionId;
     int64_t m_version;
     RefPtr<IDBCallbacks> m_callbacks;
-    RefPtr<IDBDatabaseCallbacks> m_databaseCallbacks;
+    Persistent<IDBDatabaseCallbacks> m_databaseCallbacks;
 };
 
 class CreateObjectStoreAbortOperation : public IDBTransactionBackendImpl::Operation {
 public:
-    static PassOwnPtr<IDBTransactionBackendImpl::Operation> create(PassRefPtr<IDBDatabaseBackendImpl> database, int64_t objectStoreId)
+    static PassOwnPtr<IDBTransactionBackendImpl::Operation> create(IDBDatabaseBackendImpl* database, int64_t objectStoreId)
     {
         return adoptPtr(new CreateObjectStoreAbortOperation(database, objectStoreId));
     }
     virtual void perform(IDBTransactionBackendImpl*);
 private:
-    CreateObjectStoreAbortOperation(PassRefPtr<IDBDatabaseBackendImpl> database, int64_t objectStoreId)
+    CreateObjectStoreAbortOperation(IDBDatabaseBackendImpl* database, int64_t objectStoreId)
         : m_database(database)
         , m_objectStoreId(objectStoreId)
     {
     }
 
-    const RefPtr<IDBDatabaseBackendImpl> m_database;
+    const Persistent<IDBDatabaseBackendImpl> m_database;
     const int64_t m_objectStoreId;
 };
 
 class DeleteObjectStoreAbortOperation : public IDBTransactionBackendImpl::Operation {
 public:
-    static PassOwnPtr<IDBTransactionBackendImpl::Operation> create(PassRefPtr<IDBDatabaseBackendImpl> database, const IDBObjectStoreMetadata& objectStore)
+    static PassOwnPtr<IDBTransactionBackendImpl::Operation> create(IDBDatabaseBackendImpl* database, const IDBObjectStoreMetadata& objectStore)
     {
         return adoptPtr(new DeleteObjectStoreAbortOperation(database, objectStore));
     }
     virtual void perform(IDBTransactionBackendImpl*);
 private:
-    DeleteObjectStoreAbortOperation(PassRefPtr<IDBDatabaseBackendImpl> database, const IDBObjectStoreMetadata& objectStoreMetadata)
+    DeleteObjectStoreAbortOperation(IDBDatabaseBackendImpl* database, const IDBObjectStoreMetadata& objectStoreMetadata)
         : m_database(database)
         , m_objectStoreMetadata(objectStoreMetadata)
     {
     }
 
-    RefPtr<IDBDatabaseBackendImpl> m_database;
+    Persistent<IDBDatabaseBackendImpl> m_database;
     IDBObjectStoreMetadata m_objectStoreMetadata;
 };
 
 class IDBDatabaseBackendImpl::VersionChangeAbortOperation : public IDBTransactionBackendImpl::Operation {
 public:
-    static PassOwnPtr<IDBTransactionBackendImpl::Operation> create(PassRefPtr<IDBDatabaseBackendImpl> database, const String& previousVersion, int64_t previousIntVersion)
+    static PassOwnPtr<IDBTransactionBackendImpl::Operation> create(IDBDatabaseBackendImpl* database, const String& previousVersion, int64_t previousIntVersion)
     {
         return adoptPtr(new VersionChangeAbortOperation(database, previousVersion, previousIntVersion));
     }
     virtual void perform(IDBTransactionBackendImpl*);
 private:
-    VersionChangeAbortOperation(PassRefPtr<IDBDatabaseBackendImpl> database, const String& previousVersion, int64_t previousIntVersion)
+    VersionChangeAbortOperation(IDBDatabaseBackendImpl* database, const String& previousVersion, int64_t previousIntVersion)
         : m_database(database)
         , m_previousVersion(previousVersion)
         , m_previousIntVersion(previousIntVersion)
     {
     }
 
-    RefPtr<IDBDatabaseBackendImpl> m_database;
+    Persistent<IDBDatabaseBackendImpl> m_database;
     String m_previousVersion;
     int64_t m_previousIntVersion;
 };
@@ -199,40 +201,40 @@ private:
 
 class CreateIndexAbortOperation : public IDBTransactionBackendImpl::Operation {
 public:
-    static PassOwnPtr<IDBTransactionBackendImpl::Operation> create(PassRefPtr<IDBDatabaseBackendImpl> database, int64_t objectStoreId, int64_t indexId)
+    static PassOwnPtr<IDBTransactionBackendImpl::Operation> create(IDBDatabaseBackendImpl* database, int64_t objectStoreId, int64_t indexId)
     {
         return adoptPtr(new CreateIndexAbortOperation(database, objectStoreId, indexId));
     }
     virtual void perform(IDBTransactionBackendImpl*);
 private:
-    CreateIndexAbortOperation(PassRefPtr<IDBDatabaseBackendImpl> database, int64_t objectStoreId, int64_t indexId)
+    CreateIndexAbortOperation(IDBDatabaseBackendImpl* database, int64_t objectStoreId, int64_t indexId)
         : m_database(database)
         , m_objectStoreId(objectStoreId)
         , m_indexId(indexId)
     {
     }
 
-    const RefPtr<IDBDatabaseBackendImpl> m_database;
+    const Persistent<IDBDatabaseBackendImpl> m_database;
     const int64_t m_objectStoreId;
     const int64_t m_indexId;
 };
 
 class DeleteIndexAbortOperation : public IDBTransactionBackendImpl::Operation {
 public:
-    static PassOwnPtr<IDBTransactionBackendImpl::Operation> create(PassRefPtr<IDBDatabaseBackendImpl> database, int64_t objectStoreId, const IDBIndexMetadata& indexMetadata)
+    static PassOwnPtr<IDBTransactionBackendImpl::Operation> create(IDBDatabaseBackendImpl* database, int64_t objectStoreId, const IDBIndexMetadata& indexMetadata)
     {
         return adoptPtr(new DeleteIndexAbortOperation(database, objectStoreId, indexMetadata));
     }
     virtual void perform(IDBTransactionBackendImpl*);
 private:
-    DeleteIndexAbortOperation(PassRefPtr<IDBDatabaseBackendImpl> database, int64_t objectStoreId, const IDBIndexMetadata& indexMetadata)
+    DeleteIndexAbortOperation(IDBDatabaseBackendImpl* database, int64_t objectStoreId, const IDBIndexMetadata& indexMetadata)
         : m_database(database)
         , m_objectStoreId(objectStoreId)
         , m_indexMetadata(indexMetadata)
     {
     }
 
-    const RefPtr<IDBDatabaseBackendImpl> m_database;
+    const Persistent<IDBDatabaseBackendImpl> m_database;
     const int64_t m_objectStoreId;
     const IDBIndexMetadata m_indexMetadata;
 };
@@ -425,17 +427,17 @@ private:
 
 class IDBDatabaseBackendImpl::PendingOpenCall {
 public:
-    static PassOwnPtr<PendingOpenCall> create(PassRefPtr<IDBCallbacks> callbacks, PassRefPtr<IDBDatabaseCallbacks> databaseCallbacks, int64_t transactionId, int64_t version)
+    static PassOwnPtr<PendingOpenCall> create(PassRefPtr<IDBCallbacks> callbacks, IDBDatabaseCallbacks* databaseCallbacks, int64_t transactionId, int64_t version)
     {
         return adoptPtr(new PendingOpenCall(callbacks, databaseCallbacks, transactionId, version));
     }
     PassRefPtr<IDBCallbacks> callbacks() { return m_callbacks; }
-    PassRefPtr<IDBDatabaseCallbacks> databaseCallbacks() { return m_databaseCallbacks; }
+    IDBDatabaseCallbacks* databaseCallbacks() { return m_databaseCallbacks; }
     int64_t version() { return m_version; }
     int64_t transactionId() const { return m_transactionId; }
 
 private:
-    PendingOpenCall(PassRefPtr<IDBCallbacks> callbacks, PassRefPtr<IDBDatabaseCallbacks> databaseCallbacks, int64_t transactionId, int64_t version)
+    PendingOpenCall(PassRefPtr<IDBCallbacks> callbacks, IDBDatabaseCallbacks* databaseCallbacks, int64_t transactionId, int64_t version)
         : m_callbacks(callbacks)
         , m_databaseCallbacks(databaseCallbacks)
         , m_version(version)
@@ -443,7 +445,7 @@ private:
     {
     }
     RefPtr<IDBCallbacks> m_callbacks;
-    RefPtr<IDBDatabaseCallbacks> m_databaseCallbacks;
+    Persistent<IDBDatabaseCallbacks> m_databaseCallbacks;
     int64_t m_version;
     const int64_t m_transactionId;
 };
@@ -464,12 +466,12 @@ private:
     RefPtr<IDBCallbacks> m_callbacks;
 };
 
-PassRefPtr<IDBDatabaseBackendImpl> IDBDatabaseBackendImpl::create(const String& name, IDBBackingStore* database, IDBFactoryBackendImpl* factory, const String& uniqueIdentifier)
+IDBDatabaseBackendImpl* IDBDatabaseBackendImpl::create(const String& name, IDBBackingStore* database, IDBFactoryBackendImpl* factory, const String& uniqueIdentifier)
 {
-    RefPtr<IDBDatabaseBackendImpl> backend = adoptRef(new IDBDatabaseBackendImpl(name, database, factory, uniqueIdentifier));
+    IDBDatabaseBackendImpl* backend = new IDBDatabaseBackendImpl(name, database, factory, uniqueIdentifier);
     if (!backend->openInternal())
         return 0;
-    return backend.release();
+    return backend;
 }
 
 namespace {
@@ -1172,18 +1174,17 @@ void IDBDatabaseBackendImpl::processPendingCalls()
     }
 }
 
-void IDBDatabaseBackendImpl::createTransaction(int64_t transactionId, PassRefPtr<IDBDatabaseCallbacks> callbacks, const Vector<int64_t>& objectStoreIds, unsigned short mode)
+void IDBDatabaseBackendImpl::createTransaction(int64_t transactionId, IDBDatabaseCallbacks* callbacks, const Vector<int64_t>& objectStoreIds, unsigned short mode)
 {
     RefPtr<IDBTransactionBackendImpl> transaction = IDBTransactionBackendImpl::create(transactionId, callbacks, objectStoreIds, static_cast<IndexedDB::TransactionMode>(mode), this);
     ASSERT(!m_transactions.contains(transactionId));
     m_transactions.add(transactionId, transaction.get());
 }
 
-void IDBDatabaseBackendImpl::openConnection(PassRefPtr<IDBCallbacks> prpCallbacks, PassRefPtr<IDBDatabaseCallbacks> prpDatabaseCallbacks, int64_t transactionId, int64_t version)
+void IDBDatabaseBackendImpl::openConnection(PassRefPtr<IDBCallbacks> prpCallbacks, IDBDatabaseCallbacks* databaseCallbacks, int64_t transactionId, int64_t version)
 {
     ASSERT(m_backingStore.get());
     RefPtr<IDBCallbacks> callbacks = prpCallbacks;
-    RefPtr<IDBDatabaseCallbacks> databaseCallbacks = prpDatabaseCallbacks;
 
     if (!m_pendingDeleteCalls.isEmpty() || m_runningVersionChangeTransaction) {
         m_pendingOpenCalls.append(PendingOpenCall::create(callbacks, databaseCallbacks, transactionId, version));
@@ -1220,7 +1221,7 @@ void IDBDatabaseBackendImpl::openConnection(PassRefPtr<IDBCallbacks> prpCallback
 
     if (version == IDBDatabaseMetadata::NoIntVersion) {
         if (!isNewDatabase) {
-            m_databaseCallbacksSet.add(RefPtr<IDBDatabaseCallbacks>(databaseCallbacks));
+            m_databaseCallbacksSet.add(databaseCallbacks);
             callbacks->onSuccess(this, this->metadata());
             return;
         }
@@ -1241,10 +1242,9 @@ void IDBDatabaseBackendImpl::openConnection(PassRefPtr<IDBCallbacks> prpCallback
     callbacks->onSuccess(this, this->metadata());
 }
 
-void IDBDatabaseBackendImpl::runIntVersionChangeTransaction(PassRefPtr<IDBCallbacks> prpCallbacks, PassRefPtr<IDBDatabaseCallbacks> prpDatabaseCallbacks, int64_t transactionId, int64_t requestedVersion)
+void IDBDatabaseBackendImpl::runIntVersionChangeTransaction(PassRefPtr<IDBCallbacks> prpCallbacks, IDBDatabaseCallbacks* databaseCallbacks, int64_t transactionId, int64_t requestedVersion)
 {
     RefPtr<IDBCallbacks> callbacks = prpCallbacks;
-    RefPtr<IDBDatabaseCallbacks> databaseCallbacks = prpDatabaseCallbacks;
     ASSERT(callbacks);
     for (DatabaseCallbacksSet::const_iterator it = m_databaseCallbacksSet.begin(); it != m_databaseCallbacksSet.end(); ++it) {
         // Front end ensures the event is not fired at connections that have closePending set.
@@ -1314,9 +1314,8 @@ void IDBDatabaseBackendImpl::deleteDatabaseFinal(PassRefPtr<IDBCallbacks> callba
     callbacks->onSuccess();
 }
 
-void IDBDatabaseBackendImpl::close(PassRefPtr<IDBDatabaseCallbacks> prpCallbacks)
+void IDBDatabaseBackendImpl::close(IDBDatabaseCallbacks* callbacks)
 {
-    RefPtr<IDBDatabaseCallbacks> callbacks = prpCallbacks;
     ASSERT(m_databaseCallbacksSet.contains(callbacks));
 
     // Close outstanding transactions from the closing connection. This can not happen
@@ -1385,4 +1384,12 @@ void IDBDatabaseBackendImpl::VersionChangeAbortOperation::perform(IDBTransaction
     m_database->m_metadata.intVersion = m_previousIntVersion;
 }
 
+void IDBDatabaseBackendImpl::trace(Visitor* visitor) const
+{
+    visitor->visit(m_factory);
+    for (DatabaseCallbacksSet::const_iterator it = m_databaseCallbacksSet.begin(); it != m_databaseCallbacksSet.end(); ++it) {
+        visitor->visit(*it);
+    }
+}
+
 } // namespace WebCore