Oilpan: Enable oilpan for callback classes

Source/modules/webdatabase/InspectorDatabaseAgent.cpp

 /*
  * Copyright (C) 2010 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 51 matching lines @@
 void reportTransactionFailed(ExecuteSQLCallback* requestCallback, SQLError* error)
 {
     RefPtr<TypeBuilder::Database::Error> errorObject = TypeBuilder::Database::Error::create()
         .setMessage(error->message())
         .setCode(error->code());
     requestCallback->sendSuccess(nullptr, nullptr, errorObject.release());
 }
 
 class StatementCallback FINAL : public SQLStatementCallback {
 public:
-    static PassOwnPtrWillBeRawPtr<StatementCallback> create(PassRefPtrWillBeRawPtr<ExecuteSQLCallback> requestCallback)
+    static StatementCallback* create(PassRefPtrWillBeRawPtr<ExecuteSQLCallback> requestCallback)
     {
-        return adoptPtrWillBeNoop(new StatementCallback(requestCallback));
+        return new StatementCallback(requestCallback);
     }
 
     virtual ~StatementCallback() { }
 
     virtual void trace(Visitor* visitor)
     {
         visitor->trace(m_requestCallback);
         SQLStatementCallback::trace(visitor);
     }
 
@@ skipping 21 matching lines @@
     }
 
 private:
     StatementCallback(PassRefPtrWillBeRawPtr<ExecuteSQLCallback> requestCallback)
         : m_requestCallback(requestCallback) { }
     RefPtrWillBeMember<ExecuteSQLCallback> m_requestCallback;
 };
 
 class StatementErrorCallback FINAL : public SQLStatementErrorCallback {
 public:
-    static PassOwnPtrWillBeRawPtr<StatementErrorCallback> create(PassRefPtrWillBeRawPtr<ExecuteSQLCallback> requestCallback)
+    static StatementErrorCallback* create(PassRefPtrWillBeRawPtr<ExecuteSQLCallback> requestCallback)
     {
-        return adoptPtrWillBeNoop(new StatementErrorCallback(requestCallback));
+        return new StatementErrorCallback(requestCallback);
     }
 
     virtual ~StatementErrorCallback() { }
 
     virtual void trace(Visitor* visitor) OVERRIDE
     {
         visitor->trace(m_requestCallback);
         SQLStatementErrorCallback::trace(visitor);
     }
 
     virtual bool handleEvent(SQLTransaction*, SQLError* error) OVERRIDE
     {
         reportTransactionFailed(m_requestCallback.get(), error);
         return true;
     }
 
 private:
     StatementErrorCallback(PassRefPtrWillBeRawPtr<ExecuteSQLCallback> requestCallback)
         : m_requestCallback(requestCallback) { }
     RefPtrWillBeMember<ExecuteSQLCallback> m_requestCallback;
 };
 
 class TransactionCallback FINAL : public SQLTransactionCallback {
 public:
-    static PassOwnPtrWillBeRawPtr<TransactionCallback> create(const String& sqlStatement, PassRefPtrWillBeRawPtr<ExecuteSQLCallback> requestCallback)
+    static TransactionCallback* create(const String& sqlStatement, PassRefPtrWillBeRawPtr<ExecuteSQLCallback> requestCallback)
     {
-        return adoptPtrWillBeNoop(new TransactionCallback(sqlStatement, requestCallback));
+        return new TransactionCallback(sqlStatement, requestCallback);
     }
 
     virtual ~TransactionCallback() { }
 
     virtual void trace(Visitor* visitor) OVERRIDE
     {
         visitor->trace(m_requestCallback);
         SQLTransactionCallback::trace(visitor);
     }
 
     virtual bool handleEvent(SQLTransaction* transaction) OVERRIDE
     {
         if (!m_requestCallback->isActive())
             return true;
 
         Vector<SQLValue> sqlValues;
-        OwnPtrWillBeRawPtr<SQLStatementCallback> callback(StatementCallback::create(m_requestCallback.get()));
-        OwnPtrWillBeRawPtr<SQLStatementErrorCallback> errorCallback(StatementErrorCallback::create(m_requestCallback.get()));
-        transaction->executeSQL(m_sqlStatement, sqlValues, callback.release(), errorCallback.release(), IGNORE_EXCEPTION);
+        SQLStatementCallback* callback = StatementCallback::create(m_requestCallback.get());
+        SQLStatementErrorCallback* errorCallback = StatementErrorCallback::create(m_requestCallback.get());
+        transaction->executeSQL(m_sqlStatement, sqlValues, callback, errorCallback, IGNORE_EXCEPTION);
         return true;
     }
 private:
     TransactionCallback(const String& sqlStatement, PassRefPtrWillBeRawPtr<ExecuteSQLCallback> requestCallback)
         : m_sqlStatement(sqlStatement)
         , m_requestCallback(requestCallback) { }
     String m_sqlStatement;
     RefPtrWillBeMember<ExecuteSQLCallback> m_requestCallback;
 };
 
 class TransactionErrorCallback FINAL : public SQLTransactionErrorCallback {
 public:
-    static PassOwnPtrWillBeRawPtr<TransactionErrorCallback> create(PassRefPtrWillBeRawPtr<ExecuteSQLCallback> requestCallback)
+    static TransactionErrorCallback* create(PassRefPtrWillBeRawPtr<ExecuteSQLCallback> requestCallback)
     {
-        return adoptPtrWillBeNoop(new TransactionErrorCallback(requestCallback));
+        return new TransactionErrorCallback(requestCallback);
     }
 
     virtual ~TransactionErrorCallback() { }
 
     virtual void trace(Visitor* visitor) OVERRIDE
     {
         visitor->trace(m_requestCallback);
         SQLTransactionErrorCallback::trace(visitor);
     }
 
     virtual bool handleEvent(SQLError* error) OVERRIDE
     {
         reportTransactionFailed(m_requestCallback.get(), error);
         return true;
     }
 private:
     TransactionErrorCallback(PassRefPtrWillBeRawPtr<ExecuteSQLCallback> requestCallback)
         : m_requestCallback(requestCallback) { }
     RefPtrWillBeMember<ExecuteSQLCallback> m_requestCallback;
 };
 
 class TransactionSuccessCallback FINAL : public VoidCallback {
 public:
-    static PassOwnPtrWillBeRawPtr<TransactionSuccessCallback> create()
+    static TransactionSuccessCallback* create()
     {
-        return adoptPtrWillBeNoop(new TransactionSuccessCallback());
+        return new TransactionSuccessCallback();
     }
 
     virtual ~TransactionSuccessCallback() { }
 
     virtual void handleEvent() OVERRIDE { }
 
 private:
     TransactionSuccessCallback() { }
 };
 
@@ skipping 91 matching lines @@
         requestCallback->sendFailure("Database agent is not enabled");
         return;
     }
 
     Database* database = databaseForId(databaseId);
     if (!database) {
         requestCallback->sendFailure("Database not found");
         return;
     }
 
-    OwnPtrWillBeRawPtr<SQLTransactionCallback> callback(TransactionCallback::create(query, requestCallback.get()));
-    OwnPtrWillBeRawPtr<SQLTransactionErrorCallback> errorCallback(TransactionErrorCallback::create(requestCallback.get()));
-    OwnPtrWillBeRawPtr<VoidCallback> successCallback(TransactionSuccessCallback::create());
-    database->transaction(callback.release(), errorCallback.release(), successCallback.release());
+    SQLTransactionCallback* callback = TransactionCallback::create(query, requestCallback.get());
+    SQLTransactionErrorCallback* errorCallback = TransactionErrorCallback::create(requestCallback.get());
+    VoidCallback* successCallback = TransactionSuccessCallback::create();
+    database->transaction(callback, errorCallback, successCallback);
 }
 
 InspectorDatabaseResource* InspectorDatabaseAgent::findByFileName(const String& fileName)
 {
     for (DatabaseResourcesHeapMap::iterator it = m_resources.begin(); it != m_resources.end(); ++it) {
         if (it->value->database()->fileName() == fileName)
             return it->value.get();
     }
     return 0;
 }
 
 Database* InspectorDatabaseAgent::databaseForId(const String& databaseId)
 {
     DatabaseResourcesHeapMap::iterator it = m_resources.find(databaseId);
     if (it == m_resources.end())
         return 0;
     return it->value->database();
 }
 
 void InspectorDatabaseAgent::trace(Visitor* visitor)
 {
 #if ENABLE(OILPAN)
     visitor->trace(m_resources);
 #endif
     InspectorBaseAgent::trace(visitor);
 }
 
 } // namespace blink