blob: fbbcd09ff58d481ce4c7e3565139cce9054fe42f [file] [log] [blame]
/*
* Copyright (C) 2012 Google 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 "third_party/blink/renderer/modules/indexeddb/inspector_indexed_db_agent.h"
#include <memory>
#include <utility>
#include "third_party/blink/public/common/indexeddb/web_idb_types.h"
#include "third_party/blink/renderer/bindings/core/v8/script_controller.h"
#include "third_party/blink/renderer/bindings/core/v8/v8_binding_for_core.h"
#include "third_party/blink/renderer/core/dom/document.h"
#include "third_party/blink/renderer/core/dom/dom_string_list.h"
#include "third_party/blink/renderer/core/dom/events/native_event_listener.h"
#include "third_party/blink/renderer/core/execution_context/execution_context.h"
#include "third_party/blink/renderer/core/frame/local_frame.h"
#include "third_party/blink/renderer/core/inspector/inspected_frames.h"
#include "third_party/blink/renderer/core/inspector/v8_inspector_string.h"
#include "third_party/blink/renderer/modules/indexed_db_names.h"
#include "third_party/blink/renderer/modules/indexeddb/global_indexed_db.h"
#include "third_party/blink/renderer/modules/indexeddb/idb_cursor.h"
#include "third_party/blink/renderer/modules/indexeddb/idb_cursor_with_value.h"
#include "third_party/blink/renderer/modules/indexeddb/idb_database.h"
#include "third_party/blink/renderer/modules/indexeddb/idb_factory.h"
#include "third_party/blink/renderer/modules/indexeddb/idb_index.h"
#include "third_party/blink/renderer/modules/indexeddb/idb_key.h"
#include "third_party/blink/renderer/modules/indexeddb/idb_key_path.h"
#include "third_party/blink/renderer/modules/indexeddb/idb_key_range.h"
#include "third_party/blink/renderer/modules/indexeddb/idb_metadata.h"
#include "third_party/blink/renderer/modules/indexeddb/idb_object_store.h"
#include "third_party/blink/renderer/modules/indexeddb/idb_open_db_request.h"
#include "third_party/blink/renderer/modules/indexeddb/idb_request.h"
#include "third_party/blink/renderer/modules/indexeddb/idb_transaction.h"
#include "third_party/blink/renderer/modules/indexeddb/web_idb_cursor.h"
#include "third_party/blink/renderer/platform/bindings/exception_state.h"
#include "third_party/blink/renderer/platform/bindings/script_state.h"
#include "third_party/blink/renderer/platform/bindings/v8_per_isolate_data.h"
#include "third_party/blink/renderer/platform/weborigin/security_origin.h"
#include "third_party/blink/renderer/platform/wtf/vector.h"
using blink::protocol::Array;
using blink::protocol::IndexedDB::DatabaseWithObjectStores;
using blink::protocol::IndexedDB::DataEntry;
using blink::protocol::IndexedDB::Key;
using blink::protocol::IndexedDB::KeyPath;
using blink::protocol::IndexedDB::KeyRange;
using blink::protocol::IndexedDB::ObjectStore;
using blink::protocol::IndexedDB::ObjectStoreIndex;
using blink::protocol::Maybe;
using blink::protocol::Response;
typedef blink::protocol::IndexedDB::Backend::RequestDatabaseNamesCallback
RequestDatabaseNamesCallback;
typedef blink::protocol::IndexedDB::Backend::RequestDatabaseCallback
RequestDatabaseCallback;
typedef blink::protocol::IndexedDB::Backend::RequestDataCallback
RequestDataCallback;
typedef blink::protocol::IndexedDB::Backend::DeleteObjectStoreEntriesCallback
DeleteObjectStoreEntriesCallback;
typedef blink::protocol::IndexedDB::Backend::ClearObjectStoreCallback
ClearObjectStoreCallback;
typedef blink::protocol::IndexedDB::Backend::
GetKeyGeneratorCurrentNumberCallback GetKeyGeneratorCurrentNumberCallback;
typedef blink::protocol::IndexedDB::Backend::DeleteDatabaseCallback
DeleteDatabaseCallback;
namespace blink {
namespace {
const char kIndexedDBObjectGroup[] = "indexeddb";
const char kNoDocumentError[] = "No document for given frame found";
Response AssertIDBFactory(Document* document, IDBFactory*& result) {
LocalDOMWindow* dom_window = document->domWindow();
if (!dom_window)
return Response::Error("No IndexedDB factory for given frame found");
IDBFactory* idb_factory = GlobalIndexedDB::indexedDB(*dom_window);
if (!idb_factory)
return Response::Error("No IndexedDB factory for given frame found");
result = idb_factory;
return Response::OK();
}
class GetDatabaseNamesCallback final : public NativeEventListener {
public:
static GetDatabaseNamesCallback* Create(
std::unique_ptr<RequestDatabaseNamesCallback> request_callback,
const String& security_origin) {
return MakeGarbageCollected<GetDatabaseNamesCallback>(
std::move(request_callback), security_origin);
}
GetDatabaseNamesCallback(
std::unique_ptr<RequestDatabaseNamesCallback> request_callback,
const String& security_origin)
: request_callback_(std::move(request_callback)),
security_origin_(security_origin) {}
~GetDatabaseNamesCallback() override = default;
void Invoke(ExecutionContext*, Event* event) override {
if (event->type() != event_type_names::kSuccess) {
request_callback_->sendFailure(Response::Error("Unexpected event type."));
return;
}
IDBRequest* idb_request = static_cast<IDBRequest*>(event->target());
IDBAny* request_result = idb_request->ResultAsAny();
if (request_result->GetType() != IDBAny::kDOMStringListType) {
request_callback_->sendFailure(
Response::Error("Unexpected result type."));
return;
}
DOMStringList* database_names_list = request_result->DomStringList();
std::unique_ptr<protocol::Array<String>> database_names =
protocol::Array<String>::create();
for (uint32_t i = 0; i < database_names_list->length(); ++i)
database_names->addItem(database_names_list->item(i));
request_callback_->sendSuccess(std::move(database_names));
}
private:
std::unique_ptr<RequestDatabaseNamesCallback> request_callback_;
String security_origin_;
};
class DeleteCallback final : public NativeEventListener {
public:
static DeleteCallback* Create(
std::unique_ptr<DeleteDatabaseCallback> request_callback,
const String& security_origin) {
return MakeGarbageCollected<DeleteCallback>(std::move(request_callback),
security_origin);
}
DeleteCallback(std::unique_ptr<DeleteDatabaseCallback> request_callback,
const String& security_origin)
: request_callback_(std::move(request_callback)),
security_origin_(security_origin) {}
~DeleteCallback() override = default;
void Invoke(ExecutionContext*, Event* event) override {
if (event->type() != event_type_names::kSuccess) {
request_callback_->sendFailure(
Response::Error("Failed to delete database."));
return;
}
request_callback_->sendSuccess();
}
private:
std::unique_ptr<DeleteDatabaseCallback> request_callback_;
String security_origin_;
};
template <typename RequestCallback>
class OpenDatabaseCallback;
template <typename RequestCallback>
class UpgradeDatabaseCallback;
template <typename RequestCallback>
class ExecutableWithDatabase
: public RefCounted<ExecutableWithDatabase<RequestCallback>> {
public:
virtual ~ExecutableWithDatabase() = default;
virtual void Execute(IDBDatabase*, ScriptState*) = 0;
virtual RequestCallback* GetRequestCallback() = 0;
void Start(LocalFrame* frame, const String& database_name) {
Document* document = frame ? frame->GetDocument() : nullptr;
if (!document) {
SendFailure(Response::Error(kNoDocumentError));
return;
}
IDBFactory* idb_factory = nullptr;
Response response = AssertIDBFactory(document, idb_factory);
if (!response.isSuccess()) {
SendFailure(response);
return;
}
ScriptState* script_state = ToScriptStateForMainWorld(frame);
if (!script_state) {
SendFailure(Response::InternalError());
return;
}
ScriptState::Scope scope(script_state);
DoStart(idb_factory, script_state, document->GetSecurityOrigin(),
database_name);
}
private:
void DoStart(IDBFactory* idb_factory,
ScriptState* script_state,
const SecurityOrigin*,
const String& database_name) {
OpenDatabaseCallback<RequestCallback>* open_callback =
OpenDatabaseCallback<RequestCallback>::Create(this, script_state);
UpgradeDatabaseCallback<RequestCallback>* upgrade_callback =
UpgradeDatabaseCallback<RequestCallback>::Create(this);
DummyExceptionStateForTesting exception_state;
IDBOpenDBRequest* idb_open_db_request =
idb_factory->open(script_state, database_name, exception_state);
if (exception_state.HadException()) {
SendFailure(Response::Error("Could not open database."));
return;
}
idb_open_db_request->addEventListener(event_type_names::kUpgradeneeded,
upgrade_callback, false);
idb_open_db_request->addEventListener(event_type_names::kSuccess,
open_callback, false);
}
void SendFailure(Response response) {
GetRequestCallback()->sendFailure(response);
}
};
template <typename RequestCallback>
class OpenDatabaseCallback final : public NativeEventListener {
public:
static OpenDatabaseCallback* Create(
ExecutableWithDatabase<RequestCallback>* executable_with_database,
ScriptState* script_state) {
return MakeGarbageCollected<OpenDatabaseCallback>(executable_with_database,
script_state);
}
OpenDatabaseCallback(
ExecutableWithDatabase<RequestCallback>* executable_with_database,
ScriptState* script_state)
: executable_with_database_(executable_with_database),
script_state_(script_state) {}
~OpenDatabaseCallback() override = default;
void Invoke(ExecutionContext* context, Event* event) override {
if (event->type() != event_type_names::kSuccess) {
executable_with_database_->GetRequestCallback()->sendFailure(
Response::Error("Unexpected event type."));
return;
}
IDBOpenDBRequest* idb_open_db_request =
static_cast<IDBOpenDBRequest*>(event->target());
IDBAny* request_result = idb_open_db_request->ResultAsAny();
if (request_result->GetType() != IDBAny::kIDBDatabaseType) {
executable_with_database_->GetRequestCallback()->sendFailure(
Response::Error("Unexpected result type."));
return;
}
IDBDatabase* idb_database = request_result->IdbDatabase();
executable_with_database_->Execute(idb_database, script_state_);
V8PerIsolateData::From(script_state_->GetIsolate())->RunEndOfScopeTasks();
idb_database->close();
}
void Trace(blink::Visitor* visitor) override {
visitor->Trace(script_state_);
NativeEventListener::Trace(visitor);
}
private:
scoped_refptr<ExecutableWithDatabase<RequestCallback>>
executable_with_database_;
Member<ScriptState> script_state_;
};
template <typename RequestCallback>
class UpgradeDatabaseCallback final : public NativeEventListener {
public:
static UpgradeDatabaseCallback* Create(
ExecutableWithDatabase<RequestCallback>* executable_with_database) {
return MakeGarbageCollected<UpgradeDatabaseCallback>(
executable_with_database);
}
UpgradeDatabaseCallback(
ExecutableWithDatabase<RequestCallback>* executable_with_database)
: executable_with_database_(executable_with_database) {}
~UpgradeDatabaseCallback() override = default;
void Invoke(ExecutionContext* context, Event* event) override {
if (event->type() != event_type_names::kUpgradeneeded) {
executable_with_database_->GetRequestCallback()->sendFailure(
Response::Error("Unexpected event type."));
return;
}
// If an "upgradeneeded" event comes through then the database that
// had previously been enumerated was deleted. We don't want to
// implicitly re-create it here, so abort the transaction.
IDBOpenDBRequest* idb_open_db_request =
static_cast<IDBOpenDBRequest*>(event->target());
NonThrowableExceptionState exception_state;
idb_open_db_request->transaction()->abort(exception_state);
executable_with_database_->GetRequestCallback()->sendFailure(
Response::Error("Aborted upgrade."));
}
private:
scoped_refptr<ExecutableWithDatabase<RequestCallback>>
executable_with_database_;
};
IDBTransaction* TransactionForDatabase(
ScriptState* script_state,
IDBDatabase* idb_database,
const String& object_store_name,
const String& mode = indexed_db_names::kReadonly) {
DummyExceptionStateForTesting exception_state;
StringOrStringSequence scope;
scope.SetString(object_store_name);
IDBTransaction* idb_transaction =
idb_database->transaction(script_state, scope, mode, exception_state);
if (exception_state.HadException())
return nullptr;
return idb_transaction;
}
IDBObjectStore* ObjectStoreForTransaction(IDBTransaction* idb_transaction,
const String& object_store_name) {
DummyExceptionStateForTesting exception_state;
IDBObjectStore* idb_object_store =
idb_transaction->objectStore(object_store_name, exception_state);
if (exception_state.HadException())
return nullptr;
return idb_object_store;
}
IDBIndex* IndexForObjectStore(IDBObjectStore* idb_object_store,
const String& index_name) {
DummyExceptionStateForTesting exception_state;
IDBIndex* idb_index = idb_object_store->index(index_name, exception_state);
if (exception_state.HadException())
return nullptr;
return idb_index;
}
std::unique_ptr<KeyPath> KeyPathFromIDBKeyPath(const IDBKeyPath& idb_key_path) {
std::unique_ptr<KeyPath> key_path;
switch (idb_key_path.GetType()) {
case mojom::IDBKeyPathType::Null:
key_path = KeyPath::create().setType(KeyPath::TypeEnum::Null).build();
break;
case mojom::IDBKeyPathType::String:
key_path = KeyPath::create()
.setType(KeyPath::TypeEnum::String)
.setString(idb_key_path.GetString())
.build();
break;
case mojom::IDBKeyPathType::Array: {
key_path = KeyPath::create().setType(KeyPath::TypeEnum::Array).build();
std::unique_ptr<protocol::Array<String>> array =
protocol::Array<String>::create();
const Vector<String>& string_array = idb_key_path.Array();
for (wtf_size_t i = 0; i < string_array.size(); ++i)
array->addItem(string_array[i]);
key_path->setArray(std::move(array));
break;
}
default:
NOTREACHED();
}
return key_path;
}
class DatabaseLoader final
: public ExecutableWithDatabase<RequestDatabaseCallback> {
public:
static scoped_refptr<DatabaseLoader> Create(
std::unique_ptr<RequestDatabaseCallback> request_callback) {
return base::AdoptRef(new DatabaseLoader(std::move(request_callback)));
}
~DatabaseLoader() override = default;
void Execute(IDBDatabase* idb_database, ScriptState*) override {
const IDBDatabaseMetadata database_metadata = idb_database->Metadata();
std::unique_ptr<protocol::Array<protocol::IndexedDB::ObjectStore>>
object_stores =
protocol::Array<protocol::IndexedDB::ObjectStore>::create();
for (const auto& store_map_entry : database_metadata.object_stores) {
const IDBObjectStoreMetadata& object_store_metadata =
*store_map_entry.value;
std::unique_ptr<protocol::Array<protocol::IndexedDB::ObjectStoreIndex>>
indexes =
protocol::Array<protocol::IndexedDB::ObjectStoreIndex>::create();
for (const auto& metadata_map_entry : object_store_metadata.indexes) {
const IDBIndexMetadata& index_metadata = *metadata_map_entry.value;
std::unique_ptr<ObjectStoreIndex> object_store_index =
ObjectStoreIndex::create()
.setName(index_metadata.name)
.setKeyPath(KeyPathFromIDBKeyPath(index_metadata.key_path))
.setUnique(index_metadata.unique)
.setMultiEntry(index_metadata.multi_entry)
.build();
indexes->addItem(std::move(object_store_index));
}
std::unique_ptr<ObjectStore> object_store =
ObjectStore::create()
.setName(object_store_metadata.name)
.setKeyPath(KeyPathFromIDBKeyPath(object_store_metadata.key_path))
.setAutoIncrement(object_store_metadata.auto_increment)
.setIndexes(std::move(indexes))
.build();
object_stores->addItem(std::move(object_store));
}
std::unique_ptr<DatabaseWithObjectStores> result =
DatabaseWithObjectStores::create()
.setName(idb_database->name())
.setVersion(idb_database->version())
.setObjectStores(std::move(object_stores))
.build();
request_callback_->sendSuccess(std::move(result));
}
RequestDatabaseCallback* GetRequestCallback() override {
return request_callback_.get();
}
private:
DatabaseLoader(std::unique_ptr<RequestDatabaseCallback> request_callback)
: request_callback_(std::move(request_callback)) {}
std::unique_ptr<RequestDatabaseCallback> request_callback_;
};
static std::unique_ptr<IDBKey> IdbKeyFromInspectorObject(
protocol::IndexedDB::Key* key) {
std::unique_ptr<IDBKey> idb_key;
if (!key)
return nullptr;
String type = key->getType();
DEFINE_STATIC_LOCAL(String, number_type, ("number"));
DEFINE_STATIC_LOCAL(String, string_type, ("string"));
DEFINE_STATIC_LOCAL(String, date_type, ("date"));
DEFINE_STATIC_LOCAL(String, array_type, ("array"));
if (type == number_type) {
if (!key->hasNumber())
return nullptr;
idb_key = IDBKey::CreateNumber(key->getNumber(0));
} else if (type == string_type) {
if (!key->hasString())
return nullptr;
idb_key = IDBKey::CreateString(key->getString(String()));
} else if (type == date_type) {
if (!key->hasDate())
return nullptr;
idb_key = IDBKey::CreateDate(key->getDate(0));
} else if (type == array_type) {
IDBKey::KeyArray key_array;
auto* array = key->getArray(nullptr);
for (size_t i = 0; array && i < array->length(); ++i)
key_array.push_back(IdbKeyFromInspectorObject(array->get(i)));
idb_key = IDBKey::CreateArray(std::move(key_array));
} else {
return nullptr;
}
return idb_key;
}
static IDBKeyRange* IdbKeyRangeFromKeyRange(
protocol::IndexedDB::KeyRange* key_range) {
std::unique_ptr<IDBKey> idb_lower =
IdbKeyFromInspectorObject(key_range->getLower(nullptr));
if (key_range->hasLower() && !idb_lower)
return nullptr;
std::unique_ptr<IDBKey> idb_upper =
IdbKeyFromInspectorObject(key_range->getUpper(nullptr));
if (key_range->hasUpper() && !idb_upper)
return nullptr;
IDBKeyRange::LowerBoundType lower_bound_type =
key_range->getLowerOpen() ? IDBKeyRange::kLowerBoundOpen
: IDBKeyRange::kLowerBoundClosed;
IDBKeyRange::UpperBoundType upper_bound_type =
key_range->getUpperOpen() ? IDBKeyRange::kUpperBoundOpen
: IDBKeyRange::kUpperBoundClosed;
return IDBKeyRange::Create(std::move(idb_lower), std::move(idb_upper),
lower_bound_type, upper_bound_type);
}
class DataLoader;
class OpenCursorCallback final : public NativeEventListener {
public:
static OpenCursorCallback* Create(
v8_inspector::V8InspectorSession* v8_session,
ScriptState* script_state,
std::unique_ptr<RequestDataCallback> request_callback,
int skip_count,
unsigned page_size) {
return MakeGarbageCollected<OpenCursorCallback>(v8_session, script_state,
std::move(request_callback),
skip_count, page_size);
}
OpenCursorCallback(v8_inspector::V8InspectorSession* v8_session,
ScriptState* script_state,
std::unique_ptr<RequestDataCallback> request_callback,
int skip_count,
unsigned page_size)
: v8_session_(v8_session),
script_state_(script_state),
request_callback_(std::move(request_callback)),
skip_count_(skip_count),
page_size_(page_size) {
result_ = Array<DataEntry>::create();
}
~OpenCursorCallback() override = default;
void Invoke(ExecutionContext*, Event* event) override {
if (event->type() != event_type_names::kSuccess) {
request_callback_->sendFailure(Response::Error("Unexpected event type."));
return;
}
IDBRequest* idb_request = static_cast<IDBRequest*>(event->target());
IDBAny* request_result = idb_request->ResultAsAny();
if (request_result->GetType() == IDBAny::kIDBValueType) {
end(false);
return;
}
if (request_result->GetType() != IDBAny::kIDBCursorWithValueType) {
request_callback_->sendFailure(
Response::Error("Unexpected result type."));
return;
}
IDBCursorWithValue* idb_cursor = request_result->IdbCursorWithValue();
if (skip_count_) {
DummyExceptionStateForTesting exception_state;
idb_cursor->advance(skip_count_, exception_state);
if (exception_state.HadException()) {
request_callback_->sendFailure(
Response::Error("Could not advance cursor."));
}
skip_count_ = 0;
return;
}
if (result_->length() == page_size_) {
end(true);
return;
}
// Continue cursor before making injected script calls, otherwise
// transaction might be finished.
DummyExceptionStateForTesting exception_state;
idb_cursor->Continue(nullptr, nullptr, IDBRequest::AsyncTraceState(),
exception_state);
if (exception_state.HadException()) {
request_callback_->sendFailure(
Response::Error("Could not continue cursor."));
return;
}
Document* document = To<Document>(ExecutionContext::From(script_state_));
if (!document)
return;
ScriptState::Scope scope(script_state_);
v8::Local<v8::Context> context = script_state_->GetContext();
v8_inspector::StringView object_group =
ToV8InspectorStringView(kIndexedDBObjectGroup);
std::unique_ptr<DataEntry> data_entry =
DataEntry::create()
.setKey(v8_session_->wrapObject(
context, idb_cursor->key(script_state_).V8Value(), object_group,
true /* generatePreview */))
.setPrimaryKey(v8_session_->wrapObject(
context, idb_cursor->primaryKey(script_state_).V8Value(),
object_group, true /* generatePreview */))
.setValue(v8_session_->wrapObject(
context, idb_cursor->value(script_state_).V8Value(),
object_group, true /* generatePreview */))
.build();
result_->addItem(std::move(data_entry));
}
void end(bool has_more) {
request_callback_->sendSuccess(std::move(result_), has_more);
}
void Trace(blink::Visitor* visitor) override {
visitor->Trace(script_state_);
NativeEventListener::Trace(visitor);
}
private:
v8_inspector::V8InspectorSession* v8_session_;
Member<ScriptState> script_state_;
std::unique_ptr<RequestDataCallback> request_callback_;
int skip_count_;
unsigned page_size_;
std::unique_ptr<Array<DataEntry>> result_;
};
class DataLoader final : public ExecutableWithDatabase<RequestDataCallback> {
public:
static scoped_refptr<DataLoader> Create(
v8_inspector::V8InspectorSession* v8_session,
std::unique_ptr<RequestDataCallback> request_callback,
const String& object_store_name,
const String& index_name,
IDBKeyRange* idb_key_range,
int skip_count,
unsigned page_size) {
return base::AdoptRef(new DataLoader(
v8_session, std::move(request_callback), object_store_name, index_name,
idb_key_range, skip_count, page_size));
}
~DataLoader() override = default;
void Execute(IDBDatabase* idb_database, ScriptState* script_state) override {
IDBTransaction* idb_transaction =
TransactionForDatabase(script_state, idb_database, object_store_name_);
if (!idb_transaction) {
request_callback_->sendFailure(
Response::Error("Could not get transaction"));
return;
}
IDBObjectStore* idb_object_store =
ObjectStoreForTransaction(idb_transaction, object_store_name_);
if (!idb_object_store) {
request_callback_->sendFailure(
Response::Error("Could not get object store"));
return;
}
IDBRequest* idb_request;
if (!index_name_.IsEmpty()) {
IDBIndex* idb_index = IndexForObjectStore(idb_object_store, index_name_);
if (!idb_index) {
request_callback_->sendFailure(Response::Error("Could not get index"));
return;
}
idb_request = idb_index->openCursor(script_state, idb_key_range_.Get(),
mojom::IDBCursorDirection::Next);
} else {
idb_request = idb_object_store->openCursor(
script_state, idb_key_range_.Get(), mojom::IDBCursorDirection::Next);
}
OpenCursorCallback* open_cursor_callback = OpenCursorCallback::Create(
v8_session_, script_state, std::move(request_callback_), skip_count_,
page_size_);
idb_request->addEventListener(event_type_names::kSuccess,
open_cursor_callback, false);
}
RequestDataCallback* GetRequestCallback() override {
return request_callback_.get();
}
DataLoader(v8_inspector::V8InspectorSession* v8_session,
std::unique_ptr<RequestDataCallback> request_callback,
const String& object_store_name,
const String& index_name,
IDBKeyRange* idb_key_range,
int skip_count,
unsigned page_size)
: v8_session_(v8_session),
request_callback_(std::move(request_callback)),
object_store_name_(object_store_name),
index_name_(index_name),
idb_key_range_(idb_key_range),
skip_count_(skip_count),
page_size_(page_size) {}
v8_inspector::V8InspectorSession* v8_session_;
std::unique_ptr<RequestDataCallback> request_callback_;
String object_store_name_;
String index_name_;
Persistent<IDBKeyRange> idb_key_range_;
int skip_count_;
unsigned page_size_;
};
} // namespace
// static
InspectorIndexedDBAgent::InspectorIndexedDBAgent(
InspectedFrames* inspected_frames,
v8_inspector::V8InspectorSession* v8_session)
: inspected_frames_(inspected_frames),
v8_session_(v8_session),
enabled_(&agent_state_, /*default_value=*/false) {}
InspectorIndexedDBAgent::~InspectorIndexedDBAgent() = default;
void InspectorIndexedDBAgent::Restore() {
if (enabled_.Get())
enable();
}
void InspectorIndexedDBAgent::DidCommitLoadForLocalFrame(LocalFrame* frame) {
if (frame == inspected_frames_->Root()) {
v8_session_->releaseObjectGroup(
ToV8InspectorStringView(kIndexedDBObjectGroup));
}
}
Response InspectorIndexedDBAgent::enable() {
enabled_.Set(true);
return Response::OK();
}
Response InspectorIndexedDBAgent::disable() {
enabled_.Clear();
v8_session_->releaseObjectGroup(
ToV8InspectorStringView(kIndexedDBObjectGroup));
return Response::OK();
}
void InspectorIndexedDBAgent::requestDatabaseNames(
const String& security_origin,
std::unique_ptr<RequestDatabaseNamesCallback> request_callback) {
LocalFrame* frame =
inspected_frames_->FrameWithSecurityOrigin(security_origin);
Document* document = frame ? frame->GetDocument() : nullptr;
if (!document) {
request_callback->sendFailure(Response::Error(kNoDocumentError));
return;
}
IDBFactory* idb_factory = nullptr;
Response response = AssertIDBFactory(document, idb_factory);
if (!response.isSuccess()) {
request_callback->sendFailure(response);
return;
}
ScriptState* script_state = ToScriptStateForMainWorld(frame);
if (!script_state) {
request_callback->sendFailure(Response::InternalError());
return;
}
ScriptState::Scope scope(script_state);
DummyExceptionStateForTesting exception_state;
IDBRequest* idb_request =
idb_factory->GetDatabaseNames(script_state, exception_state);
if (exception_state.HadException()) {
request_callback->sendFailure(
Response::Error("Could not obtain database names."));
return;
}
idb_request->addEventListener(
event_type_names::kSuccess,
GetDatabaseNamesCallback::Create(
std::move(request_callback),
document->GetSecurityOrigin()->ToRawString()),
false);
}
void InspectorIndexedDBAgent::requestDatabase(
const String& security_origin,
const String& database_name,
std::unique_ptr<RequestDatabaseCallback> request_callback) {
scoped_refptr<DatabaseLoader> database_loader =
DatabaseLoader::Create(std::move(request_callback));
database_loader->Start(
inspected_frames_->FrameWithSecurityOrigin(security_origin),
database_name);
}
void InspectorIndexedDBAgent::requestData(
const String& security_origin,
const String& database_name,
const String& object_store_name,
const String& index_name,
int skip_count,
int page_size,
Maybe<protocol::IndexedDB::KeyRange> key_range,
std::unique_ptr<RequestDataCallback> request_callback) {
IDBKeyRange* idb_key_range =
key_range.isJust() ? IdbKeyRangeFromKeyRange(key_range.fromJust())
: nullptr;
if (key_range.isJust() && !idb_key_range) {
request_callback->sendFailure(Response::Error("Can not parse key range."));
return;
}
scoped_refptr<DataLoader> data_loader = DataLoader::Create(
v8_session_, std::move(request_callback), object_store_name, index_name,
idb_key_range, skip_count, page_size);
data_loader->Start(
inspected_frames_->FrameWithSecurityOrigin(security_origin),
database_name);
}
class GetKeyGeneratorCurrentNumberListener final : public NativeEventListener {
public:
static GetKeyGeneratorCurrentNumberListener* Create(
std::unique_ptr<GetKeyGeneratorCurrentNumberCallback> request_callback) {
return MakeGarbageCollected<GetKeyGeneratorCurrentNumberListener>(
std::move(request_callback));
}
GetKeyGeneratorCurrentNumberListener(
std::unique_ptr<GetKeyGeneratorCurrentNumberCallback> request_callback)
: request_callback_(std::move(request_callback)) {}
~GetKeyGeneratorCurrentNumberListener() override = default;
void Invoke(ExecutionContext*, Event* event) override {
if (event->type() != event_type_names::kSuccess) {
request_callback_->sendFailure(
Response::Error("Failed to get current number of key generator."));
return;
}
IDBRequest* idb_request = static_cast<IDBRequest*>(event->target());
IDBAny* request_result = idb_request->ResultAsAny();
if (request_result->GetType() != IDBAny::kIntegerType) {
request_callback_->sendFailure(
Response::Error("Unexpected result type."));
return;
}
request_callback_->sendSuccess(request_result->Integer());
}
private:
std::unique_ptr<GetKeyGeneratorCurrentNumberCallback> request_callback_;
};
class GetKeyGeneratorCurrentNumber final
: public ExecutableWithDatabase<GetKeyGeneratorCurrentNumberCallback> {
public:
static scoped_refptr<GetKeyGeneratorCurrentNumber> Create(
const String& object_store_name,
std::unique_ptr<GetKeyGeneratorCurrentNumberCallback> request_callback) {
return AdoptRef(new GetKeyGeneratorCurrentNumber(
object_store_name, std::move(request_callback)));
}
private:
GetKeyGeneratorCurrentNumber(
const String& object_store_name,
std::unique_ptr<GetKeyGeneratorCurrentNumberCallback> request_callback)
: object_store_name_(object_store_name),
request_callback_(std::move(request_callback)) {}
void Execute(IDBDatabase* idb_database, ScriptState* script_state) override {
IDBTransaction* idb_transaction =
TransactionForDatabase(script_state, idb_database, object_store_name_,
indexed_db_names::kReadonly);
if (!idb_transaction) {
request_callback_->sendFailure(
Response::Error("Could not get transaction"));
return;
}
IDBObjectStore* idb_object_store =
ObjectStoreForTransaction(idb_transaction, object_store_name_);
if (!idb_object_store) {
request_callback_->sendFailure(
Response::Error("Could not get object store"));
return;
}
IDBRequest* idb_request =
idb_object_store->getKeyGeneratorCurrentNumber(script_state);
idb_request->addEventListener(event_type_names::kSuccess,
GetKeyGeneratorCurrentNumberListener::Create(
std::move(request_callback_)),
false);
idb_request->addEventListener(event_type_names::kError,
GetKeyGeneratorCurrentNumberListener::Create(
std::move(request_callback_)),
false);
}
GetKeyGeneratorCurrentNumberCallback* GetRequestCallback() override {
return request_callback_.get();
}
private:
const String object_store_name_;
std::unique_ptr<GetKeyGeneratorCurrentNumberCallback> request_callback_;
};
void InspectorIndexedDBAgent::getKeyGeneratorCurrentNumber(
const String& security_origin,
const String& database_name,
const String& object_store_name,
std::unique_ptr<GetKeyGeneratorCurrentNumberCallback> request_callback) {
scoped_refptr<GetKeyGeneratorCurrentNumber> get_auto_increment_number =
GetKeyGeneratorCurrentNumber::Create(object_store_name,
std::move(request_callback));
get_auto_increment_number->Start(
inspected_frames_->FrameWithSecurityOrigin(security_origin),
database_name);
}
class DeleteObjectStoreEntriesListener final : public NativeEventListener {
public:
static DeleteObjectStoreEntriesListener* Create(
std::unique_ptr<DeleteObjectStoreEntriesCallback> request_callback) {
return MakeGarbageCollected<DeleteObjectStoreEntriesListener>(
std::move(request_callback));
}
DeleteObjectStoreEntriesListener(
std::unique_ptr<DeleteObjectStoreEntriesCallback> request_callback)
: request_callback_(std::move(request_callback)) {}
~DeleteObjectStoreEntriesListener() override = default;
void Invoke(ExecutionContext*, Event* event) override {
if (event->type() != event_type_names::kSuccess) {
request_callback_->sendFailure(
Response::Error("Failed to delete specified entries"));
return;
}
request_callback_->sendSuccess();
}
private:
std::unique_ptr<DeleteObjectStoreEntriesCallback> request_callback_;
};
class DeleteObjectStoreEntries final
: public ExecutableWithDatabase<DeleteObjectStoreEntriesCallback> {
public:
static scoped_refptr<DeleteObjectStoreEntries> Create(
const String& object_store_name,
IDBKeyRange* idb_key_range,
std::unique_ptr<DeleteObjectStoreEntriesCallback> request_callback) {
return AdoptRef(new DeleteObjectStoreEntries(
object_store_name, idb_key_range, std::move(request_callback)));
}
DeleteObjectStoreEntries(
const String& object_store_name,
IDBKeyRange* idb_key_range,
std::unique_ptr<DeleteObjectStoreEntriesCallback> request_callback)
: object_store_name_(object_store_name),
idb_key_range_(idb_key_range),
request_callback_(std::move(request_callback)) {}
void Execute(IDBDatabase* idb_database, ScriptState* script_state) override {
IDBTransaction* idb_transaction =
TransactionForDatabase(script_state, idb_database, object_store_name_,
indexed_db_names::kReadwrite);
if (!idb_transaction) {
request_callback_->sendFailure(
Response::Error("Could not get transaction"));
return;
}
IDBObjectStore* idb_object_store =
ObjectStoreForTransaction(idb_transaction, object_store_name_);
if (!idb_object_store) {
request_callback_->sendFailure(
Response::Error("Could not get object store"));
return;
}
IDBRequest* idb_request =
idb_object_store->deleteFunction(script_state, idb_key_range_.Get());
idb_request->addEventListener(
event_type_names::kSuccess,
DeleteObjectStoreEntriesListener::Create(std::move(request_callback_)),
false);
}
DeleteObjectStoreEntriesCallback* GetRequestCallback() override {
return request_callback_.get();
}
private:
const String object_store_name_;
Persistent<IDBKeyRange> idb_key_range_;
std::unique_ptr<DeleteObjectStoreEntriesCallback> request_callback_;
};
void InspectorIndexedDBAgent::deleteObjectStoreEntries(
const String& security_origin,
const String& database_name,
const String& object_store_name,
std::unique_ptr<protocol::IndexedDB::KeyRange> key_range,
std::unique_ptr<DeleteObjectStoreEntriesCallback> request_callback) {
IDBKeyRange* idb_key_range = IdbKeyRangeFromKeyRange(key_range.get());
if (!idb_key_range) {
request_callback->sendFailure(Response::Error("Can not parse key range"));
return;
}
scoped_refptr<DeleteObjectStoreEntries> delete_object_store_entries =
DeleteObjectStoreEntries::Create(object_store_name, idb_key_range,
std::move(request_callback));
delete_object_store_entries->Start(
inspected_frames_->FrameWithSecurityOrigin(security_origin),
database_name);
}
class ClearObjectStoreListener final : public NativeEventListener {
public:
static ClearObjectStoreListener* Create(
std::unique_ptr<ClearObjectStoreCallback> request_callback) {
return MakeGarbageCollected<ClearObjectStoreListener>(
std::move(request_callback));
}
ClearObjectStoreListener(
std::unique_ptr<ClearObjectStoreCallback> request_callback)
: request_callback_(std::move(request_callback)) {}
~ClearObjectStoreListener() override = default;
void Invoke(ExecutionContext*, Event* event) override {
if (event->type() != event_type_names::kComplete) {
request_callback_->sendFailure(Response::Error("Unexpected event type."));
return;
}
request_callback_->sendSuccess();
}
private:
std::unique_ptr<ClearObjectStoreCallback> request_callback_;
};
class ClearObjectStore final
: public ExecutableWithDatabase<ClearObjectStoreCallback> {
public:
static scoped_refptr<ClearObjectStore> Create(
const String& object_store_name,
std::unique_ptr<ClearObjectStoreCallback> request_callback) {
return base::AdoptRef(
new ClearObjectStore(object_store_name, std::move(request_callback)));
}
ClearObjectStore(const String& object_store_name,
std::unique_ptr<ClearObjectStoreCallback> request_callback)
: object_store_name_(object_store_name),
request_callback_(std::move(request_callback)) {}
void Execute(IDBDatabase* idb_database, ScriptState* script_state) override {
IDBTransaction* idb_transaction =
TransactionForDatabase(script_state, idb_database, object_store_name_,
indexed_db_names::kReadwrite);
if (!idb_transaction) {
request_callback_->sendFailure(
Response::Error("Could not get transaction"));
return;
}
IDBObjectStore* idb_object_store =
ObjectStoreForTransaction(idb_transaction, object_store_name_);
if (!idb_object_store) {
request_callback_->sendFailure(
Response::Error("Could not get object store"));
return;
}
DummyExceptionStateForTesting exception_state;
idb_object_store->clear(script_state, exception_state);
DCHECK(!exception_state.HadException());
if (exception_state.HadException()) {
ExceptionCode ec = exception_state.Code();
request_callback_->sendFailure(Response::Error(
String::Format("Could not clear object store '%s': %d",
object_store_name_.Utf8().data(), ec)));
return;
}
idb_transaction->addEventListener(
event_type_names::kComplete,
ClearObjectStoreListener::Create(std::move(request_callback_)), false);
}
ClearObjectStoreCallback* GetRequestCallback() override {
return request_callback_.get();
}
private:
const String object_store_name_;
std::unique_ptr<ClearObjectStoreCallback> request_callback_;
};
void InspectorIndexedDBAgent::clearObjectStore(
const String& security_origin,
const String& database_name,
const String& object_store_name,
std::unique_ptr<ClearObjectStoreCallback> request_callback) {
scoped_refptr<ClearObjectStore> clear_object_store =
ClearObjectStore::Create(object_store_name, std::move(request_callback));
clear_object_store->Start(
inspected_frames_->FrameWithSecurityOrigin(security_origin),
database_name);
}
void InspectorIndexedDBAgent::deleteDatabase(
const String& security_origin,
const String& database_name,
std::unique_ptr<DeleteDatabaseCallback> request_callback) {
LocalFrame* frame =
inspected_frames_->FrameWithSecurityOrigin(security_origin);
Document* document = frame ? frame->GetDocument() : nullptr;
if (!document) {
request_callback->sendFailure(Response::Error(kNoDocumentError));
return;
}
IDBFactory* idb_factory = nullptr;
Response response = AssertIDBFactory(document, idb_factory);
if (!response.isSuccess()) {
request_callback->sendFailure(response);
return;
}
ScriptState* script_state = ToScriptStateForMainWorld(frame);
if (!script_state) {
request_callback->sendFailure(Response::InternalError());
return;
}
ScriptState::Scope scope(script_state);
DummyExceptionStateForTesting exception_state;
IDBRequest* idb_request = idb_factory->CloseConnectionsAndDeleteDatabase(
script_state, database_name, exception_state);
if (exception_state.HadException()) {
request_callback->sendFailure(
Response::Error("Could not delete database."));
return;
}
idb_request->addEventListener(
event_type_names::kSuccess,
DeleteCallback::Create(std::move(request_callback),
document->GetSecurityOrigin()->ToRawString()),
false);
}
void InspectorIndexedDBAgent::Trace(blink::Visitor* visitor) {
visitor->Trace(inspected_frames_);
InspectorBaseAgent::Trace(visitor);
}
} // namespace blink