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

Source/WebKit/chromium/tests/IDBDatabaseBackendTest.cpp

Index: Source/WebKit/chromium/tests/IDBDatabaseBackendTest.cpp
diff --git a/Source/WebKit/chromium/tests/IDBDatabaseBackendTest.cpp b/Source/WebKit/chromium/tests/IDBDatabaseBackendTest.cpp
index 656705c300352de17b44b9618dac9616e33fcdf7..603967b4198e7248356bb82c47de7d406ce63096 100644
--- a/Source/WebKit/chromium/tests/IDBDatabaseBackendTest.cpp
+++ b/Source/WebKit/chromium/tests/IDBDatabaseBackendTest.cpp
@@ -51,20 +51,22 @@ namespace {
 
 TEST(IDBDatabaseBackendTest, BackingStoreRetention)
 {
-    RefPtr<IDBFakeBackingStore> backingStore = adoptRef(new IDBFakeBackingStore());
-    EXPECT_TRUE(backingStore->hasOneRef());
-
-    IDBFactoryBackendImpl* factory = 0;
-    RefPtr<IDBDatabaseBackendImpl> db = IDBDatabaseBackendImpl::create("db", backingStore.get(), factory, "uniqueid");
-    EXPECT_GT(backingStore->refCount(), 1);
+    RefPtr<IDBFakeBackingStore> backingStore;
+    {
+        backingStore = adoptRef(new IDBFakeBackingStore());
+        EXPECT_TRUE(backingStore->hasOneRef());
 
-    db.clear();
+        IDBFactoryBackendImpl* factory = 0;
+        IDBDatabaseBackendImpl::create("db", backingStore.get(), factory, "uniqueid");
+        EXPECT_GT(backingStore->refCount(), 1);
+    }
+    Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
     EXPECT_TRUE(backingStore->hasOneRef());
 }
 
 class MockIDBCallbacks : public IDBCallbacks {
 public:
-    static PassRefPtr<MockIDBCallbacks> create() { return adoptRef(new MockIDBCallbacks()); }
+    static MockIDBCallbacks* create() { return new MockIDBCallbacks(); }
     virtual ~MockIDBCallbacks()
     {
         EXPECT_TRUE(m_wasSuccessDBCalled);
@@ -72,7 +74,7 @@ public:
     virtual void onError(PassRefPtr<IDBDatabaseError>) OVERRIDE { }
     virtual void onSuccess(const Vector<String>&) OVERRIDE { }
     virtual void onSuccess(PassRefPtr<IDBCursorBackendInterface>, PassRefPtr<IDBKey>, PassRefPtr<IDBKey>, PassRefPtr<SharedBuffer>) OVERRIDE { }
-    virtual void onSuccess(PassRefPtr<IDBDatabaseBackendInterface>, const IDBDatabaseMetadata&) OVERRIDE
+    virtual void onSuccess(IDBDatabaseBackendInterface*, const IDBDatabaseMetadata&) OVERRIDE
     {
         m_wasSuccessDBCalled = true;
     }
@@ -91,12 +93,13 @@ private:
 
 class FakeIDBDatabaseCallbacks : public IDBDatabaseCallbacks {
 public:
-    static PassRefPtr<FakeIDBDatabaseCallbacks> create() { return adoptRef(new FakeIDBDatabaseCallbacks()); }
+    static FakeIDBDatabaseCallbacks* create() { return new FakeIDBDatabaseCallbacks(); }
     virtual ~FakeIDBDatabaseCallbacks() { }
     virtual void onVersionChange(int64_t oldVersion, int64_t newVersion) OVERRIDE { }
     virtual void onForcedClose() OVERRIDE { }
     virtual void onAbort(int64_t transactionId, PassRefPtr<IDBDatabaseError> error) OVERRIDE { }
     virtual void onComplete(int64_t transactionId) OVERRIDE { }
+    virtual void trace(Visitor*) OVERRIDE { }
 private:
     FakeIDBDatabaseCallbacks() { }
 };
@@ -107,15 +110,15 @@ TEST(IDBDatabaseBackendTest, ConnectionLifecycle)
     EXPECT_TRUE(backingStore->hasOneRef());
 
     IDBFactoryBackendImpl* factory = 0;
-    RefPtr<IDBDatabaseBackendImpl> db = IDBDatabaseBackendImpl::create("db", backingStore.get(), factory, "uniqueid");
+    IDBDatabaseBackendImpl* db = IDBDatabaseBackendImpl::create("db", backingStore.get(), factory, "uniqueid");
     EXPECT_GT(backingStore->refCount(), 1);
 
-    RefPtr<MockIDBCallbacks> request1 = MockIDBCallbacks::create();
-    RefPtr<FakeIDBDatabaseCallbacks> connection1 = FakeIDBDatabaseCallbacks::create();
+    MockIDBCallbacks* request1 = MockIDBCallbacks::create();
+    FakeIDBDatabaseCallbacks* connection1 = FakeIDBDatabaseCallbacks::create();
     db->openConnection(request1, connection1, 1, IDBDatabaseMetadata::DefaultIntVersion);
 
-    RefPtr<MockIDBCallbacks> request2 = MockIDBCallbacks::create();
-    RefPtr<FakeIDBDatabaseCallbacks> connection2 = FakeIDBDatabaseCallbacks::create();
+    MockIDBCallbacks* request2 = MockIDBCallbacks::create();
+    FakeIDBDatabaseCallbacks* connection2 = FakeIDBDatabaseCallbacks::create();
     db->openConnection(request2, connection2, 2, IDBDatabaseMetadata::DefaultIntVersion);
 
     db->close(connection1);
@@ -127,9 +130,9 @@ TEST(IDBDatabaseBackendTest, ConnectionLifecycle)
 
 class MockIDBDatabaseBackendProxy : public IDBDatabaseBackendInterface {
 public:
-    static PassRefPtr<MockIDBDatabaseBackendProxy> create(WebIDBDatabaseImpl* database)
+    static MockIDBDatabaseBackendProxy* create(WebIDBDatabaseImpl* database)
     {
-        return adoptRef(new MockIDBDatabaseBackendProxy(database));
+        return new MockIDBDatabaseBackendProxy(database);
     }
 
     ~MockIDBDatabaseBackendProxy()
@@ -141,9 +144,9 @@ public:
     virtual IDBDatabaseMetadata metadata() const { return IDBDatabaseMetadata(); }
     virtual void createObjectStore(int64_t transactionId, int64_t objectStoreId, const String& name, const IDBKeyPath&, bool autoIncrement) OVERRIDE { };
     virtual void deleteObjectStore(int64_t transactionId, int64_t objectStoreId) OVERRIDE { }
-    virtual void createTransaction(int64_t, PassRefPtr<IDBDatabaseCallbacks>, const Vector<int64_t>&, unsigned short mode) OVERRIDE { }
+    virtual void createTransaction(int64_t, IDBDatabaseCallbacks*, const Vector<int64_t>&, unsigned short mode) OVERRIDE { }
 
-    virtual void close(PassRefPtr<IDBDatabaseCallbacks>) OVERRIDE
+    virtual void close(IDBDatabaseCallbacks*) OVERRIDE
     {
         m_wasCloseCalled = true;
         m_webDatabase->close();
@@ -153,18 +156,20 @@ public:
     virtual void abort(int64_t transactionId, PassRefPtr<IDBDatabaseError>) OVERRIDE { }
     virtual void commit(int64_t transactionId) OVERRIDE { }
 
-    virtual void openCursor(int64_t transactionId, int64_t objectStoreId, int64_t indexId, PassRefPtr<IDBKeyRange>, IndexedDB::CursorDirection, bool keyOnly, TaskType, PassRefPtr<IDBCallbacks>) OVERRIDE { }
-    virtual void count(int64_t objectStoreId, int64_t indexId, int64_t transactionId, PassRefPtr<IDBKeyRange>, PassRefPtr<IDBCallbacks>) OVERRIDE { }
-    virtual void get(int64_t objectStoreId, int64_t indexId, int64_t transactionId, PassRefPtr<IDBKeyRange>, bool keyOnly, PassRefPtr<IDBCallbacks>) OVERRIDE { }
-    virtual void put(int64_t transactionId, int64_t objectStoreId, PassRefPtr<SharedBuffer>, PassRefPtr<IDBKey>, PutMode, PassRefPtr<IDBCallbacks>, const Vector<int64_t>& indexIds, const Vector<IndexKeys>&) OVERRIDE { }
+    virtual void openCursor(int64_t transactionId, int64_t objectStoreId, int64_t indexId, PassRefPtr<IDBKeyRange>, IndexedDB::CursorDirection, bool keyOnly, TaskType, IDBCallbacks*) OVERRIDE { }
+    virtual void count(int64_t objectStoreId, int64_t indexId, int64_t transactionId, PassRefPtr<IDBKeyRange>, IDBCallbacks*) OVERRIDE { }
+    virtual void get(int64_t objectStoreId, int64_t indexId, int64_t transactionId, PassRefPtr<IDBKeyRange>, bool keyOnly, IDBCallbacks*) OVERRIDE { }
+    virtual void put(int64_t transactionId, int64_t objectStoreId, PassRefPtr<SharedBuffer>, PassRefPtr<IDBKey>, PutMode, IDBCallbacks*, const Vector<int64_t>& indexIds, const Vector<IndexKeys>&) OVERRIDE { }
     virtual void setIndexKeys(int64_t transactionId, int64_t objectStoreId, PassRefPtr<IDBKey> prpPrimaryKey, const Vector<int64_t>& indexIds, const Vector<IndexKeys>&) OVERRIDE { }
     virtual void setIndexesReady(int64_t transactionId, int64_t objectStoreId, const Vector<int64_t>& indexIds) OVERRIDE { }
-    virtual void deleteRange(int64_t transactionId, int64_t objectStoreId, PassRefPtr<IDBKeyRange>, PassRefPtr<IDBCallbacks>) OVERRIDE { }
-    virtual void clear(int64_t transactionId, int64_t objectStoreId, PassRefPtr<IDBCallbacks>) OVERRIDE { }
+    virtual void deleteRange(int64_t transactionId, int64_t objectStoreId, PassRefPtr<IDBKeyRange>, IDBCallbacks*) OVERRIDE { }
+    virtual void clear(int64_t transactionId, int64_t objectStoreId, IDBCallbacks*) OVERRIDE { }
 
     virtual void createIndex(int64_t transactionId, int64_t objectStoreId, int64_t indexId, const String& name, const IDBKeyPath&, bool unique, bool multiEntry) OVERRIDE { ASSERT_NOT_REACHED(); }
     virtual void deleteIndex(int64_t transactionId, int64_t objectStoreId, int64_t indexId) OVERRIDE { ASSERT_NOT_REACHED(); }
 
+    virtual void trace(Visitor*) { }
+
 private:
     MockIDBDatabaseBackendProxy(WebIDBDatabaseImpl* webDatabase)
         : m_wasCloseCalled(false)
@@ -177,7 +182,7 @@ private:
 
 class MockIDBDatabaseCallbacks : public IDBDatabaseCallbacks {
 public:
-    static PassRefPtr<MockIDBDatabaseCallbacks> create() { return adoptRef(new MockIDBDatabaseCallbacks()); }
+    static MockIDBDatabaseCallbacks* create() { return new MockIDBDatabaseCallbacks(); }
     virtual ~MockIDBDatabaseCallbacks()
     {
         EXPECT_TRUE(m_wasAbortCalled);
@@ -189,6 +194,7 @@ public:
         m_wasAbortCalled = true;
     }
     virtual void onComplete(int64_t transactionId) OVERRIDE { }
+    virtual void trace(Visitor*) OVERRIDE { }
 private:
     MockIDBDatabaseCallbacks()
         : m_wasAbortCalled(false) { }
@@ -201,15 +207,15 @@ TEST(IDBDatabaseBackendTest, ForcedClose)
     EXPECT_TRUE(backingStore->hasOneRef());
 
     IDBFactoryBackendImpl* factory = 0;
-    RefPtr<IDBDatabaseBackendImpl> backend = IDBDatabaseBackendImpl::create("db", backingStore.get(), factory, "uniqueid");
+    IDBDatabaseBackendImpl* backend = IDBDatabaseBackendImpl::create("db", backingStore.get(), factory, "uniqueid");
     EXPECT_GT(backingStore->refCount(), 1);
 
-    RefPtr<MockIDBDatabaseCallbacks> connection = MockIDBDatabaseCallbacks::create();
-    RefPtr<IDBDatabaseCallbacksProxy> connectionProxy = IDBDatabaseCallbacksProxy::create(adoptPtr(new WebIDBDatabaseCallbacksImpl(connection)));
+    MockIDBDatabaseCallbacks* connection = MockIDBDatabaseCallbacks::create();
+    IDBDatabaseCallbacksProxy* connectionProxy = IDBDatabaseCallbacksProxy::create(adoptPtr(new WebIDBDatabaseCallbacksImpl(connection)));
     WebIDBDatabaseImpl* webDatabase = new WebIDBDatabaseImpl(backend, connectionProxy);
 
-    RefPtr<MockIDBDatabaseBackendProxy> proxy = MockIDBDatabaseBackendProxy::create(webDatabase);
-    RefPtr<MockIDBCallbacks> request = MockIDBCallbacks::create();
+    MockIDBDatabaseBackendProxy* proxy = MockIDBDatabaseBackendProxy::create(webDatabase);
+    MockIDBCallbacks* request = MockIDBCallbacks::create();
     const int64_t upgradeTransactionId = 3;
     backend->openConnection(request, connectionProxy, upgradeTransactionId, IDBDatabaseMetadata::DefaultIntVersion);