Prepare to remove WebSecurityOrigin from IDB backend

Source/modules/indexeddb/IDBFactoryBackendImpl.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 11 matching lines @@
  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "modules/indexeddb/IDBFactoryBackendImpl.h"
 
-#include "core/dom/DOMStringList.h"
-#include "core/page/SecurityOrigin.h"
 #include "modules/indexeddb/IDBBackingStore.h"
 #include "modules/indexeddb/IDBDatabaseBackendImpl.h"
 #include "modules/indexeddb/IDBDatabaseException.h"
 #include "modules/indexeddb/IDBTracing.h"
 #include "modules/indexeddb/IDBTransactionCoordinator.h"
 #include "wtf/UnusedParam.h"
 
 namespace WebCore {
 
 template<typename K, typename M>
@@ skipping 28 matching lines @@
 IDBFactoryBackendImpl::~IDBFactoryBackendImpl()
 {
 }
 
 void IDBFactoryBackendImpl::removeIDBDatabaseBackend(const String& uniqueIdentifier)
 {
     ASSERT(m_databaseBackendMap.contains(uniqueIdentifier));
     m_databaseBackendMap.remove(uniqueIdentifier);
 }
 
-void IDBFactoryBackendImpl::getDatabaseNames(PassRefPtr<IDBCallbacks> callbacks, PassRefPtr<SecurityOrigin> securityOrigin, ScriptExecutionContext*, const String& dataDirectory)
+void IDBFactoryBackendImpl::getDatabaseNames(PassRefPtr<IDBCallbacks> callbacks, const String& databaseIdentifier, ScriptExecutionContext*, const String& dataDirectory)
 {
     IDB_TRACE("IDBFactoryBackendImpl::getDatabaseNames");
-    RefPtr<IDBBackingStore> backingStore = openBackingStore(securityOrigin->databaseIdentifier(), dataDirectory);
+    RefPtr<IDBBackingStore> backingStore = openBackingStore(databaseIdentifier, dataDirectory);
     if (!backingStore) {
         callbacks->onError(IDBDatabaseError::create(IDBDatabaseException::UnknownError, "Internal error opening backing store for indexedDB.webkitGetDatabaseNames."));
         return;
     }
 
     callbacks->onSuccess(backingStore->getDatabaseNames());
 }
 
-void IDBFactoryBackendImpl::deleteDatabase(const String& name, PassRefPtr<IDBCallbacks> callbacks, PassRefPtr<SecurityOrigin> securityOrigin, ScriptExecutionContext*, const String& dataDirectory)
+void IDBFactoryBackendImpl::deleteDatabase(const String& name, PassRefPtr<IDBCallbacks> callbacks, const String& databaseIdentifier, ScriptExecutionContext*, const String& dataDirectory)
 {
     IDB_TRACE("IDBFactoryBackendImpl::deleteDatabase");
-    const String uniqueIdentifier = computeUniqueIdentifier(name, securityOrigin->databaseIdentifier());
+    const String uniqueIdentifier = computeUniqueIdentifier(name, databaseIdentifier);
 
     IDBDatabaseBackendMap::iterator it = m_databaseBackendMap.find(uniqueIdentifier);
     if (it != m_databaseBackendMap.end()) {
         // If there are any connections to the database, directly delete the
         // database.
         it->value->deleteDatabase(callbacks);
         return;
     }
 
     // FIXME: Everything from now on should be done on another thread.
-    RefPtr<IDBBackingStore> backingStore = openBackingStore(securityOrigin->databaseIdentifier(), dataDirectory);
+    RefPtr<IDBBackingStore> backingStore = openBackingStore(databaseIdentifier, dataDirectory);
     if (!backingStore) {
         callbacks->onError(IDBDatabaseError::create(IDBDatabaseException::UnknownError, "Internal error opening backing store for indexedDB.deleteDatabase."));
         return;
     }
 
     RefPtr<IDBDatabaseBackendImpl> databaseBackend = IDBDatabaseBackendImpl::create(name, backingStore.get(), this, uniqueIdentifier);
     if (databaseBackend) {
         m_databaseBackendMap.set(uniqueIdentifier, databaseBackend.get());
         databaseBackend->deleteDatabase(callbacks);
         m_databaseBackendMap.remove(uniqueIdentifier);
@@ skipping 25 matching lines @@
 
         // All backing stores associated with this factory should be of the same type.
         ASSERT(m_sessionOnlyBackingStores.isEmpty() || openInMemory);
 
         return backingStore.release();
     }
 
     return 0;
 }
 
-void IDBFactoryBackendImpl::open(const String& name, int64_t version, int64_t transactionId, PassRefPtr<IDBCallbacks> callbacks, PassRefPtr<IDBDatabaseCallbacks> databaseCallbacks, PassRefPtr<SecurityOrigin> prpSecurityOrigin, ScriptExecutionContext*, const String& dataDirectory)
+void IDBFactoryBackendImpl::open(const String& name, int64_t version, int64_t transactionId, PassRefPtr<IDBCallbacks> callbacks, PassRefPtr<IDBDatabaseCallbacks> databaseCallbacks, const String& databaseIdentifier, ScriptExecutionContext*, const String& dataDirectory)
 {
     IDB_TRACE("IDBFactoryBackendImpl::open");
-    RefPtr<SecurityOrigin> securityOrigin = prpSecurityOrigin;
-    const String uniqueIdentifier = computeUniqueIdentifier(name, securityOrigin->databaseIdentifier());
+    const String uniqueIdentifier = computeUniqueIdentifier(name, databaseIdentifier);
 
     RefPtr<IDBDatabaseBackendImpl> databaseBackend;
     IDBDatabaseBackendMap::iterator it = m_databaseBackendMap.find(uniqueIdentifier);
     if (it == m_databaseBackendMap.end()) {
-        RefPtr<IDBBackingStore> backingStore = openBackingStore(securityOrigin->databaseIdentifier(), dataDirectory);
+        RefPtr<IDBBackingStore> backingStore = openBackingStore(databaseIdentifier, dataDirectory);
         if (!backingStore) {
             callbacks->onError(IDBDatabaseError::create(IDBDatabaseException::UnknownError, "Internal error opening backing store for indexedDB.open."));
             return;
         }
 
         databaseBackend = IDBDatabaseBackendImpl::create(name, backingStore.get(), this, uniqueIdentifier);
         if (databaseBackend)
             m_databaseBackendMap.set(uniqueIdentifier, databaseBackend.get());
         else {
             callbacks->onError(IDBDatabaseError::create(IDBDatabaseException::UnknownError, "Internal error creating database backend for indexeddb.open."));
             return;
         }
     } else
         databaseBackend = it->value;
 
     databaseBackend->openConnection(callbacks, databaseCallbacks, transactionId, version);
 }
 
 } // namespace WebCore