/*
* Copyright (C) 2010 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 "NetscapePlugin.h"
#include "NPRuntimeObjectMap.h"
#include "NetscapePluginStream.h"
#include "PluginController.h"
#include "ShareableBitmap.h"
#include <WebCore/GraphicsContext.h>
#include <WebCore/HTTPHeaderMap.h>
#include <WebCore/IntRect.h>
#include <WebCore/KURL.h>
#include <utility>
#include <wtf/text/CString.h>
using namespace WebCore;
using namespace std;
namespace WebKit {
// The plug-in that we're currently calling NPP_New for.
static NetscapePlugin* currentNPPNewPlugin;
PassRefPtr<NetscapePlugin> NetscapePlugin::create(PassRefPtr<NetscapePluginModule> pluginModule)
{
if (!pluginModule)
return 0;
return adoptRef(new NetscapePlugin(pluginModule));
}
NetscapePlugin::NetscapePlugin(PassRefPtr<NetscapePluginModule> pluginModule)
: m_pluginController(0)
, m_nextRequestID(0)
, m_pluginModule(pluginModule)
, m_npWindow()
, m_isStarted(false)
#if PLATFORM(MAC)
, m_isWindowed(false)
#else
, m_isWindowed(true)
#endif
, m_isTransparent(false)
, m_inNPPNew(false)
, m_loadManually(false)
#if PLATFORM(MAC)
, m_drawingModel(static_cast<NPDrawingModel>(-1))
, m_eventModel(static_cast<NPEventModel>(-1))
, m_currentMouseEvent(0)
, m_pluginHasFocus(false)
, m_windowHasFocus(false)
#ifndef NP_NO_CARBON
, m_nullEventTimer(RunLoop::main(), this, &NetscapePlugin::nullEventTimerFired)
, m_npCGContext()
#endif
#elif PLUGIN_ARCHITECTURE(X11)
, m_drawable(0)
, m_pluginDisplay(0)
#endif
{
m_npp.ndata = this;
m_npp.pdata = 0;
m_pluginModule->incrementLoadCount();
}
NetscapePlugin::~NetscapePlugin()
{
ASSERT(!m_isStarted);
m_pluginModule->decrementLoadCount();
}
PassRefPtr<NetscapePlugin> NetscapePlugin::fromNPP(NPP npp)
{
if (npp)
return static_cast<NetscapePlugin*>(npp->ndata);
// FIXME: Return the current NetscapePlugin here.
ASSERT_NOT_REACHED();
return 0;
}
void NetscapePlugin::invalidate(const NPRect* invalidRect)
{
IntRect rect;
if (!invalidRect)
rect = IntRect(0, 0, m_frameRect.width(), m_frameRect.height());
else
rect = IntRect(invalidRect->left, invalidRect->top,
invalidRect->right - invalidRect->left, invalidRect->bottom - invalidRect->top);
if (platformInvalidate(rect))
return;
m_pluginController->invalidate(rect);
}
const char* NetscapePlugin::userAgent(NPP npp)
{
if (npp)
return fromNPP(npp)->userAgent();
if (currentNPPNewPlugin)
return currentNPPNewPlugin->userAgent();
return 0;
}
const char* NetscapePlugin::userAgent()
{
if (m_userAgent.isNull()) {
m_userAgent = m_pluginController->userAgent().utf8();
ASSERT(!m_userAgent.isNull());
}
return m_userAgent.data();
}
void NetscapePlugin::loadURL(const String& method, const String& urlString, const String& target, const HTTPHeaderMap& headerFields, const Vector<uint8_t>& httpBody,
bool sendNotification, void* notificationData)
{
uint64_t requestID = ++m_nextRequestID;
m_pluginController->loadURL(requestID, method, urlString, target, headerFields, httpBody, allowPopups());
if (target.isNull()) {
// The browser is going to send the data in a stream, create a plug-in stream.
RefPtr<NetscapePluginStream> pluginStream = NetscapePluginStream::create(this, requestID, sendNotification, notificationData);
ASSERT(!m_streams.contains(requestID));
m_streams.set(requestID, pluginStream.release());
return;
}
if (sendNotification) {
// Eventually we are going to get a frameDidFinishLoading or frameDidFail call for this request.
// Keep track of the notification data so we can call NPP_URLNotify.
ASSERT(!m_pendingURLNotifications.contains(requestID));
m_pendingURLNotifications.set(requestID, make_pair(urlString, notificationData));
}
}
NPError NetscapePlugin::destroyStream(NPStream* stream, NPReason reason)
{
NetscapePluginStream* pluginStream = 0;
for (StreamsMap::const_iterator it = m_streams.begin(), end = m_streams.end(); it != end; ++it) {
if (it->second->npStream() == stream) {
pluginStream = it->second.get();
break;
}
}
if (!pluginStream)
return NPERR_INVALID_INSTANCE_ERROR;
return pluginStream->destroy(reason);
}
void NetscapePlugin::setIsWindowed(bool isWindowed)
{
// Once the plugin has started, it's too late to change whether the plugin is windowed or not.
// (This is true in Firefox and Chrome, too.) Disallow setting m_isWindowed in that case to
// keep our internal state consistent.
if (m_isStarted)
return;
m_isWindowed = isWindowed;
}
void NetscapePlugin::setIsTransparent(bool isTransparent)
{
m_isTransparent = isTransparent;
}
void NetscapePlugin::setStatusbarText(const String& statusbarText)
{
m_pluginController->setStatusbarText(statusbarText);
}
void NetscapePlugin::setException(const String& exceptionString)
{
// FIXME: If the plug-in is running in its own process, this needs to send a CoreIPC message instead of
// calling the runtime object map directly.
NPRuntimeObjectMap::setGlobalException(exceptionString);
}
bool NetscapePlugin::evaluate(NPObject* npObject, const String& scriptString, NPVariant* result)
{
return m_pluginController->evaluate(npObject, scriptString, result, allowPopups());
}
bool NetscapePlugin::isPrivateBrowsingEnabled()
{
return m_pluginController->isPrivateBrowsingEnabled();
}
NPObject* NetscapePlugin::windowScriptNPObject()
{
return m_pluginController->windowScriptNPObject();
}
NPObject* NetscapePlugin::pluginElementNPObject()
{
return m_pluginController->pluginElementNPObject();
}
void NetscapePlugin::cancelStreamLoad(NetscapePluginStream* pluginStream)
{
if (pluginStream == m_manualStream) {
m_pluginController->cancelManualStreamLoad();
return;
}
// Ask the plug-in controller to cancel this stream load.
m_pluginController->cancelStreamLoad(pluginStream->streamID());
}
void NetscapePlugin::removePluginStream(NetscapePluginStream* pluginStream)
{
if (pluginStream == m_manualStream) {
m_manualStream = 0;
return;
}
ASSERT(m_streams.get(pluginStream->streamID()) == pluginStream);
m_streams.remove(pluginStream->streamID());
}
bool NetscapePlugin::isAcceleratedCompositingEnabled()
{
#if USE(ACCELERATED_COMPOSITING)
return m_pluginController->isAcceleratedCompositingEnabled();
#else
return false;
#endif
}
void NetscapePlugin::pushPopupsEnabledState(bool state)
{
m_popupEnabledStates.append(state);
}
void NetscapePlugin::popPopupsEnabledState()
{
ASSERT(!m_popupEnabledStates.isEmpty());
m_popupEnabledStates.removeLast();
}
String NetscapePlugin::proxiesForURL(const String& urlString)
{
return m_pluginController->proxiesForURL(urlString);
}
String NetscapePlugin::cookiesForURL(const String& urlString)
{
return m_pluginController->cookiesForURL(urlString);
}
void NetscapePlugin::setCookiesForURL(const String& urlString, const String& cookieString)
{
m_pluginController->setCookiesForURL(urlString, cookieString);
}
NPError NetscapePlugin::NPP_New(NPMIMEType pluginType, uint16_t mode, int16_t argc, char* argn[], char* argv[], NPSavedData* savedData)
{
return m_pluginModule->pluginFuncs().newp(pluginType, &m_npp, mode, argc, argn, argv, savedData);
}
NPError NetscapePlugin::NPP_Destroy(NPSavedData** savedData)
{
return m_pluginModule->pluginFuncs().destroy(&m_npp, savedData);
}
NPError NetscapePlugin::NPP_SetWindow(NPWindow* npWindow)
{
return m_pluginModule->pluginFuncs().setwindow(&m_npp, npWindow);
}
NPError NetscapePlugin::NPP_NewStream(NPMIMEType mimeType, NPStream* stream, NPBool seekable, uint16_t* streamType)
{
return m_pluginModule->pluginFuncs().newstream(&m_npp, mimeType, stream, seekable, streamType);
}
NPError NetscapePlugin::NPP_DestroyStream(NPStream* stream, NPReason reason)
{
return m_pluginModule->pluginFuncs().destroystream(&m_npp, stream, reason);
}
void NetscapePlugin::NPP_StreamAsFile(NPStream* stream, const char* filename)
{
return m_pluginModule->pluginFuncs().asfile(&m_npp, stream, filename);
}
int32_t NetscapePlugin::NPP_WriteReady(NPStream* stream)
{
return m_pluginModule->pluginFuncs().writeready(&m_npp, stream);
}
int32_t NetscapePlugin::NPP_Write(NPStream* stream, int32_t offset, int32_t len, void* buffer)
{
return m_pluginModule->pluginFuncs().write(&m_npp, stream, offset, len, buffer);
}
int16_t NetscapePlugin::NPP_HandleEvent(void* event)
{
return m_pluginModule->pluginFuncs().event(&m_npp, event);
}
void NetscapePlugin::NPP_URLNotify(const char* url, NPReason reason, void* notifyData)
{
m_pluginModule->pluginFuncs().urlnotify(&m_npp, url, reason, notifyData);
}
NPError NetscapePlugin::NPP_GetValue(NPPVariable variable, void *value)
{
if (!m_pluginModule->pluginFuncs().getvalue)
return NPERR_GENERIC_ERROR;
return m_pluginModule->pluginFuncs().getvalue(&m_npp, variable, value);
}
NPError NetscapePlugin::NPP_SetValue(NPNVariable variable, void *value)
{
if (!m_pluginModule->pluginFuncs().setvalue)
return NPERR_GENERIC_ERROR;
return m_pluginModule->pluginFuncs().setvalue(&m_npp, variable, value);
}
void NetscapePlugin::callSetWindow()
{
#if PLUGIN_ARCHITECTURE(X11)
// We use a backing store as the painting area for the plugin.
m_npWindow.x = 0;
m_npWindow.y = 0;
#else
m_npWindow.x = m_frameRect.x();
m_npWindow.y = m_frameRect.y();
#endif
m_npWindow.width = m_frameRect.width();
m_npWindow.height = m_frameRect.height();
m_npWindow.clipRect.top = m_clipRect.y();
m_npWindow.clipRect.left = m_clipRect.x();
m_npWindow.clipRect.bottom = m_clipRect.maxY();
m_npWindow.clipRect.right = m_clipRect.maxX();
NPP_SetWindow(&m_npWindow);
}
bool NetscapePlugin::shouldLoadSrcURL()
{
// Check if we should cancel the load
NPBool cancelSrcStream = false;
if (NPP_GetValue(NPPVpluginCancelSrcStream, &cancelSrcStream) != NPERR_NO_ERROR)
return true;
return !cancelSrcStream;
}
NetscapePluginStream* NetscapePlugin::streamFromID(uint64_t streamID)
{
return m_streams.get(streamID).get();
}
void NetscapePlugin::stopAllStreams()
{
Vector<RefPtr<NetscapePluginStream> > streams;
copyValuesToVector(m_streams, streams);
for (size_t i = 0; i < streams.size(); ++i)
streams[i]->stop(NPRES_USER_BREAK);
}
bool NetscapePlugin::allowPopups() const
{
if (m_pluginModule->pluginFuncs().version >= NPVERS_HAS_POPUPS_ENABLED_STATE) {
if (!m_popupEnabledStates.isEmpty())
return m_popupEnabledStates.last();
}
// FIXME: Check if the current event is a user gesture.
// Really old versions of Flash required this for popups to work, but all newer versions
// support NPN_PushPopupEnabledState/NPN_PopPopupEnabledState.
return false;
}
bool NetscapePlugin::initialize(PluginController* pluginController, const Parameters& parameters)
{
ASSERT(!m_pluginController);
ASSERT(pluginController);
m_pluginController = pluginController;
uint16_t mode = parameters.loadManually ? NP_FULL : NP_EMBED;
m_loadManually = parameters.loadManually;
CString mimeTypeCString = parameters.mimeType.utf8();
ASSERT(parameters.names.size() == parameters.values.size());
Vector<CString> paramNames;
Vector<CString> paramValues;
for (size_t i = 0; i < parameters.names.size(); ++i) {
paramNames.append(parameters.names[i].utf8());
paramValues.append(parameters.values[i].utf8());
}
// The strings that these pointers point to are kept alive by paramNames and paramValues.
Vector<const char*> names;
Vector<const char*> values;
for (size_t i = 0; i < paramNames.size(); ++i) {
names.append(paramNames[i].data());
values.append(paramValues[i].data());
}
#if PLATFORM(MAC)
if (m_pluginModule->pluginQuirks().contains(PluginQuirks::MakeTransparentIfBackgroundAttributeExists)) {
for (size_t i = 0; i < parameters.names.size(); ++i) {
if (equalIgnoringCase(parameters.names[i], "background")) {
setIsTransparent(true);
break;
}
}
}
#endif
NetscapePlugin* previousNPPNewPlugin = currentNPPNewPlugin;
m_inNPPNew = true;
currentNPPNewPlugin = this;
NPError error = NPP_New(const_cast<char*>(mimeTypeCString.data()), mode, names.size(),
const_cast<char**>(names.data()), const_cast<char**>(values.data()), 0);
m_inNPPNew = false;
currentNPPNewPlugin = previousNPPNewPlugin;
if (error != NPERR_NO_ERROR)
return false;
m_isStarted = true;
// FIXME: This is not correct in all cases.
m_npWindow.type = NPWindowTypeDrawable;
if (!platformPostInitialize()) {
destroy();
return false;
}
// Load the src URL if needed.
if (!parameters.loadManually && !parameters.url.isEmpty() && shouldLoadSrcURL())
loadURL("GET", parameters.url.string(), String(), HTTPHeaderMap(), Vector<uint8_t>(), false, 0);
return true;
}
void NetscapePlugin::destroy()
{
ASSERT(m_isStarted);
// Stop all streams.
stopAllStreams();
#if !PLUGIN_ARCHITECTURE(MAC)
m_npWindow.window = 0;
callSetWindow();
#endif
NPP_Destroy(0);
m_isStarted = false;
m_pluginController = 0;
platformDestroy();
}
void NetscapePlugin::paint(GraphicsContext* context, const IntRect& dirtyRect)
{
ASSERT(m_isStarted);
platformPaint(context, dirtyRect);
}
PassRefPtr<ShareableBitmap> NetscapePlugin::snapshot()
{
if (!supportsSnapshotting() || m_frameRect.isEmpty())
return 0;
ASSERT(m_isStarted);
RefPtr<ShareableBitmap> bitmap = ShareableBitmap::createShareable(m_frameRect.size(), ShareableBitmap::SupportsAlpha);
OwnPtr<GraphicsContext> context = bitmap->createGraphicsContext();
context->translate(-m_frameRect.x(), -m_frameRect.y());
platformPaint(context.get(), m_frameRect, true);
return bitmap.release();
}
bool NetscapePlugin::isTransparent()
{
return m_isTransparent;
}
void NetscapePlugin::geometryDidChange(const IntRect& frameRect, const IntRect& clipRect)
{
ASSERT(m_isStarted);
if (m_frameRect == frameRect && m_clipRect == clipRect) {
// Nothing to do.
return;
}
m_frameRect = frameRect;
m_clipRect = clipRect;
platformGeometryDidChange();
callSetWindow();
}
void NetscapePlugin::frameDidFinishLoading(uint64_t requestID)
{
ASSERT(m_isStarted);
PendingURLNotifyMap::iterator it = m_pendingURLNotifications.find(requestID);
if (it == m_pendingURLNotifications.end())
return;
String url = it->second.first;
void* notificationData = it->second.second;
m_pendingURLNotifications.remove(it);
NPP_URLNotify(url.utf8().data(), NPRES_DONE, notificationData);
}
void NetscapePlugin::frameDidFail(uint64_t requestID, bool wasCancelled)
{
ASSERT(m_isStarted);
PendingURLNotifyMap::iterator it = m_pendingURLNotifications.find(requestID);
if (it == m_pendingURLNotifications.end())
return;
String url = it->second.first;
void* notificationData = it->second.second;
m_pendingURLNotifications.remove(it);
NPP_URLNotify(url.utf8().data(), wasCancelled ? NPRES_USER_BREAK : NPRES_NETWORK_ERR, notificationData);
}
void NetscapePlugin::didEvaluateJavaScript(uint64_t requestID, const String& requestURLString, const String& result)
{
ASSERT(m_isStarted);
if (NetscapePluginStream* pluginStream = streamFromID(requestID))
pluginStream->sendJavaScriptStream(requestURLString, result);
}
void NetscapePlugin::streamDidReceiveResponse(uint64_t streamID, const KURL& responseURL, uint32_t streamLength,
uint32_t lastModifiedTime, const String& mimeType, const String& headers)
{
ASSERT(m_isStarted);
if (NetscapePluginStream* pluginStream = streamFromID(streamID))
pluginStream->didReceiveResponse(responseURL, streamLength, lastModifiedTime, mimeType, headers);
}
void NetscapePlugin::streamDidReceiveData(uint64_t streamID, const char* bytes, int length)
{
ASSERT(m_isStarted);
if (NetscapePluginStream* pluginStream = streamFromID(streamID))
pluginStream->didReceiveData(bytes, length);
}
void NetscapePlugin::streamDidFinishLoading(uint64_t streamID)
{
ASSERT(m_isStarted);
if (NetscapePluginStream* pluginStream = streamFromID(streamID))
pluginStream->didFinishLoading();
}
void NetscapePlugin::streamDidFail(uint64_t streamID, bool wasCancelled)
{
ASSERT(m_isStarted);
if (NetscapePluginStream* pluginStream = streamFromID(streamID))
pluginStream->didFail(wasCancelled);
}
void NetscapePlugin::manualStreamDidReceiveResponse(const KURL& responseURL, uint32_t streamLength, uint32_t lastModifiedTime,
const String& mimeType, const String& headers)
{
ASSERT(m_isStarted);
ASSERT(m_loadManually);
ASSERT(!m_manualStream);
m_manualStream = NetscapePluginStream::create(this, 0, false, 0);
m_manualStream->didReceiveResponse(responseURL, streamLength, lastModifiedTime, mimeType, headers);
}
void NetscapePlugin::manualStreamDidReceiveData(const char* bytes, int length)
{
ASSERT(m_isStarted);
ASSERT(m_loadManually);
ASSERT(m_manualStream);
m_manualStream->didReceiveData(bytes, length);
}
void NetscapePlugin::manualStreamDidFinishLoading()
{
ASSERT(m_isStarted);
ASSERT(m_loadManually);
ASSERT(m_manualStream);
m_manualStream->didFinishLoading();
}
void NetscapePlugin::manualStreamDidFail(bool wasCancelled)
{
ASSERT(m_isStarted);
ASSERT(m_loadManually);
ASSERT(m_manualStream);
m_manualStream->didFail(wasCancelled);
}
bool NetscapePlugin::handleMouseEvent(const WebMouseEvent& mouseEvent)
{
ASSERT(m_isStarted);
return platformHandleMouseEvent(mouseEvent);
}
bool NetscapePlugin::handleWheelEvent(const WebWheelEvent& wheelEvent)
{
ASSERT(m_isStarted);
return platformHandleWheelEvent(wheelEvent);
}
bool NetscapePlugin::handleMouseEnterEvent(const WebMouseEvent& mouseEvent)
{
ASSERT(m_isStarted);
return platformHandleMouseEnterEvent(mouseEvent);
}
bool NetscapePlugin::handleMouseLeaveEvent(const WebMouseEvent& mouseEvent)
{
ASSERT(m_isStarted);
return platformHandleMouseLeaveEvent(mouseEvent);
}
bool NetscapePlugin::handleKeyboardEvent(const WebKeyboardEvent& keyboardEvent)
{
ASSERT(m_isStarted);
return platformHandleKeyboardEvent(keyboardEvent);
}
void NetscapePlugin::setFocus(bool hasFocus)
{
ASSERT(m_isStarted);
platformSetFocus(hasFocus);
}
NPObject* NetscapePlugin::pluginScriptableNPObject()
{
ASSERT(m_isStarted);
NPObject* scriptableNPObject = 0;
if (NPP_GetValue(NPPVpluginScriptableNPObject, &scriptableNPObject) != NPERR_NO_ERROR)
return 0;
return scriptableNPObject;
}
void NetscapePlugin::privateBrowsingStateChanged(bool privateBrowsingEnabled)
{
ASSERT(m_isStarted);
// From https://wiki.mozilla.org/Plugins:PrivateMode
// When the browser turns private mode on or off it will call NPP_SetValue for "NPNVprivateModeBool"
// (assigned enum value 18) with a pointer to an NPBool value on all applicable instances.
// Plugins should check the boolean value pointed to, not the pointer itself.
// The value will be true when private mode is on.
NPBool value = privateBrowsingEnabled;
NPP_SetValue(NPNVprivateModeBool, &value);
}
bool NetscapePlugin::supportsSnapshotting() const
{
#if PLATFORM(MAC)
return m_pluginModule && m_pluginModule->pluginQuirks().contains(PluginQuirks::SupportsSnapshotting);
#endif
return false;
}
PluginController* NetscapePlugin::controller()
{
return m_pluginController;
}
} // namespace WebKit