Changeset 96322 in webkit


Ignore:
Timestamp:
Sep 29, 2011 5:29:13 AM (13 years ago)
Author:
hans@chromium.org
Message:

IndexedDB: Use LevelDB also for in-memory databases
​https://bugs.webkit.org/show_bug.cgi?id=68903

Reviewed by Steve Block.

Source/WebCore:

Add LevelDBDatabase::openInMemory() which uses leveldb::NewMemEnv()
to create in-memory LevelDB databases.

Use this in IDBLeveLDBBackingStore::open() when the caller passes in
an empty file path.
This happens in Chromium's incognito mode, and when running layout
tests.

Fix IDBSQLiteBackingStore::backingStoreExists() so it doesn't create
files when passed in an empty file path, but uses the in-memory mode
instead.

Existing layout tests will all be run in-memory.

  • platform/leveldb/LevelDBDatabase.cpp:

(WebCore::LevelDBDatabase::~LevelDBDatabase):
(WebCore::openDB):
(WebCore::LevelDBDatabase::open):
(WebCore::LevelDBDatabase::openInMemory):

  • platform/leveldb/LevelDBDatabase.h:
  • storage/IDBLevelDBBackingStore.cpp:

(WebCore::IDBLevelDBBackingStore::open):

  • storage/IDBSQLiteBackingStore.cpp:

(WebCore::IDBSQLiteBackingStore::backingStoreExists):

Source/WebKit/chromium:

Don't fall back to SQLite or use a temporary dir for in-memory
databases (Incognito and layout tests); LevelDB supports in-memory
databases now.

  • public/WebIDBFactory.h:
  • src/WebIDBFactoryImpl.cpp:

(WebKit::WebIDBFactoryImpl::getDatabaseNames):
(WebKit::WebIDBFactoryImpl::open):

Tools:

Remove the temporary dir that was necessary before LevelDB supported
in-memory databases.

  • DumpRenderTree/chromium/TestShell.cpp:

(TestShell::TestShell):

  • DumpRenderTree/chromium/TestShell.h:
Location:
trunk
Files:
11 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r96321 r96322  
     12011-09-29  Hans Wennborg  <hans@chromium.org>
     2
     3        IndexedDB: Use LevelDB also for in-memory databases
     4        https://bugs.webkit.org/show_bug.cgi?id=68903
     5
     6        Reviewed by Steve Block.
     7
     8        Add LevelDBDatabase::openInMemory() which uses leveldb::NewMemEnv()
     9        to create in-memory LevelDB databases.
     10
     11        Use this in IDBLeveLDBBackingStore::open() when the caller passes in
     12        an empty file path.
     13        This happens in Chromium's incognito mode, and when running layout
     14        tests.
     15
     16        Fix IDBSQLiteBackingStore::backingStoreExists() so it doesn't create
     17        files when passed in an empty file path, but uses the in-memory mode
     18        instead.
     19
     20        Existing layout tests will all be run in-memory.
     21
     22        * platform/leveldb/LevelDBDatabase.cpp:
     23        (WebCore::LevelDBDatabase::~LevelDBDatabase):
     24        (WebCore::openDB):
     25        (WebCore::LevelDBDatabase::open):
     26        (WebCore::LevelDBDatabase::openInMemory):
     27        * platform/leveldb/LevelDBDatabase.h:
     28        * storage/IDBLevelDBBackingStore.cpp:
     29        (WebCore::IDBLevelDBBackingStore::open):
     30        * storage/IDBSQLiteBackingStore.cpp:
     31        (WebCore::IDBSQLiteBackingStore::backingStoreExists):
     32
    1332011-09-29  Ilya Tikhonovsky  <loislo@chromium.org>
    234

  • trunk/Source/WebCore/platform/leveldb/LevelDBDatabase.cpp

    r95901 r96322  
    3434#include "LevelDBWriteBatch.h"
    3535#include "Logging.h"
     36#include <helpers/memenv/memenv.h>
    3637#include <leveldb/comparator.h>
    3738#include <leveldb/db.h>
     39#include <leveldb/env.h>
    3840#include <leveldb/slice.h>
    3941#include <string>
    … …  
    9799    m_db.clear();
    98100    m_comparatorAdapter.clear();
    99 }
    100 
    101 PassOwnPtr<LevelDBDatabase> LevelDBDatabase::open(const String& fileName, const LevelDBComparator* comparator)
    102 {
    103     OwnPtr<ComparatorAdapter> comparatorAdapter = adoptPtr(new ComparatorAdapter(comparator));
    104 
     101    m_env.clear();
     102}
     103
     104static leveldb::Status openDB(leveldb::Comparator* comparator, leveldb::Env* env, const String& path, leveldb::DB** db)
     105{
    105106    leveldb::Options options;
    106     options.comparator = comparatorAdapter.get();
     107    options.comparator = comparator;
    107108    options.create_if_missing = true;
    108109    options.paranoid_checks = true;
     110    options.env = env;
     111
     112    return leveldb::DB::Open(options, path.utf8().data(), db);
     113}
     114
     115PassOwnPtr<LevelDBDatabase> LevelDBDatabase::open(const String& fileName, const LevelDBComparator* comparator)
     116{
     117    OwnPtr<ComparatorAdapter> comparatorAdapter = adoptPtr(new ComparatorAdapter(comparator));
     118
    109119    leveldb::DB* db;
    110     const leveldb::Status s = leveldb::DB::Open(options, fileName.utf8().data(), &db);
     120    const leveldb::Status s = openDB(comparatorAdapter.get(), leveldb::Env::Default(), fileName, &db);
    111121
    112122    if (!s.ok()) {
    … …  
    116126
    117127    OwnPtr<LevelDBDatabase> result = adoptPtr(new LevelDBDatabase);
     128    result->m_db = adoptPtr(db);
     129    result->m_comparatorAdapter = comparatorAdapter.release();
     130    result->m_comparator = comparator;
     131
     132    return result.release();
     133}
     134
     135PassOwnPtr<LevelDBDatabase> LevelDBDatabase::openInMemory(const LevelDBComparator* comparator)
     136{
     137    OwnPtr<ComparatorAdapter> comparatorAdapter = adoptPtr(new ComparatorAdapter(comparator));
     138    OwnPtr<leveldb::Env> inMemoryEnv = adoptPtr(leveldb::NewMemEnv(leveldb::Env::Default()));
     139
     140    leveldb::DB* db;
     141    const leveldb::Status s = openDB(comparatorAdapter.get(), inMemoryEnv.get(), String(), &db);
     142
     143    if (!s.ok()) {
     144        LOG_ERROR("Failed to open in-memory LevelDB database: %s", s.ToString().c_str());
     145        return nullptr;
     146    }
     147
     148    OwnPtr<LevelDBDatabase> result = adoptPtr(new LevelDBDatabase);
     149    result->m_env = inMemoryEnv.release();
    118150    result->m_db = adoptPtr(db);
    119151    result->m_comparatorAdapter = comparatorAdapter.release();

  • trunk/Source/WebCore/platform/leveldb/LevelDBDatabase.h

    r95901 r96322  
    3737class Comparator;
    3838class DB;
     39class Env;
    3940}
    4041
    … …  
    4950public:
    5051    static PassOwnPtr<LevelDBDatabase> open(const String& fileName, const LevelDBComparator*);
     52    static PassOwnPtr<LevelDBDatabase> openInMemory(const LevelDBComparator*);
    5153    ~LevelDBDatabase();
    5254
    … …  
    6163    LevelDBDatabase();
    6264
     65    OwnPtr<leveldb::Env> m_env;
     66    OwnPtr<leveldb::Comparator> m_comparatorAdapter;
    6367    OwnPtr<leveldb::DB> m_db;
    6468    const LevelDBComparator* m_comparator;
    65     OwnPtr<leveldb::Comparator> m_comparatorAdapter;
    6669};
    6770

  • trunk/Source/WebCore/storage/IDBLevelDBBackingStore.cpp

    r96054 r96322  
    137137    String pathBase = pathBaseArg;
    138138
    139     if (pathBase.isEmpty()) {
    140         ASSERT_NOT_REACHED(); // FIXME: We need to handle this case for incognito and DumpRenderTree.
    141         return PassRefPtr<IDBBackingStore>();
    142     }
    143 
    144     if (!makeAllDirectories(pathBase)) {
    145         LOG_ERROR("Unable to create IndexedDB database path %s", pathBase.utf8().data());
    146         return PassRefPtr<IDBBackingStore>();
    147     }
    148     // FIXME: We should eventually use the same LevelDB database for all origins.
    149     String path = pathByAppendingComponent(pathBase, securityOrigin->databaseIdentifier() + ".indexeddb.leveldb");
    150 
    151139    OwnPtr<LevelDBComparator> comparator = adoptPtr(new Comparator());
    152     OwnPtr<LevelDBDatabase> db = LevelDBDatabase::open(path, comparator.get());
     140    OwnPtr<LevelDBDatabase> db;
     141
     142    if (pathBase.isEmpty())
     143        db = LevelDBDatabase::openInMemory(comparator.get());
     144    else {
     145        if (!makeAllDirectories(pathBase)) {
     146            LOG_ERROR("Unable to create IndexedDB database path %s", pathBase.utf8().data());
     147            return PassRefPtr<IDBBackingStore>();
     148        }
     149        // FIXME: We should eventually use the same LevelDB database for all origins.
     150        String path = pathByAppendingComponent(pathBase, securityOrigin->databaseIdentifier() + ".indexeddb.leveldb");
     151
     152        db = LevelDBDatabase::open(path, comparator.get());
     153    }
     154
    153155    if (!db)
    154156        return PassRefPtr<IDBBackingStore>();

  • trunk/Source/WebCore/storage/IDBSQLiteBackingStore.cpp

    r96054 r96322  
    170170    RefPtr<IDBSQLiteBackingStore> backingStore(adoptRef(new IDBSQLiteBackingStore(fileIdentifier, factory)));
    171171
    172     String path = ":memory:";
     172    String path = ":memory:"; // in-memory SQLite database.
    173173    if (!pathBase.isEmpty()) {
    174174        if (!makeAllDirectories(pathBase)) {
    … …  
    10131013bool IDBSQLiteBackingStore::backingStoreExists(SecurityOrigin* securityOrigin, const String& name, const String& pathBase)
    10141014{
    1015     String path = pathByAppendingComponent(pathBase, securityOrigin->databaseIdentifier() + ".indexeddb");
     1015    String path = ":memory:"; // in-memory SQLite database.
     1016    if (!pathBase.isEmpty())
     1017        path = pathByAppendingComponent(pathBase, securityOrigin->databaseIdentifier() + ".indexeddb");
    10161018    SQLiteDatabase db;
    10171019    if (!db.open(path))

  • trunk/Source/WebKit/chromium/ChangeLog

    r96233 r96322  
     12011-09-29  Hans Wennborg  <hans@chromium.org>
     2
     3        IndexedDB: Use LevelDB also for in-memory databases
     4        https://bugs.webkit.org/show_bug.cgi?id=68903
     5
     6        Reviewed by Steve Block.
     7
     8        Don't fall back to SQLite or use a temporary dir for in-memory
     9        databases (Incognito and layout tests); LevelDB supports in-memory
     10        databases now.
     11
     12        * public/WebIDBFactory.h:
     13        * src/WebIDBFactoryImpl.cpp:
     14        (WebKit::WebIDBFactoryImpl::getDatabaseNames):
     15        (WebKit::WebIDBFactoryImpl::open):
     16
    1172011-09-28  Fady Samuel  <fsamuel@chromium.org>
    218

  • trunk/Source/WebKit/chromium/public/WebIDBFactory.h

    r95901 r96322  
    6767    // Used for DumpRenderTree tests.
    6868    WEBKIT_EXPORT static void setOverrideBackingStoreType(BackingStoreType);
    69     WEBKIT_EXPORT static void setTemporaryDatabaseFolder(const WebString& path);
    7069};
    7170

  • trunk/Source/WebKit/chromium/src/WebIDBFactoryImpl.cpp

    r96054 r96322  
    4646
    4747static WebIDBFactory::BackingStoreType overriddenBackingStoreType = WebIDBFactory::DefaultBackingStore;
    48 static WebString tempDatabaseFolder;
    4948
    5049WebIDBFactory* WebIDBFactory::create()
    … …  
    5655{
    5756    overriddenBackingStoreType = type;
    58 }
    59 
    60 void WebIDBFactory::setTemporaryDatabaseFolder(const WebString& path)
    61 {
    62     tempDatabaseFolder = path;
    6357}
    6458
    … …  
    8478        backingStoreType = LevelDBBackingStore;
    8579
    86     if (dataDir.isEmpty() && backingStoreType == LevelDBBackingStore) {
    87         if (!tempDatabaseFolder.isEmpty()) {
    88             // Layout tests provide a temporary folder.
    89             path = tempDatabaseFolder;
    90         } else {
    91             // For incognito mode, fall back to SQLite.
    92             backingStoreType = SQLiteBackingStore;
    93         }
    94     }
    95 
    9680    m_idbFactoryBackend->getDatabaseNames(IDBCallbacksProxy::create(adoptPtr(callbacks)), origin, 0, path, maximumSize, static_cast<IDBFactoryBackendInterface::BackingStoreType>(backingStoreType));
    9781}
    … …  
    11094        backingStoreType = LevelDBBackingStore;
    11195
    112     if (dataDir.isEmpty() && backingStoreType == LevelDBBackingStore) {
    113         if (!tempDatabaseFolder.isEmpty()) {
    114             // Layout tests provide a temporary folder.
    115             path = tempDatabaseFolder;
    116         } else {
    117             // For incognito mode, fall back to SQLite.
    118             backingStoreType = SQLiteBackingStore;
    119         }
    120     }
    121 
    12296    m_idbFactoryBackend->open(name, IDBCallbacksProxy::create(adoptPtr(callbacks)), origin, 0, path, maximumSize, static_cast<IDBFactoryBackendInterface::BackingStoreType>(backingStoreType));
    12397}

  • trunk/Tools/ChangeLog

    r96289 r96322  
     12011-09-29  Hans Wennborg  <hans@chromium.org>
     2
     3        IndexedDB: Use LevelDB also for in-memory databases
     4        https://bugs.webkit.org/show_bug.cgi?id=68903
     5
     6        Reviewed by Steve Block.
     7
     8        Remove the temporary dir that was necessary before LevelDB supported
     9        in-memory databases.
     10
     11        * DumpRenderTree/chromium/TestShell.cpp:
     12        (TestShell::TestShell):
     13        * DumpRenderTree/chromium/TestShell.h:
     14
    1152011-09-28  Xianzhu Wang  <wangxianzhu@chromium.org>
    216

  • trunk/Tools/DumpRenderTree/chromium/TestShell.cpp

    r96147 r96322  
    137137    m_timeout = 30 * 1000;
    138138
    139 #if ENABLE(INDEXED_DATABASE)
    140     m_tempIndexedDBDirectory = adoptPtr(webkit_support::CreateScopedTempDirectory());
    141     m_tempIndexedDBDirectory->CreateUniqueTempDir();
    142     WebIDBFactory::setTemporaryDatabaseFolder(WebString::fromUTF8(m_tempIndexedDBDirectory->path().c_str()));
    143 #endif
    144 
    145139    createMainWindow();
    146140}

  • trunk/Tools/DumpRenderTree/chromium/TestShell.h

    r95180 r96322  
    236236    HANDLE m_finishedEvent;
    237237#endif
    238 
    239     // Temporary directory for IndexedDB (LevelDB doesn't support in-memory databases.)
    240     OwnPtr<webkit_support::ScopedTempDirectory> m_tempIndexedDBDirectory;
    241238};
    242239
Note: See TracChangeset for help on using the changeset viewer.