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

Source/modules/indexeddb/IDBDatabaseBackendImpl.cpp

 /*
  * Copyright (C) 2011 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 23 matching lines @@
 #include "modules/indexeddb/IDBKeyRange.h"
 #include "modules/indexeddb/IDBObjectStoreBackendImpl.h"
 #include "modules/indexeddb/IDBTracing.h"
 #include "modules/indexeddb/IDBTransactionBackendImpl.h"
 #include "modules/indexeddb/IDBTransactionCoordinator.h"
 #include <public/Platform.h>
 #include "wtf/TemporaryChange.h"
 
 namespace WebCore {
 
+DEFINE_GC_INFO(IDBDatabaseBackendInterface);
+
 class CreateObjectStoreOperation : public IDBTransactionBackendImpl::Operation {
 public:
     static PassOwnPtr<IDBTransactionBackendImpl::Operation> create(PassRefPtr<IDBBackingStore> backingStore, const IDBObjectStoreMetadata& objectStoreMetadata)
     {
         return adoptPtr(new CreateObjectStoreOperation(backingStore, objectStoreMetadata));
     }
     virtual void perform(IDBTransactionBackendImpl*);
 private:
     CreateObjectStoreOperation(PassRefPtr<IDBBackingStore> backingStore, const IDBObjectStoreMetadata& objectStoreMetadata)
         : m_backingStore(backingStore)
@@ skipping 18 matching lines @@
         , m_objectStoreMetadata(objectStoreMetadata)
     {
     }
 
     const RefPtr<IDBBackingStore> m_backingStore;
     const IDBObjectStoreMetadata m_objectStoreMetadata;
 };
 
 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, 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, IDBCallbacks* callbacks, IDBDatabaseCallbacks* databaseCallbacks)
         : m_database(database)
         , m_transactionId(transactionId)
         , m_version(version)
         , m_callbacks(callbacks)
         , m_databaseCallbacks(databaseCallbacks)
     {
     }
 
-    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<IDBCallbacks> m_callbacks;
+    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;
 };
 
 class CreateIndexOperation : public IDBTransactionBackendImpl::Operation {
 public:
     static PassOwnPtr<IDBTransactionBackendImpl::Operation> create(PassRefPtr<IDBBackingStore> backingStore, int64_t objectStoreId, const IDBIndexMetadata& indexMetadata)
     {
         return adoptPtr(new CreateIndexOperation(backingStore, objectStoreId, indexMetadata));
     }
@@ skipping 26 matching lines @@
     {
     }
 
     const RefPtr<IDBBackingStore> m_backingStore;
     const int64_t m_objectStoreId;
     const IDBIndexMetadata m_indexMetadata;
 };
 
 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;
 };
 
 class GetOperation : public IDBTransactionBackendImpl::Operation {
 public:
-    static PassOwnPtr<IDBTransactionBackendImpl::Operation> create(PassRefPtr<IDBBackingStore> backingStore, const IDBDatabaseMetadata& metadata, int64_t objectStoreId, int64_t indexId, PassRefPtr<IDBKeyRange> keyRange, IndexedDB::CursorType cursorType, PassRefPtr<IDBCallbacks> callbacks)
+    static PassOwnPtr<IDBTransactionBackendImpl::Operation> create(PassRefPtr<IDBBackingStore> backingStore, const IDBDatabaseMetadata& metadata, int64_t objectStoreId, int64_t indexId, PassRefPtr<IDBKeyRange> keyRange, IndexedDB::CursorType cursorType, IDBCallbacks* callbacks)
     {
         return adoptPtr(new GetOperation(backingStore, metadata, objectStoreId, indexId, keyRange, cursorType, callbacks));
     }
     virtual void perform(IDBTransactionBackendImpl*);
 private:
-    GetOperation(PassRefPtr<IDBBackingStore> backingStore, const IDBDatabaseMetadata& metadata, int64_t objectStoreId, int64_t indexId, PassRefPtr<IDBKeyRange> keyRange, IndexedDB::CursorType cursorType, PassRefPtr<IDBCallbacks> callbacks)
+    GetOperation(PassRefPtr<IDBBackingStore> backingStore, const IDBDatabaseMetadata& metadata, int64_t objectStoreId, int64_t indexId, PassRefPtr<IDBKeyRange> keyRange, IndexedDB::CursorType cursorType, IDBCallbacks* callbacks)
         : m_backingStore(backingStore)
         , m_databaseId(metadata.id)
         , m_objectStoreId(objectStoreId)
         , m_indexId(indexId)
         , m_keyPath(metadata.objectStores.get(objectStoreId).keyPath)
         , m_autoIncrement(metadata.objectStores.get(objectStoreId).autoIncrement)
         , m_keyRange(keyRange)
         , m_cursorType(cursorType)
         , m_callbacks(callbacks)
     {
         ASSERT(metadata.objectStores.contains(objectStoreId));
         ASSERT(metadata.objectStores.get(objectStoreId).id == objectStoreId);
     }
 
     const RefPtr<IDBBackingStore> m_backingStore;
     const int64_t m_databaseId;
     const int64_t m_objectStoreId;
     const int64_t m_indexId;
     const IDBKeyPath m_keyPath;
     const bool m_autoIncrement;
     const RefPtr<IDBKeyRange> m_keyRange;
     const IndexedDB::CursorType m_cursorType;
-    const RefPtr<IDBCallbacks> m_callbacks;
+    const Persistent<IDBCallbacks> m_callbacks;
 };
 
 class PutOperation : public IDBTransactionBackendImpl::Operation {
 public:
-    static PassOwnPtr<IDBTransactionBackendImpl::Operation> create(PassRefPtr<IDBBackingStore> backingStore, int64_t databaseId, const IDBObjectStoreMetadata& objectStore, PassRefPtr<SharedBuffer> value, PassRefPtr<IDBKey> key, IDBDatabaseBackendInterface::PutMode putMode, PassRefPtr<IDBCallbacks> callbacks, const Vector<int64_t>& indexIds, const Vector<IDBDatabaseBackendInterface::IndexKeys>& indexKeys)
+    static PassOwnPtr<IDBTransactionBackendImpl::Operation> create(PassRefPtr<IDBBackingStore> backingStore, int64_t databaseId, const IDBObjectStoreMetadata& objectStore, PassRefPtr<SharedBuffer> value, PassRefPtr<IDBKey> key, IDBDatabaseBackendInterface::PutMode putMode, IDBCallbacks* callbacks, const Vector<int64_t>& indexIds, const Vector<IDBDatabaseBackendInterface::IndexKeys>& indexKeys)
     {
         return adoptPtr(new PutOperation(backingStore, databaseId, objectStore, value, key, putMode, callbacks, indexIds, indexKeys));
     }
     virtual void perform(IDBTransactionBackendImpl*);
 private:
-    PutOperation(PassRefPtr<IDBBackingStore> backingStore, int64_t databaseId, const IDBObjectStoreMetadata& objectStore, PassRefPtr<SharedBuffer>& value, PassRefPtr<IDBKey> key, IDBDatabaseBackendInterface::PutMode putMode, PassRefPtr<IDBCallbacks> callbacks, const Vector<int64_t>& indexIds, const Vector<IDBDatabaseBackendInterface::IndexKeys>& indexKeys)
+    PutOperation(PassRefPtr<IDBBackingStore> backingStore, int64_t databaseId, const IDBObjectStoreMetadata& objectStore, PassRefPtr<SharedBuffer>& value, PassRefPtr<IDBKey> key, IDBDatabaseBackendInterface::PutMode putMode, IDBCallbacks* callbacks, const Vector<int64_t>& indexIds, const Vector<IDBDatabaseBackendInterface::IndexKeys>& indexKeys)
         : m_backingStore(backingStore)
         , m_databaseId(databaseId)
         , m_objectStore(objectStore)
         , m_value(value)
         , m_key(key)
         , m_putMode(putMode)
         , m_callbacks(callbacks)
         , m_indexIds(indexIds)
         , m_indexKeys(indexKeys)
     {
     }
 
     const RefPtr<IDBBackingStore> m_backingStore;
     const int64_t m_databaseId;
     const IDBObjectStoreMetadata m_objectStore;
     const RefPtr<SharedBuffer> m_value;
     const RefPtr<IDBKey> m_key;
     const IDBDatabaseBackendInterface::PutMode m_putMode;
-    const RefPtr<IDBCallbacks> m_callbacks;
+    const Persistent<IDBCallbacks> m_callbacks;
     const Vector<int64_t> m_indexIds;
     const Vector<IDBDatabaseBackendInterface::IndexKeys> m_indexKeys;
 };
 
 class SetIndexesReadyOperation : public IDBTransactionBackendImpl::Operation {
 public:
     static PassOwnPtr<IDBTransactionBackendImpl::Operation> create(size_t indexCount)
     {
         return adoptPtr(new SetIndexesReadyOperation(indexCount));
     }
     virtual void perform(IDBTransactionBackendImpl*);
 private:
     SetIndexesReadyOperation(size_t indexCount)
         : m_indexCount(indexCount)
     {
     }
 
     const size_t m_indexCount;
 };
 
 class OpenCursorOperation : public IDBTransactionBackendImpl::Operation {
 public:
-    static PassOwnPtr<IDBTransactionBackendImpl::Operation> create(PassRefPtr<IDBBackingStore> backingStore, int64_t databaseId, int64_t objectStoreId, int64_t indexId, PassRefPtr<IDBKeyRange> keyRange, IndexedDB::CursorDirection direction, IndexedDB::CursorType cursorType, IDBDatabaseBackendInterface::TaskType taskType, PassRefPtr<IDBCallbacks> callbacks)
+    static PassOwnPtr<IDBTransactionBackendImpl::Operation> create(PassRefPtr<IDBBackingStore> backingStore, int64_t databaseId, int64_t objectStoreId, int64_t indexId, PassRefPtr<IDBKeyRange> keyRange, IndexedDB::CursorDirection direction, IndexedDB::CursorType cursorType, IDBDatabaseBackendInterface::TaskType taskType, IDBCallbacks* callbacks)
     {
         return adoptPtr(new OpenCursorOperation(backingStore, databaseId, objectStoreId, indexId, keyRange, direction, cursorType, taskType, callbacks));
     }
     virtual void perform(IDBTransactionBackendImpl*);
 private:
-    OpenCursorOperation(PassRefPtr<IDBBackingStore> backingStore, int64_t databaseId, int64_t objectStoreId, int64_t indexId, PassRefPtr<IDBKeyRange> keyRange, IndexedDB::CursorDirection direction, IndexedDB::CursorType cursorType, IDBDatabaseBackendInterface::TaskType taskType, PassRefPtr<IDBCallbacks> callbacks)
+    OpenCursorOperation(PassRefPtr<IDBBackingStore> backingStore, int64_t databaseId, int64_t objectStoreId, int64_t indexId, PassRefPtr<IDBKeyRange> keyRange, IndexedDB::CursorDirection direction, IndexedDB::CursorType cursorType, IDBDatabaseBackendInterface::TaskType taskType, IDBCallbacks* callbacks)
         : m_backingStore(backingStore)
         , m_databaseId(databaseId)
         , m_objectStoreId(objectStoreId)
         , m_indexId(indexId)
         , m_keyRange(keyRange)
         , m_direction(direction)
         , m_cursorType(cursorType)
         , m_taskType(taskType)
         , m_callbacks(callbacks)
     {
     }
 
     const RefPtr<IDBBackingStore> m_backingStore;
     const int64_t m_databaseId;
     const int64_t m_objectStoreId;
     const int64_t m_indexId;
     const PassRefPtr<IDBKeyRange> m_keyRange;
     const IndexedDB::CursorDirection m_direction;
     const IndexedDB::CursorType m_cursorType;
     const IDBDatabaseBackendInterface::TaskType m_taskType;
-    const RefPtr<IDBCallbacks> m_callbacks;
+    const Persistent<IDBCallbacks> m_callbacks;
 };
 
 class CountOperation : public IDBTransactionBackendImpl::Operation {
 public:
-    static PassOwnPtr<IDBTransactionBackendImpl::Operation> create(PassRefPtr<IDBBackingStore> backingStore, int64_t databaseId, int64_t objectStoreId, int64_t indexId, PassRefPtr<IDBKeyRange> keyRange, PassRefPtr<IDBCallbacks> callbacks)
+    static PassOwnPtr<IDBTransactionBackendImpl::Operation> create(PassRefPtr<IDBBackingStore> backingStore, int64_t databaseId, int64_t objectStoreId, int64_t indexId, PassRefPtr<IDBKeyRange> keyRange, IDBCallbacks* callbacks)
     {
         return adoptPtr(new CountOperation(backingStore, databaseId, objectStoreId, indexId, keyRange, callbacks));
     }
     virtual void perform(IDBTransactionBackendImpl*);
 private:
-    CountOperation(PassRefPtr<IDBBackingStore> backingStore, int64_t databaseId, int64_t objectStoreId, int64_t indexId, PassRefPtr<IDBKeyRange> keyRange, PassRefPtr<IDBCallbacks> callbacks)
+    CountOperation(PassRefPtr<IDBBackingStore> backingStore, int64_t databaseId, int64_t objectStoreId, int64_t indexId, PassRefPtr<IDBKeyRange> keyRange, IDBCallbacks* callbacks)
         : m_backingStore(backingStore)
         , m_databaseId(databaseId)
         , m_objectStoreId(objectStoreId)
         , m_indexId(indexId)
         , m_keyRange(keyRange)
         , m_callbacks(callbacks)
     {
     }
 
     const RefPtr<IDBBackingStore> m_backingStore;
     const int64_t m_databaseId;
     const int64_t m_objectStoreId;
     const int64_t m_indexId;
     const RefPtr<IDBKeyRange> m_keyRange;
-    const RefPtr<IDBCallbacks> m_callbacks;
+    const Persistent<IDBCallbacks> m_callbacks;
 };
 
 class DeleteRangeOperation : public IDBTransactionBackendImpl::Operation {
 public:
-    static PassOwnPtr<IDBTransactionBackendImpl::Operation> create(PassRefPtr<IDBBackingStore> backingStore, int64_t databaseId, int64_t objectStoreId, PassRefPtr<IDBKeyRange> keyRange, PassRefPtr<IDBCallbacks> callbacks)
+    static PassOwnPtr<IDBTransactionBackendImpl::Operation> create(PassRefPtr<IDBBackingStore> backingStore, int64_t databaseId, int64_t objectStoreId, PassRefPtr<IDBKeyRange> keyRange, IDBCallbacks* callbacks)
     {
         return adoptPtr(new DeleteRangeOperation(backingStore, databaseId, objectStoreId, keyRange, callbacks));
     }
     virtual void perform(IDBTransactionBackendImpl*);
 private:
-    DeleteRangeOperation(PassRefPtr<IDBBackingStore> backingStore, int64_t databaseId, int64_t objectStoreId, PassRefPtr<IDBKeyRange> keyRange, PassRefPtr<IDBCallbacks> callbacks)
+    DeleteRangeOperation(PassRefPtr<IDBBackingStore> backingStore, int64_t databaseId, int64_t objectStoreId, PassRefPtr<IDBKeyRange> keyRange, IDBCallbacks* callbacks)
         : m_backingStore(backingStore)
         , m_databaseId(databaseId)
         , m_objectStoreId(objectStoreId)
         , m_keyRange(keyRange)
         , m_callbacks(callbacks)
     {
     }
 
     const RefPtr<IDBBackingStore> m_backingStore;
     const int64_t m_databaseId;
     const int64_t m_objectStoreId;
     const RefPtr<IDBKeyRange> m_keyRange;
-    const RefPtr<IDBCallbacks> m_callbacks;
+    const Persistent<IDBCallbacks> m_callbacks;
 };
 
 class ClearOperation : public IDBTransactionBackendImpl::Operation {
 public:
-    static PassOwnPtr<IDBTransactionBackendImpl::Operation> create(PassRefPtr<IDBBackingStore> backingStore, int64_t databaseId, int64_t objectStoreId, PassRefPtr<IDBCallbacks> callbacks)
+    static PassOwnPtr<IDBTransactionBackendImpl::Operation> create(PassRefPtr<IDBBackingStore> backingStore, int64_t databaseId, int64_t objectStoreId, IDBCallbacks* callbacks)
     {
         return adoptPtr(new ClearOperation(backingStore, databaseId, objectStoreId, callbacks));
     }
     virtual void perform(IDBTransactionBackendImpl*);
 private:
-    ClearOperation(PassRefPtr<IDBBackingStore> backingStore, int64_t databaseId, int64_t objectStoreId, PassRefPtr<IDBCallbacks> callbacks)
+    ClearOperation(PassRefPtr<IDBBackingStore> backingStore, int64_t databaseId, int64_t objectStoreId, IDBCallbacks* callbacks)
         : m_backingStore(backingStore)
         , m_databaseId(databaseId)
         , m_objectStoreId(objectStoreId)
         , m_callbacks(callbacks)
     {
     }
 
     const RefPtr<IDBBackingStore> m_backingStore;
     const int64_t m_databaseId;
     const int64_t m_objectStoreId;
-    const RefPtr<IDBCallbacks> m_callbacks;
+    const Persistent<IDBCallbacks> m_callbacks;
 };
 
 class IDBDatabaseBackendImpl::PendingOpenCall {
 public:
-    static PassOwnPtr<PendingOpenCall> create(PassRefPtr<IDBCallbacks> callbacks, PassRefPtr<IDBDatabaseCallbacks> databaseCallbacks, int64_t transactionId, int64_t version)
+    static PassOwnPtr<PendingOpenCall> create(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; }
+    IDBCallbacks* callbacks() { return m_callbacks; }
+    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(IDBCallbacks* callbacks, IDBDatabaseCallbacks* databaseCallbacks, int64_t transactionId, int64_t version)
         : m_callbacks(callbacks)
         , m_databaseCallbacks(databaseCallbacks)
         , m_version(version)
         , m_transactionId(transactionId)
     {
     }
-    RefPtr<IDBCallbacks> m_callbacks;
-    RefPtr<IDBDatabaseCallbacks> m_databaseCallbacks;
+    Persistent<IDBCallbacks> m_callbacks;
+    Persistent<IDBDatabaseCallbacks> m_databaseCallbacks;
     int64_t m_version;
     const int64_t m_transactionId;
 };
 
 class IDBDatabaseBackendImpl::PendingDeleteCall {
 public:
-    static PassOwnPtr<PendingDeleteCall> create(PassRefPtr<IDBCallbacks> callbacks)
+    static PassOwnPtr<PendingDeleteCall> create(IDBCallbacks* callbacks)
     {
         return adoptPtr(new PendingDeleteCall(callbacks));
     }
-    PassRefPtr<IDBCallbacks> callbacks() { return m_callbacks; }
+    IDBCallbacks* callbacks() { return m_callbacks; }
 
 private:
-    PendingDeleteCall(PassRefPtr<IDBCallbacks> callbacks)
+    PendingDeleteCall(IDBCallbacks* callbacks)
         : m_callbacks(callbacks)
     {
     }
-    RefPtr<IDBCallbacks> m_callbacks;
+    Persistent<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 {
 const char* NoStringVersion = "";
 }
 
 IDBDatabaseBackendImpl::IDBDatabaseBackendImpl(const String& name, IDBBackingStore* backingStore, IDBFactoryBackendImpl* factory, const String& uniqueIdentifier)
     : m_backingStore(backingStore)
     , m_metadata(name, InvalidId, NoStringVersion, IDBDatabaseMetadata::NoIntVersion, InvalidId)
     , m_identifier(uniqueIdentifier)
@@ skipping 192 matching lines @@
         m_transactions.get(transactionId)->abort();
 }
 
 void IDBDatabaseBackendImpl::abort(int64_t transactionId, PassRefPtr<IDBDatabaseError> error)
 {
     // If the transaction is unknown, then it has already been aborted by the backend before this call so it is safe to ignore it.
     if (m_transactions.contains(transactionId))
         m_transactions.get(transactionId)->abort(error);
 }
 
-void IDBDatabaseBackendImpl::get(int64_t transactionId, int64_t objectStoreId, int64_t indexId, PassRefPtr<IDBKeyRange> keyRange, bool keyOnly, PassRefPtr<IDBCallbacks> callbacks)
+void IDBDatabaseBackendImpl::get(int64_t transactionId, int64_t objectStoreId, int64_t indexId, PassRefPtr<IDBKeyRange> keyRange, bool keyOnly, IDBCallbacks* callbacks)
 {
     IDB_TRACE("IDBDatabaseBackendImpl::get");
     IDBTransactionBackendImpl* transaction = m_transactions.get(transactionId);
     if (!transaction)
         return;
 
     transaction->scheduleTask(GetOperation::create(m_backingStore, m_metadata, objectStoreId, indexId, keyRange, keyOnly ? IndexedDB::CursorKeyOnly : IndexedDB::CursorKeyAndValue, callbacks));
 }
 
 void GetOperation::perform(IDBTransactionBackendImpl* transaction)
@@ skipping 81 matching lines @@
         m_callbacks->onSuccess();
         return;
     }
     if (m_autoIncrement && !m_keyPath.isNull()) {
         m_callbacks->onSuccess(SharedBuffer::adoptVector(value), primaryKey, m_keyPath);
         return;
     }
     m_callbacks->onSuccess(SharedBuffer::adoptVector(value));
 }
 
-void IDBDatabaseBackendImpl::put(int64_t transactionId, int64_t objectStoreId, PassRefPtr<SharedBuffer> value, PassRefPtr<IDBKey> key, PutMode putMode, PassRefPtr<IDBCallbacks> callbacks, const Vector<int64_t>& indexIds, const Vector<IndexKeys>& indexKeys)
+void IDBDatabaseBackendImpl::put(int64_t transactionId, int64_t objectStoreId, PassRefPtr<SharedBuffer> value, PassRefPtr<IDBKey> key, PutMode putMode, IDBCallbacks* callbacks, const Vector<int64_t>& indexIds, const Vector<IndexKeys>& indexKeys)
 {
     IDB_TRACE("IDBDatabaseBackendImpl::put");
     IDBTransactionBackendImpl* transaction = m_transactions.get(transactionId);
     if (!transaction)
         return;
     ASSERT(transaction->mode() != IndexedDB::TransactionReadOnly);
 
     const IDBObjectStoreMetadata objectStoreMetadata = m_metadata.objectStores.get(objectStoreId);
 
     ASSERT(objectStoreMetadata.autoIncrement || key.get());
@@ skipping 128 matching lines @@
     transaction->scheduleTask(IDBDatabaseBackendInterface::PreemptiveTask, SetIndexesReadyOperation::create(indexIds.size()));
 }
 
 void SetIndexesReadyOperation::perform(IDBTransactionBackendImpl* transaction)
 {
     IDB_TRACE("SetIndexesReadyOperation");
     for (size_t i = 0; i < m_indexCount; ++i)
         transaction->didCompletePreemptiveEvent();
 }
 
-void IDBDatabaseBackendImpl::openCursor(int64_t transactionId, int64_t objectStoreId, int64_t indexId, PassRefPtr<IDBKeyRange> keyRange, IndexedDB::CursorDirection direction, bool keyOnly, TaskType taskType, PassRefPtr<IDBCallbacks> callbacks)
+void IDBDatabaseBackendImpl::openCursor(int64_t transactionId, int64_t objectStoreId, int64_t indexId, PassRefPtr<IDBKeyRange> keyRange, IndexedDB::CursorDirection direction, bool keyOnly, TaskType taskType, IDBCallbacks* callbacks)
 {
     IDB_TRACE("IDBDatabaseBackendImpl::openCursor");
     IDBTransactionBackendImpl* transaction = m_transactions.get(transactionId);
     if (!transaction)
         return;
 
     transaction->scheduleTask(OpenCursorOperation::create(m_backingStore, id(), objectStoreId, indexId, keyRange, direction, keyOnly ? IndexedDB::CursorKeyOnly : IndexedDB::CursorKeyAndValue, taskType, callbacks));
 }
 
 void OpenCursorOperation::perform(IDBTransactionBackendImpl* transaction)
@@ skipping 22 matching lines @@
     if (!backingStoreCursor) {
         m_callbacks->onSuccess(static_cast<SharedBuffer*>(0));
         return;
     }
 
     IDBDatabaseBackendInterface::TaskType taskType(static_cast<IDBDatabaseBackendInterface::TaskType>(m_taskType));
     RefPtr<IDBCursorBackendImpl> cursor = IDBCursorBackendImpl::create(backingStoreCursor.get(), m_cursorType, taskType, transaction, m_objectStoreId);
     m_callbacks->onSuccess(cursor, cursor->key(), cursor->primaryKey(), cursor->value());
 }
 
-void IDBDatabaseBackendImpl::count(int64_t transactionId, int64_t objectStoreId, int64_t indexId, PassRefPtr<IDBKeyRange> keyRange, PassRefPtr<IDBCallbacks> callbacks)
+void IDBDatabaseBackendImpl::count(int64_t transactionId, int64_t objectStoreId, int64_t indexId, PassRefPtr<IDBKeyRange> keyRange, IDBCallbacks* callbacks)
 {
     IDB_TRACE("IDBDatabaseBackendImpl::count");
     IDBTransactionBackendImpl* transaction = m_transactions.get(transactionId);
     if (!transaction)
         return;
 
     ASSERT(m_metadata.objectStores.contains(objectStoreId));
     transaction->scheduleTask(CountOperation::create(m_backingStore, id(), objectStoreId, indexId, keyRange, callbacks));
 }
 
@@ skipping 12 matching lines @@
         return;
     }
 
     do {
         ++count;
     } while (backingStoreCursor->continueFunction(0));
 
     m_callbacks->onSuccess(count);
 }
 
-void IDBDatabaseBackendImpl::deleteRange(int64_t transactionId, int64_t objectStoreId, PassRefPtr<IDBKeyRange> keyRange, PassRefPtr<IDBCallbacks> callbacks)
+void IDBDatabaseBackendImpl::deleteRange(int64_t transactionId, int64_t objectStoreId, PassRefPtr<IDBKeyRange> keyRange, IDBCallbacks* callbacks)
 {
     IDB_TRACE("IDBDatabaseBackendImpl::deleteRange");
     IDBTransactionBackendImpl* transaction = m_transactions.get(transactionId);
     if (!transaction)
         return;
     ASSERT(transaction->mode() != IndexedDB::TransactionReadOnly);
 
     transaction->scheduleTask(DeleteRangeOperation::create(m_backingStore, id(), objectStoreId, keyRange, callbacks));
 }
 
 void DeleteRangeOperation::perform(IDBTransactionBackendImpl* transaction)
 {
     IDB_TRACE("DeleteRangeOperation");
     RefPtr<IDBBackingStore::Cursor> backingStoreCursor = m_backingStore->openObjectStoreCursor(transaction->backingStoreTransaction(), m_databaseId, m_objectStoreId, m_keyRange.get(), IndexedDB::CursorNext);
     if (backingStoreCursor) {
         do {
             if (!m_backingStore->deleteRecord(transaction->backingStoreTransaction(), m_databaseId, m_objectStoreId, backingStoreCursor->recordIdentifier())) {
                 m_callbacks->onError(IDBDatabaseError::create(IDBDatabaseException::UnknownError, "Error deleting data in range"));
                 return;
             }
         } while (backingStoreCursor->continueFunction(0));
     }
 
     m_callbacks->onSuccess();
 }
 
-void IDBDatabaseBackendImpl::clear(int64_t transactionId, int64_t objectStoreId, PassRefPtr<IDBCallbacks> callbacks)
+void IDBDatabaseBackendImpl::clear(int64_t transactionId, int64_t objectStoreId, IDBCallbacks* callbacks)
 {
     IDB_TRACE("IDBDatabaseBackendImpl::clear");
     IDBTransactionBackendImpl* transaction = m_transactions.get(transactionId);
     if (!transaction)
         return;
     ASSERT(transaction->mode() != IndexedDB::TransactionReadOnly);
 
     transaction->scheduleTask(ClearOperation::create(m_backingStore, id(), objectStoreId, callbacks));
 }
 
@@ skipping 115 matching lines @@
 
     // Open calls can be requeued if an open call started a version change transaction.
     Deque<OwnPtr<PendingOpenCall> > pendingOpenCalls;
     m_pendingOpenCalls.swap(pendingOpenCalls);
     while (!pendingOpenCalls.isEmpty()) {
         OwnPtr<PendingOpenCall> pendingOpenCall = pendingOpenCalls.takeFirst();
         openConnection(pendingOpenCall->callbacks(), pendingOpenCall->databaseCallbacks(), pendingOpenCall->transactionId(), pendingOpenCall->version());
     }
 }
 
-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(IDBCallbacks* callbacks, 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));
         return;
     }
 
     if (m_metadata.id == InvalidId) {
         // The database was deleted then immediately re-opened; openInternal() recreates it in the backing store.
         if (openInternal())
             ASSERT(m_metadata.intVersion == IDBDatabaseMetadata::NoIntVersion);
@@ skipping 16 matching lines @@
         // For unit tests only - skip upgrade steps. Calling from script with DefaultIntVersion throws exception.
         ASSERT(WebKit::Platform::current()->unitTestSupport());
         ASSERT(isNewDatabase);
         m_databaseCallbacksSet.add(databaseCallbacks);
         callbacks->onSuccess(this, this->metadata());
         return;
     }
 
     if (version == IDBDatabaseMetadata::NoIntVersion) {
         if (!isNewDatabase) {
-            m_databaseCallbacksSet.add(RefPtr<IDBDatabaseCallbacks>(databaseCallbacks));
+            m_databaseCallbacksSet.add(databaseCallbacks);
             callbacks->onSuccess(this, this->metadata());
             return;
         }
         // Spec says: If no version is specified and no database exists, set database version to 1.
         version = 1;
     }
 
     if (version > m_metadata.intVersion) {
         runIntVersionChangeTransaction(callbacks, databaseCallbacks, transactionId, version);
         return;
     }
     if (version < m_metadata.intVersion) {
         callbacks->onError(IDBDatabaseError::create(IDBDatabaseException::VersionError, String::format("The requested version (%lld) is less than the existing version (%lld).", static_cast<long long>(version), static_cast<long long>(m_metadata.intVersion))));
         return;
     }
     ASSERT(version == m_metadata.intVersion);
     m_databaseCallbacksSet.add(databaseCallbacks);
     callbacks->onSuccess(this, this->metadata());
 }
 
-void IDBDatabaseBackendImpl::runIntVersionChangeTransaction(PassRefPtr<IDBCallbacks> prpCallbacks, PassRefPtr<IDBDatabaseCallbacks> prpDatabaseCallbacks, int64_t transactionId, int64_t requestedVersion)
+void IDBDatabaseBackendImpl::runIntVersionChangeTransaction(IDBCallbacks* callbacks, 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.
         if (*it != databaseCallbacks)
             (*it)->onVersionChange(m_metadata.intVersion, requestedVersion);
     }
     // The spec dictates we wait until all the version change events are
     // delivered and then check m_databaseCallbacks.empty() before proceeding
     // or firing a blocked event, but instead we should be consistent with how
     // the old setVersion (incorrectly) did it.
@@ skipping 11 matching lines @@
     Vector<int64_t> objectStoreIds;
     createTransaction(transactionId, databaseCallbacks, objectStoreIds, IndexedDB::TransactionVersionChange);
     RefPtr<IDBTransactionBackendImpl> transaction = m_transactions.get(transactionId);
 
     transaction->scheduleTask(VersionChangeOperation::create(this, transactionId, requestedVersion, callbacks, databaseCallbacks), VersionChangeAbortOperation::create(this, m_metadata.version, m_metadata.intVersion));
 
     ASSERT(!m_pendingSecondHalfOpen);
     m_databaseCallbacksSet.add(databaseCallbacks);
 }
 
-void IDBDatabaseBackendImpl::deleteDatabase(PassRefPtr<IDBCallbacks> prpCallbacks)
+void IDBDatabaseBackendImpl::deleteDatabase(IDBCallbacks* callbacks)
 {
-    RefPtr<IDBCallbacks> callbacks = prpCallbacks;
     if (isDeleteDatabaseBlocked()) {
         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.
             (*it)->onVersionChange(m_metadata.intVersion, IDBDatabaseMetadata::NoIntVersion);
         }
         // FIXME: Only fire onBlocked if there are open connections after the
         // VersionChangeEvents are received, not just set up to fire.
         // https://bugs.webkit.org/show_bug.cgi?id=71130
         callbacks->onBlocked(m_metadata.intVersion);
-        m_pendingDeleteCalls.append(PendingDeleteCall::create(callbacks.release()));
+        m_pendingDeleteCalls.append(PendingDeleteCall::create(callbacks));
         return;
     }
-    deleteDatabaseFinal(callbacks.release());
+    deleteDatabaseFinal(callbacks);
 }
 
 bool IDBDatabaseBackendImpl::isDeleteDatabaseBlocked()
 {
     return connectionCount();
 }
 
-void IDBDatabaseBackendImpl::deleteDatabaseFinal(PassRefPtr<IDBCallbacks> callbacks)
+void IDBDatabaseBackendImpl::deleteDatabaseFinal(IDBCallbacks* callbacks)
 {
     ASSERT(!isDeleteDatabaseBlocked());
     ASSERT(m_backingStore);
     if (!m_backingStore->deleteDatabase(m_metadata.name)) {
         callbacks->onError(IDBDatabaseError::create(IDBDatabaseException::UnknownError, "Internal error deleting database."));
         return;
     }
     m_metadata.version = NoStringVersion;
     m_metadata.id = InvalidId;
     m_metadata.intVersion = IDBDatabaseMetadata::NoIntVersion;
     m_metadata.objectStores.clear();
     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
     // if the close is requested by the connection itself as the front-end defers
     // the close until all transactions are complete, so something unusual has happened
     // e.g. unexpected process termination.
     {
         TransactionMap transactions(m_transactions);
         for (TransactionMap::const_iterator::Values it = transactions.values().begin(), end = transactions.values().end(); it != end; ++it) {
             if ((*it)->connection() == callbacks)
@@ skipping 48 matching lines @@
 }
 
 void IDBDatabaseBackendImpl::VersionChangeAbortOperation::perform(IDBTransactionBackendImpl* transaction)
 {
     IDB_TRACE("VersionChangeAbortOperation");
     ASSERT(!transaction);
     m_database->m_metadata.version = m_previousVersion;
     m_database->m_metadata.intVersion = m_previousIntVersion;
 }
 
+void IDBDatabaseBackendImpl::trace(Visitor* visitor)
+{
+    visitor->trace(m_factory);
+    visitor->trace(m_databaseCallbacksSet);
+}
+
 } // namespace WebCore