Changeset 61154 in webkit


Ignore:
Timestamp:
Jun 14, 2010 3:07:58 PM (14 years ago)
Author:
dumi@chromium.org
Message:

Get DatabaseTracker ready for sync DBs.
​https://bugs.webkit.org/show_bug.cgi?id=39041

Reviewed by Adam Barth.

WebCore:

  • storage/AbstractDatabase.cpp:

(WebCore::AbstractDatabase::~AbstractDatabase):

  • storage/AbstractDatabase.h:
  • storage/Database.cpp:

(WebCore::Database::closeImmediately):

  • storage/Database.h:

(WebCore::Database::scriptExecutionContext):

  • storage/DatabaseTracker.cpp:

(WebCore::DatabaseTracker::getMaxSizeForDatabase):
(WebCore::DatabaseTracker::databaseChanged):
(WebCore::DatabaseTracker::addOpenDatabase):
(WebCore::DatabaseTracker::removeOpenDatabase):
(WebCore::DatabaseTracker::getOpenDatabases):
(WebCore::DatabaseTracker::deleteDatabaseFile):

  • storage/DatabaseTracker.h:
  • storage/OriginQuotaManager.cpp:

(WebCore::OriginQuotaManager::markDatabase):

  • storage/OriginQuotaManager.h:
  • storage/chromium/DatabaseObserver.h:
  • storage/chromium/DatabaseTrackerChromium.cpp:

(WebCore::DatabaseTracker::addOpenDatabase):
(WebCore::TrackerRemoveOpenDatabaseTask::create):
(WebCore::TrackerRemoveOpenDatabaseTask::TrackerRemoveOpenDatabaseTask):
(WebCore::DatabaseTracker::removeOpenDatabase):
(WebCore::DatabaseTracker::getOpenDatabases):
(WebCore::DatabaseTracker::getMaxSizeForDatabase):

WebKit/chromium:

  • public/WebDatabase.h:
  • src/DatabaseObserver.cpp:

(WebCore::DatabaseObserver::databaseOpened):
(WebCore::DatabaseObserver::databaseModified):
(WebCore::DatabaseObserver::databaseClosed):

  • src/WebDatabase.cpp:

(WebKit::WebDatabase::closeDatabaseImmediately):
(WebKit::WebDatabase::WebDatabase):
(WebKit::WebDatabase::operator=):
(WebKit::WebDatabase::operator WTF::PassRefPtr<AbstractDatabase>):

Location:
trunk
Files:
15 edited

Legend:

Unmodified
Added
Removed

  • trunk/WebCore/ChangeLog

    r61153 r61154  
     12010-06-14  Dumitru Daniliuc  <dumi@chromium.org>
     2
     3        Reviewed by Adam Barth.
     4
     5        Get DatabaseTracker ready for sync DBs.
     6        https://bugs.webkit.org/show_bug.cgi?id=39041
     7
     8        * storage/AbstractDatabase.cpp:
     9        (WebCore::AbstractDatabase::~AbstractDatabase):
     10        * storage/AbstractDatabase.h:
     11        * storage/Database.cpp:
     12        (WebCore::Database::closeImmediately):
     13        * storage/Database.h:
     14        (WebCore::Database::scriptExecutionContext):
     15        * storage/DatabaseTracker.cpp:
     16        (WebCore::DatabaseTracker::getMaxSizeForDatabase):
     17        (WebCore::DatabaseTracker::databaseChanged):
     18        (WebCore::DatabaseTracker::addOpenDatabase):
     19        (WebCore::DatabaseTracker::removeOpenDatabase):
     20        (WebCore::DatabaseTracker::getOpenDatabases):
     21        (WebCore::DatabaseTracker::deleteDatabaseFile):
     22        * storage/DatabaseTracker.h:
     23        * storage/OriginQuotaManager.cpp:
     24        (WebCore::OriginQuotaManager::markDatabase):
     25        * storage/OriginQuotaManager.h:
     26        * storage/chromium/DatabaseObserver.h:
     27        * storage/chromium/DatabaseTrackerChromium.cpp:
     28        (WebCore::DatabaseTracker::addOpenDatabase):
     29        (WebCore::TrackerRemoveOpenDatabaseTask::create):
     30        (WebCore::TrackerRemoveOpenDatabaseTask::TrackerRemoveOpenDatabaseTask):
     31        (WebCore::DatabaseTracker::removeOpenDatabase):
     32        (WebCore::DatabaseTracker::getOpenDatabases):
     33        (WebCore::DatabaseTracker::getMaxSizeForDatabase):
     34
    1352010-06-14  Alexey Proskuryakov  <ap@apple.com>
    236

  • trunk/WebCore/storage/AbstractDatabase.cpp

    r59349 r61154  
    3434namespace WebCore {
    3535
     36AbstractDatabase::~AbstractDatabase()
     37{
     38}
     39
    3640} // namespace WebCore
    3741

  • trunk/WebCore/storage/AbstractDatabase.h

    r59349 r61154  
    3232#if ENABLE(DATABASE)
    3333
     34#include "PlatformString.h"
     35#include <wtf/ThreadSafeShared.h>
     36
    3437namespace WebCore {
    3538
    36 class AbstractDatabase {
     39class ScriptExecutionContext;
     40class SecurityOrigin;
     41
     42class AbstractDatabase : public ThreadSafeShared<AbstractDatabase> {
     43public:
     44    virtual ~AbstractDatabase();
     45
     46    virtual ScriptExecutionContext* scriptExecutionContext() const = 0;
     47    virtual SecurityOrigin* securityOrigin() const = 0;
     48    virtual String stringIdentifier() const = 0;
     49    virtual String displayName() const = 0;
     50    virtual unsigned long estimatedSize() const = 0;
     51    virtual String fileName() const = 0;
     52
     53    virtual void markAsDeletedAndClose() = 0;
     54    virtual void closeImmediately() = 0;
    3755};
    3856

  • trunk/WebCore/storage/Database.cpp

    r60683 r61154  
    452452}
    453453
     454void Database::closeImmediately()
     455{
     456    DatabaseThread* databaseThread = scriptExecutionContext()->databaseThread();
     457    if (databaseThread && !databaseThread->terminationRequested()) {
     458        stop();
     459        databaseThread->scheduleTask(DatabaseCloseTask::create(this, Database::RemoveDatabaseFromContext, 0));
     460    }
     461}
     462
    454463void Database::stop()
    455464{

  • trunk/WebCore/storage/Database.h

    r60513 r61154  
    3131
    3232#if ENABLE(DATABASE)
     33#include "AbstractDatabase.h"
    3334#include "PlatformString.h"
    3435#include "SQLiteDatabase.h"
    … …  
    5657typedef int ExceptionCode;
    5758
    58 class Database : public ThreadSafeShared<Database> {
     59class Database : public AbstractDatabase {
    5960public:
    6061    static void setIsAvailable(bool);
    6162    static bool isAvailable();
    6263
    63     ~Database();
     64    virtual ~Database();
    6465
    6566    // Direct support for the DOM API
    … …  
    8586    Vector<String> tableNames();
    8687
    87     ScriptExecutionContext* scriptExecutionContext() const { return m_scriptExecutionContext.get(); }
    88     SecurityOrigin* securityOrigin() const;
     88    virtual ScriptExecutionContext* scriptExecutionContext() const { return m_scriptExecutionContext.get(); }
     89    virtual SecurityOrigin* securityOrigin() const;
    8990    SQLiteDatabase& sqliteDatabase() { return m_sqliteDatabase; }
    90     String stringIdentifier() const;
    91     String displayName() const;
    92     unsigned long estimatedSize() const;
    93     String fileName() const;
     91    virtual String stringIdentifier() const;
     92    virtual String displayName() const;
     93    virtual unsigned long estimatedSize() const;
     94    virtual String fileName() const;
    9495
    9596    bool getVersionFromDatabase(String&);
    … …  
    9899    bool versionMatchesExpected() const;
    99100
    100     void markAsDeletedAndClose();
     101    virtual void markAsDeletedAndClose();
    101102    bool deleted() const { return m_deleted; }
    102103
    103104    enum ClosePolicy { DoNotRemoveDatabaseFromContext, RemoveDatabaseFromContext };
    104105    void close(ClosePolicy);
     106    virtual void closeImmediately();
    105107    bool opened() const { return m_opened; }
    106108

  • trunk/WebCore/storage/DatabaseTracker.cpp

    r60408 r61154  
    3232#if ENABLE(DATABASE)
    3333
     34#include "AbstractDatabase.h"
    3435#include "Chrome.h"
    3536#include "ChromeClient.h"
    36 #include "Database.h"
    3737#include "DatabaseThread.h"
    3838#include "DatabaseTrackerClient.h"
    … …  
    220220}
    221221
    222 unsigned long long DatabaseTracker::getMaxSizeForDatabase(const Database* database)
     222unsigned long long DatabaseTracker::getMaxSizeForDatabase(const AbstractDatabase* database)
    223223{
    224224    ASSERT(currentThread() == database->scriptExecutionContext()->databaseThread()->getThreadID());
    … …  
    231231}
    232232
    233 void DatabaseTracker::databaseChanged(Database* database)
     233void DatabaseTracker::databaseChanged(AbstractDatabase* database)
    234234{
    235235    Locker<OriginQuotaManager> quotaManagerLocker(originQuotaManager());
    … …  
    480480}
    481481
    482 void DatabaseTracker::addOpenDatabase(Database* database)
     482void DatabaseTracker::addOpenDatabase(AbstractDatabase* database)
    483483{
    484484    if (!database)
    … …  
    513513}
    514514
    515 void DatabaseTracker::removeOpenDatabase(Database* database)
     515void DatabaseTracker::removeOpenDatabase(AbstractDatabase* database)
    516516{
    517517    if (!database)
    … …  
    560560}
    561561
    562 void DatabaseTracker::getOpenDatabases(SecurityOrigin* origin, const String& name, HashSet<RefPtr<Database> >* databases)
     562void DatabaseTracker::getOpenDatabases(SecurityOrigin* origin, const String& name, HashSet<RefPtr<AbstractDatabase> >* databases)
    563563{
    564564    MutexLocker openDatabaseMapLock(m_openDatabaseMapGuard);
    … …  
    974974#endif
    975975
    976     Vector<RefPtr<Database> > deletedDatabases;
     976    Vector<RefPtr<AbstractDatabase> > deletedDatabases;
    977977
    978978    // Make sure not to hold the any locks when calling

  • trunk/WebCore/storage/DatabaseTracker.h

    r60092 r61154  
    4545namespace WebCore {
    4646
    47 class Database;
     47class AbstractDatabase;
    4848class ScriptExecutionContext;
    4949class SecurityOrigin;
    … …  
    7171    String fullPathForDatabase(SecurityOrigin*, const String& name, bool createIfDoesNotExist = true);
    7272
    73     void addOpenDatabase(Database*);
    74     void removeOpenDatabase(Database*);
    75     void getOpenDatabases(SecurityOrigin* origin, const String& name, HashSet<RefPtr<Database> >* databases);
     73    void addOpenDatabase(AbstractDatabase*);
     74    void removeOpenDatabase(AbstractDatabase*);
     75    void getOpenDatabases(SecurityOrigin* origin, const String& name, HashSet<RefPtr<AbstractDatabase> >* databases);
    7676
    77     unsigned long long getMaxSizeForDatabase(const Database*);
    78     void databaseChanged(Database*);
     77    unsigned long long getMaxSizeForDatabase(const AbstractDatabase*);
     78    void databaseChanged(AbstractDatabase*);
    7979
    8080private:
    8181    DatabaseTracker(const String& databasePath);
    8282
    83     typedef HashSet<Database*> DatabaseSet;
     83    typedef HashSet<AbstractDatabase*> DatabaseSet;
    8484    typedef HashMap<String, DatabaseSet*> DatabaseNameMap;
    8585    typedef HashMap<RefPtr<SecurityOrigin>, DatabaseNameMap*, SecurityOriginHash> DatabaseOriginMap;

  • trunk/WebCore/storage/OriginQuotaManager.cpp

    r56293 r61154  
    3131#if ENABLE(DATABASE)
    3232
    33 #include "Database.h"
     33#include "AbstractDatabase.h"
    3434#include "OriginUsageRecord.h"
    3535
    … …  
    113113}
    114114
    115 void OriginQuotaManager::markDatabase(Database* database)
     115void OriginQuotaManager::markDatabase(AbstractDatabase* database)
    116116{
    117117    ASSERT(database);

  • trunk/WebCore/storage/OriginQuotaManager.h

    r56293 r61154  
    3939namespace WebCore {
    4040
    41 class Database;
     41class AbstractDatabase;
    4242class OriginUsageRecord;
    4343
    … …  
    5656    void removeOrigin(SecurityOrigin*);
    5757
    58     void markDatabase(Database*); // Mark dirtiness of a specific database.
     58    void markDatabase(AbstractDatabase*); // Mark dirtiness of a specific database.
    5959    unsigned long long diskUsage(SecurityOrigin*) const;
    6060

  • trunk/WebCore/storage/chromium/DatabaseObserver.h

    r56548 r61154  
    3434namespace WebCore {
    3535
    36 class Database;
     36class AbstractDatabase;
    3737class ScriptExecutionContext;
    3838class String;
    … …  
    4343public:
    4444    static bool canEstablishDatabase(ScriptExecutionContext*, const String&, const String&, unsigned long);
    45     static void databaseOpened(Database*);
    46     static void databaseModified(Database*);
    47     static void databaseClosed(Database*);
     45    static void databaseOpened(AbstractDatabase*);
     46    static void databaseModified(AbstractDatabase*);
     47    static void databaseClosed(AbstractDatabase*);
    4848};
    4949

  • trunk/WebCore/storage/chromium/DatabaseTrackerChromium.cpp

    r60092 r61154  
    3232#include "DatabaseTracker.h"
    3333
    34 #include "Database.h"
     34#include "AbstractDatabase.h"
    3535#include "DatabaseObserver.h"
    3636#include "DatabaseThread.h"
    … …  
    7373}
    7474
    75 void DatabaseTracker::addOpenDatabase(Database* database)
     75void DatabaseTracker::addOpenDatabase(AbstractDatabase* database)
    7676{
    7777    ASSERT(database->scriptExecutionContext()->isContextThread());
    … …  
    100100class TrackerRemoveOpenDatabaseTask : public ScriptExecutionContext::Task {
    101101public:
    102     static PassOwnPtr<TrackerRemoveOpenDatabaseTask> create(PassRefPtr<Database> database)
     102    static PassOwnPtr<TrackerRemoveOpenDatabaseTask> create(PassRefPtr<AbstractDatabase> database)
    103103    {
    104104        return new TrackerRemoveOpenDatabaseTask(database);
    … …  
    111111
    112112private:
    113     TrackerRemoveOpenDatabaseTask(PassRefPtr<Database> database)
     113    TrackerRemoveOpenDatabaseTask(PassRefPtr<AbstractDatabase> database)
    114114        : m_database(database)
    115115    {
    116116    }
    117117
    118     RefPtr<Database> m_database;
     118    RefPtr<AbstractDatabase> m_database;
    119119};
    120120
    121 void DatabaseTracker::removeOpenDatabase(Database* database)
     121void DatabaseTracker::removeOpenDatabase(AbstractDatabase* database)
    122122{
    123123    if (!database->scriptExecutionContext()->isContextThread()) {
    … …  
    148148
    149149
    150 void DatabaseTracker::getOpenDatabases(SecurityOrigin* origin, const String& name, HashSet<RefPtr<Database> >* databases)
     150void DatabaseTracker::getOpenDatabases(SecurityOrigin* origin, const String& name, HashSet<RefPtr<AbstractDatabase> >* databases)
    151151{
    152152    MutexLocker openDatabaseMapLock(m_openDatabaseMapGuard);
    … …  
    166166}
    167167
    168 unsigned long long DatabaseTracker::getMaxSizeForDatabase(const Database* database)
     168unsigned long long DatabaseTracker::getMaxSizeForDatabase(const AbstractDatabase* database)
    169169{
    170170    ASSERT(currentThread() == database->scriptExecutionContext()->databaseThread()->getThreadID());

  • trunk/WebKit/chromium/ChangeLog

    r61151 r61154  
     12010-06-14  Dumitru Daniliuc  <dumi@chromium.org>
     2
     3        Reviewed by Adam Barth.
     4
     5        Get DatabaseTracker ready for sync DBs.
     6        https://bugs.webkit.org/show_bug.cgi?id=39041
     7
     8        * public/WebDatabase.h:
     9        * src/DatabaseObserver.cpp:
     10        (WebCore::DatabaseObserver::databaseOpened):
     11        (WebCore::DatabaseObserver::databaseModified):
     12        (WebCore::DatabaseObserver::databaseClosed):
     13        * src/WebDatabase.cpp:
     14        (WebKit::WebDatabase::closeDatabaseImmediately):
     15        (WebKit::WebDatabase::WebDatabase):
     16        (WebKit::WebDatabase::operator=):
     17        (WebKit::WebDatabase::operator WTF::PassRefPtr<AbstractDatabase>):
     18
    1192010-06-14  Chris Fleizach  <cfleizach@apple.com>
    220

  • trunk/WebKit/chromium/public/WebDatabase.h

    r54506 r61154  
    3636
    3737#if WEBKIT_IMPLEMENTATION
    38 namespace WebCore { class Database; }
     38namespace WebCore { class AbstractDatabase; }
    3939namespace WTF { template <typename T> class PassRefPtr; }
    4040#endif
    … …  
    7777
    7878#if WEBKIT_IMPLEMENTATION
    79     WebDatabase(const WTF::PassRefPtr<WebCore::Database>&);
    80     WebDatabase& operator=(const WTF::PassRefPtr<WebCore::Database>&);
    81     operator WTF::PassRefPtr<WebCore::Database>() const;
     79    WebDatabase(const WTF::PassRefPtr<WebCore::AbstractDatabase>&);
     80    WebDatabase& operator=(const WTF::PassRefPtr<WebCore::AbstractDatabase>&);
     81    operator WTF::PassRefPtr<WebCore::AbstractDatabase>() const;
    8282#endif
    8383

  • trunk/WebKit/chromium/src/DatabaseObserver.cpp

    r60330 r61154  
    3232#include "DatabaseObserver.h"
    3333
    34 #include "Database.h"
     34#include "AbstractDatabase.h"
    3535#include "Document.h"
    3636#include "ScriptExecutionContext.h"
    … …  
    6666}
    6767
    68 void DatabaseObserver::databaseOpened(Database* database)
     68void DatabaseObserver::databaseOpened(AbstractDatabase* database)
    6969{
    7070    ASSERT(database->scriptExecutionContext()->isContextThread());
    … …  
    7272}
    7373
    74 void DatabaseObserver::databaseModified(Database* database)
     74void DatabaseObserver::databaseModified(AbstractDatabase* database)
    7575{
    7676    ASSERT(database->scriptExecutionContext()->isContextThread());
    … …  
    7878}
    7979
    80 void DatabaseObserver::databaseClosed(Database* database)
     80void DatabaseObserver::databaseClosed(AbstractDatabase* database)
    8181{
    8282    ASSERT(database->scriptExecutionContext()->isContextThread());

  • trunk/WebKit/chromium/src/WebDatabase.cpp

    r57768 r61154  
    3232#include "WebDatabase.h"
    3333
    34 #include "Database.h"
     34#include "AbstractDatabase.h"
    3535#include "DatabaseTask.h"
    3636#include "DatabaseThread.h"
    … …  
    5151static WebDatabaseObserver* databaseObserver = 0;
    5252
    53 class WebDatabasePrivate : public Database {
     53class WebDatabasePrivate : public AbstractDatabase {
    5454};
    5555
    … …  
    111111void WebDatabase::closeDatabaseImmediately(const WebString& originIdentifier, const WebString& databaseName)
    112112{
    113     HashSet<RefPtr<Database> > databaseHandles;
    114     PassRefPtr<SecurityOrigin> originPrp(WebSecurityOrigin::createFromDatabaseIdentifier(originIdentifier));
    115     RefPtr<SecurityOrigin> origin = originPrp;
     113    HashSet<RefPtr<AbstractDatabase> > databaseHandles;
     114    RefPtr<SecurityOrigin> origin = SecurityOrigin::createFromDatabaseIdentifier(originIdentifier);
    116115    DatabaseTracker::tracker().getOpenDatabases(origin.get(), databaseName, &databaseHandles);
    117     for (HashSet<RefPtr<Database> >::iterator it = databaseHandles.begin(); it != databaseHandles.end(); ++it) {
    118         Database* database = it->get();
    119         DatabaseThread* databaseThread = database->scriptExecutionContext()->databaseThread();
    120         if (databaseThread && !databaseThread->terminationRequested()) {
    121             database->stop();
    122             databaseThread->scheduleTask(DatabaseCloseTask::create(database, Database::RemoveDatabaseFromContext, 0));
    123         }
    124     }
     116    for (HashSet<RefPtr<AbstractDatabase> >::iterator it = databaseHandles.begin(); it != databaseHandles.end(); ++it)
     117        it->get()->closeImmediately();
    125118}
    126119
    127 WebDatabase::WebDatabase(const WTF::PassRefPtr<Database>& database)
     120WebDatabase::WebDatabase(const WTF::PassRefPtr<AbstractDatabase>& database)
    128121    : m_private(static_cast<WebDatabasePrivate*>(database.releaseRef()))
    129122{
    130123}
    131124
    132 WebDatabase& WebDatabase::operator=(const WTF::PassRefPtr<Database>& database)
     125WebDatabase& WebDatabase::operator=(const WTF::PassRefPtr<AbstractDatabase>& database)
    133126{
    134127    assign(static_cast<WebDatabasePrivate*>(database.releaseRef()));
    … …  
    136129}
    137130
    138 WebDatabase::operator WTF::PassRefPtr<Database>() const
     131WebDatabase::operator WTF::PassRefPtr<AbstractDatabase>() const
    139132{
    140     return PassRefPtr<Database>(const_cast<WebDatabasePrivate*>(m_private));
     133    return PassRefPtr<AbstractDatabase>(const_cast<WebDatabasePrivate*>(m_private));
    141134}
    142135
Note: See TracChangeset for help on using the changeset viewer.