ChangeLog

2012-09-07  Joshua Bell  <jsbell@chromium.org>

        IndexedDB: IDBFactory.deleteDatabase() is slow

        https://bugs.webkit.org/show_bug.cgi?id=96036

        Reviewed by NOBODY (OOPS!).

        The deleteDatabase() operation is implemented by creating a LevelDBTansaction to accumulate

        the records to delete, then committing it. The transaction is a tree of key/operation pairs.

        As each (key, delete) entry is added to the tree compares need to be made, potentially

        requiring full key decodes. Since this temporary transaction is never read from, this is

        overkill.

        Add a new "write only" transaction type that simply wraps a write batch, which provides

        transaction integrity but avoids the insertion overhead.

        No new tests - no functional changes, only perf improvement.

        * Modules/indexeddb/IDBLevelDBBackingStore.cpp:

        (WebCore::IDBLevelDBBackingStore::deleteDatabase): Use new write-only transaction type.

        * platform/leveldb/LevelDBTransaction.cpp:

        (WebCore::LevelDBWriteOnlyTransaction::create):

        (WebCore):

        (WebCore::LevelDBWriteOnlyTransaction::LevelDBWriteOnlyTransaction):

        (WebCore::LevelDBWriteOnlyTransaction::~LevelDBWriteOnlyTransaction):

        (WebCore::LevelDBWriteOnlyTransaction::put):

        (WebCore::LevelDBWriteOnlyTransaction::remove):

        (WebCore::LevelDBWriteOnlyTransaction::commit):

        (WebCore::LevelDBWriteOnlyTransaction::rollback):

        * platform/leveldb/LevelDBTransaction.h:

        (WebCore):

        (LevelDBWriteOnlyTransaction):

2012-09-03  Sam Weinig  <sam@webkit.org>

        Part 1 of removing PlatformString.h, move remaining functions to new homes

Source/WebCore/Modules/indexeddb/IDBLevelDBBackingStore.cpp

@@static bool deleteRange(LevelDBTransaction* transaction, const Vector<char>& beg

bool IDBLevelDBBackingStore::deleteDatabase(const String& name)

{

    IDB_TRACE("IDBLevelDBBackingStore::deleteDatabase");

363 RefPtr<LevelDBTransaction> transaction = LevelDBTransaction::create(m_db.get());

363 RefPtr<LevelDBWriteOnlyTransaction> transaction = LevelDBWriteOnlyTransaction::create(m_db.get());

    int64_t databaseId;

    String version;

@@bool IDBLevelDBBackingStore::deleteDatabase(const String& name)

    const Vector<char> startKey = DatabaseMetaDataKey::encode(databaseId, DatabaseMetaDataKey::OriginName);

    const Vector<char> stopKey = DatabaseMetaDataKey::encode(databaseId + 1, DatabaseMetaDataKey::OriginName);

    if (!deleteRange(transaction.get(), startKey, stopKey)) {

        transaction->rollback();

        return false;

    OwnPtr<LevelDBIterator> it = m_db->createIterator();

    for (it->seek(startKey); it->isValid() && compareKeys(it->key(), stopKey) < 0; it->next()) {

        if (!transaction->remove(it->key())) {

            transaction->rollback();

            return false;

        }

    }

    const Vector<char> key = DatabaseNameKey::encode(m_identifier, name);

Source/WebCore/platform/leveldb/LevelDBTransaction.cpp

@@void LevelDBTransaction::notifyIteratorsOfTreeChange()

    }

}

PassRefPtr<LevelDBWriteOnlyTransaction> LevelDBWriteOnlyTransaction::create(LevelDBDatabase* db)

{

    return adoptRef(new LevelDBWriteOnlyTransaction(db));

}

LevelDBWriteOnlyTransaction::LevelDBWriteOnlyTransaction(LevelDBDatabase* db)

    : m_db(db)

    , m_writeBatch(LevelDBWriteBatch::create())

    , m_finished(false)

{

}

LevelDBWriteOnlyTransaction::~LevelDBWriteOnlyTransaction()

{

    m_writeBatch->clear();

}

bool LevelDBWriteOnlyTransaction::put(const LevelDBSlice& key, const Vector<char>& value)

{

    ASSERT(!m_finished);

    m_writeBatch->put(key, value);

    return true;

}

bool LevelDBWriteOnlyTransaction::remove(const LevelDBSlice& key)

{

    ASSERT(!m_finished);

    m_writeBatch->remove(key);

    return true;

}

bool LevelDBWriteOnlyTransaction::commit()

{

    ASSERT(!m_finished);

    if (!m_db->write(*m_writeBatch))

        return false;

    m_finished = true;

    m_writeBatch->clear();

    return true;

}

void LevelDBWriteOnlyTransaction::rollback()

{

    ASSERT(!m_finished);

    m_finished = true;

    m_writeBatch->clear();

}

} // namespace WebCore

#endif // USE(LEVELDB)

Source/WebCore/platform/leveldb/LevelDBTransaction.h

namespace WebCore {

class LevelDBDatabase;

46class LevelDBWriteBatch;

using WTF::AVLTree;

@@private:

    HashSet<TransactionIterator*> m_iterators;

};

class LevelDBWriteOnlyTransaction : public RefCounted<LevelDBWriteOnlyTransaction> {

public:

    static PassRefPtr<LevelDBWriteOnlyTransaction> create(LevelDBDatabase*);

    ~LevelDBWriteOnlyTransaction();

    bool put(const LevelDBSlice& key, const Vector<char>& value);

    bool remove(const LevelDBSlice& key);

    bool commit();

    void rollback();

private:

    LevelDBWriteOnlyTransaction(LevelDBDatabase*);

    bool set(const LevelDBSlice& key, const Vector<char>& value, bool deleted);

    LevelDBDatabase* m_db;

    OwnPtr<LevelDBWriteBatch> m_writeBatch;

    bool m_finished;

};

}

#endif // USE(LEVELDB)