blob: bdae55d05939a5f8d66eb4897da1392acca50ea9 [file] [log] [blame]
/*
* Copyright (C) 2012 Google Inc. All rights reserved.
* Copyright (C) 2015-2017 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
* * Neither the name of Google Inc. nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "config.h"
#include "InspectorIndexedDBAgent.h"
#if ENABLE(INDEXED_DATABASE)
#include "DOMStringList.h"
#include "DOMWindow.h"
#include "DOMWindowIndexedDatabase.h"
#include "Document.h"
#include "Event.h"
#include "EventListener.h"
#include "EventNames.h"
#include "EventTarget.h"
#include "Frame.h"
#include "IDBBindingUtilities.h"
#include "IDBCursor.h"
#include "IDBCursorWithValue.h"
#include "IDBDatabase.h"
#include "IDBFactory.h"
#include "IDBIndex.h"
#include "IDBKey.h"
#include "IDBKeyPath.h"
#include "IDBKeyRange.h"
#include "IDBObjectStore.h"
#include "IDBOpenDBRequest.h"
#include "IDBRequest.h"
#include "IDBTransaction.h"
#include "InspectorPageAgent.h"
#include "InstrumentingAgents.h"
#include "ScriptState.h"
#include "SecurityOrigin.h"
#include <JavaScriptCore/HeapInlines.h>
#include <JavaScriptCore/InjectedScript.h>
#include <JavaScriptCore/InjectedScriptManager.h>
#include <JavaScriptCore/InspectorFrontendDispatchers.h>
#include <JavaScriptCore/InspectorFrontendRouter.h>
#include <wtf/JSONValues.h>
#include <wtf/NeverDestroyed.h>
#include <wtf/Vector.h>
#include <wtf/text/StringConcatenateNumbers.h>
using JSON::ArrayOf;
using Inspector::Protocol::IndexedDB::DatabaseWithObjectStores;
using Inspector::Protocol::IndexedDB::DataEntry;
using Inspector::Protocol::IndexedDB::Key;
using Inspector::Protocol::IndexedDB::KeyPath;
using Inspector::Protocol::IndexedDB::KeyRange;
using Inspector::Protocol::IndexedDB::ObjectStore;
using Inspector::Protocol::IndexedDB::ObjectStoreIndex;
typedef Inspector::BackendDispatcher::CallbackBase RequestCallback;
typedef Inspector::IndexedDBBackendDispatcherHandler::RequestDatabaseNamesCallback RequestDatabaseNamesCallback;
typedef Inspector::IndexedDBBackendDispatcherHandler::RequestDatabaseCallback RequestDatabaseCallback;
typedef Inspector::IndexedDBBackendDispatcherHandler::RequestDataCallback RequestDataCallback;
typedef Inspector::IndexedDBBackendDispatcherHandler::ClearObjectStoreCallback ClearObjectStoreCallback;
typedef String ErrorString;
template <typename T>
using ErrorStringOr = Expected<T, ErrorString>;
namespace WebCore {
using namespace Inspector;
namespace {
class ExecutableWithDatabase : public RefCounted<ExecutableWithDatabase> {
public:
ExecutableWithDatabase(ScriptExecutionContext* context)
: m_context(context) { }
virtual ~ExecutableWithDatabase() = default;
void start(IDBFactory*, SecurityOrigin*, const String& databaseName);
virtual void execute(IDBDatabase&) = 0;
virtual RequestCallback& requestCallback() = 0;
ScriptExecutionContext* context() const { return m_context; }
private:
ScriptExecutionContext* m_context;
};
class OpenDatabaseCallback final : public EventListener {
public:
static Ref<OpenDatabaseCallback> create(ExecutableWithDatabase& executableWithDatabase)
{
return adoptRef(*new OpenDatabaseCallback(executableWithDatabase));
}
bool operator==(const EventListener& other) const final
{
return this == &other;
}
void handleEvent(ScriptExecutionContext&, Event& event) final
{
if (event.type() != eventNames().successEvent) {
m_executableWithDatabase->requestCallback().sendFailure("Unexpected event type.");
return;
}
auto& request = static_cast<IDBOpenDBRequest&>(*event.target());
auto result = request.result();
if (result.hasException()) {
m_executableWithDatabase->requestCallback().sendFailure("Could not get result in callback.");
return;
}
auto resultValue = result.releaseReturnValue();
if (!WTF::holds_alternative<RefPtr<IDBDatabase>>(resultValue)) {
m_executableWithDatabase->requestCallback().sendFailure("Unexpected result type.");
return;
}
auto databaseResult = WTF::get<RefPtr<IDBDatabase>>(resultValue);
m_executableWithDatabase->execute(*databaseResult);
databaseResult->close();
}
private:
OpenDatabaseCallback(ExecutableWithDatabase& executableWithDatabase)
: EventListener(EventListener::CPPEventListenerType)
, m_executableWithDatabase(executableWithDatabase) { }
Ref<ExecutableWithDatabase> m_executableWithDatabase;
};
void ExecutableWithDatabase::start(IDBFactory* idbFactory, SecurityOrigin*, const String& databaseName)
{
if (!context()) {
requestCallback().sendFailure("Could not open database.");
return;
}
auto result = idbFactory->open(*context(), databaseName, WTF::nullopt);
if (result.hasException()) {
requestCallback().sendFailure("Could not open database.");
return;
}
result.releaseReturnValue()->addEventListener(eventNames().successEvent, OpenDatabaseCallback::create(*this), false);
}
static RefPtr<KeyPath> keyPathFromIDBKeyPath(const Optional<IDBKeyPath>& idbKeyPath)
{
if (!idbKeyPath)
return KeyPath::create().setType(KeyPath::Type::Null).release();
auto visitor = WTF::makeVisitor([](const String& string) {
auto keyPath = KeyPath::create().setType(KeyPath::Type::String).release();
keyPath->setString(string);
return keyPath;
}, [](const Vector<String>& vector) {
auto array = JSON::ArrayOf<String>::create();
for (auto& string : vector)
array->addItem(string);
auto keyPath = KeyPath::create().setType(KeyPath::Type::Array).release();
keyPath->setArray(WTFMove(array));
return keyPath;
});
return WTF::visit(visitor, idbKeyPath.value());
}
static RefPtr<IDBTransaction> transactionForDatabase(IDBDatabase* idbDatabase, const String& objectStoreName, IDBTransactionMode mode = IDBTransactionMode::Readonly)
{
auto result = idbDatabase->transaction(objectStoreName, mode);
if (result.hasException())
return nullptr;
return result.releaseReturnValue();
}
static RefPtr<IDBObjectStore> objectStoreForTransaction(IDBTransaction* idbTransaction, const String& objectStoreName)
{
auto result = idbTransaction->objectStore(objectStoreName);
if (result.hasException())
return nullptr;
return result.releaseReturnValue();
}
static RefPtr<IDBIndex> indexForObjectStore(IDBObjectStore* idbObjectStore, const String& indexName)
{
auto index = idbObjectStore->index(indexName);
if (index.hasException())
return nullptr;
return index.releaseReturnValue();
}
class DatabaseLoader final : public ExecutableWithDatabase {
public:
static Ref<DatabaseLoader> create(ScriptExecutionContext* context, Ref<RequestDatabaseCallback>&& requestCallback)
{
return adoptRef(*new DatabaseLoader(context, WTFMove(requestCallback)));
}
~DatabaseLoader() override = default;
void execute(IDBDatabase& database) override
{
if (!requestCallback().isActive())
return;
auto& databaseInfo = database.info();
auto objectStores = JSON::ArrayOf<Inspector::Protocol::IndexedDB::ObjectStore>::create();
auto objectStoreNames = databaseInfo.objectStoreNames();
for (auto& name : objectStoreNames) {
auto* objectStoreInfo = databaseInfo.infoForExistingObjectStore(name);
if (!objectStoreInfo)
continue;
auto indexes = JSON::ArrayOf<Inspector::Protocol::IndexedDB::ObjectStoreIndex>::create();
for (auto& indexInfo : objectStoreInfo->indexMap().values()) {
auto objectStoreIndex = ObjectStoreIndex::create()
.setName(indexInfo.name())
.setKeyPath(keyPathFromIDBKeyPath(indexInfo.keyPath()))
.setUnique(indexInfo.unique())
.setMultiEntry(indexInfo.multiEntry())
.release();
indexes->addItem(WTFMove(objectStoreIndex));
}
auto objectStore = ObjectStore::create()
.setName(objectStoreInfo->name())
.setKeyPath(keyPathFromIDBKeyPath(objectStoreInfo->keyPath()))
.setAutoIncrement(objectStoreInfo->autoIncrement())
.setIndexes(WTFMove(indexes))
.release();
objectStores->addItem(WTFMove(objectStore));
}
auto result = DatabaseWithObjectStores::create()
.setName(databaseInfo.name())
.setVersion(databaseInfo.version())
.setObjectStores(WTFMove(objectStores))
.release();
m_requestCallback->sendSuccess(WTFMove(result));
}
RequestCallback& requestCallback() override { return m_requestCallback.get(); }
private:
DatabaseLoader(ScriptExecutionContext* context, Ref<RequestDatabaseCallback>&& requestCallback)
: ExecutableWithDatabase(context)
, m_requestCallback(WTFMove(requestCallback)) { }
Ref<RequestDatabaseCallback> m_requestCallback;
};
static RefPtr<IDBKey> idbKeyFromInspectorObject(JSON::Object* key)
{
String type;
if (!key->getString("type", type))
return nullptr;
static NeverDestroyed<const String> numberType(MAKE_STATIC_STRING_IMPL("number"));
static NeverDestroyed<const String> stringType(MAKE_STATIC_STRING_IMPL("string"));
static NeverDestroyed<const String> dateType(MAKE_STATIC_STRING_IMPL("date"));
static NeverDestroyed<const String> arrayType(MAKE_STATIC_STRING_IMPL("array"));
RefPtr<IDBKey> idbKey;
if (type == numberType) {
double number;
if (!key->getDouble("number", number))
return nullptr;
idbKey = IDBKey::createNumber(number);
} else if (type == stringType) {
String string;
if (!key->getString("string", string))
return nullptr;
idbKey = IDBKey::createString(string);
} else if (type == dateType) {
double date;
if (!key->getDouble("date", date))
return nullptr;
idbKey = IDBKey::createDate(date);
} else if (type == arrayType) {
Vector<RefPtr<IDBKey>> keyArray;
RefPtr<JSON::Array> array;
if (!key->getArray("array", array))
return nullptr;
for (size_t i = 0; i < array->length(); ++i) {
RefPtr<JSON::Value> value = array->get(i);
RefPtr<JSON::Object> object;
if (!value->asObject(object))
return nullptr;
keyArray.append(idbKeyFromInspectorObject(object.get()));
}
idbKey = IDBKey::createArray(keyArray);
} else
return nullptr;
return idbKey;
}
static RefPtr<IDBKeyRange> idbKeyRangeFromKeyRange(const JSON::Object* keyRange)
{
RefPtr<IDBKey> idbLower;
RefPtr<JSON::Object> lower;
if (keyRange->getObject("lower"_s, lower)) {
idbLower = idbKeyFromInspectorObject(lower.get());
if (!idbLower)
return nullptr;
}
RefPtr<IDBKey> idbUpper;
RefPtr<JSON::Object> upper;
if (keyRange->getObject("upper"_s, upper)) {
idbUpper = idbKeyFromInspectorObject(upper.get());
if (!idbUpper)
return nullptr;
}
bool lowerOpen;
if (!keyRange->getBoolean("lowerOpen"_s, lowerOpen))
return nullptr;
bool upperOpen;
if (!keyRange->getBoolean("upperOpen"_s, upperOpen))
return nullptr;
return IDBKeyRange::create(WTFMove(idbLower), WTFMove(idbUpper), lowerOpen, upperOpen);
}
class OpenCursorCallback final : public EventListener {
public:
static Ref<OpenCursorCallback> create(InjectedScript injectedScript, Ref<RequestDataCallback>&& requestCallback, int skipCount, unsigned pageSize)
{
return adoptRef(*new OpenCursorCallback(injectedScript, WTFMove(requestCallback), skipCount, pageSize));
}
~OpenCursorCallback() override = default;
bool operator==(const EventListener& other) const override
{
return this == &other;
}
void handleEvent(ScriptExecutionContext& context, Event& event) override
{
if (event.type() != eventNames().successEvent) {
m_requestCallback->sendFailure("Unexpected event type.");
return;
}
auto& request = static_cast<IDBRequest&>(*event.target());
auto result = request.result();
if (result.hasException()) {
m_requestCallback->sendFailure("Could not get result in callback.");
return;
}
auto resultValue = result.releaseReturnValue();
if (!WTF::holds_alternative<RefPtr<IDBCursor>>(resultValue)) {
end(false);
return;
}
auto cursor = WTF::get<RefPtr<IDBCursor>>(resultValue);
if (m_skipCount) {
if (cursor->advance(m_skipCount).hasException())
m_requestCallback->sendFailure("Could not advance cursor.");
m_skipCount = 0;
return;
}
if (m_result->length() == m_pageSize) {
end(true);
return;
}
// Continue cursor before making injected script calls, otherwise transaction might be finished.
if (cursor->continueFunction(nullptr).hasException()) {
m_requestCallback->sendFailure("Could not continue cursor.");
return;
}
auto* state = context.execState();
auto key = toJS(*state, *state->lexicalGlobalObject(), cursor->key());
auto primaryKey = toJS(*state, *state->lexicalGlobalObject(), cursor->primaryKey());
auto value = deserializeIDBValueToJSValue(*state, cursor->value());
auto dataEntry = DataEntry::create()
.setKey(m_injectedScript.wrapObject(key, String(), true))
.setPrimaryKey(m_injectedScript.wrapObject(primaryKey, String(), true))
.setValue(m_injectedScript.wrapObject(value, String(), true))
.release();
m_result->addItem(WTFMove(dataEntry));
}
void end(bool hasMore)
{
if (!m_requestCallback->isActive())
return;
m_requestCallback->sendSuccess(WTFMove(m_result), hasMore);
}
private:
OpenCursorCallback(InjectedScript injectedScript, Ref<RequestDataCallback>&& requestCallback, int skipCount, unsigned pageSize)
: EventListener(EventListener::CPPEventListenerType)
, m_injectedScript(injectedScript)
, m_requestCallback(WTFMove(requestCallback))
, m_result(JSON::ArrayOf<DataEntry>::create())
, m_skipCount(skipCount)
, m_pageSize(pageSize)
{
}
InjectedScript m_injectedScript;
Ref<RequestDataCallback> m_requestCallback;
Ref<JSON::ArrayOf<DataEntry>> m_result;
int m_skipCount;
unsigned m_pageSize;
};
class DataLoader final : public ExecutableWithDatabase {
public:
static Ref<DataLoader> create(ScriptExecutionContext* context, Ref<RequestDataCallback>&& requestCallback, const InjectedScript& injectedScript, const String& objectStoreName, const String& indexName, RefPtr<IDBKeyRange>&& idbKeyRange, int skipCount, unsigned pageSize)
{
return adoptRef(*new DataLoader(context, WTFMove(requestCallback), injectedScript, objectStoreName, indexName, WTFMove(idbKeyRange), skipCount, pageSize));
}
~DataLoader() override = default;
void execute(IDBDatabase& database) override
{
if (!requestCallback().isActive())
return;
auto idbTransaction = transactionForDatabase(&database, m_objectStoreName);
if (!idbTransaction) {
m_requestCallback->sendFailure("Could not get transaction");
return;
}
auto idbObjectStore = objectStoreForTransaction(idbTransaction.get(), m_objectStoreName);
if (!idbObjectStore) {
m_requestCallback->sendFailure("Could not get object store");
return;
}
TransactionActivator activator(idbTransaction.get());
RefPtr<IDBRequest> idbRequest;
auto* exec = context() ? context()->execState() : nullptr;
if (!m_indexName.isEmpty()) {
auto idbIndex = indexForObjectStore(idbObjectStore.get(), m_indexName);
if (!idbIndex) {
m_requestCallback->sendFailure("Could not get index");
return;
}
if (exec) {
auto result = idbIndex->openCursor(*exec, m_idbKeyRange.get(), IDBCursorDirection::Next);
if (!result.hasException())
idbRequest = result.releaseReturnValue();
}
} else {
if (exec) {
auto result = idbObjectStore->openCursor(*exec, m_idbKeyRange.get(), IDBCursorDirection::Next);
if (!result.hasException())
idbRequest = result.releaseReturnValue();
}
}
if (!idbRequest) {
m_requestCallback->sendFailure("Could not open cursor to populate database data");
return;
}
auto openCursorCallback = OpenCursorCallback::create(m_injectedScript, m_requestCallback.copyRef(), m_skipCount, m_pageSize);
idbRequest->addEventListener(eventNames().successEvent, WTFMove(openCursorCallback), false);
}
RequestCallback& requestCallback() override { return m_requestCallback.get(); }
DataLoader(ScriptExecutionContext* scriptExecutionContext, Ref<RequestDataCallback>&& requestCallback, const InjectedScript& injectedScript, const String& objectStoreName, const String& indexName, RefPtr<IDBKeyRange> idbKeyRange, int skipCount, unsigned pageSize)
: ExecutableWithDatabase(scriptExecutionContext)
, m_requestCallback(WTFMove(requestCallback))
, m_injectedScript(injectedScript)
, m_objectStoreName(objectStoreName)
, m_indexName(indexName)
, m_idbKeyRange(WTFMove(idbKeyRange))
, m_skipCount(skipCount)
, m_pageSize(pageSize) { }
Ref<RequestDataCallback> m_requestCallback;
InjectedScript m_injectedScript;
String m_objectStoreName;
String m_indexName;
RefPtr<IDBKeyRange> m_idbKeyRange;
int m_skipCount;
unsigned m_pageSize;
};
} // namespace
InspectorIndexedDBAgent::InspectorIndexedDBAgent(PageAgentContext& context)
: InspectorAgentBase("IndexedDB"_s, context)
, m_injectedScriptManager(context.injectedScriptManager)
, m_backendDispatcher(Inspector::IndexedDBBackendDispatcher::create(context.backendDispatcher, this))
, m_inspectedPage(context.inspectedPage)
{
}
InspectorIndexedDBAgent::~InspectorIndexedDBAgent() = default;
void InspectorIndexedDBAgent::didCreateFrontendAndBackend(Inspector::FrontendRouter*, Inspector::BackendDispatcher*)
{
}
void InspectorIndexedDBAgent::willDestroyFrontendAndBackend(Inspector::DisconnectReason)
{
ErrorString ignored;
disable(ignored);
}
void InspectorIndexedDBAgent::enable(ErrorString&)
{
}
void InspectorIndexedDBAgent::disable(ErrorString&)
{
}
static ErrorStringOr<Document*> documentFromFrame(Frame* frame)
{
Document* document = frame ? frame->document() : nullptr;
if (!document)
return makeUnexpected("Missing document for given frame"_s);
return document;
}
static ErrorStringOr<IDBFactory*> IDBFactoryFromDocument(Document* document)
{
DOMWindow* domWindow = document->domWindow();
if (!domWindow)
return makeUnexpected("Missing window for given document"_s);
IDBFactory* idbFactory = DOMWindowIndexedDatabase::indexedDB(*domWindow);
if (!idbFactory)
makeUnexpected("Missing IndexedDB factory of window for given document"_s);
return idbFactory;
}
static bool getDocumentAndIDBFactoryFromFrameOrSendFailure(Frame* frame, Document*& out_document, IDBFactory*& out_idbFactory, BackendDispatcher::CallbackBase& callback)
{
ErrorStringOr<Document*> document = documentFromFrame(frame);
if (!document.has_value()) {
callback.sendFailure(document.error());
return false;
}
ErrorStringOr<IDBFactory*> idbFactory = IDBFactoryFromDocument(document.value());
if (!idbFactory.has_value()) {
callback.sendFailure(idbFactory.error());
return false;
}
out_document = document.value();
out_idbFactory = idbFactory.value();
return true;
}
void InspectorIndexedDBAgent::requestDatabaseNames(const String& securityOrigin, Ref<RequestDatabaseNamesCallback>&& callback)
{
auto* frame = InspectorPageAgent::findFrameWithSecurityOrigin(m_inspectedPage, securityOrigin);
Document* document;
IDBFactory* idbFactory;
if (!getDocumentAndIDBFactoryFromFrameOrSendFailure(frame, document, idbFactory, callback))
return;
auto& openingOrigin = document->securityOrigin();
auto& topOrigin = document->topOrigin();
idbFactory->getAllDatabaseNames(topOrigin, openingOrigin, [callback = WTFMove(callback)](auto& databaseNames) {
if (!callback->isActive())
return;
Ref<JSON::ArrayOf<String>> databaseNameArray = JSON::ArrayOf<String>::create();
for (auto& databaseName : databaseNames)
databaseNameArray->addItem(databaseName);
callback->sendSuccess(WTFMove(databaseNameArray));
});
}
void InspectorIndexedDBAgent::requestDatabase(const String& securityOrigin, const String& databaseName, Ref<RequestDatabaseCallback>&& callback)
{
auto* frame = InspectorPageAgent::findFrameWithSecurityOrigin(m_inspectedPage, securityOrigin);
Document* document;
IDBFactory* idbFactory;
if (!getDocumentAndIDBFactoryFromFrameOrSendFailure(frame, document, idbFactory, callback))
return;
Ref<DatabaseLoader> databaseLoader = DatabaseLoader::create(document, WTFMove(callback));
databaseLoader->start(idbFactory, &document->securityOrigin(), databaseName);
}
void InspectorIndexedDBAgent::requestData(const String& securityOrigin, const String& databaseName, const String& objectStoreName, const String& indexName, int skipCount, int pageSize, const JSON::Object* keyRange, Ref<RequestDataCallback>&& callback)
{
auto* frame = InspectorPageAgent::findFrameWithSecurityOrigin(m_inspectedPage, securityOrigin);
Document* document;
IDBFactory* idbFactory;
if (!getDocumentAndIDBFactoryFromFrameOrSendFailure(frame, document, idbFactory, callback))
return;
InjectedScript injectedScript = m_injectedScriptManager.injectedScriptFor(mainWorldExecState(frame));
RefPtr<IDBKeyRange> idbKeyRange = keyRange ? idbKeyRangeFromKeyRange(keyRange) : nullptr;
if (keyRange && !idbKeyRange) {
callback->sendFailure("Could not parse key range."_s);
return;
}
Ref<DataLoader> dataLoader = DataLoader::create(document, WTFMove(callback), injectedScript, objectStoreName, indexName, WTFMove(idbKeyRange), skipCount, pageSize);
dataLoader->start(idbFactory, &document->securityOrigin(), databaseName);
}
namespace {
class ClearObjectStoreListener final : public EventListener {
WTF_MAKE_NONCOPYABLE(ClearObjectStoreListener);
public:
static Ref<ClearObjectStoreListener> create(Ref<ClearObjectStoreCallback> requestCallback)
{
return adoptRef(*new ClearObjectStoreListener(WTFMove(requestCallback)));
}
~ClearObjectStoreListener() override = default;
bool operator==(const EventListener& other) const override
{
return this == &other;
}
void handleEvent(ScriptExecutionContext&, Event& event) override
{
if (!m_requestCallback->isActive())
return;
if (event.type() != eventNames().completeEvent) {
m_requestCallback->sendFailure("Unexpected event type.");
return;
}
m_requestCallback->sendSuccess();
}
private:
ClearObjectStoreListener(Ref<ClearObjectStoreCallback>&& requestCallback)
: EventListener(EventListener::CPPEventListenerType)
, m_requestCallback(WTFMove(requestCallback))
{
}
Ref<ClearObjectStoreCallback> m_requestCallback;
};
class ClearObjectStore final : public ExecutableWithDatabase {
public:
static Ref<ClearObjectStore> create(ScriptExecutionContext* context, const String& objectStoreName, Ref<ClearObjectStoreCallback>&& requestCallback)
{
return adoptRef(*new ClearObjectStore(context, objectStoreName, WTFMove(requestCallback)));
}
ClearObjectStore(ScriptExecutionContext* context, const String& objectStoreName, Ref<ClearObjectStoreCallback>&& requestCallback)
: ExecutableWithDatabase(context)
, m_objectStoreName(objectStoreName)
, m_requestCallback(WTFMove(requestCallback))
{
}
void execute(IDBDatabase& database) override
{
if (!requestCallback().isActive())
return;
auto idbTransaction = transactionForDatabase(&database, m_objectStoreName, IDBTransactionMode::Readwrite);
if (!idbTransaction) {
m_requestCallback->sendFailure("Could not get transaction");
return;
}
auto idbObjectStore = objectStoreForTransaction(idbTransaction.get(), m_objectStoreName);
if (!idbObjectStore) {
m_requestCallback->sendFailure("Could not get object store");
return;
}
TransactionActivator activator(idbTransaction.get());
RefPtr<IDBRequest> idbRequest;
if (auto* exec = context() ? context()->execState() : nullptr) {
auto result = idbObjectStore->clear(*exec);
ASSERT(!result.hasException());
if (result.hasException()) {
m_requestCallback->sendFailure(makeString("Could not clear object store '", m_objectStoreName, "': ", static_cast<int>(result.releaseException().code())));
return;
}
idbRequest = result.releaseReturnValue();
}
idbTransaction->addEventListener(eventNames().completeEvent, ClearObjectStoreListener::create(m_requestCallback.copyRef()), false);
}
RequestCallback& requestCallback() override { return m_requestCallback.get(); }
private:
const String m_objectStoreName;
Ref<ClearObjectStoreCallback> m_requestCallback;
};
} // anonymous namespace
void InspectorIndexedDBAgent::clearObjectStore(const String& securityOrigin, const String& databaseName, const String& objectStoreName, Ref<ClearObjectStoreCallback>&& callback)
{
auto* frame = InspectorPageAgent::findFrameWithSecurityOrigin(m_inspectedPage, securityOrigin);
Document* document;
IDBFactory* idbFactory;
if (!getDocumentAndIDBFactoryFromFrameOrSendFailure(frame, document, idbFactory, callback))
return;
Ref<ClearObjectStore> clearObjectStore = ClearObjectStore::create(document, objectStoreName, WTFMove(callback));
clearObjectStore->start(idbFactory, &document->securityOrigin(), databaseName);
}
} // namespace WebCore
#endif // ENABLE(INDEXED_DATABASE)