WebPluginSiteDataManager.cpp [plain text]
#include "config.h"
#include "WebPluginSiteDataManager.h"
#if ENABLE(NETSCAPE_PLUGIN_API)
#include "APIArray.h"
#include "PluginProcessManager.h"
#include "WebContext.h"
#include "WebProcessMessages.h"
using namespace WebCore;
namespace WebKit {
class WebPluginSiteDataManager::GetSitesWithDataState {
public:
explicit GetSitesWithDataState(WebPluginSiteDataManager* webPluginSiteDataManager, uint64_t callbackID)
: m_webPluginSiteDataManager(webPluginSiteDataManager)
, m_callbackID(callbackID)
, m_plugins(webPluginSiteDataManager->m_webContext->pluginInfoStore().plugins())
{
}
void getSitesWithDataForNextPlugin()
{
if (m_plugins.isEmpty()) {
Vector<String> sites;
copyToVector(m_sites, sites);
m_webPluginSiteDataManager->didGetSitesWithDataForAllPlugins(sites, m_callbackID);
return;
}
PluginProcessManager::shared().getSitesWithData(m_plugins.last(), m_webPluginSiteDataManager, m_callbackID);
m_plugins.removeLast();
}
void didGetSitesWithDataForSinglePlugin(const Vector<String>& sites)
{
for (size_t i = 0; i < sites.size(); ++i)
m_sites.add(sites[i]);
getSitesWithDataForNextPlugin();
}
private:
WebPluginSiteDataManager* m_webPluginSiteDataManager;
uint64_t m_callbackID;
Vector<PluginModuleInfo> m_plugins;
HashSet<String> m_sites;
};
class WebPluginSiteDataManager::ClearSiteDataState {
public:
explicit ClearSiteDataState(WebPluginSiteDataManager* webPluginSiteDataManager, const Vector<String>& sites, uint64_t flags, uint64_t maxAgeInSeconds, uint64_t callbackID)
: m_webPluginSiteDataManager(webPluginSiteDataManager)
, m_sites(sites)
, m_flags(flags)
, m_maxAgeInSeconds(maxAgeInSeconds)
, m_callbackID(callbackID)
, m_plugins(webPluginSiteDataManager->m_webContext->pluginInfoStore().plugins())
{
}
void clearSiteDataForNextPlugin()
{
if (m_plugins.isEmpty()) {
m_webPluginSiteDataManager->didClearSiteDataForAllPlugins(m_callbackID);
return;
}
PluginProcessManager::shared().clearSiteData(m_plugins.last(), m_webPluginSiteDataManager, m_sites, m_flags, m_maxAgeInSeconds, m_callbackID);
m_plugins.removeLast();
}
void didClearSiteDataForSinglePlugin()
{
clearSiteDataForNextPlugin();
}
private:
WebPluginSiteDataManager* m_webPluginSiteDataManager;
Vector<String> m_sites;
uint64_t m_flags;
uint64_t m_maxAgeInSeconds;
uint64_t m_callbackID;
Vector<PluginModuleInfo> m_plugins;
};
PassRefPtr<WebPluginSiteDataManager> WebPluginSiteDataManager::create(WebContext* webContext)
{
return adoptRef(new WebPluginSiteDataManager(webContext));
}
WebPluginSiteDataManager::WebPluginSiteDataManager(WebContext* webContext)
: m_webContext(webContext)
{
}
WebPluginSiteDataManager::~WebPluginSiteDataManager()
{
ASSERT(m_arrayCallbacks.isEmpty());
ASSERT(m_voidCallbacks.isEmpty());
ASSERT(m_pendingGetSitesWithData.isEmpty());
ASSERT(m_pendingClearSiteData.isEmpty());
}
void WebPluginSiteDataManager::invalidate()
{
invalidateCallbackMap(m_arrayCallbacks, CallbackBase::Error::OwnerWasInvalidated);
m_pendingGetSitesWithData.clear();
m_pendingClearSiteData.clear();
}
void WebPluginSiteDataManager::getSitesWithData(std::function<void (API::Array*, CallbackBase::Error)> callbackFunction)
{
RefPtr<ArrayCallback> callback = ArrayCallback::create(WTF::move(callbackFunction));
if (!m_webContext) {
callback->invalidate();
return;
}
uint64_t callbackID = callback->callbackID();
m_arrayCallbacks.set(callbackID, callback.release());
ASSERT(!m_pendingGetSitesWithData.contains(callbackID));
GetSitesWithDataState* state = new GetSitesWithDataState(this, callbackID);
m_pendingGetSitesWithData.set(callbackID, std::unique_ptr<GetSitesWithDataState>(state));
state->getSitesWithDataForNextPlugin();
}
void WebPluginSiteDataManager::didGetSitesWithData(const Vector<String>& sites, uint64_t callbackID)
{
RefPtr<ArrayCallback> callback = m_arrayCallbacks.take(callbackID);
if (!callback) {
return;
}
callback->performCallbackWithReturnValue(API::Array::createStringArray(sites).get());
}
void WebPluginSiteDataManager::clearSiteData(API::Array* sites, uint64_t flags, uint64_t maxAgeInSeconds, std::function<void (CallbackBase::Error)> callbackFunction)
{
RefPtr<VoidCallback> callback = VoidCallback::create(WTF::move(callbackFunction));
if (!m_webContext) {
callback->invalidate(CallbackBase::Error::OwnerWasInvalidated);
return;
}
Vector<String> sitesVector;
if (sites) {
if (!sites->size()) {
callback->performCallback();
return;
}
for (size_t i = 0; i < sites->size(); ++i) {
if (API::String* site = sites->at<API::String>(i))
sitesVector.append(site->string());
}
}
uint64_t callbackID = callback->callbackID();
m_voidCallbacks.set(callbackID, callback.release());
ASSERT(!m_pendingClearSiteData.contains(callbackID));
ClearSiteDataState* state = new ClearSiteDataState(this, sitesVector, flags, maxAgeInSeconds, callbackID);
m_pendingClearSiteData.set(callbackID, std::unique_ptr<ClearSiteDataState>(state));
state->clearSiteDataForNextPlugin();
}
void WebPluginSiteDataManager::didClearSiteData(uint64_t callbackID)
{
RefPtr<VoidCallback> callback = m_voidCallbacks.take(callbackID);
if (!callback) {
return;
}
callback->performCallback();
}
void WebPluginSiteDataManager::didGetSitesWithDataForSinglePlugin(const Vector<String>& sites, uint64_t callbackID)
{
GetSitesWithDataState* state = m_pendingGetSitesWithData.get(callbackID);
ASSERT(state);
state->didGetSitesWithDataForSinglePlugin(sites);
}
void WebPluginSiteDataManager::didGetSitesWithDataForAllPlugins(const Vector<String>& sites, uint64_t callbackID)
{
std::unique_ptr<GetSitesWithDataState> state = m_pendingGetSitesWithData.take(callbackID);
ASSERT(state);
didGetSitesWithData(sites, callbackID);
}
void WebPluginSiteDataManager::didClearSiteDataForSinglePlugin(uint64_t callbackID)
{
ClearSiteDataState* state = m_pendingClearSiteData.get(callbackID);
ASSERT(state);
state->didClearSiteDataForSinglePlugin();
}
void WebPluginSiteDataManager::didClearSiteDataForAllPlugins(uint64_t callbackID)
{
std::unique_ptr<ClearSiteDataState> state = m_pendingClearSiteData.take(callbackID);
ASSERT(state);
didClearSiteData(callbackID);
}
}
#endif // ENABLE(NETSCAPE_PLUGIN_API)