WebDatabaseManagerProxy.cpp [plain text]
#include "config.h"
#include "WebDatabaseManagerProxy.h"
#if ENABLE(SQL_DATABASE)
#include "APIArray.h"
#include "ImmutableDictionary.h"
#include "WebContext.h"
#include "WebDatabaseManagerMessages.h"
#include "WebDatabaseManagerProxyMessages.h"
#include "WebSecurityOrigin.h"
#include <wtf/NeverDestroyed.h>
using namespace WebCore;
namespace WebKit {
const char* WebDatabaseManagerProxy::supplementName()
{
return "WebDatabaseManagerProxy";
}
String WebDatabaseManagerProxy::originKey()
{
static NeverDestroyed<String> key(ASCIILiteral("WebDatabaseManagerOriginKey"));
return key;
}
String WebDatabaseManagerProxy::originQuotaKey()
{
static NeverDestroyed<String> key(ASCIILiteral("WebDatabaseManagerOriginQuotaKey"));
return key;
}
String WebDatabaseManagerProxy::originUsageKey()
{
static NeverDestroyed<String> key(ASCIILiteral("WebDatabaseManagerOriginUsageKey"));
return key;
}
String WebDatabaseManagerProxy::databaseDetailsKey()
{
static NeverDestroyed<String> key(ASCIILiteral("WebDatabaseManagerDatabaseDetailsKey"));
return key;
}
String WebDatabaseManagerProxy::databaseDetailsNameKey()
{
static NeverDestroyed<String> key(ASCIILiteral("WebDatabaseManagerDatabaseDetailsNameKey"));
return key;
}
String WebDatabaseManagerProxy::databaseDetailsDisplayNameKey()
{
static NeverDestroyed<String> key(ASCIILiteral("WebDatabaseManagerDatabaseDetailsDisplayNameKey"));
return key;
}
String WebDatabaseManagerProxy::databaseDetailsExpectedUsageKey()
{
static NeverDestroyed<String> key(ASCIILiteral("WebDatabaseManagerDatabaseDetailsExpectedUsageKey"));
return key;
}
String WebDatabaseManagerProxy::databaseDetailsCurrentUsageKey()
{
static NeverDestroyed<String> key(ASCIILiteral("WebDatabaseManagerDatabaseDetailsCurrentUsageKey"));
return key;
}
String WebDatabaseManagerProxy::databaseDetailsCreationTimeKey()
{
static NeverDestroyed<String> key(ASCIILiteral("WebDatabaseManagerDatabaseDetailsCreationTimeKey"));
return key;
}
String WebDatabaseManagerProxy::databaseDetailsModificationTimeKey()
{
static NeverDestroyed<String> key(ASCIILiteral("WebDatabaseManagerDatabaseDetailsModificationTimeKey"));
return key;
}
PassRefPtr<WebDatabaseManagerProxy> WebDatabaseManagerProxy::create(WebContext* webContext)
{
return adoptRef(new WebDatabaseManagerProxy(webContext));
}
WebDatabaseManagerProxy::WebDatabaseManagerProxy(WebContext* webContext)
: WebContextSupplement(webContext)
{
WebContextSupplement::context()->addMessageReceiver(Messages::WebDatabaseManagerProxy::messageReceiverName(), *this);
}
WebDatabaseManagerProxy::~WebDatabaseManagerProxy()
{
}
void WebDatabaseManagerProxy::initializeClient(const WKDatabaseManagerClientBase* client)
{
m_client.initialize(client);
}
void WebDatabaseManagerProxy::contextDestroyed()
{
invalidateCallbackMap(m_arrayCallbacks, CallbackBase::Error::OwnerWasInvalidated);
}
void WebDatabaseManagerProxy::processDidClose(WebProcessProxy*)
{
invalidateCallbackMap(m_arrayCallbacks, CallbackBase::Error::ProcessExited);
}
bool WebDatabaseManagerProxy::shouldTerminate(WebProcessProxy*) const
{
return m_arrayCallbacks.isEmpty();
}
void WebDatabaseManagerProxy::refWebContextSupplement()
{
API::Object::ref();
}
void WebDatabaseManagerProxy::derefWebContextSupplement()
{
API::Object::deref();
}
void WebDatabaseManagerProxy::getDatabasesByOrigin(std::function<void (API::Array*, CallbackBase::Error)> callbackFunction)
{
RefPtr<ArrayCallback> callback = ArrayCallback::create(WTF::move(callbackFunction));
uint64_t callbackID = callback->callbackID();
m_arrayCallbacks.set(callbackID, callback.release());
context()->sendToOneProcess(Messages::WebDatabaseManager::GetDatabasesByOrigin(callbackID));
}
void WebDatabaseManagerProxy::didGetDatabasesByOrigin(const Vector<OriginAndDatabases>& originAndDatabasesVector, uint64_t callbackID)
{
RefPtr<ArrayCallback> callback = m_arrayCallbacks.take(callbackID);
if (!callback) {
return;
}
Vector<RefPtr<API::Object>> result;
result.reserveInitialCapacity(originAndDatabasesVector.size());
for (const auto& originAndDatabases : originAndDatabasesVector) {
RefPtr<API::Object> origin = WebSecurityOrigin::create(SecurityOrigin::createFromDatabaseIdentifier(originAndDatabases.originIdentifier));
Vector<RefPtr<API::Object>> databases;
databases.reserveInitialCapacity(originAndDatabases.databases.size());
for (const auto& databaseDetails : originAndDatabases.databases) {
HashMap<String, RefPtr<API::Object>> detailsMap;
detailsMap.set(databaseDetailsNameKey(), API::String::create(databaseDetails.name()));
detailsMap.set(databaseDetailsDisplayNameKey(), API::String::create(databaseDetails.displayName()));
detailsMap.set(databaseDetailsExpectedUsageKey(), API::UInt64::create(databaseDetails.expectedUsage()));
detailsMap.set(databaseDetailsCurrentUsageKey(), API::UInt64::create(databaseDetails.currentUsage()));
if (databaseDetails.creationTime())
detailsMap.set(databaseDetailsCreationTimeKey(), API::Double::create(databaseDetails.creationTime()));
if (databaseDetails.modificationTime())
detailsMap.set(databaseDetailsModificationTimeKey(), API::Double::create(databaseDetails.modificationTime()));
databases.uncheckedAppend(ImmutableDictionary::create(WTF::move(detailsMap)));
}
HashMap<String, RefPtr<API::Object>> originAndDatabasesMap;
originAndDatabasesMap.set(originKey(), origin);
originAndDatabasesMap.set(originQuotaKey(), API::UInt64::create(originAndDatabases.originQuota));
originAndDatabasesMap.set(originUsageKey(), API::UInt64::create(originAndDatabases.originUsage));
originAndDatabasesMap.set(databaseDetailsKey(), API::Array::create(WTF::move(databases)));
result.uncheckedAppend(ImmutableDictionary::create(WTF::move(originAndDatabasesMap)));
}
callback->performCallbackWithReturnValue(API::Array::create(WTF::move(result)).get());
}
void WebDatabaseManagerProxy::getDatabaseOrigins(std::function<void (API::Array*, CallbackBase::Error)> callbackFunction)
{
RefPtr<ArrayCallback> callback = ArrayCallback::create(WTF::move(callbackFunction));
uint64_t callbackID = callback->callbackID();
m_arrayCallbacks.set(callbackID, callback.release());
context()->sendToOneProcess(Messages::WebDatabaseManager::GetDatabaseOrigins(callbackID));
}
void WebDatabaseManagerProxy::didGetDatabaseOrigins(const Vector<String>& originIdentifiers, uint64_t callbackID)
{
RefPtr<ArrayCallback> callback = m_arrayCallbacks.take(callbackID);
if (!callback) {
return;
}
Vector<RefPtr<API::Object>> securityOrigins;
securityOrigins.reserveInitialCapacity(originIdentifiers.size());
for (const auto& originIdentifier : originIdentifiers)
securityOrigins.uncheckedAppend(WebSecurityOrigin::create(SecurityOrigin::createFromDatabaseIdentifier(originIdentifier)));
callback->performCallbackWithReturnValue(API::Array::create(WTF::move(securityOrigins)).get());
}
void WebDatabaseManagerProxy::deleteDatabaseWithNameForOrigin(const String& databaseIdentifier, WebSecurityOrigin* origin)
{
context()->sendToOneProcess(Messages::WebDatabaseManager::DeleteDatabaseWithNameForOrigin(databaseIdentifier, origin->securityOrigin().databaseIdentifier()));
}
void WebDatabaseManagerProxy::deleteDatabasesForOrigin(WebSecurityOrigin* origin)
{
context()->sendToOneProcess(Messages::WebDatabaseManager::DeleteDatabasesForOrigin(origin->securityOrigin().databaseIdentifier()));
}
void WebDatabaseManagerProxy::deleteAllDatabases()
{
context()->sendToOneProcess(Messages::WebDatabaseManager::DeleteAllDatabases());
}
void WebDatabaseManagerProxy::setQuotaForOrigin(WebSecurityOrigin* origin, uint64_t quota)
{
context()->sendToOneProcess(Messages::WebDatabaseManager::SetQuotaForOrigin(origin->securityOrigin().databaseIdentifier(), quota));
}
void WebDatabaseManagerProxy::didModifyOrigin(const String& originIdentifier)
{
RefPtr<WebSecurityOrigin> origin = WebSecurityOrigin::create(SecurityOrigin::createFromDatabaseIdentifier(originIdentifier));
m_client.didModifyOrigin(this, origin.get());
}
void WebDatabaseManagerProxy::didModifyDatabase(const String& originIdentifier, const String& databaseIdentifier)
{
RefPtr<WebSecurityOrigin> origin = WebSecurityOrigin::create(SecurityOrigin::createFromDatabaseIdentifier(originIdentifier));
m_client.didModifyDatabase(this, origin.get(), databaseIdentifier);
}
}
#endif // ENABLE(SQL_DATABASE)