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

Source/modules/indexeddb/IDBOpenDBRequest.cpp

 /*
  * Copyright (C) 2012 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 17 matching lines @@
 
 #include "core/dom/ScriptExecutionContext.h"
 #include "modules/indexeddb/IDBDatabase.h"
 #include "modules/indexeddb/IDBDatabaseCallbacksImpl.h"
 #include "modules/indexeddb/IDBPendingTransactionMonitor.h"
 #include "modules/indexeddb/IDBTracing.h"
 #include "modules/indexeddb/IDBVersionChangeEvent.h"
 
 namespace WebCore {
 
-PassRefPtr<IDBOpenDBRequest> IDBOpenDBRequest::create(ScriptExecutionContext* context, PassRefPtr<IDBDatabaseCallbacksImpl> callbacks, int64_t transactionId, int64_t version)
+IDBOpenDBRequest* IDBOpenDBRequest::create(ScriptExecutionContext* context, IDBDatabaseCallbacksImpl* callbacks, int64_t transactionId, int64_t version)
 {
-    RefPtr<IDBOpenDBRequest> request(adoptRef(new IDBOpenDBRequest(context, callbacks, transactionId, version)));
+    IDBOpenDBRequest* request = new IDBOpenDBRequest(context, callbacks, transactionId, version);
     request->suspendIfNeeded();
-    return request.release();
+    return request;
 }
 
-IDBOpenDBRequest::IDBOpenDBRequest(ScriptExecutionContext* context, PassRefPtr<IDBDatabaseCallbacksImpl> callbacks, int64_t transactionId, int64_t version)
+IDBOpenDBRequest::IDBOpenDBRequest(ScriptExecutionContext* context, IDBDatabaseCallbacksImpl* callbacks, int64_t transactionId, int64_t version)
     : IDBRequest(context, IDBAny::createNull(), IDBDatabaseBackendInterface::NormalTask, 0)
     , m_databaseCallbacks(callbacks)
     , m_transactionId(transactionId)
     , m_version(version)
 {
     ASSERT(!m_result);
     ScriptWrappable::init(this);
 }
 
 IDBOpenDBRequest::~IDBOpenDBRequest()
 {
 }
 
 const AtomicString& IDBOpenDBRequest::interfaceName() const
 {
     return eventNames().interfaceForIDBOpenDBRequest;
 }
 
 void IDBOpenDBRequest::onBlocked(int64_t oldVersion)
 {
     IDB_TRACE("IDBOpenDBRequest::onBlocked()");
     if (!shouldEnqueueEvent())
         return;
     RefPtr<IDBAny> newVersionAny = (m_version == IDBDatabaseMetadata::DefaultIntVersion) ? IDBAny::createNull() : IDBAny::create(m_version);
     enqueueEvent(IDBVersionChangeEvent::create(IDBAny::create(oldVersion), newVersionAny.release(), eventNames().blockedEvent));
 }
 
-void IDBOpenDBRequest::onUpgradeNeeded(int64_t oldVersion, PassRefPtr<IDBDatabaseBackendInterface> prpDatabaseBackend, const IDBDatabaseMetadata& metadata)
+void IDBOpenDBRequest::onUpgradeNeeded(int64_t oldVersion, IDBDatabaseBackendInterface* databaseBackend, const IDBDatabaseMetadata& metadata)
 {
     IDB_TRACE("IDBOpenDBRequest::onUpgradeNeeded()");
     if (m_contextStopped || !scriptExecutionContext()) {
-        RefPtr<IDBDatabaseBackendInterface> db = prpDatabaseBackend;
-        db->abort(m_transactionId);
-        db->close(m_databaseCallbacks);
+        databaseBackend->abort(m_transactionId);
+        databaseBackend->close(m_databaseCallbacks);
         return;
     }
     if (!shouldEnqueueEvent())
         return;
 
     ASSERT(m_databaseCallbacks);
 
-    RefPtr<IDBDatabaseBackendInterface> databaseBackend = prpDatabaseBackend;
-
-    RefPtr<IDBDatabase> idbDatabase = IDBDatabase::create(scriptExecutionContext(), databaseBackend, m_databaseCallbacks);
+    IDBDatabase* idbDatabase = IDBDatabase::create(scriptExecutionContext(), databaseBackend, m_databaseCallbacks);
     idbDatabase->setMetadata(metadata);
-    m_databaseCallbacks->connect(idbDatabase.get());
+    m_databaseCallbacks->connect(idbDatabase);
     m_databaseCallbacks = 0;
 
     if (oldVersion == IDBDatabaseMetadata::NoIntVersion) {
         // This database hasn't had an integer version before.
         oldVersion = IDBDatabaseMetadata::DefaultIntVersion;
     }
     IDBDatabaseMetadata oldMetadata(metadata);
     oldMetadata.intVersion = oldVersion;
 
-    m_transaction = IDBTransaction::create(scriptExecutionContext(), m_transactionId, idbDatabase.get(), this, oldMetadata);
-    m_result = IDBAny::create(idbDatabase.release());
+    m_transaction = IDBTransaction::create(scriptExecutionContext(), m_transactionId, idbDatabase, this, oldMetadata);
+    m_result = IDBAny::create(idbDatabase);
 
     if (m_version == IDBDatabaseMetadata::NoIntVersion)
         m_version = 1;
     enqueueEvent(IDBVersionChangeEvent::create(IDBAny::create(oldVersion), IDBAny::create(m_version), eventNames().upgradeneededEvent));
 }
 
-void IDBOpenDBRequest::onSuccess(PassRefPtr<IDBDatabaseBackendInterface> prpBackend, const IDBDatabaseMetadata& metadata)
+void IDBOpenDBRequest::onSuccess(IDBDatabaseBackendInterface* backend, const IDBDatabaseMetadata& metadata)
 {
     IDB_TRACE("IDBOpenDBRequest::onSuccess()");
     if (m_contextStopped || !scriptExecutionContext()) {
-        RefPtr<IDBDatabaseBackendInterface> db = prpBackend;
-        db->close(m_databaseCallbacks);
+        backend->close(m_databaseCallbacks);
         return;
     }
     if (!shouldEnqueueEvent())
         return;
 
-    RefPtr<IDBDatabaseBackendInterface> backend = prpBackend;
-    RefPtr<IDBDatabase> idbDatabase;
+    IDBDatabase* idbDatabase;
     if (m_result) {
         idbDatabase = m_result->idbDatabase();
         ASSERT(idbDatabase);
         ASSERT(!m_databaseCallbacks);
     } else {
         ASSERT(m_databaseCallbacks);
-        idbDatabase = IDBDatabase::create(scriptExecutionContext(), backend.release(), m_databaseCallbacks);
-        m_databaseCallbacks->connect(idbDatabase.get());
+        idbDatabase = IDBDatabase::create(scriptExecutionContext(), backend, m_databaseCallbacks);
+        m_databaseCallbacks->connect(idbDatabase);
         m_databaseCallbacks = 0;
-        m_result = IDBAny::create(idbDatabase.get());
+        m_result = IDBAny::create(idbDatabase);
     }
     idbDatabase->setMetadata(metadata);
     enqueueEvent(Event::create(eventNames().successEvent, false, false));
 }
 
 bool IDBOpenDBRequest::shouldEnqueueEvent() const
 {
     if (m_contextStopped || !scriptExecutionContext())
         return false;
     ASSERT(m_readyState == PENDING || m_readyState == DONE);
     if (m_requestAborted)
         return false;
     return true;
 }
 
 bool IDBOpenDBRequest::dispatchEvent(PassRefPtr<Event> event)
 {
     // If the connection closed between onUpgradeNeeded and the delivery of the "success" event,
     // an "error" event should be fired instead.
     if (event->type() == eventNames().successEvent && m_result->type() == IDBAny::IDBDatabaseType && m_result->idbDatabase()->isClosePending()) {
         m_result.clear();
         onError(IDBDatabaseError::create(IDBDatabaseException::AbortError, "The connection was closed."));
         return false;
     }
 
     return IDBRequest::dispatchEvent(event);
 }
 
+void IDBOpenDBRequest::trace(Visitor* visitor)
+{
+    visitor->trace(m_databaseCallbacks);
+    IDBRequest::trace(visitor);
+}
+
 } // namespace WebCore