Rename DatabaseBackend to DatabaseBackendBase.
authormark.lam@apple.com <mark.lam@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Wed, 20 Feb 2013 17:56:55 +0000 (17:56 +0000)
committermark.lam@apple.com <mark.lam@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Wed, 20 Feb 2013 17:56:55 +0000 (17:56 +0000)
https://bugs.webkit.org/show_bug.cgi?id=110303.

Rubber stamped by Alexey Proskuryakov.

Source/WebCore:

This is a purely cosmetic change to make the naming consistent with
the front-end DatabaseBase.

No new tests.

* CMakeLists.txt:
* GNUmakefile.list.am:
* Modules/webdatabase/AbstractDatabaseServer.h:
* Modules/webdatabase/Database.cpp:
(WebCore::Database::create):
(WebCore::Database::version):
* Modules/webdatabase/Database.h:
(Database):
* Modules/webdatabase/DatabaseBackend.cpp: Removed.
* Modules/webdatabase/DatabaseBackend.h: Removed.
* Modules/webdatabase/DatabaseBackendAsync.cpp:
(WebCore::DatabaseBackendAsync::DatabaseBackendAsync):
(WebCore::DatabaseBackendAsync::performOpenAndVerify):
* Modules/webdatabase/DatabaseBackendAsync.h:
* Modules/webdatabase/DatabaseBackendBase.cpp: Copied from Source/WebCore/Modules/webdatabase/DatabaseBackend.cpp.
(WebCore::DatabaseBackendBase::databaseInfoTableName):
(WebCore::DatabaseBackendBase::DatabaseBackendBase):
(WebCore::DatabaseBackendBase::~DatabaseBackendBase):
(WebCore::DatabaseBackendBase::closeDatabase):
(WebCore::DatabaseBackendBase::version):
(WebCore::DoneCreatingDatabaseOnExitCaller::DoneCreatingDatabaseOnExitCaller):
(DoneCreatingDatabaseOnExitCaller):
(WebCore::DatabaseBackendBase::performOpenAndVerify):
(WebCore::DatabaseBackendBase::securityOrigin):
(WebCore::DatabaseBackendBase::stringIdentifier):
(WebCore::DatabaseBackendBase::displayName):
(WebCore::DatabaseBackendBase::estimatedSize):
(WebCore::DatabaseBackendBase::fileName):
(WebCore::DatabaseBackendBase::details):
(WebCore::DatabaseBackendBase::getVersionFromDatabase):
(WebCore::DatabaseBackendBase::setVersionInDatabase):
(WebCore::DatabaseBackendBase::setExpectedVersion):
(WebCore::DatabaseBackendBase::getCachedVersion):
(WebCore::DatabaseBackendBase::setCachedVersion):
(WebCore::DatabaseBackendBase::getActualVersionForTransaction):
(WebCore::DatabaseBackendBase::disableAuthorizer):
(WebCore::DatabaseBackendBase::enableAuthorizer):
(WebCore::DatabaseBackendBase::setAuthorizerReadOnly):
(WebCore::DatabaseBackendBase::setAuthorizerPermissions):
(WebCore::DatabaseBackendBase::lastActionChangedDatabase):
(WebCore::DatabaseBackendBase::lastActionWasInsert):
(WebCore::DatabaseBackendBase::resetDeletes):
(WebCore::DatabaseBackendBase::hadDeletes):
(WebCore::DatabaseBackendBase::resetAuthorizer):
(WebCore::DatabaseBackendBase::maximumSize):
(WebCore::DatabaseBackendBase::incrementalVacuumIfNeeded):
(WebCore::DatabaseBackendBase::interrupt):
(WebCore::DatabaseBackendBase::isInterrupted):
(WebCore::DatabaseBackendBase::reportOpenDatabaseResult):
(WebCore::DatabaseBackendBase::reportChangeVersionResult):
(WebCore::DatabaseBackendBase::reportStartTransactionResult):
(WebCore::DatabaseBackendBase::reportCommitTransactionResult):
(WebCore::DatabaseBackendBase::reportExecuteStatementResult):
(WebCore::DatabaseBackendBase::reportVacuumDatabaseResult):
* Modules/webdatabase/DatabaseBackendBase.h: Copied from Source/WebCore/Modules/webdatabase/DatabaseBackend.h.
(DatabaseBackendBase):
* Modules/webdatabase/DatabaseBackendSync.cpp:
(WebCore::DatabaseBackendSync::DatabaseBackendSync):
* Modules/webdatabase/DatabaseBackendSync.h:
* Modules/webdatabase/DatabaseBase.h:
* Modules/webdatabase/DatabaseManager.cpp:
(WebCore::DatabaseManager::openDatabaseBackend):
(WebCore::DatabaseManager::openDatabase):
(WebCore::DatabaseManager::openDatabaseSync):
(WebCore::DatabaseManager::getMaxSizeForDatabase):
* Modules/webdatabase/DatabaseManager.h:
(DatabaseManager):
* Modules/webdatabase/DatabaseServer.cpp:
(WebCore::DatabaseServer::openDatabase):
(WebCore::DatabaseServer::createDatabase):
(WebCore::DatabaseServer::getMaxSizeForDatabase):
* Modules/webdatabase/DatabaseServer.h:
* Modules/webdatabase/DatabaseSync.cpp:
(WebCore::DatabaseSync::create):
* Modules/webdatabase/DatabaseSync.h:
(DatabaseSync):
* Modules/webdatabase/DatabaseTracker.cpp:
(WebCore::DatabaseTracker::getMaxSizeForDatabase):
(WebCore::DatabaseTracker::databaseChanged):
(WebCore::DatabaseTracker::interruptAllDatabasesForContext):
(WebCore::DatabaseTracker::doneCreatingDatabase):
(WebCore::DatabaseTracker::addOpenDatabase):
(WebCore::DatabaseTracker::removeOpenDatabase):
(WebCore::DatabaseTracker::getOpenDatabases):
(WebCore::DatabaseTracker::deleteDatabaseFile):
* Modules/webdatabase/DatabaseTracker.h:
(DatabaseTracker):
* Modules/webdatabase/OriginQuotaManager.cpp:
(WebCore::OriginQuotaManager::markDatabase):
* Modules/webdatabase/OriginQuotaManager.h:
(OriginQuotaManager):
* Modules/webdatabase/SQLTransactionClient.cpp:
(WebCore::SQLTransactionClient::didCommitWriteTransaction):
(WebCore::SQLTransactionClient::didExecuteStatement):
(WebCore::SQLTransactionClient::didExceedQuota):
* Modules/webdatabase/SQLTransactionClient.h:
(SQLTransactionClient):
* Modules/webdatabase/chromium/DatabaseObserver.h:
(DatabaseObserver):
* Modules/webdatabase/chromium/DatabaseTrackerChromium.cpp:
(WebCore::DatabaseTracker::addOpenDatabase):
(WebCore::NotifyDatabaseObserverOnCloseTask::create):
(WebCore::NotifyDatabaseObserverOnCloseTask::NotifyDatabaseObserverOnCloseTask):
(NotifyDatabaseObserverOnCloseTask):
(WebCore::DatabaseTracker::removeOpenDatabase):
(WebCore::DatabaseTracker::prepareToOpenDatabase):
(WebCore::DatabaseTracker::failedToOpenDatabase):
(WebCore::DatabaseTracker::getMaxSizeForDatabase):
(WebCore::DatabaseTracker::CloseOneDatabaseImmediatelyTask::create):
(WebCore::DatabaseTracker::CloseOneDatabaseImmediatelyTask::CloseOneDatabaseImmediatelyTask):
(DatabaseTracker::CloseOneDatabaseImmediatelyTask):
(WebCore::DatabaseTracker::closeOneDatabaseImmediately):
* Modules/webdatabase/chromium/SQLTransactionClientChromium.cpp:
(WebCore::NotifyDatabaseChangedTask::create):
(WebCore::NotifyDatabaseChangedTask::NotifyDatabaseChangedTask):
(NotifyDatabaseChangedTask):
(WebCore::SQLTransactionClient::didCommitWriteTransaction):
(WebCore::SQLTransactionClient::didExecuteStatement):
(WebCore::SQLTransactionClient::didExceedQuota):
* Target.pri:
* WebCore.gypi:
* WebCore.vcproj/WebCore.vcproj:
* WebCore.vcxproj/WebCore.vcxproj:
* WebCore.vcxproj/WebCore.vcxproj.filters:
* WebCore.xcodeproj/project.pbxproj:

Source/WebKit/chromium:

* public/WebDatabase.h:
(WebDatabase):
* src/DatabaseObserver.cpp:
(WebCore::DatabaseObserver::databaseOpened):
(WebCore::DatabaseObserver::databaseModified):
(WebCore::DatabaseObserver::databaseClosed):
(WebCore::DatabaseObserver::reportOpenDatabaseResult):
(WebCore::DatabaseObserver::reportChangeVersionResult):
(WebCore::DatabaseObserver::reportStartTransactionResult):
(WebCore::DatabaseObserver::reportCommitTransactionResult):
(WebCore::DatabaseObserver::reportExecuteStatementResult):
(WebCore::DatabaseObserver::reportVacuumDatabaseResult):
* src/WebDatabase.cpp:
(WebKit::WebDatabase::WebDatabase):

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@143471 268f45cc-cd09-0410-ab3c-d52691b4dbfc

38 files changed:
Source/WebCore/CMakeLists.txt
Source/WebCore/ChangeLog
Source/WebCore/GNUmakefile.list.am
Source/WebCore/Modules/webdatabase/AbstractDatabaseServer.h
Source/WebCore/Modules/webdatabase/Database.cpp
Source/WebCore/Modules/webdatabase/Database.h
Source/WebCore/Modules/webdatabase/DatabaseBackendAsync.cpp
Source/WebCore/Modules/webdatabase/DatabaseBackendAsync.h
Source/WebCore/Modules/webdatabase/DatabaseBackendBase.cpp [moved from Source/WebCore/Modules/webdatabase/DatabaseBackend.cpp with 87% similarity]
Source/WebCore/Modules/webdatabase/DatabaseBackendBase.h [moved from Source/WebCore/Modules/webdatabase/DatabaseBackend.h with 94% similarity]
Source/WebCore/Modules/webdatabase/DatabaseBackendSync.cpp
Source/WebCore/Modules/webdatabase/DatabaseBackendSync.h
Source/WebCore/Modules/webdatabase/DatabaseBase.h
Source/WebCore/Modules/webdatabase/DatabaseManager.cpp
Source/WebCore/Modules/webdatabase/DatabaseManager.h
Source/WebCore/Modules/webdatabase/DatabaseServer.cpp
Source/WebCore/Modules/webdatabase/DatabaseServer.h
Source/WebCore/Modules/webdatabase/DatabaseSync.cpp
Source/WebCore/Modules/webdatabase/DatabaseSync.h
Source/WebCore/Modules/webdatabase/DatabaseTracker.cpp
Source/WebCore/Modules/webdatabase/DatabaseTracker.h
Source/WebCore/Modules/webdatabase/OriginQuotaManager.cpp
Source/WebCore/Modules/webdatabase/OriginQuotaManager.h
Source/WebCore/Modules/webdatabase/SQLTransactionClient.cpp
Source/WebCore/Modules/webdatabase/SQLTransactionClient.h
Source/WebCore/Modules/webdatabase/chromium/DatabaseObserver.h
Source/WebCore/Modules/webdatabase/chromium/DatabaseTrackerChromium.cpp
Source/WebCore/Modules/webdatabase/chromium/SQLTransactionClientChromium.cpp
Source/WebCore/Target.pri
Source/WebCore/WebCore.gypi
Source/WebCore/WebCore.vcproj/WebCore.vcproj
Source/WebCore/WebCore.vcxproj/WebCore.vcxproj
Source/WebCore/WebCore.vcxproj/WebCore.vcxproj.filters
Source/WebCore/WebCore.xcodeproj/project.pbxproj
Source/WebKit/chromium/ChangeLog
Source/WebKit/chromium/public/WebDatabase.h
Source/WebKit/chromium/src/DatabaseObserver.cpp
Source/WebKit/chromium/src/WebDatabase.cpp

index 6bc0be2..018dd10 100644 (file)
@@ -939,8 +939,8 @@ set(WebCore_SOURCES
     Modules/webdatabase/DOMWindowWebDatabase.cpp
     Modules/webdatabase/Database.cpp
     Modules/webdatabase/DatabaseAuthorizer.cpp
-    Modules/webdatabase/DatabaseBackend.cpp
     Modules/webdatabase/DatabaseBackendAsync.cpp
+    Modules/webdatabase/DatabaseBackendBase.cpp
     Modules/webdatabase/DatabaseBackendContext.cpp
     Modules/webdatabase/DatabaseBackendSync.cpp
     Modules/webdatabase/DatabaseBase.cpp
index ca9ec54..0e2ad60 100644 (file)
@@ -1,3 +1,141 @@
+2013-02-20  Mark Lam  <mark.lam@apple.com>
+
+        Rename DatabaseBackend to DatabaseBackendBase.
+        https://bugs.webkit.org/show_bug.cgi?id=110303.
+
+        Rubber stamped by Alexey Proskuryakov.
+
+        This is a purely cosmetic change to make the naming consistent with
+        the front-end DatabaseBase.
+
+        No new tests.
+
+        * CMakeLists.txt:
+        * GNUmakefile.list.am:
+        * Modules/webdatabase/AbstractDatabaseServer.h:
+        * Modules/webdatabase/Database.cpp:
+        (WebCore::Database::create):
+        (WebCore::Database::version):
+        * Modules/webdatabase/Database.h:
+        (Database):
+        * Modules/webdatabase/DatabaseBackend.cpp: Removed.
+        * Modules/webdatabase/DatabaseBackend.h: Removed.
+        * Modules/webdatabase/DatabaseBackendAsync.cpp:
+        (WebCore::DatabaseBackendAsync::DatabaseBackendAsync):
+        (WebCore::DatabaseBackendAsync::performOpenAndVerify):
+        * Modules/webdatabase/DatabaseBackendAsync.h:
+        * Modules/webdatabase/DatabaseBackendBase.cpp: Copied from Source/WebCore/Modules/webdatabase/DatabaseBackend.cpp.
+        (WebCore::DatabaseBackendBase::databaseInfoTableName):
+        (WebCore::DatabaseBackendBase::DatabaseBackendBase):
+        (WebCore::DatabaseBackendBase::~DatabaseBackendBase):
+        (WebCore::DatabaseBackendBase::closeDatabase):
+        (WebCore::DatabaseBackendBase::version):
+        (WebCore::DoneCreatingDatabaseOnExitCaller::DoneCreatingDatabaseOnExitCaller):
+        (DoneCreatingDatabaseOnExitCaller):
+        (WebCore::DatabaseBackendBase::performOpenAndVerify):
+        (WebCore::DatabaseBackendBase::securityOrigin):
+        (WebCore::DatabaseBackendBase::stringIdentifier):
+        (WebCore::DatabaseBackendBase::displayName):
+        (WebCore::DatabaseBackendBase::estimatedSize):
+        (WebCore::DatabaseBackendBase::fileName):
+        (WebCore::DatabaseBackendBase::details):
+        (WebCore::DatabaseBackendBase::getVersionFromDatabase):
+        (WebCore::DatabaseBackendBase::setVersionInDatabase):
+        (WebCore::DatabaseBackendBase::setExpectedVersion):
+        (WebCore::DatabaseBackendBase::getCachedVersion):
+        (WebCore::DatabaseBackendBase::setCachedVersion):
+        (WebCore::DatabaseBackendBase::getActualVersionForTransaction):
+        (WebCore::DatabaseBackendBase::disableAuthorizer):
+        (WebCore::DatabaseBackendBase::enableAuthorizer):
+        (WebCore::DatabaseBackendBase::setAuthorizerReadOnly):
+        (WebCore::DatabaseBackendBase::setAuthorizerPermissions):
+        (WebCore::DatabaseBackendBase::lastActionChangedDatabase):
+        (WebCore::DatabaseBackendBase::lastActionWasInsert):
+        (WebCore::DatabaseBackendBase::resetDeletes):
+        (WebCore::DatabaseBackendBase::hadDeletes):
+        (WebCore::DatabaseBackendBase::resetAuthorizer):
+        (WebCore::DatabaseBackendBase::maximumSize):
+        (WebCore::DatabaseBackendBase::incrementalVacuumIfNeeded):
+        (WebCore::DatabaseBackendBase::interrupt):
+        (WebCore::DatabaseBackendBase::isInterrupted):
+        (WebCore::DatabaseBackendBase::reportOpenDatabaseResult):
+        (WebCore::DatabaseBackendBase::reportChangeVersionResult):
+        (WebCore::DatabaseBackendBase::reportStartTransactionResult):
+        (WebCore::DatabaseBackendBase::reportCommitTransactionResult):
+        (WebCore::DatabaseBackendBase::reportExecuteStatementResult):
+        (WebCore::DatabaseBackendBase::reportVacuumDatabaseResult):
+        * Modules/webdatabase/DatabaseBackendBase.h: Copied from Source/WebCore/Modules/webdatabase/DatabaseBackend.h.
+        (DatabaseBackendBase):
+        * Modules/webdatabase/DatabaseBackendSync.cpp:
+        (WebCore::DatabaseBackendSync::DatabaseBackendSync):
+        * Modules/webdatabase/DatabaseBackendSync.h:
+        * Modules/webdatabase/DatabaseBase.h:
+        * Modules/webdatabase/DatabaseManager.cpp:
+        (WebCore::DatabaseManager::openDatabaseBackend):
+        (WebCore::DatabaseManager::openDatabase):
+        (WebCore::DatabaseManager::openDatabaseSync):
+        (WebCore::DatabaseManager::getMaxSizeForDatabase):
+        * Modules/webdatabase/DatabaseManager.h:
+        (DatabaseManager):
+        * Modules/webdatabase/DatabaseServer.cpp:
+        (WebCore::DatabaseServer::openDatabase):
+        (WebCore::DatabaseServer::createDatabase):
+        (WebCore::DatabaseServer::getMaxSizeForDatabase):
+        * Modules/webdatabase/DatabaseServer.h:
+        * Modules/webdatabase/DatabaseSync.cpp:
+        (WebCore::DatabaseSync::create):
+        * Modules/webdatabase/DatabaseSync.h:
+        (DatabaseSync):
+        * Modules/webdatabase/DatabaseTracker.cpp:
+        (WebCore::DatabaseTracker::getMaxSizeForDatabase):
+        (WebCore::DatabaseTracker::databaseChanged):
+        (WebCore::DatabaseTracker::interruptAllDatabasesForContext):
+        (WebCore::DatabaseTracker::doneCreatingDatabase):
+        (WebCore::DatabaseTracker::addOpenDatabase):
+        (WebCore::DatabaseTracker::removeOpenDatabase):
+        (WebCore::DatabaseTracker::getOpenDatabases):
+        (WebCore::DatabaseTracker::deleteDatabaseFile):
+        * Modules/webdatabase/DatabaseTracker.h:
+        (DatabaseTracker):
+        * Modules/webdatabase/OriginQuotaManager.cpp:
+        (WebCore::OriginQuotaManager::markDatabase):
+        * Modules/webdatabase/OriginQuotaManager.h:
+        (OriginQuotaManager):
+        * Modules/webdatabase/SQLTransactionClient.cpp:
+        (WebCore::SQLTransactionClient::didCommitWriteTransaction):
+        (WebCore::SQLTransactionClient::didExecuteStatement):
+        (WebCore::SQLTransactionClient::didExceedQuota):
+        * Modules/webdatabase/SQLTransactionClient.h:
+        (SQLTransactionClient):
+        * Modules/webdatabase/chromium/DatabaseObserver.h:
+        (DatabaseObserver):
+        * Modules/webdatabase/chromium/DatabaseTrackerChromium.cpp:
+        (WebCore::DatabaseTracker::addOpenDatabase):
+        (WebCore::NotifyDatabaseObserverOnCloseTask::create):
+        (WebCore::NotifyDatabaseObserverOnCloseTask::NotifyDatabaseObserverOnCloseTask):
+        (NotifyDatabaseObserverOnCloseTask):
+        (WebCore::DatabaseTracker::removeOpenDatabase):
+        (WebCore::DatabaseTracker::prepareToOpenDatabase):
+        (WebCore::DatabaseTracker::failedToOpenDatabase):
+        (WebCore::DatabaseTracker::getMaxSizeForDatabase):
+        (WebCore::DatabaseTracker::CloseOneDatabaseImmediatelyTask::create):
+        (WebCore::DatabaseTracker::CloseOneDatabaseImmediatelyTask::CloseOneDatabaseImmediatelyTask):
+        (DatabaseTracker::CloseOneDatabaseImmediatelyTask):
+        (WebCore::DatabaseTracker::closeOneDatabaseImmediately):
+        * Modules/webdatabase/chromium/SQLTransactionClientChromium.cpp:
+        (WebCore::NotifyDatabaseChangedTask::create):
+        (WebCore::NotifyDatabaseChangedTask::NotifyDatabaseChangedTask):
+        (NotifyDatabaseChangedTask):
+        (WebCore::SQLTransactionClient::didCommitWriteTransaction):
+        (WebCore::SQLTransactionClient::didExecuteStatement):
+        (WebCore::SQLTransactionClient::didExceedQuota):
+        * Target.pri:
+        * WebCore.gypi:
+        * WebCore.vcproj/WebCore.vcproj:
+        * WebCore.vcxproj/WebCore.vcxproj:
+        * WebCore.vcxproj/WebCore.vcxproj.filters:
+        * WebCore.xcodeproj/project.pbxproj:
+
 2013-02-20  Eric Carlson  <eric.carlson@apple.com>
 
         iOS does not use CaptionUserPreferencesMac
index 69ed837..72f8880 100644 (file)
@@ -2111,10 +2111,10 @@ webcore_modules_sources += \
        Source/WebCore/Modules/webdatabase/Database.h \
        Source/WebCore/Modules/webdatabase/DatabaseAuthorizer.cpp \
        Source/WebCore/Modules/webdatabase/DatabaseAuthorizer.h \
-       Source/WebCore/Modules/webdatabase/DatabaseBackend.cpp \
-       Source/WebCore/Modules/webdatabase/DatabaseBackend.h \
        Source/WebCore/Modules/webdatabase/DatabaseBackendAsync.cpp \
        Source/WebCore/Modules/webdatabase/DatabaseBackendAsync.h \
+       Source/WebCore/Modules/webdatabase/DatabaseBackendBase.cpp \
+       Source/WebCore/Modules/webdatabase/DatabaseBackendBase.h \
        Source/WebCore/Modules/webdatabase/DatabaseBackendContext.cpp \
        Source/WebCore/Modules/webdatabase/DatabaseBackendContext.h \
        Source/WebCore/Modules/webdatabase/DatabaseBackendSync.cpp \
index 1c7c326..febee0f 100644 (file)
@@ -37,7 +37,7 @@
 
 namespace WebCore {
 
-class DatabaseBackend;
+class DatabaseBackendBase;
 class DatabaseBackendContext;
 class DatabaseManagerClient;
 class SecurityOrigin;
@@ -57,7 +57,9 @@ public:
         RetryOpenDatabase
     };
 
-    virtual PassRefPtr<DatabaseBackend> openDatabase(RefPtr<DatabaseBackendContext>&, DatabaseType, const String& name, const String& expectedVersion, const String& displayName, unsigned long estimatedSize, bool setVersionInNewDatabase, DatabaseError&, String& errorMessage, OpenAttempt = FirstTryToOpenDatabase) = 0;
+    virtual PassRefPtr<DatabaseBackendBase> openDatabase(RefPtr<DatabaseBackendContext>&, DatabaseType,
+        const String& name, const String& expectedVersion, const String& displayName, unsigned long estimatedSize,
+        bool setVersionInNewDatabase, DatabaseError&, String& errorMessage, OpenAttempt = FirstTryToOpenDatabase) = 0;
 
 #if !PLATFORM(CHROMIUM)
     virtual bool hasEntryForOrigin(SecurityOrigin*) = 0;
@@ -80,7 +82,7 @@ public:
 
     virtual void interruptAllDatabasesForContext(const DatabaseBackendContext*) = 0;
 
-    virtual unsigned long long getMaxSizeForDatabase(const DatabaseBackend*) = 0;
+    virtual unsigned long long getMaxSizeForDatabase(const DatabaseBackendBase*) = 0;
 
 protected:
     AbstractDatabaseServer() { }
index 835cc42..4e321d7 100644 (file)
@@ -65,7 +65,7 @@
 
 namespace WebCore {
 
-PassRefPtr<Database> Database::create(ScriptExecutionContext*, PassRefPtr<DatabaseBackend> backend)
+PassRefPtr<Database> Database::create(ScriptExecutionContext*, PassRefPtr<DatabaseBackendBase> backend)
 {
     // FIXME: Currently, we're only simulating the backend by return the
     // frontend database as its own the backend. When we split the 2 apart,
@@ -137,7 +137,7 @@ String Database::version() const
 {
     if (m_deleted)
         return String();
-    return DatabaseBackend::version();
+    return DatabaseBackendBase::version();
 }
 
 void Database::markAsDeletedAndClose()
index 0b513cc..9d71271 100644 (file)
@@ -82,7 +82,7 @@ private:
     Database(PassRefPtr<DatabaseBackendContext>, const String& name,
         const String& expectedVersion, const String& displayName, unsigned long estimatedSize);
     PassRefPtr<DatabaseBackendAsync> backend();
-    static PassRefPtr<Database> create(ScriptExecutionContext*, PassRefPtr<DatabaseBackend>);
+    static PassRefPtr<Database> create(ScriptExecutionContext*, PassRefPtr<DatabaseBackendBase>);
 
     void runTransaction(PassRefPtr<SQLTransactionCallback>, PassRefPtr<SQLTransactionErrorCallback>,
         PassRefPtr<VoidCallback> successCallback, bool readOnly, const ChangeVersionData* = 0);
index f8c5d53..03ebc78 100644 (file)
@@ -43,7 +43,7 @@
 namespace WebCore {
 
 DatabaseBackendAsync::DatabaseBackendAsync(PassRefPtr<DatabaseBackendContext> databaseContext, const String& name, const String& expectedVersion, const String& displayName, unsigned long estimatedSize)
-    : DatabaseBackend(databaseContext, name, expectedVersion, displayName, estimatedSize, DatabaseType::Async)
+    : DatabaseBackendBase(databaseContext, name, expectedVersion, displayName, estimatedSize, DatabaseType::Async)
     , m_transactionInProgress(false)
     , m_isTransactionQueueEnabled(true)
 {
@@ -68,7 +68,7 @@ bool DatabaseBackendAsync::openAndVerifyVersion(bool setVersionInNewDatabase, Da
 
 bool DatabaseBackendAsync::performOpenAndVerify(bool setVersionInNewDatabase, DatabaseError& error, String& errorMessage)
 {
-    if (DatabaseBackend::performOpenAndVerify(setVersionInNewDatabase, error, errorMessage)) {
+    if (DatabaseBackendBase::performOpenAndVerify(setVersionInNewDatabase, error, errorMessage)) {
         if (databaseContext()->databaseThread())
             databaseContext()->databaseThread()->recordDatabaseOpen(this);
 
index 22f1205..5bc63a4 100644 (file)
@@ -28,7 +28,7 @@
 
 #if ENABLE(SQL_DATABASE)
 
-#include "DatabaseBackend.h"
+#include "DatabaseBackendBase.h"
 #include <wtf/Deque.h>
 #include <wtf/text/WTFString.h>
 
@@ -48,7 +48,7 @@ class SQLTransactionCoordinator;
 // DatabaseBackendAsync to do so before the proper backend split is
 // available. This should be replaced with the actual implementation later.
 
-class DatabaseBackendAsync : public DatabaseBackend {
+class DatabaseBackendAsync : public DatabaseBackendBase {
 public:
     DatabaseBackendAsync(PassRefPtr<DatabaseBackendContext>, const String& name, const String& expectedVersion, const String& displayName, unsigned long estimatedSize);
 
@@ -28,7 +28,7 @@
  */
 
 #include "config.h"
-#include "DatabaseBackend.h"
+#include "DatabaseBackendBase.h"
 
 #if ENABLE(SQL_DATABASE)
 
 // The only databases instances not tracked by the tracker's open database
 // list are the ones that have not been added yet, or the ones that we
 // attempted an open on but failed to. Such instances only exist in the
-// DatabaseServer's factory methods for creating DatabaseBackends.
+// DatabaseServer's factory methods for creating database backends.
 //
 // The factory methods will either call openAndVerifyVersion() or
 // performOpenAndVerify(). These methods will add the newly instantiated
-// DatabaseBackend if they succeed in opening the requested database.
+// database backend if they succeed in opening the requested database.
 // In the case of failure to open the database, the factory methods will
-// simply discard the newly instantiated DatabaseBackend when they return.
+// simply discard the newly instantiated database backend when they return.
 // The ref counting mechanims will automatically destruct the un-added
 // (and un-returned) databases instances.
 
@@ -171,7 +171,7 @@ static inline void updateGuidVersionMap(DatabaseGuid guid, String newVersion)
     guidToVersionMap().set(guid, newVersion.isEmpty() ? String() : newVersion.isolatedCopy());
 }
 
-typedef HashMap<DatabaseGuid, HashSet<DatabaseBackend*>*> GuidDatabaseMap;
+typedef HashMap<DatabaseGuid, HashSet<DatabaseBackendBase*>*> GuidDatabaseMap;
 static GuidDatabaseMap& guidToDatabaseMap()
 {
     // Ensure the the mutex is locked.
@@ -200,13 +200,13 @@ static DatabaseGuid guidForOriginAndName(const String& origin, const String& nam
 }
 
 // static
-const char* DatabaseBackend::databaseInfoTableName()
+const char* DatabaseBackendBase::databaseInfoTableName()
 {
     return infoTableName;
 }
 
-DatabaseBackend::DatabaseBackend(PassRefPtr<DatabaseBackendContext> databaseContext, const String& name, const String& expectedVersion,
-    const String& displayName, unsigned long estimatedSize, DatabaseType databaseType)
+DatabaseBackendBase::DatabaseBackendBase(PassRefPtr<DatabaseBackendContext> databaseContext, const String& name,
+    const String& expectedVersion, const String& displayName, unsigned long estimatedSize, DatabaseType databaseType)
     : m_databaseContext(databaseContext)
     , m_name(name.isolatedCopy())
     , m_expectedVersion(expectedVersion.isolatedCopy())
@@ -227,9 +227,9 @@ DatabaseBackend::DatabaseBackend(PassRefPtr<DatabaseBackendContext> databaseCont
     {
         MutexLocker locker(guidMutex());
         m_guid = guidForOriginAndName(securityOrigin()->toString(), name);
-        HashSet<DatabaseBackend*>* hashSet = guidToDatabaseMap().get(m_guid);
+        HashSet<DatabaseBackendBase*>* hashSet = guidToDatabaseMap().get(m_guid);
         if (!hashSet) {
-            hashSet = new HashSet<DatabaseBackend*>;
+            hashSet = new HashSet<DatabaseBackendBase*>;
             guidToDatabaseMap().set(m_guid, hashSet);
         }
 
@@ -239,7 +239,7 @@ DatabaseBackend::DatabaseBackend(PassRefPtr<DatabaseBackendContext> databaseCont
     m_filename = DatabaseManager::manager().fullPathForDatabase(securityOrigin(), m_name);
 }
 
-DatabaseBackend::~DatabaseBackend()
+DatabaseBackendBase::~DatabaseBackendBase()
 {
     // SQLite is "multi-thread safe", but each database handle can only be used
     // on a single thread at a time.
@@ -253,7 +253,7 @@ DatabaseBackend::~DatabaseBackend()
     ASSERT(!m_opened);
 }
 
-void DatabaseBackend::closeDatabase()
+void DatabaseBackendBase::closeDatabase()
 {
     if (!m_opened)
         return;
@@ -265,7 +265,7 @@ void DatabaseBackend::closeDatabase()
     {
         MutexLocker locker(guidMutex());
 
-        HashSet<DatabaseBackend*>* hashSet = guidToDatabaseMap().get(m_guid);
+        HashSet<DatabaseBackendBase*>* hashSet = guidToDatabaseMap().get(m_guid);
         ASSERT(hashSet);
         ASSERT(hashSet->contains(this));
         hashSet->remove(this);
@@ -277,7 +277,7 @@ void DatabaseBackend::closeDatabase()
     }
 }
 
-String DatabaseBackend::version() const
+String DatabaseBackendBase::version() const
 {
     // Note: In multi-process browsers the cached value may be accurate, but we cannot read the
     // actual version from the database without potentially inducing a deadlock.
@@ -287,7 +287,7 @@ String DatabaseBackend::version() const
 
 class DoneCreatingDatabaseOnExitCaller {
 public:
-    DoneCreatingDatabaseOnExitCaller(DatabaseBackend* database)
+    DoneCreatingDatabaseOnExitCaller(DatabaseBackendBase* database)
         : m_database(database)
         , m_openSucceeded(false)
     {
@@ -305,11 +305,11 @@ public:
     void setOpenSucceeded() { m_openSucceeded = true; }
 
 private:
-    DatabaseBackend* m_database;
+    DatabaseBackendBase* m_database;
     bool m_openSucceeded;
 };
 
-bool DatabaseBackend::performOpenAndVerify(bool shouldSetVersionInNewDatabase, DatabaseError& error, String& errorMessage)
+bool DatabaseBackendBase::performOpenAndVerify(bool shouldSetVersionInNewDatabase, DatabaseError& error, String& errorMessage)
 {
     DoneCreatingDatabaseOnExitCaller onExitCaller(this);
     ASSERT(errorMessage.isEmpty());
@@ -435,40 +435,40 @@ bool DatabaseBackend::performOpenAndVerify(bool shouldSetVersionInNewDatabase, D
     return true;
 }
 
-SecurityOrigin* DatabaseBackend::securityOrigin() const
+SecurityOrigin* DatabaseBackendBase::securityOrigin() const
 {
     return m_contextThreadSecurityOrigin.get();
 }
 
-String DatabaseBackend::stringIdentifier() const
+String DatabaseBackendBase::stringIdentifier() const
 {
     // Return a deep copy for ref counting thread safety
     return m_name.isolatedCopy();
 }
 
-String DatabaseBackend::displayName() const
+String DatabaseBackendBase::displayName() const
 {
     // Return a deep copy for ref counting thread safety
     return m_displayName.isolatedCopy();
 }
 
-unsigned long DatabaseBackend::estimatedSize() const
+unsigned long DatabaseBackendBase::estimatedSize() const
 {
     return m_estimatedSize;
 }
 
-String DatabaseBackend::fileName() const
+String DatabaseBackendBase::fileName() const
 {
     // Return a deep copy for ref counting thread safety
     return m_filename.isolatedCopy();
 }
 
-DatabaseDetails DatabaseBackend::details() const
+DatabaseDetails DatabaseBackendBase::details() const
 {
     return DatabaseDetails(stringIdentifier(), displayName(), estimatedSize(), 0);
 }
 
-bool DatabaseBackend::getVersionFromDatabase(String& version, bool shouldCacheVersion)
+bool DatabaseBackendBase::getVersionFromDatabase(String& version, bool shouldCacheVersion)
 {
     String query(String("SELECT value FROM ") + infoTableName +  " WHERE key = '" + versionKey + "';");
 
@@ -486,7 +486,7 @@ bool DatabaseBackend::getVersionFromDatabase(String& version, bool shouldCacheVe
     return result;
 }
 
-bool DatabaseBackend::setVersionInDatabase(const String& version, bool shouldCacheVersion)
+bool DatabaseBackendBase::setVersionInDatabase(const String& version, bool shouldCacheVersion)
 {
     // The INSERT will replace an existing entry for the database with the new version number, due to the UNIQUE ON CONFLICT REPLACE
     // clause in the CREATE statement (see Database::performOpenAndVerify()).
@@ -506,25 +506,25 @@ bool DatabaseBackend::setVersionInDatabase(const String& version, bool shouldCac
     return result;
 }
 
-void DatabaseBackend::setExpectedVersion(const String& version)
+void DatabaseBackendBase::setExpectedVersion(const String& version)
 {
     m_expectedVersion = version.isolatedCopy();
 }
 
-String DatabaseBackend::getCachedVersion() const
+String DatabaseBackendBase::getCachedVersion() const
 {
     MutexLocker locker(guidMutex());
     return guidToVersionMap().get(m_guid).isolatedCopy();
 }
 
-void DatabaseBackend::setCachedVersion(const String& actualVersion)
+void DatabaseBackendBase::setCachedVersion(const String& actualVersion)
 {
     // Update the in memory database version map.
     MutexLocker locker(guidMutex());
     updateGuidVersionMap(m_guid, actualVersion);
 }
 
-bool DatabaseBackend::getActualVersionForTransaction(String &actualVersion)
+bool DatabaseBackendBase::getActualVersionForTransaction(String &actualVersion)
 {
     ASSERT(m_sqliteDatabase.transactionInProgress());
 #if PLATFORM(CHROMIUM)
@@ -537,66 +537,66 @@ bool DatabaseBackend::getActualVersionForTransaction(String &actualVersion)
 #endif
 }
 
-void DatabaseBackend::disableAuthorizer()
+void DatabaseBackendBase::disableAuthorizer()
 {
     ASSERT(m_databaseAuthorizer);
     m_databaseAuthorizer->disable();
 }
 
-void DatabaseBackend::enableAuthorizer()
+void DatabaseBackendBase::enableAuthorizer()
 {
     ASSERT(m_databaseAuthorizer);
     m_databaseAuthorizer->enable();
 }
 
-void DatabaseBackend::setAuthorizerReadOnly()
+void DatabaseBackendBase::setAuthorizerReadOnly()
 {
     ASSERT(m_databaseAuthorizer);
     m_databaseAuthorizer->setReadOnly();
 }
 
-void DatabaseBackend::setAuthorizerPermissions(int permissions)
+void DatabaseBackendBase::setAuthorizerPermissions(int permissions)
 {
     ASSERT(m_databaseAuthorizer);
     m_databaseAuthorizer->setPermissions(permissions);
 }
 
-bool DatabaseBackend::lastActionChangedDatabase()
+bool DatabaseBackendBase::lastActionChangedDatabase()
 {
     ASSERT(m_databaseAuthorizer);
     return m_databaseAuthorizer->lastActionChangedDatabase();
 }
 
-bool DatabaseBackend::lastActionWasInsert()
+bool DatabaseBackendBase::lastActionWasInsert()
 {
     ASSERT(m_databaseAuthorizer);
     return m_databaseAuthorizer->lastActionWasInsert();
 }
 
-void DatabaseBackend::resetDeletes()
+void DatabaseBackendBase::resetDeletes()
 {
     ASSERT(m_databaseAuthorizer);
     m_databaseAuthorizer->resetDeletes();
 }
 
-bool DatabaseBackend::hadDeletes()
+bool DatabaseBackendBase::hadDeletes()
 {
     ASSERT(m_databaseAuthorizer);
     return m_databaseAuthorizer->hadDeletes();
 }
 
-void DatabaseBackend::resetAuthorizer()
+void DatabaseBackendBase::resetAuthorizer()
 {
     if (m_databaseAuthorizer)
         m_databaseAuthorizer->reset();
 }
 
-unsigned long long DatabaseBackend::maximumSize() const
+unsigned long long DatabaseBackendBase::maximumSize() const
 {
     return DatabaseManager::manager().getMaxSizeForDatabase(this);
 }
 
-void DatabaseBackend::incrementalVacuumIfNeeded()
+void DatabaseBackendBase::incrementalVacuumIfNeeded()
 {
     int64_t freeSpaceSize = m_sqliteDatabase.freeSpaceSize();
     int64_t totalSize = m_sqliteDatabase.totalSize();
@@ -608,12 +608,12 @@ void DatabaseBackend::incrementalVacuumIfNeeded()
     }
 }
 
-void DatabaseBackend::interrupt()
+void DatabaseBackendBase::interrupt()
 {
     m_sqliteDatabase.interrupt();
 }
 
-bool DatabaseBackend::isInterrupted()
+bool DatabaseBackendBase::isInterrupted()
 {
     MutexLocker locker(m_sqliteDatabase.databaseMutex());
     return m_sqliteDatabase.isInterrupted();
@@ -622,32 +622,32 @@ bool DatabaseBackend::isInterrupted()
 #if PLATFORM(CHROMIUM)
 // These are used to generate histograms of errors seen with websql.
 // See about:histograms in chromium.
-void DatabaseBackend::reportOpenDatabaseResult(int errorSite, int webSqlErrorCode, int sqliteErrorCode)
+void DatabaseBackendBase::reportOpenDatabaseResult(int errorSite, int webSqlErrorCode, int sqliteErrorCode)
 {
     DatabaseObserver::reportOpenDatabaseResult(this, errorSite, webSqlErrorCode, sqliteErrorCode);
 }
 
-void DatabaseBackend::reportChangeVersionResult(int errorSite, int webSqlErrorCode, int sqliteErrorCode)
+void DatabaseBackendBase::reportChangeVersionResult(int errorSite, int webSqlErrorCode, int sqliteErrorCode)
 {
     DatabaseObserver::reportChangeVersionResult(this, errorSite, webSqlErrorCode, sqliteErrorCode);
 }
 
-void DatabaseBackend::reportStartTransactionResult(int errorSite, int webSqlErrorCode, int sqliteErrorCode)
+void DatabaseBackendBase::reportStartTransactionResult(int errorSite, int webSqlErrorCode, int sqliteErrorCode)
 {
     DatabaseObserver::reportStartTransactionResult(this, errorSite, webSqlErrorCode, sqliteErrorCode);
 }
 
-void DatabaseBackend::reportCommitTransactionResult(int errorSite, int webSqlErrorCode, int sqliteErrorCode)
+void DatabaseBackendBase::reportCommitTransactionResult(int errorSite, int webSqlErrorCode, int sqliteErrorCode)
 {
     DatabaseObserver::reportCommitTransactionResult(this, errorSite, webSqlErrorCode, sqliteErrorCode);
 }
 
-void DatabaseBackend::reportExecuteStatementResult(int errorSite, int webSqlErrorCode, int sqliteErrorCode)
+void DatabaseBackendBase::reportExecuteStatementResult(int errorSite, int webSqlErrorCode, int sqliteErrorCode)
 {
     DatabaseObserver::reportExecuteStatementResult(this, errorSite, webSqlErrorCode, sqliteErrorCode);
 }
 
-void DatabaseBackend::reportVacuumDatabaseResult(int sqliteErrorCode)
+void DatabaseBackendBase::reportVacuumDatabaseResult(int sqliteErrorCode)
 {
     DatabaseObserver::reportVacuumDatabaseResult(this, sqliteErrorCode);
 }
@@ -27,8 +27,8 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef DatabaseBackend_h
-#define DatabaseBackend_h
+#ifndef DatabaseBackendBase_h
+#define DatabaseBackendBase_h
 
 #if ENABLE(SQL_DATABASE)
 
@@ -52,9 +52,9 @@ class DatabaseBackendContext;
 class DatabaseBase;
 class SecurityOrigin;
 
-class DatabaseBackend : public ThreadSafeRefCounted<DatabaseBackend> {
+class DatabaseBackendBase : public ThreadSafeRefCounted<DatabaseBackendBase> {
 public:
-    virtual ~DatabaseBackend();
+    virtual ~DatabaseBackendBase();
 
     virtual String version() const;
 
@@ -98,7 +98,7 @@ protected:
     friend class SQLTransactionBackend;
     friend class SQLTransactionBackendSync;
 
-    DatabaseBackend(PassRefPtr<DatabaseBackendContext>, const String& name, const String& expectedVersion,
+    DatabaseBackendBase(PassRefPtr<DatabaseBackendContext>, const String& name, const String& expectedVersion,
         const String& displayName, unsigned long estimatedSize, DatabaseType);
 
     void closeDatabase();
@@ -164,4 +164,4 @@ private:
 
 #endif // ENABLE(SQL_DATABASE)
 
-#endif // DatabaseBackend_h
+#endif // DatabaseBackendBase_h
index c19448c..b68038d 100644 (file)
@@ -34,7 +34,7 @@
 namespace WebCore {
 
 DatabaseBackendSync::DatabaseBackendSync(PassRefPtr<DatabaseBackendContext> databaseContext, const String& name, const String& expectedVersion, const String& displayName, unsigned long estimatedSize)
-    : DatabaseBackend(databaseContext, name, expectedVersion, displayName, estimatedSize, DatabaseType::Sync)
+    : DatabaseBackendBase(databaseContext, name, expectedVersion, displayName, estimatedSize, DatabaseType::Sync)
 {
 }
 
index 560fe3b..a976f7f 100644 (file)
@@ -28,7 +28,7 @@
 
 #if ENABLE(SQL_DATABASE)
 
-#include "DatabaseBackend.h"
+#include "DatabaseBackendBase.h"
 #include <wtf/text/WTFString.h>
 
 namespace WebCore {
@@ -41,7 +41,7 @@ class DatabaseServer;
 // DatabaseBackendSync to do so before the proper backend split is
 // available. This should be replaced with the actual implementation later.
 
-class DatabaseBackendSync : public DatabaseBackend {
+class DatabaseBackendSync : public DatabaseBackendBase {
 public:
     virtual ~DatabaseBackendSync();
 
index 7a2533b..573bf14 100644 (file)
@@ -28,7 +28,7 @@
 
 #if ENABLE(SQL_DATABASE)
 
-#include "DatabaseBackend.h"
+#include <wtf/text/WTFString.h>
 
 namespace WebCore {
 
index d5d1d49..3c3ce0d 100644 (file)
@@ -30,8 +30,8 @@
 
 #include "AbstractDatabaseServer.h"
 #include "Database.h"
-#include "DatabaseBackend.h"
 #include "DatabaseBackendAsync.h"
+#include "DatabaseBackendBase.h"
 #include "DatabaseBackendContext.h"
 #include "DatabaseBackendSync.h"
 #include "DatabaseCallback.h"
@@ -227,7 +227,7 @@ static void logOpenDatabaseError(ScriptExecutionContext* context, const String&
         context->securityOrigin()->toString().ascii().data());
 }
 
-PassRefPtr<DatabaseBackend> DatabaseManager::openDatabaseBackend(ScriptExecutionContext* context,
+PassRefPtr<DatabaseBackendBase> DatabaseManager::openDatabaseBackend(ScriptExecutionContext* context,
     DatabaseType type, const String& name, const String& expectedVersion, const String& displayName,
     unsigned long estimatedSize, bool setVersionInNewDatabase, DatabaseError& error, String& errorMessage)
 {
@@ -236,7 +236,7 @@ PassRefPtr<DatabaseBackend> DatabaseManager::openDatabaseBackend(ScriptExecution
     RefPtr<DatabaseContext> databaseContext = databaseContextFor(context);
     RefPtr<DatabaseBackendContext> backendContext = databaseContext->backend();
 
-    RefPtr<DatabaseBackend> backend = m_server->openDatabase(backendContext, type, name, expectedVersion,
+    RefPtr<DatabaseBackendBase> backend = m_server->openDatabase(backendContext, type, name, expectedVersion,
         displayName, estimatedSize, setVersionInNewDatabase, error, errorMessage);
 
     if (!backend) {
@@ -297,7 +297,7 @@ PassRefPtr<Database> DatabaseManager::openDatabase(ScriptExecutionContext* conte
 
     bool setVersionInNewDatabase = !creationCallback;
     String errorMessage;
-    RefPtr<DatabaseBackend> backend = openDatabaseBackend(context, DatabaseType::Async, name,
+    RefPtr<DatabaseBackendBase> backend = openDatabaseBackend(context, DatabaseType::Async, name,
         expectedVersion, displayName, estimatedSize, setVersionInNewDatabase, error, errorMessage);
     if (!backend)
         return 0;
@@ -326,7 +326,7 @@ PassRefPtr<DatabaseSync> DatabaseManager::openDatabaseSync(ScriptExecutionContex
 
     bool setVersionInNewDatabase = !creationCallback;
     String errorMessage;
-    RefPtr<DatabaseBackend> backend = openDatabaseBackend(context, DatabaseType::Sync, name,
+    RefPtr<DatabaseBackendBase> backend = openDatabaseBackend(context, DatabaseType::Sync, name,
         expectedVersion, displayName, estimatedSize, setVersionInNewDatabase, error, errorMessage);
     if (!backend)
         return 0;
@@ -428,7 +428,7 @@ void DatabaseManager::interruptAllDatabasesForContext(ScriptExecutionContext* co
         m_server->interruptAllDatabasesForContext(databaseContext->backend().get());
 }
 
-unsigned long long DatabaseManager::getMaxSizeForDatabase(const DatabaseBackend* database)
+unsigned long long DatabaseManager::getMaxSizeForDatabase(const DatabaseBackendBase* database)
 {
     return m_server->getMaxSizeForDatabase(database);
 }
index b260293..35f83b1 100644 (file)
@@ -40,7 +40,7 @@ namespace WebCore {
 
 class AbstractDatabaseServer;
 class Database;
-class DatabaseBackend;
+class DatabaseBackendBase;
 class DatabaseCallback;
 class DatabaseContext;
 class DatabaseManagerClient;
@@ -110,7 +110,7 @@ public:
 
     void interruptAllDatabasesForContext(ScriptExecutionContext*);
 
-    unsigned long long getMaxSizeForDatabase(const DatabaseBackend*);
+    unsigned long long getMaxSizeForDatabase(const DatabaseBackendBase*);
 
 private:
     DatabaseManager();
@@ -120,7 +120,7 @@ private:
     // it already exist previously. Otherwise, it returns 0.
     PassRefPtr<DatabaseContext> existingDatabaseContextFor(ScriptExecutionContext*);
 
-    PassRefPtr<DatabaseBackend> openDatabaseBackend(ScriptExecutionContext*,
+    PassRefPtr<DatabaseBackendBase> openDatabaseBackend(ScriptExecutionContext*,
         DatabaseType, const String& name, const String& expectedVersion, const String& displayName,
         unsigned long estimatedSize, bool setVersionInNewDatabase, DatabaseError&, String& errorMessage);
 
index c967793..ede541e 100644 (file)
@@ -140,12 +140,12 @@ void DatabaseServer::interruptAllDatabasesForContext(const DatabaseBackendContex
     DatabaseTracker::tracker().interruptAllDatabasesForContext(context);
 }
 
-PassRefPtr<DatabaseBackend> DatabaseServer::openDatabase(RefPtr<DatabaseBackendContext>& backendContext,
+PassRefPtr<DatabaseBackendBase> DatabaseServer::openDatabase(RefPtr<DatabaseBackendContext>& backendContext,
     DatabaseType type, const String& name, const String& expectedVersion, const String& displayName,
     unsigned long estimatedSize, bool setVersionInNewDatabase, DatabaseError &error, String& errorMessage,
     OpenAttempt attempt)
 {
-    RefPtr<DatabaseBackend> database;
+    RefPtr<DatabaseBackendBase> database;
     bool success = false; // Make some older compilers happy.
     
     switch (attempt) {
@@ -161,11 +161,11 @@ PassRefPtr<DatabaseBackend> DatabaseServer::openDatabase(RefPtr<DatabaseBackendC
     return database.release();
 }
 
-PassRefPtr<DatabaseBackend> DatabaseServer::createDatabase(RefPtr<DatabaseBackendContext>& backendContext,
+PassRefPtr<DatabaseBackendBase> DatabaseServer::createDatabase(RefPtr<DatabaseBackendContext>& backendContext,
     DatabaseType type, const String& name, const String& expectedVersion, const String& displayName,
     unsigned long estimatedSize, bool setVersionInNewDatabase, DatabaseError& error, String& errorMessage)
 {
-    RefPtr<DatabaseBackend> database;
+    RefPtr<DatabaseBackendBase> database;
     switch (type) {
     case DatabaseType::Async:
         database = adoptRef(new Database(backendContext, name, expectedVersion, displayName, estimatedSize));
@@ -181,7 +181,7 @@ PassRefPtr<DatabaseBackend> DatabaseServer::createDatabase(RefPtr<DatabaseBacken
     return database.release();
 }
 
-unsigned long long DatabaseServer::getMaxSizeForDatabase(const DatabaseBackend* database)
+unsigned long long DatabaseServer::getMaxSizeForDatabase(const DatabaseBackendBase* database)
 {
     return DatabaseTracker::tracker().getMaxSizeForDatabase(database);
 }
index 44c9438..a2b6cd8 100644 (file)
@@ -45,7 +45,9 @@ public:
 
     virtual String fullPathForDatabase(SecurityOrigin*, const String& name, bool createIfDoesNotExist);
 
-    virtual PassRefPtr<DatabaseBackend> openDatabase(RefPtr<DatabaseBackendContext>&, DatabaseType, const String& name, const String& expectedVersion, const String& displayName, unsigned long estimatedSize, bool setVersionInNewDatabase, DatabaseError&, String& errorMessage, OpenAttempt);
+    virtual PassRefPtr<DatabaseBackendBase> openDatabase(RefPtr<DatabaseBackendContext>&, DatabaseType,
+        const String& name, const String& expectedVersion, const String& displayName, unsigned long estimatedSize,
+        bool setVersionInNewDatabase, DatabaseError&, String& errorMessage, OpenAttempt);
 
 #if !PLATFORM(CHROMIUM)
     virtual bool hasEntryForOrigin(SecurityOrigin*);
@@ -68,10 +70,12 @@ public:
 
     virtual void interruptAllDatabasesForContext(const DatabaseBackendContext*);
 
-    virtual unsigned long long getMaxSizeForDatabase(const DatabaseBackend*);
+    virtual unsigned long long getMaxSizeForDatabase(const DatabaseBackendBase*);
 
 protected:
-    virtual PassRefPtr<DatabaseBackend> createDatabase(RefPtr<DatabaseBackendContext>&, DatabaseType, const String& name, const String& expectedVersion, const String& displayName, unsigned long estimatedSize, bool setVersionInNewDatabase, DatabaseError&, String& errorMessage);
+    virtual PassRefPtr<DatabaseBackendBase> createDatabase(RefPtr<DatabaseBackendContext>&, DatabaseType,
+        const String& name, const String& expectedVersion, const String& displayName, unsigned long estimatedSize,
+        bool setVersionInNewDatabase, DatabaseError&, String& errorMessage);
 };
 
 } // namespace WebCore
index ee7f4d1..faa9c9b 100644 (file)
@@ -51,7 +51,7 @@
 
 namespace WebCore {
 
-PassRefPtr<DatabaseSync> DatabaseSync::create(ScriptExecutionContext*, PassRefPtr<DatabaseBackend> backend)
+PassRefPtr<DatabaseSync> DatabaseSync::create(ScriptExecutionContext*, PassRefPtr<DatabaseBackendBase> backend)
 {
     return static_cast<DatabaseSync*>(backend.get());
 }
index 5f62e7c..f0e3593 100644 (file)
@@ -77,7 +77,7 @@ private:
     DatabaseSync(PassRefPtr<DatabaseBackendContext>, const String& name,
         const String& expectedVersion, const String& displayName, unsigned long estimatedSize);
     PassRefPtr<DatabaseBackendSync> backend();
-    static PassRefPtr<DatabaseSync> create(ScriptExecutionContext*, PassRefPtr<DatabaseBackend>);
+    static PassRefPtr<DatabaseSync> create(ScriptExecutionContext*, PassRefPtr<DatabaseBackendBase>);
 
     void runTransaction(PassRefPtr<SQLTransactionSyncCallback>, bool readOnly, ExceptionCode&);
 
index e9a0b90..47b949e 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2007, 2008, 2012 Apple Inc. All rights reserved.
+ * Copyright (C) 2007, 2008, 2012, 2013 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -33,7 +33,7 @@
 
 #include "Chrome.h"
 #include "ChromeClient.h"
-#include "DatabaseBackend.h"
+#include "DatabaseBackendBase.h"
 #include "DatabaseBackendContext.h"
 #include "DatabaseManager.h"
 #include "DatabaseManagerClient.h"
@@ -283,7 +283,7 @@ bool DatabaseTracker::hasEntryForDatabase(SecurityOrigin* origin, const String&
     return statement.step() == SQLResultRow;
 }
 
-unsigned long long DatabaseTracker::getMaxSizeForDatabase(const DatabaseBackend* database)
+unsigned long long DatabaseTracker::getMaxSizeForDatabase(const DatabaseBackendBase* database)
 {
     // The maximum size for a database is the full quota for its origin, minus the current usage within the origin,
     // plus the current usage of the given database
@@ -293,7 +293,7 @@ unsigned long long DatabaseTracker::getMaxSizeForDatabase(const DatabaseBackend*
     return quotaForOriginNoLock(origin) - originQuotaManager().diskUsage(origin) + SQLiteFileSystem::getDatabaseFileSize(database->fileName());
 }
 
-void DatabaseTracker::databaseChanged(DatabaseBackend* database)
+void DatabaseTracker::databaseChanged(DatabaseBackendBase* database)
 {
     Locker<OriginQuotaManager> quotaManagerLocker(originQuotaManager());
     originQuotaManager().markDatabase(database);
@@ -301,7 +301,7 @@ void DatabaseTracker::databaseChanged(DatabaseBackend* database)
 
 void DatabaseTracker::interruptAllDatabasesForContext(const DatabaseBackendContext* context)
 {
-    Vector<RefPtr<DatabaseBackend> > openDatabases;
+    Vector<RefPtr<DatabaseBackendBase> > openDatabases;
     {
         MutexLocker openDatabaseMapLock(m_openDatabaseMapGuard);
 
@@ -323,8 +323,8 @@ void DatabaseTracker::interruptAllDatabasesForContext(const DatabaseBackendConte
         }
     }
 
-    Vector<RefPtr<DatabaseBackend> >::const_iterator openDatabasesEndIt = openDatabases.end();
-    for (Vector<RefPtr<DatabaseBackend> >::const_iterator openDatabasesIt = openDatabases.begin(); openDatabasesIt != openDatabasesEndIt; ++openDatabasesIt)
+    Vector<RefPtr<DatabaseBackendBase> >::const_iterator openDatabasesEndIt = openDatabases.end();
+    for (Vector<RefPtr<DatabaseBackendBase> >::const_iterator openDatabasesIt = openDatabases.begin(); openDatabasesIt != openDatabasesEndIt; ++openDatabasesIt)
         (*openDatabasesIt)->interrupt();
 }
 
@@ -562,13 +562,13 @@ unsigned long long DatabaseTracker::usageForDatabase(const String& name, Securit
     return SQLiteFileSystem::getDatabaseFileSize(path);
 }
 
-void DatabaseTracker::doneCreatingDatabase(DatabaseBackend* database)
+void DatabaseTracker::doneCreatingDatabase(DatabaseBackendBase* database)
 {
     MutexLocker lockDatabase(m_databaseGuard);
     doneCreatingDatabase(database->securityOrigin(), database->stringIdentifier());
 }
 
-void DatabaseTracker::addOpenDatabase(DatabaseBackend* database)
+void DatabaseTracker::addOpenDatabase(DatabaseBackendBase* database)
 {
     if (!database)
         return;
@@ -604,7 +604,7 @@ void DatabaseTracker::addOpenDatabase(DatabaseBackend* database)
     }
 }
 
-void DatabaseTracker::removeOpenDatabase(DatabaseBackend* database)
+void DatabaseTracker::removeOpenDatabase(DatabaseBackendBase* database)
 {
     if (!database)
         return;
@@ -651,7 +651,7 @@ void DatabaseTracker::removeOpenDatabase(DatabaseBackend* database)
     }
 }
 
-void DatabaseTracker::getOpenDatabases(SecurityOrigin* origin, const String& name, HashSet<RefPtr<DatabaseBackend> >* databases)
+void DatabaseTracker::getOpenDatabases(SecurityOrigin* origin, const String& name, HashSet<RefPtr<DatabaseBackendBase> >* databases)
 {
     MutexLocker openDatabaseMapLock(m_openDatabaseMapGuard);
     if (!m_openDatabaseMap)
@@ -1077,7 +1077,7 @@ bool DatabaseTracker::deleteDatabaseFile(SecurityOrigin* origin, const String& n
     }
 #endif
 
-    Vector<RefPtr<DatabaseBackend> > deletedDatabases;
+    Vector<RefPtr<DatabaseBackendBase> > deletedDatabases;
 
     // Make sure not to hold the any locks when calling
     // Database::markAsDeletedAndClose(), since that can cause a deadlock
index c18293b..32abbd1 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2007, 2008 Apple Inc. All rights reserved.
+ * Copyright (C) 2007, 2008, 2013 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -46,7 +46,7 @@
 
 namespace WebCore {
 
-class DatabaseBackend;
+class DatabaseBackendBase;
 class DatabaseBackendContext;
 class SecurityOrigin;
 
@@ -75,12 +75,12 @@ public:
     void setDatabaseDetails(SecurityOrigin*, const String& name, const String& displayName, unsigned long estimatedSize);
     String fullPathForDatabase(SecurityOrigin*, const String& name, bool createIfDoesNotExist = true);
 
-    void addOpenDatabase(DatabaseBackend*);
-    void removeOpenDatabase(DatabaseBackend*);
-    void getOpenDatabases(SecurityOrigin*, const String& name, HashSet<RefPtr<DatabaseBackend> >* databases);
+    void addOpenDatabase(DatabaseBackendBase*);
+    void removeOpenDatabase(DatabaseBackendBase*);
+    void getOpenDatabases(SecurityOrigin*, const String& name, HashSet<RefPtr<DatabaseBackendBase> >* databases);
 
-    unsigned long long getMaxSizeForDatabase(const DatabaseBackend*);
-    void databaseChanged(DatabaseBackend*);
+    unsigned long long getMaxSizeForDatabase(const DatabaseBackendBase*);
+    void databaseChanged(DatabaseBackendBase*);
 
     void interruptAllDatabasesForContext(const DatabaseBackendContext*);
 
@@ -115,7 +115,7 @@ public:
 
     bool hasEntryForOrigin(SecurityOrigin*);
 
-    void doneCreatingDatabase(DatabaseBackend*);
+    void doneCreatingDatabase(DatabaseBackendBase*);
 
 private:
     bool hasEntryForOriginNoLock(SecurityOrigin* origin);
@@ -141,7 +141,7 @@ private:
 
     bool deleteDatabaseFile(SecurityOrigin*, const String& name);
 
-    typedef HashSet<DatabaseBackend*> DatabaseSet;
+    typedef HashSet<DatabaseBackendBase*> DatabaseSet;
     typedef HashMap<String, DatabaseSet*> DatabaseNameMap;
     typedef HashMap<RefPtr<SecurityOrigin>, DatabaseNameMap*> DatabaseOriginMap;
 
@@ -184,16 +184,16 @@ private:
 public:
     void closeDatabasesImmediately(const String& originIdentifier, const String& name);
 
-    void prepareToOpenDatabase(DatabaseBackend*);
-    void failedToOpenDatabase(DatabaseBackend*);
+    void prepareToOpenDatabase(DatabaseBackendBase*);
+    void failedToOpenDatabase(DatabaseBackendBase*);
 
 private:
-    typedef HashSet<DatabaseBackend*> DatabaseSet;
+    typedef HashSet<DatabaseBackendBase*> DatabaseSet;
     typedef HashMap<String, DatabaseSet*> DatabaseNameMap;
     typedef HashMap<String, DatabaseNameMap*> DatabaseOriginMap;
     class CloseOneDatabaseImmediatelyTask;
 
-    void closeOneDatabaseImmediately(const String& originIdentifier, const String& name, DatabaseBackend*);
+    void closeOneDatabaseImmediately(const String& originIdentifier, const String& name, DatabaseBackendBase*);
 
     Mutex m_openDatabaseMapGuard;
     mutable OwnPtr<DatabaseOriginMap> m_openDatabaseMap;
index 39edacf..2c23b5c 100644 (file)
@@ -30,7 +30,7 @@
 
 #if ENABLE(SQL_DATABASE)
 
-#include "DatabaseBackend.h"
+#include "DatabaseBackendBase.h"
 #include "OriginUsageRecord.h"
 
 namespace WebCore {
@@ -112,7 +112,7 @@ void OriginQuotaManager::removeOrigin(SecurityOrigin* origin)
     }
 }
 
-void OriginQuotaManager::markDatabase(DatabaseBackend* database)
+void OriginQuotaManager::markDatabase(DatabaseBackendBase* database)
 {
     ASSERT(database);
     ASSERT(m_usageRecordGuardLocked);
index bdc9e42..d743daf 100644 (file)
@@ -38,7 +38,7 @@
 
 namespace WebCore {
 
-class DatabaseBackend;
+class DatabaseBackendBase;
 class OriginUsageRecord;
 class SecurityOrigin;
 
@@ -57,7 +57,7 @@ public:
     void removeDatabase(SecurityOrigin*, const String& databaseIdentifier);
     void removeOrigin(SecurityOrigin*);
 
-    void markDatabase(DatabaseBackend*); // Mark dirtiness of a specific database.
+    void markDatabase(DatabaseBackendBase*); // Mark dirtiness of a specific database.
     unsigned long long diskUsage(SecurityOrigin*) const;
 
 private:
index 1c7f2ba..2fbdd95 100644 (file)
@@ -33,7 +33,7 @@
 
 #if ENABLE(SQL_DATABASE)
 
-#include "DatabaseBackend.h"
+#include "DatabaseBackendBase.h"
 #include "DatabaseBackendContext.h"
 #include "DatabaseManager.h"
 #include "DatabaseTracker.h"
 
 namespace WebCore {
 
-void SQLTransactionClient::didCommitWriteTransaction(DatabaseBackend* database)
+void SQLTransactionClient::didCommitWriteTransaction(DatabaseBackendBase* database)
 {
     DatabaseTracker::tracker().scheduleNotifyDatabaseChanged(
         database->securityOrigin(), database->stringIdentifier());
 }
 
-void SQLTransactionClient::didExecuteStatement(DatabaseBackend* database)
+void SQLTransactionClient::didExecuteStatement(DatabaseBackendBase* database)
 {
     DatabaseTracker::tracker().databaseChanged(database);
 }
 
-bool SQLTransactionClient::didExceedQuota(DatabaseBackend* database)
+bool SQLTransactionClient::didExceedQuota(DatabaseBackendBase* database)
 {
     ASSERT(database->databaseContext()->scriptExecutionContext()->isContextThread());
     unsigned long long currentQuota = DatabaseManager::manager().quotaForOrigin(database->securityOrigin());
index 8e038dd..4e3d50d 100644 (file)
@@ -38,7 +38,7 @@
 
 namespace WebCore {
 
-class DatabaseBackend;
+class DatabaseBackendBase;
 
 // A client to the SQLTransaction class. Allows SQLTransaction to notify interested
 // parties that certain things have happened in a transaction.
@@ -46,9 +46,9 @@ class SQLTransactionClient {
     WTF_MAKE_NONCOPYABLE(SQLTransactionClient); WTF_MAKE_FAST_ALLOCATED;
 public:
     SQLTransactionClient() { }
-    void didCommitWriteTransaction(DatabaseBackend*);
-    void didExecuteStatement(DatabaseBackend*);
-    bool didExceedQuota(DatabaseBackend*);
+    void didCommitWriteTransaction(DatabaseBackendBase*);
+    void didExecuteStatement(DatabaseBackendBase*);
+    bool didExceedQuota(DatabaseBackendBase*);
 };
 
 }
index e1eeba8..b4bc22a 100644 (file)
@@ -37,7 +37,7 @@
 
 namespace WebCore {
 
-class DatabaseBackend;
+class DatabaseBackendBase;
 class ScriptExecutionContext;
 
 // The implementation of this class is in the WebKit API (Chromium source tree)
@@ -45,16 +45,16 @@ class ScriptExecutionContext;
 class DatabaseObserver {
 public:
     static bool canEstablishDatabase(ScriptExecutionContext*, const String&, const String&, unsigned long);
-    static void databaseOpened(DatabaseBackend*);
-    static void databaseModified(DatabaseBackend*);
-    static void databaseClosed(DatabaseBackend*);
+    static void databaseOpened(DatabaseBackendBase*);
+    static void databaseModified(DatabaseBackendBase*);
+    static void databaseClosed(DatabaseBackendBase*);
 
-    static void reportOpenDatabaseResult(DatabaseBackend*, int callsite, int webSqlErrorCode, int sqliteErrorCode);
-    static void reportChangeVersionResult(DatabaseBackend*, int callsite, int webSqlErrorCode, int sqliteErrorCode);
-    static void reportStartTransactionResult(DatabaseBackend*, int callsite, int webSqlErrorCode, int sqliteErrorCode);
-    static void reportCommitTransactionResult(DatabaseBackend*, int callsite, int webSqlErrorCode, int sqliteErrorCode);
-    static void reportExecuteStatementResult(DatabaseBackend*, int callsite, int webSqlErrorCode, int sqliteErrorCode);
-    static void reportVacuumDatabaseResult(DatabaseBackend*, int sqliteErrorCode);
+    static void reportOpenDatabaseResult(DatabaseBackendBase*, int callsite, int webSqlErrorCode, int sqliteErrorCode);
+    static void reportChangeVersionResult(DatabaseBackendBase*, int callsite, int webSqlErrorCode, int sqliteErrorCode);
+    static void reportStartTransactionResult(DatabaseBackendBase*, int callsite, int webSqlErrorCode, int sqliteErrorCode);
+    static void reportCommitTransactionResult(DatabaseBackendBase*, int callsite, int webSqlErrorCode, int sqliteErrorCode);
+    static void reportExecuteStatementResult(DatabaseBackendBase*, int callsite, int webSqlErrorCode, int sqliteErrorCode);
+    static void reportVacuumDatabaseResult(DatabaseBackendBase*, int sqliteErrorCode);
 };
 
 }
index 358ffab..4a1d812 100644 (file)
@@ -33,7 +33,7 @@
 
 #if ENABLE(SQL_DATABASE)
 
-#include "DatabaseBackend.h"
+#include "DatabaseBackendBase.h"
 #include "DatabaseBackendContext.h"
 #include "DatabaseObserver.h"
 #include "QuotaTracker.h"
@@ -83,7 +83,7 @@ String DatabaseTracker::fullPathForDatabase(SecurityOrigin* origin, const String
     return origin->databaseIdentifier() + "/" + name + "#";
 }
 
-void DatabaseTracker::addOpenDatabase(DatabaseBackend* database)
+void DatabaseTracker::addOpenDatabase(DatabaseBackendBase* database)
 {
     MutexLocker openDatabaseMapLock(m_openDatabaseMapGuard);
     if (!m_openDatabaseMap)
@@ -108,7 +108,7 @@ void DatabaseTracker::addOpenDatabase(DatabaseBackend* database)
 
 class NotifyDatabaseObserverOnCloseTask : public ScriptExecutionContext::Task {
 public:
-    static PassOwnPtr<NotifyDatabaseObserverOnCloseTask> create(PassRefPtr<DatabaseBackend> database)
+    static PassOwnPtr<NotifyDatabaseObserverOnCloseTask> create(PassRefPtr<DatabaseBackendBase> database)
     {
         return adoptPtr(new NotifyDatabaseObserverOnCloseTask(database));
     }
@@ -124,15 +124,15 @@ public:
     }
 
 private:
-    NotifyDatabaseObserverOnCloseTask(PassRefPtr<DatabaseBackend> database)
+    NotifyDatabaseObserverOnCloseTask(PassRefPtr<DatabaseBackendBase> database)
         : m_database(database)
     {
     }
 
-    RefPtr<DatabaseBackend> m_database;
+    RefPtr<DatabaseBackendBase> m_database;
 };
 
-void DatabaseTracker::removeOpenDatabase(DatabaseBackend* database)
+void DatabaseTracker::removeOpenDatabase(DatabaseBackendBase* database)
 {
     String originIdentifier = database->securityOrigin()->databaseIdentifier();
     MutexLocker openDatabaseMapLock(m_openDatabaseMapGuard);
@@ -167,13 +167,13 @@ void DatabaseTracker::removeOpenDatabase(DatabaseBackend* database)
         DatabaseObserver::databaseClosed(database);
 }
 
-void DatabaseTracker::prepareToOpenDatabase(DatabaseBackend* database)
+void DatabaseTracker::prepareToOpenDatabase(DatabaseBackendBase* database)
 {
     ASSERT(database->databaseContext()->scriptExecutionContext()->isContextThread());
     DatabaseObserver::databaseOpened(database);
 }
 
-void DatabaseTracker::failedToOpenDatabase(DatabaseBackend* database)
+void DatabaseTracker::failedToOpenDatabase(DatabaseBackendBase* database)
 {
     ScriptExecutionContext* scriptExecutionContext = database->databaseContext()->scriptExecutionContext();
     if (!scriptExecutionContext->isContextThread())
@@ -182,7 +182,7 @@ void DatabaseTracker::failedToOpenDatabase(DatabaseBackend* database)
         DatabaseObserver::databaseClosed(database);
 }
 
-unsigned long long DatabaseTracker::getMaxSizeForDatabase(const DatabaseBackend* database)
+unsigned long long DatabaseTracker::getMaxSizeForDatabase(const DatabaseBackendBase* database)
 {
     unsigned long long spaceAvailable = 0;
     unsigned long long databaseSize = 0;
@@ -216,7 +216,7 @@ void DatabaseTracker::interruptAllDatabasesForContext(const DatabaseBackendConte
 
 class DatabaseTracker::CloseOneDatabaseImmediatelyTask : public ScriptExecutionContext::Task {
 public:
-    static PassOwnPtr<CloseOneDatabaseImmediatelyTask> create(const String& originIdentifier, const String& name, DatabaseBackend* database)
+    static PassOwnPtr<CloseOneDatabaseImmediatelyTask> create(const String& originIdentifier, const String& name, DatabaseBackendBase* database)
     {
         return adoptPtr(new CloseOneDatabaseImmediatelyTask(originIdentifier, name, database));
     }
@@ -227,7 +227,7 @@ public:
     }
 
 private:
-    CloseOneDatabaseImmediatelyTask(const String& originIdentifier, const String& name, DatabaseBackend* database)
+    CloseOneDatabaseImmediatelyTask(const String& originIdentifier, const String& name, DatabaseBackendBase* database)
         : m_originIdentifier(originIdentifier.isolatedCopy())
         , m_name(name.isolatedCopy())
         , m_database(database)
@@ -236,7 +236,7 @@ private:
 
     String m_originIdentifier;
     String m_name;
-    DatabaseBackend* m_database; // Intentionally a raw pointer.
+    DatabaseBackendBase* m_database; // Intentionally a raw pointer.
 };
 
 void DatabaseTracker::closeDatabasesImmediately(const String& originIdentifier, const String& name) {
@@ -259,7 +259,7 @@ void DatabaseTracker::closeDatabasesImmediately(const String& originIdentifier,
         (*it)->databaseContext()->scriptExecutionContext()->postTask(CloseOneDatabaseImmediatelyTask::create(originIdentifier, name, *it));
 }
 
-void DatabaseTracker::closeOneDatabaseImmediately(const String& originIdentifier, const String& name, DatabaseBackend* database)
+void DatabaseTracker::closeOneDatabaseImmediately(const String& originIdentifier, const String& name, DatabaseBackendBase* database)
 {
     // First we have to confirm the 'database' is still in our collection.
     {
index eab87d1..b12331d 100644 (file)
@@ -33,7 +33,7 @@
 
 #if ENABLE(SQL_DATABASE)
 
-#include "DatabaseBackend.h"
+#include "DatabaseBackendBase.h"
 #include "DatabaseBackendContext.h"
 #include "DatabaseObserver.h"
 #include "ScriptExecutionContext.h"
@@ -42,7 +42,7 @@ namespace WebCore {
 
 class NotifyDatabaseChangedTask : public ScriptExecutionContext::Task {
 public:
-    static PassOwnPtr<NotifyDatabaseChangedTask> create(DatabaseBackend *database)
+    static PassOwnPtr<NotifyDatabaseChangedTask> create(DatabaseBackendBase *database)
     {
         return adoptPtr(new NotifyDatabaseChangedTask(database));
     }
@@ -53,15 +53,15 @@ public:
     }
 
 private:
-    NotifyDatabaseChangedTask(PassRefPtr<DatabaseBackend> database)
+    NotifyDatabaseChangedTask(PassRefPtr<DatabaseBackendBase> database)
         : m_database(database)
     {
     }
 
-    RefPtr<DatabaseBackend> m_database;
+    RefPtr<DatabaseBackendBase> m_database;
 };
 
-void SQLTransactionClient::didCommitWriteTransaction(DatabaseBackend* database)
+void SQLTransactionClient::didCommitWriteTransaction(DatabaseBackendBase* database)
 {
     ScriptExecutionContext* scriptExecutionContext = database->databaseContext()->scriptExecutionContext();
     if (!scriptExecutionContext->isContextThread()) {
@@ -72,13 +72,13 @@ void SQLTransactionClient::didCommitWriteTransaction(DatabaseBackend* database)
     WebCore::DatabaseObserver::databaseModified(database);
 }
 
-void SQLTransactionClient::didExecuteStatement(DatabaseBackend* database)
+void SQLTransactionClient::didExecuteStatement(DatabaseBackendBase* database)
 {
     // This method is called after executing every statement that changes the DB.
     // Chromium doesn't need to do anything at that point.
 }
 
-bool SQLTransactionClient::didExceedQuota(DatabaseBackend* database)
+bool SQLTransactionClient::didExceedQuota(DatabaseBackendBase* database)
 {
     // Chromium does not allow users to manually change the quota for an origin (for now, at least).
     // Don't do anything.
index 27c4879..9a45b9d 100644 (file)
@@ -33,7 +33,7 @@ SOURCES += \
     Modules/webdatabase/DOMWindowWebDatabase.cpp \
     Modules/webdatabase/Database.cpp \
     Modules/webdatabase/DatabaseAuthorizer.cpp \
-    Modules/webdatabase/DatabaseBackend.cpp \
+    Modules/webdatabase/DatabaseBackendBase.cpp \
     Modules/webdatabase/DatabaseContext.cpp \
     Modules/webdatabase/DatabaseServer.cpp \
     Modules/webdatabase/DatabaseSync.cpp \
@@ -1464,8 +1464,8 @@ HEADERS += \
     Modules/webdatabase/DOMWindowWebDatabase.h \
     Modules/webdatabase/DatabaseAuthorizer.h \
     Modules/webdatabase/Database.h \
-    Modules/webdatabase/DatabaseBackend.h \
     Modules/webdatabase/DatabaseBackendAsync.h \
+    Modules/webdatabase/DatabaseBackendBase.h \
     Modules/webdatabase/DatabaseBackendContext.h \
     Modules/webdatabase/DatabaseBackendSync.h \
     Modules/webdatabase/DatabaseBase.h \
index ba5e354..b3a5165 100644 (file)
             'Modules/webdatabase/Database.cpp',
             'Modules/webdatabase/DatabaseAuthorizer.cpp',
             'Modules/webdatabase/DatabaseAuthorizer.h',
-            'Modules/webdatabase/DatabaseBackend.cpp',
-            'Modules/webdatabase/DatabaseBackend.h',
             'Modules/webdatabase/DatabaseBackendAsync.cpp',
             'Modules/webdatabase/DatabaseBackendAsync.h',
+            'Modules/webdatabase/DatabaseBackendBase.cpp',
+            'Modules/webdatabase/DatabaseBackendBase.h',
             'Modules/webdatabase/DatabaseBackendContext.cpp',
             'Modules/webdatabase/DatabaseBackendContext.h',
             'Modules/webdatabase/DatabaseBackendSync.cpp',
index 36324bc..6fc5332 100755 (executable)
                                        >
                                </File>
                                <File
-                                       RelativePath="..\Modules\webdatabase\DatabaseBackend.cpp"
+                                       RelativePath="..\Modules\webdatabase\DatabaseBackendAsync.cpp"
                                        >
                                </File>
                                <File
-                                       RelativePath="..\Modules\webdatabase\DatabaseBackend.h"
+                                       RelativePath="..\Modules\webdatabase\DatabaseBackendAsync.h"
                                        >
                                </File>
                                <File
-                                       RelativePath="..\Modules\webdatabase\DatabaseBackendAsync.cpp"
+                                       RelativePath="..\Modules\webdatabase\DatabaseBackendBase.cpp"
                                        >
                                </File>
                                <File
-                                       RelativePath="..\Modules\webdatabase\DatabaseBackendAsync.h"
+                                       RelativePath="..\Modules\webdatabase\DatabaseBackendBase.h"
                                        >
                                </File>
                                <File
index ac4c03f..4b569be 100644 (file)
     <ClCompile Include="..\Modules\webdatabase\ChangeVersionWrapper.cpp" />
     <ClCompile Include="..\Modules\webdatabase\Database.cpp" />
     <ClCompile Include="..\Modules\webdatabase\DatabaseAuthorizer.cpp" />
-    <ClCompile Include="..\Modules\webdatabase\DatabaseBackend.cpp" />
     <ClCompile Include="..\Modules\webdatabase\DatabaseBackendAsync.cpp" />
+    <ClCompile Include="..\Modules\webdatabase\DatabaseBackendBase.cpp" />
     <ClCompile Include="..\Modules\webdatabase\DatabaseBackendContext.cpp" />
     <ClCompile Include="..\Modules\webdatabase\DatabaseBackendSync.cpp" />
     <ClCompile Include="..\Modules\webdatabase\DatabaseBase.cpp" />
     <ClInclude Include="..\Modules\webdatabase\ChangeVersionWrapper.h" />
     <ClInclude Include="..\Modules\webdatabase\Database.h" />
     <ClInclude Include="..\Modules\webdatabase\DatabaseAuthorizer.h" />
-    <ClInclude Include="..\Modules\webdatabase\DatabaseBackend.h" />
     <ClInclude Include="..\Modules\webdatabase\DatabaseBackendAsync.h" />
+    <ClInclude Include="..\Modules\webdatabase\DatabaseBackendBase.h" />
     <ClInclude Include="..\Modules\webdatabase\DatabaseBackendContext.h" />
     <ClInclude Include="..\Modules\webdatabase\DatabaseBackendSync.h" />
     <ClInclude Include="..\Modules\webdatabase\DatabaseBase.h" />
index 7727662..2a89bed 100644 (file)
     <ClCompile Include="..\Modules\webdatabase\DatabaseAuthorizer.cpp">
       <Filter>Modules\webdatabase</Filter>
     </ClCompile>
-    <ClCompile Include="..\Modules\webdatabase\DatabaseBackend.cpp">
+    <ClCompile Include="..\Modules\webdatabase\DatabaseBackendAsync.cpp">
       <Filter>Modules\webdatabase</Filter>
     </ClCompile>
-    <ClCompile Include="..\Modules\webdatabase\DatabaseBackendAsync.cpp">
+    <ClCompile Include="..\Modules\webdatabase\DatabaseBackendBase.cpp">
       <Filter>Modules\webdatabase</Filter>
     </ClCompile>
     <ClCompile Include="..\Modules\webdatabase\DatabaseBackendContext.cpp">
     <ClInclude Include="..\Modules\webdatabase\DatabaseAuthorizer.h">
       <Filter>Modules\webdatabase</Filter>
     </ClInclude>
-    <ClInclude Include="..\Modules\webdatabase\DatabaseBackend.h">
+    <ClInclude Include="..\Modules\webdatabase\DatabaseBackendAsync.h">
       <Filter>Modules\webdatabase</Filter>
     </ClInclude>
-    <ClInclude Include="..\Modules\webdatabase\DatabaseBackendAsync.h">
+    <ClInclude Include="..\Modules\webdatabase\DatabaseBackendBase.h">
       <Filter>Modules\webdatabase</Filter>
     </ClInclude>
     <ClInclude Include="..\Modules\webdatabase\DatabaseBackendContext.h">
index a6cec40..27f4b39 100644 (file)
                97B38E27151C4271004622E9 /* DOMWindowNotifications.h in Headers */ = {isa = PBXBuildFile; fileRef = 97B38E24151C4264004622E9 /* DOMWindowNotifications.h */; };
                97B38E28151C4273004622E9 /* DOMWindowNotifications.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 97B38E23151C4264004622E9 /* DOMWindowNotifications.cpp */; };
                97B8FFD116AE7F960038388D /* CharacterReferenceParserInlines.h in Headers */ = {isa = PBXBuildFile; fileRef = 97B8FFCF16AE7F920038388D /* CharacterReferenceParserInlines.h */; };
-               97BC69DA1505F076001B74AC /* DatabaseBackend.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 97BC69D61505F076001B74AC /* DatabaseBackend.cpp */; };
-               97BC69DB1505F076001B74AC /* DatabaseBackend.h in Headers */ = {isa = PBXBuildFile; fileRef = 97BC69D71505F076001B74AC /* DatabaseBackend.h */; settings = {ATTRIBUTES = (Private, ); }; };
+               97BC69DA1505F076001B74AC /* DatabaseBackendBase.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 97BC69D61505F076001B74AC /* DatabaseBackendBase.cpp */; };
+               97BC69DB1505F076001B74AC /* DatabaseBackendBase.h in Headers */ = {isa = PBXBuildFile; fileRef = 97BC69D71505F076001B74AC /* DatabaseBackendBase.h */; settings = {ATTRIBUTES = (Private, ); }; };
                97BC69DC1505F076001B74AC /* ChangeVersionWrapper.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 97BC69D81505F076001B74AC /* ChangeVersionWrapper.cpp */; };
                97BC69DD1505F076001B74AC /* ChangeVersionWrapper.h in Headers */ = {isa = PBXBuildFile; fileRef = 97BC69D91505F076001B74AC /* ChangeVersionWrapper.h */; };
                97BC6A201505F081001B74AC /* Database.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 97BC69DE1505F081001B74AC /* Database.cpp */; };
                97B38E24151C4264004622E9 /* DOMWindowNotifications.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = DOMWindowNotifications.h; path = Modules/notifications/DOMWindowNotifications.h; sourceTree = "<group>"; };
                97B38E25151C4264004622E9 /* DOMWindowNotifications.idl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; name = DOMWindowNotifications.idl; path = Modules/notifications/DOMWindowNotifications.idl; sourceTree = "<group>"; };
                97B8FFCF16AE7F920038388D /* CharacterReferenceParserInlines.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CharacterReferenceParserInlines.h; sourceTree = "<group>"; };
-               97BC69D61505F076001B74AC /* DatabaseBackend.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = DatabaseBackend.cpp; path = Modules/webdatabase/DatabaseBackend.cpp; sourceTree = "<group>"; };
-               97BC69D71505F076001B74AC /* DatabaseBackend.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = DatabaseBackend.h; path = Modules/webdatabase/DatabaseBackend.h; sourceTree = "<group>"; };
+               97BC69D61505F076001B74AC /* DatabaseBackendBase.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = DatabaseBackendBase.cpp; path = Modules/webdatabase/DatabaseBackendBase.cpp; sourceTree = "<group>"; };
+               97BC69D71505F076001B74AC /* DatabaseBackendBase.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = DatabaseBackendBase.h; path = Modules/webdatabase/DatabaseBackendBase.h; sourceTree = "<group>"; };
                97BC69D81505F076001B74AC /* ChangeVersionWrapper.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = ChangeVersionWrapper.cpp; path = Modules/webdatabase/ChangeVersionWrapper.cpp; sourceTree = "<group>"; };
                97BC69D91505F076001B74AC /* ChangeVersionWrapper.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = ChangeVersionWrapper.h; path = Modules/webdatabase/ChangeVersionWrapper.h; sourceTree = "<group>"; };
                97BC69DE1505F081001B74AC /* Database.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = Database.cpp; path = Modules/webdatabase/Database.cpp; sourceTree = "<group>"; };
                                97BC69E01505F081001B74AC /* Database.idl */,
                                97BC69E11505F081001B74AC /* DatabaseAuthorizer.cpp */,
                                97BC69E21505F081001B74AC /* DatabaseAuthorizer.h */,
-                               97BC69D61505F076001B74AC /* DatabaseBackend.cpp */,
-                               97BC69D71505F076001B74AC /* DatabaseBackend.h */,
                                FE16CFCF169D1DEC00D3A0C7 /* DatabaseBackendAsync.cpp */,
                                FE16CFD0169D1DEC00D3A0C7 /* DatabaseBackendAsync.h */,
+                               97BC69D61505F076001B74AC /* DatabaseBackendBase.cpp */,
+                               97BC69D71505F076001B74AC /* DatabaseBackendBase.h */,
                                FE6F6AAD169E057500FC30A2 /* DatabaseBackendContext.cpp */,
                                FE6F6AAE169E057500FC30A2 /* DatabaseBackendContext.h */,
                                FE16CFD1169D1DEC00D3A0C7 /* DatabaseBackendSync.cpp */,
                                A80E6D0B0A1989CA007FB8C5 /* DashboardRegion.h in Headers */,
                                97BC6A211505F081001B74AC /* Database.h in Headers */,
                                97BC6A241505F081001B74AC /* DatabaseAuthorizer.h in Headers */,
-                               97BC69DB1505F076001B74AC /* DatabaseBackend.h in Headers */,
                                FE16CFD4169D1DED00D3A0C7 /* DatabaseBackendAsync.h in Headers */,
+                               97BC69DB1505F076001B74AC /* DatabaseBackendBase.h in Headers */,
                                FE6F6AB0169E057500FC30A2 /* DatabaseBackendContext.h in Headers */,
                                FE16CFD6169D1DED00D3A0C7 /* DatabaseBackendSync.h in Headers */,
                                FEBC5F3216BD0CC300659BD3 /* DatabaseBase.h in Headers */,
                                A29532CF15DD5E1700469EBC /* CustomFilterValidatedProgram.cpp in Sources */,
                                97BC6A201505F081001B74AC /* Database.cpp in Sources */,
                                97BC6A231505F081001B74AC /* DatabaseAuthorizer.cpp in Sources */,
-                               97BC69DA1505F076001B74AC /* DatabaseBackend.cpp in Sources */,
                                FE16CFD3169D1DED00D3A0C7 /* DatabaseBackendAsync.cpp in Sources */,
+                               97BC69DA1505F076001B74AC /* DatabaseBackendBase.cpp in Sources */,
                                FE6F6AAF169E057500FC30A2 /* DatabaseBackendContext.cpp in Sources */,
                                FE16CFD5169D1DED00D3A0C7 /* DatabaseBackendSync.cpp in Sources */,
                                FEBC5F3116BD0CC300659BD3 /* DatabaseBase.cpp in Sources */,
index cae0138..cf0f102 100644 (file)
@@ -1,3 +1,25 @@
+2013-02-20  Mark Lam  <mark.lam@apple.com>
+
+        Rename DatabaseBackend to DatabaseBackendBase.
+        https://bugs.webkit.org/show_bug.cgi?id=110303.
+
+        Rubber stamped by Alexey Proskuryakov.
+
+        * public/WebDatabase.h:
+        (WebDatabase):
+        * src/DatabaseObserver.cpp:
+        (WebCore::DatabaseObserver::databaseOpened):
+        (WebCore::DatabaseObserver::databaseModified):
+        (WebCore::DatabaseObserver::databaseClosed):
+        (WebCore::DatabaseObserver::reportOpenDatabaseResult):
+        (WebCore::DatabaseObserver::reportChangeVersionResult):
+        (WebCore::DatabaseObserver::reportStartTransactionResult):
+        (WebCore::DatabaseObserver::reportCommitTransactionResult):
+        (WebCore::DatabaseObserver::reportExecuteStatementResult):
+        (WebCore::DatabaseObserver::reportVacuumDatabaseResult):
+        * src/WebDatabase.cpp:
+        (WebKit::WebDatabase::WebDatabase):
+
 2013-02-20  Rouslan Solomakhin  <rouslan@chromium.org>
 
         Fix use after free in ContextMenuClientImpl.cpp
index 94e4ffb..4dea186 100644 (file)
@@ -34,7 +34,7 @@
 #include "../../../Platform/chromium/public/WebCommon.h"
 #include "WebSecurityOrigin.h"
 
-namespace WebCore { class DatabaseBackend; }
+namespace WebCore { class DatabaseBackendBase; }
 
 namespace WebKit {
 
@@ -63,12 +63,12 @@ public:
         const WebString& originIdentifier, const WebString& databaseName);
 
 #if WEBKIT_IMPLEMENTATION
-    WebDatabase(const WebCore::DatabaseBackend*);
+    WebDatabase(const WebCore::DatabaseBackendBase*);
 #endif
 
 private:
     WebDatabase() { }
-    const WebCore::DatabaseBackend* m_database;
+    const WebCore::DatabaseBackendBase* m_database;
 };
 
 } // namespace WebKit
index 866f543..607afb4 100644 (file)
@@ -35,7 +35,7 @@
 
 #include "CrossThreadCopier.h"
 #include "CrossThreadTask.h"
-#include "DatabaseBackend.h"
+#include "DatabaseBackendBase.h"
 #include "DatabaseBackendContext.h"
 #include "Document.h"
 #include "ScriptExecutionContext.h"
@@ -178,50 +178,50 @@ bool DatabaseObserver::canEstablishDatabase(ScriptExecutionContext* scriptExecut
     return true;
 }
 
-void DatabaseObserver::databaseOpened(DatabaseBackend* database)
+void DatabaseObserver::databaseOpened(DatabaseBackendBase* database)
 {
     ASSERT(database->databaseContext()->scriptExecutionContext()->isContextThread());
     WebDatabase::observer()->databaseOpened(WebDatabase(database));
 }
 
-void DatabaseObserver::databaseModified(DatabaseBackend* database)
+void DatabaseObserver::databaseModified(DatabaseBackendBase* database)
 {
     ASSERT(database->databaseContext()->scriptExecutionContext()->isContextThread());
     WebDatabase::observer()->databaseModified(WebDatabase(database));
 }
 
-void DatabaseObserver::databaseClosed(DatabaseBackend* database)
+void DatabaseObserver::databaseClosed(DatabaseBackendBase* database)
 {
     ASSERT(database->databaseContext()->scriptExecutionContext()->isContextThread());
     WebDatabase::observer()->databaseClosed(WebDatabase(database));
 }
 
-void DatabaseObserver::reportOpenDatabaseResult(DatabaseBackend* database, int errorSite, int webSqlErrorCode, int sqliteErrorCode)
+void DatabaseObserver::reportOpenDatabaseResult(DatabaseBackendBase* database, int errorSite, int webSqlErrorCode, int sqliteErrorCode)
 {
     WebDatabase::observer()->reportOpenDatabaseResult(WebDatabase(database), errorSite, webSqlErrorCode, sqliteErrorCode);
 }
 
-void DatabaseObserver::reportChangeVersionResult(DatabaseBackend* database, int errorSite, int webSqlErrorCode, int sqliteErrorCode)
+void DatabaseObserver::reportChangeVersionResult(DatabaseBackendBase* database, int errorSite, int webSqlErrorCode, int sqliteErrorCode)
 {
     WebDatabase::observer()->reportChangeVersionResult(WebDatabase(database), errorSite, webSqlErrorCode, sqliteErrorCode);
 }
 
-void DatabaseObserver::reportStartTransactionResult(DatabaseBackend* database, int errorSite, int webSqlErrorCode, int sqliteErrorCode)
+void DatabaseObserver::reportStartTransactionResult(DatabaseBackendBase* database, int errorSite, int webSqlErrorCode, int sqliteErrorCode)
 {
     WebDatabase::observer()->reportStartTransactionResult(WebDatabase(database), errorSite, webSqlErrorCode, sqliteErrorCode);
 }
 
-void DatabaseObserver::reportCommitTransactionResult(DatabaseBackend* database, int errorSite, int webSqlErrorCode, int sqliteErrorCode)
+void DatabaseObserver::reportCommitTransactionResult(DatabaseBackendBase* database, int errorSite, int webSqlErrorCode, int sqliteErrorCode)
 {
     WebDatabase::observer()->reportCommitTransactionResult(WebDatabase(database), errorSite, webSqlErrorCode, sqliteErrorCode);
 }
 
-void DatabaseObserver::reportExecuteStatementResult(DatabaseBackend* database, int errorSite, int webSqlErrorCode, int sqliteErrorCode)
+void DatabaseObserver::reportExecuteStatementResult(DatabaseBackendBase* database, int errorSite, int webSqlErrorCode, int sqliteErrorCode)
 {
     WebDatabase::observer()->reportExecuteStatementResult(WebDatabase(database), errorSite, webSqlErrorCode, sqliteErrorCode);
 }
 
-void DatabaseObserver::reportVacuumDatabaseResult(DatabaseBackend* database, int sqliteErrorCode)
+void DatabaseObserver::reportVacuumDatabaseResult(DatabaseBackendBase* database, int sqliteErrorCode)
 {
     WebDatabase::observer()->reportVacuumDatabaseResult(WebDatabase(database), sqliteErrorCode);
 }
index f617f22..b8dd472 100644 (file)
@@ -31,7 +31,7 @@
 #include "config.h"
 #include "WebDatabase.h"
 
-#include "DatabaseBackend.h"
+#include "DatabaseBackendBase.h"
 #include "DatabaseManager.h"
 #include "QuotaTracker.h"
 #include "SecurityOrigin.h"
@@ -42,7 +42,7 @@
 
 #if !ENABLE(SQL_DATABASE)
 namespace WebCore {
-class DatabaseBackend {
+class DatabaseBackendBase {
 public:
     String stringIdentifier() const { return String(); }
     String displayName() const { return String(); }
@@ -127,7 +127,7 @@ void WebDatabase::closeDatabaseImmediately(const WebString& originIdentifier, co
 #endif
 }
 
-WebDatabase::WebDatabase(const DatabaseBackend* database)
+WebDatabase::WebDatabase(const DatabaseBackendBase* database)
     : m_database(database)
 {
 }