diff options
Diffstat (limited to 'Source/WebKit2/UIProcess/Plugins')
11 files changed, 586 insertions, 23 deletions
diff --git a/Source/WebKit2/UIProcess/Plugins/PluginInfoStore.cpp b/Source/WebKit2/UIProcess/Plugins/PluginInfoStore.cpp index b3d9183..0787347 100644 --- a/Source/WebKit2/UIProcess/Plugins/PluginInfoStore.cpp +++ b/Source/WebKit2/UIProcess/Plugins/PluginInfoStore.cpp @@ -115,6 +115,21 @@ void PluginInfoStore::getPlugins(Vector<PluginInfo>& plugins) plugins.append(m_plugins[i].info); } +void PluginInfoStore::getPluginPaths(Vector<String>& pluginPaths) +{ + loadPluginsIfNecessary(); + + for (size_t i = 0; i < m_plugins.size(); ++i) + pluginPaths.append(m_plugins[i].path); +} + +const Vector<PluginInfoStore::Plugin>& PluginInfoStore::plugins() +{ + loadPluginsIfNecessary(); + + return m_plugins; +} + PluginInfoStore::Plugin PluginInfoStore::findPluginForMIMEType(const String& mimeType) { ASSERT(!mimeType.isNull()); diff --git a/Source/WebKit2/UIProcess/Plugins/PluginInfoStore.h b/Source/WebKit2/UIProcess/Plugins/PluginInfoStore.h index b342203..fc49d96 100644 --- a/Source/WebKit2/UIProcess/Plugins/PluginInfoStore.h +++ b/Source/WebKit2/UIProcess/Plugins/PluginInfoStore.h @@ -41,8 +41,9 @@ public: void setAdditionalPluginsDirectories(const Vector<String>&); void refresh(); - void getPlugins(Vector<WebCore::PluginInfo>& plugins); - + void getPlugins(Vector<WebCore::PluginInfo>&); + void getPluginPaths(Vector<String>&); + // Represents a single plug-in. struct Plugin { String path; @@ -56,6 +57,8 @@ public: #endif }; + const Vector<Plugin>& plugins(); + // Returns the info for a plug-in that can handle the given MIME type. // If the MIME type is null, the file extension of the given url will be used to infer the // plug-in type. In that case, mimeType will be filled in with the right MIME type. diff --git a/Source/WebKit2/UIProcess/Plugins/PluginProcessManager.cpp b/Source/WebKit2/UIProcess/Plugins/PluginProcessManager.cpp index bca9689..c0aa8b3 100644 --- a/Source/WebKit2/UIProcess/Plugins/PluginProcessManager.cpp +++ b/Source/WebKit2/UIProcess/Plugins/PluginProcessManager.cpp @@ -28,7 +28,6 @@ #if ENABLE(PLUGIN_PROCESS) -#include "PluginInfoStore.h" #include "PluginProcessProxy.h" #include "WebContext.h" #include <wtf/StdLibExtras.h> @@ -51,20 +50,7 @@ void PluginProcessManager::getPluginProcessConnection(const String& pluginPath, ASSERT(!pluginPath.isNull()); PluginInfoStore::Plugin plugin = webProcessProxy->context()->pluginInfoStore()->infoForPluginWithPath(pluginPath); - - PluginProcessProxy* pluginProcess = 0; - - for (size_t i = 0; i < m_pluginProcesses.size(); ++i) { - if (m_pluginProcesses[i]->pluginInfo().path == plugin.path) { - pluginProcess = m_pluginProcesses[i]; - break; - } - } - - if (!pluginProcess) { - pluginProcess = PluginProcessProxy::create(this, plugin).leakPtr(); - m_pluginProcesses.append(pluginProcess); - } + PluginProcessProxy* pluginProcess = getOrCreatePluginProcess(plugin); pluginProcess->createWebProcessConnection(webProcessProxy, reply); } @@ -77,6 +63,31 @@ void PluginProcessManager::removePluginProcessProxy(PluginProcessProxy* pluginPr m_pluginProcesses.remove(vectorIndex); } +void PluginProcessManager::getSitesWithData(const PluginInfoStore::Plugin& plugin, WebPluginSiteDataManager* webPluginSiteDataManager, uint64_t callbackID) +{ + PluginProcessProxy* pluginProcess = getOrCreatePluginProcess(plugin); + pluginProcess->getSitesWithData(webPluginSiteDataManager, callbackID); +} + +void PluginProcessManager::clearSiteData(const PluginInfoStore::Plugin& plugin, WebPluginSiteDataManager* webPluginSiteDataManager, const Vector<String>& sites, uint64_t flags, uint64_t maxAgeInSeconds, uint64_t callbackID) +{ + PluginProcessProxy* pluginProcess = getOrCreatePluginProcess(plugin); + pluginProcess->clearSiteData(webPluginSiteDataManager, sites, flags, maxAgeInSeconds, callbackID); +} + +PluginProcessProxy* PluginProcessManager::getOrCreatePluginProcess(const PluginInfoStore::Plugin& plugin) +{ + for (size_t i = 0; i < m_pluginProcesses.size(); ++i) { + if (m_pluginProcesses[i]->pluginInfo().path == plugin.path) + return m_pluginProcesses[i]; + } + + PluginProcessProxy* pluginProcess = PluginProcessProxy::create(this, plugin).leakPtr(); + m_pluginProcesses.append(pluginProcess); + + return pluginProcess; +} + } // namespace WebKit #endif // ENABLE(PLUGIN_PROCESS) diff --git a/Source/WebKit2/UIProcess/Plugins/PluginProcessManager.h b/Source/WebKit2/UIProcess/Plugins/PluginProcessManager.h index a150d67..79e5952 100644 --- a/Source/WebKit2/UIProcess/Plugins/PluginProcessManager.h +++ b/Source/WebKit2/UIProcess/Plugins/PluginProcessManager.h @@ -28,6 +28,7 @@ #if ENABLE(PLUGIN_PROCESS) +#include "PluginInfoStore.h" #include <wtf/Forward.h> #include <wtf/Noncopyable.h> #include <wtf/Vector.h> @@ -40,6 +41,7 @@ namespace WebKit { class PluginProcessProxy; class WebProcessProxy; +class WebPluginSiteDataManager; class PluginProcessManager { WTF_MAKE_NONCOPYABLE(PluginProcessManager); @@ -49,9 +51,14 @@ public: void getPluginProcessConnection(const String& pluginPath, WebProcessProxy*, CoreIPC::ArgumentEncoder* reply); void removePluginProcessProxy(PluginProcessProxy*); + void getSitesWithData(const PluginInfoStore::Plugin&, WebPluginSiteDataManager*, uint64_t callbackID); + void clearSiteData(const PluginInfoStore::Plugin&, WebPluginSiteDataManager*, const Vector<String>& sites, uint64_t flags, uint64_t maxAgeInSeconds, uint64_t callbackID); + private: PluginProcessManager(); + PluginProcessProxy* getOrCreatePluginProcess(const PluginInfoStore::Plugin&); + Vector<PluginProcessProxy*> m_pluginProcesses; }; diff --git a/Source/WebKit2/UIProcess/Plugins/PluginProcessProxy.cpp b/Source/WebKit2/UIProcess/Plugins/PluginProcessProxy.cpp index 4b3b3c0..c63d500 100644 --- a/Source/WebKit2/UIProcess/Plugins/PluginProcessProxy.cpp +++ b/Source/WebKit2/UIProcess/Plugins/PluginProcessProxy.cpp @@ -34,9 +34,20 @@ #include "PluginProcessMessages.h" #include "RunLoop.h" #include "WebCoreArgumentCoders.h" +#include "WebPluginSiteDataManager.h" #include "WebProcessProxy.h" namespace WebKit { + +#if PLATFORM(MAC) +static bool pluginNeedsExecutableHeap(const PluginInfoStore::Plugin& pluginInfo) +{ + if (pluginInfo.bundleIdentifier == "com.apple.QuickTime Plugin.plugin") + return false; + + return true; +} +#endif PassOwnPtr<PluginProcessProxy> PluginProcessProxy::create(PluginProcessManager* PluginProcessManager, const PluginInfoStore::Plugin& pluginInfo) { @@ -52,9 +63,7 @@ PluginProcessProxy::PluginProcessProxy(PluginProcessManager* PluginProcessManage launchOptions.processType = ProcessLauncher::PluginProcess; #if PLATFORM(MAC) launchOptions.architecture = pluginInfo.pluginArchitecture; - - // FIXME: This shouldn't be true for all plug-ins. - launchOptions.executableHeap = true; + launchOptions.executableHeap = pluginNeedsExecutableHeap(pluginInfo); #endif m_processLauncher = ProcessLauncher::create(this, launchOptions); @@ -80,6 +89,39 @@ void PluginProcessProxy::createWebProcessConnection(WebProcessProxy* webProcessP m_connection->send(Messages::PluginProcess::CreateWebProcessConnection(), 0, CoreIPC::DispatchMessageEvenWhenWaitingForSyncReply); } +void PluginProcessProxy::getSitesWithData(WebPluginSiteDataManager* webPluginSiteDataManager, uint64_t callbackID) +{ + ASSERT(!m_pendingGetSitesReplies.contains(callbackID)); + m_pendingGetSitesReplies.set(callbackID, webPluginSiteDataManager); + + if (m_processLauncher->isLaunching()) { + m_pendingGetSitesRequests.append(callbackID); + return; + } + + // Ask the plug-in process for the sites with data. + m_connection->send(Messages::PluginProcess::GetSitesWithData(callbackID), 0); +} + +void PluginProcessProxy::clearSiteData(WebPluginSiteDataManager* webPluginSiteDataManager, const Vector<String>& sites, uint64_t flags, uint64_t maxAgeInSeconds, uint64_t callbackID) +{ + ASSERT(!m_pendingClearSiteDataReplies.contains(callbackID)); + m_pendingClearSiteDataReplies.set(callbackID, webPluginSiteDataManager); + + if (m_processLauncher->isLaunching()) { + ClearSiteDataRequest request; + request.sites = sites; + request.flags = flags; + request.maxAgeInSeconds = maxAgeInSeconds; + request.callbackID = callbackID; + m_pendingClearSiteDataRequests.append(request); + return; + } + + // Ask the plug-in process to clear the site data. + m_connection->send(Messages::PluginProcess::ClearSiteData(sites, flags, maxAgeInSeconds, callbackID), 0); +} + void PluginProcessProxy::pluginProcessCrashedOrFailedToLaunch() { // The plug-in process must have crashed or exited, send any pending sync replies we might have. @@ -93,6 +135,12 @@ void PluginProcessProxy::pluginProcessCrashedOrFailedToLaunch() replyWebProcessProxy->connection()->sendSyncReply(reply); } + while (!m_pendingGetSitesReplies.isEmpty()) + didGetSitesWithData(Vector<String>(), m_pendingGetSitesReplies.begin()->first); + + while (!m_pendingClearSiteDataReplies.isEmpty()) + didClearSiteData(m_pendingClearSiteDataReplies.begin()->first); + // Tell the plug-in process manager to forget about this plug-in process proxy. m_pluginProcessManager->removePluginProcessProxy(this); delete this; @@ -134,6 +182,16 @@ void PluginProcessProxy::didFinishLaunching(ProcessLauncher*, CoreIPC::Connectio m_connection->send(Messages::PluginProcess::InitializePluginProcess(parameters), 0); // Send all our pending requests. + for (size_t i = 0; i < m_pendingGetSitesRequests.size(); ++i) + m_connection->send(Messages::PluginProcess::GetSitesWithData(m_pendingGetSitesRequests[i]), 0); + m_pendingGetSitesRequests.clear(); + + for (size_t i = 0; i < m_pendingClearSiteDataRequests.size(); ++i) { + const ClearSiteDataRequest& request = m_pendingClearSiteDataRequests[i]; + m_connection->send(Messages::PluginProcess::ClearSiteData(request.sites, request.flags, request.maxAgeInSeconds, request.callbackID), 0); + } + m_pendingClearSiteDataRequests.clear(); + for (unsigned i = 0; i < m_numPendingConnectionRequests; ++i) m_connection->send(Messages::PluginProcess::CreateWebProcessConnection(), 0); @@ -154,6 +212,22 @@ void PluginProcessProxy::didCreateWebProcessConnection(const CoreIPC::MachPort& replyWebProcessProxy->connection()->sendSyncReply(reply); } +void PluginProcessProxy::didGetSitesWithData(const Vector<String>& sites, uint64_t callbackID) +{ + RefPtr<WebPluginSiteDataManager> webPluginSiteDataManager = m_pendingGetSitesReplies.take(callbackID); + ASSERT(webPluginSiteDataManager); + + webPluginSiteDataManager->didGetSitesWithDataForSinglePlugin(sites, callbackID); +} + +void PluginProcessProxy::didClearSiteData(uint64_t callbackID) +{ + RefPtr<WebPluginSiteDataManager> webPluginSiteDataManager = m_pendingClearSiteDataReplies.take(callbackID); + ASSERT(webPluginSiteDataManager); + + webPluginSiteDataManager->didClearSiteDataForSinglePlugin(callbackID); +} + } // namespace WebKit #endif // ENABLE(PLUGIN_PROCESS) diff --git a/Source/WebKit2/UIProcess/Plugins/PluginProcessProxy.h b/Source/WebKit2/UIProcess/Plugins/PluginProcessProxy.h index 23a6df0..2ea2573 100644 --- a/Source/WebKit2/UIProcess/Plugins/PluginProcessProxy.h +++ b/Source/WebKit2/UIProcess/Plugins/PluginProcessProxy.h @@ -41,6 +41,7 @@ namespace CoreIPC { namespace WebKit { class PluginProcessManager; +class WebPluginSiteDataManager; class WebProcessProxy; struct PluginProcessCreationParameters; @@ -54,7 +55,13 @@ public: // Asks the plug-in process to create a new connection to a web process. The connection identifier will be // encoded in the given argument encoder and sent back to the connection of the given web process. void createWebProcessConnection(WebProcessProxy*, CoreIPC::ArgumentEncoder* reply); - + + // Asks the plug-in process to get a list of domains for which the plug-in has data stored. + void getSitesWithData(WebPluginSiteDataManager*, uint64_t callbackID); + + // Asks the plug-in process to clear the data for the given sites. + void clearSiteData(WebPluginSiteDataManager*, const Vector<String>& sites, uint64_t flags, uint64_t maxAgeInSeconds, uint64_t callbackID); + private: PluginProcessProxy(PluginProcessManager*, const PluginInfoStore::Plugin&); @@ -71,6 +78,8 @@ private: // Message handlers void didReceivePluginProcessProxyMessage(CoreIPC::Connection*, CoreIPC::MessageID, CoreIPC::ArgumentDecoder*); void didCreateWebProcessConnection(const CoreIPC::MachPort&); + void didGetSitesWithData(const Vector<String>& sites, uint64_t callbackID); + void didClearSiteData(uint64_t callbackID); void platformInitializePluginProcess(PluginProcessCreationParameters& parameters); @@ -88,10 +97,21 @@ private: Deque<std::pair<RefPtr<WebProcessProxy>, CoreIPC::ArgumentEncoder*> > m_pendingConnectionReplies; + Vector<uint64_t> m_pendingGetSitesRequests; + HashMap<uint64_t, RefPtr<WebPluginSiteDataManager> > m_pendingGetSitesReplies; + + struct ClearSiteDataRequest { + Vector<String> sites; + uint64_t flags; + uint64_t maxAgeInSeconds; + uint64_t callbackID; + }; + Vector<ClearSiteDataRequest> m_pendingClearSiteDataRequests; + HashMap<uint64_t, RefPtr<WebPluginSiteDataManager> > m_pendingClearSiteDataReplies; + // If createPluginConnection is called while the process is still launching we'll keep count of it and send a bunch of requests // when the process finishes launching. unsigned m_numPendingConnectionRequests; - }; } // namespace WebKit diff --git a/Source/WebKit2/UIProcess/Plugins/PluginProcessProxy.messages.in b/Source/WebKit2/UIProcess/Plugins/PluginProcessProxy.messages.in index cbd5abc..a504f9a 100644 --- a/Source/WebKit2/UIProcess/Plugins/PluginProcessProxy.messages.in +++ b/Source/WebKit2/UIProcess/Plugins/PluginProcessProxy.messages.in @@ -25,6 +25,9 @@ messages -> PluginProcessProxy { # FIXME: This is platform specific DidCreateWebProcessConnection(CoreIPC::MachPort connectionIdentifier) + + DidGetSitesWithData(Vector<WTF::String> sites, uint64_t callbackID) + DidClearSiteData(uint64_t callbackID) } #endif diff --git a/Source/WebKit2/UIProcess/Plugins/WebPluginSiteDataManager.cpp b/Source/WebKit2/UIProcess/Plugins/WebPluginSiteDataManager.cpp new file mode 100644 index 0000000..dfa0806 --- /dev/null +++ b/Source/WebKit2/UIProcess/Plugins/WebPluginSiteDataManager.cpp @@ -0,0 +1,299 @@ +/* + * Copyright (C) 2011 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: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. 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. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS 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 APPLE INC. OR ITS 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 "WebPluginSiteDataManager.h" + +#include "ImmutableArray.h" +#include "PluginProcessManager.h" +#include "WebContext.h" +#include "WebProcessMessages.h" + +using namespace WebCore; + +namespace WebKit { + +#if ENABLE(PLUGIN_PROCESS) +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<PluginInfoStore::Plugin> 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<PluginInfoStore::Plugin> m_plugins; +}; +#endif // ENABLE(PLUGIN_PROCESS) + +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()); +#if ENABLE(PLUGIN_PROCESS) + ASSERT(m_pendingGetSitesWithData.isEmpty()); + ASSERT(m_pendingClearSiteData.isEmpty()); +#endif +} + +void WebPluginSiteDataManager::invalidate() +{ + invalidateCallbackMap(m_arrayCallbacks); + +#if ENABLE(PLUGIN_PROCESS) + deleteAllValues(m_pendingGetSitesWithData); + m_pendingGetSitesWithData.clear(); + deleteAllValues(m_pendingClearSiteData); + m_pendingClearSiteData.clear(); +#endif +} + +void WebPluginSiteDataManager::getSitesWithData(PassRefPtr<ArrayCallback> prpCallback) +{ + RefPtr<ArrayCallback> callback = prpCallback; + + if (!m_webContext) { + callback->invalidate(); + return; + } + + uint64_t callbackID = callback->callbackID(); + m_arrayCallbacks.set(callbackID, callback.release()); + +#if ENABLE(PLUGIN_PROCESS) + ASSERT(!m_pendingGetSitesWithData.contains(callbackID)); + + GetSitesWithDataState* state = new GetSitesWithDataState(this, callbackID); + m_pendingGetSitesWithData.set(callbackID, state); + state->getSitesWithDataForNextPlugin(); +#else + if (!m_webContext->hasValidProcess()) { + RefPtr<ArrayCallback> callback = m_arrayCallbacks.take(callbackID); + callback->invalidate(); + return; + } + + Vector<String> pluginPaths; + m_webContext->pluginInfoStore()->getPluginPaths(pluginPaths); + m_webContext->ensureWebProcess(); + m_webContext->process()->send(Messages::WebProcess::GetSitesWithPluginData(pluginPaths, callbackID), 0); +#endif +} + +void WebPluginSiteDataManager::didGetSitesWithData(const Vector<String>& sites, uint64_t callbackID) +{ + RefPtr<ArrayCallback> callback = m_arrayCallbacks.take(callbackID); + if (!callback) { + // FIXME: Log error or assert. + return; + } + + Vector<RefPtr<APIObject> > sitesWK(sites.size()); + + for (size_t i = 0; i < sites.size(); ++i) + sitesWK[i] = WebString::create(sites[i]); + + RefPtr<ImmutableArray> resultArray = ImmutableArray::adopt(sitesWK); + callback->performCallbackWithReturnValue(resultArray.get()); +} + +void WebPluginSiteDataManager::clearSiteData(ImmutableArray* sites, uint64_t flags, uint64_t maxAgeInSeconds, PassRefPtr<VoidCallback> prpCallback) +{ + RefPtr<VoidCallback> callback = prpCallback; + if (!m_webContext) { + callback->invalidate(); + return; + } + + Vector<String> sitesVector; + + // If the array is empty, don't do anything. + if (sites) { + if (!sites->size()) { + callback->performCallback(); + return; + } + + for (size_t i = 0; i < sites->size(); ++i) { + if (WebString* site = sites->at<WebString>(i)) + sitesVector.append(site->string()); + } + } + + uint64_t callbackID = callback->callbackID(); + m_voidCallbacks.set(callbackID, callback.release()); + +#if ENABLE(PLUGIN_PROCESS) + ASSERT(!m_pendingClearSiteData.contains(callbackID)); + + ClearSiteDataState* state = new ClearSiteDataState(this, sitesVector, flags, maxAgeInSeconds, callbackID); + m_pendingClearSiteData.set(callbackID, state); + state->clearSiteDataForNextPlugin(); +#else + + if (!m_webContext->hasValidProcess()) { + RefPtr<VoidCallback> callback = m_voidCallbacks.take(callbackID); + callback->invalidate(); + return; + } + Vector<String> pluginPaths; + m_webContext->pluginInfoStore()->getPluginPaths(pluginPaths); + m_webContext->ensureWebProcess(); + m_webContext->process()->send(Messages::WebProcess::ClearPluginSiteData(pluginPaths, sitesVector, flags, maxAgeInSeconds, callbackID), 0); +#endif +} + +void WebPluginSiteDataManager::didClearSiteData(uint64_t callbackID) +{ + RefPtr<VoidCallback> callback = m_voidCallbacks.take(callbackID); + if (!callback) { + // FIXME: Log error or assert. + return; + } + + callback->performCallback(); +} + +bool WebPluginSiteDataManager::shouldTerminate(WebProcessProxy*) const +{ +#if ENABLE(PLUGIN_PROCESS) + // When out of process plug-ins are enabled, the web process is not involved in fetching site data. + return true; +#else + return m_arrayCallbacks.isEmpty() && m_voidCallbacks.isEmpty(); +#endif +} + +#if ENABLE(PLUGIN_PROCESS) +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) +{ + OwnPtr<GetSitesWithDataState> state = adoptPtr(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) +{ + OwnPtr<ClearSiteDataState> state = adoptPtr(m_pendingClearSiteData.take(callbackID)); + ASSERT(state); + + didClearSiteData(callbackID); +} + +#endif + +} // namespace WebKit + diff --git a/Source/WebKit2/UIProcess/Plugins/WebPluginSiteDataManager.h b/Source/WebKit2/UIProcess/Plugins/WebPluginSiteDataManager.h new file mode 100644 index 0000000..9efa175 --- /dev/null +++ b/Source/WebKit2/UIProcess/Plugins/WebPluginSiteDataManager.h @@ -0,0 +1,88 @@ +/* + * Copyright (C) 2011 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: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. 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. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS 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 APPLE INC. OR ITS 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. + */ + +#ifndef WebPluginSiteDataManagerh +#define WebPluginSiteDataManager_h + +#include "APIObject.h" +#include "Arguments.h" +#include "GenericCallback.h" +#include <wtf/HashMap.h> +#include <wtf/PassRefPtr.h> + +namespace WebKit { + +class WebContext; +class WebProcessProxy; + +typedef GenericCallback<WKArrayRef> ArrayCallback; + +class WebPluginSiteDataManager : public APIObject { +public: + static const Type APIType = TypePluginSiteDataManager; + + static PassRefPtr<WebPluginSiteDataManager> create(WebContext*); + virtual ~WebPluginSiteDataManager(); + + void invalidate(); + void clearContext() { m_webContext = 0; } + + void getSitesWithData(PassRefPtr<ArrayCallback>); + void didGetSitesWithData(const Vector<String>& sites, uint64_t callbackID); + + void clearSiteData(ImmutableArray* sites, uint64_t flags, uint64_t maxAgeInSeconds, PassRefPtr<VoidCallback>); + void didClearSiteData(uint64_t callbackID); + +#if ENABLE(PLUGIN_PROCESS) + void didGetSitesWithDataForSinglePlugin(const Vector<String>& sites, uint64_t callbackID); + void didClearSiteDataForSinglePlugin(uint64_t callbackID); +#endif + + bool shouldTerminate(WebProcessProxy*) const; + +private: + explicit WebPluginSiteDataManager(WebContext*); + + virtual Type type() const { return APIType; } + + WebContext* m_webContext; + HashMap<uint64_t, RefPtr<ArrayCallback> > m_arrayCallbacks; + HashMap<uint64_t, RefPtr<VoidCallback> > m_voidCallbacks; + +#if ENABLE(PLUGIN_PROCESS) + void didGetSitesWithDataForAllPlugins(const Vector<String>& sites, uint64_t callbackID); + void didClearSiteDataForAllPlugins(uint64_t callbackID); + + class GetSitesWithDataState; + HashMap<uint64_t, GetSitesWithDataState*> m_pendingGetSitesWithData; + + class ClearSiteDataState; + HashMap<uint64_t, ClearSiteDataState*> m_pendingClearSiteData; +#endif +}; + +} // namespace WebKit + +#endif // WebPluginSiteDataManager_h diff --git a/Source/WebKit2/UIProcess/Plugins/gtk/PluginInfoStoreGtk.cpp b/Source/WebKit2/UIProcess/Plugins/gtk/PluginInfoStoreGtk.cpp index f06f0e5..2dcea2f 100644 --- a/Source/WebKit2/UIProcess/Plugins/gtk/PluginInfoStoreGtk.cpp +++ b/Source/WebKit2/UIProcess/Plugins/gtk/PluginInfoStoreGtk.cpp @@ -27,9 +27,9 @@ #include "config.h" #include "PluginInfoStore.h" -#include "NotImplemented.h" #include "PluginDatabase.h" #include "PluginPackage.h" +#include <WebCore/NotImplemented.h> using namespace WebCore; diff --git a/Source/WebKit2/UIProcess/Plugins/qt/PluginProcessProxyQt.cpp b/Source/WebKit2/UIProcess/Plugins/qt/PluginProcessProxyQt.cpp new file mode 100644 index 0000000..cc521e0 --- /dev/null +++ b/Source/WebKit2/UIProcess/Plugins/qt/PluginProcessProxyQt.cpp @@ -0,0 +1,43 @@ +/* + * Copyright (C) 2011 Nokia 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: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. 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. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS 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 APPLE INC. OR ITS 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 "PluginProcessProxy.h" + +#if ENABLE(PLUGIN_PROCESS) + +#include "PluginProcessCreationParameters.h" +#include <WebCore/NotImplemented.h> + +namespace WebKit { + +void PluginProcessProxy::platformInitializePluginProcess(PluginProcessCreationParameters& parameters) +{ + notImplemented(); +} + +} // namespace WebKit + +#endif // ENABLE(PLUGIN_PROCESS) |